@opengsd/gsd-pi 1.5.0-dev.4fb2d460 → 1.5.0-dev.c4c8885f

package/src/resources/extensions/gsd/tests/supervisor-model-swap-inflight-guard.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Supervisor model swap honors the in-flight-tool guard (#1229 follow-up).
+ *
+ * The wrap-up soft-timeout timer gates `triggerTurn` on there being no tools
+ * in flight — sending a turn mid-tool-call skips tool results and trips
+ * provider errors (#3512). The supervisor model swap
+ * (`applySupervisorModelIfConfigured`) must honor the identical guard: swapping
+ * the session model while tool calls are still open risks the same provider
+ * errors, so it must only run when the timer will actually trigger a turn.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mock } from "node:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { startUnitSupervision, type SupervisionContext } from "../auto-timers.ts";
+import { clearGSDPreferencesCache } from "../preferences.ts";
+import {
+  markToolStart,
+  markToolEnd,
+  clearInFlightTools,
+} from "../auto-tool-tracking.ts";
+
+const SUPERVISOR_PREFS = [
+  "auto_supervisor:",
+  "  soft_timeout_minutes: 1",
+  "  idle_timeout_minutes: 100",
+  "  hard_timeout_minutes: 100",
+  "  model:",
+  "    model: supervisor-primary",
+  "    fallbacks: [supervisor-fb]",
+];
+
+interface Harness {
+  home: string;
+  base: string;
+  ctx: any;
+  pi: any;
+  s: any;
+  sctx: SupervisionContext;
+  setModelCalls: unknown[][];
+  sendMessageCalls: unknown[][];
+}
+
+function makeHarness(): Harness {
+  const home = mkdtempSync(join(tmpdir(), "gsd-supervisor-guard-home-"));
+  const base = mkdtempSync(join(tmpdir(), "gsd-supervisor-guard-base-"));
+  process.env.GSD_HOME = home;
+  writeFileSync(join(home, "preferences.md"), ["---", ...SUPERVISOR_PREFS, "---", ""].join("\n"));
+  clearGSDPreferencesCache();
+
+  const setModelCalls: unknown[][] = [];
+  const sendMessageCalls: unknown[][] = [];
+
+  const ctx = {
+    ui: { notify: () => {} },
+    model: { provider: "anthropic" },
+    modelRegistry: {
+      getAvailable: () => [
+        { id: "supervisor-primary", provider: "anthropic" },
+        { id: "supervisor-fb", provider: "anthropic" },
+      ],
+    },
+  } as any;
+
+  const pi = {
+    sendMessage: (...args: unknown[]) => {
+      sendMessageCalls.push(args);
+    },
+    setModel: async (...args: unknown[]) => {
+      setModelCalls.push(args);
+      return true;
+    },
+    getThinkingLevel: () => "off",
+    setThinkingLevel: () => {},
+  } as any;
+
+  const s = {
+    active: true,
+    verbose: false,
+    basePath: base,
+    currentUnit: { type: "task", id: "T01", startedAt: 1234 },
+    cmdCtx: undefined,
+    wrapupWarningHandle: null,
+    idleWatchdogHandle: null,
+    unitTimeoutHandle: null,
+    continueHereHandle: null,
+  } as any;
+
+  const sctx: SupervisionContext = {
+    s,
+    ctx,
+    pi,
+    unitType: "task",
+    unitId: "T01",
+    prefs: undefined,
+    buildSnapshotOpts: () => ({}) as any,
+    buildRecoveryContext: () => ({}) as any,
+    pauseAuto: async () => {},
+  };
+
+  return { home, base, ctx, pi, s, sctx, setModelCalls, sendMessageCalls };
+}
+
+function cleanup(h: Harness): void {
+  clearInFlightTools();
+  clearGSDPreferencesCache();
+  delete process.env.GSD_HOME;
+  rmSync(h.home, { recursive: true, force: true });
+  rmSync(h.base, { recursive: true, force: true });
+}
+
+/** Neutralize every timer except the soft-timeout wrap-up so only it fires. */
+function isolateSoftTimeout(s: any): void {
+  if (s.idleWatchdogHandle) clearInterval(s.idleWatchdogHandle);
+  if (s.unitTimeoutHandle) clearTimeout(s.unitTimeoutHandle);
+  if (s.continueHereHandle) clearInterval(s.continueHereHandle);
+}
+
+/** Flush the soft-timeout callback's chained awaits. */
+async function flush(): Promise<void> {
+  for (let i = 0; i < 10; i++) await Promise.resolve();
+}
+
+test("soft-timeout skips the supervisor model swap while a tool is in flight", async () => {
+  const h = makeHarness();
+  mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"], now: 0 });
+  try {
+    startUnitSupervision(h.sctx);
+    isolateSoftTimeout(h.s);
+
+    // A tool is still executing when the soft timeout fires.
+    markToolStart("call-1", true, "some_tool");
+
+    mock.timers.tick(60_000);
+    await flush();
+
+    assert.equal(
+      h.setModelCalls.length,
+      0,
+      "model must NOT swap while a tool is in flight",
+    );
+    assert.equal(h.sendMessageCalls.length, 1, "wrap-up message still sent (queued)");
+    const opts = h.sendMessageCalls[0][1] as { triggerTurn?: boolean };
+    assert.equal(opts.triggerTurn, false, "turn is not triggered mid-tool-call");
+
+    markToolEnd("call-1");
+  } finally {
+    mock.timers.reset();
+    cleanup(h);
+  }
+});
+
+test("soft-timeout applies the supervisor model swap when no tools are in flight", async () => {
+  const h = makeHarness();
+  mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"], now: 0 });
+  try {
+    startUnitSupervision(h.sctx);
+    isolateSoftTimeout(h.s);
+
+    // No tools in flight — the timer will trigger a turn, so the model swaps.
+    mock.timers.tick(60_000);
+    await flush();
+
+    assert.equal(h.setModelCalls.length, 1, "model swaps to the supervisor model");
+    assert.deepEqual(
+      h.setModelCalls[0][0],
+      { id: "supervisor-primary", provider: "anthropic" },
+      "swaps to the configured supervisor primary",
+    );
+    assert.equal(h.sendMessageCalls.length, 1);
+    const opts = h.sendMessageCalls[0][1] as { triggerTurn?: boolean };
+    assert.equal(opts.triggerTurn, true, "turn is triggered when no tools are open");
+  } finally {
+    mock.timers.reset();
+    cleanup(h);
+  }
+});

package/src/resources/extensions/gsd/tests/supervisor-model-swap-thinking-clamp.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Supervisor model swap reclamps the reasoning level (#1229 follow-up).
+ *
+ * Hook overrides in `unit-phase.ts` reapply `applyThinkingLevelForModel` after a
+ * model swap so the session's reasoning effort is re-clamped to what the newly
+ * selected model supports (ADR-026). `applySupervisorModelIfConfigured` swaps
+ * the session model for supervisor interventions (wrap-up, context-budget,
+ * timeout recovery) and must do the same — otherwise a level that was valid for
+ * the prior model can reach the provider on the steered turn.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { applySupervisorModelIfConfigured } from "../auto-model-selection.ts";
+import { clearGSDPreferencesCache } from "../preferences.ts";
+
+const SUPERVISOR_PREFS = [
+  "auto_supervisor:",
+  "  model:",
+  "    model: supervisor-primary",
+  "    fallbacks: [supervisor-fb]",
+];
+
+interface Harness {
+  home: string;
+  base: string;
+  ctx: any;
+  pi: any;
+  setModelCalls: unknown[][];
+  setThinkingCalls: unknown[];
+  order: string[];
+}
+
+function makeHarness(): Harness {
+  const home = mkdtempSync(join(tmpdir(), "gsd-supervisor-clamp-home-"));
+  const base = mkdtempSync(join(tmpdir(), "gsd-supervisor-clamp-base-"));
+  process.env.GSD_HOME = home;
+  writeFileSync(join(home, "preferences.md"), ["---", ...SUPERVISOR_PREFS, "---", ""].join("\n"));
+  clearGSDPreferencesCache();
+
+  const setModelCalls: unknown[][] = [];
+  const setThinkingCalls: unknown[] = [];
+  const order: string[] = [];
+
+  const ctx = {
+    ui: { notify: () => {} },
+    model: { provider: "anthropic" },
+    modelRegistry: {
+      getAvailable: () => [
+        { id: "supervisor-primary", provider: "anthropic" },
+        { id: "supervisor-fb", provider: "anthropic" },
+      ],
+    },
+  } as any;
+
+  const pi = {
+    setModel: async (...args: unknown[]) => {
+      setModelCalls.push(args);
+      order.push("setModel");
+      return true;
+    },
+    getThinkingLevel: () => "high",
+    setThinkingLevel: (level: unknown) => {
+      setThinkingCalls.push(level);
+      order.push("setThinkingLevel");
+    },
+  } as any;
+
+  return { home, base, ctx, pi, setModelCalls, setThinkingCalls, order };
+}
+
+function cleanup(h: Harness): void {
+  clearGSDPreferencesCache();
+  delete process.env.GSD_HOME;
+  rmSync(h.home, { recursive: true, force: true });
+  rmSync(h.base, { recursive: true, force: true });
+}
+
+test("supervisor swap reapplies the thinking level after selecting the model", async () => {
+  const h = makeHarness();
+  try {
+    await applySupervisorModelIfConfigured(h.ctx, h.pi, h.base);
+
+    assert.equal(h.setModelCalls.length, 1, "model swaps to the supervisor model");
+    assert.deepEqual(
+      h.setModelCalls[0][0],
+      { id: "supervisor-primary", provider: "anthropic" },
+      "swaps to the configured supervisor primary",
+    );
+    assert.equal(
+      h.setThinkingCalls.length,
+      1,
+      "thinking level is reclamped exactly once after the swap",
+    );
+    assert.deepEqual(
+      h.order,
+      ["setModel", "setThinkingLevel"],
+      "reclamp happens after setModel, matching the hook-override pattern",
+    );
+  } finally {
+    cleanup(h);
+  }
+});
+
+test("supervisor swap does not touch the thinking level when no model is configured", async () => {
+  const h = makeHarness();
+  // Overwrite prefs with no auto_supervisor.model.
+  writeFileSync(join(h.home, "preferences.md"), ["---", "auto_supervisor:", "  soft_timeout_minutes: 1", "---", ""].join("\n"));
+  clearGSDPreferencesCache();
+  try {
+    await applySupervisorModelIfConfigured(h.ctx, h.pi, h.base);
+
+    assert.equal(h.setModelCalls.length, 0, "no swap without a configured supervisor model");
+    assert.equal(h.setThinkingCalls.length, 0, "thinking level untouched when nothing swaps");
+  } finally {
+    cleanup(h);
+  }
+});

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/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 () => {