@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/src/resources/extensions/gsd/tests/auto-unit-closeout.test.ts

@@ -1,13 +1,23 @@
 // Project/App: gsd-pi
 // File Purpose: Regression tests for auto-unit closeout activity classification.
 
-import test from "node:test";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+import test, { type TestContext } from "node:test";
 import assert from "node:assert/strict";
 
 import {
   isSuspiciousGhostCompletion,
   snapshotUnitActivity,
 } from "../auto-unit-closeout.ts";
+import {
+  closeUnit,
+  type UnitCloseoutRequest,
+  type UnitCloseoutDeps,
+} from "../unit-closeout.ts";
+import type { NotifySeverity } from "../notification-store.js";
 
 function makeCtx(entries: unknown[]) {
   return {
@@ -17,6 +27,38 @@ function makeCtx(entries: unknown[]) {
   } as any;
 }
 
+function createTempGitRepo(t: TestContext): string {
+  const dir = mkdtempSync(join(tmpdir(), "closeout-test-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  execSync("git init", { cwd: dir });
+  execSync("git config user.email test@test.com", { cwd: dir });
+  execSync("git config user.name Test", { cwd: dir });
+  return dir;
+}
+
+function makeMockDeps(overrides: Partial<UnitCloseoutDeps> = {}): UnitCloseoutDeps & { notifications: Array<{ message: string; severity: NotifySeverity }> } {
+  const notifications: Array<{ message: string; severity: NotifySeverity }> = [];
+  return {
+    isolationMode: () => "none",
+    currentBranch: () => "main",
+    commit: () => null,
+    notify: (message, severity) => notifications.push({ message, severity }),
+    notifications,
+    ...overrides,
+  };
+}
+
+function baseRequest(overrides: Partial<UnitCloseoutRequest> = {}): UnitCloseoutRequest {
+  return {
+    basePath: "/tmp/ignored",
+    unitType: "complete-milestone",
+    unitId: "M001",
+    boundary: "milestone",
+    outcome: "complete",
+    ...overrides,
+  };
+}
+
 test("isSuspiciousGhostCompletion rejects fast completions with no assistant output or tools", () => {
   const startedAt = Date.now();
   const ctx = makeCtx([]);
@@ -66,3 +108,129 @@ test("snapshotUnitActivity counts assistant messages and tool calls", () => {
     assistantMessages: 1,
   });
 });
+
+test("closeUnit: nothing-to-commit / isolation none", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "none",
+    commit: () => null,
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "nothing-to-commit");
+  assert.equal(result.commitMessage, null);
+  assert.equal(result.notice, undefined);
+  assert.equal(deps.notifications.length, 0);
+});
+
+test("closeUnit: committed / isolation none", (t) => {
+  const dir = createTempGitRepo(t);
+  writeFileSync(join(dir, "file.txt"), "hello");
+  execSync("git add file.txt", { cwd: dir });
+
+  const deps = makeMockDeps({
+    isolationMode: () => "none",
+    commit: () => "Add file.txt",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "committed");
+  assert.equal(result.commitMessage, "Add file.txt");
+  assert.equal(result.notice, undefined);
+  assert.equal(deps.notifications.length, 0);
+});
+
+test("closeUnit: milestone-branch / worktree isolation", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "worktree",
+    currentBranch: () => "milestone/M001",
+    commit: () => "Complete M001",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "milestone-branch");
+  assert.equal(result.commitMessage, "Complete M001");
+  assert.ok(result.notice);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "info");
+  assert.match(deps.notifications[0].message, /Merge it to the integration branch/);
+});
+
+test("closeUnit: isolation-bypassed / worktree isolation", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "worktree",
+    currentBranch: () => "main",
+    commit: () => "Complete M001",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "isolation-bypassed");
+  assert.equal(result.commitMessage, "Complete M001");
+  assert.ok(result.notice);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "warning");
+  assert.match(deps.notifications[0].message, /completed outside a milestone worktree\/branch/);
+});
+
+test("closeUnit: isolation-bypassed / branch isolation", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "branch",
+    currentBranch: () => "main",
+    commit: () => "Complete M001",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "isolation-bypassed");
+  assert.equal(result.commitMessage, "Complete M001");
+  assert.ok(result.notice);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "warning");
+  assert.match(deps.notifications[0].message, /completed outside a milestone worktree\/branch/);
+});
+
+test("closeUnit: commit-failed", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "none",
+    commit: () => {
+      throw new Error("simulated commit failure");
+    },
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "commit-failed");
+  assert.equal(result.commitMessage, null);
+  assert.ok(result.notice);
+  assert.match(result.notice!, /simulated commit failure/);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "error");
+});
+
+test("closeUnit: task boundary ignores isolation verdict", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "worktree",
+    currentBranch: () => "main",
+    commit: () => "Complete task",
+  });
+
+  const result = closeUnit(
+    baseRequest({ basePath: dir, boundary: "task", unitType: "execute-task", unitId: "M001/S01/T01" }),
+    deps,
+  );
+
+  assert.equal(result.gitVerdict, "committed");
+  assert.equal(result.commitMessage, "Complete task");
+  assert.equal(result.notice, undefined);
+  assert.equal(deps.notifications.length, 0);
+});
+

