jev-layer 0.1.0 → 0.3.0

package/scripts/context-filter-e2e.mjs

@@ -1,45 +1,45 @@
-import assert from "node:assert/strict";
-import { routeRequest } from "../src/route.mjs";
-
-const messages = [
-  ...Array.from({ length: 12 }, (_, index) => `stale unrelated worker note ${index}`),
-  "Requirement: preserve /workspace/project/config.json exactly",
-  "Error: command `npm test` failed with exit status 1",
-  "recent worker state",
-];
-const context = { messages };
-const before = JSON.stringify(context);
-let projected;
-const decision = await routeRequest({
-  harness: "context-filter-e2e",
-  intent: "inspect project state",
-  context,
-  policy: { context_filter_mode: "conservative" },
-  capabilities: [{ id: "inspect", kind: "tool", name: "Inspect", description: "Inspect context", risk: "low" }],
-}, {
-  provider: {
-    name: "context-filter-e2e-provider",
-    async decide({ state }) {
-      projected = state;
-      return { answers: { tool: { type: "choice", choice: "inspect", probabilities: { inspect: 1 }, confidence: 1 } } };
-    },
-  },
-});
-assert.equal(decision.status, "selected");
-assert.equal(projected.context_filter.mode, "conservative");
-assert.ok(projected.context_filter.dropped > 0);
-assert.ok(projected.context.messages.includes("Requirement: preserve /workspace/project/config.json exactly"));
-assert.ok(projected.context.messages.includes("Error: command `npm test` failed with exit status 1"));
-assert.equal(JSON.stringify(context), before);
-console.log(JSON.stringify({
-  ok: true,
-  status: decision.status,
-  mode: projected.context_filter.mode,
-  kept: projected.context_filter.kept,
-  dropped: projected.context_filter.dropped,
-  pinned: projected.context_filter.pinned,
-  preserved: [
-    projected.context.messages.includes("Requirement: preserve /workspace/project/config.json exactly"),
-    projected.context.messages.includes("Error: command `npm test` failed with exit status 1"),
-  ],
-}, null, 2));
+import assert from "node:assert/strict";
+import { routeRequest } from "../src/route.mjs";
+
+const messages = [
+  ...Array.from({ length: 12 }, (_, index) => `stale unrelated worker note ${index}`),
+  "Requirement: preserve /workspace/project/config.json exactly",
+  "Error: command `npm test` failed with exit status 1",
+  "recent worker state",
+];
+const context = { messages };
+const before = JSON.stringify(context);
+let projected;
+const decision = await routeRequest({
+  harness: "context-filter-e2e",
+  intent: "inspect project state",
+  context,
+  policy: { context_filter_mode: "conservative" },
+  capabilities: [{ id: "inspect", kind: "tool", name: "Inspect", description: "Inspect context", risk: "low" }],
+}, {
+  provider: {
+    name: "context-filter-e2e-provider",
+    async decide({ state }) {
+      projected = state;
+      return { answers: { tool: { type: "choice", choice: "inspect", probabilities: { inspect: 1 }, confidence: 1 } } };
+    },
+  },
+});
+assert.equal(decision.status, "selected");
+assert.equal(projected.context_filter.mode, "conservative");
+assert.ok(projected.context_filter.dropped > 0);
+assert.ok(projected.context.messages.includes("Requirement: preserve /workspace/project/config.json exactly"));
+assert.ok(projected.context.messages.includes("Error: command `npm test` failed with exit status 1"));
+assert.equal(JSON.stringify(context), before);
+console.log(JSON.stringify({
+  ok: true,
+  status: decision.status,
+  mode: projected.context_filter.mode,
+  kept: projected.context_filter.kept,
+  dropped: projected.context_filter.dropped,
+  pinned: projected.context_filter.pinned,
+  preserved: [
+    projected.context.messages.includes("Requirement: preserve /workspace/project/config.json exactly"),
+    projected.context.messages.includes("Error: command `npm test` failed with exit status 1"),
+  ],
+}, null, 2));

