v1.24.0

A testing build. Everything since v1.23.0 (16 September), grouped by what changes for you.

Two commands have new names. /done is now /close and /next is now /build (or /throughliner:close and /throughliner:build where the short names don't register). What they do is unchanged.

Fewer wrong writes reach your files. The plugin now carries its own small state server, with nothing extra to install. Queue moves, holds, captures and cycle definitions go through tools that check the fields and refuse a bad write on the spot, instead of you finding the damage a session later. No speed or token saving is claimed.

One task list across all your projects. Point a project at a markdown checkbox file, and the steps that are yours land there as plain task lines. Lines keep their project's queue order, duplicates are checked before anything is added, and ticking a line in your notes app closes the step at the next planning session. A fact about you that no single project owns, such as your name, pronouns or timezone, can go into your global CLAUDE.md on your yes.

Projects talk to each other through their queues. Sending something to another project now adds a capture to the bottom of its queue, on your yes to the exact text, in place of a mail file. The special "pop-out" flow for a project inside another project is retired: move the folder out and run setup in it.

Setup works out your folders with you first. It suggests the smallest set of folders and files your kind of project uses and creates only what you approve. MAP.md says what each folder is for, replacing the separate small specs for parts.

Planning and releases. /catchup now also runs the return checks for a chat picked up after time away. A capture can wait until built on another entry. Cycles can run as a dateless chain, each step firing on the one before.

A second output style. Throughliner Code Notes adds a few plain-English points on why the code is the way it is after each piece of work, for anyone who wants to learn from it.

Steadier checks. A reply that runs long is sent back once with its count. The time-word check no longer catches "today" when it means "currently", and the bold-inside-a-sentence check is gone.

The FAQ Claude reads is the plugin's own. It's no longer copied into each project, so it stays current with every update. An old FAQ/ folder is named as a leftover you can delete.

Fixes. A release step recorded with no time is no longer read as midnight, and a Files: list written as a heading or in bold is now read by the safety check.

Install or update: see INSTALL.md. The attached port changelog lists what changed in each shipped file, for anyone porting Throughliner to another tool.

v1.23.0

A testing build. It is the build that ran as the beta from 2026-09-11 to 2026-09-16 (1.22.0-test4), promoted unchanged. Everything below is what changed for a user since v1.22.0.

Your project's shape

• Setup asks what your project's parts are. A new project is set up with the product in its own folder and repository, and the planning documents kept privately around it. Setup now asks roughly what the moving parts are, gives each its own folder, and writes a small SPEC per part; a build reads only the spec of the part it is working in.
• A project that already has a public repository is wrapped, not moved. Setup tells the two conversions apart by whether the repository has a remote, and where it does, keeps that repository whole and creates the private outer around it.
• A temp/ folder for what the project does not keep. Fetched transcripts, one-read downloads and drafts you edit land there, ignored by git, so nothing has to record when to delete them.

Cycles

• A cycle can chain its rituals into a close calendar. A weekly release, say, names the rituals that lead up to it and how many days before the anchor each falls due, and the planning opening computes which one is due today. A later ritual can carry a gate that refuses to run while an earlier one's output is unfinished.
• Every ritual step names what fires it and who performs it. A definition missing either is refused when it is written.
• Due cycle work now comes first at planning, ahead of ordinary captures.

The safety check and the hooks

• A door through a refusal, on your word. Where the safety check refuses an edit in a session with no build running, asking for the same change again in your own words opens that one path for the session, and the close records the edit.
• Every decision is logged. The safety check keeps a log of what it allowed and refused in the project's working folder, so a write that passed with no line is a check that never ran.
• Time words need a source. A record that says "an hour ago" or "yesterday" with nothing to read the time from is refused once, and so is a clock time later than the clock actually reads. The finished reply gets the same check.
• Every command tells you when the hooks are not running, and what to check: python --version must print a version, not the Windows Store placeholder.
• A step of yours says how many things are waiting on it, read off the queue, and says nothing where nothing is.

Planning and closing

• Handing work to another project for completion closes the item here. The walkthrough ends at the send, and anything depending on the outcome is filed as its own item first, so a clean close drops nothing.
• Held work says what it rests on. When a hold lifts, the offer says what the item's design was assuming and whether anything has checked it since.
• Drafts you edit are handed over as a link that opens in the side panel, in the project's temp/ folder.
• Rules trimmed. Several passes removed reasoning and history from the always-loaded rules and the procedure docs, so the same instructions are carried in fewer words.

For porters

The port-facing changelog is attached (63 entries over v1.22.0..v1.23.0). It says what changed inside which shipped file; the mapping stays yours.

Install and update: see the README. Report a problem by asking Claude to file a GitHub issue on this repository, or on the Discord.

v1.22.0

A testing build. Throughliner is in active testing and not marketplace-ready; this pre-release is the build that was labelled stable on the test-rezips channel (1.21.1-test4, commit fb7c4ee), packaged from the archived zip that was actually installed and exercised, not from the working tree.

What changed since v1.21.1, for someone using the plugin

Releases and the beta channel

• Releases are cut from the tested archive: the zip that ships is the one that was installed and run, never a fresh build of the tree.
• A beta channel exists. Each Wednesday one tested build is picked as beta and last week's beta is released; install from FlintcraftTech/throughliner#beta to ride it.
• Recurring work can be a ritual: a named step list you fire with a word, alongside cycles. Rituals are shown at every session opening with the word that fires each.

Ports

• Two port flavours are named and supported, tracking and independent, in a shipped docs/ports.md; a port declares its own flavour and no register is kept.
• A port-facing changelog is generated per release and attached, listing what changed inside the shipped package and flagging host-only work a port must not carry.

Setting up, and keeping your files private

• New: the self-hosting seed. If you are building a method or plugin of your own, setup can seed the rule gate, the disposition pattern and the host-versus-target framing into your project.
• Keeping your planning documents out of the repository is now the proposed default, and the plugin restores undo for those untracked files itself: a snapshot of the previous version is saved before each change, so a deleted queue item can be put back.
• A workshop/ folder holds a project's working material; existing projects are migrated into the new layout by setup (format epoch 5).
• Setup writes a personal fact into your spec only where you supplied it in your own answers.

Planning and building

• Lifting held work says what that work was banking on and whether anything has verified it since — the same when a dated capture returns.
• A kept item names the external facts its design rests on, with dates; every research finding filed carries an assessment of its own frame.
• A capture can be claimed by a cycle (Cycle: [slug]), so recurring material is drawn by the cycle's turns instead of being re-offered every planning session.
• Walk-through steps are capped at three instructions each, and a step that runs a terminal command supplies its own preconditions.
• The queue lint speaks only when its findings change, and flags an unbracketed blocker slug at write time.
• The stop hook no longer swallows genuine filing claims whose sentence happens to contain a hedge word.
• Reports between projects carry whose idea a thing was, as a role rather than a name.

For the developer only, inert for everyone else

• An MCP helper ships as a passenger, registered only in the development project.
• The Discord posting bot, its permissions and threads readers, and the release-from-archive machinery are development-project tooling.

The port-facing changelog attached covers this build's exact range, v1.21.1 to fb7c4ee.

Testing outcomes (added 2026-09-03)

This exact build was exercised on 2026-09-02/03 by a full build run: 22 builds and one compliance audit, all completed, and ten walk-throughs driven, four to completion. All 34 test suites passed at that session's close, and no hook, script or suite failed under real use. What the run found was in the method's wording, not its code: the audit filed eight findings where a rule carried its reasoning inline, and one walk-through's premise turned out wrong (the account it asked the user to remove was the project's own bot). Verdict: stable, with those wording findings filed as work.

