@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-YOPAUVU4.js

@@ -0,0 +1,2588 @@
+import {
+  recordPromptJournalEntry
+} from "./chunk-RFQMOKWK.js";
+import {
+  createHqPublisherFromEnv
+} from "./chunk-NIOAGFPB.js";
+import {
+  ExtensionRegistry
+} from "./chunk-MTL4O5YR.js";
+import {
+  JsonlReportStore
+} from "./chunk-HXKZ7OBQ.js";
+import {
+  getSharedProjectMailbox,
+  mailboxSessionTag,
+  resolveMailboxIdentity,
+  sessionNoteHub
+} from "./chunk-JO4MGB6Z.js";
+import {
+  MAILBOX_AWARENESS_INTERVAL_MS,
+  MAILBOX_HEARTBEAT_INTERVAL_MS,
+  PULSE_MIN_READ_INTERVAL_MS,
+  resolveProjectDir
+} from "./chunk-IRUTEHCE.js";
+import {
+  MAILBOX_TYPE_PROPERTIES,
+  acceptMailboxMessageForSession,
+  isMailboxLeader
+} from "./chunk-FWNLEZYG.js";
+import {
+  buildBtwBlock,
+  consumeBtwNotes,
+  setBtwNote
+} from "./chunk-SQJVFEBV.js";
+import {
+  runProviderWithRetry
+} from "./chunk-U45AXT5D.js";
+import {
+  clearPendingNextSteps,
+  consumeAutonomousContinue,
+  createAgentResponseHandler,
+  formatTodosForModel,
+  hasKanbanBoundTodos,
+  hasOpenTodos,
+  sizeSignals,
+  truncateForEvent
+} from "./chunk-M27LIEKV.js";
+import {
+  isRuntimeContextInput,
+  providerBoundToRequest,
+  recordToolOutputEvidence,
+  recordUserIntentEvidence,
+  resolveEventSessionId,
+  resolveOwningSessionId
+} from "./chunk-ZHZ2Y2DH.js";
+import {
+  estimateMessageTokens,
+  estimateRequestTokens,
+  getCalibrationState,
+  realAnchoredInputTokens,
+  recordActualUsage
+} from "./chunk-HMLIGAU7.js";
+import {
+  capSageLines,
+  splitSageOutputBlock
+} from "./chunk-SVT4RNTR.js";
+import {
+  wstackGlobalRoot
+} from "./chunk-SAFHACFA.js";
+import {
+  Pipeline,
+  RunController,
+  TOKENS
+} from "./chunk-NS52ISWS.js";
+import {
+  effectiveInputTokens
+} from "./chunk-3ECENVHL.js";
+import {
+  isTextBlock,
+  isToolUseBlock
+} from "./chunk-O37BQ65S.js";
+import {
+  AgentError,
+  toWrongStackError
+} from "./chunk-25LSLC3G.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/core/mailbox-loop.ts
+function createMailboxChecker(opts) {
+  const getMailbox = typeof opts.mailbox === "function" ? opts.mailbox : () => opts.mailbox;
+  const currentId = typeof opts.agentId === "function" ? opts.agentId : () => opts.agentId;
+  const currentSessionId = typeof opts.sessionId === "function" ? opts.sessionId : () => opts.sessionId;
+  const currentRole = typeof opts.role === "function" ? opts.role : () => opts.role;
+  const injectedIds = /* @__PURE__ */ new Set();
+  const broadcastFloor = opts.broadcastFloor ?? (/* @__PURE__ */ new Date()).toISOString();
+  return async () => {
+    try {
+      const mailbox = getMailbox();
+      const agentId = currentId();
+      const role = currentRole();
+      const sessionId = currentSessionId();
+      const targets = [
+        agentId,
+        ...(opts.aliases ?? []).filter((al) => al && al !== agentId),
+        ...sessionId ? [`@session:${sessionId}`] : []
+      ];
+      const batches = await Promise.all(
+        targets.map(
+          (to) => mailbox.query({ to, unreadBy: agentId, readerRole: role, limit: 10 }).catch(() => [])
+        )
+      );
+      const seen = /* @__PURE__ */ new Set();
+      const messages = [];
+      for (const batch of batches) {
+        for (const m of batch) {
+          if (seen.has(m.id)) continue;
+          if (m.to === "*" && m.timestamp < broadcastFloor) continue;
+          if (opts.include && !opts.include(m)) continue;
+          seen.add(m.id);
+          messages.push(m);
+        }
+      }
+      const fresh = messages.filter(
+        (m) => !injectedIds.has(m.id) && !m.completed
+      );
+      for (const m of fresh) {
+        injectedIds.add(m.id);
+      }
+      if (fresh.length > 0 && opts.ack !== false) {
+        void mailbox.ackMany({
+          acks: fresh.map((m) => ({
+            messageId: m.id,
+            readerId: agentId,
+            read: true
+          }))
+        }).catch(() => {
+        });
+      }
+      if (injectedIds.size > 1e3) {
+        const recent = new Set([...injectedIds].slice(-500));
+        injectedIds.clear();
+        for (const id of recent) injectedIds.add(id);
+      }
+      return fresh;
+    } catch {
+      return [];
+    }
+  };
+}
+var TYPE_LABEL = {
+  steer: "\u{1F504} STEER",
+  btw: "\u{1F4AC} BTW",
+  ask: "\u2753 ASK",
+  assign: "\u{1F4CB} ASSIGN",
+  result: "\u2705 RESULT",
+  review: "\u{1F50D} REVIEW",
+  status: "\u{1F4E8} STATUS",
+  note: "\u{1F4E8} NOTE",
+  broadcast: "\u{1F4E2} BROADCAST",
+  control: "\u2699 CONTROL"
+};
+var TYPE_GUIDANCE = {
+  steer: "After your current operation reaches a stopping point, adjust your approach per the instruction above.",
+  ask: "This agent is waiting for your answer. Reply directly or use mailbox action=send to respond.",
+  assign: "This is a task assignment. Act on it when your current operation allows.",
+  result: "A subagent has completed its work. Factor this result into your next decision.",
+  btw: "FYI only \u2014 absorb the information and stay on your current task; no reply needed.",
+  status: "Peer status update \u2014 use it to avoid duplicate or conflicting work; no reply needed.",
+  review: "This is a review request. Inspect the referenced code/doc/PR when convenient; an immediate reply is not required.",
+  note: "Read for context; no reply needed.",
+  broadcast: "Broadcast message. Read for context; no reply needed.",
+  control: ""
+  // control never reaches this rendering path — see injectPendingMailboxMessages
+};
+var ACTION_FOOTER_TYPES = /* @__PURE__ */ new Set([
+  "ask",
+  "assign",
+  "result",
+  "review"
+]);
+var BACKGROUND_DELIVERY_TYPES = /* @__PURE__ */ new Set([
+  "steer",
+  "ask",
+  "assign",
+  "result",
+  "review"
+]);
+var OUT_OF_BAND_TYPES = /* @__PURE__ */ new Set(["control"]);
+function buildMailboxBtwAwarenessBlock(messages) {
+  if (messages.length === 0) throw new Error("buildMailboxBtwAwarenessBlock called with empty messages");
+  const parts = [];
+  parts.push("[MAILBOX BTW] Mailbox awareness update:");
+  parts.push("");
+  parts.push(
+    "Disclaimer: an agent just sent mail to everyone or to you. Do not stop your current work to look at it; this is only for awareness. This notification came from the WrongStack mailbox system."
+  );
+  parts.push("");
+  for (const m of messages) {
+    const typeLabel = TYPE_LABEL[m.type] ?? `\u{1F4E8} ${m.type.toUpperCase()}`;
+    const scope = m.to === "*" ? "broadcast to everyone" : `addressed to ${m.to}`;
+    parts.push(`--- ${typeLabel} from ${m.from} (${scope}) ---`);
+    parts.push(`Subject: ${m.subject}`);
+    parts.push("");
+    parts.push(m.body);
+    parts.push("");
+  }
+  parts.push("This raw awareness block is request-scoped; absorb it once without quoting or restating it.");
+  parts.push("");
+  parts.push("[END MAILBOX BTW]");
+  return { type: "text", text: parts.join("\n") };
+}
+function buildMailboxBlock(messages) {
+  if (messages.length === 0) throw new Error("buildMailboxBlock called with empty messages");
+  const parts = [];
+  parts.push("[MAILBOX] New message(s) from other agents:");
+  parts.push("");
+  const hasActionable = messages.some((m) => ACTION_FOOTER_TYPES.has(m.type));
+  const steers = [];
+  const rest = [];
+  for (const m of messages) {
+    if (m.type === "steer") steers.push(m);
+    else rest.push(m);
+  }
+  const ordered = [...steers, ...rest];
+  for (const m of ordered) {
+    const typeLabel = TYPE_LABEL[m.type] ?? `\u{1F4E8} ${m.type.toUpperCase()}`;
+    parts.push(`--- ${typeLabel} from ${m.from} ---`);
+    parts.push(`Subject: ${m.subject}`);
+    parts.push("");
+    parts.push(m.body);
+    parts.push("");
+    const guidance = TYPE_GUIDANCE[m.type];
+    if (guidance) {
+      parts.push(`${guidance}`);
+      parts.push("");
+    }
+  }
+  if (hasActionable) {
+    parts.push("Action required: address the items above. When done, use `mailbox action=ack messageId=<id> completed=true` to mark them complete.");
+    parts.push("");
+  }
+  parts.push(
+    "Context policy: this raw mailbox block is request-scoped and will be removed after you evaluate it. Do not quote or restate the mail. If it has a durable consequence, retain only one concise conclusion/action in your response, task state, or tool output; otherwise acknowledge it internally and continue."
+  );
+  parts.push("");
+  parts.push("[END MAILBOX]");
+  return { type: "text", text: parts.join("\n") };
+}
+function removeInjectedMailboxBlocks(messages, injectedBlocks) {
+  if (injectedBlocks.length === 0) {
+    return { messages, changed: false };
+  }
+  const blockRefs = new Set(injectedBlocks);
+  const blockTexts = new Set(injectedBlocks.map((block) => block.text));
+  const next = [];
+  let changed = false;
+  for (const message of messages) {
+    if (!Array.isArray(message.content)) {
+      next.push(message);
+      continue;
+    }
+    const content = message.content.filter((block) => {
+      if (block.type !== "text") return true;
+      const isInjected = blockRefs.has(block) || blockTexts.has(block.text);
+      if (isInjected) changed = true;
+      return !isInjected;
+    });
+    if (content.length === message.content.length) {
+      next.push(message);
+      continue;
+    }
+    if (content.length === 0) continue;
+    const { _estTokens: _staleEstimate, ...rest } = message;
+    next.push({ ...rest, content });
+  }
+  return changed ? { messages: next, changed: true } : { messages, changed: false };
+}
+async function injectPendingMailboxMessages(checkMailbox, foldFn, a, deliveryMode = "inline") {
+  let messages;
+  try {
+    messages = await checkMailbox();
+  } catch {
+    return { interrupt: false };
+  }
+  for (const m of messages) {
+    a.events.emit("mailbox.received", {
+      messageId: m.id,
+      from: m.from,
+      to: m.to,
+      type: m.type,
+      audience: m.audience ?? "all",
+      subject: m.subject
+    });
+  }
+  if (messages.length === 0) return { interrupt: false };
+  const outOfBand = messages.filter((m) => OUT_OF_BAND_TYPES.has(m.type));
+  const content = messages.filter((m) => !OUT_OF_BAND_TYPES.has(m.type));
+  const deliveredContent = deliveryMode === "background" ? content.filter((message) => BACKGROUND_DELIVERY_TYPES.has(message.type)) : content;
+  if (deliveredContent.length > 0) {
+    try {
+      foldFn(buildMailboxBlock(deliveredContent));
+    } catch (err) {
+      (a.logger.debug ?? console.debug)?.(
+        `mailbox: failed to fold messages: ${toErrorMessage(err)}`
+      );
+    }
+  }
+  const interruptMsg = outOfBand.find(
+    (m) => /\b(interrupt|stop|halt|abort|cancel)\b/i.test(`${m.subject} ${m.body}`)
+  );
+  return interruptMsg ? { interrupt: true, interruptReason: interruptMsg.body || interruptMsg.subject || "operator interrupt" } : { interrupt: false };
+}
+
+// src/core/fleet-pulse.ts
+var DEFAULT_MAX_AGENTS = 15;
+var DEFAULT_MAX_CHARS = 900;
+var TASK_SNIPPET_CHARS = 60;
+function fleetPulseSignature(statuses) {
+  return statuses.map((s) => `${s.agentId}|${s.status}|${s.currentTask ?? ""}`).sort().join("\n");
+}
+function visibleLineKey(s) {
+  const role = s.role && s.role !== s.name ? s.role : "";
+  const task = s.currentTask && s.currentTask.length > TASK_SNIPPET_CHARS ? `${s.currentTask.slice(0, TASK_SNIPPET_CHARS)}\u2026` : s.currentTask ?? "";
+  const tool = s.currentTool || "";
+  const toolCalls = s.toolCalls > 0 ? String(s.toolCalls) : "";
+  return [s.name, role, s.status, task, tool, toolCalls].join("\0");
+}
+function peerLine(s, count = 1) {
+  const role = s.role && s.role !== s.name ? ` (${s.role})` : "";
+  const grouped = count > 1 ? ` \xD7${count}` : "";
+  const parts = [`\u2022 ${s.name}${role}${grouped} \u2014 ${s.status}`];
+  if (s.currentTask) {
+    const task = s.currentTask.length > TASK_SNIPPET_CHARS ? `${s.currentTask.slice(0, TASK_SNIPPET_CHARS)}\u2026` : s.currentTask;
+    parts.push(`"${task}"`);
+  }
+  if (s.currentTool) parts.push(`tool: ${s.currentTool}`);
+  if (s.toolCalls > 0) parts.push(`${s.toolCalls} tools`);
+  return parts.join(" \u2014 ");
+}
+function buildFleetPulseBlock(statuses, opts) {
+  const maxAgents = opts.maxAgents ?? DEFAULT_MAX_AGENTS;
+  const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
+  const peers = statuses.filter((s) => s.online && s.agentId !== opts.selfId);
+  if (peers.length === 0) return null;
+  const order = { running: 0, streaming: 0, waiting_user: 1, idle: 2, error: 3, offline: 4 };
+  const sorted = [...peers].sort(
+    (x, y) => (order[x.status] ?? 5) - (order[y.status] ?? 5) || visibleLineKey(x).localeCompare(visibleLineKey(y))
+  );
+  const shown = sorted.slice(0, maxAgents);
+  const hidden = sorted.length - shown.length;
+  const parts = [];
+  parts.push(`[FLEET PULSE] ${peers.length} peer${peers.length === 1 ? "" : "s"} online:`);
+  for (let i = 0; i < shown.length; ) {
+    let run = 1;
+    while (i + run < shown.length && visibleLineKey(shown[i]) === visibleLineKey(shown[i + run])) {
+      run++;
+    }
+    parts.push(peerLine(shown[i], run));
+    i += run;
+  }
+  if (hidden > 0) parts.push(`\u2026 +${hidden} more`);
+  parts.push(
+    "[END FLEET PULSE] (FYI \u2014 coordinate via mail_send; avoid duplicating peers' work)"
+  );
+  let text = parts.join("\n");
+  if (text.length > maxChars) {
+    while (parts.length > 3 && parts.join("\n").length > maxChars) {
+      parts.splice(parts.length - 2, 1);
+    }
+    text = parts.join("\n");
+    if (text.length > maxChars) text = `${text.slice(0, maxChars - 1)}\u2026`;
+  }
+  return { type: "text", text };
+}
+
+// src/mailbox-attach.ts
+function attachMailboxChecker(a, source) {
+  if (!a.ctx.projectRoot) {
+    return async () => [];
+  }
+  try {
+    return attachMailboxCheckerInner(a, source);
+  } catch {
+    return async () => [];
+  }
+}
+function attachMailboxCheckerInner(a, source) {
+  const getMailbox = () => {
+    const projectDir = resolveProjectDir(a.ctx.projectRoot, wstackGlobalRoot());
+    return getSharedProjectMailbox(projectDir, a.events, hqPublisher);
+  };
+  const hqPublisher = createHqPublisherFromEnv({
+    clientKind: source ?? "cli",
+    projectRoot: a.ctx.projectRoot,
+    logger: a.logger,
+    capabilities: ["telemetry.publish", "mailbox.summary"]
+  });
+  hqPublisher?.connect();
+  if (hqPublisher) {
+    a.ctx.registerAgentHook(() => hqPublisher.close());
+  }
+  const surface = source ?? a.ctx.meta["source"] ?? "cli";
+  if (!a.ctx.meta["source"]) a.ctx.meta["source"] = surface;
+  const baseIdOf = () => {
+    const fieldId = a.ctx.agentId && a.ctx.agentId !== "unknown" ? a.ctx.agentId : void 0;
+    return a.ctx.meta["agentId"] ?? fieldId ?? "leader";
+  };
+  const identitySessionId = () => {
+    const owning = a.ctx.meta["sessionId"];
+    return typeof owning === "string" && owning.length > 0 ? owning : a.ctx.session.id;
+  };
+  let registeredAs = "";
+  const ensureRegistered = () => {
+    const derived = `${baseIdOf()}@${mailboxSessionTag(identitySessionId())}`;
+    if (a.ctx.meta["globalAgentId"] !== derived) {
+      a.ctx.meta["globalAgentId"] = derived;
+    }
+    if (registeredAs !== derived) {
+      registeredAs = derived;
+      const identity = resolveMailboxIdentity(a.ctx);
+      getMailbox().registerAgent({
+        agentId: derived,
+        name: `${identity.name} [${surface}]`,
+        role: identity.role,
+        sessionId: identitySessionId(),
+        pid: process.pid,
+        source: surface
+      }).catch((err) => {
+        a.logger.debug(`Failed to register agent ${derived}`, {
+          agentId: derived,
+          err: toErrorMessage(err)
+        });
+      });
+    }
+    return derived;
+  };
+  ensureRegistered();
+  const HEARTBEAT_INTERVAL_MS = MAILBOX_HEARTBEAT_INTERVAL_MS;
+  const heartbeatTimer = setInterval(() => {
+    const id = ensureRegistered();
+    const identity = resolveMailboxIdentity(a.ctx);
+    getMailbox().heartbeat({
+      agentId: id,
+      sessionId: identitySessionId(),
+      name: `${identity.name} [${surface}]`,
+      role: identity.role,
+      pid: process.pid,
+      source: surface
+    }).catch(() => {
+    });
+  }, HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref?.();
+  a.ctx.registerAgentHook(() => {
+    clearInterval(heartbeatTimer);
+  });
+  const mailboxCheckerOptions = {
+    mailbox: getMailbox,
+    agentId: () => ensureRegistered(),
+    role: () => resolveMailboxIdentity(a.ctx).role,
+    aliases: [baseIdOf()],
+    sessionId: () => identitySessionId(),
+    // ACK is deferred to the session-affinity wrapper so messages dropped
+    // by the filter are NOT marked as read by this agent.
+    ack: false
+  };
+  const checkMailbox = createMailboxChecker(mailboxCheckerOptions);
+  const reportStore = new JsonlReportStore(
+    resolveProjectDir(a.ctx.projectRoot, wstackGlobalRoot())
+  );
+  const sessionAffinityCtx = {
+    resolveChimeraReportSessionId: async (reportId) => (await reportStore.get(reportId))?.sessionId
+  };
+  const applySessionAffinityFilter = (checker, ack) => {
+    return async () => {
+      const currentSessionId = identitySessionId();
+      const agentId = ack ? ensureRegistered() : null;
+      const messages = await checker();
+      const filtered = [];
+      for (const m of messages) {
+        if (await acceptMailboxMessageForSession(m, currentSessionId, sessionAffinityCtx)) {
+          filtered.push(m);
+        }
+      }
+      if (ack && filtered.length > 0 && agentId) {
+        void getMailbox().ackMany({
+          acks: filtered.map((m) => ({
+            messageId: m.id,
+            readerId: agentId,
+            read: true
+          }))
+        }).catch(() => {
+        });
+      }
+      return filtered;
+    };
+  };
+  const sessionScopedCheckMailbox = applySessionAffinityFilter(checkMailbox, true);
+  const checkMailboxAwareness = createMailboxChecker({
+    ...mailboxCheckerOptions,
+    // Exclude out-of-band types (control) from awareness polling.
+    // Uses the canonical MAILBOX_TYPE_PROPERTIES outOfBand flag instead
+    // of a hardcoded type string, so a newly-added out-of-band type is
+    // automatically excluded.
+    include: (m) => !MAILBOX_TYPE_PROPERTIES[m.type]?.outOfBand,
+    ack: false
+  });
+  const sessionScopedCheckMailboxAwareness = applySessionAffinityFilter(
+    checkMailboxAwareness,
+    false
+  );
+  const AWARENESS_FALLBACK_INTERVAL_MS = MAILBOX_AWARENESS_INTERVAL_MS;
+  const AWARENESS_PUSH_DEBOUNCE_MS = 500;
+  let pollInFlight = false;
+  let awarenessDisposed = false;
+  let pushDebounceTimer = null;
+  const pollMailboxAwareness = async () => {
+    if (awarenessDisposed || pollInFlight) return;
+    pollInFlight = true;
+    try {
+      const messages = await sessionScopedCheckMailboxAwareness();
+      if (!awarenessDisposed && messages.length > 0 && a.ctx.meta["coordinationContextMode"] !== "background") {
+        setBtwNote(a.ctx, buildMailboxBtwAwarenessBlock(messages).text);
+      }
+    } catch {
+    } finally {
+      pollInFlight = false;
+    }
+  };
+  const triggerPushPoll = () => {
+    if (awarenessDisposed) return;
+    if (pushDebounceTimer !== null) clearTimeout(pushDebounceTimer);
+    pushDebounceTimer = setTimeout(() => {
+      pushDebounceTimer = null;
+      void pollMailboxAwareness();
+    }, AWARENESS_PUSH_DEBOUNCE_MS);
+  };
+  let pushUnsub = null;
+  if (a.events && typeof a.events.onPattern === "function") {
+    pushUnsub = a.events.onPattern("mailbox.message_sent", () => {
+      triggerPushPoll();
+    });
+  }
+  const awarenessTimer = setInterval(() => {
+    void pollMailboxAwareness();
+  }, AWARENESS_FALLBACK_INTERVAL_MS);
+  awarenessTimer.unref?.();
+  a.ctx.registerAgentHook(() => {
+    awarenessDisposed = true;
+    clearInterval(awarenessTimer);
+    if (pushDebounceTimer !== null) clearTimeout(pushDebounceTimer);
+    pushUnsub?.();
+  });
+  return sessionScopedCheckMailbox;
+}
+function attachFleetPulse(a, cfg) {
+  if (!a.ctx.projectRoot || cfg?.enabled === false) {
+    return async () => null;
+  }
+  try {
+    const projectDir = resolveProjectDir(a.ctx.projectRoot, wstackGlobalRoot());
+    const mailbox = getSharedProjectMailbox(projectDir);
+    let lastReadAt = 0;
+    let lastSignature = "";
+    return async () => {
+      try {
+        const now = Date.now();
+        if (now - lastReadAt < PULSE_MIN_READ_INTERVAL_MS) return null;
+        lastReadAt = now;
+        const statuses = await mailbox.getAgentStatuses();
+        const selfId = a.ctx.meta["globalAgentId"] ?? `${a.ctx.agentId ?? "leader"}@${mailboxSessionTag(a.ctx.session.id)}`;
+        const online = statuses.filter((s) => s.online && s.agentId !== selfId);
+        const signature = fleetPulseSignature(online);
+        if (online.length === 0 || signature === lastSignature) return null;
+        const block = buildFleetPulseBlock(statuses, {
+          selfId,
+          maxAgents: cfg?.maxAgents,
+          maxChars: cfg?.maxChars
+        });
+        if (block) lastSignature = signature;
+        return block;
+      } catch {
+        return null;
+      }
+    };
+  } catch {
+    return async () => null;
+  }
+}
+
+// src/core/session-notes.ts
+var META_KEY = "_sessionNotes";
+var MAX_PENDING = 20;
+var MAX_BODY = 2e3;
+function readQueue(ctx) {
+  const raw = ctx.meta[META_KEY];
+  return Array.isArray(raw) ? raw : [];
+}
+function clipBody(body) {
+  const trimmed = body.trim();
+  if (trimmed.length <= MAX_BODY) return trimmed;
+  return `${trimmed.slice(0, MAX_BODY)}\u2026`;
+}
+function enqueueSessionNote(ctx, note) {
+  const body = clipBody(note.body);
+  if (!body) return readQueue(ctx).length;
+  const next = [
+    ...readQueue(ctx),
+    {
+      from: note.from.trim() || "unknown",
+      kind: note.kind,
+      body,
+      ...note.subject?.trim() ? { subject: note.subject.trim() } : {}
+    }
+  ].slice(-MAX_PENDING);
+  ctx.meta[META_KEY] = next;
+  return next.length;
+}
+function pendingSessionNoteCount(ctx) {
+  return readQueue(ctx).length;
+}
+function consumeSessionNotes(ctx) {
+  const notes = readQueue(ctx);
+  if (notes.length > 0) delete ctx.meta[META_KEY];
+  return notes;
+}
+function buildSessionNoteBlock(notes) {
+  const items = notes.map((n) => {
+    const header = n.subject ? `[SESSION ${n.kind.toUpperCase()} from ${n.from} \u2014 ${n.subject}]` : `[SESSION ${n.kind.toUpperCase()} from ${n.from}]`;
+    return `${header}
+${n.body}`;
+  });
+  return [
+    "[Same-session notes \u2014 in-process, not mailbox. Fold into the current task;",
+    "do not restart unless a steer contradicts the goal.]",
+    "",
+    ...items
+  ].join("\n");
+}
+
+// src/session-note-attach.ts
+function attachSessionNotes(a) {
+  const agentId = typeof a.ctx.agentId === "string" && a.ctx.agentId ? a.ctx.agentId : "unknown";
+  const aliases = [];
+  if (agentId === "leader" || isMailboxLeader(agentId)) aliases.push("leader");
+  const off = sessionNoteHub.register({
+    sessionId: () => {
+      try {
+        return resolveOwningSessionId(a.ctx);
+      } catch {
+        return void 0;
+      }
+    },
+    agentId,
+    aliases,
+    deliver: (note) => {
+      enqueueSessionNote(a.ctx, note);
+    },
+    events: a.events
+  });
+  if (typeof a.ctx.registerAgentHook !== "function") {
+    off();
+    return;
+  }
+  a.ctx.registerAgentHook(() => {
+    off();
+  });
+}
+
+// src/core/queued-messages.ts
+var META_KEY2 = "_queuedMessagesAwareness";
+var MAX_ITEMS = 20;
+var MAX_PREVIEW_CHARS = 500;
+function read(ctx) {
+  const raw = ctx.meta[META_KEY2];
+  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((t) => t.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_KEY2];
+    return;
+  }
+  ctx.meta[META_KEY2] = { items, seen: prev?.seen ?? [] };
+}
+function peekQueuedMessages(ctx) {
+  return read(ctx)?.items ?? [];
+}
+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_KEY2];
+    return null;
+  }
+  ctx.meta[META_KEY2] = { items: s.items, seen: s.items };
+  return s.items;
+}
+function buildQueuedMessagesBlock(items) {
+  const body = items.map((t, i) => `${i + 1}. ${t}`).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/agent-types.ts
+var DEFAULT_MAX_ITERATIONS = 100;
+function resolveLoopDetection(cfg) {
+  const steerThreshold = Math.max(2, cfg?.steerThreshold ?? 3);
+  return {
+    mode: cfg?.mode ?? "steer-then-cut",
+    steerThreshold,
+    cutThreshold: Math.max(steerThreshold + 1, cfg?.cutThreshold ?? steerThreshold + 2),
+    windowSize: Math.max(4, cfg?.windowSize ?? 12),
+    callRepeatThreshold: Math.max(2, cfg?.callRepeatThreshold ?? 4)
+  };
+}
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return { blocks: [{ type: "text", text: input }], text: input };
+  }
+  const text = input.filter(isTextBlock).map((b) => b.text).join("");
+  return { blocks: input, text };
+}
+function createDefaultPipelines() {
+  return {
+    request: new Pipeline(),
+    response: new Pipeline(),
+    toolCall: new Pipeline(),
+    userInput: new Pipeline(),
+    assistantOutput: new Pipeline(),
+    contextWindow: new Pipeline()
+  };
+}
+
+// src/core/agent.ts
+import { createHash } from "node:crypto";
+
+// 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;
+  }
+  async function refreshProviderContextLimit(provider, model, opts = {}) {
+    a.ctx.meta ??= {};
+    const routeKey = `${provider.id}/${model}`;
+    const previousRouteKey = a.ctx.meta["contextLimitRouteKey"];
+    const routeChanged = previousRouteKey !== void 0 && previousRouteKey !== routeKey;
+    const previousMaxContext = currentMaxContext();
+    if (routeChanged) {
+      delete a.ctx.meta["providerOverflowMaxContext"];
+      delete a.ctx.meta["contextLimitBaseline"];
+      delete a.ctx.meta["providerLimitEffectiveMaxContext"];
+      delete a.ctx.meta["effectiveMaxContext"];
+      delete a.ctx.meta["effectiveMaxContextSource"];
+      delete a.ctx.meta["contextLimitLastEmittedMaxContext"];
+      delete a.ctx.meta["contextLimitLastEmittedSource"];
+    }
+    a.ctx.meta["contextLimitRouteKey"] = routeKey;
+    const routeMeta = a.ctx.meta["effectiveMaxContext"];
+    const routeProviderCap = provider.capabilities.maxContext;
+    const currentEffective = typeof routeMeta === "number" && routeMeta > 0 ? routeMeta : typeof routeProviderCap === "number" && routeProviderCap > 0 ? routeProviderCap : 2e5;
+    const emitEffectiveLimit = (effective2, source) => {
+      const lastEmitted = a.ctx.meta["contextLimitLastEmittedMaxContext"];
+      const lastEmittedSource = a.ctx.meta["contextLimitLastEmittedSource"];
+      if (lastEmitted === effective2 && lastEmittedSource === source) return;
+      const eventPrevious = typeof lastEmitted === "number" && Number.isFinite(lastEmitted) && lastEmitted > 0 ? Math.floor(lastEmitted) : previousMaxContext;
+      a.ctx.meta["contextLimitLastEmittedMaxContext"] = effective2;
+      a.ctx.meta["contextLimitLastEmittedSource"] = source;
+      a.events.emit("ctx.max_context", {
+        sessionId: resolveEventSessionId(a.ctx),
+        providerId: provider.id,
+        modelId: model,
+        maxContext: effective2,
+        ...eventPrevious > 0 ? { previousMaxContext: eventPrevious } : {},
+        source,
+        decreased: eventPrevious > 0 && effective2 < eventPrevious
+      });
+    };
+    const emitNativeAfterRouteChange = () => {
+      if (routeChanged && currentEffective > 0) {
+        a.ctx.meta["effectiveMaxContext"] = currentEffective;
+        a.ctx.meta["effectiveMaxContextSource"] = "configured";
+        emitEffectiveLimit(currentEffective, "configured");
+      }
+    };
+    const refresh = provider.refreshContextLimit;
+    if (opts.probe === false || !refresh) {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    let discovered;
+    try {
+      discovered = await refresh.call(provider, model, { signal: a.ctx.signal });
+    } catch {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    const providerLimit = discovered?.maxContext;
+    if (typeof providerLimit !== "number" || !Number.isFinite(providerLimit) || providerLimit <= 0) {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    const providerLimitFloored = Math.floor(providerLimit);
+    const existingBaseline = a.ctx.meta["contextLimitBaseline"];
+    const lastApplied = a.ctx.meta["providerLimitEffectiveMaxContext"];
+    const existingOverflow = a.ctx.meta["providerOverflowMaxContext"];
+    const effectiveChangedOutsideProbe = typeof lastApplied === "number" && Number.isFinite(lastApplied) && currentEffective !== Math.floor(lastApplied) && currentEffective !== existingOverflow;
+    const baseline = effectiveChangedOutsideProbe || typeof existingBaseline !== "number" || !Number.isFinite(existingBaseline) || existingBaseline <= 0 ? currentEffective : Math.floor(existingBaseline);
+    a.ctx.meta["contextLimitBaseline"] = baseline;
+    const overflowLimit = a.ctx.meta["providerOverflowMaxContext"];
+    const overflowFloored = typeof overflowLimit === "number" && Number.isFinite(overflowLimit) && overflowLimit > 0 ? Math.floor(overflowLimit) : void 0;
+    const ceilings = [baseline, providerLimitFloored];
+    if (overflowFloored !== void 0) ceilings.push(overflowFloored);
+    const effective = Math.min(...ceilings.filter((limit) => limit > 0));
+    let effectiveSource;
+    if (overflowFloored !== void 0 && effective === overflowFloored) {
+      effectiveSource = "provider_overflow";
+    } else if (effective === providerLimitFloored) {
+      effectiveSource = "provider";
+    } else {
+      effectiveSource = "configured";
+    }
+    a.ctx.meta["effectiveMaxContext"] = effective;
+    a.ctx.meta["providerLimitEffectiveMaxContext"] = effective;
+    a.ctx.meta["effectiveMaxContextSource"] = effectiveSource;
+    emitEffectiveLimit(effective, effectiveSource);
+  }
+  function systemAndToolsOverhead() {
+    const sysRef = a.ctx.systemPrompt;
+    const toolsRef = a.ctx.tools;
+    if (sysRef === _cachedSysRef && toolsRef === _cachedToolsRef && _cachedOverheadTokens > 0) {
+      return _cachedOverheadTokens;
+    }
+    const breakdown = estimateRequestTokens([], sysRef, toolsRef ?? [], calibrationKey());
+    _cachedSysRef = sysRef;
+    _cachedToolsRef = toolsRef;
+    _cachedOverheadTokens = breakdown.systemPrompt + breakdown.tools;
+    return _cachedOverheadTokens;
+  }
+  function stashRequestTokens(req) {
+    const preFlight = estimateRequestTokens(
+      req.messages,
+      req.system,
+      req.tools ?? [],
+      calibrationKey(req.model)
+    );
+    a.ctx.lastRequestTokens = preFlight.total;
+    _lastPreFlightMsgCount = req.messages.length;
+    _lastPreFlightToolCount = (req.tools ?? []).length;
+    _lastPreFlightRevision = a.ctx.state.revision;
+    _cachedSysRef = req.system;
+    _cachedToolsRef = req.tools ?? [];
+    _cachedOverheadTokens = preFlight.systemPrompt + preFlight.tools;
+    a.ctx.meta["lastRequestTokensAt"] = {
+      msgCount: req.messages.length,
+      toolCount: (req.tools ?? []).length,
+      revision: a.ctx.state.revision
+    };
+    return preFlight;
+  }
+  function refreshContextRequestTokenStash(opts = {}) {
+    const msgCount = a.ctx.messages.length;
+    const toolCount = (a.ctx.tools ?? []).length;
+    const revision = a.ctx.state.revision;
+    const stashed = a.ctx.lastRequestTokens;
+    const stashedAt = a.ctx.meta?.["lastRequestTokensAt"];
+    if (!opts.force && typeof stashed === "number" && stashed > 0 && typeof stashedAt === "object" && stashedAt !== null) {
+      const meta = stashedAt;
+      if (meta.msgCount === msgCount && meta.toolCount === toolCount && meta.revision === revision && _lastPreFlightRevision === revision) {
+        return stashed;
+      }
+    }
+    const refreshed = estimateMessageTokens(a.ctx.messages) + systemAndToolsOverhead();
+    a.ctx.lastRequestTokens = refreshed;
+    _lastPreFlightMsgCount = msgCount;
+    _lastPreFlightToolCount = toolCount;
+    _lastPreFlightRevision = revision;
+    a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount, revision };
+    return refreshed;
+  }
+  async function compactContextIfNeeded() {
+    const msgCount = a.ctx.messages.length;
+    const maxContext = currentMaxContext();
+    const revision = a.ctx.state.revision;
+    const toolsRef = a.ctx.tools;
+    const systemRef = a.ctx.systemPrompt;
+    const requestTokens = a.ctx.lastRequestTokens;
+    if (_lastCompactionMsgCount === msgCount && _lastCompactionRevision === revision && _lastCompactionToolsRef === toolsRef && _lastCompactionSystemRef === systemRef && _lastCompactionRequestTokens === requestTokens && _lastCompactionWasNoop && _lastCompactionMaxContext === maxContext && maxContext > 0) {
+      return false;
+    }
+    const beforeMessages = a.ctx.messages;
+    const beforeMsgCount = a.ctx.messages.length;
+    const beforeRevision = a.ctx.state.revision;
+    await a.pipelines.contextWindow.run(a.ctx);
+    _lastCompactionMsgCount = a.ctx.messages.length;
+    _lastCompactionRevision = a.ctx.state.revision;
+    _lastCompactionToolsRef = a.ctx.tools;
+    _lastCompactionSystemRef = a.ctx.systemPrompt;
+    _lastCompactionMaxContext = maxContext;
+    const changed = a.ctx.state.revision !== beforeRevision || a.ctx.messages !== beforeMessages || a.ctx.messages.length !== beforeMsgCount;
+    const tokens = refreshContextRequestTokenStash({ force: changed });
+    _lastCompactionRequestTokens = tokens;
+    const load = maxContext > 0 ? tokens / maxContext : 0;
+    _lastCompactionWasNoop = tokens > 0 && load < 0.5;
+    if (changed) {
+      _lastEmittedMsgCount = -1;
+      _lastEmittedToolCount = -1;
+      _lastEmittedMaxContext = -1;
+    }
+    return changed;
+  }
+  async function buildRequestWithPreflightCompaction(opts) {
+    let prepared = await handlers.response.buildAndRunRequestPipeline(opts);
+    let req = prepared.request;
+    let preFlight = stashRequestTokens(req);
+    let probedRouteKey = `${prepared.provider.id}/${req.model}`;
+    await refreshProviderContextLimit(prepared.provider, req.model);
+    if (await compactContextIfNeeded()) {
+      prepared = await handlers.response.buildAndRunRequestPipeline(opts);
+      req = prepared.request;
+      preFlight = stashRequestTokens(req);
+      const rebuiltRouteKey = `${prepared.provider.id}/${req.model}`;
+      if (rebuiltRouteKey !== probedRouteKey) {
+        probedRouteKey = rebuiltRouteKey;
+        await refreshProviderContextLimit(prepared.provider, req.model);
+        if (await compactContextIfNeeded()) {
+          prepared = await handlers.response.buildAndRunRequestPipeline(opts);
+          req = prepared.request;
+          preFlight = stashRequestTokens(req);
+        }
+      }
+    }
+    return { req, provider: prepared.provider, preFlight };
+  }
+  function emitContextPct() {
+    const msgCount = a.ctx.messages.length;
+    const toolCount = (a.ctx.tools ?? []).length;
+    const maxContext = currentMaxContext();
+    const revision = a.ctx.state.revision;
+    if (msgCount === _lastEmittedMsgCount && toolCount === _lastEmittedToolCount && revision === _lastEmittedRevision && maxContext === _lastEmittedMaxContext && maxContext > 0) {
+      return;
+    }
+    _lastEmittedMsgCount = msgCount;
+    _lastEmittedToolCount = toolCount;
+    _lastEmittedRevision = revision;
+    _lastEmittedMaxContext = maxContext;
+    if (msgCount !== _lastPreFlightMsgCount || toolCount !== _lastPreFlightToolCount || revision !== _lastPreFlightRevision) {
+      refreshContextRequestTokenStash({ force: true });
+    }
+    let total;
+    const anchored = realAnchoredInputTokens(
+      a.ctx.messages,
+      a.ctx.lastRealInputTokens,
+      typeof a.ctx.meta?.["realAnchorMsgCount"] === "number" ? a.ctx.meta["realAnchorMsgCount"] : void 0
+    );
+    const stashed = a.ctx.lastRequestTokens;
+    if (anchored !== null) {
+      total = anchored;
+    } else if (typeof stashed === "number" && stashed > 0) {
+      const cal = getCalibrationState(calibrationKey());
+      total = cal.calibrated ? Math.round(stashed * Math.min(1.5, Math.max(0.5, cal.ratio))) : stashed;
+    } else {
+      const raw = refreshContextRequestTokenStash({ force: true });
+      const cal = getCalibrationState(calibrationKey());
+      total = cal.calibrated ? Math.round(raw * Math.min(1.5, Math.max(0.5, cal.ratio))) : raw;
+    }
+    const rawLoad = maxContext > 0 ? total / maxContext : 0;
+    const load = Math.max(0, Math.min(1, rawLoad));
+    a.events.emit("ctx.pct", {
+      sessionId: resolveEventSessionId(a.ctx),
+      load,
+      rawLoad,
+      tokens: total,
+      maxContext
+    });
+  }
+  return {
+    refreshProviderContextLimit,
+    compactContextIfNeeded,
+    stashRequestTokens,
+    refreshContextRequestTokenStash,
+    buildRequestWithPreflightCompaction,
+    emitContextPct,
+    currentMaxContext,
+    calibrationKey,
+    get lastPreFlightMsgCount() {
+      return _lastPreFlightMsgCount;
+    }
+  };
+}
+
+// src/core/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((t) => t.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);
+}
+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((t) => t.name).join(", ");
+      const hasText = content.some(isTextBlock);
+      const kind = toolUses.length > 0 && hasText ? "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.`
+        );
+      }
+    } else {
+      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 };
+  }
+};
+
+// src/core/iteration-limit.ts
+function requestLimitExtension(opts) {
+  const { events, sessionId, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
+  return new Promise((resolve) => {
+    let resolved = false;
+    const timerFired = () => {
+      if (!resolved) {
+        resolved = true;
+        resolve(0);
+      }
+    };
+    const timer = setTimeout(timerFired, timeoutMs);
+    timer.unref();
+    const deny = () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve(0);
+      }
+    };
+    const grant = (extra) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve(Math.max(0, extra));
+      }
+    };
+    events.emit("iteration.limit_reached", {
+      sessionId,
+      currentIterations,
+      currentLimit,
+      grant,
+      deny
+    });
+    if (autoExtend) {
+      setImmediate(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolve(100);
+        }
+      });
+    }
+  });
+}
+
+// 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);
+  attachSessionNotes(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 injectPendingBtwNotes(onMailboxBlock) {
+    const notes = consumeBtwNotes(a.ctx);
+    if (notes.length === 0) return;
+    const mailboxNotes = notes.filter((note) => note.startsWith("[MAILBOX BTW]"));
+    const regularNotes = notes.filter((note) => !note.startsWith("[MAILBOX BTW]"));
+    if (regularNotes.length > 0) {
+      foldBlockIntoConversation({ type: "text", text: buildBtwBlock(regularNotes) });
+    }
+    if (mailboxNotes.length > 0) {
+      const block = { type: "text", text: buildBtwBlock(mailboxNotes) };
+      foldBlockIntoConversation(block);
+      onMailboxBlock?.(block);
+    }
+  }
+  function injectPendingSessionNotes() {
+    const notes = consumeSessionNotes(a.ctx);
+    if (notes.length === 0) return;
+    foldBlockIntoConversation({ type: "text", text: buildSessionNoteBlock(notes) });
+  }
+  function injectQueueAwareness() {
+    const items = consumeQueuedMessagesUpdate(a.ctx);
+    if (!items) return;
+    foldBlockIntoConversation({ type: "text", text: buildQueuedMessagesBlock(items) });
+  }
+  async function checkIterationLimit(iterationIndex, limit, hasHardLimit, currentIterations, delegateSummaries) {
+    if (hasHardLimit && iterationIndex >= limit) {
+      const extendBy = await requestLimitExtension({
+        events: a.events,
+        sessionId: resolveEventSessionId(a.ctx),
+        currentIterations,
+        currentLimit: limit,
+        autoExtend: a.autoExtendLimit
+      });
+      if (extendBy > 0) {
+        const newLimit = limit + extendBy;
+        a.logger.info(`Iteration limit extended by ${extendBy} (new limit: ${newLimit})`);
+        return { limit: newLimit };
+      }
+      return {
+        limit,
+        exit: { status: "max_iterations", iterations: currentIterations, delegateSummaries }
+      };
+    }
+    return { limit };
+  }
+  async function runInner(inputPayload, opts, controller, autonomousContinue) {
+    await a.pipelines.userInput.run(inputPayload);
+    recordUserIntentEvidence(a.ctx, inputPayload.text);
+    await a.ctx.session.append({
+      type: "user_input",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      content: inputPayload.content
+    });
+    const inputOrigin = isRuntimeContextInput(inputPayload.text) ? "runtime" : "user_input";
+    a.ctx.state.appendMessage({
+      role: "user",
+      content: inputPayload.content,
+      origin: inputOrigin
+    });
+    const promptIndex = a.ctx.messages.filter((m) => m.role === "user").length - 1;
+    const preview = inputPayload.text.slice(0, 80) + (inputPayload.text.length > 80 ? "\u2026" : "");
+    await a.ctx.session.writeCheckpoint(promptIndex, preview);
+    try {
+      await a.ctx.flushConversationJournal();
+      await a.ctx.session.flush();
+    } catch (err) {
+      (a.logger.debug ?? a.logger.warn)?.(`session boundary flush failed: ${toErrorMessage(err)}`);
+    }
+    clearPendingNextSteps(a.ctx);
+    let finalText = "";
+    let iterations = 0;
+    const delegateSummaries = [];
+    let effectiveLimit = opts.maxIterations ?? a.maxIterations;
+    const hasHardLimit = effectiveLimit > 0 && Number.isFinite(effectiveLimit);
+    let recoveryRetries = 0;
+    const pendingMailboxBlocks = [];
+    function clearEvaluatedMailboxBlocks() {
+      if (pendingMailboxBlocks.length === 0) return;
+      const cleaned = removeInjectedMailboxBlocks(a.ctx.messages, pendingMailboxBlocks);
+      pendingMailboxBlocks.length = 0;
+      if (cleaned.changed) {
+        a.ctx.state.replaceMessages(cleaned.messages);
+        a.ctx.lastRealInputTokens = void 0;
+        delete a.ctx.meta["realAnchorMsgCount"];
+        loopContext.refreshContextRequestTokenStash({ force: true });
+      }
+    }
+    const loopDetector = new AgentLoopDetector(a);
+    let pendingLoopSteer = null;
+    let todoReconcileSteers = 0;
+    function queueLoopSteer(text) {
+      pendingLoopSteer = pendingLoopSteer ? `${pendingLoopSteer}
+${text}` : text;
+    }
+    const onSubagentDone = ({ summary, ok }) => {
+      delegateSummaries.push({ summary, ok });
+    };
+    const offSubagentDone = a.events.on("subagent.done", onSubagentDone);
+    const diRunner = a.container.has(TOKENS.ProviderRunner) ? a.container.resolve(TOKENS.ProviderRunner) : null;
+    const statusTracker = a.container.safeResolve(TOKENS.ProviderModelStatusTracker);
+    const baseRunner = diRunner ? (ctx, req) => diRunner.run({
+      provider: providerBoundToRequest(req) ?? ctx.provider,
+      request: req,
+      signal: controller.signal,
+      ctx,
+      events: a.events,
+      retry: a.retry,
+      logger: a.logger,
+      tracer: a.tracer,
+      ...statusTracker ? { statusTracker } : {}
+    }) : async (ctx, req) => runProviderWithRetry({
+      provider: providerBoundToRequest(req) ?? ctx.provider,
+      request: req,
+      signal: controller.signal,
+      ctx,
+      events: a.events,
+      retry: a.retry,
+      logger: a.logger,
+      tracer: a.tracer,
+      ...statusTracker ? { statusTracker } : {}
+    });
+    const customRunner = a.extensions.wrapProviderRunner(baseRunner);
+    try {
+      for (let i = 0; ; i++) {
+        iterations = i + 1;
+        if (controller.signal.aborted) {
+          return {
+            status: "aborted",
+            iterations,
+            abortReason: signalAbortReason(controller.signal)
+          };
+        }
+        try {
+          await a.ctx.session.writeInFlightMarker(`iteration ${i} / max ${a.maxIterations}`);
+        } catch (err) {
+          (a.logger.debug ?? a.logger.warn)?.(
+            `in-flight marker write failed: ${toErrorMessage(err)}`
+          );
+        }
+        if (autonomousContinue) {
+          consumeAutonomousContinue(a.ctx);
+        }
+        const limitCheck = await checkIterationLimit(
+          i,
+          effectiveLimit,
+          hasHardLimit,
+          iterations,
+          delegateSummaries
+        );
+        effectiveLimit = limitCheck.limit;
+        if (limitCheck.exit) {
+          return { ...limitCheck.exit, finalText };
+        }
+        await a.extensions.runBeforeIteration(a.ctx, i);
+        a.events.emit("iteration.started", {
+          sessionId: resolveEventSessionId(a.ctx),
+          ctx: a.ctx,
+          index: i
+        });
+        injectPendingBtwNotes((block) => pendingMailboxBlocks.push(block));
+        injectPendingSessionNotes();
+        injectQueueAwareness();
+        if (pendingLoopSteer) {
+          foldBlockIntoConversation({ type: "text", text: pendingLoopSteer });
+          pendingLoopSteer = null;
+        }
+        if (!backgroundCoordination() && (i % pulseEveryN === 1 || pulseEveryN === 1)) {
+          try {
+            const pulse = await getFleetPulse();
+            if (pulse) foldBlockIntoConversation(pulse);
+          } catch {
+          }
+        }
+        const mailboxResult = await injectPendingMailboxMessages(
+          checkMailbox,
+          (block) => {
+            foldBlockIntoConversation(block);
+            pendingMailboxBlocks.push(block);
+          },
+          {
+            events: {
+              emit: (type, payload) => {
+                a.events.emit(type, payload);
+              }
+            },
+            logger: a.logger
+          },
+          backgroundCoordination() ? "background" : "inline"
+        );
+        if (mailboxResult.interrupt) {
+          const reason = `interrupted: ${mailboxResult.interruptReason ?? "operator request"}`;
+          return { status: "aborted", iterations, abortReason: reason, finalText };
+        }
+        const {
+          req,
+          provider: requestProvider,
+          preFlight
+        } = await loopContext.buildRequestWithPreflightCompaction(opts);
+        await a.ctx.session.append({
+          type: "llm_request",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          model: req.model,
+          messageCount: req.messages.length,
+          estimatedInputTokens: preFlight.total,
+          toolCount: (req.tools ?? []).length
+        }).catch(() => {
+        });
+        let res;
+        try {
+          res = await customRunner(a.ctx, req);
+          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);
+          recordActualUsage(realInputTokens, calibratedTotal, key);
+          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 && loopContext.lastPreFlightMsgCount < previousAnchorMsgCount;
+          if (realInputTokens > 0 && anchorIsPlausible && anchorAdvanced) {
+            a.ctx.lastRealInputTokens = realInputTokens;
+            a.ctx.meta["realAnchorMsgCount"] = loopContext.lastPreFlightMsgCount;
+          }
+          recoveryRetries = 0;
+        } catch (err) {
+          if (controller.signal.aborted) {
+            a.events.emit("error", {
+              sessionId: resolveEventSessionId(a.ctx),
+              err: toError(err),
+              phase: "provider"
+            });
+            return {
+              status: "aborted",
+              iterations,
+              error: toWrongStackError(err, "AGENT_ABORTED"),
+              abortReason: signalAbortReason(controller.signal)
+            };
+          }
+          const extDecision = await a.extensions.runOnError(a.ctx, err, "provider", i);
+          if (extDecision) {
+            if (extDecision.action === "fail") {
+              a.events.emit("error", {
+                sessionId: resolveEventSessionId(a.ctx),
+                err: toError(err),
+                phase: "provider"
+              });
+              return {
+                status: "failed",
+                iterations,
+                error: toWrongStackError(err),
+                delegateSummaries
+              };
+            }
+            if (extDecision.action === "continue") {
+              await a.extensions.runAfterIteration(a.ctx, i);
+              continue;
+            }
+            if (extDecision.action === "retry") {
+              recoveryRetries++;
+              if (recoveryRetries > 2) {
+                a.events.emit("error", {
+                  sessionId: resolveEventSessionId(a.ctx),
+                  err: toError(err),
+                  phase: "provider"
+                });
+                return {
+                  status: "failed",
+                  iterations,
+                  error: toWrongStackError(err),
+                  delegateSummaries
+                };
+              }
+              if (extDecision.model) a.ctx.model = extDecision.model;
+              a.logger.info("Extension requested retry; retrying turn");
+              recordSelfHealingRetry(a, err, "extension-requested provider retry");
+              continue;
+            }
+          }
+          const recovered = await a.errorHandler.recover(err, a.ctx);
+          if (!recovered || recovered.action === "fail") {
+            a.events.emit("error", {
+              sessionId: resolveEventSessionId(a.ctx),
+              err: toError(err),
+              phase: "provider"
+            });
+            return {
+              status: "failed",
+              iterations,
+              error: toWrongStackError(recovered?.error ?? err),
+              delegateSummaries
+            };
+          }
+          if (recovered.action === "retry") {
+            recoveryRetries++;
+            if (recoveryRetries > 2) {
+              a.events.emit("error", {
+                sessionId: resolveEventSessionId(a.ctx),
+                err: toError(err),
+                phase: "provider"
+              });
+              return { status: "failed", iterations, error: toWrongStackError(err) };
+            }
+            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;
+          res = recovered.response;
+        }
+        clearEvaluatedMailboxBlocks();
+        const responseProvider = providerBoundToRequest(req) ?? requestProvider;
+        const responseResult = await handlers.response.processResponse(res, req, responseProvider);
+        await loopContext.refreshProviderContextLimit(responseProvider, req.model, {
+          probe: false
+        });
+        if (responseResult.finalText) {
+          a.ctx.meta["lastAgentOutput"] = responseResult.finalText;
+        }
+        if (responseResult.aborted) {
+          return {
+            status: "aborted",
+            iterations,
+            finalText: responseResult.finalText,
+            delegateSummaries,
+            abortReason: signalAbortReason(controller.signal)
+          };
+        }
+        if (responseResult.done) {
+          return {
+            status: "done",
+            iterations,
+            finalText: responseResult.finalText,
+            delegateSummaries
+          };
+        }
+        finalText = responseResult.finalText;
+        const toolUses = res.content.filter(isToolUseBlock);
+        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 loopContext.compactContextIfNeeded();
+          loopContext.emitContextPct();
+          a.events.emit("iteration.completed", {
+            sessionId: resolveEventSessionId(a.ctx),
+            ctx: a.ctx,
+            index: i
+          });
+          if (a.ctx.agentId === "leader" && a.tools.get("todo") !== void 0 && hasOpenTodos(a.ctx.todos) && todoReconcileSteers < 2) {
+            todoReconcileSteers++;
+            queueLoopSteer(
+              "[todo-reconciliation] The live todo/Kanban list still has open work, but you tried to end the turn without reconciling it. Call the `todo` tool now with the complete current list. Mark work you actually finished as completed, put the one item you are actively working on in_progress, and leave the rest pending. If the current item is genuinely unfinished, continue doing the work before answering; do not merely repeat the previous final response or emit <nextsteps>.\nCanonical live list:\n" + formatTodosForModel(a.ctx.todos) + (hasKanbanBoundTodos(a.ctx.todos) ? "\nEach <kanban board/task> binding must be resent verbatim as `kanbanBoardId`/`kanbanTaskId`; a row without it is not applied to its card." : "")
+            );
+            await a.extensions.runAfterIteration(a.ctx, i);
+            continue;
+          }
+          if (autonomousContinue && responseResult.directive === "continue") {
+            recordAutonomousContinue(a, finalText);
+            await a.extensions.runAfterIteration(a.ctx, i);
+            continue;
+          }
+          if (autonomousContinue && responseResult.directive === "stop") {
+            return { status: "done", iterations, finalText, delegateSummaries };
+          }
+          return { status: "done", iterations, finalText, delegateSummaries };
+        }
+        try {
+          await handlers.tools.executeTools(toolUses);
+        } catch (toolErr) {
+          if (controller.signal.aborted) {
+            return {
+              status: "aborted",
+              iterations,
+              finalText,
+              delegateSummaries,
+              abortReason: signalAbortReason(controller.signal)
+            };
+          }
+          throw toolErr;
+        }
+        if (autonomousContinue && consumeAutonomousContinue(a.ctx)) {
+          await loopContext.compactContextIfNeeded();
+          loopContext.emitContextPct();
+          a.events.emit("iteration.completed", {
+            sessionId: resolveEventSessionId(a.ctx),
+            ctx: a.ctx,
+            index: i
+          });
+          await a.extensions.runAfterIteration(a.ctx, i);
+          continue;
+        }
+        await loopContext.compactContextIfNeeded();
+        loopContext.emitContextPct();
+        a.events.emit("iteration.completed", {
+          sessionId: resolveEventSessionId(a.ctx),
+          ctx: a.ctx,
+          index: i
+        });
+        await a.extensions.runAfterIteration(a.ctx, i);
+        if (autonomousContinue && responseResult.directive === "continue") {
+          continue;
+        }
+        if (autonomousContinue && responseResult.directive === "stop") {
+          return { status: "done", iterations, finalText, delegateSummaries };
+        }
+      }
+    } finally {
+      clearEvaluatedMailboxBlocks();
+      offSubagentDone();
+      const reason = controller.signal.aborted ? "aborted" : "clean";
+      try {
+        await a.ctx.session.clearInFlightMarker(reason);
+        await a.ctx.session.flush();
+      } catch (err) {
+        (a.logger.debug ?? a.logger.warn)?.(
+          `in-flight marker clear failed: ${toErrorMessage(err)}`
+        );
+      }
+    }
+  }
+  return { runInner };
+}
+
+// src/core/agent-tools.ts
+var DIFF_TOOL_NAMES = /* @__PURE__ */ new Set(["edit", "write", "replace", "patch", "diff"]);
+var DIFF_TOOL_EVENT_PREVIEW_MAX = 16e3;
+var SAGE_EVENT_MAX = 2e3;
+function createAgentToolHandler(a) {
+  async function executeSingleWithDecision(tool, use, preToolContext) {
+    const start = Date.now();
+    try {
+      const result = await a.toolExecutor.executeTool(
+        tool,
+        {
+          type: "tool_use",
+          id: use.id,
+          name: use.name,
+          input: use.input
+        },
+        a.ctx,
+        a.perIterationOutputCapBytes,
+        preToolContext
+      );
+      return { result: result.block, durationMs: Date.now() - start };
+    } catch (err) {
+      const msg = toErrorMessage(err);
+      return {
+        result: {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${tool.name}" threw: ${msg}`,
+          is_error: true
+        },
+        durationMs: Date.now() - start
+      };
+    }
+  }
+  function waitForConfirm(info) {
+    if (a.events.listenerCount("tool.confirm_needed") === 0) {
+      console.log(
+        JSON.stringify({
+          level: "warn",
+          event: "confirm.headless_fallback",
+          tool: info.tool.name,
+          toolUseId: info.toolUseId,
+          message: `No tool.confirm_needed listener \u2014 auto-denying "${info.tool.name}" to avoid headless deadlock.`
+        })
+      );
+      return Promise.resolve("deny");
+    }
+    return new Promise((resolve) => {
+      const signal = a.ctx.signal;
+      const onAbort = () => resolve("abort");
+      if (signal.aborted) {
+        resolve("abort");
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+      a.events.emit("tool.confirm_needed", {
+        sessionId: resolveEventSessionId(a.ctx),
+        tool: info.tool,
+        input: info.input,
+        toolUseId: info.toolUseId,
+        suggestedPattern: info.suggestedPattern,
+        decisionSource: info.decisionSource,
+        riskTier: info.riskTier,
+        boundaryReason: info.boundaryReason,
+        resolve: (choice) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve(choice);
+        }
+      });
+    });
+  }
+  function emitToolExecuted(toolUseId, toolName, durationMs, ok, mutating, input, content) {
+    const sig = sizeSignals(toolName, content);
+    const { body, sageLines } = splitSageOutputBlock(content);
+    const sage = capSageLines(sageLines, SAGE_EVENT_MAX);
+    const metadata = recordToolOutputEvidence(a.ctx, {
+      toolUseId,
+      toolName,
+      input,
+      content,
+      ok,
+      outputBytes: sig.outputBytes,
+      outputTokens: sig.outputTokens,
+      outputLines: sig.outputLines
+    });
+    a.events.emit("tool.executed", {
+      sessionId: resolveEventSessionId(a.ctx),
+      ...a.ctx.traceId ? { traceId: a.ctx.traceId } : {},
+      ...a.ctx.activeLogicalRequestId ? { logicalRequestId: a.ctx.activeLogicalRequestId } : {},
+      ...a.ctx.activePromptManifestId ? { promptManifestId: a.ctx.activePromptManifestId } : {},
+      agentId: a.ctx.agentId,
+      agentName: a.ctx.agentName,
+      id: toolUseId,
+      name: toolName,
+      durationMs,
+      ok,
+      mutating,
+      input,
+      output: truncateForEvent(
+        body,
+        DIFF_TOOL_NAMES.has(toolName) ? DIFF_TOOL_EVENT_PREVIEW_MAX : void 0
+      ),
+      ...sage.length > 0 ? { sage } : {},
+      outputBytes: sig.outputBytes,
+      outputTokens: sig.outputTokens,
+      outputLines: sig.outputLines,
+      metadata,
+      taskId: a.ctx.currentKanbanTaskId,
+      boardId: a.ctx.currentKanbanBoardId,
+      ...typeof a.ctx.provider === "object" ? { provider: a.ctx.provider.id } : {},
+      ...a.ctx.model ? { model: a.ctx.model } : {}
+    });
+  }
+  async function executeTools(toolUses) {
+    const selectedToolUses = await a.extensions.runBeforeToolExecution(a.ctx, toolUses);
+    const { outputs } = await a.toolExecutor.executeBatch(
+      selectedToolUses,
+      a.ctx,
+      a.executionStrategy
+    );
+    const useById = new Map(selectedToolUses.map((u) => [u.id, u]));
+    const resultsForMessage = [];
+    const sessionEvents = [];
+    for (const { result, tool, durationMs } of outputs) {
+      if (result.type === "tool_confirm_pending" && tool) {
+        const decision = await waitForConfirm({
+          tool,
+          input: result.input,
+          toolUseId: result.toolUseId,
+          suggestedPattern: result.suggestedPattern,
+          decisionSource: result.decisionSource,
+          riskTier: result.riskTier,
+          boundaryReason: result.boundaryReason
+        });
+        if (decision === "always") {
+          try {
+            await a.permission.trust({ tool: tool.name, pattern: result.suggestedPattern });
+            a.events.emit("trust.persisted", {
+              sessionId: resolveEventSessionId(a.ctx),
+              tool: tool.name,
+              pattern: result.suggestedPattern,
+              decision
+            });
+          } catch {
+          }
+        } else if (decision === "deny") {
+          try {
+            await a.permission.deny({ tool: tool.name, pattern: result.suggestedPattern });
+            a.events.emit("trust.persisted", {
+              sessionId: resolveEventSessionId(a.ctx),
+              tool: tool.name,
+              pattern: result.suggestedPattern,
+              decision
+            });
+          } catch {
+          }
+        }
+        if (decision === "no") {
+          const p = a.permission;
+          p.denyOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
+        }
+        const reRunResult = decision === "yes" || decision === "always" ? await executeSingleWithDecision(
+          tool,
+          {
+            id: result.toolUseId,
+            name: tool.name,
+            input: result.input
+          },
+          result.preToolContext
+        ) : {
+          result: {
+            type: "tool_result",
+            tool_use_id: result.toolUseId,
+            content: decision === "abort" ? `Tool "${tool.name}" was not executed \u2014 the run was aborted while awaiting confirmation.` : decision === "deny" ? `Tool "${tool.name}" denied and blocked for this pattern.` : `Tool "${tool.name}" denied by user.`,
+            is_error: true
+          },
+          durationMs: 0
+        };
+        const use2 = useById.get(reRunResult.result.tool_use_id);
+        if (use2) {
+          await a.pipelines.toolCall.run({
+            toolUse: use2,
+            result: reRunResult.result,
+            ctx: a.ctx,
+            tool
+          });
+          sessionEvents.push({
+            type: "tool_result",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            id: reRunResult.result.tool_use_id,
+            content: reRunResult.result.content,
+            isError: !!reRunResult.result.is_error
+          });
+          emitToolExecuted(
+            reRunResult.result.tool_use_id,
+            tool.name,
+            reRunResult.durationMs,
+            !reRunResult.result.is_error,
+            tool.mutating,
+            result.input,
+            reRunResult.result.content
+          );
+        }
+        resultsForMessage.push(reRunResult.result);
+        continue;
+      }
+      if (result.type !== "tool_result") continue;
+      resultsForMessage.push(result);
+      const use = useById.get(result.tool_use_id);
+      if (!use) continue;
+      await a.pipelines.toolCall.run({ toolUse: use, result, ctx: a.ctx, tool: tool ?? void 0 });
+      sessionEvents.push({
+        type: "tool_result",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        id: result.tool_use_id,
+        content: result.content,
+        isError: !!result.is_error
+      });
+      emitToolExecuted(
+        result.tool_use_id,
+        use.name,
+        durationMs,
+        !result.is_error,
+        tool?.mutating ?? false,
+        use.input,
+        result.content
+      );
+    }
+    if (sessionEvents.length > 0) {
+      await (a.ctx.activeRunSessionWriter ?? a.ctx.session).appendBatch(sessionEvents);
+    }
+    const pendingContext = a.ctx.pendingPostToolContext;
+    a.ctx.pendingPostToolContext = void 0;
+    const contentBlocks = pendingContext ? [{ type: "text", text: pendingContext }, ...resultsForMessage] : resultsForMessage;
+    a.ctx.state.appendMessage({ role: "user", content: contentBlocks });
+    if (contentBlocks.length > 0) {
+      a.ctx.toolAdjacencyDirty = true;
+    }
+    try {
+      await a.ctx.flushConversationJournal();
+      await (a.ctx.activeRunSessionWriter ?? a.ctx.session).flush();
+    } catch (err) {
+      (a.logger.debug ?? a.logger.warn)?.(
+        `tool result boundary flush failed: ${toErrorMessage(err)}`
+      );
+    }
+    await a.extensions.runAfterToolExecution(a.ctx, outputs);
+    return resultsForMessage;
+  }
+  return { executeTools, executeSingleWithDecision };
+}
+
+// src/core/agent.ts
+var Agent = class _Agent {
+  container;
+  tools;
+  providers;
+  events;
+  pipelines;
+  ctx;
+  /** Max agent-loop iterations per run. Mutable so the TUI `/settings` picker
+   *  can apply a new value to the live session (takes effect next run). */
+  maxIterations;
+  executionStrategy;
+  perIterationOutputCapBytes;
+  plugins = [];
+  toolExecutor;
+  autoExtendLimit;
+  /** Resolved loop-detector settings (see `tools.loopDetection`). */
+  loopDetection;
+  autonomousContinue;
+  refreshSystemPrompt;
+  tracer;
+  extensions;
+  _toolHandler;
+  _responseHandler;
+  _loopHandler;
+  _logger;
+  /**
+   * Guards against concurrent `run()` calls on the same Agent instance.
+   * `run()` mutates shared state (`ctx.signal`, `ctx.messages`, token
+   * bookkeeping, compaction state) and a second concurrent call would
+   * interleave those mutations with the first, producing an invalid
+   * conversation or racing abort signals.
+   */
+  _runInProgress = false;
+  /**
+   * Dedup window for byte-identical consecutive inputs. Only accidental
+   * back-to-back duplicates fall inside it — terminal \r\n re-entrancy,
+   * stuck-key bursts, client auto-resubmit loops. A deliberate re-send later
+   * (the classic "continue" nudge after a model switch, or retyping the same
+   * instruction after a failed run) must always execute.
+   */
+  static INPUT_DEDUP_WINDOW_MS = 1500;
+  /**
+   * SHA-256 + submission time of the last committed input content. The pair
+   * powers burst-only dedup: identical text skips a run solely when it lands
+   * within {@link Agent.INPUT_DEDUP_WINDOW_MS} of the previous submission.
+   */
+  _lastInputHash;
+  _lastInputHashAt;
+  constructor(init) {
+    this.container = init.container;
+    this.tools = init.tools;
+    this.providers = init.providers;
+    this.events = init.events;
+    this.pipelines = init.pipelines;
+    this.ctx = init.context;
+    this.maxIterations = init.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    this.executionStrategy = init.executionStrategy ?? "smart";
+    this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
+    this.autoExtendLimit = init.autoExtendLimit ?? false;
+    this.loopDetection = resolveLoopDetection(init.loopDetection);
+    this.autonomousContinue = init.autonomousContinue ?? false;
+    this.refreshSystemPrompt = init.refreshSystemPrompt ?? false;
+    this.tracer = init.tracer;
+    this.extensions = init.extensions ?? new ExtensionRegistry();
+    this._logger = this.container.resolve(TOKENS.Logger).child({ sessionId: this.ctx.session.id });
+    this.extensions.setLogger(this._logger);
+    this.toolExecutor = init.toolExecutor;
+    this._toolHandler = createAgentToolHandler(this);
+    this._responseHandler = createAgentResponseHandler(this);
+    this._loopHandler = createAgentLoopHandler(this, {
+      tools: this._toolHandler,
+      response: this._responseHandler
+    });
+  }
+  get logger() {
+    return this._logger;
+  }
+  get retry() {
+    return this.container.resolve(TOKENS.RetryPolicy);
+  }
+  get errorHandler() {
+    return this.container.resolve(TOKENS.ErrorHandler);
+  }
+  get permission() {
+    return this.container.resolve(TOKENS.PermissionPolicy);
+  }
+  get renderer() {
+    return this.container.safeResolve(TOKENS.Renderer);
+  }
+  disableInteractiveConfirmation() {
+    this.toolExecutor.clearConfirmAwaiter();
+    if (typeof this.permission.setPromptDelegate === "function") {
+      this.permission.setPromptDelegate(void 0);
+    }
+  }
+  register(tool) {
+    this.tools.register(tool);
+  }
+  async use(plugin, api) {
+    await plugin.setup(api);
+    this.plugins.push({ plugin, api });
+  }
+  async teardown() {
+    const errors = [];
+    for (const { plugin, api } of this.plugins.toReversed()) {
+      if (typeof plugin.teardown !== "function") continue;
+      try {
+        await plugin.teardown(api);
+      } catch (err) {
+        errors.push(err);
+      }
+    }
+    this.plugins.length = 0;
+    try {
+      await this.ctx.drainAgentHooks();
+    } catch {
+    }
+    if (errors.length > 0) {
+      throw new AgentError({
+        message: `Agent teardown failed: ${errors.map(String).join("; ")}`,
+        code: "AGENT_RUN_FAILED",
+        context: { failures: errors.length, phase: "plugin-teardown" },
+        // Preserve the FIRST underlying failure as the cause so consumers can
+        // pull type/code off it via `instanceof` checks. The full list is
+        // flattened into the message; we don't keep the array on the error
+        // because WrongStackError.context is Record<string, unknown> and
+        // arrays of unknown Errors would lose their structured fields.
+        cause: errors[0]
+      });
+    }
+  }
+  async run(userInput, opts = {}) {
+    if (this._runInProgress) {
+      throw new AgentError({
+        message: "Agent.run() is already in progress on this instance. Concurrent runs are not supported.",
+        code: "AGENT_RUN_FAILED",
+        context: { phase: "concurrency-guard" }
+      });
+    }
+    let newInputHash;
+    const inputText = typeof userInput === "string" ? userInput : userInput?.prompt ?? "";
+    if (inputText.length > 0) {
+      const hash = createHash("sha256").update(inputText).digest("hex");
+      const elapsed = Date.now() - (this._lastInputHashAt ?? Number.NaN);
+      const burstDuplicate = hash === this._lastInputHash && elapsed >= 0 && elapsed < _Agent.INPUT_DEDUP_WINDOW_MS;
+      if (burstDuplicate) {
+        this._logger.debug(
+          "Duplicate input suppressed: identical text resubmitted inside the dedup burst window."
+        );
+        return {
+          status: "done",
+          iterations: 0
+        };
+      }
+      newInputHash = hash;
+    }
+    this._runInProgress = true;
+    const controller = new RunController({ parentSignal: opts.signal });
+    const signal = controller.signal;
+    this.ctx.signal = signal;
+    const sessionWriter = this.ctx.session;
+    const sessionId = sessionWriter.id;
+    this.ctx.activeRunSessionWriter = sessionWriter;
+    this.ctx.activeRunSessionId = sessionId;
+    this.ctx.activeLogicalRequestId = void 0;
+    this.ctx.activePromptManifestId = void 0;
+    controller.onAbort(() => this.ctx.drainAbortHooks());
+    controller.onAbort(async () => {
+      await sessionWriter.flush().catch(() => {
+      });
+    });
+    this.ctx.tools = this.tools.listForProvider();
+    this.ctx.catalogTools = this.tools.list();
+    const runStartedAt = Date.now();
+    const runStartedIso = new Date(runStartedAt).toISOString();
+    let span;
+    try {
+      if (this.refreshSystemPrompt) {
+        const builder = this.container.safeResolve(TOKENS.SystemPromptBuilder);
+        if (builder) {
+          const onlineAgents = Array.isArray(this.ctx.meta["promptOnlineAgents"]) ? this.ctx.meta["promptOnlineAgents"] : void 0;
+          const systemVariant = this.ctx.meta["systemPromptVariant"];
+          const autonomy = this.ctx.meta["autonomy"];
+          this.ctx.systemPrompt = await builder.build({
+            cwd: this.ctx.cwd,
+            projectRoot: this.ctx.projectRoot,
+            tools: this.ctx.tools,
+            catalogTools: this.ctx.catalogTools,
+            provider: this.ctx.provider.id,
+            model: opts.model ?? this.ctx.model,
+            onlineAgents,
+            ...systemVariant === "lite" || systemVariant === "pro" || systemVariant === "default" ? { systemVariant } : {},
+            ...typeof autonomy === "string" ? { autonomy } : {}
+          });
+        }
+      }
+      span = this.tracer?.startSpan("agent.run", {
+        "agent.model": opts.model ?? this.ctx.model,
+        "agent.executionStrategy": opts.executionStrategy ?? this.executionStrategy
+      });
+      const { blocks, text } = normalizeInput(userInput);
+      const inputPayload = { content: blocks, text, ctx: this.ctx };
+      await this.extensions.runBeforeRun(this.ctx, inputPayload);
+      this._lastInputHash = newInputHash;
+      this._lastInputHashAt = Date.now();
+      this.events.emit("agent.run.started", {
+        sessionId,
+        ctx: this.ctx,
+        model: opts.model ?? this.ctx.model,
+        at: runStartedIso,
+        inputText: text
+      });
+      const autonomousContinue = opts.autonomousContinue ?? this.autonomousContinue;
+      const result = await this._loopHandler.runInner(
+        inputPayload,
+        opts,
+        controller,
+        autonomousContinue
+      );
+      if (result.status === "failed" || result.status === "aborted") {
+        this._lastInputHash = void 0;
+        this._lastInputHashAt = void 0;
+      }
+      span?.setAttribute("agent.status", result.status);
+      span?.setAttribute("agent.iterations", result.iterations);
+      await this.extensions.runAfterRun(this.ctx, result);
+      this.events.emit("agent.run.completed", {
+        sessionId,
+        ctx: this.ctx,
+        status: result.status,
+        iterations: result.iterations,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - runStartedAt
+      });
+      return result;
+    } catch (err) {
+      this._lastInputHash = void 0;
+      this._lastInputHashAt = void 0;
+      const wse = err instanceof AgentError ? err : toWrongStackError(err);
+      const safeError = err instanceof Error ? new Error(err.message) : new Error(String(err));
+      this.events.emit("error", {
+        sessionId,
+        err: safeError,
+        phase: "agent",
+        _original: err instanceof Error ? err : void 0
+      });
+      if (err instanceof Error) span?.recordError(err);
+      span?.setAttribute("agent.status", "failed");
+      const result = {
+        status: signal.aborted ? "aborted" : "failed",
+        iterations: 0,
+        error: wse,
+        abortReason: signal.aborted ? signalAbortReason(signal) : void 0
+      };
+      await this.extensions.runAfterRun(this.ctx, result);
+      if (result.status === "failed") {
+        this.events.emit("agent.run.error", {
+          sessionId,
+          ctx: this.ctx,
+          err: safeError,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - runStartedAt
+        });
+      }
+      this.events.emit("agent.run.completed", {
+        sessionId,
+        ctx: this.ctx,
+        status: result.status,
+        iterations: result.iterations,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - runStartedAt
+      });
+      return result;
+    } finally {
+      span?.end();
+      try {
+        await controller.dispose();
+      } finally {
+        this.ctx.activeRunSessionId = void 0;
+        this.ctx.activeRunSessionWriter = void 0;
+        this.ctx.activeLogicalRequestId = void 0;
+        this.ctx.activePromptManifestId = void 0;
+        this._runInProgress = false;
+      }
+    }
+  }
+  // ── Tool + response execution handled by AgentToolHandler / AgentResponseHandler ──
+};
+
+// src/core/continue-intent.ts
+var CONTINUE_PHRASES = /* @__PURE__ */ new Set([
+  // ── English ──
+  "continue",
+  "cont",
+  "continue continue",
+  "continue working",
+  "keep going",
+  "keep it going",
+  "keep going on",
+  "keep working",
+  "keep on",
+  "carry on",
+  "go on",
+  "goon",
+  "go ahead",
+  "proceed",
+  "proceed further",
+  "onward",
+  "onwards",
+  "next",
+  "next step",
+  "more",
+  "resume",
+  "and continue",
+  "yes continue",
+  "ok continue",
+  // ── Turkish ──
+  "devam",
+  "devam et",
+  "devam et bakalim",
+  "devam edelim",
+  "devam edin",
+  "devam etsene",
+  "devam etsenize",
+  "devam ediyoruz",
+  "devam et lutfen",
+  "surdur",
+  "devam etsen",
+  "devam et hadi",
+  "hadi devam",
+  "bir tur daha",
+  "bir tur daha at",
+  "bir tur daha bakalim",
+  "bir tur daha atalim",
+  "bir tur daha at bakalim",
+  // ── Other Latin-script (light coverage) ──
+  "weiter",
+  // de
+  "mach weiter",
+  // de
+  "continuar",
+  // es/pt
+  "continua",
+  // es/it/pt
+  "continuer",
+  // fr
+  "continue por favor"
+  // pt/es
+]);
+var POLITENESS_SUFFIXES = [
+  "please",
+  "pls",
+  "plz",
+  "lutfen",
+  "thanks",
+  "thank you",
+  "thx",
+  "ty"
+];
+function foldDiacritics(s) {
+  return s.replace(/ü/g, "u").replace(/ö/g, "o").replace(/ç/g, "c").replace(/ş/g, "s").replace(/ğ/g, "g").replace(/ı/g, "i").replace(/İ/g, "i").replace(/â/g, "a").replace(/î/g, "i").replace(/û/g, "u");
+}
+function normalizeContinueInput(raw) {
+  let s = raw.trim().toLowerCase();
+  s = foldDiacritics(s);
+  s = s.replace(/^["'`]+/, "").replace(/["'`]+$/, "");
+  s = s.replace(/^[\s.!?,;:…]+/, "").replace(/[\s.!?,;:…]+$/, "");
+  s = s.replace(/\s+/g, " ").trim();
+  for (const suffix of POLITENESS_SUFFIXES) {
+    if (s === suffix) break;
+    if (s.endsWith(` ${suffix}`)) {
+      s = s.slice(0, s.length - suffix.length - 1).trim();
+      break;
+    }
+  }
+  return s;
+}
+var MAX_CONTINUE_WORDS = 4;
+function detectContinueIntent(raw) {
+  if (!raw) return false;
+  if (raw.length > 40) return false;
+  const normalized = normalizeContinueInput(raw);
+  if (!normalized) return false;
+  if (normalized.split(" ").length > MAX_CONTINUE_WORDS) return false;
+  return CONTINUE_PHRASES.has(normalized);
+}
+function ellipsize(s, max = 72) {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}\u2026`;
+}
+function resolveContinuation(input) {
+  const todos = Array.isArray(input.todos) ? input.todos : [];
+  const suggestions = (Array.isArray(input.suggestions) ? input.suggestions : []).filter(
+    (s) => typeof s === "string" && s.trim().length > 0
+  );
+  if (hasOpenTodos(todos)) {
+    const inProgress = todos.find((t) => t.status === "in_progress");
+    const next = inProgress ?? todos.find((t) => t.status === "pending");
+    if (next) {
+      const total = todos.length;
+      const done = todos.filter((t) => t.status === "completed").length;
+      const item = next.status === "in_progress" && next.activeForm ? next.activeForm : next.content;
+      const BOARD_MAX_ROWS = 20;
+      const board = todos.slice(0, BOARD_MAX_ROWS).map((t) => {
+        const mark = t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
+        const flatContent = t.content.replace(/\n|\r/g, " ");
+        return `  ${mark} ${flatContent}`;
+      });
+      if (todos.length > BOARD_MAX_ROWS) {
+        board.push(`  \u2026 ${todos.length - BOARD_MAX_ROWS} more`);
+      }
+      const text2 = [
+        "Continue with the plan. Resume work on the next open todo:",
+        "",
+        `  ${item}`,
+        "",
+        `Current todo board (${done}/${total} todos complete.):`,
+        ...board,
+        "",
+        "If this item is already done, mark it complete and move to the next open todo. Keep the board honest as you work \u2014 mark finished items completed and split items that need more than one turn. When every todo is complete, stop and give a short summary \u2014 do not invent new work."
+      ].join("\n");
+      return {
+        source: "todo",
+        todoId: next.id,
+        text: text2,
+        label: `\u25B6 Continue \u2192 todo: ${ellipsize(item)}`
+      };
+    }
+  }
+  const top = suggestions[0];
+  if (top) {
+    const text2 = [
+      "Continue. Proceed with this next step:",
+      "",
+      `  ${top}`,
+      "",
+      "Carry it out now. When it is done, briefly report the result."
+    ].join("\n");
+    return { source: "suggestion", text: text2, label: `\u25B6 Continue \u2192 ${ellipsize(top)}` };
+  }
+  const text = [
+    "Continue working.",
+    "",
+    "There is no explicit pending task queued, so decide the single most valuable next step yourself based on our conversation so far and the current state of the project, then carry it out.",
+    "",
+    "Prefer finishing, verifying, or hardening work already in progress over starting something unrelated. If the work is genuinely complete and nothing sensible remains, say so plainly in one or two sentences and propose a direction \u2014 do not fabricate busywork."
+  ].join("\n");
+  return { source: "open", text, label: "\u25B6 Continue \u2192 (no pending task \u2014 choosing next step)" };
+}
+
+// src/core/input-builder.ts
+var InputBuilder = class {
+  store;
+  pasteLineThreshold;
+  pasteCharThreshold;
+  display = "";
+  refs = [];
+  constructor(opts) {
+    this.store = opts.store;
+    this.pasteLineThreshold = opts.pasteLineThreshold ?? 8;
+    this.pasteCharThreshold = opts.pasteCharThreshold ?? 2e3;
+  }
+  get text() {
+    return this.display;
+  }
+  get attachments() {
+    return [...this.refs];
+  }
+  get isEmpty() {
+    return this.display.trim().length === 0;
+  }
+  appendText(text) {
+    this.display += text;
+  }
+  /**
+   * Decide whether a chunk of pasted text is "big" enough to collapse.
+   * If yes, store it and append a placeholder. If no, inline it.
+   * Returns the placeholder string actually appended (or `null` if inlined).
+   */
+  async appendPaste(text) {
+    if (this.shouldCollapse(text)) {
+      const ref = await this.store.add({
+        kind: "text",
+        data: text,
+        meta: { label: paragraphLabel(text) }
+      });
+      const placeholder = `[pasted #${ref.seq}]`;
+      this.display += placeholder;
+      this.refs.push(ref);
+      return placeholder;
+    }
+    this.display += text;
+    return null;
+  }
+  /**
+   * Always collapses to `[image #N]` — images are never inlined.
+   * `dataBase64` is the raw base64 payload (no data: prefix).
+   */
+  async appendImage(dataBase64, mediaType) {
+    const ref = await this.store.add({
+      kind: "image",
+      data: dataBase64,
+      meta: { mediaType, label: `${mediaType.split("/")[1]?.toUpperCase() ?? "IMG"}` }
+    });
+    const placeholder = `[image #${ref.seq}]`;
+    this.display += placeholder;
+    this.refs.push(ref);
+    return placeholder;
+  }
+  async appendFile(input) {
+    const ref = await this.store.add({ ...input, kind: "file" });
+    const placeholder = `[file #${ref.seq}]`;
+    this.display += placeholder;
+    this.refs.push(ref);
+    return placeholder;
+  }
+  /**
+   * Register-only variant of `appendPaste`. Always stores the paste and
+   * returns the inline `[pasted #N, L lines]` token WITHOUT mutating
+   * `display` — the caller (TUI) owns its own editable buffer as the single
+   * source of truth, inserts the token there, and expands the buffer at
+   * submit. The collapse decision is the caller's (it gates this call); use
+   * `wouldCollapse()` for that.
+   */
+  async registerPaste(text) {
+    const ref = await this.store.add({
+      kind: "text",
+      data: text,
+      meta: { label: paragraphLabel(text) }
+    });
+    this.refs.push(ref);
+    const lines = text.split(/\r?\n|\r/).length;
+    return `[pasted #${ref.seq}, ${lines} lines]`;
+  }
+  /**
+   * Register-only variant of `appendImage` — see `registerPaste`. Returns a
+   * seq-keyed `[image #N, LABEL]` token; does not touch `display`.
+   */
+  async registerImage(dataBase64, mediaType) {
+    const label = `${mediaType.split("/")[1]?.toUpperCase() ?? "IMG"}`;
+    const ref = await this.store.add({
+      kind: "image",
+      data: dataBase64,
+      meta: { mediaType, label }
+    });
+    this.refs.push(ref);
+    return `[image #${ref.seq}, ${label}]`;
+  }
+  /**
+   * Register-only variant of `appendFile` — see `registerPaste`. Returns a
+   * path-keyed `[file:<path>]` token (resolved by path at expand time); does
+   * not touch `display`. The path is read from `meta.filename` (falling back
+   * to `meta.label`).
+   */
+  async registerFile(input) {
+    const ref = await this.store.add({ ...input, kind: "file" });
+    this.refs.push(ref);
+    const path = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path}]`;
+  }
+  /**
+   * Whether `appendPaste(text)` would collapse the text to a placeholder
+   * (rather than inlining it). Lets a frontend decide where to route a paste
+   * — e.g. collapsed pastes become a pill, while inlined ones can be shown
+   * in the editable input row — without calling `appendPaste` first (which
+   * mutates the display buffer).
+   */
+  wouldCollapse(text) {
+    return this.shouldCollapse(text);
+  }
+  /** Reset display and ref list. Does NOT clear the store itself. */
+  reset() {
+    this.display = "";
+    this.refs.length = 0;
+  }
+  /**
+   * Resolve the current display string into ContentBlock[]. Empty
+   * input returns an empty array — caller decides what to do.
+   */
+  async submit() {
+    const text = this.display;
+    this.reset();
+    return text ? this.store.expand(text) : [];
+  }
+  shouldCollapse(text) {
+    if (text.length >= this.pasteCharThreshold) return true;
+    let lines = 1;
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === 10) lines++;
+      else if (c === 13 && text.charCodeAt(i + 1) !== 10) lines++;
+      if (lines >= this.pasteLineThreshold) return true;
+    }
+    return false;
+  }
+};
+function paragraphLabel(text) {
+  const lines = text.split(/\r?\n|\r/).length;
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (bytes < 1024) return `${lines} lines, ${bytes} B`;
+  return `${lines} lines, ${(bytes / 1024).toFixed(1)} KB`;
+}
+
+export {
+  createMailboxChecker,
+  buildMailboxBtwAwarenessBlock,
+  buildMailboxBlock,
+  injectPendingMailboxMessages,
+  attachMailboxChecker,
+  enqueueSessionNote,
+  pendingSessionNoteCount,
+  consumeSessionNotes,
+  buildSessionNoteBlock,
+  attachSessionNotes,
+  setQueuedMessagesSnapshot,
+  peekQueuedMessages,
+  consumeQueuedMessagesUpdate,
+  buildQueuedMessagesBlock,
+  DEFAULT_MAX_ITERATIONS,
+  createDefaultPipelines,
+  Agent,
+  detectContinueIntent,
+  resolveContinuation,
+  InputBuilder
+};
+//# sourceMappingURL=chunk-YOPAUVU4.js.map