gsd-pi 2.33.1 → 2.34.0-dev.0150ae9

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -108,14 +108,14 @@ test("dispatch: triage check guards against quick-task triggering triage", () =>
   );
 });
 
-test("dispatch: triage dispatch uses return-value pattern", () => {
+test("dispatch: triage dispatch keeps the loop in continue mode", () => {
   const triageBlock = postUnitSrc.slice(
     postUnitSrc.indexOf("// ── Triage check"),
     postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
-    triageBlock.includes('return "dispatched"'),
-    "triage dispatch should return 'dispatched' after sending message",
+    triageBlock.includes('return "continue"'),
+    "triage dispatch should return 'continue' after enqueuing sidecar work",
   );
 });
 
@@ -309,14 +309,14 @@ test("dispatch: quick-task dispatch marks capture as executed", () => {
   );
 });
 
-test("dispatch: quick-task dispatch uses return-value pattern", () => {
+test("dispatch: quick-task dispatch keeps the loop in continue mode", () => {
   const quickTaskSection = postUnitSrc.slice(
     postUnitSrc.indexOf("// ── Quick-task dispatch"),
     postUnitSrc.indexOf("if (s.stepMode)"),
   );
   assert.ok(
-    quickTaskSection.includes('return "dispatched"'),
-    "quick-task dispatch should return 'dispatched' after sending message",
+    quickTaskSection.includes('return "continue"'),
+    "quick-task dispatch should return 'continue' after enqueuing sidecar work",
   );
 });
 

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

@@ -19,11 +19,17 @@ test("handleUndo without --force only warns and leaves completed units intact",
   const base = makeTempDir("gsd-undo-confirm");
   try {
     mkdirSync(join(base, ".gsd"), { recursive: true });
+    mkdirSync(join(base, ".gsd", "activity"), { recursive: true });
     writeFileSync(
       join(base, ".gsd", "completed-units.json"),
       JSON.stringify(["execute-task/M001/S01/T01"]),
       "utf-8",
     );
+    writeFileSync(
+      join(base, ".gsd", "activity", "001-execute-task-M001-S01-T01.jsonl"),
+      "",
+      "utf-8",
+    );
 
     const notifications: Array<{ message: string; level: string }> = [];
     const ctx = {

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

@@ -58,7 +58,6 @@ test("verification-evidence: writeVerificationJSON writes correct JSON shape", (
           stdout: "all good",
           stderr: "",
           durationMs: 2340,
-          blocking: true,
         },
       ],
     });
@@ -106,9 +105,9 @@ test("verification-evidence: writeVerificationJSON maps exitCode to verdict corr
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "lint", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
-        { command: "test", exitCode: 1, stdout: "", stderr: "fail", durationMs: 200, blocking: true },
-        { command: "audit", exitCode: 2, stdout: "", stderr: "err", durationMs: 300, blocking: true },
+        { command: "lint", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+        { command: "test", exitCode: 1, stdout: "", stderr: "fail", durationMs: 200 },
+        { command: "audit", exitCode: 2, stdout: "", stderr: "err", durationMs: 300 },
       ],
     });
 
@@ -134,7 +133,6 @@ test("verification-evidence: writeVerificationJSON excludes stdout/stderr from o
           stdout: "hello\n",
           stderr: "some warning",
           durationMs: 50,
-          blocking: true,
         },
       ],
     });
