@inetafrica/open-claudia 3.5.17 → 3.5.18

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" },

package/test-provider-language.js

@@ -578,7 +578,15 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // 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.
-assert.strictEqual(pkg.version, "3.5.17", "release version must remain unchanged without explicit approval");
+// 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-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",
@@ -1633,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-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,