@wrongstack/core 0.306.4 → 0.307.1

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,1281 +5663,1653 @@ 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;
+    if (autoExtend) {
+      setImmediate(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolve10(100);
+        }
+      });
+    }
+  });
+}
+
+// src/core/next-steps-slot.ts
+var SLOT_KEY = "nextsteps.pending";
+var MAX_PENDING_NEXT_STEPS = 4;
+var NEXT_STEPS_TAG_RE = /<nextsteps\b[^>]*>/i;
+function writePendingNextSteps(ctx, steps) {
+  const cleaned = [];
+  for (const step of steps) {
+    const text = typeof step?.text === "string" ? step.text.replace(/\s+/g, " ").trim() : "";
+    if (!text) continue;
+    cleaned.push(step.auto === true && cleaned.length === 0 ? { text, auto: true } : { text });
+    if (cleaned.length >= MAX_PENDING_NEXT_STEPS) break;
+  }
+  if (cleaned.length === 0) {
+    clearPendingNextSteps(ctx);
+    return;
   }
+  ctx.meta[SLOT_KEY] = cleaned;
 }
-function handleContentBlockStop(state, ev) {
-  void state;
-  void ev;
+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 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 clearPendingNextSteps(ctx) {
+  delete ctx.meta[SLOT_KEY];
 }
-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 hasNextStepsTag(text) {
+  return NEXT_STEPS_TAG_RE.test(text);
 }
-function handleToolUseInputDelta(state, ev) {
-  const t2 = state.tools.get(ev.id);
-  if (t2) t2.partial += ev.partial;
+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 safeJsonOrRaw(s) {
-  if (!s) return {};
+function endsTurn(stopReason) {
+  return stopReason !== "tool_use" && stopReason !== "tool_call";
+}
+function maybeAppendPendingNextSteps(ctx, res) {
+  if (ctx.agentId !== "leader") return res;
+  if (!endsTurn(res.stopReason)) return res;
+  if (ctx.signal.aborted) return res;
+  const steps = readPendingNextSteps(ctx);
+  if (!steps) return res;
+  if (hasOpenTodos(ctx.todos)) {
+    clearPendingNextSteps(ctx);
+    return res;
+  }
+  const lastTextIndex = res.content.findLastIndex(isTextBlock);
+  if (lastTextIndex >= 0) {
+    const block = res.content[lastTextIndex];
+    if (block && isTextBlock(block) && hasNextStepsTag(block.text)) {
+      clearPendingNextSteps(ctx);
+      return res;
+    }
+  }
+  const rendered = renderNextStepsBlock(steps);
+  const content = [...res.content];
+  const target = lastTextIndex >= 0 ? content[lastTextIndex] : void 0;
+  if (target && isTextBlock(target)) {
+    const separator = target.text.trim() ? "\n\n" : "";
+    content[lastTextIndex] = { ...target, text: `${target.text}${separator}${rendered}` };
+  } else {
+    content.push({ type: "text", text: rendered });
+  }
+  clearPendingNextSteps(ctx);
+  return { ...res, content };
+}
+
+// src/prompts/prompt-journal.ts
+import * as fs5 from "node:fs/promises";
+import * as path11 from "node:path";
+async function ensureGitignore(projectRoot) {
+  const gitignorePath = path11.join(projectRoot, ".gitignore");
   try {
-    return JSON.parse(s);
-  } catch {
-    const repaired = completePartialObject(s);
+    let content = "";
     try {
-      return JSON.parse(repaired);
+      content = await fs5.readFile(gitignorePath, "utf8");
     } catch {
-      return { _raw: repaired };
+      content = "";
+    }
+    if (!content.includes(".wrongstack") && !content.includes(".wrongstack/")) {
+      const addition = content.endsWith("\n") || content.length === 0 ? ".wrongstack/\n" : "\n.wrongstack/\n";
+      await fs5.writeFile(gitignorePath, content + addition, "utf8");
     }
+  } catch {
   }
 }
-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;
+function sessionFileId(sessionId) {
+  const leaf = sessionId.split(/[\\/]/u).pop();
+  return leaf && leaf.trim().length > 0 ? leaf : "general";
+}
+async function recordPromptJournalEntry(opts) {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString();
+  const dateStr = timestamp.slice(0, 10);
+  const monthStr = dateStr.slice(0, 7);
+  const sessionId = opts.sessionId && opts.sessionId.trim() ? opts.sessionId.trim() : "general";
+  const id = `pmt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  const content = opts.content ?? "";
+  const lines = content.split("\n");
+  const characterCount = content.length;
+  const lineCount = lines.length;
+  const tokenEstimate = Math.ceil(characterCount / 4);
+  const entry = {
+    id,
+    timestamp,
+    sessionId,
+    projectRoot: opts.projectRoot,
+    role: opts.role ?? (opts.category === "system_prompt" ? "system" : "user"),
+    category: opts.category,
+    content,
+    rawContent: opts.rawContent,
+    metadata: {
+      model: opts.model,
+      provider: opts.provider,
+      iterationIndex: opts.iterationIndex,
+      tokenEstimate,
+      characterCount,
+      lineCount,
+      activeTools: opts.activeTools,
+      contextFiles: opts.contextFiles,
+      durationMs: opts.durationMs,
+      decisionReason: opts.decisionReason,
+      tags: opts.tags
+    }
+  };
+  const basePromptsDir = path11.join(opts.projectRoot, ".wrongstack", "prompts");
+  const dayDir = path11.join(basePromptsDir, monthStr, dateStr);
+  try {
+    await fs5.mkdir(dayDir, { recursive: true });
+    await ensureGitignore(opts.projectRoot);
+    const sessionJsonlFile = path11.join(dayDir, `session-${sessionFileId(sessionId)}.jsonl`);
+    await fs5.appendFile(sessionJsonlFile, JSON.stringify(entry) + "\n", "utf8");
+    const sessionMdFile = path11.join(dayDir, `session-${sessionFileId(sessionId)}.md`);
+    const mdSection = formatEntryMarkdown(entry);
+    await fs5.appendFile(sessionMdFile, mdSection, "utf8");
+    const dailySummaryFile = path11.join(dayDir, "daily-summary.md");
+    await updateDailySummary(dailySummaryFile, dateStr, entry);
+    await updateRootCatalog(basePromptsDir, monthStr, dateStr, sessionId, entry);
+  } catch (err) {
+    console.error?.(`Failed to write hierarchical prompt journal: ${err}`);
+  }
+  return entry;
+}
+function formatEntryMarkdown(entry) {
+  const tagList = [
+    `**Category:** \`${entry.category}\``,
+    `**Role:** \`${entry.role}\``,
+    entry.metadata.model ? `**Model:** \`${entry.metadata.model}\`` : null,
+    `**Tokens (est):** ~${entry.metadata.tokenEstimate}`,
+    entry.metadata.iterationIndex !== void 0 ? `**Iteration:** #${entry.metadata.iterationIndex}` : null,
+    `**Session:** \`${entry.sessionId}\``
+  ].filter(Boolean).join(" | ");
+  let md = `
+### \u{1F4DD} [${entry.timestamp}] \`${entry.id}\`
+${tagList}
+
+`;
+  if (entry.metadata.decisionReason) {
+    md += `> **Rationale:** ${entry.metadata.decisionReason}
+
+`;
   }
-  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, {});
+  if (entry.metadata.activeTools && entry.metadata.activeTools.length > 0) {
+    md += `*Active Tools:* \`${entry.metadata.activeTools.join("`, `")}\`
+
+`;
   }
-  const t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.textBuf += text;
-}
-function handleThinkingSignature(state, signature) {
-  if (state.currentThinkingIndex === -1) {
-    handleThinkingStart(state, {});
+  if (entry.rawContent && entry.rawContent !== entry.content) {
+    md += `**Raw Input:**
+\`\`\`text
+${entry.rawContent.trim()}
+\`\`\`
+
+`;
+    md += `**Refined / Injected Prompt:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
+  } else {
+    md += `**Prompt Content:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
   }
-  const t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.signature = signature;
-}
-function handleThinkingStop(state) {
-  state.currentThinkingIndex = -1;
+  md += `---
+`;
+  return md;
 }
-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]();
+async function updateDailySummary(summaryFile, dateStr, entry) {
   try {
-    for (; ; ) {
-      const next = await iter.next();
-      if (next.done) break;
-      const ev = next.value;
-      try {
-        switch (ev.type) {
-          case "message_start":
-            handleMessageStart(state, ev.model);
-            break;
-          case "content_block_start":
-            handleContentBlockStart(state, ev);
-            break;
-          case "content_block_stop":
-            handleContentBlockStop(state, ev);
-            break;
-          case "text_delta":
-            handleTextDelta(state, ev.text);
-            pendingText += ev.text;
-            pendingCount++;
-            if (pendingCount >= TEXT_BATCH_SIZE) flushText();
-            break;
-          case "tool_use_start": {
-            flushText();
-            const idVal = ev.id;
-            const nameVal = ev.name;
-            handleToolUseStart(state, { id: idVal, name: nameVal });
-            const emittedPayload = { sessionId, ctx, id: idVal ?? "unknown", name: nameVal ?? "unknown" };
-            events.emit("provider.tool_use_start", emittedPayload);
-            break;
-          }
-          case "tool_use_input_delta":
-            handleToolUseInputDelta(state, ev);
-            break;
-          case "tool_use_stop": {
-            flushText();
-            const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
-            handleToolUseStop(state, ev);
-            events.emit("provider.tool_use_stop", { sessionId, ctx, id: ev.id, name: stoppedName });
-            break;
-          }
-          case "thinking_start":
-            handleThinkingStart(state, ev);
-            break;
-          case "thinking_delta":
-            flushText();
-            handleThinkingDelta(state, ev.text);
-            events.emit("provider.thinking_delta", { sessionId, ctx, text: ev.text });
-            break;
-          case "thinking_signature":
-            handleThinkingSignature(state, ev.signature);
-            break;
-          case "thinking_stop":
-            handleThinkingStop(state);
-            break;
-          case "message_stop":
-            handleMessageStop(state, ev);
-            break;
-          default: {
-            const unknownEv = ev;
-            logger.warn(`Stream received unknown event type: "${String(unknownEv.type)}"`, {
-              providerId: provider.id,
-              model: req.model,
-              eventType: String(unknownEv.type)
-            });
-            break;
-          }
-        }
-      } catch (handlerErr) {
-        const errMsg = handlerErr instanceof Error ? handlerErr.message : String(handlerErr);
-        const evAny = ev;
-        logger.warn(`Stream handler error for event type "${String(evAny.type)}": ${errMsg}`, {
-          providerId: provider.id,
-          model: req.model,
-          eventType: String(evAny.type),
-          errorMessage: errMsg
-        });
-        flushText();
-        events.emit("provider.stream_error", {
-          sessionId,
-          ctx,
-          eventType: String(evAny.type),
-          msg: errMsg
-        });
-      }
-    }
-  } catch (err) {
-    if (signal.aborted) {
-      state.stopReason = "end_turn";
-      flushText();
-      logger.debug("Stream aborted \u2014 returning partial state", {
-        providerId: provider.id,
-        model: req.model,
-        textBlockCount: state.textBuffers.length,
-        toolBlockCount: state.tools.size,
-        thinkingBlockCount: state.thinking.length
-      });
-      return buildResponse(state);
-    }
-    throw err;
-  } finally {
+    let content = "";
     try {
-      let drainTimer = null;
-      try {
-        const drainPromise = Promise.resolve(iter.return?.()).catch(() => {
-        });
-        await Promise.race([
-          drainPromise,
-          new Promise((resolve10) => {
-            drainTimer = setTimeout(resolve10, STREAM_DRAIN_TIMEOUT_MS);
-          })
-        ]);
-      } finally {
-        if (drainTimer) clearTimeout(drainTimer);
-      }
+      content = await fs5.readFile(summaryFile, "utf8");
     } catch {
+      content = `# \u{1F4C5} Daily Prompt Summary \u2014 ${dateStr}
+
+| Time | ID | Session | Category | Model | Tokens | Rationale |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+`;
     }
+    const time = entry.timestamp.slice(11, 19);
+    const model = entry.metadata.model ?? "-";
+    const reason = entry.metadata.decisionReason ? entry.metadata.decisionReason.slice(0, 40) : "-";
+    const row = `| ${time} | [\`${entry.id}\`](session-${sessionFileId(entry.sessionId)}.md) | \`${entry.sessionId}\` | \`${entry.category}\` | ${model} | ~${entry.metadata.tokenEstimate} | ${reason} |
+`;
+    await fs5.writeFile(summaryFile, content + row, "utf8");
+  } catch {
   }
-  flushText();
-  logger.debug("Stream completed", {
-    providerId: provider.id,
-    model: req.model,
-    stopReason: state.stopReason,
-    textBlockCount: state.textBuffers.length,
-    toolBlockCount: state.tools.size,
-    thinkingBlockCount: state.thinking.length,
-    usageInput: state.usage.input,
-    usageOutput: state.usage.output
-  });
-  return buildResponse(state);
 }
+async function updateRootCatalog(baseDir, monthStr, dateStr, sessionId, entry) {
+  const indexJsonFile = path11.join(baseDir, "index.json");
+  const indexMdFile = path11.join(baseDir, "index.md");
+  let catalog;
+  try {
+    const raw = await fs5.readFile(indexJsonFile, "utf8");
+    catalog = JSON.parse(raw);
+  } catch {
+    catalog = {
+      updatedAt: entry.timestamp,
+      totalPrompts: 0,
+      totalTokensEstimated: 0,
+      months: {}
+    };
+  }
+  catalog.updatedAt = entry.timestamp;
+  catalog.totalPrompts += 1;
+  catalog.totalTokensEstimated += entry.metadata.tokenEstimate;
+  if (!catalog.months[monthStr]) {
+    catalog.months[monthStr] = { days: {} };
+  }
+  const monthData = catalog.months[monthStr];
+  if (!monthData.days[dateStr]) {
+    monthData.days[dateStr] = { sessions: {} };
+  }
+  const dayData = monthData.days[dateStr];
+  if (!dayData.sessions[sessionId]) {
+    dayData.sessions[sessionId] = {
+      promptCount: 0,
+      tokenEstimate: 0,
+      lastTimestamp: entry.timestamp,
+      categories: {}
+    };
+  }
+  const sessionData = dayData.sessions[sessionId];
+  sessionData.promptCount += 1;
+  sessionData.tokenEstimate += entry.metadata.tokenEstimate;
+  sessionData.lastTimestamp = entry.timestamp;
+  sessionData.categories[entry.category] = (sessionData.categories[entry.category] ?? 0) + 1;
+  try {
+    await fs5.writeFile(indexJsonFile, JSON.stringify(catalog, null, 2), "utf8");
+    let md = `# \u{1F5C2}\uFE0F Prompt Journal Navigation Index
 
-// src/chronicle/prompt-manifest.ts
-import { createHash as createHash5 } from "node:crypto";
-function createChroniclePromptManifest(request) {
-  const roleCounts = {}, blockCounts = {};
-  const messages = request.messages.map((message, index) => messageSummary(message, index, roleCounts, blockCounts));
-  const systemText = (request.system ?? []).map((block) => block.text).join("\n");
-  const toolRecords = (request.tools ?? []).map((tool) => ({
-    name: tool.name,
-    schemaHash: hash(stable(tool.inputSchema)),
-    permission: tool.permission,
-    mutating: tool.mutating,
-    riskTier: tool.riskTier,
-    capabilities: tool.capabilities,
-    estimatedTokens: tool._estDefTokens ?? 0
-  }));
-  const core = {
-    systemHash: hash(systemText),
-    messages: messages.map(({ hash: contentHash, ...rest }) => ({ ...rest, contentHash })),
-    tools: toolRecords,
-    model: request.model,
-    maxTokens: request.maxTokens,
-    temperature: request.temperature,
-    topP: request.topP,
-    topK: request.topK,
-    seed: request.seed,
-    toolChoice: request.toolChoice,
-    reasoning: request.reasoning,
-    cache: request.cache,
-    responseFormat: request.responseFormat?.type
-  };
-  return {
-    manifestId: `prompt_${hash(stable(core))}`,
-    messageCount: messages.length,
-    estimatedMessageTokens: messages.reduce((sum, message) => sum + (message.estimatedTokens ?? 0), 0),
-    contentBytes: messages.reduce((sum, message) => sum + message.bytes, 0) + Buffer.byteLength(systemText),
-    roleCounts,
-    blockCounts,
-    system: { blockCount: request.system?.length ?? 0, bytes: Buffer.byteLength(systemText), hash: hash(systemText) },
-    messages,
-    tools: {
-      count: toolRecords.length,
-      estimatedDefinitionTokens: toolRecords.reduce((sum, tool) => sum + tool.estimatedTokens, 0),
-      manifestHash: hash(stable(toolRecords)),
-      names: toolRecords.map((tool) => tool.name),
-      mutating: toolRecords.filter((tool) => tool.mutating).length,
-      destructive: toolRecords.filter((tool) => tool.riskTier === "destructive").length
-    },
-    request: {
-      maxTokens: request.maxTokens,
-      temperature: request.temperature,
-      topP: request.topP,
-      topK: request.topK,
-      frequencyPenalty: request.frequencyPenalty,
-      presencePenalty: request.presencePenalty,
-      seed: request.seed,
-      candidateCount: request.candidateCount,
-      logprobs: request.logprobs,
-      topLogprobs: request.topLogprobs,
-      stopSequenceCount: request.stopSequences?.length ?? 0,
-      toolChoice: request.toolChoice,
-      reasoning: request.reasoning,
-      cache: request.cache,
-      responseFormat: request.responseFormat?.type,
-      safetySettingCount: request.safetySettings?.length ?? 0,
-      userHash: request.user ? hash(request.user) : void 0
+`;
+    md += `* **Total Prompts Logged:** ${catalog.totalPrompts}
+`;
+    md += `* **Total Tokens (est):** ~${catalog.totalTokensEstimated.toLocaleString()}
+`;
+    md += `* **Last Recorded Activity:** ${catalog.updatedAt}
+
+`;
+    md += `## \u{1F4C5} Recorded Dates & Sessions
+
+`;
+    md += `| Date | Session | Prompts | Tokens (est) | Daily Log | Session Log |
+`;
+    md += `| :--- | :--- | :--- | :--- | :--- | :--- |
+`;
+    for (const [m, mObj] of Object.entries(catalog.months).sort().reverse()) {
+      for (const [d, dObj] of Object.entries(mObj.days).sort().reverse()) {
+        for (const [sId, sData] of Object.entries(dObj.sessions)) {
+          const dailyLink = `[daily-summary.md](./${m}/${d}/daily-summary.md)`;
+          const sessionLink = `[session-${sessionFileId(sId)}.md](./${m}/${d}/session-${sessionFileId(sId)}.md)`;
+          md += `| **${d}** | \`${sId}\` | ${sData.promptCount} | ~${sData.tokenEstimate.toLocaleString()} | ${dailyLink} | ${sessionLink} |
+`;
+        }
+      }
     }
-  };
+    await fs5.writeFile(indexMdFile, md, "utf8");
+  } catch {
+  }
 }
