spec-ctx 0.1.0 → 0.1.1

package/README.md

@@ -1,111 +1,160 @@
 # spec-ctx
 
-spec-ctx ticks an [OpenSpec](https://github.com/Fission-AI/OpenSpec) task only after its Verify command passes and hands the agent one task of spec text, a context ratio of 0.0518 (`docs/metrics/2026-10-25.md`).
+Stable IDs for OpenSpec. Your coding agent loads only the spec one task needs, and knows what to do next.
 
-```bash
-npx -y github:sonqh/spec-ctx#4490d188ad48 init --all
-npx -y github:sonqh/spec-ctx#4490d188ad48 task next
-npx -y github:sonqh/spec-ctx#4490d188ad48 task start add-mfa/1.3
-```
+For teams that run Claude Code, Codex, or Cursor on an OpenSpec project.
 
-```text
-$ specctx task start add-mfa/1.3
--- REQ-UA-004 | openspec/changes/add-mfa/specs/user-auth/spec.md:5 | active | requested
-### Requirement: REQ-UA-004 Second factor
-The system SHALL ask for a TOTP code after a valid password.
-
-#### Scenario: SCN-UA-004-1 Valid code
-- **WHEN** the user enters the current TOTP code
-- **THEN** the system opens a session
-
-#### Scenario: SCN-UA-004-2 Expired code
-- **WHEN** the user enters a code older than 30 seconds
-- **THEN** the system rejects it
+## What OpenSpec is
+
+[OpenSpec](https://github.com/Fission-AI/OpenSpec) is a folder named `openspec/` in your repo. It holds specs, the rules your software must follow, and changes. A change holds a proposal, a design, and a task list. A coding agent reads them and works down the list.
+
+## The problem
+
+Three things go wrong.
+
+- The agent reads the whole `openspec/` tree for every task. Most of it is not about the task. Tokens go to text the agent will not use.
+- OpenSpec links a change to a spec by header text. A reword breaks the link, and the agent loses the thread between requirement, code, and test.
+- A new session starts cold. The agent does not know which task is next, what it already did, or which questions are open.
+
+## What spec-ctx adds
+
+| Without | With spec-ctx |
+| --- | --- |
+| The agent reads the whole `openspec/` tree. | The agent gets the bundle of one task: the requirements it cites, their scenarios, decisions, and neighbors. |
+| Links go by header text. | Every requirement, scenario, decision, and task has an ID. Code and tests carry tags that name it. |
+| Each session starts cold. | `status`, `task next`, and the generated handoff say where the work stands. |
+| The agent ticks `[x]` by hand. | `[x]` appears only after the Verify command of the task exits 0. The run leaves an evidence file. |
+
+A later edit can break a task that passed. `check --strict` names each task whose files changed after its Verify passed.
+
+No LLM call. No daemon. The same files give the same output.
+
+## See it work
+
+Six commands on a small project. Each clip is one command.
+
+### 1. Give every requirement an ID
+
+OpenSpec names a requirement by its header text. A reword breaks every link to it. `adopt` gives each requirement and scenario an ID that stays. Run it once on a project that has specs. A new project gets IDs from `init --all`.
+
+![The adopt dry run lists each header and its new ID](docs/demo/clips/1-adopt.svg)
+
+You see: the dry run prints each header and the ID it gets. Then `adopt` writes them.
+
+### 2. Where are we
+
+`status` shows the open change, the task counts, and the next command to run.
+
+![One change with two tasks done and one open](docs/demo/clips/2-status.svg)
+
+You see: one change, two tasks done, one open, and the hint.
+
+### 3. What is next
+
+`task next` picks the first open task. It prints the requirement IDs the task cites and the Verify command, the shell command that proves the task is done.
+
+![Task add-mfa/1.3 with its requirement and Verify command](docs/demo/clips/3-next.svg)
+
+You see: task `add-mfa/1.3`, its requirement, and `grep -q totp src/login.ts`.
+
+### 4. Only the spec this task needs
+
+`task start` prints the requirement, its scenarios, the task line, and the test that covers it. Nothing else. The last line is the size of that bundle next to the size of all spec text.
+
+![The bundle of one task and its size footer](docs/demo/clips/4-start.svg)
+
+You see: 711 characters, 3.6 percent of the tree. The agent reads this instead of the tree.
+
+### 5. Done means Verify passed
+
+`task done` runs the Verify command. On exit 1 the box stays open. On exit 0 the box flips to `[x]` and an evidence file records the files that were checked. The agent cannot tick the box by hand.
+
+![A refused done, the edit, and a passing done](docs/demo/clips/5-done.svg)
+
+You see: a red refusal, the edit, then a green done line.
+
+### 6. Hand off to the next session
+
+`handoff write` puts the state in one file: the change, the done tasks, the current task, and the open questions. The next session starts from it.
+
+![The head of the handoff file](docs/demo/clips/6-handoff.svg)
+
+You see: the head of `.ctx/handoff.md`.
+
+The transcript of all six clips is in `docs/demo/loop.txt`. The clips run on a copy of `tests/fixtures/no-id-repo` plus the six capabilities in `docs/demo/specs/`. `bash docs/demo/record.sh` records them again.
+
+## Quickstart
+
+```bash
+npx -y spec-ctx init --all              # config, schema, and three agent skills
+npx -y spec-ctx task next               # the next task and the command that proves it
+npx -y spec-ctx task start <task>       # only the spec that this task needs
+npx -y spec-ctx task done <task>        # runs that command. A pass ticks the box.
 ```
 
-## Why
+A project with specs but no IDs needs `specctx adopt` first. See [Two paths](#two-paths).
 
-- Checkboxes lie. `task done` runs Verify and writes evidence, and 70 of 86 tasks hold it (evidence ratio 0.81).
-- Context overflows. A bundle holds 0.0518 of the spec text on average (27 tasks).
-- Evidence goes stale. The check caught 36 stale results in 59 reopens.
+## How it finds the context
 
-## Demo
+```mermaid
+graph LR
+  T["task add-mfa/1.3"] -->|cites| R["REQ-UA-004"]
+  R -->|scenario| S1["SCN-UA-004-1"]
+  R -->|scenario| S2["SCN-UA-004-2"]
+  R -->|"// REQ tag"| C["src/login.ts"]
+  R -->|"Covers:"| X["tests/login.test.ts"]
+```
 
-![One task loop: status, task next, task start, an edit, task done, stats](docs/demo/loop.svg)
+The ID is the stable key. A reword of a header does not change it. The index is the graph of IDs: tasks, requirements, scenarios, decisions, code tags, and test tags. `bundle` walks the edges to the configured depth inside a character budget. A decision record joins the graph through its `Refs:` line. The demo fixture has none, so the graph above shows no decision.
 
-<details>
-<summary>Transcript of the demo</summary>
+`specctx related` prints each neighbor of an ID and the reason for the link. This is the output for the demo project after its last step:
 
 ```text
-$ specctx status
-index rebuilt
-add-mfa  done 2  open 1
-uncovered active REQs in main: 5
-next: specctx task next
-$ specctx task next
-add-mfa/1.3  Add the TOTP prompt to the login form.
-reqs: REQ-UA-004
-verify: grep -q totp src/login.ts
-$ specctx task start add-mfa/1.3 | head -12
--- REQ-UA-004 | openspec/changes/add-mfa/specs/user-auth/spec.md:5 | active | requested
-### Requirement: REQ-UA-004 Second factor
-The system SHALL ask for a TOTP code after a valid password.
-
-#### Scenario: SCN-UA-004-1 Valid code
-- **WHEN** the user enters the current TOTP code
-- **THEN** the system opens a session
-
-#### Scenario: SCN-UA-004-2 Expired code
-- **WHEN** the user enters a code older than 30 seconds
-- **THEN** the system rejects it
-
-$ printf '// REQ-UA-004\nexport const prompt = "totp";\n' > src/login.ts
-$ specctx task done add-mfa/1.3
-index rebuilt
-done add-mfa/1.3. Evidence: .ctx/evidence/add-mfa/1.3.json
-$ specctx stats --change add-mfa
-index rebuilt
-change   context_ratio  evidence_ratio  stale_catches  cycle_time_median_s  debt
-add-mfa  0.2950 (n=1)   1.00 (1/1)      n/a            6 (n=1)              2
-total    0.2950 (n=1)   1.00 (1/1)      n/a            6 (n=1)              13 (0 baselined + 13 new)
-gate_runs n/a
-gate_pass_rate n/a
-gate_failures_caught n/a
-context_ratio = bundle chars / chars of all specs. Lower is better.
+$ specctx related REQ-UA-004
+scn  SCN-UA-004-1  active  openspec/changes/add-mfa/specs/user-auth/spec.md:8  scenario of REQ-UA-004
+scn  SCN-UA-004-2  active  openspec/changes/add-mfa/specs/user-auth/spec.md:12  scenario of REQ-UA-004
+task  add-mfa/1.3  done  openspec/changes/add-mfa/tasks.md:7  task cites REQ-UA-004
+code  src/login.ts:1  active  src/login.ts:1  implements REQ-UA-004
+test  tests/login.test.ts:1  active  tests/login.test.ts:1  covers REQ-UA-004
 ```
 
-</details>
-
-The demo runs on a copy of `tests/fixtures/no-id-repo` after `specctx adopt`. `bash docs/demo/record.sh` records it again.
+## The life cycle for agents
 
-## What it does
+`init --all` installs three skills. Each one fires at a fixed point of the session.
 
-spec-ctx is a deterministic context engine and task workflow for OpenSpec projects. The CLI is `specctx`.
+- `specctx-bootstrap` fires at the start of a session. It reads the status and the handoff and starts the task.
+- `specctx-next` fires after a task closes. It picks the next task and loads its bundle.
+- `specctx-done` fires when the work is complete. It runs Verify, closes the task, and writes the handoff.
 
-OpenSpec gives you a proposal, specs, a design, and tasks. spec-ctx adds what an AI agent needs to work on them without reading the whole tree:
+The loop that the skills teach:
 
-- Stable IDs on every requirement, scenario, decision, and task.
-- An index that links each ID to code, tests, and other IDs.
-- `bundle`: the few kilobytes of spec that one task needs, with the file and line of each block.
-- `task next`, `task start`, `task done`: the checkbox changes only after the `Verify:` command of the task exits 0, and the evidence stays beside the tree.
-- A generated handoff, so the next session starts with one command.
+```bash
+specctx init --all             # config, schema, and the three skills
+specctx status                 # active changes, current task, open questions
+specctx task next              # the next open task, its REQ IDs, and its Verify command
+specctx task start <task>      # the bundle of that task and its size
+specctx task done <task>       # run Verify, write evidence, set the checkbox
+specctx check --strict         # IDs, links, coverage, and evidence
+specctx handoff write          # .ctx/handoff.md for the next session
+```
 
-No LLM call. No daemon. The same files give the same bytes.
+The rule: the agent never opens `openspec/specs/` by hand. It uses `task start` or `bundle`. The skills are in [`skills/`](skills/). Install them alone with `npx skills add sonqh/spec-ctx` or `specctx init --skills`.
 
 ## Install
 
 spec-ctx needs Node 22. Run it in a project after `openspec init`.
 
 ```bash
-npx -y github:sonqh/spec-ctx#4490d188ad48 init --all    # from git, works today
-npx spec-ctx init --all                                # from npm, after the 0.1.0 publish
+npx -y spec-ctx init --all                           # from npm
+npm install -g spec-ctx                              # puts specctx on your path
+npx -y github:sonqh/spec-ctx#<sha> init --all        # from git, for an unreleased commit
 ```
 
 The git form builds the package on install with Node only. Pin a commit SHA. A branch name such as `main` also works, but it moves.
 
 The command writes `spec-ctx.toml`, installs the `spec-driven-ids` schema into `openspec/schemas/`, adds its rules to `openspec/config.yaml`, and installs three skills into `.claude/skills/` and `.agents/skills/`.
 
-The examples below use `specctx`. With `npx`, write the `npx` form in its place. After the publish, `npm install -g spec-ctx` puts `specctx` on your path. Each GitHub release also carries a single binary for Linux and macOS.
+The examples below use `specctx`. With `npx`, write `npx -y spec-ctx` in its place. Each GitHub release also carries a single binary for Linux and macOS.
 
 ## Two paths
 
@@ -137,19 +186,6 @@ specctx gate --strict
 
 Both paths have an end to end test: `tests/paths/fresh.sh` and `tests/paths/existing.sh`.
 
-## The loop
-
-```bash
-specctx status                 # active changes, current task, open questions
-specctx task next              # the next open task, its REQ IDs, and its Verify command
-specctx task start 001/1.1     # the spec bundle for that task
-specctx task done 001/1.1      # run Verify, write evidence, set the checkbox
-specctx check --strict         # IDs, links, coverage, and evidence
-specctx handoff write          # .ctx/handoff.md for the next session
-```
-
-The skills `specctx-bootstrap`, `specctx-next`, and `specctx-done` teach an agent this loop. Install them alone with `npx skills add sonqh/spec-ctx` or `specctx init --skills`.
-
 ## Commands
 
 | Command | Use |
@@ -233,9 +269,26 @@ The action runs `specctx gate`: `check --strict`, both markdown linters, `opensp
 
 ## Status
 
-- Archived: 001 engine port, 002 IDs and tasks, 004 adopt existing, 005 metrics, 006 polish, 007 README and demo, 008 first run UX.
-- Open: 003 distribution. Only the npm publish of `0.1.0` waits.
-- Until the publish, install from git with `npx -y github:sonqh/spec-ctx#4490d188ad48`. The npm forms `npx spec-ctx` and `npm install -g spec-ctx` work after it.
+- Published: `spec-ctx@0.1.1` on npm, with tags `v0.1.1` and `v0` and binaries on the GitHub release.
+- Archived: 001 to 013. No change is open. See `CHANGELOG.md` for each release.
+- A version bump on `main` publishes the next release. See `docs/CONTRIBUTING.md`.
+- Upstream: the ID scheme is proposed as a comment on [OpenSpec#1967](https://github.com/Fission-AI/OpenSpec/issues/1967#issuecomment-6414314730). The schema bundle is submitted to the community table in [OpenSpec#2157](https://github.com/Fission-AI/OpenSpec/issues/2157). No pull request until a maintainer asks.
+
+## Measured
+
+`specctx stats --write` measures this repository after each change. The newest file is `docs/metrics/2026-10-26.md`. Its total row:
+
+| change | context_ratio | evidence_ratio | stale_catches | cycle_time_median_s | debt |
+| --- | --- | --- | --- | --- | --- |
+| total | 0.0469 (n=41) | 0.85 (88/104) | 36 (of 62 reopens) | 60 (n=41) | 0 (0 baselined + 0 new) |
+
+- `context_ratio`: the size of one task bundle divided by the size of all spec text. Lower is better.
+- `evidence_ratio`: done tasks with a passed Verify command, divided by all done tasks. The rest have a manual note. Higher is better.
+- `stale_catches`: reopened tasks that `check --strict` flagged as stale, out of all reopened tasks. A higher share means the check found the drift before a person did.
+- `cycle_time_median_s`: the median number of seconds from `task start` to `task done`. Lower is faster.
+- `debt`: findings that the baseline hides plus new findings. Zero is the goal.
+
+The value in brackets is the count of inputs. A value without inputs reads n/a.
 
 ## Contribute
 

package/dist/assets.generated.js

@@ -1,14 +1,14 @@
 // Generated by scripts/gen-assets.mjs from schemas/spec-driven-ids/ and skills/. Do not edit.
 // REQ-SCH-001 REQ-SKL-002
 export const ASSETS = {
-    "schemas/spec-driven-ids/README.md": "IyBzcGVjLWRyaXZlbi1pZHMKCkEgZm9yayBvZiB0aGUgT3BlblNwZWMgYHNwZWMtZHJpdmVuYCBzY2hlbWEuIEl0IGFkZHMgc3RhYmxlIElEcyBmcm9tIHNwZWMtY3R4IHRvIGV2ZXJ5IGFydGlmYWN0LgoKLSBUaGUgc3BlYyB0ZW1wbGF0ZSBzdGFydHMgZWFjaCByZXF1aXJlbWVudCB3aXRoIGBSRVEtPENBUD4tTk5OYCBhbmQgZWFjaCBzY2VuYXJpbyB3aXRoIGBTQ04tPENBUD4tTk5OLTxuPmAuCi0gVGhlIGluc3RydWN0aW9ucyB0ZWxsIHRoZSBhZ2VudCB0byBnZXQgSURzIGZyb20gYHNwZWNjdHggaWQgbmV3YCBhbmQgdG8gbGluayBJRHMgd2l0aCBgUmVmczpgIGxpbmVzLgotIFRoZSB0YXNrcyB0ZW1wbGF0ZSBjaXRlcyBSRVEgSURzIGFuZCBwdXRzIHRoZSBgVmVyaWZ5OmAgY29tbWFuZCBpbiBhIGNvZGUgc3Bhbiwgc28gYHNwZWNjdHggdGFzayBkb25lYCBjYW4gcnVuIGl0LgotIGBjb25maWctZnJhZ21lbnQueWFtbGAgaG9sZHMgdGhlIGBydWxlc2AgYW5kIGBvcGVyYXRpb25zYCB0aGF0IGBzcGVjY3R4IGluaXQgLS1zY2hlbWFgIGFkZHMgdG8gYG9wZW5zcGVjL2NvbmZpZy55YW1sYC4KCkZvcmtlZCBmcm9tIE9wZW5TcGVjIDEuMTQuMyB3aXRoIGBvcGVuc3BlYyBzY2hlbWEgZm9yayBzcGVjLWRyaXZlbiBzcGVjLWRyaXZlbi1pZHNgLiBDSSB2YWxpZGF0ZXMgaXQgYWdhaW5zdCB0aGF0IHZlcnNpb24uCgojIyBJbnN0YWxsCgpgYGBiYXNoCm5weCBzcGVjLWN0eCBpbml0IC0tc2NoZW1hCmBgYAoKVGhlIGNvbW1hbmQgY29waWVzIHRoaXMgZm9sZGVyIHRvIGBvcGVuc3BlYy9zY2hlbWFzL3NwZWMtZHJpdmVuLWlkcy9gIGFuZCBzZXRzIGBzY2hlbWE6IHNwZWMtZHJpdmVuLWlkc2AgaW4gYG9wZW5zcGVjL2NvbmZpZy55YW1sYC4K",
-    "schemas/spec-driven-ids/config-fragment.yaml": "IyBzcGVjLWN0eCBmcmFnbWVudCBmb3Igb3BlbnNwZWMvY29uZmlnLnlhbWwuIHNwZWNjdHggaW5pdCAtLXNjaGVtYSBhZGRzIGVhY2ggdG9wLWxldmVsIGtleQojIHRoYXQgdGhlIHByb2plY3QgY29uZmlnIGRvZXMgbm90IGhhdmUgeWV0LiBJdCBuZXZlciBjaGFuZ2VzIGEga2V5IHRoYXQgZXhpc3RzLgpydWxlczoKICBzcGVjczoKICAgIC0gRXZlcnkgcmVxdWlyZW1lbnQgaGVhZGVyIHN0YXJ0cyB3aXRoIGl0cyBJRCwgZS5nLiAiIyMjIFJlcXVpcmVtZW50OiBSRVEtQUJDLTAwMSBOYW1lIi4gR2V0IHRoZSBJRCBmcm9tIGBzcGVjY3R4IGlkIG5ldyBSRVEgQUJDYC4KICAgIC0gRXZlcnkgc2NlbmFyaW8gaGVhZGVyIHN0YXJ0cyB3aXRoIGl0cyBJRCwgZS5nLiAiIyMjIyBTY2VuYXJpbzogU0NOLUFCQy0wMDEtMSBOYW1lIi4KICAgIC0gQSByZXF1aXJlbWVudCBtYXkgZW5kIHdpdGggYSBsaW5lICJSZWZzOiBSRVEtQUJDLTAwMiwgQURSLTAwMSIgdG8gbGluayByZWxhdGVkIElEcy4KICAgIC0gUmVxdWlyZW1lbnQgdGV4dCBzdGF5cyB1bmRlciA1MDAgY2hhcmFjdGVycy4gTW92ZSBkZXRhaWwgaW50byBzY2VuYXJpb3MuCiAgZGVzaWduOgogICAgLSBFYWNoIGRlY2lzaW9uIGlzIG9uZSBidWxsZXQgdW5kZXIgIiMjIERlY2lzaW9ucyIuIEFkZCBuZXcgZGVjaXNpb25zIGF0IHRoZSBlbmQuCiAgdGFza3M6CiAgICAtIEV2ZXJ5IHRhc2sgY2l0ZXMgYXQgbGVhc3Qgb25lIFJFUSBJRCBpbiBzcXVhcmUgYnJhY2tldHMsIGUuZy4gIltSRVEtQUJDLTAwMV0iLgogICAgLSBFdmVyeSB0YXNrIHN0YXRlcyBpdHMgdmVyaWZpY2F0aW9uIGFzIGEgY29tbWFuZCBpbiBhIGNvZGUgc3BhbiBhZnRlciAiVmVyaWZ5OiIuCgpvcGVyYXRpb25zOgogIGFwcGx5OgogICAgZ3VpZGFuY2U6CiAgICAgIC0gU3RhcnQgZWFjaCB0YXNrIHdpdGggYHNwZWNjdHggdGFzayBzdGFydCA8aWQ+YCBhbmQgcmVhZCB0aGUgYnVuZGxlIGl0IHByaW50cyBiZWZvcmUgeW91IHJlYWQgc3BlY3MuCiAgICAgIC0gVGFnIGNvZGUgd2l0aCB0aGUgUkVRIElEIGl0IGltcGxlbWVudHMgKGEgY29tbWVudCBgLy8gUkVRLUFCQy0wMDFgKS4gVGFnIHRlc3RzIHdpdGggYC8vIENvdmVyczogUkVRLUFCQy0wMDFgLgogICAgICAtIENsb3NlIGVhY2ggdGFzayB3aXRoIGBzcGVjY3R4IHRhc2sgZG9uZSA8aWQ+YC4gTmV2ZXIgdGljayBhIGNoZWNrYm94IGJ5IGhhbmQuCiAgICAgIC0gUnVuIGBzcGVjY3R4IGNoZWNrIC0tc3RyaWN0YCBhZnRlciBlYWNoIHRhc2sgZ3JvdXAuCiAgYXJjaGl2ZToKICAgIGd1aWRhbmNlOgogICAgICAtIFJ1biBgc3BlY2N0eCBjaGVjayAtLXN0cmljdGAgYW5kIGBvcGVuc3BlYyB2YWxpZGF0ZSAtLWFsbCAtLXN0cmljdGAuIEJvdGggbXVzdCBwYXNzIGJlZm9yZSBhcmNoaXZlLgogICAgICAtIFJ1biBgb3BlbnNwZWMgdmFsaWRhdGUgLS1hbGwgLS1zdHJpY3RgIGFnYWluIGFmdGVyIGFyY2hpdmUgYW5kIGJlZm9yZSBwdXNoLgo=",
+    "schemas/spec-driven-ids/README.md": "IyBzcGVjLWRyaXZlbi1pZHMKCkEgZm9yayBvZiB0aGUgT3BlblNwZWMgYHNwZWMtZHJpdmVuYCBzY2hlbWEuIEl0IGFkZHMgc3RhYmxlIElEcyBmcm9tIHNwZWMtY3R4IHRvIGV2ZXJ5IGFydGlmYWN0LgoKLSBUaGUgc3BlYyB0ZW1wbGF0ZSBzdGFydHMgZWFjaCByZXF1aXJlbWVudCB3aXRoIGBSRVEtPENBUD4tTk5OYCBhbmQgZWFjaCBzY2VuYXJpbyB3aXRoIGBTQ04tPENBUD4tTk5OLTxuPmAuCi0gVGhlIGluc3RydWN0aW9ucyB0ZWxsIHRoZSBhZ2VudCB0byBnZXQgSURzIGZyb20gYHNwZWNjdHggaWQgbmV3YCBhbmQgdG8gbGluayBJRHMgd2l0aCBgUmVmczpgIGxpbmVzLgotIFRoZSB0YXNrcyB0ZW1wbGF0ZSBjaXRlcyBSRVEgSURzIGFuZCBwdXRzIHRoZSBgVmVyaWZ5OmAgY29tbWFuZCBpbiBhIGNvZGUgc3Bhbiwgc28gYHNwZWNjdHggdGFzayBkb25lYCBjYW4gcnVuIGl0LgotIGBjb25maWctZnJhZ21lbnQueWFtbGAgaG9sZHMgdGhlIGBydWxlc2AgYW5kIGBvcGVyYXRpb25zYCBmb3IgYG9wZW5zcGVjL2NvbmZpZy55YW1sYC4KCiMjIEluc3RhbGwgYnkgY29weQoKLSBDbG9uZSB0aGUgcmVwb3NpdG9yeTogYGdpdCBjbG9uZSBodHRwczovL2dpdGh1Yi5jb20vc29ucWgvc3BlYy1jdHhgLgotIENvcHkgYHNjaGVtYXMvc3BlYy1kcml2ZW4taWRzYCB0byBgb3BlbnNwZWMvc2NoZW1hcy9zcGVjLWRyaXZlbi1pZHNgIGluIHlvdXIgcHJvamVjdC4KLSBTZXQgYHNjaGVtYTogc3BlYy1kcml2ZW4taWRzYCBpbiBgb3BlbnNwZWMvY29uZmlnLnlhbWxgLgotIE1lcmdlIGBjb25maWctZnJhZ21lbnQueWFtbGAgaW50byBgb3BlbnNwZWMvY29uZmlnLnlhbWxgIGJ5IGhhbmQuIEFkZCBpdHMgYHJ1bGVzYCBhbmQgYG9wZXJhdGlvbnNgIGtleXMuIEtlZXAgZXZlcnkgaXRlbSBxdW90ZWQuCi0gUnVuIGBvcGVuc3BlYyBzY2hlbWEgdmFsaWRhdGUgc3BlYy1kcml2ZW4taWRzYC4KCiMjIEluc3RhbGwgd2l0aCBpbml0IC0tc2NoZW1hCgpgYGBiYXNoCm5weCAteSBzcGVjLWN0eCBpbml0IC0tc2NoZW1hCmBgYAoKLSBUaGUgY29tbWFuZCBjb3BpZXMgdGhpcyBmb2xkZXIgdG8gYG9wZW5zcGVjL3NjaGVtYXMvc3BlYy1kcml2ZW4taWRzL2AuCi0gSXQgc2V0cyBgc2NoZW1hOiBzcGVjLWRyaXZlbi1pZHNgIGluIGBvcGVuc3BlYy9jb25maWcueWFtbGAuCi0gSXQgYWRkcyB0aGUgYHJ1bGVzYCBhbmQgYG9wZXJhdGlvbnNgIGtleXMgdGhhdCB0aGUgY29uZmlnIGRvZXMgbm90IGhhdmUgeWV0LiBJdCBsZWF2ZXMgb3RoZXIga2V5cyBhcyB0aGV5IGFyZS4KLSBJdCBxdW90ZXMgYSBsaXN0IGl0ZW0gdGhhdCBZQU1MIHdvdWxkIHJlYWQgYXMgYSBtYXBwaW5nLgoKIyMgVmVyc2lvbgoKRm9ya2VkIGZyb20gT3BlblNwZWMgMS4xNC4zIHdpdGggYG9wZW5zcGVjIHNjaGVtYSBmb3JrIHNwZWMtZHJpdmVuIHNwZWMtZHJpdmVuLWlkc2AuIENJIHZhbGlkYXRlcyBpdCBhZ2FpbnN0IHRoYXQgdmVyc2lvbi4K",
+    "schemas/spec-driven-ids/config-fragment.yaml": "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",
     "schemas/spec-driven-ids/schema.yaml": "name: spec-driven-ids
version: 1
description: OpenSpec spec-driven workflow with stable IDs from spec-ctx - proposal → specs → design → tasks
artifacts:
  - id: proposal
    generates: proposal.md
    description: Initial proposal document outlining the change
    template: proposal.md
    instruction: |
      Create the proposal document that establishes WHY this change is needed.

      Sections:
      - **Why**: 1-2 sentences on the problem or opportunity. What problem does this solve? Why now?
      - **What Changes**: Bullet list of changes. Be specific about new capabilities, modifications, or removals. Mark breaking changes with **BREAKING**.
      - **Capabilities**: Identify which specs will be created or modified:
        - **New Capabilities**: List capabilities being introduced. Each becomes a new `specs/<capability-path>/spec.md`. Name each capability for a durable system behavior (for example, `user-auth`), not the work in this change (for example, `add-login-endpoint`). Choose a cohesive boundary that can own related requirements as the system evolves; avoid broad catch-all capabilities. Use kebab-case for path segments you introduce (e.g., `user-auth` or `identity/user-auth`) and follow the project's existing spec organization.
        - **Modified Capabilities**: List existing capabilities whose REQUIREMENTS are changing. Only include if spec-level behavior changes (not just implementation details). Each needs a delta spec file. Use the exact existing path under `openspec/specs/`. Leave empty if no requirement changes.
      - **Impact**: Affected code, APIs, dependencies, or systems.

      IMPORTANT: The Capabilities section is critical. It creates the contract between
      proposal and specs phases. Research existing specs before filling this in:
      run `openspec list --specs` for the project's capability inventory, then
      `openspec show "<spec-id>" --type spec --json --no-scenarios` for any that
      look related - that returns a capability's purpose and requirement texts
      without pulling whole spec files into context. Append `--store "<id>"` to
      both commands only for a registered standalone store, and keep `--type
      spec`: a change and a spec sharing a name is otherwise an ambiguous-item
      error. `openspec list` without `--specs` lists in-flight changes, not
      specs - it never shows what the project already covers. Reuse an existing
      capability's exact path instead of introducing a near-duplicate name.
      The filtered read is only an overview. Before deciding what is already
      covered or what should change, read each relevant spec in full, including
      scenarios, with `openspec show "<spec-id>" --type spec` (same `--store` rule).
      Each capability listed here will need a corresponding spec file.

      Every change must either declare at least one capability (new or
      modified) or explicitly opt out of specs: `openspec validate` rejects a
      change with zero deltas unless the change's `.openspec.yaml` sets
      `skip_specs: true`. Use `skip_specs: true` only when no spec-level
      behavior changes (pure refactor, tooling, docs) - specs describe
      behavior, so if behavior does not change, no spec should change either.
      Do not invent a requirement just to satisfy validation.

      Keep it concise (1-2 pages). Focus on the "why" not the "how" -
      implementation details belong in design.md.

      This is the foundation - specs, design, and tasks all build on this.
    requires: []

  - id: specs
    generates: "specs/**/*.md"
    description: Detailed specifications for the change
    template: spec.md
    instruction: |
      Create specification files that define WHAT the system should do.

      A spec is a behavior contract, not an implementation plan.

      Good spec content:
      - Observable behavior users or downstream systems rely on
      - Inputs, outputs, and error conditions
      - External constraints (security, privacy, reliability, compatibility)
      - Scenarios that can be tested or explicitly validated

      Avoid in specs:
      - Internal class/function names
      - Library or framework choices
      - Step-by-step implementation details
      - Detailed execution plans (those belong in design.md or tasks.md)

      Quick test: if the implementation can change without changing externally
      visible behavior, it likely does not belong in the spec.

      Create one spec file per capability listed in the proposal's Capabilities section.
      `<capability-path>` is the spec directory relative to `specs/` (for example,
      `user-auth` or `identity/user-auth`). Preserve the full path:
      - New capabilities: use the exact path from the proposal at `specs/<capability-path>/spec.md`. Any path segment newly introduced in the proposal must be kebab-case. Follow the project's existing organization; do not add a new domain level when the project uses a flat layout.
      - Modified capabilities: use the exact existing path from `openspec/specs/<capability-path>/` when creating the delta at `specs/<capability-path>/spec.md`. Run `openspec list --specs` to confirm that path before writing the delta, appending `--store "<id>"` only for a registered standalone store - a mistyped or invented path targets a capability that does not exist rather than the one you meant. Do not move or rename the capability.

      Write the spec files one at a time, so the user sees progress and an
      interrupted run keeps the files it already wrote:
      - Before writing anything, compare the capabilities the proposal lists
        with the `specs/<capability-path>/spec.md` files that already exist,
        and start with the first capability that has no file. Do not rewrite
        an existing file unless the user asks you to.
      - Before each file, say in one line which capability you are writing.
      - Write each file as soon as you have drafted it. Do not plan every file
        before writing the first.
      - Stop when every capability the proposal lists has its file.

      There must be at least one spec file unless the change's `.openspec.yaml`
      sets `skip_specs: true` (no spec-level behavior change) - `openspec validate`
      rejects a zero-delta change without that marker. If the proposal lists no
      capabilities and `skip_specs` is not set, revisit the proposal first.

      Delta operations (use ## headers):
      - **ADDED Requirements**: New capabilities
      - **MODIFIED Requirements**: Changed behavior - MUST include full updated content
      - **REMOVED Requirements**: Deprecated features - MUST include **Reason** and **Migration**
      - **RENAMED Requirements**: Name changes only - use FROM:/TO: format

      Format requirements:
      - Each requirement: `### Requirement: <name>` followed by description
      - Use SHALL/MUST for normative requirements (avoid should/may)
      - Each scenario: `#### Scenario: <name>` with WHEN/THEN format
      - **CRITICAL**: Scenarios MUST use exactly 4 hashtags (`####`). Using 3 hashtags or bullets will fail silently.
      - Every requirement MUST have at least one scenario.
      - Keep each requirement's description (the text between `### Requirement:` and its first scenario) to 500 characters or fewer. `openspec validate` flags longer descriptions in ADDED requirements and in the main spec. This is a warning: normal validation still passes, but `openspec validate --strict` fails on it. When writing a new requirement, state one behavior per requirement: move examples and edge cases into scenarios, and split a requirement that covers several behaviors into separate `### Requirement:` blocks, each with its own scenarios. Under MODIFIED, keep the existing requirement block whole; never split, trim or rewrite existing text just to meet the length. Split an existing long requirement only when the user asks for it, in a change made for that purpose: under MODIFIED, keep its header and every scenario and cut its description down to one behavior without changing its meaning, then add each behavior you removed as its own ADDED requirement with its own scenarios.

      New capabilities only: the delta spec's first section is `## Purpose` -
      one or two sentences (50+ characters, or `openspec validate --strict`
      reports it as too brief) describing what the capability is for. Archive
      copies it into the main spec it creates; without it the new main spec is
      left with a `TBD ... Update Purpose after archive` placeholder to fill in
      by hand. Do NOT add `## Purpose` to a delta for an existing capability -
      that spec already has one and the delta's is ignored. To change an
      existing capability's Purpose - including a leftover `TBD` placeholder -
      edit `<planningHome.root>/openspec/specs/<capability-path>/spec.md`
      directly. `planningHome.root` comes from the `openspec instructions ...
      --json` response. Always use it rather than a repo-relative path: it
      resolves to the store whenever the change lives in one - whether that
      came from `--store`, a project `store:` pointer, or a global default
      store - and to the current repository otherwise. Do not try to work out
      which case applies; the field already has.

      MODIFIED requirements workflow:
      1. Locate the existing requirement in `<planningHome.root>/openspec/specs/<capability-path>/spec.md` (the same store-aware root as above)
      2. Copy the ENTIRE requirement block (from `### Requirement:` through all scenarios)
      3. Paste under `## MODIFIED Requirements` and edit to reflect new behavior
      4. Ensure header text matches exactly (whitespace-insensitive)

      Common pitfall: Using MODIFIED with partial content loses detail at archive time.
      If adding new concerns without changing existing behavior, use ADDED instead.

      Example (a new capability, so its first section is `## Purpose`):
      ```
      # Spec Delta

      ## Purpose

      Lets users take their data out of the product in a portable format.

      ## ADDED Requirements

      ### Requirement: User can export data
      The system SHALL allow users to export their data in CSV format.

      #### Scenario: Successful export
      - **WHEN** user clicks "Export" button
      - **THEN** system downloads a CSV file with all user data

      ## REMOVED Requirements

      ### Requirement: Legacy export
      **Reason**: Replaced by new export system
      **Migration**: Use new export endpoint at /api/v2/export
      ```


      Stable IDs (spec-ctx):
      - Every requirement header starts with an ID: `### Requirement: REQ-<CAP>-NNN <name>`.
        Get a new ID from `specctx id new REQ <CAP>`. Never count numbers by hand.
        `<CAP>` is a capability code from `[ids] caps` in `spec-ctx.toml`.
      - Every scenario header starts with an ID: `#### Scenario: SCN-<CAP>-NNN-<n> <name>`.
        Get it from `specctx id new SCN <CAP> --for REQ-<CAP>-NNN`.
      - Under MODIFIED, REMOVED, or RENAMED, keep the existing ID. An ID never changes.
      - Link related IDs with one line `Refs: ID, ID` after the requirement text.
      - Replace every placeholder of the template. `specctx check` reports a header with
        no ID as `missing-id`.

      Specs should be testable - each scenario is a potential test case.
    requires:
      - proposal

  - id: design
    generates: design.md
    description: Technical design document with implementation details
    template: design.md
    instruction: |
      Create the design document that explains HOW to implement the change.

      When to include design.md (create only if any apply):
      - Cross-cutting change (multiple services/modules) or new architectural pattern
      - New external dependency or significant data model changes
      - Security, performance, or migration complexity
      - Ambiguity that benefits from technical decisions before coding

      Sections:
      - **Context**: Only the current state and constraints needed to explain the approach. Reference the proposal for motivation instead of restating it (e.g., "See proposal.md - Why").
      - **Goals / Non-Goals**: What this design achieves and explicitly excludes. Don't restate the proposal's scope - add only design-level boundaries.
      - **Decisions**: Key technical choices with rationale (why X over Y?). Include alternatives considered for each decision.
      - **Risks / Trade-offs**: Known limitations, things that could go wrong. Format: [Risk] → Mitigation
      - **Migration Plan**: Steps to deploy, rollback strategy (if applicable)
      - **Open Questions**: Unknowns that can safely be answered later without
        changing the specs, the approach, or the task breakdown. Omit if none.

      Open questions are for genuinely deferrable unknowns, not decisions you
      skipped. If a question would change the specs, the chosen approach, or
      the task breakdown, resolve it now - ask the user instead of guessing.

      Focus on architecture and approach, not line-by-line implementation.
      The proposal covers why and what; design covers how. Reference the
      proposal for motivation and, once written, the specs for requirements -
      if a section would only restate them, point to them instead.


      Stable IDs (spec-ctx):
      - Each bullet under `## Decisions` is one decision. Its ID is `<change number>/D<n>`
        by position, so add new decisions at the end and never reorder them.
      - End a decision with `Refs: ` and the REQ or ADR IDs it serves. Then `specctx bundle`
        prints the decision with those requirements.

      Good design docs explain the "why" behind technical decisions.
    requires:
      - proposal

  - id: tasks
    generates: tasks.md
    description: Implementation checklist with trackable tasks
    template: tasks.md
    instruction: |
      Create the task list that breaks down the implementation work.

      Before writing tasks, check design.md for Open Questions. If any of them
      would change what gets built, resolve them with the user first - do not
      bake an unstated assumption into the task list.

      **IMPORTANT: Follow the template below for tracked tasks.** The apply phase parses
      checkbox format to track progress. A box holding only `x` counts as done,
      upper or lower case and with any spacing, so `- [ x]` is done too. Every
      other marker, including `- [~]`, `- [-]` and an empty `- []`, reads as
      unfinished. A line with no checkbox is not tracked at all.

      Guidelines:
      - Group related tracked tasks under ## numbered headings
      - Each tracked task MUST be a checkbox: `- [ ] X.Y Task description`
      - Tasks should be small enough to complete in one session
      - Order tasks by dependency (what must be done first?)
      - Track implementation and verification work that can be completed before
        archive. If the requested workflow includes archive or work that requires
        this change to be archived, preserve those steps as plain bullets in an
        optional `## Workflow follow-up` section at the end of tasks.md. These
        bullets are reference information outside tracked task progress.
      - Each task MUST state how to verify completion (a test, command,
        observable behavior, or delivered artifact). Put the verification in
        that task's checkbox description. Use a separate verification task only
        when it checks broader integration or system behavior that spans
        multiple implementation tasks.
      - Each task group MUST land the tests and documentation its own work
        calls for. Do NOT collect testing or documentation into a final group -
        when a late group first exercises work from an early one, the failures
        cascade back through every group in between and force rework. A group
        whose work calls for neither, such as scaffolding or dependency setup,
        carries neither. A final group is for integration checks only, not for
        the tests and docs an earlier group owed.

      Example:
      ```
      # Tasks

      ## 1. Setup

      - [ ] 1.1 Create new module structure and verify expected files are present
      - [ ] 1.2 Add dependencies to package.json and verify package installation succeeds

      ## 2. Core Implementation

      - [ ] 2.1 Implement data export function and verify the export test passes
      - [ ] 2.2 Add CSV formatting utilities and verify unit tests cover quoting and delimiters
      - [ ] 2.3 Document the export API in docs/export.md and verify the documented command runs as written
      ```

      When applicable, append workflow follow-up as plain bullets, for example:
      ```
      ## Workflow follow-up

      - Archive the change after the project's review requirements are satisfied.
      - Verify the archived result.
      ```


      Stable IDs and Verify (spec-ctx):
      - Every task cites at least one requirement in square brackets: `[REQ-<CAP>-NNN]`.
      - Every task ends with `Verify:` and the command in a code span, for example
        ``Verify: `npm test -- tests/export.test.ts` ``. Two spans run joined with `&&`.
      - Use prose after `Verify:` only when no command can check the work. Then
        `specctx task done <id> --manual "<note>"` records it.
      - Close a task only with `specctx task done <id>`. It runs the command, writes
        evidence under `.ctx/evidence/`, and sets the checkbox.

      Reference specs for what needs to be built, design for how to build it.
    requires:
      - specs
      - design

apply:
  requires: [ tasks ]
  tracks: tasks.md
  instruction: |
    Read context files, work through pending tasks, mark complete as you go.
    Pause if you hit blockers or need clarification.
",
     "schemas/spec-driven-ids/templates/design.md": "IyBEZXNpZ24KCiMjIENvbnRleHQKCjwhLS0gVGhlIGN1cnJlbnQgc3RhdGUgYW5kIHRoZSBjb25zdHJhaW50cyB0aGF0IHNoYXBlIHRoZSBhcHByb2FjaC4gVGhlIHByb3Bvc2FsIGhvbGRzIHRoZSBtb3RpdmF0aW9uLiAtLT4KCiMjIEdvYWxzIC8gTm9uLUdvYWxzCgoqKkdvYWxzOioqCjwhLS0gV2hhdCB0aGlzIGRlc2lnbiBnaXZlcyAtLT4KCioqTm9uLUdvYWxzOioqCjwhLS0gV2hhdCBzdGF5cyBvdXQgb2Ygc2NvcGUgLS0+CgojIyBEZWNpc2lvbnMKCjwhLS0gT25lIGJ1bGxldCBwZXIgZGVjaXNpb24uIFRoZSBJRCBvZiBhIGRlY2lzaW9uIGlzIDxjaGFuZ2UgbnVtYmVyPi9EPG4+IGJ5IHBvc2l0aW9uLiBBZGQgbmV3IG9uZXMgYXQgdGhlIGVuZC4gLS0+Ci0gPCEtLSBUaGUgZGVjaXNpb24sIHRoZSBhbHRlcm5hdGl2ZSwgYW5kIHdoeS4gLS0+IFJlZnM6IDwhLS0gUkVRLTxDQVA+LU5OTiwgQURSLU5OTiAtLT4KCiMjIFJpc2tzIC8gVHJhZGUtb2ZmcwoKPCEtLSBLbm93biByaXNrcyBhbmQgdGhlIG1pdGlnYXRpb24gZm9yIGVhY2ggLS0+Cg==",
     "schemas/spec-driven-ids/templates/proposal.md": "IyBQcm9wb3NhbAoKIyMgV2h5Cgo8IS0tIEV4cGxhaW4gdGhlIG1vdGl2YXRpb24gZm9yIHRoaXMgY2hhbmdlLiBXaGF0IHByb2JsZW0gZG9lcyB0aGlzIHNvbHZlPyBXaHkgbm93PyAtLT4KCiMjIFdoYXQgQ2hhbmdlcwoKPCEtLSBEZXNjcmliZSB3aGF0IHdpbGwgY2hhbmdlLiBCZSBzcGVjaWZpYyBhYm91dCBuZXcgY2FwYWJpbGl0aWVzLCBtb2RpZmljYXRpb25zLCBvciByZW1vdmFscy4gLS0+CgojIyBDYXBhYmlsaXRpZXMKCiMjIyBOZXcgQ2FwYWJpbGl0aWVzCjwhLS0gQ2FwYWJpbGl0aWVzIGJlaW5nIGludHJvZHVjZWQuIE5hbWUgZWFjaCBjYXBhYmlsaXR5IGZvciBhIGNvaGVzaXZlIHN5c3RlbQogICAgIGJlaGF2aW9yIHRoYXQgY2FuIG93biByZWxhdGVkIHJlcXVpcmVtZW50cyBhcyB0aGUgc3lzdGVtIGV2b2x2ZXMuIERvIG5vdCBuYW1lCiAgICAgaW1wbGVtZW50YXRpb24gdGFza3Mgb3IgcHJvcG9zYWwgc2VjdGlvbnMuIEF2b2lkIGJyb2FkIGNhdGNoLWFsbCBuYW1lcy4gVXNlCiAgICAga2ViYWItY2FzZSBmb3IgcGF0aCBzZWdtZW50cyB5b3UgaW50cm9kdWNlIChlLmcuLCB1c2VyLWF1dGggb3IgaWRlbnRpdHkvdXNlci1hdXRoKQogICAgIHRoYXQgZm9sbG93IHRoZSBwcm9qZWN0J3MgZXhpc3Rpbmcgc3BlYyBvcmdhbml6YXRpb24uIEVhY2ggY3JlYXRlcwogICAgIHNwZWNzLzxjYXBhYmlsaXR5LXBhdGg+L3NwZWMubWQuIC0tPgotIGA8Y2FwYWJpbGl0eS1wYXRoPmA6IDxicmllZiBkZXNjcmlwdGlvbiBvZiB3aGF0IHRoaXMgY2FwYWJpbGl0eSBjb3ZlcnM+CgojIyMgTW9kaWZpZWQgQ2FwYWJpbGl0aWVzCjwhLS0gRXhpc3RpbmcgY2FwYWJpbGl0aWVzIHdob3NlIFJFUVVJUkVNRU5UUyBhcmUgY2hhbmdpbmcgKG5vdCBqdXN0IGltcGxlbWVudGF0aW9uKS4KICAgICBPbmx5IGxpc3QgaGVyZSBpZiBzcGVjLWxldmVsIGJlaGF2aW9yIGNoYW5nZXMuIEVhY2ggbmVlZHMgYSBkZWx0YSBzcGVjIGZpbGUuCiAgICAgVXNlIHRoZSBleGFjdCBleGlzdGluZyBwYXRoIHVuZGVyIG9wZW5zcGVjL3NwZWNzLy4gTGVhdmUgZW1wdHkgaWYgbm8gcmVxdWlyZW1lbnQKICAgICBjaGFuZ2VzLiBBIGNoYW5nZSB3aXRoIG5vIGNhcGFiaWxpdGllcyBhdCBhbGwgKHB1cmUgcmVmYWN0b3IsIHRvb2xpbmcsIGRvY3MpCiAgICAgbXVzdCBzZXQgYHNraXBfc3BlY3M6IHRydWVgIGluIGl0cyAub3BlbnNwZWMueWFtbCAtIG9wZW5zcGVjIHZhbGlkYXRlIHJlamVjdHMKICAgICBhIHplcm8tZGVsdGEgY2hhbmdlIHdpdGhvdXQgdGhhdCBtYXJrZXIuIERvIG5vdCBpbnZlbnQgYSByZXF1aXJlbWVudCBqdXN0IHRvCiAgICAgc2F0aXNmeSB2YWxpZGF0aW9uLiAtLT4KLSBgPGV4aXN0aW5nLWNhcGFiaWxpdHktcGF0aD5gOiA8d2hhdCByZXF1aXJlbWVudCBpcyBjaGFuZ2luZz4KCiMjIEltcGFjdAoKPCEtLSBBZmZlY3RlZCBjb2RlLCBBUElzLCBkZXBlbmRlbmNpZXMsIHN5c3RlbXMgLS0+Cg==",
     "schemas/spec-driven-ids/templates/spec.md": "IyBTcGVjIERlbHRhCgojIyBQdXJwb3NlCjwhLS0gTmV3IGNhcGFiaWxpdHkgb25seS4gV3JpdGUgb25lIG9yIHR3byBzZW50ZW5jZXMgb2YgNTAgY2hhcmFjdGVycyBvciBtb3JlLiBEZWxldGUgdGhpcyBzZWN0aW9uIGZvciBhbiBleGlzdGluZyBjYXBhYmlsaXR5LiAtLT4KCiMjIEFEREVEIFJlcXVpcmVtZW50cwoKIyMjIFJlcXVpcmVtZW50OiBSRVEtPENBUD4tTk5OIDwhLS0gcmVxdWlyZW1lbnQgbmFtZSAtLT4KPCEtLSBSZXF1aXJlbWVudCB0ZXh0LiBSZXBsYWNlIFJFUS08Q0FQPi1OTk4gd2l0aCB0aGUgb3V0cHV0IG9mIGBzcGVjY3R4IGlkIG5ldyBSRVEgPENBUD5gLiAtLT4KClJlZnM6IDwhLS0gcmVsYXRlZCBJRHMgc3VjaCBhcyBBRFItMDAxLiBEZWxldGUgdGhpcyBsaW5lIHdoZW4gdGhlcmUgYXJlIG5vbmUuIC0tPgoKIyMjIyBTY2VuYXJpbzogU0NOLTxDQVA+LU5OTi0xIDwhLS0gc2NlbmFyaW8gbmFtZS4gR2V0IHRoZSBJRCBmcm9tIGBzcGVjY3R4IGlkIG5ldyBTQ04gPENBUD4gLS1mb3IgUkVRLTxDQVA+LU5OTmAuIC0tPgotICoqV0hFTioqIDwhLS0gY29uZGl0aW9uIC0tPgotICoqVEhFTioqIDwhLS0gZXhwZWN0ZWQgb3V0Y29tZSAtLT4K",
     "schemas/spec-driven-ids/templates/tasks.md": "IyBUYXNrcwoKIyMgMS4gPCEtLSBUYXNrIGdyb3VwIG5hbWUgLS0+CgotIFsgXSAxLjEgPCEtLSBUYXNrIGRlc2NyaXB0aW9uIC0tPiBbUkVRLTxDQVA+LU5OTl0gVmVyaWZ5OiBgPCEtLSBjb21tYW5kIC0tPmAKLSBbIF0gMS4yIDwhLS0gVGFzayBkZXNjcmlwdGlvbiAtLT4gW1JFUS08Q0FQPi1OTk5dIFZlcmlmeTogYDwhLS0gY29tbWFuZCAtLT5gCgojIyAyLiA8IS0tIFRhc2sgZ3JvdXAgbmFtZSAtLT4KCi0gWyBdIDIuMSA8IS0tIFRhc2sgZGVzY3JpcHRpb24gLS0+IFtSRVEtPENBUD4tTk5OXSBWZXJpZnk6IGA8IS0tIGNvbW1hbmQgLS0+YAo=",
     "skills/specctx-bootstrap/SKILL.md": "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",
-    "skills/specctx-done/SKILL.md": "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",
+    "skills/specctx-done/SKILL.md": "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",
     "skills/specctx-next/SKILL.md": "LS0tCm5hbWU6IHNwZWNjdHgtbmV4dApkZXNjcmlwdGlvbjogUGljayBhbmQgc3RhcnQgdGhlIG5leHQgdGFzayBpbiB0aGUgbWlkZGxlIG9mIGEgc2Vzc2lvbiBpbiBhbiBPcGVuU3BlYyBwcm9qZWN0IHRoYXQgdXNlcyBzcGVjLWN0eC4gVXNlIGFmdGVyIHlvdSBjbG9zZSBhIHRhc2ssIG9yIG9uICJuZXh0IHRhc2siIGFuZCAid2hhdCBpcyBuZXh0Ii4KLS0tCgojIHNwZWNjdHgtbmV4dAoKTW92ZSB0byB0aGUgbmV4dCBvcGVuIHRhc2suIFJ1biBgc3BlY2N0eGAgYXMgYG5weCBzcGVjLWN0eGAgd2hlbiBpdCBpcyBub3QgaW5zdGFsbGVkLgoKIyMgU3RlcHMKCjEuIFJ1biBgc3BlY2N0eCB0YXNrIG5leHRgLiBJdCBwcmludHMgdGhlIHRhc2sgSUQgYW5kIHRleHQsIHRoZW4gYHJlcXM6YCBhbmQgYHZlcmlmeTpgLgoyLiBJZiBpdCBwcmludHMgYG5vIG9wZW4gdGFzay4gRXZlcnkgdGFzayBpbiB0aGUgYWN0aXZlIGNoYW5nZXMgaXMgZG9uZS4gTmV4dDogYXJjaGl2ZSA8Y2hhbmdlPi5gLCBldmVyeSB0YXNrIG9mIHRoZSBhY3RpdmUgY2hhbmdlcyBoYXMgaXRzIGNoZWNrYm94IHNldC4gUnVuIGBzcGVjY3R4IHN0YXR1c2AuIEl0cyBsYXN0IGxpbmUgaXMgYG5leHQ6IGFyY2hpdmUgPGNoYW5nZT5gLiBUZWxsIHRoZSB1c2VyIHRoYXQgdGhlIGNoYW5nZSBpcyByZWFkeSBmb3IgYHNwZWNjdHggY2hlY2sgLS1zdHJpY3RgIGFuZCBhcmNoaXZlLiBTdG9wIGhlcmUuCjMuIFJ1biBgc3BlY2N0eCB0YXNrIHN0YXJ0IDx0YXNrPmAuIEl0IHByaW50cyB0aGUgYnVuZGxlIGZvciB0aGUgUkVRIElEcyBvZiB0aGUgdGFzayBhbmQgc2V0cyB0aGUgY3VycmVudCB0YXNrIGluIGAuY3R4L2N1cnJlbnQuanNvbmAuCjQuIFJlYWQgdGhlIGJ1bmRsZS4gUmVxdWVzdCBhbiBvbWl0dGVkIElEIHdpdGggYHNwZWNjdHggYnVuZGxlIDxpZD5gIG9ubHkgd2hlbiB0aGUgdGFzayBuZWVkcyBpdC4KNS4gUnVuIGBzcGVjY3R4IHRhc2sgdmVyaWZ5IDx0YXNrPmAgb25jZSBiZWZvcmUgdGhlIHdvcmsuIEl0IHJ1bnMgdGhlIGBWZXJpZnk6YCBjb21tYW5kIGFuZCB3cml0ZXMgbm90aGluZy4gQSBmYWlsdXJlIG5vdyBzaG93cyB3aGF0IHRoZSB3b3JrIG11c3QgZml4Lgo2LiBTYXkgaW4gb25lIGxpbmUgd2hpY2ggdGFzayB5b3UgYXJlIG9uLiBUaGVuIHN0YXJ0IHRoZSB3b3JrLgoKIyMgUnVsZXMKCi0gVGFrZSB0aGUgdGFza3MgaW4gdGhlIG9yZGVyIHRoYXQgYHNwZWNjdHggdGFzayBuZXh0YCBnaXZlcy4gRWFybGllciB0YXNrcyBpbiBhIGdyb3VwIGNvbWUgZmlyc3QuCi0gQSBxdWVzdGlvbiB0aGF0IGJsb2NrcyB5b3UgZ29lcyB0byBgc3BlY2N0eCBoYW5kb2ZmIGFzayAiPHF1ZXN0aW9uPiJgLiBUaGVuIGNvbnRpbnVlIHdpdGggd2hhdCB5b3UgY2FuIGRvLgotIENsb3NlIHRoZSB0YXNrIHdpdGggdGhlIGBzcGVjY3R4LWRvbmVgIHNraWxsLgo=",
 };

package/dist/cli/color.js

@@ -0,0 +1,23 @@
+// REQ-CLI-008 color on a TTY. Without color the bytes equal the plain output.
+const CODES = { ok: "\x1b[32m", fail: "\x1b[31m", dim: "\x1b[2m" };
+const RESET = "\x1b[0m";
+/**
+ * Color is on when `FORCE_COLOR` is set, or when stdout is a TTY and `TERM` is not `dumb`.
+ * `NO_COLOR` wins over both. An empty value counts as unset. `FORCE_COLOR=0` counts as unset.
+ */
+export function colorOn(tty, env = process.env) {
+    if (env.NO_COLOR)
+        return false;
+    const force = env.FORCE_COLOR;
+    if (force && force !== "0" && force !== "false")
+        return true;
+    return tty && env.TERM !== "dumb";
+}
+/** Wrap one line of text in the code of its kind. A trailing newline stays outside the codes. */
+export function paint(kind, text, tty) {
+    if (!colorOn(tty === true))
+        return text;
+    const nl = text.endsWith("\n") ? "\n" : "";
+    const body = nl ? text.slice(0, -1) : text;
+    return `${CODES[kind]}${body}${RESET}${nl}`;
+}

package/dist/cli/commands.js

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { UsageExit } from "./errors.js";
 import { findRoot, requireOpenSpec } from "./root.js";
 import { hintOf } from "../check/hints.js";
+import { paint } from "./color.js";
 /** check with warnings and the baseline filter. Strict mode adds the strict rules and the warnings. */
 async function runCheck(root, cfg, data, strict) {
     const { check } = await import("../check/check.js");
@@ -20,13 +21,14 @@ async function runCheck(root, cfg, data, strict) {
  * REQ-CHK-004 the findings, then a blank line, the summary line, and one line per rule with its hint.
  * A warning counts as advisory. The `baselined` line stays last (REQ-CHK-002).
  */
-export function checkText(r) {
-    const body = r.findings.map((x) => `${x.file}:${x.line}  ${x.rule}  ${x.id}\n`).join("")
+export function checkText(r, tty) {
+    // REQ-CLI-008 every finding of check is hard, so every finding line is red. stale-evidence is one of them.
+    const body = r.findings.map((x) => paint("fail", `${x.file}:${x.line}  ${x.rule}  ${x.id}\n`, tty)).join("")
         + r.warnings.map((w) => `warning: ${w}\n`).join("");
     const base = r.baselined ? `baselined: ${r.baselined}\n` : "";
     const n = r.findings.length + r.warnings.length;
     if (!n)
-        return `0 findings\n${base}`;
+        return paint("dim", "0 findings\n", tty) + base;
     const files = new Set(r.findings.map((x) => x.file));
     const count = new Map();
     for (const x of r.findings)
@@ -40,7 +42,7 @@ export function checkText(r) {
     }
     const rules = [...count.keys()].sort();
     return body
-        + `\n${n} finding${n === 1 ? "" : "s"} in ${files.size} file${files.size === 1 ? "" : "s"} (${r.findings.length} hard, ${r.warnings.length} advisory)\n`
+        + "\n" + paint("dim", `${n} finding${n === 1 ? "" : "s"} in ${files.size} file${files.size === 1 ? "" : "s"} (${r.findings.length} hard, ${r.warnings.length} advisory)\n`, tty)
         + rules.map((rule) => `${rule}  ${count.get(rule)}  ${hintOf(rule)}\n`).join("")
         + base;
 }
@@ -134,7 +136,7 @@ export async function run(p, io) {
                 void check;
                 const data = buildIndex(root, cfg);
                 const r = await runCheck(root, cfg, data, strict);
-                return { code: r.findings.length ? 1 : 0, out: checkText(r) };
+                return { code: r.findings.length ? 1 : 0, out: checkText(r, io.tty) };
             },
         }, io);
     }
@@ -169,8 +171,9 @@ export async function run(p, io) {
             const r = statusReport(root, entries);
             if (json)
                 print(r);
+            // REQ-CLI-008 the next: line is dim
             else
-                io.out(statusLines(r).map((l) => l + "\n").join(""));
+                io.out(statusLines(r).map((l) => (l.startsWith("next: ") ? paint("dim", l, io.tty) : l) + "\n").join(""));
             return 0;
         }
         case "query": {
@@ -248,7 +251,7 @@ export async function run(p, io) {
             if (json)
                 print({ baselined: r.baselined, count: r.findings.length, findings: r.findings, warnings: r.warnings });
             else
-                io.out(checkText(r));
+                io.out(checkText(r, io.tty));
             return r.findings.length ? 1 : 0;
         }
     }
@@ -264,12 +267,12 @@ async function init(p, io) {
     if (p.flags.json)
         io.out(JSON.stringify(r, null, 2) + "\n");
     else if (r.nothing)
-        io.out("nothing to do\nnext: specctx status\n");
+        io.out("nothing to do\n" + paint("dim", "next: specctx status\n", io.tty));
     else {
         io.out(r.written.map((w) => `wrote ${w}\n`).join(""));
         io.out(r.kept.map((k) => `kept ${k}\n`).join(""));
         // REQ-CLI-007 init ends with the next step
-        io.out("next: specctx status\n");
+        io.out(paint("dim", "next: specctx status\n", io.tty));
     }
     return 0;
 }

package/dist/cli/workflow.js

@@ -2,6 +2,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { dumps } from "../util/json.js";
+import { paint } from "./color.js";
 import { UsageExit } from "./errors.js";
 const arg = (c, n, what) => {
     const v = c.p.positional[n];
@@ -94,7 +95,7 @@ export async function runWorkflow(c) {
             if (c.json)
                 print(c, { bundle: b, task: t.id });
             else
-                c.io.out(b.text);
+                c.io.out(b.text + footer(cpLen(b.text), (await import("../stats/stats.js")).specCharsOf(entries)));
             return 0;
         }
         case "task verify":
@@ -118,7 +119,7 @@ export async function runWorkflow(c) {
                 if (c.json)
                     print(c, { evidence: rel, kind: "manual", task: t.id });
                 else
-                    c.io.out(`done ${t.id} (manual). Evidence: ${rel}\n`);
+                    c.io.out(paint("ok", `done ${t.id} (manual). Evidence: ${rel}\n`, c.io.tty));
                 return 0;
             }
             if (!dry && t.done)
@@ -154,7 +155,12 @@ export async function runWorkflow(c) {
                     print(c, { command: t.verify.command, error: msg, exit: r.exit, tail: outTail, task: t.id });
                 else
                     c.io.out(outTail ? outTail + "\n" : "");
-                c.io.err(`specctx: ${msg}. Task ${t.id} stays open.\n`);
+                // REQ-VER-003 a timeout keeps its own line on stderr
+                if (r.timedOut)
+                    c.io.err(`specctx: ${msg}. Task ${t.id} stays open.\n`);
+                // REQ-TASK-003 the refusal is the last line of the output. REQ-CLI-008 it is red on a TTY.
+                else if (!c.json)
+                    c.io.out(paint("fail", `Verify failed (exit ${r.exit}). The task stays open.\n`, c.io.tty));
                 return 1;
             }
             const { sha256 } = await import("../util/hash.js");
@@ -170,7 +176,7 @@ export async function runWorkflow(c) {
             if (c.json)
                 print(c, { evidence: rel, kind: "command", task: t.id });
             else
-                c.io.out(`done ${t.id}. Evidence: ${rel}\n`);
+                c.io.out(paint("ok", `done ${t.id}. Evidence: ${rel}\n`, c.io.tty)); // REQ-CLI-008
             return 0;
         }
         case "task backfill": {
@@ -272,3 +278,8 @@ function clearCurrent(root, task) {
         // a damaged current.json stays for the user to read
     }
 }
+// REQ-TASK-002 the footer of task start: the bundle size and its share of the spec text. bundle never prints it.
+export function footer(n, m) {
+    const p = m > 0 ? Math.round((n / m) * 1000) / 10 : 0;
+    return `-- bundle ${n} chars, ${p}% of ${m} chars of spec text\n`;
+}

package/dist/cli.js

@@ -9,5 +9,6 @@ const code = await main(process.argv.slice(2), {
     cwd: process.cwd(),
     out: (s) => process.stdout.write(s),
     err: (s) => process.stderr.write(s),
+    tty: process.stdout.isTTY === true,
 });
 process.exitCode = code;

package/dist/init/init.js

@@ -64,6 +64,29 @@ function topBlocks(text) {
     flush();
     return blocks;
 }
+/**
+ * REQ-SCH-003 quote list items under `rules` and `operations` that hold `: ` and are not quoted.
+ * YAML reads such an item as a one key mapping. Every other line stays byte for byte.
+ */
+export function repairItems(text) {
+    let inBlock = false;
+    let fixed = 0;
+    const out = text.split("\n").map((line) => {
+        const top = TOP_KEY.exec(line);
+        if (top) {
+            inBlock = top[1] === "rules" || top[1] === "operations";
+            return line;
+        }
+        if (!inBlock)
+            return line;
+        const m = /^(\s+- )(.*?)(\s*)$/.exec(line);
+        if (!m || /^['"]/.test(m[2]) || !/:(\s|$)/.test(m[2]))
+            return line;
+        fixed++;
+        return `${m[1]}'${m[2].replace(/'/g, "''")}'${m[3]}`;
+    });
+    return { text: out.join("\n"), fixed };
+}
 /**
  * REQ-SCH-003 add each top-level key of the fragment that the project config lacks.
  * Keys that exist stay as they are. The schema key names the installed bundle.
@@ -92,6 +115,11 @@ export function mergeConfig(current, fragment) {
         text = text.replace(/\n*$/, "\n\n") + block;
         added.push(key);
     }
+    const r = repairItems(text);
+    if (r.fixed) {
+        text = r.text;
+        added.push("repaired items");
+    }
     return { text, added, kept };
 }
 export function runInit(root, o) {

package/dist/stats/stats.js

@@ -92,10 +92,14 @@ export function gateMetrics(root, last = 100) {
         gate_failures_caught: { value: failed, n: runs.length, text: String(failed) },
     };
 }
-export function computeStats(root, entries, strictFindings, warnings, only) {
-    const specChars = entries
+// REQ-STAT-002 REQ-TASK-002 the size of all canonical req, scn, and decision text. stats and the task start footer share it.
+export function specCharsOf(entries) {
+    return entries
         .filter((e) => e.canonical && (e.kind === "req" || e.kind === "scn" || e.kind === "decision"))
         .reduce((a, e) => a + cpLen(e.text ?? ""), 0);
+}
+export function computeStats(root, entries, strictFindings, warnings, only) {
+    const specChars = specCharsOf(entries);
     const { live, reopened } = readEvidence(root);
     // REQ-IDX-005 the change name of each change key, from the task entries
     const names = new Map();

package/dist/version.js

@@ -1,2 +1,2 @@
 // REQ-CLI-001 version string. tests/cli/version.test.ts keeps it equal to package.json.
-export const VERSION = "0.1.0";
+export const VERSION = "0.1.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spec-ctx",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Deterministic context engine and task workflow for OpenSpec projects.",
   "type": "module",
   "license": "MIT",

package/schemas/spec-driven-ids/README.md

@@ -5,14 +5,27 @@ A fork of the OpenSpec `spec-driven` schema. It adds stable IDs from spec-ctx to
 - The spec template starts each requirement with `REQ-<CAP>-NNN` and each scenario with `SCN-<CAP>-NNN-<n>`.
 - The instructions tell the agent to get IDs from `specctx id new` and to link IDs with `Refs:` lines.
 - The tasks template cites REQ IDs and puts the `Verify:` command in a code span, so `specctx task done` can run it.
-- `config-fragment.yaml` holds the `rules` and `operations` that `specctx init --schema` adds to `openspec/config.yaml`.
+- `config-fragment.yaml` holds the `rules` and `operations` for `openspec/config.yaml`.
 
-Forked from OpenSpec 1.14.3 with `openspec schema fork spec-driven spec-driven-ids`. CI validates it against that version.
+## Install by copy
+
+- Clone the repository: `git clone https://github.com/sonqh/spec-ctx`.
+- Copy `schemas/spec-driven-ids` to `openspec/schemas/spec-driven-ids` in your project.
+- Set `schema: spec-driven-ids` in `openspec/config.yaml`.
+- Merge `config-fragment.yaml` into `openspec/config.yaml` by hand. Add its `rules` and `operations` keys. Keep every item quoted.
+- Run `openspec schema validate spec-driven-ids`.
 
-## Install
+## Install with init --schema
 
 ```bash
-npx spec-ctx init --schema
+npx -y spec-ctx init --schema
 ```
 
-The command copies this folder to `openspec/schemas/spec-driven-ids/` and sets `schema: spec-driven-ids` in `openspec/config.yaml`.
+- The command copies this folder to `openspec/schemas/spec-driven-ids/`.
+- It sets `schema: spec-driven-ids` in `openspec/config.yaml`.
+- It adds the `rules` and `operations` keys that the config does not have yet. It leaves other keys as they are.
+- It quotes a list item that YAML would read as a mapping.
+
+## Version
+
+Forked from OpenSpec 1.14.3 with `openspec schema fork spec-driven spec-driven-ids`. CI validates it against that version.

package/schemas/spec-driven-ids/config-fragment.yaml

@@ -2,24 +2,24 @@
 # that the project config does not have yet. It never changes a key that exists.
 rules:
   specs:
-    - Every requirement header starts with its ID, e.g. "### Requirement: REQ-ABC-001 Name". Get the ID from `specctx id new REQ ABC`.
-    - Every scenario header starts with its ID, e.g. "#### Scenario: SCN-ABC-001-1 Name".
-    - A requirement may end with a line "Refs: REQ-ABC-002, ADR-001" to link related IDs.
-    - Requirement text stays under 500 characters. Move detail into scenarios.
+    - 'Every requirement header starts with its ID, e.g. "### Requirement: REQ-ABC-001 Name". Get the ID from `specctx id new REQ ABC`.'
+    - 'Every scenario header starts with its ID, e.g. "#### Scenario: SCN-ABC-001-1 Name".'
+    - 'A requirement may end with a line "Refs: REQ-ABC-002, ADR-001" to link related IDs.'
+    - 'Requirement text stays under 500 characters. Move detail into scenarios.'
   design:
-    - Each decision is one bullet under "## Decisions". Add new decisions at the end.
+    - 'Each decision is one bullet under "## Decisions". Add new decisions at the end.'
   tasks:
-    - Every task cites at least one REQ ID in square brackets, e.g. "[REQ-ABC-001]".
-    - Every task states its verification as a command in a code span after "Verify:".
+    - 'Every task cites at least one REQ ID in square brackets, e.g. "[REQ-ABC-001]".'
+    - 'Every task states its verification as a command in a code span after "Verify:".'
 
 operations:
   apply:
     guidance:
-      - Start each task with `specctx task start <id>` and read the bundle it prints before you read specs.
-      - Tag code with the REQ ID it implements (a comment `// REQ-ABC-001`). Tag tests with `// Covers: REQ-ABC-001`.
-      - Close each task with `specctx task done <id>`. Never tick a checkbox by hand.
-      - Run `specctx check --strict` after each task group.
+      - 'Start each task with `specctx task start <id>` and read the bundle it prints before you read specs.'
+      - 'Tag code with the REQ ID it implements (a comment `// REQ-ABC-001`). Tag tests with `// Covers: REQ-ABC-001`.'
+      - 'Close each task with `specctx task done <id>`. Never tick a checkbox by hand.'
+      - 'Run `specctx check --strict` after each task group.'
   archive:
     guidance:
-      - Run `specctx check --strict` and `openspec validate --all --strict`. Both must pass before archive.
-      - Run `openspec validate --all --strict` again after archive and before push.
+      - 'Run `specctx check --strict` and `openspec validate --all --strict`. Both must pass before archive.'
+      - 'Run `openspec validate --all --strict` again after archive and before push.'

package/skills/specctx-done/SKILL.md

@@ -11,7 +11,7 @@ Close the current task with evidence. Run `specctx` as `npx spec-ctx` when it is
 
 1. Run `specctx task done <task>`. It runs the `Verify:` command of the task in the project root.
 2. On exit 0 it writes `.ctx/evidence/<change>/<task>.json` and sets `[x]` on the task line. Nothing else in `tasks.md` changes.
-3. On a failure it prints the last 20 lines of output and exits 1. The task stays open. Fix the cause and run step 1 again.
+3. On a failure it prints the last 20 lines of output and then the line `Verify failed (exit <n>). The task stays open.` It exits 1. Fix the cause and run step 1 again.
 4. If the task has prose after `Verify:` and no command, run `specctx task done <task> --manual "<what you checked>"`.
 5. After the last task of a group, run `specctx check --strict`. Fix every finding before the next group.
 6. Run `specctx handoff write`. It writes `.ctx/handoff.md` from the index, the evidence, and the open questions.