@inetafrica/open-claudia 3.5.19 → 3.5.23

package/core/browser-view.js

@@ -98,13 +98,15 @@ function listSessions({ dirs = socketDirs(), alive = processAlive } = {}) {
         } catch (_) { /* try the next file */ }
       }
       seen.add(name);
-      sessions.push({ name, port, page, updatedAt });
+      // dir: the socket folder, so the bot's own agent-browser calls (core/browser-teach.js) reach
+      // this session and never start a new one. Internal like the port.
+      sessions.push({ name, port, page, updatedAt, dir });
     }
   }
   return sessions.sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || "")));
 }
 
-// Public view of a session: the stream port stays inside the bot.
+// Public view of a session: the stream port and socket folder stay inside the bot.
 function describeSessions(options) {
   return listSessions(options).map(({ name, page, updatedAt }) => ({ name, page, updatedAt }));
 }
@@ -189,6 +191,7 @@ function serveStream(res, sessionName, { fps, sessions, connect, keepaliveMs = K
 module.exports = {
   DEFAULT_FPS,
   MAX_FPS,
+  SESSION_NAME,
   clampFps,
   describeSessions,
   listSessions,

package/core/cards.js

@@ -255,7 +255,9 @@ function describeResponse(rec, payload, now = Date.now()) {
 // ---------------------------------------------------------------------------
 // Waking the conversation a card (or decision) came from
 
-function wakeOrigin(origin, prompt, label, { scheduler, delayMs = 1500 } = {}) {
+// `source` tags the job for job lists and audits: "card" for card answers,
+// "browser" for the Browser app's hand-backs and Teach-me recordings.
+function wakeOrigin(origin, prompt, label, { scheduler, delayMs = 1500, source = "card" } = {}) {
   if (!origin || !origin.channelId || !origin.provider || !origin.project || !origin.canonicalUserId) {
     throw new Error("the card's origin conversation is unknown");
   }
@@ -282,7 +284,7 @@ function wakeOrigin(origin, prompt, label, { scheduler, delayMs = 1500 } = {}) {
     },
     prompt,
     label: String(label).slice(0, 60),
-    source: "card",
+    source,
     fireAt: Date.now() + delayMs,
   });
 }

package/core/dream.js

@@ -26,6 +26,7 @@ const daySeeds = require("./day-seeds");
 const packGuard = require("./pack-guard");
 const persona = require("./persona");
 const { spawnUtilityAgent } = require("./utility-agent");
+const usageLimits = require("./usage-limits");
 const recallMetrics = require("./recall/metrics");
 const recallTuning = require("./recall/tuning");
 const recallGraphLib = require("./recall/graph");
@@ -1117,6 +1118,40 @@ function failedIntelligenceMetadata(error) {
   };
 }
 
+// Waits in a row for a limit (a reset that is used up again at once) before
+// the dream gives up until its next nightly run.
+const DREAM_LIMIT_MAX_WAITS = 5;
+
+// A dream AI step a usage limit stopped waits for the reset, like a chat
+// message or a scheduled run (core/usage-limits limitRetryAt), never on
+// another provider. Null when the failure was not a limit, or its reset is
+// unknown or too far out to wait for.
+function dreamLimitWait(error, { now = Date.now() } = {}) {
+  const result = error?.result || null;
+  if ((error?.code || result?.error?.code) !== "PROVIDER_USAGE_LIMIT") return null;
+  const provider = result?.provider || null;
+  const hit = usageLimits.limitHitDetails({ provider, error: result?.error || error, now });
+  const runAt = usageLimits.limitRetryAt(hit?.resetsAt, { now });
+  if (!hit || runAt === null || !usageLimits.canWaitFor(runAt, { now })) return null;
+  return { provider, limitType: hit.limitType || null, resetsAt: hit.resetsAt, runAt };
+}
+
+function limitName(provider, limitType) {
+  return `${usageLimits.providerLabel(provider)}'s ${usageLimits.windowLabel(limitType)}`;
+}
+
+// The "Heads up — <note>, so I skipped the AI-led merges" note of an AI step
+// that failed for good: plain words for a sign-in that died or a limit with
+// no reset, the provider's own message otherwise.
+function dreamFailNote(error) {
+  const result = error?.result || null;
+  const code = error?.code || result?.error?.code;
+  const label = usageLimits.providerLabel(result?.provider);
+  if (code === "PROVIDER_UNAUTHENTICATED") return `${label}'s sign-in on this bot has expired (send /login to sign in again)`;
+  if (code === "PROVIDER_USAGE_LIMIT") return `${label}'s usage limit is used up and it gave no reset time`;
+  return `the AI consolidation step didn't finish (${error?.message || "unknown error"})`;
+}
+
 async function previewDreamWith(runUtility, { provider = null } = {}) {
   const result = await runUtility(buildDreamPrompt(), dreamUtilityOptions("dream", {
     provider,
@@ -1189,6 +1224,14 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
     // decision (applyDream no-ops), note it for the report, and carry on.
     let decision = null;
     let modelFailNote = "";
+    let limitWait = null;
+    // Waits in a row so far: a run after a reset that is used up again counts on.
+    const waitsBefore = trigger === "limit-reset" ? Number(dreamState.limitWait?.attempts) || 0 : 0;
+    const limitWaitFor = (error) => {
+      const wait = dreamLimitWait(error);
+      if (!wait || waitsBefore + 1 <= DREAM_LIMIT_MAX_WAITS) return { wait, note: "" };
+      return { wait: null, note: `${limitName(wait.provider, wait.limitType)} is still used up after ${DREAM_LIMIT_MAX_WAITS} waits (the next nightly dream tries again)` };
+    };
     let consolidationIntelligence = intelligenceMetadata(null, "not_run");
     try {
       const dreamRun = await runUtility(
@@ -1208,7 +1251,10 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
       }
     } catch (e) {
       consolidationIntelligence = failedIntelligenceMetadata(e);
-      modelFailNote = `the AI consolidation step didn't finish (${e.message})`;
+      const waiting = limitWaitFor(e);
+      limitWait = waiting.wait;
+      if (limitWait) consolidationIntelligence.status = "waiting_for_limit";
+      else modelFailNote = waiting.note || dreamFailNote(e);
     }
     if (!decision) decision = { report: "" };
 
@@ -1266,7 +1312,9 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
     catch (e) { console.warn(`[dream] certification proposals failed: ${e.message}`); }
     const consolidationLines = applied.concat(nestLines, journalLines, coRescueLines, hebbianLines, prospectiveLines, regressionLines, costLines, certLines, knobLines);
     let report = decision.report || (consolidationLines.length > 0 ? "Tidied up my memory overnight." : "");
-    if (modelFailNote) {
+    if (limitWait) {
+      report = `⏳ ${limitName(limitWait.provider, limitWait.limitType)} is used up, so the AI-led merges wait for its reset: I'll run them ${usageLimits.whenPhrase(limitWait.runAt)}. The automatic filing + graph upkeep ran now.${report ? " " + report : ""}`;
+    } else if (modelFailNote) {
       report = `Heads up — ${modelFailNote}, so I skipped the AI-led merges this round but still ran the automatic filing + graph upkeep.${report ? " " + report : ""}`;
     }
 
@@ -1278,8 +1326,9 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
     let introReport = "";
     let introApplied = [];
     let introProposed = null;
-    let introspectionIntelligence = intelligenceMetadata(null, introspectEnabled() ? "not_run" : "disabled");
-    if (introspectEnabled()) {
+    let introspectionIntelligence = intelligenceMetadata(null, introspectEnabled() ? (limitWait ? "waiting_for_limit" : "not_run") : "disabled");
+    // A used-up limit stops this step too: it runs with the dream after the reset.
+    if (introspectEnabled() && !limitWait) {
       try {
         const introRun = await runUtility(buildIntrospectionPrompt(), dreamUtilityOptions("introspection", {
           provider,
@@ -1300,6 +1349,11 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
         }
       } catch (e) {
         introspectionIntelligence = failedIntelligenceMetadata(e);
+        limitWait = limitWaitFor(e).wait;
+        if (limitWait) {
+          introspectionIntelligence.status = "waiting_for_limit";
+          introReport = `⏳ ${limitName(limitWait.provider, limitWait.limitType)} ran out during my self-review: I'll run the dream again ${usageLimits.whenPhrase(limitWait.runAt)}, when it resets.`;
+        }
         console.warn(`[dream] introspection phase failed: ${e.message}`);
       }
     }
@@ -1493,6 +1547,12 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
       dreamState.fallbackUsed = consolidationIntelligence.fallbackUsed;
       dreamState.lastRunStatus = consolidationIntelligence.status;
       dreamState.introspection = introspectionIntelligence;
+      // The AI step waits for a limit's reset (createDreamLimitWait runs the
+      // dream then); a run that got past the limit, or failed another way,
+      // leaves nothing waiting. Waits in a row are counted and capped.
+      dreamState.limitWait = limitWait
+        ? { ...limitWait, attempts: waitsBefore + 1, since: (waitsBefore && dreamState.limitWait?.since) || nowISO }
+        : null;
       writeDreamState(dreamState);
     } catch (e) { console.warn(`[dream] state write failed: ${e.message}`); }
 
@@ -1553,6 +1613,7 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
     introspectionProvider: introspectionIntelligence.provider,
     introspectionModel: introspectionIntelligence.model,
     introspectionFallbackUsed: introspectionIntelligence.fallbackUsed,
+    limitWait,
   };
 }
 
@@ -1622,10 +1683,11 @@ async function dreamSummaryTarget(adapters, deps = {}) {
   return null;
 }
 
-// One scheduled dream (cron or catch-up) with its summary.
+// One scheduled dream (cron, catch-up, or after a limit's reset) with its summary.
 async function runScheduledDream(trigger, adapters, deps = {}) {
   try {
     const res = await (deps.runDream || runDream)({ trigger });
+    try { deps.afterRun?.(res); } catch (_) { /* arming the next wait is best effort */ }
     if (res.skipped) { console.log(`dream: skipped — ${res.skipped}`); return res; }
     console.log(`dream: applied ${(res.applied || []).length} change(s)`);
     if (!summaryEnabled()) { console.log("dream: summary muted (DREAM_SUMMARY=off)"); return res; }
@@ -1670,6 +1732,63 @@ function createDreamCatchUp(adapters, deps = {}) {
   };
 }
 
+// The dream whose AI step a usage limit stopped runs again after the reset
+// (dream state limitWait.runAt), as a whole dream: its automatic steps are
+// safe to repeat. Armed at boot, after every scheduled run, and hourly (a
+// manual /dream may have recorded a wait), so a restart never loses it.
+function createDreamLimitWait(adapters, deps = {}) {
+  const now = deps.now || Date.now;
+  const readState = deps.readState || readDreamState;
+  const setTimer = deps.setTimer || setTimeout;
+  const clearTimer = deps.clearTimer || clearTimeout;
+  const isDreaming = deps.isDreaming || defaultDreamService.isDreaming;
+  // setTimeout's ceiling is ~24.8 days; a week's wait fits, the rest re-arms.
+  const MAX_TIMER_MS = 2 ** 31 - 1;
+  let timer = null;
+  let armedFor = null;
+
+  function disarm() {
+    if (timer) clearTimer(timer);
+    timer = null;
+    armedFor = null;
+  }
+
+  function arm() {
+    let runAt = NaN;
+    try { runAt = Number(readState()?.limitWait?.runAt); } catch (_) { runAt = NaN; }
+    if (!Number.isFinite(runAt)) { disarm(); return null; }
+    if (timer && armedFor === runAt) return runAt;
+    disarm();
+    armedFor = runAt;
+    timer = setTimer(() => { fire().catch((e) => console.warn(`dream: limit-reset run failed: ${e.message}`)); }, Math.min(Math.max(runAt - now(), 0), MAX_TIMER_MS));
+    timer?.unref?.();
+    console.log(`dream: AI step waits for a usage limit; runs ${new Date(runAt).toISOString()}`);
+    return runAt;
+  }
+
+  async function fire() {
+    timer = null;
+    armedFor = null;
+    let wait = null;
+    try { wait = readState()?.limitWait || null; } catch (_) { wait = null; }
+    const runAt = Number(wait?.runAt);
+    if (!Number.isFinite(runAt)) return { skipped: "nothing waits" };
+    if (runAt - now() > 1000) return { skipped: "not yet", runAt: arm() };
+    if (isDreaming()) {
+      // A dream is running now: look again in a minute.
+      timer = setTimer(() => { fire().catch(() => {}); }, 60000);
+      timer?.unref?.();
+      armedFor = runAt;
+      return { skipped: "a dream is already running" };
+    }
+    const res = await runScheduledDream("limit-reset", adapters, deps);
+    arm();
+    return res;
+  }
+
+  return { arm, fire, disarm };
+}
+
 // In-bot scheduler: one quiet-hours cron (tolerating a late start up to
 // DREAM_LATE_TOLERANCE_MS, see core/cron-schedule), a boot + hourly catch-up
 // check, and the summary to the owner's channel (dreamSummaryTarget). When the
@@ -1685,18 +1804,20 @@ function initDream(adapters, deps = {}) {
   }
   const { DREAM_LATE_TOLERANCE_MS } = require("./config");
   const toleranceMs = Number.isFinite(deps.toleranceMs) ? deps.toleranceMs : DREAM_LATE_TOLERANCE_MS;
-  const task = scheduleTolerant(DREAM_CRON, () => runScheduledDream("cron", adapters, deps), {
+  const limitWait = createDreamLimitWait(adapters, deps);
+  const runDeps = { ...deps, afterRun: () => limitWait.arm() };
+  const task = scheduleTolerant(DREAM_CRON, () => runScheduledDream("cron", adapters, runDeps), {
     cron: cronLib, toleranceMs, noOverlap: true, label: "dream",
   });
-  const catchUp = createDreamCatchUp(adapters, deps);
+  const catchUp = createDreamCatchUp(adapters, runDeps);
   const setTimer = deps.setTimer || setTimeout;
   const setRepeat = deps.setInterval || setInterval;
-  const boot = setTimer(() => { catchUp("boot").catch(() => {}); }, Number.isFinite(deps.bootDelayMs) ? deps.bootDelayMs : 60000);
-  const hourly = setRepeat(() => { catchUp("hourly").catch(() => {}); }, 3600000);
+  const boot = setTimer(() => { limitWait.arm(); catchUp("boot").catch(() => {}); }, Number.isFinite(deps.bootDelayMs) ? deps.bootDelayMs : 60000);
+  const hourly = setRepeat(() => { limitWait.arm(); catchUp("hourly").catch(() => {}); }, 3600000);
   boot?.unref?.();
   hourly?.unref?.();
   console.log(`dream: scheduled (${DREAM_CRON}, late tolerance ${Math.round(toleranceMs / 60000)} min, provider policy tier ${dreamTier()}, effort ${DREAM_EFFORT}, introspect ${introspectEnabled() ? "on" : "off"})`);
-  return { task, catchUp };
+  return { task, catchUp, limitWait };
 }
 
 module.exports = {
@@ -1704,6 +1825,7 @@ module.exports = {
   buildIntrospectionPrompt, parseIntrospection, applyIntrospection, writeDreamReport,
   summaryDelta, healthOf, mergeClusters, selectDumpDirs, journalBackfillDedupe, staleTaskReport,
   dreamSummaryTarget, runScheduledDream, dreamOverdue, createDreamCatchUp, DREAM_CATCHUP_MS,
+  createDreamLimitWait, dreamLimitWait, dreamFailNote, DREAM_LIMIT_MAX_WAITS,
   coRescueEdgesPhase, negativeHebbianPhase, readDreamState, writeDreamState,
   enabled, summaryEnabled, introspectEnabled, selfApplyEnabled, dreamTier,
   DREAM_CRON, DREAM_EFFORT, DREAM_OUTPUT_SCHEMA, INTROSPECTION_OUTPUT_SCHEMA,

package/core/handlers.js

@@ -118,6 +118,8 @@ function dropLaneQueue(lane, reason) {
 // Clears the CURRENT conversation's queue only: /new, /end or a project change
 // in one thread must not drop what another conversation has waiting.
 function clearTransientQueue(state, reason = "Session context changed before the queued run started") {
+  // The stopped turn's history goes with the session: nothing to warn about.
+  if (state) { try { require("./turn-journal").clearStopped(currentLaneKey(state)); } catch (_) {} }
   return dropLaneQueue(state ? peekLane(state) : null, reason).length;
 }
 
@@ -1739,6 +1741,18 @@ function stopLane(state, lane) {
   return null;
 }
 
+// stopLane for /stop: a run killed mid-turn left its request in the session's
+// history, so the conversation's next turn is told it was cancelled (core/
+// turn-journal markStopped). A compaction or a turn still preparing left none.
+function stopAndMarkLane(state, lane) {
+  const killed = lane.runningProcess && lane.activeRunContext ? lane.activeRunContext : null;
+  const stopped = stopLane(state, lane);
+  if (stopped && killed) {
+    try { require("./turn-journal").markStopped(lane.key, { runContext: killed }); } catch (_) {}
+  }
+  return stopped;
+}
+
 const STOP_DROP_REASON = "Dropped by /stop before it started";
 
 // /stop never silently loses a queued message: each dropped one comes back
@@ -1803,7 +1817,7 @@ register({
       const lanes = state.lanes instanceof Map ? [...state.lanes.values()] : [];
       // Drop the queues first, so no stopped lane's unwind admits them.
       const dropped = lanes.flatMap((lane) => dropLaneQueue(lane, STOP_DROP_REASON));
-      const stopped = lanes.filter((lane) => stopLane(state, lane)).length;
+      const stopped = lanes.filter((lane) => stopAndMarkLane(state, lane)).length;
       const sideStopped = await sideCancellation;
       let pickups = [];
       try { pickups = require("./limit-pickup").cancelAllFor(state.userId, "/stop all"); } catch (_) {}
@@ -1827,7 +1841,7 @@ register({
     // A pick-up waiting for a usage limit to reset is dropped too.
     const pickup = dropLimitPickup("/stop", state, lane.key);
     const pickupNote = pickup ? ` ${pickupDroppedNote(1)}` : "";
-    if (stopLane(state, lane)) {
+    if (stopAndMarkLane(state, lane)) {
       await sideCancellation;
       await send(`${dropped.length ? `Cancelled. ${droppedNote(dropped, "queued")}` : "Cancelled."}${pickupNote}`, dropOffer(dropped));
     } else if (dropped.length) {

package/core/limit-pickup.js

@@ -17,6 +17,9 @@
 //     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).
+// When to run again is one rule for every kind of work (usage-limits
+// limitRetryAt); a scheduled run a limit stopped waits the same way in the
+// jobs store (core/scheduler.js), with the notice worded here.
 
 const path = require("path");
 const crypto = require("crypto");
@@ -37,16 +40,10 @@ function setting(name) {
 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;
-}
+// The shared rule (core/usage-limits.js): LIMIT_PICKUP_DELAY_S after the
+// reset, never for a reset more than LIMIT_PICKUP_MAX_WAIT_H away.
+const delayMs = () => limits.limitRetryDelayMs();
+const maxWaitMs = () => limits.limitMaxWaitMs();
 
 // A test run that did not point the store somewhere else never touches the
 // live bot's pick-ups.
@@ -100,9 +97,10 @@ function limitName(provider, 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.
+ * What a turn stopped by a limit should do: arm a pick-up (armable), wait in
+ * the scheduler (waits: a scheduled run), or only say when the limit lifts.
+ * Pure: deliverForegroundResult posts `notice` and then calls arm() with the
+ * plan when armable; the scheduler reads `waits` and `runAt`.
  */
 function planFor(result, runContext, { now = Date.now(), windows = [], guarded = false } = {}) {
   const hit = limits.limitHitDetails({
@@ -111,21 +109,27 @@ function planFor(result, runContext, { now = Date.now(), windows = [], guarded =
   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 runAt = limits.limitRetryAt(hit.resetsAt, { now });
+  const known = runAt !== null;
   const pickup = runContext?.limitPickup || null;
   const attempts = (pickup?.attempts || 0) + 1;
+  const waitable = known && limits.canWaitFor(runAt, { now }) && attempts <= MAX_ATTEMPTS;
+  // A scheduled run waits in the jobs store for the reset (core/scheduler.js).
+  const waits = waitable && runContext?.purpose === "scheduled";
   const armable = enabled()
-    && known
-    && runAt - now <= maxWaitMs()
-    && attempts <= MAX_ATTEMPTS
+    && waitable
     && runContext?.purpose === "foreground"
     && !runContext?.passive
     && !runContext?.liveCall
     && !!runContext?.origin?.adapterId
     && !!runContext?.channelId;
   let notice;
-  if (known && runContext?.purpose && runContext.purpose !== "foreground") {
+  if (waits) {
+    const again = pickup && pickup.limitType && pickup.limitType === hit.limitType ? "is still used up" : "is used up too";
+    notice = pickup
+      ? `⏳ ${name} ${again}. I'll try this scheduled run again ${at(runAt, now)}.`
+      : `⏳ ${name} is used up, so this scheduled run waits. I'll run it ${at(runAt, now)}, when it resets.`;
+  } else 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";
@@ -141,7 +145,7 @@ function planFor(result, runContext, { now = Date.now(), windows = [], guarded =
   } 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 };
+  return { hit, armable, waits, runAt, attempts, notice };
 }
 
 // ── arm / cancel ────────────────────────────────────────────────────────

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/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,