@inetafrica/open-claudia 2.14.8 → 3.0.0

package/test-recall-engine.js

@@ -26,19 +26,19 @@ if (prev === undefined) delete process.env.RECALL_ENGINE; else process.env.RECAL
     packsLib: { matchPacks: () => [{ dir: "p1", name: "P1" }] },
     entitiesLib: { matchEntities: () => [{ slug: "e1", name: "E1" }] },
     mergeMatches: (a, b) => { calls.push("merge"); return a.map((m) => ({ ...m, origin: "user" })); },
-    filterMatches: async (u, c, pm, em) => { calls.push("filter"); return { packMatches: pm, entityMatches: em }; },
+    filterMatches: async (u, c, pm, em, opts) => { calls.push(`filter:${opts.provider}`); return { packMatches: pm, entityMatches: em }; },
     logRecall: () => { calls.push("log"); },
     buildPackBlock: (m) => { calls.push("buildPack"); return m.length ? "PACKBLOCK" : ""; },
     buildEntityBlock: (m) => { calls.push("buildEntity"); return m.length ? "ENTITYBLOCK" : ""; },
   };
   const out = await recall.getEngine("classic").run({
-    userText: "hello", contextText: "", fullContext: "", packLimit: 6, budget: {}, helpers,
+    userText: "hello", contextText: "", fullContext: "", packLimit: 6, budget: {}, helpers, provider: "codex",
   });
   assert.strictEqual(out.packBlock, "PACKBLOCK");
   assert.strictEqual(out.entityBlock, "ENTITYBLOCK");
   assert.strictEqual(out.packMatches.length, 1);
   assert.strictEqual(out.entityMatches.length, 1);
-  assert.ok(calls.includes("filter") && calls.includes("log") && calls.includes("buildPack"));
+  assert.ok(calls.includes("filter:codex") && calls.includes("log") && calls.includes("buildPack"));
 
   // resilient: a throwing matcher must not blow up the engine
   const out2 = await recall.getEngine("classic").run({

package/test-recall-evolution.js

@@ -211,4 +211,22 @@ const parsed = dream.parseDream(JSON.stringify({ report: "hi", tuning: { knob: "
 assert.deepStrictEqual(parsed.tuning, { knob: "episodeLimit", to: 4, reason: "r" }, "tuning proposal parses");
 assert.strictEqual(dream.parseDream(JSON.stringify({ report: "hi", tuning: "bogus" })).tuning, null, "non-object tuning ignored");
 
+// Provider-neutral dream audit metadata stays visible in the durable report,
+// while invalid tier configuration preserves the historical high-tier default.
+process.env.DREAM_TIER = "sideways";
+assert.strictEqual(dream.dreamTier(), "high");
+process.env.DREAM_TIER = "medium";
+assert.strictEqual(dream.dreamTier(), "medium");
+delete process.env.DREAM_TIER;
+const dreamReportPath = dream.writeDreamReport({
+  trigger: "test",
+  intelligence: { provider: "codex", model: "gpt-fixture", effort: "xhigh", status: "succeeded" },
+  introspectionIntelligence: { provider: "claude", model: "claude-fixture", status: "succeeded" },
+  consolidation: { report: "provider metadata fixture", lines: [] },
+  introspection: { report: "introspection fixture", lines: [], proposed: null },
+});
+const dreamReport = fs.readFileSync(dreamReportPath, "utf8");
+assert.match(dreamReport, /Provider: codex · Model: gpt-fixture/);
+assert.match(dreamReport, /Introspection: claude · Model: claude-fixture/);
+
 console.log("recall evolution OK");

package/test-run-lock.js

@@ -0,0 +1,63 @@
+// P0-3: single-flight run-lock regression test. Under unified identity the
+// owner's Telegram and Kazee turns resolve to ONE canonical user and therefore
+// share ONE in-memory state object. If two of those turns could both pass the
+// "is a run in progress?" check they would race the shared state and the JSON
+// files behind it. acquireRunLock() closes that window by arming the lock
+// SYNCHRONOUSLY (no await between the check and the arm), so the second turn is
+// always refused and queued. This test pins that contract on the raw helper.
+
+const assert = require("assert");
+process.env.OPEN_CLAUDIA_TEST = "1";
+
+const { acquireRunLock } = require("./core/state");
+
+// A run-lock must be synchronous — its whole point is that no await can
+// interleave between the check and the arm. If this ever returned a Promise the
+// guarantee would silently evaporate.
+{
+  const r = acquireRunLock({ runningProcess: null, preparingRun: false });
+  assert.strictEqual(typeof r, "boolean", "acquireRunLock must be synchronous (return a boolean, not a Promise)");
+}
+
+// Idle → acquires and arms preparingRun.
+{
+  const s = { runningProcess: null, preparingRun: false };
+  assert.strictEqual(acquireRunLock(s), true, "idle state acquires");
+  assert.strictEqual(s.preparingRun, true, "acquiring arms preparingRun");
+}
+
+// Already preparing (armed but not yet spawned) → refused, lock left intact.
+{
+  const s = { runningProcess: null, preparingRun: true };
+  assert.strictEqual(acquireRunLock(s), false, "preparing state is refused");
+  assert.strictEqual(s.preparingRun, true, "refusal leaves the existing lock armed");
+}
+
+// A process is actively running → refused.
+{
+  const s = { runningProcess: { pid: 123 }, preparingRun: false };
+  assert.strictEqual(acquireRunLock(s), false, "running process is refused");
+}
+
+// THE guarantee: two turns sharing ONE state object (owner's Telegram + Kazee
+// under unified identity). Exactly one may acquire; the other must be refused
+// until the first fully releases.
+{
+  const shared = { runningProcess: null, preparingRun: false };
+
+  const first = acquireRunLock(shared);   // Telegram turn arrives
+  const second = acquireRunLock(shared);  // Kazee turn arrives before the first releases
+  assert.strictEqual(first, true, "first turn wins the lock");
+  assert.strictEqual(second, false, "second concurrent turn is refused (no double-acquire)");
+
+  // First turn spawns its process, then finishes and clears both flags.
+  shared.preparingRun = false;
+  shared.runningProcess = { pid: 1 };     // spawned
+  assert.strictEqual(acquireRunLock(shared), false, "still refused while the process runs");
+  shared.runningProcess = null;           // turn complete
+
+  // Now the queued second turn (drained from messageQueue) can proceed.
+  assert.strictEqual(acquireRunLock(shared), true, "lock is re-acquirable once the turn fully releases");
+}
+
+console.log("run-lock OK");

package/test-runner-watchdog-static.js

@@ -6,16 +6,24 @@ const path = require('path');
 const root = __dirname;
 const runner = fs.readFileSync(path.join(root, 'core', 'runner.js'), 'utf8');
 const monolith = fs.readFileSync(path.join(root, 'bot-agent.js'), 'utf8');
+const lifecycleStart = runner.indexOf('async function executeProviderInvocation');
+const lifecycleEnd = runner.indexOf('function capabilitySupported', lifecycleStart);
+assert.ok(lifecycleStart >= 0 && lifecycleEnd > lifecycleStart, 'provider lifecycle implementation must exist');
+const lifecycle = runner.slice(lifecycleStart, lifecycleEnd);
 
 assert.match(runner, /OC_TURN_IDLE_MS/, 'live core/runner.js must read OC_TURN_IDLE_MS');
-assert.match(runner, /watchdogTripped/, 'live core/runner.js must guard close handling after watchdog trip');
-assert.match(runner, /lastActivity\s*=\s*Date\.now\(\)/, 'live core/runner.js must track last child activity');
-assert.match(runner, /proc\.stdout\.on\("data",[\s\S]{0,120}\blastActivity\s*=\s*Date\.now\(\)/, 'stdout must refresh lastActivity');
-assert.match(runner, /proc\.stderr\.on\("data",[\s\S]{0,120}\blastActivity\s*=\s*Date\.now\(\)/, 'stderr must refresh lastActivity');
-assert.match(runner, /killProcessTree\(proc\.pid,\s*"SIGTERM"\)/, 'watchdog must terminate the child process tree first');
-assert.match(runner, /killProcessTree\(proc\.pid,\s*"SIGKILL"\)/, 'watchdog must force-kill the child process tree after grace');
-assert.match(runner, /await drainQueuedMessages\(\)/, 'watchdog path must not strand queued follow-up messages');
+assert.match(lifecycle, /watchdogTripped/, 'active provider lifecycle must guard after watchdog trip');
+assert.match(lifecycle, /lastActivity\s*=\s*Date\.now\(\)/, 'active provider lifecycle must track last child activity');
+assert.match(lifecycle, /proc\.stdout\.on\("data",[\s\S]{0,120}\blastActivity\s*=\s*Date\.now\(\)/, 'stdout must refresh lastActivity');
+assert.match(lifecycle, /proc\.stderr\.on\("data",[\s\S]{0,120}\blastActivity\s*=\s*Date\.now\(\)/, 'stderr must refresh lastActivity');
+assert.match(lifecycle, /beginTermination\(true\)/, 'idle watchdog must use the tracked termination lifecycle');
+assert.match(lifecycle, /killTree\(proc\?\.pid,\s*"SIGTERM"\)/, 'watchdog must terminate the child process tree first');
+assert.match(lifecycle, /killTree\(proc\?\.pid,\s*"SIGKILL"\)/, 'watchdog must force-kill the child process tree after grace');
+assert.match(lifecycle, /await terminationPromise/, 'terminal settlement must await forced descendant cleanup');
+assert.match(runner, /await drainQueuedMessages\(state\)/, 'watchdog path must not strand queued follow-up messages');
 
-assert.match(monolith, /OC_TURN_IDLE_MS/, 'legacy bot-agent.js watchdog should remain for monolith users');
+assert.ok(monolith.split('\n').length <= 12, 'bot-agent.js must be only a compatibility shim');
+assert.match(monolith, /require\(["']\.\/bot["']\)/, 'legacy entrypoint must delegate to bot.js');
+assert.ok(!/(?:OC_TURN_IDLE_MS|CLAUDE_PATH|spawn\(|parseStream|writeFile|saveState|codex)/i.test(monolith), 'compatibility shim must contain no watchdog, provider, parser, or writer implementation');
 
 console.log('runner watchdog static OK');

package/test-single-runtime.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+
+const root = __dirname;
+const shim = fs.readFileSync(path.join(root, "bot-agent.js"), "utf8");
+const bot = fs.readFileSync(path.join(root, "bot.js"), "utf8");
+const cli = fs.readFileSync(path.join(root, "bin", "cli.js"), "utf8");
+const runner = fs.readFileSync(path.join(root, "core", "runner.js"), "utf8");
+const sideChat = fs.readFileSync(path.join(root, "core", "side-chat.js"), "utf8");
+
+assert.ok(shim.split("\n").length <= 12, "bot-agent.js must be only a small compatibility shim");
+assert.match(shim, /require\(["']\.\/bot["']\)/, "compatibility shim delegates to the modular runtime");
+for (const [label, pattern] of [
+  ["provider invocation", /\b(?:spawn|execFile|build\w*Invocation)\b/],
+  ["session parser", /(?:parseStream|session[_A-Z]|SessionId)/],
+  ["state writer", /(?:writeFile|appendFile|rename|saveState|recordSession)/],
+  ["Claude executable", /CLAUDE_PATH/],
+  ["Codex logic", /codex/i],
+]) {
+  assert.ok(!pattern.test(shim), `bot-agent.js must contain no ${label}`);
+}
+
+assert.match(bot, /readRuntimeMode/, "the modular runtime owns both mode behaviors");
+assert.match(runner, /SideChatCoordinator|sideChatCoordinator/, "side chat is part of the modular runner");
+assert.match(sideChat, /class SideChatCoordinator/, "side-chat coordinator is explicit and testable");
+assert.ok(!cli.includes('return "bot-agent.js"'), "agent mode must not select the legacy entrypoint");
+assert.ok(!cli.includes('require(path.join(botDir, botFile))'), "CLI startup must not dynamically select a second runtime");
+assert.match(cli, /require\(path\.join\(botDir, ["']bot\.js["']\)\)/, "CLI always starts the modular runtime");
+
+console.log("single runtime OK");

package/test-telegram-poll-recovery.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const assert = require("assert");
+const { TelegramAdapter } = require("./channels/telegram/adapter");
+
+async function testHealCancelsWedgedLongPollBeforeRestarting() {
+  const calls = [];
+  let stopOptions;
+  const adapter = Object.create(TelegramAdapter.prototype);
+  adapter._healTimer = null;
+  adapter._healthyTimer = null;
+  adapter._wedgedSince = 0;
+  adapter._healBackoff = 0;
+  adapter._agent = {
+    destroy() { calls.push("destroy"); },
+  };
+  adapter.bot = {
+    async stopPolling(options) {
+      stopOptions = options;
+      calls.push("stop");
+    },
+    async startPolling() {
+      calls.push("start");
+    },
+  };
+
+  const realSetTimeout = global.setTimeout;
+  const realClearTimeout = global.clearTimeout;
+  global.setTimeout = (fn, ms) => {
+    if (ms === 500) fn();
+    return { ms };
+  };
+  global.clearTimeout = () => {};
+
+  try {
+    await adapter._heal();
+  } finally {
+    global.setTimeout = realSetTimeout;
+    global.clearTimeout = realClearTimeout;
+  }
+
+  assert.deepStrictEqual(
+    stopOptions,
+    { cancel: true, reason: "stale Telegram long-poll recovery" },
+    "recovery must cancel a wedged getUpdates request rather than await it forever",
+  );
+  assert.deepStrictEqual(calls, ["stop", "destroy", "start"]);
+}
+
+(async () => {
+  await testHealCancelsWedgedLongPollBeforeRestarting();
+  console.log("telegram poll recovery OK");
+})().catch((err) => {
+  console.error(err.stack || err);
+  process.exit(1);
+});

package/test-tool-guard.js

@@ -17,6 +17,42 @@ process.env.KEYRING_FILE = path.join(tmp, "keyring.json");
 
 const guard = require("./core/tool-guard");
 
+// The Open Claudia command policy is provider-neutral and side-effect free.
+// Hook payload parsing, tooling-mode reads, audit writes, and exit-code
+// translation belong to the Claude/Codex transport adapters around it.
+const strictDecision = guard.evaluateCommandPolicy(
+  "curl https://central.inet.africa/policy-sentinel",
+  { mode: "strict" },
+);
+assert.deepStrictEqual(strictDecision, {
+  decision: "deny",
+  ruleId: "inet-central-api",
+  message: guard.denyMessage(guard.RULES.find((rule) => rule.id === "inet-central-api")),
+  auditKind: "deny",
+});
+const relaxedDecision = guard.evaluateCommandPolicy(
+  "curl https://central.inet.africa/policy-sentinel",
+  { mode: "relaxed" },
+);
+assert.deepStrictEqual(relaxedDecision, {
+  decision: "allow",
+  ruleId: "inet-central-api",
+  message: "",
+  auditKind: "relaxed-pass",
+});
+assert.deepStrictEqual(guard.evaluateCommandPolicy("ls -la", { mode: "strict" }), {
+  decision: "allow",
+  ruleId: null,
+  message: "",
+  auditKind: null,
+});
+assert.throws(
+  () => guard.evaluateCommandPolicy("ls", { mode: "unknown" }),
+  (error) => error && error.code === "INVALID_TOOL_POLICY_MODE",
+  "invalid policy modes fail closed at configuration time",
+);
+assert.ok(!fs.existsSync(process.env.TOOL_GUARD_LOG), "pure policy evaluation never writes the audit log");
+
 // ── denies: acting command × prod surface ──
 assert.strictEqual(guard.matchRule("curl -s https://central.inet.africa/api/v1/users").id, "inet-central-api");
 assert.strictEqual(guard.matchRule("wget http://ticketcentral.inet.africa/tickets").id, "ticket-central-api");
@@ -39,6 +75,26 @@ assert.strictEqual(guard.matchRule("curl https://api.github.com/repos"), null, "
 assert.strictEqual(guard.matchRule("open-claudia tool run inet-central-cli users list"), null, "tool run is the authorised channel");
 assert.strictEqual(guard.matchRule('open-claudia keyring exec --reason "x" -- curl https://central.inet.africa/x'), null,
   "keyring exec is the logged escape hatch, never denied");
+assert.strictEqual(
+  guard.matchRule("open-claudia tool run inet-central-cli users list && curl https://central.inet.africa/x").id,
+  "inet-central-api",
+  "an authorised command prefix cannot smuggle a raw compound-command suffix",
+);
+assert.strictEqual(
+  guard.matchRule('open-claudia keyring exec --reason "x" -- echo safe; curl https://central.inet.africa/x').id,
+  "inet-central-api",
+  "the escape hatch exemption is limited to one complete outer command",
+);
+assert.strictEqual(
+  guard.matchRule("open-claudia tool run probe --arg \"$(curl https://central.inet.africa/x)\"").id,
+  "inet-central-api",
+  "command substitution is not hidden by an authorised outer command",
+);
+assert.strictEqual(
+  guard.matchRule("open-claudia tool run probe --arg 'curl https://central.inet.africa/x'"),
+  null,
+  "a quoted literal argument remains part of the authorised command",
+);
 assert.strictEqual(guard.matchRule(""), null, "empty command → allow");
 assert.strictEqual(guard.matchRule("see the ticketcentral docs for details"), null, "mentioning a surface without acting → allow");
 

package/test-tools.js

@@ -108,18 +108,37 @@ delete process.env.api_key;
 //    conflict; a tool with no requires gets no keyring keys at all ──
 fs.writeFileSync(process.env.KEYRING_FILE, JSON.stringify({
   api_key: "from-keyring", api_secret: "s3cret-from-keyring", unrelated_key: "never-injected",
+  OPENAI_API_KEY: "declared-keyring-provider-canary",
 }));
 process.env.api_key = "env-wins";
+process.env.OPENAI_API_KEY = "ambient-provider-canary";
+process.env.CLAUDE_CODE_OAUTH_TOKEN = "ambient-claude-canary";
 const env = tools.runEnv(tools.findTool("hello")); // requires: api_key, api_secret
 assert.ok(env && typeof env === "object" && env.PATH, "runEnv yields an env object carrying PATH");
 assert.strictEqual(env.api_secret, "s3cret-from-keyring", "a declared --requires key is injected from the keyring");
 assert.strictEqual(env.api_key, "env-wins", "process.env wins over the keyring on conflict");
 assert.strictEqual(env.unrelated_key, undefined, "an undeclared keyring key never reaches a tool run");
+assert.strictEqual(env.OPENAI_API_KEY, undefined, "Codex auth never leaks from the provider shell into a tool");
+assert.strictEqual(env.CLAUDE_CODE_OAUTH_TOKEN, undefined, "Claude auth never leaks from the provider shell into a tool");
+assert.strictEqual(
+  tools.runEnv({ requires: ["OPENAI_API_KEY"] }).OPENAI_API_KEY,
+  "declared-keyring-provider-canary",
+  "a provider credential reaches a tool only when explicitly declared in the keyring",
+);
 const envNoReq = tools.runEnv(tools.findTool("peek")); // no requires declared
 assert.strictEqual(envNoReq.api_secret, undefined, "a tool with no requires gets no keyring keys");
 assert.strictEqual(tools.runEnv().unrelated_key, undefined, "runEnv without a tool injects nothing");
 delete process.env.api_key;
+delete process.env.OPENAI_API_KEY;
+delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
 fs.writeFileSync(process.env.KEYRING_FILE, "{}");
+process.env.OPENAI_API_KEY = "ambient-provider-canary";
+assert.deepStrictEqual(
+  tools.missingRequires({ requires: ["OPENAI_API_KEY"] }),
+  ["OPENAI_API_KEY"],
+  "ambient provider auth does not satisfy a tool's explicit keyring requirement",
+);
+delete process.env.OPENAI_API_KEY;
 
 // ── toolNameFromPath recognises legacy flat files and the directory layout's
 //    agent-editable members; state.json and outside paths do not resolve ──

package/test-unified-identity.js

@@ -78,7 +78,9 @@ function runChild(mode) {
     assert.ok(!("voice:voice-owner" in after.users), "on: voice bucket folded away");
     assert.ok("telegram:6251055967" in after.users, "on: owner bucket present");
     const sess = JSON.parse(fs.readFileSync(path.join(CFG, "sessions.json"), "utf-8"));
-    assert.ok(sess["telegram:6251055967"] && sess["telegram:6251055967"].hr, "on: hr session folded into owner");
+    assert.strictEqual(sess.schemaVersion, state.SESSIONS_SCHEMA_VERSION, "on: provider session schema persisted");
+    assert.ok(sess.users["telegram:6251055967"] && sess.users["telegram:6251055967"].hr, "on: hr session folded into owner");
+    assert.strictEqual(sess.users["telegram:6251055967"].hr[0].provider, "legacy", "on: provider-blind history remains unclassified");
     const backups = fs.existsSync(path.join(CFG, "backups")) ? fs.readdirSync(path.join(CFG, "backups")) : [];
     assert.ok(backups.length >= 3, "on: state/sessions/identities backed up before merge");
   }

package/test-usage-accounting.js

@@ -1,29 +1,47 @@
 const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-usage-accounting-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = configDir;
 const {
   usageParts,
   normalizeCodexUsage,
   applyUsageToState,
   shouldAutoCompact,
 } = require("./core/runner");
+const stateApi = require("./core/state");
+const { normalizeUsageRecord, loadUsageHistory, USAGE_HISTORY_FILE } = require("./core/usage-log");
 
 function state(overrides = {}) {
-  return {
+  const requestedUsage = overrides.sessionUsage;
+  const result = {
+    userId: "usage-fixture",
+    currentSession: { name: "alpha", dir: "/workspace/alpha" },
     settings: { backend: "codex", compactWindow: 100 },
-    codexSessionId: "codex-session-1",
-    codexUsageSnapshots: {},
-    sessionUsage: {
-      turns: 0,
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheReadTokens: 0,
-      cacheCreationTokens: 0,
-      costUsd: 0,
-      lastInputTokens: 0,
-      liveContextTokens: 0,
-      lastUsageScope: "turn_delta",
-    },
+    activeSessions: { alpha: { codex: "codex-session-1", claude: "claude-session-1" } },
+    usageBySession: {},
     ...overrides,
   };
+  delete result.sessionUsage;
+  if (requestedUsage) {
+    result.usageBySession["alpha\0codex\0codex-session-1"] = {
+      ...stateApi.freshUsage(),
+      ...requestedUsage,
+    };
+  }
+  Object.defineProperty(result, "sessionUsage", {
+    configurable: true,
+    enumerable: true,
+    get() { return stateApi.getActiveUsage(result); },
+    set(value) {
+      const project = stateApi.getProjectKey(result);
+      const provider = stateApi.getActiveProvider(result);
+      const sessionId = stateApi.getProviderSession(result, provider, project);
+      result.usageBySession[`${project}\0${provider}\0${sessionId || "new"}`] = value;
+    },
+  });
+  return result;
 }
 
 assert.deepStrictEqual(
@@ -41,7 +59,7 @@ const first = normalizeCodexUsage(s, "codex-session-1", {
   input_tokens: 1000,
   cached_input_tokens: 700,
   output_tokens: 50,
-});
+}, { project: "alpha" });
 assert.strictEqual(first.usageScope, "session_total");
 assert.strictEqual(usageParts(first.usage, "codex").context, 1000);
 
@@ -49,7 +67,7 @@ const second = normalizeCodexUsage(s, "codex-session-1", {
   input_tokens: 1250,
   cached_input_tokens: 800,
   output_tokens: 80,
-});
+}, { project: "alpha" });
 assert.strictEqual(second.usageScope, "turn_delta");
 assert.deepStrictEqual(second.usage, {
   input_tokens: 250,
@@ -60,6 +78,9 @@ assert.deepStrictEqual(second.usage, {
 });
 
 applyUsageToState(s, second.usage, 0, {
+  backend: "codex",
+  project: "alpha",
+  sessionId: "codex-session-1",
   usageScope: second.usageScope,
   liveContextTokens: usageParts(second.rawUsage, "codex").context,
 });
@@ -69,16 +90,67 @@ assert.strictEqual(s.sessionUsage.cacheReadTokens, 100);
 assert.strictEqual(s.sessionUsage.lastInputTokens, 250);
 assert.strictEqual(s.sessionUsage.liveContextTokens, 1250);
 
+// The same native-looking ID in another project has an independent cumulative
+// checkpoint; live provider/project switches cannot redirect captured usage.
+const otherProject = normalizeCodexUsage(s, "codex-session-1", {
+  input_tokens: 2000,
+  cached_input_tokens: 1200,
+  output_tokens: 100,
+}, { project: "beta" });
+assert.strictEqual(otherProject.usageScope, "session_total");
+s.currentSession = { name: "beta", dir: "/workspace/beta" };
+s.settings.backend = "claude";
+s.activeSessions.beta = { claude: "claude-beta", codex: "codex-session-1" };
+applyUsageToState(s, { input_tokens: 25, cached_input_tokens: 5, output_tokens: 2 }, 0, {
+  backend: "codex",
+  project: "alpha",
+  sessionId: "codex-session-1",
+  usageScope: "turn_delta",
+});
+assert.strictEqual(stateApi.getUsageForSession(s, "alpha", "codex", "codex-session-1").turns, 2);
+assert.strictEqual(stateApi.getUsageForSession(s, "beta", "claude", "claude-beta").turns, 0);
+
+assert.deepStrictEqual(normalizeUsageRecord({ backend: "codex", contextTokens: 10 }), {
+  backend: "codex",
+  provider: "codex",
+  contextTokens: 10,
+});
+assert.deepStrictEqual(normalizeUsageRecord({ provider: "claude", contextTokens: 10 }), {
+  provider: "claude",
+  backend: "claude",
+  contextTokens: 10,
+});
+fs.writeFileSync(USAGE_HISTORY_FILE, `${JSON.stringify({ backend: "codex", contextTokens: 12 })}\n`);
+assert.deepStrictEqual(loadUsageHistory(), [{
+  backend: "codex",
+  provider: "codex",
+  contextTokens: 12,
+}]);
+
+const recentlyCompactedCodex = state({
+  sessionUsage: {
+    liveContextTokens: 120,
+    lastInputTokens: 120,
+    lastCompactedAt: Date.now(),
+  },
+});
+assert.strictEqual(shouldAutoCompact(recentlyCompactedCodex), false);
+recentlyCompactedCodex.settings.backend = "claude";
+Object.assign(stateApi.getUsageForSession(recentlyCompactedCodex, "alpha", "claude", "claude-session-1"), {
+  liveContextTokens: 120,
+  lastInputTokens: 120,
+});
+assert.strictEqual(shouldAutoCompact(recentlyCompactedCodex), true, "another provider tuple is not throttled by Codex compaction");
+
 assert.strictEqual(shouldAutoCompact(state({
   sessionUsage: { liveContextTokens: 99, lastInputTokens: 99 },
 })), false);
 assert.strictEqual(shouldAutoCompact(state({
-  sessionUsage: { liveContextTokens: 150, lastInputTokens: 150 },
-  lastCompactedAt: Date.now(),
+  sessionUsage: { liveContextTokens: 150, lastInputTokens: 150, lastCompactedAt: Date.now() },
 })), false);
 assert.strictEqual(shouldAutoCompact(state({
-  sessionUsage: { liveContextTokens: 250, lastInputTokens: 250 },
-  lastCompactedAt: Date.now(),
+  sessionUsage: { liveContextTokens: 250, lastInputTokens: 250, lastCompactedAt: Date.now() },
 })), true);
 
+fs.rmSync(configDir, { recursive: true, force: true });
 console.log("usage accounting OK");