pi-gauntlet 7.0.2 → 7.0.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v7.0.3 - 2026-10-02
+
+### Fixed
+
+- **Amendment aftermath keeps the phase; reopened tasks close in place.** A spec amendment approved during `verify` or `ship` reopens its plan tasks inside that phase; `amendment-surface.md` no longer prescribes `skip <phase>` + `start implement force: true`, and the batch card's phase slot is the constant `no phase change`. Each reopened task is repaired through the current phase's fix loop and closed with `plan_tracker update ... complete` once its re-review or re-audit accepts. Supersedes the phase-restart clauses of the 2026-09-10 gh-27 spec and the 2026-09-22 batch-card spec.
+- **Skill resources load with `read`, never a shell command.** Brainstorming's amend section states the rule (pi-condense's `**/skills/**/*.md` protection keys on `read`'s `path`, so a `bash sed` load was pruned mid-flow); `amendment-surface.md`, SDD, and finishing name `read` at their amendment entry points, and section 5 re-reads itself before the aftermath.
+- **phase-tracker: open-task nudge after a verify-phase repair wave.** Under `flowGuards.enforce`, every non-error implementer-wave result while `verify` is in progress is prefixed with the latest `plan_tracker` snapshot's `pending`/`in_progress` rows and the `update ... complete` call that closes them. Advisory only - no block, no fix-round or phase change - and it reads session entries, so context pruning cannot hide it. The completion backstop's branch scan is shared with it (`latestPlanSnapshot`/`unfinishedTaskLines`). Documented in `doc/configuration.md`.
+
 ## v7.0.2 - 2026-10-02
 
 ### Added

package/extensions/phase-tracker.test.ts

@@ -1814,3 +1814,111 @@ test("grant: accepts MAX_SAFE_INTEGER and current on-disk cap controls whether t
   writeFileSync(join(changed.ctx.cwd, ".pi", "settings.json"), JSON.stringify({ piGauntlet: { closureReview: { maxFixRounds: 1 } } }));
   assert.match((await grant(changed, "g", { rounds: 1, reason: "ok" })).details.error ?? "", /0 used, cap 1/);
 });
