@inetafrica/open-claudia 3.5.20 → 3.5.24

package/core/providers/claude.js

@@ -18,15 +18,22 @@ const { createClaudeHookTransport } = require("./claude-hook");
 // consulting this list, so `/model claude-opus-4-8` still works as a rollback.
 // The list is consulted on tapped mb: callbacks (core/actions.js), whose job is
 // to reject a stale button from an old message — that is the intended effect.
-// claude-sonnet-4-6 and claude-haiku-4-5 STAY: they are the tier models for
-// utility work (see tierModel below), not just picker entries.
+// claude-sonnet-5-5 and claude-haiku-5-5 STAY: they are the tier models for
+// utility work (see tierModel below), not just picker entries. Haiku 5.5
+// replaced Haiku 4.5 as the low tier on 9 Oct 2026 (Sumeet: "check if anything
+// using haiku and have it shifted to the new haiku 5.5"), and Sonnet 5.5
+// replaced Sonnet 4.6 as the medium tier the same day ("sonnet should also be
+// just 5.5"); `/model claude-haiku-4-5-20251001` and `/model claude-sonnet-4-6`
+// still work typed.
+const CLAUDE_LOW_TIER_MODEL = "claude-haiku-5-5";
+const CLAUDE_MEDIUM_TIER_MODEL = "claude-sonnet-5-5";
 const CLAUDE_MODELS = Object.freeze([
   "claude-fable-5-1",
   "claude-fable-5",
   "claude-opus-5-5",
   "claude-opus-5",
-  "claude-sonnet-4-6",
-  "claude-haiku-4-5-20251001",
+  CLAUDE_MEDIUM_TIER_MODEL,
+  CLAUDE_LOW_TIER_MODEL,
 ]);
 const CLAUDE_EFFORT_VALUES = Object.freeze(["low", "medium", "high", "xhigh", "max"]);
 // The default governs MAIN turns only: utility work is pinned by tier below
@@ -99,8 +106,8 @@ function appendModelAndLimits(args, context, defaultModel, utility) {
   let model = context.model || settings.model || null;
   if (!model && utility && context.tier) {
     model = context.tier === "low"
-      ? "claude-haiku-4-5-20251001"
-      : (context.tier === "medium" ? "claude-sonnet-4-6" : defaultModel);
+      ? CLAUDE_LOW_TIER_MODEL
+      : (context.tier === "medium" ? CLAUDE_MEDIUM_TIER_MODEL : defaultModel);
   }
   args.push("--model", String(model || defaultModel));
 
@@ -311,8 +318,8 @@ function createClaudeProvider(options = {}) {
     },
     nativeToolsNote: "Claude Code exposes its native tools; Open Claudia's tool hook and approval policy remain authoritative.",
     tierModel(tier) {
-      if (tier === "low") return "claude-haiku-4-5-20251001";
-      if (tier === "medium") return "claude-sonnet-4-6";
+      if (tier === "low") return CLAUDE_LOW_TIER_MODEL;
+      if (tier === "medium") return CLAUDE_MEDIUM_TIER_MODEL;
       return defaultModel;
     },
   };

package/core/providers/env.js

@@ -78,6 +78,21 @@ function pickStandardProcessEnv(source = process.env) {
   return env;
 }
 