package/scripts/fail-open-smoke.mjs

@@ -1,120 +1,120 @@
-import assert from "node:assert/strict";
-import { routeRequest } from "../src/route.mjs";
-
-const candidates = [
-  {
-    id: "read_manifest",
-    name: "read",
-    kind: "tool",
-    description: "Read the repository package manifest without modifying it.",
-    execution: { mode: "native", target: "read" },
-    permissions: ["read"],
-    risk: "low",
-  },
-  {
-    id: "read_route",
-    name: "read",
-    kind: "tool",
-    description: "Read the routing implementation without modifying it.",
-    execution: { mode: "native", target: "read" },
-    permissions: ["read"],
-    risk: "low",
-  },
-];
-
-const request = {
-  intent: "inspect repository metadata",
-  harness: "fail-open-smoke",
-  context: { workspace: "jev-layer", operation: "read-only" },
-  actor_permissions: ["read"],
-  capabilities: candidates,
-};
-
-const originalEnabled = process.env.JEV_LAYER_ENABLED;
-const disabled = await withEnv("JEV_LAYER_ENABLED", "0", () => routeRequest(request, { provider: "openrouter" }));
-restoreEnv("JEV_LAYER_ENABLED", originalEnabled);
-assert.equal(disabled.status, "fallback");
-assert.equal(disabled.fallback.type, "disabled");
-assert.equal(disabled.execution.enabled, false);
-
-const unavailable = await routeRequest(request, {
-  provider: "openrouter",
-  openrouter: {
-    apiKey: "smoke-token",
-    endpoint: "http://127.0.0.1:1/unavailable",
-    timeoutMs: 100,
-  },
-});
-assert.equal(unavailable.status, "fallback");
-assert.equal(unavailable.fallback.type, "provider_error");
-assert.equal(unavailable.execution.enabled, false);
-
-const noDecision = await routeRequest({
-  ...request,
-  capabilities: candidates.map((candidate) => ({
-    ...candidate,
-    availability: { available: false, reason: "host capability intentionally unavailable" },
-  })),
-}, { provider: "demo" });
-assert.equal(noDecision.status, "no_decision");
-assert.equal(noDecision.execution.enabled, false);
-
-const lowConfidence = await routeRequest(request, {
-  provider: {
-    name: "low-confidence-smoke-provider",
-    async decide() {
-      return {
-        answers: {
-          tool: {
-            type: "choice",
-            choice: "read_manifest",
-            probabilities: { read_manifest: 0.51, read_route: 0.49 },
-            confidence: 0.51,
-          },
-        },
-      };
-    },
-  },
-  policy: { min_confidence: 0.8 },
-});
-assert.equal(lowConfidence.status, "fallback");
-assert.equal(lowConfidence.fallback.type, "low_confidence");
-assert.equal(lowConfidence.selected, "read_manifest");
-assert.equal(lowConfidence.execution.enabled, false);
-
-console.log(JSON.stringify({
-  ok: true,
-  scenarios: [
-    summarize("disabled", disabled),
-    summarize("provider_unavailable", unavailable),
-    summarize("no_decision", noDecision),
-    summarize("low_confidence", lowConfidence),
-  ],
-}, null, 2));
-
-async function withEnv(name, value, operation) {
-  const previous = process.env[name];
-  process.env[name] = value;
-  try {
-    return await operation();
-  } finally {
-    restoreEnv(name, previous);
-  }
-}
-
-function restoreEnv(name, value) {
-  if (value === undefined) delete process.env[name];
-  else process.env[name] = value;
-}
-
-function summarize(name, result) {
-  return {
-    name,
-    status: result.status,
-    selected: result.selected,
-    fallback: result.fallback?.type ?? null,
-    confidence: result.confidence ?? null,
-    latency_ms: result.latency_ms,
-    execution: result.execution,
-  };
-}
+import assert from "node:assert/strict";
+import { routeRequest } from "../src/route.mjs";
+
+const candidates = [
+  {
+    id: "read_manifest",
+    name: "read",
+    kind: "tool",
+    description: "Read the repository package manifest without modifying it.",
+    execution: { mode: "native", target: "read" },
+    permissions: ["read"],
+    risk: "low",
+  },
+  {
+    id: "read_route",
+    name: "read",
+    kind: "tool",
+    description: "Read the routing implementation without modifying it.",
+    execution: { mode: "native", target: "read" },
+    permissions: ["read"],
+    risk: "low",
+  },
+];
+
+const request = {
+  intent: "inspect repository metadata",
+  harness: "fail-open-smoke",
+  context: { workspace: "jev-layer", operation: "read-only" },
+  actor_permissions: ["read"],
+  capabilities: candidates,
+};
+
+const originalEnabled = process.env.JEV_LAYER_ENABLED;
+const disabled = await withEnv("JEV_LAYER_ENABLED", "0", () => routeRequest(request, { provider: "openrouter" }));
+restoreEnv("JEV_LAYER_ENABLED", originalEnabled);
+assert.equal(disabled.status, "fallback");
+assert.equal(disabled.fallback.type, "disabled");
+assert.equal(disabled.execution.enabled, false);
+
+const unavailable = await routeRequest(request, {
+  provider: "openrouter",
+  openrouter: {
+    apiKey: "smoke-token",
+    endpoint: "http://127.0.0.1:1/unavailable",
+    timeoutMs: 100,
+  },
+});
+assert.equal(unavailable.status, "fallback");
+assert.equal(unavailable.fallback.type, "provider_error");
+assert.equal(unavailable.execution.enabled, false);
+
+const noDecision = await routeRequest({
+  ...request,
+  capabilities: candidates.map((candidate) => ({
+    ...candidate,
+    availability: { available: false, reason: "host capability intentionally unavailable" },
+  })),
+}, { provider: "demo" });
+assert.equal(noDecision.status, "no_decision");
+assert.equal(noDecision.execution.enabled, false);
+
+const lowConfidence = await routeRequest(request, {
+  provider: {
+    name: "low-confidence-smoke-provider",
+    async decide() {
+      return {
+        answers: {
+          tool: {
+            type: "choice",
+            choice: "read_manifest",
+            probabilities: { read_manifest: 0.51, read_route: 0.49 },
+            confidence: 0.51,
+          },
+        },
+      };
+    },
+  },
+  policy: { min_confidence: 0.8 },
+});
+assert.equal(lowConfidence.status, "fallback");
+assert.equal(lowConfidence.fallback.type, "low_confidence");
+assert.equal(lowConfidence.selected, "read_manifest");
+assert.equal(lowConfidence.execution.enabled, false);
+
+console.log(JSON.stringify({
+  ok: true,
+  scenarios: [
+    summarize("disabled", disabled),
+    summarize("provider_unavailable", unavailable),
+    summarize("no_decision", noDecision),
+    summarize("low_confidence", lowConfidence),
+  ],
+}, null, 2));
+
+async function withEnv(name, value, operation) {
+  const previous = process.env[name];
+  process.env[name] = value;
+  try {
+    return await operation();
+  } finally {
+    restoreEnv(name, previous);
+  }
+}
+
+function restoreEnv(name, value) {
+  if (value === undefined) delete process.env[name];
+  else process.env[name] = value;
+}
+
+function summarize(name, result) {
+  return {
+    name,
+    status: result.status,
+    selected: result.selected,
+    fallback: result.fallback?.type ?? null,
+    confidence: result.confidence ?? null,
+    latency_ms: result.latency_ms,
+    execution: result.execution,
+  };
+}

