gsd-pi 2.76.0 → 2.77.0

package/src/resources/extensions/gsd/tests/pre-exec-gate-loop.test.ts

@@ -0,0 +1,272 @@
+/**
+ * pre-exec-gate-loop.test.ts — Regression tests for #4551.
+ *
+ * Verifies that when a pre-execution gate fails on a plan-slice unit:
+ *   1. `s.lastPreExecFailure` is populated on the AutoSession with the blocking
+ *      findings and a verdict excerpt.
+ *   2. The `planning → plan-slice` dispatch rule reads that field and injects a
+ *      "Fix these specific issues" section into the prompt.
+ *   3. The field is cleared (consumed) after the prompt is built so that stale
+ *      context does not bleed into an unrelated future plan-slice run.
+ *   4. When the failure belongs to a *different* unit ID, the dispatch rule
+ *      does NOT inject the stale context into the prompt.
+ */
+
+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 { tmpdir } from "node:os";
+
+import { AutoSession } from "../auto/session.ts";
+import { resolveDispatch } from "../auto-dispatch.ts";
+import type { DispatchContext } from "../auto-dispatch.ts";
+import { buildPlanSlicePrompt } from "../auto-prompts.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+import { deriveStateFromDb } from "../state.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeTempBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-4551-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function seedPlanningState(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Core Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "demo",
+    sequence: 1,
+    isSketch: false,
+  });
+  // Write minimal ROADMAP so state derivation doesn't error
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# Roadmap\n",
+  );
+}
+
+function cleanup(base: string, originalCwd: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { process.chdir(originalCwd); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+test("#4551: AutoSession.lastPreExecFailure defaults to null", () => {
+  const s = new AutoSession();
+  assert.equal(s.lastPreExecFailure, null, "lastPreExecFailure must start null");
+});
+
+test("#4551: AutoSession.reset() clears lastPreExecFailure", () => {
+  const s = new AutoSession();
+  s.lastPreExecFailure = {
+    unitId: "M001/S01",
+    blockingFindings: ["[file] src/foo.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+  s.reset();
+  assert.equal(s.lastPreExecFailure, null, "reset() must clear lastPreExecFailure");
+});
+
+test("#4551: buildPlanSlicePrompt injects fix section when priorPreExecFailure provided", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const prompt = await buildPlanSlicePrompt(
+    "M001", "Test Milestone", "S01", "Core Slice", base,
+    undefined,
+    {
+      priorPreExecFailure: {
+        blockingFindings: [
+          "[file] src/utils/helper.ts: file not found",
+          "[package] nonexistent-pkg: package not found on npm",
+        ],
+        verdictExcerpt: "status=fail; 2 blocking issues detected",
+      },
+    },
+  );
+
+  assert.ok(
+    prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must contain the fix section heading",
+  );
+  assert.ok(
+    prompt.includes("src/utils/helper.ts: file not found"),
+    "prompt must include the specific file finding",
+  );
+  assert.ok(
+    prompt.includes("nonexistent-pkg: package not found on npm"),
+    "prompt must include the specific package finding",
+  );
+  assert.ok(
+    prompt.includes("status=fail; 2 blocking issues detected"),
+    "prompt must include the verdict excerpt",
+  );
+});
+
+test("#4551: buildPlanSlicePrompt with no priorPreExecFailure does NOT include fix section", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const prompt = await buildPlanSlicePrompt(
+    "M001", "Test Milestone", "S01", "Core Slice", base,
+    undefined,
+    { /* no priorPreExecFailure */ },
+  );
+
+  assert.ok(
+    !prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must NOT include the fix section when no failure context is given",
+  );
+});
+
+test("#4551: dispatch rule injects failure context and clears session field", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  // Write a RESEARCH file so the dispatch rule skips research-slice and reaches
+  // plan-slice (which is the phase we're testing).
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+    "# Research\n",
+  );
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const state = await deriveStateFromDb(base);
+  assert.equal(state.phase, "planning", "state must be in planning phase");
+
+  const session = new AutoSession();
+  session.basePath = base;
+  session.active = true;
+  session.lastPreExecFailure = {
+    unitId: "M001/S01",
+    blockingFindings: ["[file] src/missing.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+
+  const ctx: DispatchContext = {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { phases: { reassess_after_slice: false, skip_research: true } } as any,
+    session,
+  };
+
+  const result = await resolveDispatch(ctx);
+  assert.equal(result.action, "dispatch", "must dispatch a unit");
+  if (result.action !== "dispatch") throw new Error("unreachable");
+  assert.equal(result.unitType, "plan-slice", "must be a plan-slice unit");
+
+  // The fix section must appear in the prompt
+  assert.ok(
+    result.prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "dispatched prompt must include the fix section",
+  );
+  assert.ok(
+    result.prompt.includes("src/missing.ts: file not found"),
+    "dispatched prompt must include the specific blocking finding",
+  );
+
+  // Field must be cleared after consumption
+  assert.equal(
+    session.lastPreExecFailure,
+    null,
+    "lastPreExecFailure must be cleared after being consumed by the dispatch rule",
+  );
+});
+
+test("#4551: dispatch rule does NOT inject stale failure for a different slice", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  // Write a RESEARCH file so dispatch reaches plan-slice, making the assertion
+  // about the prompt meaningful (we can check it's a plan-slice prompt without
+  // the fix section rather than a research-slice prompt without it).
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+    "# Research\n",
+  );
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const state = await deriveStateFromDb(base);
+
+  const session = new AutoSession();
+  session.basePath = base;
+  session.active = true;
+  // Failure belongs to a different slice (S02), not the active one (S01)
+  session.lastPreExecFailure = {
+    unitId: "M001/S02",
+    blockingFindings: ["[file] src/other.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+
+  const ctx: DispatchContext = {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { phases: { reassess_after_slice: false, skip_research: true } } as any,
+    session,
+  };
+
+  const result = await resolveDispatch(ctx);
+  assert.equal(result.action, "dispatch");
+  if (result.action !== "dispatch") throw new Error("unreachable");
+
+  // The stale fix section must NOT appear
+  assert.ok(
+    !result.prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must NOT include fix section for a mismatched unit ID",
+  );
+  assert.ok(
+    !result.prompt.includes("src/other.ts"),
+    "prompt must NOT include findings from a different slice",
+  );
+
+  // Field must remain untouched (not consumed)
+  assert.notEqual(
+    session.lastPreExecFailure,
+    null,
+    "lastPreExecFailure must NOT be cleared when unit IDs don't match",
+  );
+});

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

@@ -140,6 +140,25 @@ import type { Request } from 'express';
     assert.ok(packages.includes("typescript"));
     assert.ok(!packages.includes("-D"));
   });
