gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -85,7 +85,11 @@ function makeMockDeps(
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => ({ units: [] }),
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,
@@ -399,6 +403,240 @@ test("runDispatch pauses when complete-milestone summary exists on disk but the
   assert.equal(stopCalls, 0, "mismatch pause should not hard-stop the loop");
 });
 
+test("runDispatch pauses when execute-task artifacts exist but DB status is still open", async (t) => {
+  const capture = createEventCapture();
+  let pauseCalls = 0;
+  let stopCalls = 0;
+  let invalidateCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-execute-task-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: First task** `est:1h`",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone on disk.\n");
+
+  const deps = makeMockDeps(capture, {
+    pauseAuto: async () => { pauseCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    invalidateAllCaches: () => { invalidateCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "execute the task",
+      matchedRule: "executing → execute-task",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "T01", title: "First task" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "execute-task/M001/S01/T01" },
+      { key: "execute-task/M001/S01/T01" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
+  assert.equal(pauseCalls, 1, "execute-task disk/db mismatch should pause auto-mode");
+  assert.equal(stopCalls, 0, "execute-task disk/db mismatch should not hard-stop the loop");
+  assert.equal(invalidateCalls, 0, "mismatch should not clear caches and continue toward redispatch");
+  assert.equal(loopState.recentUnits.length, 3, "mismatch should keep the stuck window intact");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "mismatch should not reset the recovery counter");
+});
+
+test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB status is still open", async (t) => {
+  const capture = createEventCapture();
+  let pauseCalls = 0;
+  let stopCalls = 0;
+  let invalidateCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-execute-task-l2-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01\n\n## Tasks\n\n- [x] **T01: First task** `est:1h`\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone on disk.\n");
+
+  const deps = makeMockDeps(capture, {
+    pauseAuto: async () => { pauseCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    invalidateAllCaches: () => { invalidateCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "execute the task",
+      matchedRule: "executing execute-task",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "T01", title: "First task" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "execute-task/M001/S01/T01" },
+      { key: "execute-task/M001/S01/T01" },
+    ],
+    stuckRecoveryAttempts: 1,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
+  assert.equal(pauseCalls, 1, "Level 2 execute-task disk/db mismatch should pause auto-mode");
+  assert.equal(stopCalls, 0, "Level 2 execute-task disk/db mismatch should not hard-stop the loop");
+  assert.equal(invalidateCalls, 1, "Level 2 should invalidate caches before the final artifact recheck");
+  assert.equal(loopState.recentUnits.length, 3, "Level 2 mismatch should keep the stuck window intact");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 2 mismatch should not reset the recovery counter");
+});
+
+test("runDispatch clears execute-task stuck state when artifacts and DB status are complete", async (t) => {
+  const capture = createEventCapture();
+  let pauseCalls = 0;
+  let stopCalls = 0;
+  let invalidateCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-execute-task-complete-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "complete" });
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01\n\n## Tasks\n\n- [x] **T01: First task** `est:1h`\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone on disk.\n");
+
+  const deps = makeMockDeps(capture, {
+    pauseAuto: async () => { pauseCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    invalidateAllCaches: () => { invalidateCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "execute the task",
+      matchedRule: "executing execute-task",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "T01", title: "First task" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "execute-task/M001/S01/T01" },
+      { key: "execute-task/M001/S01/T01" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(pauseCalls, 0, "closed DB task should not pause auto-mode");
+  assert.equal(stopCalls, 0, "closed DB task should not hard-stop the loop");
+  assert.equal(invalidateCalls, 1, "closed DB task recovery should invalidate caches once");
+  assert.deepEqual(loopState.recentUnits, [], "closed DB task recovery should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "closed DB task recovery should reset the recovery counter");
+});
+
 test("runDispatch clears stuck state after Level 1 artifact recovery", async (t) => {
   const capture = createEventCapture();
   let invalidateCalls = 0;

package/src/resources/extensions/gsd/tests/journal-query-tool.test.ts

@@ -52,6 +52,16 @@ async function executeToolInDir(tool: any, params: Record<string, unknown>, dir:
   }
 }
 
+async function executeToolWithContextRoot(tool: any, params: Record<string, unknown>, processDir: string, contextRoot: string) {
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(processDir);
+    return await tool.execute("test-call-id", params, undefined, undefined, { cwd: contextRoot });
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
 // ─── Registration ─────────────────────────────────────────────────────────────
 
 test("registerJournalTools registers gsd_journal_query tool", () => {
@@ -126,6 +136,28 @@ test("gsd_journal_query respects limit parameter", async () => {
   }
 });
 
+test("gsd_journal_query uses context cwd instead of process cwd", async () => {
+  const processBase = makeTmpBase();
+  const contextBase = makeTmpBase();
+  try {
+    emitJournalEvent(processBase, makeEntry({ seq: 0, flowId: "process-flow" }));
+    emitJournalEvent(contextBase, makeEntry({ seq: 0, flowId: "context-flow" }));
+
+    const pi = makeMockPi();
+    registerJournalTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolWithContextRoot(tool, { limit: 5 }, processBase, contextBase);
+    const entries = JSON.parse(result.content[0].text) as JournalEntry[];
+
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].flowId, "context-flow");
+  } finally {
+    cleanup(processBase);
+    cleanup(contextBase);
+  }
+});
+
 // ─── Error Handling ───────────────────────────────────────────────────────────
 
 test("gsd_journal_query handles errors gracefully", async () => {

package/src/resources/extensions/gsd/tests/knowledge.test.ts

@@ -249,6 +249,28 @@ test('loadKnowledgeBlock: reports globalSizeKb above 4KB threshold', () => {
   rmSync(tmp, { recursive: true, force: true });
 });
 
+test('loadKnowledgeBlock: caps repeated system prompt knowledge by default with source path', () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-kb-')));
+  const gsdHome = join(tmp, 'home');
+  const cwd = join(tmp, 'project');
+  mkdirSync(join(cwd, '.gsd'), { recursive: true });
+  mkdirSync(join(gsdHome, 'agent'), { recursive: true });
+  writeFileSync(join(cwd, '.gsd', 'KNOWLEDGE.md'), `K001: ${'large project knowledge '.repeat(1200)}`);
+
+  const original = process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+  delete process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+  try {
+    const result = loadKnowledgeBlock(gsdHome, cwd);
+    assert.ok(result.block.includes('Source: `'));
+    assert.ok(result.block.length <= 12_500, `knowledge block ${result.block.length} should stay near default cap`);
+    assert.ok(result.block.includes('[Knowledge Truncated]'));
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+    else process.env.PI_GSD_KNOWLEDGE_MAX_CHARS = original;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 // ─── inlineKnowledgeBudgeted — issue #4719 ─────────────────────────────────
 // Milestone-phase prompts must not inject the full KNOWLEDGE.md. The budgeted
 // helper scopes by milestone-level keywords and caps the injected size.
@@ -315,6 +337,31 @@ test('inlineKnowledgeBudgeted: caps payload below budget for large files', async
   rmSync(tmp, { recursive: true, force: true });
 });
 
+test('inlineKnowledgeBudgeted: default budget keeps auto prompt knowledge compact', async () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  const entries = Array.from({ length: 300 }, (_, i) =>
+    `### Entry ${i}: shared topic\n${'default budget filler '.repeat(25)}\n`,
+  ).join('\n');
+  writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), `# Project Knowledge\n\n## Patterns\n\n${entries}`);
+
+  const result = await inlineKnowledgeBudgeted(tmp, ['shared']);
+  assert.ok(result !== null, 'should return content');
+  assert.ok(
+    result!.length <= 12_500,
+    `default payload ${result!.length} chars should stay near the 12k budget`,
+  );
+  assert.match(
+    result!,
+    /\[\.\.\.truncated \d+ chars; rerun with narrower scope if needed\]/,
+    'should include truncation note when default budget is exceeded',
+  );
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
 test('inlineKnowledgeBudgeted: returns null when no KNOWLEDGE.md exists', async () => {
   const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
   const gsdDir = join(tmp, '.gsd');

package/src/resources/extensions/gsd/tests/lazy-pi-tui-import.test.ts

@@ -1,15 +1,53 @@
-// Structural contract: shared/mod.ts must never import @gsd/pi-tui.
-// TUI-dependent exports live in shared/tui.ts instead.
+// GSD2 — Shared barrel import behavior without TUI dependency loading
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-test("shared/mod.ts has no import from @gsd/pi-tui", () => {
-  const src = readFileSync(join(__dirname, "../../shared/mod.ts"), "utf-8");
-  assert.ok(!src.includes("@gsd/pi-tui"), "mod.ts must not import @gsd/pi-tui");
+test("shared/mod.ts imports without resolving @gsd/pi-tui", () => {
+  const tmp = mkdtempSync(join(process.env.TMPDIR ?? "/tmp", "gsd-shared-mod-"));
+  const loaderPath = join(tmp, "block-pi-tui-loader.mjs");
+  writeFileSync(
+    loaderPath,
+    [
+      "export async function resolve(specifier, context, nextResolve) {",
+      "  if (specifier === '@gsd/pi-tui') throw new Error('unexpected @gsd/pi-tui import');",
+      "  return nextResolve(specifier, context);",
+      "}",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  try {
+    const sharedModPath = join(__dirname, "../../shared/mod.ts");
+    const resolveTsPath = join(__dirname, "resolve-ts.mjs");
+    const result = spawnSync(
+      process.execPath,
+      [
+        "--experimental-strip-types",
+        "--import",
+        resolveTsPath,
+        "--experimental-loader",
+        loaderPath,
+        "--input-type=module",
+        "--eval",
+        `await import(${JSON.stringify(sharedModPath)});`,
+      ],
+      { encoding: "utf-8" },
+    );
+
+    assert.equal(
+      result.status,
+      0,
+      `shared/mod.ts should import without @gsd/pi-tui; stderr:\n${result.stderr}`,
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/memory-decay-factor.test.ts

@@ -0,0 +1,90 @@
+// gsd-2 / memoryDecayFactor unit tests
+//
+// Pure-function boundary tests for the V28 time-decay scoring helper.
+// The function maps last_hit_at → multiplier in [0.7, 1.0] used by
+// queryMemoriesRanked to down-weight stale memories without fully suppressing
+// them. These tests pin the contract:
+//
+//   - null / invalid / future timestamps → 1.0 (no decay penalty)
+//   - 0 days ago → 1.0
+//   - linear decay between 0 and 90 days
+//   - 90+ days ago → 0.7 floor
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { memoryDecayFactor } from "../memory-store.ts";
+
+const DAY_MS = 86_400_000;
+
+function isoDaysAgo(days: number): string {
+  return new Date(Date.now() - days * DAY_MS).toISOString();
+}
+
+test("memoryDecayFactor: null lastHitAt returns 1.0 (never-hit = no decay)", () => {
+  assert.equal(memoryDecayFactor(null), 1.0);
+});
+
+test("memoryDecayFactor: invalid timestamp string returns 1.0 (defensive)", () => {
+  assert.equal(memoryDecayFactor("not-a-date"), 1.0);
+  assert.equal(memoryDecayFactor(""), 1.0);
+});
+
+test("memoryDecayFactor: future timestamp clamps to daysAgo=0 → 1.0", () => {
+  // Clock skew or manual DB edits can yield future last_hit_at values.
+  // The factor must stay within [0.7, 1.0] regardless.
+  const future = new Date(Date.now() + 30 * DAY_MS).toISOString();
+  const factor = memoryDecayFactor(future);
+  assert.ok(factor <= 1.0, `factor must not exceed 1.0, got ${factor}`);
+  assert.ok(factor >= 0.7, `factor must not fall below 0.7, got ${factor}`);
+  assert.equal(factor, 1.0);
+});
+
+test("memoryDecayFactor: 0 days ago returns 1.0", () => {
+  const factor = memoryDecayFactor(new Date().toISOString());
+  // Tiny clock drift between now-string and Date.now() inside the function;
+  // assert it's effectively 1.0 within float tolerance.
+  assert.ok(Math.abs(factor - 1.0) < 1e-6, `expected ≈1.0, got ${factor}`);
+});
+
+test("memoryDecayFactor: 30 days ago returns ~0.90 (linear midpoint)", () => {
+  // Formula: 1.0 - 0.3 * (30/90) = 1.0 - 0.1 = 0.90
+  const factor = memoryDecayFactor(isoDaysAgo(30));
+  assert.ok(Math.abs(factor - 0.90) < 1e-3, `expected ≈0.90, got ${factor}`);
+});
+
+test("memoryDecayFactor: 60 days ago returns ~0.80", () => {
+  // Formula: 1.0 - 0.3 * (60/90) = 1.0 - 0.2 = 0.80
+  const factor = memoryDecayFactor(isoDaysAgo(60));
+  assert.ok(Math.abs(factor - 0.80) < 1e-3, `expected ≈0.80, got ${factor}`);
+});
+
+test("memoryDecayFactor: 90 days ago returns 0.70 (floor)", () => {
+  const factor = memoryDecayFactor(isoDaysAgo(90));
+  assert.ok(Math.abs(factor - 0.70) < 1e-3, `expected ≈0.70, got ${factor}`);
+});
+
+test("memoryDecayFactor: 180 days ago stays at 0.70 floor", () => {
+  const factor = memoryDecayFactor(isoDaysAgo(180));
+  assert.equal(factor, 0.70);
+});
+
+test("memoryDecayFactor: result always in [0.7, 1.0] for any input", () => {
+  const samples: (string | null)[] = [
+    null,
+    "",
+    "garbage",
+    new Date(0).toISOString(),
+    isoDaysAgo(0),
+    isoDaysAgo(15),
+    isoDaysAgo(45),
+    isoDaysAgo(89),
+    isoDaysAgo(91),
+    isoDaysAgo(365),
+    new Date(Date.now() + 365 * DAY_MS).toISOString(),
+  ];
+  for (const s of samples) {
+    const f = memoryDecayFactor(s);
+    assert.ok(f >= 0.7 && f <= 1.0, `factor out of [0.7, 1.0] for ${s}: ${f}`);
+  }
+});

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -5,16 +5,11 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { decideMemoryPressure } from "../auto/workflow-kernel.ts";
+import { completeWorkflowIteration } from "../auto/workflow-iteration-completion.ts";
 import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
-
 describe("memory pressure monitoring (#3331)", () => {
   test("measureMemoryPressure reports pressure above threshold", () => {
     const snapshot = measureMemoryPressure({
@@ -41,10 +36,6 @@ describe("memory pressure monitoring (#3331)", () => {
     assert.equal(snapshot.pressured, true);
   });
 
-  test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
-    assert.match(loopSource, /iteration\s*%\s*MEMORY_CHECK_INTERVAL\s*===\s*0/);
-  });
-
   test("memory pressure triggers graceful stopAuto", () => {
     const decision = decideMemoryPressure({
       pressured: true,
@@ -60,34 +51,29 @@ describe("memory pressure monitoring (#3331)", () => {
 });
 
 describe("stuck detection persistence (#3704)", () => {
-  test("loadStuckState function exists", () => {
-    assert.match(loopSource, /function loadStuckState/);
-  });
-
-  test("saveStuckState function exists", () => {
-    assert.match(loopSource, /function saveStuckState/);
-  });
-
-  // Phase C: API changed from (basePath) to (session) — recentUnits is
-  // now reconstructed from unit_dispatches and stuckRecoveryAttempts
-  // persists in runtime_kv (worker scope).
-  test("loopState initialized from persisted state", () => {
-    assert.match(loopSource, /loadStuckState\(s\)/);
-  });
-
-  test("stuck state saved after each iteration", () => {
-    assert.match(loopSource, /saveStuckState\(s,\s*loopState\)/);
-  });
-
   // Phase C: stuck-state.json file IO deleted; persistence moved to
   // unit_dispatches (recentUnits) + runtime_kv (stuckRecoveryAttempts).
   // The stuck-state-via-db.test.ts suite covers the round-trip.
 
-  test("completeIteration centralizes stuck-state persistence for both loop paths (#4382)", () => {
-    assert.match(loopSource, /const completeIteration = \(\): void =>/);
-    assert.match(loopSource, /completeWorkflowIteration\(/);
-    assert.match(loopSource, /saveStuckState:\s*\(\)\s*=>\s*saveStuckState\(s,\s*loopState\)/);
-    assert.match(loopSource, /completeIteration,/);
-    assert.match(loopSource, /completeIteration\(\);/);
+  test("completeWorkflowIteration saves stuck state while clearing recovery counters (#4382)", () => {
+    const calls: string[] = [];
+    const state = {
+      consecutiveErrors: 2,
+      consecutiveCooldowns: 1,
+      recentErrorMessages: ["boom"],
+    };
+
+    completeWorkflowIteration(state, {
+      emitIterationEnd: () => calls.push("emit"),
+      saveStuckState: () => calls.push("save"),
+      logIterationComplete: () => calls.push("log"),
+    });
+
+    assert.deepEqual(calls, ["emit", "save", "log"]);
+    assert.deepEqual(state, {
+      consecutiveErrors: 0,
+      consecutiveCooldowns: 0,
+      recentErrorMessages: [],
+    });
   });
 });

package/src/resources/extensions/gsd/tests/merge-conflict-stops-loop.test.ts

@@ -70,6 +70,7 @@ function makeDeps(
     getAutoWorktreePath: () => null,
     autoCommitCurrentBranch: () => undefined,
     getCurrentBranch: () => "worktree/M001",
+    checkoutBranch: () => undefined,
     autoWorktreeBranch: (mid: string) => `worktree/${mid}`,
     resolveMilestoneFile: () => null, // no roadmap → early return path
     readFileSync: () => "",

package/src/resources/extensions/gsd/tests/migrate-writer-integration.test.ts

@@ -13,6 +13,9 @@ import { parseRoadmap, parsePlan } from '../parsers-legacy.ts';
 import { parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
 import { invalidateAllCaches } from '../cache.ts';
+import { ensureDbOpen } from '../bootstrap/dynamic-tools.ts';
+import { closeDatabase, getAllMilestones } from '../gsd-db.ts';
+import { importWrittenMigrationToDb } from '../migrate/command.ts';
 import type {
   GSDProject,
   GSDMilestone,
@@ -250,6 +253,51 @@ test('Scenario 1: Incomplete project — write, parse, deriveState', async () =>
     }
 });
 
+test('Scenario 1b: written migration imports into authoritative DB state', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-db-import-'));
+    try {
+      const project = buildIncompleteProject();
+      await writeGSDDirectory(project, base);
+
+      assert.equal(await ensureDbOpen(base), true, 'db import: ensureDbOpen creates authoritative DB');
+
+      invalidateAllCaches();
+      const before = await deriveState(base);
+      assert.equal(before.activeMilestone, null, 'db import: markdown-only migration is invisible before DB import');
+
+      const imported = await importWrittenMigrationToDb(base);
+      assert.deepStrictEqual(imported.hierarchy, { milestones: 1, slices: 2, tasks: 3 }, 'db import: hierarchy counts');
+
+      invalidateAllCaches();
+      const after = await deriveState(base);
+      assert.deepStrictEqual(after.phase, 'executing', 'db import: deriveState sees imported DB hierarchy');
+      assert.deepStrictEqual(after.activeMilestone?.id, 'M001', 'db import: active milestone');
+      assert.deepStrictEqual(after.activeSlice?.id, 'S02', 'db import: active slice');
+      assert.deepStrictEqual(after.activeTask?.id, 'T03', 'db import: active task');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
+});
+
+test('Scenario 1c: DB import verification fails when preview counts do not match', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-db-check-'));
+    try {
+      const project = buildIncompleteProject();
+      await writeGSDDirectory(project, base);
+
+      const preview = generatePreview(project);
+      await assert.rejects(
+        () => importWrittenMigrationToDb(base, { ...preview, totalTasks: preview.totalTasks + 1 }),
+        /migration DB import verification failed: tasks 3\/4/,
+      );
+      assert.deepStrictEqual(getAllMilestones(), [], 'db import: failed verification rolls back hierarchy rewrite');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
+});
+
   // ─── Scenario 2: Fully complete project ────────────────────────────────
 
 test('Scenario 2: Fully complete project — deriveState phase', async () => {