@opengsd/gsd-pi 1.2.0-dev.b1abb545 → 1.2.0-dev.d6c5343c

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -41,6 +41,7 @@ after(() => {
 
 const { resolveDispatch } = await import("../auto-dispatch.ts");
 const { buildParallelResearchSlicesPrompt } = await import("../auto-prompts.ts");
+const { openDatabase, closeDatabase, insertMilestone, insertSlice } = await import("../gsd-db.ts");
 
 type DispatchState = Parameters<typeof resolveDispatch>[0]["state"];
 
@@ -51,6 +52,20 @@ function writeRoadmap(
 ): void {
   const milestoneDir = join(base, ".gsd", "milestones", mid);
   mkdirSync(milestoneDir, { recursive: true });
+  // The dispatch rule reads slices from the DB (ADR-017), not the ROADMAP
+  // projection — seed both so disk-based artifact checks still resolve.
+  insertMilestone({ id: mid, title: "Parallel Research Milestone" });
+  let sequence = 1;
+  for (const s of slices) {
+    insertSlice({
+      id: s.id,
+      milestoneId: mid,
+      title: s.title,
+      status: s.done ? "complete" : "pending",
+      depends: s.depends ?? [],
+      sequence: sequence++,
+    });
+  }
   const lines = [
     `# ${mid}: Parallel Research Milestone`,
     "",
@@ -100,9 +115,12 @@ describe("parallel-research-slices dispatch rule", () => {
 
   beforeEach(() => {
     base = mkdtempSync(join(tmpdir(), "parallel-research-"));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
   afterEach(() => {
+    closeDatabase();
     rmSync(base, { recursive: true, force: true });
   });
 

package/src/resources/extensions/gsd/tests/parsers-legacy-importers.test.ts

@@ -0,0 +1,139 @@
+// Structural invariant: parsers-legacy is banned from decision paths (ADR-017).
+//
+// The DB is the single source of truth; `.gsd/*.md` files are projections.
+// Dispatch/gate/completion code must read state via gsd-db queries (e.g.
+// getMilestoneSliceSummaries), never by parsing markdown projections.
+//
+// Two assertions:
+// 1. Decision-path modules must NOT import parsers-legacy (hard ban).
+// 2. Every other importer must be on the explicit allowlist below, each with
+//    a one-line justification. When this test fails, do not extend the
+//    allowlist for a decision path — add/extend a query in db/queries.ts and
+//    read the DB instead.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+
+const extensionsDir = join(process.cwd(), "src/resources/extensions");
+
+// Modules that make dispatch/gate/completion decisions. Importing
+// parsers-legacy here is always a violation, allowlist or not.
+const BANNED_DECISION_PATHS = new Set([
+  "gsd/auto-direct-dispatch.ts",
+  "gsd/dispatch-guard.ts",
+  "gsd/auto-verification.ts",
+  "gsd/auto-dispatch.ts",
+  "gsd/auto-post-unit.ts",
+  "gsd/milestone-closeout.ts",
+  "gsd/auto/phases.ts",
+  "gsd/auto/orchestrator.ts",
+  "gsd/auto/loop.ts",
+  "gsd/tools/complete-slice.ts",
+]);
+
+// Legitimate importers. Each entry carries its justification; anything not
+// listed here (and not under a tests/ directory) fails the test.
+const ALLOWED_IMPORTERS = new Set([
+  // migration/import: parses markdown to populate the DB
+  "gsd/md-importer.ts",
+  "gsd/workflow-migration.ts",
+  "gsd/migration-auto-check.ts",
+  // drift detection: compares markdown projection against DB by design
+  "gsd/state-reconciliation/drift/roadmap.ts",
+  // stale-render detection + render verification helpers over rendered output
+  "gsd/markdown-renderer.ts",
+  // pre-migration fallback: deriveState must work before the DB exists
+  "gsd/state.ts",
+  // explicit degraded-mode fallback when DB has no task rows (warns on use)
+  "gsd/reactive-graph.ts",
+  // recovery path: explicit pre-migration/DB-unavailable fallback branches
+  "gsd/auto-recovery.ts",
+  // diagnostics-only surfaces: report on projections, make no dispatch decisions
+  "gsd/doctor.ts",
+  "gsd/doctor-git-checks.ts",
+  // display/telemetry-only surfaces
+  "gsd/workspace-index.ts",
+  "gsd/visualizer-data.ts",
+  // prompt context text (display strings injected into unit prompts)
+  "gsd/auto-prompts.ts",
+  // cold-path maintenance command (branch cleanup messaging)
+  "gsd/commands-maintenance.ts",
+  // display-only GitHub issue/PR body sync
+  "github-sync/sync.ts",
+]);
+
+const IMPORT_RE = /from\s+["'][^"']*parsers-legacy(?:\.js)?["']|import\(\s*["'][^"']*parsers-legacy(?:\.js)?["']\s*\)|require\(\s*["'][^"']*parsers-legacy(?:\.js)?["']\s*\)/;
+
+function walkTsFiles(root: string): string[] {
+  const out: string[] = [];
+  const stack: string[] = [root];
+
+  while (stack.length > 0) {
+    const dir = stack.pop()!;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      const full = join(dir, ent.name);
+      if (ent.isDirectory()) {
+        if (ent.name === "tests" || ent.name === "node_modules") continue;
+        stack.push(full);
+        continue;
+      }
+      if (!ent.isFile()) continue;
+      if (!ent.name.endsWith(".ts")) continue;
+      if (ent.name.startsWith(".")) continue;
+      if (ent.name.endsWith(".test.ts")) continue;
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function findImporters(): string[] {
+  const importers: string[] = [];
+  for (const file of walkTsFiles(extensionsDir)) {
+    const rel = relative(extensionsDir, file).split("\\").join("/");
+    if (rel === "gsd/parsers-legacy.ts") continue; // the module itself
+    const content = readFileSync(file, "utf-8");
+    if (IMPORT_RE.test(content)) importers.push(rel);
+  }
+  return importers.sort();
+}
+
+test("decision-path modules do not import parsers-legacy (ADR-017)", () => {
+  const violations = findImporters().filter((rel) => BANNED_DECISION_PATHS.has(rel));
+  assert.deepEqual(
+    violations,
+    [],
+    `Decision-path modules must read the DB (db/queries.ts, e.g. getMilestoneSliceSummaries), ` +
+      `not parse .gsd/*.md projections. Violations:\n  ${violations.join("\n  ")}`,
+  );
+});
+
+test("every parsers-legacy importer is on the explicit allowlist", () => {
+  const unexpected = findImporters().filter((rel) => !ALLOWED_IMPORTERS.has(rel));
+  assert.deepEqual(
+    unexpected,
+    [],
+    `New parsers-legacy importer(s) detected:\n  ${unexpected.join("\n  ")}\n` +
+      `If this is migration/drift/display-only code, add it to ALLOWED_IMPORTERS ` +
+      `with a one-line justification. If it makes dispatch/gate/completion ` +
+      `decisions, read the DB instead (db/queries.ts).`,
+  );
+});
+
+test("allowlist has no stale entries", () => {
+  const importers = new Set(findImporters());
+  const stale = [...ALLOWED_IMPORTERS].filter((rel) => !importers.has(rel));
+  assert.deepEqual(
+    stale,
+    [],
+    `Allowlist entries no longer import parsers-legacy — remove them:\n  ${stale.join("\n  ")}`,
+  );
+});

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

@@ -21,6 +21,7 @@ import { join } from "node:path";
 import {
   extractPackageReferences,
   checkFilePathConsistency,
+  checkPlanningArtifactReferences,
   checkTaskOrdering,
   checkInterfaceContracts,
   checkVerificationCommands,
@@ -973,7 +974,12 @@ describe("runPreExecutionChecks", () => {
     }
   });
 
-  test("resolves .gsd metadata inputs from canonical project root in worktree mode (#5492)", async () => {
+  // Supersedes #5492: .gsd metadata inputs used to be accepted in worktree mode
+  // by resolving from the canonical project root. Task inputs are source files
+  // only (CONTEXT.md "Task Input") — planning artifacts are now blocked with a
+  // removal message regardless of where they resolve. The canonical-root
+  // resolution itself remains for merged-but-unsynced source files.
+  test("blocks .gsd metadata inputs even when resolvable from canonical project root in worktree mode", async () => {
     const projectRoot = join(tmpdir(), `pre-exec-project-root-${Date.now()}`);
     const worktreeRoot = join(tmpdir(), `pre-exec-worktree-root-${Date.now()}`);
     mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
@@ -990,6 +996,35 @@ describe("runPreExecutionChecks", () => {
         }),
       ];
 
+      const result = await runPreExecutionChecks(tasks, worktreeRoot, {
+        canonicalProjectRoot: projectRoot,
+      });
+      assert.equal(result.status, "fail");
+      assert.equal(result.checks.length, 1);
+      assert.ok(result.checks[0].message.includes("preloaded as context"));
+    } finally {
+      rmSync(projectRoot, { recursive: true, force: true });
+      rmSync(worktreeRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("resolves source-file inputs from canonical project root in worktree mode (#5492)", async () => {
+    const projectRoot = join(tmpdir(), `pre-exec-project-root-src-${Date.now()}`);
+    const worktreeRoot = join(tmpdir(), `pre-exec-worktree-root-src-${Date.now()}`);
+    mkdirSync(join(projectRoot, "src"), { recursive: true });
+    mkdirSync(worktreeRoot, { recursive: true });
+    writeFileSync(join(projectRoot, "src", "merged.ts"), "// merged upstream");
+
+    try {
+      const tasks = [
+        createTask({
+          id: "T01",
+          files: [],
+          inputs: ["src/merged.ts"],
+          expected_output: [],
+        }),
+      ];
+
       const result = await runPreExecutionChecks(tasks, worktreeRoot, {
         canonicalProjectRoot: projectRoot,
       });
@@ -2263,3 +2298,160 @@ describe("checkFilePathConsistency quote-wrapped annotation (#3747)", () => {
     );
   });
 });
+
+// ─── Planning Artifact Reference Tests ───────────────────────────────────────
+
+describe("checkPlanningArtifactReferences", () => {
+  function withTempDir(run: (tempDir: string) => void): void {
+    const tempDir = join(tmpdir(), `pre-exec-artifact-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+      run(tempDir);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  test("blocks .gsd/ paths in inputs even when the file exists", () => {
+    withTempDir((tempDir) => {
+      const artifactDir = join(tempDir, ".gsd", "milestones", "M001");
+      mkdirSync(artifactDir, { recursive: true });
+      writeFileSync(join(artifactDir, "M001-CONTEXT.md"), "# context");
+
+      const tasks = [
+        createTask({ id: "T01", inputs: [".gsd/milestones/M001/M001-CONTEXT.md"] }),
+      ];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 1);
+      assert.equal(results[0].blocking, true);
+      assert.ok(results[0].message.includes("preloaded as context"));
+    });
+  });
+
+  test("blocks bare artifact names that do not resolve to a real file, with the truthful message", () => {
+    withTempDir((tempDir) => {
+      const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 1);
+      assert.ok(results[0].message.includes("preloaded as context"));
+      assert.ok(!results[0].message.includes("doesn't exist"));
+
+      // The consistency check must not double-report the same entry with the
+      // misleading "doesn't exist" message.
+      const consistency = checkFilePathConsistency(tasks, tempDir);
+      assert.deepEqual(consistency, []);
+    });
+  });
+
+  test("allows a bare artifact-style name that exists as a real source file", () => {
+    withTempDir((tempDir) => {
+      writeFileSync(join(tempDir, "M001-CONTEXT.md"), "# tracked source file");
+
+      const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+      assert.deepEqual(checkPlanningArtifactReferences(tasks, tempDir), []);
+    });
+  });
+
+  test("leaves artifact-style names with directory components to the existence checks", () => {
+    withTempDir((tempDir) => {
+      const tasks = [createTask({ id: "T01", inputs: ["tests/fixtures/M001-CONTEXT.md"] })];
+
+      assert.deepEqual(checkPlanningArtifactReferences(tasks, tempDir), []);
+      const consistency = checkFilePathConsistency(tasks, tempDir);
+      assert.equal(consistency.length, 1);
+      assert.ok(consistency[0].message.includes("doesn't exist"));
+    });
+  });
+
+  test("blocks .planning/ and .audits/ paths in files", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({ id: "T01", files: [".planning/codebase/STACK.md", ".audits/security.md"] }),
+      ];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 2);
+      assert.ok(results.every((r) => r.blocking && r.message.includes("never task files")));
+    });
+  });
+
+  test("blocks .gsd/ paths in expectedOutput with the workflow-tools message and no ordering duplicate", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({
+          id: "T01",
+          sequence: 0,
+          expected_output: [".gsd/milestones/M001/M001-SUMMARY.md"],
+        }),
+        createTask({
+          id: "T02",
+          sequence: 1,
+          inputs: [".gsd/milestones/M001/M001-SUMMARY.md"],
+        }),
+      ];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 2);
+      const outputFinding = results.find((r) => r.message.includes("expectedOutput"));
+      assert.ok(outputFinding);
+      assert.ok(outputFinding.message.includes("written by workflow tools"));
+
+      assert.deepEqual(checkTaskOrdering(tasks, tempDir), []);
+    });
+  });
+
+  test("skips prose, sentinels, and runtime-only entries", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({
+          id: "T01",
+          inputs: ["none", "Current enum shape", "server logs (runtime)"],
+        }),
+      ];
+
+      assert.deepEqual(checkPlanningArtifactReferences(tasks, tempDir), []);
+    });
+  });
+
+  test("runPreExecutionChecks surfaces artifact findings as blocking failures", async () => {
+    const tempDir = join(tmpdir(), `pre-exec-artifact-run-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+      const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+      const result: PreExecutionResult = await runPreExecutionChecks(tasks, tempDir);
+      assert.equal(result.status, "fail");
+      assert.ok(
+        result.checks.some((c) => !c.passed && c.blocking && c.message.includes("preloaded as context")),
+      );
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test("allows a bare artifact-style name that exists only at canonicalProjectRoot (not at worktree basePath)", () => {
+    withTempDir((canonicalRoot) => {
+      withTempDir((worktreeRoot) => {
+        writeFileSync(join(canonicalRoot, "M001-CONTEXT.md"), "# tracked source file");
+        const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+        assert.deepEqual(
+          checkPlanningArtifactReferences(tasks, worktreeRoot, { canonicalProjectRoot: canonicalRoot }),
+          [],
+        );
+      });
+    });
+  });
+
+  test("blocks .GSD/ paths with mixed casing (case-insensitive metadata dir match)", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({ id: "T01", inputs: [".GSD/milestones/M001/M001-CONTEXT.md"] }),
+      ];
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 1);
+      assert.equal(results[0].blocking, true);
+      assert.ok(results[0].message.includes("preloaded as context"));
+    });
+  });
+});

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

@@ -7,6 +7,9 @@
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import {
   openDatabase,
   closeDatabase,
@@ -22,6 +25,17 @@ import {
   formatDecisionsForPrompt,
   formatRequirementsForPrompt,
 } from '../context-store.ts';
+import { inlineRequirementsFromDb } from '../auto-prompts.ts';
+import { migrateFromMarkdown } from '../md-importer.ts';
+
+function createDbProjectWithRequirements(content: string): { tmpDir: string; gsdDir: string } {
+  const tmpDir = mkdtempSync(join(tmpdir(), 'prompt-db-requirements-'));
+  const gsdDir = join(tmpDir, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, 'REQUIREMENTS.md'), content);
+  openDatabase(join(gsdDir, 'gsd.db'));
+  return { tmpDir, gsdDir };
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: DB-aware decisions helper returns scoped content
@@ -182,6 +196,116 @@ console.log('\n=== prompt-db: fallback when DB unavailable ===');
   assert.deepStrictEqual(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: DB-aware requirements helper does not fall back on empty DB rows
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('prompt-db: inlineRequirementsFromDb returns null instead of full file when DB query is empty', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    `# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n\n${'large requirement body\n'.repeat(500)}`,
+  );
+  try {
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', undefined, 'full');
+
+    assert.equal(inlined, null);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('prompt-db: inlineRequirementsFromDb cascades from empty milestone query to active requirements', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    '# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n',
+  );
+  try {
+    insertRequirement({
+      id: 'R001',
+      class: 'functional',
+      status: 'active',
+      description: 'active requirement for another milestone',
+      why: 'needed',
+      source: 'M001',
+      primary_owner: 'M001/S01',
+      supporting_slices: '',
+      validation: 'test',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R002',
+      class: 'functional',
+      status: 'validated',
+      description: 'validated requirement should not be active fallback',
+      why: 'already done',
+      source: 'M001',
+      primary_owner: 'M001/S02',
+      supporting_slices: '',
+      validation: 'done',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', undefined, 'full');
+
+    assert.ok(inlined);
+    assert.match(inlined, /### Requirements/);
+    assert.match(inlined, /# Requirements \(compact\)/);
+    assert.match(inlined, /R001/);
+    assert.match(inlined, /active requirement for another milestone/);
+    assert.doesNotMatch(inlined, /R002/);
+    assert.doesNotMatch(inlined, /FULL FILE SHOULD NOT BE INLINED/);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('prompt-db: inlineRequirementsFromDb keeps active fallback compact for slice-scoped full calls', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    '# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n',
+  );
+  try {
+    insertRequirement({
+      id: 'R001',
+      class: 'functional',
+      status: 'active',
+      description: 'active requirement for another milestone',
+      why: 'needed',
+      source: 'M001',
+      primary_owner: 'M001/S01',
+      supporting_slices: '',
+      validation: 'test',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+
+    // Slice-scoped call at inlineLevel "full" with no matching rows for the
+    // milestone+slice or milestone-only queries. The cascade should land on
+    // status: "active" rows from another milestone, and those project-wide
+    // active rows must be formatted compactly even though sliceId is set —
+    // otherwise the full per-requirement markdown would be inlined for every
+    // active row across the project.
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', 'S99', 'full');
+
+    assert.ok(inlined);
+    assert.match(inlined, /### Requirements/);
+    assert.match(inlined, /# Requirements \(compact\)/);
+    assert.match(inlined, /R001/);
+    // Full per-requirement markdown is forbidden here — its hallmark fields
+    // (Class:/Status:/Why: as bolded list items) are emitted only by
+    // formatRequirementsForPrompt, never by formatRequirementsCompact.
+    assert.doesNotMatch(inlined, /\*\*Class:\*\*/);
+    assert.doesNotMatch(inlined, /FULL FILE SHOULD NOT BE INLINED/);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: scoped filtering reduces content vs unscoped
 // ═══════════════════════════════════════════════════════════════════════════
@@ -316,12 +440,6 @@ console.log('\n=== prompt-db: DB helpers wrapper format matches expected pattern
 // prompt-db: re-import updates DB when source markdown changes
 // ═══════════════════════════════════════════════════════════════════════════
 
-import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { migrateFromMarkdown } from '../md-importer.ts';
-
-
 describe('prompt-db', () => {
 test('prompt-db: re-import updates DB when source markdown changes', () => {
   // Create a temp dir simulating a project with .gsd/DECISIONS.md

package/src/resources/extensions/gsd/tests/provider-error-guidance.test.ts

@@ -3,10 +3,10 @@ import assert from "node:assert/strict";
 
 import { classifyError, isTransient } from "../error-classifier.ts";
 import {
-  formatProviderErrorGuidance,
   resolveProviderErrorGuidance,
   unitTypeToPrefsPhaseKey,
 } from "../provider-error-guidance.ts";
+import { formatGuidance } from "../guidance.ts";
 
 test("classifyError: Cloud Code Assist 400 invalid argument is model-error", () => {
   const result = classifyError(
@@ -75,8 +75,8 @@ test("resolveProviderErrorGuidance suggests gemini-3-flash for antigravity pro-h
   assert.ok(guidance.steps.some((step) => step.includes("fallbacks")));
 });
 
-test("formatProviderErrorGuidance numbers steps", () => {
-  const text = formatProviderErrorGuidance({
+test("formatGuidance numbers steps", () => {
+  const text = formatGuidance({
     summary: "Provider error on test/model.",
     steps: ["Change model", "Run /gsd next"],
   });