v1.21.1

v1.21.1 — the recommended install.

This release packages the build that has been validated in real use — full planning and build sessions run on it. It supersedes v1.21.0, which shipped with issues; if you're on v1.21.0, update to this. The beta install route (#beta) points at the same code.

Same features and install routes as before. Still a testing build — expect rough edges, and report anything odd via a GitHub issue on this repository (ask Claude to draft one for you).

v1.21.0

This is a testing build. Throughliner is in active beta and is not marketplace-ready — expect rough edges, and please report anything odd.

This is the first release since the project was renamed, and it covers a lot of ground. The headline changes:

New name

Sovereign Implementer is now Throughliner. The plugin slug, the package folder and the project marker files all moved together. The name is about the thing the tool actually protects: the reasoning behind your decisions, carried forward as prose so a fresh session builds what you meant instead of guessing from your code.

Two new pieces of the workflow

/rescan — a one-word way to catch anything you decided, noticed or asked for in a chat that never made it into a file. It files what it finds and commits nothing, so it isn't a second close, and you can run it as often as you like. It's especially useful after a close, when work carries on and would otherwise be invisible in the record.

Cycles — recurring work, defined once. A weekly release, a posting rhythm, a maintenance pass: you name the steps and how often, and the queue brings it round on its own. Projects with no cycles get no cycles doc and pay nothing for the feature.

