jev-layer 0.1.0

package/src/supervision.mjs

@@ -0,0 +1,244 @@
+import { randomUUID } from "node:crypto";
+import { stableJson } from "./contract.mjs";
+import { DemoProvider } from "./providers/demo.mjs";
+import { OpenRouterDecisionsProvider, TypeSafeProvider } from "./providers/typesafe.mjs";
+import { appendSupervisionReceipt } from "./receipts.mjs";
+
+export const SUPERVISION_ENV = "JEV_SUPERVISION";
+export const SUPERVISION_DIMENSIONS = Object.freeze([
+  "requirements_addressed",
+  "verification_needed",
+  "meaningful_progress",
+  "worker_stuck",
+  "work_off_track",
+  "completion",
+]);
+
+const MAX_STATE_BYTES = 8_000;
+
+export function supervisionEnabled(options = {}) {
+  if (options.enabled === true) return true;
+  if (options.enabled === false) return false;
+  return process.env[SUPERVISION_ENV] === "1";
+}
+
+export function buildSupervisionRequest({
+  job = {},
+  observation = {},
+  evidence = {},
+  harness = "unknown",
+  actor_permissions = [],
+  policy = {},
+} = {}) {
+  return {
+    schema_version: 1,
+    harness,
+    intent: "Assess supervised work against its requirements and verification evidence.",
+    actor_permissions: Array.isArray(actor_permissions) ? actor_permissions.filter((value) => typeof value === "string") : [],
+    policy: { ...policy },
+    context: {
+      job: bounded(job),
+      observation: bounded(observation),
+      evidence: bounded(evidence),
+      supervision: {
+        judgments: bounded(evidence?.judgments ?? {}),
+      },
+    },
+  };
+}
+
+export function supervisionQuestions() {
+  return Object.fromEntries(SUPERVISION_DIMENSIONS.map((dimension) => [dimension, {
+    type: "noul",
+    instructions: questionInstructions(dimension),
+    criteria: {
+      true: "The statement is supported by the supplied work state and evidence.",
+      false: "The statement is not supported, is contradicted, or is unknown.",
+    },
+  }]));
+}
+
+export function normalizeAssessment(raw) {
+  const answers = raw?.answers;
+  if (!answers || typeof answers !== "object") throw new Error("supervision response has no answers object");
+  const assessment = {};
+  for (const dimension of SUPERVISION_DIMENSIONS) {
+    const answer = answers[dimension];
+    const probability = readProbability(answer);
+    if (probability === null) throw new Error(`supervision response has no valid ${dimension} judgment`);
+    assessment[dimension] = Number(probability.toFixed(4));
+  }
+  return assessment;
+}
+
+export function deterministicSupervisionPolicy({ assessment, evidence = {}, attempts = 0, policy = {} } = {}) {
+  const values = assessment && typeof assessment === "object" ? assessment : {};
+  const threshold = Number.isFinite(policy.threshold) ? Math.max(0, Math.min(1, policy.threshold)) : 0.7;
+  const maxRetries = Number.isInteger(policy.max_retries) && policy.max_retries >= 0 ? policy.max_retries : 2;
+  const verificationEvidence = evidence.verification_passed === true || evidence.tests_passed === true;
+
+  if (value(values.worker_stuck) >= threshold) {
+    return attempts < maxRetries
+      ? { action: "retry", reason: "worker appears stuck and retry budget remains", policy_source: "deterministic_host_policy" }
+      : { action: "escalate", reason: "worker appears stuck and retry budget is exhausted", policy_source: "deterministic_host_policy" };
+  }
+  if (value(values.work_off_track) >= threshold) {
+    return attempts < maxRetries
+      ? { action: "retry", reason: "work appears off track and retry budget remains", policy_source: "deterministic_host_policy" }
+      : { action: "escalate", reason: "work appears off track and retry budget is exhausted", policy_source: "deterministic_host_policy" };
+  }
+  if (value(values.verification_needed) >= threshold || (value(values.completion) >= threshold && !verificationEvidence)) {
+    return { action: "verify", reason: "verification is required before continuing or finishing", policy_source: "deterministic_host_policy" };
+  }
+  if (value(values.completion) >= threshold && value(values.requirements_addressed) >= threshold) {
+    return { action: "finish", reason: "completion and requirement coverage are supported", policy_source: "deterministic_host_policy" };
+  }
+  return { action: "continue", reason: value(values.meaningful_progress) >= threshold ? "meaningful progress is supported" : "continue while evidence is incomplete", policy_source: "deterministic_host_policy" };
+}
+
+export async function superviseWork({
+  job,
+  observation,
+  evidence,
+  harness,
+  actor_permissions,
+  policy,
+  provider = "demo",
+  enabled,
+  attempts = 0,
+  receiptPath,
+} = {}) {
+  const started = performance.now();
+  const request = buildSupervisionRequest({ job, observation, evidence, harness, actor_permissions, policy });
+  const base = {
+    status: "fallback",
+    action: "continue",
+    reason: "supervision unavailable",
+    assessment: null,
+    policy: null,
+    request,
+    metrics: { wall_time_ms: 0, jev_calls: 0, cost_usd: 0, failures: 0 },
+    receipt: null,
+  };
+
+  if (!supervisionEnabled({ enabled })) return finalize(base, started, "disabled", 0);
+  let resolved;
+  try {
+    resolved = resolveProvider(provider);
+    if (!resolved || typeof resolved.evaluate !== "function") throw new Error("provider does not support supervision evaluation");
+  } catch (error) {
+    return finalize(base, started, "provider_error", 1, error);
+  }
+
+  let raw;
+  try {
+    raw = await resolved.evaluate({ state: request, questions: supervisionQuestions() });
+  } catch (error) {
+    return finalize(base, started, "provider_error", 1, error);
+  }
+
+  let assessment;
+  try {
+    assessment = normalizeAssessment(raw);
+  } catch (error) {
+    return finalize({ ...base, raw_jev: raw }, started, "malformed_response", 1, error);
+  }
+
+  const selectedPolicy = deterministicSupervisionPolicy({ assessment, evidence, attempts, policy });
+  const result = {
+    status: "judged",
+    action: selectedPolicy.action,
+    reason: selectedPolicy.reason,
+    assessment,
+    policy: selectedPolicy,
+    request,
+    metrics: {
+      wall_time_ms: Number((performance.now() - started).toFixed(3)),
+      jev_calls: 1,
+      cost_usd: finiteCost(raw?.usage?.cost),
+      failures: 0,
+    },
+    receipt: {
+      correlation_id: randomUUID(),
+      provider: resolved.name ?? providerName(provider),
+      latency_ms: Number((performance.now() - started).toFixed(3)),
+      cost_usd: finiteCost(raw?.usage?.cost),
+      dimensions: SUPERVISION_DIMENSIONS.length,
+    },
+  };
+  if (receiptPath) {
+    try {
+      const appended = await appendSupervisionReceipt({ path: receiptPath, request, result });
+      result.receipt_path = appended.path;
+    } catch (error) {
+      result.receipt_error = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return result;
+}
+
+function resolveProvider(provider) {
+  if (provider && typeof provider === "object") return provider;
+  if (provider === "demo") return new DemoProvider();
+  if (provider === "openrouter") return new OpenRouterDecisionsProvider();
+  if (provider === "typesafe") return new TypeSafeProvider();
+  throw new Error(`unsupported provider: ${provider}`);
+}
+
+function finalize(result, started, reason, jevCalls, error = null) {
+  const message = error instanceof Error ? error.message : error ? String(error) : reason;
+  return {
+    ...result,
+    reason: message,
+    metrics: {
+      ...result.metrics,
+      wall_time_ms: Number((performance.now() - started).toFixed(3)),
+      jev_calls: jevCalls,
+      failures: reason === "disabled" ? 0 : 1,
+    },
+    fallback: { type: reason, reason: message },
+  };
+}
+
+function readProbability(answer) {
+  if (typeof answer === "boolean") return answer ? 1 : 0;
+  if (typeof answer === "number" && Number.isFinite(answer) && answer >= 0 && answer <= 1) return answer;
+  if (!answer || typeof answer !== "object") return null;
+  for (const key of ["probability", "p_true", "score", "value", "noul"]) {
+    const value = answer[key];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1) return value;
+    if (typeof value === "boolean") return value ? 1 : 0;
+  }
+  return null;
+}
+
+function questionInstructions(dimension) {
+  const labels = {
+    requirements_addressed: "The worker has addressed the stated requirements.",
+    verification_needed: "Additional verification is needed before trusting the current work.",
+    meaningful_progress: "The worker has made meaningful progress toward the goal.",
+    worker_stuck: "The worker is stuck and is not making useful progress.",
+    work_off_track: "The worker's current work is materially off track.",
+    completion: "The work is complete for the stated requirements.",
+  };
+  return `Judge whether this statement is supported: ${labels[dimension]}`;
+}
+
+function bounded(value) {
+  const encoded = stableJson(value ?? {});
+  if (Buffer.byteLength(encoded, "utf8") <= MAX_STATE_BYTES) return value ?? {};
+  return { truncated: true, preview: encoded.slice(0, MAX_STATE_BYTES) };
+}
+
+function value(assessment, key) {
+  const candidate = key === undefined ? assessment : assessment?.[key];
+  return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : 0;
+}
+
+function finiteCost(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function providerName(provider) {
+  return typeof provider === "string" ? provider : "unknown";
+}

package/test/browser.test.mjs

@@ -0,0 +1,199 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { buildBrowserRequest, browserActions, decideBrowserStep, runBrowserFastPath } from "../src/browser.mjs";
+import { readRoutingCases } from "../src/receipts.mjs";
+import { routeRequest } from "../src/route.mjs";
+function providerFor(choices) {
+  let call = 0;
+  return {
+    name: "browser-test-provider",
+    async decide({ candidates }) {
+      const requested = choices[call++] ?? "browser:handoff";
+      const choice = candidates.some((candidate) => candidate.id === requested)
+        ? requested
+        : candidates.find((candidate) => candidate.id === "browser:handoff")?.id ?? candidates[0]?.id;
+      return {
+        answers: { tool: { type: "choice", choice, probabilities: Object.fromEntries(candidates.map((candidate) => [candidate.id, candidate.id === choice ? 1 : 0])), confidence: 1 } },
+        usage: { cost: 0.0001 },
+      };
+    },
+  };
+}
+
+test("browser request exposes only bounded structured actions", () => {
+  const request = buildBrowserRequest({
+    goal: "inspect the visible page",
+    observation: {
+      url: "https://example.test",
+      visible_text: "Visible content",
+      scroll: { up: false, down: true },
+      targets: [{ id: "submit", name: "Submit", role: "button", clickable: true }, { id: "country", name: "Country", options: [{ id: "de", label: "Germany" }] }],
+      tabs: [{ id: "tab-1", title: "Current", active: true }, { id: "tab-2", title: "Other", active: false }],
+    },
+  });
+  assert.ok(request.capabilities.some((candidate) => candidate.id === "browser:scroll:down"));
+  assert.ok(request.capabilities.some((candidate) => candidate.id === "browser:click:submit"));
+  assert.ok(request.capabilities.some((candidate) => candidate.id === "browser:select:country:de"));
+  assert.ok(request.capabilities.some((candidate) => candidate.id === "browser:switch_tab:tab-2"));
+  assert.ok(request.capabilities.every((candidate) => candidate.permissions.includes("browser")));
+  assert.equal(request.capabilities.some((candidate) => candidate.id.includes("type")), false);
+});
+
+test("browser progress removes completed targets and exposes link navigation", () => {
+  const request = buildBrowserRequest({
+    goal: "click the action then navigate",
+    observation: {
+      url: "https://example.test/start",
+      targets: [
+        { id: "action", role: "button", name: "Action", clickable: true },
+        { id: "next", role: "a", name: "Next", href: "/next", clickable: true },
+      ],
+    },
+    progress: {
+      executed_actions: [{ id: "browser:click:action", operation: "click", target_id: "action", status: "completed" }],
+      used_targets: ["action"],
+      current_url: "https://example.test/start",
+      last_action: { id: "browser:click:action", operation: "click", target_id: "action", status: "completed" },
+      last_result: { status: "completed", state_changed: true },
+    },
+  });
+  assert.equal(request.capabilities.some((candidate) => candidate.id === "browser:click:action"), false);
+  assert.ok(request.capabilities.some((candidate) => candidate.id === "browser:navigate:https%3A%2F%2Fexample.test%2Fnext:next"));
+  assert.equal(request.context.browser.progress.goal, "click the action then navigate");
+  assert.equal(request.context.browser.progress.current_url, "https://example.test/start");
+  assert.equal(request.context.browser.progress.last_action.target_id, "action");
+});
+
+test("browser progress infers actionable roles and deterministic goal order", () => {
+  const request = buildBrowserRequest({
+    goal: "Click Increment, then select Beta, then navigate to the next page",
+    observation: {
+      url: "https://example.test/start",
+      targets: [
+        { id: "increment", role: "button", name: "Increment" },
+        { id: "choice", role: "select", name: "Choice", options: [{ id: "beta", value: "beta", label: "Beta" }] },
+        { id: "next", role: "a", name: "Next", href: "/next" },
+      ],
+    },
+  });
+  assert.deepEqual(request.context.browser.progress.remaining_expected_progress, [
+    "browser:click:increment",
+    "browser:select:choice:beta",
+    "browser:navigate:https%3A%2F%2Fexample.test%2Fnext:next",
+  ]);
+  assert.deepEqual(request.capabilities.map((candidate) => candidate.id), ["browser:click:increment", "browser:handoff"]);
+});
+
+test("browser progress only permits repeated scroll after measurable progress", () => {
+  const base = {
+    goal: "scroll down",
+    observation: { url: "https://example.test", scroll: { down: true, position: 100, max: 1000 } },
+  };
+  const blocked = browserActions({
+    ...base,
+    progress: {
+      last_action: { id: "browser:scroll:down", operation: "scroll", direction: "down", status: "completed" },
+      last_result: { status: "completed", state_changed: false, scroll_progress: false },
+    },
+  });
+  assert.equal(blocked.some((candidate) => candidate.id === "browser:scroll:down"), false);
+  const allowed = browserActions({
+    ...base,
+    progress: {
+      last_action: { id: "browser:scroll:down", operation: "scroll", direction: "down", status: "completed" },
+      last_result: { status: "completed", state_changed: true, scroll_progress: true },
+    },
+  });
+  assert.ok(allowed.some((candidate) => candidate.id === "browser:scroll:down"));
+});
+
+test("browser fast-path is opt-in and fails open without an executor", async () => {
+  const disabled = await decideBrowserStep({ goal: "inspect", observation: {} }, { enabled: false, provider: "demo" });
+  assert.equal(disabled.decision.status, "fallback");
+  assert.equal(disabled.decision.fallback.type, "browser_fast_path_disabled");
+  const unavailable = await runBrowserFastPath({ goal: "inspect", enabled: true, provider: "demo" });
+  assert.equal(unavailable.status, "handoff");
+  assert.equal(unavailable.reason, "browser_executor_unavailable");
+});
+
+test("browser fast-path executes safe actions then hands control back", async () => {
+  const path = join(await mkdtemp(join(tmpdir(), "jev-browser-")), "cases.jsonl");
+  const executed = [];
+  const observations = [
+    { url: "https://example.test", scroll: { up: false, down: true }, tabs: [{ id: "tab-1", active: true }, { id: "tab-2", title: "Other", active: false }] },
+    { url: "https://example.test", scroll: { up: false, down: false }, tabs: [{ id: "tab-1", active: true }, { id: "tab-2", title: "Other", active: false }] },
+  ];
+  const executor = {
+    async observe() { return observations.shift() ?? observations.at(-1) ?? {}; },
+    async execute(action) {
+      executed.push(action);
+      return { result: { operation: action.operation }, observation: observations.shift() ?? {}, handoff: executed.length === 2 };
+    },
+  };
+  const result = await runBrowserFastPath({
+    goal: "scroll and switch to the other tab",
+    harness: "browser-test",
+    enabled: true,
+    provider: providerFor(["browser:scroll:down", "browser:switch_tab:tab-2"]),
+    executor,
+    receiptPath: path,
+  });
+  assert.equal(result.status, "handoff");
+  assert.equal(result.reason, "host_handoff");
+  assert.deepEqual(executed.map((action) => action.operation), ["scroll", "switch_tab"]);
+  assert.equal(result.metrics.jev_calls, 2);
+  assert.equal(result.metrics.browser_actions, 2);
+  assert.equal(result.metrics.failures, 0);
+  assert.equal(result.metrics.cost_usd, 0.0002);
+  const records = (await readFile(path, "utf8")).trim().split(/\r?\n/).map(JSON.parse);
+  assert.equal(records.length, 4);
+  assert.equal(records.filter((record) => record.record_type === "routing_case").length, 2);
+  assert.equal(records.filter((record) => record.record_type === "execution_receipt").length, 2);
+  assert.equal(records[1].host.browser.operation, "scroll");
+  assert.equal(records[3].host.browser.operation, "switch_tab");
+  const replayCases = await readRoutingCases(path);
+  const replayed = await Promise.all(replayCases.map((routingCase) => routeRequest(routingCase.request, { provider: "demo" })));
+  assert.equal(replayed.length, 2);
+  assert.ok(replayed.every((decision) => decision.execution.enabled === false));
+});
+
+test("consequential browser action hands off for host approval", async () => {
+  let executeCalls = 0;
+  const result = await runBrowserFastPath({
+    goal: "click the visible action",
+    enabled: true,
+    provider: providerFor(["browser:click:action"]),
+    executor: {
+      async observe() { return { targets: [{ id: "action", name: "Action", clickable: true }] }; },
+      async approve() { return false; },
+      async execute() { executeCalls += 1; return {}; },
+    },
+  });
+  assert.equal(result.status, "handoff");
+  assert.equal(result.reason, "host_confirmation_required");
+  assert.equal(executeCalls, 0);
+});
+
+test("native select uses the optional host select executor", async () => {
+  let selectCalls = 0;
+  let executeCalls = 0;
+  const result = await runBrowserFastPath({
+    goal: "select beta",
+    enabled: true,
+    maxSteps: 1,
+    provider: providerFor(["browser:select:choice:beta"]),
+    executor: {
+      async observe() { return { targets: [{ id: "choice", role: "select", options: [{ id: "beta", label: "Beta" }] }] }; },
+      async approve() { return true; },
+      async select(action) { selectCalls += 1; return { result: { value: action.option_id }, observation: { targets: [] } }; },
+      async execute() { executeCalls += 1; },
+    },
+  });
+  assert.equal(result.reason, "browser_step_budget_exhausted");
+  assert.equal(result.metrics.browser_actions, 1);
+  assert.equal(selectCalls, 1);
+  assert.equal(executeCalls, 0);
+});

package/test/capability.test.mjs

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { discoverCapabilities } from "../src/discovery.mjs";
+import { routeRequest } from "../src/route.mjs";
+
+function discovered() {
+  return discoverCapabilities({
+    skills: [{ id: "skill:inspect", name: "Inspect skill", description: "Inspect work", verified: true }],
+    mcp: [{ id: "mcp:search", name: "Search MCP", description: "Search files" }],
+    cli: [{ id: "cli:git", name: "Git CLI", command: "git", description: "Run git" }],
+    dsh: [{ id: "dsh:worker", name: "Worker DSH", description: "Delegate work" }],
+    subagents: [{ id: "subagent:review", name: "Review subagent", description: "Review code" }],
+    models: [{ id: "model:jev", name: "Jev model", description: "Make bounded decisions" }],
+    tools: [{ id: "tool:read", name: "Read tool", description: "Read files" }],
+  });
+}
+
+test("discovery normalizes skills, MCP, CLI, DSH, subagent, model, and tool candidates", () => {
+  const capabilities = discovered();
+  assert.deepEqual(new Set(capabilities.map((capability) => capability.kind)), new Set(["skill", "mcp", "cli", "dsh", "subagent", "model", "tool"]));
+  assert.equal(capabilities.find((capability) => capability.id === "cli:git").metadata.cli, "git");
+  assert.equal(capabilities.find((capability) => capability.id === "skill:inspect").verified, true);
+});
+
+test("explicit deterministic policy selects one discovered capability before Jev", async () => {
+  let providerCalls = 0;
+  const decision = await routeRequest({
+    intent: "make a bounded model decision",
+    context: { request: "model" },
+    policy: { deterministic: true, prefer_kind: "model", prefer_verified: true },
+  }, {
+    discovery: { models: [{ id: "model:jev", name: "Jev model", description: "Make bounded decisions", verified: true, risk: "low" }] },
+    provider: { name: "must-not-run", async decide() { providerCalls += 1; throw new Error("deterministic route should not call Jev"); } },
+  });
+  assert.equal(providerCalls, 0);
+  assert.equal(decision.status, "selected");
+  assert.equal(decision.selected, "model:jev");
+  assert.equal(decision.receipt.provider, "must-not-run:deterministic");
+  assert.equal(decision.candidates[0].verified, true);
+});
+
+test("availability policy excludes an unavailable discovered capability", async () => {
+  const decision = await routeRequest({
+    intent: "inspect",
+    context: {},
+    policy: { deterministic: true, deterministic_capability_id: "tool:offline" },
+  }, {
+    discovery: { tools: [{ id: "tool:offline", name: "Offline", description: "Unavailable", available: false }] },
+    provider: "demo",
+  });
+  assert.equal(decision.status, "no_decision");
+  assert.equal(decision.candidates[0].filtered, true);
+  assert.equal(decision.candidates[0].filter_reason, "capability unavailable");
+});

package/test/context-filter.test.mjs

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { filterContext } from "../src/relevance-filter.mjs";
+import { projectState } from "../src/context-filter.mjs";
+import { routeRequest } from "../src/route.mjs";
+
+const capabilities = [{ id: "inspect", kind: "tool", name: "Inspect", description: "Inspect the supplied context", risk: "low" }];
+
+function messages() {
+  return [
+    ...Array.from({ length: 10 }, (_, index) => `old unrelated note ${index}`),
+    "Requirement: preserve /workspace/project/config.json exactly",
+    "command: `npm test` failed with exit status 1; Error: fixture failed",
+    "recent worker update",
+  ];
+}
+
+test("shadow mode never mutates context and reports evidence", () => {
+  const context = { messages: messages() };
+  const before = JSON.stringify(context);
+  const result = filterContext(context, { mode: "shadow", recent: 2 });
+  assert.strictEqual(result.context, context);
+  assert.equal(JSON.stringify(context), before);
+  assert.equal(result.report.mode, "shadow");
+  assert.equal(result.report.changed, false);
+  assert.ok(result.report.pinned >= 2);
+});
+
+test("conservative mode drops stale noise but preserves exact evidence", () => {
+  const result = filterContext({ messages: messages() }, { mode: "conservative", recent: 2 });
+  assert.equal(result.report.mode, "conservative");
+  assert.equal(result.report.changed, true);
+  assert.ok(result.report.dropped > 0);
+  assert.ok(result.context.messages.includes("Requirement: preserve /workspace/project/config.json exactly"));
+  assert.ok(result.context.messages.includes("command: `npm test` failed with exit status 1; Error: fixture failed"));
+  assert.ok(!result.context.messages.includes("old unrelated note 0"));
+});
+
+test("route projection applies explicit filtering without losing pinned evidence", async () => {
+  let captured;
+  const decision = await routeRequest({
+    intent: "inspect project state",
+    policy: { context_filter_mode: "conservative" },
+    context: { messages: messages() },
+    capabilities,
+  }, {
+    provider: {
+      name: "context-filter-test-provider",
+      async decide({ state }) {
+        captured = state;
+        return { answers: { tool: { type: "choice", choice: "inspect", probabilities: { inspect: 1 }, confidence: 1 } } };
+      },
+    },
+  });
+  assert.equal(decision.status, "selected");
+  assert.equal(captured.context_filter.mode, "conservative");
+  assert.ok(captured.context.messages.includes("Requirement: preserve /workspace/project/config.json exactly"));
+  assert.ok(captured.context.messages.includes("command: `npm test` failed with exit status 1; Error: fixture failed"));
+});
+
+test("no mode keeps the existing projection contract", () => {
+  const result = projectState({ intent: "inspect", context: { messages: ["plain"] } }, capabilities, 6_000);
+  assert.equal(result.state.context_filter, undefined);
+  assert.deepEqual(result.state.context, { messages: ["plain"] });
+});

package/test/openrouter-provider.test.mjs

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { OpenRouterDecisionsProvider } from "../src/providers/typesafe.mjs";
+
+const candidates = [{
+  id: "search",
+  kind: "mcp",
+  name: "Repository search",
+  description: "Search repository files",
+  risk: "low",
+}];
+
+test("OpenRouter provider sends Decisions Choice payload, not chat completion payload", async () => {
+  let requestUrl;
+  let requestInit;
+  const provider = new OpenRouterDecisionsProvider({
+    apiKey: "test-key",
+    endpoint: "https://openrouter.ai/api/alpha/decisions",
+    model: "typesafe/jev-1.13",
+    fetchImpl: async (url, init) => {
+      requestUrl = url;
+      requestInit = init;
+      return new Response(JSON.stringify({
+        id: "decision-test",
+        model: "typesafe/jev-1.13",
+        provider: "TypeSafe",
+        answers: {
+          tool: {
+            type: "choice",
+            choice: "search",
+            probabilities: { search: 1 },
+            confidence: 1,
+          },
+        },
+        usage: { input_tokens: 10, output_tokens: 2, cost: 0.000001 },
+      }), { status: 200, headers: { "content-type": "application/json" } });
+    },
+  });
+
+  const raw = await provider.decide({
+    state: { intent: "Search repository files" },
+    candidates,
+  });
+  const body = JSON.parse(requestInit.body);
+  assert.equal(requestUrl, "https://openrouter.ai/api/alpha/decisions");
+  assert.equal(requestInit.method, "POST");
+  assert.equal(requestInit.headers.Authorization, "Bearer test-key");
+  assert.equal(body.model, "typesafe/jev-1.13");
+  assert.equal(body.questions.tool.type, "choice");
+  assert.equal(body.questions.tool.criteria.search.description, "Search repository files");
+  assert.deepEqual(body.state, { intent: "Search repository files" });
+  assert.equal("messages" in body, false);
+  assert.equal(raw.answers.tool.choice, "search");
+  assert.equal(raw.usage.cost, 0.000001);
+});