@wrongstack/core 0.306.3 → 0.307.0

package/dist/core/index.js

@@ -1158,7 +1158,10 @@ var MAILBOX_TYPE_PROPERTIES = {
   }
 };
 
-// src/coordination/mailbox-types.ts
+// src/coordination/mailbox-predicates.ts
+var SESSION_RECIPIENT_PREFIX = "@session:";
+
+// src/coordination/mailbox-session-sync.ts
 function isAffectedBySessionAffinity(message) {
   return message.sessionAffinity !== void 0;
 }
@@ -1189,7 +1192,6 @@ async function acceptMailboxMessageForSession(message, currentSessionId, ctx) {
   if (ctx?.allowUnscoped === true) return true;
   return false;
 }
-var SESSION_RECIPIENT_PREFIX = "@session:";
 
 // src/coordination/sqlite-mailbox.ts
 var SQLITE_MAILBOX_FILE = "_mailbox.sqlite";
@@ -1722,6 +1724,24 @@ import { randomUUID } from "node:crypto";
 import * as v8 from "node:v8";
 
 // src/security/secret-scrubber.ts
+var JSON_CREDENTIAL_KEY_ANCHORS = [
+  'Key"',
+  'key"',
+  'KEY"',
+  'token"',
+  'Token"',
+  'TOKEN"',
+  'secret"',
+  'Secret"',
+  'SECRET"',
+  'password"',
+  'Password"',
+  'PASSWORD"',
+  'authorization"',
+  'Authorization"',
+  'bearer"',
+  'Bearer"'
+];
 var PATTERNS = [
   // Anchored at the start where possible so partial matches inside larger
   // strings don't trigger false positives.
@@ -1824,6 +1844,30 @@ var PATTERNS = [
     regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
     anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD"]
   },
+  {
+    type: "json_credential_key",
+    // The JSON counterpart to `high_entropy_env`, and the pattern that the
+    // now-deleted `JSON_KEY_ANCHORS` list was written for. Without it those
+    // anchors only widened the cheap pre-scan — `hasCredentialAnchors` said
+    // "this text may hold a secret", every pattern then declined to match, and
+    // the value went out verbatim. `high_entropy_env` cannot cover these: it
+    // requires an UPPERCASE unquoted key (`API_KEY=…`), so `{"apiKey":"…"}`
+    // never matched.
+    //
+    // Tool results are routinely serialised as JSON, and a credential with no
+    // recognisable prefix (Azure, self-hosted gateways, Anthropic/Codex OAuth)
+    // has no other pattern that can catch it — this is the only thing standing
+    // between such a value and the session JSONL, chronicle, HQ broadcast and
+    // the model's own context.
+    //
+    // The key may carry a prefix (`"anthropicApiKey"`), but the credential word
+    // must END the key: `"tokenCount"` and `"maxTokens"` do not match, because
+    // the closing quote has to follow the word immediately.
+    // Value floor of 8 chars keeps enum-ish values (`"authorization":"none"`)
+    // out. Capture groups: 1=key + punctuation, 2=value, 3=closing quote.
+    regex: /("[A-Za-z0-9_]*(?:apiKey|api_key|token|secret|password|authorization|bearer|private_key|access_token|refresh_token|client_secret)"\s*:\s*")([^"\\]{8,512})(")/gi,
+    anchor: JSON_CREDENTIAL_KEY_ANCHORS
+  },
   // ── Ported from packages/plugins credential-patterns.ts (WS-034) ─────────
   // The plugin runtime carried 37 patterns while this scrubber — the one that
   // guards session JSONL, chronicle, HQ broadcast, WebUI events and the auth
@@ -1906,9 +1950,12 @@ var PATTERNS = [
     anchor: "GOCSPX-"
   }
 ];
-var SIMPLE_PATTERNS = PATTERNS.filter((p) => p.type !== "high_entropy_env");
+var SIMPLE_PATTERNS = PATTERNS.filter(
+  (p) => p.type !== "high_entropy_env" && p.type !== "json_credential_key"
+);
 var COMBINED_REGEX = new RegExp(SIMPLE_PATTERNS.map((p) => `(${p.regex.source})`).join("|"), "g");
 var HIGH_ENTROPY_REGEX = PATTERNS.find((p) => p.type === "high_entropy_env").regex;
+var JSON_CREDENTIAL_REGEX = PATTERNS.find((p) => p.type === "json_credential_key").regex;
 var COMBINED_REPLACEMENTS = SIMPLE_PATTERNS.map((p) => `[REDACTED:${p.type}]`);
 var SCRUB_CHUNK_BYTES = 64 * 1024;
 var SCRUB_OVERLAP_BYTES = 1024;
@@ -1919,20 +1966,7 @@ var PATTERN_ANCHORS = [
     )
   )
 ];
