gsd-pi 2.80.0-dev.2be7caf18 → 2.80.0-dev.3065f7bfa

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

@@ -542,6 +542,60 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  // Regression: #5500. The LLM occasionally hallucinates files in
+  // task.keyFiles that were never written. Pre-existing scoped-stage code
+  // ran `git add -- <every keyFile>` and failed the entire commit on the
+  // first missing path. Verify that valid paths still commit and missing
+  // ones are dropped silently.
+  test('GitServiceImpl: scoped staging drops missing keyFiles and commits the rest', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "src/index.ts", "export const ok = true;");
+    // Note: src/commands/list.ts is intentionally NOT created — the LLM
+    // claimed it wrote this file but didn't.
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T02", [], {
+      taskId: "S01/T02",
+      taskTitle: "wire up command list",
+      oneLiner: "Added list command stub",
+      keyFiles: ["src/index.ts", "src/commands/list.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit succeeds when at least one keyFile exists");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(committed.includes("src/index.ts"), "existing key file is committed");
+    assert.ok(!committed.includes("src/commands/list.ts"), "missing key file is silently dropped");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  // Regression: #5500. When ALL keyFiles are bogus, scopedStageTaskFiles
+  // must return false so autoCommit falls back to smartStage. The commit
+  // still goes out (using `git add -A` semantics) instead of failing.
+  test('GitServiceImpl: all missing keyFiles falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "src/actually-changed.ts", "export const real = true;");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T03", [], {
+      taskId: "S01/T03",
+      taskTitle: "fix path handling",
+      oneLiner: "Hardened path resolution",
+      keyFiles: ["src/wrong/path-1.ts", "src/wrong/path-2.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit falls back to smartStage when all keyFiles are missing");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(
+      committed.includes("src/actually-changed.ts"),
+      "smartStage fallback stages real dirty files when scoped staging finds nothing",
+    );
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── GitServiceImpl: empty-after-staging guard ─────────────────────────
 
   test('GitServiceImpl: empty-after-staging guard', () => {

package/src/resources/extensions/gsd/tests/isolation-none-branch-guard.test.ts

@@ -52,9 +52,12 @@ describe('isolation:none stale branch guard (#3675)', () => {
   });
 
   test('guard is wrapped in try-catch (non-fatal)', () => {
-    // Find the milestone/ check and verify it is inside a try block
-    const milestoneIdx = source.indexOf('startsWith("milestone/")');
-    assert.ok(milestoneIdx > 0, 'milestone/ check should exist');
+    // Pin to the specific guard usage (`currentBranch.startsWith(...)`) so
+    // unrelated occurrences of `startsWith("milestone/")` elsewhere in the
+    // file (e.g. branch-name iteration helpers added later) don't shift the
+    // index and break this structural assertion.
+    const milestoneIdx = source.indexOf('currentBranch.startsWith("milestone/")');
+    assert.ok(milestoneIdx > 0, 'isolation:none guard milestone/ check should exist');
     const before = source.slice(Math.max(0, milestoneIdx - 500), milestoneIdx);
     assert.match(before, /try\s*\{/,
       'milestone branch guard should be inside a try block');

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/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/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: () => "",