Whetstone

Throughline

✅ Open source (MIT) · ✅ Model-agnostic — runs in any agent

Keep the thread — within a session, and across them.

A small, agent-agnostic skill that keeps work on-thread — within a single session, and across the seam between sessions or agents. (Task Track + Handoff.)

It packages two linked habits:

• Task Track (within a session) — an emoji-tagged task list with exactly one ⭐️ MAIN goal anchor, so you can tell at a glance whether you’re still solving the main thing or have drifted onto a transient.
• Handoff (across sessions) — compact the session into a plain-markdown document the next agent (any agent, any platform) can pick up cleanly, then re-derive against ground truth before trusting it.

The point that ties them together: the ⭐️ MAIN tag is the shared goal anchor. Task Track holds it within a run; the handoff’s ⭐️ Goal carries it across runs. One sentence: don’t lose the thread — within a session, or between them.

New in 0.3.0 — the rules live in one data file (rules/task-rules.json) that the checker reads and the flow is drawn from; the handoff has nine sections found by name, and a skeleton every project can share. See the CHANGELOG.

New in 0.2.0 — disciplines extracted from another year of daily use:

• Frozen titles & verdicts. A goal’s title freezes when it’s confirmed, and it closes under that name with an explicit LANDED / PARTIAL / NOT-LANDED (evidence attached; silence is not a verdict). A redirect appends a new goal — it never rewrites the old one.
• One boot = one session — however many wrap-ups happen inside it; name the session early and let the handoff carry the name.
• Two-box checklists — built and verified tick separately; verified only after the named check actually ran.
• Decisions, numbered and append-only — a handoff section that ends re-litigating.
• Atomic wraps — work landing after the handoff was written makes it stale; re-run the wrap.
• Gaps are findings — the resume side reports what the wrap side skipped, out loud.
• Multi-agent rules — one writer per shared artifact; the docs, not chat history, are the coordination channel.
• A companion meter — strain says when to wrap; Throughline is how. When the two run together, strain’s periodic tick (every N tool calls) doubles as the task-track re-read moment: each tick is the cue to glance the list — is the ⭐️ MAIN still the thing being worked on, or has a side task ballooned past it? Strain 0.4.1 asks for exactly this glance in its tick line; drift found this way is reported as a note, never fed into strain’s tier.

How the two halves connect

A single, self-contained SVG — opens in any browser or Markdown viewer, nothing to install. For the rules themselves there is an interactive rule map (open the HTML in a browser): every rule in rules/task-rules.json as a card under the moment it first fires — hover a card for its why, its pass condition and what checks it. The map is generated from the rule file, so it changes when the rules do; the picture above is the idea, and stays. Both are drawn with Arcgram — the project Throughline’s disciplines were lived on before they were extracted here.

The thread runs: a session’s ⭐️ MAIN is written into the handoff’s ⭐️ Goal, picked up by the next session, re-derived against ground truth, and carried forward as the next ⭐️ MAIN — which loops back to begin the cycle again.

What’s in here

Path	What it is
skills/throughline/SKILL.md	The skill — the two habits and how they connect. Works as a skill or a paste-in prompt.
.claude-plugin/plugin.json	Plugin manifest (so it installs as a Claude Code / Cowork plugin).
commands/handoff.md	The write operation: compact a session into a handoff doc.
commands/resume.md	The read operation: pick up a handoff and re-derive before trusting it.
templates/handoff.template.md	The single source of truth for a handoff’s structure.
references/task-track.md	The within-session discipline, in depth.
references/handoff.md	The across-session protocol (the seven anti-drift mechanisms + the multi-agent rules), in depth.
examples/example-handoff.md	A filled-in handoff to copy the shape from.
rules/task-rules.json	Every rule as data — the one source the checker reads and the flow is drawn from.
tools/handoff.py	Optional, zero-dependency helper: new (scaffold), check (validate against the rules), brief.
tools/test_handoff.py	Its tests: python3 tools/test_handoff.py.
assets/logic-flow.svg	The diagram above — how the two halves share one goal anchor (an Arcgram flow, exported as SVG).
assets/throughline-flow.html	The rule map, interactive: every rule under the moment it first fires, drawn from the rule file (hover a card for its why, pass condition and what checks it).

Use it

As a prompt (any agent — Claude, OpenAI, Gemini, Cursor, Cline, a local model). Paste the relevant file into your agent. Nothing assumes a particular platform; every capability degrades gracefully (no file write → emit inline; no live access → re-derive from the artifacts you have; no code execution → skip the helper).

As a skill / slash command (Claude Code, Cursor, etc.). Drop the folder where your tool reads skills/commands. Then handoff to wrap up and resume to pick up.

The optional helper (only where you can run code) does the mechanizable half — it never summarizes:

python3 tools/handoff.py new                 # scaffold a blank handoff from the template
python3 tools/handoff.py check HANDOFF.md    # validate: sections, one ⭐️ MAIN, re-derive note, secret sweep

It reads the required sections from the template at runtime, so the prompt and the validator can’t drift apart — the skill dogfoods its own single-source-of-truth rule.

Why it’s shaped this way

Long or multi-agent work fails two ways: reasoning drifts off the goal within a session, and the thread gets dropped between sessions. The same goal anchor closes both gaps. The handoff is deliberately light — a plain-text artifact, capability-agnostic, with a write side and a read side — because the next agent might be anyone, anywhere, and a heavy protocol that assumes your platform is a protocol nobody else can pick up.

License

MIT — see LICENSE.

This site is open source. Improve this page.