gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

package/src/resources/extensions/gsd/tests/model-unittype-mapping.test.ts

@@ -215,6 +215,65 @@ test("unitVerb handles discuss-slice", () => {
 // auto-artifact-paths.ts: artifact resolution
 // ═══════════════════════════════════════════════════════════════════════════
 
+// ═══════════════════════════════════════════════════════════════════════════
+// ADR-011: meta-test — every KNOWN_UNIT_TYPES entry must appear in all four
+// downstream registries so a future unit type added to KNOWN_UNIT_TYPES can't
+// silently fall through to wrong defaults in metrics/dashboard/artifacts/post-unit.
+// ═══════════════════════════════════════════════════════════════════════════
+
+// Intentional exceptions — unit types that legitimately rely on default/null
+// behavior in a specific registry. Entries captured here reflect the current
+// baseline at the time ADR-011 landed; adding to this allowlist for a NEW unit
+// type requires explicit justification in the commit.
+//
+// Test intent: catch the case where someone adds a new unit type to
+// KNOWN_UNIT_TYPES but forgets to wire it into one of the four registries.
+// The allowlist freezes the baseline so pre-existing omissions do not block
+// the test, but any brand-new addition must be either handled or justified.
+const REGISTRY_EXCEPTIONS: Record<string, Set<string>> = {
+  // metrics.ts classifyUnitPhase uses default → "execution" for most unit types.
+  "metrics.ts": new Set([
+    "worktree-merge", "custom-step",
+    "rewrite-docs", "run-uat", "gate-evaluate", "replan-slice",
+    "reactive-execute", "validate-milestone", "complete-milestone",
+  ]),
+  "auto-dashboard.ts": new Set([
+    "worktree-merge",
+    "gate-evaluate", "reactive-execute", "validate-milestone", "complete-milestone",
+  ]),
+  "auto-artifact-paths.ts": new Set([
+    "rewrite-docs", "gate-evaluate", "reactive-execute", "discuss-slice", "worktree-merge",
+  ]),
+  "auto-post-unit.ts": new Set([
+    "execute-task", "reactive-execute", "gate-evaluate", "worktree-merge",
+  ]),
+};
+
+const REGISTRY_SOURCES: Array<[string, string]> = [
+  ["metrics.ts", metricsSrc],
+  ["auto-dashboard.ts", dashboardSrc],
+  ["auto-artifact-paths.ts", artifactSrc],
+  ["auto-post-unit.ts", postUnitSrc],
+];
+
+test("ADR-011 meta: every KNOWN_UNIT_TYPES entry appears in all 4 downstream registries", () => {
+  const missing: Array<{ registry: string; unitType: string }> = [];
+  for (const [registry, src] of REGISTRY_SOURCES) {
+    for (const ut of ALL_KNOWN_UNIT_TYPES) {
+      if (REGISTRY_EXCEPTIONS[registry]?.has(ut)) continue;
+      if (!src.includes(`"${ut}"`)) {
+        missing.push({ registry, unitType: ut });
+      }
+    }
+  }
+  assert.deepEqual(
+    missing,
+    [],
+    "Each listed unit type is absent from the given registry — either add a handler or add to REGISTRY_EXCEPTIONS with justification:\n" +
+      missing.map((m) => `  ${m.registry}: "${m.unitType}"`).join("\n"),
+  );
+});
+
 test("resolveExpectedArtifactPath handles discuss-slice", () => {
   assert.ok(artifactSrc.includes('"discuss-slice"'), "missing discuss-slice in artifact paths");
 });

package/src/resources/extensions/gsd/tests/native-git-bridge-exec-fallback.test.ts

@@ -0,0 +1,140 @@
+// native-git-bridge-exec-fallback.test.ts — regression for #4180
+//
+// nativeCommit, nativeIsRepo, and nativeResetHard used execSync() (string
+// command) in their fallback paths. On Windows, execSync spawns cmd.exe which
+// cannot resolve git when Git for Windows is installed via MSYS2/bash but not
+// in cmd.exe's PATH. All other fallback paths in this file use execFileSync()
+// which invokes the binary directly — these three must do the same.
+//
+// Static-analysis tests fail before the fix (source still has execSync calls)
+// and pass after (replaced with execFileSync). Integration tests verify the
+// fallback functions behave correctly on all platforms.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+import { nativeIsRepo, nativeCommit, nativeResetHard } from "../native-git-bridge.js";
+
+// ─── Static analysis ──────────────────────────────────────────────────────
+// Verify the fallback paths of the three affected functions do not call the
+// raw execSync() string-command variant. Replacing all execFileSync( tokens
+// first ensures we match only the bare execSync( form.
+
+const SRC_PATH = join(import.meta.dirname, "..", "native-git-bridge.ts");
+
+function extractFunctionBody(src: string, fnName: string): string {
+  const idx = src.indexOf(`export function ${fnName}`);
+  if (idx === -1) throw new Error(`${fnName} not found in source`);
+  return src.slice(idx, idx + 1500);
+}
+
+function hasRawExecSync(body: string): boolean {
+  const withoutFileSync = body.replace(/execFileSync\(/g, "__FILESYNC__");
+  return withoutFileSync.includes("execSync(");
+}
+
+describe("native-git-bridge #4180: fallback paths use execFileSync not execSync", () => {
+  const src = readFileSync(SRC_PATH, "utf-8");
+
+  test("nativeIsRepo fallback does not use raw execSync", () => {
+    const body = extractFunctionBody(src, "nativeIsRepo");
+    assert.equal(
+      hasRawExecSync(body),
+      false,
+      "nativeIsRepo fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
+    );
+  });
+
+  test("nativeCommit fallback does not use raw execSync", () => {
+    const body = extractFunctionBody(src, "nativeCommit");
+    assert.equal(
+      hasRawExecSync(body),
+      false,
+      "nativeCommit fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
+    );
+  });
+
+  test("nativeResetHard fallback does not use raw execSync", () => {
+    const body = extractFunctionBody(src, "nativeResetHard");
+    assert.equal(
+      hasRawExecSync(body),
+      false,
+      "nativeResetHard fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
+    );
+  });
+});
+
+// ─── Integration tests ────────────────────────────────────────────────────
+// Verify correct runtime behaviour through the fallback path (native module
+// is disabled by default in tests — GSD_ENABLE_NATIVE_GSD_GIT is not set).
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+describe("native-git-bridge #4180: fallback runtime behaviour", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "ngb4180-"));
+    git(["init"], repo);
+    git(["config", "user.email", "test@test.com"], repo);
+    git(["config", "user.name", "Test"], repo);
+    writeFileSync(join(repo, "file.txt"), "initial\n");
+    git(["add", "."], repo);
+    git(["commit", "-m", "init"], repo);
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("nativeIsRepo returns true for a valid git repository", () => {
+    assert.equal(nativeIsRepo(repo), true);
+  });
+
+  test("nativeIsRepo returns false for a plain directory", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "ngb4180-notrepo-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    assert.equal(nativeIsRepo(dir), false);
+  });
+
+  test("nativeCommit commits staged changes and returns non-null output", () => {
+    writeFileSync(join(repo, "file.txt"), "modified\n");
+    git(["add", "."], repo);
+
+    const result = nativeCommit(repo, "test: regression commit #4180");
+    assert.ok(result !== null, "should return output string for a successful commit");
+
+    const subject = git(["log", "-1", "--format=%s"], repo);
+    assert.equal(subject, "test: regression commit #4180");
+  });
+
+  test("nativeCommit returns null when nothing is staged", () => {
+    const result = nativeCommit(repo, "test: nothing staged");
+    assert.equal(result, null);
+  });
+
+  test("nativeCommit respects the allowEmpty option", () => {
+    const result = nativeCommit(repo, "test: empty commit #4180", { allowEmpty: true });
+    assert.ok(result !== null, "allow-empty commit should return output");
+
+    const subject = git(["log", "-1", "--format=%s"], repo);
+    assert.equal(subject, "test: empty commit #4180");
+  });
+
+  test("nativeResetHard discards unstaged working tree changes", () => {
+    writeFileSync(join(repo, "file.txt"), "dirty content\n");
+
+    const statusBefore = git(["status", "--short"], repo);
+    assert.ok(statusBefore.length > 0, "repo should be dirty before reset");
+
+    nativeResetHard(repo);
+
+    const content = readFileSync(join(repo, "file.txt"), "utf-8");
+    assert.equal(content, "initial\n", "file should be restored to HEAD content after hard reset");
+  });
+});

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -17,7 +17,7 @@ test("buildNotificationWidgetLines shows unread count with shortcut pair", () =>
 
     const lines = buildNotificationWidgetLines();
     assert.equal(lines.length, 1);
-    assert.match(lines[0]!, /Notifications:\s+1 unread/);
+    assert.match(lines[0]!, /🔔\s+1 unread/);
     assert.match(lines[0]!, /\(.+\/.+\)/);
   } finally {
     _resetNotificationStore();

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"');