jev-layer 0.1.0 → 0.2.0

package/scripts/browser-e2e.mjs

@@ -1,117 +1,117 @@
-import assert from "node:assert/strict";
-import { mkdtemp, readFile } from "node:fs/promises";
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const casesPath = join(await mkdtemp(join(tmpdir(), "jev-browser-e2e-")), "cases.jsonl");
-const child = spawn(process.env.JEV_NODE ?? "node", [resolve(root, "src/mcp-server.mjs")], {
-  cwd: root,
-  env: { ...process.env, JEV_BROWSER_FAST_PATH: "1", JEV_REPLAY_CASES: casesPath },
-  stdio: ["pipe", "pipe", "pipe"],
-});
-const lines = createInterface({ input: child.stdout });
-const pending = new Map();
-lines.on("line", (line) => {
-  if (!line.trim()) return;
-  const message = JSON.parse(line);
-  const waiter = pending.get(message.id);
-  if (waiter) {
-    pending.delete(message.id);
-    waiter(message);
-  }
-});
-
-try {
-  const initialized = await request(1, "initialize", {});
-  assert.equal(initialized.result.serverInfo.name, "jev-layer");
-  await notification("notifications/initialized", {});
-  const listed = await request(2, "tools/list", {});
-  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_browser_step"));
-
-  const routed = await request(3, "tools/call", {
-    name: "jev_browser_step",
-    arguments: {
-      provider: process.env.JEV_BROWSER_PROVIDER ?? "demo",
-      enabled: true,
-      harness: "browser-e2e",
-      goal: "scroll the page downward",
-      observation: {
-        url: "https://example.test",
-        title: "Fixture",
-        visible_text: "Additional content is below the fold",
-        scroll: { up: false, down: true },
-        targets: [],
-        tabs: [],
-      },
-      policy: { min_confidence: 0 },
-    },
-  });
-  const decision = routed.result.structuredContent;
-  assert.equal(decision.status, "selected");
-  assert.equal(decision.browser_action.operation, "scroll");
-  assert.equal(decision.browser_action.target_id, null);
-
-  const started = performance.now();
-  const hostResult = { operation: decision.browser_action.operation, direction: "down", fixture: true };
-  const recorded = await request(4, "tools/call", {
-    name: "jev_record_execution",
-    arguments: {
-      correlation_id: decision.correlation_id,
-      harness: "browser-e2e",
-      capability_id: decision.selected,
-      status: "completed",
-      result: hostResult,
-      browser: { operation: "scroll", direction: "down", executed: true },
-      exit_status: 0,
-      duration_ms: Number((performance.now() - started).toFixed(3)),
-    },
-  });
-  const receipt = recorded.result.structuredContent;
-  assert.equal(receipt.correlation_id, decision.correlation_id);
-  assert.equal(receipt.host.browser.operation, "scroll");
-  assert.equal(receipt.host.exit_status, 0);
-
-  const records = (await readFile(casesPath, "utf8")).trim().split(/\r?\n/).map(JSON.parse);
-  assert.deepEqual(records.map((record) => record.record_type), ["routing_case", "execution_receipt"]);
-  assert.equal(records[0].request.context.browser.goal, "scroll the page downward");
-  console.log(JSON.stringify({
-    ok: true,
-    cases_path: casesPath,
-    decision: {
-      correlation_id: decision.correlation_id,
-      selected: decision.selected,
-      operation: decision.browser_action.operation,
-      confidence: decision.confidence,
-      latency_ms: decision.receipt.latency_ms,
-      cost_usd: decision.receipt.cost_usd ?? null,
-    },
-    host_execution: { operation: hostResult.operation, exit_status: receipt.host.exit_status },
-    receipts: records.length,
-  }, null, 2));
-} finally {
-  child.kill();
-  await new Promise((resolveExit) => child.once("close", resolveExit));
-}
-
-function request(id, method, params) {
-  return new Promise((resolveResponse, reject) => {
-    const timer = setTimeout(() => {
-      pending.delete(id);
-      reject(new Error(`MCP request timed out: ${method}`));
-    }, 15_000);
-    pending.set(id, (message) => {
-      clearTimeout(timer);
-      resolveResponse(message);
-    });
-    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
-  });
-}
-
-function notification(method, params) {
-  child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
-  return new Promise((resolveNotification) => setImmediate(resolveNotification));
-}
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const casesPath = join(await mkdtemp(join(tmpdir(), "jev-browser-e2e-")), "cases.jsonl");
+const child = spawn(process.env.JEV_NODE ?? "node", [resolve(root, "src/mcp-server.mjs")], {
+  cwd: root,
+  env: { ...process.env, JEV_BROWSER_FAST_PATH: "1", JEV_REPLAY_CASES: casesPath },
+  stdio: ["pipe", "pipe", "pipe"],
+});
+const lines = createInterface({ input: child.stdout });
+const pending = new Map();
+lines.on("line", (line) => {
+  if (!line.trim()) return;
+  const message = JSON.parse(line);
+  const waiter = pending.get(message.id);
+  if (waiter) {
+    pending.delete(message.id);
+    waiter(message);
+  }
+});
+
+try {
+  const initialized = await request(1, "initialize", {});
+  assert.equal(initialized.result.serverInfo.name, "jev-layer");
+  await notification("notifications/initialized", {});
+  const listed = await request(2, "tools/list", {});
+  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_browser_step"));
+
+  const routed = await request(3, "tools/call", {
+    name: "jev_browser_step",
+    arguments: {
+      provider: process.env.JEV_BROWSER_PROVIDER ?? "demo",
+      enabled: true,
+      harness: "browser-e2e",
+      goal: "scroll the page downward",
+      observation: {
+        url: "https://example.test",
+        title: "Fixture",
+        visible_text: "Additional content is below the fold",
+        scroll: { up: false, down: true },
+        targets: [],
+        tabs: [],
+      },
+      policy: { min_confidence: 0 },
+    },
+  });
+  const decision = routed.result.structuredContent;
+  assert.equal(decision.status, "selected");
+  assert.equal(decision.browser_action.operation, "scroll");
+  assert.equal(decision.browser_action.target_id, null);
+
+  const started = performance.now();
+  const hostResult = { operation: decision.browser_action.operation, direction: "down", fixture: true };
+  const recorded = await request(4, "tools/call", {
+    name: "jev_record_execution",
+    arguments: {
+      correlation_id: decision.correlation_id,
+      harness: "browser-e2e",
+      capability_id: decision.selected,
+      status: "completed",
+      result: hostResult,
+      browser: { operation: "scroll", direction: "down", executed: true },
+      exit_status: 0,
+      duration_ms: Number((performance.now() - started).toFixed(3)),
+    },
+  });
+  const receipt = recorded.result.structuredContent;
+  assert.equal(receipt.correlation_id, decision.correlation_id);
+  assert.equal(receipt.host.browser.operation, "scroll");
+  assert.equal(receipt.host.exit_status, 0);
+
+  const records = (await readFile(casesPath, "utf8")).trim().split(/\r?\n/).map(JSON.parse);
+  assert.deepEqual(records.map((record) => record.record_type), ["routing_case", "execution_receipt"]);
+  assert.equal(records[0].request.context.browser.goal, "scroll the page downward");
+  console.log(JSON.stringify({
+    ok: true,
+    cases_path: casesPath,
+    decision: {
+      correlation_id: decision.correlation_id,
+      selected: decision.selected,
+      operation: decision.browser_action.operation,
+      confidence: decision.confidence,
+      latency_ms: decision.receipt.latency_ms,
+      cost_usd: decision.receipt.cost_usd ?? null,
+    },
+    host_execution: { operation: hostResult.operation, exit_status: receipt.host.exit_status },
+    receipts: records.length,
+  }, null, 2));
+} finally {
+  child.kill();
+  await new Promise((resolveExit) => child.once("close", resolveExit));
+}
+
+function request(id, method, params) {
+  return new Promise((resolveResponse, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`MCP request timed out: ${method}`));
+    }, 15_000);
+    pending.set(id, (message) => {
+      clearTimeout(timer);
+      resolveResponse(message);
+    });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+  });
+}
+
+function notification(method, params) {
+  child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  return new Promise((resolveNotification) => setImmediate(resolveNotification));
+}

