gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/workflow-logger-wiring.test.ts

@@ -1,131 +1,58 @@
-// GSD Extension — workflow-logger wiring regression tests
-//
-// Verifies the plumbing between workflow-logger and the rest of the state
-// system (auto-loop phases, detect-stuck, notification store). Without this
-// wiring, warnings/errors logged during a unit leak across units, never
-// reach the user as a consolidated post-unit alert, and don't enrich
-// stuck-detection reasons.
+// GSD-2 — workflow-logger behavior regression tests.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
 import {
-  logWarning,
+  drainAndSummarize,
+  formatForNotification,
+  hasAnyIssues,
   logError,
+  logWarning,
   peekLogs,
   _resetLogs,
   setStderrLoggingEnabled,
 } from "../workflow-logger.ts";
 import { detectStuck } from "../auto/detect-stuck.ts";
 
-const phasesSrc = readFileSync(
-  join(import.meta.dirname, "..", "auto", "phases.ts"),
-  "utf-8",
-);
-const autoSrc = readFileSync(
-  join(import.meta.dirname, "..", "auto.ts"),
-  "utf-8",
-);
+test("drainAndSummarize summarizes and clears the workflow log buffer", () => {
+  const previous = setStderrLoggingEnabled(false);
+  try {
+    _resetLogs();
+    logWarning("projection", "STATE.md render failed", { file: "STATE.md" });
+    logError("db", "WAL checkpoint failed");
 
-// ─── Source-scan: phases.ts calls the logger lifecycle API ─────────────────
+    assert.equal(hasAnyIssues(), true);
+    const drained = drainAndSummarize();
 
-test("auto/phases.ts imports _resetLogs, drainAndSummarize, formatForNotification, hasAnyIssues", () => {
-  assert.match(
-    phasesSrc,
-    /from\s+"\.\.\/workflow-logger\.js"/,
-    "phases.ts imports from workflow-logger",
-  );
-  for (const name of [
-    "_resetLogs",
-    "drainLogs",
-    "drainAndSummarize",
-    "formatForNotification",
-    "hasAnyIssues",
-  ]) {
-    assert.ok(
-      phasesSrc.includes(name),
-      `phases.ts should reference ${name}`,
-    );
+    assert.equal(drained.logs.length, 2);
+    assert.match(drained.summary ?? "", /STATE\.md render failed/);
+    assert.match(drained.summary ?? "", /WAL checkpoint failed/);
+    assert.equal(peekLogs().length, 0);
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
   }
 });
 
-test("runUnitPhase calls _resetLogs() before assigning s.currentUnit", () => {
-  // Find the "s.currentUnit = { type: unitType" assignment line and check
-  // the preceding ~500 chars contain a _resetLogs() call.
-  const idx = phasesSrc.indexOf("s.currentUnit = { type: unitType");
-  assert.ok(idx > 0, "runUnitPhase should assign s.currentUnit");
-  const before = phasesSrc.slice(Math.max(0, idx - 500), idx);
-  assert.match(
-    before,
-    /_resetLogs\(\)/,
-    "_resetLogs() must be called immediately before s.currentUnit assignment",
-  );
-});
-
-test("runFinalize drains and surfaces logger buffer via ctx.ui.notify", () => {
-  // Locate the runFinalize success path and verify it calls drainAndSummarize
-  // and routes the result through ctx.ui.notify.
-  const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
-  assert.ok(runFinalizeIdx > 0, "runFinalize export should exist");
-  const finalizeBody = phasesSrc.slice(runFinalizeIdx);
-  assert.match(
-    finalizeBody,
-    /hasAnyIssues\(\)/,
-    "runFinalize should gate drain on hasAnyIssues",
-  );
-  assert.match(
-    finalizeBody,
-    /drainAndSummarize\(\)/,
-    "runFinalize should call drainAndSummarize on success",
-  );
-  assert.match(
-    finalizeBody,
-    /formatForNotification\(logs\)/,
-    "runFinalize should format drained logs for the notification",
-  );
-});
-
-test("runFinalize timeout branches drain the buffer to prevent bleed", () => {
-  // Both timeout branches route through failClosedOnFinalizeTimeout; that
-  // helper must drain the buffer so timed-out unit logs do not bleed into
-  // the next unit.
-  const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
-  const finalizeBody = phasesSrc.slice(runFinalizeIdx);
-  const timeoutHelperCalls =
-    (finalizeBody.match(/failClosedOnFinalizeTimeout\(/g) ?? []).length;
-  assert.ok(
-    timeoutHelperCalls >= 2,
-    `runFinalize timeout branches should each route through failClosedOnFinalizeTimeout() (found ${timeoutHelperCalls}, expected >= 2)`,
-  );
-
-  const helperMatch = phasesSrc.match(
-    /async function failClosedOnFinalizeTimeout[\s\S]*?drainLogs\(\)/,
-  );
-  assert.ok(
-    helperMatch,
-    "failClosedOnFinalizeTimeout should drain the logger buffer before returning",
-  );
-});
-
-// ─── Source-scan: auto.ts calls setLogBasePath in startAuto ────────────────
-
-test("startAuto calls setLogBasePath(base) so audit log is pinned on resume", () => {
-  const startAutoIdx = autoSrc.indexOf("export async function startAuto");
-  assert.ok(startAutoIdx > 0, "startAuto export should exist");
-  const body = autoSrc.slice(startAutoIdx);
-  assert.match(
-    body,
-    /setLogBasePath\(base\)/,
-    "startAuto must call setLogBasePath(base) to pin the audit log",
-  );
+test("formatForNotification includes component and useful context", () => {
+  const text = formatForNotification([
+    {
+      ts: "2026-01-01T00:00:00.000Z",
+      severity: "warn",
+      component: "projection",
+      message: "render failed",
+      context: { file: "STATE.md", command: "derive" },
+    },
+  ]);
+
+  assert.match(text, /\[projection\] render failed/);
+  assert.match(text, /file: STATE\.md/);
+  assert.match(text, /command: derive/);
 });
 
-// ─── Runtime: detect-stuck enriches reason with summarizeLogs() ────────────
-
 test("detectStuck reason includes workflow-logger summary when logs present", () => {
-  setStderrLoggingEnabled(false);
+  const previous = setStderrLoggingEnabled(false);
   try {
     _resetLogs();
     logWarning("projection", "STATE.md render failed");
@@ -138,37 +65,18 @@ test("detectStuck reason includes workflow-logger summary when logs present", ()
 
     assert.notEqual(result, null);
     assert.equal(result!.stuck, true);
-    assert.match(
-      result!.reason,
-      /Same error repeated:/,
-      "reason should still start with the rule string",
-    );
-    assert.match(
-      result!.reason,
-      /STATE\.md render failed/,
-      "reason should include the accumulated logger warning",
-    );
-    assert.match(
-      result!.reason,
-      /WAL checkpoint failed/,
-      "reason should include the accumulated logger error",
-    );
-
-    // Critical: summarizeLogs must not drain — the auto-loop's finalize
-    // step owns the buffer lifecycle, detect-stuck is read-only.
-    assert.equal(
-      peekLogs().length,
-      2,
-      "detect-stuck must not drain the buffer",
-    );
+    assert.match(result!.reason, /Same error repeated:/);
+    assert.match(result!.reason, /STATE\.md render failed/);
+    assert.match(result!.reason, /WAL checkpoint failed/);
+    assert.equal(peekLogs().length, 2, "detect-stuck must not drain the buffer");
   } finally {
     _resetLogs();
-    setStderrLoggingEnabled(true);
+    setStderrLoggingEnabled(previous);
   }
 });
 
 test("detectStuck reason unchanged when logger buffer is empty", () => {
-  setStderrLoggingEnabled(false);
+  const previous = setStderrLoggingEnabled(false);
   try {
     _resetLogs();
     const result = detectStuck([
@@ -176,62 +84,9 @@ test("detectStuck reason unchanged when logger buffer is empty", () => {
       { key: "A", error: "boom" },
     ]);
     assert.notEqual(result, null);
-    // No trailing " — " suffix when there are no logs to summarize.
-    assert.doesNotMatch(
-      result!.reason,
-      / — \d+ (error|warning)/,
-      "reason should have no logger suffix when buffer is empty",
-    );
+    assert.doesNotMatch(result!.reason, / — \d+ (error|warning)/);
   } finally {
-    setStderrLoggingEnabled(true);
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
   }
 });
-
-// ─── Runtime: readTransaction rollback failure surfaces via logError ────────
-//
-// snapshotState now delegates its transaction to readTransaction() in
-// gsd-db.ts (single-writer refactor in #4198), so the split-brain
-// ROLLBACK-failure log lives there, not in workflow-manifest.ts.
-
-test("readTransaction logs ROLLBACK failures as split-brain signal", () => {
-  const dbSrc = readFileSync(
-    join(import.meta.dirname, "..", "gsd-db.ts"),
-    "utf-8",
-  );
-  assert.match(
-    dbSrc,
-    /logError\("db",\s*"snapshotState ROLLBACK failed"/,
-    "readTransaction ROLLBACK catch should call logError",
-  );
-});
-
-// ─── Runtime: startup/projection diagnostics stay explicit ─────────────────
-
-test("auto-start initializes the DB without implicit markdown migration", () => {
-  const autoStartSrc = readFileSync(
-    join(import.meta.dirname, "..", "auto-start.ts"),
-    "utf-8",
-  );
-  assert.doesNotMatch(
-    autoStartSrc,
-    /migrateFromMarkdown|md-importer/,
-    "auto-start must not import markdown into the runtime DB implicitly",
-  );
-  assert.match(
-    autoStartSrc,
-    /failed to initialize project database/,
-    "DB initialization failures should still be logged",
-  );
-});
-
-test("workflow-projections.ts logs DB probe failures instead of silent return", () => {
-  const projectionsSrc = readFileSync(
-    join(import.meta.dirname, "..", "workflow-projections.ts"),
-    "utf-8",
-  );
-  assert.match(
-    projectionsSrc,
-    /logWarning\("projection",\s*"renderStateProjection: DB handle probe failed/,
-    "renderStateProjection DB probe should log on failure",
-  );
-});

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

@@ -1,9 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -18,29 +17,11 @@ import {
   usesWorkflowMcpTransport,
 } from "../workflow-mcp.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
-
 type ElicitPayload = {
   message: string;
   requestedSchema: { properties: Record<string, unknown>; required?: string[] };
 };
 
-function readSrc(file: string): string {
-  return readFileSync(join(gsdDir, file), "utf-8");
-}
-
-function listTsFiles(dir: string): string[] {
-  const out: string[] = [];
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    const stat = statSync(full);
-    if (stat.isDirectory()) out.push(...listTsFiles(full));
-    else if (entry.endsWith(".ts")) out.push(full);
-  }
-  return out;
-}
-
 function extractElicitPayload(request: unknown): ElicitPayload {
   const payload = (request as { params?: unknown }).params ?? request;
   return payload as ElicitPayload;
@@ -759,39 +740,3 @@ test("transport compatibility still blocks units whose MCP tools are not exposed
   assert.match(error ?? "", /requires secure_env_collect/);
   assert.match(error ?? "", /currently exposes only/);
 });
-
-test("guided-flow source enforces workflow compatibility preflight", () => {
-  const src = readSrc("guided-flow.ts");
-  assert.match(src, /getRequiredWorkflowToolsForGuidedUnit/);
-  assert.match(src, /getWorkflowTransportSupportError/);
-});
-
-test("auto direct dispatch source enforces workflow compatibility preflight", () => {
-  const src = readSrc("auto-direct-dispatch.ts");
-  assert.match(src, /getRequiredWorkflowToolsForAutoUnit/);
-  assert.match(src, /getWorkflowTransportSupportError/);
-});
-
-test("auto phases source enforces workflow compatibility preflight", () => {
-  const src = readSrc(join("auto", "phases.ts"));
-  assert.match(src, /getRequiredWorkflowToolsForAutoUnit/);
-  assert.match(src, /getWorkflowTransportSupportError/);
-  assert.match(src, /workflow-capability/);
-});
-
-test("workflow transport error guidance includes /gsd mcp init hint", () => {
-  const src = readSrc("workflow-mcp.ts");
-  assert.match(src, /Please run \/gsd mcp init \./);
-});
-
-test("buildWorkflowMcpServers is only imported by tests or Claude Code MCP boundary code", () => {
-  const offenders: string[] = [];
-  for (const file of listTsFiles(gsdDir)) {
-    const rel = file.slice(gsdDir.length + 1).replace(/\\/g, "/");
-    if (rel === "workflow-mcp.ts" || rel.startsWith("tests/")) continue;
-    const src = readFileSync(file, "utf-8");
-    if (/\bimport\b[\s\S]*\bbuildWorkflowMcpServers\b/.test(src)) offenders.push(rel);
-  }
-
-  assert.deepEqual(offenders, []);
-});

package/src/resources/extensions/gsd/tests/workflow-protocol-excerpt.test.ts

@@ -0,0 +1,99 @@
+// Project/App: GSD-2
+// File Purpose: Tests for capped GSD workflow protocol and doctor-heal payload helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  buildDoctorHealIssuePayload,
+  buildDoctorHealSummary,
+  buildWorkflowDispatchContent,
+  buildWorkflowProtocolExcerpt,
+} from "../workflow-protocol.ts";
+
+test("workflow protocol helper emits capped excerpt plus source path", () => {
+  const workflow = `# Protocol\n${"FULL_WORKFLOW_BODY ".repeat(500)}`;
+  const excerpt = buildWorkflowProtocolExcerpt(workflow, "/tmp/GSD-WORKFLOW.md", { maxChars: 1200 });
+
+  assert.match(excerpt, /Source: `\/tmp\/GSD-WORKFLOW\.md`/);
+  assert.match(excerpt, /\[Workflow Protocol Truncated\]/);
+  assert.ok(excerpt.length < workflow.length);
+  assert.ok(excerpt.length < 1600);
+});
+
+test("workflow dispatch uses excerpt instead of full workflow body", () => {
+  const workflow = `# Protocol\n${"FULL_WORKFLOW_BODY ".repeat(500)}`;
+  const content = buildWorkflowDispatchContent({
+    workflow,
+    workflowPath: "/tmp/GSD-WORKFLOW.md",
+    task: "Run the selected unit.",
+    maxProtocolChars: 1200,
+  });
+
+  assert.match(content, /## GSD Workflow Protocol Excerpt/);
+  assert.match(content, /## Your Task/);
+  assert.match(content, /Run the selected unit/);
+  assert.ok(content.length < workflow.length);
+});
+
+test("workflow protocol excerpt includes late verification and advance rules", () => {
+  const workflow = [
+    "# GSD Workflow",
+    "intro",
+    "## Quick Start",
+    "quick",
+    "## File Format Reference",
+    "format ".repeat(400),
+    "## The Phases",
+    "phase overview",
+    "### Phase 4: Execute",
+    "execute rules",
+    "### Phase 5: Verify",
+    "verification rules",
+    "### Phase 7: Advance",
+    "advance rules",
+  ].join("\n");
+
+  const excerpt = buildWorkflowProtocolExcerpt(workflow, "/tmp/GSD-WORKFLOW.md", { maxChars: 1300 });
+
+  assert.match(excerpt, /Quick Start/);
+  assert.match(excerpt, /Phase 5: Verify/);
+  assert.match(excerpt, /Phase 7: Advance/);
+  assert.doesNotMatch(excerpt, /format format format format format/);
+});
+
+test("doctor heal summary omits duplicated full report body", () => {
+  const report = [
+    "# GSD doctor heal prep.",
+    "Scope: M001",
+    "Status: warning",
+    "Warnings: 9",
+    "",
+    "VERY_LONG_FULL_REPORT_BODY ".repeat(300),
+  ].join("\n");
+
+  const summary = buildDoctorHealSummary(report, { maxChars: 900 });
+
+  assert.match(summary, /GSD doctor heal prep/);
+  assert.match(summary, /Warnings: 9/);
+  assert.ok(summary.length <= 900);
+  assert.doesNotMatch(summary, /VERY_LONG_FULL_REPORT_BODY VERY_LONG_FULL_REPORT_BODY VERY_LONG_FULL_REPORT_BODY/);
+});
+
+test("doctor heal issue payload keeps top actionable issues and caps detail", () => {
+  const issues = Array.from({ length: 20 }, (_, index) =>
+    `### Issue ${index + 1}\n${`detail ${index + 1} `.repeat(80)}`,
+  ).join("\n");
+
+  const payload = buildDoctorHealIssuePayload(issues, {
+    maxIssues: 3,
+    maxIssueChars: 180,
+    maxChars: 900,
+  });
+
+  assert.match(payload, /Issue 1/);
+  assert.match(payload, /Issue 3/);
+  assert.doesNotMatch(payload, /Issue 4/);
+  assert.match(payload, /17 additional actionable issue/);
+  assert.ok(payload.length <= 900);
+});

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -165,6 +165,9 @@ test("executeMilestoneStatus returns milestone metadata and slice counts", async
     assert.equal(parsed.sliceCount, 1);
     assert.equal(parsed.slices[0].id, "S01");
     assert.equal(parsed.slices[0].taskCounts.pending, 1);
+    assert.equal(result.details.status, "active");
+    assert.equal(result.details.title, "Milestone One");
+    assert.deepEqual(result.details.slices, parsed.slices);
   } finally {
     closeDatabase();
     cleanup(base);

package/src/resources/extensions/gsd/tests/workflow-worker-heartbeat.test.ts

@@ -14,9 +14,11 @@ function makeDeps(overrides?: Partial<MaintainWorkerHeartbeatDeps>): {
   deps: MaintainWorkerHeartbeatDeps;
   calls: unknown[];
   errors: unknown[];
+  misses: unknown[];
 } {
   const calls: unknown[] = [];
   const errors: unknown[] = [];
+  const misses: unknown[] = [];
   const deps: MaintainWorkerHeartbeatDeps = {
     heartbeatAutoWorker: workerId => calls.push(["heartbeat", workerId]),
     refreshMilestoneLease: (workerId, milestoneId, token) => {
@@ -24,9 +26,10 @@ function makeDeps(overrides?: Partial<MaintainWorkerHeartbeatDeps>): {
       return true;
     },
     logHeartbeatFailure: err => errors.push(err),
+    logLeaseRefreshMiss: details => misses.push(details),
     ...overrides,
   };
-  return { deps, calls, errors };
+  return { deps, calls, errors, misses };
 }
 
 test("maintainWorkerHeartbeat no-ops without a worker id", () => {
@@ -121,3 +124,31 @@ test("maintainWorkerHeartbeat logs and suppresses lease refresh failures", () =>
   ]);
   assert.deepEqual(errors, [failure]);
 });
+
+test("maintainWorkerHeartbeat clears stale lease tokens when refresh misses", () => {
+  const { deps, calls, errors, misses } = makeDeps({
+    refreshMilestoneLease: (workerId, milestoneId, token) => {
+      calls.push(["refresh", workerId, milestoneId, token]);
+      return false;
+    },
+  });
+  const session: WorkerHeartbeatSession = {
+    workerId: "worker-1",
+    currentMilestoneId: "M001",
+    milestoneLeaseToken: 7,
+  };
+
+  maintainWorkerHeartbeat(session, deps);
+
+  assert.deepEqual(calls, [
+    ["heartbeat", "worker-1"],
+    ["refresh", "worker-1", "M001", 7],
+  ]);
+  assert.deepEqual(errors, []);
+  assert.deepEqual(misses, [{
+    workerId: "worker-1",
+    milestoneId: "M001",
+    fencingToken: 7,
+  }]);
+  assert.equal(session.milestoneLeaseToken, null);
+});

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -1,13 +1,4 @@
-/**
- * worktree-db-same-file.test.ts — Regression test for #2823.
- *
- * Verifies that reconcileWorktreeDb() does not ATTACH a WAL-mode DB file
- * to itself when the worktree DB path resolves to the same physical file
- * as the main DB path (shared-WAL / symlink layout).
- *
- * Also verifies that the auto-loop classifies "database disk image is
- * malformed" as an infrastructure error to prevent wasting retries.
- */
+// GSD-2 — Worktree DB same-file reconciliation regression tests.
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
@@ -15,10 +6,8 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
-  readFileSync,
   rmSync,
   symlinkSync,
-  writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -29,10 +18,11 @@ import {
   reconcileWorktreeDb,
   insertDecision,
 } from "../gsd-db.ts";
+import {
+  _shouldReconcileWorktreeDb,
+} from "../auto-worktree.ts";
 import { isInfrastructureError } from "../auto/infra-errors.ts";
 
-// ─── Fix 1 & 2: reconcileWorktreeDb same-file guard ─────────────────
-
 describe("#2823: reconcileWorktreeDb same-file guard", () => {
   let tmpDir: string;
 
@@ -50,7 +40,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
     mkdirSync(mainGsd, { recursive: true });
     const mainDbPath = join(mainGsd, "gsd.db");
 
-    // Create a real DB at mainDbPath
     openDatabase(mainDbPath);
     insertDecision({
       id: "D001",
@@ -64,17 +53,14 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
       superseded_by: null,
     });
 
-    // Create a worktree path that resolves to the same file via symlink
     const wtGsd = join(tmpDir, "worktree", ".gsd");
     mkdirSync(join(tmpDir, "worktree"), { recursive: true });
     symlinkSync(mainGsd, wtGsd, "junction");
     const worktreeDbPath = join(wtGsd, "gsd.db");
 
-    // Both paths exist and resolve to the same physical file
     assert.ok(existsSync(mainDbPath), "main DB exists");
-    assert.ok(existsSync(worktreeDbPath), "worktree DB path exists (via symlink)");
+    assert.ok(existsSync(worktreeDbPath), "worktree DB path exists via symlink");
 
-    // This should NOT attempt ATTACH — should return zero result
     const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
 
     assert.equal(result.decisions, 0, "no decisions reconciled");
@@ -101,7 +87,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
       superseded_by: null,
     });
 
-    // Same exact path — should bail immediately
     const result = reconcileWorktreeDb(dbPath, dbPath);
 
     assert.equal(result.decisions, 0);
@@ -109,7 +94,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
   });
 
   test("still reconciles when paths are genuinely different files", () => {
-    // Main DB
     const mainGsd = join(tmpDir, "main", ".gsd");
     mkdirSync(mainGsd, { recursive: true });
     const mainDbPath = join(mainGsd, "gsd.db");
@@ -128,7 +112,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
     });
     closeDatabase();
 
-    // Create a separate worktree DB with different data
     const wtGsd = join(tmpDir, "worktree", ".gsd");
     mkdirSync(wtGsd, { recursive: true });
     const worktreeDbPath = join(wtGsd, "gsd.db");
@@ -147,42 +130,36 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
     });
     closeDatabase();
 
-    // Re-open main and reconcile — should work normally
     openDatabase(mainDbPath);
     const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
 
-    assert.ok(
-      result.decisions > 0,
-      "should reconcile decisions from a genuinely different DB",
-    );
+    assert.ok(result.decisions > 0, "should reconcile decisions from a different DB");
   });
 });
 
-test("merge-time DB reconciliation only runs when legacy worktree DB exists", () => {
-  const src = readFileSync(join(import.meta.dirname, "..", "auto-worktree.ts"), "utf-8");
-  const reconcileIdx = src.indexOf("reconcileWorktreeDb(mainDbPath, worktreeDbPath)");
-  assert.ok(reconcileIdx !== -1, "merge-time reconcile call exists");
-  const guardWindow = src.slice(Math.max(0, reconcileIdx - 240), reconcileIdx);
-
-  assert.ok(
-    guardWindow.includes("existsSync(worktreeDbPath)") && guardWindow.includes("!isSamePath(worktreeDbPath, mainDbPath)"),
-    "merge-time reconcile requires a real legacy worktree DB and distinct DB paths",
+test("merge-time DB reconciliation requires an existing distinct worktree DB", () => {
+  assert.equal(
+    _shouldReconcileWorktreeDb("worktree.db", "main.db", () => true, () => false),
+    true,
+  );
+  assert.equal(
+    _shouldReconcileWorktreeDb("worktree.db", "main.db", () => false, () => false),
+    false,
+  );
+  assert.equal(
+    _shouldReconcileWorktreeDb("worktree.db", "main.db", () => true, () => true),
+    false,
   );
 });
 
-// ─── Fix 3: infrastructure error classification ─────────────────────
-
 describe("#2823: malformed DB classified as infrastructure error", () => {
   test("database disk image is malformed is detected as infra error", () => {
-    const err = new Error("database disk image is malformed");
-    const code = isInfrastructureError(err);
-    assert.ok(code !== null, "should be classified as infrastructure error");
+    const code = isInfrastructureError(new Error("database disk image is malformed"));
     assert.equal(code, "SQLITE_CORRUPT");
   });
 
   test("other SQLite errors are not falsely classified", () => {
-    const err = new Error("SQLITE_BUSY: database is locked");
-    const code = isInfrastructureError(err);
-    assert.equal(code, null, "SQLITE_BUSY should not be infra error (it's transient)");
+    const code = isInfrastructureError(new Error("SQLITE_BUSY: database is locked"));
+    assert.equal(code, null);
   });
 });