gsd-pi 2.63.0 → 2.64.0-dev.1a85e85

package/src/resources/extensions/gsd/tests/pre-execution-pause-wiring.test.ts

@@ -0,0 +1,457 @@
+/**
+ * pre-execution-pause-wiring.test.ts — Integration tests for pre-execution check → pauseAuto wiring.
+ *
+ * Tests that verify the control flow from pre-execution checks through to pauseAuto:
+ *   1. When runPreExecutionChecks returns status: "fail" with blocking: true, pauseAuto is called
+ *   2. When enhanced_verification_strict: true and status: "warn", pauseAuto is also called
+ *
+ * These are integration-level tests that exercise the actual postUnitPostVerification function
+ * with controlled mocks for external dependencies.
+ */
+
+import { describe, test, mock, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+import { postUnitPostVerification, type PostUnitContext } from "../auto-post-unit.ts";
+import { AutoSession } from "../auto/session.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+
+let tempDir: string;
+let dbPath: string;
+let originalCwd: string;
+
+/**
+ * Create a minimal mock ExtensionContext.
+ */
+function makeMockCtx() {
+  return {
+    ui: {
+      notify: mock.fn(),
+      setStatus: () => {},
+      setWidget: () => {},
+      setFooter: () => {},
+    },
+    model: { id: "test-model" },
+  } as any;
+}
+
+/**
+ * Create a minimal mock ExtensionAPI.
+ */
+function makeMockPi() {
+  return {
+    sendMessage: mock.fn(),
+    setModel: mock.fn(async () => true),
+  } as any;
+}
+
+/**
+ * Create a minimal AutoSession for testing.
+ */
+function makeMockSession(basePath: string, currentUnit?: { type: string; id: string }): AutoSession {
+  const s = new AutoSession();
+  s.basePath = basePath;
+  s.active = true;
+  if (currentUnit) {
+    s.currentUnit = {
+      type: currentUnit.type,
+      id: currentUnit.id,
+      startedAt: Date.now(),
+    };
+  }
+  return s;
+}
+
+/**
+ * Create a PostUnitContext with a mockable pauseAuto.
+ */
+function makePostUnitContext(
+  s: AutoSession,
+  ctx: ReturnType<typeof makeMockCtx>,
+  pi: ReturnType<typeof makeMockPi>,
+  pauseAutoMock: ReturnType<typeof mock.fn>,
+): PostUnitContext {
+  return {
+    s,
+    ctx,
+    pi,
+    buildSnapshotOpts: () => ({}),
+    lockBase: () => tempDir,
+    stopAuto: mock.fn(async () => {}) as unknown as PostUnitContext["stopAuto"],
+    pauseAuto: pauseAutoMock as unknown as PostUnitContext["pauseAuto"],
+    updateProgressWidget: () => {},
+  };
+}
+
+/**
+ * Set up a temp directory with GSD structure and DB.
+ * Also changes cwd so preferences loading finds the right PREFERENCES.md.
+ */
+function setupTestEnvironment(): void {
+  // Save original cwd so we can restore it
+  originalCwd = process.cwd();
+  
+  tempDir = join(tmpdir(), `pre-exec-pause-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+  
+  // Create .gsd directory structure
+  const gsdDir = join(tempDir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+  
+  // Create milestones directory structure
+  const milestonesDir = join(gsdDir, "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(milestonesDir, { recursive: true });
+  
+  // Change cwd so loadEffectiveGSDPreferences finds our PREFERENCES.md
+  process.chdir(tempDir);
+  
+  // Clear gsdRoot cache so it finds the new .gsd directory
+  _clearGsdRootCache();
+  
+  // Initialize DB
+  dbPath = join(gsdDir, "gsd.db");
+  openDatabase(dbPath);
+}
+
+/**
+ * Clean up test environment.
+ */
+function cleanupTestEnvironment(): void {
+  // Restore original cwd before cleanup
+  try {
+    process.chdir(originalCwd);
+  } catch {
+    // Ignore if original cwd doesn't exist
+  }
+  
+  try {
+    closeDatabase();
+  } catch {
+    // Ignore close errors
+  }
+  try {
+    rmSync(tempDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+/**
+ * Create a PREFERENCES.md file with specified preferences.
+ * Uses YAML frontmatter format (---\nkey: value\n---).
+ * Also invalidates caches so the preferences are re-read.
+ */
+function writePreferences(prefs: Record<string, unknown>): void {
+  const yamlLines = Object.entries(prefs).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  const prefsContent = `---
+${yamlLines.join("\n")}
+---
+
+# GSD Preferences
+`;
+  writeFileSync(join(tempDir, ".gsd", "PREFERENCES.md"), prefsContent);
+  // Invalidate caches so the new preferences file is found
+  invalidateAllCaches();
+  _clearGsdRootCache();
+}
+
+/**
+ * Create tasks in DB that will cause pre-execution checks to fail.
+ * A task that references a non-existent file will produce a blocking failure.
+ */
+function createFailingTasks(): void {
+  // Insert milestone first
+  insertMilestone({ id: "M001" });
+
+  // Insert slice
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    risk: "low",
+  });
+
+  // Create a task that references a file that doesn't exist
+  // This will cause checkFilePathConsistency to produce a blocking failure
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task with missing file",
+    status: "pending",
+    planning: {
+      description: "This task references a non-existent file",
+      estimate: "1h",
+      files: ["nonexistent-file-that-does-not-exist.ts"],
+      verify: "npm test",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 0,
+  });
+}
+
+/**
+ * Create tasks in DB that will produce only warnings (non-blocking issues).
+ * Interface contract mismatches produce warnings, not blocking failures.
+ */
+function createWarningOnlyTasks(): void {
+  // Insert milestone first
+  insertMilestone({ id: "M001" });
+
+  // Insert slice
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    risk: "low",
+  });
+
+  // Create tasks with interface contract mismatch (produces warn, not fail)
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task 1 with function signature",
+    status: "pending",
+    planning: {
+      description: `
+\`\`\`typescript
+function processData(input: string): boolean
+\`\`\`
+      `.trim(),
+      estimate: "1h",
+      files: [],
+      verify: "npm test",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 0,
+  });
+
+  insertTask({
+    id: "T02",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task 2 with mismatched signature",
+    status: "pending",
+    planning: {
+      description: `
+\`\`\`typescript
+function processData(input: number): string
+\`\`\`
+      `.trim(),
+      estimate: "1h",
+      files: [],
+      verify: "npm test",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 1,
+  });
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("Pre-execution checks → pauseAuto wiring", () => {
+  beforeEach(() => {
+    setupTestEnvironment();
+  });
+
+  afterEach(() => {
+    cleanupTestEnvironment();
+  });
+
+  test("pauseAuto is called when pre-execution checks return status: fail with blocking: true", async () => {
+    // Set up tasks that will cause a blocking failure
+    createFailingTasks();
+
+    // Create mocks
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "plan-slice", id: "M001/S01" });
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+
+    // Call postUnitPostVerification
+    const result = await postUnitPostVerification(pctx);
+
+    // Verify pauseAuto was called
+    assert.equal(
+      pauseAutoMock.mock.callCount(),
+      1,
+      "pauseAuto should be called exactly once when pre-execution checks fail with blocking issues"
+    );
+
+    // Verify return value is "stopped"
+    assert.equal(
+      result,
+      "stopped",
+      "postUnitPostVerification should return 'stopped' when pre-execution checks fail"
+    );
+
+    // Verify UI was notified of the failure
+    const notifyCalls = ctx.ui.notify.mock.calls;
+    const errorNotify = notifyCalls.find(
+      (call: { arguments: unknown[] }) =>
+        call.arguments[1] === "error" &&
+        String(call.arguments[0]).includes("Pre-execution checks failed")
+    );
+    assert.ok(errorNotify, "Should show error notification about pre-execution check failure");
+  });
+
+  test("pauseAuto is called when enhanced_verification_strict: true and pre-execution returns warn", async () => {
+    // Write preferences with strict mode enabled
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_pre: true,
+      enhanced_verification_strict: true,
+    });
+
+    // Set up tasks that will produce only warnings (interface contract mismatch)
+    createWarningOnlyTasks();
+
+    // Create mocks
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "plan-slice", id: "M001/S01" });
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+
+    // Call postUnitPostVerification
+    const result = await postUnitPostVerification(pctx);
+
+    // Verify pauseAuto was called (strict mode promotes warnings to blocking)
+    assert.equal(
+      pauseAutoMock.mock.callCount(),
+      1,
+      "pauseAuto should be called when strict mode is enabled and pre-execution returns warn"
+    );
+
+    // Verify return value is "stopped"
+    assert.equal(
+      result,
+      "stopped",
+      "postUnitPostVerification should return 'stopped' when strict mode treats warnings as blocking"
+    );
+
+    // Verify UI was notified of the warning
+    const notifyCalls = ctx.ui.notify.mock.calls;
+    const warnNotify = notifyCalls.find(
+      (call: { arguments: unknown[] }) =>
+        call.arguments[1] === "warning" &&
+        String(call.arguments[0]).includes("Pre-execution checks passed with warnings")
+    );
+    assert.ok(warnNotify, "Should show warning notification about pre-execution check warnings");
+  });
+
+  test("pauseAuto is NOT called when enhanced_verification_strict: false and pre-execution returns warn", async () => {
+    // Write preferences with strict mode disabled (default behavior)
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_pre: true,
+      enhanced_verification_strict: false,
+    });
+
+    // Set up tasks that will produce only warnings
+    createWarningOnlyTasks();
+
+    // Create mocks
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "plan-slice", id: "M001/S01" });
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+
+    // Call postUnitPostVerification
+    const result = await postUnitPostVerification(pctx);
+
+    // Verify pauseAuto was NOT called (warnings don't block in non-strict mode)
+    assert.equal(
+      pauseAutoMock.mock.callCount(),
+      0,
+      "pauseAuto should NOT be called when strict mode is disabled and only warnings exist"
+    );
+
+    // Verify return value is "continue" (not "stopped")
+    assert.equal(
+      result,
+      "continue",
+      "postUnitPostVerification should return 'continue' when warnings don't block in non-strict mode"
+    );
+  });
+
+  test("pre-execution checks are skipped when unit type is not plan-slice", async () => {
+    // Set up tasks that would fail if checked
+    createFailingTasks();
+
+    // Create mocks with execute-task unit (not plan-slice)
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+
+    // Call postUnitPostVerification
+    const result = await postUnitPostVerification(pctx);
+
+    // Verify pauseAuto was NOT called (pre-execution checks only run for plan-slice)
+    assert.equal(
+      pauseAutoMock.mock.callCount(),
+      0,
+      "pauseAuto should NOT be called for non-plan-slice unit types"
+    );
+
+    // Verify return value is "continue"
+    assert.equal(
+      result,
+      "continue",
+      "postUnitPostVerification should return 'continue' for non-plan-slice unit types"
+    );
+  });
+
+  test("pre-execution checks are skipped when enhanced_verification_pre: false", async () => {
+    // Write preferences with pre-execution checks disabled
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_pre: false,
+    });
+
+    // Set up tasks that would fail if checked
+    createFailingTasks();
+
+    // Create mocks
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "plan-slice", id: "M001/S01" });
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+
+    // Call postUnitPostVerification
+    const result = await postUnitPostVerification(pctx);
+
+    // Verify pauseAuto was NOT called (pre-execution checks disabled)
+    assert.equal(
+      pauseAutoMock.mock.callCount(),
+      0,
+      "pauseAuto should NOT be called when enhanced_verification_pre is disabled"
+    );
+
+    // Verify return value is "continue"
+    assert.equal(
+      result,
+      "continue",
+      "postUnitPostVerification should return 'continue' when pre-execution checks are disabled"
+    );
+  });
+});

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