+
+  // Regression tests for #4388: prose containing `from "..."` must not produce false-positive packages
+  test("does not treat prose 'from \"What's Next\"' as a package name (#4388)", () => {
+    const desc = 'Build the feature described from "What\'s Next" in the roadmap';
+    const packages = extractPackageReferences(desc);
+    assert.deepEqual(packages, [], `prose 'from "What\\'s Next"' must not produce package names, got: ${JSON.stringify(packages)}`);
+  });
+
+  test("does not treat prose \"from 'master'\" as a package name (#4388)", () => {
+    const desc = "Review changes from 'master' branch before merging";
+    const packages = extractPackageReferences(desc);
+    assert.deepEqual(packages, [], `prose "from 'master'" must not produce package names, got: ${JSON.stringify(packages)}`);
+  });
+
+  test("still extracts import statements in code blocks after #4388 fix", () => {
+    const desc = "```typescript\nimport express from 'express';\nimport { Router } from 'express';\n```";
+    const packages = extractPackageReferences(desc);
+    assert.ok(packages.includes("express"), "import...from in code blocks must still be recognized");
+  });
 });
 
 // ─── File Path Consistency Tests ─────────────────────────────────────────────
@@ -1580,6 +1599,221 @@ describe("checkTaskOrdering directory inputs (#4446)", () => {
   });
 });
 
