@opengsd/gsd-pi 1.5.0 → 1.6.0

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

@@ -0,0 +1,211 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for run-uat dispatch discovery boundaries.
+
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { checkNeedsRunUat as checkNeedsRunUatFromPrompts } from "../auto-prompts.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  isDbAvailable,
+  openDatabase,
+} from "../gsd-db.ts";
+import { checkNeedsRunUat } from "../uat-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-uat-dispatch-test-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeRoadmap(base: string, milestoneId: string): void {
+  const dir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, `${milestoneId}-ROADMAP.md`),
+    [
+      `# ${milestoneId}: UAT dispatch`,
+      "",
+      "## Slices",
+      "",
+      "- [x] **S01: First slice** `risk:low` `depends:[]`",
+      "- [ ] **S02: Next slice** `risk:low` `depends:[S01]`",
+      "",
+      "## Boundary Map",
+      "",
+    ].join("\n"),
+  );
+}
+
+function writeSliceFile(
+  base: string,
+  milestoneId: string,
+  sliceId: string,
+  suffix: string,
+  content: string,
+): void {
+  const dir = join(base, ".gsd", "milestones", milestoneId, "slices", sliceId);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sliceId}-${suffix}.md`), content);
+}
+
+test("checkNeedsRunUat resolves runtime harness dispatch from UAT plus summary context", async (t) => {
+  const base = createFixtureBase();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  writeRoadmap(base, "M001");
+  writeSliceFile(
+    base,
+    "M001",
+    "S01",
+    "UAT",
+    [
+      "# S01 UAT",
+      "",
+      "## UAT Type",
+      "- UAT mode: browser-executable",
+      "",
+      "## Preconditions",
+      "- Start the dev server with `npm run test:server`.",
+    ].join("\n"),
+  );
+  writeSliceFile(
+    base,
+    "M001",
+    "S01",
+    "SUMMARY",
+    [
+      "# S01 Summary",
+      "",
+      "Verification: `npm run test:uat` passed and exercises the browser harness end-to-end.",
+    ].join("\n"),
+  );
+
+  assert.deepEqual(await checkNeedsRunUat(base, "M001", { uat_dispatch: true }, [{ sliceId: "S01" }]), {
+    sliceId: "S01",
+    uatType: "runtime-executable",
+  });
+});
+
+test("checkNeedsRunUat skips slices that already have an ASSESSMENT verdict", async (t) => {
+  const base = createFixtureBase();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  writeRoadmap(base, "M001");
+  writeSliceFile(
+    base,
+    "M001",
+    "S01",
+    "UAT",
+    [
+      "# S01 UAT",
+      "",
+      "## UAT Type",
+      "- UAT mode: artifact-driven",
+    ].join("\n"),
+  );
+  writeSliceFile(base, "M001", "S01", "ASSESSMENT", "---\nverdict: PASS\n---\n# UAT Assessment\n");
+
+  assert.equal(await checkNeedsRunUat(base, "M001", { uat_dispatch: true }, [{ sliceId: "S01" }]), null);
+});
+
+test("auto-prompts keeps the compatibility checkNeedsRunUat wrapper", async (t) => {
+  const base = createFixtureBase();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  writeRoadmap(base, "M001");
+  writeSliceFile(
+    base,
+    "M001",
+    "S01",
+    "UAT",
+    [
+      "# S01 UAT",
+      "",
+      "## UAT Type",
+      "- UAT mode: human-experience",
+    ].join("\n"),
+  );
+
+  const legacyState: GSDState = {
+    activeMilestone: { id: "M001", title: "UAT dispatch" },
+    activeSlice: { id: "S02", title: "Next slice" },
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Plan S02",
+    registry: [],
+  };
+
+  assert.deepEqual(
+    await checkNeedsRunUatFromPrompts(base, "M001", legacyState, { uat_dispatch: true }),
+    { sliceId: "S01", uatType: "human-experience" },
+  );
+});
+
+test("checkNeedsRunUat treats the DB as authoritative and ignores roadmap fallback when DB slices exist but none are complete", async (t) => {
+  const base = createFixtureBase();
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  // DB knows this milestone's slices, but none are complete.
+  openDatabase(":memory:");
+  assert.ok(isDbAvailable());
+  insertMilestone({ id: "M001", title: "UAT dispatch", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "active", risk: "low", depends: [] });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Next slice", status: "pending", risk: "low", depends: [] });
+
+  // The roadmap shows S01 completed and a dispatchable UAT file exists, so the
+  // roadmap fallback *would* dispatch S01 if it were (incorrectly) consulted.
+  writeRoadmap(base, "M001");
+  writeSliceFile(
+    base,
+    "M001",
+    "S01",
+    "UAT",
+    ["# S01 UAT", "", "## UAT Type", "- UAT mode: human-experience"].join("\n"),
+  );
+
+  // DB is authoritative: no completed slices means no dispatch, and the roadmap
+  // fallback candidate must NOT be consulted (regression for #1268).
+  assert.equal(
+    await checkNeedsRunUat(base, "M001", { uat_dispatch: true }, [{ sliceId: "S01" }]),
+    null,
+  );
+});
+
+test("checkNeedsRunUat uses roadmap fallback candidates when the DB has no slice rows for the milestone", async (t) => {
+  const base = createFixtureBase();
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  // DB is available but has no rows for M001, so it has no authoritative view.
+  openDatabase(":memory:");
+  assert.ok(isDbAvailable());
+
+  writeRoadmap(base, "M001");
+  writeSliceFile(
+    base,
+    "M001",
+    "S01",
+    "UAT",
+    ["# S01 UAT", "", "## UAT Type", "- UAT mode: human-experience"].join("\n"),
+  );
+
+  // With no DB slice rows, the roadmap-derived fallback candidate is honored.
+  assert.deepEqual(
+    await checkNeedsRunUat(base, "M001", { uat_dispatch: true }, [{ sliceId: "S01" }]),
+    { sliceId: "S01", uatType: "human-experience" },
+  );
+});

package/src/resources/extensions/gsd/tests/uat-stuck-loop-orphaned-worktree.test.ts

@@ -30,7 +30,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { syncProjectRootToWorktree } from "../auto-worktree.ts";
+import { syncProjectRootToWorktree } from "../auto-worktree-sync.ts";
 import {
   createWorktree,
   removeWorktree,

package/src/resources/extensions/gsd/tests/unit-registry.test.ts

@@ -18,6 +18,7 @@ import {
   getUnitDescriptor,
   getUnitPhaseChain,
   getUnitPromptTemplate,
+  getUnitPromptTemplates,
 } from "../unit-registry.ts";
 import {
   AUTO_UNIT_SCOPED_TOOLS,
@@ -123,13 +124,16 @@ const EXPECTED_DIRECT_PROMPT_TEMPLATES: Record<string, string> = {
 };
 
 const EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES = [
-  "discuss-milestone",
   "discuss-slice",
   "execute-task-simple",
   "triage-captures",
   "quick-task",
 ];
 
+const EXPECTED_CONDITIONAL_PROMPT_TEMPLATES: Record<string, string[]> = {
+  "discuss-milestone": ["discuss", "discuss-headless", "guided-discuss-milestone"],
+};
+
 // ─── Derived-view parity ──────────────────────────────────────────────────
 
 test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
@@ -190,6 +194,27 @@ test("direct prompt-template associations live on the Unit Registry", () => {
   }
 });
 
+test("conditional prompt-template associations live on the Unit Registry without pretending to be direct", () => {
+  for (const [unitType, promptTemplates] of Object.entries(EXPECTED_CONDITIONAL_PROMPT_TEMPLATES)) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      undefined,
+      `${unitType} must not expose a single direct prompt template`,
+    );
+    assert.deepEqual(
+      getUnitPromptTemplates(unitType),
+      promptTemplates,
+      `prompt templates for ${unitType}`,
+    );
+    for (const promptTemplate of promptTemplates) {
+      assert.ok(
+        existsSync(join(process.cwd(), "src/resources/extensions/gsd/prompts", `${promptTemplate}.md`)),
+        `prompt template file must exist for ${unitType}: ${promptTemplate}`,
+      );
+    }
+  }
+});
+
 test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
   for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
     assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);

package/src/resources/extensions/gsd/tests/uok-gate-runner.test.ts

@@ -3,14 +3,20 @@ import assert from "node:assert/strict";
 
 import { closeDatabase, openDatabase, _getAdapter } from "../gsd-db.ts";
 import { UokGateRunner } from "../uok/gate-runner.ts";
+import {
+  clearUnifiedAuditOverrideForTests,
+  setUnifiedAuditEnabled,
+} from "../uok/audit-toggle.ts";
 
 test.beforeEach(() => {
+  setUnifiedAuditEnabled(true);
   closeDatabase();
   const ok = openDatabase(":memory:");
   assert.equal(ok, true);
 });
 
 test.afterEach(() => {
+  clearUnifiedAuditOverrideForTests();
   closeDatabase();
 });
 
@@ -69,6 +75,39 @@ test("uok gate runner returns manual-attention for unknown gate id", async () =>
   assert.equal(result.failureClass, "unknown");
 });
 
+test("uok gate runner emits audit by default for standalone callers", async () => {
+  clearUnifiedAuditOverrideForTests();
+  const runner = new UokGateRunner();
+  await runner.run("standalone-missing-gate", {
+    basePath: process.cwd(),
+    traceId: "trace-standalone",
+    turnId: "turn-standalone",
+  });
+
+  const adapter = _getAdapter();
+  const rows = adapter?.prepare(
+    "SELECT type FROM audit_events WHERE trace_id = 'trace-standalone'",
+  ).all() ?? [];
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0]?.["type"], "gate-run");
+});
+
+test("uok gate runner skips audit when unified audit is explicitly disabled", async () => {
+  setUnifiedAuditEnabled(false);
+  const runner = new UokGateRunner();
+  await runner.run("disabled-audit-missing-gate", {
+    basePath: process.cwd(),
+    traceId: "trace-disabled-audit",
+    turnId: "turn-disabled-audit",
+  });
+
+  const adapter = _getAdapter();
+  const rows = adapter?.prepare(
+    "SELECT type FROM audit_events WHERE trace_id = 'trace-disabled-audit'",
+  ).all() ?? [];
+  assert.equal(rows.length, 0);
+});
+
 // Regression tests for #4950
 
 test("uok gate runner: gate.execute throws — outcome is fail, audit emitted, DB row written, no exception escapes", async () => {

package/src/resources/extensions/gsd/tests/uok-kernel-path.test.ts

@@ -2,7 +2,7 @@
 // File Purpose: Verifies UOK kernel path selection and legacy fallback telemetry.
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -14,6 +14,16 @@ import type { LoopDeps } from "../auto/loop-deps.ts";
 import { gsdRoot } from "../paths.ts";
 import type { GSDPreferences } from "../preferences.ts";
 import { getLegacyTelemetry, resetLegacyTelemetry } from "../legacy-telemetry.ts";
+import { _getAdapter, closeDatabase, openDatabase } from "../gsd-db.ts";
+import { UokGateRunner } from "../uok/gate-runner.ts";
+import { applyModelPolicyFilter } from "../uok/model-policy.ts";
+import {
+  clearUnifiedAuditOverrideForTests,
+  isUnifiedAuditEnabled,
+  setUnifiedAuditEnabled,
+} from "../uok/audit-toggle.ts";
+import { writeEscalationArtifact } from "../escalation.ts";
+import { peekLogs, _resetLogs } from "../workflow-logger.ts";
 
 function makeBasePath(): string {
   return mkdtempSync(join(tmpdir(), "gsd-uok-kernel-"));
@@ -104,7 +114,8 @@ test("runAutoLoopWithUok uses kernel path by default and records uok-kernel pari
     assert.ok(args.calls.kernelDeps);
     assert.notEqual(args.calls.kernelDeps, args.deps);
     assert.ok(args.calls.kernelDeps?.uokObserver);
-    assert.equal(process.env.GSD_UOK_AUDIT_UNIFIED, "0");
+    assert.equal(isUnifiedAuditEnabled(), true);
+    assert.equal(isUnifiedAuditEnabled(basePath), false);
 
     const events = readParityEvents(basePath);
     assert.equal(events.length, 2);
@@ -120,6 +131,37 @@ test("runAutoLoopWithUok uses kernel path by default and records uok-kernel pari
   }
 });
 
+test("runAutoLoopWithUok keeps audit disabled for legacy-wrapper while restoring process override", async () => {
+  const basePath = makeBasePath();
+  clearUnifiedAuditOverrideForTests();
+  try {
+    resetLegacyTelemetry();
+    const args = makeArgs(basePath, {
+      uok: {
+        enabled: false,
+        audit_unified: { enabled: false },
+      },
+    });
+    await runAutoLoopWithUok(args);
+
+    assert.equal(args.calls.kernel, 0);
+    assert.equal(args.calls.legacy, 1);
+    assert.equal(isUnifiedAuditEnabled(), true);
+    assert.equal(isUnifiedAuditEnabled(basePath), false);
+
+    const events = readParityEvents(basePath);
+    assert.equal(events.length, 2);
+    assert.equal(events[0]?.path, "legacy-wrapper");
+    assert.equal(events[1]?.path, "legacy-wrapper");
+    assert.equal(events[1]?.status, "ok");
+    assert.equal(getLegacyTelemetry()["legacy.uokFallbackUsed"], 1);
+  } finally {
+    clearUnifiedAuditOverrideForTests();
+    resetLegacyTelemetry();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
 test("runAutoLoopWithUok uses legacy path when explicit legacy fallback is enabled", async () => {
   const basePath = makeBasePath();
   try {
@@ -176,3 +218,185 @@ test("runAutoLoopWithUok respects GSD_UOK_FORCE_LEGACY emergency switch", async
     rmSync(basePath, { recursive: true, force: true });
   }
 });
+
+test("runAutoLoopWithUok records error exit and restores previous audit override when kernel fails", async () => {
+  const basePath = makeBasePath();
+  clearUnifiedAuditOverrideForTests();
+  setUnifiedAuditEnabled(false);
+  try {
+    resetLegacyTelemetry();
+    const args = makeArgs(basePath, {
+      uok: {
+        enabled: true,
+        audit_unified: { enabled: true },
+        gitops: { enabled: false },
+      },
+    });
+    args.runKernelLoop = async (_ctx, _pi, _s, loopDeps): Promise<void> => {
+      args.calls.kernel += 1;
+      args.calls.kernelDeps = loopDeps;
+      throw new Error("kernel exploded");
+    };
+
+    await assert.rejects(
+      () => runAutoLoopWithUok(args),
+      /kernel exploded/,
+    );
+
+    assert.equal(args.calls.kernel, 1);
+    assert.equal(args.calls.legacy, 0);
+    assert.equal(isUnifiedAuditEnabled(), false);
+
+    const events = readParityEvents(basePath);
+    assert.equal(events.length, 2);
+    assert.equal(events[0]?.phase, "enter");
+    assert.equal(events[1]?.phase, "exit");
+    assert.equal(events[1]?.status, "error");
+    assert.match(String(events[1]?.error), /kernel exploded/);
+  } finally {
+    clearUnifiedAuditOverrideForTests();
+    resetLegacyTelemetry();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("runAutoLoopWithUok treats kernel-enter audit failures as telemetry-only", async (t) => {
+  const basePath = makeBasePath();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  clearUnifiedAuditOverrideForTests();
+  _resetLogs();
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+  assert.equal(openDatabase(dbPath), true, "DB must open for this scenario");
+  t.after(() => {
+    clearUnifiedAuditOverrideForTests();
+    closeDatabase();
+    _resetLogs();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  _getAdapter()!.exec("DROP TABLE audit_events");
+
+  const args = makeArgs(basePath, {
+    uok: {
+      enabled: true,
+      audit_unified: { enabled: true },
+      gitops: { enabled: false },
+    },
+  });
+  args.runKernelLoop = async (_ctx, _pi, _s, loopDeps): Promise<void> => {
+    args.calls.kernel += 1;
+    args.calls.kernelDeps = loopDeps;
+    const observer = loopDeps.uokObserver;
+    assert.ok(observer, "kernel path must still install a turn observer");
+    observer.onTurnStart({
+      basePath,
+      traceId: "trace-audit-down",
+      turnId: "turn-audit-down",
+      iteration: 1,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      startedAt: new Date().toISOString(),
+    });
+    observer.onTurnResult({
+      traceId: "trace-audit-down",
+      turnId: "turn-audit-down",
+      iteration: 1,
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      status: "completed",
+      failureClass: "none",
+      phaseResults: [],
+      startedAt: new Date().toISOString(),
+      finishedAt: new Date().toISOString(),
+    });
+
+    const gateRunner = new UokGateRunner();
+    gateRunner.register({
+      id: "test-gate",
+      type: "policy",
+      execute: async () => ({
+        outcome: "pass",
+        failureClass: "none",
+        rationale: "ok",
+      }),
+    });
+    await gateRunner.run("test-gate", {
+      basePath,
+      traceId: "trace-audit-down",
+      turnId: "turn-audit-down",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+
+    const filtered = applyModelPolicyFilter(
+      [{ id: "model-a", provider: "openai", api: "responses" }],
+      {
+        basePath,
+        traceId: "trace-audit-down",
+        turnId: "turn-audit-down",
+        unitType: "execute-task",
+      },
+    );
+    assert.equal(filtered.eligible.length, 1);
+
+    mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), {
+      recursive: true,
+    });
+    writeEscalationArtifact(basePath, {
+      version: 1,
+      taskId: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      question: "Choose a path",
+      options: [
+        { id: "a", label: "A", tradeoffs: "First path" },
+        { id: "b", label: "B", tradeoffs: "Second path" },
+      ],
+      recommendation: "a",
+      recommendationRationale: "Test recommendation",
+      continueWithDefault: false,
+      createdAt: new Date().toISOString(),
+    });
+  };
+
+  await runAutoLoopWithUok(args);
+
+  assert.equal(args.calls.kernel, 1);
+  assert.equal(args.calls.legacy, 0);
+
+  const events = readParityEvents(basePath);
+  assert.equal(events.length, 3);
+  assert.equal(events[0]?.phase, "enter");
+  assert.equal(events[1]?.phase, "telemetry-error");
+  assert.equal(events[1]?.telemetry, "uok-kernel-enter");
+  assert.equal(events[2]?.phase, "exit");
+  assert.equal(events[2]?.status, "ok");
+  assert.equal(isUnifiedAuditEnabled(), true);
+  assert.equal(isUnifiedAuditEnabled(basePath), false);
+  assert.ok(
+    peekLogs().some(entry =>
+      entry.severity === "warn" &&
+      entry.component === "db" &&
+      entry.message.includes("uok-kernel-enter audit emit failed"),
+    ),
+    "degraded audit path should emit a non-fatal warning",
+  );
+
+  assert.doesNotThrow(() => {
+    writeEscalationArtifact(basePath, {
+      version: 1,
+      taskId: "T02",
+      sliceId: "S01",
+      milestoneId: "M001",
+      question: "Continue?",
+      options: [
+        { id: "yes", label: "Yes", tradeoffs: "Continue" },
+        { id: "no", label: "No", tradeoffs: "Stop" },
+      ],
+      recommendation: "yes",
+      recommendationRationale: "Audit stayed disabled after degraded enter",
+      continueWithDefault: true,
+      createdAt: new Date().toISOString(),
+    });
+  });
+});

package/src/resources/extensions/gsd/tests/uok-model-policy.test.ts

@@ -12,8 +12,13 @@ import {
   registerToolCompatibility,
   resetToolCompatibilityRegistry,
 } from "@gsd/pi-coding-agent";
+import {
+  clearUnifiedAuditOverrideForTests,
+  setUnifiedAuditEnabled,
+} from "../uok/audit-toggle.ts";
 
 test.afterEach(() => {
+  clearUnifiedAuditOverrideForTests();
   resetToolCompatibilityRegistry();
 });
 
@@ -32,6 +37,7 @@ test("uok model policy builds requirement vectors from unit metadata", () => {
 test("uok model policy enforces provider/api/tool constraints and emits decision audit events", () => {
   const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-model-policy-"));
   try {
+    setUnifiedAuditEnabled(true);
     mkdirSync(join(basePath, ".gsd"), { recursive: true });
     registerToolCompatibility("screenshot", { producesImages: true });