+
+const eightTasks = (open: number[]) =>
+  Array.from({ length: 8 }, (_, i) => ({ name: `T${i + 1} task`, status: open.includes(i) ? "in_progress" : "complete" }));
+
+const resultText = async (h: ReturnType<typeof harness>, id: string, isError = false) => {
+  const [res] = (await h.emitEvent("tool_result", waveResult(id, [{ agent: "implementer", exitCode: 0 }], isError))) as (
+    | { content: { text: string }[] }
+    | undefined
+  )[];
+  return res?.content[0]?.text;
+};
+
+test("open-task nudge: verify-phase implementer wave lists mid-list open rows with the closure instruction, before any audit", async () => {
+  const h = harness({ branch: verifyBranch([taskSnapshot(eightTasks([3]))]) });
+  await h.emit("session_start");
+  const text = await resultText(h, "w1");
+  assert.ok(text, "nudge present");
+  assert.match(text, /^Plan tasks still open after this repair wave:\n3: T4 task \(in_progress\)\nOnce this wave's repair is integrated and its re-review or re-audit accepts it, close that task: plan_tracker\(\{ action: "update", index: N, status: "complete" \}\)\. Leave unaccepted repairs in_progress\. A pending row is a task still to run, not to close\. Open tasks block complete verify\.$/);
+  assert.doesNotMatch(text, /0: T1 task/);
+});
+
+// fixRounds is observed through the cap guard: one nudged wave against maxFixRounds 1
+// blocks the next dispatch exactly as an un-nudged wave would.
+test("open-task nudge: fires on every qualifying wave and leaves fix-round counting unchanged", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { enforce: true, maxFixRounds: 1 } } }, [taskSnapshot(eightTasks([0, 3]))]);
+  await h.emit("session_start");
+  assert.equal(await firstCallResult(h, "c1", implementerWave(1)), undefined);
+  assert.match((await resultText(h, "c1")) ?? "", /0: T1 task \(in_progress\)\n3: T4 task \(in_progress\)/);
+  const blocked = await firstCallResult(h, "c2", implementerWave(1));
+  assert.equal(blocked?.block, true, "one wave counted, cap 1 reached");
+  const h2 = guardedHarness({ piGauntlet: { closureReview: { enforce: true } } }, [taskSnapshot(eightTasks([3]))]);
+  await h2.emit("session_start");
+  assert.match((await resultText(h2, "a")) ?? "", /^Plan tasks still open/);
+  assert.match((await resultText(h2, "b")) ?? "", /^Plan tasks still open/);
+});
+
+// The closure-model mismatch warning is stashed at tool_call; it must render first.
+test("open-task nudge: a stashed tool_call warning stays ahead of the nudge on the same result", async () => {
+  const h = harness({
+    cwd: tempCwd({ piGauntlet: { closureReview: { enforce: true, model: "p/configured" } } }),
+    branch: verifyBranch([taskSnapshot(eightTasks([3]))]),
+  });
+  await h.emit("session_start");
+  const call = { tasks: [{ agent: "conformance-reviewer", model: "p/other", task: "audit" }, { agent: "implementer", task: "fix", worktree: true }] };
+  assert.equal(await firstCallResult(h, "m1", call), undefined);
+  const text = (await resultText(h, "m1")) ?? "";
+  const warningAt = text.indexOf("p/other");
+  const nudgeAt = text.indexOf("Plan tasks still open after this repair wave:");
+  assert.ok(warningAt >= 0 && nudgeAt > warningAt, `warning first, nudge second: ${text}`);
+});
+
+test("open-task nudge: silent outside the verify window and without open rows", async () => {
+  const cases: [string, ReturnType<typeof harness>][] = [
+    ["implement in progress", harness({ branch: implementBranch([taskSnapshot(eightTasks([3]))]) })],
+    [
+      "ship in progress",
+      harness({
+        branch: verifyBranch([
+          phaseResult("complete", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete" })),
+          phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete", ship: "in_progress" })),
+          taskSnapshot(eightTasks([3])),
+        ]),
+      }),
+    ],
+    ["all tasks complete or skipped", harness({ branch: verifyBranch([taskSnapshot([...eightTasks([]).slice(0, 7), { name: "T8 task", status: "skipped" }])]) })],
+    ["no snapshot on the branch", harness({ branch: verifyBranch() })],
+    ["latest snapshot is a clear", harness({ branch: verifyBranch([taskSnapshot(eightTasks([3])), taskSnapshot([])]) })],
+    ["rejected update is skipped, prior all-complete snapshot used", harness({ branch: verifyBranch([taskSnapshot(eightTasks([])), { type: "message", message: { role: "toolResult", toolName: "plan_tracker", details: { tasks: eightTasks([3]), error: "rejected" } } }]) })],
+    ["flowGuards.enforce: false", harness({ cwd: tempCwd({ piGauntlet: { flowGuards: { enforce: false } } }), branch: verifyBranch([taskSnapshot(eightTasks([3]))]) })],
+    ["async handle results: []", harness({ branch: verifyBranch([taskSnapshot(eightTasks([3]))]) })],
+  ];
+  for (const [label, h] of cases) {
+    await h.emit("session_start");
+    if (label === "async handle results: []") {
+      assert.deepEqual(await h.emitEvent("tool_result", waveResult("x", [])), [undefined], label);
+      continue;
+    }
+    assert.equal(await resultText(h, "x"), undefined, label);
+  }
+});
+
+test("open-task nudge: closureReview.enforce: false does not silence it", async () => {
+  const h = harness({ cwd: tempCwd({ piGauntlet: { closureReview: { enforce: false } } }), branch: verifyBranch([taskSnapshot(eightTasks([3]))]) });
+  await h.emit("session_start");
+  assert.match((await resultText(h, "k")) ?? "", /^Plan tasks still open/);
+});
+
+test("open-task nudge: silent on an isError result, a degraded settings read, and in a subagent child", async () => {
+  const errored = harness({ branch: verifyBranch([taskSnapshot(eightTasks([3]))]) });
+  await errored.emit("session_start");
+  assert.equal(await resultText(errored, "e", true), undefined, "isError result");
+
+  const malformed = tempCwd();
+  mkdirSync(join(malformed, ".pi"), { recursive: true });
+  writeFileSync(join(malformed, ".pi", "settings.json"), "{ not json");
+  const degraded = harness({ cwd: malformed, branch: verifyBranch([taskSnapshot(eightTasks([3]))]) });
+  await degraded.emit("session_start");
+  assert.equal(await resultText(degraded, "d"), undefined, "settings errors");
+
+  process.env.PI_SUBAGENT_DEPTH = "1";
+  try {
+    const child = harness({ branch: verifyBranch([taskSnapshot(eightTasks([3]))]) });
+    await child.emit("session_start");
+    assert.equal(await resultText(child, "c"), undefined, "subagent child");
+  } finally {
+    process.env.PI_SUBAGENT_DEPTH = "0";
+  }
+});

package/extensions/phase-tracker.ts

@@ -101,6 +101,33 @@ const isImplementerWave = (details: unknown, isError: boolean | undefined): bool
   return d.results.some((r) => r?.agent === "implementer");
 };
 