-var JSON_KEY_ANCHORS = [
-  '"apiKey"',
-  '"api_key"',
-  '"token"',
-  '"secret"',
-  '"password"',
-  '"authorization"',
-  '"bearer"',
-  '"private_key"',
-  '"access_token"',
-  '"refresh_token"',
-  '"client_secret"'
-];
-var ALL_ANCHORS = [...PATTERN_ANCHORS, ...JSON_KEY_ANCHORS];
+var ALL_ANCHORS = PATTERN_ANCHORS;
 function hasCredentialAnchors(text) {
   for (const anchor of ALL_ANCHORS) {
     if (text.includes(anchor)) return true;
@@ -1981,6 +2015,9 @@ var DefaultSecretScrubber = class {
     out = out.replace(HIGH_ENTROPY_REGEX, (_match, lead, key, _value) => {
       return `${lead}${key}=[REDACTED:high_entropy_env]`;
     });
+    out = out.replace(JSON_CREDENTIAL_REGEX, (_match, keyPrefix, _value, closingQuote) => {
+      return `${keyPrefix}[REDACTED:json_credential_key]${closingQuote}`;
+    });
     return out;
   }
   /**
@@ -4669,6 +4706,7 @@ function getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
 }
 
 // src/core/context.ts
+import { realpathSync } from "node:fs";
 import * as path10 from "node:path";
 
 // src/core/conversation-state.ts
@@ -4744,12 +4782,15 @@ var ConversationState = class {
    * cap determines the starting index for the sum but does not gate it.
    */
   overflowCount(arr) {
-    let drop = Context.MAX_MESSAGES > 0 ? Math.max(0, arr.length - Context.MAX_MESSAGES) : 0;
-    if (Context.MAX_MESSAGE_TOKENS <= 0) return this.protocolSafeDropCount(arr, drop);
+    const contextClass = this.ctx.constructor;
+    const maxMessages = contextClass.MAX_MESSAGES;
+    const maxMessageTokens = contextClass.MAX_MESSAGE_TOKENS;
+    let drop = maxMessages > 0 ? Math.max(0, arr.length - maxMessages) : 0;
+    if (maxMessageTokens <= 0) return this.protocolSafeDropCount(arr, drop);
     let total = 0;
     for (let i = drop; i < arr.length; i++) total += arr[i]?._estTokens ?? 0;
-    if (total <= Context.MAX_MESSAGE_TOKENS) return this.protocolSafeDropCount(arr, drop);
-    while (drop < arr.length - 1 && total > Context.MAX_MESSAGE_TOKENS) {
+    if (total <= maxMessageTokens) return this.protocolSafeDropCount(arr, drop);
+    while (drop < arr.length - 1 && total > maxMessageTokens) {
       total -= arr[drop]?._estTokens ?? 0;
       drop++;
     }
@@ -5575,6 +5616,19 @@ var Context = class _Context {
       if (rel.startsWith("..") || path10.isAbsolute(rel)) {
         throw new Error(`Working directory "${resolved}" is outside project root "${root}"`);
       }
+      let realTarget = resolved;
+      let realRoot = root;
+      try {
+        realTarget = realpathSync.native(resolved);
+        realRoot = realpathSync.native(root);
+      } catch {
+      }
+      const realRel = path10.relative(realRoot, realTarget);
+      if (realRel.startsWith("..") || path10.isAbsolute(realRel)) {
+        throw new Error(
+          `Working directory "${resolved}" resolves to "${realTarget}", outside project root "${realRoot}"`
+        );
+      }
     }
     const old = this.workingDir;
     this.workingDir = resolved;
@@ -5609,237 +5663,651 @@ function resolveEventSessionId(ctx) {
   return session?.id ?? "";
 }
 
-// src/core/continue-to-next-iteration.ts
-function parseContinueDirective(text) {
-  const LINE_MARKERS = /^\s*\[(continue|next step|proceed|done)\]\s*$/gim;
-  const tail = text.length <= DIRECTIVE_SCAN_WINDOW ? text : text.slice(text.length - DIRECTIVE_SCAN_WINDOW);
-  let match;
-  let lastDirective = "none";
-  while ((match = LINE_MARKERS.exec(tail)) !== null) {
-    const value = (match[1] ?? "").toLowerCase();
-    if (value === "continue" || value === "next step" || value === "proceed") {
-      lastDirective = "continue";
-    } else if (value === "done") {
-      lastDirective = "stop";
-    }
+// src/core/agent-loop-context.ts
+function createAgentLoopContextManager(a, handlers) {
+  let _lastEmittedMsgCount = -1;
+  let _lastEmittedToolCount = -1;
+  let _lastEmittedRevision = -1;
+  let _lastEmittedMaxContext = -1;
+  let _lastPreFlightMsgCount = -1;
+  let _lastPreFlightToolCount = -1;
+  let _lastPreFlightRevision = -1;
+  let _lastCompactionMsgCount = -1;
+  let _lastCompactionRevision = -1;
+  let _lastCompactionToolsRef = null;
+  let _lastCompactionSystemRef = null;
+  let _lastCompactionRequestTokens;
+  let _lastCompactionMaxContext = -1;
+  let _lastCompactionWasNoop = false;
+  let _cachedSysRef = null;
+  let _cachedToolsRef = null;
+  let _cachedOverheadTokens = 0;
+  const calibrationKey = (model = a.ctx.model) => `${a.ctx.provider?.id ?? "unknown"}/${model}`;
+  function currentMaxContext() {
+    const metaLimit = a.ctx.meta?.["effectiveMaxContext"];
+    const providerMax = a.ctx.provider.capabilities.maxContext;
+    return typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : 2e5;
   }
-  return lastDirective;
-}
-var DIRECTIVE_SCAN_WINDOW = 2048;
-var META_KEY2 = "_autonomousContinue";
-function consumeAutonomousContinue(ctx) {
-  const val = ctx.meta[META_KEY2] === true;
-  delete ctx.meta[META_KEY2];
-  return val;
-}
-
-// src/core/iteration-limit.ts
-function requestLimitExtension(opts) {
-  const { events, sessionId, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve10) => {
-    let resolved = false;
-    const timerFired = () => {
-      if (!resolved) {
-        resolved = true;
-        resolve10(0);
-      }
-    };
-    const timer = setTimeout(timerFired, timeoutMs);
-    timer.unref();
-    const deny = () => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve10(0);
-      }
+  async function refreshProviderContextLimit(provider, model, opts = {}) {
+    a.ctx.meta ??= {};
+    const routeKey = `${provider.id}/${model}`;
+    const previousRouteKey = a.ctx.meta["contextLimitRouteKey"];
+    const routeChanged = previousRouteKey !== void 0 && previousRouteKey !== routeKey;
+    const previousMaxContext = currentMaxContext();
+    if (routeChanged) {
+      delete a.ctx.meta["providerOverflowMaxContext"];
+      delete a.ctx.meta["contextLimitBaseline"];
+      delete a.ctx.meta["providerLimitEffectiveMaxContext"];
+      delete a.ctx.meta["effectiveMaxContext"];
+      delete a.ctx.meta["effectiveMaxContextSource"];
+      delete a.ctx.meta["contextLimitLastEmittedMaxContext"];
+      delete a.ctx.meta["contextLimitLastEmittedSource"];
+    }
+    a.ctx.meta["contextLimitRouteKey"] = routeKey;
+    const routeMeta = a.ctx.meta["effectiveMaxContext"];
+    const routeProviderCap = provider.capabilities.maxContext;
+    const currentEffective = typeof routeMeta === "number" && routeMeta > 0 ? routeMeta : typeof routeProviderCap === "number" && routeProviderCap > 0 ? routeProviderCap : 2e5;
+    const emitEffectiveLimit = (effective2, source) => {
+      const lastEmitted = a.ctx.meta["contextLimitLastEmittedMaxContext"];
+      const lastEmittedSource = a.ctx.meta["contextLimitLastEmittedSource"];
+      if (lastEmitted === effective2 && lastEmittedSource === source) return;
+      const eventPrevious = typeof lastEmitted === "number" && Number.isFinite(lastEmitted) && lastEmitted > 0 ? Math.floor(lastEmitted) : previousMaxContext;
+      a.ctx.meta["contextLimitLastEmittedMaxContext"] = effective2;
+      a.ctx.meta["contextLimitLastEmittedSource"] = source;
+      a.events.emit("ctx.max_context", {
+        sessionId: resolveEventSessionId(a.ctx),
+        providerId: provider.id,
+        modelId: model,
+        maxContext: effective2,
+        ...eventPrevious > 0 ? { previousMaxContext: eventPrevious } : {},
+        source,
+        decreased: eventPrevious > 0 && effective2 < eventPrevious
+      });
     };
-    const grant = (extra) => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve10(Math.max(0, extra));
+    const emitNativeAfterRouteChange = () => {
+      if (routeChanged && currentEffective > 0) {
+        a.ctx.meta["effectiveMaxContext"] = currentEffective;
+        a.ctx.meta["effectiveMaxContextSource"] = "configured";
+        emitEffectiveLimit(currentEffective, "configured");
       }
     };
-    events.emit("iteration.limit_reached", {
-      sessionId,
-      currentIterations,
-      currentLimit,
-      grant,
-      deny
-    });
-    if (autoExtend) {
-      setImmediate(() => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timer);
-          resolve10(100);
-        }
-      });
+    const refresh = provider.refreshContextLimit;
+    if (opts.probe === false || !refresh) {
+      emitNativeAfterRouteChange();
+      return;
     }
-  });
-}
-
-// src/core/next-steps-slot.ts
-var SLOT_KEY = "nextsteps.pending";
-var MAX_PENDING_NEXT_STEPS = 4;
-var NEXT_STEPS_TAG_RE = /<nextsteps\b[^>]*>/i;
-function writePendingNextSteps(ctx, steps) {
-  const cleaned = [];
-  for (const step of steps) {
-    const text = typeof step?.text === "string" ? step.text.replace(/\s+/g, " ").trim() : "";
-    if (!text) continue;
-    cleaned.push(step.auto === true && cleaned.length === 0 ? { text, auto: true } : { text });
-    if (cleaned.length >= MAX_PENDING_NEXT_STEPS) break;
-  }
-  if (cleaned.length === 0) {
-    clearPendingNextSteps(ctx);
-    return;
-  }
-  ctx.meta[SLOT_KEY] = cleaned;
-}
-function readPendingNextSteps(ctx) {
-  const raw = ctx.meta[SLOT_KEY];
-  if (!Array.isArray(raw) || raw.length === 0) return void 0;
-  const steps = raw.filter(
-    (s) => typeof s?.text === "string" && s.text.length > 0
-  );
-  return steps.length > 0 ? steps : void 0;
-}
-function clearPendingNextSteps(ctx) {
-  delete ctx.meta[SLOT_KEY];
-}
-function hasNextStepsTag(text) {
-  return NEXT_STEPS_TAG_RE.test(text);
-}
-function renderNextStepsBlock(steps) {
-  const lines = steps.map((step, i) => {
-    const auto = i === 0 && step.auto === true ? ' auto="true"' : "";
-    return `${i + 1}. ${step.text}${auto}`;
-  });
-  return `<nextsteps>
-${lines.join("\n")}
-</nextsteps>`;
-}
-function endsTurn(stopReason) {
-  return stopReason !== "tool_use" && stopReason !== "tool_call";
-}
-function maybeAppendPendingNextSteps(ctx, res) {
-  if (ctx.agentId !== "leader") return res;
-  if (!endsTurn(res.stopReason)) return res;
-  if (ctx.signal.aborted) return res;
-  const steps = readPendingNextSteps(ctx);
-  if (!steps) return res;
-  if (hasOpenTodos(ctx.todos)) {
-    clearPendingNextSteps(ctx);
-    return res;
+    let discovered;
+    try {
+      discovered = await refresh.call(provider, model, { signal: a.ctx.signal });
+    } catch {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    const providerLimit = discovered?.maxContext;
+    if (typeof providerLimit !== "number" || !Number.isFinite(providerLimit) || providerLimit <= 0) {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    const providerLimitFloored = Math.floor(providerLimit);
+    const existingBaseline = a.ctx.meta["contextLimitBaseline"];
+    const lastApplied = a.ctx.meta["providerLimitEffectiveMaxContext"];
+    const existingOverflow = a.ctx.meta["providerOverflowMaxContext"];
+    const effectiveChangedOutsideProbe = typeof lastApplied === "number" && Number.isFinite(lastApplied) && currentEffective !== Math.floor(lastApplied) && currentEffective !== existingOverflow;
+    const baseline = effectiveChangedOutsideProbe || typeof existingBaseline !== "number" || !Number.isFinite(existingBaseline) || existingBaseline <= 0 ? currentEffective : Math.floor(existingBaseline);
+    a.ctx.meta["contextLimitBaseline"] = baseline;
+    const overflowLimit = a.ctx.meta["providerOverflowMaxContext"];
+    const overflowFloored = typeof overflowLimit === "number" && Number.isFinite(overflowLimit) && overflowLimit > 0 ? Math.floor(overflowLimit) : void 0;
+    const ceilings = [baseline, providerLimitFloored];
+    if (overflowFloored !== void 0) ceilings.push(overflowFloored);
+    const effective = Math.min(...ceilings.filter((limit) => limit > 0));
+    let effectiveSource;
+    if (overflowFloored !== void 0 && effective === overflowFloored) {
+      effectiveSource = "provider_overflow";
+    } else if (effective === providerLimitFloored) {
+      effectiveSource = "provider";
+    } else {
+      effectiveSource = "configured";
+    }
+    a.ctx.meta["effectiveMaxContext"] = effective;
+    a.ctx.meta["providerLimitEffectiveMaxContext"] = effective;
+    a.ctx.meta["effectiveMaxContextSource"] = effectiveSource;
+    emitEffectiveLimit(effective, effectiveSource);
   }
-  const lastTextIndex = res.content.findLastIndex(isTextBlock);
-  if (lastTextIndex >= 0) {
-    const block = res.content[lastTextIndex];
-    if (block && isTextBlock(block) && hasNextStepsTag(block.text)) {
-      clearPendingNextSteps(ctx);
-      return res;
+  function systemAndToolsOverhead() {
+    const sysRef = a.ctx.systemPrompt;
+    const toolsRef = a.ctx.tools;
+    if (sysRef === _cachedSysRef && toolsRef === _cachedToolsRef && _cachedOverheadTokens > 0) {
+      return _cachedOverheadTokens;
     }
+    const breakdown = estimateRequestTokens([], sysRef, toolsRef ?? [], calibrationKey());
+    _cachedSysRef = sysRef;
+    _cachedToolsRef = toolsRef;
+    _cachedOverheadTokens = breakdown.systemPrompt + breakdown.tools;
+    return _cachedOverheadTokens;
   }
-  const rendered = renderNextStepsBlock(steps);
-  const content = [...res.content];
-  const target = lastTextIndex >= 0 ? content[lastTextIndex] : void 0;
-  if (target && isTextBlock(target)) {
-    const separator = target.text.trim() ? "\n\n" : "";
-    content[lastTextIndex] = { ...target, text: `${target.text}${separator}${rendered}` };
-  } else {
-    content.push({ type: "text", text: rendered });
+  function stashRequestTokens(req) {
+    const preFlight = estimateRequestTokens(
+      req.messages,
+      req.system,
+      req.tools ?? [],
+      calibrationKey(req.model)
+    );
+    a.ctx.lastRequestTokens = preFlight.total;
+    _lastPreFlightMsgCount = req.messages.length;
+    _lastPreFlightToolCount = (req.tools ?? []).length;
+    _lastPreFlightRevision = a.ctx.state.revision;
+    _cachedSysRef = req.system;
+    _cachedToolsRef = req.tools ?? [];
+    _cachedOverheadTokens = preFlight.systemPrompt + preFlight.tools;
+    a.ctx.meta["lastRequestTokensAt"] = {
+      msgCount: req.messages.length,
+      toolCount: (req.tools ?? []).length,
+      revision: a.ctx.state.revision
+    };
+    return preFlight;
   }
-  clearPendingNextSteps(ctx);
-  return { ...res, content };
+  function refreshContextRequestTokenStash(opts = {}) {
+    const msgCount = a.ctx.messages.length;
+    const toolCount = (a.ctx.tools ?? []).length;
+    const revision = a.ctx.state.revision;
+    const stashed = a.ctx.lastRequestTokens;
+    const stashedAt = a.ctx.meta?.["lastRequestTokensAt"];
+    if (!opts.force && typeof stashed === "number" && stashed > 0 && typeof stashedAt === "object" && stashedAt !== null) {
+      const meta = stashedAt;
+      if (meta.msgCount === msgCount && meta.toolCount === toolCount && meta.revision === revision && _lastPreFlightRevision === revision) {
+        return stashed;
+      }
+    }
+    const refreshed = estimateMessageTokens(a.ctx.messages) + systemAndToolsOverhead();
+    a.ctx.lastRequestTokens = refreshed;
+    _lastPreFlightMsgCount = msgCount;
+    _lastPreFlightToolCount = toolCount;
+    _lastPreFlightRevision = revision;
+    a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount, revision };
+    return refreshed;
+  }
+  async function compactContextIfNeeded() {
+    const msgCount = a.ctx.messages.length;
+    const maxContext = currentMaxContext();
+    const revision = a.ctx.state.revision;
+    const toolsRef = a.ctx.tools;
+    const systemRef = a.ctx.systemPrompt;
+    const requestTokens = a.ctx.lastRequestTokens;
+    if (_lastCompactionMsgCount === msgCount && _lastCompactionRevision === revision && _lastCompactionToolsRef === toolsRef && _lastCompactionSystemRef === systemRef && _lastCompactionRequestTokens === requestTokens && _lastCompactionWasNoop && _lastCompactionMaxContext === maxContext && maxContext > 0) {
+      return false;
+    }
+    const beforeMessages = a.ctx.messages;
+    const beforeMsgCount = a.ctx.messages.length;
+    const beforeRevision = a.ctx.state.revision;
+    await a.pipelines.contextWindow.run(a.ctx);
+    _lastCompactionMsgCount = a.ctx.messages.length;
+    _lastCompactionRevision = a.ctx.state.revision;
+    _lastCompactionToolsRef = a.ctx.tools;
+    _lastCompactionSystemRef = a.ctx.systemPrompt;
+    _lastCompactionMaxContext = maxContext;
+    const changed = a.ctx.state.revision !== beforeRevision || a.ctx.messages !== beforeMessages || a.ctx.messages.length !== beforeMsgCount;
+    const tokens = refreshContextRequestTokenStash({ force: changed });
+    _lastCompactionRequestTokens = tokens;
+    const load = maxContext > 0 ? tokens / maxContext : 0;
+    _lastCompactionWasNoop = tokens > 0 && load < 0.5;
+    if (changed) {
+      _lastEmittedMsgCount = -1;
+      _lastEmittedToolCount = -1;
+      _lastEmittedMaxContext = -1;
+    }
+    return changed;
+  }
+  async function buildRequestWithPreflightCompaction(opts) {
+    let prepared = await handlers.response.buildAndRunRequestPipeline(opts);
+    let req = prepared.request;
+    let preFlight = stashRequestTokens(req);
+    let probedRouteKey = `${prepared.provider.id}/${req.model}`;
+    await refreshProviderContextLimit(prepared.provider, req.model);
+    if (await compactContextIfNeeded()) {
+      prepared = await handlers.response.buildAndRunRequestPipeline(opts);
+      req = prepared.request;
+      preFlight = stashRequestTokens(req);
+      const rebuiltRouteKey = `${prepared.provider.id}/${req.model}`;
+      if (rebuiltRouteKey !== probedRouteKey) {
+        probedRouteKey = rebuiltRouteKey;
+        await refreshProviderContextLimit(prepared.provider, req.model);
+        if (await compactContextIfNeeded()) {
+          prepared = await handlers.response.buildAndRunRequestPipeline(opts);
+          req = prepared.request;
+          preFlight = stashRequestTokens(req);
+        }
+      }
+    }
+    return { req, provider: prepared.provider, preFlight };
+  }
+  function emitContextPct() {
+    const msgCount = a.ctx.messages.length;
+    const toolCount = (a.ctx.tools ?? []).length;
+    const maxContext = currentMaxContext();
+    const revision = a.ctx.state.revision;
+    if (msgCount === _lastEmittedMsgCount && toolCount === _lastEmittedToolCount && revision === _lastEmittedRevision && maxContext === _lastEmittedMaxContext && maxContext > 0) {
+      return;
+    }
+    _lastEmittedMsgCount = msgCount;
+    _lastEmittedToolCount = toolCount;
+    _lastEmittedRevision = revision;
+    _lastEmittedMaxContext = maxContext;
+    if (msgCount !== _lastPreFlightMsgCount || toolCount !== _lastPreFlightToolCount || revision !== _lastPreFlightRevision) {
+      refreshContextRequestTokenStash({ force: true });
+    }
+    let total;
+    const anchored = realAnchoredInputTokens(
+      a.ctx.messages,
+      a.ctx.lastRealInputTokens,
+      typeof a.ctx.meta?.["realAnchorMsgCount"] === "number" ? a.ctx.meta["realAnchorMsgCount"] : void 0
+    );
+    const stashed = a.ctx.lastRequestTokens;
+    if (anchored !== null) {
+      total = anchored;
+    } else if (typeof stashed === "number" && stashed > 0) {
+      const cal = getCalibrationState(calibrationKey());
+      total = cal.calibrated ? Math.round(stashed * Math.min(1.5, Math.max(0.5, cal.ratio))) : stashed;
+    } else {
+      const raw = refreshContextRequestTokenStash({ force: true });
+      const cal = getCalibrationState(calibrationKey());
+      total = cal.calibrated ? Math.round(raw * Math.min(1.5, Math.max(0.5, cal.ratio))) : raw;
+    }
+    const rawLoad = maxContext > 0 ? total / maxContext : 0;
+    const load = Math.max(0, Math.min(1, rawLoad));
+    a.events.emit("ctx.pct", {
+      sessionId: resolveEventSessionId(a.ctx),
+      load,
+      rawLoad,
+      tokens: total,
+      maxContext
+    });
+  }
+  return {
+    refreshProviderContextLimit,
+    compactContextIfNeeded,
+    stashRequestTokens,
+    refreshContextRequestTokenStash,
+    buildRequestWithPreflightCompaction,
+    emitContextPct,
+    currentMaxContext,
+    calibrationKey,
+    get lastPreFlightMsgCount() {
+      return _lastPreFlightMsgCount;
+    }
+  };
 }
 
-// src/core/streaming-response-builder.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-
-// src/utils/json-repair.ts
-function completePartialObject(s) {
-  if (!s.trim().startsWith("{")) return s;
-  if (tryParse(s).ok) return s;
-  return repairTruncated(s);
+// src/core/agent-loop-detector.ts
+function iterationFingerprint(blocks) {
+  const toolUses = blocks.filter(isToolUseBlock);
+  const texts = blocks.filter(isTextBlock);
+  const toolNameSet = Array.from(new Set(toolUses.map((u) => u.name))).sort();
+  const firstInputHash = toolUses[0] ? hashSmall(stableStringify(toolUses[0].input ?? {})) : "";
+  const textBlob = texts.map((t2) => t2.text).join("").slice(0, 512);
+  const hasContent = toolNameSet.length > 0 || textBlob.length > 0;
+  if (!hasContent) return "__empty__";
+  return [
+    `tools=${toolNameSet.join("+") || "-"}`,
+    `in0=${firstInputHash}`,
+    `txt=${textBlob}`
+  ].join("\n");
 }
-function repairTruncated(s) {
-  const stack = [];
-  let inString = false;
-  let escaped = false;
-  let sawKey = false;
-  let prevSig = "";
-  let contentEnd = 0;
-  let stringBraceDepth = 0;
+function stableStringify(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    const src = value;
+    const out = {};
+    for (const k of Object.keys(src).sort()) out[k] = canonicalize(src[k]);
+    return out;
+  }
+  return value;
+}
+function hashSmall(s) {
+  let h = 2166136261;
   for (let i = 0; i < s.length; i++) {
-    const ch = expectDefined(s[i]);
-    if (inString) {
-      contentEnd = i + 1;
-      if (escaped) {
-        escaped = false;
-        continue;
+    h ^= s.charCodeAt(i);
+    h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+  }
+  return h.toString(36);
+}
+var AgentLoopDetector = class {
+  constructor(a) {
+    this.a = a;
+  }
+  a;
+  lastToolSignature = "";
+  toolLoopCount = 0;
+  iterationSteerDone = false;
+  recentCallKeys = [];
+  steeredCallKeys = /* @__PURE__ */ new Set();
+  checkIteration(iterationIndex, content, toolUses, queueSteer) {
+    const loopCfg = this.a.loopDetection;
+    if (loopCfg.mode === "off") return { cut: false };
+    const sig = iterationFingerprint(content);
+    if (sig !== "__empty__") {
+      if (sig === this.lastToolSignature) {
+        this.toolLoopCount++;
+      } else {
+        this.lastToolSignature = sig;
+        this.toolLoopCount = 1;
+        this.iterationSteerDone = false;
       }
-      if (ch === "\\") {
-        escaped = true;
-        continue;
+      const names = toolUses.map((t2) => t2.name).join(", ");
+      const hasText2 = content.some(isTextBlock);
+      const kind = toolUses.length > 0 && hasText2 ? "mixed" : toolUses.length > 0 ? "tool" : "message";
+      const observationRepeat = loopCfg.mode === "steer-then-cut" && toolUses.length > 0 && toolUses.every((use) => {
+        const tool = this.a.tools.get(use.name);
+        return tool?.mutating === false && (tool.riskTier === "safe" || (tool.capabilities?.length ?? 0) > 0);
+      });
+      const repeatMultiplier = observationRepeat ? 2 : 1;
+      const detail = kind === "tool" ? `"${names}" called with effectively identical inputs ${this.toolLoopCount} times in a row` : kind === "mixed" ? `"${names}" + same text repeated ${this.toolLoopCount} times in a row` : `same assistant text repeated ${this.toolLoopCount} times in a row`;
+      const cutAt = (loopCfg.mode === "cut" ? loopCfg.steerThreshold : loopCfg.cutThreshold) * repeatMultiplier;
+      if (this.toolLoopCount >= cutAt) {
+        this.a.logger.warn(`Loop detected: ${detail} \u2014 stopping to prevent infinite loop.`);
+        this.a.events.emit("tool.loop_detected", {
+          sessionId: resolveEventSessionId(this.a.ctx),
+          ctx: this.a.ctx,
+          tools: names,
+          repeatCount: this.toolLoopCount,
+          iteration: iterationIndex,
+          kind,
+          action: "cut",
+          scope: "iteration"
+        });
+        const summary = kind === "message" ? `[Loop detected: same assistant message repeated ${this.toolLoopCount}\xD7 \u2014 stopping to prevent infinite repetition.]` : `[Loop detected: ${detail} \u2014 stopping to prevent infinite repetition.]`;
+        return { cut: true, cutSummary: summary };
       }
-      if (ch === '"') {
-        inString = false;
-        prevSig = '"';
-        stringBraceDepth = 0;
-        continue;
+      if (loopCfg.mode === "steer-then-cut" && this.toolLoopCount >= loopCfg.steerThreshold * repeatMultiplier && !this.iterationSteerDone) {
+        this.iterationSteerDone = true;
+        this.a.logger.warn(`Loop detected: ${detail} \u2014 steering the model to change approach.`);
+        this.a.events.emit("tool.loop_detected", {
+          sessionId: resolveEventSessionId(this.a.ctx),
+          ctx: this.a.ctx,
+          tools: names,
+          repeatCount: this.toolLoopCount,
+          iteration: iterationIndex,
+          kind,
+          action: "steer",
+          scope: "iteration"
+        });
+        queueSteer(
+          `[loop-detector] Your last ${this.toolLoopCount} responses were effectively identical (${detail}). This approach is not working. Change strategy: use a different tool, different arguments, or a different plan \u2014 or explain what is blocking you and stop. Repeating the same response ${cutAt - this.toolLoopCount} more time(s) will terminate the turn.`
+        );
       }
-      if (ch === "{") stringBraceDepth++;
-      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
-      continue;
-    }
-    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
-    contentEnd = i + 1;
-    if (ch === '"') {
-      inString = true;
-      sawKey = true;
-      stringBraceDepth = 0;
-      prevSig = '"';
-    } else if (ch === "{" || ch === "[") {
-      stack.push(ch);
-      prevSig = ch;
-    } else if (ch === "}" || ch === "]") {
-      stack.pop();
-      prevSig = ch;
     } else {
-      prevSig = ch;
+      this.lastToolSignature = "";
+      this.toolLoopCount = 0;
+      this.iterationSteerDone = false;
+    }
+    if (loopCfg.mode === "steer-then-cut") {
+      for (const u of toolUses) {
+        const key = `${u.name}:${hashSmall(stableStringify(u.input ?? {}))}`;
+        this.recentCallKeys.push(key);
+        if (this.recentCallKeys.length > loopCfg.windowSize) this.recentCallKeys.shift();
+        if (this.steeredCallKeys.has(key)) continue;
+        let count = 0;
+        for (const k of this.recentCallKeys) if (k === key) count++;
+        const tool = this.a.tools.get(u.name);
+        const observationThreshold = tool?.mutating === false && (tool.riskTier === "safe" || (tool.capabilities?.length ?? 0) > 0) ? loopCfg.callRepeatThreshold * 2 : loopCfg.callRepeatThreshold;
+        if (count < observationThreshold) continue;
+        this.steeredCallKeys.add(key);
+        const preview = JSON.stringify(u.input ?? {}).slice(0, 160);
+        this.a.logger.warn(
+          `Loop detected: "${u.name}" called with identical arguments ${count}\xD7 within the last ${loopCfg.windowSize} tool calls \u2014 steering the model to change approach.`
+        );
+        this.a.events.emit("tool.loop_detected", {
+          sessionId: resolveEventSessionId(this.a.ctx),
+          ctx: this.a.ctx,
+          tools: u.name,
+          repeatCount: count,
+          iteration: iterationIndex,
+          kind: "tool",
+          action: "steer",
+          scope: "call"
+        });
+        queueSteer(
+          `[loop-detector] You have called ${u.name}(${preview}) ${count} times with identical arguments within the last ${loopCfg.windowSize} tool calls. The result will not change. Do not repeat this call \u2014 use what you already know, try a different approach, or explain the blocker.`
+        );
+      }
     }
+    return { cut: false };
   }
-  if (!sawKey && !inString) return s;
-  let result = s.slice(0, contentEnd);
-  if (inString) {
-    if (escaped) {
-      result = result.slice(0, -1);
-    } else if (endsWithInvalidEscape(result)) {
-      result = result.slice(0, -2);
+};
+
+// src/core/continue-to-next-iteration.ts
+function parseContinueDirective(text) {
+  const LINE_MARKERS = /^\s*\[(continue|next step|proceed|done)\]\s*$/gim;
+  const tail = text.length <= DIRECTIVE_SCAN_WINDOW ? text : text.slice(text.length - DIRECTIVE_SCAN_WINDOW);
+  let match;
+  let lastDirective = "none";
+  while ((match = LINE_MARKERS.exec(tail)) !== null) {
+    const value = (match[1] ?? "").toLowerCase();
+    if (value === "continue" || value === "next step" || value === "proceed") {
+      lastDirective = "continue";
+    } else if (value === "done") {
+      lastDirective = "stop";
     }
-    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
-    result += '"';
-  } else if (prevSig === ":") {
-    result += "null";
-  }
-  for (let k = stack.length - 1; k >= 0; k--) {
-    result += stack[k] === "{" ? "}" : "]";
-  }
-  if (!tryParse(result).ok) {
-    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
-    if (tryParse(patched).ok) result = patched;
   }
-  return result;
+  return lastDirective;
 }
-var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
-function endsWithInvalidEscape(str) {
-  const last = str[str.length - 1];
-  if (str[str.length - 2] !== "\\" || last === void 0) return false;
-  if (VALID_ESCAPE.has(last)) return false;
-  let backslashes = 0;
-  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
-  return backslashes % 2 === 1;
+var DIRECTIVE_SCAN_WINDOW = 2048;
+var META_KEY2 = "_autonomousContinue";
+function consumeAutonomousContinue(ctx) {
+  const val = ctx.meta[META_KEY2] === true;
+  delete ctx.meta[META_KEY2];
+  return val;
+}
+
+// src/core/iteration-limit.ts
+function requestLimitExtension(opts) {
+  const { events, sessionId, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
+  return new Promise((resolve10) => {
+    let resolved = false;
+    const timerFired = () => {
+      if (!resolved) {
+        resolved = true;
+        resolve10(0);
+      }
+    };
+    const timer = setTimeout(timerFired, timeoutMs);
+    timer.unref();
+    const deny = () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve10(0);
+      }
+    };
+    const grant = (extra) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve10(Math.max(0, extra));
+      }
+    };
+    events.emit("iteration.limit_reached", {
+      sessionId,
+      currentIterations,
+      currentLimit,
+      grant,
+      deny
+    });
+    if (autoExtend) {
+      setImmediate(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolve10(100);
+        }
+      });
+    }
+  });
+}
+
+// src/core/next-steps-slot.ts
+var SLOT_KEY = "nextsteps.pending";
+var MAX_PENDING_NEXT_STEPS = 4;
+var NEXT_STEPS_TAG_RE = /<nextsteps\b[^>]*>/i;
+function writePendingNextSteps(ctx, steps) {
+  const cleaned = [];
+  for (const step of steps) {
+    const text = typeof step?.text === "string" ? step.text.replace(/\s+/g, " ").trim() : "";
+    if (!text) continue;
+    cleaned.push(step.auto === true && cleaned.length === 0 ? { text, auto: true } : { text });
+    if (cleaned.length >= MAX_PENDING_NEXT_STEPS) break;
+  }
+  if (cleaned.length === 0) {
+    clearPendingNextSteps(ctx);
+    return;
+  }
+  ctx.meta[SLOT_KEY] = cleaned;
+}
+function readPendingNextSteps(ctx) {
+  const raw = ctx.meta[SLOT_KEY];
+  if (!Array.isArray(raw) || raw.length === 0) return void 0;
+  const steps = raw.filter(
+    (s) => typeof s?.text === "string" && s.text.length > 0
+  );
+  return steps.length > 0 ? steps : void 0;
+}
+function clearPendingNextSteps(ctx) {
+  delete ctx.meta[SLOT_KEY];
+}
+function hasNextStepsTag(text) {
+  return NEXT_STEPS_TAG_RE.test(text);
+}
+function renderNextStepsBlock(steps) {
+  const lines = steps.map((step, i) => {
+    const auto = i === 0 && step.auto === true ? ' auto="true"' : "";
+    return `${i + 1}. ${step.text}${auto}`;
+  });
+  return `<nextsteps>
+${lines.join("\n")}
+</nextsteps>`;
+}
+function endsTurn(stopReason) {
+  return stopReason !== "tool_use" && stopReason !== "tool_call";
+}
+function maybeAppendPendingNextSteps(ctx, res) {
+  if (ctx.agentId !== "leader") return res;
+  if (!endsTurn(res.stopReason)) return res;
+  if (ctx.signal.aborted) return res;
+  const steps = readPendingNextSteps(ctx);
+  if (!steps) return res;
+  if (hasOpenTodos(ctx.todos)) {
+    clearPendingNextSteps(ctx);
+    return res;
+  }
+  const lastTextIndex = res.content.findLastIndex(isTextBlock);
+  if (lastTextIndex >= 0) {
+    const block = res.content[lastTextIndex];
+    if (block && isTextBlock(block) && hasNextStepsTag(block.text)) {
+      clearPendingNextSteps(ctx);
+      return res;
+    }
+  }
+  const rendered = renderNextStepsBlock(steps);
+  const content = [...res.content];
+  const target = lastTextIndex >= 0 ? content[lastTextIndex] : void 0;
+  if (target && isTextBlock(target)) {
+    const separator = target.text.trim() ? "\n\n" : "";
+    content[lastTextIndex] = { ...target, text: `${target.text}${separator}${rendered}` };
+  } else {
+    content.push({ type: "text", text: rendered });
+  }
+  clearPendingNextSteps(ctx);
+  return { ...res, content };
+}
+
+// src/core/streaming-response-builder.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// src/utils/json-repair.ts
+function completePartialObject(s) {
+  if (!s.trim().startsWith("{")) return s;
+  if (tryParse(s).ok) return s;
+  return repairTruncated(s);
+}
+function repairTruncated(s) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let sawKey = false;
+  let prevSig = "";
+  let contentEnd = 0;
+  let stringBraceDepth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = expectDefined(s[i]);
+    if (inString) {
+      contentEnd = i + 1;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+        prevSig = '"';
+        stringBraceDepth = 0;
+        continue;
+      }
+      if (ch === "{") stringBraceDepth++;
+      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
+    contentEnd = i + 1;
+    if (ch === '"') {
+      inString = true;
+      sawKey = true;
+      stringBraceDepth = 0;
+      prevSig = '"';
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      prevSig = ch;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      prevSig = ch;
+    } else {
+      prevSig = ch;
+    }
+  }
+  if (!sawKey && !inString) return s;
+  let result = s.slice(0, contentEnd);
+  if (inString) {
+    if (escaped) {
+      result = result.slice(0, -1);
+    } else if (endsWithInvalidEscape(result)) {
+      result = result.slice(0, -2);
+    }
+    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
+    result += '"';
+  } else if (prevSig === ":") {
+    result += "null";
+  }
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result += stack[k] === "{" ? "}" : "]";
+  }
+  if (!tryParse(result).ok) {
+    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
+    if (tryParse(patched).ok) result = patched;
+  }
+  return result;
+}
+var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function endsWithInvalidEscape(str) {
+  const last = str[str.length - 1];
+  if (str[str.length - 2] !== "\\" || last === void 0) return false;
+  if (VALID_ESCAPE.has(last)) return false;
+  let backslashes = 0;
+  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
+  return backslashes % 2 === 1;
 }
 function tryParse(s) {
   try {
@@ -6493,397 +6961,106 @@ async function runProviderWithRetry(opts) {
           return;
         }
         signal.addEventListener("abort", onAbort);
-      });
-      attempt++;
-    }
-  }
-}
-function elapsedMs(startedNs) {
-  return Number(process.hrtime.bigint() - startedNs) / 1e6;
-}
-
-// src/core/queued-messages.ts
-var META_KEY3 = "_queuedMessagesAwareness";
-var MAX_ITEMS = 20;
-var MAX_PREVIEW_CHARS = 500;
-function read(ctx) {
-  const raw = ctx.meta[META_KEY3];
-  if (!raw || typeof raw !== "object") return void 0;
-  const s = raw;
-  return Array.isArray(s.items) && Array.isArray(s.seen) ? s : void 0;
-}
-function sameList(a, b) {
-  return a.length === b.length && a.every((v, i) => v === b[i]);
-}
-function toPreview(text) {
-  const trimmed = text.trim();
-  if (trimmed.length <= MAX_PREVIEW_CHARS) return trimmed;
-  return `${trimmed.slice(0, MAX_PREVIEW_CHARS - 1)}\u2026`;
-}
-function setQueuedMessagesSnapshot(ctx, texts) {
-  const items = texts.map(toPreview).filter((t2) => t2.length > 0).slice(0, MAX_ITEMS);
-  const prev = read(ctx);
-  if (items.length === 0 && (!prev || prev.seen.length === 0)) {
-    if (prev) delete ctx.meta[META_KEY3];
-    return;
-  }
-  ctx.meta[META_KEY3] = { items, seen: prev?.seen ?? [] };
-}
-function consumeQueuedMessagesUpdate(ctx) {
-  const s = read(ctx);
-  if (!s) return null;
-  if (sameList(s.items, s.seen)) return null;
-  if (s.items.length === 0) {
-    delete ctx.meta[META_KEY3];
-    return null;
-  }
-  ctx.meta[META_KEY3] = { items: s.items, seen: s.items };
-  return s.items;
-}
-function buildQueuedMessagesBlock(items) {
-  const body = items.map((t2, i) => `${i + 1}. ${t2}`).join("\n");
-  return [
-    "[QUEUED MESSAGES \u2014 the user typed these while you were working. They are",
-    "waiting in the input queue and each will be delivered as its own turn",
-    "after you finish, so do NOT answer or act on them as new tasks now. Read",
-    "them as a heads-up: if one changes what you should be doing right now",
-    "(new constraint, invalidated approach), adapt your current work; if one",
-    "is just an FYI, fold it in. The queue may still change before delivery.",
-    "This notice replaces any earlier one \u2014 the queue now holds exactly:",
-    "",
-    body,
-    "]"
-  ].join("\n");
-}
-
-// src/core/request-provider-binding.ts
-var requestProviders = /* @__PURE__ */ new WeakMap();
-function bindRequestProvider(request, provider) {
-  requestProviders.set(request, provider);
-}
-function providerBoundToRequest(request) {
-  return requestProviders.get(request);
-}
-
-// src/core/agent-loop.ts
-function toError(err) {
-  return err instanceof Error ? err : new Error(String(err));
-}
-function signalAbortReason(signal) {
-  const r = signal.reason;
-  if (r instanceof Error) return r.message || r.name;
-  if (typeof r === "string" && r.length > 0) return r;
-  return "aborted";
-}
-function createAgentLoopHandler(a, handlers) {
-  const checkMailbox = attachMailboxChecker(a);
-  const fleetPulseCfg = (() => {
-    try {
-      return typeof a.container?.has === "function" && a.container.has(TOKENS.ConfigStore) ? a.container.resolve(TOKENS.ConfigStore).get().fleet?.pulse : void 0;
-    } catch {
-      return void 0;
-    }
-  })();
-  const getFleetPulse = attachFleetPulse(a, fleetPulseCfg);
-  const pulseEveryN = Math.max(1, fleetPulseCfg?.everyNIterations ?? 5);
-  const backgroundCoordination = () => a.ctx.meta["coordinationContextMode"] === "background";
-  async function refreshProviderContextLimit(provider, model, opts = {}) {
-    a.ctx.meta ??= {};
-    const routeKey = `${provider.id}/${model}`;
-    const previousRouteKey = a.ctx.meta["contextLimitRouteKey"];
-    const routeChanged = previousRouteKey !== void 0 && previousRouteKey !== routeKey;
-    const previousMaxContext = currentMaxContext();
-    if (routeChanged) {
-      delete a.ctx.meta["providerOverflowMaxContext"];
-      delete a.ctx.meta["contextLimitBaseline"];
-      delete a.ctx.meta["providerLimitEffectiveMaxContext"];
-      delete a.ctx.meta["effectiveMaxContext"];
-      delete a.ctx.meta["effectiveMaxContextSource"];
-      delete a.ctx.meta["contextLimitLastEmittedMaxContext"];
-      delete a.ctx.meta["contextLimitLastEmittedSource"];
-    }
-    a.ctx.meta["contextLimitRouteKey"] = routeKey;
-    const routeMeta = a.ctx.meta["effectiveMaxContext"];
-    const routeProviderCap = provider.capabilities.maxContext;
-    const currentEffective = typeof routeMeta === "number" && routeMeta > 0 ? routeMeta : typeof routeProviderCap === "number" && routeProviderCap > 0 ? routeProviderCap : 2e5;
-    const emitEffectiveLimit = (effective2, source) => {
-      const lastEmitted = a.ctx.meta["contextLimitLastEmittedMaxContext"];
-      const lastEmittedSource = a.ctx.meta["contextLimitLastEmittedSource"];
-      if (lastEmitted === effective2 && lastEmittedSource === source) return;
-      const eventPrevious = typeof lastEmitted === "number" && Number.isFinite(lastEmitted) && lastEmitted > 0 ? Math.floor(lastEmitted) : previousMaxContext;
-      a.ctx.meta["contextLimitLastEmittedMaxContext"] = effective2;
-      a.ctx.meta["contextLimitLastEmittedSource"] = source;
-      a.events.emit("ctx.max_context", {
-        sessionId: resolveEventSessionId(a.ctx),
-        providerId: provider.id,
-        modelId: model,
-        maxContext: effective2,
-        ...eventPrevious > 0 ? { previousMaxContext: eventPrevious } : {},
-        source,
-        decreased: eventPrevious > 0 && effective2 < eventPrevious
-      });
-    };
-    const emitNativeAfterRouteChange = () => {
-      if (routeChanged && currentEffective > 0) {
-        a.ctx.meta["effectiveMaxContext"] = currentEffective;
-        a.ctx.meta["effectiveMaxContextSource"] = "configured";
-        emitEffectiveLimit(currentEffective, "configured");
-      }
-    };
-    const refresh = provider.refreshContextLimit;
-    if (opts.probe === false || !refresh) {
-      emitNativeAfterRouteChange();
-      return;
-    }
-    let discovered;
-    try {
-      discovered = await refresh.call(provider, model, { signal: a.ctx.signal });
-    } catch {
-      emitNativeAfterRouteChange();
-      return;
-    }
-    const providerLimit = discovered?.maxContext;
-    if (typeof providerLimit !== "number" || !Number.isFinite(providerLimit) || providerLimit <= 0) {
-      emitNativeAfterRouteChange();
-      return;
-    }
-    const providerLimitFloored = Math.floor(providerLimit);
-    const existingBaseline = a.ctx.meta["contextLimitBaseline"];
-    const lastApplied = a.ctx.meta["providerLimitEffectiveMaxContext"];
-    const existingOverflow = a.ctx.meta["providerOverflowMaxContext"];
-    const effectiveChangedOutsideProbe = typeof lastApplied === "number" && Number.isFinite(lastApplied) && currentEffective !== Math.floor(lastApplied) && currentEffective !== existingOverflow;
-    const baseline = effectiveChangedOutsideProbe || typeof existingBaseline !== "number" || !Number.isFinite(existingBaseline) || existingBaseline <= 0 ? currentEffective : Math.floor(existingBaseline);
-    a.ctx.meta["contextLimitBaseline"] = baseline;
-    const overflowLimit = a.ctx.meta["providerOverflowMaxContext"];
-    const overflowFloored = typeof overflowLimit === "number" && Number.isFinite(overflowLimit) && overflowLimit > 0 ? Math.floor(overflowLimit) : void 0;
-    const ceilings = [baseline, providerLimitFloored];
-    if (overflowFloored !== void 0) ceilings.push(overflowFloored);
-    const effective = Math.min(...ceilings.filter((limit) => limit > 0));
-    let effectiveSource;
-    if (overflowFloored !== void 0 && effective === overflowFloored) {
-      effectiveSource = "provider_overflow";
-    } else if (effective === providerLimitFloored) {
-      effectiveSource = "provider";
-    } else {
-      effectiveSource = "configured";
-    }
-    a.ctx.meta["effectiveMaxContext"] = effective;
-    a.ctx.meta["providerLimitEffectiveMaxContext"] = effective;
-    a.ctx.meta["effectiveMaxContextSource"] = effectiveSource;
-    emitEffectiveLimit(effective, effectiveSource);
-  }
-  async function compactContextIfNeeded() {
-    const msgCount = a.ctx.messages.length;
-    const maxContext = currentMaxContext();
-    const revision = a.ctx.state.revision;
-    const toolsRef = a.ctx.tools;
-    const systemRef = a.ctx.systemPrompt;
-    const requestTokens = a.ctx.lastRequestTokens;
-    if (_lastCompactionMsgCount === msgCount && _lastCompactionRevision === revision && _lastCompactionToolsRef === toolsRef && _lastCompactionSystemRef === systemRef && _lastCompactionRequestTokens === requestTokens && _lastCompactionWasNoop && _lastCompactionMaxContext === maxContext && maxContext > 0) {
-      return false;
-    }
-    const beforeMessages = a.ctx.messages;
-    const beforeMsgCount = a.ctx.messages.length;
-    const beforeRevision = a.ctx.state.revision;
-    await a.pipelines.contextWindow.run(a.ctx);
-    _lastCompactionMsgCount = a.ctx.messages.length;
-    _lastCompactionRevision = a.ctx.state.revision;
-    _lastCompactionToolsRef = a.ctx.tools;
-    _lastCompactionSystemRef = a.ctx.systemPrompt;
-    _lastCompactionMaxContext = maxContext;
-    const changed = a.ctx.state.revision !== beforeRevision || a.ctx.messages !== beforeMessages || a.ctx.messages.length !== beforeMsgCount;
-    const tokens = refreshContextRequestTokenStash({ force: changed });
-    _lastCompactionRequestTokens = tokens;
-    const load = maxContext > 0 ? tokens / maxContext : 0;
-    _lastCompactionWasNoop = tokens > 0 && load < 0.5;
-    if (changed) {
-      _lastEmittedMsgCount = -1;
-      _lastEmittedToolCount = -1;
-      _lastEmittedMaxContext = -1;
-    }
-    return changed;
-  }
-  const calibrationKey = (model = a.ctx.model) => `${a.ctx.provider?.id ?? "unknown"}/${model}`;
-  let _cachedSysRef = null;
-  let _cachedToolsRef = null;
-  let _cachedOverheadTokens = 0;
-  function systemAndToolsOverhead() {
-    const sysRef = a.ctx.systemPrompt;
-    const toolsRef = a.ctx.tools;
-    if (sysRef === _cachedSysRef && toolsRef === _cachedToolsRef && _cachedOverheadTokens > 0) {
-      return _cachedOverheadTokens;
-    }
-    const breakdown = estimateRequestTokens([], sysRef, toolsRef ?? [], calibrationKey());
-    _cachedSysRef = sysRef;
-    _cachedToolsRef = toolsRef;
-    _cachedOverheadTokens = breakdown.systemPrompt + breakdown.tools;
-    return _cachedOverheadTokens;
-  }
-  function stashRequestTokens(req) {
-    const preFlight = estimateRequestTokens(
-      req.messages,
-      req.system,
-      req.tools ?? [],
-      calibrationKey(req.model)
-    );
-    a.ctx.lastRequestTokens = preFlight.total;
-    _lastPreFlightMsgCount = req.messages.length;
-    _lastPreFlightToolCount = (req.tools ?? []).length;
-    _lastPreFlightRevision = a.ctx.state.revision;
-    _cachedSysRef = req.system;
-    _cachedToolsRef = req.tools ?? [];
-    _cachedOverheadTokens = preFlight.systemPrompt + preFlight.tools;
-    a.ctx.meta["lastRequestTokensAt"] = {
-      msgCount: req.messages.length,
-      toolCount: (req.tools ?? []).length,
-      revision: a.ctx.state.revision
-    };
-    return preFlight;
-  }
-  function refreshContextRequestTokenStash(opts = {}) {
-    const msgCount = a.ctx.messages.length;
-    const toolCount = (a.ctx.tools ?? []).length;
-    const revision = a.ctx.state.revision;
-    const stashed = a.ctx.lastRequestTokens;
-    const stashedAt = a.ctx.meta?.["lastRequestTokensAt"];
-    if (!opts.force && typeof stashed === "number" && stashed > 0 && typeof stashedAt === "object" && stashedAt !== null) {
-      const meta = stashedAt;
-      if (meta.msgCount === msgCount && meta.toolCount === toolCount && meta.revision === revision && _lastPreFlightRevision === revision) {
-        return stashed;
-      }
-    }
-    const refreshed = estimateMessageTokens(a.ctx.messages) + systemAndToolsOverhead();
-    a.ctx.lastRequestTokens = refreshed;
-    _lastPreFlightMsgCount = msgCount;
-    _lastPreFlightToolCount = toolCount;
-    _lastPreFlightRevision = revision;
-    a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount, revision };
-    return refreshed;
-  }
-  async function buildRequestWithPreflightCompaction(opts) {
-    let prepared = await handlers.response.buildAndRunRequestPipeline(opts);
-    let req = prepared.request;
-    let preFlight = stashRequestTokens(req);
-    let probedRouteKey = `${prepared.provider.id}/${req.model}`;
-    await refreshProviderContextLimit(prepared.provider, req.model);
-    if (await compactContextIfNeeded()) {
-      prepared = await handlers.response.buildAndRunRequestPipeline(opts);
-      req = prepared.request;
-      preFlight = stashRequestTokens(req);
-      const rebuiltRouteKey = `${prepared.provider.id}/${req.model}`;
-      if (rebuiltRouteKey !== probedRouteKey) {
-        probedRouteKey = rebuiltRouteKey;
-        await refreshProviderContextLimit(prepared.provider, req.model);
-        if (await compactContextIfNeeded()) {
-          prepared = await handlers.response.buildAndRunRequestPipeline(opts);
-          req = prepared.request;
-          preFlight = stashRequestTokens(req);
-        }
-      }
+      });
+      attempt++;
     }
-    return { req, provider: prepared.provider, preFlight };
   }
-  function emitContextPct() {
-    const msgCount = a.ctx.messages.length;
-    const toolCount = (a.ctx.tools ?? []).length;
-    const maxContext = currentMaxContext();
-    const revision = a.ctx.state.revision;
-    if (msgCount === _lastEmittedMsgCount && toolCount === _lastEmittedToolCount && revision === _lastEmittedRevision && maxContext === _lastEmittedMaxContext && maxContext > 0) {
-      return;
-    }
-    _lastEmittedMsgCount = msgCount;
-    _lastEmittedToolCount = toolCount;
-    _lastEmittedRevision = revision;
-    _lastEmittedMaxContext = maxContext;
-    if (msgCount !== _lastPreFlightMsgCount || toolCount !== _lastPreFlightToolCount || revision !== _lastPreFlightRevision) {
-      refreshContextRequestTokenStash({ force: true });
-    }
-    let total;
-    const anchored = realAnchoredInputTokens(
-      a.ctx.messages,
-      a.ctx.lastRealInputTokens,
-      typeof a.ctx.meta?.["realAnchorMsgCount"] === "number" ? a.ctx.meta["realAnchorMsgCount"] : void 0
-    );
-    const stashed = a.ctx.lastRequestTokens;
-    if (anchored !== null) {
-      total = anchored;
-    } else if (typeof stashed === "number" && stashed > 0) {
-      const cal = getCalibrationState(calibrationKey());
-      total = cal.calibrated ? Math.round(stashed * Math.min(1.5, Math.max(0.5, cal.ratio))) : stashed;
-    } else {
-      const raw = refreshContextRequestTokenStash({ force: true });
-      const cal = getCalibrationState(calibrationKey());
-      total = cal.calibrated ? Math.round(raw * Math.min(1.5, Math.max(0.5, cal.ratio))) : raw;
-    }
-    const rawLoad = maxContext > 0 ? total / maxContext : 0;
-    const load = Math.max(0, Math.min(1, rawLoad));
-    a.events.emit("ctx.pct", {
-      sessionId: resolveEventSessionId(a.ctx),
-      load,
-      rawLoad,
-      tokens: total,
-      maxContext
-    });
+}
+function elapsedMs(startedNs) {
+  return Number(process.hrtime.bigint() - startedNs) / 1e6;
+}
+
+// src/core/queued-messages.ts
+var META_KEY3 = "_queuedMessagesAwareness";
+var MAX_ITEMS = 20;
+var MAX_PREVIEW_CHARS = 500;
+function read(ctx) {
+  const raw = ctx.meta[META_KEY3];
+  if (!raw || typeof raw !== "object") return void 0;
+  const s = raw;
+  return Array.isArray(s.items) && Array.isArray(s.seen) ? s : void 0;
+}
+function sameList(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function toPreview(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= MAX_PREVIEW_CHARS) return trimmed;
+  return `${trimmed.slice(0, MAX_PREVIEW_CHARS - 1)}\u2026`;
+}
+function setQueuedMessagesSnapshot(ctx, texts) {
+  const items = texts.map(toPreview).filter((t2) => t2.length > 0).slice(0, MAX_ITEMS);
+  const prev = read(ctx);
+  if (items.length === 0 && (!prev || prev.seen.length === 0)) {
+    if (prev) delete ctx.meta[META_KEY3];
+    return;
   }
-  function currentMaxContext() {
-    const metaLimit = a.ctx.meta?.["effectiveMaxContext"];
-    const providerMax = a.ctx.provider.capabilities.maxContext;
-    return typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : 2e5;
+  ctx.meta[META_KEY3] = { items, seen: prev?.seen ?? [] };
+}
+function consumeQueuedMessagesUpdate(ctx) {
+  const s = read(ctx);
+  if (!s) return null;
+  if (sameList(s.items, s.seen)) return null;
+  if (s.items.length === 0) {
+    delete ctx.meta[META_KEY3];
+    return null;
   }
-  let _lastEmittedMsgCount = -1;
-  let _lastEmittedToolCount = -1;
-  let _lastEmittedRevision = -1;
-  let _lastEmittedMaxContext = -1;
-  let _lastPreFlightMsgCount = -1;
-  let _lastPreFlightToolCount = -1;
-  let _lastPreFlightRevision = -1;
-  let _lastCompactionMsgCount = -1;
-  let _lastCompactionRevision = -1;
-  let _lastCompactionToolsRef = null;
-  let _lastCompactionSystemRef = null;
-  let _lastCompactionRequestTokens;
-  let _lastCompactionMaxContext = -1;
-  let _lastCompactionWasNoop = false;
+  ctx.meta[META_KEY3] = { items: s.items, seen: s.items };
+  return s.items;
+}
+function buildQueuedMessagesBlock(items) {
+  const body = items.map((t2, i) => `${i + 1}. ${t2}`).join("\n");
+  return [
+    "[QUEUED MESSAGES \u2014 the user typed these while you were working. They are",
+    "waiting in the input queue and each will be delivered as its own turn",
+    "after you finish, so do NOT answer or act on them as new tasks now. Read",
+    "them as a heads-up: if one changes what you should be doing right now",
+    "(new constraint, invalidated approach), adapt your current work; if one",
+    "is just an FYI, fold it in. The queue may still change before delivery.",
+    "This notice replaces any earlier one \u2014 the queue now holds exactly:",
+    "",
+    body,
+    "]"
+  ].join("\n");
+}
+
+// src/core/request-provider-binding.ts
+var requestProviders = /* @__PURE__ */ new WeakMap();
+function bindRequestProvider(request, provider) {
+  requestProviders.set(request, provider);
+}
+function providerBoundToRequest(request) {
+  return requestProviders.get(request);
+}
+
+// src/core/agent-loop.ts
+function toError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function signalAbortReason(signal) {
+  const r = signal.reason;
+  if (r instanceof Error) return r.message || r.name;
+  if (typeof r === "string" && r.length > 0) return r;
+  return "aborted";
+}
+function createAgentLoopHandler(a, handlers) {
+  const checkMailbox = attachMailboxChecker(a);
+  const fleetPulseCfg = (() => {
+    try {
+      return typeof a.container?.has === "function" && a.container.has(TOKENS.ConfigStore) ? a.container.resolve(TOKENS.ConfigStore).get().fleet?.pulse : void 0;
+    } catch {
+      return void 0;
+    }
+  })();
+  const getFleetPulse = attachFleetPulse(a, fleetPulseCfg);
+  const pulseEveryN = Math.max(1, fleetPulseCfg?.everyNIterations ?? 5);
+  const backgroundCoordination = () => a.ctx.meta["coordinationContextMode"] === "background";
+  const loopContext = createAgentLoopContextManager(a, handlers);
   function foldBlockIntoConversation(block) {
     if (!a.ctx.state.appendBlockToLastUserMessage(block)) {
       a.ctx.state.appendMessage({ role: "user", content: [block], origin: "runtime" });
     }
   }
-  function iterationFingerprint(blocks) {
-    const toolUses = blocks.filter(isToolUseBlock);
-    const texts = blocks.filter(isTextBlock);
-    const toolNameSet = Array.from(new Set(toolUses.map((u) => u.name))).sort();
-    const firstInputHash = toolUses[0] ? hashSmall(stableStringify(toolUses[0].input ?? {})) : "";
-    const textBlob = texts.map((t2) => t2.text).join("").slice(0, 512);
-    const hasContent = toolNameSet.length > 0 || textBlob.length > 0;
-    if (!hasContent) return "__empty__";
-    return [
-      `tools=${toolNameSet.join("+") || "-"}`,
-      `in0=${firstInputHash}`,
-      `txt=${textBlob}`
-    ].join("\n");
-  }
-  function stableStringify(value) {
-    return JSON.stringify(canonicalize(value));
-  }
-  function canonicalize(value) {
-    if (Array.isArray(value)) return value.map(canonicalize);
-    if (value && typeof value === "object") {
-      const src = value;
-      const out = {};
-      for (const k of Object.keys(src).sort()) out[k] = canonicalize(src[k]);
-      return out;
-    }
-    return value;
-  }
-  function hashSmall(s) {
-    let h = 2166136261;
-    for (let i = 0; i < s.length; i++) {
-      h ^= s.charCodeAt(i);
-      h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
-    }
-    return h.toString(36);
-  }
   function injectPendingBtwNotes(onMailboxBlock) {
     const notes = consumeBtwNotes(a.ctx);
     if (notes.length === 0) return;
@@ -6963,15 +7140,10 @@ function createAgentLoopHandler(a, handlers) {
         a.ctx.state.replaceMessages(cleaned.messages);
         a.ctx.lastRealInputTokens = void 0;
         delete a.ctx.meta["realAnchorMsgCount"];
-        refreshContextRequestTokenStash({ force: true });
+        loopContext.refreshContextRequestTokenStash({ force: true });
       }
     }
-    const loopCfg = a.loopDetection;
-    let lastToolSignature = "";
-    let toolLoopCount = 0;
-    let iterationSteerDone = false;
-    const recentCallKeys = [];
-    const steeredCallKeys = /* @__PURE__ */ new Set();
+    const loopDetector = new AgentLoopDetector(a);
     let pendingLoopSteer = null;
     let todoReconcileSteers = 0;
     function queueLoopSteer(text) {
@@ -7078,7 +7250,7 @@ ${text}` : text;
           req,
           provider: requestProvider,
           preFlight
-        } = await buildRequestWithPreflightCompaction(opts);
+        } = await loopContext.buildRequestWithPreflightCompaction(opts);
         await a.ctx.session.append({
           type: "llm_request",
           ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7091,7 +7263,7 @@ ${text}` : text;
         let res;
         try {
           res = await customRunner(a.ctx, req);
-          const key = calibrationKey(req.model);
+          const key = loopContext.calibrationKey(req.model);
           const cal = getCalibrationState(key);
           const calibratedTotal = cal.calibrated ? Math.round(preFlight.total * Math.min(1.5, Math.max(0.5, cal.ratio))) : preFlight.total;
           const realInputTokens = effectiveInputTokens(res.usage);
@@ -7099,10 +7271,10 @@ ${text}` : text;
           const previousRealInput = a.ctx.lastRealInputTokens;
           const previousAnchorMsgCount = typeof a.ctx.meta?.["realAnchorMsgCount"] === "number" ? a.ctx.meta["realAnchorMsgCount"] : void 0;
           const anchorIsPlausible = realInputTokens >= calibratedTotal * 0.5;
-          const anchorAdvanced = previousRealInput === void 0 || realInputTokens > previousRealInput || previousAnchorMsgCount !== void 0 && _lastPreFlightMsgCount < previousAnchorMsgCount;
+          const anchorAdvanced = previousRealInput === void 0 || realInputTokens > previousRealInput || previousAnchorMsgCount !== void 0 && loopContext.lastPreFlightMsgCount < previousAnchorMsgCount;
           if (realInputTokens > 0 && anchorIsPlausible && anchorAdvanced) {
             a.ctx.lastRealInputTokens = realInputTokens;
-            a.ctx.meta["realAnchorMsgCount"] = _lastPreFlightMsgCount;
+            a.ctx.meta["realAnchorMsgCount"] = loopContext.lastPreFlightMsgCount;
           }
           recoveryRetries = 0;
         } catch (err) {
@@ -7192,7 +7364,9 @@ ${text}` : text;
         clearEvaluatedMailboxBlocks();
         const responseProvider = providerBoundToRequest(req) ?? requestProvider;
         const responseResult = await handlers.response.processResponse(res, req, responseProvider);
-        await refreshProviderContextLimit(responseProvider, req.model, { probe: false });
+        await loopContext.refreshProviderContextLimit(responseProvider, req.model, {
+          probe: false
+        });
         if (responseResult.finalText) {
           a.ctx.meta["lastAgentOutput"] = responseResult.finalText;
         }
@@ -7215,103 +7389,18 @@ ${text}` : text;
         }
         finalText = responseResult.finalText;
         const toolUses = res.content.filter(isToolUseBlock);
-        if (loopCfg.mode !== "off") {
-          const sig = iterationFingerprint(res.content);
-          if (sig !== "__empty__") {
-            if (sig === lastToolSignature) {
-              toolLoopCount++;
-            } else {
-              lastToolSignature = sig;
-              toolLoopCount = 1;
-              iterationSteerDone = false;
-            }
-            const names = toolUses.map((t2) => t2.name).join(", ");
-            const hasText2 = res.content.some(isTextBlock);
-            const kind = toolUses.length > 0 && hasText2 ? "mixed" : toolUses.length > 0 ? "tool" : "message";
-            const observationRepeat = loopCfg.mode === "steer-then-cut" && toolUses.length > 0 && toolUses.every((use) => {
-              const tool = a.tools.get(use.name);
-              return tool?.mutating === false && (tool.riskTier === "safe" || (tool.capabilities?.length ?? 0) > 0);
-            });
-            const repeatMultiplier = observationRepeat ? 2 : 1;
-            const detail = kind === "tool" ? `"${names}" called with effectively identical inputs ${toolLoopCount} times in a row` : kind === "mixed" ? `"${names}" + same text repeated ${toolLoopCount} times in a row` : `same assistant text repeated ${toolLoopCount} times in a row`;
-            const cutAt = (loopCfg.mode === "cut" ? loopCfg.steerThreshold : loopCfg.cutThreshold) * repeatMultiplier;
-            if (toolLoopCount >= cutAt) {
-              a.logger.warn(`Loop detected: ${detail} \u2014 stopping to prevent infinite loop.`);
-              a.events.emit("tool.loop_detected", {
-                sessionId: resolveEventSessionId(a.ctx),
-                ctx: a.ctx,
-                tools: names,
-                repeatCount: toolLoopCount,
-                iteration: i,
-                kind,
-                action: "cut",
-                scope: "iteration"
-              });
-              const summary = kind === "message" ? `[Loop detected: same assistant message repeated ${toolLoopCount}\xD7 \u2014 stopping to prevent infinite repetition.]` : `[Loop detected: ${detail} \u2014 stopping to prevent infinite repetition.]`;
-              return {
-                status: "max_iterations",
-                iterations,
-                finalText: finalText || summary,
-                delegateSummaries
-              };
-            }
-            if (loopCfg.mode === "steer-then-cut" && toolLoopCount >= loopCfg.steerThreshold * repeatMultiplier && !iterationSteerDone) {
-              iterationSteerDone = true;
-              a.logger.warn(`Loop detected: ${detail} \u2014 steering the model to change approach.`);
-              a.events.emit("tool.loop_detected", {
-                sessionId: resolveEventSessionId(a.ctx),
-                ctx: a.ctx,
-                tools: names,
-                repeatCount: toolLoopCount,
-                iteration: i,
-                kind,
-                action: "steer",
-                scope: "iteration"
-              });
-              queueLoopSteer(
-                `[loop-detector] Your last ${toolLoopCount} responses were effectively identical (${detail}). This approach is not working. Change strategy: use a different tool, different arguments, or a different plan \u2014 or explain what is blocking you and stop. Repeating the same response ${cutAt - toolLoopCount} more time(s) will terminate the turn.`
-              );
-            }
-          } else {
-            lastToolSignature = "";
-            toolLoopCount = 0;
-            iterationSteerDone = false;
-          }
-          if (loopCfg.mode === "steer-then-cut") {
-            for (const u of toolUses) {
-              const key = `${u.name}:${hashSmall(stableStringify(u.input ?? {}))}`;
-              recentCallKeys.push(key);
-              if (recentCallKeys.length > loopCfg.windowSize) recentCallKeys.shift();
-              if (steeredCallKeys.has(key)) continue;
-              let count = 0;
-              for (const k of recentCallKeys) if (k === key) count++;
-              const tool = a.tools.get(u.name);
-              const observationThreshold = tool?.mutating === false && (tool.riskTier === "safe" || (tool.capabilities?.length ?? 0) > 0) ? loopCfg.callRepeatThreshold * 2 : loopCfg.callRepeatThreshold;
-              if (count < observationThreshold) continue;
-              steeredCallKeys.add(key);
-              const preview2 = JSON.stringify(u.input ?? {}).slice(0, 160);
-              a.logger.warn(
-                `Loop detected: "${u.name}" called with identical arguments ${count}\xD7 within the last ${loopCfg.windowSize} tool calls \u2014 steering the model to change approach.`
-              );
-              a.events.emit("tool.loop_detected", {
-                sessionId: resolveEventSessionId(a.ctx),
-                ctx: a.ctx,
-                tools: u.name,
-                repeatCount: count,
-                iteration: i,
-                kind: "tool",
-                action: "steer",
-                scope: "call"
-              });
-              queueLoopSteer(
-                `[loop-detector] You have called ${u.name}(${preview2}) ${count} times with identical arguments within the last ${loopCfg.windowSize} tool calls. The result will not change. Do not repeat this call \u2014 use what you already know, try a different approach, or explain the blocker.`
-              );
-            }
-          }
+        const loopCheck = loopDetector.checkIteration(i, res.content, toolUses, queueLoopSteer);
+        if (loopCheck.cut) {
+          return {
+            status: "max_iterations",
+            iterations,
+            finalText: finalText || loopCheck.cutSummary || "",
+            delegateSummaries
+          };
         }
         if (toolUses.length === 0) {
-          await compactContextIfNeeded();
-          emitContextPct();
+          await loopContext.compactContextIfNeeded();
+          loopContext.emitContextPct();
           a.events.emit("iteration.completed", {
             sessionId: resolveEventSessionId(a.ctx),
             ctx: a.ctx,
@@ -7349,8 +7438,8 @@ ${text}` : text;
           throw toolErr;
         }
         if (autonomousContinue && consumeAutonomousContinue(a.ctx)) {
-          await compactContextIfNeeded();
-          emitContextPct();
+          await loopContext.compactContextIfNeeded();
+          loopContext.emitContextPct();
           a.events.emit("iteration.completed", {
             sessionId: resolveEventSessionId(a.ctx),
             ctx: a.ctx,
@@ -7359,8 +7448,8 @@ ${text}` : text;
           await a.extensions.runAfterIteration(a.ctx, i);
           continue;
         }
-        await compactContextIfNeeded();
-        emitContextPct();
+        await loopContext.compactContextIfNeeded();
+        loopContext.emitContextPct();
         a.events.emit("iteration.completed", {
           sessionId: resolveEventSessionId(a.ctx),
           ctx: a.ctx,
@@ -7559,6 +7648,9 @@ var RUNTIME_CAPABILITY_MANIFEST = [
       "codebase-incoming-calls",
       "codebase-outgoing-calls",
       "codebase-index",
+      "codebase-skeleton",
+      "codebase-repo-map",
+      "codebase-impact-analysis",
       "dead-code-scan",
       "diff",
       "json",
@@ -7569,7 +7661,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "filesystem.write",
     pack: "development",
     exposure: "direct",
-    tools: ["write", "edit", "replace", "patch"]
+    tools: ["write", "edit", "replace", "patch", "codebase-ast-replace"]
   },
   {
     id: "execution.shell",
@@ -7581,7 +7673,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "verification.run",
     pack: "development",
     exposure: "direct",
-    tools: ["lint", "format", "typecheck", "test", "e2e_plan"]
+    tools: ["lint", "format", "typecheck", "test", "e2e_plan", "codebase-targeted-test"]
   },
   {
     id: "version-control.manage",
@@ -7718,7 +7810,13 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "quality.analyze",
     pack: "development",
     exposure: "on-demand",
-    tools: ["dead_code_scan", "detect_duplicate_code", "secret_scanner_test", "error_lens_history"]
+    tools: [
+      "dead_code_scan",
+      "detect_duplicate_code",
+      "secret_scanner_test",
+      "error_lens_history",
+      "security-ast-scan"
+    ]
   },
   {
     id: "release.manage",
@@ -7736,7 +7834,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "tools.discover",
     pack: "admin",
     exposure: "direct",
-    tools: ["tool_search", "tool_use", "tool_help", "batch_tool_use"]
+    tools: ["tool_search", "tool_use", "tool_help", "batch_tool_use", "clarify"]
   },
   {
     id: "runtime.admin",
@@ -8119,26 +8217,41 @@ function stripNextStepsFromMessage(msg) {
   strippedNextStepsCache.set(msg, clone);
   return clone;
 }
-function composeRequestMessages(history, tail) {
+function markCacheBoundary(msg) {
+  if (typeof msg.content === "string") return void 0;
+  const blocks = msg.content.slice();
+  const boundary = blocks[blocks.length - 1];
+  if (!boundary || boundary.type !== "text" && boundary.type !== "tool_result") return void 0;
+  blocks[blocks.length - 1] = { ...boundary, cache_control: { type: "ephemeral" } };
+  return { ...msg, content: blocks };
+}
+function composeRequestMessages(history, tail, previous) {
   if (history.length === 0) return null;
   const out = history.slice();
   const lastIdx = out.length - 1;
   const last = out[lastIdx];
+  if (previous && previous.index < lastIdx && history[previous.index] === previous.message) {
+    const marked2 = markCacheBoundary(previous.message);
+    if (marked2) out[previous.index] = marked2;
+  }
   const blocks = typeof last.content === "string" ? [{ type: "text", text: last.content }] : last.content.slice();
-  const boundary = blocks[blocks.length - 1];
-  if (boundary && (boundary.type === "text" || boundary.type === "tool_result")) {
-    blocks[blocks.length - 1] = { ...boundary, cache_control: { type: "ephemeral" } };
+  const tailBlock = blocks[blocks.length - 1];
+  const marked = tailBlock && (tailBlock.type === "text" || tailBlock.type === "tool_result");
+  if (marked) {
+    blocks[blocks.length - 1] = { ...tailBlock, cache_control: { type: "ephemeral" } };
   }
+  const boundary = marked ? { message: last, index: lastIdx } : void 0;
   if (tail.length === 0 || last.role !== "user") {
     out[lastIdx] = { ...last, content: blocks };
     if (tail.length > 0) out.push({ role: "user", content: [LIVE_CONTEXT_HEADER, ...tail] });
-    return out;
+    return { messages: out, boundary };
   }
   out[lastIdx] = { ...last, content: [...blocks, LIVE_CONTEXT_HEADER, ...tail] };
-  return out;
+  return { messages: out, boundary };
 }
 function createAgentResponseHandler(a) {
   const stabilizedPromptEpochs = /* @__PURE__ */ new WeakSet();
+  let previousBoundary;
   function stabilizePromptEpoch() {
     const prompt = a.ctx.systemPrompt;
     if (stabilizedPromptEpochs.has(prompt)) return;
@@ -8161,7 +8274,7 @@ function createAgentResponseHandler(a) {
           ...repaired.report
         });
         a.logger.warn(
-          `Repaired context tool adjacency: removed ${repaired.report.removedToolUses.length} tool_use block(s), ${repaired.report.removedToolResults.length} tool_result block(s), ${repaired.report.removedMessages} empty message(s)`
+          `Repaired context tool adjacency: removed ${repaired.report.removedToolUses.length} tool_use block(s), ${repaired.report.removedToolResults.length} tool_result block(s), ${repaired.report.removedMessages} empty message(s)` + formatAdjacencyRepairIds(repaired.report.removedToolUses, repaired.report.removedToolResults)
         );
       }
     }
@@ -8179,7 +8292,9 @@ function createAgentResponseHandler(a) {
       ...memoryEvidence
     ].filter((block) => block !== void 0);
     const requestHistory = stripDeliveredNextSteps(a.ctx.messages);
-    const composedMessages = composeRequestMessages(requestHistory, liveContextTail);
+    const composed = composeRequestMessages(requestHistory, liveContextTail, previousBoundary);
+    if (composed) previousBoundary = composed.boundary;
+    const composedMessages = composed?.messages ?? null;
     const system = composedMessages ? stableSystem : liveContextTail.length > 0 ? [...stableSystem, ...liveContextTail] : stableSystem;
     await a.ctx.waitForModelTransition();
     const provider = a.ctx.provider;
@@ -8279,6 +8394,10 @@ function createAgentResponseHandler(a) {
   }
   return { buildAndRunRequestPipeline, processResponse };
 }
+function formatAdjacencyRepairIds(toolUses, toolResults) {
+  const ids = [.../* @__PURE__ */ new Set([...toolUses, ...toolResults])].slice(0, 8);
+  return ids.length > 0 ? `; affected tool ids: ${ids.join(", ")}${toolUses.length + toolResults.length > ids.length ? ", \u2026" : ""}` : "";
+}
 
 // src/utils/sage-output-block.ts
 var SAGE_INJECTOR_HEADINGS = /* @__PURE__ */ new Set([
@@ -8850,7 +8969,7 @@ var Agent = class {
     this.maxIterations = init.maxIterations ?? DEFAULT_MAX_ITERATIONS;
     this.executionStrategy = init.executionStrategy ?? "smart";
     this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
-    this.autoExtendLimit = init.autoExtendLimit ?? true;
+    this.autoExtendLimit = init.autoExtendLimit ?? false;
     this.loopDetection = resolveLoopDetection(init.loopDetection);
     this.autonomousContinue = init.autonomousContinue ?? false;
     this.refreshSystemPrompt = init.refreshSystemPrompt ?? false;
@@ -9217,9 +9336,6 @@ function resolveContinuation(input) {
   return { source: "open", text, label: "\u25B6 Continue \u2192 (no pending task \u2014 choosing next step)" };
 }
 
-// src/core/fallback-model.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
-
 // src/core/model-availability-calendar.ts
 function logicalCalendarTarget(providerId, model) {
   if (providerId !== "omniroute") return { providerId, model };
@@ -9326,6 +9442,12 @@ function normalizeModelRef(ref, defaultProvider) {
 function hasText(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
+function asRefList(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function asProfileName(value) {
+  return hasText(value) ? value : void 0;
+}
 function providerHasKey(entry) {
   if (!entry) return false;
   if (hasText(entry.apiKey)) return true;
@@ -9336,7 +9458,7 @@ function providerHasKey(entry) {
 }
 function visibleProviderModels(config, providerId, providerModels) {
   const entry = config.providers?.[providerId];
-  return entry?.models !== void 0 ? [...entry.models] : providerModels;
+  return Array.isArray(entry?.models) ? [...entry.models] : providerModels;
 }
 function buildProfiles(config) {
   const entries = /* @__PURE__ */ new Map();
@@ -9373,13 +9495,34 @@ var FallbackProfileManager = class {
   listProfiles() {
     return Object.freeze([...this.profiles.keys()]);
   }
+  /**
+   * The profile the session has selected (`config.fallbackProfile`, set by
+   * `/fallback profile use <name>`), or undefined when none is selected or the
+   * name no longer resolves to a defined profile.
+   *
+   * Consulted by every resolution entry point when the caller does not name a
+   * profile itself. Without this the leader — which passes no profile — could
+   * never use a named profile at all: `config.fallbackProfiles` was reachable
+   * only by copying a chain into `fallbackModels`.
+   */
+  activeProfileName() {
+    const name = asProfileName(this.config.fallbackProfile);
+    return name && this.profiles.has(name) ? name : void 0;
+  }
   // ── Resolution ─────────────────────────────────────────────────────────
   /**
    * Resolve a named fallback profile to a validated, provider-filtered chain.
    *
-   * Returns an empty chain when:
-   * - The profile doesn't exist.
-   * - Every entry's provider is missing, has no key, or has no matching model.
+   * Returns an empty chain when the profile doesn't exist, or when every entry
+   * is excluded, quarantined, or blacked out.
+   *
+   * Filtering is intentionally identical to {@link resolveRefs} (the explicit
+   * `fallbackModels` path): the self-exclusion, the runtime status tracker,
+   * and the availability calendar — nothing else. Anything a named profile
+   * drops, an explicit chain drops too, and vice versa. Profiles used to apply
+   * two extra filters (provider "usability" and the `providers[].models`
+   * snapshot) that the explicit path did not, which silently rerouted roles
+   * pinned to a profile onto a different model than the one configured.
    *
    * @param name - Profile name from config.fallbackProfiles.
    * @param defaultProvider - Used when an entry has no explicit provider.
@@ -9400,13 +9543,9 @@ var FallbackProfileManager = class {
       if (seen.has(key)) continue;
       seen.add(key);
       if (excludeKey && key === excludeKey) continue;
-      const health = this.checkProvider(providerId);
-      if (!health.usable) continue;
       if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
       if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
         continue;
-      const allowedModels = this.config.providers?.[providerId]?.models;
-      if (allowedModels && !allowedModels.includes(parsed.model)) continue;
       resolved.push({
         providerId,
         model: parsed.model,
@@ -9424,12 +9563,14 @@ var FallbackProfileManager = class {
   resolveEffective(opts = {}) {
     const bridge = this.resolveBridge(opts.exclude);
     let selected = FREEZER_EMPTY;
-    if (opts.fallbackModels && opts.fallbackModels.length > 0) {
-      const resolved = this.resolveRefs(opts.fallbackModels, opts.exclude);
+    const explicitRefs = asRefList(opts.fallbackModels);
+    const profileName = asProfileName(opts.fallbackProfile) ?? this.activeProfileName();
+    if (explicitRefs && explicitRefs.length > 0) {
+      const resolved = this.resolveRefs(explicitRefs, opts.exclude);
       if (resolved.length > 0) selected = resolved;
     }
-    if (selected.length === 0 && opts.fallbackProfile) {
-      const resolved = this.resolve(opts.fallbackProfile, { exclude: opts.exclude });
+    if (selected.length === 0 && profileName) {
+      const resolved = this.resolve(profileName, { exclude: opts.exclude });
       if (resolved.length > 0) selected = resolved;
     }
     if (selected.length === 0 && opts.fallbackAuto !== false) {
@@ -9505,13 +9646,14 @@ var FallbackProfileManager = class {
     };
     const configFallbackAuto = this.config.fallbackAuto;
     const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
-    const explicitRefs = opts.fallbackModels ?? this.config.fallbackModels;
+    const explicitRefs = asRefList(opts.fallbackModels) ?? asRefList(this.config.fallbackModels);
+    const profileName = asProfileName(opts.fallbackProfile) ?? this.activeProfileName();
     const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && this.resolveRefs(explicitRefs, current).length > 0;
-    const profileUsable = opts.fallbackProfile !== void 0 && this.hasProfile(opts.fallbackProfile) && this.resolve(opts.fallbackProfile, { exclude: current }).length > 0;
+    const profileUsable = profileName !== void 0 && this.hasProfile(profileName) && this.resolve(profileName, { exclude: current }).length > 0;
     const fromExplicitSource = explicitUsable || profileUsable;
-    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : opts.fallbackProfile ? this.resolve(opts.fallbackProfile, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
+    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : profileName ? this.resolve(profileName, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
       fallbackModels: explicitRefs,
-      fallbackProfile: opts.fallbackProfile,
+      fallbackProfile: profileName,
       fallbackAuto: effectiveFallbackAuto,
       exclude: current
     });
@@ -9528,7 +9670,7 @@ var FallbackProfileManager = class {
         });
       }
       candidates.push(...selectedChain);
-      if (!fromExplicitSource && effectiveFallbackAuto && opts.fallbackProfile !== "default") {
+      if (!fromExplicitSource && effectiveFallbackAuto && profileName !== "default") {
         candidates.push(...this.resolve("default", { exclude: current }));
       }
       if (!fromExplicitSource && effectiveFallbackAuto) {
@@ -9606,7 +9748,7 @@ var FallbackProfileManager = class {
     const leaderModel = this.config.model;
     const providers = this.config.providers ?? {};
     const favoriteSet = new Set(
-      (this.config.favoriteModels ?? []).map((ref) => {
+      (asRefList(this.config.favoriteModels) ?? []).map((ref) => {
         const p = parseModelRef(ref);
         return `${p.provider ?? leaderProvider}/${p.model}`;
       })
@@ -9681,7 +9823,206 @@ function dedupeChain(entries, current) {
   );
 }
 
+// src/core/fallback-doctor.ts
+function diagnoseFallbackConfig(config, tracker, opts) {
+  const mgr = new FallbackProfileManager(config, { statusTracker: tracker });
+  const primary = { providerId: config.provider, model: config.model };
+  const activeProfile = mgr.activeProfileName();
+  const explicitChain = Object.freeze([...config.fallbackModels ?? []]);
+  const effectiveCandidates = mgr.resolveCandidates(primary, {
+    fallbackProfile: activeProfile
+  });
+  const effectiveOrder = Object.freeze(
+    effectiveCandidates.map((c) => `${c.providerId}/${c.model}`)
+  );
+  const autoEnabled = config.fallbackAuto !== false;
+  const warnings = [];
+  const providersInChain = /* @__PURE__ */ new Set();
+  for (const entry of effectiveCandidates) {
+    providersInChain.add(entry.providerId);
+  }
+  if (effectiveCandidates.length === 0) {
+    warnings.push({
+      code: "EMPTY_CHAIN",
+      severity: "critical",
+      message: "The effective fallback chain is empty. Any rate limit or outage on the primary model will immediately fail without recovery.",
+      recommendation: "Add fallback models using /fallback add <provider/model> or enable smart defaults with /fallback auto on."
+    });
+  }
+  if (effectiveCandidates.length > 0) {
+    const onlyPrimaryProvider = providersInChain.size === 1 && providersInChain.has(primary.providerId);
+    if (onlyPrimaryProvider) {
+      warnings.push({
+        code: "SIBLING_QUARANTINE_RISK",
+        severity: "warning",
+        message: `All fallback models belong to the same provider ("${primary.providerId}"). An account-level quota or token exhaustion will quarantine all sibling models at once.`,
+        recommendation: "Add at least one cross-provider model (e.g. OpenAI, Anthropic, or Google) to your fallback profile."
+      });
+    }
+  }
+  for (const entry of effectiveCandidates) {
+    const health = mgr.checkProvider(entry.providerId);
+    if (!health.usable) {
+      warnings.push({
+        code: "PROVIDER_UNUSABLE",
+        severity: "critical",
+        target: `${entry.providerId}/${entry.model}`,
+        message: `Provider "${entry.providerId}" is missing an API key or baseUrl in configuration.`,
+        recommendation: `Configure API credentials for "${entry.providerId}" or remove it from the fallback chain.`
+      });
+    }
+    if (tracker && !tracker.isAvailable(entry.providerId, entry.model)) {
+      const status2 = tracker.getStatus(entry.providerId, entry.model);
+      const remainingMs = status2?.stateExpiresAt ? Math.max(0, status2.stateExpiresAt - Date.now()) : 0;
+      const remainingSec = Math.round(remainingMs / 1e3);
+      warnings.push({
+        code: "MODEL_QUARANTINED",
+        severity: "warning",
+        target: `${entry.providerId}/${entry.model}`,
+        message: `Model is currently in quarantine (waiting room) due to ${status2?.lastErrorKind ?? "failures"}.${remainingSec > 0 ? ` Resets in ${remainingSec}s.` : ""}`,
+        recommendation: "Model will be automatically re-admitted once cooldown/reset expires."
+      });
+    }
+    const cal = evaluateModelCalendar(
+      config.modelAvailabilitySchedule,
+      entry.providerId,
+      entry.model
+    );
+    if (!cal.allowed) {
+      warnings.push({
+        code: "CALENDAR_BLOCKED",
+        severity: "warning",
+        target: `${entry.providerId}/${entry.model}`,
+        message: `Model is blocked by the model availability calendar (${cal.rule?.label ?? "schedule restriction"}).`
+      });
+    }
+    if (opts?.modelContextLimitMap) {
+      const primaryLimit = opts.modelContextLimitMap[`${primary.providerId}/${primary.model}`] ?? opts.modelContextLimitMap[primary.model];
+      const entryLimit = opts.modelContextLimitMap[`${entry.providerId}/${entry.model}`] ?? opts.modelContextLimitMap[entry.model];
+      if (typeof primaryLimit === "number" && typeof entryLimit === "number" && entryLimit > 0 && primaryLimit > 0 && entryLimit < primaryLimit) {
+        warnings.push({
+          code: "CONTEXT_WINDOW_WARNING",
+          severity: "warning",
+          target: `${entry.providerId}/${entry.model}`,
+          message: `Context window downgrade: primary model has ${primaryLimit.toLocaleString()} tokens capacity, but fallback candidate has only ${entryLimit.toLocaleString()} tokens. Long sessions will fail failover or require aggressive compaction.`,
+          recommendation: `Ensure fallback models have equal or greater context capacity (>= ${primaryLimit.toLocaleString()} tokens) or keep sessions below ${entryLimit.toLocaleString()} tokens.`
+        });
+      }
+    }
+  }
+  const uniqueProviders = Object.freeze([...providersInChain]);
+  const crossProviderCount = uniqueProviders.filter((p) => p !== primary.providerId).length;
+  const hasCritical = warnings.some((w) => w.severity === "critical");
+  const hasWarning = warnings.some((w) => w.severity === "warning");
+  const status = hasCritical ? "critical" : hasWarning ? "warning" : "healthy";
+  return Object.freeze({
+    primary: Object.freeze(primary),
+    activeProfile,
+    explicitChain,
+    effectiveOrder,
+    autoEnabled,
+    status,
+    warnings: Object.freeze(warnings),
+    crossProviderCount,
+    uniqueProviders
+  });
+}
+function simulateFallbackFailover(config, opts = {}) {
+  const errorKind = opts.errorKind ?? "rate_limit";
+  const isEligible = isFallbackWorthy(errorKind);
+  const primary = { providerId: config.provider, model: config.model };
+  if (!isEligible) {
+    return Object.freeze({
+      triggeringError: errorKind,
+      isFallbackEligible: false,
+      primary: Object.freeze(primary),
+      steps: Object.freeze([]),
+      finalTarget: null,
+      summary: `Error kind "${errorKind}" is not fallback-worthy (request-shaped error, e.g. context_overflow/auth). The agent loop will not attempt fallback.`
+    });
+  }
+  const mgr = new FallbackProfileManager(config, { statusTracker: opts.statusTracker });
+  const candidates = mgr.resolveCandidates(primary);
+  const steps = [];
+  let finalTarget = null;
+  for (let i = 0; i < candidates.length; i++) {
+    const entry = candidates[i];
+    const key = `${entry.providerId}/${entry.model}`;
+    const providerSwitched = entry.providerId !== primary.providerId;
+    const cal = evaluateModelCalendar(
+      config.modelAvailabilitySchedule,
+      entry.providerId,
+      entry.model
+    );
+    if (!cal.allowed) {
+      steps.push({
+        index: i + 1,
+        providerId: entry.providerId,
+        model: entry.model,
+        skipped: true,
+        reason: `Blocked by model availability calendar (${cal.rule?.label ?? "schedule"})`,
+        providerSwitched
+      });
+      continue;
+    }
+    if (opts.statusTracker && !opts.statusTracker.isAvailable(entry.providerId, entry.model)) {
+      steps.push({
+        index: i + 1,
+        providerId: entry.providerId,
+        model: entry.model,
+        skipped: true,
+        reason: "Quarantined in status tracker waiting room",
+        providerSwitched
+      });
+      continue;
+    }
+    const contextLimit = opts.modelContextLimitMap?.[key];
+    if (typeof opts.currentTokens === "number" && opts.currentTokens > 0 && typeof contextLimit === "number" && contextLimit > 0 && opts.currentTokens > contextLimit) {
+      steps.push({
+        index: i + 1,
+        providerId: entry.providerId,
+        model: entry.model,
+        skipped: true,
+        reason: `Context pre-filter: request tokens (${opts.currentTokens}) exceeds model window (${contextLimit})`,
+        providerSwitched
+      });
+      continue;
+    }
+    const health = mgr.checkProvider(entry.providerId);
+    if (!health.usable) {
+      steps.push({
+        index: i + 1,
+        providerId: entry.providerId,
+        model: entry.model,
+        skipped: true,
+        reason: `Cannot construct provider "${entry.providerId}" (missing API key/endpoint)`,
+        providerSwitched
+      });
+      continue;
+    }
+    steps.push({
+      index: i + 1,
+      providerId: entry.providerId,
+      model: entry.model,
+      skipped: false,
+      providerSwitched
+    });
+    finalTarget = { providerId: entry.providerId, model: entry.model };
+    break;
+  }
+  const summary = finalTarget ? `Failover succeeded: will rotate from ${primary.providerId}/${primary.model} to ${finalTarget.providerId}/${finalTarget.model}.` : "Failover failed: no usable fallback candidate could be reached.";
+  return Object.freeze({
+    triggeringError: errorKind,
+    isFallbackEligible: true,
+    primary: Object.freeze(primary),
+    steps: Object.freeze(steps),
+    finalTarget: finalTarget ? Object.freeze(finalTarget) : null,
+    summary
+  });
+}
+
 // src/core/fallback-model.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
 function fallbackProfileChain(config, profileName) {
   if (!profileName) return [];
   const mgr = new FallbackProfileManager(config);
@@ -9717,9 +10058,15 @@ function effectiveFallbackChain(config) {
   const mgr = new FallbackProfileManager(config);
   return mgr.resolveEffective({
     fallbackModels: config.fallbackModels,
+    fallbackProfile: config.fallbackProfile,
     fallbackAuto: config.fallbackAuto
   }).map((e) => `${e.providerId}/${e.model}`);
 }
+function runtimeFallbackChain(config) {
+  const mgr = new FallbackProfileManager(config);
+  const current = primaryTarget(config);
+  return mgr.resolveCandidates(current, {}).map((e) => `${e.providerId}/${e.model}`);
+}
 var DEFAULT_PRIMARY_COOLDOWN_MS = 6e4;
 var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
 var DEFAULT_PRIMARY_RECOVERY_SUCCESSES = 2;
@@ -9759,7 +10106,11 @@ function createFallbackModelExtension(deps) {
   let blockedPrimary;
   let primaryBlockedUntil = 0;
   const now = () => deps.now?.() ?? Date.now();
-  const cooldownBase = () => Math.max(0, deps.primaryCooldownMs ?? DEFAULT_PRIMARY_COOLDOWN_MS);
+  const liveStickiness = () => deps.getConfig().fallbackStickiness;
+  const cooldownBase = () => Math.max(
+    0,
+    deps.primaryCooldownMs ?? liveStickiness()?.primaryProbeInterval ?? DEFAULT_PRIMARY_COOLDOWN_MS
+  );
   const cooldownMax = () => Math.max(cooldownBase(), deps.primaryCooldownMaxMs ?? DEFAULT_PRIMARY_COOLDOWN_MAX_MS);
   const selectedPrimary = (cfg) => deps.getPrimaryTarget?.() ?? primaryTarget(cfg);
   const primaryInCooldown = (cfg) => sameTarget(blockedPrimary, selectedPrimary(cfg)) && now() < primaryBlockedUntil;
@@ -9778,7 +10129,7 @@ function createFallbackModelExtension(deps) {
     primaryBlockedUntil = now() + Math.min(cooldownMax(), base * multiplier);
   };
   const recoveryTarget = () => Math.max(1, deps.primaryRecoverySuccesses ?? DEFAULT_PRIMARY_RECOVERY_SUCCESSES);
-  const stickyTarget = () => Math.max(0, deps.stickyFallbackTurns ?? 0);
+  const stickyTarget = () => Math.max(0, deps.stickyFallbackTurns ?? liveStickiness()?.stickyFallbackTurns ?? 0);
   const inStickyWindow = () => stickyTurnsElapsed < stickyTarget();
   const onPrimarySuccess = (cfg) => {
     if (!sameTarget(blockedPrimary, selectedPrimary(cfg))) return;
@@ -9806,7 +10157,25 @@ function createFallbackModelExtension(deps) {
       if (!evaluateModelCalendar(cfg.modelAvailabilitySchedule, primary.providerId, primary.model).allowed || deps.statusTracker && !deps.statusTracker.isAvailable(primary.providerId, primary.model))
         return;
       try {
-        ctx.provider = await deps.buildProvider(primary.providerId, primary.model);
+        const primaryProvider = await deps.buildProvider(primary.providerId, primary.model);
+        const currentTokens = ctx.lastRequestTokens;
+        const maxContext = maxContextOf(primaryProvider);
+        if (maxContext > 0 && typeof currentTokens === "number" && currentTokens > maxContext) {
+          deps.events.emit("provider.primary_probe_context_blocked", {
+            sessionId: resolveEventSessionId(ctx),
+            providerId: primary.providerId,
+            model: primary.model,
+            currentTokens,
+            maxContext,
+            timestamp: now()
+          });
+          deps.logger?.warn(
+            `fallback-model: deferring primary probe "${primary.providerId}/${primary.model}" \u2014 context (${currentTokens}) exceeds target window (${maxContext})`
+          );
+          markPrimaryFailure(cfg);
+          return;
+        }
+        ctx.provider = primaryProvider;
         ctx.model = primary.model;
         await deps.onModelSwitch?.(primary.providerId, primary.model);
         primaryBlockedUntil = 0;
@@ -9920,9 +10289,10 @@ function createFallbackModelExtension(deps) {
         const status = shouldFallback(firstErr_);
         if (status === null) throw firstErr_;
         let gateRequestId;
-        if (deps.fallbackGate && usableChain.length > 0) {
+        const configuredGateSeconds = cfg.fallbackGateSeconds ?? deps.fallbackGateSeconds;
+        if (configuredGateSeconds !== 0 && deps.fallbackGate && usableChain.length > 0) {
           gateRequestId = randomUUID6();
-          const autoSwitchSeconds = Math.max(1, deps.fallbackGateSeconds ?? 7);
+          const autoSwitchSeconds = Math.max(1, configuredGateSeconds ?? 7);
           const gateCandidates = usableChain.map((e) => ({
             providerId: e.providerId,
             model: e.model
@@ -10749,6 +11119,7 @@ function shellGuidanceBlock(shell, detail) {
 var MAX_ENVIRONMENT_CACHE_ENTRIES = 16;
 async function buildEnvironment(ctx, env) {
   const modelCapabilities = env.modelCapabilities;
+  const today = env.todayIso ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const cacheKey = [
     ctx.projectRoot,
     ctx.provider ?? "",
@@ -10757,7 +11128,9 @@ async function buildEnvironment(ctx, env) {
     modelCapabilities?.supportsTools ? 1 : 0,
     modelCapabilities?.supportsVision ? 1 : 0,
     modelCapabilities?.supportsReasoning ? 1 : 0,
-    env.skillCache ?? ""
+    env.skillCache ?? "",
+    today,
+    env.modeId ?? ""
   ].join("\0");
   const cached = env.envCacheByRoot.get(cacheKey);
   if (cached) {
@@ -10765,7 +11138,6 @@ async function buildEnvironment(ctx, env) {
     env.envCacheByRoot.set(cacheKey, cached);
     return cached;
   }
-  const today = env.todayIso ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const platform2 = `${os3.platform()} ${os3.release()}`;
   const effShell = effectiveShell(os3.platform(), process.env["WRONGSTACK_SHELL"]);
   const shell = effShell === "posix" ? process.env.SHELL ?? process.env.ComSpec ?? "unknown" : SHELL_DISPLAY[effShell];
@@ -11611,7 +11983,9 @@ ${peers}
     const tpl = tplCtx ?? this.templateContext(ctx);
     const section = (key, vars = {}) => instructionSection(instructions, key, vars, tpl);
     const tier = this.tier;
-    if (this._toolsUsageCache?.toolsRef === tools && this._toolsUsageCache?.tier === tier) {
+    const subagent = ctx.subagent === true;
+    const maxContextTokens = this.modelCapabilities()?.maxContextTokens ?? 0;
+    if (this._toolsUsageCache?.toolsRef === tools && this._toolsUsageCache?.tier === tier && this._toolsUsageCache?.subagent === subagent && this._toolsUsageCache?.maxContextTokens === maxContextTokens) {
       return this._toolsUsageCache.text;
     }
     const byCat = /* @__PURE__ */ new Map();
@@ -11738,7 +12112,7 @@ ${hint.trim()}`);
       }
     }
     const text = lines.join("\n");
-    this._toolsUsageCache = { toolsRef: tools, tier, text };
+    this._toolsUsageCache = { toolsRef: tools, tier, subagent, maxContextTokens, text };
     return text;
   }
   renderOnlineAgents(agents) {
@@ -11801,6 +12175,7 @@ export {
   createDefaultPipelines,
   createFallbackModelExtension,
   detectContinueIntent,
+  diagnoseFallbackConfig,
   effectiveFallbackChain,
   fallbackProfileChain,
   formatModelRef,
@@ -11816,8 +12191,10 @@ export {
   renderNextStepsBlock,
   resolveContinuation,
   runProviderWithRetry,
+  runtimeFallbackChain,
   setBtwNote,
   setQueuedMessagesSnapshot,
+  simulateFallbackFailover,
   smartDefaultFallbackChain,
   wrapAsState,
   writePendingNextSteps