package/scripts/feature-flags-smoke.mjs

@@ -1,46 +1,46 @@
-import assert from "node:assert/strict";
-import { loadConfig } from "../src/config.mjs";
-import { decideBrowserStep } from "../src/browser.mjs";
-import { routeRequest } from "../src/route.mjs";
-import { superviseWork } from "../src/supervision.mjs";
-
-const { config } = await loadConfig({ cwd: "/tmp/jev-no-config" });
-assert.equal(config.features.browser_fast_path, false);
-assert.equal(config.features.supervision, false);
-assert.equal(config.features.context_filter, null);
-
-const browser = await decideBrowserStep({ goal: "scroll down", observation: { scroll: { down: true } } }, {
-  provider: { name: "must-not-run", async decide() { throw new Error("disabled browser must not call Jev"); } },
-});
-assert.equal(browser.decision.fallback.type, "browser_fast_path_disabled");
-
-const previousSupervision = process.env.JEV_SUPERVISION;
-delete process.env.JEV_SUPERVISION;
-try {
-  const supervision = await superviseWork({ provider: { async evaluate() { throw new Error("disabled supervision must not call Jev"); } } });
-  assert.equal(supervision.fallback.type, "disabled");
-} finally {
-  if (previousSupervision === undefined) delete process.env.JEV_SUPERVISION;
-  else process.env.JEV_SUPERVISION = previousSupervision;
-}
-
-let calls = 0;
-const route = await routeRequest({
-  intent: "inspect",
-  context: { messages: ["plain context"] },
-  capabilities: [{ id: "inspect", kind: "tool", name: "Inspect", description: "Inspect context", risk: "low" }],
-}, {
-  provider: { name: "default-route-provider", async decide() {
-    calls += 1;
-    return { answers: { tool: { type: "choice", choice: "inspect", probabilities: { inspect: 1 }, confidence: 1 } } };
-  } },
-});
-assert.equal(route.status, "selected");
-assert.equal(calls, 1);
-console.log(JSON.stringify({
-  ok: true,
-  browser: browser.decision.fallback.type,
-  supervision: "disabled",
-  context_filter: "disabled",
-  default_route_provider_calls: calls,
-}, null, 2));
+import assert from "node:assert/strict";
+import { loadConfig } from "../src/config.mjs";
+import { decideBrowserStep } from "../src/browser.mjs";
+import { routeRequest } from "../src/route.mjs";
+import { superviseWork } from "../src/supervision.mjs";
+
+const { config } = await loadConfig({ cwd: "/tmp/jev-no-config" });
+assert.equal(config.features.browser_fast_path, false);
+assert.equal(config.features.supervision, false);
+assert.equal(config.features.context_filter, null);
+
+const browser = await decideBrowserStep({ goal: "scroll down", observation: { scroll: { down: true } } }, {
+  provider: { name: "must-not-run", async decide() { throw new Error("disabled browser must not call Jev"); } },
+});
+assert.equal(browser.decision.fallback.type, "browser_fast_path_disabled");
+
+const previousSupervision = process.env.JEV_SUPERVISION;
+delete process.env.JEV_SUPERVISION;
+try {
+  const supervision = await superviseWork({ provider: { async evaluate() { throw new Error("disabled supervision must not call Jev"); } } });
+  assert.equal(supervision.fallback.type, "disabled");
+} finally {
+  if (previousSupervision === undefined) delete process.env.JEV_SUPERVISION;
+  else process.env.JEV_SUPERVISION = previousSupervision;
+}
+
+let calls = 0;
+const route = await routeRequest({
+  intent: "inspect",
+  context: { messages: ["plain context"] },
+  capabilities: [{ id: "inspect", kind: "tool", name: "Inspect", description: "Inspect context", risk: "low" }],
+}, {
+  provider: { name: "default-route-provider", async decide() {
+    calls += 1;
+    return { answers: { tool: { type: "choice", choice: "inspect", probabilities: { inspect: 1 }, confidence: 1 } } };
+  } },
+});
+assert.equal(route.status, "selected");
+assert.equal(calls, 1);
+console.log(JSON.stringify({
+  ok: true,
+  browser: browser.decision.fallback.type,
+  supervision: "disabled",
+  context_filter: "disabled",
+  default_route_provider_calls: calls,
+}, null, 2));

