gsd-pi 2.44.0 → 2.45.0-dev.6b9da3e

package/src/resources/extensions/gsd/tests/session-lock-regression.test.ts

@@ -25,9 +25,9 @@ import {
   isSessionLockHeld,
 } from '../session-lock.ts';
 import { gsdRoot } from '../paths.ts';
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 const require = createRequire(import.meta.url);
 
 function hasProperLockfile(): boolean {
@@ -41,7 +41,7 @@ function hasProperLockfile(): boolean {
 
 const properLockfileAvailable = hasProperLockfile();
 
-async function main(): Promise<void> {
+describe('session-lock-regression', async () => {
 
   // ─── 1. Basic acquire/release lifecycle ───────────────────────────────
   console.log('\n=== 1. acquire → validate → release lifecycle ===');
@@ -51,22 +51,22 @@ async function main(): Promise<void> {
 
     try {
       const result = acquireSessionLock(base);
-      assertTrue(result.acquired, 'lock acquired successfully');
+      assert.ok(result.acquired, 'lock acquired successfully');
 
       const valid = validateSessionLock(base);
-      assertTrue(valid, 'lock validates after acquisition');
+      assert.ok(valid, 'lock validates after acquisition');
 
-      assertTrue(isSessionLockHeld(base), 'isSessionLockHeld returns true');
+      assert.ok(isSessionLockHeld(base), 'isSessionLockHeld returns true');
 
       releaseSessionLock(base);
 
       // After release, the lock file should be cleaned up
       const lockFile = join(gsdRoot(base), 'auto.lock');
-      assertTrue(!existsSync(lockFile), 'lock file removed after release');
+      assert.ok(!existsSync(lockFile), 'lock file removed after release');
 
       // The .gsd.lock/ directory should be cleaned up
       const lockDir = gsdRoot(base) + '.lock';
-      assertTrue(!existsSync(lockDir), '.gsd.lock/ directory removed after release (#1245)');
+      assert.ok(!existsSync(lockDir), '.gsd.lock/ directory removed after release (#1245)');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -88,7 +88,7 @@ async function main(): Promise<void> {
       } catch {
         threw = true;
       }
-      assertTrue(!threw, 'double release does not throw');
+      assert.ok(!threw, 'double release does not throw');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -106,13 +106,13 @@ async function main(): Promise<void> {
       updateSessionLock(base, 'execute-task', 'M001/S01/T01', 5, '/tmp/session.json');
 
       const data = readSessionLockData(base);
-      assertTrue(data !== null, 'lock data readable after update');
+      assert.ok(data !== null, 'lock data readable after update');
       if (data) {
-        assertEq(data.pid, process.pid, 'lock data has correct PID');
-        assertEq(data.unitType, 'execute-task', 'lock data has correct unit type');
-        assertEq(data.unitId, 'M001/S01/T01', 'lock data has correct unit ID');
-        assertEq(data.completedUnits, 5, 'lock data has correct completed count');
-        assertEq(data.sessionFile, '/tmp/session.json', 'lock data has session file');
+        assert.deepStrictEqual(data.pid, process.pid, 'lock data has correct PID');
+        assert.deepStrictEqual(data.unitType, 'execute-task', 'lock data has correct unit type');
+        assert.deepStrictEqual(data.unitId, 'M001/S01/T01', 'lock data has correct unit ID');
+        assert.deepStrictEqual(data.completedUnits, 5, 'lock data has correct completed count');
+        assert.deepStrictEqual(data.sessionFile, '/tmp/session.json', 'lock data has session file');
       }
 
       releaseSessionLock(base);
@@ -142,7 +142,7 @@ async function main(): Promise<void> {
 
       // Should be able to acquire despite the stale lock
       const result = acquireSessionLock(base);
-      assertTrue(result.acquired, '#1245: stale lock from dead PID → re-acquirable');
+      assert.ok(result.acquired, '#1245: stale lock from dead PID → re-acquirable');
 
       releaseSessionLock(base);
     } finally {
@@ -158,7 +158,7 @@ async function main(): Promise<void> {
 
     try {
       const data = readSessionLockData(base);
-      assertEq(data, null, 'no lock file → null');
+      assert.deepStrictEqual(data, null, 'no lock file → null');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -176,7 +176,7 @@ async function main(): Promise<void> {
       // Multiple validations should all return true (regression for #1257)
       for (let i = 0; i < 5; i++) {
         const valid = validateSessionLock(base);
-        assertTrue(valid, `#1257: validation ${i + 1} returns true for own lock`);
+        assert.ok(valid, `#1257: validation ${i + 1} returns true for own lock`);
       }
 
       releaseSessionLock(base);
@@ -196,7 +196,7 @@ async function main(): Promise<void> {
       writeFileSync(lockFile, 'NOT VALID JSON {{{');
 
       const data = readSessionLockData(base);
-      assertEq(data, null, 'corrupt JSON → null');
+      assert.deepStrictEqual(data, null, 'corrupt JSON → null');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -210,9 +210,9 @@ async function main(): Promise<void> {
 
     try {
       const status = getSessionLockStatus(base);
-      assertEq(status.valid, false, 'missing lock metadata is invalid');
-      assertEq(status.failureReason, 'missing-metadata', 'missing metadata reason is surfaced');
-      assertEq(status.expectedPid, process.pid, 'expected PID is included');
+      assert.deepStrictEqual(status.valid, false, 'missing lock metadata is invalid');
+      assert.deepStrictEqual(status.failureReason, 'missing-metadata', 'missing metadata reason is surfaced');
+      assert.deepStrictEqual(status.expectedPid, process.pid, 'expected PID is included');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -237,10 +237,10 @@ async function main(): Promise<void> {
       }, null, 2));
 
       const status = getSessionLockStatus(base);
-      assertEq(status.valid, false, 'foreign PID lock is invalid');
-      assertEq(status.failureReason, 'pid-mismatch', 'PID mismatch reason is surfaced');
-      assertEq(status.existingPid, foreignPid, 'existing PID is included');
-      assertEq(status.expectedPid, process.pid, 'expected PID is included');
+      assert.deepStrictEqual(status.valid, false, 'foreign PID lock is invalid');
+      assert.deepStrictEqual(status.failureReason, 'pid-mismatch', 'PID mismatch reason is surfaced');
+      assert.deepStrictEqual(status.existingPid, foreignPid, 'existing PID is included');
+      assert.deepStrictEqual(status.expectedPid, process.pid, 'expected PID is included');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -254,11 +254,11 @@ async function main(): Promise<void> {
 
     try {
       const r1 = acquireSessionLock(base);
-      assertTrue(r1.acquired, 'first acquisition');
+      assert.ok(r1.acquired, 'first acquisition');
       releaseSessionLock(base);
 
       const r2 = acquireSessionLock(base);
-      assertTrue(r2.acquired, 're-acquisition after release');
+      assert.ok(r2.acquired, 're-acquisition after release');
       releaseSessionLock(base);
     } finally {
       rmSync(base, { recursive: true, force: true });
@@ -273,13 +273,13 @@ async function main(): Promise<void> {
 
     try {
       const r1 = acquireSessionLock(base);
-      assertTrue(r1.acquired, 'first acquisition succeeds');
+      assert.ok(r1.acquired, 'first acquisition succeeds');
 
       const r2 = acquireSessionLock(base);
-      assertTrue(r2.acquired, 're-entrant acquisition succeeds');
+      assert.ok(r2.acquired, 're-entrant acquisition succeeds');
 
       const valid = validateSessionLock(base);
-      assertTrue(valid, 're-entrant acquisition does not corrupt validation state');
+      assert.ok(valid, 're-entrant acquisition does not corrupt validation state');
 
       releaseSessionLock(base);
     } finally {
@@ -295,31 +295,24 @@ async function main(): Promise<void> {
 
     try {
       const r1 = acquireSessionLock(base);
-      assertTrue(r1.acquired, 'first acquisition succeeds');
+      assert.ok(r1.acquired, 'first acquisition succeeds');
 
       const lockDir = gsdRoot(base) + '.lock';
       if (properLockfileAvailable) {
-        assertTrue(existsSync(lockDir), '.gsd.lock/ exists after first acquisition');
+        assert.ok(existsSync(lockDir), '.gsd.lock/ exists after first acquisition');
       }
 
       const r2 = acquireSessionLock(base);
-      assertTrue(r2.acquired, 'second acquisition succeeds');
+      assert.ok(r2.acquired, 'second acquisition succeeds');
       if (properLockfileAvailable) {
-        assertTrue(existsSync(lockDir), '.gsd.lock/ exists after re-entrant acquisition');
+        assert.ok(existsSync(lockDir), '.gsd.lock/ exists after re-entrant acquisition');
       }
-      assertTrue(validateSessionLock(base), 'lock remains valid after re-entrant acquisition');
+      assert.ok(validateSessionLock(base), 'lock remains valid after re-entrant acquisition');
 
       releaseSessionLock(base);
-      assertTrue(!existsSync(lockDir), '.gsd.lock/ is removed after release');
+      assert.ok(!existsSync(lockDir), '.gsd.lock/ is removed after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
   }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/shared-wal.test.ts

@@ -14,9 +14,9 @@ import {
   getAllMilestones,
   _getAdapter,
 } from '../gsd-db.ts';
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -30,14 +30,14 @@ function cleanup(dir: string): void {
 
 // ─── Tests ────────────────────────────────────────────────────────────────
 
-async function main() {
+describe('shared-wal', async () => {
   // ─── Test (a): resolveProjectRootDbPath returns project root DB for worktree path ───
   console.log('\n=== shared-wal: resolve worktree path to project root DB ===');
   {
     const projectRoot = '/home/user/myproject';
     const worktreePath = join(projectRoot, '.gsd', 'worktrees', 'M001');
     const result = resolveProjectRootDbPath(worktreePath);
-    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
+    assert.deepStrictEqual(result, join(projectRoot, '.gsd', 'gsd.db'),
       'worktree path resolves to project root DB');
   }
 
@@ -46,7 +46,7 @@ async function main() {
   {
     const projectRoot = '/home/user/myproject';
     const result = resolveProjectRootDbPath(projectRoot);
-    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
+    assert.deepStrictEqual(result, join(projectRoot, '.gsd', 'gsd.db'),
       'project root path stays at project root DB');
   }
 
@@ -56,7 +56,7 @@ async function main() {
     const projectRoot = '/home/user/myproject';
     const nestedPath = join(projectRoot, '.gsd', 'worktrees', 'M002', 'src', 'lib');
     const result = resolveProjectRootDbPath(nestedPath);
-    assertEq(result, join(projectRoot, '.gsd', 'gsd.db'),
+    assert.deepStrictEqual(result, join(projectRoot, '.gsd', 'gsd.db'),
       'nested worktree subdir resolves to project root DB');
   }
 
@@ -64,7 +64,7 @@ async function main() {
   console.log('\n=== shared-wal: resolve forward-slash path ===');
   {
     const result = resolveProjectRootDbPath('/proj/.gsd/worktrees/M001');
-    assertEq(result, join('/proj', '.gsd', 'gsd.db'),
+    assert.deepStrictEqual(result, join('/proj', '.gsd', 'gsd.db'),
       'forward-slash worktree path resolves correctly');
   }
 
@@ -99,9 +99,9 @@ async function main() {
 
       // Verify all 3 milestones are visible
       const all = getAllMilestones();
-      assertEq(all.length, 3, 'concurrent: all 3 milestones visible');
+      assert.deepStrictEqual(all.length, 3, 'concurrent: all 3 milestones visible');
       const ids = all.map(m => m.id).sort();
-      assertEq(ids, ['M001', 'M002', 'M003'], 'concurrent: correct IDs');
+      assert.deepStrictEqual(ids, ['M001', 'M002', 'M003'], 'concurrent: correct IDs');
 
       closeDatabase();
     } finally {
@@ -132,7 +132,7 @@ async function main() {
       // Connection 2: write M002, verify sees M001
       openDatabase(dbPath);
       const afterConn2Before = getAllMilestones();
-      assertTrue(afterConn2Before.some(m => m.id === 'M001'),
+      assert.ok(afterConn2Before.some(m => m.id === 'M001'),
         'rawconc: conn2 sees M001 from conn1');
       insertMilestone({ id: 'M002', title: 'Writer 2', status: 'active' });
       closeDatabase();
@@ -140,16 +140,16 @@ async function main() {
       // Connection 3: write M003, verify sees M001 + M002
       openDatabase(dbPath);
       const afterConn3Before = getAllMilestones();
-      assertTrue(afterConn3Before.some(m => m.id === 'M001'),
+      assert.ok(afterConn3Before.some(m => m.id === 'M001'),
         'rawconc: conn3 sees M001');
-      assertTrue(afterConn3Before.some(m => m.id === 'M002'),
+      assert.ok(afterConn3Before.some(m => m.id === 'M002'),
         'rawconc: conn3 sees M002');
       insertMilestone({ id: 'M003', title: 'Writer 3', status: 'active' });
 
       // Final read: all 3 visible
       const finalAll = getAllMilestones();
-      assertEq(finalAll.length, 3, 'rawconc: all 3 milestones visible');
-      assertEq(
+      assert.deepStrictEqual(finalAll.length, 3, 'rawconc: all 3 milestones visible');
+      assert.deepStrictEqual(
         finalAll.map(m => m.id).sort(),
         ['M001', 'M002', 'M003'],
         'rawconc: all IDs present',
@@ -177,7 +177,7 @@ async function main() {
 
       // Verify it committed
       const all = getAllMilestones();
-      assertEq(all.length, 1, 'busy: M001 committed via transaction');
+      assert.deepStrictEqual(all.length, 1, 'busy: M001 committed via transaction');
 
       // Verify transaction rolls back on error
       let errorCaught = false;
@@ -188,17 +188,17 @@ async function main() {
         });
       } catch (err) {
         errorCaught = true;
-        assertTrue(
+        assert.ok(
           (err as Error).message.includes('Simulated failure'),
           'busy: error propagated from transaction',
         );
       }
-      assertTrue(errorCaught, 'busy: transaction threw on error');
+      assert.ok(errorCaught, 'busy: transaction threw on error');
 
       // M002 should NOT be visible (rolled back)
       const afterRollback = getAllMilestones();
-      assertEq(afterRollback.length, 1, 'busy: M002 rolled back — still only 1 milestone');
-      assertEq(afterRollback[0]!.id, 'M001', 'busy: only M001 survives');
+      assert.deepStrictEqual(afterRollback.length, 1, 'busy: M002 rolled back — still only 1 milestone');
+      assert.deepStrictEqual(afterRollback[0]!.id, 'M001', 'busy: only M001 survives');
 
       closeDatabase();
     } finally {
@@ -206,11 +206,4 @@ async function main() {
       cleanup(tmp);
     }
   }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

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

@@ -0,0 +1,63 @@
+/**
+ * sqlite-unavailable-gate.test.ts — #2419
+ *
+ * When the SQLite provider fails to open, bootstrapAutoSession must
+ * refuse to start auto-mode. Otherwise gsd_task_complete returns
+ * "db_unavailable", artifact retry re-dispatches the same task, and
+ * the session loops forever.
+ *
+ * This test verifies the gate by reading auto-start.ts source and
+ * confirming the pattern: after the DB lifecycle block, if the DB
+ * file exists on disk but isDbAvailable() still returns false after
+ * the open attempt, bootstrap must abort with an error notification.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
+const src = readFileSync(srcPath, "utf-8");
+
+console.log("\n=== #2419: SQLite unavailable gate in auto-start.ts ===");
+
+// The DB lifecycle section tries to open the DB. After those try/catch
+// blocks, there must be a HARD GATE: if the DB file exists on disk but
+// isDbAvailable() is still false (open failed), bootstrap must abort
+// by calling releaseLockAndReturn() with an error notification.
+
+const dbLifecycleIdx = src.indexOf("DB lifecycle");
+assertTrue(dbLifecycleIdx > 0, "auto-start.ts has a DB lifecycle section");
+
+const afterDbLifecycle = src.slice(dbLifecycleIdx);
+
+// Find the second isDbAvailable check — the one AFTER the open attempts.
+// The first check at line ~543 tries to open the DB.
+// There must be a SECOND check that gates bootstrap if it's still unavailable.
+const firstCheck = afterDbLifecycle.indexOf("isDbAvailable()");
+assertTrue(firstCheck > 0, "DB lifecycle section has isDbAvailable() check");
+
+const afterFirstCheck = afterDbLifecycle.slice(firstCheck + "isDbAvailable()".length);
+const secondCheck = afterFirstCheck.indexOf("isDbAvailable()");
+
+assertTrue(
+  secondCheck > 0,
+  "auto-start.ts has a SECOND isDbAvailable() check after the open attempt — this is the gate (#2419)",
+);
+
+// The second check must lead to releaseLockAndReturn (abort bootstrap)
+if (secondCheck > 0) {
+  const gateRegion = afterFirstCheck.slice(secondCheck, secondCheck + 500);
+  assertTrue(
+    gateRegion.includes("releaseLockAndReturn"),
+    "The DB availability gate calls releaseLockAndReturn() to abort bootstrap (#2419)",
+  );
+  assertTrue(
+    /database|sqlite|db.*unavailable/i.test(gateRegion),
+    "The DB availability gate includes a user-facing error message about the database (#2419)",
+  );
+}
+
+report();

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -19,9 +19,9 @@ import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertTrue, report } = createTestContext();
 
 // Minimal mock for ExtensionContext — only the fields recoverTimedOutUnit touches.
 function makeMockCtx() {
@@ -55,12 +55,12 @@ function makeMockPi() {
     await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", emptyRctx);
   } catch (err: any) {
     crashed = true;
-    assertTrue(
+    assert.ok(
       err.message.includes("path") || err.message.includes("string") || err.code === "ERR_INVALID_ARG_TYPE",
       `should crash with path/type error, got: ${err.message}`,
     );
   }
-  assertTrue(crashed, "should crash when basePath is undefined (reproduces #1855)");
+  assert.ok(crashed, "should crash when basePath is undefined (reproduces #1855)");
 }
 
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
@@ -90,13 +90,11 @@ function makeMockPi() {
       crashed = true;
       console.error(`  Unexpected crash: ${err.message}`);
     }
-    assertTrue(!crashed, "should not crash with valid basePath");
+    assert.ok(!crashed, "should not crash with valid basePath");
     // With no runtime record on disk and recoveryAttempts=0, the function
     // should attempt steering recovery (sendMessage) and return "recovered".
-    assertTrue(result === "recovered", `should return 'recovered', got '${result}'`);
+    assert.ok(result === "recovered", `should return 'recovered', got '${result}'`);
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
 }
-
-report();

package/src/resources/extensions/gsd/tests/stop-auto-merge-back.test.ts

@@ -0,0 +1,67 @@
+/**
+ * stop-auto-merge-back.test.ts — Regression test for #2317.
+ *
+ * When auto-mode stops after a milestone is complete, stopAuto should trigger
+ * merge-back (mergeAndExit) instead of just exiting the worktree with
+ * preserveBranch: true. Otherwise milestone code stays stranded on the
+ * worktree branch and never reaches main.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Source analysis: stopAuto calls mergeAndExit for complete milestones ────
+
+const autoSrcPath = join(import.meta.dirname, "..", "auto.ts");
+const autoSrc = readFileSync(autoSrcPath, "utf-8");
+
+test("#2317: stopAuto should check milestone completion status before choosing exit strategy", () => {
+  // stopAuto Step 4 should NOT unconditionally call exitMilestone(preserveBranch: true).
+  // It should check if the milestone is complete and call mergeAndExit instead.
+
+  // Find the Step 4 section
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  assert.ok(step4Idx !== -1, "Step 4 comment exists in stopAuto");
+
+  // Extract a reasonable window around Step 4 (up to Step 5)
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  // The fix: Step 4 should call mergeAndExit when milestone is complete
+  assert.ok(
+    step4Block.includes("mergeAndExit"),
+    "Step 4 should call mergeAndExit for completed milestones",
+  );
+});
+
+test("#2317: stopAuto should detect milestone completion via SUMMARY file or DB", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  // Should check completion status — either via SUMMARY file, DB getMilestone, or phase
+  const checksCompletion =
+    step4Block.includes("SUMMARY") ||
+    step4Block.includes("getMilestone") ||
+    step4Block.includes("complete") ||
+    step4Block.includes("isMilestoneComplete");
+
+  assert.ok(
+    checksCompletion,
+    "Step 4 should check if milestone is complete before deciding exit strategy",
+  );
+});
+
+test("#2317: stopAuto still preserves branch for incomplete milestones", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  // preserveBranch should still be used as fallback for non-complete milestones
+  assert.ok(
+    step4Block.includes("preserveBranch"),
+    "Step 4 should still preserve branch for incomplete milestones (fallback path)",
+  );
+});

package/src/resources/extensions/gsd/tests/survivor-branch-complete.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Regression test for #2358: Survivor branch recovery skipped in phase=complete.
+ *
+ * When bootstrapAutoSession finds a survivor milestone branch and the derived
+ * state phase is "complete", recovery/finalization is skipped entirely because
+ * the survivor branch detection only triggers when phase === "pre-planning".
+ * The milestone finalization (merge, cleanup) never runs, leaving the worktree
+ * and branch alive.
+ *
+ * The fix broadens the survivor branch detection to also check phase === "complete",
+ * and adds a finalization path that runs mergeAndExit before falling through to
+ * the normal "complete" handling.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, assertEq, report } = createTestContext();
+
+// ═══ Test: survivor branch detection conditions ══════════════════════════════
+
+// The survivor branch detection block in auto-start.ts checks:
+//   state.activeMilestone &&
+//   state.phase === "pre-planning" &&  // <-- BUG: too restrictive
+//   shouldUseWorktreeIsolation() &&
+//   !detectWorktreeName(base) &&
+//   !base.includes(...)
+//
+// The fix should also include state.phase === "complete".
+
+{
+  console.log("\n=== #2358: survivor branch should be detected in phase=complete ===");
+
+  // Simulate the condition check before the fix (only pre-planning)
+  const phasesBeforeFix = ["pre-planning"];
+  const phasesAfterFix = ["pre-planning", "complete"];
+
+  const testPhase = "complete";
+
+  const detectedBefore = phasesBeforeFix.includes(testPhase);
+  assertEq(detectedBefore, false, "before fix: phase=complete should NOT trigger survivor detection");
+
+  const detectedAfter = phasesAfterFix.includes(testPhase);
+  assertEq(detectedAfter, true, "after fix: phase=complete SHOULD trigger survivor detection");
+}
+
+// ═══ Test: pre-planning survivor detection still works ═══════════════════════
+
+{
+  console.log("\n=== #2358: pre-planning survivor detection is not broken ===");
+
+  const phasesAfterFix = ["pre-planning", "complete"];
+  const testPhase = "pre-planning";
+
+  const detected = phasesAfterFix.includes(testPhase);
+  assertEq(detected, true, "pre-planning should still trigger survivor detection after fix");
+}
+
+// ═══ Test: other phases do NOT trigger survivor detection ════════════════════
+
+{
+  console.log("\n=== #2358: other phases should NOT trigger survivor detection ===");
+
+  const phasesAfterFix = ["pre-planning", "complete"];
+
+  for (const phase of ["planning", "executing", "blocked", "needs-discussion"]) {
+    const detected = phasesAfterFix.includes(phase);
+    assertEq(detected, false, `phase=${phase} should NOT trigger survivor detection`);
+  }
+}
+
+// ═══ Test: phase=complete + hasSurvivorBranch should trigger finalization ═════
+
+{
+  console.log("\n=== #2358: phase=complete + survivor branch triggers finalization path ===");
+
+  // Simulate the decision logic after the fix:
+  // if (hasSurvivorBranch && state.phase === "complete") -> finalize
+  // if (hasSurvivorBranch && state.phase === "needs-discussion") -> discuss
+  // if (!hasSurvivorBranch && state.phase === "complete") -> showSmartEntry
+
+  const scenarios = [
+    { hasSurvivorBranch: true, phase: "complete", expected: "finalize" },
+    { hasSurvivorBranch: true, phase: "needs-discussion", expected: "discuss" },
+    { hasSurvivorBranch: true, phase: "pre-planning", expected: "continue" },
+    { hasSurvivorBranch: false, phase: "complete", expected: "showSmartEntry" },
+  ];
+
+  for (const { hasSurvivorBranch, phase, expected } of scenarios) {
+    let result: string;
+    if (hasSurvivorBranch && phase === "complete") {
+      result = "finalize";
+    } else if (hasSurvivorBranch && phase === "needs-discussion") {
+      result = "discuss";
+    } else if (!hasSurvivorBranch && (!phase || phase === "complete")) {
+      result = "showSmartEntry";
+    } else {
+      result = "continue";
+    }
+
+    assertEq(
+      result,
+      expected,
+      `hasSurvivorBranch=${hasSurvivorBranch}, phase=${phase} -> expected ${expected}, got ${result}`,
+    );
+  }
+}
+
+report();