+type Task = { name: string; status: string };
+
+// Latest successful plan_tracker snapshot on the current branch. Shared by the
+// completion backstop and the open-task nudge so both reason about one state;
+// read from session entries, so context pruning cannot hide it.
+const latestPlanSnapshot = (ctx: ExtensionContext): Task[] => {
+  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?: Task[]; error?: string } | undefined;
+    if (!details || details.error || !details.tasks) continue;
+    return details.tasks;
+  }
+  return [];
+};
+
+const unfinishedTaskLines = (tasks: Task[]): string[] =>
+  tasks.flatMap((task, index) =>
+    task.status === "pending" || task.status === "in_progress" ? [`${index}: ${task.name} (${task.status})`] : [],
+  );
+
 // Review-cadence guard (spec 2026-08-12-execution-fidelity-hardening): presence-only
 // advisory ledger of the most recent completed implementer / spec-reviewer /
 // code-reviewer dispatch. Agents completing in the SAME dispatch share a sequence
@@ -210,6 +237,13 @@ const loneImplementerBlockReason =
   "a lone agent call runs unisolated and produces no worktree diff. " +
   "To disable this gate, set piGauntlet.closureReview.enforce: false.";
 
+// Preview the completion backstop so reopened tasks close at acceptance,
+// not before the repair is integrated and reviewed.
+const openTaskNudge = (rows: string[]): string =>
+  `Plan tasks still open after this repair wave:\n${rows.join("\n")}\n` +
+  'Once this wave\'s repair is integrated and its re-review or re-audit accepts it, close that task: plan_tracker({ action: "update", index: N, status: "complete" }). ' +
+  "Leave unaccepted repairs in_progress. A pending row is a task still to run, not to close. Open tasks block complete verify.";
+
 const fixRoundCapBlockReason = (used: number, cap: number, settingsPath: string): string =>
   `Conformance fix loop: ${used} fix round(s) used against a cap of ${cap} (granted rounds included); ` +
   "escalate to the human with the verdict trail instead of re-looping.\n" +
