pi-gauntlet 7.43.1 → 8.0.1

package/extensions/phase-tracker.test.ts

@@ -685,20 +685,31 @@ const commitResult = (id: string) => ({
   content: [{ type: "text", text: "ok" }],
 });
 
-test("implement-phase commit with implementer newer than both reviewers warns", async () => {
-  const priorDepth = process.env.PI_SUBAGENT_DEPTH;
-  delete process.env.PI_SUBAGENT_DEPTH; // isolate from an ambient subagent depth in the test-runner's own process
-  try {
-    const h = harness({ branch: implementBranch([subagentResult(["implementer"])]) });
-    await h.emit("session_start");
-    await h.emitEvent("tool_call", commitCall("c1"));
-    const warned = (await h.emitEvent("tool_result", commitResult("c1")))[0] as { content: { text: string }[] };
-    assert.match(warned.content[0].text, /no spec-reviewer or code-reviewer observed/);
-  } finally {
-    if (priorDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
-    else process.env.PI_SUBAGENT_DEPTH = priorDepth;
+for (const path of ["README.md", "extensions/example.ts"]) {
+  for (const [name, agents, warns] of [
+    ["missing review", ["implementer"], true],
+    ["stale review", ["wave-reviewer", "implementer"], true],
+    ["newer review", ["implementer", "wave-reviewer"], false],
+  ] as const) {
+    test(`cadence for ${path}: ${name}`, async () => {
+        const priorDepth = process.env.PI_SUBAGENT_DEPTH;
+        delete process.env.PI_SUBAGENT_DEPTH; // isolate from an ambient subagent depth in the test-runner's own process
+        try {
+          const h = harness({ branch: implementBranch(agents.map((agent) => subagentResult([agent]))) });
+          await h.emit("session_start");
+          const call = commitCall("c1");
+          call.input.command = `git commit -m 'integrate wave' -- ${path}`;
+          await h.emitEvent("tool_call", call);
+          const warned = (await h.emitEvent("tool_result", commitResult("c1")))[0] as { content: { text: string }[] } | undefined;
+          assert.equal(warned !== undefined, warns);
+          if (warned) assert.match(warned.content[0].text, /no wave-reviewer observed/);
+        } finally {
+          if (priorDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+          else process.env.PI_SUBAGENT_DEPTH = priorDepth;
+        }
+    });
   }
-});
+}
 
 test("cadence guard silent in subagent children", async () => {
   const priorDepth = process.env.PI_SUBAGENT_DEPTH;
@@ -715,15 +726,14 @@ test("cadence guard silent in subagent children", async () => {
   }
 });
 
-test("fresh SR and CR after the implementer keep the commit silent", async () => {
+test("fresh wave review after the implementer keeps the commit silent", async () => {
   const priorDepth = process.env.PI_SUBAGENT_DEPTH;
   delete process.env.PI_SUBAGENT_DEPTH;
   try {
     const h = harness({
       branch: implementBranch([
         subagentResult(["implementer"]),
-        subagentResult(["spec-reviewer"]),
-        subagentResult(["code-reviewer"]),
+        subagentResult(["wave-reviewer"]),
       ]),
     });
     await h.emit("session_start");
@@ -734,12 +744,12 @@ test("fresh SR and CR after the implementer keep the commit silent", async () =>
   }
 });
 
-test("AND-logic: fresh SR with stale CR stays silent (doc-only wave shape)", async () => {
+test("fresh wave review stays silent for a doc-only wave", async () => {
   const priorDepth = process.env.PI_SUBAGENT_DEPTH;
   delete process.env.PI_SUBAGENT_DEPTH;
   try {
     const h = harness({
-      branch: implementBranch([subagentResult(["implementer"]), subagentResult(["spec-reviewer"])]),
+      branch: implementBranch([subagentResult(["implementer"]), subagentResult(["wave-reviewer"])]),
     });
     await h.emit("session_start");
     await h.emitEvent("tool_call", commitCall("c1"));
@@ -754,7 +764,7 @@ test("fused implementer+reviewer results in one dispatch stay silent", async ()
   delete process.env.PI_SUBAGENT_DEPTH;
   try {
     const h = harness({
-      branch: implementBranch([subagentResult(["implementer", "spec-reviewer", "code-reviewer"])]),
+      branch: implementBranch([subagentResult(["implementer", "wave-reviewer"])]),
     });
     await h.emit("session_start");
     await h.emitEvent("tool_call", commitCall("c1"));
@@ -815,7 +825,7 @@ test("live tool_result observation updates the ledger", async () => {
       toolName: "subagent",
       toolCallId: "s1",
       content: [],
-      details: { results: [{ agent: "spec-reviewer", exitCode: 0 }, { agent: "code-reviewer", exitCode: 0 }] },
+      details: { results: [{ agent: "wave-reviewer", exitCode: 0 }, { agent: "wave-reviewer", exitCode: 0 }] },
     });
     await h.emitEvent("tool_call", commitCall("c1"));
     assert.equal((await h.emitEvent("tool_result", commitResult("c1")))[0], undefined);
@@ -831,15 +841,14 @@ test("second implementer after reviews re-arms the warning", async () => {
     const h = harness({
       branch: implementBranch([
         subagentResult(["implementer"]),
-        subagentResult(["spec-reviewer"]),
-        subagentResult(["code-reviewer"]),
+        subagentResult(["wave-reviewer"]),
         subagentResult(["implementer"]),
       ]),
     });
     await h.emit("session_start");
     await h.emitEvent("tool_call", commitCall("c1"));
     const warned = (await h.emitEvent("tool_result", commitResult("c1")))[0] as { content: { text: string }[] };
-    assert.match(warned.content[0].text, /no spec-reviewer or code-reviewer observed/);
+    assert.match(warned.content[0].text, /no wave-reviewer observed/);
   } finally {
     if (priorDepth !== undefined) process.env.PI_SUBAGENT_DEPTH = priorDepth;
   }
@@ -1596,15 +1605,14 @@ for (const delivery of ["live", "session_start", "session_switch", "session_fork
     const implementer = { agent: "implementer", exitCode: 0 };
     for (const row of [
       { name: "interrupted implementer", results: [{ ...implementer, interrupted: true }], prior: false, warns: false },
-      { name: "interrupted SR", results: [{ agent: "spec-reviewer", exitCode: 0, interrupted: true }], prior: true, warns: true },
-      { name: "interrupted CR", results: [{ agent: "code-reviewer", exitCode: 0, interrupted: true }], prior: true, warns: true },
+      { name: "interrupted wave reviewer", results: [{ agent: "wave-reviewer", exitCode: 0, interrupted: true }], prior: true, warns: true },
       { name: "legacy implementer", results: [implementer], prior: false, warns: true },
-      { name: "explicit uninterrupted SR", results: [{ agent: "spec-reviewer", exitCode: 0, interrupted: false }], prior: true, warns: false },
-      { name: "failed reviewer", results: [{ agent: "code-reviewer", exitCode: 1 }], prior: true, warns: true },
+      { name: "explicit uninterrupted wave reviewer", results: [{ agent: "wave-reviewer", exitCode: 0, interrupted: false }], prior: true, warns: false },
+      { name: "failed reviewer", results: [{ agent: "wave-reviewer", exitCode: 1 }], prior: true, warns: true },
       { name: "wrong agent", results: [{ agent: "spec-reviewer-extra", exitCode: 0 }], prior: true, warns: true },
       { name: "empty async/management", results: [], prior: true, warns: true },
-      { name: "mixed parallel tie", results: [implementer, { agent: "spec-reviewer", exitCode: 0 }, { agent: "code-reviewer", exitCode: 0, interrupted: true }], prior: false, warns: false },
-      { name: "earlier review in errored chain", results: [{ agent: "code-reviewer", exitCode: 0 }, { ...implementer, interrupted: true }], prior: true, isError: true, warns: false },
+      { name: "mixed parallel tie", results: [implementer, { agent: "wave-reviewer", exitCode: 0 }, { agent: "wave-reviewer", exitCode: 0, interrupted: true }], prior: false, warns: false },
+      { name: "earlier review in errored chain", results: [{ agent: "wave-reviewer", exitCode: 0 }, { ...implementer, interrupted: true }], prior: true, isError: true, warns: false },
     ]) {
       const prior = row.prior ? [subagentResult(["implementer"])] : [];
       const result = waveResult("work", row.results, row.isError);
@@ -1618,7 +1626,7 @@ for (const delivery of ["live", "session_start", "session_switch", "session_fork
       await h.emitEvent("tool_call", commitCall("commit"));
       const [warning] = await h.emitEvent("tool_result", commitResult("commit")) as ({ content: { text: string }[] } | undefined)[];
       assert.equal(warning !== undefined, row.warns, row.name);
-      if (warning) assert.match(warning.content[0].text, /no spec-reviewer or code-reviewer observed/, row.name);
+      if (warning) assert.match(warning.content[0].text, /no wave-reviewer observed/, row.name);
     }
   });
 }
@@ -1722,7 +1730,7 @@ test("cap guard: non-implementer dispatches never blocked; enforce false passes
   const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
   await h.emit("session_start");
   assert.equal(await firstCallResult(h, "r1", { agent: "conformance-reviewer", task: "re-audit" }), undefined);
-  assert.equal(await firstCallResult(h, "r2", { agent: "code-reviewer", task: "review" }), undefined);
+  assert.equal(await firstCallResult(h, "r2", { agent: "wave-reviewer", task: "review" }), undefined);
 
   const off = guardedHarness({ piGauntlet: { closureReview: { enforce: false, maxFixRounds: 0 } } });
   await off.emit("session_start");
@@ -1735,7 +1743,7 @@ test("counter: blocked, errored, empty, non-implementer, and out-of-window resul
   await h.emit("session_start");
   await h.emitEvent("tool_result", waveResult("e1", [{ agent: "implementer", exitCode: 0 }], true));
   await h.emitEvent("tool_result", waveResult("e2", []));
-  await h.emitEvent("tool_result", waveResult("e3", [{ agent: "code-reviewer", exitCode: 0 }]));
+  await h.emitEvent("tool_result", waveResult("e3", [{ agent: "wave-reviewer", exitCode: 0 }]));
   const blockedLone = await firstCallResult(h, "b1", loneImplementer());
   assert.equal(blockedLone?.block, true);
   assert.equal(await firstCallResult(h, "c1", implementerWave(1)), undefined, "budget untouched");
@@ -1795,7 +1803,7 @@ test("counter reset: start implement and reset zero it; start verify --force kee
 test("replay: two implementer waves after the audit in verify restore fixRounds 2; the same waves in ship restore 0", async () => {
   const inVerify = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 2 } } }, [
     subagentResult(["implementer"]),
-    subagentResult(["implementer", "code-reviewer"]),
+    subagentResult(["implementer", "wave-reviewer"]),
   ]);
   await inVerify.emit("session_start");
   assert.equal((await firstCallResult(inVerify, "c1", implementerWave(1)))?.block, true);
@@ -1910,7 +1918,7 @@ test("grant: only qualifying synchronous parent task waves spend credits", async
   const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
   await h.emit("session_start");
   await grant(h, "g", { rounds: 1, reason: "ok" });
-  await h.emitEvent("tool_result", waveResult("e1", [{ agent: "code-reviewer", exitCode: 0 }]));
+  await h.emitEvent("tool_result", waveResult("e1", [{ agent: "wave-reviewer", exitCode: 0 }]));
   await h.emitEvent("tool_result", waveResult("e2", [{ agent: "implementer", exitCode: 0 }], true));
   await h.emitEvent("tool_result", waveResult("e3", []));
   assert.equal((await firstCallResult(h, "a", { ...implementerWave(1), async: true }))?.block, true);
@@ -2224,14 +2232,14 @@ for (const action of ["complete", "skip"] as const) {
       const h = harness({ hasUI: true });
       const tool = h.tools.find(t => t.name === "phase_tracker")!;
       await startPhase(h, "verify");
-      await h.emitEvent("tool_call", subagentCall("review", { agent: "code-reviewer" }));
+      await h.emitEvent("tool_call", subagentCall("review", { agent: "wave-reviewer" }));
       const result = await tool.execute("transition", { action, phase: "ship", reason: "not needed" }, undefined, undefined, h.ctx) as any;
       assert.equal(result.details.error, undefined);
-      assert.match(h.widgets.at(-1)!, /verify\(code-review\)/);
+      assert.match(h.widgets.at(-1)!, /verify\(wave-review\)/);
       await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "review", isError, details: {}, content: [] });
       assert.doesNotMatch(h.widgets.at(-1)!, /verify\(/);
-      await h.emitEvent("tool_call", subagentCall("next", { agent: "code-reviewer" }));
-      assert.ok(h.widgets.at(-1)!.includes(`verify(code-review${isError ? "" : " #2"})`));
+      await h.emitEvent("tool_call", subagentCall("next", { agent: "wave-reviewer" }));
+      assert.ok(h.widgets.at(-1)!.includes(`verify(wave-review${isError ? "" : " #2"})`));
     });
   }
 }
@@ -2256,17 +2264,17 @@ for (const isError of [false, true]) {
     const shipStart = startPhase(h, "ship");
     await modelEntered;
     await startPhase(h, "verify");
-    await h.emitEvent("tool_call", subagentCall("review", { agent: "code-reviewer" }));
+    await h.emitEvent("tool_call", subagentCall("review", { agent: "wave-reviewer" }));
     release();
     assert.equal((await shipStart).status, "in_progress");
-    assert.match(h.widgets.at(-1)!, /verify\(code-review\)/);
+    assert.match(h.widgets.at(-1)!, /verify\(wave-review\)/);
     await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "review", isError, details: {}, content: [] });
     assert.doesNotMatch(h.widgets.at(-1)!, /verify\(/);
     const tool = h.tools.find(t => t.name === "phase_tracker")!;
     const status = await tool.execute("status", { action: "status" }, undefined, undefined, h.ctx) as any;
     assert.equal(status.details.phases.ship.status, "in_progress");
-    await h.emitEvent("tool_call", subagentCall("next", { agent: "code-reviewer" }));
-    assert.ok(h.widgets.at(-1)!.includes(`verify(code-review${isError ? "" : " #2"})`));
+    await h.emitEvent("tool_call", subagentCall("next", { agent: "wave-reviewer" }));
+    assert.ok(h.widgets.at(-1)!.includes(`verify(wave-review${isError ? "" : " #2"})`));
   });
 }
 
@@ -2292,10 +2300,9 @@ test("live dispatch labels repaint and keep ordinals out of status snapshots", a
 });
 
 for (const row of [
-  { phase: "implement", input: { chain: [{ parallel: [{ agent: "implementer" }] }, { parallel: [{ agent: "spec-reviewer" }] }] }, label: "implement+sr" },
-  { phase: "implement", input: { agent: "code-reviewer" }, label: "code-review" },
+  { phase: "implement", input: { chain: [{ parallel: [{ agent: "implementer" }] }, { parallel: [{ agent: "wave-reviewer" }] }] }, label: "implement" },
   { phase: "implement", input: { agent: "implementer" }, label: "implement" },
-  { phase: "implement", input: { agent: "spec-reviewer" }, label: "spec-review" },
+  { phase: "implement", input: { agent: "wave-reviewer" }, label: "wave-review" },
   { phase: "plan", toolName: "plan_check", input: {}, label: "plan-check" },
   { phase: "verify", toolName: "plan_check", input: {}, label: "plan-check" },
 ]) {
@@ -2317,15 +2324,15 @@ for (const row of [
 }
 
 for (const agents of [
-  ["code-reviewer", "implementer", "code-reviewer", "conformance-reviewer"],
-  ["conformance-reviewer", "implementer", "conformance-reviewer", "code-reviewer", "code-reviewer", "code-reviewer"],
+  ["wave-reviewer", "implementer", "wave-reviewer", "conformance-reviewer"],
+  ["conformance-reviewer", "implementer", "conformance-reviewer", "wave-reviewer", "wave-reviewer", "wave-reviewer"],
 ]) {
   test(`live repair sequence: ${agents.join(" -> ")}`, async () => {
     const h = harness({ hasUI: true });
     await startPhase(h, "verify");
     const counts: Record<string, number> = {};
     for (const [i, agent] of agents.entries()) {
-      const label = ({ "code-reviewer": "code-review", implementer: "implement", "conformance-reviewer": "conformance" })[agent]!;
+      const label = ({ "wave-reviewer": "wave-review", implementer: "implement", "conformance-reviewer": "conformance" })[agent]!;
       const n = counts[label] = (counts[label] ?? 0) + 1;
       await h.emitEvent("tool_call", subagentCall(String(i), { tasks: [{ agent }] }));
       assert.ok(h.widgets.at(-1)!.includes(`verify(${label}${n > 1 ? ` #${n}` : ""})`));
@@ -2343,7 +2350,7 @@ for (const row of [
     test(`live terminal: ${row.name}, execution-end-only=${endOnly}`, async () => {
       const h = harness({ hasUI: true });
       await startPhase(h, "verify");
-      await h.emitEvent("tool_call", subagentCall("a", { agent: "code-reviewer" }));
+      await h.emitEvent("tool_call", subagentCall("a", { agent: "wave-reviewer" }));
       const paints = h.widgets.length;
       await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "other", details: {}, content: [] });
       assert.equal(h.widgets.length, paints);
@@ -2354,8 +2361,8 @@ for (const row of [
       assert.doesNotMatch(h.widgets.at(-1)!, /verify\(/);
       await h.emitEvent("tool_execution_end", { ...terminal, result: { details: row.details } });
       assert.equal(h.widgets.length, paints + 1);
-      await h.emitEvent("tool_call", subagentCall("b", { agent: "code-reviewer" }));
-      assert.ok(h.widgets.at(-1)!.includes(`verify(code-review${row.refund ? "" : " #2"})`));
+      await h.emitEvent("tool_call", subagentCall("b", { agent: "wave-reviewer" }));
+      assert.ok(h.widgets.at(-1)!.includes(`verify(wave-review${row.refund ? "" : " #2"})`));
     });
   }
 }
@@ -2366,20 +2373,20 @@ test("live overlap forgets older calls and explicit overwrite survives cleanup",
   const tool = h.tools.find(t => t.name === "phase_tracker")!;
   const explicit = (substep: string) => tool.execute("explicit", { action: "substep", phase: "verify", substep }, undefined, undefined, h.ctx);
   await explicit("before");
-  for (const id of ["a", "b"]) await h.emitEvent("tool_call", subagentCall(id, { agent: "code-reviewer", async: true }));
-  assert.match(h.widgets.at(-1)!, /verify\(code-review #2\)/);
+  for (const id of ["a", "b"]) await h.emitEvent("tool_call", subagentCall(id, { agent: "wave-reviewer", async: true }));
+  assert.match(h.widgets.at(-1)!, /verify\(wave-review #2\)/);
   const paints = h.widgets.length;
   await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "a", details: {}, content: [] });
   assert.equal(h.widgets.length, paints);
   await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "b", details: {}, content: [] });
   assert.doesNotMatch(h.widgets.at(-1)!, /verify\(/);
-  await h.emitEvent("tool_call", subagentCall("c", { agent: "code-reviewer" }));
+  await h.emitEvent("tool_call", subagentCall("c", { agent: "wave-reviewer" }));
   const snapshot = await explicit("custom") as any;
   await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "c", isError: true, details: {}, content: [] });
   assert.match(h.widgets.at(-1)!, /verify\(custom\)/);
   assert.equal(snapshot.details.phases.verify.substep, "custom");
-  await h.emitEvent("tool_call", subagentCall("d", { agent: "code-reviewer" }));
-  assert.match(h.widgets.at(-1)!, /verify\(code-review #3\)/);
+  await h.emitEvent("tool_call", subagentCall("d", { agent: "wave-reviewer" }));
+  assert.match(h.widgets.at(-1)!, /verify\(wave-review #3\)/);
 });
 
 for (const action of ["start", "complete", "skip", "reset"]) {
@@ -2387,10 +2394,10 @@ for (const action of ["start", "complete", "skip", "reset"]) {
     const h = harness({ hasUI: true });
     const tool = h.tools.find(t => t.name === "phase_tracker")!;
     await startPhase(h, "verify");
-    await h.emitEvent("tool_call", subagentCall("old", { agent: "code-reviewer" }));
+    await h.emitEvent("tool_call", subagentCall("old", { agent: "wave-reviewer" }));
     const rejected = await tool.execute("bad", { action: "start", phase: "plan" }, undefined, undefined, h.ctx) as any;
     assert.ok(rejected.details.error);
-    assert.match(h.widgets.at(-1)!, /verify\(code-review\)/);
+    assert.match(h.widgets.at(-1)!, /verify\(wave-review\)/);
     await tool.execute("transition", { action, phase: "verify", reason: "test" }, undefined, undefined, h.ctx);
     if (action === "reset") assert.equal(h.widgets.at(-1), undefined);
     if (action !== "start") await tool.execute("restart", { action: "start", phase: "verify", force: true }, undefined, undefined, h.ctx);
@@ -2399,18 +2406,18 @@ for (const action of ["start", "complete", "skip", "reset"]) {
     await h.emitEvent("tool_execution_end", { toolName: "subagent", toolCallId: "old", result: { details: {} } });
     assert.equal(h.widgets.length, paints);
     assert.match(h.widgets.at(-1)!, /verify\(custom\)/);
-    await h.emitEvent("tool_call", subagentCall("new", { agent: "code-reviewer" }));
-    assert.match(h.widgets.at(-1)!, /verify\(code-review\)/);
+    await h.emitEvent("tool_call", subagentCall("new", { agent: "wave-reviewer" }));
+    assert.match(h.widgets.at(-1)!, /verify\(wave-review\)/);
   });
 }
 
 test("live plan backstop clears ownership only on actual implement completion", async () => {
   const h = harness({ hasUI: true });
   await startPhase(h, "implement");
-  await h.emitEvent("tool_call", subagentCall("old", { agent: "code-reviewer" }));
+  await h.emitEvent("tool_call", subagentCall("old", { agent: "wave-reviewer" }));
   for (const tasks of [undefined, [{ status: "in_progress" }]]) {
     await h.emitEvent("tool_execution_end", { toolName: "plan_tracker", result: { details: { tasks } } });
-    assert.match(h.widgets.at(-1)!, /implement\(code-review\)/);
+    assert.match(h.widgets.at(-1)!, /implement\(wave-review\)/);
   }
   await h.emitEvent("tool_execution_end", { toolName: "plan_tracker", result: { details: { tasks: [{ status: "complete" }] } } });
   await startPhase(h, "verify");
@@ -2418,8 +2425,8 @@ test("live plan backstop clears ownership only on actual implement completion",
   await tool.execute("label", { action: "substep", phase: "verify", substep: "custom" }, undefined, undefined, h.ctx);
   await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "old", details: {}, content: [] });
   assert.match(h.widgets.at(-1)!, /verify\(custom\)/);
-  await h.emitEvent("tool_call", subagentCall("new", { agent: "code-reviewer" }));
-  assert.match(h.widgets.at(-1)!, /verify\(code-review\)/);
+  await h.emitEvent("tool_call", subagentCall("new", { agent: "wave-reviewer" }));
+  assert.match(h.widgets.at(-1)!, /verify\(wave-review\)/);
 });
 
 test("live observation is dormant without a phase and in a subagent child", async () => {
@@ -2509,7 +2516,7 @@ for (const row of [
     if (status.details.phases[row.phase].status !== "in_progress") await startPhase(h, row.phase);
     const restarted = await tool.execute("status", { action: "status" }, undefined, undefined, h.ctx) as any;
     assert.equal(restarted.details.phases[row.phase].substep, row.expected);
-    await h.emitEvent("tool_call", subagentCall("new", { agent: "code-reviewer" }));
+    await h.emitEvent("tool_call", subagentCall("new", { agent: "wave-reviewer" }));
     await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "new", details: {}, content: [] });
     assert.deepEqual(row.branch, original);
   });
@@ -2521,11 +2528,11 @@ for (const event of ["session_start", "session_switch", "session_fork", "session
       const h = harness({ hasUI: true });
       const tool = h.tools.find(t => t.name === "phase_tracker")!;
       await startPhase(h, "verify");
-      await h.emitEvent("tool_call", subagentCall("first", { agent: "code-reviewer" }));
+      await h.emitEvent("tool_call", subagentCall("first", { agent: "wave-reviewer" }));
       await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "first", details: {}, content: [] });
-      await h.emitEvent("tool_call", subagentCall("old", { agent: "code-reviewer" }));
-      assert.match(h.widgets.at(-1)!, /verify\(code-review #2\)/);
-      const branch = kind === "empty" ? [assistant()] : kind === "explicit" ? explicitReplay("verify", "custom") : [phaseResult("start", replaySnapshot("verify")), phaseResult("status", replaySnapshot("verify", "code-review"))];
+      await h.emitEvent("tool_call", subagentCall("old", { agent: "wave-reviewer" }));
+      assert.match(h.widgets.at(-1)!, /verify\(wave-review #2\)/);
+      const branch = kind === "empty" ? [assistant()] : kind === "explicit" ? explicitReplay("verify", "custom") : [phaseResult("start", replaySnapshot("verify")), phaseResult("status", replaySnapshot("verify", "wave-review"))];
       const original = structuredClone(branch);
       h.setBranch(branch);
       await h.emit(event);
@@ -2540,11 +2547,11 @@ for (const event of ["session_start", "session_switch", "session_fork", "session
       await h.emitEvent("tool_execution_end", { toolName: "subagent", toolCallId: "old", result: { details: {} } });
       assert.equal(h.widgets.length, paints);
       if (kind === "empty") await startPhase(h, "verify");
-      await h.emitEvent("tool_call", subagentCall("next", { agent: "code-reviewer" }));
-      assert.match(h.widgets.at(-1)!, /verify\(code-review\)/);
+      await h.emitEvent("tool_call", subagentCall("next", { agent: "wave-reviewer" }));
+      assert.match(h.widgets.at(-1)!, /verify\(wave-review\)/);
       await h.emitEvent("tool_result", { toolName: "subagent", toolCallId: "next", details: {}, content: [] });
-      await h.emitEvent("tool_call", subagentCall("again", { agent: "code-reviewer" }));
-      assert.match(h.widgets.at(-1)!, /verify\(code-review #2\)/);
+      await h.emitEvent("tool_call", subagentCall("again", { agent: "wave-reviewer" }));
+      assert.match(h.widgets.at(-1)!, /verify\(wave-review #2\)/);
       assert.deepEqual(branch, original);
     });
   }

package/extensions/phase-tracker.ts

@@ -133,10 +133,10 @@ const unfinishedTaskLines = (tasks: Task[]): string[] =>
   );
 
 // 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
-// number, so a fused implementer+reviewer result never reads as reviewer-stale.
-const CADENCE_AGENTS = ["implementer", "spec-reviewer", "code-reviewer"] as const;
+// advisory ledger of the most recent completed implementer / wave-reviewer dispatch.
+// Agents completing in the SAME dispatch share a sequence number, so a fused
+// implementer+reviewer result never reads as reviewer-stale.
+const CADENCE_AGENTS = ["implementer", "wave-reviewer"] as const;
 type CadenceAgent = (typeof CADENCE_AGENTS)[number];
 
 const completedCadenceAgents = (details: unknown): CadenceAgent[] => {
@@ -152,9 +152,9 @@ const completedCadenceAgents = (details: unknown): CadenceAgent[] => {
 };
 
 const REVIEW_CADENCE_WARNING =
-  "⚠️ Reminder: no spec-reviewer or code-reviewer observed since the last implementer.\n" +
-  "SR is required per task; CR per wave for code waves (doc-only waves are SR-only).\n" +
-  "Dispatch the missing review(s) before committing integrated work.";
+  "Reminder: no wave-reviewer observed since the last implementer.\n" +
+  "One wave-reviewer is required per wave, for both code and documentation.\n" +
+  "Dispatch the missing wave review before committing integrated work.";
 
 const CLOSURE_GATE_ERROR =
   "Error: cannot complete 'verify': no conformance-reviewer dispatch observed.\n" +
@@ -476,8 +476,7 @@ export default function (pi: ExtensionAPI) {
   let cadenceSeq = 0;
   const cadenceLastSeen: Record<CadenceAgent, number> = {
     implementer: 0,
-    "spec-reviewer": 0,
-    "code-reviewer": 0,
+    "wave-reviewer": 0,
   };
   const observeCadence = (details: unknown) => {
     const agents = completedCadenceAgents(details);
@@ -550,8 +549,7 @@ export default function (pi: ExtensionAPI) {
     pendingGuardWarnings.clear();
     cadenceSeq = 0;
     cadenceLastSeen.implementer = 0;
-    cadenceLastSeen["spec-reviewer"] = 0;
-    cadenceLastSeen["code-reviewer"] = 0;
+    cadenceLastSeen["wave-reviewer"] = 0;
     for (const entry of ctx.sessionManager.getBranch()) {
       if (entry.type === "custom_message") {
         if (entry.customType === RECOVERY_CUSTOM_TYPE) {
@@ -813,8 +811,7 @@ export default function (pi: ExtensionAPI) {
       phases.implement.status === "in_progress" &&
       parseGitCommit(command) &&
       cadenceLastSeen.implementer > 0 &&
-      cadenceLastSeen.implementer > cadenceLastSeen["spec-reviewer"] &&
-      cadenceLastSeen.implementer > cadenceLastSeen["code-reviewer"]
+      cadenceLastSeen.implementer > cadenceLastSeen["wave-reviewer"]
     ) {
       warnings.push(REVIEW_CADENCE_WARNING);
     }

package/extensions/telemetry.test.ts

@@ -755,8 +755,8 @@
       { agent: "implementer", exitCode: 0, model: "p/impl:high", usage: usage(100, 10, 1) },
       { agent: "implementer", exitCode: 1, model: "p/impl:high", usage: usage(50, 5, 0.5) },
       { agent: "spec-summarizer", exitCode: 0, model: "p/s", usage: usage(1) },
-      { agent: "code-reviewer", exitCode: 0, model: "p/r", usage: usage(1) },
-    ], "- [major] a\n- [minor] b\n- [minor] c"));
+      { agent: "wave-reviewer", exitCode: 0, model: "p/r", usage: usage(1) },
+    ], `## Outputs\n### review\n\`\`\`json\n{"structured":{"findings":{"critical":0,"moderate":1,"minor":2}}}\n\`\`\`\nOutput saved to: /tmp/review.md\n[major] duplicate [minor] duplicate`));
     await h.emit("tool_result", subagentResult([]));
     const rec = h.readRecord();
     const dispatches = rec.events.filter((e) => e.kind === "dispatch") as any[];
@@ -765,13 +765,19 @@
     assert.equal(dispatches[1].exit, 1);
     assert.deepEqual(rec.derived.personas.implementer, { dispatches: 2, models: ["p/impl:high"], tokens: { input: 150, output: 15, cache_read: 0, cache_write: 0, cost: 1.5 } });
     assert.equal(rec.derived.gates.spec_rounds, 1);
-    assert.deepEqual(rec.derived.reviews?.["code-reviewer"], { dispatches: 1, nonzero_exit: 0, findings: { blocker: 0, major: 1, minor: 2 } });
+    assert.deepEqual(rec.derived.reviews?.["wave-reviewer"], { dispatches: 1, nonzero_exit: 0, findings: { blocker: 0, major: 1, minor: 2 } });
     assert.equal(rec.derived.conformance_loops, 0);
     assert.deepEqual(rec.derived.phases.plan?.tokens, { input: 152, output: 15, cache_read: 0, cache_write: 0, cost: 1.5 });
   });
 
+  test("zero structured findings do not fall back to inline severity tags", async () => {
+    const h = await boundInPlan();
+    await h.emit("tool_result", subagentResult([{ agent: "wave-reviewer", exitCode: 0 }], '## Outputs\n### Step 1\n#### Task 1 (wave-reviewer)\n```json\n{"structured":{"findings":{"critical":0,"moderate":0,"minor":0}}}\n```\nOutput saved to: /tmp/review.md\n[Critical] duplicate'));
+    assert.deepEqual(h.readRecord().derived.reviews?.["wave-reviewer"]?.findings, { blocker: 0, major: 0, minor: 0 });
+  });
+
   for (const [name, agents] of [
-    ["chain", ["implementer", "spec-reviewer", "spec-reviewer"]],
+    ["chain", ["implementer", "wave-reviewer", "wave-reviewer"]],
     ["plain tasks", ["implementer", "implementer"]],
     ["empty results", []],
     ["missing results", undefined],
@@ -798,7 +804,7 @@
         const retained = results!.filter((r) => r.agent === agent);
         assert.deepEqual(rec.derived.personas[agent], { dispatches: retained.length, models: retained.map((r) => r.model), tokens: { input: 10 * retained.length, output: 2 * retained.length, cache_read: 0, cache_write: 0, cost: 0.5 * retained.length } });
       }
-      if (name === "chain") assert.deepEqual(rec.derived.reviews?.["spec-reviewer"], { dispatches: 2, nonzero_exit: 1 });
+      if (name === "chain") assert.deepEqual(rec.derived.reviews?.["wave-reviewer"], { dispatches: 2, nonzero_exit: 1 });
       if (results?.length) assert.deepEqual(rec.derived.phases.implement?.tokens, { input: 10 * results.length, output: 2 * results.length, cache_read: 0, cache_write: 0, cost: 0.5 * results.length });
       else assert.deepEqual(rec, before);
       assert.deepEqual(rec.events.filter((e) => e.kind === "phase" || e.kind === "gate"), before.events.filter((e) => e.kind === "phase" || e.kind === "gate"));

package/extensions/telemetry.ts

@@ -21,7 +21,7 @@
   import { sha256 } from "./lib/plan-check.ts";
   import { SUPERSEDED_BY_RE, isPlanPath, isSpecPath, isSupersededByBanner, matchTestStatement, parseSpecLinks, planSpecHeader, recordPathFor, repoRelativeToolPath, toPosix, truncateCommand } from "./lib/telemetry-paths.ts";
   import { computeJjDiff } from "./lib/telemetry-diff.ts";
-  import { COUNTED_USER_PHASES, REVIEWER_AGENTS, countFindings, countOpenGaps, hasReopen, insertedText, planTotals, textOf, usageToTokens } from "./lib/telemetry-collect.ts";
+  import { COUNTED_USER_PHASES, REVIEWER_AGENTS, countFindings, countStructuredFindings, countOpenGaps, hasReopen, insertedText, planTotals, textOf, usageToTokens } from "./lib/telemetry-collect.ts";
   import { addTokens, capEvents, compact, currentPhase, derive, diffPhases, emptyAccumulators, emptyPhases, foldAccumulators, implementAutoCompletes, liveShipEvent, newRecord, parseRecord, serializeRecord, type Accumulators, type BaseEvent, type PhaseAcc, type PhaseKey, type PhaseMap, type TelemetryEvent, type TelemetryRecord, type Tokens } from "./lib/telemetry-record.ts";
   import { guardReason } from "./lib/telemetry-ship.ts";
   import { buildCouncil, parseAudit, parseChairReport, resolveMembers, type Cluster, type MemberResult } from "./lib/telemetry-council.ts";
@@ -704,7 +704,7 @@
           const review = (acc.reviews[agent] ??= { dispatches: 0, nonzero_exit: 0 });
           review.dispatches += 1;
           if (exit !== undefined && exit !== 0) review.nonzero_exit += 1;
-          const findings = countFindings(text);
+          const findings = countStructuredFindings(text) ?? countFindings(text);
           if (findings) {
             review.findings ??= { blocker: 0, major: 0, minor: 0 };
             review.findings.blocker += findings.blocker;

package/package.json

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

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

@@ -38,6 +38,14 @@ printf 'grant: %s\n' "<new value>" | git -C <abs worktree path> commit -q -F - -
 
 When the spec file is mid-batch (uncommitted amend edits), the consent edit rides in that batch's `amend:` commit and the footer acknowledgment says so. Either way, verify `git -C <abs worktree path> show HEAD:<spec path>` satisfies the predicate with the new value; otherwise stop and report. After the line exists, every later change is a same-line value edit; a grant given in a resumed session is an ordinary mid-flow grant.
 
+## Implement-local maintenance boundaries
+
+Apply this specialization only to implement callers with a task plan; keep planning callers and ordinary attribution/restoration below unchanged. Patch only affected task entries, coverage and shifted anchors, preserving unaffected ids, titles, wave order, state and historical evidence. Capture anchored obligation text, task bodies and Tests alongside the original inventory in the saved apply report; retain it on failure and use it on idempotent retry. Interpret `tasksAnchorChanged` semantically, not as offset-only or meaning-preserving rewording changes.
+
+For spec/plan maintenance requiring no test execution, admit declared `In-flight:` repairs and preserve staged repairs; never commit, restore or discard them merely to plan. Retain original declarations and unchanged evidence at measured revisions under `**Baseline policy:** implement-local`. Execute changed/added/missing/invalid evidence only on an identified execution tree, recording leg, checkout, revision, admitted changes, command, exit and nonzero executed-test count. Never call dirty execution clean HEAD; stop on unidentified trees, unknown dirty paths, contamination or moved test revision.
+
+Match a retained failure by failing command, assertion or path together with corresponding repair evidence, never task membership alone. Keep failed revision/output and resolving evidence in the report. Return outstanding repairs to the existing task gate loop, not repeated baseline refreshes or unrelated reopening; keep unrelated regressions substantive blockers. Decode the standing grant at every batch boundary; with amend permission take the named recommendation without reviewer, menu or another confirmation. Repeated authorized intermediate evidence is neither new consent nor a refresh trigger; do not reapply it or force the ordinary repeated-evidence exit for an already authorized intermediate disposition. Preserve budget-only, malformed-grant, redraw-only/mixed, unidentified-test-tree and unrelated-regression stops. Keep one amendment audit and existing funding; integrated tests, review and final verification remain mandatory.
+
 ## 1. Prepare - never apply yet
 
 **Implement callers only, with a task plan:** delegate preparation to `plan-writer` in a one-step chain with the ordinary five absolute paths, this surface's absolute path, and an implement-only `Amend-prepare:` block carrying evidence already in context (checker FAIL lines, structured `concerns`/`question`, or baseline rows). Consume `{ items: [{ evidence, recommended: "accept" | "alt-<n>", location: "<spec section>", edit: string }], redraws: [{ location: "<spec section>", reason: string (max 300 characters) }] }`; keep supporting context in the saved report. Require both `items` and `redraws` arrays, including when empty; redraw proposals appear only in `redraws`, never in `items`. Fail malformed preparation output. Include the literal sentence `Do not edit any file.` in the `Amend-prepare:` task text. The child reads spec and plan, writes nothing, and bounds each proposed edit to one paragraph. Enforce the redraw gate: a nonempty `redraws` array holds the whole batch before grant evaluation or applying any sibling item. Hold amend siblings for re-batching after the redraw resolves; the primary never opens the preparation report to discover redraws. Run the standing-grant predicate and Value decoding unchanged; without amend permission, take sections 2-4 and stop for the human's answer. Forward only resolved, authorized items to the apply route in section 5. Planning callers keep the ordinary preparation below. For ledger-engine (`loop-implementation`) callers, prepare through the ordinary path below without a `plan-writer` dispatch.
@@ -145,7 +153,7 @@ Reply grammar: one line per item, `<n>. <letter or free text>`; bare `1` applies
 
 Before the aftermath, `read` this section again; never run it from memory.
 
-**Implement callers only, with a task plan:** replace parent spec edits and the ordinary plan aftermath with a one-step chain to `plan-writer` carrying an implement-only `Amend-apply:` block, the granted items verbatim, the five absolute paths, and the parent's explicit `In-flight:` list. Authorize only those named spec sections. Require ordinary `Amend:` preservation of unaffected titles and wave positions, Baseline ownership, dirty-baseline safety, and the child's self-check. Consume `{ amendedSections: string[], tasksAdded: number[], tasksAnchorChanged: number[], tasksRemoved: number[], passed: boolean, failLines?: string[] }`; use pre-apply task numbers, never tracker positions. Require the child to capture the original task numbers, titles, spec anchors, and wave positions in the existing saved apply report before the first apply and retain that original inventory on every return, including failures; add no sidecar. On `passed: false`, repeat once with `failLines` as the rule and `previousApplyReport` set to the first apply report path. Require the fresh retry worker to read that original inventory, apply granted edits idempotently without duplicating already-applied edits, and compute deltas against that original inventory rather than the already-mutated plan. Missing original inventory fails the retry; send a second failure to the human with verbatim findings, including substantive baseline failures. Keep the attribution, protected-path, and dirty-baseline exits below; no delegated restoration permission is granted. On pass, print `amended the spec: <title> - <location>` for each applied item, run the parent's `plan_check` for stamping, and use its fresh manifest with the returned task numbers without reading the plan or spec. Add `tasksAdded`, reopen completed `tasksAnchorChanged` as `in_progress`, and handle `tasksRemoved` through the removal rules below. Require parent PASS before tracker changes. Skip the ordinary parent edit, `Amend:` dispatch, and amended-plan read; preserve companion aftermath, audit, and the single batch commit below. Planning callers keep the ordinary apply and aftermath below; ledger and no-plan routes stay unchanged.
+**Implement callers only, with a task plan:** replace parent spec edits and the ordinary plan aftermath with a one-step chain to `plan-writer` carrying an implement-only `Amend-apply:` block, the granted items verbatim, the five absolute paths, and the parent's explicit `In-flight:` list. Authorize only those named spec sections. Require implement-local patching and historical Baseline under the boundaries above, preservation of unaffected titles and wave positions, Baseline ownership, dirty-baseline safety, and the child's self-check. Consume `{ amendedSections: string[], tasksAdded: number[], tasksAnchorChanged: number[], tasksRemoved: number[], passed: boolean, failLines?: string[] }`; use pre-apply task numbers, never tracker positions. Require the child to capture the original task numbers, titles, spec anchors, and wave positions in the existing saved apply report before the first apply and retain that original inventory on every return, including failures; add no sidecar. On `passed: false`, repeat once with `failLines` as the rule and `previousApplyReport` set to the first apply report path. Require the fresh retry worker to read that original inventory, apply granted edits idempotently without duplicating already-applied edits, and compute deltas against that original inventory rather than the already-mutated plan. Missing original inventory fails the retry; send a second failure to the human with verbatim findings, including substantive baseline failures. Keep the attribution, protected-path, and dirty-baseline exits below; no delegated restoration permission is granted. On pass, print `amended the spec: <title> - <location>` for each applied item, run the parent's `plan_check` for stamping, and use its fresh manifest with the returned task numbers without reading the plan or spec. Add `tasksAdded`, reopen completed `tasksAnchorChanged` as `in_progress`, and handle `tasksRemoved` through the removal rules below. Require parent PASS before tracker changes. Skip the ordinary parent edit, `Amend:` dispatch, and amended-plan read; preserve companion aftermath, audit, and the single batch commit below. Planning callers keep the ordinary apply and aftermath below; ledger and no-plan routes stay unchanged.
 
 Apply accepted items only: reviewer clears, `accept`, `alt-n`, and state-changing `custom`. Print one line per applied item: `amended the spec: <title> - <what>`.
 

package/skills/chase-bug/hotfix.md

@@ -120,7 +120,7 @@ succeeds (it creates both). Every destructive command below is gated on its flag
    file or ticket is not-a-gap. Real gaps -> one implementer round -> re-run step
    5 -> no second audit; unfixable -> abort. Dispatch failure or malformed output
    -> note it, continue.
-7. **Review - last mutation gate.** One fresh `code-reviewer` over
+7. **Review - last mutation gate.** One fresh `wave-reviewer` over
    `<base-sha>..HEAD` in the worktree. Task text: the record path,
    `SCOPED_TEST_COMMANDS`, invariants 1-3 and predicates 4-6 as named review items
    (a predicate miss is Moderate unless it trips an invariant). `SHIP` -> step 8.

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

@@ -128,7 +128,7 @@ Grammar (identical across producers, modulo id prefix — `F` for code/spec revi
         | <id> " conflicts " <id> " (" <reason> ")"
 ```
 
-**Structural probe:** when the report carries >= 2 actionable finding IDs (Critical/Moderate findings for code-reviewer; PARTIAL/MISSING/scope-creep findings for spec-reviewer; non-DELIVERED gaps for conformance-reviewer), validate the certificate before the fan-out decision: the review must contain **exactly one** line matching `^Parallel-safe: ` whose remainder parses as `<group>[; <group>]*` (grammar above). Zero matching lines, an unparseable remainder, or **any second** `Parallel-safe:` line (identical or not) = malformed -> re-ask the reviewer **once**, quoting the expected grammar, before any disposition or fan-out decision. Still malformed after the re-ask -> fully sequential fixes with an explicit one-line degradation notice in the orchestrator's visible output — never silent. A probe-passing line with no >= 2-ID `disjoint` group is **valid**: sequential fixes, no re-ask, no notice (the certificate says "serial", not a malformation). Fewer than 2 actionable IDs -> skip the probe (nothing to fan out). Reviewer errors (no report at all) are out of scope here — report-shape validation, not report-existence; existing dispatch-failure handling applies.
+**Structural probe:** when the report carries >= 2 actionable finding IDs (Critical/Moderate findings for wave-reviewer; non-DELIVERED gaps for conformance-reviewer), validate the certificate before the fan-out decision: the review must contain **exactly one** line matching `^Parallel-safe: ` whose remainder parses as `<group>[; <group>]*` (grammar above). Zero matching lines, an unparseable remainder, or **any second** `Parallel-safe:` line (identical or not) = malformed -> re-ask the reviewer **once**, quoting the expected grammar, before any disposition or fan-out decision. Still malformed after the re-ask -> fully sequential fixes with an explicit one-line degradation notice in the orchestrator's visible output — never silent. A probe-passing line with no >= 2-ID `disjoint` group is **valid**: sequential fixes, no re-ask, no notice (the certificate says "serial", not a malformation). Fewer than 2 actionable IDs -> skip the probe (nothing to fan out). Reviewer errors (no report at all) are out of scope here — report-shape validation, not report-existence; existing dispatch-failure handling applies.
 
 **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.
 
@@ -191,7 +191,7 @@ Parallel dispatch rides on the `subagent` tool (the pi-cohort package). Mechanic
 - **Context** — `context: "fresh"` at the top level applies to every task. Mandatory here (see above); without it `worker` forks parent history and you lose isolation.
 - **Filesystem isolation** — `worktree: true` runs each task in its own git worktree so concurrent edits can't collide. Requires clean git state; each task's diff returns separately for you to integrate. Omit it for read-only investigations.
 - **Worktree base / `cwd`** — under `worktree: true` the base commit is `HEAD` resolved from the **top-level `cwd`**, which defaults to the orchestrator's process cwd. When you orchestrate from inside a git worktree, pass that worktree's absolute path as the top-level `cwd`, or children branch from the wrong checkout. Don't set per-task `cwd` with `worktree: true` — it must equal the shared cwd or the run errors.
-- **Agent choice** — `worker` is the pi-cohort builtin generalist. Use a persona (`implementer`, `code-reviewer`) when you want its system prompt and tool profile. Persona frontmatter (tools, thinking, context) is fixed; only `model`, `task`, `output`, `reads`, `progress`, `skill` are callable per task.
+- **Agent choice** — `worker` is the pi-cohort builtin generalist. Use a persona (`implementer`, `wave-reviewer`) when you want its system prompt and tool profile. Persona frontmatter (tools, thinking, context) is fixed; only `model`, `task`, `output`, `reads`, `progress`, `skill` are callable per task.
 - **Output capture** - `output: "<file>"` writes a task's summary to a file instead of inline; add `outputMode: "file-only"` for large results. When a batch uses `worktree: true`, each `output:` path must be absolute and outside every isolated checkout; a relative report is captured as helper work and then deleted with the checkout. In a non-isolated batch, a relative report lands in the shared working tree and risks being committed or overwritten by a later task.
 
 ```bash

package/skills/finishing-a-development-branch/reference/disposition-protocol.md

@@ -43,7 +43,7 @@ Take **no** disposition action before the reply. Then, once, in order:
 1. **Normalize** every `custom(...)` into explicit operations; classify state-changing (edits code or spec) vs not. Clarify only an ambiguous or unexecutable effect.
 2. **Commit spec edits** (`accept-into-spec`, `rescope-into-spec`, state-changing spec `custom`) - the main session edits the spec directly, before any fix dispatch (a dirty tree rejects `worktree: true`, and the re-audit must read the amended spec). A disposition chosen here is already approved: it bypasses the amendment surface's reviewer and batch. Items the pre-menu funnel auto-applied are recorded `Gn - <title>: accept-into-spec (auto-applied)`.
 3. **Re-audit if step 2 changed the spec**; regenerate the inventory and re-render if it changed. Project `fix-now` only from the refreshed inventory.
-4. **fix-now + code-changing custom:** project the selected concerns per gap into the reference's concern-scoped fix contract (excluding accepted/rescoped/followed-up siblings); run the reference "Fix loop" (unchanged - do not re-describe it). A code-changing `custom` runs the project's tests + `code-reviewer` on its delta before proceeding. Re-run Step 1's canonical tests.
+4. **fix-now + code-changing custom:** project the selected concerns per gap into the reference's concern-scoped fix contract (excluding accepted/rescoped/followed-up siblings); run the reference "Fix loop" (unchanged - do not re-describe it). A code-changing `custom` runs the project's tests + `wave-reviewer` on its delta before proceeding. Re-run Step 1's canonical tests.
 5. **Re-audit after all state-changing work;** obtain fresh decisions **only if** the refreshed inventory differs from the approved one, else proceed.
 6. **follow-up** from the current inventory: create the item via the project's issue-tracker convention (the gauntlet overrides file, see Project overrides in `finishing-a-development-branch/SKILL.md`), record the ticket ID/URL; on failure keep the concern open.
 7. **Non-state-changing custom:** execute and record the result.