The thread that survives every compaction.
throughline captures what you did and what is - commands, file changes, decisions, live git and PR state - continuously, on disk, independent of the context window. Then it hands the work off with judgment when the session wraps. Your artifacts stay readable, editable, and yours.
# register the marketplace, install the plugin /plugin marketplace add dynamic/throughline /plugin install throughline@throughline
Most memory tools replay the conversation. This one remembers the work.
Chat transcripts are lossy the moment they're summarized. throughline separates cheap, continuous capture from deliberate, judged handoff - and stays out of your way until you need it.
"Why not a manual HANDOFF.md?"
You have to remember to write it, from memory - which after a long session is itself reconstructed from a compacted transcript. throughline distills from a buffer that never forgets.
"Why not CLAUDE.md?"
CLAUDE.md holds durable preferences, true every session. throughline holds per-session work state: what you did today, where you stopped, what's still open.
"Why not native memory?"
Native memory holds global facts. throughline holds live project state, and promotes the genuinely durable facts up into memory rather than competing with it.
Three layers, each doing what it's actually capable of.
Continuous capture
Appends a structured one-liner per prompt and per captured action to a per-session buffer - the intent, then the command, file, or delegated task - with obvious secrets masked before anything is written. Mechanical and cheap. You never see it; it just protects you.
Judged handoff
The agent distills the buffer and context into a durable HANDOFF.md and a timestamped session log, and promotes genuinely durable facts into native memory where the harness has one. This is the judgment layer, so it's a skill, not a hook - it runs proactively and shows you the diff.
The thread survives the break
When a long conversation compacts, the transcript is summarized and detail is lost. The raw action buffer doesn't care - it lives on disk, appended after every action, independent of the context window. A boundary marker gets stamped at the seam, and the buffer's tail is re-injected into context right after, so the session doesn't lose its own recent history to the compaction it just went through. Honest scope: the what survives on disk; the why lives in the conversation, and is what compaction discards - run a handoff before a long session compacts to keep the reasoning too.
Safety-net flush
Stamps the buffer on exit, so a session that ended without a handoff is surfaced next time for retroactive distillation. Nothing is ever silently lost - and orientation is automated too: a session-start capture point injects a HANDOFF.md pointer and live git state at the top of every session.
One data format, four ways in.
Every harness reads and writes the same .claude/throughline/ layout, so a
project's history stays readable and continuable no matter which one you're sitting in today.
Capabilities differ - see the matrix below for the honest comparison.
Claude Code
# in Claude Code
/plugin marketplace add dynamic/throughline
/plugin install throughline@throughline
The reference implementation. All 4 skills plus all 5 hooks - full automatic capture and compaction survival. Requires git and jq.
skills + automatic captureCodex CLI
# in a terminal
codex plugin marketplace add dynamic/throughline
codex plugin add throughline@throughline
All 4 skills plus all 5 hooks - full automatic capture, same as Claude Code. Codex gates hooks behind a one-time trust step: CLI shows a "Hooks need review" dialog on first use (choose "Trust all and continue"); Desktop grants trust silently, no dialog. Requires git and jq.
skills + automatic captureOpenCode
# opencode.json
{ "plugin": ["@dynamicagency/throughline-opencode"] }
All 5 hooks, ported to TypeScript - full automatic capture and compaction
survival, no jq required. Skills install separately - OpenCode's plugin API has
no supported way to ship a skill directory alongside a plugin, but OpenCode discovers
SKILL.md from the same locations Claude Code and Codex use, so a skill installed for
another harness is often already visible here too.
Any SKILL.md harness
# works anywhere skills are read from disk
npx skills add dynamic/throughline
Installs the 4 skills directly, no plugin system required. The fallback for any
harness that reads SKILL.md files but has no plugin marketplace of its own.
| Capability | Claude Code | Codex CLI | OpenCode | npx skills |
|---|---|---|---|---|
| Skills (handoff, onboard, consolidate, consolidate-memory) | yes | yes | separate install | yes |
| Automatic capture | yes - 5 hooks | yes - 5 hooks, one-time trust | yes - 5 hooks | no |
| Compaction survival | yes | yes | yes | no |
| Native memory binding | yes | no | no | no |
| Requires jq | yes | yes | no | n/a - skills only |
Your data stays on your disk.
Everything throughline writes - HANDOFF.md, session logs, the raw buffer - is per-operator working memory, not a shared team artifact, and stays local by default.
- Capture-time redaction masks credential shapes before anything hits disk
THROUGHLINE_DISABLE=1is a machine-wide kill switch, no uninstall required- An empty
.throughlineignorefile opts one project out - Commit
HANDOFF.md+logs/when you choose to - it's an opt-in, not a default
# default layout, per project .claude/throughline/ ├── HANDOFF.md # durable record ├── logs/ # session logs └── buffer/ # raw capture # gitignore it (the default) .claude/throughline/ # or turn it off everywhere export THROUGHLINE_DISABLE=1
Support the project
throughline is free, MIT-licensed, and has no telemetry or infrastructure to fund - if it saves you a session's worth of context, consider sponsoring the work.