@@ -382,6 +416,10 @@ export default function (pi: ExtensionAPI) {
   // Warnings stashed at tool_call, prepended at tool_result (verify-before-ship pattern).
   // Relies on tool_result firing for every tool_call; reconstructState clears any stragglers.
   const pendingGuardWarnings = new Map<string, string>();
+  const addGuardWarning = (id: string, text: string) => {
+    const prior = pendingGuardWarnings.get(id);
+    pendingGuardWarnings.set(id, prior ? prior + "\n\n" + text : text);
+  };
 
   const activeGuardPhase = (): Phase | undefined =>
     GUARD_PHASES.find((p) => phases[p].status === "in_progress");
@@ -519,10 +557,6 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("tool_call", async (event, ctx) => {
     // D3.b: one fresh settings read per event, lazily, only if a guard needs it.
-    const addGuardWarning = (id: string, text: string) => {
-      const prior = pendingGuardWarnings.get(id);
-      pendingGuardWarnings.set(id, prior ? prior + "\n\n" + text : text);
-    };
     let gauntletCache: ReturnType<typeof loadGauntletSettings> | undefined;
     const g = () => {
       if (!gauntletCache) {
@@ -706,6 +740,18 @@ export default function (pi: ExtensionAPI) {
       observeFixWave(event.details, event.isError, ctx);
       if (qualifiesAsClosureDispatch(event.details)) conformanceDispatched = true;
       observeCadence(event.details);
+      if (
+        !isSubagentChild &&
+        gauntletEntered &&
+        phases.verify.status === "in_progress" &&
+        isImplementerWave(event.details, event.isError)
+      ) {
+        const loaded = loadGauntletSettings(ctx.cwd);
+        if (loaded.errors.length === 0 && resolveFlowGuards(loaded.gauntlet).enforce) {
+          const open = unfinishedTaskLines(latestPlanSnapshot(ctx));
+          if (open.length) addGuardWarning(event.toolCallId, openTaskNudge(open));
+        }
+      }
       const warning = pendingGuardWarnings.get(event.toolCallId);
       if (warning) {
         pendingGuardWarnings.delete(event.toolCallId);
@@ -989,26 +1035,7 @@ export default function (pi: ExtensionAPI) {
             (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})`]
-                : [],
-            );
+            const unfinished = unfinishedTaskLines(latestPlanSnapshot(ctx));
             if (unfinished.length) {
               return {
                 content: [

package/extensions/test-support/pi-stubs.mjs

@@ -6,13 +6,16 @@ const sources = {
     import { readFileSync } from "node:fs";
     export class SettingsManager {
       static create(cwd) { return new SettingsManager(cwd); }
-      constructor(cwd) { this.cwd = cwd; }
+      constructor(cwd) { this.cwd = cwd; this.errors = []; }
       getGlobalSettings() { return {}; }
       getProjectSettings() {
         try { return JSON.parse(readFileSync(this.cwd + "/.pi/settings.json", "utf8")); }
-        catch { return {}; }
+        catch (error) {
+          if (error?.code !== "ENOENT") this.errors.push({ scope: "project", error });
+          return {};
+        }
       }
-      drainErrors() { return []; }
+      drainErrors() { const drained = this.errors; this.errors = []; return drained; }
     }
     export const getAgentDir = () => "/tmp/pi-gauntlet-test-agent";
   `,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "7.0.2",
+  "version": "7.0.3",
   "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

@@ -146,9 +146,11 @@ Follow [User Review Gate](reference/spec-finalization.md#user-review-gate) for s
 
 Execute in place from any later phase; never invoke `/skill:brainstorming` for it (its entry resets both trackers). Worktree, spec commits, and plan survive.
 
+Every skill resource in this flow (a `SKILL.md` or a `reference/*.md`) is loaded with the `read` tool at its absolute path under `skills/`, never with a shell command - pruning protection keys on `read`'s `path`.
+
 Classify first. Redraw test: the change alters the problem statement, adds or removes a component, or moves a component boundary -> redraw. A change inside one component (a persistence mechanism, a worker's HTTP client, dropping a fallback and its task) -> amend. State the call; the user overrides either way.
 
-Amend -> load `reference/amendment-surface.md` and follow it (unreadable -> stop with a blocking error; never improvise the grammar). Apply its [Standing grants](reference/amendment-surface.md#standing-grants) boundaries.
+Amend -> `read` `reference/amendment-surface.md` and follow it (unreadable -> stop with a blocking error; never improvise the grammar). Apply its [Standing grants](reference/amendment-surface.md#standing-grants) boundaries.
 
 Redraw: keep the worktree and the approved spec file. `plan_tracker({ action: "clear" })`, `phase_tracker({ action: "reset" })`, `phase_tracker({ action: "start", phase: "brainstorm" })`, delete the plan file, resume at checklist step 4 with the approved spec as the draft (steps 2-3 skipped). Spec-writing overwrites it; the full gate follows.
 

package/skills/brainstorming/reference/amendment-surface.md

@@ -1,6 +1,6 @@
 # Amendment surface
 
-Load from `skills/brainstorming/SKILL.md` § Amending an approved spec, from any phase, for amend-class changes; at approval, load only [Standing grants](#standing-grants), not the batch procedure. Keep redraws outside this procedure. Only the main loop holding `edit`/`write` authors amendments and human-facing amendment text. Use the human last: a fresh reviewer clears evidence-backed factual corrections; present the rest to the human once per batch plainly.
+`read` this file (the `read` tool at its absolute path, never a shell command) from `skills/brainstorming/SKILL.md` § Amending an approved spec, from any phase, for amend-class changes; at approval, load only [Standing grants](#standing-grants), not the batch procedure. Keep redraws outside this procedure. Only the main loop holding `edit`/`write` authors amendments and human-facing amendment text. Use the human last: a fresh reviewer clears evidence-backed factual corrections; present the rest to the human once per batch plainly.
 
 ## Standing grants
 
@@ -77,7 +77,7 @@ Fail closed: a dispatch error, an async handle, a silence-kill, or a missing or
 Render only escalated and prefiltered items; `<N>` counts them. Nothing symbol-dense above the fold; each item's `old -> new` sits under `Details`, after the footer.
 
 ```
-Spec amendments: <N> need your call - from <trigger>; applying as recommended <reopens | adds | removes> <task ids | no tasks>; <phase consequence | no phase change>.
+Spec amendments: <N> need your call - from <trigger>; applying as recommended <reopens | adds | removes> <task ids | no tasks>; no phase change.
 
 * <handle> - <title>: <what>. <why>.
   Example: <before -> after>
@@ -93,7 +93,7 @@ Details
 <handle>: <location> - old: <text> -> new: <text>
 ```
 
-`<trigger>` is the step the main loop is running when the batch forms: `the spec review`, `planning Task <n>`, `Task <n> BLOCKED`, `the verify-phase code review (FIX_FIRST <ids>)`, `the finish-gate council-edit revert`, else `the <phase> phase`; `your request` only for an amend the user raised in prose. The plan clause is the section 5 aftermath as `recommended` would land, over reviewer-cleared plus rendered items, read from the plan file and tracker state - call no `plan_tracker`/`phase_tracker` before the reply: any of `reopens <ids>`, `adds <n> task(s)`, `removes <ids>`, comma-joined (`reopens no tasks` when the plan is untouched), then `; restarts implement, then verify` when a reopen lands in `verify`/`ship`, else `; no phase change`.
+`<trigger>` is the step the main loop is running when the batch forms: `the spec review`, `planning Task <n>`, `Task <n> BLOCKED`, `the verify-phase code review (FIX_FIRST <ids>)`, `the finish-gate council-edit revert`, else `the <phase> phase`; `your request` only for an amend the user raised in prose. The plan clause is the section 5 aftermath as `recommended` would land, over reviewer-cleared plus rendered items, read from the plan file and tracker state - call no `plan_tracker`/`phase_tracker` before the reply: any of `reopens <ids>`, `adds <n> task(s)`, `removes <ids>`, comma-joined (`reopens no tasks` when the plan is untouched), then `; no phase change`.
 
 `Reviewer:` quotes the `<one-line reason>` of the section 3 reply verbatim; the `probed:` half stays in the commit body; a prefiltered item carries `not reviewed - <the rule that prefiltered it>`. `Impact:` restates the design-contract shift from `location` in the reader's words, never quoted spec text, one clause per touched decision, `;`-joined; `(none) -> <new>` for a contract added, `<old> -> (removed)` for a contract removed. `Details` keeps the verbatim `old -> new`.
 
@@ -101,9 +101,11 @@ Details
 
 ## 5. Apply, aftermath, commit
 
+Before the aftermath, `read` this section again; never run it from memory.
+
 Apply accepted items only: reviewer clears, `accept`, `alt-n`, and state-changing `custom`. Print one line per applied item: `amended the spec: <title> - <what>`.
 
-Aftermath, once per batch, only when at least one item applied (nothing applied -> skip to the commit below). No plan yet -> commit the spec; continue. Plan exists -> update affected anchors and tasks: `plan_tracker` `add` for new tasks; anchor-changed completed tasks are reopened as `in_progress` and re-run the task loop (`update` never sets `pending`). A removed task is deleted from the plan; then re-`init` the tracker with `{ name, status }` elements: preserved tasks keep their order and statuses, reopened tasks are `in_progress` in place, every still-`pending` task (including newly added ones, whatever wave label they carry) trails the non-pending ones, removed tasks are the only deletions (the only permitted `init` after handoff; never `clear`). Re-run `plan_check` until it passes, commit spec + plan together; continue. A task reopened while `verify` or `ship` is in progress: `phase_tracker({ action: "skip", phase: "<current>", reason: "amendment reopened Task N" })`, then `phase_tracker({ action: "start", phase: "implement", force: true })`; later phases re-enter with `force: true` and rerun in full.
+Aftermath, once per batch, only when at least one item applied (nothing applied -> skip to the commit below). No plan yet -> commit the spec; continue. Plan exists -> update affected anchors and tasks: `plan_tracker` `add` for new tasks; anchor-changed completed tasks are reopened as `in_progress` and re-run the task loop (`update` never sets `pending`). A removed task is deleted from the plan; then re-`init` the tracker with `{ name, status }` elements: preserved tasks keep their order and statuses, reopened tasks are `in_progress` in place, every still-`pending` task (including newly added ones, whatever wave label they carry) trails the non-pending ones, removed tasks are the only deletions (the only permitted `init` after handoff; never `clear`). Re-run `plan_check` until it passes, commit spec + plan together; continue. A task reopened while `verify` or `ship` is in progress stays in that phase - no `phase_tracker` call. Repair it through the current phase's fix loop and `plan_tracker({ action: "update", index: N, status: "complete" })` it once that repair's review or re-audit accepts; open tasks block `complete verify`, and in `ship` nothing checks them, so close them explicitly.
 
 One commit per batch:
 

package/skills/finishing-a-development-branch/SKILL.md

@@ -94,7 +94,7 @@ then continue directly to Step 4. No approval prompt, no menu, no shared options
 
 When the sentinel carries a `happy-path:` line, print it directly under `Closure / conformance: CONFORMS` as one informational, non-blocking line in the same shape as the `auto-applied fix commits` line: `happy-path: passed`, `happy-path: failed - unattributable`, or `happy-path: not run - <reason>` (a `failed - attributed to G<n>` value cannot reach this branch: its gaps are open).
 
-**Pre-menu amendment funnel (GAPS only).** Before rendering the carried-open menu, run [`amendment-surface.md` § Conformance entry](../brainstorming/reference/amendment-surface.md) over the inventory once: gaps with `recommended: accept`, verdict `DRIFTED` or `PARTIAL`, not `UNAUTHORIZED`, whose `origin` is not an acceptance criterion are drafted as `accept-into-spec` items (the edit built from `origin` + `evidence`) and sent to the reviewer in one call; cleared items apply and land as one batch commit, the spec is re-audited, the inventory regenerated. Only concerns the re-audit actually closed drop out; sibling concerns in the same gap keep their rows and dispositions. Survivors and every other gap render as ordinary rows below - one menu, never two.
+**Pre-menu amendment funnel (GAPS only).** Before rendering the carried-open menu, `read` and run [`amendment-surface.md` § Conformance entry](../brainstorming/reference/amendment-surface.md) over the inventory once: gaps with `recommended: accept`, verdict `DRIFTED` or `PARTIAL`, not `UNAUTHORIZED`, whose `origin` is not an acceptance criterion are drafted as `accept-into-spec` items (the edit built from `origin` + `evidence`) and sent to the reviewer in one call; cleared items apply and land as one batch commit, the spec is re-audited, the inventory regenerated. Only concerns the re-audit actually closed drop out; sibling concerns in the same gap keep their rows and dispositions. Survivors and every other gap render as ordinary rows below - one menu, never two.
 
 **Carried-open (`status: GAPS (N open)`).** Read `reference/disposition-protocol.md` and follow it for the carried-open render (dense) grammar, the response grammar, and the 9-step execute order. Render the human decision menu in the shape below, with the sentinel's `happy-path:` line (when present) printed as one informational line directly under the `Conformance: N decisions needed before shipping.` header - a `failed - attributed to G<n>,...` value names the rows whose evidence is the transcript, a `rescope` recommendation on such a row means the failure lies in code the change never owned - drive the dispositions per that reference, then print the summary render and continue to Step 4. If that reference file cannot be read, stop and surface a blocking error — do **not** improvise the grammar from memory.
 

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

@@ -65,7 +65,7 @@ For each task in `plan_tracker`:
 6. If the quality review is issue-bearing → re-dispatch the implementer per `/skill:requesting-code-review` Fix rounds → re-review. Loop until ✅, within [Fix-Loop Rounds](#fix-loop-rounds).
 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 orchestrator is the spec's only writer during execution. Amendment trigger: implementer `BLOCKED` citing a spec defect, or a review finding showing the spec (not the code) is wrong -> pause the fix loop, execute brainstorming's [amendment path](../brainstorming/SKILL.md#amending-an-approved-spec) in place (it reviews first, stops only on escalation or redraw), resume. Code-vs-spec mismatch stays in the SR loop. 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.
+The orchestrator is the spec's only writer during execution. Amendment trigger: implementer `BLOCKED` citing a spec defect, or a review finding showing the spec (not the code) is wrong -> pause the fix loop, `read` and execute brainstorming's [amendment path](../brainstorming/SKILL.md#amending-an-approved-spec) in place (it reviews first, stops only on escalation or redraw), resume. Code-vs-spec mismatch stays in the SR loop. 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 parent full verification, then whole-diff code review, then conformance.