@inetafrica/open-claudia 3.5.17 → 3.5.19

package/test-fixtures/fake-agent-cli.js

@@ -290,7 +290,28 @@ function claudeEvents(sessionId) {
     ];
   }
 
+  if (scenario === "usage-limit") {
+    // Claude Code 2.1.280 at a plan limit: the rejected rate_limit_event, the
+    // synthetic notice (error "rate_limit") and an error result.
+    const resetsAt = integerControl("FAKE_AGENT_LIMIT_RESETS_AT", Math.floor(Date.now() / 1000) + 3600, { min: 0, max: 2 ** 31 });
+    const text = process.env.FAKE_AGENT_LIMIT_TEXT || "You've hit your session limit · resets 5pm (UTC)";
+    return [
+      init,
+      {
+        type: "rate_limit_event",
+        rate_limit_info: { status: "rejected", resetsAt, rateLimitType: process.env.FAKE_AGENT_LIMIT_TYPE || "five_hour", isUsingOverage: false },
+        session_id: sessionId,
+      },
+      { type: "assistant", error: "rate_limit", message: { model: "<synthetic>", role: "assistant", content: [{ type: "text", text }] }, session_id: sessionId },
+      { type: "result", subtype: "success", is_error: true, session_id: sessionId, result: text },
+    ];
+  }
+
   const events = [init];