@@ -183,8 +181,8 @@ test("verification-evidence: writeVerificationJSON uses optional unitId when pro
 test("verification-evidence: formatEvidenceTable returns markdown table with correct columns", () => {
   const result = makeResult({
     checks: [
-      { command: "npm run typecheck", exitCode: 0, stdout: "", stderr: "", durationMs: 2340, blocking: true },
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "err", durationMs: 1100, blocking: true },
+      { command: "npm run typecheck", exitCode: 0, stdout: "", stderr: "", durationMs: 2340 },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "err", durationMs: 1100 },
     ],
   });
 
@@ -216,9 +214,9 @@ test("verification-evidence: formatEvidenceTable returns no-checks message for e
 test("verification-evidence: formatEvidenceTable formats duration as seconds with 1 decimal", () => {
   const result = makeResult({
     checks: [
-      { command: "fast", exitCode: 0, stdout: "", stderr: "", durationMs: 150, blocking: true },
-      { command: "slow", exitCode: 0, stdout: "", stderr: "", durationMs: 2340, blocking: true },
-      { command: "zero", exitCode: 0, stdout: "", stderr: "", durationMs: 0, blocking: true },
+      { command: "fast", exitCode: 0, stdout: "", stderr: "", durationMs: 150 },
+      { command: "slow", exitCode: 0, stdout: "", stderr: "", durationMs: 2340 },
+      { command: "zero", exitCode: 0, stdout: "", stderr: "", durationMs: 0 },
     ],
   });
 
@@ -232,8 +230,8 @@ test("verification-evidence: formatEvidenceTable uses ✅/❌ emoji for pass/fai
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "pass-cmd", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
-      { command: "fail-cmd", exitCode: 1, stdout: "", stderr: "", durationMs: 200, blocking: true },
+      { command: "pass-cmd", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+      { command: "fail-cmd", exitCode: 1, stdout: "", stderr: "", durationMs: 200 },
     ],
   });
 
@@ -337,8 +335,8 @@ test("verification-evidence: integration — VerificationResult → JSON → tab
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500, blocking: true },
-        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200, blocking: true },
+        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
+        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200 },
       ],
       discoverySource: "package-json",
     });
@@ -392,7 +390,7 @@ test("verification-evidence: writeVerificationJSON with retryAttempt and maxRetr
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error", durationMs: 300, blocking: true },
+        { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error", durationMs: 300 },
       ],
     });
 
@@ -417,7 +415,7 @@ test("verification-evidence: writeVerificationJSON without retry params omits re
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
       ],
     });
 
@@ -443,7 +441,7 @@ test("verification-evidence: writeVerificationJSON includes runtimeErrors when p
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
       ],
       runtimeErrors: [
         { source: "bg-shell", severity: "crash", message: "Server crashed", blocking: true },
@@ -475,7 +473,7 @@ test("verification-evidence: writeVerificationJSON omits runtimeErrors when abse
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50, blocking: true },
+        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50 },
       ],
     });
 
@@ -514,7 +512,7 @@ test("verification-evidence: formatEvidenceTable appends runtime errors section"
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
     ],
     runtimeErrors: [
       { source: "bg-shell", severity: "crash", message: "Server crashed with SIGKILL", blocking: true },
@@ -539,7 +537,7 @@ test("verification-evidence: formatEvidenceTable omits runtime errors section wh
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200, blocking: true },
+      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200 },
     ],
   });
 
@@ -554,7 +552,7 @@ test("verification-evidence: formatEvidenceTable truncates runtime error message
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
     ],
     runtimeErrors: [
       { source: "bg-shell", severity: "error", message: longMessage, blocking: false },
@@ -600,7 +598,7 @@ test("verification-evidence: writeVerificationJSON includes auditWarnings when p
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
       ],
       auditWarnings: SAMPLE_AUDIT_WARNINGS,
     });
@@ -629,7 +627,7 @@ test("verification-evidence: writeVerificationJSON omits auditWarnings when abse
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50, blocking: true },
+        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50 },
       ],
     });
 
@@ -668,7 +666,7 @@ test("verification-evidence: formatEvidenceTable appends audit warnings section"
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
     ],
     auditWarnings: SAMPLE_AUDIT_WARNINGS,
   });
@@ -691,7 +689,7 @@ test("verification-evidence: formatEvidenceTable omits audit warnings section wh
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200, blocking: true },
+      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200 },
     ],
   });
 