package/src/resources/extensions/gsd/tests/auto-verification.test.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { runPostUnitVerification } from "../auto-verification.ts";
+
+function createVerificationContext(currentUnit: { type: string; id: string } | null) {
+	return {
+		s: {
+			currentUnit,
+		},
+		ctx: {
+			ui: {
+				notify() {
+					throw new Error("notify should not be called for pass-through units");
+				},
+			},
+		},
+		pi: {},
+	};
+}
+
+test("post-unit verification continues when no host-owned verification is needed", async () => {
+	let paused = false;
+	const pauseAuto = async () => {
+		paused = true;
+	};
+
+	assert.equal(await runPostUnitVerification(createVerificationContext(null) as never, pauseAuto), "continue");
+	assert.equal(
+		await runPostUnitVerification(
+			createVerificationContext({ type: "plan-slice", id: "M001-S001" }) as never,
+			pauseAuto,
+		),
+		"continue",
+	);
+	assert.equal(paused, false);
+});

package/src/resources/extensions/gsd/tests/blocker-placeholder-logs.test.ts

@@ -0,0 +1,218 @@
+// gsd-pi — Blocker-placeholder recovery log coverage.
+//
+// writeBlockerPlaceholder (auto-recovery.ts:782) writes a placeholder artifact
+// so the pipeline can advance past a stuck unit, then marks the task/slice
+// complete in the DB and appends a workflow event so reconciliation can replay
+// the recovery. Each of those side-effects is individually best-effort and logs
+// a recovery warning on failure (auto-recovery.ts:837/840/843/844/853/854). No
+// test asserted any of them. We trigger each by breaking the specific sink
+// (drop the relevant DB table, or block the events-file append) and assert the
+// warning lands.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { writeBlockerPlaceholder } from "../auto-recovery.ts";
+import { writeReactiveExecuteBlocker } from "../auto-recovery.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+  _getAdapter,
+} from "../gsd-db.ts";
+import {
+  drainLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+
+function makeBase(prefix = "gsd-blocker-logs-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  // Slice projection dirs so the placeholder path resolves.
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function captureLogs<T>(fn: () => T): { result: T; logs: LogEntry[] } {
+  const previous = setStderrLoggingEnabled(false);
+  _resetLogs();
+  try {
+    const result = fn();
+    return { result, logs: drainLogs() };
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
+  }
+}
+
+function recoveryWarnings(logs: readonly LogEntry[]): LogEntry[] {
+  return logs.filter((e) => e.component === "recovery" && e.severity === "warn");
+}
+
+test("writeBlockerPlaceholder logs a recovery warning when updateTaskStatus throws (auto-recovery.ts:837)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Drop tasks so updateTaskStatus throws inside the execute-task DB block.
+    _getAdapter()!.exec("DROP TABLE tasks");
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("execute-task", "M001/S01/T01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /updateTaskStatus failed during context exhaustion/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when updateTaskStatus throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when updateSliceStatus throws (auto-recovery.ts:843)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Drop slices so updateSliceStatus throws inside the complete-slice DB block.
+    _getAdapter()!.exec("DROP TABLE slices");
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("complete-slice", "M001/S01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /updateSliceStatus failed during context exhaustion/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when updateSliceStatus throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the plan-milestone insertSlice throws (auto-recovery.ts:853)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Drop slices so the S00-blocker insertSlice throws inside the
+    // plan-milestone placeholder branch.
+    _getAdapter()!.exec("DROP TABLE slices");
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("plan-milestone", "M001", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) =>
+      /insertSlice placeholder failed for plan-milestone recovery/u.test(w.message),
+    );
+    assert.ok(warn, "a recovery warning must be logged when the blocker slice insert throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the workflow-event append throws (auto-recovery.ts:840)", () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Block the workflow-events append by turning its target into a directory
+    // (appendFileSync on a directory throws EISDIR). The placeholder write still
+    // succeeds because it targets a different path under milestones/.
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("execute-task", "M001/S01/T01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /appendEvent failed for task recovery/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when the recovery event append fails");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the complete-slice appendEvent throws (auto-recovery.ts:898)", () => {
+  const base = makeBase("gsd-blocker-logs-cs-");
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Slices table intact so updateSliceStatus (:897) succeeds; block the
+    // workflow-event append so the complete-slice appendEvent (:898) throws.
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("complete-slice", "M001/S01", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /appendEvent failed for slice recovery/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when the complete-slice appendEvent throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("writeBlockerPlaceholder logs a recovery warning when the plan-milestone appendEvent throws (auto-recovery.ts:908)", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-blocker-logs-pm-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Slices table intact so the S00-blocker insertSlice (:907) succeeds;
+    // block the workflow-event append so the plan-milestone appendEvent (:908) throws.
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeBlockerPlaceholder("plan-milestone", "M001", base, "exhausted retries"),
+    );
+
+    const warn = recoveryWarnings(logs).find((w) => /appendEvent failed for plan-milestone recovery/u.test(w.message));
+    assert.ok(warn, "a recovery warning must be logged when the plan-milestone appendEvent throws");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ── writeReactiveExecuteBlocker append-event warnings (:755 / :768) ────────
+// These fire after the reactive batch recovery transaction commits, when the
+// per-task workflow-event append throws. We seed a real slice with two tasks,
+// plant the event-log target as a directory (appendFileSync → EISDIR), and call
+// writeReactiveExecuteBlocker; both the complete-task and skip-task appends fail.
+
+test("writeReactiveExecuteBlocker logs recovery warnings when the post-recovery event appends throw (auto-recovery.ts:755/:768)", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-blocker-logs-reactive-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "M", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "S", status: "active", risk: "low", depends: [], demo: "", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "T1", status: "active" });
+    insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "T2", status: "active" });
+    // T01 has a summary (→ complete recovery path → :755), T02 does not
+    // (→ skip recovery path → :768).
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), "# T01\n", "utf-8");
+    // Block the workflow-event append (event-log.jsonl is the real ledger file).
+    mkdirSync(join(base, ".gsd", "event-log.jsonl"), { recursive: true });
+
+    const { logs } = captureLogs(() =>
+      writeReactiveExecuteBlocker("M001/S01/reactive+T01,T02", base, "batch exhausted"),
+    );
+
+    const warnings = recoveryWarnings(logs).map((w) => w.message);
+    assert.ok(
+      warnings.some((m) => /appendEvent failed for reactive complete recovery/u.test(m)),
+      "the complete-task append warning must be logged (:755)",
+    );
+    assert.ok(
+      warnings.some((m) => /appendEvent failed for reactive skip recovery/u.test(m)),
+      "the skip-task append warning must be logged (:768)",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/complete-milestone-prompt-rendering.test.ts

@@ -42,7 +42,11 @@ test("complete milestone prompt renders compact verification and completion guid
   assert.match(prompt, /Decision Re-evaluation/);
   assert.match(prompt, /self-diff/i);
   assert.match(prompt, /GSD-(?:Task|Unit)/);
-  assert.match(prompt, /Milestone M001 complete/);
-  assert.match(prompt, /Do not add a second final-status block/);
+  assert.match(prompt, /Closeout messaging \(auto-mode\)/);
+  assert.match(prompt, /Never say "Milestone M001 is complete"/);
+  assert.match(prompt, /Milestone M001 closeout submitted/);
+  assert.match(prompt, /Do not say the milestone is complete/);
+  assert.match(prompt, /VERIFICATION FAILED/);
+  assert.doesNotMatch(prompt, /emit only one closeout line: "Milestone M001 complete\."/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -80,6 +80,20 @@ function createTempProject(): { basePath: string; planPath: string } {
   return { basePath, planPath };
 }
 
+function writeProjectPreferences(basePath: string, yaml: string): void {
+  fs.writeFileSync(path.join(basePath, '.gsd', 'PREFERENCES.md'), `---\n${yaml}---\n`);
+}
+
+async function withWorkingDirectory<T>(cwd: string, action: () => Promise<T>): Promise<T> {
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await action();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
 function makeValidParams() {
   return {
     taskId: 'T01',
@@ -104,6 +118,13 @@ function makeValidParams() {
   };
 }
 
+function makeEscalationOptions() {
+  return [
+    { id: 'continue', label: 'Continue', tradeoffs: 'Keeps execution moving with the default path.' },
+    { id: 'pause', label: 'Pause', tradeoffs: 'Stops execution until the blocker is reviewed.' },
+  ];
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: Fresh DB is migrated to the current schema version
 // ═══════════════════════════════════════════════════════════════════════════
@@ -359,6 +380,105 @@ console.log('\n=== complete-task: handler happy path ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: hard-blocker escalation with mid-execution escalation disabled
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: disabled hard-blocker escalation rolls back completion ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath } = createTempProject();
+  writeProjectPreferences(basePath, 'phases:\n  mid_execution_escalation: false\n');
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+  const params = {
+    ...makeValidParams(),
+    blockerDiscovered: true,
+    escalation: {
+      question: 'Should execution pause for the hard blocker?',
+      options: makeEscalationOptions(),
+      recommendation: 'pause',
+      recommendationRationale: 'The blocker should not be silently advanced.',
+      continueWithDefault: false,
+    },
+  };
+
+  const result = await withWorkingDirectory(basePath, () => handleCompleteTask(params, basePath));
+
+  assertTrue('error' in result, 'hard-blocker escalation should fail when escalation handling is disabled');
+  if ('error' in result) {
+    assertMatch(result.error, /hard-blocker escalation/, 'error should mention hard-blocker escalation');
+    assertMatch(result.error, /mid_execution_escalation is disabled/, 'error should mention disabled preference');
+  }
+
+  const task = getTask('M001', 'S01', 'T01');
+  assertTrue(task !== null, 'task row should remain after rollback');
+  assertEq(task!.status, 'pending', 'task status should be rolled back to pending');
+  assertEq(task!.blocker_discovered, true, 'blocker flag should remain recorded for visibility');
+  assertEq(task!.escalation_pending, 0, 'disabled preference should not create a pending escalation flag');
+  assertEq(task!.escalation_awaiting_review, 0, 'disabled preference should not create an awaiting-review flag');
+
+  const adapter = _getAdapter()!;
+  const evRows = adapter.prepare(
+    "SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'"
+  ).all();
+  assertEq(evRows.length, 0, 'verification evidence should be deleted when completion rolls back');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: soft escalation with mid-execution escalation disabled
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: disabled soft escalation still completes ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath } = createTempProject();
+  writeProjectPreferences(basePath, 'phases:\n  mid_execution_escalation: false\n');
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+  const params = {
+    ...makeValidParams(),
+    escalation: {
+      question: 'Should execution continue with the default?',
+      options: makeEscalationOptions(),
+      recommendation: 'continue',
+      recommendationRationale: 'The default path is safe enough to continue.',
+      continueWithDefault: true,
+    },
+  };
+
+  const result = await withWorkingDirectory(basePath, () => handleCompleteTask(params, basePath));
+
+  assertTrue(!('error' in result), 'soft escalation should still complete when escalation handling is disabled');
+  if (!('error' in result)) {
+    assertTrue(!result.escalation, 'disabled preference should not return escalation metadata');
+  }
+
+  const task = getTask('M001', 'S01', 'T01');
+  assertTrue(task !== null, 'task row should exist');
+  assertEq(task!.status, 'complete', 'soft escalation should leave task complete');
+
+  const adapter = _getAdapter()!;
+  const evRows = adapter.prepare(
+    "SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'"
+  ).all();
+  assertEq(evRows.length, 1, 'verification evidence should remain for soft escalation completion');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: Handler validation errors
 // ═══════════════════════════════════════════════════════════════════════════
@@ -414,6 +534,9 @@ console.log('\n=== complete-task: handler idempotency ===');
   // First call should succeed
   const r1 = await handleCompleteTask(params, basePath);
   assertTrue(!('error' in r1), 'first call should succeed');
+  if ('error' in r1) {
+    throw new Error(r1.error);
+  }
 
   // Verify complete-task did not duplicate T01. S01-PLAN.md is a projection,
   // so the remaining plan task is not imported implicitly.
@@ -421,16 +544,29 @@ console.log('\n=== complete-task: handler idempotency ===');
   assertEq(tasks.length, 1, 'should only have the completed DB task after first call');
   assertEq(tasks.filter(t => t.id === 'T01').length, 1, 'should have exactly one T01 row after first call');
 
-  // Second call with same params — state machine guard rejects (task is already complete)
+  // If the DB row is complete but the projection was lost, the duplicate call
+  // should repair the missing summary from full_summary_md instead of forcing a
+  // reopen/re-complete loop.
+  fs.unlinkSync(r1.summaryPath);
+  assertTrue(!fs.existsSync(r1.summaryPath), 'fixture should remove the task summary before repair');
   const r2 = await handleCompleteTask(params, basePath);
-  assertTrue('error' in r2, 'second call should return error (task already complete)');
+  assertTrue(!('error' in r2), 'second call should repair missing summary for DB-complete task');
   if ('error' in r2) {
-    assertMatch(r2.error, /already complete/, 'error should mention already complete');
+    throw new Error(r2.error);
+  }
+  assertTrue(fs.existsSync(r2.summaryPath), 'missing summary should be restored on disk');
+  assertEq(r2.duplicate, true, 'repair should be reported as a duplicate/no-op state mutation');
+
+  // Third call with the summary present — state machine guard rejects (task is already complete)
+  const r3 = await handleCompleteTask(params, basePath);
+  assertTrue('error' in r3, 'third call should return error (task already complete)');
+  if ('error' in r3) {
+    assertMatch(r3.error, /already complete/, 'error should mention already complete');
   }
 
-  // Still no duplicate rows from the rejected second call.
+  // Still no duplicate rows from the repair or rejected third call.
   const tasksAfter = getSliceTasks('M001', 'S01');
-  assertEq(tasksAfter.length, 1, 'should still only have T01 after rejected second call');
+  assertEq(tasksAfter.length, 1, 'should still only have T01 after duplicate repair and rejected third call');
   assertEq(tasksAfter.filter(t => t.id === 'T01').length, 1, 'should still have exactly one T01 row');
 
   cleanupDir(basePath);

package/src/resources/extensions/gsd/tests/core-overlay-fallback.test.ts

@@ -13,6 +13,7 @@ function makeCtx(customResult: unknown) {
   const customCalls: Array<{ options: any }> = [];
   return {
     hasUI: true,
+    modelRegistry: { getAvailable: () => [] },
     ui: {
       custom: async (_factory: unknown, options: any) => {
         customCalls.push({ options });