@inetafrica/open-claudia 3.5.16 → 3.5.18

package/core/limit-pickup.js

@@ -0,0 +1,313 @@
+// Limit pick-up: a chat turn stopped by a plan usage limit runs again when
+// the limit resets (Sumeet, 7 Oct 2026: "have it pick up when the session
+// replenishes … if the user sends it a message it cancels and if the session
+// limit message comes up again it will just rearm").
+//
+//   - arm(): a foreground chat turn failed on PROVIDER_USAGE_LIMIT with a
+//     known reset time. <config>/limit-pickups.json keeps ONE pick-up per
+//     person per conversation (a newer one replaces it; in a group each
+//     sender has their own lane and session) with what is needed to run the
+//     message again as the person who sent it (the turn journal's shape).
+//   - cancel(): that person writing again in that conversation drops it
+//     (router.onMessage, and runner.runAgent for turns started another way),
+//     as do /stop, /new and /end: the conversation moved on.
+//   - start(adapters) at boot sets a timer per pick-up; a reset that passed
+//     while the bot was down fires shortly after boot. When it fires the
+//     record is removed and the message runs with a "the limit has reset,
+//     pick it up" prompt. If that run hits a limit again it re-arms, keeping
+//     the original message and counting attempts (MAX_ATTEMPTS at most).
+// LIMIT_PICKUP=off turns it off (the notice then only says when it resets).
+
+const path = require("path");
+const crypto = require("crypto");
+const CONFIG_DIR = require("../config-dir");
+const { atomicWriteFileSync, readJsonWithFallback, withFileLock } = require("./fsutil");
+const limits = require("./usage-limits");
+
+const FILE = () => process.env.OC_LIMIT_PICKUPS_FILE || path.join(CONFIG_DIR, "limit-pickups.json");
+const MAX_ATTEMPTS = 5;
+// setTimeout's ceiling is ~24.8 days; a plan window is a week at most.
+const MAX_TIMER_MS = 2 ** 31 - 1;
+const BOOT_GRACE_MS = 60000;
+
+function setting(name) {
+  if (process.env[name] !== undefined) return process.env[name];
+  try { return require("./config").config[name]; } catch (_) { return undefined; }
+}
+function enabled() {
+  return !/^(off|false|0|no)$/i.test(String(setting("LIMIT_PICKUP") ?? "on").trim());
+}
+// Wait this long after the reset, so the provider's window has turned over.
+function delayMs() {
+  const n = Number(setting("LIMIT_PICKUP_DELAY_S"));
+  return (Number.isFinite(n) && n >= 0 ? n : 120) * 1000;
+}
+// A reset further out than this (a monthly spend cap) is not waited for.
+function maxWaitMs() {
+  const n = Number(setting("LIMIT_PICKUP_MAX_WAIT_H"));
+  return (Number.isFinite(n) && n > 0 ? n : 192) * 3600000;
+}
+
+// A test run that did not point the store somewhere else never touches the
+// live bot's pick-ups.
+function storeOn() {
+  return !(process.env.OPEN_CLAUDIA_TEST === "1" && !process.env.OPEN_CLAUDIA_CONFIG_DIR && !process.env.OC_LIMIT_PICKUPS_FILE);
+}
+
+function readAll() {
+  const data = readJsonWithFallback(FILE(), null);
+  return data && typeof data === "object" && data.pickups && typeof data.pickups === "object" ? data : { v: 1, pickups: {} };
+}
+function update(fn) {
+  return withFileLock(FILE(), () => {
+    const data = readAll();
+    const out = fn(data.pickups);
+    atomicWriteFileSync(FILE(), JSON.stringify(data, null, 2) + "\n");
+    return out;
+  });
+}
+
+// One pick-up per person per conversation.
+function keyFor(canonicalUserId, laneKey) {
+  return `${canonicalUserId || "-"}::${laneKey}`;
+}
+
+// Keys with a pick-up on disk, so the check on every inbound message reads
+// no file. Only this process writes the store.
+let indexCache = null;
+function index() {
+  if (!indexCache) indexCache = new Set(storeOn() ? Object.keys(readAll().pickups) : []);
+  return indexCache;
+}
+
+function list() {
+  return storeOn() ? Object.values(readAll().pickups) : [];
+}
+function get(canonicalUserId, laneKey) {
+  if (!storeOn() || !index().has(keyFor(canonicalUserId, laneKey))) return null;
+  return readAll().pickups[keyFor(canonicalUserId, laneKey)] || null;
+}
+
+// ── wording ─────────────────────────────────────────────────────────────
+
+function at(ms, now = Date.now()) {
+  return limits.whenPhrase(ms, { now });
+}
+function limitName(provider, limitType) {
+  return `${limits.providerLabel(provider)}'s ${limits.windowLabel(limitType)}`;
+}
+
+const PICKUP_PROMPT = (hitAt, provider, original) => `Your ${limits.providerLabel(provider)} usage limit stopped this turn at ${hitAt}. The limit has reset, so pick it up now. The message was: ${original}\n\nCheck what you already did (your history, git, files, tool state, the chat) before acting; never repeat a send, push, deploy or write that already happened; then finish.`;
+
+/**
+ * What a turn stopped by a limit should do: arm a pick-up (armable) or only
+ * say when the limit lifts. Pure: deliverForegroundResult posts `notice` and
+ * then calls arm() with the plan when armable.
+ */
+function planFor(result, runContext, { now = Date.now(), windows = [], guarded = false } = {}) {
+  const hit = limits.limitHitDetails({
+    provider: runContext?.provider, error: result?.error, rateLimit: result?.rateLimit, windows, now,
+  });
+  if (!hit) return null;
+  // An outside contact is not told which model or plan the bot runs on.
+  const name = guarded ? "My usage limit" : limitName(hit.provider, hit.limitType);
+  const known = Number.isFinite(hit.resetsAt) && hit.resetsAt > now - 6 * 3600000;
+  const runAt = known ? Math.max(hit.resetsAt, now) + delayMs() : null;
+  const pickup = runContext?.limitPickup || null;
+  const attempts = (pickup?.attempts || 0) + 1;
+  const armable = enabled()
+    && known
+    && runAt - now <= maxWaitMs()
+    && attempts <= MAX_ATTEMPTS
+    && runContext?.purpose === "foreground"
+    && !runContext?.passive
+    && !runContext?.liveCall
+    && !!runContext?.origin?.adapterId
+    && !!runContext?.channelId;
+  let notice;
+  if (known && runContext?.purpose && runContext.purpose !== "foreground") {
+    notice = `⏳ ${name} is used up, so this ${runContext.purpose === "scheduled" ? "scheduled run" : "run"} stopped. It resets ${at(hit.resetsAt, now)}.`;
+  } else if (armable) {
+    const again = pickup && pickup.limitType && pickup.limitType === hit.limitType ? "is still used up" : "is used up too";
+    notice = pickup
+      ? `⏳ ${name} ${again}. I'll try your message again ${at(runAt, now)}. If you write to me before then, I'll answer that instead and drop this.`
+      : `⏳ ${name} is used up, so I stopped here. I'll pick your message back up ${at(runAt, now)}, when it resets. If you write to me before then, I'll answer that instead and drop this.`;
+  } else if (known) {
+    notice = attempts > MAX_ATTEMPTS
+      ? `⏳ ${name} is used up again, after ${MAX_ATTEMPTS} tries. It resets ${at(hit.resetsAt, now)}: send your message again then.`
+      : `⏳ ${name} is used up. It resets ${at(hit.resetsAt, now)}: send your message again then.`;
+  } else if (guarded) {
+    notice = "⏳ My usage limit is reached and I can't tell when it resets, so send your message again later.";
+  } else {
+    notice = `⏳ ${limits.providerLabel(hit.provider)} says its usage limit is reached ("${String(hit.text || "").slice(0, 160)}"). I can't tell when it resets, so send your message again later.`;
+  }
+  return { hit, armable, runAt, attempts, notice };
+}
+
+// ── arm / cancel ────────────────────────────────────────────────────────
+
+const timers = new Map(); // keyFor(person, conversation) -> timeout
+let runtime = null; // { adapters, deps } once start() ran
+
+function conversationOf(runContext) {
+  return require("./turn-journal").conversationOf(runContext);
+}
+
+function arm(runContext, plan, { now = Date.now() } = {}) {
+  if (!storeOn() || !plan?.armable) return null;
+  const pickup = runContext.limitPickup || null;
+  const record = {
+    v: 1,
+    id: crypto.randomBytes(6).toString("hex"),
+    conversation: conversationOf(runContext),
+    turn: {
+      // A pick-up that hits a limit again keeps the person's original message.
+      prompt: pickup?.originalPrompt || String(runContext.userPrompt || ""),
+      imagePaths: runContext.imagePaths || [],
+      attachments: runContext.attachments || [],
+      replyToMsgId: runContext.replyToMsgId || null,
+      project: runContext.project ? { name: runContext.project.name || null, dir: runContext.project.dir || null } : null,
+    },
+    provider: plan.hit.provider,
+    limitType: plan.hit.limitType || null,
+    resetsAt: plan.hit.resetsAt,
+    runAt: plan.runAt,
+    armedAt: now,
+    firstHitAt: pickup?.firstHitAt || now,
+    attempts: plan.attempts,
+  };
+  const key = keyFor(record.conversation.canonicalUserId, record.conversation.laneKey);
+  update((pickups) => { pickups[key] = record; });
+  index().add(key);
+  schedule(key, record, now);
+  console.log(`[limit-pickup] armed ${key}: ${record.provider} ${record.limitType || "limit"} resets ${new Date(record.resetsAt).toISOString()}, runs ${new Date(record.runAt).toISOString()} (attempt ${record.attempts})`);
+  return record;
+}
+
+function drop(keys, reason) {
+  const wanted = keys.filter((key) => index().has(key) || timers.has(key));
+  if (!wanted.length) return [];
+  for (const key of wanted) {
+    const timer = timers.get(key);
+    if (timer) { clearTimeout(timer); timers.delete(key); }
+    index().delete(key);
+  }
+  const removed = update((pickups) => wanted.filter((key) => pickups[key]).map((key) => {
+    const record = pickups[key];
+    delete pickups[key];
+    return record;
+  }));
+  for (const record of removed) console.log(`[limit-pickup] cancelled ${keyFor(record.conversation.canonicalUserId, record.conversation.laneKey)} (${reason})`);
+  return removed;
+}
+
+/** Drop this person's pick-up in this conversation (they wrote, /stop, /new, /end). */
+function cancel(canonicalUserId, laneKey, reason = "a new message") {
+  if (!laneKey || !storeOn()) return null;
+  return drop([keyFor(canonicalUserId, laneKey)], reason)[0] || null;
+}
+
+/** Drop every pick-up of this person (/stop all). */
+function cancelAllFor(canonicalUserId, reason = "/stop all") {
+  if (!storeOn()) return [];
+  const prefix = `${canonicalUserId || "-"}::`;
+  return drop([...index()].filter((key) => key.startsWith(prefix)), reason);
+}
+
+// ── timers and the pick-up run ──────────────────────────────────────────
+
+function schedule(key, record, now = Date.now()) {
+  if (!runtime) return; // start() at boot sets the timers
+  const old = timers.get(key);
+  if (old) clearTimeout(old);
+  const wait = Math.min(Math.max(record.runAt - now, 0), MAX_TIMER_MS);
+  const timer = setTimeout(() => {
+    timers.delete(key);
+    // The ceiling cut the wait short: set the rest.
+    if (record.runAt - Date.now() > 1000) return schedule(key, record);
+    fire(key, record.id).catch((error) => console.warn(`[limit-pickup] ${key}: ${error?.message || error}`));
+  }, wait);
+  timer.unref?.();
+  timers.set(key, timer);
+}
+
+function defaultDeps() {
+  const journal = require("./turn-journal");
+  return {
+    ...journal.defaultDeps(),
+    chatScope: journal.chatScope,
+    findAdapter: journal.findAdapter,
+    isGuarded: () => { try { return require("./relationship").isCurrentSpeakerGuarded(); } catch (_) { return false; } },
+  };
+}
+
+async function fire(key, id) {
+  if (!runtime) return null;
+  const { adapters, deps } = runtime;
+  // Take it out first: it runs once; a new limit hit arms a new one.
+  const record = update((pickups) => {
+    const current = pickups[key];
+    if (!current || (id && current.id !== id)) return null;
+    delete pickups[key];
+    return current;
+  });
+  if (!record) return null;
+  index().delete(key);
+  if (!enabled()) return null;
+  if (deps.isSafeMode()) {
+    // Safe mode runs no turns: keep it for the next boot.
+    update((pickups) => { pickups[key] = pickups[key] || record; });
+    index().add(key);
+    return null;
+  }
+  const adapter = deps.findAdapter(adapters || [], record.conversation);
+  if (!adapter) {
+    console.warn(`[limit-pickup] ${key}: its channel is not loaded; dropped`);
+    return null;
+  }
+  const scope = deps.chatScope(record.conversation, adapter, deps);
+  const hitAt = limits.formatResetTime(record.firstHitAt, { now: deps.now() });
+  return deps.runInChat(scope, async () => {
+    // An outside contact is not told which model or plan the bot runs on.
+    const which = deps.isGuarded() ? "my usage limit" : limitName(record.provider, record.limitType);
+    await Promise.resolve(deps.send(`Picking up your message from ${hitAt} now that ${which} has reset.`, { replyTo: record.turn.replyToMsgId || undefined })).catch(() => {});
+    return deps.runAgent(PICKUP_PROMPT(hitAt, record.provider, record.turn.prompt), record.turn.project?.dir || null, record.turn.replyToMsgId, {
+      purpose: "foreground",
+      imagePaths: record.turn.imagePaths || [],
+      attachments: record.turn.attachments || [],
+      limitPickup: { originalPrompt: record.turn.prompt, firstHitAt: record.firstHitAt, attempts: record.attempts, limitType: record.limitType },
+    });
+  });
+}
+
+/** Boot (after the adapters connect): a timer per waiting pick-up. */
+function start(adapters, overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  runtime = { adapters, deps };
+  const now = deps.now();
+  const out = [];
+  indexCache = null;
+  for (const record of list()) {
+    if (!record.conversation?.laneKey) continue;
+    const key = keyFor(record.conversation.canonicalUserId, record.conversation.laneKey);
+    // A reset that passed while the bot was down: run shortly after boot,
+    // once the resumed and restored turns have started.
+    schedule(key, record.runAt < now + BOOT_GRACE_MS ? { ...record, runAt: now + BOOT_GRACE_MS } : record, now);
+    out.push(key);
+  }
+  return out;
+}
+
+function _resetForTests() {
+  for (const timer of timers.values()) clearTimeout(timer);
+  timers.clear();
+  runtime = null;
+  indexCache = null;
+}
+
+module.exports = {
+  PICKUP_PROMPT, MAX_ATTEMPTS,
+  enabled, delayMs, maxWaitMs,
+  keyFor, planFor, arm, cancel, cancelAllFor, list, get, start, fire,
+  _resetForTests,
+};