package/scripts/mcp-receipt-smoke.mjs

@@ -1,98 +1,115 @@
-import assert from "node:assert/strict";
-import { mkdtemp, readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-
-const root = resolve(new URL("..", import.meta.url).pathname);
-const casesPath = join(await mkdtemp(join(tmpdir(), "jev-mcp-receipt-")), "cases.jsonl");
-const child = spawn(process.env.JEV_NODE ?? "node", [resolve(root, "src/mcp-server.mjs")], {
-  cwd: root,
-  env: { ...process.env, 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_route"));
-  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_record_execution"));
-
-  const routed = await request(3, "tools/call", {
-    name: "jev_route",
-    arguments: {
-      provider: "demo",
-      harness: "mcp-receipt-smoke",
-      intent: "read repository metadata",
-      actor_permissions: ["read"],
-      capabilities: [{
-        id: "read_metadata",
-        kind: "tool",
-        name: "Read metadata",
-        description: "Read repository metadata without modifying files",
-        permissions: ["read"],
-        risk: "low",
-      }],
-    },
-  });
-  const decision = routed.result.structuredContent;
-  assert.equal(decision.status, "selected");
-  assert.equal(decision.receipt.replay_persisted, true);
-
-  const recorded = await request(4, "tools/call", {
-    name: "jev_record_execution",
-    arguments: {
-      correlation_id: decision.correlation_id,
-      harness: "mcp-receipt-smoke",
-      capability_id: decision.selected,
-      status: "completed",
-      result: { observed: "metadata" },
-      exit_status: 0,
-      duration_ms: 3.2,
-    },
-  });
-  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, 3.2);
-
-  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"]);
-  console.log(JSON.stringify({ ok: true, cases_path: casesPath, receipt }, 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 { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const casesPath = join(await mkdtemp(join(tmpdir(), "jev-mcp-receipt-")), "cases.jsonl");
+const child = spawn(process.env.JEV_NODE ?? "node", [resolve(root, "src/mcp-server.mjs")], {
+  cwd: root,
+  env: { ...process.env, JEV_REPLAY_CASES: casesPath },
+  stdio: ["pipe", "pipe", "pipe"],
+});
+const closed = new Promise((resolveExit) => child.once("close", resolveExit));
+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_route"));
+  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_model_route"));
+  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_shadow_compaction"));
+  assert.ok(listed.result.tools.some((tool) => tool.name === "jev_record_execution"));
+
+  const routed = await request(3, "tools/call", {
+    name: "jev_route",
+    arguments: {
+      provider: "demo",
+      harness: "mcp-receipt-smoke",
+      intent: "read repository metadata",
+      actor_permissions: ["read"],
+      capabilities: [{
+        id: "read_metadata",
+        kind: "tool",
+        name: "Read metadata",
+        description: "Read repository metadata without modifying files",
+        permissions: ["read"],
+        risk: "low",
+      }],
+    },
+  });
+  const decision = routed.result.structuredContent;
+  assert.equal(decision.status, "selected");
+  assert.equal(decision.receipt.replay_persisted, true);
+
+  const recorded = await request(4, "tools/call", {
+    name: "jev_record_execution",
+    arguments: {
+      correlation_id: decision.correlation_id,
+      harness: "mcp-receipt-smoke",
+      capability_id: decision.selected,
+      status: "completed",
+      result: { observed: "metadata" },
+      exit_status: 0,
+      duration_ms: 3.2,
+    },
+  });
+  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, 3.2);
+
+  const shadow = await request(5, "tools/call", {
+    name: "jev_shadow_compaction",
+    arguments: {
+      provider: "demo",
+      intent: "inspect context before compaction",
+      context: { messages: ["stale note", "Requirement: preserve /workspace/config.json"] },
+    },
+  });
+  const shadowReport = shadow.result.structuredContent;
+  assert.equal(shadowReport.mode, "jev_shadow");
+  assert.equal(shadowReport.changed, false);
+  assert.equal(shadowReport.protected_count, 1);
+
+  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"]);
+  console.log(JSON.stringify({ ok: true, cases_path: casesPath, receipt }, null, 2));
+} finally {
+  child.kill();
+  await closed;
+}
+
+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));
+}