Resume Button: a gentler restart for unfinished work

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Resume Button helps developers return to unfinished projects without piecing together their last session from scattered notes, code, and test logs.

Before a break, click Save my place, leave a short note, and select the relevant files or logs. A local Qwen model helps turn that context into a resume card containing:

• Your goal and completed work.
• The blocker that remains.
• Approaches you already tried.
• Your recorded next idea, or a clearly labelled AI suggestion.

When you return, open the card and pick up from there. Evidence quotes link to the exact saved source lines, and SQLite preserves cards and source copies between sessions. History, Markdown export, a focus session, and backup restore support the same workflow.

For Slow and Steady, the chore I wanted to reduce is reconstructing context before doing useful work. You can take a break with a place to restart waiting for you. Actual human time saved has not been measured.

Demo

The demo uses a fictional trip planner called Weekend Atlas. Typing “Lisbon” sometimes shows results for “Lis” because an older response arrives last. A debounce reduced requests but did not solve the bug. The card generated with the real local Qwen model preserves both the failed attempt and the author's next idea: track the latest request ID and ignore older responses.

• 18-second walkthrough: saved card, source inspection, capture, backups, focus, and mobile layout.
• Full 102-second recording: actual model generation, cancellation and retry, export, history, and restore.

The app runs locally; the recordings show its workflow without requiring the model download.

Code

Source code, setup instructions, and tests on GitHub.

The application is MIT licensed. The repository includes tests, model setup scripts, documentation, and the fictional demo context.

Run it on Windows with Node.js 22.13 or newer:

git clone https://github.com/AdityaAneNenu/resume-button.git
cd resume-button
npm ci
npm run setup:model
npm run build
npm run local:production

Open http://127.0.0.1:4173. Setup downloads about 1.1 GB of verified runtime/model files; generation works offline afterward.

How I Built It

The core AI components are Qwen2.5-1.5B-Instruct, an Apache 2.0 open-weight model, and llama.cpp, an MIT-licensed inference runtime. The bundled Windows setup uses the official Q4_K_M GGUF weights and CPU inference, with pinned downloads and SHA-256 checks. An existing local Ollama service is also supported.

React and Vite provide the interface, Express serves the local API, SQLite stores cards and source snapshots, and Zod validates inputs and model output.

The main challenge was keeping a useful recap faithful to unfinished work. The model selects numbered source lines rather than writing quotes. The server resolves those IDs into saved text and rejects invalid selections or classifications that contradict explicit labels. Labels such as Completed:, Blocked:, and Tried: take precedence, and a recorded next idea stays the author's idea. Recaps are assembled from the selected evidence.

If no next idea is recorded, Qwen can propose a suggestion with supporting sources. A matching source makes that suggestion inspectable; it does not guarantee it is correct.

flowchart LR
    N[Notes and selected sources] --> U[React interface]
    U --> A[Local Express API]
    A --> Q[Qwen through llama.cpp]
    Q --> V[Validate evidence IDs and labels]
    V --> D[(Local SQLite)]
    D --> C[Resume card and source viewer]

Recovery matters too. Cancelling generation preserves the capture draft and source selections. Restoring a backup validates its evidence and adds independent copies in a transaction.

Validation included 30 unit/API tests, three browser flows, a TypeScript/production build, formatting checks, and a separate real Qwen run. The real run confirmed cancellation saved no card, retry succeeded, and backup restore added copies. Five sources took 92.1 seconds to generate on this machine. That is inference latency, not a human time-savings result. The small model can miss details in unlabeled prose; guided notes are more reliable.

Two useful community references were From TCP to Express: Understanding Request Lifecycles and Cancellation by @silentwatcher_95, on propagating cancellation, and Preserve First: Recovery Design for Local Creative Data by @qnbs, on preserving existing work during recovery.

Why Does Open Innovation Matter?

These open components make the intended workflow possible: after setup, Resume Button can generate cards offline, without a cloud account or per-card API fee. Notes and selected source text stay on the computer. A hosted closed API would require sending that context to a provider and depending on its availability and pricing.

Open weights and a replaceable inference endpoint also let someone try another local model. The application's MIT license makes the prompts, evidence rules, storage, and recovery code available to inspect and adapt.

Local inference has tradeoffs: the initial download is about 1.1 GB, CPU generation can be slow, and saved data is plaintext. For a tool built around unfinished work, being able to keep running with local context and a model you control is valuable.

AI disclosure: Codex assisted with implementation, verification, and this write-up.