@inetafrica/open-claudia 3.5.16 → 3.5.18

package/core/runner.js

@@ -9,17 +9,21 @@ const crypto = require("crypto");
 const { spawn, execFileSync } = require("child_process");
 const {
   AUTO_COMPACT_TOKENS, MIN_COMPACT_INTERVAL_MS, MAX_PROCESS_TIMEOUT, COMPACT_SUMMARY_TIMEOUT,
+  TOKEN_DIET_CONVERSATIONS, TOKEN_DIET_COMPACT_TOKENS, TOKEN_DIET_COLD_MINUTES, TOKEN_DIET_COLD_MIN_TOKENS,
   CONFIG_DIR, WORKSPACE, config,
 } = require("./config");
 const {
   currentState, saveState, recordSession,
   resetSessionUsage, admitLane, cancelTargets, getActiveProvider, getProjectKey,
   laneFor, laneForRun, peekLane, laneBusy, runLaneKey, waitingLanes, slotBlocker, pruneIdleLanes,
-  getProviderSession, setProviderSession, clearProviderSession, quarantineProviderSession, getUsageForSession, commitProviderCompaction,
-  resolveProviderSettings,
+  getProviderSession, setProviderSession, clearProviderSession, quarantineProviderSession, getUsageForSession, commitProviderCompaction, commitBranchCompaction,
+  resolveProviderSettings, getProjectSessions,
 } = require("./state");
 const { chatContext, currentChannelId, currentAdapter, currentThreadId } = require("./context");
 const { buildTurnPrompt } = require("./system-prompt");
