gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

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

@@ -1,108 +1,109 @@
 /**
- * Regression test for #2358: Survivor branch recovery skipped in phase=complete.
+ * survivor-branch-complete.test.ts — #2358
  *
- * 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 bug: `bootstrapAutoSession` found a survivor milestone branch
+ * (previous session's worktree/branch that was never merged) but only
+ * triggered recovery when `state.phase === "pre-planning"`. In
+ * `phase === "complete"` the milestone artifacts existed but the
+ * finalization path (merge + cleanup) never ran, leaving the worktree
+ * and branch alive indefinitely.
  *
- * 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.
+ * The fix broadens the detection to include `phase === "complete"` and
+ * routes to a finalize-via-mergeAndExit path.
+ *
+ * The previous version of this file was 4 scenarios that re-implemented
+ * the decision logic inline and called `.includes(phase)` on
+ * locally-declared arrays — testing the test, not the code. Called out
+ * in #4832 and parent #4784 as a pure-tautology case (zero imports
+ * from production).
+ *
+ * This rewrite imports `decideSurvivorAction` from auto-start.ts (a
+ * helper extracted in the accompanying refactor) and drives the full
+ * decision table through the real function. The helper is wired into
+ * `bootstrapAutoSession` at the two call sites that previously used
+ * inline conditionals, so the assertions here fail if someone reverts
+ * the helper or narrows its branches.
  */
 
-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";
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { decideSurvivorAction } from "../auto-start.ts";
+import type { SurvivorAction } from "../auto-start.ts";
+
+describe("decideSurvivorAction (#2358)", () => {
+  test("no survivor branch → no action, regardless of phase", () => {
+    const phases = [
+      "pre-planning",
+      "planning",
+      "executing",
+      "complete",
+      "needs-discussion",
+      "blocked",
+      "",
+      null,
+      undefined,
+    ];
+    for (const phase of phases) {
+      const got: SurvivorAction = decideSurvivorAction(false, phase);
+      assert.equal(got, "none", `phase=${phase ?? "(nullish)"} → expected 'none', got '${got}'`);
     }
-
-    assertEq(
-      result,
-      expected,
-      `hasSurvivorBranch=${hasSurvivorBranch}, phase=${phase} -> expected ${expected}, got ${result}`,
+  });
+
+  test("survivor + needs-discussion → 'discuss' (#1726)", () => {
+    assert.equal(decideSurvivorAction(true, "needs-discussion"), "discuss");
+  });
+
+  test("survivor + complete → 'finalize' (#2358 — the bug this regression guards)", () => {
+    // This is THE assertion that fails if someone reverts the fix and
+    // narrows the recovery to pre-planning only.
+    assert.equal(decideSurvivorAction(true, "complete"), "finalize");
+  });
+
+  test("survivor + other phase → 'none' (caller continues normal flow)", () => {
+    // pre-planning, planning, executing, blocked — survivor alone is
+    // not sufficient to trigger recovery. Normal auto-mode picks up
+    // from state. This protects against regressions that try to run
+    // finalize on every survivor regardless of phase.
+    const passThroughPhases = ["pre-planning", "planning", "executing", "blocked", ""];
+    for (const phase of passThroughPhases) {
+      assert.equal(
+        decideSurvivorAction(true, phase),
+        "none",
+        `survivor + phase=${phase} → expected 'none', got ${decideSurvivorAction(true, phase)}`,
+      );
+    }
+  });
+
+  test("decision table covers the three outcomes the bootstrap code needs", () => {
+    // Belt-and-suspenders: enumerate (hasSurvivor, phase) and assert
+    // the complete truth table. If someone adds a 4th outcome, this
+    // test fails loudly so they must update both the helper and the
+    // bootstrap wiring.
+    const cases: Array<{ hasSurvivor: boolean; phase: string | null; expected: SurvivorAction }> = [
+      { hasSurvivor: true, phase: "needs-discussion", expected: "discuss" },
+      { hasSurvivor: true, phase: "complete", expected: "finalize" },
+      { hasSurvivor: true, phase: "pre-planning", expected: "none" },
+      { hasSurvivor: true, phase: "planning", expected: "none" },
+      { hasSurvivor: true, phase: null, expected: "none" },
+      { hasSurvivor: false, phase: "complete", expected: "none" },
+      { hasSurvivor: false, phase: "needs-discussion", expected: "none" },
+      { hasSurvivor: false, phase: null, expected: "none" },
+    ];
+    const outcomes = new Set<SurvivorAction>();
+    for (const { hasSurvivor, phase, expected } of cases) {
+      const got = decideSurvivorAction(hasSurvivor, phase);
+      outcomes.add(got);
+      assert.equal(
+        got,
+        expected,
+        `(hasSurvivor=${hasSurvivor}, phase=${phase}) → expected '${expected}', got '${got}'`,
+      );
+    }
+    assert.deepEqual(
+      [...outcomes].sort(),
+      ["discuss", "finalize", "none"],
+      "decision function should produce exactly three outcomes",
     );
-  }
-}
-
-report();
+  });
+});

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