-function messageSummary(message, index, roles, totals) {
-  roles[message.role] = (roles[message.role] ?? 0) + 1;
-  const blocks = typeof message.content === "string" ? { text: 1 } : countBlocks(message.content);
-  for (const [type, count] of Object.entries(blocks)) totals[type] = (totals[type] ?? 0) + count;
-  const content = contentIdentity(message.content);
-  return {
-    index,
-    role: message.role,
-    bytes: content.bytes,
-    ...message._estTokens !== void 0 ? { estimatedTokens: message._estTokens } : {},
-    hash: content.hash,
-    blocks
-  };
+
+// 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 countBlocks(blocks) {
-  const counts = {};
-  for (const block of blocks) counts[block.type] = (counts[block.type] ?? 0) + 1;
-  return counts;
-}
-function hash(value) {
-  return createHash5("sha256").update(value).digest("hex");
-}
-function contentIdentity(content) {
-  if (typeof content === "string") return { hash: hash(content), bytes: Buffer.byteLength(content) };
-  const digest = createHash5("sha256");
-  let bytes = 0;
-  const add = (value) => {
-    if (!value) return;
-    digest.update(value);
-    bytes += Buffer.byteLength(value);
-  };
-  for (const block of content) {
-    add(block.type);
-    if (block.type === "text") add(block.text);
-    else if (block.type === "thinking") {
-      add(block.thinking);
-      add(block.signature);
-    } else if (block.type === "tool_use") {
-      add(block.id);
-      add(block.name);
-      add(stable(block.input));
-    } else if (block.type === "tool_result") {
-      add(block.tool_use_id);
-      add(block.name);
-      add(block.content);
-      add(String(block.is_error ?? false));
-    } else if (block.type === "image") {
-      add(block.source.type);
-      add(block.source.media_type);
-      add(block.source.url);
-      add(block.source.data);
+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;
     }
   }
-  return { hash: digest.digest("hex"), bytes };
-}
-function stable(value) {
-  if (value === void 0) return "undefined";
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
-  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${stable(child)}`).join(",")}}`;
-}
-
-// src/observability/network-telemetry.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage();
-function runWithNetworkTelemetry(context, run) {
-  return storage.run(context, run);
-}
-
-// src/security/error-sanitize.ts
-import { homedir as homedir2 } from "node:os";
-var scrubber = new DefaultSecretScrubber();
-function scrubErrorText(text) {
-  if (!text) return text;
-  let out = scrubber.scrub(text);
-  const home = safeHomedir();
-  if (home && home.length > 2) {
-    out = replaceAllCaseInsensitive(out, home, "~");
-    const alt = home.includes("\\") ? home.replace(/\\/g, "/") : home.replace(/\//g, "\\");
-    if (alt !== home) out = replaceAllCaseInsensitive(out, alt, "~");
+  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";
   }
-  return out;
+  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;
 }
-function safeHomedir() {
+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 homedir2();
+    return { ok: true, value: JSON.parse(s) };
   } catch {
-    return "";
+    return { ok: false };
   }
 }