Your record is checked, not just written

A new hook watches for reports that don't match reality. When Claude tells you it filed something, the hook checks your queue and hands the turn back if the entry isn't actually there — so you never act on a report of work that doesn't exist.

Planning and building now read different things. A build gets a derived view carrying each item's instructions — what changes in which files, how to tell it worked, what was already ruled out — and none of the decision history. Two reasons: a run stops reading your whole queue to build three items, and reasoning stops being copied verbatim out of your record and into the rules. Your queue keeps everything, whole.

Records got shorter on purpose. Every written shape is now bounded by the median of that shape in your own project, measured by a script rather than by a number someone invented. A record too long to get through is a record you can't approve, and approving is the point.

Holding work back, properly

Work can now wait on several other items at once, and only lifts when every one of them lands. It can also wait on a date — which resolves itself off the calendar, with nobody having to confirm anything.

An item can be marked Runs alone when it must not share a run with other work — a rename or a file move that would pull paths out from under a build in flight.

Projects that message each other

Projects on the method can now send each other durable, approval-gated mail, with an address book so you never have to dig out a folder path twice. Nothing is ever sent without you seeing the exact words first.

Subprojects: running /setup inside an already-adopted project offers to pop that folder out into its own project — for a subpart that has genuinely outgrown its parent.

Setup and staying current

• A brevity style is offered at setup, with your consent, per project.
• Your privacy choice is now offered per document — a private queue with a public history is a real combination, and it used to be unreachable.
• Projects on an older document format are caught at session start rather than quietly reasoning over stale scaffolding.
• The install route is now pinned to #beta, so you get the tested weekly pick rather than whatever is on the development line that day.

Also

A published contract other apps can read while Claude is editing a file, so your Markdown editor can hold off instead of fighting it. Detection of whether your session is isolated from another one — including sessions running in the cloud, which needed telling apart. A rebuilt FAQ. And a great deal of work on the rules themselves: what may be added, what has to come out to make room, and honest reporting about what the checks can and can't tell you.

v1.20.0

A testing build, like every release so far.

This one covers an unusual stretch. The method's instruction docs had grown to the point of being self-defeating, so on 9 August the whole project was rolled back a week to the point where they were at their smallest. That deliberately threw away good work along with the bloat. Most of what's below is that good work, brought back deliberately — and several things came back better, because restoring them meant re-reading them.

Three things were quietly broken and are now fixed.

The cost guard that asks before Claude starts a subagent was watching for the wrong tool name, so it never fired — subagents could run without asking, and a single one can use up a lot of your usage. It now fires.

The session-start hook was sending its whole payload in a format Claude Code silently discards. That means the plugin's behaviour rules, your project state, and any unaddressed security flag in your queue were reaching nothing at all. Sessions still looked fine, because Claude reads your project files directly and reconstructs roughly what the hook would have said — which is exactly why nobody spotted it. Fixed, along with the size problem underneath it: the payload was 55,000 characters against a 10,000 limit, and now points at the rules rather than pasting them.

A file-freshness check was tracking how many sessions you had open rather than what was actually installed, so an up-to-date install could report itself as stale.

Claude can no longer write to your files by running a script. A shell command can be working from an out-of-date view of a file and quietly overwrite something the normal editing tools would have refused to touch. That route is now blocked outright, whatever the file is. The tool that makes large queue edits safely was restored in the same release, so there's a proper way to do the awkward edits that used to tempt the shortcut.

Your projects can now send each other messages. If you run more than one project on the method, each gets an INBOX folder. One project writes a message into another's inbox, and anything waiting is mentioned at the start of your next session, then filed into your queue, your log, or your notes depending on what it is. Nothing is ever sent without you seeing the exact wording first. Setup asks once whether these messages should be saved into your project's history — keeping them out is the safe answer if your repository is public.

