gsd-pi 2.78.0 → 2.78.1-dev.82bcf6b71

package/src/resources/extensions/gsd/tests/double-merge-guard.test.ts

@@ -1,82 +1,20 @@
+/**
+ * Behavioural regression test for #2645 — double mergeAndExit guard.
+ *
+ * AutoSession.milestoneMergedInPhases is the producer-side flag set by the
+ * "complete" / "all-milestones-complete" branches in phases.ts after they
+ * call mergeAndExit. stopAuto reads it to skip the redundant Step-4 merge
+ * (which previously failed because the branch was already deleted).
+ *
+ * Refs #4829 (rewrite from positional source-grep on phases.ts/auto.ts).
+ */
+
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { AutoSession } from "../auto/session.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("double mergeAndExit guard (#2645)", () => {
-  test("phases.ts sets milestoneMergedInPhases after mergeAndExit in milestone-complete path", () => {
-    // Source audit: the "complete" phase path must set the guard flag
-    // after calling mergeAndExit so that stopAuto skips the second merge.
-    const phasesSrc = readFileSync(
-      join(__dirname, "..", "auto", "phases.ts"),
-      "utf-8",
-    );
-
-    // Find the "complete" phase block
-    const completeIdx = phasesSrc.indexOf('state.phase === "complete"');
-    assert.ok(completeIdx > 0, "phases.ts should have a 'complete' phase check");
-
-    const afterComplete = extractSourceRegion(phasesSrc, 'state.phase === "complete"');
-    const mergeIdx = afterComplete.indexOf("deps.resolver.mergeAndExit");
-    const flagIdx = afterComplete.indexOf("s.milestoneMergedInPhases = true");
-
-    assert.ok(mergeIdx > 0, "complete path should call mergeAndExit");
-    assert.ok(flagIdx > 0, "complete path should set milestoneMergedInPhases");
-    assert.ok(
-      flagIdx > mergeIdx,
-      "milestoneMergedInPhases must be set AFTER mergeAndExit (not before)",
-    );
-  });
-
-  test("phases.ts sets milestoneMergedInPhases after mergeAndExit in all-milestones-complete path", () => {
-    const phasesSrc = readFileSync(
-      join(__dirname, "..", "auto", "phases.ts"),
-      "utf-8",
-    );
-
-    // The "all milestones complete" block checks incomplete.length === 0
-    const allCompleteIdx = phasesSrc.indexOf("incomplete.length === 0");
-    assert.ok(allCompleteIdx > 0, "phases.ts should have an all-milestones-complete check");
-
-    const afterAllComplete = extractSourceRegion(phasesSrc, "incomplete.length === 0");
-    const mergeIdx = afterAllComplete.indexOf("deps.resolver.mergeAndExit");
-    const flagIdx = afterAllComplete.indexOf("s.milestoneMergedInPhases = true");
-
-    assert.ok(mergeIdx > 0, "all-complete path should call mergeAndExit");
-    assert.ok(flagIdx > 0, "all-complete path should set milestoneMergedInPhases");
-    assert.ok(
-      flagIdx > mergeIdx,
-      "milestoneMergedInPhases must be set AFTER mergeAndExit (not before)",
-    );
-  });
-
-  test("stopAuto checks milestoneMergedInPhases before calling mergeAndExit", () => {
-    const autoSrc = readFileSync(
-      join(__dirname, "..", "auto.ts"),
-      "utf-8",
-    );
-
-    // The Step 4 worktree exit block must check the guard flag
-    const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-    assert.ok(step4Idx > 0, "auto.ts should have Step 4 worktree exit");
-
-    const step4Block = extractSourceRegion(autoSrc, "Step 4: Auto-worktree exit");
-    assert.ok(
-      step4Block.includes("milestoneMergedInPhases"),
-      "stopAuto Step 4 must check milestoneMergedInPhases before merging",
-    );
-    assert.ok(
-      step4Block.includes("!s.milestoneMergedInPhases"),
-      "stopAuto should skip merge when milestoneMergedInPhases is true",
-    );
-  });
 
-  test("AutoSession.milestoneMergedInPhases defaults to false", () => {
+describe("AutoSession.milestoneMergedInPhases (#2645)", () => {
+  test("defaults to false on a fresh session", () => {
     const session = new AutoSession();
     assert.equal(
       session.milestoneMergedInPhases,
@@ -85,7 +23,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     );
   });
 
-  test("AutoSession.reset() clears milestoneMergedInPhases", () => {
+  test("reset() clears the flag back to false", () => {
     const session = new AutoSession();
     session.milestoneMergedInPhases = true;
     session.reset();

package/src/resources/extensions/gsd/tests/ensure-preconditions-guard-4996.test.ts

@@ -0,0 +1,93 @@
+// GSD Extension — Regression test for #4996: ensurePreconditions phantom dir guard
+// Verifies that ensurePreconditions does not create milestone directories for
+// forward-referenced slice unit IDs when the milestone has no DB row.
+
+import { describe, it, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { ensurePreconditions } from "../auto.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+
+import type { GSDState } from "../types.ts";
+
+function makeBase(prefix = "gsd-precond-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function makeMinimalState(): GSDState {
+  return {
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  };
+}
+
+describe("ensurePreconditions phantom-dir guard (#4996)", () => {
+  let base: string;
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("(a) slice unit ID for unknown milestone does NOT create dirs when no DB row exists", () => {
+    base = makeBase();
+    const state = makeMinimalState();
+
+    ensurePreconditions("execute-task", "M003/S01", base, state);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    assert.ok(!existsSync(milestoneDir), "M003 dir must not be created for phantom slice dispatch");
+  });
+
+  it("(b) slice unit ID for milestone with DB row DOES create dirs", () => {
+    base = makeBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M003", status: "active" });
+    const state = makeMinimalState();
+
+    ensurePreconditions("execute-task", "M003/S01", base, state);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    assert.ok(existsSync(milestoneDir), "M003 dir must be created when DB row exists");
+  });
+
+  it("(c) slice unit ID for existing milestone dir with CONTEXT.md content file uses normal scaffolding", () => {
+    base = makeBase();
+    const mid = "M003";
+    const milestoneDir = join(base, ".gsd", "milestones", mid);
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(milestoneDir, `${mid}-CONTEXT.md`), "# Context\n");
+    const state = makeMinimalState();
+
+    ensurePreconditions("execute-task", "M003/S01", base, state);
+
+    const slicesDir = join(milestoneDir, "slices");
+    assert.ok(existsSync(slicesDir), "existing milestone dir should allow slice scaffolding");
+  });
+
+  it("(d) milestone-only unit ID (no slice) still creates dir even with no DB row", () => {
+    base = makeBase();
+    const state = makeMinimalState();
+
+    ensurePreconditions("discuss-milestone", "M003", base, state);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    assert.ok(existsSync(milestoneDir), "M003 dir must be created for milestone-only dispatch");
+  });
+});

package/src/resources/extensions/gsd/tests/false-degraded-mode-warning.test.ts

@@ -1,104 +1,43 @@
 /**
- * false-degraded-mode-warning.test.ts — Regression tests for #3922.
+ * Behavioural regression tests for #3922.
  *
- * Before this fix, deriveState() logged a "DB unavailable — degraded mode"
- * warning even when the DB simply hadn't been opened yet (e.g. during
- * before_agent_start context injection). The fix introduces wasDbOpenAttempted()
- * to distinguish "not yet initialized" from "genuinely unavailable."
+ * Before this fix, deriveState() logged "DB unavailable — degraded mode"
+ * even when the DB had not been opened yet (e.g. during
+ * before_agent_start context injection). The fix introduced
+ * wasDbOpenAttempted() so the warning fires only after a real open attempt.
  *
- * Two aspects:
- * 1. gsd-db: wasDbOpenAttempted() tracks whether openDatabase() was ever called.
- * 2. state: the degraded-mode warning is gated behind wasDbOpenAttempted().
+ * The earlier tests source-grepped state.ts for the warning string and the
+ * preceding line (POSITIONAL/SOURCE_GREP per #4826/#4829). They are
+ * replaced here with direct calls to the wasDbOpenAttempted flag.
  */
 
-import { describe, test } from "node:test";
+import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import {
   openDatabase,
   closeDatabase,
-  isDbAvailable,
   wasDbOpenAttempted,
 } from "../gsd-db.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const stateSource = readFileSync(join(__dirname, "..", "state.ts"), "utf-8");
-
-// ═══════════════════════════════════════════════════════════════════════════
-// 1. gsd-db: wasDbOpenAttempted flag
-// ═══════════════════════════════════════════════════════════════════════════
-
 describe("wasDbOpenAttempted (#3922)", () => {
+  beforeEach(() => { closeDatabase(); });
+  afterEach(() => { closeDatabase(); });
 
-  test("wasDbOpenAttempted returns true after openDatabase is called", () => {
-    // By this point in the test suite, openDatabase may or may not have been
-    // called by other tests. So we call it explicitly and verify it returns true.
+  test("returns true after a successful openDatabase call", () => {
     openDatabase(":memory:");
-    assert.strictEqual(wasDbOpenAttempted(), true,
-      "wasDbOpenAttempted should be true after openDatabase call");
-    closeDatabase();
-  });
-
-  test("openDatabase sets the flag even if it fails on invalid path", () => {
-    // openDatabase with an unreachable path may fail, but the flag should
-    // still be set because the attempt was made.
-    try { openDatabase("/nonexistent/path/that/will/fail.db"); } catch { /* expected */ }
-    assert.strictEqual(wasDbOpenAttempted(), true,
-      "wasDbOpenAttempted should be true even after a failed open attempt");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// 2. state.ts: degraded-mode warning is gated behind wasDbOpenAttempted
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("degraded-mode warning guard (#3922)", () => {
-
-  test("state.ts imports wasDbOpenAttempted from gsd-db", () => {
-    assert.ok(
-      stateSource.includes("wasDbOpenAttempted"),
-      "state.ts must import wasDbOpenAttempted to gate the degraded-mode warning",
+    assert.strictEqual(
+      wasDbOpenAttempted(),
+      true,
+      "wasDbOpenAttempted should report true after openDatabase succeeds",
     );
   });
 
-  test("degraded-mode warning is inside a wasDbOpenAttempted() guard", () => {
-    // Find the degraded-mode warning string
-    const warningStr = 'DB unavailable — using filesystem state derivation (degraded mode)';
-    const warningIdx = stateSource.indexOf(warningStr);
-    assert.ok(warningIdx > 0, "degraded-mode warning string must exist in state.ts");
-
-    // The wasDbOpenAttempted() check must appear BEFORE the warning,
-    // within the same else-branch (i.e. within a reasonable distance).
-    // Look backwards from the warning for the guard.
-    const searchWindow = stateSource.slice(Math.max(0, warningIdx - 300), warningIdx);
-    assert.ok(
-      searchWindow.includes("wasDbOpenAttempted()"),
-      "wasDbOpenAttempted() guard must appear shortly before the degraded-mode warning " +
-      "to prevent false warnings when DB has not been initialized yet",
+  test("remains true after a failed open attempt — the attempt is what matters", () => {
+    try { openDatabase("/nonexistent/path/that/will/fail.db"); } catch { /* expected */ }
+    assert.strictEqual(
+      wasDbOpenAttempted(),
+      true,
+      "wasDbOpenAttempted should be true even when openDatabase throws — the warning gate keys on the attempt, not the outcome",
     );
   });
-
-  test("warning is NOT emitted unconditionally in the else branch", () => {
-    // The old code had `logWarning(...)` directly in the else branch.
-    // The fix wraps it in `if (wasDbOpenAttempted())`.
-    // Verify the logWarning call is inside a conditional, not bare.
-    const lines = stateSource.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i]!.includes("DB unavailable") && lines[i]!.includes("degraded mode")) {
-        // This line has the warning. Check that the preceding non-empty line
-        // contains an if-condition (wasDbOpenAttempted), not a bare else.
-        let prev = i - 1;
-        while (prev >= 0 && lines[prev]!.trim() === "") prev--;
-        const prevLine = lines[prev]!.trim();
-        assert.ok(
-          prevLine.includes("wasDbOpenAttempted"),
-          `Line ${i + 1} emits degraded-mode warning — preceding line ${prev + 1} must ` +
-          `contain wasDbOpenAttempted guard, but found: "${prevLine}"`,
-        );
-        break;
-      }
-    }
-  });
 });

package/src/resources/extensions/gsd/tests/finalize-timeout-guard.test.ts

@@ -17,12 +17,7 @@
  */
 
 import { createTestContext } from "./test-helpers.ts";
-import {
-  withTimeout,
-  FINALIZE_PRE_TIMEOUT_MS,
-  FINALIZE_POST_TIMEOUT_MS,
-} from "../auto/finalize-timeout.ts";
-import { MAX_FINALIZE_TIMEOUTS } from "../auto/types.ts";
+import { withTimeout } from "../auto/finalize-timeout.ts";
 
 const { assertTrue, assertEq, report } = createTestContext();
 
@@ -80,44 +75,6 @@ const { assertTrue, assertEq, report } = createTestContext();
   assertTrue(caught, "rejection should propagate");
 }
 
-// ═══ Test: FINALIZE_PRE_TIMEOUT_MS is defined and reasonable ═════════════════
-
-{
-  console.log("\n=== #3757: pre-verification timeout constant is defined and reasonable ===");
-
-  assertTrue(
-    typeof FINALIZE_PRE_TIMEOUT_MS === "number",
-    "FINALIZE_PRE_TIMEOUT_MS should be a number",
-  );
-  assertTrue(
-    FINALIZE_PRE_TIMEOUT_MS >= 30_000,
-    `pre timeout should be >= 30s (got ${FINALIZE_PRE_TIMEOUT_MS}ms)`,
-  );
-  assertTrue(
-    FINALIZE_PRE_TIMEOUT_MS <= 120_000,
-    `pre timeout should be <= 120s (got ${FINALIZE_PRE_TIMEOUT_MS}ms)`,
-  );
-}
-
-// ═══ Test: FINALIZE_POST_TIMEOUT_MS is defined and reasonable ═════════════════
-
-{
-  console.log("\n=== #2344: timeout constant is defined and reasonable ===");
-
-  assertTrue(
-    typeof FINALIZE_POST_TIMEOUT_MS === "number",
-    "FINALIZE_POST_TIMEOUT_MS should be a number",
-  );
-  assertTrue(
-    FINALIZE_POST_TIMEOUT_MS >= 30_000,
-    `timeout should be >= 30s (got ${FINALIZE_POST_TIMEOUT_MS}ms)`,
-  );
-  assertTrue(
-    FINALIZE_POST_TIMEOUT_MS <= 120_000,
-    `timeout should be <= 120s (got ${FINALIZE_POST_TIMEOUT_MS}ms)`,
-  );
-}
-
 // ═══ Test: withTimeout cleans up timer on success ════════════════════════════
 
 {
@@ -134,25 +91,6 @@ const { assertTrue, assertEq, report } = createTestContext();
   assertEq(result.timedOut, false, "should not time out");
 }
 
-// ═══ Test: MAX_FINALIZE_TIMEOUTS is defined and reasonable ═══════════════════
-
-{
-  console.log("\n=== #3757: MAX_FINALIZE_TIMEOUTS is defined and reasonable ===");
-
-  assertTrue(
-    typeof MAX_FINALIZE_TIMEOUTS === "number",
-    "MAX_FINALIZE_TIMEOUTS should be a number",
-  );
-  assertTrue(
-    MAX_FINALIZE_TIMEOUTS >= 2,
-    `threshold should be >= 2 (got ${MAX_FINALIZE_TIMEOUTS})`,
-  );
-  assertTrue(
-    MAX_FINALIZE_TIMEOUTS <= 10,
-    `threshold should be <= 10 (got ${MAX_FINALIZE_TIMEOUTS})`,
-  );
-}
-
 // Note: the two previous source-grep blocks that scanned phases.ts for
 // `withTimeout(` / `failClosedOnFinalizeTimeout(` occurrences were removed
 // under #4825 — they encoded implementation shape (Goodhart) and broke on

package/src/resources/extensions/gsd/tests/find-missing-summaries-closed-runtime.test.ts

@@ -0,0 +1,47 @@
+/**
+ * Runtime regression — closed-status omission for missing-summary detection
+ * (#4902).
+ *
+ * `findMissingSummaries` (auto-dispatch.ts) filters out slices in any closed
+ * status before checking for an on-disk SUMMARY. The deleted source-grep
+ * test asserted the literal `CLOSED_STATUSES` Set; this rewrite tests the
+ * exported predicate (`isClosedStatus`) that the inline Set replicates,
+ * so any drift between the predicate and the inline filter surfaces as a
+ * test failure here rather than a runtime miss.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { isClosedStatus, isInactiveStatus } from '../status-guards.ts';
+
+describe('isClosedStatus — closed-status omission contract (#4902)', () => {
+  test('returns true for every status findMissingSummaries skips', () => {
+    // Mirror the inline Set in auto-dispatch.ts:findMissingSummaries.
+    for (const s of ['complete', 'done', 'skipped']) {
+      assert.equal(
+        isClosedStatus(s),
+        true,
+        `${s} must count as a closed status (would-have-summary omission)`,
+      );
+    }
+  });
+
+  test('returns false for live in-flight statuses', () => {
+    for (const s of ['pending', 'active', 'in-progress', 'planning', 'executing']) {
+      assert.equal(
+        isClosedStatus(s),
+        false,
+        `${s} is in-flight and MUST be checked for a missing SUMMARY`,
+      );
+    }
+  });
+
+  test('isInactiveStatus also covers deferred so it is not summary-checked', () => {
+    // Deferred slices likewise never produce a SUMMARY; the active-slice
+    // selector uses isInactiveStatus to skip them. Pin the contract.
+    assert.equal(isInactiveStatus('deferred'), true);
+    assert.equal(isInactiveStatus('complete'), true);
+    assert.equal(isInactiveStatus('pending'), false);
+  });
+});

package/src/resources/extensions/gsd/tests/forensics-stuck-loops.test.ts

@@ -9,7 +9,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import type { UnitMetrics } from "../metrics.js";
-import { detectStuckLoops, type ForensicAnomaly } from "../forensics.js";
+import type { WorktreeTelemetrySummary } from "../worktree-telemetry.js";
+import { detectStuckLoops, detectWorktreeOrphans, type ForensicAnomaly } from "../forensics.js";
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -163,3 +164,27 @@ test("#3760 detectStuckLoops still flags repeated dispatches within one auto ses
     `details should explain the session-aware rule: ${anomalies[0].details}`,
   );
 });
+
+test("#4711 detectWorktreeOrphans suggests doctor fix for completed unmerged branches", () => {
+  const anomalies: ForensicAnomaly[] = [];
+  const summary: WorktreeTelemetrySummary = {
+    worktreesCreated: 0,
+    worktreesMerged: 0,
+    orphansDetected: 1,
+    orphansByReason: { "complete-unmerged": 1 },
+    mergeDurationsMs: [],
+    mergeConflicts: 0,
+    exitsByReason: {},
+    exitsWithUnmergedWork: 0,
+    canonicalRedirects: 0,
+    slicesMerged: 0,
+    sliceMergeConflicts: 0,
+    milestoneResquashes: 0,
+  };
+
+  detectWorktreeOrphans(summary, anomalies);
+
+  assert.equal(anomalies.length, 1);
+  assert.match(anomalies[0]!.details, /\/gsd doctor fix/);
+  assert.doesNotMatch(anomalies[0]!.details, /\/gsd health --fix/);
+});

package/src/resources/extensions/gsd/tests/gitignore-bg-shell-runtime.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Runtime regression — `.bg-shell/` baseline pattern (#4902, prior #2655).
+ *
+ * The deleted `gitignore-bg-shell.test.ts` asserted `.bg-shell/` appeared in
+ * the BASELINE_PATTERNS array via source grep. This rewrite drives
+ * `ensureGitignore()` against a tmp directory and asserts the written
+ * `.gitignore` actually contains the `.bg-shell/` pattern — i.e. tests the
+ * behaviour the constant exists to guarantee, not the spelling of the
+ * constant.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { ensureGitignore } from '../gitignore.ts';
+
+function makeTmpRepo(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-gitignore-bg-'));
+}
+
+function cleanup(dir: string): void {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* swallow */ }
+}
+
+describe('ensureGitignore writes .bg-shell/ baseline (#4902)', () => {
+  test('appends .bg-shell/ to a fresh project .gitignore', () => {
+    const dir = makeTmpRepo();
+    try {
+      const wrote = ensureGitignore(dir);
+      assert.equal(wrote, true, 'ensureGitignore should report it wrote');
+
+      const ignore = fs.readFileSync(path.join(dir, '.gitignore'), 'utf-8');
+      const lines = new Set(
+        ignore.split('\n').map((l) => l.trim()).filter(Boolean),
+      );
+      assert.ok(
+        lines.has('.bg-shell/'),
+        `.gitignore should include .bg-shell/. Got:\n${ignore}`,
+      );
+    } finally {
+      cleanup(dir);
+    }
+  });
+
+  test('preserves .bg-shell/ when it is already present (idempotent)', () => {
+    const dir = makeTmpRepo();
+    try {
+      fs.writeFileSync(
+        path.join(dir, '.gitignore'),
+        '.bg-shell/\nnode_modules/\n',
+      );
+      ensureGitignore(dir); // run once to fill missing baseline
+      const ignore = fs.readFileSync(path.join(dir, '.gitignore'), 'utf-8');
+      const occurrences = ignore.split('\n').filter((l) => l.trim() === '.bg-shell/').length;
+      assert.equal(occurrences, 1, 'should not duplicate an existing .bg-shell/ entry');
+    } finally {
+      cleanup(dir);
+    }
+  });
+});