@inetafrica/open-claudia 2.14.8 → 3.0.0

package/test-provider-enforcer.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const RESULT_PREFIX = "__PROVIDER_ENFORCER_RESULT__";
+
+function isolate(label) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-enforcer-${label}-`));
+  process.env.OPEN_CLAUDIA_TEST = "1";
+  process.env.OPEN_CLAUDIA_CONFIG_DIR = path.join(root, "config");
+  process.env.HOME = root;
+  process.env.WORKSPACE = root;
+  fs.mkdirSync(process.env.OPEN_CLAUDIA_CONFIG_DIR, { recursive: true });
+  return root;
+}
+
+function makeProvider(kind, root, controls) {
+  const fixture = path.join(__dirname, "test-fixtures", "fake-agent-cli.js");
+  const { createClaudeProvider } = require("./core/providers/claude");
+  const { createCodexProvider } = require("./core/providers/codex");
+  const createProvider = kind === "claude" ? createClaudeProvider : createCodexProvider;
+  const provider = createProvider({
+    hookTransport: false,
+    resolveExecutable: () => fixture,
+    defaultModel: `${kind}-default-fixture`,
+    buildEnv: () => ({ PATH: process.env.PATH || "", HOME: root, FAKE_AGENT_KIND: kind }),
+    getAuthStatus: () => ({ state: "authenticated", reason: null }),
+  });
+  const base = provider.buildUtilityInvocation;
+  const captures = [];
+  provider.buildUtilityInvocation = (context) => {
+    const invocation = base(context);
+    const control = controls.shift() || { FAKE_AGENT_TEXT: '{"decision":"allow","reason":"default fixture"}' };
+    const capture = path.join(root, `${kind}-${captures.length}-${context.purpose}.json`);
+    captures.push(capture);
+    Object.assign(invocation.env, control, { FAKE_AGENT_CAPTURE: capture });
+    return invocation;
+  };
+  return { provider, captures, fixture };
+}
+
+function registry(providerEntries, states = {}) {
+  const map = Object.fromEntries(providerEntries.map((entry) => [entry.provider.id, entry]));
+  return {
+    getProvider(id) {
+      if (!map[id]) throw Object.assign(new Error(`unknown provider ${id}`), { code: "UNKNOWN_PROVIDER" });
+      return map[id].provider;
+    },
+    listProviders: () => providerEntries.map((entry) => entry.provider),
+    providerStatus(id) {
+      if (!map[id]) throw Object.assign(new Error(`unknown provider ${id}`), { code: "UNKNOWN_PROVIDER" });
+      const state = states[id] || {};
+      return {
+        id,
+        availability: state.availability || { state: "available", executable: map[id].fixture, reason: null },
+        compatibility: state.compatibility || { state: "compatible", reason: null },
+        auth: state.auth || { state: "authenticated", reason: null },
+      };
+    },
+  };
+}
+
+function auditSink() {
+  const entries = [];
+  return { entries, log(kind, payload) { const entry = { kind, ...payload }; entries.push(entry); return entry; } };
+}
+
+async function providerProbe(kind) {
+  const root = isolate(kind);
+  const timeoutSignal = path.join(root, `${kind}-timeout-signal.json`);
+  const controls = [
+    { FAKE_AGENT_TEXT: '{"decision":"allow","reason":"inside mandate"}' },
+    { FAKE_AGENT_TEXT: '{"decision":"block","reason":"outside mandate"}' },
+    { FAKE_AGENT_TEXT: '{"decision":"escalate","reason":"owner must decide"}' },
+    { FAKE_AGENT_TEXT: "not-json" },
+    { FAKE_AGENT_SCENARIO: "forced-termination", FAKE_AGENT_SIGNAL_CAPTURE: timeoutSignal },
+  ];
+  const entry = makeProvider(kind, root, controls);
+  const model = `${kind}-enforcer-exact`;
+  const { createUtilityAgentService } = require("./core/utility-agent");
+  const utility = createUtilityAgentService({
+    registry: registry([entry]),
+    env: { ENFORCER_PROVIDER: kind, [`ENFORCER_MODEL_${kind.toUpperCase()}`]: model },
+    killGraceMs: 30,
+  });
+  const enforcer = require("./core/enforcer");
+  assert.strictEqual(typeof enforcer.createEnforcerService, "function", "enforcer exposes an injectable utility-provider service");
+  const audit = auditSink();
+  const service = enforcer.createEnforcerService({
+    spawnUtilityAgent: utility.spawnUtilityAgent,
+    audit,
+    timeoutMs: 2000,
+  });
+  const speaker = { name: "External Fixture", relationship: "external", mandate: "May discuss invoice status only." };
+  const secret = ["sk", "proj", "guard", "fixture", "private"].join("-");
+  const allow = await service.vetReply(speaker, `Invoice status is paid. ${secret}`);
+  const block = await service.vetReply(speaker, "Here are internal infrastructure details.");
+  const escalate = await service.vetAction(speaker, { command: "open-claudia tool run billing change-owner", tier: "write" });
+  const malformed = await service.vetReply(speaker, "malformed verdict fixture");
+  const timeoutService = enforcer.createEnforcerService({
+    spawnUtilityAgent: utility.spawnUtilityAgent,
+    audit,
+    timeoutMs: 140,
+  });
+  const timedOut = await timeoutService.vetReply(speaker, "timeout verdict fixture");
+
+  assert.strictEqual(allow.decision, "allow");
+  assert.strictEqual(block.decision, "block");
+  assert.strictEqual(escalate.decision, "escalate");
+  for (const verdict of [allow, block, escalate]) {
+    assert.strictEqual(verdict.provider, kind);
+    assert.strictEqual(verdict.model, model);
+    assert.strictEqual(verdict.fallbackUsed, false);
+    assert.strictEqual(verdict.status, "judged");
+  }
+  for (const failure of [malformed, timedOut]) {
+    assert.strictEqual(failure.decision, "escalate", "guard failures always fail closed");
+    assert.strictEqual(failure.provider, kind);
+    assert.strictEqual(failure.model, model);
+    assert.strictEqual(failure.status, "failed");
+    assert.match(failure.reason, /failing closed/);
+  }
+
+  assert.strictEqual(audit.entries.length, 5);
+  assert.ok(audit.entries.every((item) => item.kind === "enforcer.verdict"));
+  assert.ok(audit.entries.every((item) => item.provider === kind && item.model === model));
+  const serializedAudit = JSON.stringify(audit.entries);
+  assert.ok(!serializedAudit.includes(secret), "audit metadata never contains the judged prompt or payload");
+  assert.ok(!serializedAudit.includes("mandate"), "audit metadata never contains the private mandate");
+
+  assert.strictEqual(entry.captures.length, 5);
+  for (const capture of entry.captures) {
+    const raw = fs.readFileSync(capture, "utf8");
+    const record = JSON.parse(raw);
+    assert.ok(!raw.includes(secret), "fixture capture contains stdin metadata, never the guarded payload");
+    assert.strictEqual(record.stdin.present, true);
+    assert.ok(record.argv.includes(model));
+    assert.ok(record.argv.includes(kind === "claude" ? "plan" : "read-only"));
+    assert.ok(record.argv.includes(kind === "claude" ? "--json-schema" : "--output-schema"));
+  }
+  assert.strictEqual(JSON.parse(fs.readFileSync(timeoutSignal, "utf8")).signal, "SIGTERM");
+
+  return { kind, decisions: [allow.decision, block.decision, escalate.decision, malformed.decision, timedOut.decision] };
+}
+
+async function fallbackProbe() {
+  const root = isolate("fallback");
+  const claude = makeProvider("claude", root, [{ FAKE_AGENT_SCENARIO: "auth-failure" }]);
+  const codex = makeProvider("codex", root, [{ FAKE_AGENT_TEXT: '{"decision":"allow","reason":"fallback judged"}' }]);
+  const { createUtilityAgentService } = require("./core/utility-agent");
+  const fallbackUtility = createUtilityAgentService({
+    registry: registry([claude, codex]),
+    env: {
+      ENFORCER_PROVIDER: "claude",
+      PROVIDER_FALLBACKS: "codex",
+      ENFORCER_MODEL_CLAUDE: "claude-enforcer-exact",
+      ENFORCER_MODEL_CODEX: "codex-enforcer-exact",
+    },
+  });
+  const enforcer = require("./core/enforcer");
+  const fallbackAudit = auditSink();
+  const fallbackService = enforcer.createEnforcerService({ spawnUtilityAgent: fallbackUtility.spawnUtilityAgent, audit: fallbackAudit });
+  const speaker = { relationship: "external", mandate: "May discuss invoice status." };
+  const fallback = await fallbackService.vetReply(speaker, "fallback invoice fixture");
+  assert.strictEqual(fallback.decision, "allow");
+  assert.strictEqual(fallback.provider, "codex");
+  assert.strictEqual(fallback.model, "codex-enforcer-exact");
+  assert.strictEqual(fallback.preferredProvider, "claude");
+  assert.strictEqual(fallback.fallbackUsed, true);
+  assert.strictEqual(fallbackAudit.entries[0].provider, "codex");
+  assert.strictEqual(fallbackAudit.entries[0].fallbackUsed, true);
+  assert.strictEqual(claude.captures.length, 1, "preferred provider was attempted first");
+  assert.strictEqual(codex.captures.length, 1, "only the explicitly configured fallback judged after auth failure");
+
+  const noFallbackCodex = makeProvider("codex", root, []);
+  const noFallbackUtility = createUtilityAgentService({
+    registry: registry([claude, noFallbackCodex], {
+      claude: { availability: { state: "missing", executable: null, reason: "missing fixture" } },
+    }),
+    env: { ENFORCER_PROVIDER: "claude" },
+  });
+  const noFallbackService = enforcer.createEnforcerService({ spawnUtilityAgent: noFallbackUtility.spawnUtilityAgent, audit: auditSink() });
+  const noFallback = await noFallbackService.vetReply(speaker, "no implicit fallback fixture");
+  assert.strictEqual(noFallback.decision, "escalate");
+  assert.strictEqual(noFallback.status, "failed");
+  assert.strictEqual(noFallbackCodex.captures.length, 0, "enforcer never invents an unconfigured fallback");
+
+  const failedClaude = makeProvider("claude", root, []);
+  const failedCodex = makeProvider("codex", root, []);
+  const totalFailureUtility = createUtilityAgentService({
+    registry: registry([failedClaude, failedCodex], {
+      claude: { availability: { state: "missing", executable: null, reason: "missing Claude" } },
+      codex: { auth: { state: "unauthenticated", reason: "missing Codex auth" } },
+    }),
+    env: { ENFORCER_PROVIDER: "claude", PROVIDER_FALLBACKS: "codex" },
+  });
+  const totalAudit = auditSink();
+  const totalService = enforcer.createEnforcerService({ spawnUtilityAgent: totalFailureUtility.spawnUtilityAgent, audit: totalAudit });
+  const totalFailure = await totalService.vetAction(speaker, { command: "dangerous total failure fixture", tier: "destructive" });
+  assert.strictEqual(totalFailure.decision, "escalate");
+  assert.strictEqual(totalFailure.status, "failed");
+  assert.match(totalFailure.reason, /failing closed/);
+  assert.strictEqual(totalAudit.entries[0].decision, "escalate");
+  assert.strictEqual(totalAudit.entries[0].status, "failed");
+
+  return { fallbackProvider: fallback.provider, noFallback: noFallback.decision, totalFailure: totalFailure.decision };
+}
+
+function runChild(args) {
+  const child = spawnSync(process.execPath, [__filename, ...args], {
+    cwd: __dirname,
+    env: { ...process.env },
+    encoding: "utf8",
+    timeout: 30000,
+  });
+  if (child.status !== 0) throw new Error(`enforcer child ${args.join(" ")} failed (${child.status})\n${child.stdout}\n${child.stderr}`);
+  const line = child.stdout.split("\n").find((entry) => entry.startsWith(RESULT_PREFIX));
+  if (!line) throw new Error(`enforcer child ${args.join(" ")} returned no result\n${child.stdout}\n${child.stderr}`);
+  return JSON.parse(line.slice(RESULT_PREFIX.length));
+}
+
+async function main() {
+  if (process.argv[2] === "--provider") {
+    const result = await providerProbe(process.argv[3]);
+    console.log(`${RESULT_PREFIX}${JSON.stringify(result)}`);
+    return;
+  }
+  if (process.argv[2] === "--fallback") {
+    const result = await fallbackProbe();
+    console.log(`${RESULT_PREFIX}${JSON.stringify(result)}`);
+    return;
+  }
+  const claude = runChild(["--provider", "claude"]);
+  const codex = runChild(["--provider", "codex"]);
+  assert.deepStrictEqual(claude.decisions, ["allow", "block", "escalate", "escalate", "escalate"]);
+  assert.deepStrictEqual(codex.decisions, claude.decisions);
+  assert.deepStrictEqual(runChild(["--fallback"]), { fallbackProvider: "codex", noFallback: "escalate", totalFailure: "escalate" });
+  const source = fs.readFileSync(path.join(__dirname, "core", "enforcer.js"), "utf8");
+  assert.ok(!source.includes("spawnSubagent"), "enforcer no longer uses the compatibility sub-agent transport");
+  console.log("provider enforcer OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/test-provider-env-isolation.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const baselinePath = path.join(__dirname, "test-fixtures", "current-provider-parity.json");
+assert.ok(fs.existsSync(baselinePath), "current provider-parity baseline fixture must exist");
+const baseline = JSON.parse(fs.readFileSync(baselinePath, "utf8"));
+assert.strictEqual(baseline.environment.knownDefect, true);
+assert.strictEqual(baseline.environment.invertInTask, 4);
+assert.strictEqual(baseline.environment.capture, "boolean-key-presence-only");
+
+const {
+  NATIVE_ISOLATION_NOTICE,
+  addConfiguredPassthrough,
+  baseAgentEnv,
+  claudeAgentEnv,
+  codexAgentEnv,
+  pickStandardProcessEnv,
+} = require("./core/providers/env");
+
+const synthetic = Object.fromEntries(
+  baseline.environment.keys.map((key) => [key, `synthetic-canary:${key.toLowerCase()}`]),
+);
+const source = {
+  PATH: "/fixture/bin",
+  HOME: "/fixture/home",
+  TMPDIR: "/fixture/tmp",
+  LANG: "en_US.UTF-8",
+  TZ: "UTC",
+  SHELL: "/bin/sh",
+  PROJECT_REGION: "fixture-region",
+  AGENT_ENV_PASSTHROUGH: [
+    "PROJECT_REGION",
+    "TELEGRAM_BOT_TOKEN",
+    "OPENAI_API_KEY",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "OPEN_CLAUDIA_KEYRING_CANARY",
+  ].join(","),
+  ...synthetic,
+};
+
+function presence(env) {
+  return Object.fromEntries(
+    baseline.environment.keys.map((key) => [key, Object.prototype.hasOwnProperty.call(env, key)]),
+  );
+}
+
+function hash(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex");
+}
+
+const standard = pickStandardProcessEnv(source);
+assert.deepStrictEqual(standard, {
+  PATH: source.PATH,
+  HOME: source.HOME,
+  TMPDIR: source.TMPDIR,
+  SHELL: source.SHELL,
+  LANG: source.LANG,
+  TZ: source.TZ,
+});
+
+const passTarget = {};
+addConfiguredPassthrough(passTarget, source);
+assert.deepStrictEqual(Object.keys(passTarget).sort(), [
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "OPENAI_API_KEY",
+  "OPEN_CLAUDIA_KEYRING_CANARY",
+  "PROJECT_REGION",
+  "TELEGRAM_BOT_TOKEN",
+].sort());
+assert.throws(
+  () => addConfiguredPassthrough({}, { AGENT_ENV_PASSTHROUGH: "GOOD,bad-name" }),
+  (error) => error && error.code === "INVALID_ENV_PASSTHROUGH",
+);
+assert.throws(
+  () => addConfiguredPassthrough({}, { AGENT_ENV_PASSTHROUGH: "__proto__" }),
+  (error) => error && error.code === "INVALID_ENV_PASSTHROUGH",
+);
+
+const base = baseAgentEnv(source);
+assert.strictEqual(base.PROJECT_REGION, "fixture-region", "explicit project passthrough survives");
+assert.deepStrictEqual(presence(base), Object.fromEntries(baseline.environment.keys.map((key) => [key, false])));
+
+const claude = claudeAgentEnv(source);
+const codex = codexAgentEnv(source);
+
+// This is the Task 2 inversion: the provider environments must now be
+// intentionally different and match the key-presence-only target fixture.
+assert.deepStrictEqual(presence(claude), baseline.environment.target.claude);
+assert.deepStrictEqual(presence(codex), baseline.environment.target.codex);
+assert.notDeepStrictEqual(presence(claude), presence(codex));
+assert.ok(!Object.prototype.hasOwnProperty.call(claudeAgentEnv({ ...source, ANTHROPIC_API_KEY: "" }), "ANTHROPIC_API_KEY"));
+assert.ok(!Object.prototype.hasOwnProperty.call(codexAgentEnv({ ...source, OPENAI_API_KEY: "" }), "OPENAI_API_KEY"));
+
+// Hash-only comparisons prove the provider-owned credentials were preserved
+// without ever serializing or printing the values themselves.
+assert.strictEqual(hash(claude.CLAUDE_CODE_OAUTH_TOKEN), hash(source.CLAUDE_CODE_OAUTH_TOKEN));
+assert.strictEqual(hash(claude.ANTHROPIC_API_KEY), hash(source.ANTHROPIC_API_KEY));
+assert.strictEqual(hash(claude.CLAUDE_CONFIG_DIR), hash(source.CLAUDE_CONFIG_DIR));
+assert.strictEqual(hash(codex.OPENAI_API_KEY), hash(source.OPENAI_API_KEY));
+assert.strictEqual(hash(codex.CODEX_HOME), hash(source.CODEX_HOME));
+
+assert.match(NATIVE_ISOLATION_NOTICE, /environment isolation/i);
+assert.match(NATIVE_ISOLATION_NOTICE, /same-UID/i);
+assert.match(NATIVE_ISOLATION_NOTICE, /not filesystem isolation/i);
+const runnerSource = fs.readFileSync(path.join(__dirname, "core", "runner.js"), "utf8");
+assert.ok(!/overlay\.OC_SEND_TOKEN\s*=/.test(runnerSource), "the compatibility runner must not add the loopback token back to provider envs");
+
+// The auth helpers are the compatibility entry points used by existing
+// provider-specific processes until the runner switches to adapters in Task 9.
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-provider-env-auth-"));
+try {
+  const configDir = path.join(root, "config");
+  const workspace = path.join(root, "workspace");
+  const probeScript = [
+    "const { claudeSubprocessEnv, codexSubprocessEnv } = require('./core/auth-flow');",
+    `const keys = ${JSON.stringify(baseline.environment.keys)};`,
+    "const presence = (env) => Object.fromEntries(keys.map((key) => [key, Object.prototype.hasOwnProperty.call(env, key)]));",
+    "process.stdout.write(JSON.stringify({ claude: presence(claudeSubprocessEnv()), codex: presence(codexSubprocessEnv()) }));",
+  ].join("\n");
+  const child = spawnSync(process.execPath, ["-e", probeScript], {
+    cwd: __dirname,
+    encoding: "utf8",
+    env: {
+      ...source,
+      OPEN_CLAUDIA_CONFIG_DIR: configDir,
+      WORKSPACE: workspace,
+      CLAUDE_PATH: process.execPath,
+      CODEX_PATH: process.execPath,
+      OPEN_CLAUDIA_TEST: "1",
+    },
+    timeout: 10000,
+  });
+  assert.ifError(child.error);
+  assert.strictEqual(child.status, 0, child.stderr || "auth environment probe failed");
+  assert.deepStrictEqual(JSON.parse(child.stdout), baseline.environment.target);
+  assert.ok(!fs.existsSync(configDir), "auth environment construction must not create config state");
+  assert.ok(!fs.existsSync(workspace), "auth environment construction must not create a workspace");
+} finally {
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+console.log("provider env isolation OK");

package/test-provider-events.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+const { NORMALIZED_EVENT_TYPES, selectTerminalText } = require("./core/providers/events");
+const { createClaudeParserState, normalizeClaudeEvent } = require("./core/providers/claude-events");
+const { createCodexParserState, normalizeCodexEvent } = require("./core/providers/codex-events");
+
+const samples = JSON.parse(fs.readFileSync(
+  path.join(__dirname, "test-fixtures", "provider-event-samples.json"),
+  "utf8",
+));
+
+assert.deepStrictEqual([...NORMALIZED_EVENT_TYPES].sort(), [
+  "error",
+  "result",
+  "session",
+  "text_delta",
+  "text_final",
+  "tool_end",
+  "tool_start",
+  "usage",
+].sort());
+
+const claudeState = createClaudeParserState();
+assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.session, claudeState), [
+  { type: "session", sessionId: "claude-session-1" },
+]);
+assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.delta, claudeState), [
+  { type: "text_delta", text: "Hello " },
+]);
+assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.toolUse, claudeState), [
+  { type: "tool_start", id: "tool-1", name: "Read", detail: { file_path: "fixture.txt" } },
+]);
+assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.toolResult, claudeState), [
+  { type: "tool_end", id: "tool-1", name: "Read", detail: "fixture output", exitCode: 0 },
+]);
+assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.assistant, claudeState), [
+  { type: "text_final", text: "world" },
+  { type: "usage", usage: { input_tokens: 12, output_tokens: 3 }, scope: "provider_call" },
+]);
+const claudeResult = normalizeClaudeEvent(samples.claude.result, claudeState);
+assert.deepStrictEqual(claudeResult, [
+  { type: "usage", usage: { input_tokens: 12, output_tokens: 3 }, scope: "turn" },
+  { type: "result", text: "", sessionId: "claude-session-1" },
+]);
+assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.result, claudeState), [], "duplicate Claude terminal settles once");
+
+const claudeFallback = createClaudeParserState();
+const fallback = normalizeClaudeEvent(samples.claude.result, claudeFallback);
+assert.deepStrictEqual(fallback.at(-1), { type: "result", text: "Hello world", sessionId: "claude-session-1" });
+
+const claudeStructuredState = createClaudeParserState();
+normalizeClaudeEvent({
+  type: "assistant",
+  message: { content: [{ type: "text", text: "```json\n{\"status\":\"ok\"}\n```" }] },
+}, claudeStructuredState);
+const structured = normalizeClaudeEvent({
+  type: "result",
+  subtype: "success",
+  is_error: false,
+  session_id: "claude-structured-session",
+  result: "",
+  structured_output: { status: "ok" },
+}, claudeStructuredState);
+assert.deepStrictEqual(structured.at(-1), {
+  type: "result",
+  text: '{"status":"ok"}',
+  sessionId: "claude-structured-session",
+});
+assert.strictEqual(selectTerminalText({
+  resultText: '{"status":"ok"}',
+  finalText: "```json\n{\"status\":\"ok\"}\n```",
+}), '{"status":"ok"}', "structured terminal output overrides presentation text");
+
+const usageOnly = { type: "assistant", message: { usage: { input_tokens: 1, output_tokens: 1 }, content: [] } };
+const usageState = createClaudeParserState();
+assert.strictEqual(normalizeClaudeEvent(usageOnly, usageState).filter((event) => event.type === "usage").length, 1);
+assert.strictEqual(normalizeClaudeEvent(usageOnly, usageState).filter((event) => event.type === "usage").length, 0);
+
+const claudeAuth = normalizeClaudeEvent({
+  type: "result",
+  is_error: true,
+  subtype: "error_during_execution",
+  result: "Authentication failed",
+  errors: ["Login required"],
+}, createClaudeParserState());
+assert.deepStrictEqual(claudeAuth, [{
+  type: "error",
+  message: "Authentication failed",
+  authError: true,
+  usageLimit: false,
+}]);
+
+const codexState = createCodexParserState();
+assert.deepStrictEqual(normalizeCodexEvent(samples.codex.session, codexState), [
+  { type: "session", sessionId: "codex-thread-1" },
+]);
+assert.deepStrictEqual(normalizeCodexEvent(samples.codex.toolStart, codexState), [
+  { type: "tool_start", id: "item-1", name: "Shell", detail: "printf fixture" },
+]);
+assert.deepStrictEqual(normalizeCodexEvent(samples.codex.toolEnd, codexState), [
+  { type: "tool_end", id: "item-1", name: "Shell", detail: "fixture", exitCode: 0 },
+]);
+assert.deepStrictEqual(normalizeCodexEvent(samples.codex.assistant, codexState), [
+  { type: "text_final", text: "Hello from Codex" },
+]);
+assert.deepStrictEqual(normalizeCodexEvent(samples.codex.result, codexState), [
+  { type: "usage", usage: { input_tokens: 20, cached_input_tokens: 5, output_tokens: 4 }, scope: "session_total" },
+  { type: "result", text: "", sessionId: "codex-thread-1" },
+]);
+assert.deepStrictEqual(normalizeCodexEvent(samples.codex.result, codexState), [], "duplicate Codex terminal and usage settle once");
+
+const codexAuth = normalizeCodexEvent({ type: "turn.failed", error: { message: "401 Unauthorized" } }, createCodexParserState());
+assert.deepStrictEqual(codexAuth, [{
+  type: "error",
+  message: "401 Unauthorized",
+  authError: true,
+  usageLimit: false,
+}]);
+
+const decoderError = { type: "decoder.error", code: "MALFORMED_JSON", message: "Malformed provider JSONL record" };
+assert.deepStrictEqual(normalizeClaudeEvent(decoderError, createClaudeParserState()), [{
+  type: "error", message: "Malformed provider JSONL record", authError: false, usageLimit: false,
+}]);
+assert.deepStrictEqual(normalizeCodexEvent(decoderError, createCodexParserState()), [{
+  type: "error", message: "Malformed provider JSONL record", authError: false, usageLimit: false,
+}]);
+
+assert.deepStrictEqual(normalizeClaudeEvent({ type: "future.claude.event" }, createClaudeParserState()), []);
+assert.deepStrictEqual(normalizeCodexEvent({ type: "future.codex.event" }, createCodexParserState()), []);
+
+const isolatedA = createClaudeParserState();
+const isolatedB = createClaudeParserState();
+normalizeClaudeEvent(samples.claude.session, isolatedA);
+assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.session, isolatedB), [{ type: "session", sessionId: "claude-session-1" }]);
+
+console.log("provider events OK");