Fewer questions you shouldn't have been asked. Work that's parked waiting on something gets revisited each planning session, and it was asking you about things Claude was supposed to be doing itself. It now does them, or tells you they're pending, rather than asking.

Claude stops crediting you with things it said. Work items were being marked as yours whenever you approved them, and reasoning Claude had produced was being written up as your reasoning. Agreeing to a proposal isn't authorship, and having your project's record quote you saying things you didn't say is unpleasant to read. A credit now needs your actual words behind it, and where you and Claude both contributed, the record says who did which part.

Also in this release: the plugin now ships one set of procedure docs instead of two — roughly 40,000 words of duplicate instructions removed, which were being loaded while a different copy was being maintained. Plus a rule-writing gate that asks whether a new rule should exist at all and what comes out to make room for it, a signal other apps can read to know when Claude is mid-edit on a file you also have open, and a route for reporting problems with the method itself rather than filing them in your own project's queue.

v1.19.0

A testing build. This release rolls up the second overnight blitz, a long planning session, and the build run that shipped its decisions — about two dozen changes, grouped by what they mean in use.

Saying "not now" now sticks. The plugin has a name for setting something aside: stop partway through a step, shelve a suggestion, or answer "no change" about something the work was waiting on, and that gets recorded on the item itself — including how far you got. From then on it stops being re-offered session after session. Nothing is lost: the work stays in your queue, comes back when the queue has nothing else, and the moment you mention it. Warnings are the exception — a security concern keeps surfacing until it's dealt with. Claude never sets anything aside on its own judgment; only your say-so does it.

Less asking, same control. Merging two agreed pieces of work no longer needs a yes when the merge doesn't widen what the next build can touch — Claude does it and tells you, naming the scope effect so you can object. Anything that would widen the build's reach still asks. Planning sessions also now prefer grouping work that touches the same files, so one build session clears more at once — a tie-breaker only; nothing skips vetting.

Simpler setup, one way of showing you text. The "which editor do you use?" and "computer or phone?" setup questions are gone — nothing used the first, and the second just made people pick whichever meant less text. Claude now always shows doc-bound text the same way: a short summary you can act on, a link with the exact heading to find, and the full text one word away. Old projects that still carry those settings are simply ignored, nothing to fix.

More honest checking. Steps that are yours to do get a real capability check before they're handed to you — if a tool Claude can run would do the job, Claude runs it instead. When you say you've done a step whose result is visible in the world (a file, a branch, a URL), Claude checks the world rather than just recording the report — and if it doesn't match, says so plainly instead of asking "are you sure?". Build closes now also compare what actually changed against what the work item described, surfacing mismatches instead of assuming.

Quieter, truer plumbing. The queue empties one item at a time as a build run progresses, so an item still showing always means "not built yet". If the plugin's install is ever missing the instruction set it wants, it says so in one plain line instead of silently running the fuller one. Planning check-ins about waiting work ask once, batched, and go quiet on your "no change". Plus a batch of smaller fixes across the session-close and planning procedures from the blitz run.

As always: a pre-release, in active testing, not yet on the Claude marketplace.

v1.18.0

A testing build, like every release so far — the plugin is in active use but not finished, and this flag says so honestly.

Most of this release came out of one long night of building plus the planning sessions either side of it. The theme, if there is one, is that several things the method said it did turned out not to be quite true, and this fixes those rather than adding features.

Privacy got sharper, and earlier

The rule about not writing private information into your project docs was one rule; it's now three, and two of them fire before anything is written:

• Don't name other people. Unchanged in spirit — a lesson never needs someone's name.
• Don't ask you for identifiers the work doesn't need. New. Claude used to be free to ask for an email address, an account number or a key so it could put it in a work item. It almost never needs to — you're holding those details at the moment you do the work, and by the time a review could catch it, you've already been asked and probably answered.
• Don't write assessments of you. New. Context about you gets recorded as the decision and its reason, never as a characterisation of you personally.

/setup now tells you which email address your commits will carry, before your first commit, and points at GitHub's noreply option. Commit metadata is the one exposure that no later file edit can fix. It also now says plainly that your planning notes are part of what a visitor to your repository reads.

Reporting a problem now knows what you're reporting

