@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tests/register-hooks-loop-guard-auto.test.ts

@@ -0,0 +1,378 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { resetToolCallLoopGuard } from "../bootstrap/tool-call-loop-guard.ts";
+import { readUnitHarnessAbort } from "../unit-runtime.ts";
+
+type Handler = (event: any, ctx?: any) => Promise<any> | any;
+
+function makeHookHarness(): {
+  emitToolCall: (toolName: string, input: Record<string, unknown>) => Promise<any>;
+  emitToolResult: (event: Record<string, unknown>) => Promise<void>;
+  emitToolExecutionEnd: (event: Record<string, unknown>) => Promise<void>;
+  emitAgentEnd: (event: Record<string, unknown>) => Promise<void>;
+} {
+  const handlers = new Map<string, Handler[]>();
+  const pi = {
+    on(event: string, handler: Handler) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  };
+  const ctx = {
+    cwd: process.cwd(),
+    ui: { notify: () => undefined },
+  };
+  let callId = 0;
+
+  registerHooks(pi as any, []);
+
+  return {
+    async emitToolCall(toolName: string, input: Record<string, unknown>): Promise<any> {
+      callId += 1;
+      const loopGuardHandler = handlers.get("tool_call")?.[0];
+      assert.ok(loopGuardHandler, "loop-guard tool_call handler should be registered");
+      return loopGuardHandler({ toolCallId: `loop-${callId}`, toolName, input }, ctx);
+    },
+    async emitToolResult(event: Record<string, unknown>): Promise<void> {
+      callId += 1;
+      for (const handler of handlers.get("tool_result") ?? []) {
+        await handler({
+          toolCallId: `result-${callId}`,
+          ...event,
+        }, ctx);
+      }
+    },
+    async emitToolExecutionEnd(event: Record<string, unknown>): Promise<void> {
+      callId += 1;
+      for (const handler of handlers.get("tool_execution_end") ?? []) {
+        await handler({
+          toolCallId: `exec-${callId}`,
+          ...event,
+        }, ctx);
+      }
+    },
+    async emitAgentEnd(event: Record<string, unknown>): Promise<void> {
+      for (const handler of handlers.get("agent_end") ?? []) {
+        await handler(event, ctx);
+      }
+    },
+  };
+}
+
+function makeRuntimeBase(): string {
+  const base = join(tmpdir(), `gsd-hook-runtime-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+test("register-hooks keeps loop-guard block reason interactive outside auto-mode", async (t) => {
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+  });
+
+  const { emitToolCall } = makeHookHarness();
+
+  for (let i = 0; i < 4; i += 1) {
+    await emitToolCall("web_search", { query: "same query" });
+  }
+  const block = await emitToolCall("web_search", { query: "same query" });
+
+  assert.equal(block?.block, true);
+  assert.match(block.reason, /respond to the user in text/);
+  assert.doesNotMatch(block.reason, /auto-mode recovery\/replan path/);
+});
+
+test("register-hooks rewrites loop-guard block reason for auto-mode identical-args blocks", async (t) => {
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+  });
+
+  const { emitToolCall } = makeHookHarness();
+
+  for (let i = 0; i < 4; i += 1) {
+    await emitToolCall("web_search", { query: "same query" });
+  }
+  const block = await emitToolCall("web_search", { query: "same query" });
+
+  assert.equal(block?.block, true);
+  assert.match(block.reason, /Tool loop detected \(identical args\): web_search/);
+  assert.match(block.reason, /Do not re-issue this blocked tool/);
+  assert.match(block.reason, /auto-mode recovery\/replan path/);
+  assert.doesNotMatch(block.reason, /respond to the user in text/);
+});
+
+test("register-hooks rewrites loop-guard block reason for auto-mode per-tool blocks", async (t) => {
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+  });
+
+  const { emitToolCall } = makeHookHarness();
+
+  for (let i = 0; i < 6; i += 1) {
+    await emitToolCall("gsd_complete_milestone", { milestone: `M${i}` });
+  }
+  const block = await emitToolCall("gsd_complete_milestone", { milestone: "M7" });
+
+  assert.equal(block?.block, true);
+  assert.match(block.reason, /Tool loop detected \(repeated tool\): gsd_complete_milestone/);
+  assert.match(block.reason, /Do not re-issue this blocked tool/);
+  assert.match(block.reason, /auto-mode recovery\/replan path/);
+  assert.doesNotMatch(block.reason, /respond to the user in text/);
+});
+
+test("register-hooks does not record normal product tool failures as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "gate-evaluate", id: "M001/S01/gates+Q3", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "mcp__gsd-workflow__browser_click",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "Element not found: #submit" }],
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks does not classify normal gsd_uat_exec nonzero exits as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "run-uat", id: "M001/S01", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "gsd_uat_exec",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "gsd_exec[exec-1] runtime=bash exit=1 duration=12ms" }],
+      details: {
+        operation: "gsd_uat_exec",
+        exit_code: 1,
+        aborted: false,
+        force_resolved: false,
+      },
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks records exec deadline timeouts as harness aborts", async () => {
+  for (const scenario of [
+    { toolName: "gsd_exec", unitType: "gate-evaluate", unitId: "M001/S01/gates+Q3" },
+    { toolName: "gsd_uat_exec", unitType: "run-uat", unitId: "M001/S01" },
+  ]) {
+    const base = makeRuntimeBase();
+    const startedAt = Date.now();
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.currentUnit = { type: scenario.unitType, id: scenario.unitId, startedAt };
+
+    try {
+      const { emitToolExecutionEnd } = makeHookHarness();
+      await emitToolExecutionEnd({
+        toolName: scenario.toolName,
+        isError: true,
+        result: {
+          content: [{ type: "text", text: "gsd_exec[exec-timeout] runtime=bash timeout duration=600000ms" }],
+          details: {
+            operation: scenario.toolName,
+            exit_code: null,
+            aborted: false,
+            force_resolved: false,
+            timed_out: true,
+          },
+        },
+      });
+
+      const abort = readUnitHarnessAbort(base, scenario.unitType, scenario.unitId, startedAt);
+      assert.equal(abort?.kind, "tool-error");
+      assert.equal(abort?.toolName, scenario.toolName);
+      assert.match(abort?.reason ?? "", /timeout/);
+    } finally {
+      autoSession.reset();
+      resetToolCallLoopGuard();
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+});
+
+test("register-hooks preserves retryable harness abort after later successful tools", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "run-uat", id: "M001/S01", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd, emitToolResult } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "mcp__gsd-workflow__browser_click",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "No such tool available: browser_click" }],
+    },
+  });
+
+  const recorded = readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt);
+  assert.equal(recorded?.kind, "tool-error");
+
+  await emitToolResult({
+    toolName: "read",
+    isError: false,
+    input: { path: "README.md" },
+    result: {
+      content: [{ type: "text", text: "file contents" }],
+    },
+  });
+  assert.equal(
+    readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt)?.kind,
+    "tool-error",
+    "successful native tool_result must not clear the harness abort",
+  );
+
+  await emitToolExecutionEnd({
+    toolName: "read",
+    isError: false,
+    result: {
+      content: [{ type: "text", text: "file contents" }],
+    },
+  });
+  assert.equal(
+    readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt)?.kind,
+    "tool-error",
+    "successful universal tool_execution_end must not clear the harness abort",
+  );
+});
+
+test("register-hooks does not record save-tool validation errors as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "run-uat", id: "M001/S01", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "gsd_uat_result_save",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "Error: UAT Assessment requires at least one fresh gsd_uat_exec evidence reference" }],
+      details: { operation: "save_uat_result", error: "uat_missing_fresh_evidence" },
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks does not record pending approval hard-blocks as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "gate-evaluate", id: "M001/S01/gates+Q3", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "gsd_summary_save",
+    isError: true,
+    result: {
+      content: [{
+        type: "text",
+        text: 'HARD BLOCK: Discussion gate "depth:M001" has not been confirmed by the user.',
+      }],
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks only records agent_end turn aborts for aborted or error stop reasons", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "gate-evaluate", id: "M001/S01/gates+Q3", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitAgentEnd } = makeHookHarness();
+  await emitAgentEnd({
+    abortOrigin: "auto-context",
+    messages: [{ stopReason: "stop" }],
+  });
+
+  const abort = readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt);
+  assert.equal(abort, null);
+});

package/src/resources/extensions/gsd/tests/repository-registry.test.ts

@@ -83,7 +83,7 @@ test("defaultRepositoryTargets returns [project] for a single-repo project regis
   assert.deepEqual(defaultRepositoryTargets(registry), ["project"]);
 });
 
-test("defaultRepositoryTargets returns [project] for a parent-mode registry", (t) => {
+test("defaultRepositoryTargets returns declared child repos for a parent-mode registry", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
   mkdirSync(join(base, ".gsd"), { recursive: true });
@@ -98,7 +98,46 @@ test("defaultRepositoryTargets returns [project] for a parent-mode registry", (t
     },
   });
 
-  assert.deepEqual(defaultRepositoryTargets(registry), ["project"]);
+  assert.deepEqual(defaultRepositoryTargets(registry), ["frontend"]);
+});
+
+test("defaultRepositoryTargets returns all child repos (declaration order) in parent mode", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, "frontend"), { recursive: true });
+  mkdirSync(join(base, "backend"), { recursive: true });
+
+  const registry = createRepositoryRegistryFromPreferences(base, {
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: { path: "frontend" },
+        backend: { path: "backend" },
+      },
+    },
+  });
+
+  assert.deepEqual(defaultRepositoryTargets(registry), ["frontend", "backend"]);
+});
+
+test("defaultRepositoryTargets excludes the implicit project repo in parent mode", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, "frontend"), { recursive: true });
+
+  const registry = createRepositoryRegistryFromPreferences(base, {
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: { path: "frontend" },
+      },
+    },
+  });
+
+  const targets = defaultRepositoryTargets(registry);
+  assert.ok(!targets.includes("project"), "implicit project repo must not be a default target in parent mode");
 });
 
 test("repository registry keeps project root anchored to .gsd project in monorepo subdirectory", (t) => {

package/src/resources/extensions/gsd/tests/require-slice-discussion-dispatch.test.ts

@@ -16,6 +16,13 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
 import type { GSDState } from "../types.ts";
 import type { GSDPreferences } from "../preferences.ts";
 
@@ -87,6 +94,54 @@ describe("require_slice_discussion dispatch rule (#3454)", () => {
     }
   });
 
+  test("includes prior non-PASS UAT warning when the just-closed slice failed", async () => {
+    const basePath = makeBasePath("prior-fail");
+    const dbDir = mkdtempSync(join(tmpdir(), "gsd-req-slice-db-"));
+    const dbPath = join(dbDir, "test.db");
+    try {
+      openDatabase(dbPath);
+      mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S02"), { recursive: true });
+
+      insertMilestone({ id: "M001", title: "Test milestone" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Completed slice", status: "complete", sequence: 1 });
+      insertSlice({ id: "S02", milestoneId: "M001", title: "Next slice", status: "pending", sequence: 2 });
+
+      const assessmentPath = ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md";
+      const assessmentBody = [
+        "---",
+        "verdict: fail",
+        "---",
+        "",
+        "# S01 UAT Assessment",
+      ].join("\n");
+      writeFileSync(join(basePath, assessmentPath), assessmentBody, "utf-8");
+      insertAssessment({
+        path: assessmentPath,
+        milestoneId: "M001",
+        sliceId: "S01",
+        status: "fail",
+        scope: "run-uat",
+        fullContent: assessmentBody,
+      });
+
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ activeSlice: { id: "S02", title: "Next slice" } });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+
+      assert.ok(action, "rule must still pause for discussion");
+      assert.strictEqual(action!.action, "stop");
+      if (action!.action === "stop") {
+        assert.match(action!.reason, /S02 requires discussion/);
+        assert.match(action!.reason, /slice just closed \(S01\)/);
+        assert.match(action!.reason, /non-PASS UAT verdict \(FAIL\)/);
+      }
+    } finally {
+      closeDatabase();
+      rmSync(basePath, { recursive: true, force: true });
+      rmSync(dbDir, { recursive: true, force: true });
+    }
+  });
+
   // ─── Negative cases: rule falls through ───────────────────────────────
 
   test("falls through (null) when preference is disabled", async () => {

package/src/resources/extensions/gsd/tests/root-write-leak-guard.test.ts

@@ -7,7 +7,26 @@ import { closeSync, ftruncateSync, openSync, statSync, writeFileSync } from "nod
 import { join } from "node:path";
 
 import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";
-import { cleanup, git, makeTempRepo } from "./test-utils.ts";
+import { cleanup, createFile, git, makeTempRepo } from "./test-utils.ts";
+
+test("captureRootDirtySnapshot ignores unignored GSD root runtime directories", () => {
+  const base = makeTempRepo("gsd-root-dirty-runtime-");
+  try {
+    createFile(base, ".gsd/STATE.md", "state\n");
+    createFile(base, ".gsd-backups/snap-001", "backup\n");
+    createFile(base, ".gsd-worktrees/M001/file.txt", "worktree\n");
+    createFile(base, "src/foo.ts", "export {};\n");
+
+    const snapshot = captureRootDirtySnapshot(base);
+
+    assert.equal(snapshot.has(".gsd/STATE.md"), false);
+    assert.equal(snapshot.has(".gsd-backups/snap-001"), false);
+    assert.equal(snapshot.has(".gsd-worktrees/M001/file.txt"), false);
+    assert.equal(snapshot.has("src/foo.ts"), true);
+  } finally {
+    cleanup(base);
+  }
+});
 
 test("captureRootDirtySnapshot does not read dirty files larger than Node's Buffer limit", () => {
   const base = makeTempRepo("gsd-root-dirty-large-");

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -177,10 +177,22 @@ test("auto Unit tool scope allows status/read helpers named by closeout prompts"
   }
 });
 
-test("auto Unit tool scope blocks stale per-task planner in slice planning phases", () => {
-  for (const unitType of ["plan-slice", "refine-slice", "replan-slice"]) {
+test("auto Unit tool scope allows reactive-execute status and diagnostic tools", () => {
+  for (const toolName of ["gsd_milestone_status", "gsd_exec"]) {
+    const result = shouldBlockAutoUnitToolCall("reactive-execute", toolName);
+    assert.equal(result.block, false, `reactive-execute should be able to call ${toolName}`);
+  }
+});
+
+test("auto Unit tool scope allows incremental task planning during plan-slice", () => {
+  const result = shouldBlockAutoUnitToolCall("plan-slice", "gsd_plan_task");
+  assert.equal(result.block, false, "plan-slice should be able to call gsd_plan_task incrementally");
+});
+
+test("auto Unit tool scope still blocks per-task planner outside plan-slice", () => {
+  for (const unitType of ["refine-slice", "replan-slice"]) {
     const result = shouldBlockAutoUnitToolCall(unitType, "gsd_plan_task");
-    assert.equal(result.block, true, `${unitType} should not call stale gsd_plan_task`);
+    assert.equal(result.block, true, `${unitType} should not call gsd_plan_task`);
   }
 });
 

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -18,6 +18,7 @@
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { verifyExpectedArtifact } from "../auto-recovery.ts";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
 import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { test } from 'node:test';
@@ -48,6 +49,16 @@ function makeRecordingPi() {
   } as any;
 }
 
+function makeRecordingCtx() {
+  const notifications: Array<{ message: string; level: string }> = [];
+  return {
+    notifications,
+    ui: {
+      notify: (message: string, level: string) => { notifications.push({ message, level }); },
+    },
+  } as any;
+}
+
 // ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
 
 {
@@ -111,6 +122,100 @@ function makeRecordingPi() {
   }
 }
 
+// ═══ plan-slice timeout recovery verifies stale PLAN before advancing ═══════
+
+{
+  console.log("\n=== plan-slice timeout recovery rejects stale placeholder PLAN ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-stale-plan-"));
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      "# S01: Slice\n\n## Tasks\n\nPlanning was interrupted before task rows were persisted.\n",
+      "utf-8",
+    );
+
+    const ctx = makeRecordingCtx();
+    const pi = makeRecordingPi();
+    const result = await recoverTimedOutUnit(ctx, pi, "plan-slice", "M001/S01", "idle", {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    });
+
+    assert.equal(result, "recovered", "invalid existing plan should enter steering recovery");
+    assert.equal(pi.messages.length, 1, "invalid existing plan should trigger steering instead of advancing");
+    assert.ok(
+      ctx.notifications.some((entry: { message: string }) => entry.message.includes("steering plan-slice M001/S01")),
+      "recovery notification should describe steering, not artifact advance",
+    );
+    assert.ok(
+      !ctx.notifications.some((entry: { message: string }) => entry.message.includes("artifact already exists on disk. Advancing.")),
+      "stale placeholder plan should not use the advance-on-existence path",
+    );
+    const runtime = JSON.parse(readFileSync(join(base, ".gsd", "runtime", "units", "plan-slice-M001-S01.json"), "utf-8"));
+    assert.equal(runtime.phase, "recovered", "stale placeholder plan must not be finalized");
+    assert.equal(runtime.recoveryAttempts, 1, "steering recovery attempt should be recorded");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ═══ plan-slice verification accepts completed task summaries ═══════════════
+
+{
+  console.log("\n=== plan-slice verification accepts completed task summaries ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-slice-complete-summary-"));
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S05");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S05", milestoneId: "M001", title: "Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S05", title: "Done 1", status: "complete" });
+    insertTask({ id: "T02", milestoneId: "M001", sliceId: "S05", title: "Done 2", status: "complete" });
+    insertTask({ id: "T03", milestoneId: "M001", sliceId: "S05", title: "Pending 1", status: "pending" });
+    insertTask({ id: "T04", milestoneId: "M001", sliceId: "S05", title: "Pending 2", status: "pending" });
+    writeFileSync(
+      join(sliceDir, "S05-PLAN.md"),
+      [
+        "# S05: Slice",
+        "",
+        "## Tasks",
+        "",
+        "- [x] **T01: Done 1** `est:10m`",
+        "- [x] **T02: Done 2** `est:10m`",
+        "- [ ] **T03: Pending 1** `est:10m`",
+        "- [ ] **T04: Pending 2** `est:10m`",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n", "utf-8");
+    writeFileSync(join(tasksDir, "T02-SUMMARY.md"), "# T02 Summary\n", "utf-8");
+    writeFileSync(join(tasksDir, "T03-PLAN.md"), "# T03 Plan\n", "utf-8");
+    writeFileSync(join(tasksDir, "T04-PLAN.md"), "# T04 Plan\n", "utf-8");
+
+    assert.equal(
+      verifyExpectedArtifact("plan-slice", "M001/S05", base),
+      true,
+      "completed DB tasks should be accounted for by SUMMARY files",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {