gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

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

@@ -0,0 +1,105 @@
+// GSD — Onboarding state record tests.
+// Verifies the explicit completion record (onboarding-state.ts) and step-evolution
+// behavior in setup-catalog.ts, including stale-resume fallback and version semantics.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Tests must isolate per-process to avoid clobbering the user's real ~/.gsd/agent/onboarding.json.
+// We point GSD_HOME at a fresh tmp dir before importing the modules under test.
+const tmpHome = mkdtempSync(join(tmpdir(), "gsd-onboarding-state-test-"));
+process.env.GSD_HOME = tmpHome;
+
+const state = await import("../onboarding-state.ts");
+const catalog = await import("../setup-catalog.ts");
+
+test.after(() => {
+  try { rmSync(tmpHome, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+test("default record returns when no file exists", () => {
+  const r = state.readOnboardingRecord();
+  assert.equal(r.completedAt, null);
+  assert.deepEqual(r.completedSteps, []);
+  assert.equal(r.flowVersion, state.FLOW_VERSION);
+});
+
+test("isOnboardingComplete is false until markOnboardingComplete is called", () => {
+  state.resetOnboarding();
+  assert.equal(state.isOnboardingComplete(), false);
+  state.markOnboardingComplete(["llm"]);
+  assert.equal(state.isOnboardingComplete(), true);
+});
+
+test("markStepCompleted updates lastResumePoint and dedupes", () => {
+  state.resetOnboarding();
+  state.markStepCompleted("llm");
+  state.markStepCompleted("search");
+  state.markStepCompleted("llm"); // dup
+  const r = state.readOnboardingRecord();
+  assert.deepEqual(r.completedSteps.filter(s => s === "llm"), ["llm"]);
+  assert.equal(r.lastResumePoint, "llm"); // last write wins, even on dup
+});
+
+test("markStepSkipped excludes already-completed steps", () => {
+  state.resetOnboarding();
+  state.markStepCompleted("llm");
+  state.markStepSkipped("llm");
+  const r = state.readOnboardingRecord();
+  assert.equal(r.skippedSteps.includes("llm"), false);
+});
+
+test("resetOnboarding clears completion but preserves flowVersion", () => {
+  state.markOnboardingComplete(["llm", "search"]);
+  state.resetOnboarding();
+  const r = state.readOnboardingRecord();
+  assert.equal(r.completedAt, null);
+  assert.deepEqual(r.completedSteps, []);
+  assert.equal(r.flowVersion, state.FLOW_VERSION);
+});
+
+test("flowVersion mismatch invalidates completion (forces re-onboarding)", () => {
+  state.markOnboardingComplete(["llm"]);
+  // Simulate a flow version bump after the user completed an older flow.
+  state.writeOnboardingRecord({ flowVersion: state.FLOW_VERSION - 1 });
+  assert.equal(state.isOnboardingComplete(), false);
+});
+
+test("nearestResumeStep returns first incomplete when resume point is stale", () => {
+  // Stale ID — not in catalog
+  const next = catalog.nearestResumeStep("nonexistent-step", []);
+  assert.equal(next, "llm"); // first step in ONBOARDING_STEPS
+});
+
+test("nearestResumeStep skips already-completed steps from the resume point", () => {
+  const completed = ["llm", "model"];
+  const next = catalog.nearestResumeStep("llm", completed);
+  // First step at-or-after llm that isn't in completed
+  assert.equal(next, "search");
+});
+
+test("nearestResumeStep wraps to start when everything from the point is complete", () => {
+  const allDone = catalog.ONBOARDING_STEPS.map(s => s.id);
+  const next = catalog.nearestResumeStep("llm", allDone.slice(0, allDone.length - 1));
+  // Only the last step is incomplete
+  assert.equal(next, allDone[allDone.length - 1]);
+});
+
+test("isValidStepId accepts catalog ids and rejects others", () => {
+  assert.equal(catalog.isValidStepId("llm"), true);
+  assert.equal(catalog.isValidStepId("tool-keys"), true);
+  assert.equal(catalog.isValidStepId("garbage"), false);
+});
+
+test("corrupt onboarding.json falls back to defaults instead of crashing", async () => {
+  const { writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const filePath = join(tmpHome, "agent", "onboarding.json");
+  writeFileSync(filePath, "{ this is not json", "utf-8");
+  const r = state.readOnboardingRecord();
+  assert.equal(r.completedAt, null);
+  assert.deepEqual(r.completedSteps, []);
+});

package/src/resources/extensions/gsd/tests/plan-milestone-boundary-map-preservation.test.ts

@@ -0,0 +1,114 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { openDatabase, closeDatabase } from '../gsd-db.ts';
+import { handlePlanMilestone } from '../tools/plan-milestone.ts';
+
+const boundaryMap = [
+  '| From | To | Produces | Consumes |',
+  '|------|----|----------|----------|',
+  '| S01 | S02 | roadmap | plan |',
+  '| S02 | S03 | plan | tasks |',
+  '',
+  '### S01 → S02',
+  '',
+  '- Produces: roadmap',
+  '- Consumes: plan',
+  '',
+  '### S02 → S03',
+  '',
+  '- Produces: plan',
+  '- Consumes: tasks',
+].join('\n');
+
+function planParams() {
+  return {
+    milestoneId: 'M001',
+    title: 'Preserve Boundary Map',
+    vision: 'Roadmap survives projection hook.',
+    successCriteria: ['Boundary Map section survives post-mutation hook'],
+    keyRisks: [
+      { risk: 'Projection clobber', whyItMatters: 'Authoritative roadmap would be overwritten.' },
+    ],
+    proofStrategy: [
+      { riskOrUnknown: 'Roadmap overwrite', retireIn: 'S01', whatWillBeProven: 'ROADMAP.md still contains ## Boundary Map after plan-milestone.' },
+    ],
+    verificationContract: 'Contract check',
+    verificationIntegration: 'Integration check',
+    verificationOperational: 'Operational check',
+    verificationUat: 'UAT check',
+    definitionOfDone: ['Regression test green'],
+    requirementCoverage: 'Covers #4402.',
+    boundaryMapMarkdown: boundaryMap,
+    slices: [
+      {
+        sliceId: 'S01',
+        title: 'First',
+        risk: 'low',
+        depends: [] as string[],
+        demo: 'demo 1',
+        goal: 'goal 1',
+        successCriteria: 'sc 1',
+        proofLevel: 'unit',
+        integrationClosure: 'ic 1',
+        observabilityImpact: 'oi 1',
+      },
+      {
+        sliceId: 'S02',
+        title: 'Second',
+        risk: 'low',
+        depends: ['S01'],
+        demo: 'demo 2',
+        goal: 'goal 2',
+        successCriteria: 'sc 2',
+        proofLevel: 'unit',
+        integrationClosure: 'ic 2',
+        observabilityImpact: 'oi 2',
+      },
+      {
+        sliceId: 'S03',
+        title: 'Third',
+        risk: 'low',
+        depends: ['S02'],
+        demo: 'demo 3',
+        goal: 'goal 3',
+        successCriteria: 'sc 3',
+        proofLevel: 'unit',
+        integrationClosure: 'ic 3',
+        observabilityImpact: 'oi 3',
+      },
+    ],
+  };
+}
+
+test('#4402 plan-milestone preserves ## Boundary Map after post-mutation projections', async (t) => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-4402-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const result = await handlePlanMilestone(planParams(), base);
+  assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+  const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+  assert.ok(existsSync(roadmapPath), 'ROADMAP.md must exist on disk');
+
+  const roadmap = readFileSync(roadmapPath, 'utf-8');
+
+  assert.match(
+    roadmap,
+    /^## Boundary Map$/m,
+    'final on-disk ROADMAP.md must still contain the Boundary Map heading after projection hook',
+  );
+  assert.match(roadmap, /\| S01 \| S02 \| roadmap \| plan \|/, 'boundary map row S01→S02 must survive');
+  assert.match(roadmap, /\| S02 \| S03 \| plan \| tasks \|/, 'boundary map row S02→S03 must survive');
+  assert.match(roadmap, /^### S01 → S02$/m, 'boundary map edge subsection S01→S02 must survive');
+  assert.match(roadmap, /^### S02 → S03$/m, 'boundary map edge subsection S02→S03 must survive');
+});

package/src/resources/extensions/gsd/tests/plan-milestone.test.ts

@@ -92,11 +92,10 @@ test('handlePlanMilestone writes milestone and slice planning state and renders
     assert.ok(existsSync(roadmapPath), 'roadmap should be rendered to disk');
     const roadmap = readFileSync(roadmapPath, 'utf-8');
     assert.match(roadmap, /# M001: DB-backed planning/);
-    assert.match(roadmap, /## Vision/);
-    assert.match(roadmap, /Make planning write through the database\./);
-    assert.match(roadmap, /## Slice Overview/);
-    assert.match(roadmap, /\| S01 \| Tool wiring \| medium \|/);
-    assert.match(roadmap, /\| S02 \| Prompt migration \| low \| S01 \|/);
+    assert.match(roadmap, /\*\*Vision:\*\* Make planning write through the database\./);
+    assert.match(roadmap, /^## Slices$/m);
+    assert.match(roadmap, /- \[ \] \*\*S01: Tool wiring\*\* `risk:medium` `depends:\[\]`/);
+    assert.match(roadmap, /- \[ \] \*\*S02: Prompt migration\*\* `risk:low` `depends:\[S01\]`/);
   } finally {
     cleanup(base);
   }

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

@@ -148,6 +148,23 @@ test('handlePlanSlice surfaces render failures without changing parse-visible ta
   }
 });
 
+test('handlePlanSlice reactivates a deferred parent slice to pending', async (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'deferred', demo: 'Rendered plans exist.' });
+
+  const result = await handlePlanSlice(validParams(), base);
+  assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+  const slice = getSlice('M001', 'S02');
+  assert.ok(slice);
+  assert.equal(slice?.status, 'pending', 'deferred slice must be reactivated to pending so auto-mode can dispatch it');
+  assert.equal(slice?.goal, 'Persist slice planning through the DB.');
+});
+
 test('handlePlanSlice reruns idempotently and refreshes parse-visible state', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -14,7 +14,7 @@ import { join } from "node:path";
 
 import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
 import { AutoSession } from "../auto/session.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, _getAdapter } from "../gsd-db.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 
@@ -140,6 +140,43 @@ function createBasicTask(): void {
   });
 }
 
+function createPostExecFailureTask(): void {
+  insertMilestone({ id: "M001" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    risk: "low",
+  });
+
+  const srcDir = join(tempDir, "src");
+  mkdirSync(srcDir, { recursive: true });
+  writeFileSync(
+    join(srcDir, "broken.ts"),
+    "import { missing } from './does-not-exist.js';\nexport const ok = 1;\n",
+    "utf-8",
+  );
+
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task with broken import",
+    status: "pending",
+    keyFiles: ["src/broken.ts"],
+    planning: {
+      description: "Task that introduces an unresolved import in key files",
+      estimate: "1h",
+      files: ["src/broken.ts"],
+      verify: "echo pass",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 0,
+  });
+}
+
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("Post-execution blocking failure retry bypass", () => {
@@ -249,6 +286,47 @@ describe("Post-execution blocking failure retry bypass", () => {
     // This test mainly confirms the wiring is correct
     assert.equal(result, "continue");
   });
+
+  test("uok gate runner persists post-execution gate failures when enabled", async () => {
+    createPostExecFailureTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 2,
+      uok: {
+        enabled: true,
+        gates: { enabled: true },
+      },
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+    const vctx: VerificationContext = { s, ctx, pi };
+
+    const result = await runPostUnitVerification(vctx, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+
+    const adapter = _getAdapter();
+    const row = adapter
+      ?.prepare(
+        `SELECT gate_id, outcome, failure_class
+         FROM gate_runs
+         WHERE gate_id = 'post-execution-checks'
+         ORDER BY id DESC
+         LIMIT 1`,
+      )
+      .get() as { gate_id: string; outcome: string; failure_class: string } | undefined;
+
+    assert.ok(row, "post-execution gate run should be persisted when uok.gates is enabled");
+    assert.equal(row?.gate_id, "post-execution-checks");
+    assert.equal(row?.outcome, "fail");
+    assert.equal(row?.failure_class, "artifact");
+  });
 });
 
 describe("Post-execution retry behavior", () => {

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

@@ -10,7 +10,7 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 import { tmpdir } from "node:os";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
 import {
@@ -56,6 +56,11 @@ function createTask(overrides: Partial<TaskRow> = {}): TaskRow {
     observability_impact: "",
     full_plan_md: "",
     sequence: overrides.sequence ?? 0,
+    blocker_source: "",
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
     ...overrides,
   };
 }
@@ -224,6 +229,81 @@ describe("resolveImportPath", () => {
       rmSync(tempDir, { recursive: true, force: true });
     }
   });
+
+  // Regression: issue #4411 — side-effect asset imports (CSS/SCSS/images/fonts)
+  // were misclassified as unresolved because only code extensions were tried.
+  test("resolves side-effect CSS import with explicit extension", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "post-exec-test-css-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    // frontend/src/routes/root.tsx imports '../../styles/globals.css' →
+    // resolves to frontend/styles/globals.css.
+    mkdirSync(join(dir, "frontend", "src", "routes"), { recursive: true });
+    mkdirSync(join(dir, "frontend", "styles"), { recursive: true });
+    writeFileSync(join(dir, "frontend", "styles", "globals.css"), "");
+    writeFileSync(
+      join(dir, "frontend", "src", "routes", "root.tsx"),
+      "import '../../styles/globals.css';"
+    );
+
+    const result = resolveImportPath(
+      "../../styles/globals.css",
+      "frontend/src/routes/root.tsx",
+      dir
+    );
+    assert.ok(result.exists, "CSS side-effect import should resolve");
+    assert.ok(result.resolvedPath?.endsWith("globals.css"));
+  });
+
+  test("resolves SCSS asset import", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "post-exec-test-scss-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "theme.scss"), "");
+    writeFileSync(join(dir, "src", "main.ts"), "");
+
+    const result = resolveImportPath("./theme.scss", "src/main.ts", dir);
+    assert.ok(result.exists);
+  });
+
+  test("still fails for missing asset import", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "post-exec-test-missing-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "main.ts"), "");
+
+    const result = resolveImportPath("./missing.css", "src/main.ts", dir);
+    assert.ok(!result.exists);
+    assert.equal(result.resolvedPath, null);
+  });
+
+  // Pin TS ESM convention: explicit .js import must still resolve to the
+  // sibling .ts file when only the .ts exists.
+  test("resolves .js import to sibling .ts (TS ESM convention)", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "post-exec-test-tsesm-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "types.ts"), "export {};");
+    writeFileSync(join(dir, "src", "main.ts"), "");
+
+    const result = resolveImportPath("./types.js", "src/main.ts", dir);
+    assert.ok(result.exists);
+    assert.ok(result.resolvedPath?.endsWith("types.ts"));
+  });
+
+  // Non-code explicit extensions must not fall through to code-extension
+  // shadows: a missing ./missing.css must stay unresolved even if a stray
+  // ./missing.css.ts happens to exist.
+  test("missing asset import does not match code-extension shadow", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "post-exec-test-shadow-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "missing.css.ts"), "export {};");
+    writeFileSync(join(dir, "src", "main.ts"), "");
+
+    const result = resolveImportPath("./missing.css", "src/main.ts", dir);
+    assert.ok(!result.exists);
+    assert.equal(result.resolvedPath, null);
+  });
 });
 
 // ─── Import Resolution Check Tests ───────────────────────────────────────────