+const turnJournal = require("./turn-journal");
+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");
@@ -143,6 +147,9 @@ function applyUsageToState(state, usage, costUsd, opts = {}) {
     ? getUsageForSession(state, project, backend, sessionId)
     : state.sessionUsage;
   u.turns += 1;
+  // When the conversation's last turn ended: past the prompt cache's lifetime
+  // a resume re-writes the whole context (token diet cold-resume check).
+  u.lastTurnAt = Date.now();
   u.inputTokens += parts.input;
   u.outputTokens += parts.output;
   u.cacheReadTokens += parts.cacheRead;
@@ -313,6 +320,8 @@ async function executeProviderInvocation(options = {}) {
   const cleanupOutcome = { ok: true, skipped: false };
   const rawErrors = [];
   const usageEvents = [];
+  // The provider's last plan-limit reading this run (Claude's rate_limit_event).
+  let rateLimit = null;
   const tools = [];
   const textDeltas = [];
   const textFinals = [];
@@ -398,6 +407,7 @@ async function executeProviderInvocation(options = {}) {
       tools.push(event);
     }
     else if (event.type === "usage") usageEvents.push(event);
+    else if (event.type === "rate_limit") rateLimit = event;
     else if (event.type === "result") {
       terminalSeen = true;
       if (event.sessionId) sessionId = event.sessionId;
@@ -593,6 +603,7 @@ async function executeProviderInvocation(options = {}) {
     usage: finalUsage?.usage || null,
     usageScope: finalUsage?.scope || null,
     usageEvents,
+    rateLimit,
     costUsd: Number.isFinite(invocation.parserState.totalCostUsd) ? invocation.parserState.totalCostUsd : 0,
     tools,
     exitCode: closeInfo.code,
@@ -992,12 +1003,38 @@ function resolveRunCwd(cwd) {
 
 const CODEX_WINDOW_COMPACT_FRACTION = 0.8;
 
+// Token diet canary (core/config.js). `opts.tokenDiet` overrides the
+// configured values (tests).
+function tokenDietSettings(override = null) {
+  const num = (value, fallback) => (Number.isFinite(value) && value > 0 ? value : fallback);
+  const o = override || {};
+  return {
+    conversations: Array.isArray(o.conversations) ? o.conversations : TOKEN_DIET_CONVERSATIONS,
+    compactTokens: num(o.compactTokens ?? TOKEN_DIET_COMPACT_TOKENS, 200000),
+    coldMinutes: num(o.coldMinutes ?? TOKEN_DIET_COLD_MINUTES, 60),
+    coldMinTokens: num(o.coldMinTokens ?? TOKEN_DIET_COLD_MIN_TOKENS, 120000),
+  };
+}
+
+function tokenDietListed(conversationKey, override = null) {
+  const key = String(conversationKey || "");
+  if (!key) return false;
+  const list = tokenDietSettings(override).conversations;
+  return list.includes("*") || list.includes(key);
+}
+
+// The threshold a conversation compacts at when /compactwindow sets none.
+function defaultCompactTokens(conversationKey, override = null) {
+  if (tokenDietListed(conversationKey, override)) return tokenDietSettings(override).compactTokens;
+  return Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 380000;
+}
+
 function effectiveCompactThreshold(state = currentState(), opts = {}) {
   const override = state.settings?.compactWindow;
   if (override === 0) return 0;
   const base = Number.isFinite(override) && override > 0
     ? override
-    : (Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 380000);
+    : defaultCompactTokens(opts.conversationKey || getProjectKey(state), opts.tokenDiet);
   // Codex's window (258k for gpt-6-astra) sits below the default threshold, so
   // measured honestly the bot would never compact a Codex session — and would
   // lose the brief that feeds memory. Compact at 80% of the reported window.
@@ -1011,7 +1048,7 @@ function effectiveCompactThreshold(state = currentState(), opts = {}) {
 function shouldAutoCompact(state = currentState(), opts = {}) {
   if (opts.skipAutoCompact || opts.fresh || opts.continueSession || peekLane(state, opts.laneKey)?.isCompacting) return false;
   if (!getProviderSession(state, getActiveProvider(state), getProjectKey(state))) return false;
-  const threshold = effectiveCompactThreshold(state);
+  const threshold = effectiveCompactThreshold(state, { tokenDiet: opts.tokenDiet });
   if (threshold === 0) return false;
   const activeUsage = state.sessionUsage;
   const contextTokens = activeUsage?.liveContextTokens || activeUsage?.lastInputTokens || 0;
@@ -1025,10 +1062,199 @@ function shouldAutoCompact(state = currentState(), opts = {}) {
   return true;
 }
 
+// Token diet: compact BEFORE a turn that resumes a listed conversation whose
+// prompt cache has expired (last turn ended more than coldMinutes ago) while
+// its context is large: resuming would re-write the whole context at the cache
+// write price, then keep re-reading it every step. Compacting first costs one
+// summary read and the turn runs on a small fresh session. Never for
+// compaction stages, fresh or continue runs, a live call, a lane already
+// compacting, or within MIN_COMPACT_INTERVAL of the last compaction.
+function lastTurnEndedAt(state, usage, provider, project, sessionId) {
+  const at = Number(usage?.lastTurnAt);
+  if (Number.isFinite(at) && at > 0) return at;
+  // Usage recorded before lastTurnAt existed: the session history's lastUsed.
+  try {
+    const record = getProjectSessions(state.userId, project, provider).find((entry) => entry.id === sessionId);
+    const used = Date.parse(record?.lastUsed || "");
+    return Number.isFinite(used) ? used : 0;
+  } catch (_) { return 0; }
+}
+
+function coldResumeDecision(state, runContext, opts = {}) {
+  const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+  const key = runContext?.project?.name || null;
+  const no = (reason, extra = {}) => ({ compact: false, reason, key, ...extra });
+  if (!tokenDietListed(key, opts.tokenDiet)) return no("not-listed");
+  const purpose = runContext.purpose;
+  if (purpose === "compact-summary" || purpose === "compact-seed") return no("compaction-run");
+  if (runContext.fresh || runContext.continueSession || runContext.liveCall) return no("fresh-or-continue");
+  const provider = runContext.provider;
+  const sessionId = runContext.sessionId || null;
+  if (!sessionId) return no("no-session");
+  // A scheduled job on its own conversation (a branch: its thread has moved
+  // on) gets the same cap, on that branch. Any other run only on the session
+  // its conversation points at.
+  const branch = getProviderSession(state, provider, key) !== sessionId;
+  if (branch && !isJobBranchRun(runContext)) return no("no-session");
+  if (peekLane(state, opts.laneKey || runLaneKey(runContext))?.isCompacting) return no("compacting");
+  if (effectiveCompactThreshold(state, { conversationKey: key, tokenDiet: opts.tokenDiet }) === 0) return no("compaction-off");
+  const settings = tokenDietSettings(opts.tokenDiet);
+  const usage = getUsageForSession(state, key, provider, sessionId);
+  const endedAt = lastTurnEndedAt(state, usage, provider, key, sessionId);
+  if (!endedAt) return no("never-ran");
+  const idleMinutes = Math.floor((now - endedAt) / 60000);
+  const contextTokens = usage?.liveContextTokens || usage?.lastInputTokens || 0;
+  if (now - endedAt <= settings.coldMinutes * 60000) return no("warm", { idleMinutes, contextTokens });
+  if (contextTokens <= settings.coldMinTokens) return no("small", { idleMinutes, contextTokens });
+  const minInterval = Number.isFinite(MIN_COMPACT_INTERVAL_MS) ? MIN_COMPACT_INTERVAL_MS : 1800000;
+  const checkpointTime = Date.parse(usage?.compactionCheckpoint?.at || "");
+  const lastCompactedAt = Number(usage?.lastCompactedAt) || (Number.isFinite(checkpointTime) ? checkpointTime : 0);
+  if (lastCompactedAt && now - lastCompactedAt < minInterval) return no("recently-compacted", { idleMinutes, contextTokens });
+  return { compact: true, reason: "cold-resume", key, idleMinutes, contextTokens, ...(branch ? { sessionId } : {}) };
+}
+
+// A scheduled run that resumes the job's own conversation without becoming
+// its thread's live session (scheduler: attachSession false).
+function isJobBranchRun(runContext) {
+  return !!runContext?.scheduledJobId && runContext.attachSession === false;
+}
+
+// The threshold rule for a scheduled job's own conversation, checked after
+// its run: the thread's rule (shouldAutoCompact) reads only the thread's live
+// session, so a job's branch grew without limit (Kazee Bugs monitor, 5-7 Oct:
+// 201k to 894k, $54.90 a wake). Same threshold and the same spacing.
+function jobBranchThresholdDecision(state, runContext, result, opts = {}) {
+  const key = runContext?.project?.name || null;
+  const no = (reason, extra = {}) => ({ compact: false, reason, key, ...extra });
+  if (!isJobBranchRun(runContext) || !runContext.sessionId) return no("not-a-job-branch");
+  const provider = runContext.provider;
+  const sessionId = result?.sessionId || runContext.sessionId;
+  if (!key || getProviderSession(state, provider, key) === sessionId) return no("live");
+  if (peekLane(state, opts.laneKey || runLaneKey(runContext))?.isCompacting) return no("compacting");
+  const usage = getUsageForSession(state, key, provider, sessionId);
+  const threshold = effectiveCompactThreshold(state, {
+    conversationKey: key,
+    tokenDiet: opts.tokenDiet,
+    contextWindowTokens: usage?.contextWindowTokens,
+  });
+  if (threshold === 0) return no("compaction-off");
+  const contextTokens = usage?.liveContextTokens || usage?.lastInputTokens || 0;
+  if (contextTokens < threshold) return no("under", { contextTokens });
+  const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+  const minInterval = Number.isFinite(MIN_COMPACT_INTERVAL_MS) ? MIN_COMPACT_INTERVAL_MS : 1800000;
+  const checkpointTime = Date.parse(usage?.compactionCheckpoint?.at || "");
+  const lastCompactedAt = Number(usage?.lastCompactedAt) || (Number.isFinite(checkpointTime) ? checkpointTime : 0);
+  if (contextTokens < threshold * 2 && lastCompactedAt && now - lastCompactedAt < minInterval) {
+    return no("recently-compacted", { contextTokens });
+  }
+  return { compact: true, reason: "threshold", key, sessionId, contextTokens };
+}
+
+// Runs the cold-resume compaction for a turn that holds its lane, and returns
+// the turn's run context on the fresh session (or the unchanged one).
+async function compactColdResume(runContext, state, lane, deps = {}) {
+  const decide = deps.decide || coldResumeDecision;
+  const compact = deps.compact || compactActiveSession;
+  let decision;
+  try { decision = decide(state, runContext, { laneKey: lane.key, now: deps.now, tokenDiet: deps.tokenDiet }); }
+  catch (error) {
+    console.warn(`[token-diet] cold-resume check failed: ${redactSensitive(error.message)}`);
+    return runContext;
+  }
+  if (!decision.compact) {
+    // Only a cold resume that was held back is worth a line; warm turns and
+    // unlisted conversations are the normal case.
+    if (decision.idleMinutes !== undefined && decision.reason !== "warm") {
+      console.log(`[token-diet] cold-resume skip ${decision.key} reason=${decision.reason} ctx=${decision.contextTokens} idle=${decision.idleMinutes}m`);
+    }
+    return runContext;
+  }
+  const branch = decision.sessionId || null;
+  console.log(`[token-diet] cold-resume compact ${decision.key} ctx=${decision.contextTokens} idle=${decision.idleMinutes}m${branch ? ` job-session=${String(branch).slice(0, 8)}` : ""}`);
+  let result;
+  try {
+    result = await compact(runContext.project.dir, {
+      notify: false, laneKey: lane.key, admissionHeld: true,
+      compactReason: "cold-resume", contextTokensBefore: decision.contextTokens,
+      ...(branch ? { sessionId: branch, provider: runContext.provider } : {}),
+    });
+  } catch (error) {
+    console.warn(`[token-diet] cold-resume compaction failed: ${redactSensitive(error.message)}`);
+    return runContext;
+  }
+  if (!result?.compacted || !result.newSessionId) {
+    console.warn(`[token-diet] cold-resume compaction did not complete: ${result?.reason || "unknown"}`);
+    return runContext;
+  }
+  if (branch) {
+    // The job runs on its compacted conversation; the thread's live pointer
+    // (previousSessionId) and the run's detachment from it stay as they were.
+    return deepFreeze({
+      ...runContext,
+      sessionId: result.newSessionId,
+      admittedSessionId: result.newSessionId,
+      resumeSessionId: result.newSessionId,
+      continueSession: false,
+      fresh: false,
+    });
+  }
+  return deepFreeze({
+    ...runContext,
+    sessionId: result.newSessionId,
+    admittedSessionId: result.newSessionId,
+    previousSessionId: result.newSessionId,
+    resumeSessionId: result.newSessionId,
+    continueSession: false,
+    fresh: false,
+  });
+}
+
+// One usage-ledger record per compaction (its provider stages run with
+// persistence off, so they never got a per-turn record): why it ran, the
+// context it replaced, and what the summary + seed runs cost. Kept apart from
+// turn records (kind "compaction", tokens nested) so turn counts and averages
+// stay comparable with the history before it.
+function recordCompactionUsage(entry, deps = {}) {
+  const append = deps.appendUsageRecord || appendUsageRecord;
+  const totals = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0 };
+  for (const run of [entry.summaryRun, entry.seedRun]) {
+    if (!run) continue;
+    if (run.usage) {
+      try {
+        const parts = usageParts(run.usage, entry.provider);
+        totals.inputTokens += parts.input;
+        totals.outputTokens += parts.output;
+        totals.cacheReadTokens += parts.cacheRead;
+        totals.cacheCreationTokens += parts.cacheCreation;
+      } catch (_) { /* unknown provider: tokens stay 0 */ }
+    }
+    if (typeof run.costUsd === "number") totals.costUsd += run.costUsd;
+  }
+  return append({
+    ts: new Date().toISOString(),
+    version: PKG_VERSION,
+    kind: "compaction",
+    compactReason: entry.compactReason || "manual",
+    // A scheduled job's own conversation, not its thread's live session.
+    ...(entry.branch ? { scope: "job" } : {}),
+    backend: entry.provider,
+    provider: entry.provider,
+    model: entry.model || null,
+    userId: entry.userId || null,
+    project: entry.project || null,
+    previousSessionId: entry.previousSessionId || null,
+    newSessionId: entry.newSessionId || null,
+    ok: !!entry.ok,
+    contextTokensBefore: Number.isFinite(entry.contextTokensBefore) ? entry.contextTokensBefore : null,
+    compactionUsage: totals,
+  });
+}
+
 function compactSummaryPrompt() {
   return [
     "Summarize this conversation for a fresh compacted continuation.",
     "Write a brief that lets your future self resume work without re-asking the user.",
+    "Write it now, in this one reply, from what is already in this conversation. Do NOT use any tools or run any commands (no searches, file reads or status checks): this step allows one reply only, so a tool call ends it with no brief and the compaction fails. The live repo state is attached to the seed for you; if you are unsure of a fact, say so in the brief.",
     "",
     "Include:",
     "- Current user goal and any active side threads or sub-goals.",
@@ -1305,12 +1531,14 @@ function createCompactionService(dependencies = {}) {
   const captureContext = dependencies.captureRunContext || admitRunContext;
   const runCapture = dependencies.runCapture || runAgentCapture;
   const commitCompaction = dependencies.commitCompaction || commitProviderCompaction;
+  const commitBranch = dependencies.commitBranchCompaction || commitBranchCompaction;
   const archiveBrief = dependencies.archiveBrief || archiveCompactionBrief;
   const appendDaySeed = dependencies.appendDaySeed || ((entry) => require("./day-seeds").appendDaySeed(entry));
   const collectRepoFacts = dependencies.collectRepoFacts || collectRepoStateFacts;
   const collectRecent = dependencies.collectRecentTurns || collectRecentTurns;
   const ackSchemaPath = dependencies.ackSchemaPath || ensureCompactionAckSchemaPath;
   const drainQueue = dependencies.drainQueue || drainQueuedMessages;
+  const recordCompaction = dependencies.recordCompaction || recordCompactionUsage;
 
   // Compaction acts on ONE conversation: the lane it is asked from (/compact)
   // or the lane whose turn just finished (auto-compaction, admissionHeld).
@@ -1322,9 +1550,14 @@ function createCompactionService(dependencies = {}) {
     if (lane.runningProcess || ((lane.preparingRun || lane.settling) && !opts.admissionHeld)) {
       return { compacted: false, reason: "Finish or stop the active run before compacting." };
     }
-    const provider = getActiveProvider(state);
+    const provider = opts.provider || getActiveProvider(state);
     const project = getProjectKey(state);
-    const oldSessionId = getProviderSession(state, provider, project);
+    const liveSessionId = getProviderSession(state, provider, project);
+    // opts.sessionId names a scheduled job's own conversation (a branch beside
+    // the thread's live session): that is what gets compacted, and only the
+    // job follows it; the thread's pointer stays where it is.
+    const branch = !!opts.sessionId && opts.sessionId !== liveSessionId;
+    const oldSessionId = branch ? opts.sessionId : liveSessionId;
     if (!project || !oldSessionId) return { compacted: false, reason: "No conversation." };
     const summaryPrompt = compactSummaryPrompt();
     const admitted = captureContext(summaryPrompt, cwd, null, {
@@ -1349,10 +1582,17 @@ function createCompactionService(dependencies = {}) {
     // The recent turns come from THIS conversation's transcript: the captured
     // project, not the state's legacy "Workspace" session (which read another file).
     const recentTurns = collectRecent(capturedStateView(state, summaryContext));
+    const usageBefore = branch ? getUsageForSession(state, project, provider, oldSessionId) : state.sessionUsage;
+    const contextTokensBefore = Number.isFinite(opts.contextTokensBefore)
+      ? opts.contextTokensBefore
+      : (usageBefore?.liveContextTokens || usageBefore?.lastInputTokens || 0);
+    let summaryRun = null;
+    let seedRun = null;
+    let committedSessionId = null;
     lane.isCompacting = true;
     try {
       if (opts.notify) await send(opts.message || "Context is getting large, compacting first so this stays fast…");
-      const summaryRun = await runCapture(summaryPrompt, summaryContext.cwd || cwd, {
+      summaryRun = await runCapture(summaryPrompt, summaryContext.cwd || cwd, {
         runContext: summaryContext,
         persist: false,
       });
@@ -1385,7 +1625,7 @@ function createCompactionService(dependencies = {}) {
         outputSchemaPath,
         recallQuery: seedRecallQuery(condensed || fullBrief),
       });
-      const seedRun = await runCapture(seedPrompt, seedContext.cwd || cwd, {
+      seedRun = await runCapture(seedPrompt, seedContext.cwd || cwd, {
         runContext: seedContext,
         persist: false,
       });
@@ -1397,19 +1637,20 @@ function createCompactionService(dependencies = {}) {
       }
       let commit;
       try {
-        commit = await commitCompaction(state, {
+        commit = await (branch ? commitBranch : commitCompaction)(state, {
           operationId,
           canonicalUserId: summaryContext.canonicalUserId,
           project: summaryContext.project.name,
           provider: summaryContext.provider,
           previousSessionId: oldSessionId,
           newSessionId: seedRun.sessionId,
-          title: `Compacted ${new Date().toLocaleDateString()}`,
+          title: branch ? null : `Compacted ${new Date().toLocaleDateString()}`,
           seedUsage: seedRun.usage || null,
         });
       } catch (error) {
         return { compacted: false, reason: `Compaction commit failed: ${redactSensitive(error.message)}` };
       }
+      committedSessionId = seedRun.sessionId;
       let briefPath = null;
       try { briefPath = archiveBrief(fullBrief, capturedStateView(state, summaryContext)); } catch (_) {}
       try {
@@ -1429,9 +1670,29 @@ function createCompactionService(dependencies = {}) {
         project: summaryContext.project.name,
         summary,
         commit,
+        compactReason: opts.compactReason || "manual",
+        ...(branch ? { branch: true } : {}),
       };
     } finally {
       lane.isCompacting = false;
+      if (summaryRun) {
+        try {
+          recordCompaction({
+            compactReason: opts.compactReason || "manual",
+            branch,
+            provider: summaryContext.provider,
+            model: summaryContext.providerSettings?.model || null,
+            userId: summaryContext.canonicalUserId,
+            project: summaryContext.project.name,
+            previousSessionId: oldSessionId,
+            newSessionId: committedSessionId,
+            ok: !!committedSessionId,
+            contextTokensBefore,
+            summaryRun,
+            seedRun,
+          });
+        } catch (error) { console.warn(`[compact] usage record failed: ${redactSensitive(error.message)}`); }
+      }
       // A bare cancel flag names no run: whatever it was for is over now.
       if (lane.cancelRequested === true) lane.cancelRequested = false;
       try { await drainQueue(state); }
@@ -1474,6 +1735,58 @@ function capturedTranscriptMetadata(runContext, extra = {}) {
   };
 }
 
+// Plan limits (core/usage-limits.js, core/limit-pickup.js). Worked out once
+// per run and kept on the result (not enumerable: never part of its shape).
+function keepOnResult(result, key, value) {
+  try { Object.defineProperty(result, key, { value, enumerable: false, configurable: true, writable: true }); } catch (_) {}
+  return value;
+}
+
+// Each plan window's use after this run: Claude reports it in the stream;
+// Codex in its rollout (read for the ledger on success, here on a failure).
+function planLimitWindows(result, runContext) {
+  if (result.planWindows !== undefined) return result.planWindows;
+  let windows = [];
+  try {
+    if (runContext.provider === "claude") windows = result.rateLimit?.windows || [];
+    else if (runContext.provider === "codex") {
+      const rateLimits = result.codexRateLimits !== undefined
+        ? result.codexRateLimits
+        : (result.sessionId ? readCodexRollout({ threadId: result.sessionId, includeSubagents: false })?.rateLimits || null : null);
+      windows = usageLimits.codexWindows(rateLimits);
+    }
+  } catch (_) { windows = []; }
+  return keepOnResult(result, "planWindows", windows);
+}
+
+// What a turn a usage limit stopped does: the notice it posts and, when the
+// reset time is known, the pick-up deliverForegroundResult arms.
+function limitPlanFor(result, runContext) {
+  if (result.limitPlan !== undefined) return result.limitPlan;
+  let plan = null;
+  if (!result.ok && result.error?.code === "PROVIDER_USAGE_LIMIT") {
+    let guarded = false;
+    try { guarded = require("./relationship").isCurrentSpeakerGuarded(); } catch (_) {}
+    try { plan = limitPickup.planFor(result, runContext, { windows: planLimitWindows(result, runContext), guarded }); }
+    catch (error) { console.warn(`[limit-pickup] plan failed: ${redactSensitive(String(error.message || error))}`); }
+  }
+  return keepOnResult(result, "limitPlan", plan);
+}
+
+// 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.
+function recordPlanLimits(result, runContext, { warn = true } = {}) {
+  try {
+    const windows = planLimitWindows(result, runContext);
+    if (!windows.length) return [];
+    return usageLimits.recordWindows({ provider: runContext.provider, windows, ...(warn ? {} : { percents: [] }) });
+  } catch (error) {
+    console.warn(`[usage-limits] ${redactSensitive(String(error.message || error))}`);
+    return [];
+  }
+}
+
 function providerRunDiagnostic(result, runContext) {
   if (result.ok) return null;
   let provider;
@@ -1486,6 +1799,8 @@ function providerRunDiagnostic(result, runContext) {
     return `${label} authentication failed.${help ? `\n\n${help}` : ""}`;
   }
   if (code === "PROVIDER_USAGE_LIMIT") {
+    const plan = limitPlanFor(result, runContext);
+    if (plan?.notice) return plan.notice;
     return `${label} reported a usage or rate limit. Check that provider's account status or select another configured provider.`;
   }
   if (code === "PROVIDER_REFUSAL") {
@@ -1589,6 +1904,7 @@ async function persistForegroundUsage(result, runContext, state = currentState()
       liveContextTokens = rollout && rollout.lastContextTokens > 0
         ? rollout.lastContextTokens
         : usageParts(rawUsage, "codex").context;
+      keepOnResult(result, "codexRateLimits", rollout ? rollout.rateLimits || null : null);
     }
     const rolloutOpts = rollout ? {
       contextSource: "rollout_last_request",
@@ -1714,6 +2030,20 @@ async function finalizeStreamPreview(lane, result, runContext = null) {
 // words. That is never an answer, so it is never posted.
 const PLACEHOLDER_REPLY = /^no response requested\.?$/i;
 
+// "⚠️ Claude: 82% of the 5-hour limit is used. It resets at 17:20." goes out
+// after the answer that crossed it. Never to an outside contact (plan
+// internals), never on a live call, never after an unasked group reply.
+function limitWarningsVisible(result, runContext) {
+  if (!result.ok || runContext.passive === true || runContext.liveCall || statusChatterMuted()) return false;
+  try { return !require("./relationship").isCurrentSpeakerGuarded(); } catch (_) { return false; }
+}
+
+async function sendLimitWarnings(due) {
+  for (const item of due) {
+    await send(usageLimits.formatWarning(item)).catch(() => {});
+  }
+}
+
 async function deliverForegroundResult(result, runContext, state = currentState()) {
   const lane = laneForRun(state, runContext);
   if (runContext.lastInputWasVoice) lane.lastInputWasVoice = false;
@@ -1727,6 +2057,17 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     if (stoppedHere) lane.cancelRequested = false;
     return { ok: true, suppressed: "cancelled" };
   }
+  // Plan limits: each window's use is remembered (a warning is due once per
+  // window at 80% and 95%), and a turn a usage limit stopped is picked up
+  // when the limit resets, unless the person writes again first.
+  const limitWarnings = recordPlanLimits(result, runContext, { warn: limitWarningsVisible(result, runContext) });
+  const limitPlan = limitPlanFor(result, runContext);
+  if (limitPlan?.armable) {
+    try { limitPickup.arm(runContext, limitPlan); }
+    catch (error) { console.warn(`[limit-pickup] could not arm: ${redactSensitive(String(error.message || error))}`); }
+  }
+  // Nobody asked for a passive reply: a limit that stopped one is not news.
+  if (limitPlan && runContext.passive === true) return { ok: true, held: true, suppressed: "passive" };
   const diagnostic = providerRunDiagnostic(result, runContext);
   if (diagnostic) result.diagnostic = diagnostic;
   const cleanAnswer = String(result.finalAnswerText || "").trim();
@@ -1778,6 +2119,7 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     if (!sent.ok) sent = await send(chunks[index], telegramHtmlOpts({ botTags: true }));
     if (!sent.ok) throw new Error(`failed to deliver response chunk ${index + 1}`);
   }
+  if (limitWarnings.length) await sendLimitWarnings(limitWarnings);
 
   const shouldSpeak = shouldReplyWithVoice(VOICE_REPLY_MODE, runContext.lastInputWasVoice);
   if (result.ok && shouldSpeak) {
@@ -2358,6 +2700,33 @@ function quarantineRefusedRun(result, runContext, state) {
   }
 }
 
+// A resume whose saved conversation no longer exists on disk (its transcript file is gone, or
+// was never written) fails EVERY turn of that conversation with "No conversation found with
+// session ID" until someone sends /new (chat-spaces-bot's Agent Space chat, 6 Oct 2026).
+// Recovery: retire the stale id like a refused session, then replay the message once in a
+// fresh session. Never for captures, background work, or a run that is itself a retry.
+const MISSING_CONVERSATION = /No conversation found with session ID/i;
+function shouldRetryMissingConversation(result, runContext, { capture = false, refusalRetried = false } = {}) {
+  return !capture
+    && !refusalRetried
+    && runContext?.purpose === "foreground"
+    && !!runContext?.sessionId
+    && !!result
+    && !result.ok
+    && MISSING_CONVERSATION.test(`${result.error?.message || ""}\n${result.stderr || ""}`);
+}
+
+function retireMissingConversation(runContext, state) {
+  try {
+    quarantineProviderSession(state, runContext.provider, runContext.project?.name, runContext.sessionId, { reason: "missing" });
+    saveState({ strict: true });
+    return true;
+  } catch (error) {
+    console.error("missing-conversation reset failed:", redactSensitive(String(error.message || error)));
+    return false;
+  }
+}
+
 function refusalRetryContext(runContext, state) {
   return deepFreeze({
     ...runContext,
@@ -2412,6 +2781,9 @@ async function runAdmitted(runContext, state, store, capture, ownsAdmissionLock,
   const persistCapture = executionOptions.persistCapture !== false;
   const internalCapture = capture && !persistCapture;
   if (tracksMainRun) lane.activeRunContext = runContext;
+  // Turn journal "lock": a foreground chat turn that a restart cuts short is
+  // resumed after boot (core/turn-journal).
+  if (tracksMainRun) turnJournal.begin(runContext);
   if (!internalCapture) runContext = consumeOneShotBudget(runContext, state, executionOptions);
   const stopTyping = startTypingHeartbeat(state, store, runLaneKey(runContext));
   const holdsLane = () => ownsAdmissionLock
@@ -2423,6 +2795,15 @@ async function runAdmitted(runContext, state, store, capture, ownsAdmissionLock,
   });
   let result;
   try {
+    // Token diet: a listed conversation resumed after its prompt cache expired
+    // is compacted first and the turn runs on the fresh session.
+    if (!capture && ownsAdmissionLock && !executionOptions.refusalRetried && sameCapturedProject(state, runContext)) {
+      const rebased = await compactColdResume(runContext, state, lane);
+      if (rebased !== runContext) {
+        if (tracksMainRun && lane.activeRunContext === runContext) lane.activeRunContext = rebased;
+        runContext = rebased;
+      }
+    }
     result = await service.executeCaptured(runContext.userPrompt, runContext, { capture });
     if ((result.persistence.transcript.skipped || (!capture && result.delivery.skipped)) && !internalCapture) {
       result = await settleImmediateEffects(result, runContext, { state, store, capture });
@@ -2457,6 +2838,14 @@ async function runAdmitted(runContext, state, store, capture, ownsAdmissionLock,
     return runAdmitted(refusalRetryContext(runContext, state), state, store, capture, ownsAdmissionLock, { ...executionOptions, refusalRetried: true });
   }
 
+  if (shouldRetryMissingConversation(result, runContext, { capture, refusalRetried: executionOptions.refusalRetried })
+    && retireMissingConversation(runContext, state)) {
+    try { service.turnObserver?.onTurnSettled(false); } catch (e) { /* best-effort */ }
+    if (holdsLane()) lane.preparingRun = true;
+    await send("♻️ This conversation's saved history is missing, so I started a fresh one and am answering your message there.").catch(() => {});
+    return runAdmitted(refusalRetryContext(runContext, state), state, store, capture, ownsAdmissionLock, { ...executionOptions, refusalRetried: true });
+  }
+
   if (tracksMainRun) {
     sideChatCoordinator.noteMainResult(runContext, result);
     for (const item of lane.messageQueue) {
@@ -2473,11 +2862,27 @@ async function runAdmitted(runContext, state, store, capture, ownsAdmissionLock,
   // A thread's first delivered reply may name the thread. Detached: it never
   // delays this turn, the lane or the queue behind it.
   if (!capture) nameThreadAfterTurn(result, runContext, store);
+  // "Unlock": the turn ended — answered, cancelled or failed. (A shutdown's
+  // kill keeps it journaled; see turn-journal.end.)
+  if (tracksMainRun) turnJournal.end(runContext);
   // Auto-compaction is part of the lane's turn: only when nothing waits in
-  // this conversation, and it compacts this conversation only.
-  if (!capture && !runContext.skipAutoCompact && result.ok && lane.messageQueue.length === 0 && sameCapturedProject(state, runContext) && shouldAutoCompact(state, { laneKey: lane.key })) {
-    try { await compactActiveSession(runContext.project.dir, { notify: false, laneKey: lane.key, admissionHeld: ownsAdmissionLock }); }
-    catch (error) { console.warn(`[proactive-compact] failed: ${redactSensitive(error.message)}`); }
+  // this conversation, and it compacts this conversation only. A scheduled
+  // job on its own conversation (a branch) is held to the same threshold.
+  if (!capture && !runContext.skipAutoCompact && result.ok && lane.messageQueue.length === 0 && sameCapturedProject(state, runContext)) {
+    let jobBranch = { compact: false };
+    try { jobBranch = jobBranchThresholdDecision(state, runContext, result, { laneKey: lane.key }); }
+    catch (error) { console.warn(`[proactive-compact] job conversation check failed: ${redactSensitive(error.message)}`); }
+    if (jobBranch.compact) console.log(`[proactive-compact] job conversation ${jobBranch.key} job-session=${String(jobBranch.sessionId).slice(0, 8)} ctx=${jobBranch.contextTokens}`);
+    if (jobBranch.compact || shouldAutoCompact(state, { laneKey: lane.key })) {
+      try {
+        const outcome = await compactActiveSession(runContext.project.dir, {
+          notify: false, laneKey: lane.key, admissionHeld: ownsAdmissionLock, compactReason: "threshold",
+          ...(jobBranch.compact ? { sessionId: jobBranch.sessionId, provider: runContext.provider, contextTokensBefore: jobBranch.contextTokens } : {}),
+        });
+        // A compaction that runs but does not commit returns its reason instead of throwing.
+        if (outcome && outcome.compacted === false) console.warn(`[proactive-compact] did not complete: ${redactSensitive(String(outcome.reason || "unknown"))}`);
+      } catch (error) { console.warn(`[proactive-compact] failed: ${redactSensitive(error.message)}`); }
+    }
   }
   return result;
 }
@@ -2560,6 +2965,18 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
   });
 
   if (obsoleteCallTurn(store)) return Promise.resolve(cancelledCallRunResult(runContext));
+  // A turn the person starts here (a button, a restored message) drops their
+  // pick-up waiting for a usage limit to reset; the pick-up's own run does not.
+  if (runContext.purpose === "foreground" && !runContext.limitPickup && !runContext.liveCall) {
+    try { limitPickup.cancel(runContext.canonicalUserId, runLaneKey(runContext), "a new turn"); } catch (_) {}
+  }
+  // A planned restart is draining: no new turn starts now. The message is
+  // journaled as queued and runs right after the restart.
+  if (turnJournal.isDraining() && turnJournal.journalable(runContext)) {
+    turnJournal.enqueue(runContext);
+    send("Restarting in a moment — I'll pick this up as soon as I'm back.", { replyTo: replyToMsgId }).catch(() => {});
+    return Promise.resolve({ ok: false, status: "deferred", runId: runContext.runId, error: { code: "RESTARTING", message: "Queued until after the restart" } });
+  }
   const admission = admitLane(state, runLaneKey(runContext));
   if (!admission.ok) {
     const lane = admission.lane;
@@ -2574,6 +2991,7 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
     // `text` is what the person typed (before reply/context blocks were added),
     // so /stop can say which queued messages it dropped.
     const item = queueInLane(lane, { runContext, store, deferred, queuedAt: Date.now(), text: admitted.userPrompt || prompt });
+    turnJournal.enqueue(runContext);
     cancelQueuedCallOnAbort(lane, item);
     // Waiting for a slot: admit whatever the free slots allow, oldest first.
     // This message may be among them, and then it needs no notice.
@@ -2715,6 +3133,8 @@ module.exports = {
   shouldRetryRefusedRun,
   quarantineRefusedRun,
   refusalRetryContext,
+  shouldRetryMissingConversation,
+  retireMissingConversation,
   shouldStartSideChat,
   runSideChatRequest,
   enqueueSideChatRequest,
@@ -2723,6 +3143,12 @@ module.exports = {
   deriveCompactionRunContext,
   getActiveSessionId,
   shouldAutoCompact,
+  tokenDietListed,
+  defaultCompactTokens,
+  coldResumeDecision,
+  compactColdResume,
+  jobBranchThresholdDecision,
+  recordCompactionUsage,
   effectiveCompactThreshold,
   usageParts,
   peakContextTokens,