+// ─── Regression Tests: checkTaskOrdering false positive for pre-execution refs (#4071) ──
+
+describe("checkTaskOrdering false positive for pre-execution refs (#4071)", () => {
+  test("completed task at higher index does not trigger ordering violation for its outputs", () => {
+    // Scenario: after a replan, a completed task at higher array index has already
+    // created a file. A new earlier-sequence task reads that file. Since the
+    // completed task already ran, its output is available regardless of disk state.
+    // checkTaskOrdering must not flag this as a sequence violation.
+    const tasks = [
+      createTask({
+        id: "T_NEW",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/setup.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T_SETUP",
+        sequence: 5,
+        status: "completed",
+        inputs: [],
+        expected_output: ["artifacts/setup.json"],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      0,
+      "completed task outputs must not trigger ordering violations for earlier-sequence tasks that read them",
+    );
+  });
+
+  test("pending task at higher index still triggers ordering violation", () => {
+    // A PENDING task at higher index creating a file is a real violation.
+    // Only completed tasks get the exemption.
+    const tasks = [
+      createTask({
+        id: "T01",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/output.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T02",
+        sequence: 5,
+        status: "pending",
+        inputs: [],
+        expected_output: ["artifacts/output.json"],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      1,
+      "pending task at higher index must still be flagged as ordering violation",
+    );
+    assert.equal(results[0].blocking, true);
+    assert.ok(results[0].message.includes("T01"));
+    assert.ok(results[0].message.includes("T02"));
+    assert.ok(results[0].message.includes("sequence violation"));
+  });
+
+  test("pending-first then completed-later: completed replaces pending in fileCreators (#4572)", () => {
+    // Regression for CodeRabbit Major finding on PR #4572:
+    // fileCreators only stored the FIRST task for a given path. If a PENDING task at
+    // array index 1 was registered first, and a COMPLETED task at array index 2 also
+    // declared the same output path, the completed entry was discarded. Line ~529 then
+    // saw a pending creator with index > i and incorrectly fired a sequence violation
+    // for the reader at array index 0.
+    //
+    // Scenario: path first declared by pending task (index 1), then by completed task
+    // (index 2). Reader is at index 0. Without the fix a violation fires; with the fix
+    // the completed entry replaces the pending entry and grants the exemption.
+    const tasks = [
+      // array index 0 — reads the shared path
+      createTask({
+        id: "T_READER",
+        sequence: 1,
+        status: "pending",
+        inputs: ["shared/artifact.json"],
+        expected_output: [],
+      }),
+      // array index 1 — pending producer (visited first during map build)
+      createTask({
+        id: "T_PENDING_PRODUCER",
+        sequence: 5,
+        status: "pending",
+        inputs: [],
+        expected_output: ["shared/artifact.json"],
+      }),
+      // array index 2 — completed producer (visited second; must replace pending entry)
+      createTask({
+        id: "T_COMPLETED_PRODUCER",
+        sequence: 2,
+        status: "completed",
+        inputs: [],
+        expected_output: ["shared/artifact.json"],
+      }),
+    ];
+
+    // Without the fix: creator = T_PENDING_PRODUCER (index 1), !creator.completed && 1 > 0 → violation.
+    // With the fix:    creator = T_COMPLETED_PRODUCER (index 2), creator.completed → no violation.
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      0,
+      "completed producer must replace pending producer in fileCreators and suppress false violation",
+    );
+  });
+
+  test("completed task output exemption applies regardless of whether file exists on disk", (t) => {
+    // The completed-task exemption must work even when the file is not on disk
+    // (e.g., the file was a temporary artifact that was cleaned up after the task ran).
+    const tempDir = join(tmpdir(), `pre-exec-completed-task-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    // File deliberately NOT created on disk — completed task ran in a prior session
+    const tasks = [
+      createTask({
+        id: "T_MAIN",
+        sequence: 0,
+        status: "pending",
+        inputs: ["generated/config.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T_INIT",
+        sequence: 10,
+        status: "completed",
+        inputs: [],
+        expected_output: ["generated/config.json"],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "completed task exemption must apply even when file is absent from disk",
+    );
+  });
+});
+
+describe("checkFilePathConsistency completed-task output exemption (#4071)", () => {
+  test("completed task at higher index does not cause false positive for file it produced", (t) => {
+    // Parallel to the checkTaskOrdering fix: checkFilePathConsistency also uses
+    // getExpectedOutputsUpTo which historically only looked at prior-index tasks.
+    // A completed task at a higher index has already run and its outputs are available.
+    const tempDir = join(tmpdir(), `pre-exec-fc-completed-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    // File is NOT on disk — completed task ran in a prior session and file was cleaned
+    const tasks = [
+      createTask({
+        id: "T_MAIN",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/config.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T_SETUP",
+        sequence: 10,
+        status: "completed",
+        inputs: [],
+        expected_output: ["artifacts/config.json"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "completed task at higher index should satisfy inputs of pending tasks that read its outputs",
+    );
+  });
+
+  test("pending task at higher index still causes a missing-file error", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-fc-pending-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/output.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T02",
+        sequence: 10,
+        status: "pending",
+        inputs: [],
+        expected_output: ["artifacts/output.json"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      1,
+      "pending task at higher index must still be flagged — the file is not available yet",
+    );
+    assert.equal(results[0].blocking, true);
+    assert.equal(results[0].target, "artifacts/output.json");
+  });
+});
+
 describe("checkFilePathConsistency self-referential inputs (#4459)", () => {
   test("input that is also in the same task's expected_output is not blocking when missing on disk", (t) => {
     const tempDir = join(tmpdir(), `pre-exec-self-output-${Date.now()}`);
@@ -1645,3 +1879,125 @@ describe("checkFilePathConsistency self-referential inputs (#4459)", () => {
     );
   });
 });
+
+// ─── Regression Tests: quote-wrapped inputs treated as literal paths (#3747) ──
+
+describe("checkFilePathConsistency quote-wrapped annotation (#3747)", () => {
+  test("double-quoted path annotation is stripped before path check", (t) => {
+    // Plan documents sometimes emit `"src/foo.ts"` (double-quote wrapped) as an
+    // input value. The checker must strip the quotes before checking existence so
+    // it doesn't produce a false-positive "file not found" error.
+    const tempDir = join(tmpdir(), `pre-exec-quote-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/foo.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ['"src/foo.ts"'],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Double-quoted path should be stripped and resolved to the real file",
+    );
+  });
+
+  test("single-quoted path annotation is stripped before path check", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-squote-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/bar.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ["'src/bar.ts'"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Single-quoted path should be stripped and resolved to the real file",
+    );
+  });
+
+  test("backtick-only wrapped path without annotation resolves correctly", (t) => {
+    // The bare form `src/foo.ts` (no dash annotation) must also work
+    const tempDir = join(tmpdir(), `pre-exec-backtick-bare-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/baz.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ["`src/baz.ts`"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Bare backtick-wrapped path should resolve to the real file",
+    );
+  });
+
+  test("prose value with spaces inside quotes is skipped (not a path)", () => {
+    // "some description text" contains spaces — should not be checked as a path
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ['"some description text"'],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      0,
+      "Quoted prose with spaces should not be treated as a file path",
+    );
+  });
+
+  test("17-error scenario: mixed annotated inputs produce 0 blocking errors", (t) => {
+    // Reproduces the M004-ej6j88/S07 scenario from issue #3747 where a plan with
+    // multiple backtick- and quote-wrapped input strings causes 17 false blocking errors.
+    const tempDir = join(tmpdir(), `pre-exec-3747-scenario-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/foo.ts"), "// content");
+    writeFileSync(join(tempDir, "src/bar.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: [
+          "`src/foo.ts`",
+          '"src/bar.ts"',
+          "some description text",
+          "Existing enum definition",
+        ],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Annotated file paths and prose inputs should produce zero blocking errors",
+    );
+  });
+});