v1.6.5

[1.6.5] - 2026-10-24

Added

• Workflow artifacts are now checked against the templates they come from: each node names the templates it reads, and the exit compares the artifact's heading forms, section order, empty sections and copied-through placeholders against the upstream template plus this repository's registered additions — a first failure points at the template while a repeat names the missing sections, a missing template says so explicitly instead of passing silently, and the project-level documents travel the same path. The recorded baseline follows the new coverage — 350 scenarios and 95 items in the system test suite. (#159)
• Two requirements that used to rely on the node books are now checked by the engine: entering a node prints that node's protocol prompt before the template lines, and workflow-state.mjs skill-load --prompt must name the same protocol file — a wrong path is refused rather than recorded silently; every task summary now carries a ## LESSONS 扫描 section beside the ## 自检方法 declaration, that section answering the entries the engine derives from the task's write_files, and the archive exit verifies the nomination evidence — how many summaries were scanned, that every nominated entry exists, and a reason when nothing is nominated. (#159)
• A frontend design reads one more prompt: entering the design node for a change whose visual-tone section marks it as frontend prints an additional conditional READ PROMPT line pointing at 2a-ui-design.md, decided by the same structural criterion as the conditional template line and omitted for non-frontend changes. (#159)

Changed

• Breaking: loading a node's skills now declares the templates that node reads: workflow-state.mjs skill-load requires --templates <a.md,b.md> for a built-in node with at least one template, and the declared set must match the node's template mapping exactly — missing, extra or misspelled names block a new change while an older change only warns; a node that reads no template (verify / archive) may leave the flag out, and a custom protocol declares the templates of its own nodes. (#159)
• Breaking: a lesson written as a level-two heading is now refused at three exits: entries in the project lesson book must sit inside the entry area as ### L-NNN, and a ## L-NNN heading blocks a new change at the open, verify and archive exits — the report prints file:line → write ### L-NNN for each offending line, an older change only warns, and numbering and out-of-area checks stay on verify and archive. (#159)
• Optional sections may be dropped whole: a section the template marks as optional can be deleted outright, while a conditional section keeps its heading and may say N/A inside — an optional section you keep still has to be filled. (#159)

v1.6.4

[1.6.4] - 2026-10-15

A release gathering the work accumulated after 1.6.3: the entrance page is rebuilt around the project's own material — a mark, a diagram of how flow-kit's nine stages become the eight nodes, a map of how the neighbouring projects actually relate, and an evidence board — with every comparison row checked against what those projects say today; the engine scripts and both regression suites are split into focused modules without changing any engine behaviour, and the recorded baseline follows the split; the test suites now copy fixture trees through one portable helper, so a checkout whose path contains non-ASCII characters no longer stops them without a report; and the recommended companion, brooks-lint, is now documented across the public pages. (#150) (#151) (#152) (#157)

Added

• The recommended companion is documented: the README, Installation, Core Mechanisms and Troubleshooting pages now cover brooks-lint — the third-party review engine whose decay-risk framework the per-task self-check and the review rounds are built on — including what changes once it is installed and what a run does without it. (#150)

Changed

• The entrance page is rebuilt around one story: a hero now carries the project mark and the engine's eight nodes drawn as a rail in which every transition is a gate; the real-run artifacts and their two unedited terminal captures move above the argument and become one evidence board; a new section explains how flow-kit's nine stages become the eight nodes, with a diagram and an animated version beside its static source; and the comparison table is rewritten as three columns, each row checked against what the projects say today and labelled with the relationship it really has — flow-kit as the base that also aggregated the others, comet as an early mechanism reference that is now decoupled, and brooks-lint as an optional integration. Along the way two dead anchors, a CI list that named four of six checks, a platform prompt described as first-run-only, three places where the two languages disagreed, a sentence that called Comet a dependency and a "fit" line that contradicted the supported platforms are corrected. (#152)
• The engine scripts and both regression suites are split into focused modules: the engine's decision logic, the self-test scenario set and the system test item set now live in small single-purpose modules beside the entry points they belong to, while those entry-point paths and every engine behaviour stay unchanged, and the fixtures both suites share have moved into a module of their own. The recorded baseline follows the split — 325 scenarios, with the 93 system test items unchanged. (#151)

Fixed

• The test suites survive a checkout path with non-ASCII characters: the fixture modules copied directory trees with fs.cpSync, which on Windows exits the process silently when the source path contains such characters — the suite then stopped without a failure report and without its summary line, which reads like a pass. Every tree copy now goes through one portable helper in the shared test layer, with an anchor pinning both the call sites and the helper's single home; the behaviour contract page also states, beside the fallback path, the separate six-dimension declaration the exit requires. (#157)

v1.6.3

[1.6.3] - 2026-10-11

A release gathering the work accumulated after 1.6.2: how a delegation is judged is now the same on every supported platform — it rests on the identity the host reports for the caller rather than on how the workspace was built — with the four properties that make parallel work safe written down, every delegation recorded when it is handed off, and the commit and integration discipline written into the node skills; node guidance is read on demand instead of being repeated across the node skills, the facts about a node can be asked for with a read-only command, the pages that are not for the agent's use no longer ship with the installed skill tree, reinstalling no longer leaves generated files behind, and the check that requires every new changelog entry to carry a numbered pull-request link keeps working once a release moves those entries into the version section. (#145) (#146) (#147)

Added

• Delegation is decided by the caller's identity, on every supported platform: the guard reads the agent identity the host puts in the payload and applies subagent semantics before it resolves any path, with no platform-specific branch. On Codex this closes a real gap — an interactive session carries the identity for its native subagents, whereas a headless run does not, and it was the headless finding that had been read as a platform limit. A minimal protected set (the state file and the protocol file) stays blocked for subagents, and a write aimed outside the project root is judged the same way whether it arrives as a file edit or as a shell command. (#145)
• A delegation is recorded when it is handed off: the handoff is written into the execution node's evidence, so the run shows what was delegated. The record states that a delegation happened; it does not prove who executed it, and it is documented that way. (#145)
• Write-conflict checks understand patterns: a task write-set containing a pattern is matched against the other side's literal paths, and two patterns are treated as overlapping — so a pattern-versus-file overlap can no longer pass the planning exit unnoticed. (#145)
• The full checks wait for a writer to finish: while a delegated task has been handed off and not yet reported back, running the full verification is refused with recovery guidance instead of measuring a half-written tree; changes created before the rule get a warning. (#145)
• Commit and integration discipline are written into the node skills: subagents commit only their own literal paths, retry when the index is locked and avoid whole-tree commands; the coordinator integrates by merge and falls back to a cherry-pick only with a recorded reason. (#145)
• Node facts can be asked for instead of copied into every book: a read-only command, workflow-state.mjs explain <node>, prints the output schema of one node together with its artifact paths and evidence id, its guardrails, the skills that node must load, and its entry, exit and record commands. Each answer is derived from the protocol the engine already reads, so it cannot drift from what the gates enforce; the command writes no state and changes no routing, and an unknown node is refused with the list of valid ones. (#146)

Changed

• Parallel delegation is defined by four attributes instead of one shape: the contract is write permission, commit isolation, verification isolation and integration discipline; an isolated worktree implements the first of them and is no longer a precondition for delegating work. Subagents may share the workspace, with the boundary coming from disjoint task write-sets, commit-time discipline and a minimal protected set. (#145)
• The public documents no longer describe every delegation as isolated: the platform notes state per platform which delegation channel is verified and which is still uncovered, and name the only remaining difference — who builds a workspace. (#145)
• Node guidance is read on demand instead of repeated across books: content that more than one node skill needs now has a single home, and the other books point to it with a sentence saying when to read it — every reference page is reached that way, so a page that matters only in one situation is no longer inlined into the flow. A run loads less than half of the duplicated cross-book text it used to, while each book still carries the guidance for its own node in full; and the places where two books had contradicted each other now say the same thing, including the two that changed what an executor would do — whether a hand-made worktree is a supported choice when delegating, and which section a design artifact must follow. (#146)
• Documents that are not for the agent's use no longer ship with the installed skill tree: the reference pages written for maintainers or kept as project records, together with generated files, were moved out of the tree that gets installed, so an install no longer carries them; the pages an executor needs when a situation arises stay in place, and the entry book's longer appendix moved into that on-demand layer. (#146)

Fixed

• Reinstalling no longer leaves generated files behind: an install used to overwrite files without removing anything, so a page that had been renamed or moved away stayed in the installed copy — a stale layer that the installed copy's own checks then failed on. The installer now removes, inside the skill directories it manages, only the paths the current skill set no longer contains, and it decides by location: anything it cannot prove lies inside the project — the managed directory itself being a link, a symbolic link, a path whose type differs, or a directory that is still non-empty after the cleanup — is kept, with the reason printed. A re-run stays idempotent, nothing outside those directories is touched, and the installation notes state the same boundary. (#146)
• The changelog link check no longer loses its footing when a release is prepared: the check that requires every new changelog entry to carry a numbered pull-request link read only the unreleased section, and the probe that verifies the check still has teeth removed one hard-coded link number — so once a release moved the newest entries into the version section, the section it read was empty, the probe found nothing to remove, and the check reported that its own discrimination was missing instead of passing. It now reads the newest section that actually holds entries, matches entries against the numbered links inside those entry lines rather than across the whole section (a version section's summary links are not entries), and takes the probe's target from that section. An anchor builds the released shape and asserts the check stays quiet there while the probe still catches a stripped link number. (#147)

v1.6.2

[1.6.2] - 2026-10-03

A release gathering the work accumulated after 1.6.1: three side commands ship as deterministic scripts that never enter the eight-node flow — architecture-sediment sync, the health inspection and the project-context rescan — with a single authority for timestamps and for the sync-due decision behind them; and the UI-DESIGN binding is enforced rather than advisory, so a frontend change has to produce the design artifact and declare it before the design exit opens. (#136)

Added

• Three side commands now come as deterministic scripts instead of prose: architecture-sediment sync (evolve), the health inspection (health) and the project-context rescan (context-scan) ship as scripts that never enter the eight-node flow — they are invoked explicitly, they do not route, and they neither read nor write node evidence. Each one writes its own report; beyond that, evolve apply patches the project documents you approved and records the sync time, and context-scan updates the scan metadata in the state file and the context document. evolve scan is read-only and lists the sediment candidates found in archived design documents within the window since the last sync, while evolve apply writes only the entries that were approved one by one, appends its report and records the sync time in both places. health produces a layered report — machine-decidable readings, an optional supplement section, and an explicit degradation statement — whose machine-decidable lines are byte-identical across two runs on a frozen tree, with the allowed differences declared in the report itself. context-scan rescans the project context, compares it item by item against the previous baseline, and says so explicitly when there is nothing to compare. (#136)
• One authority for time and for the sync-due decision: a single module now owns timestamp generation, parsing and the expiry window — the stored form is local time with an explicit offset, the older UTC form is still accepted, and a component round-trip check rejects calendar-inconsistent values instead of silently rolling them over. The status view adds one line when architecture sediment is due, either because the last sync is older than the threshold or because enough newly archived changes carry sediment sections; below the threshold it stays silent. (#136)

Changed

• The UI-DESIGN binding is enforced rather than advisory: the design node's flow-comet-ui-design binding is guarded, and a structural criterion decides whether it applies — the visual-tone section counts as not applicable only when the not-applicable marker stands alone on its own line, leads a line, or sits in the value position of an applicability label, and ends on a word boundary, with the matched snippet echoed. A frontend change must load the skill, declare it and produce the UI-DESIGN artifact, while a non-frontend change prints a visible skip and needs neither; earlier changes keep the gradual warning. The shipped skill texts, the entry skill's bindings table and the entry guidance page all state the same level. This is a behavior change for frontend changes: the design exit blocks until the artifact and the declaration are in place, and the recovery paths are printed with the block. (#136)
• The two-tier regression baseline moved up with the new coverage: the self-test suite now records 309 scenarios and the system test suite 93 items, and both counts stay machine-checked across the release surfaces. (#136)

---

Install / 安装: npm install -g flow-comet · 或按 README 的入口技能方式使用（Claude Code /flow-comet · Codex /use flow-comet · dsh 调用 flow-comet 技能）。

Notes source: 本说明取该 tag 当时的 CHANGELOG.md 版本段。

v1.6.1

[1.6.1] - 2026-10-02

A release gathering the work accumulated after 1.6.0: the public documents were rebuilt around one authority per topic, and the bilingual check now compares structure rather than line counts; the maintenance documents are validated by the regression suite, which also states what it skipped; a plan proven defective while executing can be revised in place through an explicitly authorized channel that re-runs the same checks without exemption, backs up the state before rewriting, keeps every use on record and caps the rounds; forced advancement is recorded and shown in the status view; a plan that splits one file across tasks without a declared order is blocked at the planning exit; and the regression suite no longer aborts when a fixture directory is still held. (#118) (#120) (#121) (#126) (#127) (#128) (#130) (#131) (#132)

Added

• A controlled plan re-validation channel: when an executable phase's plan is proven defective, its task set can now be revised in place through an explicitly authorized path that re-runs the same dependency, field and verification checks the planning exit runs (no exemption), takes a full state backup with a fingerprint before rewriting, keeps every use on record (who authorized it, why, and which round), caps revisions per change with an explicit continuation round beyond the cap, and is a visible no-op when the signature already matches.
• The maintenance-document checks now say what they skipped: the self-test suite also validates the references written in the three knowledge documents that are updated most often, resolves references written relative to the skill tree or the rule tree (reporting a missing target under those roots), and prints a visible skip line — naming the check, the reason, and the reminder to run the suite in the maintainer checkout — when a maintainer checkout does not carry those documents, instead of passing silently. A regression anchor now covers the plan-revision path's refusal to continue when the task list is missing or empty, down to unchanged state bytes.
• The issue forms now carry a public-content confirmation, and the repository keeps a local issue inspection script: every issue template asks the reporter to confirm that the text carries no process codes or unreleased material, and a script run against the repository's issue tracker scans both open and closed issues for that content, prints every hit, and reports an explicit "not applicable" (non-zero) when the GitHub CLI is missing or unauthenticated instead of passing silently.

Changed

• The two-tier regression baseline moved up with the new coverage: the self-test suite now records 275 scenarios and the system test suite 86 items, and both counts stay machine-checked across the release surfaces.
• Forced advancement is now recorded: advancing a node without its exit gate appends an audit event naming the gate that was skipped, and the status view exposes which nodes were advanced this way.
• workflow-handoff status now names a recorded result the way the state stores it: the status output used the plural key handoffResults while the state stores handoffResult, so a consumer that followed the printed name found nothing. The output key and the storage key are now the same single name; the other status fields (activeChange, handoffRequests) and the state shape are unchanged.
• The contract check no longer assumes one project's directory layout: the directories it scanned were hard-coded to a single application's layout, so in any other project it either missed the sources or pointed at paths that did not exist. It now scans the default directories (<root>/app and <root>/src) or the ones given explicitly with --backend <dir> and --frontend <dir> (resolved against --project or the current directory), and it prints the paths it actually resolved.
• The shipped skill and reference pages no longer carry unreleased-process vocabulary: the step names, window labels and verification-record terms that had leaked into them were replaced with plain descriptions; machine-readable markers, command names, and state or protocol field names are untouched.
• The skill instructions now name a single authority for artifact structure: the node skills, the task-decomposition skill and the change, requirement, dev, test and integration stage-protocol skills state that their output must follow the section shapes of the project's own templates, and that archived artifacts are historical evidence rather than a template to copy from. The entry skill's artifact-path section also explains when archive material may be read (resuming after an interruption, tracing a decision, or checking a required convention that the templates and lessons do not cover), what may be taken from it (structure and evidence only), and what it must not be used for (format rules or decisions). (#130)
• Planning guidance now defines task boundaries and parallel work honestly: tasks that touch the same file must be one task, and splitting them is allowed only with an explicit order and a written reason; a task may be marked parallel only when its wave truly contains a companion task with no overlapping file writes, while isolated tasks stay serial; and under direct execution, parallel tasks are still delegated — the direct allowance covers only serial work written in place, with mutually exclusive file scope and the pre-commit diff check as the shared-workspace discipline. (#130)
• The shipped Codex and worktree notes now separate platform facts from the current support surface: Codex's regular usage is the interactive CLI, and its native multi-agent support (multi_agent) is enabled by default — real interactive sessions do record spawn_agent, wait_agent and close_agent calls — so “Codex cannot delegate” is not a platform fact. Flow-comet's guard and whitelist model does not yet cover that native subagent shape; until the probe results (which must cover interactive sessions and native subagents) settle the follow-up contract, the execution node does not dispatch parallel subagents on Codex and delivers serially through the execute node — a current support-surface limit, not a platform boundary. What is recorded as measured is limited to the codex exec headless subface and marked as such, with no extrapolation to the interactive or native-subagent forms; a hand-made worktree remains an unsupported path and not a bypass. (#130)
• A plan that splits one file across tasks without an ordering path is now blocked at the planning exit: when two tasks outside the repair loop declare writes to the same file and neither of them reaches the other through declared dependencies, a new change is blocked, and the report names the task pair, the overlapping files and the recovery path — declare an explicit dependency between the two tasks, or merge them into one task. An older change only warns and proceeds, so existing plans are not stalled. The planning exit and the in-place revision channel (replan) apply the same judgment — a new change is blocked, an older change only warns, and the recovery path is the same: declare an explicit dependency between the two tasks, or merge them into one task.
• The machine checks now cover more of the surface they guard: the vocabulary check that keeps unreleased process wording out of the public documents now also covers the shipped skill texts and the comments inside the scripts that ship with them; the knowledge document that is updated most often joins the list of files whose recorded counts are verified, and a recorded count that no longer matches the current value is now reported as stale even when the same file also carries the current one; and the maintenance-document checks add three judgments — a file-and-line reference whose line number lies beyond the end of its target, a knowledge page whose header date is older than the newest date in its own body, and a roadmap section for work in progress that still names an archived change.
• The bilingual mirroring check now compares structure instead of line counts: the two languages of a document are matched block by block — the sequence of block types and of heading levels — so a block that exists in only one language can no longer sit inside a line-count tolerance; an intentional difference must be declared with a content pattern, and the check verifies that the declared difference really is of the declared kind. (#120)
• The bug and question forms now accept a DeepSeek Harness report: the platform list gained dsh, and the question template names the dsh version marker path alongside the Claude Code and Codex ones, so a report from that platform no longer has to go into the free-text environment section. (#121)

Fixed

• The empty-exit exemption at the execution-phase exit was narrowed: it now applies only to a change whose task set has no serial tasks; otherwise the normal output-schema checks run, an explicit notice says the exemption did not apply, and the checks that are skipped when it does apply are listed.
• The shipped reference pages no longer carry stale facts: the t...

v1.6.0

[1.6.0] - 2026-09-27

A release gathering the batches accumulated after 1.5.1: the installer no longer borrows the host repository's tags for the version it reports and its messages use the tool's own name; the internal documentation was rebuilt and cleaned up; repairs reported after review now run through the execution lifecycle, return audit lines state their source explicitly, controlled repair cycles are counted per change with a fourth one pausing for a decision, and task-set signatures record the algorithm that produced them; and an archived change can be re-opened through a controlled, explicitly authorized path. (#106) (#107) (#109) (#110) (#111) (#112) (#113)

Added

• An archived change can be re-opened through a controlled, explicitly authorized path: when a defect surfaces only after the change has been archived and before its workspace directory is moved away, the coordinator can return the work to the execution family, review or verify with one command. Each call requires an explicit authorization and a reason, takes a verifiable state snapshot before anything is moved, and records a dedicated audit entry and line that are distinguishable from an ordinary repair reposition or multi-pass finish. A change may use the path up to three times; a further attempt is blocked with continue/stop guidance, and continuing past the cap requires its own explicit authorization for the coming round. Unauthorized calls, out-of-range targets, a moved or already-completed archive are rejected with the state file byte-for-byte unchanged — including on a legacy change, whose shape must not become an authorization bypass, while legacy changes keep their warn-and-proceed behaviour everywhere else.

Changed

• The shipped regression suite no longer crashes in projects whose path contains non-ASCII characters: its installed-copy fixture copied the skill tree with the platform recursive copy, which on Windows ends the process silently when the source path contains characters outside ASCII — in such a project the suite could not get past its two hundredth scenario (reproduced twice in a project whose path contains Chinese characters, while the ASCII-path control run of the same code passed). The fixture now copies directory by directory and file by file, and an anchor copies a tree through a non-ASCII source path and checks the result is complete.

• Delegation requests are checked against the task's declared execution mode at request time: a pending task is now rejected unless the workflow is already on the node its declaration expects — the delegation node for a parallel task, the execution node for a serial one. The check runs before any handoff evidence is written, so a rejection leaves the state file byte-for-byte unchanged and records nothing; the message points to workflow-state next and then entry <target node> for recovery. A correct node that has not been entered only warns, completed tasks and explicit --write-files requests are not gated, a protocol without the expected enabled node skips the check, and a legacy change keeps the previous warn-and-proceed behaviour.

• Controlled repair cycles are counted per change and the fourth one pauses for a decision: a reposition from the review or verify node back into the execution node with pending repair work now increments a per-change counter; the first three rounds print the round in the audit line, while a fourth reposition on a new change is blocked without moving the workflow and offers "continue repairing / stop" guidance. Continuing requires an explicit user authorization recorded in the handoff evidence; a legacy change warns and proceeds. Failed verify commands use a separate per-change counter, a passing verify does not clear the repair counter, and repositions that are not this controlled form — an already-complete task set, a classification-only pass, or a verify command failure — are not counted.

• Task-set signatures carry the algorithm version that produced them: the recorded signature value is prefixed with its version and the applied-exit event also records the algorithm version, so a bare digest written by an older state is read with the original version's semantics. Return classification, controlled reposition and the task-set comparison only compare signatures produced by the same version, so an engine upgrade no longer misreads an ordinary multi-pass finish as an unclosed repair cycle or blocks an unchanged task set; changing the algorithm itself requires an explicit decision at the frozen regression anchor instead of silently reclassifying existing states.

• A claimed zero-commit handoff is re-verified when the result is recorded: a result that declares no commit must still prove at result time that its declared outputs are empty or literally ignored. If ignore rules changed, a declared path became tracked, or any existing ancestor segment is a symbolic link or junction, the recorded no-commit flag is withdrawn and the result is rejected on a new change (warned on a legacy one) instead of being exempted from the missing commit hash; the project root is realpath-normalized before the check, and anything that cannot be proven to belong to the zero-commit class still runs the full commit-subset validation. The check is a path-safety proof at decision time: unreferenced commits, a HEAD moved afterwards, races between validation and recording, and commits invisible to a worktree-isolated flow remain documented residual risk, not closed guarantees.

• Task summaries are checked against the full template skeleton: every section of the SUMMARY template must now exist — conditional sections may be present with an explicit N/A — and the sections that appear must follow template order, with the mandatory self-check method section placed after the boundary check (at the end or immediately after it). A new change missing a section is blocked with guidance to add it as N/A; a legacy change keeps the progressive warning, and a missing template falls back to the built-in skeleton.

• The installer's messages use the tool's name: the output prefix came from the script's own file name, so a command typed as fcomet reported every step under a name the user never used — and the usage line in the same output already said fcomet init, leaving one command with two names on one screen. The prefix is now flow-comet, which matches the tool however it is invoked (the packaged command, its alias, or the script in a repository clone).

• The orchestration instructions installed into projects no longer carry stale wording or a non-entry: the opening line described a "bundle" and a "portable control plane" — vocabulary this project dropped when it moved away from its predecessor's layout — and the script list included a two-line compatibility shim that is not an entry point to anything. The opening line now says plainly what the file is, and the shim is no longer advertised. A check keeps that text, which every project loads automatically, free of both.

• The regression suite now checks the maintenance documents: the self-test suite validates that references in the maintenance documents resolve and that the roadmap keeps its four sections (it skips where those documents are absent, as in a CI checkout), so drift that CI structurally cannot see is caught locally. The regression suite now runs 267 scenarios and the system test suite 82 items.

• The documentation now matches the shipped behaviour: the install guide no longer points at a retired state file or command; the npm channel is described as published; the release checklist includes the npm publish and GitHub Release steps; the Codex section describes serial delivery instead of manual worktree delegation; the force-push rule states its scope; and the Comet badge now carries a boundary note (the two projects no longer share files).

• Repair batches now run through the execution lifecycle: when the review or verify node reports defects, the follow-up work is routed back into the execution node and the reposition is recorded in the workflow state, so that node's four exit gates are actually evaluated — every task complete, every task summary present, the self-review evidence declared, and the task set unchanged since entry. Once the repairs pass, the workflow returns to the node that reported the defects and runs that node's own exit gate before continuing, instead of skipping it because its report already exists.

• Repair-return audit lines are distinguishable again: when a repair cycle re-enters the execution family and then returns control to the node that reported the defects, the printed line is classified by cause — a genuine repair batch keeps the dedicated repair label, while an ordinary multi-pass close-out prints a neutral return line instead of borrowing that label; a state without enough recorded evidence to tell the two apart prints the neutral line marked unclassified rather than guessing, and the line that keeps a source node in place so its own exit can run is always neutral. Routing, completed nodes and state writes are unchanged; only the audit text differs.

• A delivery whose declared outputs are empty or all ignored can close without a commit: a delegated task whose declared outputs are empty, or every one of them is covered by the repository's ignore rules, can now be handed off legally with no commit — the result may omit a commit hash and no handoff error is produced. Anything that cannot be proven to belong to that class stil...

v1.5.1

Installer command-surface fix: a bare fcomet with no arguments no longer installs into the current directory (it prints its usage and exits non-zero), and --version / -v report the installed version instead of failing as an unknown argument. (#103)

Added

• The installer answers --version (and -v): it prints the version identifier from the same source that ships inside the package and is written into installed projects, so the version of a global install can be checked without going through the package manager. Previously only --help was handled, and asking for the version exited non-zero with an "unknown argument" error.

Fixed

• A bare fcomet no longer installs into the current directory: with no arguments at all the command now prints its usage and exits non-zero instead of running a full install — creating .claude/, fetching flow-kit/ and appending to .gitignore — in whatever directory happened to be current. The init word remains optional whenever another argument expresses the intent, so fcomet --target <dir> is still equivalent to fcomet init --target <dir>.

v1.5.0

A release closing out the review follow-up after 1.5.0-rc.3: the two defects found by external review are fixed — a context document whose headings carry a legal ATX closing marker no longer has sections that are present reported as missing, and the installer aborts rather than truncating a .gitignore it cannot read — the protected-path helpers now have a single implementation, and several statements that had gone stale are corrected. (#100)

Fixed

• A context document whose headings carry a legal closing marker no longer blocks the workflow: an ATX heading that repeats its hashes at the end (for example ## Section name ##) was stored with the trailing ## as part of the section name, so the name comparison missed it and the structure check reported sections that are present as missing — the closing marker is now stripped (it must still be preceded by a space, so a section name that legitimately ends with # is left alone).
• The installer no longer truncates a .gitignore it cannot read: every read error was treated as "the file does not exist", so under an access failure (read denied, write allowed) the user's existing .gitignore was rewritten down to the managed entry alone. Only a genuinely absent file counts as first-time management now, and an access failure aborts the install instead — the same rule the installer already applied to its migration probe, now shared by both call sites.

Changed

• The protected-path helpers have a single implementation: the write guard carried its own byte-identical copy of the path-containment, protected-path inspection and protected-file read helpers, so a fix to one copy never reached the other — the guard imports them from the shared module.
• Stale statements corrected: the path-base error message no longer claims that only the state machine withholds support (the guard rejects the same values, and the neighbouring comment now agrees), the dsh platform reference records the npm package as published and the AGENTS.md injection as certified, and the security policy names the installer's third-party dependency together with the boundary for reporting that package's own vulnerabilities upstream.
• The changelog's own path reference is complete: the authoritative version marker is now referred to as .flow-comet/skills/flow-comet/INSTALLED_VERSION, a path that resolves from the repository root.
• Three skill descriptions match the behaviour they document: the review reference states both outcomes for a missing disposition marker (blocking on a new change, a progressive warning on a legacy one), the evolve command explains that a stale timestamp only prompts an explicit invocation instead of triggering on its own, and the decision-points reference no longer files a terminal stop condition as a user decision.
• The regression suite now runs 243 scenarios; the system test suite is unchanged at 75 items.

v1.5.0-rc.3

Release candidate shipping the distribution and runtime-namespace batches accumulated after rc.2: the npm distribution channel (an installable package declaring its published contents as a files allow-list and exposing two command entries), the runtime namespace decoupled from Comet (.flow-comet/ state file, authoritative source and FLOW_COMET_RUN_ROOT), the write guard and the workflow guard no longer reading Comet configuration, and the fixes carried in the same batch — the dsh bridge version stamp aligned with the release version, the POSIX hook command on every platform, the worktree-isolation release, and installer/migration hardening from external review. (#93) (#94) (#95) (#96) (#97) (#98)

Added

• npm distribution channel: flow-comet is now installable as an npm package that exposes the installer under two command names (fcomet and flow-comet), so a global install followed by fcomet init sets up a project in the current directory — --target is optional, and the installer also accepts an optional leading init word, so fcomet init and a bare fcomet are equivalent. The published contents are declared as a files allow-list (the skill tree, the orchestration rule, the installer and the dsh bridge script), so private and non-distributed artifacts stay out of the package structurally rather than through a deny-list. Nothing has been published to the registry yet: this batch makes the package publishable, and publishing stays a release action.

Changed

• Runtime namespace decoupled from Comet: the workflow state file now lives at .flow-comet/flow-comet-state.json, the authoritative source moved to .flow-comet/skills/ with the orchestration rule at .flow-comet/rules/, and the root-anchoring environment variable is renamed FLOW_COMET_RUN_ROOT (hard switch — the old variable is no longer read). The installer migrates an existing state file with a mandatory pre-migration backup (.flow-comet/flow-comet-state.json.bak-<timestamp>, kept after migration) and aborts without overwriting when the new and old locations both exist, when the old file is a symbolic link, or when it is not valid JSON; target-project ignore rules are handled conservatively (existing entries preserved verbatim, a .flow-comet/ entry appended only when missing, idempotent on re-run).
• Comet awareness layer removed from the write guard and the workflow guard: neither reads Comet's .comet/config.yaml nor scans classic change directories — decisions follow the state file alone, and a retired overlay protocol kind no longer takes the overlay branch.
• The migration step is explicitly temporary, with stated retirement conditions: the installer's migration module is the only remaining place that references the old namespace, and it exists solely to move an existing state file once — it never enters a runtime path. It now documents how it is retired: it can be deleted in whole either at the next breaking release (when the migration window closes) or once install runs consistently report nothing left to migrate, so the transient reference cannot silently become permanent. The migration report also states plainly when everything was skipped, so a project can tell at a glance that the installer no longer needs to touch the old directory.
• Regression suite expanded to 241 scenarios; the system test suite now runs 75 items.
• Counts are described rather than frozen where no check covers them: several documents carried a hard-coded scenario or item count while not being part of the consistency self-check, so the number could go stale silently — this happened three times in this batch alone. Those places now say where the number comes from, and two table rows that had drifted apart between a skill and its guidance file are aligned, so the same class of staleness cannot recur unnoticed.
• The package manifest version joins the release version surface: the release-consistency check now reconciles nine places instead of eight — the npm package's version is compared with the README badge, this changelog, docs/VERSIONS.md and the authoritative skills/flow-comet/INSTALLED_VERSION, so a package that would ship with a stale version fails the release check instead of reaching the registry.
• The distribution surface is asserted rather than assumed: the system test suite gained an item that inspects the real npm pack output for the package boundary and the two command entries, and reports an explicit "not applicable" when it runs from an installed copy (which carries no package manifest) instead of skipping silently; the CI installer job asserts the same boundary, so a stray private file or a dropped command entry fails a check rather than shipping.

Removed

• Residue manifests that no runtime path or guard gate read: bundle.yaml, the hook descriptor files under hooks/, and the four manifest YAML files under skills/flow-comet/comet/.
• The leftover Comet configuration in this repository: .comet/config.yaml used the Comet project schema but was never active here — this repository has no classic change directory and nothing in the codebase reads it. It lived in this repository's tree and was committed here, so its removal was ours to make; the repository now contains no .comet directory at all.

Fixed

• dsh bridge loader version stamp aligned with the release version: the loader's BRIDGE_VERSION now matches the release version (and the authoritative INSTALLED_VERSION), so the read-only bridge health check reports a version-consistent loader on a freshly installed project instead of version skew; the installer's overwrite reporting and the regression suites read the stamp from the authoritative source instead of a fixed value.
• Worktree-isolated subagents are no longer misclassified as the coordinator: the project-root anchoring chain (added in the previous release) resolved to the main repository through the host-provided variable, which sits above the isolated worktree — writes inside .claude/worktrees/** were then judged against the coordinator whitelist and blocked, even though a worktree subagent writing source is the intended design. The guard now releases that isolation prefix, with ../ traversal protection; the mechanism notes that previously read "the project hook does not apply to subagents" now state the condition under which that was true.
• A failing state path now explains itself: when the protocol's state path points at a file that does not exist, the guard reports the resolved path, detects a state file in the other runtime namespace (suggesting the project may not be migrated yet), and names the exact field to correct — instead of a bare "state does not exist". It still fails closed and never falls back.
• The runtime state path now has a single source: the literal was repeated across four scripts and a change to one would not alert the others; it now derives from one exported constant, with the write guard's added import measured at about 1.7 ms per invocation.
• The Claude Code hook command now uses the POSIX form on every platform: the installer previously emitted a cmd-style %CLAUDE_PROJECT_DIR% reference with backslash paths on Windows, but the host executes hook commands with bash semantics — the variable was never expanded and the backslashes were swallowed as escape characters, so the guard script failed to load on every tool call (the host downgraded the crashing hook to a non-blocking error, leaving writes unintercepted); the installer now emits the braced POSIX form on all platforms, and the regression suite verifies the generated command actually executes under the host's semantics.
• Migration and installer hardening from external review: four behaviours were corrected. (a) The worktree-isolation release now applies to writes detected from a Bash command, not only to those judged from a file path — previously the same write was allowed through one route and blocked through the other. (b) A path is treated as absent only when it genuinely does not exist; an access error such as a permission failure now surfaces and aborts instead of being silently read as "no legacy state", which could have left a project's state behind while reporting the migration complete. (c) A state file beginning with a UTF-8 BOM is accepted for validation, matching the runtime reader, while the backup and the migrated file keep the original bytes untouched. (d) The --purge confirmation is validated before any write, so a command that is ultimately rejected no longer modifies the target first.
• The contract checker now covers the shared modules: protocol-utils, state-schema, task-parsing and route-node are part of its required list — a copy missing one of them breaks every guard script at import time, yet the checker previously still reported success.
• The worktree delegation notes no longer document a bypass: the guidance that recommended writing through a direct File API to evade the write guard is marked as a withdrawn workaround and must not be used; on platforms without agent isolation the delegation step now requires serial execution instead.
• Task attributes and CLI checks corrected from external review: task parsing now accepts single-quoted attribute values (previously such a task was silently read as non-parallel, which skewed routing and skipped the parallel-write overlap check); the contract checker escapes the field name before building its regular expression (previously a field containing a bracket threw an error, and one such as item[0] matche...

v1.5.0-rc.2

Release candidate shipping the routing and installer batches accumulated after rc.1: dependency-driven multi-pass parallel routing (dependency gates, interleaved waves), write-guard hardening (project-root anchoring, state-file case variants), test-only parallel-task advisories, multi-pass exit hardening, next usable across parallel transitions, file-level dependency checks at planning exit, routing convergence under one shared decision, the executor authorization constraint for the direct escape hatch, and the flow-kit snapshot / dsh bridge loader governance. (#75) (#76) (#77) (#78) (#79) (#80) (#81) (#83) (#84)

Added

• Installer acquires flow-kit automatically: prepare-env clones the upstream and checks out the locked snapshot commit (9b5dda7) when the target project lacks flow-kit/; an existing upstream clone is only inspected read-only (current HEAD vs the locked snapshot is reported with the difference impact); a same-name non-clone directory is skipped with guidance; a network failure warns and continues; purge never includes flow-kit.
• dsh loader version governance and read-only bridge health check: every dsh install compares the loader's embedded version stamp with the installed copy before overwriting and reports first install / upgrade / downgrade / version consistent; workflow-state.mjs bridge-check reports six states (healthy / file missing / not mounted / version skew / duplicate registration / not applicable) with zero writes and zero network.
• Interactive platform selection upgraded to a direction-key multi-select: @clack/prompts is now the primary TTY path (pinned exact version — the repository's only third-party dependency, used solely by the installer's interactive selection), with an automatic readline number/comma multi-select fallback when the dependency is not installed, offline, or stdin has no raw mode; FLOW_COMET_FORCE_READLINE=1 forces the fallback for testing.

Changed

• Documentation aligned with repository conventions: task summaries now defer to each repository's own ignore rules and are never force-added into version control, the commit convention adopts general optional scope semantics (short subsystem nouns; recommended but optional; management codes such as change-id must not be used as scope, and task numbers go in the commit body footer), branch naming alignment via init --branch-prefix is documented in the installation guide, and planners are told the wave-grouping constraint before plan exit.
• Dependency-driven multi-pass parallel routing: the delegation node can now be entered multiple times — each pass delegates every dependency-satisfied parallel task, interleaved parallel/serial sequences run in alternating passes instead of being rejected, planning exits validate dependency cycles rather than wave shapes (with recovery guidance on a cycle), and the delegation node counts as complete only when no dependency-satisfied parallel task and no serial task remains. Write-guard hook injection hardened against directory drift: the installer injects the hook command as a project-root-referencing form, re-running the installer upgrades older relative-path entries in place (idempotent, no residue), and the installation and troubleshooting guides document the upgrade step and the fail-open symptom signature.
• Write-guard project-root resolution hardened against directory drift: the hook now resolves its project root via COMET_RUN_ROOT, then CLAUDE_PROJECT_DIR (injected by Claude Code), then walks upward from the session working directory to the nearest project marker — a drifted session no longer degrades to an error-style pass-through for out-of-project writes.
• Advisory pseudo-parallel detection at planning exit: when a parallel task's declared writes consist exclusively of test files, the planning exit emits a non-blocking warning listing the task id and suggesting an explicit depends_on declaration or merging into a vertical slice — closing the implicit-dependency blind spot opened by interleaved multi-pass routing.
• Multi-pass exit hardening: the execute-exit serial-task check now respects declared task dependencies — serial tasks waiting on later passes no longer block progress, while genuinely runnable serial tasks still block with their ids and recovery guidance; single-line semicolon-separated write-file lists are accepted by both handoff auto-parsing and pseudo-parallel detection; the routing advisory warning stays silent once every task is done; dependency-deadlock blocks now include a boundary hint for the workflow-state advance escape hatch (with its re-entry obligation); and the planning and delegation skill texts now describe interleaved parallel/serial sequences as valid under dependency-graph semantics.
• next usable across parallel transitions: after a planning or delegation exit applies, next now recognizes the routing successor (the same derivation the guard uses for its reported next) instead of only the static direct successor — parallel transitions such as plan → delegation and delegation → execution between passes are no longer falsely blocked as a "probably not exited" node; recording evidence before exiting no longer drifts the current node forward prematurely, so the subsequent normal exit still works.
• Regression suite expanded to 219 scenarios; the system test suite now runs 73 items.
• Write-guard state-file case variant closure, fail-closed task-completion routing, parallel-write path normalization, and the test matrix kept in sync: on case-insensitive file systems the hook now blocks case variants of the state file (.Comet/Flow-Comet-State.json); task routing no longer treats a task missing a status as done (a malformed block keeps the flow in execution instead of routing to review early); parallel-write overlap detection normalizes declared paths (separator, dot segments, out-of-bounds) so path variants cannot bypass the overlap check; the system test's recovery fixture keeps the original overlap path while adding the dependency, proving the recovery works by dependency rather than by changing paths.
• File-level dependency checks at planning exit: overlap between parallel tasks' declared writes without an explicit dependency blocks new changes (with recovery guidance: declare the dependency or split serial) while legacy changes keep the warning; a parallel task reading another parallel task's write path gets a non-blocking implicit-dependency warning; extensions are resolved from the actual declared paths, closing the earlier .txt/extensionless blind spot.
• Routing convergence under one shared decision: the exit-reported next and next both derive from the shared routing module — including serial-pending reflow back to execution — so multi-pass exits and queried next no longer drift (regression-anchored).
• Executor-controlled direct mode constrained: switching to the direct escape hatch now requires an explicit authorization record (written by the coordinator's explicit switch); an executor's unauthorized switch is blocked, and the state file is guarded against manual tool writes — the escape hatch stays user-confirmed.