-function replaceAllCaseInsensitive(haystack, needle, replacement) {
-  const lowerHay = haystack.toLowerCase();
-  const lowerNeedle = needle.toLowerCase();
-  let idx = lowerHay.indexOf(lowerNeedle);
-  if (idx === -1) return haystack;
-  let out = "";
-  let from = 0;
-  while (idx !== -1) {
-    out += haystack.slice(from, idx) + replacement;
-    from = idx + needle.length;
-    idx = lowerHay.indexOf(lowerNeedle, from);
+
+// 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);
+      }
+    }
   }
-  return out + haystack.slice(from);
+  if (content.length === 0) content.push({ type: "text", text: "" });
+  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
 }
-
-// src/core/provider-runner.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
-function scrubProviderBody(body) {
-  if (!body) return void 0;
+function createStreamingState(model) {
   return {
-    ...body,
-    ...body.type !== void 0 ? { type: scrubErrorText(body.type) } : {},
-    ...body.message !== void 0 ? { message: scrubErrorText(body.message) } : {},
-    ...body.raw !== void 0 ? { raw: scrubErrorText(body.raw) } : {},
-    ...body.requestId !== void 0 ? { requestId: scrubErrorText(body.requestId) } : {}
+    model,
+    stopReason: "end_turn",
+    usage: { input: 0, output: 0 },
+    textBuffers: [],
+    currentTextIndex: -1,
+    tools: /* @__PURE__ */ new Map(),
+    thinking: [],
+    currentThinkingIndex: -1,
+    blockOrder: []
   };
 }
-function providerLogCtx(p, r) {
-  return {
-    providerId: p.id,
-    model: r.model,
-    streaming: p.capabilities.streaming,
-    msgCount: r.messages.length,
-    toolCount: r.tools?.length ?? 0
-  };
+function handleMessageStart(state, model) {
+  state.model = model;
 }
-async function runProviderWithRetry(opts) {
-  const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
-  const logicalRequestId = randomUUID5();
-  const promptManifest = createChroniclePromptManifest(request);
-  let attempt = 0;
-  for (; ; ) {
-    const attemptId = randomUUID5();
-    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const startedNs = process.hrtime.bigint();
-    const correlation = {
-      sessionId: resolveEventSessionId(ctx),
-      ...ctx.traceId ? { traceId: ctx.traceId } : {},
-      ...ctx.agentId ? { agentId: ctx.agentId } : {},
-      logicalRequestId,
-      attemptId,
-      attempt,
-      providerId: provider.id,
-      model: request.model,
-      taskId: ctx.currentKanbanTaskId,
-      boardId: ctx.currentKanbanBoardId
-    };
-    events.emit("provider.attempt.started", {
-      ...correlation,
-      streaming: provider.capabilities.streaming,
-      messageCount: request.messages.length,
-      toolCount: request.tools?.length ?? 0,
-      promptManifest,
-      startedAt
-    });
-    const span = tracer?.startSpan("provider.complete", {
-      "provider.id": provider.id,
-      "provider.model": request.model,
-      "provider.streaming": provider.capabilities.streaming,
-      "provider.attempt": attempt
-    });
-    logger.debug(`Provider attempt ${attempt + 1} starting`, providerLogCtx(provider, request));
-    try {
-      const res = await runWithNetworkTelemetry({
-        events,
-        sessionId: resolveEventSessionId(ctx),
-        ...ctx.traceId ? { traceId: ctx.traceId } : {},
-        ...ctx.agentId ? { agentId: ctx.agentId } : {},
-        attemptId,
-        initiator: "provider",
-        operationName: `${provider.id}.complete`
-      }, () => provider.capabilities.streaming ? streamProviderToResponse(provider, request, signal, ctx, events, logger) : provider.complete(request, { signal }));
-      span?.setAttribute("provider.stopReason", res.stopReason);
-      span?.setAttribute("provider.usage_in", res.usage.input);
-      span?.setAttribute("provider.usage_out", res.usage.output);
-      span?.end();
-      events.emit("provider.attempt.completed", {
-        ...correlation,
-        startedAt,
-        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        durationMs: elapsedMs(startedNs),
-        stopReason: res.stopReason,
-        usage: res.usage
-      });
-      logger.debug("Provider call succeeded", {
-        ...providerLogCtx(provider, request),
-        stopReason: res.stopReason,
-        usageInput: res.usage.input,
-        usageOutput: res.usage.output,
-        cacheRead: res.usage.cacheRead,
-        cacheWrite: res.usage.cacheWrite,
-        attempts: attempt + 1
-      });
-      return res;
-    } catch (err) {
-      if (err instanceof Error) span?.recordError(err);
-      span?.end();
-      if (signal.aborted) throw err;
-      const isProviderErr = err instanceof ProviderError || ProviderError.isProviderError(err);
-      const errAsErr = err instanceof Error ? err : new Error(String(err));
-      const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
-      const providerErrorBody = isProviderErr ? scrubProviderBody(err.body) : void 0;
-      const description = scrubErrorText(
-        isProviderErr ? err.describe() : errAsErr.message
-      );
-      const delay2 = canRetry ? Math.round(retry.delayMs(attempt, isProviderErr ? err : errAsErr)) : void 0;
-      events.emit("provider.attempt.failed", {
-        ...correlation,
-        startedAt,
-        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        durationMs: elapsedMs(startedNs),
-        status: isProviderErr ? err.status : 0,
-        failureKind: isProviderErr ? err.kind : "unknown",
-        description,
-        retryable: canRetry,
-        retryScheduled: canRetry,
-        ...delay2 !== void 0 ? { retryDelayMs: delay2 } : {},
-        ...providerErrorBody?.requestId ? { providerRequestId: providerErrorBody.requestId } : {},
-        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
-      });
-      if (!canRetry) {
-        events.emit("provider.error", {
-          sessionId: resolveEventSessionId(ctx),
-          providerId: isProviderErr ? err.providerId : provider.id,
-          status: isProviderErr ? err.status : 0,
-          description,
-          retryable: false,
-          ...providerErrorBody ? { errorBody: providerErrorBody } : {}
-        });
-        logger.error(`Provider call failed after ${attempt + 1} attempt(s) \u2014 ${description}`, {
-          ...providerLogCtx(provider, request),
-          attempts: attempt + 1,
-          errorDescription: description,
-          status: isProviderErr ? err.status : void 0,
-          errorBody: providerErrorBody,
-          errorName: err instanceof Error ? err.name : void 0,
-          errorStack: err instanceof Error ? err.stack?.split("\n").slice(0, 3).join("\n") : void 0
-        });
-        throw toWrongStackError(err);
-      }
-      const attemptNum = attempt + 1;
-      const maxAttempts = retry.maxAttempts(isProviderErr ? err : errAsErr);
-      logger.warn(`Provider retry ${attemptNum}/${maxAttempts} in ${delay2}ms \u2014 ${description}`, {
-        ...providerLogCtx(provider, request),
-        attempt: attemptNum,
-        maxAttempts,
-        delayMs: delay2,
-        errorDescription: description,
-        status: isProviderErr ? err.status : void 0,
-        errorBody: providerErrorBody
-      });
-      events.emit("provider.retry", {
-        sessionId: resolveEventSessionId(ctx),
-        providerId: isProviderErr ? err.providerId : provider.id,
-        attempt: attemptNum,
-        delayMs: delay2,
-        status: isProviderErr ? err.status : 0,
-        description,
-        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
-      });
-      await new Promise((resolve10, reject) => {
-        let settled = false;
-        const cleanup = () => {
-          clearTimeout(t2);
-          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 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 elapsedMs(startedNs) {
-  return Number(process.hrtime.bigint() - startedNs) / 1e6;
+function handleContentBlockStop(state, ev) {
+  void state;
+  void ev;
 }
-
-// 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 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 sameList(a, b) {
-  return a.length === b.length && a.every((v, i) => v === b[i]);
+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 toPreview(text) {
-  const trimmed = text.trim();
-  if (trimmed.length <= MAX_PREVIEW_CHARS) return trimmed;
-  return `${trimmed.slice(0, MAX_PREVIEW_CHARS - 1)}\u2026`;
+function handleToolUseInputDelta(state, ev) {
+  const t2 = state.tools.get(ev.id);
+  if (t2) t2.partial += ev.partial;
 }
-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 safeJsonOrRaw(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    const repaired = completePartialObject(s);
+    try {
+      return JSON.parse(repaired);
+    } catch {
+      return { _raw: repaired };
+    }
   }
-  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;
+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;
   }
-  ctx.meta[META_KEY3] = { items: s.items, seen: s.items };
-  return s.items;
+  state.currentTextIndex = -1;
 }
-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");
+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;
 }
-
-// src/core/request-provider-binding.ts
-var requestProviders = /* @__PURE__ */ new WeakMap();
-function bindRequestProvider(request, provider) {
-  requestProviders.set(request, provider);
+function handleThinkingDelta(state, text) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.textBuf += text;
 }
-function providerBoundToRequest(request) {
-  return requestProviders.get(request);
+function handleThinkingSignature(state, signature) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.signature = signature;
 }
-
-// src/core/agent-loop.ts
-function toError(err) {
-  return err instanceof Error ? err : new Error(String(err));
+function handleThinkingStop(state) {
+  state.currentThinkingIndex = -1;
 }
-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 handleMessageStop(state, ev) {
+  state.stopReason = ev.stopReason ?? "end_turn";
+  state.usage = ev.usage ?? { input: 0, output: 0 };
 }
-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;
+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 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"];
+  };
+  const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
+  try {
+    for (; ; ) {
+      const next = await iter.next();
+      if (next.done) break;
+      const ev = next.value;
+      try {
+        switch (ev.type) {
+          case "message_start":
+            handleMessageStart(state, ev.model);
+            break;
+          case "content_block_start":
+            handleContentBlockStart(state, ev);
+            break;
+          case "content_block_stop":
+            handleContentBlockStop(state, ev);
+            break;
+          case "text_delta":
+            handleTextDelta(state, ev.text);
+            pendingText += ev.text;
+            pendingCount++;
+            if (pendingCount >= TEXT_BATCH_SIZE) flushText();
+            break;
+          case "tool_use_start": {
+            flushText();
+            const idVal = ev.id;
+            const nameVal = ev.name;
+            handleToolUseStart(state, { id: idVal, name: nameVal });
+            const emittedPayload = { sessionId, ctx, id: idVal ?? "unknown", name: nameVal ?? "unknown" };
+            events.emit("provider.tool_use_start", emittedPayload);
+            break;
+          }
+          case "tool_use_input_delta":
+            handleToolUseInputDelta(state, ev);
+            break;
+          case "tool_use_stop": {
+            flushText();
+            const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
+            handleToolUseStop(state, ev);
+            events.emit("provider.tool_use_stop", { sessionId, ctx, id: ev.id, name: stoppedName });
+            break;
+          }
+          case "thinking_start":
+            handleThinkingStart(state, ev);
+            break;
+          case "thinking_delta":
+            flushText();
+            handleThinkingDelta(state, ev.text);
+            events.emit("provider.thinking_delta", { sessionId, ctx, text: ev.text });
+            break;
+          case "thinking_signature":
+            handleThinkingSignature(state, ev.signature);
+            break;
+          case "thinking_stop":
+            handleThinkingStop(state);
+            break;
+          case "message_stop":
+            handleMessageStop(state, ev);
+            break;
+          default: {
+            const unknownEv = ev;
+            logger.warn(`Stream received unknown event type: "${String(unknownEv.type)}"`, {
+              providerId: provider.id,
+              model: req.model,
+              eventType: String(unknownEv.type)
+            });
+            break;
+          }
+        }
+      } catch (handlerErr) {
+        const errMsg = handlerErr instanceof Error ? handlerErr.message : String(handlerErr);
+        const evAny = ev;
+        logger.warn(`Stream handler error for event type "${String(evAny.type)}": ${errMsg}`, {
+          providerId: provider.id,
+          model: req.model,
+          eventType: String(evAny.type),
+          errorMessage: errMsg
+        });
+        flushText();
+        events.emit("provider.stream_error", {
+          sessionId,
+          ctx,
+          eventType: String(evAny.type),
+          msg: errMsg
+        });
+      }
     }
-    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),
+  } catch (err) {
+    if (signal.aborted) {
+      state.stopReason = "end_turn";
+      flushText();
+      logger.debug("Stream aborted \u2014 returning partial state", {
         providerId: provider.id,
-        modelId: model,
-        maxContext: effective2,
-        ...eventPrevious > 0 ? { previousMaxContext: eventPrevious } : {},
-        source,
-        decreased: eventPrevious > 0 && effective2 < eventPrevious
+        model: req.model,
+        textBlockCount: state.textBuffers.length,
+        toolBlockCount: state.tools.size,
+        thinkingBlockCount: state.thinking.length
       });
-    };
-    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;
+      return buildResponse(state);
     }
-    let discovered;
+    throw err;
+  } finally {
     try {
-      discovered = await refresh.call(provider, model, { signal: a.ctx.signal });
+      let drainTimer = null;
+      try {
+        const drainPromise = Promise.resolve(iter.return?.()).catch(() => {
+        });
+        await Promise.race([
+          drainPromise,
+          new Promise((resolve10) => {
+            drainTimer = setTimeout(resolve10, STREAM_DRAIN_TIMEOUT_MS);
+          })
+        ]);
+      } finally {
+        if (drainTimer) clearTimeout(drainTimer);
+      }
     } 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;
+  flushText();
+  logger.debug("Stream completed", {
+    providerId: provider.id,
+    model: req.model,
+    stopReason: state.stopReason,
+    textBlockCount: state.textBuffers.length,
+    toolBlockCount: state.tools.size,
+    thinkingBlockCount: state.thinking.length,
+    usageInput: state.usage.input,
+    usageOutput: state.usage.output
+  });
+  return buildResponse(state);
+}
+
+// src/chronicle/prompt-manifest.ts
+import { createHash as createHash5 } from "node:crypto";
+function createChroniclePromptManifest(request) {
+  const roleCounts = {}, blockCounts = {};
+  const messages = request.messages.map((message, index) => messageSummary(message, index, roleCounts, blockCounts));
+  const systemText = (request.system ?? []).map((block) => block.text).join("\n");
+  const toolRecords = (request.tools ?? []).map((tool) => ({
+    name: tool.name,
+    schemaHash: hash(stable(tool.inputSchema)),
+    permission: tool.permission,
+    mutating: tool.mutating,
+    riskTier: tool.riskTier,
+    capabilities: tool.capabilities,
+    estimatedTokens: tool._estDefTokens ?? 0
+  }));
+  const core = {
+    systemHash: hash(systemText),
+    messages: messages.map(({ hash: contentHash, ...rest }) => ({ ...rest, contentHash })),
+    tools: toolRecords,
+    model: request.model,
+    maxTokens: request.maxTokens,
+    temperature: request.temperature,
+    topP: request.topP,
+    topK: request.topK,
+    seed: request.seed,
+    toolChoice: request.toolChoice,
+    reasoning: request.reasoning,
+    cache: request.cache,
+    responseFormat: request.responseFormat?.type
+  };
+  return {
+    manifestId: `prompt_${hash(stable(core))}`,
+    messageCount: messages.length,
+    estimatedMessageTokens: messages.reduce((sum, message) => sum + (message.estimatedTokens ?? 0), 0),
+    contentBytes: messages.reduce((sum, message) => sum + message.bytes, 0) + Buffer.byteLength(systemText),
+    roleCounts,
+    blockCounts,
+    system: { blockCount: request.system?.length ?? 0, bytes: Buffer.byteLength(systemText), hash: hash(systemText) },
+    messages,
+    tools: {
+      count: toolRecords.length,
+      estimatedDefinitionTokens: toolRecords.reduce((sum, tool) => sum + tool.estimatedTokens, 0),
+      manifestHash: hash(stable(toolRecords)),
+      names: toolRecords.map((tool) => tool.name),
+      mutating: toolRecords.filter((tool) => tool.mutating).length,
+      destructive: toolRecords.filter((tool) => tool.riskTier === "destructive").length
+    },
+    request: {
+      maxTokens: request.maxTokens,
+      temperature: request.temperature,
+      topP: request.topP,
+      topK: request.topK,
+      frequencyPenalty: request.frequencyPenalty,
+      presencePenalty: request.presencePenalty,
+      seed: request.seed,
+      candidateCount: request.candidateCount,
+      logprobs: request.logprobs,
+      topLogprobs: request.topLogprobs,
+      stopSequenceCount: request.stopSequences?.length ?? 0,
+      toolChoice: request.toolChoice,
+      reasoning: request.reasoning,
+      cache: request.cache,
+      responseFormat: request.responseFormat?.type,
+      safetySettingCount: request.safetySettings?.length ?? 0,
+      userHash: request.user ? hash(request.user) : void 0
+    }
+  };
+}
+function messageSummary(message, index, roles, totals) {
+  roles[message.role] = (roles[message.role] ?? 0) + 1;
+  const blocks = typeof message.content === "string" ? { text: 1 } : countBlocks(message.content);
+  for (const [type, count] of Object.entries(blocks)) totals[type] = (totals[type] ?? 0) + count;
+  const content = contentIdentity(message.content);
+  return {
+    index,
+    role: message.role,
+    bytes: content.bytes,
+    ...message._estTokens !== void 0 ? { estimatedTokens: message._estTokens } : {},
+    hash: content.hash,
+    blocks
+  };
+}
+function countBlocks(blocks) {
+  const counts = {};
+  for (const block of blocks) counts[block.type] = (counts[block.type] ?? 0) + 1;
+  return counts;
+}
+function hash(value) {
+  return createHash5("sha256").update(value).digest("hex");
+}
+function contentIdentity(content) {
+  if (typeof content === "string") return { hash: hash(content), bytes: Buffer.byteLength(content) };
+  const digest = createHash5("sha256");
+  let bytes = 0;
+  const add = (value) => {
+    if (!value) return;
+    digest.update(value);
+    bytes += Buffer.byteLength(value);
+  };
+  for (const block of content) {
+    add(block.type);
+    if (block.type === "text") add(block.text);
+    else if (block.type === "thinking") {
+      add(block.thinking);
+      add(block.signature);
+    } else if (block.type === "tool_use") {
+      add(block.id);
+      add(block.name);
+      add(stable(block.input));
+    } else if (block.type === "tool_result") {
+      add(block.tool_use_id);
+      add(block.name);
+      add(block.content);
+      add(String(block.is_error ?? false));
+    } else if (block.type === "image") {
+      add(block.source.type);
+      add(block.source.media_type);
+      add(block.source.url);
+      add(block.source.data);
     }
-    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;
+  return { hash: digest.digest("hex"), bytes };
+}
+function stable(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${stable(child)}`).join(",")}}`;
+}
+
+// src/observability/network-telemetry.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+function runWithNetworkTelemetry(context, run) {
+  return storage.run(context, run);
+}
+
+// src/security/error-sanitize.ts
+import { homedir as homedir2 } from "node:os";
+var scrubber = new DefaultSecretScrubber();
+function scrubErrorText(text) {
+  if (!text) return text;
+  let out = scrubber.scrub(text);
+  const home = safeHomedir();
+  if (home && home.length > 2) {
+    out = replaceAllCaseInsensitive(out, home, "~");
+    const alt = home.includes("\\") ? home.replace(/\\/g, "/") : home.replace(/\//g, "\\");
+    if (alt !== home) out = replaceAllCaseInsensitive(out, alt, "~");
   }
-  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;
+  return out;
+}
+function safeHomedir() {
+  try {
+    return homedir2();
+  } catch {
+    return "";
   }
-  async function buildRequestWithPreflightCompaction(opts) {
-    let prepared = await handlers.response.buildAndRunRequestPipeline(opts);
-    let req = prepared.request;
-    let preFlight = stashRequestTokens(req);
-    let probedRouteKey = `${prepared.provider.id}/${req.model}`;
-    await refreshProviderContextLimit(prepared.provider, req.model);
-    if (await compactContextIfNeeded()) {
-      prepared = await handlers.response.buildAndRunRequestPipeline(opts);
-      req = prepared.request;
-      preFlight = stashRequestTokens(req);
-      const rebuiltRouteKey = `${prepared.provider.id}/${req.model}`;
-      if (rebuiltRouteKey !== probedRouteKey) {
-        probedRouteKey = rebuiltRouteKey;
-        await refreshProviderContextLimit(prepared.provider, req.model);
-        if (await compactContextIfNeeded()) {
-          prepared = await handlers.response.buildAndRunRequestPipeline(opts);
-          req = prepared.request;
-          preFlight = stashRequestTokens(req);
-        }
-      }
-    }
-    return { req, provider: prepared.provider, preFlight };
+}
+function replaceAllCaseInsensitive(haystack, needle, replacement) {
+  const lowerHay = haystack.toLowerCase();
+  const lowerNeedle = needle.toLowerCase();
+  let idx = lowerHay.indexOf(lowerNeedle);
+  if (idx === -1) return haystack;
+  let out = "";
+  let from = 0;
+  while (idx !== -1) {
+    out += haystack.slice(from, idx) + replacement;
+    from = idx + needle.length;
+    idx = lowerHay.indexOf(lowerNeedle, from);
   }
-  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;
+  return out + haystack.slice(from);
+}
+
+// src/core/provider-runner.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+function scrubProviderBody(body) {
+  if (!body) return void 0;
+  return {
+    ...body,
+    ...body.type !== void 0 ? { type: scrubErrorText(body.type) } : {},
+    ...body.message !== void 0 ? { message: scrubErrorText(body.message) } : {},
+    ...body.raw !== void 0 ? { raw: scrubErrorText(body.raw) } : {},
+    ...body.requestId !== void 0 ? { requestId: scrubErrorText(body.requestId) } : {}
+  };
+}
+function providerLogCtx(p, r) {
+  return {
+    providerId: p.id,
+    model: r.model,
+    streaming: p.capabilities.streaming,
+    msgCount: r.messages.length,
+    toolCount: r.tools?.length ?? 0
+  };
+}
+async function runProviderWithRetry(opts) {
+  const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
+  const logicalRequestId = randomUUID5();
+  const promptManifest = createChroniclePromptManifest(request);
+  let attempt = 0;
+  for (; ; ) {
+    const attemptId = randomUUID5();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startedNs = process.hrtime.bigint();
+    const correlation = {
+      sessionId: resolveEventSessionId(ctx),
+      ...ctx.traceId ? { traceId: ctx.traceId } : {},
+      ...ctx.agentId ? { agentId: ctx.agentId } : {},
+      logicalRequestId,
+      attemptId,
+      attempt,
+      providerId: provider.id,
+      model: request.model,
+      taskId: ctx.currentKanbanTaskId,
+      boardId: ctx.currentKanbanBoardId
+    };
+    events.emit("provider.attempt.started", {
+      ...correlation,
+      streaming: provider.capabilities.streaming,
+      messageCount: request.messages.length,
+      toolCount: request.tools?.length ?? 0,
+      promptManifest,
+      startedAt
+    });
+    const span = tracer?.startSpan("provider.complete", {
+      "provider.id": provider.id,
+      "provider.model": request.model,
+      "provider.streaming": provider.capabilities.streaming,
+      "provider.attempt": attempt
+    });
+    logger.debug(`Provider attempt ${attempt + 1} starting`, providerLogCtx(provider, request));
+    try {
+      const res = await runWithNetworkTelemetry({
+        events,
+        sessionId: resolveEventSessionId(ctx),
+        ...ctx.traceId ? { traceId: ctx.traceId } : {},
+        ...ctx.agentId ? { agentId: ctx.agentId } : {},
+        attemptId,
+        initiator: "provider",
+        operationName: `${provider.id}.complete`
+      }, () => provider.capabilities.streaming ? streamProviderToResponse(provider, request, signal, ctx, events, logger) : provider.complete(request, { signal }));
+      span?.setAttribute("provider.stopReason", res.stopReason);
+      span?.setAttribute("provider.usage_in", res.usage.input);
+      span?.setAttribute("provider.usage_out", res.usage.output);
+      span?.end();
+      events.emit("provider.attempt.completed", {
+        ...correlation,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: elapsedMs(startedNs),
+        stopReason: res.stopReason,
+        usage: res.usage
+      });
+      logger.debug("Provider call succeeded", {
+        ...providerLogCtx(provider, request),
+        stopReason: res.stopReason,
+        usageInput: res.usage.input,
+        usageOutput: res.usage.output,
+        cacheRead: res.usage.cacheRead,
+        cacheWrite: res.usage.cacheWrite,
+        attempts: attempt + 1
+      });
+      return res;
+    } catch (err) {
+      if (err instanceof Error) span?.recordError(err);
+      span?.end();
+      if (signal.aborted) throw err;
+      const isProviderErr = err instanceof ProviderError || ProviderError.isProviderError(err);
+      const errAsErr = err instanceof Error ? err : new Error(String(err));
+      const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
+      const providerErrorBody = isProviderErr ? scrubProviderBody(err.body) : void 0;
+      const description = scrubErrorText(
+        isProviderErr ? err.describe() : errAsErr.message
+      );
+      const delay2 = canRetry ? Math.round(retry.delayMs(attempt, isProviderErr ? err : errAsErr)) : void 0;
+      events.emit("provider.attempt.failed", {
+        ...correlation,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: elapsedMs(startedNs),
+        status: isProviderErr ? err.status : 0,
+        failureKind: isProviderErr ? err.kind : "unknown",
+        description,
+        retryable: canRetry,
+        retryScheduled: canRetry,
+        ...delay2 !== void 0 ? { retryDelayMs: delay2 } : {},
+        ...providerErrorBody?.requestId ? { providerRequestId: providerErrorBody.requestId } : {},
+        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
+      });
+      if (!canRetry) {
+        events.emit("provider.error", {
+          sessionId: resolveEventSessionId(ctx),
+          providerId: isProviderErr ? err.providerId : provider.id,
+          status: isProviderErr ? err.status : 0,
+          description,
+          retryable: false,
+          ...providerErrorBody ? { errorBody: providerErrorBody } : {}
+        });
+        logger.error(`Provider call failed after ${attempt + 1} attempt(s) \u2014 ${description}`, {
+          ...providerLogCtx(provider, request),
+          attempts: attempt + 1,
+          errorDescription: description,
+          status: isProviderErr ? err.status : void 0,
+          errorBody: providerErrorBody,
+          errorName: err instanceof Error ? err.name : void 0,
+          errorStack: err instanceof Error ? err.stack?.split("\n").slice(0, 3).join("\n") : void 0
+        });
+        throw toWrongStackError(err);
+      }
+      const attemptNum = attempt + 1;
+      const maxAttempts = retry.maxAttempts(isProviderErr ? err : errAsErr);
+      logger.warn(`Provider retry ${attemptNum}/${maxAttempts} in ${delay2}ms \u2014 ${description}`, {
+        ...providerLogCtx(provider, request),
+        attempt: attemptNum,
+        maxAttempts,
+        delayMs: delay2,
+        errorDescription: description,
+        status: isProviderErr ? err.status : void 0,
+        errorBody: providerErrorBody
+      });
+      events.emit("provider.retry", {
+        sessionId: resolveEventSessionId(ctx),
+        providerId: isProviderErr ? err.providerId : provider.id,
+        attempt: attemptNum,
+        delayMs: delay2,
+        status: isProviderErr ? err.status : 0,
+        description,
+        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
+      });
+      await new Promise((resolve10, reject) => {
+        let settled = false;
+        const cleanup = () => {
+          clearTimeout(t2);
+          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++;
     }
-    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 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;
+}
+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;
   }
-  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, 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 recordSelfHealingRetry(a, err, reason) {
+  const projectRoot = a.ctx.projectRoot;
+  if (!projectRoot) return;
+  void recordPromptJournalEntry({
+    projectRoot,
+    sessionId: resolveEventSessionId(a.ctx),
+    category: "self_healing_retry",
+    content: toErrorMessage(err),
+    decisionReason: reason,
+    model: a.ctx.model,
+    provider: a.ctx.provider?.id,
+    activeTools: a.ctx.tools?.map((tool) => tool.name) ?? []
+  }).catch(() => {
+  });
+}
+function recordAutonomousContinue(a, text) {
+  const projectRoot = a.ctx.projectRoot;
+  if (!projectRoot) return;
+  void recordPromptJournalEntry({
+    projectRoot,
+    sessionId: resolveEventSessionId(a.ctx),
+    category: "autonomous_next_step",
+    content: text,
+    decisionReason: "text-marker autonomous continue",
+    model: a.ctx.model,
+    provider: a.ctx.provider?.id,
+    activeTools: a.ctx.tools?.map((tool) => tool.name) ?? []
+  }).catch(() => {
+  });
+}
+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 +7389,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 +7499,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 +7512,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 +7520,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) {
@@ -7207,6 +7576,7 @@ ${text}` : text;
               }
               if (extDecision.model) a.ctx.model = extDecision.model;
               a.logger.info("Extension requested retry; retrying turn");
+              recordSelfHealingRetry(a, err, "extension-requested provider retry");
               continue;
             }
           }
@@ -7236,6 +7606,7 @@ ${text}` : text;
             }
             if (recovered.model) a.ctx.model = recovered.model;
             a.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
+            recordSelfHealingRetry(a, err, recovered.reason);
             continue;
           }
           recoveryRetries = 0;
@@ -7244,7 +7615,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 +7640,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,
@@ -7378,6 +7666,7 @@ ${text}` : text;
             continue;
           }
           if (autonomousContinue && responseResult.directive === "continue") {
+            recordAutonomousContinue(a, finalText);
             await a.extensions.runAfterIteration(a.ctx, i);
             continue;
           }
@@ -7401,8 +7690,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 +7700,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 +7900,10 @@ var RUNTIME_CAPABILITY_MANIFEST = [
       "codebase-incoming-calls",
       "codebase-outgoing-calls",
       "codebase-index",
+      "codebase-skeleton",
+      "codebase-repo-map",
+      "codebase-impact-analysis",
+      "codebase-invariant-check",
       "dead-code-scan",
       "diff",
       "json",
@@ -7621,7 +7914,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 +7926,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 +8063,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 +8087,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 +8527,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 +8647,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 +9222,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 +9589,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 +10076,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 +10410,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 +10542,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
@@ -10270,8 +10788,8 @@ var InputBuilder = class {
   async registerFile(input) {
     const ref = await this.store.add({ ...input, kind: "file" });
     this.refs.push(ref);
-    const path15 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
-    return `[file:${path15}]`;
+    const path16 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path16}]`;
   }
   /**
    * Whether `appendPaste(text)` would collapse the text to a placeholder
@@ -10318,8 +10836,8 @@ function paragraphLabel(text) {
 
 // src/core/instruction-bundle.ts
 import { statSync as statSync2 } from "node:fs";
-import * as fs5 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path12 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function loadInstructionBundle(paths) {
   let bundle = {};
@@ -10375,17 +10893,17 @@ function resolveSystemInstructionFile(paths) {
 }
 function sanitizeSystemInstructionFile(file) {
   const trimmed = file.trim();
-  if (trimmed.length === 0 || trimmed !== path11.basename(trimmed) || path11.extname(trimmed).toLowerCase() !== ".md") {
+  if (trimmed.length === 0 || trimmed !== path12.basename(trimmed) || path12.extname(trimmed).toLowerCase() !== ".md") {
     throw new Error(`Invalid system instruction file: ${file}`);
   }
   return trimmed;
 }
 async function readInstructionDir(dir, options) {
   const [json, identity, leaderAfterTask, sections] = await Promise.all([
-    readInstructionJson(path11.join(dir, "instructions.json")),
-    readOptionalText(path11.join(dir, options.systemFile)),
-    readOptionalText(path11.join(dir, "leader-after-task.md")),
-    readSections(path11.join(dir, "sections"))
+    readInstructionJson(path12.join(dir, "instructions.json")),
+    readOptionalText(path12.join(dir, options.systemFile)),
+    readOptionalText(path12.join(dir, "leader-after-task.md")),
+    readSections(path12.join(dir, "sections"))
   ]);
   const fromMarkdown = {
     system: {
@@ -10404,13 +10922,13 @@ async function readSections(root) {
 async function readSectionsInto(root, dir, out) {
   let entries;
   try {
-    entries = await fs5.readdir(dir, { withFileTypes: true });
+    entries = await fs6.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   await Promise.all(
     entries.map(async (entry) => {
-      const file = path11.join(dir, entry.name);
+      const file = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         await readSectionsInto(root, file, out);
         return;
@@ -10418,7 +10936,7 @@ async function readSectionsInto(root, dir, out) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) return;
       const text = await readOptionalText(file);
       if (text === void 0) return;
-      const rel = path11.relative(root, file).replace(/\\/g, "/").replace(/\.md$/i, "");
+      const rel = path12.relative(root, file).replace(/\\/g, "/").replace(/\.md$/i, "");
       const key = rel.split("/").join(".").replace(/-/g, ".");
       out[key] = text;
     })
@@ -10427,7 +10945,7 @@ async function readSectionsInto(root, dir, out) {
 async function readInstructionJson(file) {
   let raw;
   try {
-    raw = await fs5.readFile(file, "utf8");
+    raw = await fs6.readFile(file, "utf8");
   } catch {
     return {};
   }
@@ -10459,18 +10977,18 @@ function normalizeInstructionBundle(value) {
 }
 async function readOptionalText(file) {
   try {
-    const text = await fs5.readFile(file, "utf8");
+    const text = await fs6.readFile(file, "utf8");
     return text.trimEnd();
   } catch {
     return void 0;
   }
 }
 function defaultBundledInstructionDir() {
-  const here = path11.dirname(fileURLToPath2(import.meta.url));
+  const here = path12.dirname(fileURLToPath2(import.meta.url));
   return firstExistingDirSync([
-    path11.resolve(here, "../../instructions"),
-    path11.resolve(here, "../instructions"),
-    path11.resolve(here, "instructions")
+    path12.resolve(here, "../../instructions"),
+    path12.resolve(here, "../instructions"),
+    path12.resolve(here, "instructions")
   ]);
 }
 function definedPick(obj, keys) {
@@ -10524,13 +11042,13 @@ function flattenSystemPromptRegions(regions) {
 
 // src/core/modes/default.ts
 import { readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var PROMPT = readBundledInstructionFile("system.md");
 var LEADER_AFTER_TASK_PROMPT = readBundledInstructionFile("leader-after-task.md");
 function readBundledInstructionFile(name) {
   for (const dir of bundledInstructionDirCandidates()) {
-    const file = path12.join(dir, name);
+    const file = path13.join(dir, name);
     try {
       return readFileSync6(file, "utf8").trimEnd();
     } catch {
@@ -10539,12 +11057,12 @@ function readBundledInstructionFile(name) {
   return "";
 }
 function bundledInstructionDirCandidates() {
-  const here = path12.dirname(fileURLToPath3(import.meta.url));
+  const here = path13.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
-    path12.resolve(here, "../../../instructions"),
-    path12.resolve(here, "../../instructions"),
-    path12.resolve(here, "../instructions"),
-    path12.resolve(here, "instructions")
+    path13.resolve(here, "../../../instructions"),
+    path13.resolve(here, "../../instructions"),
+    path13.resolve(here, "../instructions"),
+    path13.resolve(here, "instructions")
   ];
   return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
 }
@@ -10558,12 +11076,12 @@ function isDirectory(candidate) {
 
 // src/core/system-prompt-environment.ts
 import * as os3 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 
 // src/core/system-prompt-environment-probes.ts
 import { spawn as spawn2 } from "node:child_process";
-import * as fs6 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path14 from "node:path";
 
 // src/utils/child-env.ts
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
@@ -10704,7 +11222,7 @@ function buildChildEnv(optsOrSessionId) {
 // src/core/system-prompt-environment-probes.ts
 async function dirExists(p) {
   try {
-    const stat3 = await fs6.stat(p);
+    const stat3 = await fs7.stat(p);
     return stat3.isDirectory();
   } catch {
     return false;
@@ -10791,7 +11309,7 @@ async function detectLanguages(root) {
   const hits = await Promise.all(
     checks.map(async ([marker, lang]) => {
       try {
-        await fs6.access(path13.join(root, marker));
+        await fs7.access(path14.join(root, marker));
         return lang;
       } catch {
         return null;
@@ -10854,6 +11372,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 +11381,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,12 +11391,11 @@ 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];
   const node = process.version;
-  const isGit = await dirExists(path14.join(ctx.projectRoot, ".git"));
+  const isGit = await dirExists(path15.join(ctx.projectRoot, ".git"));
   const [git, langs] = await Promise.all([
     isGit ? gitStatus(ctx.projectRoot) : Promise.resolve("not a git repo"),
     detectLanguages(ctx.projectRoot)
@@ -11351,16 +11871,16 @@ ${skillBodyCache}`);
 }
 
 // src/core/system-prompt-plan.ts
-import * as fs7 from "node:fs/promises";
+import * as fs8 from "node:fs/promises";
 async function readActivePlanBlock(args) {
   const { planPath, cache } = args;
   if (!planPath) return { text: "", cache };
   try {
-    const stat3 = await fs7.stat(planPath);
+    const stat3 = await fs8.stat(planPath);
     if (cache && cache.path === planPath && cache.mtimeMs === stat3.mtimeMs) {
       return { text: cache.text, cache };
     }
-    const raw = await fs7.readFile(planPath, "utf8");
+    const raw = await fs8.readFile(planPath, "utf8");
     const text = formatActivePlan(raw);
     return { text, cache: { path: planPath, mtimeMs: stat3.mtimeMs, text } };
   } catch {
@@ -11716,7 +12236,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 +12365,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 +12428,7 @@ export {
   createDefaultPipelines,
   createFallbackModelExtension,
   detectContinueIntent,
+  diagnoseFallbackConfig,
   effectiveFallbackChain,
   fallbackProfileChain,
   formatModelRef,
@@ -11924,6 +12447,7 @@ export {
   runtimeFallbackChain,
   setBtwNote,
   setQueuedMessagesSnapshot,
+  simulateFallbackFailover,
   smartDefaultFallbackChain,
   wrapAsState,
   writePendingNextSteps