+  // Plan use as Claude Code reports it on a fresh run (JSON rate_limit_info).
+  if (process.env.FAKE_AGENT_RATE_LIMIT_INFO) {
+    events.push({ type: "rate_limit_event", rate_limit_info: JSON.parse(process.env.FAKE_AGENT_RATE_LIMIT_INFO), session_id: sessionId });
+  }
   if (process.env.FAKE_AGENT_THINKING) {
     events.push({
       type: "assistant",
@@ -589,7 +610,7 @@ async function main() {
     setInterval(() => {}, 1000);
     return;
   }
-  if (scenario === "auth-failure" || scenario === "refusal") {
+  if (scenario === "auth-failure" || scenario === "refusal" || scenario === "usage-limit") {
     process.exitCode = 1;
     return;
   }

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-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,20 @@ 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.
+// 3.5.19 approved by Sumeet 2026-10-08 13:08 EAT ("I'd rather just push out
+// another release now rather than waiting for another day or so"): the memory
+// dedup judge and the classic recall filter reply in an object (the API
+// refused their bare-array formats on every Claude call), and the utility
+// agent refuses any reply format without an object root. This Mac bot first.
+assert.strictEqual(pkg.version, "3.5.19", "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-recall.js

@@ -20,7 +20,7 @@ const { createClaudeProvider } = require("./core/providers/claude");
 const { createCodexProvider } = require("./core/providers/codex");
 const { createUtilityPolicy } = require("./core/providers/utility-policy");
 const { createUtilityAgentService } = require("./core/utility-agent");
-const { createRecallFilter } = require("./core/recall-filter");
+const { createRecallFilter, FILTER_OUTPUT_SCHEMA } = require("./core/recall-filter");
 const discoverer = require("./core/recall/discoverer");
 const metrics = require("./core/recall/metrics");
 const warmWalker = require("./core/recall/warm-walker");
@@ -89,15 +89,25 @@ async function main() {
     const capture = path.join(root, `${kind}-filter.json`);
     const h = harness(kind, {
       FAKE_AGENT_CAPTURE: capture,
-      FAKE_AGENT_TEXT: '["pack:keep"]',
+      FAKE_AGENT_TEXT: '{"relevant":["pack:keep"]}',
     });
     const filter = createRecallFilter({ spawnUtilityAgent: h.utility.spawnUtilityAgent });
     const kept = await filter.judgeRelevance("keep this project", [
       { id: "pack:keep", name: "Keep", description: "relevant" },
       { id: "pack:drop", name: "Drop", description: "unrelated" },
     ], { provider: kind, context: "same project" });
-    assert.deepStrictEqual([...kept], ["pack:keep"]);
     const record = JSON.parse(fs.readFileSync(capture, "utf8"));
+    if (kind === "claude") {
+      // Claude Code turns the schema into a tool whose input_schema must be an
+      // object; the bare array the filter's schema was got a 400 on every call.
+      assert.ok(record.argv.includes("--json-schema"), "Claude Code is handed the filter's schema");
+      assert.strictEqual(JSON.parse(record.argv[record.argv.indexOf("--json-schema") + 1]).type, "object",
+        "Claude Code gets an object-root schema: the API refuses any other tool input_schema");
+    } else {
+      assert.ok(record.argv.includes("--output-schema"), "the filter's schema passes strict mode, so Codex enforces it");
+    }
+    assert.ok(kept, `${kind}: the relevance judgement is read (not failed open)`);
+    assert.deepStrictEqual([...kept], ["pack:keep"]);
     assert.strictEqual(record.stdin.present, true);
     assert.ok(!record.argv.some((arg) => /keep this project/.test(arg)), "recall candidates stay out of argv");
     if (kind === "claude") {
@@ -108,6 +118,29 @@ async function main() {
     }
   }
 
+  // The filter's schema has an object root and the reply is {"relevant": [...]};
+  // the prompts ask for that object, and a bare array is still read.
+  assert.strictEqual(FILTER_OUTPUT_SCHEMA.type, "object", "the recall filter schema's top-level type is object");
+  assert.deepStrictEqual(FILTER_OUTPUT_SCHEMA.required, ["relevant"]);
+  assert.strictEqual(FILTER_OUTPUT_SCHEMA.properties.relevant.type, "array");
+  for (const [shape, reply] of [
+    ["wrapped JSON", { json: { relevant: ["pack:a"] } }],
+    ["wrapped text", { text: 'Kept: {"relevant": ["pack:a"]}' }],
+    ["bare array JSON", { json: ["pack:a"] }],
+    ["bare array text", { text: '["pack:a"]' }],
+  ]) {
+    let asked = null;
+    const kept = await createRecallFilter({
+      spawnUtilityAgent: async (prompt, request) => { asked = { prompt, request }; return reply; },
+    }).judgeRelevance("alpha question", [{ id: "pack:a", name: "A" }, { id: "pack:b", name: "B" }]);
+    assert.ok(kept, `${shape}: the ids are read`);
+    assert.deepStrictEqual([...kept], ["pack:a"], `${shape}: only the kept candidate`);
+    assert.strictEqual(asked.request.outputSchema, FILTER_OUTPUT_SCHEMA);
+    assert.match(asked.request.systemPrompt, /\{"relevant"/, "the system prompt asks for the object");
+    assert.match(asked.prompt, /\{"relevant": \["pack:a"\]\}/, "the task prompt asks for the object");
+    assert.doesNotMatch(`${asked.request.systemPrompt}\n${asked.prompt}`, /JSON array/, "nothing asks for a bare array any more");
+  }
+
   const failedFilter = createRecallFilter({
     spawnUtilityAgent: async () => { throw new Error("fixture unavailable"); },
   });
@@ -120,7 +153,7 @@ async function main() {
   const legacyClaudeCapture = path.join(root, "legacy-claude-filter.json");
   const legacyClaude = harness("claude", {
     FAKE_AGENT_CAPTURE: legacyClaudeCapture,
-    FAKE_AGENT_TEXT: '["pack:a"]',
+    FAKE_AGENT_TEXT: '{"relevant":["pack:a"]}',
   }, { RECALL_FILTER_MODEL: "legacy-claude-filter" });
   await createRecallFilter({ spawnUtilityAgent: legacyClaude.utility.spawnUtilityAgent })
     .judgeRelevance("query", [{ id: "pack:a", name: "A" }], { provider: "claude" });
@@ -135,7 +168,7 @@ async function main() {
   const codexExactCapture = path.join(root, "exact-codex-filter.json");
   const codexExact = harness("codex", {
     FAKE_AGENT_CAPTURE: codexExactCapture,
-    FAKE_AGENT_TEXT: '["pack:a"]',
+    FAKE_AGENT_TEXT: '{"relevant":["pack:a"]}',
   }, {
     RECALL_FILTER_MODEL: "legacy-must-not-cross",
     RECALL_FILTER_MODEL_CODEX: "codex-filter-exact",

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,

package/test-utility-provider-policy.js

@@ -386,6 +386,33 @@ async function main() {
     cwd: root,
   }), "UTILITY_SCHEMA_INVALID");
 
+  // A schema whose root is not an object never reaches a provider. Claude Code
+  // turns it into a tool whose input_schema must be an object (OpenAI strict
+  // mode wants one too): the dedup adjudicator's array root got "400 ...
+  // input_schema.type: Input should be 'object'" at the API on every call and
+  // showed only as a fail-open warning. It fails here, before any spawn.
+  const arrayRootCapture = path.join(root, "array-root-capture.json");
+  const arrayRootService = createUtilityAgentService({
+    registry: registry(providers({ claude: { FAKE_AGENT_CAPTURE: arrayRootCapture, FAKE_AGENT_TEXT: "[]" } })),
+    env: { UTILITY_PROVIDER: "claude" },
+  });
+  for (const outputSchema of [
+    { type: "array", items: { type: "string" } },
+    { items: { type: "object" } },
+    [{ type: "object" }],
+  ]) {
+    await assert.rejects(arrayRootService.spawnUtilityAgent("judge", {
+      purpose: "dedup", tier: "low", systemPrompt: "judge", readOnly: true, outputSchema, cwd: root,
+    }), (error) => {
+      assert.ok(error instanceof UtilityAgentError);
+      assert.strictEqual(error.code, "INVALID_UTILITY_SCHEMA");
+      assert.match(error.message, /top-level type "object"/);
+      return true;
+    }, `${JSON.stringify(outputSchema)} is refused`);
+  }
+  assert.strictEqual(fs.existsSync(arrayRootCapture), false, "no provider ran for a schema it would refuse");
+  assert.deepStrictEqual(arrayRootService.stats(), { activeGlobal: 0, activeByPurpose: {} }, "the refused calls released their slots");
+
   const truncService = createUtilityAgentService({
     registry: registry(providers({ claude: { FAKE_AGENT_TEXT: "0123456789abcdefghijklmnopqrstuvwxyz" } })),
     env: { UTILITY_PROVIDER: "claude" },