@@ -344,6 +424,30 @@ describe("checkImportResolution", () => {
       rmSync(tempDir, { recursive: true, force: true });
     }
   });
+
+  // Regression: issue #4411 — CSS side-effect import inside a .tsx key_file
+  // must not produce a blocking post-execution failure.
+  test("does not block on valid CSS side-effect import in .tsx key_file", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "post-exec-test-asset-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    // frontend/src/routes/root.tsx imports '../../styles/globals.css' →
+    // resolves to frontend/styles/globals.css.
+    mkdirSync(join(dir, "frontend", "src", "routes"), { recursive: true });
+    mkdirSync(join(dir, "frontend", "styles"), { recursive: true });
+    writeFileSync(join(dir, "frontend", "styles", "globals.css"), "");
+    writeFileSync(
+      join(dir, "frontend", "src", "routes", "root.tsx"),
+      "import '../../styles/globals.css';\nexport default function Root() { return null; }"
+    );
+
+    const task = createTask({
+      id: "T03",
+      key_files: ["frontend/src/routes/root.tsx"],
+    });
+
+    const results = checkImportResolution(task, [], dir);
+    assert.deepEqual(results, [], "valid CSS import must not be flagged");
+  });
 });
 
 // ─── Cross-Task Signature Tests ──────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -21,7 +21,8 @@ test("postUnitPreVerification rebuilds STATE.md before worktree sync", () => {
   const fnStart = source.indexOf("export async function postUnitPreVerification");
   assert.ok(fnStart > 0, "postUnitPreVerification should exist");
 
-  const section = source.slice(fnStart, fnStart + 8000);
+  const fnEnd = source.indexOf("export async function postUnitPostVerification", fnStart);
+  const section = source.slice(fnStart, fnEnd > fnStart ? fnEnd : undefined);
   const rebuildIdx = section.indexOf('await runSafely("postUnit", "state-rebuild"');
   const syncIdx = section.indexOf('await runSafely("postUnit", "worktree-sync"');