package/core/loopback.js

@@ -91,12 +91,14 @@ const OWNER_ONLY_KINDS = new Set([
   "people-list", "people-show", "people-note",
   "task-add", "task-plan", "task-update", "task-remove",
   "task-list", "task-get", "task-tree", "task-clear-completed",
+  "task-archive", "task-restore", "task-archived",
 ]);
 const JSON_KINDS = new Set([
   "whoami",
   "schedule-wakeup", "cron-add", "cron-remove", "job-list",
   "watch-add", "watch-list", "watch-remove", "watch-toggle",
   "task-add", "task-plan", "task-update", "task-remove", "task-list", "task-get", "task-tree", "task-clear-completed",
+  "task-archive", "task-restore", "task-archived",
   "people-list", "people-show", "people-add", "people-note", "people-link", "people-unlink",
   "people-remove", "people-set-primary",
   "intros-list", "intros-approve", "intros-reject",
@@ -668,9 +670,12 @@ async function handleJson(req, res, url, kind) {
   if (kind === "task-add") {
     if (!payload.content) return reply(res, 400, { error: "missing content" });
     try {
+      // A task belongs to the conversation it was made in (the run's thread,
+      // null on the main timeline); a subtask follows its plan.
       const t = tasksStore.add(adapterId, channelId, payload.content, {
         parentId: payload.parentId || null,
         description: payload.description || null,
+        threadId: threadForCaller(callerOf(payload), channelId, payload.threadId),
       });
       return reply(res, 200, { ok: true, task: t });
     } catch (e) { return reply(res, 400, { error: e.message }); }
@@ -682,6 +687,7 @@ async function handleJson(req, res, url, kind) {
     if (subs.length === 0) return reply(res, 400, { error: "subtasks must be a non-empty array" });
     const result = tasksStore.plan(adapterId, channelId, payload.title, subs, {
       description: payload.description || null,
+      threadId: threadForCaller(callerOf(payload), channelId, payload.threadId),
     });
     return reply(res, 200, { ok: true, plan: result });
   }
@@ -723,6 +729,29 @@ async function handleJson(req, res, url, kind) {
     return reply(res, got ? 200 : 404, { ok: !!got, ...(got || {}) });
   }
 
+  if (kind === "task-archive") {
+    if (!payload.id) return reply(res, 400, { error: "missing id" });
+    try {
+      const result = tasksStore.archive(adapterId, channelId, payload.id, payload.reason);
+      return reply(res, result ? 200 : 404, { ok: !!result, ...(result || {}) });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "task-restore") {
+    if (!payload.id) return reply(res, 400, { error: "missing id" });
+    try {
+      const result = tasksStore.restore(adapterId, channelId, payload.id);
+      return reply(res, result ? 200 : 404, { ok: !!result, ...(result || {}) });
+    } catch (e) { return reply(res, 400, { error: e.message }); }
+  }
+
+  if (kind === "task-archived") {
+    const limit = Number(payload.limit);
+    const opts = { search: payload.search || "" };
+    if (Number.isFinite(limit) && limit > 0) opts.limit = limit;
+    return reply(res, 200, { ok: true, tasks: tasksStore.archived(adapterId, channelId, opts) });
+  }
+
   if (kind === "task-clear-completed") {
     const remaining = tasksStore.clearCompleted(adapterId, channelId);
     return reply(res, 200, { ok: true, tasks: remaining });

package/core/providers/claude-events.js

@@ -16,9 +16,56 @@ function createClaudeParserState() {
     seenUsage: new Set(),
     totalCostUsd: 0,
     refusal: null,
+    // Set once the plan limit rejected this run: { resetsAt, limitType, text }.
+    limitHit: null,
   };
 }
 
+const epochMs = (seconds) => {
+  const n = Number(seconds);
+  return Number.isFinite(n) && n > 0 ? Math.round(n * 1000) : null;
+};
+
+// Claude Code's rate_limit_event (emitted when the plan status changes, so at
+// least once per fresh run). rate_limit_info.unifiedWindows carries the use of
+// each window as a 0-1 fraction; status "allowed_warning" is Claude Code's own
+// pace warning (it fires at 25% early in the week), so callers should read the
+// windows, not the status, for "close to the limit".
+function claudeRateLimitEvent(info) {
+  if (!info || typeof info !== "object") return null;
+  const windows = [];
+  const unified = info.unifiedWindows && typeof info.unifiedWindows === "object" ? info.unifiedWindows : {};
+  for (const [id, window] of Object.entries(unified)) {
+    const utilization = Number(window?.utilization);
+    if (!Number.isFinite(utilization)) continue;
+    windows.push({ id, usedPercent: Math.round(utilization * 1000) / 10, resetsAt: epochMs(window.resetsAt) });
+  }
+  return {
+    type: "rate_limit",
+    provider: "claude",
+    status: typeof info.status === "string" ? info.status : null,
+    limitType: typeof info.rateLimitType === "string" ? info.rateLimitType : null,
+    resetsAt: epochMs(info.resetsAt),
+    windows,
+  };
+}
+
+function noteLimitHit(state, patch) {
+  state.limitHit = { resetsAt: null, limitType: null, text: null, ...(state.limitHit || {}) };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== null && value !== undefined && value !== "") state.limitHit[key] = value;
+  }
+}
+
+// The limit notice arrives as a synthetic assistant message (model
+// "<synthetic>", error "rate_limit"). It is not answer text.
+function isLimitNotice(rawEvent) {
+  if (rawEvent.error === "rate_limit") return true;
+  if (rawEvent.message?.model !== "<synthetic>") return false;
+  const text = (rawEvent.message?.content || []).map((block) => (block?.type === "text" ? block.text : "")).join(" ");
+  return providerErrorFlags(text).usageLimit;
+}
+
 function sessionEvent(sessionId, state) {
   if (!sessionId || state.sessionId === sessionId) return null;
   state.sessionId = sessionId;
@@ -43,6 +90,11 @@ function captureRefusal(state, stopReason, stopDetails) {
 function claudeFailureEvent(message, state) {
   const flags = providerErrorFlags(message);
   const event = { type: "error", message, ...flags };
+  if (state.limitHit) {
+    event.usageLimit = true;
+    event.limitResetsAt = state.limitHit.resetsAt;
+    event.limitType = state.limitHit.limitType;
+  }
   if (flags.refusal || state.refusal) {
     const parsed = refusalDetailsFromMessage(message);
     event.refusal = true;
@@ -58,11 +110,27 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
   const decoderFailure = normalizeDecoderError(rawEvent);
   if (decoderFailure) return [decoderFailure];
 
+  // A helper agent's (Agent/Task tool) own messages carry parent_tool_use_id:
+  // its working notes, tool calls and refusals are not this turn's reply.
+  // Only its spend still counts.
+  if (rawEvent.parent_tool_use_id && ["assistant", "stream_event", "user"].includes(rawEvent.type)) {
+    if (rawEvent.type !== "assistant") return [];
+    const usage = normalizedUsage(rawEvent.message?.usage, "provider_call", state.seenUsage);
+    return usage ? [usage] : [];
+  }
+
   if (rawEvent.type === "system" && rawEvent.subtype === "init") {
     const event = sessionEvent(rawEvent.session_id, state);
     return event ? [event] : [];
   }
 
+  if (rawEvent.type === "rate_limit_event") {
+    const event = claudeRateLimitEvent(rawEvent.rate_limit_info);
+    if (!event) return [];
+    if (event.status === "rejected") noteLimitHit(state, { resetsAt: event.resetsAt, limitType: event.limitType });
+    return [event];
+  }
+
   if (rawEvent.type === "stream_event") {
     if (rawEvent.event?.type === "message_delta") {
       captureRefusal(state, rawEvent.event.delta?.stop_reason, rawEvent.event.delta?.stop_details ?? rawEvent.event.stop_details);
@@ -76,6 +144,11 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
   }
 
   if (rawEvent.type === "assistant") {
+    if (isLimitNotice(rawEvent)) {
+      const text = (rawEvent.message?.content || []).map((block) => (block?.type === "text" ? block.text : "")).join(" ").trim();
+      noteLimitHit(state, { text });
+      return [];
+    }
     const events = [];
     captureRefusal(state, rawEvent.message?.stop_reason, rawEvent.message?.stop_details);
     for (const block of rawEvent.message?.content || []) {
@@ -124,6 +197,12 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
     if (rawEvent.is_error || /^error/.test(String(rawEvent.subtype || ""))) {
       return [claudeFailureEvent(claudeErrorMessage(rawEvent), state)];
     }
+    if (state.limitHit && !state.sawText) {
+      // A plan limit is a failed turn even when the CLI closes it as a
+      // "success": the limit notice must never go out as the reply. (With
+      // answer text, Claude Code fell back to another model and finished.)
+      return [claudeFailureEvent(state.limitHit.text || claudeErrorMessage(rawEvent), state)];
+    }
     const events = [];
     const session = sessionEvent(rawEvent.session_id, state);
     if (session) events.push(session);

package/core/providers/codex.js

@@ -75,6 +75,52 @@ function imagePathsOf(context) {
   return paths;
 }
 
+// Codex hands --output-schema to OpenAI in strict mode, which refuses the call
+// (400 invalid_json_schema) when the root is not an object, or an object has no
+// properties, allows extra keys or leaves a property out of `required`
+// (6 Oct 2026: every passive-reply check, pack review, dedup and dream on Codex
+// bots failed that way). An object whose properties are all required is closed
+// with additionalProperties: false, which costs a reply nothing. A schema that
+// needs optional or free-form fields gives null: no schema is sent, and the
+// utility agent still checks the reply against the caller's full schema.
+function strictOutputSchema(schema) {
+  function close(node, depth) {
+    if (!node || typeof node !== "object" || Array.isArray(node)) return depth > 0 ? node : null;
+    if (depth > 20 || node.$ref !== undefined) return null;
+    const copy = { ...node };
+    if ([].concat(node.type || []).includes("object")) {
+      const properties = node.properties && typeof node.properties === "object" ? node.properties : {};
+      const keys = Object.keys(properties);
+      if (!keys.length) return null;
+      if (node.additionalProperties && typeof node.additionalProperties === "object") return null;
+      const required = new Set(Array.isArray(node.required) ? node.required : []);
+      if (keys.some((key) => !required.has(key))) return null;
+      copy.properties = {};
+      for (const key of keys) {
+        const child = close(properties[key], depth + 1);
+        if (child === null) return null;
+        copy.properties[key] = child;
+      }
+      copy.additionalProperties = false;
+    }
+    if (node.items !== undefined) {
+      const items = Array.isArray(node.items) ? null : close(node.items, depth + 1);
+      if (items === null) return null;
+      copy.items = items;
+    }
+    for (const key of ["anyOf", "oneOf", "allOf"]) {
+      if (node[key] === undefined) continue;
+      if (!Array.isArray(node[key])) return null;
+      const variants = node[key].map((variant) => close(variant, depth + 1));
+      if (variants.includes(null)) return null;
+      copy[key] = variants;
+    }
+    return copy;
+  }
+  if (!schema || typeof schema !== "object" || schema.type !== "object") return null;
+  return close(schema, 0);
+}
+
 function createCodexProvider(options = {}) {
   const resolveExecutable = options.resolveExecutable || (() => config.discoverProviderExecutable("codex"));
   const defaultModel = options.defaultModel ?? config.config.CODEX_MODEL ?? null;
@@ -266,6 +312,7 @@ function createCodexProvider(options = {}) {
       return buildInvocation({ ...context, permissionMode: "plan" }, false);
     },
     buildUtilityInvocation: (context) => buildInvocation({ ...context, fresh: true }, true),
+    outputSchemaFor: (schema) => strictOutputSchema(schema),
     createEventDecoder: (decoderOptions) => createJsonlDecoder(decoderOptions),
     normalizeEvent: normalizeCodexEvent,
     authStatus: () => getAuthStatus(executable()),
@@ -300,4 +347,5 @@ module.exports = {
   capabilities,
   codexProvider,
   createCodexProvider,
+  strictOutputSchema,
 };

package/core/providers/events.js

@@ -11,6 +11,7 @@ const NORMALIZED_EVENT_TYPES = Object.freeze([
   "result",
   "error",
   "warning",
+  "rate_limit",
 ]);
 
 // 16MB: tool results carrying base64 images legitimately exceed 1MB — the old
@@ -130,7 +131,9 @@ function providerErrorFlags(message) {
   const text = String(message || "").toLowerCase();
   return {
     authError: /unauthori[sz]ed|not (?:logged in|authenticated)|unauthenticated|login required|authentication failed|auth failed|invalid api key|no credentials|401/.test(text),
-    usageLimit: /usage limit|spend limit|monthly cycle|quota|rate limit/.test(text),
+    // "You've hit your limit / session limit / weekly limit / Opus limit · resets …"
+    // is how Claude Code words a plan limit; the older patterns never matched it.
+    usageLimit: /usage limit|spend limit|monthly cycle|quota|rate limit|hit your (?:[a-z0-9'’-]+ ){0,3}limit/.test(text),
     refusal: /refusals-and-fallback|usage policy|safety classifier|stop_reason['":\s]*refusal/.test(text),
   };
 }

package/core/relationship.js

@@ -323,4 +323,4 @@ function ensureContact(envelope) {
   }
 }
 
-module.exports = { speakerFor, currentSpeaker, guardActive, isCurrentSpeakerGuarded, ownerTarget, ownerTargets, configuredOwnerTarget, ensureContact };
+module.exports = { speakerFor, currentSpeaker, guardActive, isCurrentSpeakerGuarded, ownerTarget, ownerTargets, configuredOwnerTarget, ensureContact, resolveHandleSendTarget };

package/core/router.js

@@ -167,6 +167,16 @@ async function onMessage(envelope) {
       // and the meet-greet lane all have a person to attach to.
       try { require("./relationship").ensureContact(envelope); } catch (e) {}
 
+      // The person writing again drops their pick-up of a message a usage
+      // limit stopped (core/limit-pickup.js): the conversation moved on. Also
+      // when the guard then holds this message. Another bot's message does not.
+      if (!envelope.botHandoff) {
+        try {
+          const state = currentState();
+          require("./limit-pickup").cancel(state.userId, require("./state").currentLaneKey(state), "a new message");
+        } catch (e) {}
+      }
+
       if (envelope.type === "voice") return handleVoice(envelope);
       if (envelope.type === "audio") return handleAudio(envelope);
       if (envelope.type === "photo") return handlePhoto(envelope);
@@ -431,8 +441,13 @@ async function handleDocument(envelope) {
       attachments: [{ type: "document", mimeType: media.mimeType || null, fileName: media.fileName || null }],
     });
     stopPreTurnTyping = startPreTurnTyping(state);
+    // Saved before the guard runs: a held request resumes after the owner's
+    // approval from the guard's text alone (core/actions.js), so that text
+    // must say where the file is. The adapters keep the file inside FILES_DIR
+    // under a cleaned name (core/safe-filename.js), and that name is the one
+    // shown, never the sender's raw path.
     const savePath = await envelope.adapter.downloadMedia(media);
-    const fileName = media.fileName || path.basename(savePath);
+    const fileName = path.basename(savePath);
     const mime = media.mimeType || "";
     const caption = envelope.caption || "";
     const isImage = mime.startsWith("image/");

package/core/run-context.js

@@ -213,6 +213,9 @@ function captureRunContext({
     occurrenceId: opts.occurrenceId || null,
     scheduledJobId: opts.scheduledJobId || null,
     originRunId: opts.originRunId || null,
+    // Set on a turn that core/limit-pickup.js re-runs after a usage limit
+    // reset: { originalPrompt, firstHitAt, attempts }.
+    limitPickup: opts.limitPickup ? cloneSerializable(opts.limitPickup, "limit pickup") : null,
   };
 
   return deepFreeze(context);