Previously everything routed to one place. Now Claude asks which thing is misbehaving and routes accordingly: your app becomes an item in your own queue; a problem with the method goes to flintcraft.tech/report as a scrubbed, paste-ready block; and a problem with Claude Code itself becomes a GitHub issue — which Claude will draft, search for duplicates first, show you in full, and post only when you say yes.

Audits stopped crying wolf

Two changes, both from audits that reported things that weren't true:

• An audit must search the rest of the docs before reporting a rule missing. "Absent" and "documented somewhere else" are different findings.
• An audit must check the log's record before reporting shipped work broken. Work that was verified once shouldn't be re-reported as failing on a fresh reading.

And when an audit produces a pile of findings whose fixes are unambiguous, they now consolidate into a single work item instead of a dozen — findings that need a real decision from you still stand alone.

Closes end clean

The end-of-session re-scan now runs before the log entry is written, so what it finds is in the entry from the start rather than being patched in afterwards. The forward note for your next session is written before the commit, so a close no longer leaves you with unsaved changes. And Claude no longer says "close out" at you — it was the name of a step that stopped existing, and it made people wonder whether running /done alone had skipped something.

Queue handling is mechanical where it used to be manual

Moving an item between sections, or reordering two items, used to mean Claude retyping the item's whole text — which on a long queue quietly degrades and can corrupt an item with nothing reporting an error. The queue tool now does cross-section moves and before/after placement directly, and the procedure requires using it.

One hook fix

The advisory that warns when a build is running without a recorded file scope used to fire once per project, ever — so the second time it mattered, it said nothing. It now fires per build.

---

Installing or updating: ask Claude Code to run claude plugin update sovereign-implementer@flintcraft, then fully quit and relaunch the app. Needs Claude Code 2.1.193 or later.

v1.17.0

Testing build. Not marketplace-ready — this is the release line used for private and small-group testing.

This is a large release: 29 commits since v1.16.0. The headline is that the plugin now ships two sets of its own instructions and picks between them by the model you're running.

Two docsets, chosen automatically. The method's procedure docs were rewritten as a second, lighter set (39% smaller) for the Claude 5 series, while the original heavier set stays frozen as the known-good fallback for 4.8. A session picks one at startup. Nothing to configure, and no message about it. The selector was later rebuilt when the model field it depended on turned out not to be guaranteed — it now reads a recorded project setting first.

The session-start hook was silently broken, and is fixed. It emitted the wrong output shape, so Claude Code discarded every payload — meaning the behaviour rules reached no session at all. Sessions kept working because Claude reconstructed roughly the right thing from the project files, which is exactly why nobody noticed. The payload was also 55,000 characters against a 10,000 cap; it is now 3,300, with the large documents pointed to rather than inlined.

Approval-time text is now written to its doc first and approved in place. A new queue item or log entry is written where it belongs and you read it there, rather than as a chat paste followed by a write. If you reject it, it's removed. On a phone the text is still pasted inline. This collapses two rendering rules into one.

The [user] walk-through was rewritten. Work that only you can do is now walked through live, one step at a time, and never prefaced by asking whether you've already done it.

Privacy. A write-time rule against recording third parties' names and private circumstances, a repo-visibility check at setup, and a scrub-sweep script for what's already written.

Smaller things: dependencies between queue items are expressed once, properly, with the old push marker retired; the queue reorder tool's marker bug fixed; the close now always says "start a new chat, then run the skill"; the LOG records what a session produced, not only what it changed; and the FAQ sync has real teeth.

v1.16.0

Five method refinements:

• Context wording — next-build.md no longer implies /next can sense the context window filling; the finish-vs-close-partial guidance is reframed as the response to the user reporting the squeeze.
• Safer skip-to-defer — /plan's in-session skip now routes through the mechanical mover (new tested --move mode) instead of hand-retyping the item's prose.
• CLI-tool trigger — Claude now considers a command-line tool before handing over a GUI walkthrough, and offers a web search for one (with consent/setup guards).
• Newest-first LOG — every per-entry LOG filename is date-prefixed (YYYY-MM-DD-…) so the folder sorts newest-first; existing entries migrated in lockstep with the index.
• Cheaper reorders — /plan's start-of-processing and close reorders are now conditional and change-scoped: they no-op silently when the order is already right.