pi-gauntlet 5.3.0 → 5.3.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v5.3.2 - 2026-09-06
+
+- Plan coverage: `## Spec coverage` rows accept the exact owner `Verification` for requirements the plan header's `**Verification:**` command proves. `table-closure` closes such rows (mechanical row, unparseable anchor, or literal-free anchor -> finding; never counted as task coverage); `quote-integrity` resolves their literals by verbatim containment in the backtick-stripped header. Orphan-owner reason now names `Verification`; anchor-parseability is checked once per row. `header-entrypoint` unchanged. `writing-plans` documents the owner form with a scoped-tests / final-suite example. Spec: `doc/specs/2026-09-06-gh-24-final-verification-ownership.md` (closes #24).
+
+## v5.3.1 - 2026-09-06
+
+- Task tracking: planning initializes the list once; execution starts and completes existing indices explicitly. Execution retries and fix loops reuse their task; conformance adds only new remediation gaps and reuses their `Gn` indices across rounds.
+- `phase_tracker`: explicit implement/verify completion rejects recorded pending or in-progress tasks under the existing flow guards. Terminal-negative `failed` tasks remain failed; existing escalation rules still apply. Sequential tool execution prevents same-batch tracker updates from being read too early. Requires Pi 0.85.1 or newer; no new settings or tracker schema.
+- Foreground flow dispatch: agent calls explicitly set `async: false`, preserving independent implementation, per-patch SR and council fan-outs. Final order is parent full verification -> whole-diff CR -> conformance; removes async review/test overlap and its classification/polling branches. Pi-cohort's `forceTopLevelAsync` setting is incompatible with this policy.
+- Verification: runtime regressions and real Pi batch ordering pass. Behavioral diagnostics retain observed model-following limits: missed task reopening, an omitted async flag and malformed deferred-gap output. These are documented limits, not claims of infallible tracking or runtime enforcement of foreground dispatch. Spec: `doc/specs/2026-09-06-task-tracking-reliability.md`.
+
 ## v5.3.0 - 2026-09-04
 
 - `chase-bug`: the real-bug verdict menu gains a fourth row, "Implement hotfix now", for small, evidenced, urgent fixes - a middle ceremony tier between the trivial carve-out and the full gauntlet. It hands off to the new companion `skills/chase-bug/hotfix.md`: dedicated `hotfix/<slug>` worktree, one implementer (TDD), one code review as the last mutation gate, an advisory conformance pass, then an unpushed squash commit on the default branch with guaranteed worktree/branch cleanup (or a PR when the pick says "as a PR"). Three safety invariants (no schema/persistence change, no public-contract change, one-commit rollback) gate the row's availability; three judgment predicates steer `[recommended]`. Triage itself stays read-only; the row is reachable only through the verdict menu. Zero changes to finishing, SDD, verification, extensions, or ci.mjs. Spec: `doc/specs/2026-09-03-chase-bug-hotfix.md`.

package/README.md

@@ -38,8 +38,8 @@ Concretely, one change through the gauntlet:
 0. *(Optional)* Before there's even a spec, `/skill:shape-ticket` can create or repair a single tracker issue - shaping a raw ask into a Context/Problem/Idea/Acceptance Criteria ticket, gated by an AC integrity check, a cheap council roast, and one human-confirmed write that may include one optional gated Reporter-note comment. A failed roast is retried once, then surfaced inline at the gate if it fails again. It's a tool, not a phase: no worktree, no plan/phase tracker, runs from any repo state. It never activates on its own (`disable-model-invocation: true`) - invoke it explicitly. Similarly, `/skill:chase-bug` triages a raw bug report into an evidenced verdict - and can hand off to shape-ticket, brainstorming, or a bounded hotfix - before any spec exists.
 1. You describe the change. **`brainstorming`** sets up an isolated worktree, explores the codebase, and turns your description into a written spec. A multi-model critique runs on it automatically. If the spec replaces a known prior spec, brainstorming marks the predecessor with a `> **Superseded by:**` banner under its title (default format, syntax overridable via `.pi/gauntlet-overrides.md`; event-driven only — gauntlet never sweeps historical specs). **You read and approve the spec - human gate 1.** No implementation code exists yet.
 2. **`writing-plans`** decomposes the approved spec into atomic, independently-verifiable tasks, grouped into parallel waves where they don't touch the same files.
-3. **`subagent-driven-development`** executes the plan one task at a time, each in a fresh subagent, behind spec-compliance review then code-quality review. TDD-locked: red, green, refactor.
-4. **verify**: a whole-diff code review, then the **conformance gate** - a subagent reads the finished code and docs against your *original words* from step 1, not the plan, and reports per-requirement: delivered, partial, missing, drifted, or unauthorized. Inside a brainstorming-entered flow this gate is machine-blocked from being skipped. Compatible executable recommendations auto-run through an isolated fix-and-re-audit loop with no prompt; anything still open surfaces as a dense list - one line per decision, plain-language, with its recommended choice inline. Reply `1` to take every recommendation, or `2:` with per-item overrides; a current `CONFORMS` / no-concerns result goes straight to the branch options with no extra conformance sign-off.
+3. **`subagent-driven-development`** executes the plan one task at a time, each in a fresh subagent, behind spec-compliance review then code-quality review. TDD-locked: red, green, refactor. Independent implementation, review, and council batches remain parallel, but their dispatches are foreground: the orchestrator waits for terminal results before accepting work or advancing a phase.
+4. **verify**: the parent first runs the plan's full verification command set; only a passing result permits whole-diff code review, then the **conformance gate**. A review fix invalidates that result, so the parent reruns full verification before the next review or conformance gate. The conformance subagent reads the finished code and docs against your *original words* from step 1, not the plan, and reports per-requirement: delivered, partial, missing, drifted, or unauthorized. Inside a brainstorming-entered flow this gate is machine-blocked from being skipped. Compatible executable recommendations auto-run through an isolated fix-and-re-audit loop with no prompt; anything still open surfaces as a dense list - one line per decision, plain-language, with its recommended choice inline. Reply `1` to take every recommendation, or `2:` with per-item overrides; a current `CONFORMS` / no-concerns result goes straight to the branch options with no extra conformance sign-off.
 5. **`finishing-a-development-branch`**: squash, PR, keep, or discard. Once a PR exists, run `/skill:gatekeep-pr <pr>` to verify it against its issue before merging. **Human gate 2** - the only other decision you make.
 6. *(Optional)* Once the merge lands, `/skill:check-delivery <ref>` can prove delivery - default-branch landing, delivery target, per-AC evidence - before the tracker status advances. Explicit invocation only, no auto-chain: deploys commonly lag merges by minutes to hours, so an auto-run would routinely check too early.
 