@@ -707,7 +705,7 @@ test("verification-evidence: integration — VerificationResult with auditWarnin
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500, blocking: true },
+        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
       ],
       auditWarnings: [
         {

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

@@ -581,7 +581,7 @@ test("formatFailureContext: formats a single failure with command, exit code, st
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error: unused var", durationMs: 500, blocking: true },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error: unused var", durationMs: 500 },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -598,9 +598,9 @@ test("formatFailureContext: formats multiple failures", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint error", durationMs: 100, blocking: true },
-      { command: "npm run test", exitCode: 2, stdout: "", stderr: "test failure", durationMs: 200, blocking: true },
-      { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 50, blocking: true },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint error", durationMs: 100 },
+      { command: "npm run test", exitCode: 2, stdout: "", stderr: "test failure", durationMs: 200 },
+      { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 50 },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -619,7 +619,7 @@ test("formatFailureContext: truncates stderr longer than 2000 chars", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: false,
     checks: [
-      { command: "big-err", exitCode: 1, stdout: "", stderr: longStderr, durationMs: 100, blocking: true },
+      { command: "big-err", exitCode: 1, stdout: "", stderr: longStderr, durationMs: 100 },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -634,8 +634,8 @@ test("formatFailureContext: returns empty string when all checks pass", () => {
   const result: import("../types.ts").VerificationResult = {
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
-      { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 200, blocking: true },
+      { command: "npm run lint", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
+      { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 200 },
     ],
     discoverySource: "preference",
     timestamp: Date.now(),
@@ -663,7 +663,6 @@ test("formatFailureContext: caps total output at 10,000 chars", () => {
       stdout: "",
       stderr: "e".repeat(1000), // 1000 chars each, 20 * ~1050 (with formatting) > 10,000
       durationMs: 100,
-      blocking: true,
     });
   }
   const result: import("../types.ts").VerificationResult = {
@@ -1078,131 +1077,3 @@ test("dependency-audit: subdirectory package.json does not trigger audit", () =>
   assert.equal(npmAuditCalled, false, "subdirectory dependency files should not trigger audit");
   assert.deepStrictEqual(result, []);
 });
-
-// ─── Non-Blocking Discovery Tests ────────────────────────────────────────────
-
-test("non-blocking: package-json discovered commands failing → result.passed is still true", () => {
-  const tmp = makeTempDir("vg-nb-pkg-fail");
-  try {
-    writeFileSync(
-      join(tmp, "package.json"),
-      JSON.stringify({ scripts: { lint: "eslint .", test: "vitest" } }),
-    );
-    // These commands will fail because eslint/vitest don't exist in the temp dir
-    const result = runVerificationGate({
-      basePath: tmp,
-      unitId: "T01",
-      cwd: tmp,
-      // No preference commands — discovery falls through to package.json
-    });
-    assert.equal(result.discoverySource, "package-json");
-    assert.ok(result.checks.length > 0, "should have discovered package.json checks");
-    assert.equal(result.passed, true, "package-json failures should not block the gate");
-    for (const check of result.checks) {
-      assert.equal(check.blocking, false, "package-json checks should be non-blocking");
-    }
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("non-blocking: preference commands failing → result.passed is false", () => {
-  const tmp = makeTempDir("vg-nb-pref-fail");
-  try {
-    const result = runVerificationGate({
-      basePath: tmp,
-      unitId: "T01",
-      cwd: tmp,
-      preferenceCommands: ["sh -c 'exit 1'"],
-    });
-    assert.equal(result.discoverySource, "preference");
-    assert.equal(result.passed, false, "preference failures should block the gate");
-    assert.equal(result.checks[0].blocking, true, "preference checks should be blocking");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("non-blocking: task-plan commands failing → result.passed is false", () => {
-  const tmp = makeTempDir("vg-nb-tp-fail");
-  try {
-    const result = runVerificationGate({
-      basePath: tmp,
-      unitId: "T01",
-      cwd: tmp,
-      taskPlanVerify: "sh -c 'exit 1'",
-    });
-    assert.equal(result.discoverySource, "task-plan");
-    assert.equal(result.passed, false, "task-plan failures should block the gate");
-    assert.equal(result.checks[0].blocking, true, "task-plan checks should be blocking");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("non-blocking: blocking field is set correctly based on discovery source", () => {
-  const tmp = makeTempDir("vg-nb-field");
-  try {
-    // preference → blocking
-    const prefResult = runVerificationGate({
-      basePath: tmp,
-      unitId: "T01",
-      cwd: tmp,
-      preferenceCommands: ["echo ok"],
-    });
-    assert.equal(prefResult.checks[0].blocking, true);
-
-    // task-plan → blocking
-    const tpResult = runVerificationGate({
-      basePath: tmp,
-      unitId: "T01",
-      cwd: tmp,
-      taskPlanVerify: "echo ok",
-    });
-    assert.equal(tpResult.checks[0].blocking, true);
-
-    // package-json → non-blocking
-    writeFileSync(
-      join(tmp, "package.json"),
-      JSON.stringify({ scripts: { test: "echo ok" } }),
-    );
-    const pkgResult = runVerificationGate({
-      basePath: tmp,
-      unitId: "T01",
-      cwd: tmp,
-    });
-    assert.equal(pkgResult.checks[0].blocking, false);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("non-blocking: formatFailureContext only includes blocking failures", () => {
-  const result: import("../types.ts").VerificationResult = {
-    passed: true,
-    checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint warning", durationMs: 100, blocking: false },
-      { command: "npm run test", exitCode: 1, stdout: "", stderr: "test error", durationMs: 200, blocking: true },
-      { command: "npm run typecheck", exitCode: 1, stdout: "", stderr: "type error", durationMs: 50, blocking: false },
-    ],
-    discoverySource: "preference",
-    timestamp: Date.now(),
-  };
-  const output = formatFailureContext(result);
-  assert.ok(output.includes("`npm run test`"), "should include blocking failure");
-  assert.ok(!output.includes("npm run lint"), "should not include non-blocking failure");
-  assert.ok(!output.includes("npm run typecheck"), "should not include non-blocking failure");
-});
-
-test("non-blocking: formatFailureContext returns empty when only non-blocking failures exist", () => {
-  const result: import("../types.ts").VerificationResult = {
-    passed: true,
-    checks: [
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "lint warning", durationMs: 100, blocking: false },
-      { command: "npm run test", exitCode: 1, stdout: "", stderr: "test warning", durationMs: 200, blocking: false },
-    ],
-    discoverySource: "package-json",
-    timestamp: Date.now(),
-  };
-  assert.equal(formatFailureContext(result), "", "should return empty when only non-blocking failures");
-});

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

@@ -0,0 +1,205 @@
+/**
+ * worktree-db-integration.test.ts
+ *
+ * Integration tests for the worktree DB copy and reconcile hooks.
+ * Uses real temp git repos and real SQLite databases.
+ *
+ * Test cases:
+ *   1. Copy: createAutoWorktree seeds .gsd/gsd.db into the worktree when main has one
+ *   2. Copy-skip: createAutoWorktree silently skips when main has no gsd.db
+ *   3. Reconcile: reconcileWorktreeDb merges worktree rows into main DB
+ *   4. Reconcile-skip: reconcileWorktreeDb is non-fatal when both paths are nonexistent
+ *   5. Failure path: reconcileWorktreeDb emits to stderr on open failure (observable)
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { createAutoWorktree } from "../auto-worktree.ts";
+import { worktreePath } from "../worktree-manager.ts";
+import {
+  copyWorktreeDb,
+  reconcileWorktreeDb,
+  openDatabase,
+  closeDatabase,
+  upsertDecision,
+  getActiveDecisions,
+  isDbAvailable,
+} from "../gsd-db.ts";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-db-int-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const savedCwd = process.cwd();
+  const tempDirs: string[] = [];
+
+  function makeTempDir(): string {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-db-int-")));
+    tempDirs.push(dir);
+    return dir;
+  }
+
+  try {
+
+    // ─── Test 1: copy on worktree creation ───────────────────────────
+    console.log("\n=== Test 1: copy on worktree creation ===");
+    {
+      const tempDir = createTempRepo();
+      tempDirs.push(tempDir);
+
+      // Seed a gsd.db in the main repo
+      const gsdDir = join(tempDir, ".gsd");
+      mkdirSync(gsdDir, { recursive: true });
+      const mainDbPath = join(gsdDir, "gsd.db");
+      openDatabase(mainDbPath);
+      closeDatabase();
+
+      // Commit so createAutoWorktree can copy planning artifacts
+      run("git add .", tempDir);
+      run('git commit -m "add gsd dir"', tempDir);
+
+      // createAutoWorktree should copy the DB into the worktree
+      const wtPath = createAutoWorktree(tempDir, "M004");
+
+      const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
+      assertTrue(
+        existsSync(worktreeDbPath),
+        "gsd.db exists in worktree .gsd after createAutoWorktree",
+      );
+
+      // Restore cwd for next test
+      process.chdir(savedCwd);
+    }
+
+    // ─── Test 2: copy skip when no source DB ─────────────────────────
+    console.log("\n=== Test 2: copy skip when no source DB ===");
+    {
+      const tempDir = createTempRepo();
+      tempDirs.push(tempDir);
+
+      // No gsd.db — just a bare repo
+      let threw = false;
+      let wtPath: string | null = null;
+      try {
+        wtPath = createAutoWorktree(tempDir, "M004");
+      } catch (err) {
+        threw = true;
+        console.error("  Unexpected throw:", err);
+      }
+
+      assertTrue(!threw, "createAutoWorktree does not throw when no source DB");
+
+      const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
+      assertTrue(
+        !existsSync(worktreeDbPath),
+        "gsd.db is absent in worktree when source had none",
+      );
+
+      process.chdir(savedCwd);
+    }
+
+    // ─── Test 3: reconcile inserts worktree rows into main ───────────
+    console.log("\n=== Test 3: reconcile merges worktree rows into main ===");
+    {
+      const mainDbPath = join(makeTempDir(), "main.db");
+      const worktreeDbPath = join(makeTempDir(), "wt.db");
+
+      // Seed main DB (empty schema)
+      openDatabase(mainDbPath);
+      closeDatabase();
+
+      // Seed worktree DB with one decision
+      openDatabase(worktreeDbPath);
+      upsertDecision({
+        id: "D-WT-001",
+        when_context: "integration test",
+        scope: "test",
+        decision: "use reconcile",
+        choice: "reconcile on merge",
+        rationale: "test coverage",
+        revisable: "no",
+        superseded_by: null,
+      });
+      closeDatabase();
+
+      // Reconcile worktree → main
+      const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+      assertTrue(result.decisions >= 1, "reconcile reports at least 1 decision merged");
+
+      // Open main DB and verify the row is present
+      openDatabase(mainDbPath);
+      const decisions = getActiveDecisions();
+      closeDatabase();
+
+      const found = decisions.some((d) => d.id === "D-WT-001");
+      assertTrue(found, "worktree decision D-WT-001 present in main DB after reconcile");
+    }
+
+    // ─── Test 4: reconcile non-fatal when both paths nonexistent ─────
+    console.log("\n=== Test 4: reconcile non-fatal on nonexistent paths ===");
+    {
+      let threw = false;
+      try {
+        reconcileWorktreeDb("/nonexistent/path/gsd.db", "/also/nonexistent/gsd.db");
+      } catch {
+        threw = true;
+      }
+      assertTrue(!threw, "reconcileWorktreeDb does not throw when worktree DB is absent");
+    }
+
+    // ─── Test 5: failure path observable via stderr (diagnostic) ─────
+    // reconcileWorktreeDb emits to stderr on reconciliation failures.
+    // We can't easily intercept stderr in this test harness, but we verify
+    // that the function returns the zero-result shape (not undefined/throws)
+    // when the worktree DB is missing — confirming the failure path is non-fatal
+    // and returns a structured result.
+    console.log("\n=== Test 5: reconcile returns zero-shape when worktree DB absent ===");
+    {
+      const mainDbPath = join(makeTempDir(), "main2.db");
+      openDatabase(mainDbPath);
+      closeDatabase();
+
+      const result = reconcileWorktreeDb(mainDbPath, "/definitely/does/not/exist.db");
+      assertEq(result.decisions, 0, "decisions is 0 when worktree DB absent");
+      assertEq(result.requirements, 0, "requirements is 0 when worktree DB absent");
+      assertEq(result.artifacts, 0, "artifacts is 0 when worktree DB absent");
+      assertEq(result.conflicts.length, 0, "conflicts is empty when worktree DB absent");
+    }
+
+  } finally {
+    // Always restore cwd
+    process.chdir(savedCwd);
+    // Ensure DB is closed
+    if (isDbAvailable()) closeDatabase();
+    // Remove all temp dirs
+    for (const dir of tempDirs) {
+      if (existsSync(dir)) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+
+  report();
+}
+
+main();