@@ -120,3 +120,34 @@ test('sync-lock: overrides stale lock file (mtime backdated)', (t) => {
     cleanupDir(base);
   }
 });
+
+test('sync-lock: EPERM from live owner PID prevents stale lock stealing', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  const lockPath = path.join(base, '.gsd', 'sync.lock');
+  const fakePid = process.pid + 100_000;
+  const originalKill = process.kill;
+
+  try {
+    fs.writeFileSync(lockPath, JSON.stringify({ pid: fakePid, acquired_at: new Date(0).toISOString() }));
+    const staleTime = new Date(Date.now() - 120_000);
+    fs.utimesSync(lockPath, staleTime, staleTime);
+
+    process.kill = ((pid: number, signal?: NodeJS.Signals | number) => {
+      if (pid === fakePid && signal === 0) {
+        const err = new Error('operation not permitted') as NodeJS.ErrnoException;
+        err.code = 'EPERM';
+        throw err;
+      }
+      return originalKill(pid, signal);
+    }) as typeof process.kill;
+
+    const result = acquireSyncLock(base, 100);
+    assert.strictEqual(result.acquired, false, 'EPERM owner should be treated as live');
+    const content = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+    assert.strictEqual(content.pid, fakePid, 'lock file should not be overwritten');
+  } finally {
+    process.kill = originalKill;
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/test-helpers.test.ts

@@ -1,70 +1,21 @@
 /**
- * Tests for test-helpers.ts — the source-inspection and timing helpers
- * introduced in #4773 / #4774 to replace brittle fixed-byte slice and
- * magic-number sleep patterns in the test suite.
+ * Tests for test-helpers.ts — the timing helpers (waitForCondition,
+ * findLine) used to replace magic-number sleeps and positional line
+ * indexing in the test suite.
+ *
+ * The `extractSourceRegion` helper (introduced in #4773/#4774) is
+ * deliberately NOT tested here. It is the source-grep antipattern that
+ * #4784 names as the root problem; tests against toy fixtures only
+ * legitimize the pattern without validating behaviour. Its test cases
+ * were removed as part of #4834 — callers are being migrated to
+ * behaviour tests one file at a time, after which the helper is slated
+ * for deletion.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { extractSourceRegion, waitForCondition, findLine } from "./test-helpers.ts";
-
-// ─── extractSourceRegion ──────────────────────────────────────────────────
-
-test("extractSourceRegion returns empty string when start anchor missing", () => {
-  assert.equal(extractSourceRegion("const x = 1;", "missing"), "");
-});
-
-test("extractSourceRegion uses explicit end anchor when provided", () => {
-  const src = "START_TOKEN\nbody line\nEND_TOKEN tail";
-  const region = extractSourceRegion(src, "START_TOKEN", "END_TOKEN");
-  assert.ok(region.includes("START_TOKEN"));
-  assert.ok(region.includes("body line"));
-  assert.ok(!region.includes("END_TOKEN"));
-});
-
-test("extractSourceRegion stops at next private method boundary", () => {
-  const src = [
-    "class Foo {",
-    "  private alpha(): void {",
-    "    const a = 1;",
-    "    someCall();",
-    "  }",
-    "",
-    "  private beta(): void {",
-    "    const b = 2;",
-    "  }",
-    "}",
-  ].join("\n");
-
-  // Anchor on alpha's declaration; helper should stop at the next
-  // private method (beta), not on alpha itself.
-  const region = extractSourceRegion(src, "private alpha");
-  assert.ok(region.includes("alpha"));
-  assert.ok(region.includes("someCall()"));
-  assert.ok(!region.includes("beta"));
-});
-
-test("extractSourceRegion stops at next top-level function", () => {
-  const src = [
-    "function alpha() {",
-    "  throw new Error('alpha');",
-    "}",
-    "",
-    "function beta() {",
-    "  return 2;",
-    "}",
-  ].join("\n");
-
-  const region = extractSourceRegion(src, "function alpha");
-  assert.ok(region.includes("throw new Error"));
-  assert.ok(!region.includes("beta"));
-});
-
-test("extractSourceRegion returns to end-of-source when no terminator found", () => {
-  const src = "just one line";
-  assert.equal(extractSourceRegion(src, "just"), "just one line");
-});
+import { waitForCondition, findLine } from "./test-helpers.ts";
 
 // ─── waitForCondition ─────────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/test-helpers.ts

@@ -60,22 +60,35 @@ export function createTestContext() {
   return { assertEq, assertTrue, assertMatch, assertNoMatch, report };
 }
 
-// ─── Source-inspection helpers ────────────────────────────────────────────────
+// ─── Source-inspection helpers (DEPRECATED — do not add new callers) ──────────
 //
-// Replace brittle fixed-byte slice patterns like `src.slice(idx, idx + 6000)`
-// with structural boundary detection. See #4773, #4774.
+// `extractSourceRegion` was introduced in #4773 / #4774 as a more-durable
+// replacement for hand-rolled `src.slice(idx, idx + N)` patterns. Issue
+// #4784 surfaced that the helper is the wrong target: its use case —
+// testing that an identifier or phrase exists in production source text
+// — is the source-grep antipattern that causes false coverage in the
+// first place. Tests should exercise behaviour (call the function,
+// assert on its return value or observable effects) rather than check
+// whether specific identifier strings remain in source.
+//
+// CONTRIBUTING.md forbids new callers of this helper. Existing callers
+// are being migrated one file at a time; the helper is slated for
+// removal once the last caller is converted.
+//
+// Do not add new callers. If you are tempted to, file an issue
+// describing the behavioural invariant you want to test and we will
+// find a runtime assertion instead.
 
 /**
+ * @deprecated Use a real behaviour test against the function under
+ *   inspection instead. See #4784 and CONTRIBUTING.md > "Test behaviour,
+ *   not source shape". No new callers.
+ *
  * Extract a region of source between a start anchor and either an explicit
  * end anchor or, if none is given, a set of reasonable structural
  * terminators (next `private `/`export `/`function `/`class `/`interface `/
  * `//` section separator). Falls back to end-of-source if none match.
  *
- * Use this instead of `src.slice(startIdx, startIdx + N)` when searching
- * for patterns within a specific method or region — the start anchor is
- * what the caller already has, and the end is determined by structure,
- * not by a magic byte count that breaks under refactors.
- *
  * @param src        The source text.
  * @param startAnchor Literal substring that marks the start of the region.
  *                   Typically a function name, a section header comment, or

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -44,7 +44,19 @@ describe("#2883: tool invocation error tracking on AutoSession", () => {
 
 // ─── isToolInvocationError classifier ────────────────────────────────────
 
-import { isToolInvocationError, isQueuedUserMessageSkip } from "../auto-tool-tracking.ts";
+import {
+  isDeterministicPolicyError,
+  isToolInvocationError,
+  isQueuedUserMessageSkip,
+} from "../auto-tool-tracking.ts";
+import {
+  shouldBlockContextWrite,
+  shouldBlockPendingGateInSnapshot,
+  shouldBlockQueueExecutionInSnapshot,
+  resetWriteGateState,
+  type WriteGateSnapshot,
+} from "../bootstrap/write-gate.ts";
+import { BLOCKED_WRITE_ERROR } from "../write-intercept.ts";
 
 describe("#2883: isToolInvocationError classification", () => {
   test("detects JSON validation failure pattern", () => {
@@ -89,11 +101,59 @@ describe("#2883: isToolInvocationError classification", () => {
     );
   });
 
+  test("detects raw write-gate CONTEXT failures for non-GSD write tools", () => {
+    resetWriteGateState();
+    const result = shouldBlockContextWrite(
+      "write",
+      "/tmp/project/.gsd/milestones/M001/M001-CONTEXT.md",
+      "M001",
+      false,
+    );
+
+    assert.equal(result.block, true);
+    assert.equal(isDeterministicPolicyError(result.reason ?? ""), true);
+    assert.equal(isToolInvocationError(result.reason ?? ""), true);
+  });
+
+  test("detects raw pending-gate failures for non-GSD write tools", () => {
+    const snapshot: WriteGateSnapshot = {
+      verifiedDepthMilestones: [],
+      activeQueuePhase: false,
+      pendingGateId: "depth_verification_M001",
+    };
+    const result = shouldBlockPendingGateInSnapshot(snapshot, "write", "M001", false);
+
+    assert.equal(result.block, true);
+    assert.equal(isDeterministicPolicyError(result.reason ?? ""), true);
+    assert.equal(isToolInvocationError(result.reason ?? ""), true);
+  });
+
+  test("detects queue-mode policy blocks for raw write/edit/bash tools", () => {
+    const snapshot: WriteGateSnapshot = {
+      verifiedDepthMilestones: [],
+      activeQueuePhase: true,
+      pendingGateId: null,
+    };
+    const writeResult = shouldBlockQueueExecutionInSnapshot(snapshot, "write", "src/app.ts", true);
+    const bashResult = shouldBlockQueueExecutionInSnapshot(snapshot, "bash", "npm run build", true);
+
+    assert.equal(writeResult.block, true);
+    assert.equal(bashResult.block, true);
+    assert.equal(isDeterministicPolicyError(writeResult.reason ?? ""), true);
+    assert.equal(isToolInvocationError(bashResult.reason ?? ""), true);
+  });
+
+  test("detects direct STATE.md/gsd.db write-intercept policy blocks", () => {
+    assert.equal(isDeterministicPolicyError(BLOCKED_WRITE_ERROR), true);
+    assert.equal(isToolInvocationError(BLOCKED_WRITE_ERROR), true);
+  });
+
   test("returns false for normal tool errors (business logic)", () => {
     assert.equal(
       isToolInvocationError("Slice S01 is already complete"),
       false,
     );
+    assert.equal(isDeterministicPolicyError("Slice S01 is already complete"), false);
   });
 
   test("returns false for empty string", () => {

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

@@ -36,6 +36,9 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
   { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
   { canonical: "gsd_validate_milestone", alias: "gsd_milestone_validate" },
+  { canonical: "gsd_task_reopen", alias: "gsd_reopen_task" },
+  { canonical: "gsd_slice_reopen", alias: "gsd_reopen_slice" },
+  { canonical: "gsd_milestone_reopen", alias: "gsd_reopen_milestone" },
 ];
 
 // ─── Registration count ──────────────────────────────────────────────────────
@@ -45,7 +48,11 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assert.deepStrictEqual(pi.tools.length, 30, 'Should register exactly 30 tools (14 canonical + 14 aliases + 1 gate tool + 1 gsd_skip_slice)');
+assert.deepStrictEqual(
+  pi.tools.length,
+  RENAME_MAP.length * 2 + 2,
+  'Should register canonical/alias tool pairs plus 1 gate tool and 1 gsd_skip_slice',
+);
 
 // ─── Both names exist for each pair ──────────────────────────────────────────