@@ -71,7 +71,7 @@ pi-gauntlet ships three kinds of pieces, layered on top of pi-cohort's dispatch:
 
 - **17 skills** - the workflow logic. Thirteen activate automatically when pi sees the matching kind of task, and each one gates the next: `brainstorming`, `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`, `writing-skills`, `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). Four more are explicit-invocation-only (`disable-model-invocation: true`): `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 - run it with `/skill:shape-ticket`. `gatekeep-pr` is consent-gated pre-merge verification of a PR against its issue - read-only gathering, verification evidence resolved CI-first (green checks on the exact assessed head count as evidence; the project's verification command runs only as fallback), a rubric-based review, then a deterministic authorship-aware menu with stable finding IDs (P#/L#/C#/F#) and numbered pre-composed courses (fixes execute as a single parallel-safe wave: one gate run, one re-review, one push); nothing mutates (fixes, pushes, reviews, merges) until you pick a row - run it with `/skill:gatekeep-pr <pr>`. `check-delivery` 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>`. `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`.
 - **7 subagent personas** - the specialized child agents the skills dispatch via pi-cohort: `implementer`, `code-reviewer`, `spec-reviewer`, `conformance-reviewer`, `spec-summarizer`, `spec-council-member`, `spec-council-synthesizer`. See [doc/personas.md](./doc/personas.md) for what each one does and why its permissions are scoped the way they are.
-- **3 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. phase-tracker also registers plan_check, a deterministic plan linter (8 mechanical plan-vs-spec checks) whose pass stamp gates implement-start inside a gauntlet flow. See [doc/configuration.md](./doc/configuration.md) for the settings each one reads.
+- **3 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, a deterministic plan linter (8 mechanical plan-vs-spec checks) whose pass stamp gates implement-start inside a gauntlet flow. See [doc/configuration.md](./doc/configuration.md) for the settings each one reads.
 
 pi-gauntlet is **opinionated**: every non-trivial change is *meant* to ride this one pipeline, entered through `brainstorming`. 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.
 
@@ -93,8 +93,8 @@ pi-gauntlet is **opinionated**: every non-trivial change is *meant* to ride this
 
 ## Requirements
 
-- [pi-coding-agent](https://github.com/earendil-works/pi) ≥ 0.1.0
-- [pi-cohort](https://github.com/jjuraszek/pi-cohort) ≥ 1.4.5 - required peer package. Skills that dispatch agents (`requesting-code-review`, `subagent-driven-development`, `dispatching-parallel-agents`, `writing-plans`, `writing-skills`, `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.
+- [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) ≥ 1.4.5 - required peer package. Skills that dispatch agents (`requesting-code-review`, `subagent-driven-development`, `dispatching-parallel-agents`, `writing-plans`, `writing-skills`, `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.
 
 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/extensions/lib/plan-check.test.ts

@@ -16,6 +16,9 @@ const SPEC_TEXT = [
   "", // 11
   "## Other", // 12
   "Stuff.", // 13
+  "", // 14
+  "## Acceptance", // 15
+  "Full suite passes: `npm run fixture-verify`.", // 16
 ].join("\n");
 
 const VALID_PLAN = `# Fixture Plan
@@ -70,6 +73,7 @@ The literal TODO is intentionally documented here per spec quote-integrity requi
 | § "Testing" L9-L9 | banned token literal handling | Task 3 |
 | - | mechanical: wire test into CI | Task 2 |
 | § "Other" L12-L13 | out of scope thing | waived: out of scope per spec |
+| § "Acceptance" L16 | full suite passes | Verification |
 `;
 
 function alwaysTruePort(): FsPort {
@@ -157,7 +161,7 @@ test("check 1 owner-cell grammar: trailing junk after a Task <n> list is malform
   assert.ok(
     tc.some(
       (f) =>
-        f.reason.includes("owner cell is not a 'Task <n>' list or 'waived: <reason>'") &&
+        f.reason.includes("owner cell is not a 'Task <n>' list, 'Verification', or 'waived: <reason>'") &&
         f.text.includes("Task 1 (see note)"),
     ),
     `expected an owner-cell malformed finding, got: ${JSON.stringify(tc)}`,
@@ -165,7 +169,7 @@ test("check 1 owner-cell grammar: trailing junk after a Task <n> list is malform
   assert.ok(
     tc.some(
       (f) =>
-        f.reason.includes("owner cell is not a 'Task <n>' list or 'waived: <reason>'") &&
+        f.reason.includes("owner cell is not a 'Task <n>' list, 'Verification', or 'waived: <reason>'") &&
         f.line === lineOf(mutated, '| § "Design" L4-L6 | parser grammar basics | Task 1 (see note) |'),
     ),
     `expected the owner-cell malformed finding's line to point at the offending row, got: ${JSON.stringify(tc)}`,
@@ -180,19 +184,173 @@ test("check 1 owner-cell grammar: empty waiver reason is malformed, not accepted
   const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
   const tc = findingsFor(findings, "table-closure");
   assert.ok(
-    tc.some((f) => f.reason.includes("owner cell is not a 'Task <n>' list or 'waived: <reason>'")),
+    tc.some((f) => f.reason.includes("owner cell is not a 'Task <n>' list, 'Verification', or 'waived: <reason>'")),
     `expected an owner-cell malformed finding for empty waiver reason, got: ${JSON.stringify(tc)}`,
   );
   assert.ok(
     tc.some(
       (f) =>
-        f.reason.includes("owner cell is not a 'Task <n>' list or 'waived: <reason>'") &&
+        f.reason.includes("owner cell is not a 'Task <n>' list, 'Verification', or 'waived: <reason>'") &&
         f.line === lineOf(mutated, '| § "Other" L12-L13 | out of scope thing | waived: |'),
     ),
     `expected the owner-cell malformed finding's line to point at the offending row, got: ${JSON.stringify(tc)}`,
   );
 });
 
+const VERIFICATION_ROW = '| § "Acceptance" L16 | full suite passes | Verification |';
+
+function withRow(plan: string, row: string): string {
+  return plan.replace(
+    '| § "Other" L12-L13 | out of scope thing | waived: out of scope per spec |',
+    `| § "Other" L12-L13 | out of scope thing | waived: out of scope per spec |\n${row}`,
+  );
+}
+
+for (const owner of ["verification", "Verify", "VERIFICATION", "Task 1, Verification"]) {
+  test(`Verification owner: '${owner}' is a malformed owner -> table-closure`, () => {
+    const row = `| § "Acceptance" L16 | full suite passes | ${owner} |`;
+    const findings = checkPlan(withRow(VALID_PLAN, row), SPEC_TEXT, alwaysTruePort());
+    const tc = findingsFor(findings, "table-closure");
+    assert.ok(
+      tc.some(
+        (f) =>
+          f.reason === "owner cell is not a 'Task <n>' list, 'Verification', or 'waived: <reason>'" &&
+          f.text === row,
+      ),
+      `expected orphan-owner finding for ${owner}, got: ${JSON.stringify(tc)}`,
+    );
+  });
+}
+
+test("Verification owner: unparseable anchor ('-') -> table-closure parseability reason", () => {
+  const row = "| - | full suite passes | Verification |";
+  const findings = checkPlan(withRow(VALID_PLAN, row), SPEC_TEXT, alwaysTruePort());
+  const tc = findingsFor(findings, "table-closure");
+  assert.ok(
+    tc.some(
+      (f) =>
+        f.reason === 'requirement row anchor is not a parseable § "heading" L<n>-L<n> anchor' && f.text === row,
+    ),
+    `expected parseability finding, got: ${JSON.stringify(tc)}`,
+  );
+});
+
+test("Verification owner: anchored lines without a backtick literal -> table-closure", () => {
+  const row = '| § "Other" L13 | stuff | Verification |';
+  const findings = checkPlan(withRow(VALID_PLAN, row), SPEC_TEXT, alwaysTruePort());
+  const tc = findingsFor(findings, "table-closure");
+  assert.ok(
+    tc.some(
+      (f) => f.reason === "Verification row has no backtick literal to check against the header" && f.text === row,
+    ),
+    `expected no-literal finding, got: ${JSON.stringify(tc)}`,
+  );
+});
+
+test("Verification owner: mechanical row -> table-closure", () => {
+  const row = "| - | mechanical: run the suite | Verification |";
+  const findings = checkPlan(withRow(VALID_PLAN, row), SPEC_TEXT, alwaysTruePort());
+  const tc = findingsFor(findings, "table-closure");
+  assert.ok(
+    tc.some((f) => f.reason === "mechanical row owner must be a Task <n>" && f.text === row),
+    `expected mechanical-owner finding, got: ${JSON.stringify(tc)}`,
+  );
+});
+
+test("table-closure: multi-owner row with unparseable anchor yields one parseability finding", () => {
+  const row = "| L999 | naming details | Task 1, Task 2 |";
+  const findings = checkPlan(withRow(VALID_PLAN, row), SPEC_TEXT, alwaysTruePort());
+  const parseability = findingsFor(findings, "table-closure").filter(
+    (f) => f.text === row && f.reason.includes("not a parseable"),
+  );
+  assert.equal(parseability.length, 1);
+});
+
+test("Verification owner: does not satisfy a task's coverage requirement", () => {
+  const mutated = withRow(VALID_PLAN, VERIFICATION_ROW).replace(
+    '| § "Testing" L9-L9 | banned token literal handling | Task 3 |\n',
+    "",
+  );
+  const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
+  assert.ok(
+    findingsFor(findings, "table-closure").some((f) =>
+      f.reason.includes("Task 3 does not appear as an owner"),
+    ),
+  );
+});
+
+test("Verification quote-integrity: literal missing from header -> quote-integrity on the row", () => {
+  const mutated = VALID_PLAN.replace("**Verification:** npm run fixture-verify", "**Verification:** npm run other");
+  const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
+  const qi = findingsFor(findings, "quote-integrity");
+  const row = '| § "Acceptance" L16 | full suite passes | Verification |';
+  assert.ok(
+    qi.some(
+      (f) =>
+        f.reason === "verification header does not contain the required verbatim literal `npm run fixture-verify`" &&
+        f.text === row &&
+        f.line === lineOf(mutated, row),
+    ),
+    `expected header-containment finding, got: ${JSON.stringify(qi)}`,
+  );
+});
+
+test("Verification quote-integrity: multi-command header contains the literal", () => {
+  const mutated = VALID_PLAN.replace(
+    "**Verification:** npm run fixture-verify",
+    "**Verification:** `npm run fixture-verify && npm run lint`",
+  );
+  assert.deepEqual(findingsFor(checkPlan(mutated, SPEC_TEXT, alwaysTruePort()), "quote-integrity"), []);
+});
+
+test("Verification quote-integrity: two-span header contains both literals", () => {
+  const spec = SPEC_TEXT.replace(
+    "Full suite passes: `npm run fixture-verify`.",
+    "Full suite passes: `npm run fixture-verify` and `npm run lint`.",
+  );
+  const mutated = VALID_PLAN.replace(
+    "**Verification:** npm run fixture-verify",
+    "**Verification:** `npm run fixture-verify`, `npm run lint`",
+  );
+  assert.deepEqual(findingsFor(checkPlan(mutated, spec, alwaysTruePort()), "quote-integrity"), []);
+});
+
+test("Verification quote-integrity: missing header -> quote-integrity per literal plus header-entrypoint", () => {
+  const mutated = VALID_PLAN.replace("**Verification:** npm run fixture-verify\n", "");
+  const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
+  assert.equal(
+    findingsFor(findings, "quote-integrity").filter((f) => f.reason.includes("`npm run fixture-verify`")).length,
+    1,
+  );
+  assert.ok(findingsFor(findings, "header-entrypoint").some((f) => f.reason.includes("missing header")));
+});
+
+test("Verification quote-integrity: task body containing the full header string still fails header-entrypoint", () => {
+  const mutated = VALID_PLAN.replace(
+    "This task handles naming details.",
+    "This task handles naming details. Run npm run fixture-verify here.",
+  );
+  const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
+  assert.ok(findingsFor(findings, "header-entrypoint").some((f) => f.text.includes("Run npm run fixture-verify here")));
+  assert.deepEqual(findingsFor(findings, "quote-integrity"), []);
+});
+
+test("Verification quote-integrity: task body containing only a sub-command of a multi-command header is not caught by header-entrypoint", () => {
+  const mutated = VALID_PLAN.replace(
+    "**Verification:** npm run fixture-verify",
+    "**Verification:** `npm run fixture-verify && npm run lint`",
+  ).replace("This task handles naming details.", "This task handles naming details. Run npm run fixture-verify here.");
+  const findings = checkPlan(mutated, SPEC_TEXT, alwaysTruePort());
+  assert.deepEqual(findingsFor(findings, "header-entrypoint"), []);
+  assert.deepEqual(findingsFor(findings, "quote-integrity"), []);
+});
+
+test("Verification quote-integrity: task-owned literal check unchanged", () => {
+  const mutated = VALID_PLAN.replace("This task implements helperFn() for parsing.", "This task implements the helper.");
+  const qi = findingsFor(checkPlan(mutated, SPEC_TEXT, alwaysTruePort()), "quote-integrity");
+  assert.ok(qi.some((f) => f.reason.includes("Task 1 body does not contain the required verbatim literal `helperFn()`")));
+});
+
 test("check 3 anchor-resolution: ambiguous heading match (duplicate spec heading)", () => {
   const dupSpec = SPEC_TEXT.replace('## Testing', '## Design\n\nduplicate section body.\n\n## Testing');
   const findings = checkPlan(VALID_PLAN, dupSpec, alwaysTruePort());

package/extensions/lib/plan-check.ts

@@ -69,6 +69,7 @@ interface CoverageRow {
   isWaived: boolean;
   ownerTasks: number[];
   ownerMalformed: boolean;
+  isVerification: boolean;
   anchor: Anchor | undefined;
 }
 
@@ -270,6 +271,7 @@ function parsePlan(planText: string): ParsedPlan {
       let isWaived = false;
       let ownerTasks: number[] = [];
       let ownerMalformed = false;
+      const isVerification = ownerCell === "Verification";
       if (waivedMatch) {
         if (waivedMatch[1].trim().length === 0) {
           ownerMalformed = true;
@@ -278,7 +280,7 @@ function parsePlan(planText: string): ParsedPlan {
         }
       } else if (isTaskList) {
         ownerTasks = [...ownerCell.matchAll(/Task (\d+)/g)].map((mm) => Number(mm[1]));
-      } else {
+      } else if (!isVerification) {
         ownerMalformed = true;
       }
       let anchor: Anchor | undefined;
@@ -296,6 +298,7 @@ function parsePlan(planText: string): ParsedPlan {
         isWaived,
         ownerTasks,
         ownerMalformed,
+        isVerification,
         anchor,
       });
       p++;
@@ -380,7 +383,7 @@ function computeRequiredLiteralsPerTask(parsed: ParsedPlan, specLines: string[])
   return map;
 }
 
-function checkTableClosure(parsed: ParsedPlan): PlanCheckFinding[] {
+function checkTableClosure(parsed: ParsedPlan, specLines: string[]): PlanCheckFinding[] {
   const findings: PlanCheckFinding[] = [];
   if (!parsed.coverageTableFound) {
     findings.push({ check: "table-closure", line: 0, text: "", reason: "no '## Spec coverage' table found" });
@@ -396,34 +399,54 @@ function checkTableClosure(parsed: ParsedPlan): PlanCheckFinding[] {
         check: "table-closure",
         line: row.line,
         text: row.text,
-        reason: "owner cell is not a 'Task <n>' list or 'waived: <reason>'",
+        reason: "owner cell is not a 'Task <n>' list, 'Verification', or 'waived: <reason>'",
+      });
+      continue;
+    }
+    if (row.isVerification && row.isMechanical) {
+      findings.push({
+        check: "table-closure",
+        line: row.line,
+        text: row.text,
+        reason: "mechanical row owner must be a Task <n>",
       });
       continue;
     }
     if (row.isWaived) continue;
-    for (const n of row.ownerTasks) {
-      coveredTasks.add(n);
-      if (row.isMechanical) mechanicalCoveredTasks.add(n);
-      const task = taskByNumber.get(n);
-      if (!task) {
+    const anchorUnparseable = !row.isMechanical && !row.anchor;
+    if (anchorUnparseable) {
+      findings.push({
+        check: "table-closure",
+        line: row.line,
+        text: row.text,
+        reason: 'requirement row anchor is not a parseable § "heading" L<n>-L<n> anchor',
+      });
+    }
+    if (row.isVerification) {
+      if (!anchorUnparseable && requiredLiteralsForRow(row, specLines).length === 0) {
         findings.push({
           check: "table-closure",
           line: row.line,
           text: row.text,
-          reason: `row references Task ${n} but no such task exists`,
+          reason: "Verification row has no backtick literal to check against the header",
         });
-        continue;
       }
-      if (row.isMechanical) continue;
-      if (!row.anchor) {
+      continue;
+    }
+    for (const n of row.ownerTasks) {
+      coveredTasks.add(n);
+      if (row.isMechanical) mechanicalCoveredTasks.add(n);
+      const task = taskByNumber.get(n);
+      if (!task) {
         findings.push({
           check: "table-closure",
           line: row.line,
           text: row.text,
-          reason: 'requirement row anchor is not a parseable \u00a7 "heading" L<n>-L<n> anchor',
+          reason: `row references Task ${n} but no such task exists`,
         });
         continue;
       }
+      if (row.isMechanical || anchorUnparseable) continue;
       const contained = task.anchors.some(
         (a) => a.heading === row.anchor!.heading && a.start === row.anchor!.start && a.end === row.anchor!.end,
       );
@@ -465,10 +488,24 @@ function checkQuoteIntegrity(parsed: ParsedPlan, specLines: string[]): PlanCheck
   const findings: PlanCheckFinding[] = [];
   if (!parsed.coverageTableFound) return findings;
   const taskByNumber = new Map(parsed.tasks.map((t) => [t.number, t]));
+  const headerText = (parsed.header.verificationText ?? "").replaceAll("`", "");
   for (const row of parsed.coverageRows) {
     if (row.ownerMalformed || row.isWaived || row.isMechanical) continue;
     const literals = requiredLiteralsForRow(row, specLines);
     if (literals.length === 0) continue;
+    if (row.isVerification) {
+      for (const lit of literals) {
+        if (!headerText.includes(lit)) {
+          findings.push({
+            check: "quote-integrity",
+            line: row.line,
+            text: row.text,
+            reason: `verification header does not contain the required verbatim literal \`${lit}\``,
+          });
+        }
+      }
+      continue;
+    }
     for (const n of row.ownerTasks) {
       const task = taskByNumber.get(n);
       if (!task) continue;
@@ -805,7 +842,7 @@ export function checkPlan(planText: string, specText: string, fs: FsPort): PlanC
     }
 
     const specLines = specText.split("\n");
-    findings.push(...checkTableClosure(parsed));
+    findings.push(...checkTableClosure(parsed, specLines));
     findings.push(...checkQuoteIntegrity(parsed, specLines));
     findings.push(...checkAnchorResolution(parsed, specLines));
     findings.push(...checkPathsExist(parsed, fs));

package/extensions/phase-tracker.test.ts

@@ -56,11 +56,12 @@ function harness(options: { cwd?: string; branch?: unknown[]; idle?: boolean; be
   const tools: { name: string; execute: (...args: any[]) => unknown }[] = [];
   const sent: { message: any; options: any }[] = [];
   let idle = options.idle ?? true;
+  let branch = options.branch ?? [];
   const ctx = {
     cwd: options.cwd ?? tempCwd(),
     hasUI: false,
     isIdle: () => idle,
-    sessionManager: { getBranch: () => options.branch ?? [] },
+    sessionManager: { getBranch: () => branch },
   };
   const pi = {
     on(event: string, handler: (event: unknown, context: unknown) => unknown) {
@@ -68,7 +69,7 @@ function harness(options: { cwd?: string; branch?: unknown[]; idle?: boolean; be
       registered.push(handler);
       handlers.set(event, registered);
     },
-    registerTool(tool: { name: string; execute: (...args: any[]) => unknown }) {
+    registerTool(tool: { name: string; executionMode?: string; execute: (...args: any[]) => unknown }) {
       tools.push(tool);
     },
     sendMessage(message: unknown, sendOptions: unknown) {
@@ -86,7 +87,7 @@ function harness(options: { cwd?: string; branch?: unknown[]; idle?: boolean; be
     for (const handler of handlers.get(name) ?? []) results.push(await handler(event, ctx));
     return results;
   };
-  return { emit, emitEvent, sent, tools, ctx, setIdle: (next: boolean) => (idle = next) };
+  return { emit, emitEvent, sent, tools, ctx, setIdle: (next: boolean) => (idle = next), setBranch: (next: unknown[]) => (branch = next) };
 }
 
 const settle = async (h: ReturnType<typeof harness>) => {
@@ -289,6 +290,163 @@ test("resumed session: closure gate blocks complete verify without a conformance
   assert.equal(res.details.error, "no conformance-reviewer dispatch observed");
 });
 
+const taskSnapshot = (tasks: { name: string; status: string }[], isError = false) => ({
+  type: "message",
+  message: { role: "toolResult", toolName: "plan_tracker", isError, details: { tasks } },
+});
+
+const completePhase = async (h: ReturnType<typeof harness>, phase: "implement" | "verify") => {
+  const tool = h.tools.find((t) => t.name === "phase_tracker")!;
+  return (await tool.execute("complete", { action: "complete", phase }, undefined, undefined, h.ctx)) as {
+    content: { text: string }[];
+    details: { error?: string; phases: Record<Phase, { status: string }> };
+  };
+};
+
+test("phase_tracker registration requests sequential execution", () => {
+  const h = harness();
+  assert.equal(h.tools.find((t) => t.name === "phase_tracker")!.executionMode, "sequential");
+});
+
+test("all-complete plan activity auto-completes an active implement phase", async () => {
+  const h = harness({ branch: implementBranch() });
+  await h.emit("session_start");
+  await h.emitEvent("tool_execution_end", {
+    toolName: "plan_tracker",
+    isError: false,
+    result: { details: { tasks: [{ status: "complete" }, { status: "complete" }] } },
+  });
+  const tool = h.tools.find((t) => t.name === "phase_tracker")!;
+  const status = (await tool.execute("t1", { action: "status" }, undefined, undefined, h.ctx)) as {
+    details: { phases: { implement: { status: string } } };
+  };
+  assert.equal(status.details.phases.implement.status, "complete");
+});
+
+test("cold implement and verify completions ignore unfinished snapshots", async () => {
+  for (const phase of ["implement", "verify"] as const) {
+    const h = harness({
+      branch: [
+        phaseResult("start", phases({ [phase]: "in_progress" })),
+        taskSnapshot([{ name: "standalone task", status: "pending" }]),
+      ],
+    });
+    await h.emit("session_start");
+    const completed = await completePhase(h, phase);
+    assert.equal(completed.details.error, undefined, phase);
+    assert.equal(completed.details.phases[phase].status, "complete", phase);
+  }
+});
+
+test("completion backstop rejects unfinished snapshot indices, preserves state, and permits same-index retry", async () => {
+  const branch: unknown[] = [
+    ...resumedBranch({ plan: "complete", implement: "complete", verify: "in_progress" }),
+    subagentResult(["conformance-reviewer"]),
+    taskSnapshot([
+      { name: "T1 implementation", status: "complete" },
+      { name: "G1 conformance", status: "pending" },
+      { name: "G2 conformance", status: "in_progress" },
+    ]),
+  ];
+  const h = harness({ branch });
+  await h.emit("session_start");
+  const rejected = await completePhase(h, "verify");
+  assert.equal(rejected.details.error, "unfinished tasks");
+  assert.equal(rejected.details.phases.verify.status, "in_progress");
+  assert.match(rejected.content[0].text, /1: G1 conformance \(pending\)/);
+  assert.match(rejected.content[0].text, /2: G2 conformance \(in_progress\)/);
+
+  branch.push(taskSnapshot([
+    { name: "T1 implementation", status: "complete" },
+    { name: "G1 conformance", status: "complete" },
+    { name: "G2 conformance", status: "complete" },
+  ]));
+  const completed = await completePhase(h, "verify");
+  assert.equal(completed.details.error, undefined);
+  assert.equal(completed.details.phases.verify.status, "complete");
+});
+
+test("completion backstop uses the latest successful current-branch snapshot", async () => {
+  const branch: unknown[] = [
+    ...resumedBranch({ plan: "complete", implement: "in_progress" }),
+    taskSnapshot([{ name: "old", status: "pending" }]),
+    taskSnapshot([{ name: "errored", status: "pending" }], true),
+  ];
+  const h = harness({ branch });
+  await h.emit("session_start");
+  const rejected = await completePhase(h, "implement");
+  assert.equal(rejected.details.error, "unfinished tasks");
+  assert.match(rejected.content[0].text, /0: old \(pending\)/);
+
+  branch.push(taskSnapshot([])); // clear/init supersedes the old snapshot
+  assert.equal((await completePhase(h, "implement")).details.phases.implement.status, "complete");
+
+  const resetOnlyBranch: unknown[] = [
+    ...resumedBranch({ plan: "complete", implement: "in_progress" }),
+    taskSnapshot([{ name: "retained through reset", status: "in_progress" }]),
+    phaseResult("reset", phases()),
+    ...resumedBranch({ plan: "complete", implement: "in_progress" }),
+  ];
+  const resetOnly = harness({ branch: resetOnlyBranch });
+  await resetOnly.emit("session_start");
+  assert.equal((await completePhase(resetOnly, "implement")).details.error, "unfinished tasks");
+  resetOnlyBranch.push(taskSnapshot([{ name: "retained through reset", status: "complete" }]));
+  assert.equal((await completePhase(resetOnly, "implement")).details.phases.implement.status, "complete");
+});
+
+test("completion backstop preserves exclusions and closure-error precedence", async () => {
+  const unfinished = taskSnapshot([{ name: "failed", status: "failed" }]);
+  const explicitImplement = harness({ branch: [...resumedBranch({ plan: "complete", implement: "in_progress" }), unfinished] });
+  await explicitImplement.emit("session_start");
+  assert.equal((await completePhase(explicitImplement, "implement")).details.phases.implement.status, "complete");
+
+  const closureFirst = harness({
+    branch: [...resumedBranch({ plan: "complete", implement: "complete", verify: "in_progress" }), taskSnapshot([{ name: "T1", status: "pending" }])],
+  });
+  await closureFirst.emit("session_start");
+  assert.equal((await completePhase(closureFirst, "verify")).details.error, "no conformance-reviewer dispatch observed");
+
+  const disabled = harness({
+    cwd: tempCwd({ piGauntlet: { flowGuards: { enforce: false } } }),
+    branch: [...resumedBranch({ plan: "complete", implement: "in_progress" }), taskSnapshot([{ name: "T1", status: "pending" }])],
+  });
+  await disabled.emit("session_start");
+  assert.equal((await completePhase(disabled, "implement")).details.phases.implement.status, "complete");
+
+  const adHoc = harness({ branch: [taskSnapshot([{ name: "T1", status: "pending" }])] });
+  await adHoc.emit("session_start");
+  const tool = adHoc.tools.find((t) => t.name === "phase_tracker")!;
+  assert.equal((await tool.execute("x", { action: "complete", phase: "plan" }, undefined, undefined, adHoc.ctx)).details.error, undefined);
+});
+
+test("completion backstop leaves no/empty snapshots and skip alone, and uses the switched branch", async () => {
+  const noSnapshot = harness({ branch: resumedBranch({ plan: "complete", implement: "in_progress" }) });
+  await noSnapshot.emit("session_start");
+  assert.equal((await completePhase(noSnapshot, "implement")).details.phases.implement.status, "complete");
+
+  const skipped = harness({
+    branch: [...resumedBranch({ plan: "complete", implement: "in_progress" }), taskSnapshot([{ name: "T1", status: "pending" }])],
+  });
+  await skipped.emit("session_start");
+  const skipTool = skipped.tools.find((t) => t.name === "phase_tracker")!;
+  assert.equal((await skipTool.execute("skip", { action: "skip", phase: "implement", reason: "waived" }, undefined, undefined, skipped.ctx)).details.error, undefined);
+
+  const switched = harness({
+    branch: [...resumedBranch({ plan: "complete", implement: "in_progress" }), taskSnapshot([{ name: "off branch", status: "pending" }])],
+  });
+  await switched.emit("session_start");
+  switched.setBranch([...resumedBranch({ plan: "complete", implement: "in_progress" }), taskSnapshot([{ name: "active", status: "complete" }])]);
+  await switched.emit("session_switch");
+  assert.equal((await completePhase(switched, "implement")).details.phases.implement.status, "complete");
+
+  const closureOff = harness({
+    cwd: tempCwd({ piGauntlet: { closureReview: { enforce: false } } }),
+    branch: [...resumedBranch({ plan: "complete", implement: "complete", verify: "in_progress" }), taskSnapshot([{ name: "T1", status: "pending" }])],
+  });
+  await closureOff.emit("session_start");
+  assert.equal((await completePhase(closureOff, "verify")).details.error, "unfinished tasks");
+});
+
 const subagentResult = (agents: string[]) => ({
   type: "message",
   message: {

package/extensions/phase-tracker.ts

@@ -774,6 +774,7 @@ export default function (pi: ExtensionAPI) {
       "Track workflow phase progress (brainstorm → plan → implement → verify → ship); " +
       "ad-hoc calls do not arm gates. Not for ad-hoc use.",
     parameters: PhaseTrackerParams,
+    executionMode: "sequential",
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       switch (params.action) {
@@ -891,6 +892,43 @@ export default function (pi: ExtensionAPI) {
               } as PhaseTrackerDetails,
             };
           }
+          if (
+            gauntletEntered &&
+            (params.phase === "implement" || params.phase === "verify") &&
+            resolveFlowGuards(loadGauntletSettings(ctx.cwd).gauntlet).enforce
+          ) {
+            let tasks: { name: string; status: string }[] = [];
+            for (const entry of [...ctx.sessionManager.getBranch()].reverse()) {
+              if (
+                entry.type !== "message" ||
+                entry.message.role !== "toolResult" ||
+                entry.message.toolName !== "plan_tracker" ||
+                entry.message.isError
+              ) {
+                continue;
+              }
+              const details = entry.message.details as { tasks?: { name: string; status: string }[]; error?: string } | undefined;
+              if (!details || details.error || !details.tasks) continue;
+              tasks = details.tasks;
+              break;
+            }
+            const unfinished = tasks.flatMap((task, index) =>
+              task.status === "pending" || task.status === "in_progress"
+                ? [`${index}: ${task.name} (${task.status})`]
+                : [],
+            );
+            if (unfinished.length) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Cannot complete ${params.phase}: unfinished tasks:\n${unfinished.join("\n")}\nReconcile these same indices against acceptance evidence, update them and retry.`,
+                  },
+                ],
+                details: { action: "complete", phases: { ...phases }, error: "unfinished tasks" } as PhaseTrackerDetails,
+              };
+            }
+          }
           phases = { ...phases, [params.phase]: transitionPhaseState("complete") as PhaseState };
           firedGuards.clear();
           updateWidget(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "5.3.0",
+  "version": "5.3.2",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",

package/skills/brainstorming/SKILL.md

@@ -36,6 +36,12 @@ The line: exercising the system **as it is today** is research; exercising the *
 
 This skill ends with a **written, user-reviewed spec inside a worktree**. Nothing else.
 
+## Foreground dispatch policy
+
+Flow-owned execution dispatches run in the foreground: set top-level `async: false` on gather, critique, council, summary, implementation, review, conformance, and retry calls. `forceTopLevelAsync` must remain unset or false; it is incompatible with this flow. See [pi-cohort dispatch configuration](https://github.com/jjuraszek/pi-cohort/blob/main/doc/configuration.md). If a dispatch returns an async handle despite `async: false`, stop and report the configuration error: do not poll it, relaunch work, or advance the flow. An intercom-detached child is likewise incomplete work; use the existing coordination path and never accept or duplicate it.
+
+Foreground does not serialize independent work: preserve existing isolated parallel `tasks` batches and await their terminal results before acceptance or tracker/phase advancement.
+
 ## Checklist
 
 Work through the items below **in order**. This is your own checklist to follow, not a `plan_tracker` plan — brainstorming is open-ended exploration, and `plan_tracker` is execution-only (the implement phase). The terminal state is the user review gate; after approval the **only** next skill is `/skill:writing-plans`. Do not jump to implementation, and do not silently drop the critique pass.
@@ -280,7 +286,7 @@ The first three checks — **placeholder scan**, **internal consistency**, and *
 - **Otherwise** → dispatch one fresh `worker` that applies the scope + ambiguity checks and fixes them in place:
 
   ```
-  subagent({ agent: "worker", context: "fresh", cwd: "<abs worktree path, from git rev-parse --show-toplevel>", task:
+  subagent({ agent: "worker", context: "fresh", async: false, cwd: "<abs worktree path, from git rev-parse --show-toplevel>", task:
     "Problem statement: <the problem the spec addresses + the user's stated intent>.\n" +
     "Read the spec at <abs path to doc/specs/...>. Edit ONLY that file. Apply two checks and\n" +
     "fix what you find in place: (1) Scope — does every paragraph serve the goal? Cut filler;\n" +
@@ -311,7 +317,7 @@ SUMMARY_PATH=$(mktemp "${TMPDIR:-/tmp}/gauntlet-spec-summary.XXXXXX")   # absolu
 ```
 
 ```
-subagent({ agent: "spec-summarizer", context: "fresh", cwd: "<abs worktree path, from git rev-parse --show-toplevel>",
+subagent({ agent: "spec-summarizer", context: "fresh", async: false, cwd: "<abs worktree path, from git rev-parse --show-toplevel>",
   output: "<SUMMARY_PATH>", outputMode: "file-only", task:
   "Summarize the spec at <abs path to doc/specs/...> for the user review gate. Read ONLY that file." })
 ```

package/skills/brainstorming/gatherer.md

@@ -12,12 +12,14 @@ Mint a temp dir outside the worktree (never committed):
 GATHER_DIR=$(mktemp -d)
 ```
 
-Set the substep, then dispatch one parallel-tasks `subagent` call (foreground — no
-`async:`; no `model:` — pi-cohort `agentOverrides` owns builder models):
+Set the substep, then dispatch one foreground parallel-tasks `subagent` call (`async: false`; no
+`model:` — pi-cohort `agentOverrides` owns builder models). Preserve the parallel batch and await
+its terminal result before assembling the draft:
 
 ```
 phase_tracker({ action: "substep", phase: "brainstorm", substep: "gather" })
 subagent({
+  async: false,
   tasks: [
     { agent: "scout", cwd: "<abs worktree path>", phase: "context-gather",
       output: "<GATHER_DIR>/scout.md",

package/skills/dispatching-parallel-agents/SKILL.md

@@ -15,6 +15,8 @@ When you have multiple **independent tasks** — unrelated test failures, or imp
 
 This skill is the **mechanic home** for parallel fan-out: fresh-context isolation, `worktree: true` filesystem isolation, and serial patch integration. `subagent-driven-development`'s Parallel-Wave Mode builds its per-wave dispatch on this skill — debugging is the worked example below, but the mechanics are identical for implementation tasks.
 
+Gauntlet flow callers dispatch foreground: explicitly set top-level `async: false`, including retries and prose-described dispatches. `forceTopLevelAsync` is incompatible; if an async handle is returned anyway, stop and report rather than polling or relaunching. See [pi-cohort dispatch configuration](https://github.com/jjuraszek/pi-cohort/blob/main/doc/configuration.md).
+
 **Why parallel subagents:** each agent gets a fresh context window with only its problem domain. No cross-contamination between investigations, smaller diffs, faster wall-clock time. You stay the orchestrator — you read the summaries, resolve any file overlap, and run the integrated tests.
 
 **Fresh context is not the default.** Some packaged subagents (including `worker`) fork the parent context unless you opt out. Always pass `context: "fresh"` on every task entry — if it's missing, you're getting forked agents and losing the isolation that makes parallel dispatch worth doing in the first place.
@@ -78,6 +80,7 @@ Use the `subagent` tool in parallel mode, with explicit fresh context per task:
 ```ts
 subagent({
   context: "fresh",
+  async: false,
   tasks: [
     { agent: "worker", task: "Fix agent-tool-abort.test.ts failures" },
     { agent: "worker", task: "Fix batch-completion-behavior.test.ts failures" },
@@ -123,7 +126,7 @@ Grammar (identical across producers, modulo id prefix — `F` for code/spec revi
 
 **After the fix wave:** integrate patches serially per "Review and Integrate" above (mis-partition is self-healing: integrate the successes, re-run the conflicting finding sequentially on integrated HEAD); run the consuming loop's scoped test gate on the integrated tree; then one re-review of the integrated fix delta, per the consuming loop's own rules. The fan-out counts as one fix round against the consuming loop's budget — it grants no extra rounds.
 
-**Progress:** `plan_tracker({ action: "add" })` one task per fixed finding, named mechanically — `"<prefix>fix F<n>: <finding's first line verbatim>"`, where `<prefix>` is `"W<k>-"` inside an execution wave and empty elsewhere. Fix tasks always extend the tracker, never re-init. Mark `in_progress` at dispatch, `complete` at integration.
+**Progress:** In a gauntlet flow, fix work reuses the consuming task/wave index (or durable `Gn:` gap index) and preserves it through retries, fan-out, tests, and re-review; do not append a fix task or replace an active flow list. Mark the existing index `in_progress` before dispatch and `complete` only after its consuming acceptance point. For standalone non-flow consumers with no owning task, preserve the generic append behavior: `plan_tracker({ action: "add" })` one task per fixed finding, named mechanically — `"<prefix>fix F<n>: <finding's first line verbatim>"`; mark it `in_progress` at dispatch and `complete` at integration.
 
 ## Agent Prompt Structure
 
@@ -192,6 +195,7 @@ REPORT_DIR=$(mktemp -d)
 ```ts
 subagent({
   context: "fresh",
+  async: false,
   worktree: true,        // isolate edits; omit for read-only investigations
   concurrency: 3,
   tasks: [

package/skills/requesting-code-review/SKILL.md

@@ -37,10 +37,10 @@ Fill the template at `code-reviewer.md` in this skill directory, then dispatch a
 
 **How to dispatch:**
 
-Use the `subagent` tool with the code-reviewer template filled in:
+Use the `subagent` tool with the code-reviewer template filled in. This foreground dispatch must return a terminal result before acting on review feedback:
 
 ```ts
-subagent({ agent: "code-reviewer", task: "... filled template ..." })
+subagent({ agent: "code-reviewer", async: false, task: "... filled template ..." })
 ```
 
 **Placeholders:**
@@ -57,7 +57,7 @@ subagent({ agent: "code-reviewer", task: "... filled template ..." })
 - Note Minor issues for later
 - Push back if reviewer is wrong (with reasoning)
 
-**Fix rounds.** Critical and Moderate findings trigger a fix round; when dispatched from an orchestrating skill, fixes go to `implementer` subagents (per the orchestrator's no-self-coding rule), fanned out per `dispatching-parallel-agents` "Fix fan-out" when the review's `Parallel-safe:` line certifies a `disjoint` group of ≥ 2 findings. Before fanning out, validate the review's `Parallel-safe:` line with the structural probe in `dispatching-parallel-agents` § Fix fan-out (exactly-one-line grammar check, one re-ask, then explicit sequential fallback). After integration and the project's test command, re-dispatch the reviewer once on the integrated delta. If Critical or Moderate findings remain, run one more fix round and one more re-review; still failing → escalate to the user. Minor findings never trigger the fan-out.
+**Fix rounds.** Critical and Moderate findings trigger a fix round; when dispatched from an orchestrating skill, fixes go to `implementer` subagents (per the orchestrator's no-self-coding rule), fanned out per `dispatching-parallel-agents` "Fix fan-out" when the review's `Parallel-safe:` line certifies a `disjoint` group of ≥ 2 findings. Before fanning out, validate the review's `Parallel-safe:` line with the structural probe in `dispatching-parallel-agents` § Fix fan-out (exactly-one-line grammar check, one re-ask, then explicit sequential fallback). After integration and the project's test command, re-dispatch the reviewer once on the integrated delta in the foreground with top-level `async: false`; await its terminal result. If Critical or Moderate findings remain, run one more fix round and one more foreground re-review; still failing → escalate to the user. Minor findings never trigger the fan-out.
 
 ## Example
 

package/skills/roasting-the-spec/SKILL.md

@@ -58,6 +58,7 @@ Capture the worktree path once (`git rev-parse --show-toplevel`, run from inside
 
 ```
 subagent({
+  async: false,
   control: { needsAttentionAfterMs: 300000, inFlightSilenceCeilingMs: 300000, inFlightSilenceKillMs: 600000 },
   tasks: members.map((model, i) => ({
     agent: "spec-council-member",
@@ -76,7 +77,7 @@ subagent({
 
 **Usable-critique test (mechanical structural probe).** After the fanout returns - success or failure of the tool call itself - probe the expected output paths on disk; judge by files, not by the tool result's failed/succeeded labels (a killed member may have written a usable critique first). A member file is usable iff it is non-empty AND contains both a `^verdict:\s*(sound|needs-work|unsound)` line and an `^addresses-problem:` line. A `findings:` header with zero bullets is a valid, usable sound critique. Existence plus header regex only - never read or weigh findings content.
 
-**Targeted retry.** Members whose file is missing or not usable are re-dispatched **once**, together, in a second parallel call carrying the same `control` block, with fresh output paths that preserve the `member-<i>-<slug>` basename under a `retry/` subdir of the same temp dir (the chair recovers `raised-by` attribution from that filename pattern). Members with usable files are never re-run.
+**Targeted retry.** Members whose file is missing or not usable are re-dispatched **once**, together, in a second foreground parallel call carrying `async: false` and the same `control` block, with fresh output paths that preserve the `member-<i>-<slug>` basename under a `retry/` subdir of the same temp dir (the chair recovers `raised-by` attribution from that filename pattern). Await its terminal result. Members with usable files are never re-run.
 
 **Quorum.** At least one usable file after retry -> dispatch the chair over the usable files only (next section). Zero usable files -> abort the council, say so, and return to the user gate.
 
@@ -87,6 +88,7 @@ Dispatch the chair once. It reads the member files (not you), the spec, and the
 ```
 subagent({
   agent: "spec-council-synthesizer",
+  async: false,
   model: <chair from config, else omit to inherit>,
   cwd: "<abs worktree path>",
   control: { needsAttentionAfterMs: 300000, inFlightSilenceCeilingMs: 600000, inFlightSilenceKillMs: 900000 },
@@ -99,11 +101,11 @@ subagent({
 })
 ```
 
-The chair runs one long single-turn synthesis; the control block sets an effective silence-kill of max(900s, 600+300) = 900s. Margin rationale: one observed healthy chair turn ran 506s of silence, so a 600s kill would leave under 2 minutes of margin - the chair gets 900s. In the coverage line, use pi-cohort's kill diagnostic as the reason when present (e.g. "Likely wedged in a tool call"), else "no output produced"; omit per-member reasons at full coverage. With one usable member, use singular wording ("synthesize the single member critique").
+The chair runs one long foreground single-turn synthesis; await its terminal result before applying findings. The control block sets an effective silence-kill of max(900s, 600+300) = 900s. Margin rationale: one observed healthy chair turn ran 506s of silence, so a 600s kill would leave under 2 minutes of margin - the chair gets 900s. In the coverage line, use pi-cohort's kill diagnostic as the reason when present (e.g. "Likely wedged in a tool call"), else "no output produced"; omit per-member reasons at full coverage. With one usable member, use singular wording ("synthesize the single member critique").
 
 List the exact member paths in the task text. The `reads:` array injects their contents, but the chair's prompt expects the paths explicitly; without them it scans the tree for `*.md` and stalls.
 
-A chair synthesis is usable iff it contains a `^consensus:` line. If the configured `chair` model is unreachable, retry once with the inherited model; a wedge-killed or unusable chair retries once with the same model. Second failure -> abort the council, say so, and return to the user gate.
+A chair synthesis is usable iff it contains a `^consensus:` line. If the configured `chair` model is unreachable, retry once with the inherited model; a wedge-killed or unusable chair retries once with the same model. Each retry remains foreground with top-level `async: false` and is awaited to a terminal result. Second failure -> abort the council, say so, and return to the user gate.
 
 ### 3 — Decide and apply
 

package/skills/subagent-driven-development/SKILL.md

@@ -13,6 +13,8 @@ Execute a plan by dispatching a **fresh subagent per task**, with two-stage revi
 
 If a tool result contains a ⚠️ workflow warning, stop immediately and address it before continuing.
 
+Gauntlet execution dispatches are foreground: set top-level `async: false` on every implementation, review, conformance, retry, and prose-described dispatch. Preserve parallel `tasks` batches and chain groups. `forceTopLevelAsync` is incompatible; an unexpected async handle means stop and report, never poll or relaunch. See [pi-cohort dispatch configuration](https://github.com/jjuraszek/pi-cohort/blob/main/doc/configuration.md).
+
 ## Why Subagents
 
 Your context window holds the full plan, prior decisions, and conversation history. Each subagent gets a fresh window with only the current task's text and context.
@@ -39,7 +41,7 @@ Periodic "should I continue?" prompts add latency without adding safety. The pla
 
 - Running inside a dedicated worktree (the same one the spec and plan were authored in). If you're on `main` in the primary checkout, stop and invoke `/skill:using-git-worktrees` first — implementation never lands directly on `main`.
 - Approved plan or clear task scope
-- `plan_tracker` initialized with the full task list
+- `plan_tracker` list initialized at writing-plans handoff with the full wave-ordered task list. Consume and preserve it on continuation; only direct recovery with no tracker initializes the full plan list once, before dispatch, and never over an existing list.
 
 ## Sequential vs. Parallel-Wave
 
@@ -53,17 +55,17 @@ Before the first task, enter the implement phase: `phase_tracker({ action: "star
 
 For each task in `plan_tracker`:
 
-1. **Dispatch implementer.** Pass the full task text + scene-setting context + the task's plan-declared test commands as `SCOPED_TEST_COMMANDS` (or `none`). Don't make the subagent re-read the plan.
+1. **Start, then dispatch implementer.** Mark the task's existing `plan_tracker` index `in_progress` before dispatch. Pass the full task text + scene-setting context + the task's plan-declared test commands as `SCOPED_TEST_COMMANDS` (or `none`). Don't make the subagent re-read the plan.
 2. **Handle implementer status** (see below).
 3. **Dispatch spec reviewer.** Pass the task text, the patch diff, the absolute spec path, and the task's `**Spec:**` anchors — SR reads the anchored ranges from the spec file itself; never inline spec excerpts. The spec wins every dispute; the authority hierarchy and finding labels live in `./spec-reviewer-prompt.md`. Anchor-less tasks (no `**Spec:**` line): task text alone is the contract. Verify the change satisfies the anchored spec — nothing missing, nothing extra.
 4. If spec reviewer finds gaps → re-dispatch implementer to fix → re-review. Loop until ✅, within [Fix-Loop Rounds](#fix-loop-rounds).
 5. **Dispatch code-quality reviewer.** Only after spec is ✅. Skip for doc-only tasks (every file in the task's `Files:` block documentation-only) — SR-only, same exemption as doc-only waves. Pass `SCOPED_TEST_COMMANDS` = the task's plan-declared commands.
 6. If quality reviewer finds issues → re-dispatch implementer → re-review. Loop until ✅, within [Fix-Loop Rounds](#fix-loop-rounds).
-7. Mark task complete in `plan_tracker`.
+7. After its existing reviews accept the work (and its required commit point), mark that same task index `complete` in `plan_tracker`. A subagent exit or green tests alone are not acceptance.
 
 The spec is frozen at plan time and the orchestrator is its only writer during execution; if you do edit it mid-run, re-run writing-plans' anchor-resolution check before the next wave. An SR unable to read the spec at a cited anchor (missing file, unresolvable heading/range) returns a blocking finding — the contract is spec+task or stop, never a silent fallback to task-only review.
 
-After all tasks: proceed to [After All Tasks](#after-all-tasks-complete) - it owns the whole-diff code review dispatch and the full verification run (concurrent when the verification set classifies safe).
+After all tasks: proceed to [After All Tasks](#after-all-tasks-complete) - it owns parent full verification, then whole-diff code review, then conformance.
 
 ## Fix-Loop Rounds
 
@@ -121,6 +123,7 @@ Pi-subagents accepts a per-task `model` override. Use it.
 ```ts
 subagent({
   agent: "implementer",
+  async: false,
   task: "...",
   model: "anthropic/claude-haiku-4"   // cheap tier
 })
@@ -132,18 +135,18 @@ When in doubt, default. Don't downgrade reviewers — false negatives are expens
 
 ```ts
 // implementer
-subagent({ agent: "implementer", task: "<task text + context + SCOPED_TEST_COMMANDS + status protocol>" })
+subagent({ agent: "implementer", async: false, task: "<task text + context + SCOPED_TEST_COMMANDS + status protocol>" })
 
 // spec compliance
-subagent({ agent: "spec-reviewer", task: "<task text + patch diff + absolute spec path + task's Spec: anchors>" })
+subagent({ agent: "spec-reviewer", async: false, task: "<task text + patch diff + absolute spec path + task's Spec: anchors>" })
 
 // code quality
-subagent({ agent: "code-reviewer", task: "<diff range + SCOPED_TEST_COMMANDS (task commands; wave: union; whole-diff: none) + ask: production-ready?>" })
+subagent({ agent: "code-reviewer", async: false, task: "<diff range + SCOPED_TEST_COMMANDS (task commands; wave: union; whole-diff: none) + ask: production-ready?>" })
 
 // closing-loop conformance (origin vs deliverable) — its OWN dispatch, never fused with code quality
 // model: call gauntlet_setting({ key: "closureReview" }) first; use the returned model (omit model: if undefined to inherit) and maxFixRounds
 // If gauntlet_setting is unavailable, stop and report - never fall back to a manual bash/JSON settings merge.
-subagent({ agent: "conformance-reviewer", model: /* gauntlet_setting({ key: "closureReview" }).model, else omit to inherit */, task: "<spec path + verbatim original prompt + full diff vs main; per conformance-check.md>" })
+subagent({ agent: "conformance-reviewer", async: false, model: /* gauntlet_setting({ key: "closureReview" }).model, else omit to inherit */, task: "<spec path + verbatim original prompt + full diff vs main; per conformance-check.md>" })
 ```
 
 Prompt templates live alongside this SKILL.md:
@@ -160,22 +163,22 @@ Auto-selected at handoff by `writing-plans` (any wave with ≥2 tasks) when the
 
 **Progress tracking (`plan_tracker`).** `plan_tracker` is a flat list with no native group concept, so waves are *encoded*, not modeled:
 
-- **Init once, wave-ordered:** `init` with every task across all waves in wave order, each name prefixed with its wave (`"W1: <title>"`, `"W2: <title>"`, …). Indices are positional and stable; never re-init mid-run (it drops statuses).
-- **Wave fan-out → `in_progress`:** mark every task index in the wave `in_progress`. Multiple simultaneous `in_progress` entries is expected (sequential mode has one).
-- **Wave commit → `complete`:** after the wave's gate passes and it commits, mark all that wave's indices `complete`. `complete` = durably committed, so a task in conflict-fallback stays `in_progress` until its wave commits.
+- **Consume, preserve, recover only if absent:** consume the wave-ordered list initialized at writing-plans handoff; indices are positional and stable, so never re-init on continuation or mid-run. Only direct recovery with no tracker initializes the full plan list once before dispatch.
+- **Wave fan-out → `in_progress`:** unconditionally mark every task index in the wave `in_progress` before dispatch. Multiple simultaneous entries are expected (sequential mode has one).
+- **Wave commit → `complete`:** after the wave's gate passes and it commits, unconditionally mark all those same indices `complete`. `complete` = durably committed, so a task in conflict fallback stays `in_progress` until its wave commits.
 - **Lifecycle per task:** `pending → in_progress (wave fan-out) → complete (wave commit)`.
 - **Widget caveat (known, deliberately unfixed).** The persistent `plan_tracker` widget's icon strip (`○ → ✓`) and `(c/total)` count reflect every task, but its trailing *name* shows only the **first** `in_progress` task. In parallel mode the icon strip and the `status` action are the full in-flight view; a richer multi-task widget is a separate extension change, out of scope (YAGNI).
-- **Sequential mode is unchanged:** init the full list, one `in_progress` at a time; wave prefixes are harmless if present.
+- **Sequential mode:** consume the same existing full list, one `in_progress` index at a time; wave prefixes are harmless.
 
 **Per-wave loop:**
 
 1. **Independence check.** Parse the wave's tasks' `Files:` blocks; assert pairwise-disjoint (mechanical). Runtime-resource disjointness (DB/schema, port, fixture, external service, shared temp path) is not machine-checkable here — trust the plan's wave grouping, which `writing-plans`' D5 contract guarantees. Either kind of overlap → the wave is mis-grouped; run those tasks as sequential single-task waves and note it.
-2. **Fan out.** One parallel dispatch (shape below): `implementer` per task, `context: "fresh"`, `worktree: true`. Each returns a status + a patch.
+2. **Start, then fan out.** Mark every wave index `in_progress` before one parallel foreground dispatch (shape below): `implementer` per task, `context: "fresh"`, `worktree: true`. Each returns a status + a patch.
 3. **Status + spec review per task.** Parse each `DONE`/`BLOCKED`/etc. (see [Implementer Status](#implementer-status)) **first**. Then **dispatch a `spec-reviewer` per accepted patch** (`DONE`, or a `DONE_WITH_CONCERNS` you proceeded with) in one parallel fan-out — `context: "fresh"`, `cwd: <this worktree>`, **no `worktree` flag** (read-only) — each passed its task text, the returned **patch diff**, the absolute spec path, and the task's `**Spec:**` anchors — SR reads the anchored ranges itself (never inline excerpts; authority hierarchy in `./spec-reviewer-prompt.md`; anchor-less tasks are task-text-only). Review starts from the diff (its hunks carry `file:line`) and reads each touched file in full, and test execution is never the reviewer's job - in either mode (persona rule; the wave test gate in step 5 runs the wave's declared test commands). Inline verdicts are fine at normal wave sizes; large waves use `output:` + `outputMode: "file-only"` to keep verdicts out of your context. **Re-dispatch by cause:** `BLOCKED`/`NEEDS_CONTEXT` per the [Implementer Status](#implementer-status) matrix; a **spec gap** re-dispatches the implementer (fresh, `worktree: true`) carrying the prior patch + the reviewer's findings, the new patch superseding the old at step 4. Loop until accepted + spec ✅, within [Fix-Loop Rounds](#fix-loop-rounds), same as sequential.
 4. **Integrate.** `git apply` each task's patch sequentially onto HEAD. Apply fails = textual conflict → drop that task, finish the rest, re-run the dropped task sequentially on the updated HEAD.
 5. **Test gate.** Run the union of the wave's tasks' declared test commands on the integrated tree — the full verification set is the verify phase's job, run once. Failure = semantic conflict or bug → re-run the offending task sequentially, else fix per [When a Subagent Fails](#when-a-subagent-fails).
 6. **Quality review.** CR binds to the wave: exactly one **initial** code-review dispatch per code-touching wave, over the integrated wave diff - never per task within a wave, never batched across waves. Subsequent dispatches within the wave are re-reviews triggered only by findings, per Fix-Loop Rounds. Pass `SCOPED_TEST_COMMANDS` = the union of the wave's tasks' declared commands. Code-quality review on the integrated wave diff; loop fixes to ✅ within [Fix-Loop Rounds](#fix-loop-rounds), same as sequential. Skip for doc-only waves (SR-only per the commit precondition below).
-7. **Commit the wave.** Leaves a clean tree; the next wave's children branch from this commit and so see the integrated work.
+7. **Commit and complete the wave.** After the gate passes and the wave commits, mark all of its existing indices `complete`. Leaves a clean tree; the next wave's children branch from this commit and so see the integrated work.
 
 **Two-stage review is preserved:** spec review per task (pre-integration, dispatched `spec-reviewer` — not inline), quality review per wave (post-integration). A wave commit requires one spec-review verdict per accepted task, plus one code-review verdict on the integrated diff for waves that touch code. A doc-only wave (every task's `Files:` block documentation-only, per `writing-plans`' Wave Grouping) is SR-only — the CR gate does not apply.
 
@@ -192,6 +195,7 @@ REPORT_DIR=$(mktemp -d)
 ```ts
 subagent({
   context: "fresh",
+  async: false,
   cwd: "/abs/path/to/this/worktree",  // REQUIRED: the worktree you're in, else children branch from main
   worktree: true,        // each task in its own git worktree, branched from cwd's HEAD
   concurrency: 4,        // default; cap = wave size
@@ -223,11 +227,9 @@ For the fan-out + worktree + patch-integration + conflict mechanics, see `dispat
 ## After All Tasks Complete
 
 0. Call `phase_tracker({ action: "start", phase: "verify" })`. (The `implement` phase was started at execution start and auto-completes from `plan_tracker` once all tasks are done; this flow runs its own verify gate instead of `/skill:verification-before-completion`, so it must mark verify itself.)
-1. **Classify, then dispatch both audits.** Classify the plan header's `**Verification:**` commands once per verify entry (post-fix re-runs are serial by nature — no re-classification): **unsafe** = anything that can rewrite tracked files — write-mode formatters (`--write`, `-w`), autofixers (`--fix`, `-u` snapshot updates), codegen, migrations regenerating checked-in artifacts; **safe** = commands that write only untracked/ignored paths — test runners, check-mode linters/formatters (`--check`, `--diff`), type checkers, builds only when their outputs are untracked; wrappers (`script/verify`, `package.json` aliases, `Makefile` targets) — read one level in, safe iff every invoked command classifies safe; deeper nesting or an undeterminable write destination → unsafe. The rule is the write destination; examples are illustrative, not authoritative. Unclear → serial. Orchestrator judgment, not config — no settings key, never a prompt.
-   - **Safe → concurrent (default).** Dispatch the whole-diff review per `/skill:requesting-code-review` against the worktree's full diff vs `main`, passing `SCOPED_TEST_COMMANDS: none` (the full run below is the orchestrator's): `subagent({ agent: "code-reviewer", context: "fresh", async: true, cwd: <worktree>, output: <absolute non-colliding $TMPDIR path>, task: <review template> })` — capture the returned run id; never a relative `output:` path (it lands untracked in the worktree). In the same turn, run the full `**Verification:**` set foreground in your own bash: tests + style + format (a single bundling entrypoint, or the listed individual commands). This is the only full run before conformance — task and wave gates ran scoped commands only.
-   - **Unsafe/unclear → serial.** Same two audits, review first (a plain synchronous dispatch), then the verification set, with one declarative notice naming the offender — e.g. `Serial review->verify: 'npm run fmt' writes tracked files.` Only the start order changes; step 2's join invariant is identical.
-2. **Join, then disposition.** Never busy-wait: after verification returns, check the review at most once via `subagent({ action: "status", id: <run id> })`; if still running, end the turn with no disposition — pi delivers the async completion, and the review output file is read only after terminal completion. If the async dispatch errored or the child died, re-dispatch the review serially (the verification result is already in hand). **No disposition of either result — no fix dispatch, no finding triage, no verify-complete claim, no `conformance-reviewer` dispatch — before both results are in hand and any fix-triggered re-run is green.** Post-join, address Critical and Moderate findings before handoff. Verification failed, review clean → dispatch fixes, then re-run the full set before any subsequent gate. Both audits dirty → strictly ordered, never merged: the review's certified `Parallel-safe:` fan-out first (when present, else sequential fixes), then the remaining verification failures sequentially, then one re-review and one full verification re-run — verification failures never join a `Parallel-safe:` group (they carry no finding IDs and no disjointness certification, and `dispatching-parallel-agents` forbids orchestrator-invented partitions). Both audits bind to the committed HEAD: any post-join fix commit — review-derived or conformance-derived — invalidates the verification result; re-run the full set before re-dispatching any gate. (Consumers wanting an in-flow project-specific audit re-add it via the gauntlet overrides file (see Project overrides), or run `/self-audit` manually.)
-3. **Close the loop — conformance check.** The review in step 1 is plan-vs-code (single-step); it inherits any requirement the plan already dropped. Before marking verify complete, dispatch a fresh-context **`conformance-reviewer`** — its **own** dispatch, never fused into the step-1 review — to confront the deliverable (code **and** docs) against the *origin* — the spec **and** the original prompt — per `verification-before-completion/reference/conformance-check.md`. Pass the spec path, the verbatim original prompt, and the full diff. Follow that reference for the partition rule, concern decomposition, and fix-loop mechanics; do not reimplement them here. The fix loop may drive `plan_tracker` to surface fix-wave progress (task naming and lifecycle per conformance-check.md's fix loop / the Fix fan-out Progress rule); it never calls `phase_tracker`. Call `phase_tracker({ action: "complete", phase: "verify" })` only when the reference says the handoff is durably complete: either a current `CONFORMS` result, or a current `## Closure / conformance` inventory whose carried-open concerns all come from valid deferred gaps, including `recommended: fix` gaps carried open because a declared precondition made the fix loop unavailable (`maxFixRounds: 0`, or no eligible named-branch worktree). A started positive-cap fix loop that blocks, fails, or exhausts its rounds with an open `fix` gap is escalation, not completion; on escalation, do not complete verify, stop and report.
+1. **Parent full verification.** Run the complete plan-header `**Verification:**` command set foreground: tests plus every declared lint, type, format, and build check. A failure must be repaired and the full set rerun successfully before the next step. Before dispatching a verification repair, reopen (`in_progress`) every existing plan-task index whose `Files:` ownership includes its touched files; leave unowned cross-cutting repair work in the verification report. Those indices stay `in_progress` through the successful full rerun **and** step 2's whole-diff review accepting the repair — that acceptance is their completion point, not the passing rerun. Commit any verification-produced tracked changes; use the resulting `HEAD_SHA` in the review task and include the commands/results in its existing `DESCRIPTION`.
+2. **Whole-diff code review.** Only after passing full verification, dispatch one foreground whole-diff `code-reviewer` per `/skill:requesting-code-review` against that committed HEAD, with `SCOPED_TEST_COMMANDS: none`; the reviewer does not repeat the full suite. Address Critical and Moderate findings. Before dispatching a review repair, reopen (`in_progress`) every existing plan-task index whose `Files:` ownership includes its touched files; leave unowned cross-cutting repair work in the review report. Mark each reopened index `complete` only once the repair is re-verified and the re-review accepts it — this is the same completion point step 1's reopened indices wait for, not an extra gate, and the gate order stays full verification -> whole-diff CR -> conformance. Any repair invalidates prior full verification, so rerun the full set successfully before the next gate.
+3. **Close the loop — conformance check.** The review in step 2 is plan-vs-code (single-step); it inherits any requirement the plan already dropped. Before marking verify complete, dispatch a fresh-context **`conformance-reviewer`** — its **own** dispatch, never fused into the step-2 review — to confront the deliverable (code **and** docs) against the *origin* — the spec **and** the original prompt — per `verification-before-completion/reference/conformance-check.md`. Pass the spec path, the verbatim original prompt, and the full diff. Follow that reference for the partition rule, concern decomposition, and fix-loop mechanics; do not reimplement them here. The fix loop reuses durable `Gn` gap indices as defined in conformance-check.md; it never calls `phase_tracker`. Call `phase_tracker({ action: "complete", phase: "verify" })` only when the reference says the handoff is durably complete: either a current `CONFORMS` result, or a current `## Closure / conformance` inventory whose carried-open concerns all come from valid deferred gaps, including `recommended: fix` gaps carried open because a declared precondition made the fix loop unavailable (`maxFixRounds: 0`, or no eligible named-branch worktree). A started positive-cap fix loop that blocks, fails, or exhausts its rounds with an open `fix` gap is escalation, not completion; on escalation, do not complete verify, stop and report.
 4. Summarize what was implemented (tasks completed, files changed, test counts, code-review verdict). Emit the `## Closure / conformance` block exactly as defined in `verification-before-completion/reference/conformance-check.md`: it must open with the two-line sentinel (`status: CONFORMS (0 open)` or `status: GAPS (N open)`, then `audited-base: <full HEAD SHA>`), then carry the exact durable concern schema by reference with no renamed or reformatted fields. `finishing-a-development-branch` Step 3.5 consumes that block verbatim.
 5. **Proceed to finishing — no confirmation prompt.** Once verify is complete per step 3's criterion, invoke `/skill:finishing-a-development-branch` immediately. Its Step 4 menu (squash / PR / keep / discard) is the human gate; a separate "ready to finish?" prompt only stacks a second stop in front of it. Carried-open concerns are resolved there per concern via the `## Closure / conformance` block from step 4. Manual testing is a follow-up after the finishing choice (on `<base-branch>` after a squash-merge, or on the PR branch), never a reason to hold this gate.
 
@@ -251,7 +253,9 @@ For the fan-out + worktree + patch-integration + conflict mechanics, see `dispat
 - Dispatching `code-reviewer` per task inside a wave (CR binds to the integrated wave diff)
 - Dispatching an implementer or code-reviewer without a `SCOPED_TEST_COMMANDS` value (commands or `none`)
 - About to run the full verification entrypoint during the implement phase — task and wave gates run scoped, plan-declared commands only; the full set belongs to verify
-- Dispositioning either after-all-tasks audit — fix dispatch, finding triage, verify-complete claim, or `conformance-reviewer` dispatch — before both the whole-diff review and the full verification run have completed
+- Dispatching a verification or review repair before reopening (`in_progress`) the plan-task indices that own its touched files, or completing them on the passing rerun instead of on the accepting whole-diff review
+- Dispatching whole-diff CR before parent full verification passes, or conformance before the foreground CR result and any invalidating repair re-verification/re-review are accepted
+- Polling, joining, or relaunching an unexpectedly asynchronous gauntlet dispatch instead of stopping and reporting
 
 ## Integration
 

package/skills/test-driven-development/SKILL.md

@@ -219,7 +219,7 @@ Otherwise → not TDD
 
 No exceptions without your human partner's permission.
 
-When the TDD implementation cycle is complete (all tests green, code committed), mark the implement phase complete:
+When the TDD implementation cycle is complete (all tests green, code committed), mark the implement phase complete only for a direct, standalone task. In an orchestrated gauntlet task or review loop, green tests and a commit do not accept the parent task or complete its phase: the parent retains tracker and phase ownership through its required reviews.
 
 ```
 phase_tracker({ action: "complete", phase: "implement" })

package/skills/verification-before-completion/SKILL.md

@@ -160,7 +160,7 @@ Defaults recognise `make ci`, `make test`, `npm test`, `pnpm test`, `yarn test`,
 
 Before running the verification gate, call `phase_tracker({ action: "start", phase: "verify" })`.
 
-When all verification passes, mark the verify phase complete:
+When all verification passes, finish and await the required `plan_tracker` updates before marking verify complete. Reconcile accepted work on its existing indices; never clear or reinitialize to obtain closure. In a direct verification path, complete only after those updates have actually returned.
 
 ```
 phase_tracker({ action: "complete", phase: "verify" })

package/skills/verification-before-completion/reference/conformance-check.md

@@ -130,7 +130,7 @@ Mirrors `subagent-driven-development` Parallel-Wave Mode and reuses its
 `plan_tracker` progress surface. Runs entirely inside the gate — it invokes
 **no** `phase_tracker` calls (`phase_tracker({ phase: "implement" })` errors
 while verify is `in_progress`) and does **not** enter SDD's phase machinery.
-Only the fan-out/integrate/review shape and `plan_tracker` are reused.
+Only the fan-out/integrate/review shape and `plan_tracker` are reused. Every execution dispatch is foreground with top-level `async: false`, including retries and prose-described dispatches; an unexpected async handle is a configuration failure: stop and report, never poll or relaunch. `forceTopLevelAsync` is incompatible; see [pi-cohort dispatch configuration](https://github.com/jjuraszek/pi-cohort/blob/main/doc/configuration.md).
 
 **Precondition — worktree required.** The loop needs a worktree HEAD to branch
 fixes from. On the ad-hoc `finishing-a-development-branch` paths that run in a
@@ -143,23 +143,16 @@ prerequisites hold.
 
 Per round:
 
-1. **`plan_tracker` add** — append the round's gaps as tasks (`Gn: <gap origin
-   clause verbatim, truncated>`; carry the gap's requirement text mechanically,
-   no orchestrator-authored summaries); never `init`, which would wipe the
-   implement phase's completed task list. Lifecycle per gap: `pending` →
-   `in_progress` → `complete`. The widget now shows fix-wave progress during
-   verify.
+1. **Synchronize gap tasks** — append only a genuinely new gap that is entering remediation, named `Gn: <gap origin clause verbatim, truncated>`; never `init`. Find existing gaps by their exact `Gn:` prefix and reuse that index even if origin wording changes. Carried-OPEN inventory-only gaps add nothing. Before dispatch, mark every remediated gap's existing index `in_progress`; a re-audit needing more work reopens that same `Gn` index. The lifecycle traces `[T1,T2]`, then `[T1,T2,G1]`, then `[T1,T2,G1,G2]`; no test-retry or review-round wrapper task.
 2. **Fix dispatch** — per `dispatching-parallel-agents` "Fix fan-out": a `disjoint`
    group of ≥ 2 gaps (per the report's `Parallel-safe:` line) fixes in one parallel
-   dispatch — one `implementer` per gap (fresh context, `worktree: true`, `cwd` =
-   the conformance worktree, task = the gap block verbatim with `touched-files` as
-   the ownership boundary). The dispatch adds `SCOPED_TEST_COMMANDS` to the gap
-   block: the gap-relevant plan-declared commands, or `none` (the round's test
-   gate owns execution). `conflicts` pairs serialize. Gaps outside any ≥ 2-ID
-   `disjoint` group run sequentially as before. Then dispatch `spec-reviewer` per
-   gap on the gap-block reference contract below. Task lifecycle: mark `in_progress` at
-   dispatch; `complete` is deferred until the gap's patch is successfully
-   integrated in step 3 below.
+   foreground dispatch — one `implementer` per gap (fresh context, `async: false`,
+   `worktree: true`, `cwd` = the conformance worktree, task = the gap block verbatim
+   with `touched-files` as the ownership boundary). The dispatch adds `SCOPED_TEST_COMMANDS`
+   to the gap block: the gap-relevant plan-declared commands, or `none` (the round's
+   test gate owns execution). `conflicts` pairs serialize. Gaps outside any ≥ 2-ID
+   `disjoint` group run sequentially as before. Then dispatch foreground `spec-reviewer`
+   per gap on the gap-block reference contract below.
 3. **Integrate** serially via `git apply` onto the worktree HEAD, one gap's
    patch at a time. Failure handling is inherited verbatim from
    `dispatching-parallel-agents` "Review and Integrate": textual conflict →
@@ -168,10 +161,9 @@ Per round:
    offending task sequentially on integrated HEAD; a failed agent → integrate
    the successes, then retry the failure with fresh context including the
    integrated changes. A `BLOCKED`/`NEEDS_CONTEXT` return surfaces to the user.
-4. **Test gate** on the integrated tree, using the project's canonical test
-   command. A failure re-enters the failure-handling rules above.
-5. **`code-reviewer` once** on the round's cumulative fix delta (not per gap), with `SCOPED_TEST_COMMANDS` = the round's gap-relevant commands, or `none` (the round's test gate owns execution).
-6. **Re-audit**: re-dispatch `conformance-reviewer` over the fixes **plus** the
+4. **Test gate** on the integrated tree. In a plan flow, run the full plan-header `Verification` set once here; on an ad-hoc no-plan path, use the project's canonical test command. A failure re-enters the failure-handling rules above.
+5. **Round CR and completion** — run `code-reviewer` once on the round's cumulative fix delta (not per gap), foreground with `async: false` and `SCOPED_TEST_COMMANDS` = the round's gap-relevant commands, or `none` (the round's test gate owns execution). After integration, tests, and this CR accept the work, explicitly mark every remediated gap's same `Gn` index `complete`, before re-audit.
+6. **Re-audit**: foreground re-dispatch `conformance-reviewer` with `async: false` over the fixes **plus** the
    regression guard (any prior-`DELIVERED` requirement whose `evidence` file
    the fix diff touched). Pass the full prior conformance report (every row,
    including DELIVERED rows and their `evidence` `file:line`) and the round's

package/skills/writing-plans/SKILL.md

@@ -85,7 +85,7 @@ Otherwise one plan. Service, contract, or schema count is not a split signal - o
 Before mapping files, dispatch a scout to build the implementation map. Foreground, no announcement, no user interaction. The task template below is fixed — fill exactly **one** variable, the absolute spec path; compose nothing else:
 
 ```
-subagent({ agent: "scout", context: "fresh", cwd: "<abs worktree path>",
+subagent({ agent: "scout", context: "fresh", async: false, cwd: "<abs worktree path>",
   phase: "plan-recon", output: "<abs plan path — same filename as the spec, per the table above>",
   task: <the fixed template below, with the spec path filled> })
 ```
@@ -264,11 +264,14 @@ Every plan ends with a `## Spec coverage` section — authored last, placed afte
 |---|---|---|
 | § "Design" L34-L37 | anchor line in task template | Task 2 |
 | § "Edge cases" L120 | stale anchor = blocking SR finding | Task 4, Task 5 |
+| § "Testing" L84 | checker fixtures: `node --test extensions/lib/plan-check.test.ts` | Task 3 |
+| § "Acceptance" L88 | full suite passes: `npm test` | Verification |
 | § "Out of scope" L131 | fix-round anchoring | waived: out of scope per spec |
 | - | mechanical: release commit | Task 7 |
 ```
 
-- **Requirement rows:** anchor + short requirement + owner = task-ID list, or `waived: <reason>` **only when the spec itself marks the item out of scope**. A waiver on an in-scope normative requirement is a Self-Review failure — there is no human plan-review gate to catch it downstream.
+- **Requirement rows:** anchor + short requirement + owner = task-ID list, or `Verification`, or `waived: <reason>` **only when the spec itself marks the item out of scope**. A waiver on an in-scope normative requirement is a Self-Review failure — there is no human plan-review gate to catch it downstream.
+- **`Verification` owner:** use for a requirement the header `**Verification:**` command proves. Write the exact string `Verification`, alone. Quote only literals contained in that header. Anchor the single requirement line. Keep scoped commands task-owned.
 - **Mechanical-task rows:** anchor `-`, requirement `mechanical: <short>`, owner = the task ID. One such row per anchor-less task.
 - The table is plan-authoring-time only — never passed to implementer or reviewer dispatches.
 
@@ -293,12 +296,13 @@ If a decision is genuinely open, put it in an explicit **Open Questions** sectio
 After drafting the plan and before announcing it complete, run the deterministic checker, then the judgment checks yourself — not a subagent dispatch.
 
 - **Deterministic checker.** Run `plan_check({ planPath })` on the saved plan. Assess and fix every finding yourself (no human involvement), then re-run until it passes — a pass writes the execution stamp that implement-start verifies mechanically. If the same finding survives 3 fix rounds, convert it to an explicit Open Question and stop (the pre-existing Open-Questions halt, resolved by the human in-session — not a new gate). The checker covers table closure, quote integrity, anchor resolution, path existence, placeholder scan, wave file-disjointness, solo-line presence, and header-only entrypoint.
-- **Code-vs-anchor sanity.** For each non-waived requirement row, re-read the anchored spec lines and confirm the owner tasks' bodies do what they say - mechanism present, not just the quoted literal. Fix the task, don't annotate.
+- **Code-vs-anchor sanity.** For each task-owned requirement row, re-read the anchored spec lines and confirm the owner tasks' bodies do what they say - mechanism present, not just the quoted literal. For each `Verification` row, confirm the header command exercises the anchored requirement. Fix the task, don't annotate.
 - **Type / API consistency.** Function signatures and field names that appear in multiple tasks must match exactly. The plan is its own contract — internal contradictions surface as bugs during execution.
 - **Scoped-test coverage.** Every code-touching wave declares at least one scoped test command; only doc-only waves may have none.
 - **Runtime-resource disjointness.** For every multi-task wave, confirm no two tasks contend on a shared mutable runtime resource (DB/schema, port, fixture, external service, shared temp path) — `Files:` overlap is checked mechanically, resource contention is not. Contention = mis-grouped wave; split or re-order before handoff.
 - **Solo-reason validity.** Every single-task wave's `Solo:` line (presence is checked mechanically) must name its specific blocker — the blocking task/wave, the contended resource, or `lone remaining task`. Category-only justifications are under-justified; merge or justify before handoff.
 - **Waiver authorization.** Every `waived: <reason>` owner in `## Spec coverage` is authorized by the spec itself marking the item out of scope. A waiver on an in-scope normative requirement is a Self-Review failure — there is no human plan-review gate to catch it downstream.
+- **Verification-ownership authorization.** `Verification` on a requirement no header command exercises is a Self-Review failure.
 - **Documentation-impact mapping.** Each Documentation impact entry maps to a plan task (or explicit "none").
 
 Fix what this review finds before handoff.
@@ -316,10 +320,11 @@ Fix what this review finds before handoff.
 
 ## Execution Handoff
 
-After saving the plan, mark the planning phase complete:
+After saving the plan, mark the planning phase complete, then initialize `plan_tracker` once with every plan task in wave order. Name each entry `W<k>: <title>` using its containing wave and task title. This is the execution list: do not initialize it again on continuation.
 
 ```
 phase_tracker({ action: "complete", phase: "plan" })
+plan_tracker({ action: "init", tasks: ["W1: <title>", "W1: <title>", "W2: <title>"] })
 ```
 
 Then auto-select the execution mode and proceed — no pause, no picker. The mode is a pure function of the plan's wave structure: