@inetafrica/open-claudia 3.4.11 → 3.4.13

package/test-kazee-call-manager.js

@@ -94,7 +94,7 @@ function fixture() {
     if (["call:allocate", "call:room-access"].includes(name)) {
       setImmediate(() => originalEmit(`${name}-result`, { requestId: payload.requestId, ok: true, protocolVersion: 3,
         callAttemptId: "managed-attempt-123456789", organizationId: "tenant-a", roomId: 100, chatId: "managed-chat",
-        deviceId: payload.deviceId, generation: 0, ...replyPlacement, janusToken: "root-token", roomToken: "room-token", roomTokenExpiresAt: Date.now() + 300000, leaseExpiresAt: Date.now() + 120000 }));
+        deviceId: payload.deviceId, generation: 0, roomAdmissionRequired: true, iceServers: [{ urls: ["turn:secondary:3478", "turns:secondary:5349"], username: "assigned", credential: "assigned" }], iceCredentialsExpiresAt: Date.now() + 3600000, ...replyPlacement, janusToken: "root-token", roomToken: "room-token", roomTokenExpiresAt: Date.now() + 300000, leaseExpiresAt: Date.now() + 120000 }));
     }
     return originalEmit(name, payload);
   };
@@ -105,7 +105,8 @@ function fixture() {
   assert.strictEqual(f.manager.session.options.janusToken, "root-token");
   assert.strictEqual(f.manager.session.options.roomToken, "room-token");
   assert.strictEqual(f.manager.session.options.janusUrl, "wss://assigned/janus");
-  assert.deepStrictEqual(f.manager.session.options.iceServers[0].urls, ["turn:relay:3478"]);
+  assert.strictEqual(f.manager.session.options.iceServers[0].urls, "turn:secondary:3478");
+  assert.ok(f.manager.session.options.iceCredentialsExpiresAt > Date.now());
   const refreshed = await f.manager.session.options.refreshRoomAccess();
   assert.strictEqual(refreshed.server, "wss://assigned/janus");
   replyPlacement = {nodeId: "secondary", server: "wss://other/janus"};
@@ -139,8 +140,12 @@ function fixture() {
   assert.strictEqual(f.manager.session, null, "authoritative end also ends an unanswered modern call");
   assert.strictEqual(socket.listenerCount("call:allocate-result"), 0);
   assert.strictEqual(socket.listenerCount("call:heartbeat-result"), 0, "ended manager session releases lease listener");
-  await f.manager.incoming({ fromUserId: "owner-1", chatId: "managed-chat", roomId: 100, callType: "audio", callAttemptId: managedInvite.callAttemptId, organizationId: "tenant-a" });
+  f.manager.adapter._request = async () => ({ config: { roomAdmissionEnabled: false, janusServer: "wss://legacy/janus", iceServers: [{ urls: "turn:legacy:3478", username: "legacy", credential: "legacy" }] } });
+  await f.manager.incoming({ fromUserId: "owner-1", chatId: "managed-chat", roomId: 100, callType: "audio", callAttemptId: managedInvite.callAttemptId, organizationId: "tenant-a", roomAdmissionRequired: true });
   const incomingManaged = f.manager.session;
+  assert.strictEqual(incomingManaged.options.managedRoom, true);
+  assert.strictEqual(incomingManaged.options.janusUrl, "wss://assigned/janus");
+  assert.strictEqual(incomingManaged.options.iceServers[0].urls, "turn:secondary:3478");
   const managedAccept = emitted.filter(event => event.name === "call:accept").at(-1).payload;
   assert.strictEqual(managedAccept.deviceId, f.manager.deviceId);
   assert.strictEqual(managedAccept.generation, 0);
@@ -156,6 +161,19 @@ function fixture() {
   assert.strictEqual(socket.listenerCount("call:heartbeat-result"), 0);
 
 
+  // Legacy attempts, including those with modern attempt IDs, keep baseline
+  // transport even when the organization now enables new managed allocations.
+  for (const roomAdmissionRequired of [undefined, false]) {
+    f = fixture();
+    f.manager.adapter._request = async () => ({ config: { roomAdmissionEnabled: true, janusServer: "wss://legacy/janus", iceServers: [{ urls: "turn:legacy:3478", username: "legacy", credential: "legacy" }] } });
+    await f.manager.incoming({ fromUserId: "owner-1", chatId: "legacy", roomId: 99, callType: "audio", callAttemptId: "legacy-attempt-123456789", roomAdmissionRequired });
+    assert.strictEqual(f.manager.session.options.managedRoom, false);
+    assert.strictEqual(f.manager.session.options.janusUrl, "wss://legacy/janus");
+    assert.strictEqual(f.manager.session.options.refreshRoomAccess, undefined);
+    assert.ok(!f.events.some(event => event.name === "call:room-access"));
+    await f.manager.stop();
+  }
+
   f = fixture();
   await f.manager.incoming({ fromUserId: "owner-1", chatId: "managed-chat", roomId: 100, callType: "video", callAttemptId: "managed-attempt-123456789", organizationId: "tenant-a", generation: 7 });
   assert.strictEqual(f.events[0].payload.generation, 7, "pre-access decline preserves recipient reinvite generation");
@@ -200,12 +218,23 @@ function fixture() {
   accessSocket.emit("call:allocate-result", { requestId: requested.requestId, ok: true, protocolVersion: 3, callAttemptId: "attempt-1234567890", organizationId: "tenant-a", roomId: 20, chatId: "chat", deviceId: "different-device", generation: 0, janusToken: "t", roomToken: "t", roomTokenExpiresAt: Date.now() + 300000 });
   await assert.rejects(accessPromise, /Invalid call room/);
   assert.strictEqual(accessSocket.listenerCount("call:allocate-result"), 0);
-  for (const server of ["http://assigned/janus", "wss://user:password@assigned/janus", "wss://assigned/janus#fragment", 123]) {
+  for (const server of ["http://assigned/janus", "wss://user:password@assigned/janus", "wss://assigned/janus#fragment", "wss://assigned/janus?token=bad", 123]) {
     const invalid = requestRoomAccess(accessSocket, "allocate", { deviceId: "device-1234567890", chatId: "chat" });
     accessSocket.emit("call:allocate-result", { requestId: requested.requestId, ok: true, protocolVersion: 3, callAttemptId: "attempt-1234567890", organizationId: "tenant-a", roomId: 20, chatId: "chat", deviceId: "device-1234567890", generation: 0, server, janusToken: "t", roomToken: "t", roomTokenExpiresAt: Date.now() + 300000 });
     await assert.rejects(invalid, /Invalid call room/);
     assert.strictEqual(accessSocket.listenerCount("call:allocate-result"), 0);
   }
+  for (const malformed of [
+    { roomAdmissionRequired: undefined }, { roomAdmissionRequired: false },
+    { iceServers: undefined }, { iceServers: [] }, { iceCredentialsExpiresAt: Date.now() - 1 },
+    { iceServers: [{ urls: 'turn:user:secret@relay:3478', username: 'u', credential: 'p' }] },
+    { iceServers: [{ urls: 'turn:relay:3478' }] },
+  ]) {
+    const invalid = requestRoomAccess(accessSocket, "allocate", { deviceId: "device-1234567890", chatId: "chat" });
+    accessSocket.emit("call:allocate-result", { requestId: requested.requestId, ok: true, protocolVersion: 3, callAttemptId: "attempt-1234567890", organizationId: "tenant-a", roomId: 20, chatId: "chat", deviceId: "device-1234567890", generation: 0, server: "wss://assigned/janus", nodeId: "secondary", roomAdmissionRequired: true, iceServers: [{ urls: 'turn:relay:3478', username: 'u', credential: 'p' }], iceCredentialsExpiresAt: Date.now() + 3600000, janusToken: "t", roomToken: "t", roomTokenExpiresAt: Date.now() + 300000, ...malformed });
+    await assert.rejects(invalid, /Invalid call room/);
+    assert.strictEqual(accessSocket.listenerCount("call:allocate-result"), 0);
+  }
   const controller = new AbortController();
   const cancelledAccess = requestRoomAccess(accessSocket, "allocate", { deviceId: "device-1234567890", chatId: "chat" }, { signal: controller.signal });
   controller.abort();

package/test-kazee-call-session.js

@@ -19,7 +19,7 @@ class FakeJanus {
 }
 
 class FakePC {
-  constructor() { this.onTrack = { subscribe: () => {} }; }
+  constructor(options) { this.options = options; this.onTrack = { subscribe: () => {} }; }
   addTrack() { return { codec: { payloadType: 111 } }; }
   async createOffer() { return {}; }
   async setLocalDescription() {}
@@ -448,19 +448,22 @@ async function testManagedRoomCredentials() {
     constructor(options) { super(); this.options = options; this.calls = []; }
     async message(handle, body) {
       this.calls.push(body);
-      if (body.request === "join" && body.ptype === "publisher") return { plugindata: { data: { videoroom: "joined", private_id: 999, publishers: [] } } };
+      if (body.request === "join" && body.ptype === "publisher") return { plugindata: { data: { videoroom: "joined", id: 41, private_id: 999, publishers: [] } } };
       return {};
     }
   }
   let refreshes = 0;
   const session = new KazeeCallSession({ roomId: 7, chatId: "chat", callerId: "owner", botUserId: "bot", janusUrl: "ws://test",
-    janusToken: "root-token", roomToken: "publisher-token", roomTokenExpiresAt: Date.now() + 300000, managedRoom: true, asCaller: true,
-    refreshRoomAccess: async () => { refreshes += 1; return { janusToken: "fresh-root", janusTokenExpiresAt: Date.now() + 86400000, roomToken: "subscriber-token", roomTokenExpiresAt: Date.now() + 300000 }; },
+    janusToken: "root-token", roomToken: "publisher-token", roomTokenExpiresAt: Date.now() + 300000, managedRoom: true, asCaller: true, iceServers: [{ urls: "turn:relay:3478", username: "fixture", credential: "fixture" }], iceCredentialsExpiresAt: Date.now() + 3600000,
+    refreshRoomAccess: async () => { refreshes += 1; return { iceServers: [{ urls: "turn:relay:3478", username: "fresh", credential: "fresh" }], iceCredentialsExpiresAt: Date.now() + 3600000, janusToken: "fresh-root", janusTokenExpiresAt: Date.now() + 86400000, roomToken: "subscriber-token", roomTokenExpiresAt: Date.now() + 300000 }; },
     JanusClientImpl: SignedJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream });
   session._maybePublish = async () => {};
   await session.start();
   assert.strictEqual(session.janus.options.token, "root-token");
   assert.strictEqual(session.janus.calls[0].token, "publisher-token");
+  await session._consumePublisherFrame({ plugindata: { data: { publishers: [{ id: 41, display: 'canonical-bot@calling.invalid' }, { id: 42, display: 'open-claudia:legacy-bot' }] } } });
+  assert.strictEqual(session.subscribers.size, 0, 'own joined publisher ID is excluded independently of canonical display; legacy bot exclusion remains');
+
   session.roomTokenExpiresAt = Date.now() - 1;
   await Promise.all([session._subscribe(17, "owner"), session._subscribe(18, "other")]);
   const subJoin = session.janus.calls.find(body => body.ptype === "subscriber");
@@ -481,7 +484,61 @@ async function testManagedRoomCredentials() {
   assert.ok(!session.janus.calls.some(body => ["create", "destroy"].includes(body.request)), "server allocated room ownership never transfers to the bot");
 }
 
+async function testAssignedRelayTransportLifetime() {
+  const { RTCPeerConnection } = require('werift');
+  const originalExpiry = Date.now() + 3600000;
+  const assigned = (username, expiresAt) => ({ iceServers: [{ urls: 'turn:127.0.0.1:3478', username, credential: username + '-password' }], iceCredentialsExpiresAt: expiresAt });
+  const session = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true,
+    ...assigned('original-fixture', originalExpiry), roomToken: 'room', roomTokenExpiresAt: Date.now() + 300000,
+    refreshRoomAccess: async () => ({ ...assigned('renewed-fixture', originalExpiry + 3600000), roomToken: 'renewed-room', roomTokenExpiresAt: Date.now() + 300000, janusToken: 'renewed-root', janusTokenExpiresAt: Date.now() + 300000 }),
+    JanusClientImpl: FakeJanus, PeerConnectionImpl: RTCPeerConnection, SpeechStreamImpl: FakeSpeechStream });
+  try {
+    const old = session._newPeerConnection(); old.addTransceiver('audio');
+    assert.strictEqual(old.iceTransports[0].connection.options.turnUsername, 'original-fixture');
+    // Calling Werift's public setter cannot refresh an already-created ICE
+    // transport. Verify the installed implementation, without network gathering.
+    old.setConfiguration({ iceServers: assigned('setter-fixture', originalExpiry).iceServers });
+    assert.strictEqual(old.getConfiguration().iceServers[0].username, 'setter-fixture');
+    assert.strictEqual(old.iceTransports[0].connection.options.turnUsername, 'original-fixture');
+    await session._roomAuth(true);
+    assert.strictEqual(session._transportIceExpiry.get(old), originalExpiry, 'new access never extends an existing allocation deadline');
+    assert.strictEqual(old.iceTransports[0].connection.options.turnUsername, 'original-fixture');
+    const fresh = session._newPeerConnection(); fresh.addTransceiver('audio');
+    assert.strictEqual(fresh.iceTransports[0].connection.options.turnUsername, 'renewed-fixture');
+    assert.strictEqual(session._transportIceExpiry.get(fresh), originalExpiry + 3600000);
+  } finally { await session.close(); }
+  assert.strictEqual(session._transportExpiryTimer, null);
+  assert.strictEqual(session._transportIceExpiry.size, 0);
+
+  let ended;
+  const bounded = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true,
+    ...assigned('short-fixture', Date.now() + 1500), roomToken: 'room', roomTokenExpiresAt: Date.now() + 300000,
+    refreshRoomAccess: async () => ({ ...assigned('fresh-fixture', Date.now() + 3600000), roomToken: 'fresh', roomTokenExpiresAt: Date.now() + 300000 }),
+    onEnded: reason => { ended = reason; }, JanusClientImpl: FakeJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream });
+  try {
+    const old = bounded._newPeerConnection();
+    const deadline = bounded._transportIceExpiry.get(old);
+    await bounded._roomAuth(true);
+    assert.strictEqual(bounded._transportIceExpiry.get(old), deadline);
+    const until = Date.now() + 2000;
+    while (!bounded.closed && Date.now() < until) await wait(25);
+    assert.strictEqual(ended, 'relay-credentials-expired', 'existing transport closes on its original expiry despite successful refresh');
+  } finally { await bounded.close(); }
+
+  let publications = 0;
+  class PublishingPC extends FakePC { constructor(options) { super(options); publications += 1; } }
+  class PublishingJanus extends FakeJanus { async message() { return { jsep: { type: 'answer', sdp: 'fixture' } }; } }
+  const concurrent = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true,
+    ...assigned('original-fixture', Date.now() + 3600000), roomToken: 'room', roomTokenExpiresAt: Date.now() + 300000,
+    JanusClientImpl: PublishingJanus, PeerConnectionImpl: PublishingPC });
+  try { await Promise.all([concurrent._publish(), concurrent._publish()]); assert.strictEqual(publications, 1, 'concurrent publisher events cannot race across async room authorization'); } finally { await concurrent.close(); }
+
+  const missing = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true, JanusClientImpl: FakeJanus, PeerConnectionImpl: FakePC });
+  try { assert.throws(() => missing._newPeerConnection(), /relay credentials unavailable/); } finally { await missing.close(); }
+}
+
 (async () => {
+  await testAssignedRelayTransportLifetime();
   await testManagedRoomCredentials();
   await testSpeakSerialization();
   await testSpeakCancellation();

package/test-provider-codex.js

@@ -134,6 +134,18 @@ const directResume = provider.buildMainInvocation(simpleContext({ sessionId: "th
 assert.ok(directResume.args.includes("--dangerously-bypass-approvals-and-sandbox"));
 assert.ok(directResume.args.indexOf("--dangerously-bypass-approvals-and-sandbox") < directResume.args.indexOf("thread-direct"));
 
+{
+  const before = process.env.CODEX_MULTI_AGENT;
+  delete process.env.CODEX_MULTI_AGENT;
+  assert.ok(!provider.buildMainInvocation(simpleContext({})).args.includes("features.multi_agent=false"), "multi_agent stays as Codex ships it by default");
+  process.env.CODEX_MULTI_AGENT = "off";
+  const noAgents = provider.buildMainInvocation(simpleContext({}));
+  const at = noAgents.args.indexOf("features.multi_agent=false");
+  assert.ok(at > 0 && noAgents.args[at - 1] === "-c", "CODEX_MULTI_AGENT=off passes -c features.multi_agent=false");
+  assert.ok(at < noAgents.args.indexOf("--json"), "the override sits with the other -c overrides, before the exec flags");
+  if (before === undefined) delete process.env.CODEX_MULTI_AGENT; else process.env.CODEX_MULTI_AGENT = before;
+}
+
 const continued = provider.buildMainInvocation(simpleContext({ continueSession: true, sessionId: "thread-continue" }));
 assert.strictEqual(continued.args[1], "resume");
 assert.ok(continued.args.includes("thread-continue"));

package/test-provider-events.js

@@ -203,7 +203,7 @@ 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: "usage", usage: { input_tokens: 20, cached_input_tokens: 5, output_tokens: 4 }, scope: "turn" },
   { type: "result", text: "", sessionId: "codex-thread-1" },
 ]);
 assert.deepStrictEqual(normalizeCodexEvent(samples.codex.result, codexState), [], "duplicate Codex terminal and usage settle once");

package/test-provider-language.js

@@ -463,8 +463,10 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // Codex turn. Live probe: unified-exec shell calls still reach PreToolUse as
 // tool_name "Bash" and the deny gate caught the probe, so the gate no longer
 // requires unified_exec off. Push approved by Sumeet before release.
-// 3.4.11: owner approved end-to-end calling rollout on 2026-09-05.
-assert.strictEqual(pkg.version, "3.4.11", "release version must remain unchanged without explicit approval");
+// 3.4.12: Sumeet approved the full calling rollout on 2026-09-05; preserve assigned media configuration across canary changes.
+// 3.4.13: Codex usage accounting fix — Sumeet approved the three-bug fix on 2026-09-05 ("Yes");
+// prepared 2026-09-06 for his release go. Rollout-based Codex context, per-turn ledger, sub-agent + quota accounting.
+assert.strictEqual(pkg.version, "3.4.13", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }

package/test-usage-accounting.js

@@ -9,6 +9,7 @@ const {
   normalizeCodexUsage,
   applyUsageToState,
   shouldAutoCompact,
+  effectiveCompactThreshold,
   peakContextTokens,
   usageSessionColdStart,
 } = require("./core/runner");
@@ -48,7 +49,9 @@ function state(overrides = {}) {
 
 assert.deepStrictEqual(
   usageParts({ input_tokens: 100, cached_input_tokens: 60, output_tokens: 10 }, "codex"),
-  { input: 100, cacheRead: 60, cacheCreation: 0, output: 10, context: 100 },
+  // OpenAI counts cached tokens inside input_tokens: `input` is the uncached
+  // part so it compares like-for-like with Claude; `context` is the full prefix.
+  { input: 40, cacheRead: 60, cacheCreation: 0, output: 10, context: 100 },
 );
 
 assert.deepStrictEqual(
@@ -62,7 +65,7 @@ const first = normalizeCodexUsage(s, "codex-session-1", {
   cached_input_tokens: 700,
   output_tokens: 50,
 }, { project: "alpha" });
-assert.strictEqual(first.usageScope, "session_total");
+assert.strictEqual(first.usageScope, "turn", "Codex turn.completed usage is per turn, never a session total");
 assert.strictEqual(usageParts(first.usage, "codex").context, 1000);
 
 const second = normalizeCodexUsage(s, "codex-session-1", {
@@ -70,13 +73,13 @@ const second = normalizeCodexUsage(s, "codex-session-1", {
   cached_input_tokens: 800,
   output_tokens: 80,
 }, { project: "alpha" });
-assert.strictEqual(second.usageScope, "turn_delta");
+assert.strictEqual(second.usageScope, "turn");
+// No delta against the previous turn: a smaller turn after a bigger one used
+// to be recorded as 0 (9 of 36 Codex turns on 2026-09-05).
 assert.deepStrictEqual(second.usage, {
-  input_tokens: 250,
-  cached_input_tokens: 100,
-  cache_read_input_tokens: 0,
-  cache_creation_input_tokens: 0,
-  output_tokens: 30,
+  input_tokens: 1250,
+  cached_input_tokens: 800,
+  output_tokens: 80,
 });
 
 applyUsageToState(s, second.usage, 0, {
@@ -87,9 +90,9 @@ applyUsageToState(s, second.usage, 0, {
   liveContextTokens: usageParts(second.rawUsage, "codex").context,
 });
 assert.strictEqual(s.sessionUsage.turns, 1);
-assert.strictEqual(s.sessionUsage.inputTokens, 250);
-assert.strictEqual(s.sessionUsage.cacheReadTokens, 100);
-assert.strictEqual(s.sessionUsage.lastInputTokens, 250);
+assert.strictEqual(s.sessionUsage.inputTokens, 450, "uncached input only");
+assert.strictEqual(s.sessionUsage.cacheReadTokens, 800);
+assert.strictEqual(s.sessionUsage.lastInputTokens, 1250);
 assert.strictEqual(s.sessionUsage.liveContextTokens, 1250);
 
 // The same native-looking ID in another project has an independent cumulative
@@ -99,7 +102,7 @@ const otherProject = normalizeCodexUsage(s, "codex-session-1", {
   cached_input_tokens: 1200,
   output_tokens: 100,
 }, { project: "beta" });
-assert.strictEqual(otherProject.usageScope, "session_total");
+assert.strictEqual(otherProject.usageScope, "turn");
 s.currentSession = { name: "beta", dir: "/workspace/beta" };
 s.settings.backend = "claude";
 s.activeSessions.beta = { claude: "claude-beta", codex: "codex-session-1" };
@@ -154,6 +157,36 @@ assert.strictEqual(shouldAutoCompact(state({
   sessionUsage: { liveContextTokens: 250, lastInputTokens: 250, lastCompactedAt: Date.now() },
 })), true);
 
+// Codex is compacted at 80% of the window it reports, because its window
+// (258k on gpt-6-astra) is below the default threshold — measured honestly the
+// bot would otherwise never compact a Codex session.
+{
+  const windowed = state({ sessionUsage: { liveContextTokens: 210000, lastInputTokens: 210000, contextWindowTokens: 258400 } });
+  delete windowed.settings.compactWindow;
+  assert.strictEqual(effectiveCompactThreshold(windowed), 206720, "80% of the reported Codex window");
+  assert.strictEqual(shouldAutoCompact(windowed), true, "210k of a 258k window compacts");
+  windowed.sessionUsage.liveContextTokens = 200000;
+  assert.strictEqual(shouldAutoCompact(windowed), false, "200k of a 258k window does not");
+  windowed.settings.backend = "claude";
+  assert.strictEqual(effectiveCompactThreshold(windowed), 380000, "the Codex window cap never applies to Claude");
+}
+
+// Rollout-derived facts ride along into the session bucket.
+{
+  const enriched = state();
+  applyUsageToState(enriched, { input_tokens: 1000, cached_input_tokens: 900, output_tokens: 10 }, 0, {
+    backend: "codex", project: "alpha", sessionId: "codex-session-1", usageScope: "turn", liveContextTokens: 1000,
+    contextWindowTokens: 258400, quota: { usedPercent: 31, resetsAt: "2026-09-12T13:57:00.000Z" },
+    subagents: { threads: 2, requests: 5, totals: { input: 70000, cached: 50000, output: 300 } },
+  });
+  assert.strictEqual(enriched.sessionUsage.contextWindowTokens, 258400);
+  assert.strictEqual(enriched.sessionUsage.quotaUsedPercent, 31);
+  assert.strictEqual(enriched.sessionUsage.subagentThreads, 2);
+  assert.strictEqual(enriched.sessionUsage.subagentInputTokens, 20000, "sub-agent input is stored uncached");
+  assert.strictEqual(enriched.sessionUsage.subagentCacheReadTokens, 50000);
+  assert.strictEqual(enriched.sessionUsage.subagentOutputTokens, 300);
+}
+
 // peakContextTokens: the live context number must be the LARGEST single API
 // call, not the turn-cumulative sum (the v3.0.0 347k-vs-160k regression).
 assert.strictEqual(peakContextTokens([