@inetafrica/open-claudia 3.5.16 → 3.5.18

package/test-provider-compaction.js

@@ -97,9 +97,11 @@ async function immutableSuccessProbe() {
   assert.strictEqual(stateApi.acquireRunLock(state), false, "foreground admission stays closed between compaction stages");
   alphaLane().isCompacting = false;
   const contexts = [];
-  const service = serviceWith(async (_prompt, _cwd, options) => {
+  const prompts = [];
+  const service = serviceWith(async (prompt, _cwd, options) => {
     assert.strictEqual(options.persist, false, "compaction provider stages have no ordinary capture persistence");
     contexts.push(options.runContext);
+    prompts.push(String(prompt));
     assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude", "pointer stays old during both provider stages");
     if (contexts.length === 1) {
       state.currentSession = { name: "beta", dir: betaDir };
@@ -125,6 +127,11 @@ async function immutableSuccessProbe() {
   assert.strictEqual(contexts[1].timeoutMs, contexts[0].timeoutMs);
   assert.strictEqual(contexts[0].purpose, "compact-summary");
   assert.strictEqual(contexts[0].recallQuery, null, "summary stage carries no recall query");
+  // Claude runs the summary stage with --max-turns 1: a tool call (a transcript
+  // search, a status check) uses up the one turn and ends it with no brief, so
+  // the compaction fails and its cost is wasted (4 of 23 failed on 7-8 Oct).
+  assert.strictEqual(contexts[0].maxTurns, 1);
+  assert.ok(prompts[0].includes("Do NOT use any tools"), "the one-turn summary stage forbids tool calls");
   assert.strictEqual(contexts[1].purpose, "compact-seed");
   assert.ok(String(contexts[1].recallQuery || "").includes("A sufficiently detailed condensed continuation"),
     "seed recall query carries the condensed brief, not seed-prompt boilerplate");
@@ -156,6 +163,63 @@ async function immutableSuccessProbe() {
   assert.strictEqual(alphaLane().isCompacting, false);
 }
 
+// A scheduled job's own conversation (a branch beside the thread's live
+// session) is compacted in place of the live one: the summary reads the
+// branch, the lineage lands in the history and the index, and the thread's
+// live pointer stays where it is. Only the job follows the new session.
+async function branchCompactionProbe() {
+  resetFixture("claude");
+  state.usageBySession["alpha\0claude\0job-branch"] = { ...stateApi.freshUsage(), turns: 17, liveContextTokens: 894000 };
+  const contexts = [];
+  const recorded = [];
+  const service = serviceWith(async (_prompt, _cwd, options) => {
+    contexts.push(options.runContext);
+    return result({ sessionId: contexts.length === 1 ? "job-branch" : "job-branch-new" });
+  }, {
+    commitBranchCompaction: stateApi.commitBranchCompaction,
+    recordCompaction: (entry) => recorded.push(entry),
+  });
+  const compacted = await service.compact(alphaDir, {
+    operationId: "compact-branch", sessionId: "job-branch", provider: "claude", compactReason: "cold-resume",
+  });
+  assert.strictEqual(compacted.compacted, true, JSON.stringify(compacted));
+  assert.strictEqual(compacted.branch, true);
+  assert.strictEqual(compacted.oldSessionId, "job-branch");
+  assert.strictEqual(contexts[0].sessionId, "job-branch", "the summary stage reads the job's conversation");
+  assert.strictEqual(contexts[0].resumeSessionId, "job-branch");
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude", "the thread's live pointer stays");
+  const record = stateApi.getProjectSessions(state.userId, "alpha", "claude").find((entry) => entry.id === "job-branch-new");
+  assert.deepStrictEqual(record.lineage, {
+    type: "compaction",
+    operationId: "compact-branch",
+    previousSessionId: "job-branch",
+    newSessionId: "job-branch-new",
+    branch: true,
+  });
+  assert.strictEqual(state.completedCompactions["compact-branch"].previousSessionId, "job-branch");
+  assert.strictEqual(state.completedCompactions["compact-branch"].newSessionId, "job-branch-new");
+  const usage = stateApi.getUsageForSession(state, "alpha", "claude", "job-branch-new");
+  assert.strictEqual(usage.turns, 0, "the seed is not billed as a turn");
+  assert.strictEqual(usage.compactionCheckpoint.previousSessionId, "job-branch");
+  assert.ok(usage.lastCompactedAt > 0, "the new session carries the compaction spacing");
+  assert.strictEqual(recorded[0].branch, true);
+  assert.strictEqual(recorded[0].contextTokensBefore, 894000, "the context it replaced is the branch's, not the thread's");
+  assert.strictEqual(runner.recordCompactionUsage({ ...recorded[0] }, { appendUsageRecord: (entry) => entry }).scope, "job", "the ledger marks a job conversation");
+  assert.ok(!("scope" in runner.recordCompactionUsage({ compactReason: "threshold", provider: "claude" }, { appendUsageRecord: (entry) => entry })), "and only that");
+  assert.strictEqual(alphaLane().isCompacting, false);
+
+  const again = stateApi.commitBranchCompaction(state, {
+    operationId: "compact-branch", canonicalUserId: state.userId, project: "alpha", provider: "claude",
+    previousSessionId: "job-branch", newSessionId: "job-branch-new",
+  });
+  assert.strictEqual(again.duplicate, true, "a repeated commit is a no-op");
+  assert.throws(() => stateApi.commitBranchCompaction(state, {
+    operationId: "compact-became-live", canonicalUserId: state.userId, project: "alpha", provider: "claude",
+    previousSessionId: "old-claude", newSessionId: "other-new",
+  }), /became the live session/, "a branch that is now the live session is the thread's to compact");
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude");
+}
+
 async function failureProbe() {
   resetFixture("claude");
   alphaLane().runningProcess = { pid: 123 };
@@ -492,6 +556,7 @@ function restartRecoveryProbe() {
     assert.strictEqual(typeof runner.createCompactionService, "function");
     assert.strictEqual(typeof stateApi.commitProviderCompaction, "function");
     await immutableSuccessProbe();
+    await branchCompactionProbe();
     await failureProbe();
     await codexRestrictionProbe();
     await deferredWatchAcrossCompactionProbe();

package/test-provider-dream.js

@@ -267,7 +267,9 @@ async function providerProbe(kind) {
         assert.ok(record.argv.includes("plan"), "extra memory access does not expand the read-only boundary");
       }
     } else {
-      assert.ok(record.argv.includes("--output-schema"));
+      // The dream schemas have optional fields, which OpenAI strict mode refuses
+      // (6 Oct 2026); Codex gets none and the reply is checked locally.
+      assert.ok(!record.argv.includes("--output-schema"), "Codex is not handed a schema OpenAI strict mode would refuse");
       assert.ok(record.argv.some((arg) => /model_reasoning_effort=.*max/.test(arg)), "max effort passes through natively since codex 0.144 supports it");
     }
   }

package/test-provider-events.js

@@ -25,6 +25,7 @@ assert.deepStrictEqual([...NORMALIZED_EVENT_TYPES].sort(), [
   "tool_start",
   "usage",
   "warning",
+  "rate_limit",
 ].sort());
 
 const claudeState = createClaudeParserState();
@@ -189,6 +190,90 @@ assert.strictEqual(normalizeClaudeEvent({
   result: "",
 }, partialState).at(-1).type, "result");
 
+// Plan limits. Claude Code 2.1.280 reports each window's use on every fresh
+// run (shape captured live 7 Oct 2026) …
+const rateLimitState = createClaudeParserState();
+assert.deepStrictEqual(normalizeClaudeEvent({
+  type: "rate_limit_event",
+  rate_limit_info: {
+    status: "allowed_warning",
+    resetsAt: 1791939600,
+    rateLimitType: "seven_day",
+    utilization: 0.26,
+    isUsingOverage: false,
+    unifiedWindows: {
+      five_hour: { utilization: 0.57, resetsAt: 1791382800 },
+      seven_day: { utilization: 0.26, resetsAt: 1791939600 },
+    },
+  },
+  uuid: "u-1",
+  session_id: "s-1",
+}, rateLimitState), [{
+  type: "rate_limit",
+  provider: "claude",
+  status: "allowed_warning",
+  limitType: "seven_day",
+  resetsAt: 1791939600000,
+  windows: [
+    { id: "five_hour", usedPercent: 57, resetsAt: 1791382800000 },
+    { id: "seven_day", usedPercent: 26, resetsAt: 1791939600000 },
+  ],
+}]);
+assert.strictEqual(rateLimitState.limitHit, null, "a warning is not a limit hit");
+
+// … and a limit hit as status "rejected", a synthetic assistant notice
+// (error "rate_limit") and an error result. The notice is never answer text,
+// and the failure carries the reset time.
+const limitText = "You've hit your session limit · resets 4:10pm (Africa/Nairobi)";
+const limitState = createClaudeParserState();
+assert.strictEqual(normalizeClaudeEvent({
+  type: "rate_limit_event",
+  rate_limit_info: { status: "rejected", resetsAt: 1791205800, rateLimitType: "five_hour", isUsingOverage: false },
+}, limitState)[0].status, "rejected");
+assert.deepStrictEqual(normalizeClaudeEvent({
+  type: "assistant",
+  error: "rate_limit",
+  message: { model: "<synthetic>", role: "assistant", content: [{ type: "text", text: limitText }] },
+}, limitState), [], "the limit notice must not stream as a reply");
+const limitFailure = normalizeClaudeEvent({ type: "result", subtype: "success", is_error: true, result: limitText }, limitState);
+assert.deepStrictEqual(limitFailure, [{
+  type: "error",
+  message: limitText,
+  authError: false,
+  usageLimit: true,
+  refusal: false,
+  limitResetsAt: 1791205800000,
+  limitType: "five_hour",
+}]);
+
+// The same notice closed as a "success" (no answer text) still fails.
+const quietLimit = createClaudeParserState();
+normalizeClaudeEvent({
+  type: "assistant",
+  message: { model: "<synthetic>", content: [{ type: "text", text: "You've hit your weekly limit · resets Oct 9, 5am (UTC)" }] },
+}, quietLimit);
+const quietFailure = normalizeClaudeEvent({ type: "result", subtype: "success", is_error: false, result: "You've hit your weekly limit · resets Oct 9, 5am (UTC)" }, quietLimit);
+assert.strictEqual(quietFailure.at(-1).type, "error");
+assert.strictEqual(quietFailure.at(-1).usageLimit, true);
+
+// A rejection Claude Code recovered from (it answered) stays a success.
+const recovered = createClaudeParserState();
+normalizeClaudeEvent({ type: "rate_limit_event", rate_limit_info: { status: "rejected", rateLimitType: "seven_day_opus", resetsAt: 1791939600 } }, recovered);
+normalizeClaudeEvent({ type: "assistant", message: { content: [{ type: "text", text: "Here is the answer." }] } }, recovered);
+assert.strictEqual(normalizeClaudeEvent({ type: "result", subtype: "success", is_error: false, result: "Here is the answer." }, recovered).at(-1).type, "result");
+
+// Every wording of a plan limit counts as one, for both providers.
+for (const text of [
+  "You've hit your limit · resets 1pm (Africa/Nairobi)",
+  "You've hit your session limit · resets 11:30am (Africa/Nairobi)",
+  "You've hit your weekly limit · resets Oct 9, 5am (UTC)",
+  "You’ve hit your Opus limit · resets Oct 9, 5am (UTC)",
+  "You've hit your usage limit. Visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again at Sep 7th, 2026 5:28 AM.",
+]) {
+  assert.strictEqual(normalizeClaudeEvent({ type: "result", is_error: true, result: text }, createClaudeParserState())[0].usageLimit, true, text);
+  assert.strictEqual(normalizeCodexEvent({ type: "turn.failed", error: { message: text } }, createCodexParserState())[0].usageLimit, true, text);
+}
+
 const codexState = createCodexParserState();
 assert.deepStrictEqual(normalizeCodexEvent(samples.codex.session, codexState), [
   { type: "session", sessionId: "codex-thread-1" },
@@ -240,4 +325,25 @@ const isolatedB = createClaudeParserState();
 normalizeClaudeEvent(samples.claude.session, isolatedA);
 assert.deepStrictEqual(normalizeClaudeEvent(samples.claude.session, isolatedB), [{ type: "session", sessionId: "claude-session-1" }]);
 
+// Helper agents (the Agent/Task tool) stream their own messages with
+// parent_tool_use_id set. Their notes, tool calls and refusals are not this
+// turn's reply (6 Oct: an audit's helper narration was posted to the owner as
+// the answer, and one helper's refusal would have marked the turn refused).
+{
+  const st = createClaudeParserState();
+  const helper = { parent_tool_use_id: "toolu_helper" };
+  assert.deepStrictEqual(normalizeClaudeEvent({ ...helper, type: "stream_event", event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Let me look at the server files." } } }, st), [], "helper text delta is not reply text");
+  normalizeClaudeEvent({ ...helper, type: "stream_event", event: { type: "message_delta", delta: { stop_reason: "refusal" } } }, st);
+  const helperAssistant = normalizeClaudeEvent({ ...helper, type: "assistant", message: { id: "msg_helper", stop_reason: "refusal", content: [{ type: "text", text: "I can't give you the security review." }, { type: "tool_use", id: "toolu_inner", name: "Bash", input: {} }] } }, st);
+  assert.deepStrictEqual(helperAssistant.filter((event) => event.type !== "usage"), [], "helper text and tool calls stay out of the reply");
+  assert.deepStrictEqual(normalizeClaudeEvent({ ...helper, type: "user", message: { content: [{ type: "tool_result", tool_use_id: "toolu_inner", content: "ok" }] } }, st), [], "helper tool results are not this turn's tool activity");
+  assert.strictEqual(st.refusal, null, "a helper's refusal is not this turn's refusal");
+  assert.strictEqual(st.sawText, false, "helper text does not count as reply text");
+  assert.deepStrictEqual(
+    normalizeClaudeEvent({ type: "assistant", parent_tool_use_id: null, message: { id: "msg_main", content: [{ type: "text", text: "Here is the verdict." }] } }, st).filter((event) => event.type !== "usage"),
+    [{ type: "text_final", text: "Here is the verdict." }],
+    "the turn's own text still flows",
+  );
+}
+
 console.log("provider events OK");

package/test-provider-language.js

@@ -571,7 +571,22 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // bot's own browser (/api/browser/sessions + /api/browser/stream, Browser tab
 // on the dashboard), agent-browser pinned, the Codex hook re-check, and the
 // thread-lanes test fix that unblocks 3.5.15, which this release carries.
-assert.strictEqual(pkg.version, "3.5.16", "release version must remain unchanged without explicit approval");
+// 3.5.17 approved by Sumeet 2026-10-07: one combined release (main thread,
+// 09:21 EAT), then "implement this end to end and lets monitor it to see if
+// it improves the token economics over the next few days" (10:05 EAT, with
+// resuming interrupted turns): Release 1 (token diet canary, scheduling and
+// dream fixes, task archive, interrupted turns resume), the 7 Oct security
+// fixes, the 6 Oct dashboard and provider fixes, and the rule-catcher fix.
+// Canary on the owner's Mac bot (one thread on the token diet), then the fleet.
+// 3.5.18 approved by Sumeet 2026-10-08 09:25 EAT ("Yeah, go ahead and then
+// maybe by the end of the day if everything is stable on this bot, then we
+// roll it out to the whole fleet"), answering the 08:19 EAT plan for "Let's
+// roll it out to the fleet if we already seeing savings?": the token diet on
+// by default (fleet pods set no TOKEN_DIET_* env), the compaction summary
+// step without tools, the same cap for scheduled jobs' own conversations,
+// and usage-limit pick-ups with 80/95% warnings. This Mac bot first, then the
+// fleet once it is stable here.
+assert.strictEqual(pkg.version, "3.5.18", "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-provider-pack-review.js

@@ -230,7 +230,9 @@ async function providerProbe(kind) {
   if (kind === "claude") assert.ok(captureRecord.argv.includes("plan"), "Claude reviewer is read-only");
   else {
     assert.ok(captureRecord.argv.includes("read-only"), "Codex reviewer is read-only");
-    assert.ok(captureRecord.argv.includes("--output-schema"), "Codex receives the reviewer schema file");
+    // The reviewer schema has free-form objects, which OpenAI strict mode refuses
+    // (6 Oct 2026); Codex gets none and the reply is checked locally.
+    assert.ok(!captureRecord.argv.includes("--output-schema"), "Codex is not handed a schema OpenAI strict mode would refuse");
   }
 
   const metrics = JSON.parse(fs.readFileSync(path.join(process.env.OPEN_CLAUDIA_CONFIG_DIR, "recall-metrics-summary.json"), "utf8"));

package/test-provider-scheduler.js

@@ -442,6 +442,7 @@ function schedulerHarness(createSchedulerService, seed, options = {}) {
       return next && typeof next.then === "function" ? next : next;
     },
     providerStatus: options.providerStatus || (() => ({ availability: { state: "available" }, auth: { state: "authenticated" } })),
+    getProjectSessions: options.getProjectSessions || (() => []),
     fallbackProviders: options.fallbackProviders || [],
     retryDelayMs: 1000,
     busyDelayMs: 250,
@@ -615,6 +616,73 @@ async function detachedHistoricalBranchProbe(createSchedulerService) {
   assert.strictEqual(h.admissions[0].opts.attachSession, false, "historical scheduled work must not replace an unrelated live branch");
 }
 
+// The completed-compactions index keeps only the last 20, under a day of
+// token-diet compactions, so the conversation's session history is walked too
+// (7 Oct: the PBX thread's wakeup and watch lost their entry and resumed a
+// 790k session compacted that morning). A recurring job then remembers the
+// session it ran on, so it never depends on old lineage records again.
+async function historyLineageProbe(createSchedulerService) {
+  // Newest first, as getProjectSessions returns them.
+  const history = [
+    { id: "claude-third", provider: "claude", lineage: { type: "compaction", previousSessionId: "claude-second", newSessionId: "claude-third" } },
+    { id: "claude-second", provider: "claude", lineage: { type: "compaction", previousSessionId: "claude-before-compact", newSessionId: "claude-second" } },
+    { id: "claude-before-compact", provider: "claude" },
+  ];
+  const lookups = [];
+  const cron = (id, extra = {}) => baseJob({ id, kind: "cron", schedule: "0 * * * *", fireAt: undefined, occurrenceId: `occ-${id}`, ...extra });
+  const pruned = schedulerHarness(createSchedulerService, [cron("pruned")], {
+    state: {
+      userId: "fixture-user",
+      currentSession: { name: "other", dir: "/workspace/other" },
+      settings: { backend: "claude" },
+      activeSessions: { alpha: { claude: "claude-third" } },
+      completedCompactions: {},
+    },
+    getProjectSessions: (userId, project, provider) => { lookups.push([userId, project, provider]); return history; },
+    outcomes: [{ ...succeededRun(), sessionId: "claude-third" }],
+  });
+  await pruned.service.fireJob("pruned");
+  assert.deepStrictEqual(lookups[0], ["fixture-user", "alpha", "claude"], "the job's own conversation history, under its provider");
+  assert.strictEqual(pruned.admissions[0].opts.resumeSessionId, "claude-third", "a pruned index entry no longer strands the job on its old session");
+  assert.strictEqual(pruned.admissions[0].opts.attachSession, true, "it reached the thread's live session");
+  assert.strictEqual(pruned.jobsStore.get("pruned").sessionId, "claude-third", "a recurring job remembers the session it ran on");
+
+  // A job on its own branch whose run moved to a compacted session (cold
+  // resume) keeps that session; the thread's live session is not its own.
+  const branch = schedulerHarness(createSchedulerService, [cron("branch")], {
+    state: {
+      userId: "fixture-user",
+      currentSession: { name: "other", dir: "/workspace/other" },
+      settings: { backend: "claude" },
+      activeSessions: { alpha: { claude: "unrelated-live-session" } },
+      completedCompactions: {},
+    },
+    outcomes: [{ ...succeededRun(), sessionId: "claude-branch-compacted" }],
+  });
+  await branch.service.fireJob("branch");
+  assert.strictEqual(branch.admissions[0].opts.resumeSessionId, "claude-before-compact");
+  assert.strictEqual(branch.admissions[0].opts.attachSession, false);
+  assert.strictEqual(branch.jobsStore.get("branch").sessionId, "claude-branch-compacted", "the job follows its compacted conversation");
+
+  // A run that did not resume the job's conversation (provider switched:
+  // fresh, on another provider) leaves the saved session alone; so does a
+  // one-shot, which is removed anyway.
+  const switched = schedulerHarness(createSchedulerService, [cron("switched")], {
+    state: {
+      userId: "fixture-user",
+      currentSession: { name: "other", dir: "/workspace/other" },
+      settings: { backend: "codex" },
+      providerSettings: { codex: { model: "codex-current" } },
+      activeSessions: { alpha: { claude: "claude-before-compact", codex: "codex-live" } },
+      completedCompactions: {},
+    },
+    outcomes: [{ ...succeededRun(), sessionId: "codex-fresh-thread" }],
+  });
+  await switched.service.fireJob("switched");
+  assert.strictEqual(switched.admissions[0].opts.fresh, true);
+  assert.strictEqual(switched.jobsStore.get("switched").sessionId, "claude-before-compact", "a fresh run on another provider is not the job's conversation");
+}
+
 async function busyRestartAndMissedProbe(createSchedulerService) {
   const busyState = {
     userId: "fixture-user",
@@ -1276,7 +1344,9 @@ async function durablePendingProbe(createSchedulerService, jobsApi) {
     await retry.service.fireJob("failure");
     assert.strictEqual(retry.jobsStore.get("failure").status, "dead-letter", "real failures retain bounded retries");
     assert.strictEqual(retry.jobsStore.get("failure").attemptCount, 3);
-    assert.strictEqual(retry.sends.length, 0, "advisory is not repeated across failure/restart");
+    await nextTurn();
+    assert.strictEqual(retry.sends.filter((text) => !/gave up/.test(text)).length, 0, "advisory is not repeated across failure/restart");
+    assert.strictEqual(retry.sends.filter((text) => /gave up \(SCHEDULED_RUN_FAILED\)/.test(text)).length, 1, "the dead-lettered watch says so once");
     retry.service.stopAll();
   } finally {
     fs.rmSync(configDir, { recursive: true, force: true });
@@ -1631,6 +1701,7 @@ async function main() {
   await duplicateFireProbe(schedulerApi.createSchedulerService);
   await failureAndRetryProbe(schedulerApi.createSchedulerService);
   await detachedHistoricalBranchProbe(schedulerApi.createSchedulerService);
+  await historyLineageProbe(schedulerApi.createSchedulerService);
   await busyRestartAndMissedProbe(schedulerApi.createSchedulerService);
   await threadLaneProbe(schedulerApi.createSchedulerService);
   await durablePendingProbe(schedulerApi.createSchedulerService, jobsApi);

package/test-thread-lanes.js

@@ -39,6 +39,11 @@ fs.mkdirSync(configDir, { recursive: true });
 fs.mkdirSync(workspace, { recursive: true });
 const OWNER = "owner-chat-777";
 process.env.OPEN_CLAUDIA_TEST = "1";
+// The fake agent CLI is the configured Claude Code, so a run has a provider
+// without the npm test environment (CI runs this file alone).
+process.env.CLAUDE_PATH = path.join(__dirname, "test-fixtures", "fake-agent-cli.js");
+process.env.FAKE_AGENT_KIND = "claude";
+process.env.AGENT_ENV_PASSTHROUGH = "FAKE_AGENT_KIND";
 process.env.OPEN_CLAUDIA_CONFIG_DIR = configDir;
 process.env.WORKSPACE = workspace;
 process.env.TELEGRAM_CHAT_ID = OWNER;
@@ -504,7 +509,7 @@ async function wiringAndBounds() {
       project: { name: conversationKeyFor("telegram", "dedupe-chan", threadId), dir: workspace },
     },
   }));
-  const full = (text) => text.includes("## Pending tasks\n");
+  const full = (text) => text.includes("## Pending tasks (this conversation)\n");
   assert.ok(full(block(null)), "main timeline: full tree first");
   assert.ok(full(block(T(8))), "thread: full tree first");
   assert.ok(!full(block(null)), "back in the main timeline: only the count (not re-injected)");

package/test-usage-accounting.js

@@ -4,6 +4,10 @@ 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;
+// These cases pin the classic thresholds (AUTO_COMPACT_TOKENS, Codex's
+// 80%-of-window rule). The token diet, on by default since 3.5.18, has its own
+// test (test-token-diet.js).
+process.env.TOKEN_DIET_CONVERSATIONS = "off";
 const {
   usageParts,
   normalizeCodexUsage,