pi-gauntlet 7.20.1 → 7.22.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v7.22.0 - 2026-10-20
+
+### Added
+
+- **Plans carry base-commit test evidence.** The `plan-writer` persona gains `bash`, runs every task's `Tests:` command on the base commit, and records a `- baseline: <sha> pass | pass via <base command> | skipped - <paths> created by this task` bullet; `plan_check` gains the `baseline-line` and `open-questions` findings and refuses to stamp without that evidence or while `## Open Questions` holds a substantive row. A failing base reaches the human once, with the command and output, through the fix-first / narrow / amend menu. A boundary the spec leaves open is settled from the caller or harness contract as a `Decision:` line in the task. `/skill:gauntlet-resume` re-baselines pre-release plans without replacing task statuses. (#72)
+- **Brainstorming traces implicit dependencies.** The scout reports every unnamed file, binary, extension, or fixture the design relies on; a missing one lands in the premise note and the spec as a corrected fact instead of a stop. (#72)
+- **Lookup before asking in the implement loop.** A worker's `NEEDS_CONTEXT`/`BLOCKED` question is classified as a fact ask or a decision; fact asks are looked up in the documented spec, plan, and repo locations before any stop, and the stop note carries `Searched: <where> - <result>` lines. (#72)
+
+### Changed
+
+- **Eval runner accepts unplanned improvements.** An unlisted `fails -> holds` fact is labeled `unplanned improvement` and counts as `improved`; only same-fact regressions are confirmed; cached cells are reclassified locally with zero model calls and the report regenerates even on a zero-call run. (#72)
+
+## v7.21.0 - 2026-10-19
+
+### Changed
+
+- **Removed sequential mode; every plan task runs through the wave loop.** Singleton waves use the same implementer/spec-review chain, integration, review, and accepted-wave commit as larger waves. Re-review fixes use a single tree-to-tree fix delta captured through a scratch index, so committed, staged, and unstaged repairs produce the same repair-only patch. Each accepted wave folds repair commits into one wave commit before tracker completion. (#71)
+
 ## v7.20.1 - 2026-10-19
 
 ### Changed

package/README.md

@@ -79,7 +79,7 @@ pi-gauntlet ships three kinds of pieces, layered on top of pi-cohort's dispatch:
 
 - **20 skills** - the workflow logic. Fifteen activate automatically when pi sees the matching kind of task, and the workflow skills chain through their gates: `shape-ticket` (creates or repairs one tracker issue per run against a Context/Problem/Idea/Acceptance-Criteria template, gated by an AC integrity check, a cheap council roast, and a single human-confirmed write; model-invocable so other skills and commands can route "file a ticket" to it, the gate still needs your yes), `gatekeep-pr` (model-invocable on an explicit ask that names the PR and the verb; the gates still need your selection - is consent-gated pre-merge verification of a PR against the scope contract at its head - the approved spec's acceptance-criteria dispositions and Design when the PR carries one, else the PR's stated intent; the ticket is cross-checked, never judged here (`check-delivery` owns it) - read-only gathering, verification evidence resolved CI-first (green checks on the exact assessed head count as evidence; a pending commit status that GitHub does not report as blocking the gating actor (`mergeStateStatus` not `BLOCKED`) is not waited for - external-CI commit statuses included - while a running Actions check, an unknown merge state, and every other merge precondition still withhold; the project's verification command runs only as fallback), a rubric-based review, a compact bottom-up report (what the PR delivers, including rows deferred or deviating per spec, PR comments, nits, blockers, then a `mergeable` / `fixable` verdict) and a verb menu whose rows derive from the actor's permissions on the PR; nothing mutates (fixes, pushes, reviews, merges, tracker comments) until you pick a row, except the opt-in `--rebase [base]` sync that rebases, reviews, and lease-pushes the head before verification, or holds the rebased head locally when a conflict stop's scoped tests fail, so the normal `fix` row resolves it before the lease push; after your own merge two opt-in rows post the `AC coverage` block to the ticket or the PR; every terminal menu offers a recommended `cleanup` row that tears down the gate's worktree and branch and runs the overrides file's `## cleanup` steps - run it with `/skill:gatekeep-pr <pr> [--rebase [base]]`), `check-delivery` (model-invocable on an explicit ask that names the ticket and the verb; the gates still need your selection - is a post-merge detective control: proves an issue actually shipped (default-branch landing, delivery target, per-AC evidence) before its tracker status advances; it never writes a terminal status - run it with `/skill:check-delivery <ref>`), `writing-plans`, `roasting-the-spec`, `test-driven-development`, `subagent-driven-development`, `dispatching-parallel-agents`, `verification-before-completion`, `requesting-code-review`, `receiving-code-review`, `using-git-worktrees`, `finishing-a-development-branch`, `forge-skill`, `linear` (reads/searches/comments on/manages Linear tickets via the `linearis` CLI; owns all linearis mechanics and the `## Issue tracker` overrides schema; tracker-facing skills route to it). Five more require explicit entry (`disable-model-invocation: true`): `brainstorming` starts the gated workflow on explicit consent - use `/skill:brainstorming` for reliable discovery, or opt in through reachable explicit prose or a human-selected handoff; after spec approval, downstream planning and implementation still chain automatically. `chase-bug` is human-only bug triage: read-only root-cause discovery to an evidenced verdict menu (real bug -> ticket/brainstorm/hotfix/respond; five negative verdicts), then a gated response to the reporter for addressable origins (GitHub issue / tracker ticket) and a rendered verdict summary otherwise - it never fixes during triage; the hotfix row hands off to `skills/chase-bug/hotfix.md` after the menu - run it with `/skill:chase-bug`. `gauntlet-performance` reads the committed run telemetry (current repo by default, `--dir <path>` adds others) through the parse-only `gauntlet-performance` CLI and answers with one example-led recommendation, 3-5 cornerstone numbers, a council assessment when available, and a menu of at most three actions (render a report file, open the recommendation as a ticket via `shape-ticket`, drill into one run); it writes nothing unless you pick render - run it with `/skill:gauntlet-performance [--dir <path>]... [--since <version>]`. `gauntlet-handoff` ends a session whose flow a fresh session will continue: it invokes pi-cohort's `handoff` skill (`--out <path>` or `--key <name>`, default key = the run worktree's branch with `/` flattened to `-`, default file `<tmpdir>/pi-handoff/<key>.md`), then appends the gauntlet process-state section (phase/plan tracker status) per the shared contract `skills/gauntlet-resume/reference/brief-contract.md` - run it with `/skill:gauntlet-handoff [--out <path> | --key <name>]`. `gauntlet-resume` is the only way back into an interrupted flow from a fresh session: it takes a `gauntlet-handoff` brief (a file path, pasted text, or - with no arguments - a pick from the briefs under `<tmpdir>/pi-handoff/`), a bare worktree that already holds a spec, or a spec tracked on main under a configured spec dir (a spec seed: it creates or reuses the worktree through `using-git-worktrees` and pins the spec), restores phase/plan tracker state through the legal arming sequence (`start brainstorm`, `skip` with `resume:` reasons, `plan_check` before implement-or-later), and never infers approval from artifacts - run it with `/skill:gauntlet-resume [<brief-file> | <spec>.md | <worktree-name-or-path>]`.
 - **9 subagent personas** - the specialized child agents the skills dispatch via pi-cohort: `implementer`, `code-reviewer`, `spec-reviewer`, `conformance-reviewer`, `spec-summarizer`, `plan-writer`, `spec-council-member`, `spec-council-synthesizer`, `spec-council-applier`. See [doc/personas.md](./doc/personas.md) for what each one does and why its permissions are scoped the way they are.
-- **4 runtime extensions** - the enforcement layer. `plan-tracker` and `phase-tracker` are tools skills call to track progress (with a TUI widget); `verify-before-ship` is a hook that warns if you push or open a PR without a passing test run since your last edit; a phase-tracker flow guard reminds on implement-phase commits missing spec/code review. In a brainstorming-entered flow, phase-tracker rejects `implement` or `verify` completion while tracker tasks remain pending or in progress; see [its configuration reference](./doc/configuration.md#phase-tracker). phase-tracker also registers `plan_check`, which verifies a plan against its spec and against the grammar in [skills/writing-plans/reference/plan-contract.md](./skills/writing-plans/reference/plan-contract.md), including that each task's `Tests:` commands are selective and never the full suite; a pass stamps the plan for implementation. `telemetry` records one YAML record per gauntlet run (phase timing, models, personas, gate/fix rounds, diff at ship) that ships in the squash beside the spec - it is written only inside a brainstorming-entered flow, kept out of history until `finishing-a-development-branch` seals it once with `gauntlet-telemetry-seal` (a `telemetry:` commit under git; the working-copy snapshot in a plain jj workspace) - and blocks a brainstorm `write` into an already-shipped spec; see [its configuration reference](./doc/configuration.md#telemetry). See [doc/configuration.md](./doc/configuration.md) for the settings each one reads.
+- **4 runtime extensions** - the enforcement layer. `plan-tracker` and `phase-tracker` are tools skills call to track progress (with a TUI widget); `verify-before-ship` is a hook that warns if you push or open a PR without a passing test run since your last edit; a phase-tracker flow guard reminds on implement-phase commits missing spec/code review. In a brainstorming-entered flow, phase-tracker rejects `implement` or `verify` completion while tracker tasks remain pending or in progress; see [its configuration reference](./doc/configuration.md#phase-tracker). phase-tracker also registers `plan_check`, which verifies a plan against its spec and against the grammar in [skills/writing-plans/reference/plan-contract.md](./skills/writing-plans/reference/plan-contract.md), including that each task's `Tests:` commands are selective and never the full suite, and that every test command carries a passing base-commit result; a pass stamps the plan for implementation. `telemetry` records one YAML record per gauntlet run (phase timing, models, personas, gate/fix rounds, diff at ship) that ships in the squash beside the spec - it is written only inside a brainstorming-entered flow, kept out of history until `finishing-a-development-branch` seals it once with `gauntlet-telemetry-seal` (a `telemetry:` commit under git; the working-copy snapshot in a plain jj workspace) - and blocks a brainstorm `write` into an already-shipped spec; see [its configuration reference](./doc/configuration.md#telemetry). See [doc/configuration.md](./doc/configuration.md) for the settings each one reads.
 
 pi-gauntlet is **opinionated**: it recommends this pipeline for non-trivial changes, but starts `brainstorming` only after explicit user consent. Enforcement is opt-in by entry, not ambient: once brainstorming starts a flow, the phase-tracker extension mechanically blocks a phase from closing before its gate runs, and warns once if the main loop writes code during implement (subagents own implement-phase edits). A change made *without* entering the flow (a typo, a formatting run, a dependency bump - see "When to use / when NOT to use") is not gated; the discipline of routing real work through the pipeline is a convention the tooling supports, not a trap it springs on every edit.
 
@@ -110,7 +110,7 @@ Run by a human against pi-cohort >= 7.1.0, before a pi-gauntlet release claims t
 | Gate | A machine-enforced checkpoint between phases (e.g. within a brainstorming-entered flow, `complete verify` is blocked until conformance review has run). Not a suggestion. |
 | Spec council | Multi-model critique of the spec before you see it (`roasting-the-spec`); members and chair return saved-file references, and a fresh applier inherits the main loop's model and thinking unless overridden, edits only the spec, and returns the audit. The main loop checks structure without ingesting member/chair findings, re-reads the spec, and hands it to the unchanged user gate to ratify or revert. Members flag unrelated extras or sufficient in-scope simplifications (`over-spec`); every member closes with a `lean:` line - "nothing to cut" is a first-class answer - and the chair tallies them (`lean: <k> of <n> members found nothing to cut`). Falls back to a single-model critique if no council is configured. |
 | Conformance gate | The closing check: does the delivered code + docs match your *original prompt*, not the derived plan? Compatible executable recommendations auto-fix first; anything still open renders as a numbered decision brief - one item per decision, the problem in plain words first, lettered options each with a one-line consequence, and `Recommended: <letter> - <reason>` or `No recommendation - pick one`. Reply with one line per item (`1. B`), or bare `1` to take every recommendation (no-recommendation items are re-asked by number); a current `CONFORMS` / no-concerns handoff goes straight to branch options with no extra sign-off. |
-| Wave | A batch of plan tasks that don't touch the same files, dispatched to implementers in parallel. |
+| Wave | A batch of N >= 1 plan tasks with disjoint files, run through the one wave loop; N > 1 dispatches concurrently |
 | Overrides file | `.pi/gauntlet-overrides.md` - where you put project-specific detail the generic skills don't know (CI command, worktree wrapper, routing rules). |
 
 ## When to use / when NOT to use
@@ -122,7 +122,7 @@ Run by a human against pi-cohort >= 7.1.0, before a pi-gauntlet release claims t
 ## Requirements
 
 - [pi-coding-agent](https://github.com/earendil-works/pi) ≥ 0.85.1 - tested minimum for sequential `phase_tracker` tool execution, which persists a tracker update before a later tool call in the same model message.
-- [pi-cohort](https://github.com/jjuraszek/pi-cohort) >= 7.4.1 - required peer package, including binary-safe worktree patches. Skills that dispatch agents (`requesting-code-review`, `subagent-driven-development`, `dispatching-parallel-agents`, `writing-plans`, `forge-skill`, `shape-ticket`, `roasting-the-spec`) call `subagent({})`, which pi-cohort provides. pi-gauntlet does not vendor the dispatch tool; without pi-cohort those skills have nothing to call. Gauntlet execution dispatches explicitly use `async: false`; do not enable pi-cohort's incompatible `forceTopLevelAsync` setting. See pi-cohort's [dispatch configuration](https://github.com/jjuraszek/pi-cohort/blob/main/doc/configuration.md) for that setting's owner and semantics. In Parallel-Wave Mode a wave's implementers and first spec reviews are one chain call.
+- [pi-cohort](https://github.com/jjuraszek/pi-cohort) >= 7.4.1 - required peer package, including binary-safe worktree patches. Skills that dispatch agents (`requesting-code-review`, `subagent-driven-development`, `dispatching-parallel-agents`, `writing-plans`, `forge-skill`, `shape-ticket`, `roasting-the-spec`) call `subagent({})`, which pi-cohort provides. pi-gauntlet does not vendor the dispatch tool; without pi-cohort those skills have nothing to call. Gauntlet execution dispatches explicitly use `async: false`; do not enable pi-cohort's incompatible `forceTopLevelAsync` setting. See pi-cohort's [dispatch configuration](https://github.com/jjuraszek/pi-cohort/blob/main/doc/configuration.md) for that setting's owner and semantics. A wave of N >= 1 tasks dispatches its implementers and first spec reviews as one chain call.
 
 Both packages must be listed in your `.pi/settings.json#packages` array (pi adds them automatically when you `pi install`). pi-gauntlet and pi-cohort are versioned independently but release together whenever dispatch semantics change - pin compatible versions of both.
 

package/agents/code-reviewer.md

@@ -77,8 +77,6 @@ with one partition line over the `Fn` IDs assigned above; when a task requires
 a trailing `TRAJECTORY:` verdict (re-review), that verdict comes after `Behaviour-change:` as the
 true final line:
 
-<!-- writing-plans' plan-time Parallel-safe: line is a deliberately different free-text form; do not unify -->
-
 ```
 Parallel-safe: <group>[; <group>]*
   <group> = <comma-separated finding-id list> " disjoint"

package/agents/plan-writer.md

@@ -1,7 +1,7 @@
 ---
 name: plan-writer
 description: Writes, checks, and repairs the gauntlet implementation plan for one approved spec in a fresh context; the plan file is its only output. Dispatched only by the writing-plans skill; not for direct dispatch.
-tools: read, grep, find, ls, write, plan_check
+tools: read, grep, find, ls, bash, write, plan_check
 inheritProjectContext: false
 inheritSkills: false
 completionGuard: true
@@ -23,7 +23,7 @@ No plan content, no summary, no commentary.
 
 The task names five absolute paths: the worktree, the approved spec, the plan path, the plan skill file, and the plan contract file. It may also carry one block after them:
 
-- `Findings:` - the verbatim output of the orchestrator's own `plan_check` on the plan at the plan path, or a human's answers to the plan's open questions. Read the existing plan first and keep everything the block does not touch. Treat each answer as the resolution of the matching open question; remove the `## Open Questions` section when every question is answered.
+- `Findings:` - the verbatim output of the orchestrator's own `plan_check` on the plan at the plan path, or a human's answers to the plan's open questions. Read the existing plan first and keep everything the block does not touch, except baseline rows, which Baseline owns and regenerates. Treat each answer as the resolution of the matching contract question; remove the section when no questions remain. `Findings: rerun baseline` reruns every task command.
 - `Amend:` - the amended spec sections and the rule for the edit. Read the existing plan first; preserve every task title and wave position the amendment does not touch; edit only the affected anchors and tasks.
 
 ## Procedure
@@ -32,12 +32,13 @@ The task names five absolute paths: the worktree, the approved spec, the plan pa
 2. Read the plan skill file (`SKILL.md`) from its `## File Structure` heading through the end of its `## Self-Review` section, and the whole plan contract file (`plan-contract.md`). That text is the plan contract; follow it as written.
 3. Read the spec in full. Recon the code the spec touches by reading it directly: exact paths to create, modify, or delete; call sites and tests with line ranges; the scoped command that runs one test file; scoped and repo-wide lint and format commands; the full-suite verification entrypoint and whether it bundles style checks. Dispatch nothing.
 4. Write the plan at the plan path with `write` as a full replacement. The plan path is the only file you write; never create or edit any other file.
-5. Run `plan_check({ planPath })` on the plan path. A result whose first line starts with `PASS` is a pass; `PASS (no flow to stamp)` is the expected text here. On `FAIL`, fix every finding in the plan and run it again.
-6. Apply the judgment checks the skill's `## Self-Review` section lists: code-vs-anchor sanity, type and API consistency, test contract, runtime-resource disjointness, solo-reason validity, waiver authorization, verification-ownership authorization, documentation-impact mapping. Any edit returns you to step 5.
-7. Stop when `plan_check` passes and the judgment checks caused no edit. When the same finding has survived 3 fix rounds, write it under an `## Open Questions` section at the top of the plan and stop; rows in a `Findings:` block continue that finding's count, so one 3-round budget per finding covers every dispatch. Then reply per the output contract.
+5. Run Baseline from the skill's Self-Review before `plan_check({ planPath })`. On Findings/Amend re-dispatch, read provenance once for the current base; retain evidence only for unchanged commands on that same base, rerun missing, invalid, changed-command or changed-SHA evidence, and rerun every command for `Findings: rerun baseline`. Never rewrite SHAs without execution. Baseline owns and regenerates its rows; preserve unresolved contract rows.
+6. Run the deterministic checker and judgment checks in Self-Review, including Contract decisions. Repair `baseline-line` and substantive baseline `open-questions` findings only by Baseline execution, never by authoring evidence or deleting/rewording a row. Normalize malformed Open Questions into rows without changing substantive text. Fix every other finding; with substantive rows remaining, reply `OPEN QUESTIONS <abs plan path>` immediately, without a passing check or repair rounds for those rows. Any ordinary edit returns to step 5.
+7. Stop when `plan_check` passes and judgment checks cause no edit. Apply the 3-round budget only to ordinary findings: convert an exhausted finding to an Open Questions row and stop. Findings blocks continue that finding's count across dispatches. Omit the section when no rows remain and reply per the output contract.
 
 ## Rules
 
-- Never leave a placeholder in the plan; a decision you cannot make is a named open question.
+- Use `bash` only for Baseline provenance (`git rev-parse`, `git status --porcelain`, or the contract's jj equivalents) and the plan's own `Tests:` commands in the worktree. Write only the plan. Never edit tracked source, commit, run `stash`, `checkout`, `restore`, `clean`, or mutate jj's working copy or revisions (`new`, `commit`, `abandon`, `restore`, `squash`).
+- Never leave a placeholder in authored plan prose; retain verbatim failure evidence in row continuation fences. Derive decisions from source per Contract decisions; name only an unsettled decision as an open question.
 - Never call `plan_tracker`, `phase_tracker`, or `subagent`; the orchestrator owns them.
 - Never reply with more than the one line.

package/extensions/lib/plan-check.test.ts

@@ -42,6 +42,7 @@ const VALID_PLAN = `# Fixture Plan
 
 **Tests:**
 - \`node --test extensions/lib/fixture-task1.test.ts\`
+- baseline: abc1234 pass
 - via: \`helperFn()\`
 
 This task implements helperFn() for parsing.
@@ -57,13 +58,12 @@ This task implements helperFn() for parsing.
 
 **Tests:**
 - \`node --test extensions/lib/fixture-task2.test.ts\`
+- baseline: abc1234 pass
 
 This task handles naming details.
 
 ## Wave 2 — Solo task
 
-Solo: lone remaining task
-
 ### Task 3: Document banned token handling
 
 **Spec:** doc/specs/fixture-spec.md § "Testing" L9
@@ -74,6 +74,7 @@ Solo: lone remaining task
 
 **Tests:**
 - \`node --test extensions/lib/fixture-task3.test.ts\`
+- baseline: abc1234 pass
 
 The literal TODO is intentionally documented here per spec quote-integrity requirement.
 
@@ -520,8 +521,6 @@ const ENTRYPOINT_PLAN = `# Fixture Plan
 
 ## Wave 1 — Solo
 
-Solo: lone remaining task
-
 ### Task 1: Scoped test
 
 **Spec:** doc/specs/fixture-spec.md § "Testing" L4
@@ -532,6 +531,7 @@ Solo: lone remaining task
 
 **Tests:**
 - \`node --test extensions/lib/plan-check.test.ts\`
+- baseline: abc1234 pass
 
 Run node --test extensions/lib/plan-check.test.ts and confirm green.
 
@@ -550,7 +550,7 @@ test("quote-integrity: header entrypoint literal on an anchored line is satisfie
 
 test("quote-integrity: scoped command on the same anchored line is still required in the task body", () => {
   const mutated = ENTRYPOINT_PLAN.replace(
-    "- Test: extensions/lib/plan-check.test.ts\n\n**Tests:**\n- `node --test extensions/lib/plan-check.test.ts`\n\nRun node --test extensions/lib/plan-check.test.ts and confirm green.",
+    "- Test: extensions/lib/plan-check.test.ts\n\n**Tests:**\n- `node --test extensions/lib/plan-check.test.ts`\n- baseline: abc1234 pass\n\nRun node --test extensions/lib/plan-check.test.ts and confirm green.",
     "- Test: extensions/lib/other.test.ts\n\n**Tests:**\n- `node --test extensions/lib/other.test.ts`\n\nRun the scoped test and confirm green.",
   );
   const qi = findingsFor(checkPlan(mutated, ENTRYPOINT_SPEC, alwaysTruePort()), "quote-integrity");
@@ -649,7 +649,7 @@ test("check 4 fail-closed: invalid glob (port throws)", () => {
 
 test("check 4 fail-closed: task missing **Files:** block", () => {
   const mutated = VALID_PLAN.replace(
-    "**Files:**\n- Modify: extensions/lib/fixture-task3.ts\n- Test: extensions/lib/fixture-task3.test.ts\n\n**Tests:**\n- `node --test extensions/lib/fixture-task3.test.ts`\n\n",
+    "**Files:**\n- Modify: extensions/lib/fixture-task3.ts\n- Test: extensions/lib/fixture-task3.test.ts\n\n**Tests:**\n- `node --test extensions/lib/fixture-task3.test.ts`\n- baseline: abc1234 pass\n\n",
     "",
   );
   const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
@@ -698,13 +698,14 @@ test("check 6 wave-file-disjointness: two tasks in the same wave declare the sam
   );
 });
 
-test("check 7 solo-line: single-task wave missing its Solo: line", () => {
-  const mutated = VALID_PLAN.replace("Solo: lone remaining task\n\n", "");
-  const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
-  const sl = findingsFor(findings, "solo-line");
-  assert.equal(sl.length, 1);
-  assert.match(sl[0].reason, /missing a 'Solo: <reason>' line/);
-  assert.equal(sl[0].line, lineOf(mutated, "## Wave 2 — Solo task"));
+test("every-wave-singleton plan without Solo: lines passes; legacy Solo: lines are accepted silently", () => {
+  const plan = VALID_PLAN.replace(
+    "### Task 2: Implement naming",
+    "## Wave 2 - Naming\n\n### Task 2: Implement naming",
+  ).replace("## Wave 2 — Solo task", "## Wave 3 - Documentation");
+  assert.deepEqual(checkPlan(plan, SPEC_TEXT, alwaysTruePort()), []);
+  const legacy = plan.replace("## Wave 2 - Naming", "## Wave 2 - Naming\n\nSolo: Task 2 depends on Wave 1");
+  assert.deepEqual(checkPlan(legacy, SPEC_TEXT, alwaysTruePort()), []);
 });
 
 test("check 8 header-entrypoint: verification entrypoint string reused outside the header", () => {
@@ -746,8 +747,6 @@ const EXEMPTION_PLAN = `# Exemption Plan
 
 ## Wave 1 — Solo task
 
-Solo: only task in this wave
-
 ### Task 1: Document banned token handling
 
 **Spec:** doc/specs/exemption-spec.md § "Notes" L4
@@ -758,6 +757,7 @@ Solo: only task in this wave
 
 **Tests:**
 - \`node --test extensions/lib/exemption-task1.test.ts\`
+- baseline: abc1234 pass
 
 The literal TODO is intentionally documented here per spec quote-integrity requirement.
 
@@ -799,9 +799,8 @@ test("check 2/5 exemption negative: without the task body carrying the literal,
   );
 });
 
-test("aggregate: independent mutations across three checks are all reported together", () => {
+test("aggregate: independent mutations across two checks are all reported together", () => {
   let mutated = VALID_PLAN;
-  mutated = mutated.replace("Solo: lone remaining task\n\n", "");
   mutated = mutated.replace(
     "- via: `helperFn()`\n\nThis task implements helperFn() for parsing.",
     "- via: `parserSeam()`\n\nThis task implements the helper for parsing.",
@@ -811,7 +810,6 @@ test("aggregate: independent mutations across three checks are all reported toge
     "- Modify: extensions/lib/fixture-shared.ts",
   );
   const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
-  assert.ok(findingsFor(findings, "solo-line").length > 0, "expected a solo-line finding");
   assert.ok(findingsFor(findings, "quote-integrity").length > 0, "expected a quote-integrity finding");
   assert.ok(findingsFor(findings, "wave-file-disjointness").length > 0, "expected a wave-file-disjointness finding");
 });
@@ -1050,6 +1048,104 @@ test("tests-block: no path normalization - ./x and x differ, as in Files:", () =
   assert.ok(tb(mutated).some((x) => x.reason.includes("not anchored")));
 });
 
+const BASELINE = "- baseline: abc1234 pass";
+const T1_COMMAND = "node --test extensions/lib/fixture-task1.test.ts";
+const T1_PATH = "extensions/lib/fixture-task1.test.ts";
+const baselineFindings = (plan: string) => findingsFor(checkPlan(plan, SPEC_TEXT, alwaysTruePort()), "baseline-line");
+
+for (const [name, evidence] of [
+  ["pass", BASELINE],
+  ["pass artifacts", BASELINE + " - artifacts: coverage.json, report.txt"],
+  ["via", BASELINE + " via `" + T1_COMMAND + "`"],
+  ["via artifacts", BASELINE + " via `" + T1_COMMAND + "` - artifacts: coverage.json"],
+] ) {
+  test(`baseline-line accepts ${name}`, () => {
+    assert.deepEqual(baselineFindings(VALID_PLAN.replace(BASELINE, evidence)), []);
+  });
+}
+
+for (const [name, evidence, reason] of [
+  ["missing", "", `Task 1: command \`${T1_COMMAND}\` has no baseline: bullet`],
+  ["bad sha", "- baseline: ABC1234 pass", "Task 1: baseline: bullet malformed:"],
+  ["short sha", "- baseline: abc123 pass", "Task 1: baseline: bullet malformed:"],
+  ["long sha", "- baseline: " + "a".repeat(41) + " pass", "Task 1: baseline: bullet malformed:"],
+  ["bad result", "- baseline: abc1234 fail", "Task 1: baseline: bullet malformed:"],
+  ["empty base command", BASELINE + " via `   `", "Task 1: baseline: bullet malformed:"],
+  ["separator-only base command", BASELINE + " via ` ; `", "Task 1: baseline: bullet malformed:"],
+  ["misplaced", "- via: seam\n" + BASELINE, "Task 1: baseline: not directly after its command"],
+  ["duplicate", BASELINE + "\n" + BASELINE, "Task 1: baseline: not directly after its command"],
+  ["sha mismatch", "- baseline: def5678 pass", "baseline SHAs differ: def5678, abc1234"],
+  ["skip existing", `- baseline: abc1234 skipped - ${T1_PATH} created by this task`, `Task 1: baseline: skipped but \`${T1_PATH}\` is not a Create: path`],
+  ["via unanchored", BASELINE + " via `echo hi`", `Task 1: baseline: pass via \`echo hi\` segment \`echo hi\` anchors no existing Test: path`],
+  ["via unanchored compound", BASELINE + " via `" + T1_COMMAND + " && echo hi`", "anchors no existing Test: path"],
+]) {
+  test(`baseline-line rejects ${name}`, () => {
+    const findings = baselineFindings(VALID_PLAN.replace(BASELINE, evidence));
+    assert.ok(findings.some(f => f.reason.includes(reason)), JSON.stringify(findings));
+  });
+}
+
+test("baseline-line accepts 40-character SHAs and introduced-selector base commands", () => {
+  assert.deepEqual(baselineFindings(VALID_PLAN.replaceAll("abc1234", "a".repeat(40))), []);
+  const plan = VALID_PLAN.replace(`- \`${T1_COMMAND}\``, `- \`${T1_COMMAND}::new_case\``)
+    .replace(BASELINE, BASELINE + " via `" + T1_COMMAND + "`");
+  assert.deepEqual(baselineFindings(plan), []);
+});
+
+test("baseline-line pass via rejects created tokens outside this task's Test paths", () => {
+  const plan = VALID_PLAN.replace(BASELINE, BASELINE + " via `" + T1_COMMAND + " extensions/lib/fixture-task2.ts`");
+  assert.ok(baselineFindings(plan).some(f => f.reason.includes("anchors Create: path extensions/lib/fixture-task2.ts")));
+});
+
+test("baseline-line validates skipped anchor sets and derived surviving segments", () => {
+  const created = VALID_PLAN.replace("- Create: extensions/lib/fixture-task1.ts", `- Create: ${T1_PATH}`);
+  const skipped = `- baseline: abc1234 skipped - ${T1_PATH} created by this task`;
+  assert.deepEqual(baselineFindings(created.replace(BASELINE, skipped)), []);
+  assert.ok(baselineFindings(created.replace(BASELINE, BASELINE + " via `" + T1_COMMAND + "`" )).some(f => f.reason.includes("anchors Create: path " + T1_PATH)));
+  for (const list of ["other.test.ts", `${T1_PATH}, other.test.ts`]) {
+    assert.ok(baselineFindings(created.replace(BASELINE, `- baseline: abc1234 skipped - ${list} created by this task`)).length);
+  }
+  const compound = created.replace(`- \`${T1_COMMAND}\``, `- \`${T1_COMMAND} && node --test extensions/lib/fixture-task2.test.ts\``)
+    .replace(`- Test: ${T1_PATH}`, `- Test: ${T1_PATH}\n- Test: extensions/lib/fixture-task2.test.ts`);
+  assert.deepEqual(baselineFindings(compound.replace(BASELINE, BASELINE + " via `node --test extensions/lib/fixture-task2.test.ts`")), []);
+  assert.ok(baselineFindings(compound.replace(BASELINE, skipped)).length);
+  const allCreated = compound.replace("- Create: extensions/lib/fixture-task1.ts", "- Create: extensions/lib/fixture-task2.test.ts")
+    .replace("- Create: extensions/lib/fixture-task2.ts", "- Create: extensions/lib/fixture-task2.test.ts");
+  const bothSkipped = `- baseline: abc1234 skipped - ${T1_PATH}, extensions/lib/fixture-task2.test.ts created by this task`;
+  assert.deepEqual(baselineFindings(allCreated.replace(BASELINE, bothSkipped)), []);
+  assert.ok(baselineFindings(allCreated.replace(BASELINE, skipped)).length);
+  const none = VALID_PLAN.replace(`- \`${T1_COMMAND}\``, "- none: docs");
+  assert.ok(baselineFindings(none).some(f => f.reason === "Task 1: baseline: under a none: task"));
+});
+
+const FAILURE_ROW = `- Task 1: \`${T1_COMMAND}\` fails on abc1234 (exit 2): assertion failed`;
+for (const [name, body, count, malformed] of [
+  ["absent", "", 0, false],
+  ["sentinel", "- none", 0, false],
+  ["failure", FAILURE_ROW, 1, false],
+  ["global then failure", "- Baseline: worktree dirty on abc1234: source.ts\n" + FAILURE_ROW, 2, false],
+  ["contract", "- Task 1: unresolved caller contract", 1, false],
+  ["prose", "Not resolved", 1, true],
+  ["table", "| question | owner |", 1, true],
+  ["continuations", FAILURE_ROW + "\n  ran: `node --test original.ts`\n  blocked: Task 2 `node --test next.ts`\n  ```text\n  TODO etc.\n  ```", 1, false],
+] as const) {
+  test(`open-questions ${name}`, () => {
+    const plan = VALID_PLAN + (body ? "\n## Open Questions\n\n" + body + "\n" : "");
+    const findings = checkPlan(plan, SPEC_TEXT, alwaysTruePort());
+    const questions = findingsFor(findings, "open-questions");
+    assert.equal(questions.length, count);
+    if (malformed) assert.equal(questions[0].reason, "## Open Questions malformed: expected `- ` rows or `- none`");
+    if (body.includes(FAILURE_ROW)) assert.ok(questions.some(f => f.reason === "plan has open questions: " + FAILURE_ROW));
+    assert.deepEqual(findingsFor(findings, "placeholder-scan"), []);
+  });
+}
+
+test("placeholder-scan masks only valid question output, not authored fences or continuations", () => {
+  for (const text of ["```\nTODO\n```", "## Open Questions\n  ```\n  TODO\n  ```", "## Open Questions\n- TODO unresolved", "## Open Questions\n" + FAILURE_ROW + "\n  ```\n  TODO", "## Open Questions\n" + FAILURE_ROW + "\n  ```\nTODO\n  ```", "## Open Questions\n" + FAILURE_ROW + "\n  ran: `TODO`", "## Open Questions\n" + FAILURE_ROW + "\n  blocked: TODO"]) {
+    assert.ok(findingsFor(checkPlan(VALID_PLAN + "\n" + text, SPEC_TEXT, alwaysTruePort()), "placeholder-scan").length);
+  }
+});
+
 test("tests-block: fenced **Tests:** lines are ignored", () => {
   const mutated = VALID_PLAN.replace(
     "This task handles naming details.",

package/extensions/lib/plan-check.ts

@@ -58,6 +58,7 @@ interface Task {
   testsMisplacedLines: number[];
   tests: TestsBullet[];
   testsVia: TestsBullet[];
+  testsBaseline: TestsBullet[];
   testsNone: TestsBullet[];
   testsMalformed: TestsBullet[];
 }
@@ -67,8 +68,6 @@ interface Wave {
   line: number;
   text: string;
   label: string;
-  soloLine: number | undefined;
-  soloReason: string | undefined;
 }
 
 interface CoverageRow {
@@ -103,6 +102,7 @@ interface ParsedPlan {
   tasks: Task[];
   coverageTableFound: boolean;
   coverageRows: CoverageRow[];
+  openQuestions: { findings: PlanCheckFinding[]; output: Set<number> };
 }
 
 interface SpecHeading {
@@ -188,18 +188,7 @@ function parsePlan(planText: string): ParsedPlan {
     if (mask[i]) continue;
     const m = waveRe.exec(lines[i]);
     if (!m) continue;
-    let soloLine: number | undefined;
-    let soloReason: string | undefined;
-    let j = i + 1;
-    while (j < lines.length && lines[j].trim() === "") j++;
-    if (j < lines.length) {
-      const sm = /^Solo: (.+)$/.exec(lines[j]);
-      if (sm) {
-        soloLine = j + 1;
-        soloReason = sm[1];
-      }
-    }
-    waves.push({ number: Number(m[1]), line: i + 1, text: lines[i], label: m[3], soloLine, soloReason });
+    waves.push({ number: Number(m[1]), line: i + 1, text: lines[i], label: m[3] });
   }
 
   const taskHeaderIdxs: number[] = [];
@@ -263,6 +252,7 @@ function parsePlan(planText: string): ParsedPlan {
     const testsMisplacedLines: number[] = [];
     const tests: TestsBullet[] = [];
     const testsVia: TestsBullet[] = [];
+    const testsBaseline: TestsBullet[] = [];
     const testsNone: TestsBullet[] = [];
     const testsMalformed: TestsBullet[] = [];
 
@@ -295,10 +285,12 @@ function parsePlan(planText: string): ParsedPlan {
         const cmd = /^- `([^`]+)`$/.exec(l);
         const via = /^- via: (\S.*)$/.exec(l);
         const none = /^- none: (\S.*)$/.exec(l);
-        const bullet = { line: p + 1, text: l, value: (cmd ?? via ?? none)?.[1] ?? "" };
+        const baseline = /^- baseline: (\S.*)$/.exec(l);
+        const bullet = { line: p + 1, text: l, value: (cmd ?? via ?? none ?? baseline)?.[1] ?? "" };
         if (cmd) tests.push(bullet);
         else if (via) testsVia.push(bullet);
         else if (none) testsNone.push(bullet);
+        else if (baseline) testsBaseline.push(bullet);
         else testsMalformed.push(bullet);
       }
     }
@@ -319,6 +311,7 @@ function parsePlan(planText: string): ParsedPlan {
       testsMisplacedLines,
       tests,
       testsVia,
+      testsBaseline,
       testsNone,
       testsMalformed,
     });
@@ -380,8 +373,59 @@ function parsePlan(planText: string): ParsedPlan {
     break;
   }
 
+  const questionFindings: PlanCheckFinding[] = [];
+  const questionOutput = new Set<number>();
+  let inSection = false;
+  let row = false;
+  let inOutput = false;
+  let sentinel: number | undefined;
+  let contentCount = 0;
+  const malformed = (idx: number) => questionFindings.push({ check: "open-questions", line: idx + 1, text: lines[idx], reason: "## Open Questions malformed: expected `- ` rows or `- none`" });
+  for (let idx = 0; idx < lines.length; idx++) {
+    const line = lines[idx];
+    if (!mask[idx] && /^## /.test(line)) {
+      if (inSection && sentinel !== undefined && contentCount !== 1) malformed(sentinel);
+      inSection = line === "## Open Questions";
+      row = false;
+      inOutput = false;
+      sentinel = undefined;
+      contentCount = 0;
+      continue;
+    }
+    if (!inSection) continue;
+    if (inOutput) {
+      questionOutput.add(idx);
+      if (/^\s+```/.test(line)) inOutput = false;
+      continue;
+    }
+    if (!line.trim()) continue;
+    contentCount++;
+    if (/^- \S/.test(line)) {
+      row = line !== "- none";
+      if (row) questionFindings.push({ check: "open-questions", line: idx + 1, text: line, reason: `plan has open questions: ${line}` });
+      else sentinel = idx;
+    } else if (row && /^\s+\S/.test(line)) {
+      if (/^\s+```/.test(line)) {
+        let end = idx + 1;
+        while (end < lines.length && !/^\s+```/.test(lines[end])) {
+          if (lines[end].trim() && !/^\s+/.test(lines[end])) break;
+          end++;
+        }
+        if (end < lines.length && /^\s+```/.test(lines[end])) {
+          inOutput = true;
+          questionOutput.add(idx);
+        }
+      }
+    } else {
+      malformed(idx);
+      row = false;
+    }
+  }
+  if (inSection && sentinel !== undefined && contentCount !== 1) malformed(sentinel);
+
   return {
     lines,
+    openQuestions: { findings: questionFindings, output: questionOutput },
     header: { specPathLine, specPath, verificationLine, verificationText, happyPathLine, happyPathText, happyPathCommand, separatorLine },
     waves,
     tasks,
@@ -487,7 +531,7 @@ function checkTestsBlock(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
 
     const headingText = parsed.lines[task.testsHeadingLine - 1];
     if (task.tests.length === 0 && task.testsNone.length === 0) push(task, task.testsHeadingLine, headingText, "block empty: no command bullet and no `none:`");
-    for (const b of task.testsMalformed) push(task, b.line, b.text, "malformed bullet: expected `- \\`command\\``, `- via: <seam>`, or `- none: <category>`");
+    for (const b of task.testsMalformed) push(task, b.line, b.text, "malformed bullet: expected `- \\`command\\``, `- baseline: <evidence>`, `- via: <seam>`, or `- none: <category>`");
     if (task.testsNone.length > 1 || (task.testsNone.length > 0 && (task.tests.length > 0 || task.testsVia.length > 0))) {
       push(task, task.testsNone[0].line, task.testsNone[0].text, "contradictory block: `none:` with a command or `via:`, or more than one `none:`");
     }
@@ -515,6 +559,55 @@ function checkTestsBlock(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
   return findings;
 }
 
+function checkBaselineLines(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
+  const findings: PlanCheckFinding[] = [];
+  const shas = new Set<string>();
+  const creates = new Set(parsed.tasks.flatMap(t => t.files.filter(f => f.kind === "create").map(f => stripLineSuffix(f.path))));
+  for (const task of parsed.tasks) {
+    const push = (bullet: TestsBullet, reason: string) => findings.push({ check: "baseline-line", line: bullet.line, text: bullet.text, reason: `Task ${task.number}: ${reason}` });
+    const paths = task.files.filter(f => f.kind === "test").map(f => stripLineSuffix(f.path)).filter(p => !isBroadening(p));
+    const anchors = (command: string) => commandSegments(command).flatMap(segment => segment.split(" ").flatMap(token => paths.filter(p => token === p || token.startsWith(p + "::") || token.startsWith(p + "#") || token.startsWith(p + ":"))));
+    for (const command of task.tests) {
+      if (!task.testsBaseline.some(b => b.line === command.line + 1)) push(command, `command \`${command.value}\` has no baseline: bullet`);
+    }
+    for (const bullet of task.testsBaseline) {
+      const command = task.tests.find(c => c.line + 1 === bullet.line);
+      if (task.testsNone.length) push(bullet, "baseline: under a none: task");
+      else if (!command) push(bullet, "baseline: not directly after its command");
+      const match = /^([a-f0-9]{7,40}) (?:pass(?: via `([^`]+)`)?(?: - artifacts: (\S.*))?|skipped - (\S.*) created by this task)$/.exec(bullet.value);
+      if (!match || (match[2] !== undefined && !match[2].trim()) || (match[3] !== undefined && !match[3].split(", ").every(p => p.trim().length > 0))) {
+        push(bullet, `baseline: bullet malformed: ${bullet.text}`);
+        continue;
+      }
+      shas.add(match[1]);
+      if (match[4] !== undefined && command) {
+        const listed = match[4].split(", ");
+        const expected = new Set(anchors(command.value));
+        for (const path of new Set([...expected, ...listed])) {
+          if (!creates.has(path)) push(bullet, `baseline: skipped but \`${path}\` is not a Create: path`);
+          else if (!expected.has(path) || !listed.includes(path)) push(bullet, `baseline: bullet malformed: ${bullet.text}`);
+        }
+        if (!expected.size || listed.length !== new Set(listed).size) push(bullet, `baseline: bullet malformed: ${bullet.text}`);
+      }
+      if (match[2] !== undefined) {
+        const segments = commandSegments(match[2]);
+        if (!segments.length) {
+          push(bullet, `baseline: bullet malformed: ${bullet.text}`);
+          continue;
+        }
+        for (const segment of segments) {
+          const found = anchors(segment);
+          const created = [...creates].filter(p => segment.split(" ").some(token => token === p || token.startsWith(p + "::") || token.startsWith(p + "#") || token.startsWith(p + ":")));
+          for (const path of created) push(bullet, `baseline: pass via \`${match[2]}\` segment \`${segment}\` anchors Create: path ${path}`);
+          if (!found.some(p => !creates.has(p) && fs.exists(p))) push(bullet, `baseline: pass via \`${match[2]}\` segment \`${segment}\` anchors no existing Test: path`);
+        }
+      }
+    }
+  }
+  if (shas.size > 1) findings.push({ check: "baseline-line", line: 0, text: "", reason: `baseline SHAs differ: ${[...shas].join(", ")}` });
+  return findings;
+}
+
 function taskBodyText(task: Task, lines: string[]): string {
   return lines.slice(task.bodyStartLine - 1, task.bodyEndLine).join("\n");
 }
@@ -822,6 +915,7 @@ function checkPlaceholderScan(parsed: ParsedPlan, requiredLiterals: Map<number,
     for (let ln = t.bodyStartLine; ln <= t.bodyEndLine; ln++) lineTask.set(ln, t);
   }
   parsed.lines.forEach((line, idx) => {
+    if (parsed.openQuestions.output.has(idx)) return;
     const lineNo = idx + 1;
     const lower = line.toLowerCase();
     const task = lineTask.get(lineNo);
@@ -944,23 +1038,6 @@ function globErrFinding(wave: Wave, pattern: string, err: Error): PlanCheckFindi
   };
 }
 
-function checkSoloLine(parsed: ParsedPlan): PlanCheckFinding[] {
-  const findings: PlanCheckFinding[] = [];
-  for (const wave of parsed.waves) {
-    const count = parsed.tasks.filter((t) => t.waveNumber === wave.number).length;
-    if (count !== 1) continue;
-    if (wave.soloLine === undefined || !wave.soloReason || wave.soloReason.trim().length === 0) {
-      findings.push({
-        check: "solo-line",
-        line: wave.line,
-        text: wave.text,
-        reason: `single-task Wave ${wave.number} is missing a 'Solo: <reason>' line directly under its header`,
-      });
-    }
-  }
-  return findings;
-}
-
 function checkHappyPathLine(parsed: ParsedPlan): PlanCheckFinding[] {
   const { happyPathLine, happyPathText, happyPathCommand } = parsed.header;
   if (happyPathLine === undefined || happyPathCommand !== undefined) return [];
@@ -992,7 +1069,7 @@ function checkHeaderEntrypoint(parsed: ParsedPlan): PlanCheckFinding[] {
   const entrypoints = [entrypoint, parsed.header.happyPathCommand].filter((e): e is string => Boolean(e));
   const executable = new Set<number>();
   for (const task of parsed.tasks) {
-    for (const bullet of [...task.tests, ...task.testsVia, ...task.testsNone, ...task.testsMalformed]) {
+    for (const bullet of [...task.tests, ...task.testsVia, ...task.testsBaseline, ...task.testsNone, ...task.testsMalformed]) {
       executable.add(bullet.line);
     }
   }
@@ -1087,10 +1164,11 @@ export function checkPlan(planText: string, specText: string, fs: FsPort): PlanC
     findings.push(...checkAnchorResolution(parsed, specLines));
     findings.push(...checkPathsExist(parsed, fs));
     findings.push(...checkTestsBlock(parsed, fs));
+    findings.push(...checkBaselineLines(parsed, fs));
+    findings.push(...parsed.openQuestions.findings);
     const requiredLiterals = computeRequiredLiteralsPerTask(parsed, specLines);
     findings.push(...checkPlaceholderScan(parsed, requiredLiterals));
     findings.push(...checkWaveFileDisjointness(parsed, fs));
-    findings.push(...checkSoloLine(parsed));
     findings.push(...checkHeaderEntrypoint(parsed));
     findings.push(...checkHappyPathLine(parsed));
     findings.push(...checkWaiverLiteral(parsed));