@wrongstack/core 0.306.4 → 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";
@@ -5661,406 +5663,820 @@ 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;
-  }
-  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;
+    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 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 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;
   }
-  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;
+  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;
       }
-      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;
     }
+    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;
   }
-  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);
+  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;
     }
-    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
-    result += '"';
-  } else if (prevSig === ":") {
-    result += "null";
+    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;
   }
-  for (let k = stack.length - 1; k >= 0; k--) {
-    result += stack[k] === "{" ? "}" : "]";
+  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 };
   }
-  if (!tryParse(result).ok) {
-    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
-    if (tryParse(patched).ok) result = patched;
+  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 result;
+  return {
+    refreshProviderContextLimit,
+    compactContextIfNeeded,
+    stashRequestTokens,
+    refreshContextRequestTokenStash,
+    buildRequestWithPreflightCompaction,
+    emitContextPct,
+    currentMaxContext,
+    calibrationKey,
+    get lastPreFlightMsgCount() {
+      return _lastPreFlightMsgCount;
+    }
+  };
 }
-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;
+
+// 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 tryParse(s) {
-  try {
-    return { ok: true, value: JSON.parse(s) };
-  } catch {
-    return { ok: false };
+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;
 }
-
-// src/core/streaming-response-builder.ts
-var STREAM_DRAIN_TIMEOUT_MS = 500;
-function buildResponse(state) {
-  const content = [];
-  for (const b of state.blockOrder) {
-    if (b.kind === "text") {
-      const txt = state.textBuffers[b.idx] ?? "";
-      if (txt) content.push({ type: "text", text: txt });
-    } else if (b.kind === "thinking") {
-      const t2 = state.thinking[b.idx];
-      if (!t2) continue;
-      if (!t2.textBuf && !t2.signature) continue;
-      const block = { type: "thinking", thinking: t2.textBuf };
-      if (t2.signature) block.signature = t2.signature;
-      if (t2.providerMeta && Object.keys(t2.providerMeta).length > 0) {
-        block.providerMeta = t2.providerMeta;
+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);
+}
+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;
+      }
+      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 (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.`
+        );
       }
-      content.push(block);
     } else {
-      const tb = state.tools.get(b.id);
-      if (tb) {
-        const block = {
-          type: "tool_use",
-          id: b.id,
-          name: tb.name,
-          input: tb.input ?? {}
-        };
-        if (tb.providerMeta && Object.keys(tb.providerMeta).length > 0) {
-          block.providerMeta = tb.providerMeta;
-        }
-        content.push(block);
-      }
+      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 (content.length === 0) content.push({ type: "text", text: "" });
-  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
-}
-function createStreamingState(model) {
-  return {
-    model,
-    stopReason: "end_turn",
-    usage: { input: 0, output: 0 },
-    textBuffers: [],
-    currentTextIndex: -1,
-    tools: /* @__PURE__ */ new Map(),
-    thinking: [],
-    currentThinkingIndex: -1,
-    blockOrder: []
-  };
+};
+
+// 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";
+    }
+  }
+  return lastDirective;
 }
-function handleMessageStart(state, model) {
-  state.model = model;
+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;
 }
-function handleContentBlockStart(state, ev) {
-  const kind = ev.kind ?? "text";
-  if (kind === "text") {
-    state.currentTextIndex = state.textBuffers.length;
-    state.textBuffers.push("");
-    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
-  } else if (kind === "tool_use") {
-    const id = ev.id ?? randomUUID4();
-    state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
-    state.blockOrder.push({ kind: "tool", id });
-    state.currentTextIndex = -1;
-  } else if (kind === "thinking") {
-    state.currentThinkingIndex = state.thinking.length;
-    state.thinking.push({
-      textBuf: "",
-      ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+
+// 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
     });
-    state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
-    state.currentTextIndex = -1;
-  }
-}
-function handleContentBlockStop(state, ev) {
-  void state;
-  void ev;
+    if (autoExtend) {
+      setImmediate(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolve10(100);
+        }
+      });
+    }
+  });
 }
-function handleTextDelta(state, text) {
-  if (state.currentTextIndex === -1) {
-    state.currentTextIndex = state.textBuffers.length;
-    state.textBuffers.push("");
-    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+
+// 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;
   }
-  state.textBuffers[state.currentTextIndex] = (state.textBuffers[state.currentTextIndex] ?? "") + text;
-}
-function handleToolUseStart(state, ev) {
-  state.currentTextIndex = -1;
-  state.tools.set(ev.id, { name: ev.name, partial: "" });
-  state.blockOrder.push({ kind: "tool", id: ev.id });
+  if (cleaned.length === 0) {
+    clearPendingNextSteps(ctx);
+    return;
+  }
+  ctx.meta[SLOT_KEY] = cleaned;
 }
-function handleToolUseInputDelta(state, ev) {
-  const t2 = state.tools.get(ev.id);
-  if (t2) t2.partial += ev.partial;
+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 safeJsonOrRaw(s) {
-  if (!s) return {};
-  try {
-    return JSON.parse(s);
-  } catch {
-    const repaired = completePartialObject(s);
-    try {
-      return JSON.parse(repaired);
-    } catch {
-      return { _raw: repaired };
-    }
-  }
+function clearPendingNextSteps(ctx) {
+  delete ctx.meta[SLOT_KEY];
 }
-function handleToolUseStop(state, ev) {
-  const t2 = state.tools.get(ev.id);
-  if (t2) {
-    t2.input = ev.input !== void 0 ? ev.input : safeJsonOrRaw(t2.partial);
-    if (ev.providerMeta) t2.providerMeta = ev.providerMeta;
-  }
-  state.currentTextIndex = -1;
+function hasNextStepsTag(text) {
+  return NEXT_STEPS_TAG_RE.test(text);
 }
-function handleThinkingStart(state, ev) {
-  state.currentThinkingIndex = state.thinking.length;
-  state.thinking.push({
-    textBuf: "",
-    ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+function renderNextStepsBlock(steps) {
+  const lines = steps.map((step, i) => {
+    const auto = i === 0 && step.auto === true ? ' auto="true"' : "";
+    return `${i + 1}. ${step.text}${auto}`;
   });
-  state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
-  state.currentTextIndex = -1;
+  return `<nextsteps>
+${lines.join("\n")}
+</nextsteps>`;
 }
-function handleThinkingDelta(state, text) {
-  if (state.currentThinkingIndex === -1) {
-    handleThinkingStart(state, {});
-  }
-  const t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.textBuf += text;
+function endsTurn(stopReason) {
+  return stopReason !== "tool_use" && stopReason !== "tool_call";
 }
-function handleThinkingSignature(state, signature) {
-  if (state.currentThinkingIndex === -1) {
-    handleThinkingStart(state, {});
+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 t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.signature = signature;
-}
-function handleThinkingStop(state) {
-  state.currentThinkingIndex = -1;
+  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 };
 }
-function handleMessageStop(state, ev) {
-  state.stopReason = ev.stopReason ?? "end_turn";
-  state.usage = ev.usage ?? { input: 0, output: 0 };
+
+// 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);
 }
-async function streamProviderToResponse(provider, req, signal, ctx, events, logger) {
-  const state = createStreamingState(req.model);
-  const sessionId = resolveEventSessionId(ctx);
-  logger.debug("Stream started", { providerId: provider.id, model: req.model });
-  const TEXT_BATCH_SIZE = 4;
-  let pendingText = "";
-  let pendingCount = 0;
-  const flushText = () => {
-    if (pendingCount > 0) {
-      events.emit("provider.text_delta", { sessionId, ctx, text: pendingText });
-      pendingText = "";
-      pendingCount = 0;
-    }
-  };
+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 {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+// src/core/streaming-response-builder.ts
+var STREAM_DRAIN_TIMEOUT_MS = 500;
+function buildResponse(state) {
+  const content = [];
+  for (const b of state.blockOrder) {
+    if (b.kind === "text") {
+      const txt = state.textBuffers[b.idx] ?? "";
+      if (txt) content.push({ type: "text", text: txt });
+    } else if (b.kind === "thinking") {
+      const t2 = state.thinking[b.idx];
+      if (!t2) continue;
+      if (!t2.textBuf && !t2.signature) continue;
+      const block = { type: "thinking", thinking: t2.textBuf };
+      if (t2.signature) block.signature = t2.signature;
+      if (t2.providerMeta && Object.keys(t2.providerMeta).length > 0) {
+        block.providerMeta = t2.providerMeta;
+      }
+      content.push(block);
+    } else {
+      const tb = state.tools.get(b.id);
+      if (tb) {
+        const block = {
+          type: "tool_use",
+          id: b.id,
+          name: tb.name,
+          input: tb.input ?? {}
+        };
+        if (tb.providerMeta && Object.keys(tb.providerMeta).length > 0) {
+          block.providerMeta = tb.providerMeta;
+        }
+        content.push(block);
+      }
+    }
+  }
+  if (content.length === 0) content.push({ type: "text", text: "" });
+  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
+}
+function createStreamingState(model) {
+  return {
+    model,
+    stopReason: "end_turn",
+    usage: { input: 0, output: 0 },
+    textBuffers: [],
+    currentTextIndex: -1,
+    tools: /* @__PURE__ */ new Map(),
+    thinking: [],
+    currentThinkingIndex: -1,
+    blockOrder: []
+  };
+}
+function handleMessageStart(state, model) {
+  state.model = model;
+}
+function handleContentBlockStart(state, ev) {
+  const kind = ev.kind ?? "text";
+  if (kind === "text") {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  } else if (kind === "tool_use") {
+    const id = ev.id ?? randomUUID4();
+    state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
+    state.blockOrder.push({ kind: "tool", id });
+    state.currentTextIndex = -1;
+  } else if (kind === "thinking") {
+    state.currentThinkingIndex = state.thinking.length;
+    state.thinking.push({
+      textBuf: "",
+      ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+    });
+    state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+    state.currentTextIndex = -1;
+  }
+}
+function handleContentBlockStop(state, ev) {
+  void state;
+  void ev;
+}
+function handleTextDelta(state, text) {
+  if (state.currentTextIndex === -1) {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  }
+  state.textBuffers[state.currentTextIndex] = (state.textBuffers[state.currentTextIndex] ?? "") + text;
+}
+function handleToolUseStart(state, ev) {
+  state.currentTextIndex = -1;
+  state.tools.set(ev.id, { name: ev.name, partial: "" });
+  state.blockOrder.push({ kind: "tool", id: ev.id });
+}
+function handleToolUseInputDelta(state, ev) {
+  const t2 = state.tools.get(ev.id);
+  if (t2) t2.partial += ev.partial;
+}
+function safeJsonOrRaw(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    const repaired = completePartialObject(s);
+    try {
+      return JSON.parse(repaired);
+    } catch {
+      return { _raw: repaired };
+    }
+  }
+}
+function handleToolUseStop(state, ev) {
+  const t2 = state.tools.get(ev.id);
+  if (t2) {
+    t2.input = ev.input !== void 0 ? ev.input : safeJsonOrRaw(t2.partial);
+    if (ev.providerMeta) t2.providerMeta = ev.providerMeta;
+  }
+  state.currentTextIndex = -1;
+}
+function handleThinkingStart(state, ev) {
+  state.currentThinkingIndex = state.thinking.length;
+  state.thinking.push({
+    textBuf: "",
+    ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+  });
+  state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+  state.currentTextIndex = -1;
+}
+function handleThinkingDelta(state, text) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.textBuf += text;
+}
+function handleThinkingSignature(state, signature) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.signature = signature;
+}
+function handleThinkingStop(state) {
+  state.currentThinkingIndex = -1;
+}
+function handleMessageStop(state, ev) {
+  state.stopReason = ev.stopReason ?? "end_turn";
+  state.usage = ev.usage ?? { input: 0, output: 0 };
+}
+async function streamProviderToResponse(provider, req, signal, ctx, events, logger) {
+  const state = createStreamingState(req.model);
+  const sessionId = resolveEventSessionId(ctx);
+  logger.debug("Stream started", { providerId: provider.id, model: req.model });
+  const TEXT_BATCH_SIZE = 4;
+  let pendingText = "";
+  let pendingCount = 0;
+  const flushText = () => {
+    if (pendingCount > 0) {
+      events.emit("provider.text_delta", { sessionId, ctx, text: pendingText });
+      pendingText = "";
+      pendingCount = 0;
+    }
+  };
   const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
   try {
     for (; ; ) {
@@ -6529,413 +6945,122 @@ async function runProviderWithRetry(opts) {
           signal.removeEventListener("abort", onAbort);
         };
         const onAbort = () => {
-          if (settled) return;
-          settled = true;
-          cleanup();
-          reject(new Error("aborted"));
-        };
-        const t2 = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          cleanup();
-          resolve10();
-        }, delay2);
-        if (signal.aborted) {
-          onAbort();
-          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);
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(new Error("aborted"));
+        };
+        const t2 = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve10();
+        }, delay2);
+        if (signal.aborted) {
+          onAbort();
+          return;
         }
-      }
+        signal.addEventListener("abort", onAbort);
+      });
+      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;
@@ -7015,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) {
@@ -7130,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(),
@@ -7143,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);
@@ -7151,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) {
@@ -7244,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;
         }
@@ -7267,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,
@@ -7401,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,
@@ -7411,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,
@@ -7611,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",
@@ -7621,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",
@@ -7633,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",
@@ -7770,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",
@@ -7788,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",
@@ -8228,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)
         );
       }
     }
@@ -8348,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([
@@ -8919,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;
@@ -9286,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 };
@@ -9776,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);
@@ -9911,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;
@@ -10025,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
@@ -10854,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 ?? "",
@@ -10862,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) {
@@ -10870,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];
@@ -11716,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();
@@ -11843,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) {
@@ -11906,6 +12175,7 @@ export {
   createDefaultPipelines,
   createFallbackModelExtension,
   detectContinueIntent,
+  diagnoseFallbackConfig,
   effectiveFallbackChain,
   fallbackProfileChain,
   formatModelRef,
@@ -11924,6 +12194,7 @@ export {
   runtimeFallbackChain,
   setBtwNote,
   setQueuedMessagesSnapshot,
+  simulateFallbackFailover,
   smartDefaultFallbackChain,
   wrapAsState,
   writePendingNextSteps