package/scripts/capability-e2e.mjs

@@ -1,31 +1,31 @@
-import assert from "node:assert/strict";
-import { routeRequest } from "../src/route.mjs";
-
-let providerCalls = 0;
-const decision = await routeRequest({
-  harness: "capability-e2e",
-  intent: "use the verified model for a bounded decision",
-  context: { task: "model" },
-  policy: { deterministic: true, prefer_kind: "model", prefer_verified: true },
-}, {
-  discovery: {
-    skills: [{ id: "skill:inspect", name: "Inspect skill", description: "Inspect context" }],
-    models: [{ id: "model:verified", name: "Verified model", description: "Make bounded decisions", verified: true, risk: "low", source: "e2e-manifest" }],
-    tools: [{ id: "tool:offline", name: "Offline tool", description: "Unavailable", available: false }],
-  },
-  provider: { name: "capability-e2e-provider", async decide() { providerCalls += 1; throw new Error("deterministic selection should not call Jev"); } },
-});
-assert.equal(providerCalls, 0);
-assert.equal(decision.status, "selected");
-assert.equal(decision.selected, "model:verified");
-assert.equal(decision.candidates.find((candidate) => candidate.id === "model:verified").source, "e2e-manifest");
-assert.equal(decision.candidates.find((candidate) => candidate.id === "model:verified").verified, true);
-console.log(JSON.stringify({
-  ok: true,
-  status: decision.status,
-  selected: decision.selected,
-  provider: decision.receipt.provider,
-  deterministic: true,
-  jev_calls: providerCalls,
-  candidate_metadata: decision.candidates.find((candidate) => candidate.id === decision.selected),
-}, null, 2));
+import assert from "node:assert/strict";
+import { routeRequest } from "../src/route.mjs";
+
+let providerCalls = 0;
+const decision = await routeRequest({
+  harness: "capability-e2e",
+  intent: "use the verified model for a bounded decision",
+  context: { task: "model" },
+  policy: { deterministic: true, prefer_kind: "model", prefer_verified: true },
+}, {
+  discovery: {
+    skills: [{ id: "skill:inspect", name: "Inspect skill", description: "Inspect context" }],
+    models: [{ id: "model:verified", name: "Verified model", description: "Make bounded decisions", verified: true, risk: "low", source: "e2e-manifest" }],
+    tools: [{ id: "tool:offline", name: "Offline tool", description: "Unavailable", available: false }],
+  },
+  provider: { name: "capability-e2e-provider", async decide() { providerCalls += 1; throw new Error("deterministic selection should not call Jev"); } },
+});
+assert.equal(providerCalls, 0);
+assert.equal(decision.status, "selected");
+assert.equal(decision.selected, "model:verified");
+assert.equal(decision.candidates.find((candidate) => candidate.id === "model:verified").source, "e2e-manifest");
+assert.equal(decision.candidates.find((candidate) => candidate.id === "model:verified").verified, true);
+console.log(JSON.stringify({
+  ok: true,
+  status: decision.status,
+  selected: decision.selected,
+  provider: decision.receipt.provider,
+  deterministic: true,
+  jev_calls: providerCalls,
+  candidate_metadata: decision.candidates.find((candidate) => candidate.id === decision.selected),
+}, null, 2));