@@ -412,6 +412,16 @@ test("unrecognized format warning is emitted at most once (#2373)", () => {
   }
 });
 
+test("parsePreferencesMarkdown parses heading+list format without frontmatter (#2036)", () => {
+  // A GSD agent recovery session wrote preferences in markdown heading+list
+  // format instead of YAML frontmatter. Since the heading+list fallback parser
+  // was added, this format is now handled gracefully.
+  const content = "## Git\n\n- isolation: none\n";
+  const result = parsePreferencesMarkdown(content);
+  assert.notEqual(result, null, "heading+list content should be parsed");
+  assert.deepStrictEqual(result!.git, { isolation: "none" });
+});
+
 // ── Experimental preferences ─────────────────────────────────────────────────
 
 test("experimental.rtk: true is accepted and stored", () => {

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -231,6 +231,31 @@ test("complete-slice prompt uses camelCase parameter names matching TypeBox sche
   assert.match(toolCallLine!, /sliceId/);
 });
 
+// ─── File system safety: complete-slice parity with complete-milestone (#2935) ──
+
+test("complete-slice prompt includes filesystem safety guard against EISDIR", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(
+    prompt,
+    /File system safety/i,
+    "complete-slice.md must include a 'File system safety' instruction to prevent EISDIR errors when the LLM passes a directory path to the read tool"
+  );
+  assert.match(
+    prompt,
+    /never pass.*directory path.*directly to the.*read.*tool/i,
+    "complete-slice.md must warn against passing directory paths to the read tool"
+  );
+});
+
+test("complete-milestone prompt still has its filesystem safety guard (regression)", () => {
+  const prompt = readPrompt("complete-milestone");
+  assert.match(
+    prompt,
+    /File system safety/i,
+    "complete-milestone.md must keep its filesystem safety guard"
+  );
+});
+
 test("reactive-execute prompt references tool calls instead of checkbox updates", () => {
   const prompt = readPrompt("reactive-execute");
   assert.doesNotMatch(prompt, /checkbox updates/);

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -133,6 +133,19 @@ test("parseRoadmapSlices: table with glyph completion markers (#2841)", () => {
   assert.equal(slices[3]?.done, true);
 });
 
+test("parseRoadmapSlices: table with heavy check mark U+2714 (#2940)", () => {
+  const tableContent = [
+    "# M003: Heavy Check", "", "## Slices", "",
+    "| Slice | Title | Risk | Status |", "|---|---|---|---|",
+    "| S01 | First | Low | \u2714 |",
+    "| S02 | Second | High | Pending |", "",
+  ].join("\n");
+  const slices = parseRoadmapSlices(tableContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "U+2714 heavy check mark should mark slice as done");
+  assert.equal(slices[1]?.done, false);
+});
+
 test("parseRoadmapSlices: table with dependencies column (#1736)", () => {
   const tableContent = [
     "# M004: Deps", "", "## Slices", "",
@@ -393,3 +406,59 @@ test("parseRoadmapSlices: indented H3 headers under ## Slices (#2567)", () => {
   assert.equal(slices[1]?.id, "S02");
   assert.equal(slices[1]?.title, "Build");
 });
+
+// ── Regression tests for #1884: ✅ (U+2705) completion marker ──────────────
+
+test("parseRoadmapSlices: prose headers with ✅ suffix detected as done (#1884)", () => {
+  const proseContent = `# M013: Prose Roadmap
+
+### S01: Plan Limits & Billing Foundation ✅
+All tasks done.
+
+### S02: Usage Tracking
+Not done yet.
+
+### S03: Notification System ✅
+Also done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 3);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true, "S01 with trailing ✅ should be done");
+  assert.equal(slices[0]?.title, "Plan Limits & Billing Foundation");
+  assert.equal(slices[1]?.done, false);
+  assert.equal(slices[2]?.done, true, "S03 with trailing ✅ should be done");
+  assert.equal(slices[2]?.title, "Notification System");
+});
+
+test("parseRoadmapSlices: prose headers with ✅ prefix before title detected as done (#1884)", () => {
+  const proseContent = `# M014: Prose
+
+## ✅ S01: Done Slice
+Complete.
+
+## S02: Pending Slice
+Not done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "prefix ✅ should mark as done");
+  assert.equal(slices[0]?.title, "Done Slice");
+  assert.equal(slices[1]?.done, false);
+});
+
+test("parseRoadmapSlices: prose headers with ✅ after separator detected as done (#1884)", () => {
+  const proseContent = `# M015: Prose
+
+## S01: ✅ First Feature
+Done.
+
+## S02: Second Feature
+Not done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "✅ after colon should mark as done");
+  assert.equal(slices[0]?.title, "First Feature");
+  assert.equal(slices[1]?.done, false);
+});

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

@@ -68,6 +68,36 @@ describe('shared-wal', async () => {
       'forward-slash worktree path resolves correctly');
   }
 
+  // ─── Test (e1): external-state worktree resolves to project state DB (#2952) ───
+  console.log('\n=== shared-wal: resolve external-state worktree path (#2952) ===');
+  {
+    // External-state layout: ~/.gsd/projects/<hash>/worktrees/<MID>
+    // Should resolve to:     ~/.gsd/projects/<hash>/gsd.db
+    const stateRoot = '/home/user/.gsd/projects/a1b2c3d4';
+    const worktreePath = join(stateRoot, 'worktrees', 'M002');
+    const result = resolveProjectRootDbPath(worktreePath);
+    assert.deepStrictEqual(result, join(stateRoot, 'gsd.db'),
+      'external-state worktree path resolves to project state DB (#2952)');
+  }
+
+  // ─── Test (e2): external-state worktree nested subdir (#2952) ─────────
+  console.log('\n=== shared-wal: resolve external-state worktree nested subdir (#2952) ===');
+  {
+    const stateRoot = '/home/user/.gsd/projects/deadbeef42';
+    const nestedPath = join(stateRoot, 'worktrees', 'M003', 'src', 'lib');
+    const result = resolveProjectRootDbPath(nestedPath);
+    assert.deepStrictEqual(result, join(stateRoot, 'gsd.db'),
+      'external-state nested worktree subdir resolves to project state DB (#2952)');
+  }
+
+  // ─── Test (e3): external-state worktree with forward slashes (#2952) ──
+  console.log('\n=== shared-wal: resolve external-state worktree forward-slash (#2952) ===');
+  {
+    const result = resolveProjectRootDbPath('/Users/dev/.gsd/projects/cafe0123/worktrees/M001');
+    assert.deepStrictEqual(result, join('/Users/dev/.gsd/projects/cafe0123', 'gsd.db'),
+      'external-state forward-slash worktree path resolves correctly (#2952)');
+  }
+
   // ─── Test (e): Concurrent writes — 3 connections to same WAL DB ───────
   console.log('\n=== shared-wal: concurrent writes via WAL ===');
   {

package/src/resources/extensions/gsd/tests/slice-context-injection.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Regression test: S##-CONTEXT.md from slice discussion must be
+ * injected into all 5 downstream prompt builders (#3452).
+ *
+ * Scans auto-prompts.ts for the 5 builder functions and verifies
+ * each one resolves and inlines the slice-level CONTEXT file.
+ */
+
+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";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
+const source = readFileSync(autoPromptsPath, "utf-8");
+
+const BUILDERS = [
+  "buildResearchSlicePrompt",
+  "buildPlanSlicePrompt",
+  "buildCompleteSlicePrompt",
+  "buildReplanSlicePrompt",
+  "buildReassessRoadmapPrompt",
+];
+
+describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
+  for (const builder of BUILDERS) {
+    test(`${builder} resolves slice CONTEXT file`, () => {
+      // Find the function body
+      const fnStart = source.indexOf(`export async function ${builder}`);
+      assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
+
+      // Get a reasonable chunk after the function start (enough to cover the inlining section)
+      const chunk = source.slice(fnStart, fnStart + 3000);
+
+      // Must resolve the slice CONTEXT path
+      assert.ok(
+        chunk.includes('resolveSliceFile(base, mid,') && chunk.includes('"CONTEXT"'),
+        `${builder} should call resolveSliceFile with "CONTEXT"`,
+      );
+
+      // Must inline it with inlineFileOptional
+      assert.ok(
+        chunk.includes('Slice Context'),
+        `${builder} should inline slice CONTEXT with a "Slice Context" label`,
+      );
+    });
+  }
+});