@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

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

@@ -152,35 +152,50 @@ test("ADR-017 (#5700): repair failure throws ReconciliationFailedError with shap
   );
 });
 
-test("ADR-017 (#5700): detector failure throws ReconciliationFailedError with shape", async () => {
-  const handler: DriftHandler = {
-    kind: "stale-sketch-flag",
+test("ADR-017 (#5700): a detector failure degrades to a blocker without aborting other handlers", async () => {
+  // A single detector throwing (e.g. a transient file read error) must NOT
+  // abort the whole cycle and hide every later handler's drift. It is collected
+  // as a blocker (so dispatch is still gated) while the remaining detectors run
+  // and their drift is repaired — graceful degradation, not fail-fast.
+  const throwingHandler: DriftHandler = {
+    kind: "stale-render",
     detect: () => {
       throw new Error("simulated detect failure");
     },
     repair: () => {
-      /* detect fails before repair */
+      /* never reached: detect throws */
     },
   };
 
-  await assert.rejects(
-    () =>
-      reconcileBeforeDispatch("/project", {
-        invalidateStateCache: () => {},
-        deriveState: async () => makeState(),
-        registry: [handler],
-      }),
-    (err: unknown) => {
-      assert.ok(err instanceof ReconciliationFailedError, "must be ReconciliationFailedError");
-      assert.equal(err.failures.length, 1);
-      assert.equal(err.failures[0]?.drift.kind, "stale-sketch-flag");
-      assert.ok(err.failures[0]?.cause instanceof Error);
-      assert.equal((err.failures[0]?.cause as Error).message, "simulated detect failure");
-      assert.equal(err.pass, 0);
-      assert.equal(err.detectionFailures.length, 0);
-      assert.equal(err.persistentDrift.length, 0);
-      return true;
+  let repairCount = 0;
+  const workingHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () =>
+      repairCount === 0
+        ? [{ kind: "stale-sketch-flag", mid: "M001", sid: "S02" }]
+        : [],
+    repair: () => {
+      repairCount++;
     },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [throwingHandler, workingHandler],
+  });
+
+  assert.equal(result.ok, true, "cycle must not abort on a single detector failure");
+  // The working handler (registered AFTER the thrower) still detected + repaired.
+  assert.equal(repairCount, 1, "later handler must still run despite earlier detect failure");
+  assert.equal(result.repaired.length, 1);
+  assert.equal(result.repaired[0]?.kind, "stale-sketch-flag");
+  // The detector failure surfaces as a blocker so dispatch is still gated.
+  assert.ok(
+    result.blockers.some(
+      (b) => b.includes("stale-render") && b.includes("simulated detect failure"),
+    ),
+    "detect failure must surface as a blocker",
   );
 });
 
@@ -746,6 +761,46 @@ test("ADR-017 (#5702): missing UAT.md clears stale full_uat_md from DB", async (
   );
 });
 
+test("ADR-017 (#5702): stale-render plan repair works with descriptor-layout milestone dir", async (t) => {
+  // Regression for bugbot finding: repairStaleRenderFromBasePath was passing the
+  // raw dir segment (e.g. M001-DESCRIPTOR) straight to renderPlanCheckboxes, which
+  // queries the DB as getSliceTasks("M001-DESCRIPTOR", …) → empty → throws.
+  // After the fix it calls canonicalizeMilestoneId() first.
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-descriptor-"));
+  // Use a descriptor-style directory name (M001-DESCRIPTOR → DB milestone M001)
+  const milestoneDir = "M001-DESCRIPTOR";
+  const sliceDir = join(base, ".gsd", "milestones", milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceDir, "tasks"), { recursive: true });
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmTreeQuiet(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  clearRendererCaches();
+  // DB uses the canonical ID (M001), directory uses the descriptor name.
+  insertMilestone({ id: "M001", title: "Descriptor Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task One", status: "done" });
+
+  const planPath = join(sliceDir, "S01-PLAN.md");
+  writeFileSync(planPath, makeStalePlanContent("S01", [
+    { id: "T01", title: "Task One", done: false },
+  ]));
+  clearRendererCaches();
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+
+  assert.equal(result.ok, true, "reconcile should succeed with descriptor-layout milestone dir");
+  const renderRepaired = result.repaired.find((d) => d.kind === "stale-render");
+  assert.ok(renderRepaired, "stale-render drift should be repaired");
+  const repairedContent = readFileSync(planPath, "utf-8");
+  assert.match(repairedContent, /\[x\][^\n]*T01:/, "T01 checkbox should be checked after repair");
+});
+
 // ─── #5703: stale-worker drift ───────────────────────────────────────────────
 
 const DEAD_PID = 999_999_999; // far above any realistic system PID; process.kill(pid, 0) → ESRCH

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",