package/scripts/clean-install-smoke.mjs

@@ -1,162 +1,162 @@
-import assert from "node:assert/strict";
-import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { execFile, spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { delimiter, dirname, join, resolve } from "node:path";
-import { promisify } from "node:util";
-import { tmpdir } from "node:os";
-
-const execFileAsync = promisify(execFile);
-const sourceRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const stage = await mkdtemp(join(tmpdir(), "jev-clean-install-"));
-const packageRoot = join(stage, "package");
-const workspace = join(stage, "workspace");
-
-try {
-  await copyDistribution(packageRoot);
-  await execFileAsync("npm", ["install", "--ignore-scripts", "--no-audit", "--no-fund"], { cwd: packageRoot, env: process.env });
-  await mkdir(workspace, { recursive: true });
-  await writeFile(join(workspace, "package.json"), JSON.stringify({ name: "clean-install-workspace", private: true }, null, 2) + "\n", "utf8");
-  await execFileAsync("npm", ["install", "--ignore-scripts", "--no-audit", "--no-fund", "--no-save", packageRoot], { cwd: workspace, env: process.env });
-  await runNode(packageRoot, ["bin/jev.mjs", "install", "--project", workspace]);
-  await runNode(packageRoot, ["bin/jev.mjs", "add", "generic", "--project", workspace]);
-  const doctor = await runNode(packageRoot, ["bin/jev.mjs", "doctor", "--project", workspace]);
-  const doctorReport = JSON.parse(doctor.stdout);
-  assert.equal(doctorReport.ok, true);
-
-  const cli = await runJev(workspace, ["cli", "--provider", "demo", "--input", join(packageRoot, "examples", "route-request.json")]);
-  const cliDecision = JSON.parse(cli.stdout.trim().split(/\r?\n/).at(-1));
-  assert.equal(cliDecision.execution.enabled, false);
-  assert.ok(cliDecision.correlation_id);
-
-  const genericConfig = JSON.parse(await readFile(join(workspace, ".jev", "adapters", "generic.json"), "utf8"));
-  const genericServer = genericConfig.mcpServers.jev;
-  assert.deepEqual(genericServer.args, ["mcp"]);
-  const mcpEnv = localEnv(workspace);
-  const mcp = spawn(genericServer.command, genericServer.args, {
-    cwd: workspace,
-    env: { ...mcpEnv, JEV_LAYER_PROVIDER: "demo", JEV_REPLAY_CASES: join(workspace, ".jev", "replay", "cases.jsonl") },
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-  const pending = new Map();
-  let nextId = 1;
-  const stderr = [];
-  let buffer = "";
-  mcp.stderr.on("data", (chunk) => stderr.push(String(chunk)));
-  mcp.stdout.on("data", (chunk) => {
-    buffer += String(chunk);
-    for (const line of buffer.split(/\r?\n/).slice(0, -1)) {
-      if (!line.trim()) continue;
-      const message = JSON.parse(line);
-      pending.get(message.id)?.(message);
-      pending.delete(message.id);
-    }
-    buffer = buffer.split(/\r?\n/).at(-1) ?? "";
-  });
-
-  const request = (method, params) => new Promise((resolveRequest, reject) => {
-    const id = nextId++;
-    pending.set(id, resolveRequest);
-    mcp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
-    setTimeout(() => {
-      if (pending.delete(id)) reject(new Error(`timeout waiting for ${method}`));
-    }, 10_000).unref();
-  });
-  const notify = (method, params) => mcp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
-
-  const initialized = await request("initialize", {});
-  assert.equal(initialized.result.serverInfo.name, "jev-layer");
-  notify("notifications/initialized", {});
-  const listed = await request("tools/list", {});
-  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_route"));
-  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_record_execution"));
-  const routed = await request("tools/call", {
-    name: "jev_route",
-    arguments: {
-      harness: "clean-install",
-      intent: "read the installed package manifest",
-      actor_permissions: ["read"],
-      capabilities: [{
-        id: "read_manifest",
-        kind: "tool",
-        name: "Read package manifest",
-        description: "Read package.json without changing files",
-        permissions: ["read"],
-        risk: "low",
-      }],
-    },
-  });
-  const decision = routed.result.structuredContent;
-  assert.equal(decision.status, "selected");
-  const hostResult = await readFile(join(packageRoot, "package.json"), "utf8");
-  const recorded = await request("tools/call", {
-    name: "jev_record_execution",
-    arguments: {
-      correlation_id: decision.correlation_id,
-      harness: "clean-install",
-      capability_id: decision.selected,
-      status: "completed",
-      result: { bytes: Buffer.byteLength(hostResult) },
-      exit_status: 0,
-      duration_ms: 1,
-    },
-  });
-  const receipt = recorded.result.structuredContent;
-  assert.equal(receipt.correlation_id, decision.correlation_id);
-  assert.equal(receipt.host.exit_status, 0);
-  assert.equal(receipt.host.duration_ms, 1);
-  mcp.stdin.end();
-  await onceExit(mcp);
-  assert.equal(stderr.join(""), "");
-
-  const records = (await readFile(join(workspace, ".jev", "replay", "cases.jsonl"), "utf8"))
-    .trim().split(/\r?\n/).map((line) => JSON.parse(line));
-  assert.equal(records.length, 2);
-  assert.deepEqual(records.map((record) => record.record_type), ["routing_case", "execution_receipt"]);
-  assert.equal(records[0].correlation_id, records[1].correlation_id);
-  const replay = await runNode(packageRoot, ["scripts/replay-eval.mjs", "--provider", "demo", "--input", join(workspace, ".jev", "replay", "cases.jsonl"), "--limit", "1"]);
-  const replayReport = JSON.parse(replay.stdout);
-  assert.equal(replayReport.replayed_cases, 1);
-  assert.equal(replayReport.host_execution_calls, 0);
-  console.log(JSON.stringify({
-    ok: true,
-    stage,
-    package_root: packageRoot,
-    workspace,
-    install: "npm install",
-    cli: { status: cliDecision.status, correlation_id: cliDecision.correlation_id },
-    mcp: { tools: listed.result.tools.map((tool) => tool.name), selected: decision.selected, host_exit_status: receipt.host.exit_status },
-    receipts: records.length,
-    replay_cases: records.filter((record) => record.record_type === "routing_case").length,
-    replay: { replayed_cases: replayReport.replayed_cases, host_execution_calls: replayReport.host_execution_calls },
-  }, null, 2));
-} finally {
-  await rm(stage, { recursive: true, force: true });
-}
-
-async function copyDistribution(destination) {
-  const entries = ["bin", "config", "examples", "integrations", "scripts", "src", "test", "README.md", "package.json", "package-lock.json"];
-  for (const entry of entries) await cp(join(sourceRoot, entry), join(destination, entry), { recursive: true });
-}
-
-function runNode(cwd, args) {
-  return execFileAsync(process.execPath, args, { cwd, env: process.env, maxBuffer: 2 * 1024 * 1024 });
-}
-
-function runJev(cwd, args) {
-  return execFileAsync("jev", args, { cwd, env: localEnv(cwd), maxBuffer: 2 * 1024 * 1024 });
-}
-
-function localEnv(workspaceRoot) {
-  return {
-    ...process.env,
-    PATH: `${join(workspaceRoot, "node_modules", ".bin")}${delimiter}${process.env.PATH ?? ""}`,
-  };
-}
-
-function onceExit(child) {
-  return new Promise((resolveExit, reject) => {
-    child.once("error", reject);
-    child.once("close", (code) => code === 0 ? resolveExit() : reject(new Error(`MCP exited with ${code}`)));
-  });
-}
+import assert from "node:assert/strict";
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { tmpdir } from "node:os";
+
+const execFileAsync = promisify(execFile);
+const sourceRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const stage = await mkdtemp(join(tmpdir(), "jev-clean-install-"));
+const packageRoot = join(stage, "package");
+const workspace = join(stage, "workspace");
+
+try {
+  await copyDistribution(packageRoot);
+  await execFileAsync("npm", ["install", "--ignore-scripts", "--no-audit", "--no-fund"], { cwd: packageRoot, env: process.env });
+  await mkdir(workspace, { recursive: true });
+  await writeFile(join(workspace, "package.json"), JSON.stringify({ name: "clean-install-workspace", private: true }, null, 2) + "\n", "utf8");
+  await execFileAsync("npm", ["install", "--ignore-scripts", "--no-audit", "--no-fund", "--no-save", packageRoot], { cwd: workspace, env: process.env });
+  await runNode(packageRoot, ["bin/jev.mjs", "install", "--project", workspace]);
+  await runNode(packageRoot, ["bin/jev.mjs", "add", "generic", "--project", workspace]);
+  const doctor = await runNode(packageRoot, ["bin/jev.mjs", "doctor", "--project", workspace]);
+  const doctorReport = JSON.parse(doctor.stdout);
+  assert.equal(doctorReport.ok, true);
+
+  const cli = await runJev(workspace, ["cli", "--provider", "demo", "--input", join(packageRoot, "examples", "route-request.json")]);
+  const cliDecision = JSON.parse(cli.stdout.trim().split(/\r?\n/).at(-1));
+  assert.equal(cliDecision.execution.enabled, false);
+  assert.ok(cliDecision.correlation_id);
+
+  const genericConfig = JSON.parse(await readFile(join(workspace, ".jev", "adapters", "generic.json"), "utf8"));
+  const genericServer = genericConfig.mcpServers.jev;
+  assert.deepEqual(genericServer.args, ["mcp"]);
+  const mcpEnv = localEnv(workspace);
+  const mcp = spawn(genericServer.command, genericServer.args, {
+    cwd: workspace,
+    env: { ...mcpEnv, JEV_LAYER_PROVIDER: "demo", JEV_REPLAY_CASES: join(workspace, ".jev", "replay", "cases.jsonl") },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const pending = new Map();
+  let nextId = 1;
+  const stderr = [];
+  let buffer = "";
+  mcp.stderr.on("data", (chunk) => stderr.push(String(chunk)));
+  mcp.stdout.on("data", (chunk) => {
+    buffer += String(chunk);
+    for (const line of buffer.split(/\r?\n/).slice(0, -1)) {
+      if (!line.trim()) continue;
+      const message = JSON.parse(line);
+      pending.get(message.id)?.(message);
+      pending.delete(message.id);
+    }
+    buffer = buffer.split(/\r?\n/).at(-1) ?? "";
+  });
+
+  const request = (method, params) => new Promise((resolveRequest, reject) => {
+    const id = nextId++;
+    pending.set(id, resolveRequest);
+    mcp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    setTimeout(() => {
+      if (pending.delete(id)) reject(new Error(`timeout waiting for ${method}`));
+    }, 10_000).unref();
+  });
+  const notify = (method, params) => mcp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+
+  const initialized = await request("initialize", {});
+  assert.equal(initialized.result.serverInfo.name, "jev-layer");
+  notify("notifications/initialized", {});
+  const listed = await request("tools/list", {});
+  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_route"));
+  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_record_execution"));
+  const routed = await request("tools/call", {
+    name: "jev_route",
+    arguments: {
+      harness: "clean-install",
+      intent: "read the installed package manifest",
+      actor_permissions: ["read"],
+      capabilities: [{
+        id: "read_manifest",
+        kind: "tool",
+        name: "Read package manifest",
+        description: "Read package.json without changing files",
+        permissions: ["read"],
+        risk: "low",
+      }],
+    },
+  });
+  const decision = routed.result.structuredContent;
+  assert.equal(decision.status, "selected");
+  const hostResult = await readFile(join(packageRoot, "package.json"), "utf8");
+  const recorded = await request("tools/call", {
+    name: "jev_record_execution",
+    arguments: {
+      correlation_id: decision.correlation_id,
+      harness: "clean-install",
+      capability_id: decision.selected,
+      status: "completed",
+      result: { bytes: Buffer.byteLength(hostResult) },
+      exit_status: 0,
+      duration_ms: 1,
+    },
+  });
+  const receipt = recorded.result.structuredContent;
+  assert.equal(receipt.correlation_id, decision.correlation_id);
+  assert.equal(receipt.host.exit_status, 0);
+  assert.equal(receipt.host.duration_ms, 1);
+  mcp.stdin.end();
+  await onceExit(mcp);
+  assert.equal(stderr.join(""), "");
+
+  const records = (await readFile(join(workspace, ".jev", "replay", "cases.jsonl"), "utf8"))
+    .trim().split(/\r?\n/).map((line) => JSON.parse(line));
+  assert.equal(records.length, 2);
+  assert.deepEqual(records.map((record) => record.record_type), ["routing_case", "execution_receipt"]);
+  assert.equal(records[0].correlation_id, records[1].correlation_id);
+  const replay = await runNode(packageRoot, ["scripts/replay-eval.mjs", "--provider", "demo", "--input", join(workspace, ".jev", "replay", "cases.jsonl"), "--limit", "1"]);
+  const replayReport = JSON.parse(replay.stdout);
+  assert.equal(replayReport.replayed_cases, 1);
+  assert.equal(replayReport.host_execution_calls, 0);
+  console.log(JSON.stringify({
+    ok: true,
+    stage,
+    package_root: packageRoot,
+    workspace,
+    install: "npm install",
+    cli: { status: cliDecision.status, correlation_id: cliDecision.correlation_id },
+    mcp: { tools: listed.result.tools.map((tool) => tool.name), selected: decision.selected, host_exit_status: receipt.host.exit_status },
+    receipts: records.length,
+    replay_cases: records.filter((record) => record.record_type === "routing_case").length,
+    replay: { replayed_cases: replayReport.replayed_cases, host_execution_calls: replayReport.host_execution_calls },
+  }, null, 2));
+} finally {
+  await rm(stage, { recursive: true, force: true });
+}
+
+async function copyDistribution(destination) {
+  const entries = ["bin", "config", "examples", "integrations", "scripts", "src", "test", "README.md", "package.json", "package-lock.json"];
+  for (const entry of entries) await cp(join(sourceRoot, entry), join(destination, entry), { recursive: true });
+}
+
+function runNode(cwd, args) {
+  return execFileAsync(process.execPath, args, { cwd, env: process.env, maxBuffer: 2 * 1024 * 1024 });
+}
+
+function runJev(cwd, args) {
+  return execFileAsync("jev", args, { cwd, env: localEnv(cwd), maxBuffer: 2 * 1024 * 1024 });
+}
+
+function localEnv(workspaceRoot) {
+  return {
+    ...process.env,
+    PATH: `${join(workspaceRoot, "node_modules", ".bin")}${delimiter}${process.env.PATH ?? ""}`,
+  };
+}
+
+function onceExit(child) {
+  return new Promise((resolveExit, reject) => {
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolveExit() : reject(new Error(`MCP exited with ${code}`)));
+  });
+}