gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.6b9da3e

package/src/resources/extensions/gsd/tests/derive-state-db-disk-reconcile.test.ts

@@ -0,0 +1,121 @@
+/**
+ * derive-state-db-disk-reconcile.test.ts — #2416
+ *
+ * After migration to DB-backed state, milestones that exist on disk
+ * (in .gsd/milestones/) but were never imported into the DB become
+ * invisible to deriveStateFromDb(). This test verifies that
+ * deriveStateFromDb reconciles disk milestones with DB milestones.
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-disk-reconcile-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, ".gsd", relativePath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+const CONTEXT_CONTENT = `# M002: Disk-Only Milestone
+
+This milestone exists on disk but not in the DB.
+
+## Must-Haves
+- Something important
+`;
+
+const ROADMAP_CONTENT = `# M002: Disk-Only Milestone
+
+**Vision:** Test disk reconciliation.
+
+## Slices
+
+- [ ] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > Do something.
+`;
+
+async function main(): Promise<void> {
+  console.log("\n=== #2416: deriveStateFromDb reconciles disk milestones ===");
+
+  // Set up: M001 in DB, M002 on disk only
+  const base = createFixtureBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+
+  try {
+    openDatabase(dbPath);
+
+    // M001 is in the DB with a complete status
+    insertMilestone({ id: "M001", title: "M001: DB Milestone", status: "complete", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "S01: Done Slice", status: "complete", depends: [] });
+
+    // Write M001 summary on disk (marks it complete on filesystem too)
+    writeFile(base, "milestones/M001/SUMMARY.md", "# M001: DB Milestone\n\nDone.");
+
+    // M002 exists ONLY on disk, not in DB
+    writeFile(base, "milestones/M002/CONTEXT.md", CONTEXT_CONTENT);
+    writeFile(base, "milestones/M002/ROADMAP.md", ROADMAP_CONTENT);
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    // M002 should be visible in the registry
+    const m002Entry = state.registry.find((m) => m.id === "M002");
+    assertTrue(
+      m002Entry !== undefined,
+      "M002 (disk-only milestone) should appear in state.registry (#2416)",
+    );
+
+    // M001 should still be in the registry
+    const m001Entry = state.registry.find((m) => m.id === "M001");
+    assertTrue(
+      m001Entry !== undefined,
+      "M001 (DB milestone) should still appear in state.registry",
+    );
+
+    // The active milestone should be M002 (since M001 is complete)
+    assertTrue(
+      state.activeMilestone !== null,
+      "There should be an active milestone",
+    );
+    if (state.activeMilestone) {
+      assertEq(
+        state.activeMilestone.id,
+        "M002",
+        "Active milestone should be M002 (disk-only, not complete) (#2416)",
+      );
+    }
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+
+  report();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/derive-state-db.test.ts

@@ -11,6 +11,7 @@ import {
   insertArtifact,
   isDbAvailable,
   insertMilestone,
+  getAllMilestones,
   insertSlice,
   insertTask,
 } from '../gsd-db.ts';
@@ -962,4 +963,63 @@ describe('derive-state-db', async () => {
       cleanup(base);
     }
   });
+
+  // ─── Regression: disk-only milestones synced into DB (#2416) ─────────
+  test('derive-state-db: disk-only milestone auto-synced into DB (#2416)', async () => {
+    const base = createFixtureBase();
+    try {
+      // M001 is complete and exists in DB. M002 was queued on disk only — no DB row.
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
+      writeFile(base, 'milestones/M002/M002-CONTEXT.md', '# M002: Queued\n\nQueued milestone.');
+
+      openDatabase(':memory:');
+      // Only insert M001 — simulates the state after migration guard ran then /gsd queue added M002
+      insertMilestone({ id: 'M001', title: 'First', status: 'complete' });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      // Before the fix, M002 was invisible: getAllMilestones() returned only M001
+      // (complete) → phase='complete' → auto-mode stopped.
+      // After the fix, deriveStateFromDb reconciles disk dirs and inserts M002.
+      assert.deepStrictEqual(state.phase, 'pre-planning', 'disk-sync-2416: phase is pre-planning, not complete');
+      assert.deepStrictEqual(state.registry.length, 2, 'disk-sync-2416: both milestones visible in registry');
+      assert.deepStrictEqual(state.registry[0]?.id, 'M001', 'disk-sync-2416: registry[0] is M001');
+      assert.deepStrictEqual(state.registry[0]?.status, 'complete', 'disk-sync-2416: M001 is complete');
+      assert.deepStrictEqual(state.registry[1]?.id, 'M002', 'disk-sync-2416: registry[1] is M002');
+      assert.deepStrictEqual(state.registry[1]?.status, 'active', 'disk-sync-2416: M002 is active');
+      assert.deepStrictEqual(state.activeMilestone?.id, 'M002', 'disk-sync-2416: activeMilestone is M002');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  // ─── Queued milestone row not clobbered by later plan (#2416 root cause) ──
+  test('derive-state-db: queued milestone row survives gsd_plan_milestone INSERT OR IGNORE', async () => {
+    try {
+      openDatabase(':memory:');
+
+      // Simulates gsd_milestone_generate_id inserting a minimal queued row
+      insertMilestone({ id: 'M001', status: 'queued' });
+
+      const before = getAllMilestones();
+      assert.equal(before.length, 1, 'queued-row: one row after generate_id');
+      assert.equal(before[0]!.status, 'queued', 'queued-row: status is queued');
+
+      // Simulates gsd_plan_milestone calling insertMilestone (INSERT OR IGNORE)
+      insertMilestone({ id: 'M001', title: 'Planned Title', status: 'active' });
+
+      const after = getAllMilestones();
+      assert.equal(after.length, 1, 'queued-row: still one row after plan');
+      // INSERT OR IGNORE keeps the original row — status stays 'queued'
+      assert.equal(after[0]!.status, 'queued', 'queued-row: INSERT OR IGNORE preserves original status');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/est-annotation-timeout.test.ts

@@ -0,0 +1,120 @@
+/**
+ * est-annotation-timeout.test.ts — Regression tests for #2243.
+ *
+ * Tasks with `est: 30m` or `est: 2h` annotations should get extended
+ * supervision timeouts. The parseEstimateMinutes helper should parse
+ * estimate strings, and startUnitSupervision should use them.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const timersSrcPath = join(import.meta.dirname, "..", "auto-timers.ts");
+const timersSrc = readFileSync(timersSrcPath, "utf-8");
+
+// ─── Source analysis: parseEstimateMinutes exists and is exported ────────────
+
+test("#2243: auto-timers.ts should export parseEstimateMinutes", () => {
+  assert.ok(
+    timersSrc.includes("export function parseEstimateMinutes"),
+    "parseEstimateMinutes should be exported from auto-timers.ts",
+  );
+});
+
+// ─── Inline unit test of parseEstimateMinutes logic ─────────────────────────
+// Since importing the module pulls in heavy deps, test the parsing logic inline.
+
+function parseEstimateMinutes(estimate: string): number | null {
+  if (!estimate || typeof estimate !== "string") return null;
+  const trimmed = estimate.trim();
+  if (!trimmed) return null;
+
+  let totalMinutes = 0;
+  let matched = false;
+
+  const hoursMatch = trimmed.match(/(\d+)\s*h/i);
+  if (hoursMatch) {
+    totalMinutes += Number(hoursMatch[1]) * 60;
+    matched = true;
+  }
+
+  const minutesMatch = trimmed.match(/(\d+)\s*m/i);
+  if (minutesMatch) {
+    totalMinutes += Number(minutesMatch[1]);
+    matched = true;
+  }
+
+  return matched ? totalMinutes : null;
+}
+
+test("#2243: parseEstimateMinutes parses '30m' correctly", () => {
+  assert.equal(parseEstimateMinutes("30m"), 30);
+});
+
+test("#2243: parseEstimateMinutes parses '2h' correctly", () => {
+  assert.equal(parseEstimateMinutes("2h"), 120);
+});
+
+test("#2243: parseEstimateMinutes parses '1h30m' correctly", () => {
+  assert.equal(parseEstimateMinutes("1h30m"), 90);
+});
+
+test("#2243: parseEstimateMinutes parses '15m' correctly", () => {
+  assert.equal(parseEstimateMinutes("15m"), 15);
+});
+
+test("#2243: parseEstimateMinutes returns null for empty string", () => {
+  assert.equal(parseEstimateMinutes(""), null);
+});
+
+test("#2243: parseEstimateMinutes returns null for invalid string", () => {
+  assert.equal(parseEstimateMinutes("not a time"), null);
+});
+
+// ─── Source analysis: startUnitSupervision uses task estimates ───────────────
+
+test("#2243: startUnitSupervision should reference task estimates for timeout scaling", () => {
+  const usesEstimate =
+    timersSrc.includes("parseEstimateMinutes") &&
+    timersSrc.includes("estimateMinutes") &&
+    timersSrc.includes("taskEstimate");
+
+  assert.ok(
+    usesEstimate,
+    "startUnitSupervision should use task estimate annotations for timeout scaling",
+  );
+});
+
+test("#2243: SupervisionContext should accept an optional taskEstimate field", () => {
+  const ctxIdx = timersSrc.indexOf("SupervisionContext");
+  assert.ok(ctxIdx !== -1, "SupervisionContext interface exists");
+
+  const ctxEnd = timersSrc.indexOf("}", ctxIdx);
+  const ctxBlock = timersSrc.slice(ctxIdx, ctxEnd);
+
+  assert.ok(
+    ctxBlock.includes("taskEstimate"),
+    "SupervisionContext should include a taskEstimate field",
+  );
+});
+
+test("#2243: timeouts should be scaled by estimate (timeoutScale in source)", () => {
+  assert.ok(
+    timersSrc.includes("timeoutScale"),
+    "auto-timers.ts should use a timeoutScale factor derived from est: annotations",
+  );
+});
+
+test("#2243: idle timeout should NOT be scaled (idle is idle regardless of estimate)", () => {
+  // Find the idleTimeoutMs line
+  const idleIdx = timersSrc.indexOf("const idleTimeoutMs");
+  assert.ok(idleIdx !== -1, "idleTimeoutMs variable exists");
+  
+  const idleLine = timersSrc.slice(idleIdx, timersSrc.indexOf("\n", idleIdx));
+  assert.ok(
+    !idleLine.includes("timeoutScale"),
+    "idleTimeoutMs should NOT be scaled — idle is idle",
+  );
+});

package/src/resources/extensions/gsd/tests/infra-error.test.ts

@@ -7,10 +7,13 @@ import { isInfrastructureError, INFRA_ERROR_CODES } from "../auto/infra-errors.j
 // ── INFRA_ERROR_CODES constant ───────────────────────────────────────────────
 
 test("INFRA_ERROR_CODES contains the expected codes", () => {
-  for (const code of ["ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE", "ENFILE"]) {
+  for (const code of [
+    "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE", "ENFILE",
+    "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+  ]) {
     assert.ok(INFRA_ERROR_CODES.has(code), `missing ${code}`);
   }
-  assert.equal(INFRA_ERROR_CODES.size, 6, "unexpected extra codes");
+  assert.equal(INFRA_ERROR_CODES.size, 9, "unexpected extra codes");
 });
 
 // ── isInfrastructureError: code property detection ───────────────────────────
@@ -45,6 +48,21 @@ test("detects ENFILE via code property", () => {
   assert.equal(isInfrastructureError(err), "ENFILE");
 });
 
+test("detects ECONNREFUSED via code property", () => {
+  const err = Object.assign(new Error("connect ECONNREFUSED 127.0.0.1:3000"), { code: "ECONNREFUSED" });
+  assert.equal(isInfrastructureError(err), "ECONNREFUSED");
+});
+
+test("detects ENOTFOUND via code property", () => {
+  const err = Object.assign(new Error("getaddrinfo ENOTFOUND api.example.com"), { code: "ENOTFOUND" });
+  assert.equal(isInfrastructureError(err), "ENOTFOUND");
+});
+
+test("detects ENETUNREACH via code property", () => {
+  const err = Object.assign(new Error("connect ENETUNREACH 2607:f8b0:4004::"), { code: "ENETUNREACH" });
+  assert.equal(isInfrastructureError(err), "ENETUNREACH");
+});
+
 // ── isInfrastructureError: message fallback ──────────────────────────────────
 
 test("falls back to message scanning when no code property", () => {

package/src/resources/extensions/gsd/tests/inherited-repo-home-dir.test.ts

@@ -0,0 +1,121 @@
+/**
+ * inherited-repo-home-dir.test.ts — Regression test for #2393.
+ *
+ * When the user's home directory IS a git repo (common with dotfile
+ * managers like yadm), isInheritedRepo() must not treat ~/.gsd (the
+ * global GSD state directory) as a project .gsd belonging to the home
+ * repo. Without the fix, isInheritedRepo() returns false for project
+ * subdirectories because it sees ~/.gsd and concludes the parent repo
+ * has already been initialised with GSD — causing the wrong project
+ * state to be loaded.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  realpathSync,
+  symlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { isInheritedRepo } from "../repo-identity.ts";
+
+function run(cmd: string, args: string[], cwd: string): string {
+  return execFileSync(cmd, args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+describe("isInheritedRepo when git root is HOME (#2393)", () => {
+  let fakeHome: string;
+  let stateDir: string;
+  let origGsdHome: string | undefined;
+  let origGsdStateDir: string | undefined;
+
+  beforeEach(() => {
+    // Create a fake HOME that is itself a git repo (dotfile manager scenario).
+    fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-home-repo-")));
+    run("git", ["init", "-b", "main"], fakeHome);
+    run("git", ["config", "user.name", "Test"], fakeHome);
+    run("git", ["config", "user.email", "test@example.com"], fakeHome);
+    writeFileSync(join(fakeHome, ".bashrc"), "# dotfiles\n", "utf-8");
+    run("git", ["add", ".bashrc"], fakeHome);
+    run("git", ["commit", "-m", "init dotfiles"], fakeHome);
+
+    // Create a plain ~/.gsd directory at fakeHome — this simulates the
+    // global GSD home directory, NOT a project .gsd.
+    mkdirSync(join(fakeHome, ".gsd", "projects"), { recursive: true });
+
+    // Save and override env. Point GSD_HOME at fakeHome/.gsd so the
+    // function recognizes it as the global state directory.
+    origGsdHome = process.env.GSD_HOME;
+    origGsdStateDir = process.env.GSD_STATE_DIR;
+    process.env.GSD_HOME = join(fakeHome, ".gsd");
+    stateDir = mkdtempSync(join(tmpdir(), "gsd-state-"));
+    process.env.GSD_STATE_DIR = stateDir;
+  });
+
+  afterEach(() => {
+    if (origGsdHome !== undefined) process.env.GSD_HOME = origGsdHome;
+    else delete process.env.GSD_HOME;
+    if (origGsdStateDir !== undefined) process.env.GSD_STATE_DIR = origGsdStateDir;
+    else delete process.env.GSD_STATE_DIR;
+
+    rmSync(fakeHome, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+  });
+
+  test("subdirectory of home-as-git-root is detected as inherited even when ~/.gsd exists", () => {
+    // Create a project directory inside fake HOME
+    const projectDir = join(fakeHome, "projects", "my-app");
+    mkdirSync(projectDir, { recursive: true });
+
+    // The bug: isInheritedRepo sees ~/.gsd and returns false, thinking
+    // the home repo is a legitimate GSD project. It should return true
+    // because ~/.gsd is the global state dir, not a project .gsd.
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      true,
+      "project inside home-as-git-root must be detected as inherited repo, " +
+      "even when ~/.gsd (global state dir) exists",
+    );
+  });
+
+  test("subdirectory with a real project .gsd symlink at git root is NOT inherited", () => {
+    // Simulate a legitimately initialised GSD project at the home repo root:
+    // .gsd is a symlink to an external state directory.
+    const externalState = join(stateDir, "projects", "home-project");
+    mkdirSync(externalState, { recursive: true });
+    const gsdDir = join(fakeHome, ".gsd");
+
+    // Remove the plain directory and replace with a symlink (real project .gsd)
+    rmSync(gsdDir, { recursive: true, force: true });
+    symlinkSync(externalState, gsdDir);
+
+    const projectDir = join(fakeHome, "projects", "my-app");
+    mkdirSync(projectDir, { recursive: true });
+
+    // When .gsd at root IS a project symlink, subdirectories are legitimate children
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      false,
+      "subdirectory of a legitimately-initialised GSD project should NOT be inherited",
+    );
+  });
+
+  test("home-as-git-root itself is never inherited", () => {
+    assert.strictEqual(
+      isInheritedRepo(fakeHome),
+      false,
+      "the git root itself is never inherited",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/mcp-status.test.ts

@@ -0,0 +1,103 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatMcpStatusReport,
+  formatMcpServerDetail,
+  type McpServerStatus,
+} from "../commands-mcp-status.ts";
+
+// ─── formatMcpStatusReport ──────────────────────────────────────────────────
+
+describe("formatMcpStatusReport", () => {
+  test("returns no-servers message when list is empty", () => {
+    const result = formatMcpStatusReport([]);
+    assert.match(result, /no mcp servers configured/i);
+  });
+
+  test("lists all servers with connection status", () => {
+    const servers: McpServerStatus[] = [
+      { name: "railway", transport: "stdio", connected: true, toolCount: 5, error: undefined },
+      { name: "linear", transport: "http", connected: false, toolCount: 0, error: undefined },
+    ];
+    const result = formatMcpStatusReport(servers);
+    assert.match(result, /railway/);
+    assert.match(result, /linear/);
+    assert.match(result, /connected/i);
+    assert.match(result, /disconnected/i);
+    assert.match(result, /5 tools/);
+  });
+
+  test("shows error state for servers with errors", () => {
+    const servers: McpServerStatus[] = [
+      { name: "broken", transport: "stdio", connected: false, toolCount: 0, error: "Connection refused" },
+    ];
+    const result = formatMcpStatusReport(servers);
+    assert.match(result, /error/i);
+    assert.match(result, /Connection refused/);
+  });
+
+  test("includes server count in header", () => {
+    const servers: McpServerStatus[] = [
+      { name: "a", transport: "stdio", connected: true, toolCount: 3, error: undefined },
+      { name: "b", transport: "http", connected: true, toolCount: 2, error: undefined },
+    ];
+    const result = formatMcpStatusReport(servers);
+    assert.match(result, /2/);
+  });
+});
+
+// ─── formatMcpServerDetail ──────────────────────────────────────────────────
+
+describe("formatMcpServerDetail", () => {
+  test("shows server name and transport", () => {
+    const result = formatMcpServerDetail({
+      name: "railway",
+      transport: "stdio",
+      connected: true,
+      toolCount: 3,
+      tools: ["railway_list_projects", "railway_deploy", "railway_logs"],
+      error: undefined,
+    });
+    assert.match(result, /railway/);
+    assert.match(result, /stdio/);
+  });
+
+  test("lists individual tools when available", () => {
+    const result = formatMcpServerDetail({
+      name: "railway",
+      transport: "stdio",
+      connected: true,
+      toolCount: 2,
+      tools: ["railway_list_projects", "railway_deploy"],
+      error: undefined,
+    });
+    assert.match(result, /railway_list_projects/);
+    assert.match(result, /railway_deploy/);
+  });
+
+  test("shows error message for failed servers", () => {
+    const result = formatMcpServerDetail({
+      name: "broken",
+      transport: "stdio",
+      connected: false,
+      toolCount: 0,
+      tools: [],
+      error: "spawn ENOENT",
+    });
+    assert.match(result, /error/i);
+    assert.match(result, /spawn ENOENT/);
+  });
+
+  test("shows disconnected status with no tools", () => {
+    const result = formatMcpServerDetail({
+      name: "offline",
+      transport: "http",
+      connected: false,
+      toolCount: 0,
+      tools: [],
+      error: undefined,
+    });
+    assert.match(result, /disconnected/i);
+  });
+});

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

@@ -0,0 +1,66 @@
+/**
+ * merge-conflict-stops-loop.test.ts — #2330
+ *
+ * When a squash merge has real code conflicts (not just .gsd/ files),
+ * the merge retries forever because MergeConflictError is caught
+ * silently in mergeAndExit. This test verifies that:
+ * 1. worktree-resolver re-throws MergeConflictError for code conflicts
+ * 2. auto/phases.ts wraps mergeAndExit calls to stop the loop on conflict
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const resolverPath = join(import.meta.dirname, "..", "worktree-resolver.ts");
+const resolverSrc = readFileSync(resolverPath, "utf-8");
+
+const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesPath, "utf-8");
+
+console.log("\n=== #2330: Merge conflict stops auto loop ===");
+
+// ── Test 1: worktree-resolver re-throws MergeConflictError ──────────────
+
+const methodStart = resolverSrc.indexOf("Worktree-mode merge:");
+assertTrue(methodStart > 0, "worktree-resolver has _mergeWorktreeMode method");
+
+const methodBody = resolverSrc.slice(methodStart, methodStart + 5000);
+const rethrowsConflict =
+  methodBody.includes("MergeConflictError") &&
+  methodBody.includes("throw err");
+
+assertTrue(
+  rethrowsConflict,
+  "worktree-resolver._mergeWorktreeMode re-throws MergeConflictError (#2330)",
+);
+
+// ── Test 2: auto/phases.ts imports and uses MergeConflictError ──────────
+
+assertTrue(
+  phasesSrc.includes("MergeConflictError") && phasesSrc.includes("mergeAndExit"),
+  "auto/phases.ts handles MergeConflictError from mergeAndExit (#2330)",
+);
+
+// ── Test 3: The handler stops the loop (doesn't just warn) ──────────────
+
+// Find the instanceof MergeConflictError check (not the import line)
+const instanceofIdx = phasesSrc.indexOf("instanceof MergeConflictError");
+assertTrue(instanceofIdx > 0, "auto/phases.ts has instanceof MergeConflictError check");
+
+if (instanceofIdx > 0) {
+  const afterHandler = phasesSrc.slice(instanceofIdx, instanceofIdx + 500);
+  const stopsLoop =
+    afterHandler.includes("stopAuto") ||
+    afterHandler.includes('action: "break"') ||
+    afterHandler.includes("reason: \"merge-conflict\"");
+
+  assertTrue(
+    stopsLoop,
+    "auto/phases.ts stops the loop when merge conflict is detected (#2330)",
+  );
+}
+
+report();

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -147,12 +147,12 @@ test("plan-slice prompt no longer frames direct PLAN writes as the source of tru
   assert.match(prompt, /Do \*\*not\*\* rely on direct `PLAN\.md` writes as the source of truth/i);
 });
 
-test("plan-slice prompt explicitly names gsd_plan_slice and gsd_plan_task as DB-backed planning tools", () => {
+test("plan-slice prompt explicitly names gsd_plan_slice as DB-backed planning tool", () => {
   const prompt = readPrompt("plan-slice");
   assert.match(prompt, /gsd_plan_slice/);
   assert.match(prompt, /gsd_plan_task/);
-  // The prompt should describe these as the canonical write path
-  assert.match(prompt, /DB-backed tools are the canonical write path/i);
+  // The prompt should describe the DB-backed tool as the canonical write path
+  assert.match(prompt, /DB-backed tool is the canonical write path/i);
 });
 
 test("plan-slice prompt does not instruct direct file writes as a primary step", () => {
@@ -161,14 +161,18 @@ test("plan-slice prompt does not instruct direct file writes as a primary step",
   assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{outputPath\}\}`?\s*$/m);
 });
 
-test("plan-slice prompt instructs calling gsd_plan_task for each task", () => {
+test("plan-slice prompt clarifies gsd_plan_slice handles task persistence", () => {
   const prompt = readPrompt("plan-slice");
-  assert.match(prompt, /call `gsd_plan_task` for each task/i);
+  // gsd_plan_slice persists tasks in its transaction — no separate gsd_plan_task calls needed
+  assert.match(prompt, /gsd_plan_task/);
+  assert.match(prompt, /gsd_plan_slice` handles task persistence/i);
 });
 
-test("replan-slice prompt requires DB-backed planning state when available", () => {
+test("replan-slice prompt uses gsd_replan_slice as canonical DB-backed tool", () => {
   const prompt = readPrompt("replan-slice");
-  assert.match(prompt, /DB-backed planning tool exists for this phase, use it as the source of truth/i);
+  assert.match(prompt, /gsd_replan_slice/);
+  // Degraded fallback (direct file writes) was removed — DB tools are always available
+  assert.doesNotMatch(prompt, /Degraded fallback/i);
 });
 
 test("reassess-roadmap prompt references gsd_reassess_roadmap tool", () => {