@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/tests/thinking-level-resolution.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Per-phase thinking level resolution — behavior tests for ADR-026 (#497).
+ *
+ * Verifies the (model, thinking) pairing, the hybrid inline/block precedence,
+ * sibling-chain fallback, and static validation through exported runtime APIs.
+ */
+
+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 { resolveThinkingLevelForUnit, resolveModelWithFallbacksForUnit } from "../preferences-models.ts";
+import { validatePreferences } from "../preferences-validation.ts";
+
+function withPreferences<T>(frontmatter: string[], fn: () => T): T {
+  const oldHome = process.env.GSD_HOME;
+  const home = mkdtempSync(join(tmpdir(), "gsd-thinking-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "preferences.md"), ["---", ...frontmatter, "---", ""].join("\n"));
+    return fn();
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+test("inline models.<phase>.thinking resolves for that phase", () => {
+  withPreferences(
+    ["models:", "  planning:", "    model: planning-model", "    thinking: xhigh"],
+    () => {
+      assert.equal(resolveThinkingLevelForUnit("plan-milestone"), "xhigh");
+      // Model still resolves normally alongside the paired thinking.
+      assert.equal(resolveModelWithFallbacksForUnit("plan-milestone")?.primary, "planning-model");
+    },
+  );
+});
+
+test("separate thinking block resolves without a model pin", () => {
+  withPreferences(["thinking:", "  execution: low"], () => {
+    assert.equal(resolveThinkingLevelForUnit("execute-task"), "low");
+    // No model configured — model resolution stays undefined.
+    assert.equal(resolveModelWithFallbacksForUnit("execute-task"), undefined);
+  });
+});
+
+test("inline thinking on a model-less models entry resolves", () => {
+  // `models.planning: { thinking: high }` with no model — inline thinking must
+  // be honored even though the entry pins no model (resolveWinningPhase skips it).
+  withPreferences(["models:", "  planning:", "    thinking: high"], () => {
+    assert.equal(resolveThinkingLevelForUnit("plan-milestone"), "high");
+    // Model resolution still yields nothing for that phase.
+    assert.equal(resolveModelWithFallbacksForUnit("plan-milestone"), undefined);
+  });
+});
+
+test("inline thinking wins over the block for the same phase", () => {
+  withPreferences(
+    [
+      "models:",
+      "  planning:",
+      "    model: planning-model",
+      "    thinking: high",
+      "thinking:",
+      "  planning: low",
+    ],
+    () => {
+      assert.equal(resolveThinkingLevelForUnit("plan-slice"), "high");
+    },
+  );
+});
+
+test("a bare-string model bucket is complemented by the block for the same phase", () => {
+  withPreferences(
+    ["models:", "  execution: execution-model", "thinking:", "  execution: high"],
+    () => {
+      assert.equal(resolveModelWithFallbacksForUnit("execute-task")?.primary, "execution-model");
+      assert.equal(resolveThinkingLevelForUnit("execute-task"), "high");
+    },
+  );
+});
+
+test("a claimed model bucket does not inherit a sibling's thinking", () => {
+  // discuss has its own model (claims the bucket) but no thinking; planning has
+  // thinking. discuss must NOT borrow planning's thinking — the pair is anchored
+  // to the resolved model phase.
+  withPreferences(
+    [
+      "models:",
+      "  discuss: discuss-model",
+      "  planning:",
+      "    model: planning-model",
+      "    thinking: xhigh",
+    ],
+    () => {
+      assert.equal(resolveModelWithFallbacksForUnit("discuss-milestone")?.primary, "discuss-model");
+      assert.equal(resolveThinkingLevelForUnit("discuss-milestone"), undefined);
+    },
+  );
+});
+
+test("with no model configured, the thinking block follows the sibling chain", () => {
+  // discuss-milestone's chain is [discuss, planning]; only planning is set in
+  // the block, so discuss inherits it.
+  withPreferences(["thinking:", "  planning: high"], () => {
+    assert.equal(resolveThinkingLevelForUnit("discuss-milestone"), "high");
+  });
+});
+
+test("execution_simple inherits the execution block when its own is unset", () => {
+  withPreferences(["thinking:", "  execution: medium"], () => {
+    assert.equal(resolveThinkingLevelForUnit("execute-task-simple"), "medium");
+  });
+});
+
+test("thinking.execution_simple resolves for execute-task-simple even when model falls through to execution", () => {
+  // models.execution wins the model chain for execute-task-simple (no execution_simple model).
+  // thinking.execution_simple is explicitly set and must be found — it must not
+  // be shadowed by the winning model phase (execution).
+  withPreferences(
+    ["models:", "  execution: execution-model", "thinking:", "  execution_simple: low"],
+    () => {
+      assert.equal(resolveModelWithFallbacksForUnit("execute-task-simple")?.primary, "execution-model");
+      assert.equal(resolveThinkingLevelForUnit("execute-task-simple"), "low");
+    },
+  );
+});
+
+test("returns undefined when nothing is configured", () => {
+  withPreferences(["models:", "  planning: planning-model"], () => {
+    assert.equal(resolveThinkingLevelForUnit("execute-task"), undefined);
+    assert.equal(resolveThinkingLevelForUnit("plan-milestone"), undefined);
+  });
+});
+
+test("validation warns on an illegal thinking level in the block", () => {
+  const result = validatePreferences({ thinking: { planning: "ultra" } } as never);
+  assert.ok(result.warnings.some((w) => w.includes("thinking.planning") && w.includes("not a valid thinking level")));
+  // Invalid entry is dropped, not kept.
+  assert.equal(result.preferences.thinking, undefined);
+});
+
+test("validation warns on an unknown phase key in the block", () => {
+  const result = validatePreferences({ thinking: { plannning: "high" } } as never);
+  assert.ok(result.warnings.some((w) => w.includes("unknown thinking phase") && w.includes("plannning")));
+});
+
+test("validation warns on AND strips an illegal inline models thinking level", () => {
+  const result = validatePreferences({
+    models: { planning: { model: "m", thinking: "max" } },
+  } as never);
+  assert.ok(result.warnings.some((w) => w.includes("models.planning.thinking") && w.includes("not a valid thinking level")));
+  // The bad thinking field must be stripped so it can't reach the resolver,
+  // while the rest of the model config survives.
+  const planning = (result.preferences.models as Record<string, { model?: string; thinking?: string }>).planning;
+  assert.equal(planning.thinking, undefined);
+  assert.equal(planning.model, "m");
+});
+
+test("an empty-string model is treated as unconfigured (no {primary: ''})", () => {
+  withPreferences(["models:", '  planning: ""'], () => {
+    assert.equal(resolveModelWithFallbacksForUnit("plan-milestone"), undefined);
+  });
+});
+
+test("an empty-string model falls through the sibling chain", () => {
+  withPreferences(["models:", '  discuss: ""', "  planning: planning-model"], () => {
+    // discuss is empty → chain falls through to planning.
+    assert.equal(resolveModelWithFallbacksForUnit("discuss-milestone")?.primary, "planning-model");
+  });
+});
+
+test("a model-less object entry is unconfigured and falls through to a sibling", () => {
+  withPreferences(
+    ["models:", "  discuss:", "    provider: anthropic", "  planning: planning-model"],
+    () => {
+      // discuss has no `model` → skipped → planning wins.
+      assert.equal(resolveModelWithFallbacksForUnit("discuss-milestone")?.primary, "planning-model");
+    },
+  );
+});
+
+test("a sole model-less object entry yields undefined (no {primary: undefined})", () => {
+  withPreferences(["models:", "  planning:", "    provider: anthropic"], () => {
+    assert.equal(resolveModelWithFallbacksForUnit("plan-milestone"), undefined);
+  });
+});
+
+test("validation drops a phase left hollow after stripping invalid thinking", () => {
+  const result = validatePreferences({ models: { planning: { thinking: "bad" } } } as never);
+  assert.ok(result.warnings.some((w) => w.includes("models.planning.thinking")));
+  // No model remained after stripping → phase dropped entirely, not stored as {}.
+  assert.equal((result.preferences.models as Record<string, unknown>).planning, undefined);
+});
+
+test("validation accepts a valid thinking block", () => {
+  const result = validatePreferences({ thinking: { planning: "xhigh", execution: "low" } } as never);
+  assert.deepEqual(result.preferences.thinking, { planning: "xhigh", execution: "low" });
+  assert.equal(result.errors.length, 0);
+});

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

@@ -0,0 +1,170 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  classifyUatContent,
+  getDeclaredUatType,
+  getUatBrowserToolSupportError,
+  hasUatBrowserToolSurface,
+  isPartialEligibleUatType,
+  resolveEffectiveUatType,
+  shouldDispatchUatForContent,
+  shouldEscalateArtifactUatToBrowser,
+  uatTypeIncludesBrowser,
+  validateUatModePolicy,
+} from "../uat-policy.ts";
+
+describe("uat-policy", () => {
+  it("defaults missing UAT mode to artifact-driven", () => {
+    assert.equal(getDeclaredUatType("# UAT\n\nCheck generated files."), "artifact-driven");
+  });
+
+  it("escalates artifact-driven UAT to browser-executable when the spec requires browser work", () => {
+    const content = [
+      "## UAT Type",
+      "- UAT mode: artifact-driven",
+      "",
+      "## Test",
+      "Open the page in a browser and verify the submit button is visible.",
+    ].join("\n");
+
+    assert.equal(shouldEscalateArtifactUatToBrowser(content), true);
+    assert.equal(resolveEffectiveUatType(content), "browser-executable");
+    assert.equal(shouldDispatchUatForContent(content, undefined), true);
+    assert.deepEqual(classifyUatContent(content), {
+      declaredType: "artifact-driven",
+      effectiveType: "browser-executable",
+      browserRequired: true,
+      shouldDispatchByDefault: true,
+    });
+  });
+
+  it("does not escalate disclaimer-only browser mentions", () => {
+    const content = [
+      "## UAT Type",
+      "- UAT mode: artifact-driven",
+      "",
+      "## Not Proven By This UAT",
+      "- No live browser session was run in this artifact check.",
+    ].join("\n");
+
+    assert.equal(shouldEscalateArtifactUatToBrowser(content), false);
+    assert.equal(resolveEffectiveUatType(content), "artifact-driven");
+    assert.equal(shouldDispatchUatForContent(content, undefined), false);
+  });
+
+  it("centralizes which UAT modes receive browser tools", () => {
+    for (const uatType of ["browser-executable", "live-runtime", "mixed", "human-experience"] as const) {
+      assert.equal(uatTypeIncludesBrowser(uatType), true, `${uatType} should include browser tools`);
+    }
+
+    for (const uatType of ["artifact-driven", "runtime-executable"] as const) {
+      assert.equal(uatTypeIncludesBrowser(uatType), false, `${uatType} should not include browser tools`);
+    }
+  });
+
+  it("detects direct and MCP-shaped browser tool surfaces", () => {
+    assert.equal(hasUatBrowserToolSurface(["read", "browser_navigate"]), true);
+    assert.equal(hasUatBrowserToolSurface(["read", "mcp__gsd-browser__browser_navigate"]), true);
+    assert.equal(hasUatBrowserToolSurface(["read", "gsd_uat_exec"]), false);
+    assert.equal(hasUatBrowserToolSurface(undefined), false);
+  });
+
+  it("reports missing browser tools only for browser-backed UAT with a known tool snapshot", () => {
+    assert.equal(
+      getUatBrowserToolSupportError({
+        uatType: "artifact-driven",
+        activeTools: ["read", "gsd_uat_exec"],
+        milestoneId: "M001",
+        sliceId: "S01",
+      }),
+      null,
+    );
+    assert.equal(
+      getUatBrowserToolSupportError({
+        uatType: "browser-executable",
+        activeTools: undefined,
+        milestoneId: "M001",
+        sliceId: "S01",
+      }),
+      null,
+    );
+
+    const error = getUatBrowserToolSupportError({
+      uatType: "browser-executable",
+      activeTools: ["read", "gsd_uat_exec"],
+      milestoneId: "M001",
+      sliceId: "S01",
+    });
+    assert.match(error ?? "", /Cannot dispatch browser-backed run-uat for M001\/S01/);
+  });
+
+  it("centralizes partial verdict eligibility", () => {
+    assert.equal(isPartialEligibleUatType("mixed"), true);
+    assert.equal(isPartialEligibleUatType("human-experience"), true);
+    assert.equal(isPartialEligibleUatType("live-runtime"), true);
+    assert.equal(isPartialEligibleUatType("artifact-driven"), false);
+    assert.equal(isPartialEligibleUatType("browser-executable"), false);
+    assert.equal(isPartialEligibleUatType("runtime-executable"), false);
+  });
+
+  it("requires runtime evidence for runtime-executable UAT", () => {
+    assert.equal(
+      validateUatModePolicy({
+        uatType: "runtime-executable",
+        verdict: "PASS",
+        checks: [{ mode: "artifact", result: "PASS" }],
+      }),
+      "runtime-executable UAT requires runtime evidence",
+    );
+
+    assert.equal(
+      validateUatModePolicy({
+        uatType: "runtime-executable",
+        verdict: "PASS",
+        checks: [{ mode: "runtime", result: "PASS" }],
+      }),
+      null,
+    );
+  });
+
+  it("requires browser evidence for browser-executable UAT", () => {
+    assert.equal(
+      validateUatModePolicy({
+        uatType: "browser-executable",
+        verdict: "PASS",
+        checks: [{ mode: "runtime", result: "PASS" }],
+      }),
+      "browser-executable UAT requires browser evidence",
+    );
+
+    assert.equal(
+      validateUatModePolicy({
+        uatType: "browser-executable",
+        verdict: "PASS",
+        checks: [{ mode: "browser", result: "PASS" }],
+      }),
+      null,
+    );
+  });
+
+  it("allows live-runtime evidence through either runtime or browser checks", () => {
+    assert.equal(
+      validateUatModePolicy({
+        uatType: "live-runtime",
+        verdict: "PASS",
+        checks: [{ mode: "artifact", result: "PASS" }],
+      }),
+      "live-runtime UAT requires runtime or browser evidence",
+    );
+
+    assert.equal(
+      validateUatModePolicy({
+        uatType: "live-runtime",
+        verdict: "PASS",
+        checks: [{ mode: "browser", result: "PASS" }],
+      }),
+      null,
+    );
+  });
+});

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

@@ -85,6 +85,12 @@ test("#4782 phase 1: no manifest has the same artifact key in inline AND excerpt
   }
 });
 
+test("gate-evaluate manifest matches its prompt builder context", () => {
+  assert.deepEqual(UNIT_MANIFESTS["gate-evaluate"].artifacts.inline, ["slice-plan"]);
+  assert.deepEqual(UNIT_MANIFESTS["gate-evaluate"].artifacts.excerpt, []);
+  assert.deepEqual(UNIT_MANIFESTS["gate-evaluate"].artifacts.onDemand, []);
+});
+
 test("#4782 phase 1: every manifest has a positive maxSystemPromptChars", () => {
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     assert.ok(
@@ -432,7 +438,7 @@ test('Unit Tool Contract exposes subagent dispatch permissions', () => {
   });
   assert.deepEqual(resolveSubagentPermissionContract("gate-evaluate"), {
     allowed: true,
-    allowedSubagents: ["reviewer", "security", "tester"],
+    allowedSubagents: ["tester"],
     toolsMode: "planning-dispatch",
   });
   assert.deepEqual(resolveSubagentPermissionContract("run-uat"), {

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

@@ -172,6 +172,13 @@ test("decideFinalizeResult maps step-wizard breaks to completed step exits", ()
   );
 });
 
+test("decideFinalizeResult maps milestone-complete breaks to completed exits", () => {
+  assert.deepEqual(
+    decideFinalizeResult({ action: "break", reason: "milestone-complete" }),
+    { action: "complete-and-break" },
+  );
+});
+
 test("decideFinalizeResult maps finalize pause breaks to completed exits", () => {
   for (const reason of [
     "post-verification-stopped",