+// agent-browser's own settings (Chrome path and flags, the browser container's CDP port, pinned
+// tabs, the download folder...). Every caller of agent-browser must share them: Open Claudia's
+// Browser app and Teach me run it with this process's AGENT_BROWSER_*, and on a bot pod a session
+// reached with different launch settings is relaunched and loses its page (with a browser
+// container, an agent without AGENT_BROWSER_CDP would start its own Chrome instead). They configure
+// a tool the agent runs, not a provider or the control plane, so the agent gets the same set.
+const AGENT_BROWSER_KEY = /^AGENT_BROWSER_[A-Z0-9_]+$/;
+
+function addAgentBrowserEnv(target, source = process.env) {
+  for (const key of Object.keys(source)) {
+    if (AGENT_BROWSER_KEY.test(key)) copyEnvValue(target, source, key);
+  }
+  return target;
+}
+
 function passthroughKeys(source = process.env, configured = source.AGENT_ENV_PASSTHROUGH) {
   const keys = String(configured || "")
     .split(",")
@@ -100,6 +115,7 @@ function addConfiguredPassthrough(target, source = process.env, configured = sou
 
 function baseAgentEnv(source = process.env, options = {}) {
   const env = pickStandardProcessEnv(source);
+  addAgentBrowserEnv(env, source);
   addConfiguredPassthrough(env, source, options.passthrough);
   // Strip after passthrough so a broad/operator-supplied list cannot re-open a
   // provider credential, control-plane token, or keyring canary boundary.
@@ -141,6 +157,7 @@ module.exports = {
   PROVIDER_CONFIG_ROOT_KEYS,
   PROVIDER_CREDENTIAL_KEYS,
   STANDARD_PROCESS_ENV_KEYS,
+  addAgentBrowserEnv,
   addConfiguredPassthrough,
   baseAgentEnv,
   claudeAgentEnv,

package/core/providers/events.js

@@ -127,17 +127,40 @@ function createJsonlDecoder(options = {}) {
   return api;
 }
 
+// What a provider's failure means, read in one place for chat turns
+// (core/runner) and background calls (core/utility-agent):
+//   authError  — signed out, or the sign-in died. Waiting does not fix it;
+//                /login does. Claude Code 2.1 words a dead refresh "Failed to
+//                authenticate: OAuth session expired and could not be
+//                refreshed"; Codex "Your authentication token has expired".
+//   usageLimit — a plan limit. Its reset fixes it.
+//   transient  — Claude Code's refresh-lock race ("another Claude Code process
+//                is refreshing it or exited mid-refresh"): a later try works.
+//                Four fleet bots lost the 9 Oct 07:00 dream to it.
 function providerErrorFlags(message) {
   const text = String(message || "").toLowerCase();
+  const transient = /another claude code process is refreshing|exited mid-refresh/.test(text);
   return {
-    authError: /unauthori[sz]ed|not (?:logged in|authenticated)|unauthenticated|login required|authentication failed|auth failed|invalid api key|no credentials|401/.test(text),
+    authError: !transient && /unauthori[sz]ed|not (?:logged in|authenticated)|unauthenticated|login required|authentication failed|auth failed|failed to authenticate|invalid api key|no credentials|401|oauth (?:session|access token|token) (?:expired|has expired|is invalid|is no longer valid)|could not be refreshed|refresh token is no longer valid|authentication token (?:has )?expired/.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),
+    transient,
     refusal: /refusals-and-fallback|usage policy|safety classifier|stop_reason['":\s]*refusal/.test(text),
   };
 }
 
+// The error code of a failed run, from its normalized error event's flags.
+// Chat turns pass PROVIDER_EVENT_ERROR as the fallback, background calls
+// UTILITY_PROVIDER_ERROR, so both read a limit or a dead sign-in the same way.
+function providerFailureCode(event, fallback = "PROVIDER_EVENT_ERROR") {
+  if (event?.refusal) return "PROVIDER_REFUSAL";
+  if (event?.authError) return "PROVIDER_UNAUTHENTICATED";
+  if (event?.usageLimit) return "PROVIDER_USAGE_LIMIT";
+  if (event?.transient) return "PROVIDER_TRANSIENT";
+  return fallback;
+}
+
 // The CLI flattens the API's stop_details into the error text; recover the
 // human-readable pieces so the chat message can lead with the actual reason.
 function refusalDetailsFromMessage(message) {
@@ -184,6 +207,7 @@ module.exports = {
   normalizeDecoderError,
   normalizedUsage,
   providerErrorFlags,
+  providerFailureCode,
   refusalDetailsFromMessage,
   selectTerminalText,
   usageFingerprint,

package/core/providers/utility-policy.js

@@ -84,13 +84,29 @@ function parseProviderFallbacks(value) {
   return result;
 }
 
+// The provider of work with a person behind it is that person's; work with
+// nobody behind it (the dream, introspection, a check outside any chat) runs
+// on the bot's own provider: the one its owner chats on (/backend and /login
+// set it). It used to take the first provider that did not look signed out,
+// so on 9 Oct 2026 every Codex bot's dream ran on a signed-out Claude.
+function ownerActiveProvider() {
+  try {
+    const owner = require("../identity").ownerCanonical();
+    if (!owner) return null;
+    const state = require("../state");
+    return state.getActiveProvider(state.getUserState(owner));
+  } catch (_) {
+    return null;
+  }
+}
+
 function defaultActiveProvider(env = process.env) {
   const inherited = String(env?.OC_PROVIDER || process.env.OC_PROVIDER || "").trim().toLowerCase();
   if (PROVIDER_ID_SET.has(inherited)) return inherited;
+  let canonicalUserId = null;
+  try { canonicalUserId = require("../context").currentCanonicalUserId(); } catch (_) { canonicalUserId = null; }
+  if (!canonicalUserId) return ownerActiveProvider();
   try {
-    const { currentCanonicalUserId } = require("../context");
-    const canonicalUserId = currentCanonicalUserId();
-    if (!canonicalUserId) return null;
     const state = require("../state");
     return state.getActiveProvider(state.getUserState(canonicalUserId));
   } catch (_) {
@@ -98,6 +114,16 @@ function defaultActiveProvider(env = process.env) {
   }
 }
 
+// With no active provider at all: the one a new chat starts on (DEFAULT_PROVIDER,
+// else the first installed), as for a chat turn; then the first runnable.
+function registryDefaultProvider(registry) {
+  try {
+    const selected = typeof registry.selectDefaultProvider === "function" ? registry.selectDefaultProvider()?.providerId : null;
+    if (selected && PROVIDER_ID_SET.has(selected) && runnableStatus(registry, selected).runnable) return selected;
+  } catch (_) { /* fall through */ }
+  return registryProviders(registry).find((providerId) => runnableStatus(registry, providerId).runnable) || null;
+}
+
 function registryProviders(registry) {
   try {
     const listed = registry.listProviders();
@@ -189,9 +215,7 @@ function createUtilityPolicy(options = {}) {
       if (active) preferred = normalizeProvider(active);
       else {
         const globalDefault = envValue(env, "DEFAULT_PROVIDER");
-        preferred = globalDefault
-          ? normalizeProvider(globalDefault)
-          : (registryProviders(registry).find((providerId) => runnableStatus(registry, providerId).runnable) || null);
+        preferred = globalDefault ? normalizeProvider(globalDefault) : registryDefaultProvider(registry);
       }
     }
     if (!preferred) {
@@ -267,6 +291,7 @@ module.exports = {
   UtilityPolicyError,
   createUtilityPolicy,
   defaultActiveProvider,
+  ownerActiveProvider,
   exactModelOverride,
   normalizePurpose,
   normalizeTier,

package/core/runner.js

@@ -15,7 +15,7 @@ const {
 const {
   currentState, saveState, recordSession,
   resetSessionUsage, admitLane, cancelTargets, getActiveProvider, getProjectKey,
-  laneFor, laneForRun, peekLane, laneBusy, runLaneKey, waitingLanes, slotBlocker, pruneIdleLanes,
+  laneFor, laneForRun, peekLane, laneBusy, runLaneKey, waitingLanes, slotBlocker, pruneIdleLanes, findQueued,
   getProviderSession, setProviderSession, clearProviderSession, quarantineProviderSession, getUsageForSession, commitProviderCompaction, commitBranchCompaction,
   resolveProviderSettings, getProjectSessions,
 } = require("./state");
@@ -26,7 +26,7 @@ const usageLimits = require("./usage-limits");
 const limitPickup = require("./limit-pickup");
 const { getProvider, resolveProviderForRun } = require("./providers");
 const { validateInvocation } = require("./providers/contract");
-const { selectTerminalText } = require("./providers/events");
+const { providerFailureCode, selectTerminalText } = require("./providers/events");
 const {
   bindRunInputs,
   captureRunContext,
@@ -581,7 +581,7 @@ async function executeProviderInvocation(options = {}) {
     const event = rawErrors[0];
     failure = stableRunError(
       event.message || "Provider reported an error",
-      event.refusal ? "PROVIDER_REFUSAL" : (event.authError ? "PROVIDER_UNAUTHENTICATED" : (event.usageLimit ? "PROVIDER_USAGE_LIMIT" : "PROVIDER_EVENT_ERROR")),
+      providerFailureCode(event, "PROVIDER_EVENT_ERROR"),
       event,
     );
   } else if (closeInfo.code !== 0) failure = stableRunError(`Provider process exited with code ${closeInfo.code}`, "PROVIDER_NONZERO_EXIT", { exitCode: closeInfo.code });
@@ -620,6 +620,9 @@ async function executeProviderInvocation(options = {}) {
     delivery,
     timings: { startedAt, finishedAt: null, durationMs: null },
   };
+  // Every run, whatever its purpose, keeps the limit record current: a limit
+  // hit marks the provider used up until its reset, a run that worked clears it.
+  noteRunLimit(result, runContext);
 
   const runStage = async (name, hook) => {
     if (!hook) return;
@@ -1773,6 +1776,23 @@ function limitPlanFor(result, runContext) {
   return keepOnResult(result, "limitPlan", plan);
 }
 
+// The limit record (core/usage-limits.js) background work reads: a run a
+// limit stopped marks the provider used up until the reset; a run that
+// worked clears it. Never throws.
+function noteRunLimit(result, runContext) {
+  try {
+    const provider = runContext?.provider || result.provider;
+    if (result.ok) { usageLimits.clearLimitBlock(provider, { model: runContext?.providerSettings?.model || null }); return; }
+    if (result.error?.code !== "PROVIDER_USAGE_LIMIT") return;
+    const hit = usageLimits.limitHitDetails({
+      provider, error: result.error, rateLimit: result.rateLimit, windows: planLimitWindows(result, runContext || {}),
+    });
+    if (hit?.resetsAt) usageLimits.noteLimitHit({ provider, limitType: hit.limitType, resetsAt: hit.resetsAt });
+  } catch (error) {
+    console.warn(`[usage-limits] limit record: ${redactSensitive(String(error.message || error))}`);
+  }
+}
+
 // Remember each window's use; the warnings now due (80% / 95%, once per
 // window). A run that cannot show them only updates the use, so the warning
 // is still due on the next turn that can.
@@ -2637,16 +2657,18 @@ function cancelQueuedCallOnAbort(lane, item) {
 
 // Admit waiting lanes into free slots: every lane with queued work and no run,
 // oldest waiting message first, as far as the caps allow. An admitted lane runs
-// its next queued message (one at a time within a lane) in that message's own
-// captured context. Called whenever a run, a compaction or a /stop frees a
-// lane, and synchronous up to the admission, so no newcomer can take a freed
-// slot ahead of a lane that was already waiting. Every state's lanes are
-// considered (the global cap is shared); the argument is kept for callers.
+// what waits in it as ONE turn: the person's queued messages together (see
+// takeQueueBatch), in the first message's captured context. Called whenever a
+// run, a compaction or a /stop frees a lane, and synchronous up to the
+// admission, so no newcomer can take a freed slot ahead of a lane that was
+// already waiting. Every state's lanes are considered (the global cap is
+// shared); the argument is kept for callers.
 function drainQueuedMessages(_state) {
   for (const { state, lane } of waitingLanes()) {
     if (laneBusy(lane) || !lane.messageQueue.length) continue;
     if (slotBlocker(state)) { lane.waitingForSlot = true; continue; }
-    const item = lane.messageQueue.shift();
+    const batch = takeQueueBatch(lane);
+    const item = batch.length > 1 ? mergeQueueBatch(lane, batch) : batch[0];
     item.disposeCallListener?.();
     lane.preparingRun = true;
     lane.waitingForSlot = false;
@@ -2666,6 +2688,163 @@ function queueInLane(lane, item) {
   return item;
 }
 
+// ── The queue: run together, remove one ────────────────────────────────
+// Messages a person sends while their conversation is busy used to run one
+// turn each, in series, every one answering without the others. Now, when the
+// lane frees, the queued messages run as one turn (QUEUE_BATCH=off restores
+// one at a time). Only plain chat messages from the same person, in the same
+// session, project, provider and model join; anything else (a scheduled run,
+// a side chat's follow-up, a limit pick-up, a live call) runs on its own, in
+// order. Up to QUEUE_BATCH_MAX (10) per turn.
+const QUEUE_BATCH_MAX = 10;
+function queueBatchOn() {
+  return !/^(off|false|0|no)$/i.test(String(process.env.QUEUE_BATCH ?? config.QUEUE_BATCH ?? "on").trim());
+}
+
+function queuedSender(item) {
+  return String(item?.store?.canonicalUserId || item?.runContext?.canonicalUserId || "");
+}
+
+function batchable(item) {
+  const runContext = item?.runContext;
+  return !!runContext
+    && !item.pendingSideChat
+    && !item.followMainRunId
+    && runContext.purpose === "foreground"
+    && !runContext.liveCall
+    && !runContext.limitPickup
+    && item.store?.adapter?.liveCall !== true;
+}
+
+function sameBatch(a, b) {
+  const x = a.runContext;
+  const y = b.runContext;
+  return !!queuedSender(a)
+    && queuedSender(a) === queuedSender(b)
+    && x.provider === y.provider
+    && (x.project?.dir || null) === (y.project?.dir || null)
+    && (x.sessionId || null) === (y.sessionId || null)
+    && (x.providerSettings?.model || null) === (y.providerSettings?.model || null);
+}
+
+// The next turn's messages, taken off the front of the lane's queue.
+function takeQueueBatch(lane) {
+  const first = lane.messageQueue.shift();
+  const batch = [first];
+  if (!queueBatchOn() || !batchable(first)) return batch;
+  while (lane.messageQueue.length && batch.length < QUEUE_BATCH_MAX) {
+    const next = lane.messageQueue[0];
+    if (!batchable(next) || !sameBatch(first, next)) break;
+    batch.push(lane.messageQueue.shift());
+  }
+  return batch;
+}
+
+function queueClock(ms) {
+  return new Date(ms).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit", hour12: false });
+}
+
+function batchPrompt(batch) {
+  const n = batch.length;
+  const parts = [`[${n} messages arrived while you were busy. Read them all, then reply once: answer each, and where a later one changes or cancels an earlier one, the later one wins.]`];
+  batch.forEach((item, index) => {
+    const at = Number(item.queuedAt);
+    const when = Number.isFinite(at) && at > 0 ? ` (${queueClock(at)})` : "";
+    parts.push(`--- Message ${index + 1} of ${n}${when} ---\n${item.runContext.userPrompt}`);
+  });
+  return parts.join("\n\n");
+}
+
+// One queue item for the whole batch: the first message's captured context
+// (its session and lineage), every message's text, images and files, and the
+// newest message as the one the reply answers. Every sender's caller gets the
+// one result; the journal keeps the batch as the first message's turn.
+function mergeQueueBatch(lane, batch) {
+  const first = batch[0];
+  const last = batch[batch.length - 1];
+  for (const item of batch.slice(1)) {
+    try { item.disposeCallListener?.(); } catch (_) {}
+  }
+  const runContext = deepFreeze({
+    ...bindRunInputs(first.runContext, {
+      userPrompt: batchPrompt(batch),
+      imagePaths: batch.flatMap((item) => item.runContext.imagePaths || []),
+      attachments: batch.flatMap((item) => item.runContext.attachments || []),
+      lastInputWasVoice: !!last.runContext.lastInputWasVoice,
+      voiceStream: !!last.runContext.voiceStream,
+    }),
+    replyToMsgId: last.runContext.replyToMsgId ?? first.runContext.replyToMsgId ?? null,
+  });
+  try { turnJournal.dropQueued(lane.key, batch.slice(1).map((item) => item.runContext.runId).filter(Boolean)); } catch (_) {}
+  const words = batch.map((item) => String(item.store?.inboundText || "").trim()).filter(Boolean);
+  const store = last.store ? { ...last.store, inboundText: words.join("\n\n") } : first.store;
+  console.log(`[queue] ${lane.key}: ${batch.length} queued messages run as one turn (run ${runContext.runId || "?"})`);
+  return {
+    runContext,
+    store,
+    queuedAt: first.queuedAt,
+    seq: first.seq,
+    text: batch.map((item) => item.text).filter(Boolean).join(" / "),
+    deferred: {
+      resolve: (result) => { for (const item of batch) item.deferred?.resolve(result); },
+      reject: (error) => { for (const item of batch) item.deferred?.reject(error); },
+    },
+  };
+}
+
+// The ✕ on a "Queued." notice takes that one message out of its queue
+// (callback "qx:<boot>:<seq>"). The boot id keeps a button from before a
+// restart from naming a message that got the same number since.
+const QUEUE_BOOT = crypto.randomBytes(3).toString("hex");
+
+function queueRemoveKeyboard(item) {
+  if (!item?.runContext || item.runContext.liveCall || !Number.isSafeInteger(item.seq)) return null;
+  return { inline_keyboard: [[{ text: "✕ Remove from queue", callback_data: `qx:${QUEUE_BOOT}:${item.seq}` }]] };
+}
+
+function queuedWords(item) {
+  const text = String(item?.text || item?.runContext?.userPrompt || "").replace(/\s+/g, " ").trim();
+  return text.length > 40 ? `${text.slice(0, 39)}…` : (text || "…");
+}
+
+// Only the person whose message it is, or the owner, in the chat it was sent in.
+function mayRemoveQueued(envelope, item, opts = {}) {
+  const channelId = item.store?.channelId || item.runContext?.channelId || "";
+  if (String(envelope?.channelId || "") !== String(channelId)) return false;
+  if (opts.isOwner === true) return true;
+  const sender = queuedSender(item);
+  return !!sender && String(envelope?.canonicalUserId || "") === sender;
+}
+
+async function handleQueueRemove(data, envelope, opts = {}) {
+  const [, boot, seqText] = String(data || "").split(":");
+  const seq = Number(seqText);
+  const noticeId = envelope?.action?.sourceMessageId || null;
+  const answer = (text) => (noticeId ? editMessage(String(noticeId), text) : send(text));
+  const hit = boot === QUEUE_BOOT && Number.isSafeInteger(seq) ? findQueued((item) => item.seq === seq) : null;
+  if (!hit) return answer("No longer queued: it already started (or was dropped). /stop cancels a running turn.");
+  const { lane, item } = hit;
+  if (!mayRemoveQueued(envelope, item, opts)) return send("That button belongs to another person.");
+  const index = lane.messageQueue.indexOf(item);
+  if (index >= 0) lane.messageQueue.splice(index, 1);
+  try { item.disposeCallListener?.(); } catch (_) {}
+  try { turnJournal.dropQueued(lane.key, [item.runContext?.runId].filter(Boolean)); } catch (_) {}
+  if (!lane.messageQueue.length) {
+    lane.waitingForSlot = false;
+    if (!laneBusy(lane)) stopLaneTyping(lane);
+  }
+  item.deferred?.resolve({
+    ok: false,
+    status: "cancelled",
+    runId: item.runContext?.runId || null,
+    provider: item.runContext?.provider || null,
+    project: item.runContext?.project || null,
+    error: { code: "QUEUE_REMOVED", message: "Removed from the queue" },
+  });
+  console.log(`[queue] ${lane.key}: removed queued message ${seq} (${lane.messageQueue.length} left)`);
+  return answer(`Removed from the queue: "${queuedWords(item)}"`);
+}
+
 // A refusal on a RESUMED session is almost always the safety classifier
 // rejecting flagged material in the old context — which every resume re-sends
 // — not the user's new message. Recovery: quarantine the poisoned session so
@@ -2781,6 +2960,16 @@ async function runAdmitted(runContext, state, store, capture, ownsAdmissionLock,
   const persistCapture = executionOptions.persistCapture !== false;
   const internalCapture = capture && !persistCapture;
   if (tracksMainRun) lane.activeRunContext = runContext;
+  // The turn after a /stop: the stopped request is in the session's history
+  // looking cut off, so this turn opens with a note that it was cancelled.
+  if (tracksMainRun && runContext.purpose === "foreground" && !runContext.liveCall) {
+    const stopped = turnJournal.takeStopped(runLaneKey(runContext));
+    if (stopped) {
+      const noted = bindRunInputs(runContext, { userPrompt: `${turnJournal.stoppedNote(stopped)}\n\n${runContext.userPrompt}` });
+      if (lane.activeRunContext === runContext) lane.activeRunContext = noted;
+      runContext = noted;
+    }
+  }
   // Turn journal "lock": a foreground chat turn that a restart cuts short is
   // resumed after boot (core/turn-journal).
   if (tracksMainRun) turnJournal.begin(runContext);
@@ -3010,7 +3199,8 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
       const notice = admission.reason === "busy"
         ? (lane.isCompacting ? "Compacting context, will pick this up next…" : queuedNotice(lane.activeRunContext))
         : waitingNotice(admission.running);
-      send(notice, { replyTo: replyToMsgId }).catch(() => {});
+      const keyboard = queueRemoveKeyboard(item);
+      send(notice, keyboard ? { replyTo: replyToMsgId, keyboard } : { replyTo: replyToMsgId }).catch(() => {});
     }
     return deferred.promise;
   }
@@ -3110,6 +3300,9 @@ function runAgentSilent(prompt, cwd, label, opts = {}) {
 
 module.exports = {
   queuedNotice,
+  handleQueueRemove,
+  takeQueueBatch,
+  mergeQueueBatch,
   waitingNotice,
   deliverForegroundResult,
   drainQueuedMessages,

package/core/scheduler.js

@@ -44,6 +44,10 @@ const { providerStatus: defaultProviderStatus } = require("./providers");
 const { redactSensitive } = require("./redact");
 
 const MISSED_WAKEUP_GRACE_MS = 60 * 60 * 1000;
+// A new occurrence starts with no usage-limit wait behind it.
+const LIMIT_WAIT_CLEARED = Object.freeze({
+  limitWaitCount: 0, limitWaitUntil: null, limitWaitType: null, limitWaitProvider: null, limitFirstHitAt: null,
+});
 const RETRY_DELAY_MS = 30 * 1000;
 const BUSY_DELAY_MS = 30 * 1000;
 // A watch alarm that has waited this long behind a busy room says so in the
@@ -247,6 +251,9 @@ function createSchedulerService(dependencies = {}) {
     ? (dependencies.jobsStore ? null : CRONS_FILE)
     : dependencies.legacyCronsFile;
   const runInProvider = dependencies.runAgent || ((...args) => require("./runner").runAgent(...args));
+  // What a run a usage limit stopped does (core/limit-pickup.js planFor): the
+  // same rule and wording as a chat message the limit stopped.
+  const planLimit = dependencies.planLimit || ((...args) => require("./limit-pickup").planFor(...args));
   const admit = dependencies.admitRunContext || ((...args) => require("./runner").admitRunContext(...args));
   const projectSessions = dependencies.getProjectSessions || getProjectSessions;
   const timers = new Map();
@@ -510,6 +517,9 @@ function createSchedulerService(dependencies = {}) {
     }
     const polled = job.check ? pendingPollNote(job) : null;
     if (polled) lines.push(polled);
+    if (Number(job.limitWaitCount) > 0 && Number.isFinite(Number(job.limitFirstHitAt))) {
+      lines.push(`[A usage limit stopped this run at ${new Date(Number(job.limitFirstHitAt)).toISOString()}; it waited for the reset and runs now. Check what still applies before acting.]`);
+    }
     if (target.fallbackFrom) {
       lines.push(`[Archived provider-neutral brief: the originating ${target.fallbackFrom} provider is unavailable. Its native session is not being resumed; this explicitly configured fallback starts fresh.]`);
     } else if (target.revertedFrom) {
@@ -653,6 +663,7 @@ function createSchedulerService(dependencies = {}) {
         watchLastHitAt: null,
         watchLastClearAt: null,
         advisoryOccurrenceId: null,
+        ...LIMIT_WAIT_CLEARED,
       };
       const advanced = jobsStore.update(job.id, advance) || { ...latest, ...advance };
       unscheduleJob(job.id);
@@ -705,6 +716,41 @@ function createSchedulerService(dependencies = {}) {
     return { ok: false, deferred: true, status: updated.status, job: updated };
   }
 
+  // The usage-limit plan of a failed run, or null (the runner keeps it on the
+  // result; a run that never reached delivery is planned here).
+  function limitPlanOf(result, runContext) {
+    if (result?.error?.code !== "PROVIDER_USAGE_LIMIT") return null;
+    if (result.limitPlan !== undefined) return result.limitPlan;
+    try { return planLimit(result, runContext, { now: now() }); }
+    catch (_) { return null; }
+  }
+
+  // A usage limit is not a failed attempt: the occurrence waits for the reset,
+  // as a chat message does (core/limit-pickup.js), and never moves to another
+  // provider (it may not be signed in, or be used up too). The notice was
+  // posted with the run's result.
+  function markLimitWait(job, plan, result) {
+    const latest = jobsStore.get(job.id) || job;
+    const patch = {
+      status: "deferred",
+      disabled: false,
+      attemptCount: Math.max(0, (Number(latest.attemptCount) || 1) - 1),
+      nextAttemptAt: plan.runAt,
+      lastFireAt: now(),
+      lastFireOk: false,
+      lastError: stableFailure(result),
+      limitWaitCount: (Number(latest.limitWaitCount) || 0) + 1,
+      limitWaitUntil: plan.runAt,
+      limitWaitType: plan.hit?.limitType || null,
+      limitWaitProvider: plan.hit?.provider || null,
+      limitFirstHitAt: Number(latest.limitFirstHitAt) || now(),
+    };
+    const updated = jobsStore.update(job.id, patch) || { ...latest, ...patch };
+    armRetry(updated);
+    console.log(`[scheduler] ${job.id}: ${patch.limitWaitProvider || "provider"} ${patch.limitWaitType || "usage limit"} used up; waits until ${new Date(plan.runAt).toISOString()} (wait ${patch.limitWaitCount})`);
+    return { ok: false, status: "deferred", limitWait: true, runAt: plan.runAt, job: updated, result };
+  }
+
   async function settleSuccess(job, result, target) {
     const successPatch = {
       status: "succeeded",
@@ -759,6 +805,7 @@ function createSchedulerService(dependencies = {}) {
       watchLastHitAt: null,
       watchLastClearAt: null,
       advisoryOccurrenceId: null,
+      ...LIMIT_WAIT_CLEARED,
     });
     if (reset && timers.get(job.id)?.timeout) scheduleJob(reset);
     return reset
@@ -909,6 +956,11 @@ function createSchedulerService(dependencies = {}) {
         occurrenceId: job.occurrenceId,
         scheduledJobId: job.id,
         originRunId: job.originRunId || null,
+        // A run that waited for a limit's reset: a new hit says "still used up"
+        // and counts towards the most waits (limit-pickup MAX_ATTEMPTS).
+        ...(Number(job.limitWaitCount) > 0 ? {
+          limitPickup: { attempts: Number(job.limitWaitCount), firstHitAt: Number(job.limitFirstHitAt) || null, limitType: job.limitWaitType || null },
+        } : {}),
       };
       // Admission is synchronous and precedes all notification delivery. A
       // refusal is a failed attempt, never a rejection that drops the job.
@@ -978,6 +1030,11 @@ function createSchedulerService(dependencies = {}) {
         catch (persistError) { return keepRetrying(running, persistError); }
       }
       if (!terminalRunSucceeded(result)) {
+        const limitPlan = limitPlanOf(result, runContext);
+        if (limitPlan?.waits && Number.isFinite(limitPlan.runAt)) {
+          try { return markLimitWait(running, limitPlan, result); }
+          catch (error) { return { ...keepRetrying(running, error), result }; }
+        }
         try { return markFailure(running, result, { attemptAlreadyCounted: true }); }
         catch (error) { return { ...keepRetrying(running, error), result }; }
       }

package/core/state.js

@@ -1045,6 +1045,19 @@ function waitingLanes() {
   });
 }
 
+// A queued message anywhere (every person's state, every conversation), for
+// the ✕ on its "Queued." notice. Returns { state, lane, item } or null.
+function findQueued(predicate) {
+  for (const state of statesWithLanes()) {
+    if (!(state.lanes instanceof Map)) continue;
+    for (const lane of state.lanes.values()) {
+      const item = lane.messageQueue.find(predicate);
+      if (item) return { state, lane, item };
+    }
+  }
+  return null;
+}
+
 // /stop arms lane.cancelRequested with the id of the run it stops (true only
 // when no run context is known), and a run acts on the flag only when it names
 // that run. A bare boolean let a stop outlive its run and cancel the next one.
@@ -1898,6 +1911,7 @@ module.exports = {
   runningLanes,
   slotBlocker,
   waitingLanes,
+  findQueued,
   pruneIdleLanes,
   maxParallelTurns,
   maxParallelTurnsGlobal,