@namzu/cli 38.1.1 → 39.0.0

package/dist/chunks/{chunk-WXMFE5SS.js → chunk-OXJEMOBQ.js}

@@ -2,17 +2,19 @@ import { createRequire as __namzuCreateRequire } from 'node:module';
 const require = __namzuCreateRequire(import.meta.url);
 import {
   openManagedWorktrees
-} from "./chunk-54BF5YUB.js";
+} from "./chunk-LFVQSMJG.js";
 import {
   createSessionSkillCatalog
-} from "./chunk-6N6HLU4F.js";
+} from "./chunk-YKEPC6NH.js";
+import {
+  diffColors,
+  theme
+} from "./chunk-CDYUGK7F.js";
 import {
   createBrowserControl
 } from "./chunk-WHODOMXA.js";
 import {
   SAVE_SKILL_TOOL_NAME,
-  WORKFLOW_TOOL_DESCRIPTION,
-  WORKFLOW_TOOL_NAME,
   attachAgentView,
   closeOpenAgents,
   completionNotice,
@@ -21,16 +23,15 @@ import {
   readStoredTurnGuards,
   reduceRunView,
   resolveTurnGuards,
-  viewFromJournal,
-  workflowOffered,
-  workflowRefusal
-} from "./chunk-AMT74CY7.js";
+  settledElapsed,
+  viewFromJournal
+} from "./chunk-HV77F4SF.js";
 import {
   connectMcpServers
-} from "./chunk-LQFMXCHI.js";
+} from "./chunk-W27ZDC4R.js";
 import {
   openInBrowser
-} from "./chunk-WWGLUAHZ.js";
+} from "./chunk-EUU4TDTH.js";
 import {
   CredentialRefreshRejectedError,
   CredentialWithdrawnError,
@@ -38,24 +39,30 @@ import {
   ensureFreshStoredCodexCredential,
   readSubscriptionCredential,
   sameOAuthCredential
-} from "./chunk-FDAOPSRK.js";
+} from "./chunk-DFA5OB46.js";
 import {
   debugRequested
 } from "./chunk-GNBMKISG.js";
 import {
+  DEFAULT_WORKFLOW_SIZE_GUIDELINE,
   LOCAL_CONFIG_FILE,
   configuredPassthroughTools,
+  parseTokenTarget,
   resolveToolResultScreens,
-  unmatchedPassthroughTools
-} from "./chunk-OUTFB7EJ.js";
+  unmatchedPassthroughTools,
+  workflowSizeAdvice,
+  workflowTokenCeiling
+} from "./chunk-GU5YARBU.js";
 import {
   formatSize,
   homePath,
-  plural
-} from "./chunk-US5ZFPAU.js";
+  plural,
+  productName,
+  stringWidth
+} from "./chunk-AXCOWIIH.js";
 import {
   createLazyCodeAnalysis
-} from "./chunk-YA4IH46E.js";
+} from "./chunk-N3FI7O4U.js";
 import {
   canSelectModel,
   chainCapabilityDisagreements,
@@ -78,7 +85,7 @@ import {
   requiresCredentialForModel,
   resolveChainCapabilities,
   unresolvedMembers
-} from "./chunk-5DJ5YIHY.js";
+} from "./chunk-XJ4IUCH6.js";
 import {
   PROVIDER_REGISTRY,
   missingCredentialMessage,
@@ -87,11 +94,11 @@ import {
 import {
   isPermissionMode,
   permissionModeLabel
-} from "./chunk-UASN4SLO.js";
+} from "./chunk-2VMMTC2V.js";
 import {
   conversationLogPath,
   ensureSessionStarted
-} from "./chunk-42CAONYE.js";
+} from "./chunk-UBOPUGDN.js";
 import {
   INSTRUCTIONS_FILENAME,
   MAX_CHARS_PER_FILE,
@@ -102,26 +109,26 @@ import {
 import {
   compilePermissions,
   isPermissionEffect
-} from "./chunk-FHDYGPGC.js";
+} from "./chunk-CZEU2JYJ.js";
 import {
   cliLogger
-} from "./chunk-52E6DDZD.js";
+} from "./chunk-CUOWARJI.js";
 import {
   probeCapabilities
 } from "./chunk-OH6TB27S.js";
 import {
   activeZenCatalogue,
   isOfferableModel
-} from "./chunk-U3JIZFOS.js";
+} from "./chunk-IE5XIE4W.js";
 import {
   ensurePrivateStateDirectory
-} from "./chunk-GIBXNY7Z.js";
+} from "./chunk-4K2NRXHJ.js";
 import {
   restrictToOwner
-} from "./chunk-MW3PKVXY.js";
+} from "./chunk-MCNEFI5Q.js";
 import {
   namzuHomePath
-} from "./chunk-AEB7KCO6.js";
+} from "./chunk-AZ3YHVFA.js";
 import {
   AgentManager,
   AgentRegistry,
@@ -129,7 +136,6 @@ import {
   BOOT_EVENT_NAMES,
   BackgroundJobRegistry,
   CODING_AGENT_DELEGATION_DOCTRINE,
-  CODING_AGENT_HYPERMODE_DOCTRINE,
   CODING_AGENT_WORKING_DOCTRINE,
   COMPUTER_USE_TOOL_NAME,
   CompletionInbox,
@@ -219,11 +225,13 @@ import {
   createUserMessage,
   deferred,
   defineTool,
+  diffWords,
   discoverAgentDefinitions,
   discoverAllPluginDirs,
   ensureProject,
   external_exports,
   filtered,
+  formatCompletionNotification,
   formatMonitorEnd,
   formatMonitorEvent,
   generateSessionId,
@@ -267,6 +275,7 @@ import {
   selectAssistantText,
   selectTaskContext,
   slugifyMemoryName,
+  structuredPatch,
   toToolSourceRef,
   toolWireSchema,
   toolset,
@@ -275,7 +284,7 @@ import {
   windowsShellNotice,
   withProviderFallback,
   wrapUntrusted
-} from "./chunk-XM3W7NMM.js";
+} from "./chunk-RQBT4RVE.js";
 import {
   __name
 } from "./chunk-76FLAFCG.js";
@@ -430,10 +439,10 @@ var tail = Promise.resolve();
 var nextStart = 0;
 function cancelled(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const abort = /* @__PURE__ */ __name(() => reject(signal.reason), "abort");
     signal.addEventListener("abort", abort, { once: true });
-    promise.then(resolve11, reject).finally(() => signal.removeEventListener("abort", abort));
+    promise.then(resolve13, reject).finally(() => signal.removeEventListener("abort", abort));
   });
 }
 __name(cancelled, "cancelled");
@@ -474,8 +483,8 @@ async function searchExa(query2, limit, context) {
   const deadline = Date.now() + DEADLINE_MS;
   const previous = tail;
   let release;
-  tail = new Promise((resolve11) => {
-    release = resolve11;
+  tail = new Promise((resolve13) => {
+    release = resolve13;
   });
   let acquired = false;
   try {
@@ -624,6 +633,654 @@ function createWebSearchTool() {
 }
 __name(createWebSearchTool, "createWebSearchTool");
 
+// src/tui/capability-notice.ts
+function describeCapabilityNotice(input) {
+  const name = productName(input.providerId) ?? "This provider";
+  if (input.contentSource === "media-limit") {
+    return "This conversation holds more pictures or files than this model accepts at once, so Namzu left the oldest out of what it sends. They stay in the conversation.";
+  }
+  if (input.contentSource === "media-removed-current") {
+    return input.capability === "documents" ? "The document you just attached couldn\u2019t be processed, so Namzu left it out of this reply. It stays in the conversation; attach a corrected copy to try again." : "The picture you just attached couldn\u2019t be processed, so Namzu left it out of this reply. It stays in the conversation; attach a corrected copy to try again.";
+  }
+  if (input.contentSource === "media-removed") {
+    return input.capability === "documents" ? "A document in this conversation couldn\u2019t be processed, so Namzu left it out of what it sends. It stays in the conversation; attach a corrected copy to try again." : "A picture in this conversation couldn\u2019t be processed, so Namzu left it out of what it sends. It stays in the conversation; attach a corrected copy to try again.";
+  }
+  if (input.contentSource === "history") {
+    return "This model can\u2019t read images, so Namzu is leaving pictures out of what it sends. They come back if you pick a model that reads images with /model.";
+  }
+  if (input.contentSource === "tool-result") {
+    return input.capability === "documents" ? `${name} can\u2019t read documents, so Namzu gave it a text note in place of a document a tool returned. Switch to a provider that reads documents to include it.` : `${name} can\u2019t see images, so Namzu gave it a text note in place of a picture a tool returned. Switch to a provider that reads images to include it.`;
+  }
+  switch (input.capability) {
+    case "tools":
+      return `${name} can\u2019t use tools, so Namzu will only chat while you use it. Switch to another provider to let Namzu work with files and commands.`;
+    case "vision":
+      return `${name} can\u2019t see images, so it won\u2019t see the picture you attached. Switch to a provider that reads images to include it.`;
+    case "documents":
+      return `${name} can\u2019t read documents, so it won\u2019t see the file you attached. Switch to a provider that reads documents to include it.`;
+  }
+}
+__name(describeCapabilityNotice, "describeCapabilityNotice");
+function describeHistoryRepairNotice(input) {
+  if (input.source === "provider-rejected-image") {
+    const count = input.rejectedImages ?? 0;
+    const what = count > 1 ? `${count.toLocaleString("en-US")} pictures you attached` : "a picture you attached";
+    const name = productName(input.providerId);
+    return name ? `${name} didn\u2019t accept ${what}. Namzu kept the file but will leave it out of later messages. Attach a corrected copy to try again.` : `${what.charAt(0).toUpperCase()}${what.slice(1)} wasn\u2019t accepted. Namzu kept the file but will leave it out of later messages. Attach a corrected copy to try again.`;
+  }
+  if ((input.interruptedCalls ?? 0) > 0) {
+    return input.source === "abandoned-checkpoint" ? "Your last reply was cut off before its steps finished, so Namzu marked them as unfinished. Check any files or commands they touched before asking again." : "Some steps in this conversation never finished, so Namzu marked them as unfinished. Check any files or commands they touched before asking again.";
+  }
+  return "Namzu cleaned up some leftover steps from earlier in this conversation. Nothing you need to do.";
+}
+__name(describeHistoryRepairNotice, "describeHistoryRepairNotice");
+var FALLBACK_WHY = {
+  rate_limit: "was too busy",
+  overloaded: "was too busy",
+  server_error: "kept failing",
+  timeout: "did not answer in time",
+  network: "could not be reached",
+  auth: "did not accept the sign-in",
+  not_found: "does not have that model"
+};
+function describeProviderFallbackNotice(input) {
+  const from = productName(input.fromProviderId) ?? "The first provider";
+  const to = productName(input.toProviderId) ?? "another provider";
+  const why = FALLBACK_WHY[input.reason] ?? "could not answer";
+  return `${from} ${why}, so Namzu used ${to} for the rest of that reply.`;
+}
+__name(describeProviderFallbackNotice, "describeProviderFallbackNotice");
+function withDebugDetail(plain, raw, debug) {
+  return debug && raw.trim() !== "" ? `${plain}
+${raw}` : plain;
+}
+__name(withDebugDetail, "withDebugDetail");
+
+// src/tui/compaction-rows.ts
+var COMPACTING_LABEL = "Compacting conversation\u2026";
+var COMPACTED_TEXT = "Conversation compacted";
+var COMPACTED_HINT = "(ctrl+o for history)";
+var COMPACT_RESULT_TEXT = "Compacted";
+var COMPACT_RESULT_HINT = "(ctrl+o to see full summary)";
+var NOTHING_TO_COMPACT_TEXT = "Nothing to compact yet. The conversation is still short enough.";
+var COMPACT_NOT_SAVED_TEXT = "This conversation could not be saved, so the summary lasts only until you quit.";
+function approximate(tokens) {
+  return tokens >= 1e3 ? `${Math.round(tokens / 1e3)}k` : String(tokens);
+}
+__name(approximate, "approximate");
+function compactionHistoryLines(event) {
+  const messages = /* @__PURE__ */ __name((n) => `${n} message${n === 1 ? "" : "s"}`, "messages");
+  const about = event.measuredBy === "estimate" ? "about " : "";
+  return [
+    `${messages(event.messagesBefore)} became ${messages(event.messagesAfter)}.`,
+    `Context went from ${about}${approximate(event.tokensBefore)} to ${about}${approximate(event.tokensAfter)} tokens.`
+  ];
+}
+__name(compactionHistoryLines, "compactionHistoryLines");
+function stripCompactionMarker(text) {
+  return text.replace(/^\[COMPACTED CONTEXT\][^\n]*\n*/u, "").trimStart();
+}
+__name(stripCompactionMarker, "stripCompactionMarker");
+function compactionSummaryLines(text) {
+  const body = stripCompactionMarker(text).trimEnd();
+  return body.length > 0 ? body.split("\n") : ["(the summary was empty)"];
+}
+__name(compactionSummaryLines, "compactionSummaryLines");
+function describeCompactionFailure(event, debug) {
+  switch (event.cause) {
+    case "reducer_threw":
+      return withDebugDetail(
+        "Compaction failed \xB7 the summary could not be written. Your conversation is unchanged and Namzu will try again.",
+        event.error ?? "",
+        debug
+      );
+    case "shed_nothing":
+      return "Compaction failed \xB7 conversation could not be reduced below the context limit. Your conversation is unchanged; a large file or tool output is probably filling it, so try reading it in smaller parts.";
+    case "split_tool_pair":
+      return withDebugDetail(
+        "Compaction failed \xB7 the summary could not be used. Your conversation is unchanged.",
+        event.error ?? "",
+        debug
+      );
+    case "breaker_open":
+      return "Automatic compaction is paused for this reply after repeated attempts that freed nothing.";
+    case "refilling":
+      return withDebugDetail(
+        "The context filled up again right after being compacted, three times in a row. A file being read or a tool output is probably too large. Try reading it in smaller parts.",
+        event.error ?? "",
+        debug
+      );
+  }
+}
+__name(describeCompactionFailure, "describeCompactionFailure");
+
+// src/tui/diff-rows.ts
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+
+// src/tui/truncation.ts
+var EXPAND_HINT = "(ctrl+o to expand)";
+var HIDDEN_SIZE_FROM_CHARS = 1e3;
+function hiddenLinesHint(lines, options = {}) {
+  const noun = lines === 1 ? "line" : "lines";
+  const action = options.canExpand === false ? "" : ` ${EXPAND_HINT}`;
+  const size = options.chars !== void 0 && options.chars >= HIDDEN_SIZE_FROM_CHARS ? ` (~${Math.max(1, Math.round(options.chars / 1024)).toLocaleString("en-US")} KB)` : "";
+  return `\u2026 +${lines.toLocaleString("en-US")} ${noun}${action}${size}`;
+}
+__name(hiddenLinesHint, "hiddenLinesHint");
+function clipText(text, max) {
+  if (text.length <= max) return text;
+  const room = Math.max(0, max - 1);
+  let end = room;
+  const last = text.charCodeAt(end - 1);
+  if (end > 0 && last >= 55296 && last <= 56319) end -= 1;
+  return `${text.slice(0, end)}\u2026`;
+}
+__name(clipText, "clipText");
+
+// src/tui/diff-view.ts
+var CREATE_PREVIEW_ROWS = 10;
+var WORKSPACE_PREVIEW_ROWS = 40;
+var MAX_LINE_CHARS = 2e3;
+var WORD_DIFF_RATIO = 0.4;
+var TAB_STOP = 8;
+var HUNK_GAP = "...";
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function expandTabs(text) {
+  if (!text.includes("	")) return text;
+  let out = "";
+  let column = 0;
+  for (const { segment } of segmenter.segment(text)) {
+    if (segment === "	") {
+      const fill = TAB_STOP - column % TAB_STOP;
+      out += " ".repeat(fill);
+      column += fill;
+    } else {
+      out += segment;
+      column += stringWidth(segment);
+    }
+  }
+  return out;
+}
+__name(expandTabs, "expandTabs");
+function cutLine(code) {
+  if (code.length <= MAX_LINE_CHARS) return { code, cut: 0 };
+  let end = MAX_LINE_CHARS;
+  const last = code.charCodeAt(end - 1);
+  if (last >= 55296 && last <= 56319) end -= 1;
+  return { code: code.slice(0, end), cut: code.length - end };
+}
+__name(cutLine, "cutLine");
+function truncationNote(cut) {
+  return ` \u2026 [+${cut.toLocaleString("en-US")} chars]`;
+}
+__name(truncationNote, "truncationNote");
+function wrapRuns(runs, width) {
+  const rows = [[]];
+  let used = 0;
+  for (const run2 of runs) {
+    let pending = "";
+    const flush = /* @__PURE__ */ __name(() => {
+      if (pending.length === 0) return;
+      rows[rows.length - 1]?.push({ text: pending, mark: run2.mark });
+      pending = "";
+    }, "flush");
+    for (const { segment } of segmenter.segment(run2.text)) {
+      const w = stringWidth(segment);
+      if (used + w > width && used > 0) {
+        flush();
+        rows.push([]);
+        used = 0;
+      }
+      pending += segment;
+      used += w;
+    }
+    flush();
+  }
+  return rows;
+}
+__name(wrapRuns, "wrapRuns");
+function entriesOf(hunk) {
+  const entries = [];
+  for (const row of hunk.lines) {
+    if (row.startsWith("\\")) continue;
+    const kind = row.startsWith("+") ? "add" : row.startsWith("-") ? "remove" : "same";
+    const { code, cut } = cutLine(expandTabs(row.slice(1)));
+    entries.push({ kind, code, cut, number: 0 });
+  }
+  for (let i = 0; i < entries.length; ) {
+    if (entries[i]?.kind !== "remove") {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (entries[j]?.kind === "remove") j++;
+    let k = j;
+    while (entries[k]?.kind === "add") k++;
+    const pairs = Math.min(j - i, k - j);
+    for (let n = 0; n < pairs; n++) {
+      const gone = entries[i + n];
+      const came = entries[j + n];
+      if (gone && came) {
+        gone.pair = came;
+        came.pair = gone;
+      }
+    }
+    i = k > j ? k : j;
+  }
+  let counter = hunk.oldStart;
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (!entry) continue;
+    if (entry.kind === "remove") {
+      entry.number = counter;
+      let run2 = 0;
+      while (entries[i + 1]?.kind === "remove") {
+        counter++;
+        i++;
+        run2++;
+        const next = entries[i];
+        if (next) next.number = counter;
+      }
+      counter -= run2;
+    } else {
+      entry.number = counter;
+      counter++;
+    }
+  }
+  return entries;
+}
+__name(entriesOf, "entriesOf");
+function gutterWidth(entries) {
+  const most = entries.reduce((max, entry) => Math.max(max, entry.number), 0);
+  return String(most).length + 1;
+}
+__name(gutterWidth, "gutterWidth");
+var MARKER = { add: "+", remove: "-", same: " " };
+function diffViewRows(hunks, options) {
+  const colors = options.colors ?? diffColors();
+  const text = options.text ?? theme.text.primary;
+  const dim = options.dim === true;
+  const width = Math.max(1, Math.floor(options.width));
+  const rows = [];
+  let first = true;
+  for (const hunk of hunks) {
+    const entries = entriesOf(hunk);
+    if (entries.length === 0) continue;
+    if (!first) rows.push([{ text: HUNK_GAP, dim: true }]);
+    first = false;
+    const m = gutterWidth(entries);
+    for (const entry of entries) rows.push(...entryRows(entry, m, width, dim, colors, text));
+  }
+  return rows;
+}
+__name(diffViewRows, "diffViewRows");
+function backgroundOf(kind, dim, colors) {
+  if (kind === "add") return dim ? colors.addedDimmed : colors.added;
+  if (kind === "remove") return dim ? colors.removedDimmed : colors.removed;
+  return void 0;
+}
+__name(backgroundOf, "backgroundOf");
+function entryRows(entry, m, width, dim, colors, text) {
+  const bg = backgroundOf(entry.kind, dim, colors);
+  const fg = bg === void 0 ? void 0 : text;
+  const marker = MARKER[entry.kind];
+  const words = wordRuns(entry, dim);
+  const room = Math.max(1, width - m - 1 - (words ? marker.length : 2));
+  const pieces = wrapRuns(words ?? [{ text: entry.code, mark: false }], room);
+  const note = entry.cut > 0 ? truncationNote(entry.cut) : "";
+  let noteRow = -1;
+  if (note) {
+    const last = pieces.at(-1) ?? [];
+    const used = last.reduce((sum, run2) => sum + stringWidth(run2.text), 0);
+    if (used + stringWidth(note) > room) pieces.push([]);
+    noteRow = pieces.length - 1;
+  }
+  const wordBg = entry.kind === "add" ? colors.addedWord : colors.removedWord;
+  return pieces.map((runs, index) => {
+    const number = index === 0 ? String(entry.number).padStart(m) : " ".repeat(m);
+    const gutter = `${number} `;
+    const code = runs.reduce((sum, run2) => sum + stringWidth(run2.text), 0);
+    const tail2 = index === noteRow ? note : "";
+    const pad = Math.max(0, width - (gutter.length + marker.length + code + stringWidth(tail2)));
+    const row = [
+      {
+        text: `${gutter}${marker}`,
+        ...bg ? { bg } : {},
+        ...fg ? { fg } : {},
+        ...dim || entry.kind === "same" ? { dim: true } : {}
+      }
+    ];
+    for (const run2 of runs) {
+      row.push({
+        text: run2.text,
+        ...run2.mark ? { bg: wordBg } : bg ? { bg } : {},
+        ...fg ? { fg } : {},
+        ...dim ? { dim: true } : {}
+      });
+    }
+    if (tail2) row.push({ text: tail2, dim: true });
+    if (bg && pad > 0) {
+      row.push({ text: " ".repeat(pad), bg, ...fg ? { fg } : {}, ...dim ? { dim: true } : {} });
+    }
+    return row;
+  });
+}
+__name(entryRows, "entryRows");
+function wordRuns(entry, dim) {
+  const partner = entry.pair;
+  if (dim || !partner) return void 0;
+  const [old, now] = entry.kind === "remove" ? [entry.code, partner.code] : [partner.code, entry.code];
+  const parts = diffWords(old, now);
+  const changed = parts.filter((part) => part.added || part.removed).reduce((sum, part) => sum + part.value.length, 0);
+  const total = old.length + now.length;
+  if (total === 0 || changed / total > WORD_DIFF_RATIO) return void 0;
+  const runs = [];
+  for (const part of parts) {
+    if (entry.kind === "add") {
+      if (part.removed) continue;
+      runs.push({ text: part.value, mark: part.added === true });
+    } else {
+      if (part.added) continue;
+      runs.push({ text: part.value, mark: part.removed === true });
+    }
+  }
+  return runs;
+}
+__name(wordRuns, "wordRuns");
+function viewRowText(row) {
+  return row.map((segment) => segment.text).join("");
+}
+__name(viewRowText, "viewRowText");
+function fileViewRows(hunks, options) {
+  const width = Math.max(1, Math.floor(options.width));
+  const rows = [];
+  for (const hunk of hunks) {
+    for (const line of hunk.lines) {
+      if (line.startsWith("\\")) continue;
+      const { code, cut } = cutLine(expandTabs(line.slice(1)));
+      const note = cut > 0 ? truncationNote(cut) : "";
+      const pieces = wrapRuns([{ text: code, mark: false }], width);
+      const last = pieces.at(-1) ?? [];
+      const used = last.reduce((sum, run2) => sum + stringWidth(run2.text), 0);
+      if (note && used + stringWidth(note) > width) pieces.push([]);
+      pieces.forEach((runs, index) => {
+        const segments = runs.map((run2) => ({
+          text: run2.text,
+          ...options.dim ? { dim: true } : {}
+        }));
+        if (note && index === pieces.length - 1) segments.push({ text: note, dim: true });
+        rows.push(segments);
+      });
+    }
+  }
+  return rows;
+}
+__name(fileViewRows, "fileViewRows");
+function allRows(info, width) {
+  const dim = info.dim ? { dim: true } : {};
+  if (info.files) {
+    const rows = [];
+    for (const file of info.files) {
+      if (rows.length > 0) rows.push([{ text: "" }]);
+      rows.push([{ text: file.heading }]);
+      rows.push(...diffViewRows(file.hunks, { width, ...dim }));
+    }
+    for (const line of info.footer ?? []) rows.push([{ text: line, dim: true }]);
+    return rows;
+  }
+  return info.mode === "file" ? fileViewRows(info.hunks, { width, ...dim }) : diffViewRows(info.hunks, { width, ...dim });
+}
+__name(allRows, "allRows");
+function diffViewBody(info, options) {
+  const all = allRows(info, options.width);
+  const limit = options.expanded || info.preview === void 0 ? all.length : info.preview;
+  const shown = all.slice(0, limit);
+  const carried = info.hunks.reduce(
+    (count, hunk) => count + hunk.lines.filter((line) => line.startsWith("+")).length,
+    0
+  );
+  const missing2 = info.mode === "file" && info.truncated && info.added !== void 0 ? Math.max(0, info.added - carried) : 0;
+  const hidden = all.length - shown.length + (shown.length === all.length ? 0 : missing2);
+  if (hidden > 0) {
+    shown.push([
+      {
+        text: hiddenLinesHint(hidden, { canExpand: options.canExpand }),
+        dim: true
+      }
+    ]);
+  } else if (info.truncated) {
+    shown.push([{ text: "\u2026 more changes are not shown", dim: true }]);
+  }
+  return shown;
+}
+__name(diffViewBody, "diffViewBody");
+function plainDiffRows(info) {
+  const rows = [];
+  if (info.files) {
+    for (const file of info.files) {
+      if (rows.length > 0) rows.push("");
+      rows.push(file.heading, ...plainDiffRows({ mode: "hunks", hunks: file.hunks }));
+    }
+    rows.push(...info.footer ?? []);
+    return rows;
+  }
+  if (info.mode === "file") {
+    for (const hunk of info.hunks) {
+      for (const line of hunk.lines) {
+        if (!line.startsWith("\\")) rows.push(expandTabs(line.slice(1)));
+      }
+    }
+    return rows;
+  }
+  let first = true;
+  for (const hunk of info.hunks) {
+    const entries = entriesOf(hunk);
+    if (entries.length === 0) continue;
+    if (!first) rows.push(HUNK_GAP);
+    first = false;
+    const m = gutterWidth(entries);
+    for (const entry of entries) {
+      rows.push(`${String(entry.number).padStart(m)} ${MARKER[entry.kind]}${entry.code}`);
+    }
+  }
+  return rows;
+}
+__name(plainDiffRows, "plainDiffRows");
+function plural2(count, one, many) {
+  return count === 1 ? one : many;
+}
+__name(plural2, "plural");
+function bold(count) {
+  return { text: count.toLocaleString("en-US"), bold: true };
+}
+__name(bold, "bold");
+function editSummary(added, removed) {
+  const spans = [];
+  if (added > 0) {
+    spans.push({ text: "Added " }, bold(added), { text: ` ${plural2(added, "line", "lines")}` });
+  }
+  if (added > 0 && removed > 0) spans.push({ text: ", " });
+  if (removed > 0) {
+    spans.push({ text: added === 0 ? "Removed " : "removed " }, bold(removed), {
+      text: ` ${plural2(removed, "line", "lines")}`
+    });
+  }
+  return spans;
+}
+__name(editSummary, "editSummary");
+function writeSummary(lines, path) {
+  return [
+    { text: "Wrote " },
+    bold(lines),
+    { text: ` ${plural2(lines, "line", "lines")} to ` },
+    { text: path, bold: true }
+  ];
+}
+__name(writeSummary, "writeSummary");
+function spansText(spans) {
+  return spans.map((span) => span.text).join("");
+}
+__name(spansText, "spansText");
+
+// src/tui/display-path.ts
+import { isAbsolute, relative, resolve } from "node:path";
+function displayPath(path, cwd, home) {
+  if (path.length === 0 || /^[A-Za-z][A-Za-z0-9+.-]+:\/\//.test(path)) return path;
+  if (cwd === void 0) return homePath(path, home);
+  const absolute = isAbsolute(path) ? path : resolve(cwd, path);
+  const inside = relative(cwd, absolute);
+  const escapes = inside === ".." || inside.startsWith("../") || inside.startsWith("..\\");
+  if (!escapes && !isAbsolute(inside)) {
+    return isAbsolute(path) ? inside || "." : path;
+  }
+  return homePath(absolute, home);
+}
+__name(displayPath, "displayPath");
+
+// src/tui/diff-rows.ts
+function countRows(hunks) {
+  let added = 0;
+  let removed = 0;
+  for (const hunk of hunks) {
+    for (const row of hunk.lines) {
+      if (row.startsWith("+")) added += 1;
+      else if (row.startsWith("-")) removed += 1;
+    }
+  }
+  return { added, removed };
+}
+__name(countRows, "countRows");
+function bodyOf(info) {
+  return { rows: plainDiffRows(info).map((row) => clipText(row, 600)), diff: info };
+}
+__name(bodyOf, "bodyOf");
+function diffBodyFromFacts(facts, cwd) {
+  if (!facts || facts.kind !== "edit" && facts.kind !== "write") return void 0;
+  const hunks = facts.hunks ?? [];
+  const carried = countRows(hunks);
+  const added = facts.added ?? carried.added;
+  const removed = facts.removed ?? carried.removed;
+  const created = facts.kind === "write" && facts.operation === "created";
+  if (hunks.length === 0 && (created ? added === 0 : added === 0 && removed === 0)) return void 0;
+  if (facts.kind === "write" && (facts.operation === "unchanged" || facts.operation === "wrote"))
+    return void 0;
+  const truncated = facts.hunksTruncated === true ? { truncated: true } : {};
+  if (created) {
+    return bodyOf({
+      mode: "file",
+      hunks,
+      preview: CREATE_PREVIEW_ROWS,
+      added,
+      removed,
+      ...truncated,
+      summary: writeSummary(added, displayPath(facts.path, cwd))
+    });
+  }
+  return bodyOf({
+    mode: "hunks",
+    hunks,
+    added,
+    removed,
+    ...truncated,
+    summary: editSummary(added, removed)
+  });
+}
+__name(diffBodyFromFacts, "diffBodyFromFacts");
+var PROPOSED_LINE_CAP = 400;
+var LOCATE_MAX_BYTES = 2 * 1024 * 1024;
+function proposedFromInput(toolName2, input) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const fields = input;
+  const name = toolName2.toLowerCase();
+  if (name === "write") {
+    const content = fields.content ?? fields.newStr;
+    return typeof content === "string" && content.length > 0 ? { kind: "write", content } : void 0;
+  }
+  if (name === "edit") {
+    const before = fields.old_string ?? fields.oldStr;
+    const after = fields.new_string ?? fields.newStr;
+    if (typeof before !== "string" || typeof after !== "string") return void 0;
+    return {
+      kind: "edit",
+      ...typeof fields.path === "string" ? { path: fields.path } : {},
+      before,
+      after
+    };
+  }
+  return void 0;
+}
+__name(proposedFromInput, "proposedFromInput");
+function startLine(path, snippet, cwd) {
+  if (!path || snippet.length === 0) return 1;
+  try {
+    const full = isAbsolute2(path) ? path : resolve2(cwd ?? process.cwd(), path);
+    if (statSync(full).size > LOCATE_MAX_BYTES) return 1;
+    const text = readFileSync(full, "utf8");
+    const at = text.indexOf(snippet);
+    if (at < 0) return 1;
+    let line = 1;
+    for (let i = text.indexOf("\n"); i >= 0 && i < at; i = text.indexOf("\n", i + 1)) line += 1;
+    return line;
+  } catch {
+    return 1;
+  }
+}
+__name(startLine, "startLine");
+function withNewline(text) {
+  return text.length === 0 || text.endsWith("\n") ? text : `${text}
+`;
+}
+__name(withNewline, "withNewline");
+function proposedBody(proposed, cwd) {
+  if (!proposed) return void 0;
+  if (proposed.kind === "write") {
+    const lines = withNewline(proposed.content).split("\n");
+    lines.pop();
+    const carried = lines.slice(0, PROPOSED_LINE_CAP);
+    return bodyOf({
+      mode: "file",
+      hunks: [
+        {
+          oldStart: 0,
+          oldLines: 0,
+          newStart: 1,
+          newLines: carried.length,
+          lines: carried.map((line) => `+${line}`)
+        }
+      ],
+      preview: CREATE_PREVIEW_ROWS,
+      added: lines.length,
+      removed: 0,
+      dim: true,
+      ...lines.length > carried.length ? { truncated: true } : {}
+    });
+  }
+  const patch = structuredPatch(
+    "a",
+    "a",
+    withNewline(proposed.before),
+    withNewline(proposed.after),
+    void 0,
+    void 0,
+    {
+      context: 3
+    }
+  );
+  const offset = startLine(proposed.path, proposed.before, cwd) - 1;
+  const hunks = patch.hunks.map((hunk) => ({
+    oldStart: hunk.oldStart + offset,
+    oldLines: hunk.oldLines,
+    newStart: hunk.oldStart + offset,
+    newLines: hunk.newLines,
+    lines: hunk.lines.filter((row) => !row.startsWith("\\"))
+  }));
+  if (hunks.length === 0) return void 0;
+  const counts = countRows(hunks);
+  return bodyOf({ mode: "hunks", hunks, dim: true, ...counts });
+}
+__name(proposedBody, "proposedBody");
+
 // src/tui/plain-failure.ts
 var StartupRefusal = class extends Error {
   static {
@@ -766,11 +1423,11 @@ function endedHow(facts) {
   return void 0;
 }
 __name(endedHow, "endedHow");
-var NOT_SHOWN_LINE = /^… ([\d,]+) lines? not shown$/;
+var NOT_SHOWN_LINE = /^… \+([\d,]+) lines?$/;
 function windowLines(window) {
   const lines = window.head.length > 0 ? window.head.split("\n") : [];
   if (window.omittedLines) {
-    lines.push(`\u2026 ${plural(window.omittedLines, "line")} not shown`);
+    lines.push(hiddenLinesHint(window.omittedLines, { canExpand: false }));
   }
   if (window.tail) lines.push(...window.tail.split("\n"));
   return lines;
@@ -819,8 +1476,8 @@ function declinedLine(note) {
   return said ? `You declined this, so it did not run. You said: \u201C${said}\u201D` : "You declined this, so it did not run.";
 }
 __name(declinedLine, "declinedLine");
-function failureFactsLine(facts) {
-  const subject = facts.subject ? homePath(facts.subject) : void 0;
+function failureFactsLine(facts, cwd) {
+  const subject = facts.subject ? facts.reason === "unknown_tool" ? facts.subject : displayPath(facts.subject, cwd) : void 0;
   switch (facts.reason) {
     case "not_found":
       return subject ? `Couldn\u2019t find ${subject}.` : "Couldn\u2019t find that.";
@@ -849,8 +1506,7 @@ function fileName(path) {
 }
 __name(fileName, "fileName");
 function clipped(text, max) {
-  const flat = text.replace(/\s+/g, " ").trim();
-  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+  return clipText(text.replace(/\s+/g, " ").trim(), max);
 }
 __name(clipped, "clipped");
 function changeStats(added, removed) {
@@ -860,18 +1516,7 @@ function changeStats(added, removed) {
   return parts.join(" ");
 }
 __name(changeStats, "changeStats");
-function editedLineCounts(before, after) {
-  const a = before === "" ? [] : before.split("\n");
-  const b = after === "" ? [] : after.split("\n");
-  let head = 0;
-  while (head < a.length && head < b.length && a[head] === b[head]) head++;
-  let tail2 = 0;
-  while (tail2 < a.length - head && tail2 < b.length - head && a[a.length - 1 - tail2] === b[b.length - 1 - tail2])
-    tail2++;
-  return { removed: a.length - head - tail2, added: b.length - head - tail2 };
-}
-__name(editedLineCounts, "editedLineCounts");
-function factsHeadline(facts, edit) {
+function factsHeadline(facts) {
   if (!facts) return void 0;
   switch (facts.kind) {
     case "read": {
@@ -903,8 +1548,7 @@ function factsHeadline(facts, edit) {
     }
     case "edit": {
       if (!facts.path) return void 0;
-      const counts = edit ? editedLineCounts(edit.before, edit.after) : void 0;
-      const stats = counts ? changeStats(counts.added, counts.removed) : "";
+      const stats = changeStats(facts.added, facts.removed);
       return `Edited ${fileName(facts.path)}${stats ? ` ${stats}` : ""}`;
     }
     default:
@@ -913,22 +1557,6 @@ function factsHeadline(facts, edit) {
 }
 __name(factsHeadline, "factsHeadline");
 
-// src/tui/units.ts
-function formatElapsed(ms) {
-  const s = ms / 1e3;
-  if (s < 10) return `${s.toFixed(1)}s`;
-  if (s < 60) return `${Math.round(s)}s`;
-  const m = Math.floor(s / 60);
-  return `${m}m${Math.round(s - m * 60)}s`;
-}
-__name(formatElapsed, "formatElapsed");
-function formatCompactCount(value) {
-  if (value < 1e3) return String(value);
-  if (value < 1e6) return `${(value / 1e3).toFixed(1)}k`;
-  return `${(value / 1e6).toFixed(2)}M`;
-}
-__name(formatCompactCount, "formatCompactCount");
-
 // src/tui/web-activity.ts
 function webActivityKind(toolName2) {
   if (toolName2 === "web_search") return "search";
@@ -958,7 +1586,8 @@ function webLiveStatus(activity) {
 }
 __name(webLiveStatus, "webLiveStatus");
 function webSettledLine(activity, outcome) {
-  const took = outcome.durationMs !== void 0 ? ` in ${formatElapsed(outcome.durationMs)}` : "";
+  const elapsed = settledElapsed(outcome.durationMs);
+  const took = elapsed !== void 0 ? ` in ${elapsed}` : "";
   if (activity.kind === "search") {
     const n = activity.results;
     return n !== void 0 ? `Found ${n} result${n === 1 ? "" : "s"}${took}` : `Did 1 search${took}`;
@@ -992,7 +1621,7 @@ __name(oneLine, "oneLine");
 // src/tui/agent.ts
 import { SubprocessComputerUseHost } from "@namzu/computer-use";
 import { realpath as realpath4, stat as stat4 } from "node:fs/promises";
-import { join as join14, parse, resolve as resolve10 } from "node:path";
+import { join as join14, parse, resolve as resolve12 } from "node:path";
 
 // src/checkpoints/store.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -1008,7 +1637,7 @@ import {
   unlink as unlink2,
   writeFile
 } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join as join2, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute as isAbsolute3, join as join2, relative as relative2, resolve as resolve3, sep } from "node:path";
 
 // src/checkpoints/manifest.ts
 import { createHash, randomBytes } from "node:crypto";
@@ -1407,7 +2036,7 @@ var FileCheckpointStore = class {
   // -- paths ------------------------------------------------------------------
   realCwdPromise;
   realCwd() {
-    this.realCwdPromise ??= realExisting(resolve(this.cwd)).catch(() => resolve(this.cwd));
+    this.realCwdPromise ??= realExisting(resolve3(this.cwd)).catch(() => resolve3(this.cwd));
     return this.realCwdPromise;
   }
   /**
@@ -1425,13 +2054,13 @@ var FileCheckpointStore = class {
     return this.insideReal(real, await this.realCwd()) ? real : null;
   }
   insideReal(real, root) {
-    const rel = relative(root, real);
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+    const rel = relative2(root, real);
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute3(rel);
   }
   /** Whether a host path is one this store would cover. */
   covers(hostPath) {
-    const rel = relative(this.cwd, resolve(this.cwd, hostPath));
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+    const rel = relative2(this.cwd, resolve3(this.cwd, hostPath));
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute3(rel);
   }
   // -- turns ------------------------------------------------------------------
   /**
@@ -1639,7 +2268,7 @@ var FileCheckpointStore = class {
     });
   }
   async snapshotNow(history, rec, hostPath, meta) {
-    const lexical = resolve(this.cwd, hostPath);
+    const lexical = resolve3(this.cwd, hostPath);
     if (!this.covers(lexical)) {
       await this.skipNow(history, rec, lexical, "outside-cwd");
       return "outside";
@@ -1669,7 +2298,7 @@ var FileCheckpointStore = class {
     const before = await this.capture(history.root, path, true);
     rec.m.entries.push({
       path,
-      rel: relative(await this.realCwd(), path),
+      rel: relative2(await this.realCwd(), path),
       root: "cwd",
       before,
       after: null,
@@ -1692,7 +2321,7 @@ var FileCheckpointStore = class {
       const history = await this.load(root);
       const rec = outcome.turnId !== void 0 ? this.byId.get(outcome.turnId) : this.current;
       if (!rec || rec.root === void 0) return;
-      const lexical = resolve(this.cwd, hostPath);
+      const lexical = resolve3(this.cwd, hostPath);
       const path = await this.canonical(lexical).catch(() => null) ?? lexical;
       const entry = rec.m.entries.find((e) => sameFile(e.path, path));
       if (!entry) return;
@@ -1715,7 +2344,7 @@ var FileCheckpointStore = class {
     const root = this.rootOf(turnId);
     return this.locked(root, async () => {
       const history = await this.load(root);
-      await this.skipNow(history, this.resolveRec(turnId), resolve(this.cwd, hostPath), reason);
+      await this.skipNow(history, this.resolveRec(turnId), resolve3(this.cwd, hostPath), reason);
     });
   }
   async skipNow(history, rec, path, reason) {
@@ -1770,8 +2399,8 @@ var FileCheckpointStore = class {
             turnId,
             status: "none",
             files: 0,
-            added: 0,
-            removed: 0,
+            created: 0,
+            deleted: 0,
             uncoveredShell: false,
             skipped: []
           };
@@ -1781,8 +2410,8 @@ var FileCheckpointStore = class {
           turnId,
           status,
           files: changed.length,
-          added: changed.filter((e) => e.before === null).length,
-          removed: changed.filter((e) => e.before !== null && e.after === null).length,
+          created: changed.filter((e) => e.before === null).length,
+          deleted: changed.filter((e) => e.before !== null && e.after === null).length,
           uncoveredShell: rec.m.uncoveredShell,
           skipped: rec.m.skipped
         };
@@ -2216,13 +2845,13 @@ function renderCheckpoints(turns, cwd, skipped = []) {
   for (const turn of turns) {
     const partly = turn.status === "partially_undone" ? "  (partly undone)" : "";
     lines.push(`  ${turn.index}. ${turn.label || "(no prompt)"}${partly}`);
-    for (const file of turn.files) lines.push(`       ${relative(cwd, file) || file}`);
+    for (const file of turn.files) lines.push(`       ${relative2(cwd, file) || file}`);
   }
   if (turns.length === 0) lines.push("  (none)");
   if (skipped.length > 0) {
     lines.push("", "Not covered, so /restore cannot bring these back:");
     for (const s of skipped) {
-      lines.push(`  ${relative(cwd, s.path) || s.path}  (${SKIP_TEXT[s.reason]})`);
+      lines.push(`  ${relative2(cwd, s.path) || s.path}  (${SKIP_TEXT[s.reason]})`);
     }
   }
   lines.push(
@@ -2240,7 +2869,7 @@ var CONFLICT_TEXT = {
   "outside-cwd": "now resolves outside the project"
 };
 function renderRestore(report, cwd) {
-  const rel = /* @__PURE__ */ __name((p) => relative(cwd, p) || p, "rel");
+  const rel = /* @__PURE__ */ __name((p) => relative2(cwd, p) || p, "rel");
   const left = report.conflicts.length > 0 || report.failed.length > 0;
   const wrote = report.restored.length + report.removed.length > 0;
   const lines = [
@@ -2350,18 +2979,18 @@ __name(withShellNote, "withShellNote");
 
 // src/context/directories.ts
 import { realpath as realpath2, stat as stat3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+import { isAbsolute as isAbsolute4, relative as relative3, resolve as resolve4 } from "node:path";
 function isInside(root, candidate) {
-  const rel = relative2(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+  const rel = relative3(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
 }
 __name(isInside, "isInside");
 function createSessionDirectories(cwd, directories) {
-  const root = resolve2(cwd);
+  const root = resolve4(cwd);
   return {
     list: /* @__PURE__ */ __name(() => [...directories], "list"),
     add: /* @__PURE__ */ __name(async (path, options) => {
-      const absolute = resolve2(root, path);
+      const absolute = resolve4(root, path);
       if (absolute === root)
         return { added: false, path: absolute, reason: "That is the working directory." };
       if (directories.includes(absolute))
@@ -2404,7 +3033,7 @@ You are in plan mode. Read, search and think; the only file you may change is th
 
 // src/context/project-tracker.ts
 import { realpathSync } from "node:fs";
-import { dirname as dirname2, isAbsolute as isAbsolute3, join as join3, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute5, join as join3, relative as relative4, resolve as resolve5, sep as sep2 } from "node:path";
 
 // src/context/project-path.ts
 function visibleProjectInstructionPath(path) {
@@ -2422,21 +3051,21 @@ function canonicalRoot(path) {
   try {
     return realpathSync(path);
   } catch {
-    return resolve3(path);
+    return resolve5(path);
   }
 }
 __name(canonicalRoot, "canonicalRoot");
 function contained(root, candidate) {
-  const rel = relative3(root, candidate);
-  return rel === "" || !isAbsolute3(rel) && rel !== ".." && !rel.startsWith(`..${sep2}`);
+  const rel = relative4(root, candidate);
+  return rel === "" || !isAbsolute5(rel) && rel !== ".." && !rel.startsWith(`..${sep2}`);
 }
 __name(contained, "contained");
 function relativeInstructionPath(root, file) {
-  return relative3(root, file).split(sep2).join("/");
+  return relative4(root, file).split(sep2).join("/");
 }
 __name(relativeInstructionPath, "relativeInstructionPath");
 function scopeDepth(root, file) {
-  const rel = relative3(root, dirname2(file.path));
+  const rel = relative4(root, dirname2(file.path));
   return rel === "" ? 0 : rel.split(sep2).length;
 }
 __name(scopeDepth, "scopeDepth");
@@ -2486,7 +3115,7 @@ var ProjectInstructionTracker = class {
       if (message2.role !== "user" || message2.source?.type !== "project-instructions") continue;
       if (!isProjectInstructionMessageSource(message2.source)) continue;
       for (const file of message2.source.files) {
-        const absolute = resolve3(this.root, file);
+        const absolute = resolve5(this.root, file);
         if (!contained(this.root, absolute)) continue;
         this.registerPath(dirname2(absolute));
       }
@@ -2523,7 +3152,7 @@ var ProjectInstructionTracker = class {
       return;
     }
     const rawPath = observation.input.path;
-    const lexical = resolve3(this.cwd, rawPath);
+    const lexical = resolve5(this.cwd, rawPath);
     let target;
     try {
       target = realpathSync(lexical);
@@ -2535,9 +3164,9 @@ var ProjectInstructionTracker = class {
     this.refreshDirectories(this.scopes.keys());
   }
   registerPath(directory) {
-    const target = resolve3(directory);
+    const target = resolve5(directory);
     if (!contained(this.root, target)) return;
-    const rel = relative3(this.root, target);
+    const rel = relative4(this.root, target);
     let current = this.root;
     if (!this.scopes.has(current)) this.scopes.set(current, { directory: current });
     if (rel === "") return;
@@ -2678,7 +3307,7 @@ var GIT_TIMEOUT_MS = 2e3;
 var GIT_MAX_BUFFER = 4 * 1024 * 1024;
 var MAX_STATUS_LINES = 30;
 var RECENT_COMMITS = 5;
-var MAX_LINE_CHARS = 200;
+var MAX_LINE_CHARS2 = 200;
 async function git(cwd, args) {
   try {
     const { stdout } = await run("git", [...args], {
@@ -2694,7 +3323,7 @@ async function git(cwd, args) {
 __name(git, "git");
 function boundLine(line) {
   const printable = line.replace(new RegExp("\\p{Cc}", "gu"), "");
-  return printable.length > MAX_LINE_CHARS ? `${printable.slice(0, MAX_LINE_CHARS)}\u2026` : printable;
+  return printable.length > MAX_LINE_CHARS2 ? `${printable.slice(0, MAX_LINE_CHARS2)}\u2026` : printable;
 }
 __name(boundLine, "boundLine");
 async function readTurnSnapshot(cwd) {
@@ -3818,7 +4447,7 @@ __name(createContextInventoryStep, "createContextInventoryStep");
 
 // src/integrations/sessions/conversation-search.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 
 // src/integrations/sessions/evidence-page-validation.ts
 var integer = /* @__PURE__ */ __name((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0, "integer");
@@ -3904,7 +4533,7 @@ function parseQueryIdentity(identity) {
 }
 __name(parseQueryIdentity, "parseQueryIdentity");
 function conversationScope(sessions, sessionId) {
-  return JSON.stringify([resolve4(sessions.root), sessions.tenantId, sessions.projectId, sessionId]);
+  return JSON.stringify([resolve6(sessions.root), sessions.tenantId, sessions.projectId, sessionId]);
 }
 __name(conversationScope, "conversationScope");
 var readLocations = /* @__PURE__ */ new Map();
@@ -4418,15 +5047,15 @@ function newScan(terms) {
   return { terms, started: false };
 }
 __name(newScan, "newScan");
-function advanceScan(scans, scan2, nextCursor, excerpts, hasDerivedSummaries, canRefine) {
-  scan2.started = true;
-  scan2.cursor = nextCursor;
+function advanceScan(scans, scan3, nextCursor, excerpts, hasDerivedSummaries, canRefine) {
+  scan3.started = true;
+  scan3.cursor = nextCursor;
   if (!canRefine || scans.length !== 1 || !nextCursor) return;
   if (hasDerivedSummaries) {
-    scans.push({ ...newScan(scan2.terms), excludeDerivedSummaries: true });
+    scans.push({ ...newScan(scan3.terms), excludeDerivedSummaries: true });
     return;
   }
-  const focused = refineEvidenceRecallTerms(scan2.terms, excerpts);
+  const focused = refineEvidenceRecallTerms(scan3.terms, excerpts);
   if (focused) scans.push(newScan(focused));
 }
 __name(advanceScan, "advanceScan");
@@ -4451,8 +5080,8 @@ function createConversationEvidenceRecall(sessions, sessionId, assertOwner, reso
       let excludedSummaries = 0;
       const scans = [newScan(terms)];
       for (let pages = 0; pages < RECALL_PAGES; pages++) {
-        const scan2 = [...scans].reverse().find((s) => !s.started || s.cursor);
-        if (!scan2) break;
+        const scan3 = [...scans].reverse().find((s) => !s.started || s.cursor);
+        if (!scan3) break;
         signal.throwIfAborted();
         const remaining = maxReadBytes - scannedBytes;
         if (remaining < 1024 * 1024) {
@@ -4463,12 +5092,12 @@ function createConversationEvidenceRecall(sessions, sessionId, assertOwner, reso
           sessions,
           sessionId,
           {
-            terms: scan2.terms,
+            terms: scan3.terms,
             matchMode: "token",
             excludeSuccessfulTools: CONVERSATION_RETRIEVAL_TOOLS,
-            excludeDerivedSummaries: scan2.excludeDerivedSummaries ?? false,
+            excludeDerivedSummaries: scan3.excludeDerivedSummaries ?? false,
             maxReadBytes: remaining,
-            ...scan2.cursor ? { cursor: scan2.cursor } : {}
+            ...scan3.cursor ? { cursor: scan3.cursor } : {}
           },
           signal,
           active
@@ -4499,7 +5128,7 @@ function createConversationEvidenceRecall(sessions, sessionId, assertOwner, reso
         }
         advanceScan(
           scans,
-          scan2,
+          scan3,
           page.nextCursor,
           page.matches.map((match) => match.text),
           page.matches.some((match) => match.source === "compaction_shed:summary"),
@@ -4509,9 +5138,9 @@ function createConversationEvidenceRecall(sessions, sessionId, assertOwner, reso
       }
       assertOwner(turnId);
       signal.throwIfAborted();
-      const continuations = [...scans].reverse().filter((scan2) => scan2.cursor !== void 0).map((scan2) => ({
+      const continuations = [...scans].reverse().filter((scan3) => scan3.cursor !== void 0).map((scan3) => ({
         toolName: "search_conversation",
-        input: { cursor: scan2.cursor }
+        input: { cursor: scan3.cursor }
       }));
       return {
         candidates,
@@ -4669,7 +5298,7 @@ function estimateTokens(text) {
 __name(estimateTokens, "estimateTokens");
 function createSideModel(deps) {
   const routes = /* @__PURE__ */ new Map();
-  const resolve11 = /* @__PURE__ */ __name(async (sessionId, signal) => {
+  const resolve13 = /* @__PURE__ */ __name(async (sessionId, signal) => {
     const active = deps.active();
     if (deps.configured !== void 0) {
       const target = parseSmallModel(deps.configured, active.providerId, deps.isKnownProvider);
@@ -4706,7 +5335,7 @@ ${active.model}
 ${deps.configured ?? ""}`;
     let pending = routes.get(key);
     if (pending === void 0) {
-      pending = resolve11(sessionId, signal);
+      pending = resolve13(sessionId, signal);
       routes.set(key, pending);
       void pending.then((value) => {
         if (signal.aborted && value.source === "main" && routes.get(key) === pending) {
@@ -4763,6 +5392,16 @@ __name(createSideModel, "createSideModel");
 // src/integrations/state/retention.ts
 var CLI_CHECKPOINT_RETENTION = 10;
 
+// src/integrations/subagents/workflow-assignment.ts
+var WORKFLOW_STEP_ASSIGNMENT = "This step is your assigned job. The person who started this workflow approved the script that gives it to you, so carry it out and report what you found or did; do not decline it or skip it.";
+function stepTaskOnly(prompt) {
+  const opening = `${WORKFLOW_STEP_ASSIGNMENT}
+
+`;
+  return prompt.startsWith(opening) ? prompt.slice(opening.length) : prompt;
+}
+__name(stepTaskOnly, "stepTaskOnly");
+
 // src/integrations/subagents/activity.ts
 var MAX_RETAINED_AGENTS = 80;
 var MAX_TRANSCRIPT_ROWS = 120;
@@ -4822,15 +5461,18 @@ var SubagentActivityMonitor = class {
   resume(viewId, input) {
     const prior = this.records.get(viewId);
     if (!prior || !prior.closed || this.options.replay)
-      throw new Error("This child conversation is not available for continuation.");
+      throw new Error("This agent has finished and cannot be continued.");
     const opened = this.open(input, viewId);
     opened.record.resumed = true;
+    opened.record.startedAt = prior.startedAt;
+    if (prior.tokens !== void 0) opened.record.tokens = prior.tokens;
+    if (prior.toolCalls !== void 0) opened.record.toolCalls = prior.toolCalls;
     opened.record.rows = [...prior.rows];
     opened.record.sessionId = prior.sessionId;
     pushRow(opened.record, {
       id: `${viewId}:invocation:${opened.record.order}`,
       kind: "system",
-      text: "New task in this conversation; previous tasks remain finished."
+      text: "Continuing with a new task."
     });
     this.notifyNow();
     return opened.tracker;
@@ -4854,7 +5496,7 @@ var SubagentActivityMonitor = class {
       } : {},
       description: bounded(input.description, MAX_AGENT_ACTIVITY_LABEL_CODE_UNITS),
       ...input.background ? { background: true } : {},
-      prompt: bounded(input.prompt, MAX_PROMPT_CODE_UNITS),
+      prompt: bounded(stepTaskOnly(input.prompt), MAX_PROMPT_CODE_UNITS),
       batchId,
       ...input.toolUseId ? { toolUseId: bounded(input.toolUseId, MAX_IDENTITY_LABEL_CODE_UNITS) } : {},
       workflowId,
@@ -4912,13 +5554,10 @@ var SubagentActivityMonitor = class {
         if (!owned) return;
         const cancelled2 = cancellationLike(error);
         owned.status = cancelled2 ? "cancelled" : "failed";
+        if (cancelled2 && !owned.stoppedBy) owned.stoppedBy = "user";
         owned.completedAt = Date.now();
         owned.latestActivity = terminalLabel(owned.status);
-        pushRow(owned, {
-          id: `${owned.viewId}:failure`,
-          kind: "system",
-          text: bounded(errorMessage(error), MAX_ROW_CODE_UNITS)
-        });
+        pushFailure(owned, `${owned.viewId}:failure`, errorMessage(error));
         owned.closed = true;
         this.prune();
         this.notifyNow();
@@ -5121,6 +5760,7 @@ var SubagentActivityMonitor = class {
       startedAt: record.startedAt,
       ...record.completedAt !== void 0 ? { completedAt: record.completedAt } : {},
       ...record.latestActivity ? { latestActivity: record.latestActivity } : {},
+      ...failureOf(record) !== void 0 ? { error: failureOf(record) } : {},
       transcript: Object.freeze(record.rows.map((row) => Object.freeze({ ...row })))
     });
   }
@@ -5388,30 +6028,38 @@ function projectEvent(record, event) {
       record.status = "failed";
       record.completedAt = Date.now();
       record.latestActivity = "Failed";
-      pushRow(record, {
-        id: `${record.viewId}:agent-failed`,
-        kind: "system",
-        text: bounded(event.error, MAX_ROW_CODE_UNITS)
-      });
+      pushFailure(record, `${record.viewId}:agent-failed`, event.error);
       return;
     case "agent_canceled":
       record.status = "cancelled";
+      if (!record.stoppedBy) record.stoppedBy = "user";
       record.completedAt = Date.now();
       record.latestActivity = "Cancelled";
       return;
     case "turn_failed":
       record.latestActivity = "Failed";
-      pushRow(record, {
-        id: `${record.viewId}:turn-failed`,
-        kind: "system",
-        text: bounded(event.error, MAX_ROW_CODE_UNITS)
-      });
+      pushFailure(record, `${record.viewId}:turn-failed`, event.error);
       return;
     default:
       return;
   }
 }
 __name(projectEvent, "projectEvent");
+function pushFailure(record, id, error) {
+  const text = error.trim();
+  if (text === "") return;
+  pushRow(record, { id, kind: "system", text: bounded(text, MAX_ROW_CODE_UNITS), failure: true });
+}
+__name(pushFailure, "pushFailure");
+function failureOf(record) {
+  if (record.status !== "failed") return void 0;
+  for (let index = record.rows.length - 1; index >= 0; index -= 1) {
+    const row = record.rows[index];
+    if (row?.kind === "system" && row.failure) return row.text;
+  }
+  return void 0;
+}
+__name(failureOf, "failureOf");
 function pushRow(record, row) {
   record.rows.push(row);
   if (record.rows.length > MAX_TRANSCRIPT_ROWS) {
@@ -6224,7 +6872,7 @@ __name(settledAnswer, "settledAnswer");
 // src/integrations/subagents/worktree-driver.ts
 import { execFile as execFile2 } from "node:child_process";
 import { mkdir as mkdir3, realpath as realpath3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, relative as relative4, resolve as resolve5, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute6, relative as relative5, resolve as resolve7, sep as sep3 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var runFile = promisify2(execFile2);
 var DelegatedWorktreeDriver = class {
@@ -6243,9 +6891,9 @@ var DelegatedWorktreeDriver = class {
     this.ready ??= openManagedWorktrees(this.cwd, {
       stateRoot: this.stateRoot
     }).then(async (managed) => {
-      const selectedDirectory = await realpath3(resolve5(this.cwd));
-      const subdirectory = relative4(managed.sourceRoot, selectedDirectory);
-      if (isAbsolute4(subdirectory) || subdirectory === ".." || subdirectory.startsWith(`..${sep3}`)) {
+      const selectedDirectory = await realpath3(resolve7(this.cwd));
+      const subdirectory = relative5(managed.sourceRoot, selectedDirectory);
+      if (isAbsolute6(subdirectory) || subdirectory === ".." || subdirectory.startsWith(`..${sep3}`)) {
         throw new Error("Selected directory is outside its Git checkout");
       }
       return {
@@ -6364,6 +7012,7 @@ var refuseUnownedChildReview = /* @__PURE__ */ __name(async () => ({
 }), "refuseUnownedChildReview");
 async function createSubagentRuntime(input) {
   const childMessageListeners = /* @__PURE__ */ new Set();
+  const backgroundCompletionListeners = /* @__PURE__ */ new Set();
   const opts = {
     ...input,
     childExtraTools: /* @__PURE__ */ __name(() => childMessageListeners.size > 0 ? [toolset("agents:message-main", [messageMainTool])] : [], "childExtraTools")
@@ -6567,12 +7216,16 @@ async function createSubagentRuntime(input) {
           await refreshLimits(lease.shared, current);
           assertOwned();
         });
-        const completionInbox = new CompletionInbox();
+        const completionInbox = new CompletionInbox(void 0, {
+          holdsTurnOpen: opts.backgroundByDefault !== true
+        });
         completionInbox.attach(gateway);
         const runtime = {
           gateway,
           completionInbox,
           budget,
+          parentSessionId: String(parent.sessionId),
+          retired: false,
           close() {
             if (released) return;
             released = true;
@@ -6665,11 +7318,65 @@ async function createSubagentRuntime(input) {
       if (oldest !== void 0) releasedTurns.delete(oldest);
     }
     parents.delete(turnId);
-    await pending.then(
-      (runtime) => runtime.close(),
-      () => void 0
-    );
+    const runtime = await pending.catch(() => void 0);
+    if (runtime === void 0) return;
+    if (runtime.retired) {
+      parents.set(turnId, pending);
+      return;
+    }
+    if (!closed && opts.backgroundByDefault === true && retireWithRunningTasks(turnId, runtime)) {
+      parents.set(turnId, pending);
+      return;
+    }
+    runtime.close();
   }, "releaseTurn");
+  const retireWithRunningTasks = /* @__PURE__ */ __name((turnId, runtime) => {
+    const running = runtime.gateway.listTasks().filter((task) => !isTerminalAgentTaskState(task.state));
+    const unheard = runtime.completionInbox.drain();
+    for (const handle of unheard) reportBackgroundCompletion(turnId, runtime, handle);
+    if (running.length === 0) return false;
+    runtime.retired = true;
+    let remaining = running.length;
+    for (const task of running) {
+      runtime.gateway.waitForTask(task.taskId).then(
+        (handle) => reportBackgroundCompletion(turnId, runtime, handle),
+        () => void 0
+      ).finally(() => {
+        remaining -= 1;
+        if (remaining > 0 || parents.get(turnId) === void 0) return;
+        parents.delete(turnId);
+        runtime.close();
+      });
+    }
+    return true;
+  }, "retireWithRunningTasks");
+  const reportBackgroundCompletion = /* @__PURE__ */ __name((turnId, runtime, handle) => {
+    if (closed || backgroundCompletionListeners.size === 0) return;
+    if (!isTerminalAgentTaskState(handle.state)) return;
+    runtime.completionInbox.claim(handle.taskId);
+    const shown = activity.getSnapshot().find((entry) => entry.taskId === String(handle.taskId));
+    const completion = {
+      parentSessionId: runtime.parentSessionId,
+      taskId: String(handle.taskId),
+      ...shown ? { viewId: shown.viewId } : {},
+      agentId: shown?.agentId ?? String(handle.agentId),
+      description: shown?.description ?? String(handle.agentId),
+      state: handle.state === "completed" ? "completed" : handle.state === "canceled" ? "cancelled" : "failed",
+      ...shown?.stoppedBy ? { stoppedBy: shown.stoppedBy } : {},
+      text: formatCompletionNotification([handle])
+    };
+    for (const listener of [...backgroundCompletionListeners]) listener(completion);
+  }, "reportBackgroundCompletion");
+  const gatewayHolding = /* @__PURE__ */ __name(async (taskId, turnId) => {
+    const own = await gatewayForTurn(turnId);
+    if (own.getTask(taskId)) return own;
+    for (const [otherId, pending] of parents) {
+      if (otherId === turnId) continue;
+      const runtime = await pending.catch(() => void 0);
+      if (runtime?.retired && runtime.gateway.getTask(taskId)) return runtime.gateway;
+    }
+    return own;
+  }, "gatewayHolding");
   const completionInboxForTurn = /* @__PURE__ */ __name(async (turnId) => {
     await gatewayForTurn(turnId);
     const pending = parents.get(turnId);
@@ -6902,8 +7609,8 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
   const agentTool = defineTool({
     name: "Agent",
     description: [
-      "Delegate a self-contained task to a sub-agent. Set run_in_background: true to receive its task ID immediately and continue independent work; completion arrives as a task notification. Otherwise wait for its result. Operator input can also release a blocking wait while the child keeps working. Use agent_task_list for current agent status (task_list is only the planning list), send_message to correct a running task, cancel_agent to stop only one owned task, and wait_for_task to retrieve its result; never launch duplicate work.",
-      "For a request to run multiple independent tasks in parallel, issue all Agent calls together in one response, or set run_in_background: true on each launch before waiting. A single blocking Agent call followed by another call runs them sequentially.",
+      opts.backgroundByDefault === true ? "Delegate a self-contained task to a sub-agent. Agents run in the background by default: you get the task ID at once and are notified automatically when one ends, so do not sleep, poll or check on its progress; continue with other work or answer the user instead. Pass run_in_background: false only when your very next action depends on the result and nothing else could usefully happen while it runs. Operator input can also release a blocking wait while the child keeps working. Use agent_task_list for current agent status (task_list is only the planning list), send_message to correct a running task, cancel_agent to stop only one owned task, and wait_for_task to retrieve its result; never launch duplicate work." : "Delegate a self-contained task to a sub-agent. Set run_in_background: true to receive its task ID immediately and continue independent work; completion arrives as a task notification. Otherwise wait for its result. Operator input can also release a blocking wait while the child keeps working. Use agent_task_list for current agent status (task_list is only the planning list), send_message to correct a running task, cancel_agent to stop only one owned task, and wait_for_task to retrieve its result; never launch duplicate work.",
+      opts.backgroundByDefault === true ? "For a request to run multiple independent tasks in parallel, issue all Agent calls together in one response. A blocking Agent call (run_in_background: false) followed by another call runs them sequentially." : "For a request to run multiple independent tasks in parallel, issue all Agent calls together in one response, or set run_in_background: true on each launch before waiting. A single blocking Agent call followed by another call runs them sequentially.",
       'Pick `subagent_type: "explore"` for anything that only needs to look \u2014 where is X defined, which files reference Y, how does Z work \u2014 it has reading and searching tools only and never asks for permission.',
       'Use the default "general-purpose" when the task must change files or run commands.',
       'Set `workspace: "worktree"` when the child needs its own Git checkout. It starts from this checkout\'s committed HEAD; uncommitted parent changes are absent. The checkout and its edits remain after the child ends, so report its path and branch to the operator.',
@@ -6929,7 +7636,7 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
         },
         run_in_background: {
           type: "boolean",
-          description: "Return after launch so the parent can continue independent work. Defaults to false."
+          description: opts.backgroundByDefault === true ? "Agents run in the background by default; you will be notified when one completes. Set to false only when your very next action depends on this agent's result and nothing else could usefully happen while it runs; otherwise leave it in the background so the user can hand you other work." : "Return after launch so the parent can continue independent work. Defaults to false."
         },
         workspace: {
           type: "string",
@@ -6996,8 +7703,10 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
     concurrencySafe: true,
     timeoutMs: opts.resolveLimits ? 0 : opts.timeoutMs ?? CLI_INTERACTIVE_TURN_TIMEOUT_MS,
     async execute(input2, context) {
-      const { description, run_in_background } = input2;
-      const { outcome, agentId } = await launchChild(input2, context);
+      const call = input2;
+      const run_in_background = call.run_in_background ?? opts.backgroundByDefault === true;
+      const { description } = call;
+      const { outcome, agentId } = await launchChild({ ...call, run_in_background }, context);
       if (outcome.kind === "yielded") {
         const progress = outcome.handle.state === "pending" ? "queued for an available slot" : "still running";
         return {
@@ -7023,10 +7732,13 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
     if (launch.effort !== void 0 && launch.model === void 0) {
       throw new Error("Supply model when selecting an agent effort.");
     }
-    const prompt = launch.schema === void 0 ? launch.prompt : `${launch.prompt}
+    const step = launch.schema === void 0 ? launch.prompt : `${launch.prompt}
 
 Answer with one JSON value that satisfies this JSON Schema and nothing else:
 ${JSON.stringify(launch.schema)}`;
+    const prompt = `${WORKFLOW_STEP_ASSIGNMENT}
+
+${step}`;
     const label = launch.workflowName === DEFAULT_AGENT_WORKFLOW ? "Workflow" : launch.workflowName;
     let viewId;
     let lastReport = 0;
@@ -7143,7 +7855,12 @@ ${JSON.stringify(launch.schema)}`;
         };
       }
       const gateway = await gatewayForTurn(context.turnId);
-      const tasks = gateway.listTasks();
+      const tasks = [...gateway.listTasks()];
+      for (const [otherId, pending] of parents) {
+        if (otherId === context.turnId) continue;
+        const runtime = await pending.catch(() => void 0);
+        if (runtime?.retired) tasks.push(...runtime.gateway.listTasks());
+      }
       const snapshot = activity.getSnapshot();
       const labels = new Map(snapshot.map((entry) => [entry.taskId, entry.description]));
       const shown = tasks.slice(-40).map((task) => ({
@@ -7190,7 +7907,7 @@ ${JSON.stringify(launch.schema)}`;
     concurrencySafe: true,
     timeoutMs: opts.resolveLimits ? 0 : opts.timeoutMs ?? CLI_INTERACTIVE_TURN_TIMEOUT_MS,
     async execute(input2, context) {
-      const gateway = await gatewayForTurn(context.turnId);
+      let gateway = await gatewayForTurn(context.turnId);
       let taskId;
       const asked = input2.task_id;
       if (typeof asked === "string" && /^w[0-9a-z]{8}$/.test(asked.trim())) {
@@ -7209,6 +7926,7 @@ ${JSON.stringify(launch.schema)}`;
           error: "task_id must be a task UUID returned by Agent or a task notification."
         };
       }
+      gateway = await gatewayHolding(taskId, context.turnId);
       const task = gateway.getTask(taskId);
       if (!task)
         return {
@@ -7280,7 +7998,7 @@ ${JSON.stringify(launch.schema)}`;
           error: "Message must not be blank."
         };
       const taskId = asTaskId(task_id);
-      const gateway = await gatewayForTurn(context.turnId);
+      const gateway = await gatewayHolding(taskId, context.turnId);
       const task = gateway.getTask(taskId);
       if (!task)
         return {
@@ -7344,7 +8062,7 @@ ${JSON.stringify(launch.schema)}`;
     async execute(input2, context) {
       context.abortSignal.throwIfAborted();
       const taskId = asTaskId(input2.task_id);
-      const gateway = await gatewayForTurn(context.turnId);
+      const gateway = await gatewayHolding(taskId, context.turnId);
       const task = gateway.getTask(taskId);
       if (!task)
         return {
@@ -7520,7 +8238,7 @@ ${JSON.stringify(launch.schema)}`;
     const owned = conversations.get(viewId);
     const shown = activity.getSnapshot().find((value) => value.viewId === viewId);
     if (!owned || !shown || shown.replayed)
-      throw new Error("This child is saved evidence or is no longer owned by this host.");
+      throw new Error("This agent is a saved record and is no longer running.");
     if (shown.status === "cancelled")
       throw new Error(
         source === "operator" ? `${shown.agentId} was stopped, so it cannot take a message. Start a new agent for that work.` : `Agent "${shown.agentId}" was stopped by the user and was not resumed. Treat its work as cancelled; only start a new agent for it if the user explicitly asks.`
@@ -7714,6 +8432,12 @@ ${JSON.stringify(launch.schema)}`;
         childMessageListeners.delete(listener);
       };
     },
+    onBackgroundCompletion(listener) {
+      backgroundCompletionListeners.add(listener);
+      return () => {
+        backgroundCompletionListeners.delete(listener);
+      };
+    },
     cancelAgentTool,
     modelCatalogueTool,
     messageChild,
@@ -7964,9 +8688,13 @@ __name(buildDefinition, "buildDefinition");
 
 // src/integrations/workflows/doctrine.ts
 var WORKFLOW_DOCTRINE = [
-  "The `workflow` tool is available this turn because the operator asked for orchestration.",
-  "Use it for work with several phases or many agents: write the script once, call `workflow`, and the runtime schedules the agents and groups them by phase. Keep `Agent` calls (with a `workflow` label and a `phase`) for a small fan-out of a few agents, and for a single subagent.",
-  "A workflow runs in the background and the operator approves the script before it starts. After you start one, tell the operator in one sentence that it is running; its result reaches you in a single message when it ends, and you then report the outcome."
+  "The `workflow` tool starts many agents on one decision. Call it only after an explicit opt-in, which is one of:",
+  `- the operator's message included the keyword "hypermode" or "workflow" (a note from Namzu confirms it for that turn);`,
+  "- hypermode is on for the session (a note from Namzu confirms it); then it is a standing opt-in for every substantive task, and you work alone only on conversational or trivial turns;",
+  "- the operator asked for a workflow or for multi-agent orchestration in their own words;",
+  "- the operator named a specific saved workflow to run.",
+  "For any other task, even one that would clearly benefit from parallelism, do not call it: use `Agent` for a single subagent or a small fan-out of a few agents.",
+  "Use it for work with several phases or many agents: write the script once, call `workflow`, and the runtime schedules the agents and groups them by phase. A workflow runs in the background and the operator approves the script before it starts. After you start one, tell the operator in one sentence that it is running; its result reaches you in a single message when it ends, and you then report the outcome."
 ].join("\n");
 
 // src/integrations/workflows/history.ts
@@ -8020,6 +8748,43 @@ __name(listWorkflowRuns, "listWorkflowRuns");
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { join as join9 } from "node:path";
 
+// src/integrations/workflows/offering.ts
+var WORKFLOW_TOOL_NAME = "workflow";
+var WORKFLOW_BACKGROUND_NOTE = "Running in the background (\u2193 to manage)";
+var WORKFLOW_TOOL_DESCRIPTION = [
+  `Run a workflow: a short JavaScript program you write once that starts many subagents, in order and in parallel, and returns one value. It runs in the background: this call returns once the first agent is requested, and one message arrives when the run ends. A script that fails before it requests any agent is an error of this call, and one that finishes without any returns its result here. ONLY call it after an explicit opt-in: the operator's message included the keyword "hypermode" or "workflow" (a note confirms it), hypermode is on for the session (a note confirms it), the operator asked for a workflow or multi-agent orchestration in their own words, or they named a saved workflow to run. For any other task, even one that would clearly benefit from parallelism, do not call it; for a single subagent or a small fan-out, use the Agent tool.`,
+  "",
+  "The script is confined: no files, no network, no commands, no timers, no imports. Its only power is agent(), which starts a subagent with the same tools, permissions, sandbox and budget the Agent tool gives. A prompt you pass is data for that subagent and cannot widen what it may do.",
+  "",
+  "The first statement must be a pure literal, with no variables, calls or spreads:",
+  'export const meta = { name: "audit", description: "One line the operator reads before it starts", phases: [{ title: "Scan" }, { title: "Fix", detail: "safe fixes only" }] }',
+  "",
+  "Then plain code. Everything below is a global:",
+  '- agent(prompt, opts?) starts one subagent and resolves to its final text, or to a parsed value when opts.schema (a JSON Schema) is given, or to null when it failed or was skipped. Always handle null. opts: label (a short row title), phase (a phase title), schema, agentType ("general-purpose", "explore", or a project agent), model, effort. The subagent cannot see this conversation or your variables: put everything it needs in the prompt.',
+  "- parallel([() => agent(...), ...]) starts every thunk now and resolves when all are done. It never rejects: a thunk that throws becomes null in its place and the reason goes through log(), so filter the nulls (.filter(Boolean)).",
+  "- pipeline(items, stage1, stage2, ...) runs one chain per item with no barrier between stages; a stage gets (prevResult, originalItem, index), where the first stage gets the item as prevResult, and an item whose stage gives null stops there. It never rejects either: a stage that throws drops its item to null and the reason goes through log(), so filter the nulls.",
+  "- phase(title) names the stage that the following agents belong to; inside parallel() or pipeline() pass opts.phase instead. Use the same titles as in meta.phases.",
+  '- log(message) writes a progress line. args is exactly the JSON you pass in the args input of the call (undefined when you omit it). budget is { total, spent(), remaining() }: total is the token target the person typed (a standalone "+500k" in their message) or null when there is none; spent() is the tokens this run has used; remaining() is max(0, total - spent()), or Infinity with no target. The target is a hard ceiling: once spent() reaches total, agent() throws, so wrap loops in try/catch and guard them on budget.total (with no target remaining() is Infinity). Example: while (budget.total && budget.remaining() > 50_000) { ... }.',
+  "- return a small JSON value: it is what you get back, capped at about 8000 characters. Have agents write large results to files and return the paths.",
+  "",
+  "Limits: a handful of agents run at once (the cap comes from the configuration; usually up to 16) and at most 1000 start per run (fewer if configured); a script that asks for more fails, so give any loop a hard iteration cap. The script may be up to 256 KiB and args 64 KiB, but the operator reads the script before it starts, so keep it as short as it can be: loops over lists, shared helpers, prompts built from args. Put long per-agent instructions in a file the agents read.",
+  "",
+  "Quality patterns, when hypermode is on or the task is large: adversarial verify (a second agent tries to disprove each finding), a judge panel (several agents score the same candidates, keep the consensus), loop until dry (repeat a sweep until a pass finds nothing new), and a completeness critic (a last agent lists what the others missed). Pick what fits; skip them for trivial or already verified work.",
+  "",
+  "Before it starts the operator sees the name, description, phases, limits and the script, and approves or declines. If they decline, do not retry with the same script; ask what to change."
+].join("\n");
+function workflowToolDescription(sizeAdvice = "") {
+  return sizeAdvice === "" ? WORKFLOW_TOOL_DESCRIPTION : `${WORKFLOW_TOOL_DESCRIPTION}
+
+${sizeAdvice}`;
+}
+__name(workflowToolDescription, "workflowToolDescription");
+function workflowRefusal(turn) {
+  if (turn.mode === "auto" || turn.mode === "bypass" || turn.interactive) return void 0;
+  return "A workflow starts many agents on one decision, so a person has to approve it first. This session has nobody to ask and is not set to run without asking, so no workflow was started. Run it from the terminal, or start the session with --permission-mode bypass.";
+}
+__name(workflowRefusal, "workflowRefusal");
+
 // src/integrations/workflows/registry.ts
 var WorkflowRunRegistry = class {
   static {
@@ -8119,11 +8884,11 @@ var WorkflowRunRegistry = class {
   whenIdle(signal) {
     const going = /* @__PURE__ */ __name(() => [...this.runs.values()].some((run2) => !run2.finalized), "going");
     if (!going() || signal?.aborted) return Promise.resolve();
-    return new Promise((resolve11) => {
+    return new Promise((resolve13) => {
       const done = /* @__PURE__ */ __name(() => {
         off();
         signal?.removeEventListener("abort", done);
-        resolve11();
+        resolve13();
       }, "done");
       const off = this.subscribe(() => {
         if (!going()) done();
@@ -8213,6 +8978,22 @@ function createWorkflowRunId(isTaken = () => false) {
   }
 }
 __name(createWorkflowRunId, "createWorkflowRunId");
+function plainScriptFailure(raw) {
+  const newline = raw.indexOf("\n");
+  const first = newline === -1 ? raw : raw.slice(0, newline);
+  const rest = newline === -1 ? "" : raw.slice(newline);
+  const names = /^(?:[A-Za-z]*Error:\s*)+/;
+  const at = /^([\s\S]*?) — line (\d+), column (\d+): ([\s\S]*)$/.exec(first);
+  if (at) {
+    const [, what, line, column, source] = at;
+    return `The script stopped at line ${line}, column ${column}: ${(what ?? "").replace(names, "")}
+That line reads: ${source}${rest}`;
+  }
+  const none = /^([\s\S]*?) — the interpreter gave no line number for this error\.$/.exec(first);
+  if (none) return `The script stopped: ${(none[1] ?? "").replace(names, "")}${rest}`;
+  return `${first.replace(names, "")}${rest}`;
+}
+__name(plainScriptFailure, "plainScriptFailure");
 function endedBeforeAgents(end, noArgs) {
   const { view } = end;
   if (view.status === "completed") {
@@ -8222,8 +9003,8 @@ function endedBeforeAgents(end, noArgs) {
       data: { run_id: view.runId, name: view.name, status: "completed", inline: true }
     };
   }
-  const reason = view.error ?? "no reason was given";
-  const hint = view.status === "failed" && noArgs ? '\nThis call passed no "args", so `args` was undefined in the script.' : "";
+  const reason = plainScriptFailure(view.error ?? "no reason was given");
+  const hint = view.status === "failed" && noArgs && /\bargs\b/.test(reason) ? '\nThis call passed no "args", so `args` was undefined in the script.' : "";
   return {
     success: false,
     output: "",
@@ -8256,7 +9037,7 @@ function createWorkflowHost(options) {
   const registry = options.registry ?? new WorkflowRunRegistry();
   const tool = defineTool({
     name: WORKFLOW_TOOL_NAME,
-    description: WORKFLOW_TOOL_DESCRIPTION,
+    description: workflowToolDescription(options.sizeAdvice),
     inputSchema: mcpJsonSchemaToZod({
       type: "object",
       properties: {
@@ -8320,8 +9101,8 @@ function createWorkflowHost(options) {
       let launching = true;
       let settleLaunch = /* @__PURE__ */ __name(() => {
       }, "settleLaunch");
-      const launch = new Promise((resolve11) => {
-        settleLaunch = resolve11;
+      const launch = new Promise((resolve13) => {
+        settleLaunch = resolve13;
       });
       const detach = /* @__PURE__ */ __name(() => {
         if (!launching) return;
@@ -8420,7 +9201,7 @@ __name(createWorkflowHost, "createWorkflowHost");
 
 // src/memory/store.ts
 import { realpathSync as realpathSync3 } from "node:fs";
-import { join as join11, resolve as resolve7 } from "node:path";
+import { join as join11, resolve as resolve9 } from "node:path";
 
 // src/memory/io.ts
 import {
@@ -8434,20 +9215,20 @@ import {
   realpathSync as realpathSync2,
   writeSync
 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join10, relative as relative5, resolve as resolve6, sep as sep4 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join10, relative as relative6, resolve as resolve8, sep as sep4 } from "node:path";
 var MEMORY_FILE_MAX_BYTES = 1024 * 1024;
 function missing(error) {
   return error.code === "ENOENT";
 }
 __name(missing, "missing");
 function within(path, root) {
-  const part = relative5(root, path);
-  return !isAbsolute5(part) && part !== ".." && !part.startsWith(`..${sep4}`);
+  const part = relative6(root, path);
+  return !isAbsolute7(part) && part !== ".." && !part.startsWith(`..${sep4}`);
 }
 __name(within, "within");
 function resolveMemoryPath(location, createParents = false) {
-  const root = resolve6(location.root);
-  const path = resolve6(location.path);
+  const root = resolve8(location.root);
+  const path = resolve8(location.path);
   if (!within(path, root)) throw new Error("Memory path is outside its allowed scope.");
   let rootStat;
   try {
@@ -8462,7 +9243,7 @@ function resolveMemoryPath(location, createParents = false) {
     throw new Error("Memory scope root is a symlink outside its allowed scope.");
   if (!rootStat.isDirectory()) throw new Error("Memory scope root must be a directory.");
   const canonicalRoot2 = realpathSync2(root);
-  const parts = relative5(root, path).split(sep4);
+  const parts = relative6(root, path).split(sep4);
   let candidate = canonicalRoot2;
   for (let i = 0; i < parts.length; i += 1) {
     const part = parts[i];
@@ -8605,7 +9386,7 @@ function memoryFilePath(home) {
 }
 __name(memoryFilePath, "memoryFilePath");
 function projectMemoryFilePath(cwd) {
-  let directory = resolve7(cwd);
+  let directory = resolve9(cwd);
   try {
     directory = realpathSync3(directory);
   } catch (error) {
@@ -8622,7 +9403,7 @@ function projectMemoryLocation(cwd) {
 }
 __name(projectMemoryLocation, "projectMemoryLocation");
 function projectLocation(cwd) {
-  const directory = realpathSync3(resolve7(cwd));
+  const directory = realpathSync3(resolve9(cwd));
   return { path: projectMemoryFilePath(directory), root: cliProjectRoot(directory) };
 }
 __name(projectLocation, "projectLocation");
@@ -8652,7 +9433,7 @@ function readMemory(home, cwd) {
     root: userRoot,
     path: join11(userRoot, "MEMORY.md")
   }));
-  const project = cwd && !isUserMemoryFile(join11(resolve7(cwd), ".namzu", "MEMORY.md"), userRoot) ? read(join11(resolve7(cwd), ".namzu", "MEMORY.md"), () => projectLocation(cwd)) : null;
+  const project = cwd && !isUserMemoryFile(join11(resolve9(cwd), ".namzu", "MEMORY.md"), userRoot) ? read(join11(resolve9(cwd), ".namzu", "MEMORY.md"), () => projectLocation(cwd)) : null;
   return { user, memory, project, ...diagnostics.length > 0 ? { diagnostics } : {} };
 }
 __name(readMemory, "readMemory");
@@ -8661,7 +9442,7 @@ function isUserMemoryFile(projectPath, userRoot) {
     try {
       return realpathSync3(path);
     } catch {
-      return resolve7(path);
+      return resolve9(path);
     }
   }, "canonical");
   return canonical(projectPath) === canonical(join11(userRoot, "MEMORY.md"));
@@ -8868,10 +9649,10 @@ function composeStoredMemoryPrompt(index) {
   ].join("\n");
 }
 __name(composeStoredMemoryPrompt, "composeStoredMemoryPrompt");
-var MARKER = "migration.json";
+var MARKER2 = "migration.json";
 async function readMarker(directory) {
   try {
-    const parsed = JSON.parse(await readFile4(join12(directory, MARKER), "utf8"));
+    const parsed = JSON.parse(await readFile4(join12(directory, MARKER2), "utf8"));
     return parsed !== null && typeof parsed === "object" ? parsed : {};
   } catch (error) {
     if (error.code === "ENOENT") return {};
@@ -8884,7 +9665,7 @@ async function markCuratedFile(directory, path, state) {
   const files = { ...marker.curatedFiles ?? {} };
   files[path] = { ...files[path] ?? {}, ...state };
   await writeFile2(
-    join12(directory, MARKER),
+    join12(directory, MARKER2),
     `${JSON.stringify({ ...marker, curatedFiles: files }, null, 2)}
 `,
     { mode: 384 }
@@ -9066,9 +9847,9 @@ function describeCuratedNotesImport(result, directory) {
   if (result.found === 0) {
     return `No top-level bullets to copy in ${result.path}; it is unchanged.`;
   }
-  const plural2 = /* @__PURE__ */ __name((n) => n === 1 ? "" : "s", "plural");
+  const plural3 = /* @__PURE__ */ __name((n) => n === 1 ? "" : "s", "plural");
   const already = result.alreadyStored > 0 ? ` ${result.alreadyStored} ${result.alreadyStored === 1 ? "was" : "were"} already stored and not copied again.` : "";
-  return `Copied ${result.copied} of ${result.found} bullet${plural2(result.found)} from ${result.path} into typed memory files in ${directory}.${already} ${result.path} is unchanged: its bullets are still curated text in every turn. Delete the ones you no longer want there yourself.`;
+  return `Copied ${result.copied} of ${result.found} bullet${plural3(result.found)} from ${result.path} into typed memory files in ${directory}.${already} ${result.path} is unchanged: its bullets are still curated text in every turn. Delete the ones you no longer want there yourself.`;
 }
 __name(describeCuratedNotesImport, "describeCuratedNotesImport");
 
@@ -9224,12 +10005,12 @@ __name(createLiveModeControl, "createLiveModeControl");
 
 // src/permissions/local-settings.ts
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync, readFileSync, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { appendFile as appendFile3, mkdir as mkdir5, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute6, join as join13, resolve as resolve8 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute8, join as join13, resolve as resolve10 } from "node:path";
 function localConfigPath(cwd) {
-  return resolve8(cwd, LOCAL_CONFIG_FILE);
+  return resolve10(cwd, LOCAL_CONFIG_FILE);
 }
 __name(localConfigPath, "localConfigPath");
 function isRecord2(value) {
@@ -9264,7 +10045,7 @@ function writeLocalAllows(cwd, additions) {
   if (existsSync(path)) {
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync(path, "utf-8"));
+      parsed = JSON.parse(readFileSync2(path, "utf-8"));
     } catch (cause) {
       return {
         path,
@@ -9308,9 +10089,9 @@ function globalIgnorePath(configured, env) {
   const home = env.HOME ?? env.USERPROFILE ?? homedir();
   const value = configured.trim();
   if (value === "~" || value.startsWith("~/")) return join13(home, value.slice(2));
-  if (value !== "" && isAbsolute6(value)) return value;
+  if (value !== "" && isAbsolute8(value)) return value;
   const xdg = env.XDG_CONFIG_HOME;
-  if (xdg && isAbsolute6(xdg)) return join13(xdg, "git", "ignore");
+  if (xdg && isAbsolute8(xdg)) return join13(xdg, "git", "ignore");
   return join13(home, ".config", "git", "ignore");
 }
 __name(globalIgnorePath, "globalIgnorePath");
@@ -9628,17 +10409,17 @@ var EXIT_PLAN_MODE_TOOL_NAME = "exit_plan_mode";
 
 // src/plan/plan-file.ts
 import { readFile as readFile6 } from "node:fs/promises";
-import { isAbsolute as isAbsolute7, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute9, resolve as resolve11 } from "node:path";
 var WRITERS = /* @__PURE__ */ new Set(["write", "edit"]);
 function isPlanFileWrite(planPath, cwd) {
-  const target = resolve9(planPath);
+  const target = resolve11(planPath);
   return (call) => {
     if (!WRITERS.has(call.name)) return false;
     const input = call.input;
     if (input === null || typeof input !== "object") return false;
     const path = input.path;
     if (typeof path !== "string" || path.length === 0 || path.includes("\0")) return false;
-    return resolve9(isAbsolute7(path) ? path : resolve9(cwd, path)) === target;
+    return resolve11(isAbsolute9(path) ? path : resolve11(cwd, path)) === target;
   };
 }
 __name(isPlanFileWrite, "isPlanFileWrite");
@@ -9782,7 +10563,7 @@ __name(frameReminder, "frameReminder");
 function reminderKindOf(message2) {
   if (!isReminderMessage(message2) || typeof message2.content !== "string") return void 0;
   const kind = TAG.exec(message2.content)?.[1];
-  return kind === "plan-mode" || kind === "plan-reentry" || kind === "plan-exit" || kind === "task-nudge" ? kind : void 0;
+  return kind === "plan-mode" || kind === "plan-reentry" || kind === "plan-exit" || kind === "task-nudge" || kind === "hypermode-on" || kind === "hypermode-exit" ? kind : void 0;
 }
 __name(reminderKindOf, "reminderKindOf");
 function isOperatorTurn(message2) {
@@ -9792,10 +10573,53 @@ function isOperatorTurn(message2) {
 }
 __name(isOperatorTurn, "isOperatorTurn");
 
+// src/reminders/hypermode.ts
+var HYPERMODE_REMINDER_EVERY = 10;
+var FULL_WITH_TOOL = "Hypermode is on: optimize for the most exhaustive, correct answer, not the fastest or cheapest. Use the `workflow` tool on every substantive task; token cost is not a constraint. Pick from the quality patterns in the tool description (adversarial verify, judge panel, loop until dry, completeness critic). Solo only on conversational or trivial turns.";
+var FULL_WITHOUT_TOOL = "Hypermode is on: optimize for the most exhaustive, correct answer, not the fastest or cheapest. The `workflow` tool is not available in this run, so delegate every substantive task to parallel agents with the `Agent` tool and have their findings verified; token cost is not a constraint. Solo only on conversational or trivial turns.";
+var SPARSE_WITH_TOOL = "Hypermode is still on: use the `workflow` tool for substantive work.";
+var SPARSE_WITHOUT_TOOL = "Hypermode is still on: delegate substantive work to parallel agents with the `Agent` tool.";
+var EXIT = "Hypermode is off: the `workflow` tool's standard opt-in rule applies again.";
+function scan(messages) {
+  let turns = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message2 = messages[i];
+    const kind = reminderKindOf(message2);
+    if (kind === "hypermode-on" || kind === "hypermode-exit") return { last: kind, turns };
+    if (isOperatorTurn(message2)) turns++;
+  }
+  return { last: void 0, turns };
+}
+__name(scan, "scan");
+function hypermodeExitOwed(messages) {
+  return scan(messages).last === "hypermode-on";
+}
+__name(hypermodeExitOwed, "hypermodeExitOwed");
+function hypermodeReminders(input) {
+  const { last, turns } = scan(input.messages);
+  if (!input.on) {
+    return last === "hypermode-on" ? [frameReminder("hypermode-exit", EXIT)] : [];
+  }
+  if (last !== "hypermode-on") {
+    return [
+      frameReminder("hypermode-on", input.toolListed ? FULL_WITH_TOOL : FULL_WITHOUT_TOOL, "full")
+    ];
+  }
+  if (turns < HYPERMODE_REMINDER_EVERY) return [];
+  return [
+    frameReminder(
+      "hypermode-on",
+      input.toolListed ? SPARSE_WITH_TOOL : SPARSE_WITHOUT_TOOL,
+      "sparse"
+    )
+  ];
+}
+__name(hypermodeReminders, "hypermodeReminders");
+
 // src/reminders/plan-mode.ts
 var PLAN_REMINDER_EVERY_N_TURNS = 5;
 var PLAN_REMINDER_FULL_EVERY_N = 5;
-function scan(messages) {
+function scan2(messages) {
   let turns = 0;
   let hasReminder = false;
   let sent = 0;
@@ -9818,7 +10642,7 @@ function scan(messages) {
   }
   return { turnsSinceReminder: turns, hasReminder, sent, hasExited };
 }
-__name(scan, "scan");
+__name(scan2, "scan");
 function fullText(input) {
   const file = input.planExists ? `A plan already exists at ${input.planPath}. Read it, then revise it in place with the edit tool.` : `No plan exists yet. Create it at ${input.planPath} with the write tool.`;
   const ending = input.canAsk ? "Your turn ends in exactly one of two ways: you ask the user a question with ask_user_question to settle something you cannot decide yourself, or you call exit_plan_mode once the plan file is ready for approval." : "Your turn ends by calling exit_plan_mode once the plan file is ready for approval.";
@@ -9846,7 +10670,7 @@ function exitText(input) {
 }
 __name(exitText, "exitText");
 function planModeReminders(input) {
-  const stretch = scan(input.messages);
+  const stretch = scan2(input.messages);
   if (input.mode !== "plan") {
     return stretch.hasReminder ? [frameReminder("plan-exit", exitText(input))] : [];
   }
@@ -9927,6 +10751,7 @@ function createCliReminderSource(options) {
         })
       );
     }
+    if (options.hypermode) out.push(...hypermodeReminders({ messages, ...options.hypermode() }));
     if (options.tasks) {
       const nudge = taskNudge(messages, []);
       if (nudge.length > 0) out.push(...taskNudge(messages, await options.tasks()));
@@ -10085,19 +10910,19 @@ async function resolveModelSwitch(request, options) {
     listed.set(detected.entry.id, listing);
     return listing.kind === "ok" && listing.models.some((candidate) => candidate.id === model);
   }, "inspect");
-  const resolve11 = /* @__PURE__ */ __name((detected) => ({
+  const resolve13 = /* @__PURE__ */ __name((detected) => ({
     kind: "resolved",
     selection: { id: detected.entry.id, model }
   }), "resolve");
   const first = selected ?? usable.find(({ entry }) => entry.id === options.currentProvider);
-  if (first && await inspect(first)) return resolve11(first);
+  if (first && await inspect(first)) return resolve13(first);
   const candidates = selected ? [selected] : usable;
   const matches = selected ? [] : (await Promise.all(
     candidates.filter((candidate) => candidate !== first).map(async (candidate) => await inspect(candidate) ? candidate : void 0)
   )).filter((candidate) => candidate !== void 0);
   signal?.throwIfAborted();
   const uniqueMatch = matches.length === 1 ? matches[0] : void 0;
-  if (uniqueMatch) return resolve11(uniqueMatch);
+  if (uniqueMatch) return resolve13(uniqueMatch);
   if (matches.length > 1) {
     return {
       kind: "rejected",
@@ -10253,8 +11078,8 @@ var SessionOperationOwner = class {
     })()[Symbol.asyncIterator]();
     let settled = false;
     let settle;
-    const settlement = new Promise((resolve11) => {
-      settle = resolve11;
+    const settlement = new Promise((resolve13) => {
+      settle = resolve13;
     });
     let operationTail = Promise.resolve();
     let returnStarted = false;
@@ -10501,6 +11326,14 @@ function withCheckpointsWrap(builtin, checkpoints) {
   });
 }
 __name(withCheckpointsWrap, "withCheckpointsWrap");
+var builtinPresenter;
+function builtinToolPresenter() {
+  builtinPresenter ??= createCliToolPresenter(
+    new ToolManager({ toolsets: [toolset("builtin", builtinTools(true))], messages: /* @__PURE__ */ __name(() => [], "messages") })
+  );
+  return builtinPresenter;
+}
+__name(builtinToolPresenter, "builtinToolPresenter");
 function buildBaseToolsets(paths, backgroundJobs) {
   const builtin = toolset("builtin", builtinTools(backgroundJobs));
   const directory = ensurePrivateStateDirectory(paths.projectDir(), "memory");
@@ -10523,14 +11356,16 @@ function clipRequestContext(prompt, limit, kind) {
 __name(clipRequestContext, "clipRequestContext");
 async function createAgentSession(prefs, detected, options = {}) {
   if (options.palEnvironment) {
-    const { createPalAgentSession } = await import("./agent-session-CQ52CRGK.js");
+    const { createPalAgentSession } = await import("./agent-session-HFOLAFFL.js");
     return createPalAgentSession(prefs, detected, options);
   }
-  const { palAtWorkspace } = await import("./store-UKFFPFLI.js");
+  const { palAtWorkspace } = await import("./store-TKJKR5NM.js");
   if (palAtWorkspace(options.cwd ?? process.cwd()))
     throw new Error("This Pal requires its owned virtual computer. Open it with namzu pal chat.");
   const commandArguments = builtinCommandArguments();
-  const sessionAllows = createSessionAllows(commandArguments, { cwd: /* @__PURE__ */ __name(() => cwd, "cwd") });
+  const sessionAllows = createSessionAllows(commandArguments, {
+    cwd: /* @__PURE__ */ __name(() => cwd, "cwd")
+  });
   const sessionRules = [...options.rules ?? [], sessionAllows.rule];
   const fileObservations = /* @__PURE__ */ new Map();
   const observationsFor = /* @__PURE__ */ __name((id, prior) => {
@@ -10560,7 +11395,7 @@ async function createAgentSession(prefs, detected, options = {}) {
     }
     return seeded;
   }, "observationsFor");
-  const requestedCwd = resolve10(options.cwd ?? process.cwd());
+  const requestedCwd = resolve12(options.cwd ?? process.cwd());
   let cwd;
   try {
     const entry2 = await stat4(requestedCwd);
@@ -10592,13 +11427,13 @@ async function createAgentSession(prefs, detected, options = {}) {
       paths = options.conversationSessions.paths;
       projectId = options.conversationSessions.projectId;
     } else {
-      const home = resolve10(options.stateRoot ?? resolveNamzuHome());
+      const home = resolve12(options.stateRoot ?? resolveNamzuHome());
       ensurePrivateStateDirectory(home, "projects");
       const project = await ensureProject({ home, cwd: cliProjectRoot(cwd) });
       paths = new SessionPaths({ home, slug: project.slug });
       projectId = project.projectId;
     }
-    ensurePrivateStateDirectory(resolve10(paths.projectDir(), ".."), paths.slug);
+    ensurePrivateStateDirectory(resolve12(paths.projectDir(), ".."), paths.slug);
     ensurePrivateStateDirectory(paths.projectDir(), "memory");
   } catch (error) {
     return emptySession(
@@ -10883,8 +11718,8 @@ async function createAgentSession(prefs, detected, options = {}) {
   }
   const directories = [];
   for (const dir of options.additionalDirectories ?? []) {
-    const absolute = resolve10(cwd, dir);
-    if (absolute !== resolve10(cwd) && !directories.includes(absolute)) directories.push(absolute);
+    const absolute = resolve12(cwd, dir);
+    if (absolute !== resolve12(cwd) && !directories.includes(absolute)) directories.push(absolute);
   }
   const sessionDirectories = createSessionDirectories(cwd, directories);
   const checkpoints = new FileCheckpointStore(
@@ -11088,7 +11923,7 @@ async function createAgentSession(prefs, detected, options = {}) {
   }
   let sideModel;
   const webCapability = options.web?.fetch ? {
-    // A page may be ten mebibytes, as in the reference; the guard's own
+    // A page may be ten mebibytes; the guard's own
     // default is two.
     fetch: new GuardedFetchProvider({ maxBytes: WEB_FETCH_MAX_BYTES }),
     // The answer to a prompt about a page comes from the small model. It is
@@ -11109,6 +11944,7 @@ async function createAgentSession(prefs, detected, options = {}) {
   if (webCapability) toolsets.push(toolset("web-fetch", [WebFetchTool]));
   const delegationScopes = /* @__PURE__ */ new Map();
   const delegationLimits = /* @__PURE__ */ new Map();
+  const workflowTokenTargets = /* @__PURE__ */ new Map();
   const delegationModels = /* @__PURE__ */ new Map();
   const delegatedInputWaiters = /* @__PURE__ */ new Map();
   if (options.residentHistory) {
@@ -11213,6 +12049,9 @@ async function createAgentSession(prefs, detected, options = {}) {
     }
     const sub = await createSubagentRuntime({
       cwd,
+      // An operator is watching: agents run in the background by default and
+      // the turn ends without waiting for them.
+      ...options.askUser ? { backgroundByDefault: true } : {},
       worktreeStateRoot: paths.home,
       model,
       tokenBudget: options.limits?.tokenBudget,
@@ -11385,8 +12224,11 @@ async function createAgentSession(prefs, detected, options = {}) {
       }, "runsDirectory"),
       refusal: /* @__PURE__ */ __name((turnId) => {
         const auth = delegatedWorkflowAuth.get(turnId);
-        if (!auth) return "This turn cannot start a workflow.";
-        return workflowRefusal({ interactive: auth.interactive, mode: auth.mode() });
+        if (!auth) return "This reply cannot start a workflow.";
+        return workflowRefusal({
+          interactive: auth.interactive,
+          mode: auth.mode()
+        });
       }, "refusal"),
       openRunTurn: /* @__PURE__ */ __name((originTurnId, runId) => {
         const runTurnId = generateTurnId();
@@ -11434,11 +12276,17 @@ async function createAgentSession(prefs, detected, options = {}) {
           }, "release")
         };
       }, "openRunTurn"),
+      sizeAdvice: workflowSizeAdvice(
+        options.workflow?.sizeGuideline ?? DEFAULT_WORKFLOW_SIZE_GUIDELINE,
+        options.workflow?.sizeGuideline !== void 0
+      ),
       limitsFor: /* @__PURE__ */ __name((turnId) => {
         const budget = delegationLimits.get(turnId)?.tokenBudget;
+        const ceiling = workflowTokenCeiling(budget, workflowTokenTargets.get(turnId));
+        const { sizeGuideline: _advice, ...caps } = options.workflow ?? {};
         return {
-          ...budget !== void 0 && budget > 0 ? { tokenBudget: budget } : {},
-          ...options.workflow
+          ...ceiling !== void 0 ? { tokenBudget: ceiling } : {},
+          ...caps
         };
       }, "limitsFor"),
       onEnd: /* @__PURE__ */ __name((end) => {
@@ -11588,7 +12436,7 @@ async function createAgentSession(prefs, detected, options = {}) {
     );
     toolsets.push(options.toolLoading === "eager" ? monitorToolset : deferred(monitorToolset));
   }
-  const operatorPals = await import("./operator-tools-UH4SJXQJ.js");
+  const operatorPals = await import("./operator-tools-6RYAHVSL.js");
   toolsets.push(
     readyWhen(
       toolset(
@@ -12106,12 +12954,12 @@ async function createAgentSession(prefs, detected, options = {}) {
         while (queue.length > 0) {
           const next = queue.shift();
           if (!next) break;
-          const mapped = toAgentEvent(next, presenter, readsOnly);
+          const mapped = toAgentEvent(next, presenter, readsOnly, cwd);
           if (mapped) yield mapped;
         }
         if (settled) break;
-        await new Promise((resolve11) => {
-          wake = resolve11;
+        await new Promise((resolve13) => {
+          wake = resolve13;
         });
         wake = void 0;
       }
@@ -12264,6 +13112,8 @@ async function createAgentSession(prefs, detected, options = {}) {
       }, "onSubagentReport"),
       onSubagentMessage: /* @__PURE__ */ __name((listener) => subagentRuntime?.onChildMessage(listener) ?? (() => {
       }), "onSubagentMessage"),
+      onSubagentCompletion: /* @__PURE__ */ __name((listener) => subagentRuntime?.onBackgroundCompletion(listener) ?? (() => {
+      }), "onSubagentCompletion"),
       stopSubagent: /* @__PURE__ */ __name((viewId) => subagentRuntime?.stopChild(viewId) ?? false, "stopSubagent"),
       messageSubagent: /* @__PURE__ */ __name((viewId, message2, opts) => operations.promise(opts?.signal, async (signal) => {
         const runtime = subagentRuntime;
@@ -12333,7 +13183,10 @@ async function createAgentSession(prefs, detected, options = {}) {
 ` + wrapUntrusted(
                   {
                     kind: "agent-result",
-                    attributes: { task: receipt.taskId, agent: finished.agentId },
+                    attributes: {
+                      task: receipt.taskId,
+                      agent: finished.agentId
+                    },
                     provenance: "This is child-authored output, not operator instructions or proof of permissions."
                   },
                   output || "(no output)"
@@ -12349,7 +13202,10 @@ async function createAgentSession(prefs, detected, options = {}) {
                   );
                 for (const listener of directChildReports) {
                   try {
-                    listener({ parentSessionId: String(turnScope.sessionId), text });
+                    listener({
+                      parentSessionId: String(turnScope.sessionId),
+                      text
+                    });
                   } catch (error) {
                     cliLogger().warn("Child follow-up report observer failed", {
                       "exception.message": describeError2(error)
@@ -12532,6 +13388,8 @@ async function createAgentSession(prefs, detected, options = {}) {
           if (opts?.waitForInbound) delegatedInputWaiters.set(turnId2, opts.waitForInbound);
           delegationScopes.set(turnId2, turnScope);
           delegationLimits.set(turnId2, turnLimits);
+          const typedTarget = parseTokenTarget(opts?.typedInput ?? "");
+          if (typedTarget !== void 0) workflowTokenTargets.set(turnId2, typedTarget);
           delegatedWorkflowAuth.set(turnId2, {
             interactive: opts?.workflowReview?.onPermission !== void 0,
             mode: /* @__PURE__ */ __name(() => modeControl.current(), "mode"),
@@ -12659,10 +13517,7 @@ async function createAgentSession(prefs, detected, options = {}) {
               render: /* @__PURE__ */ __name(() => invocationContext, "render")
             });
           }
-          const workflowOffer = workflowHost !== void 0 && opts?.workflowReview !== void 0 && !residentContext && workflowOffered({
-            hypermode: opts?.hypermode === true,
-            userText: lastUserText(messages)
-          });
+          const workflowOffer = workflowHost !== void 0 && opts?.workflowReview !== void 0 && !residentContext;
           if (workflowOffer && workflowHost) {
             runToolsets = [...runToolsets, toolset("workflow", [workflowHost.tool])];
             if (runManager !== manager) runManager.dispose();
@@ -12696,7 +13551,6 @@ async function createAgentSession(prefs, detected, options = {}) {
             // a scheduled run whose job withholds it would only be told how
             // to use a tool it was not sent.
             residentContext || options.withheldTools?.includes(AGENT_LAUNCH_TOOL) ? void 0 : CODING_AGENT_DELEGATION_DOCTRINE,
-            !residentContext && opts?.hypermode ? CODING_AGENT_HYPERMODE_DOCTRINE : void 0,
             workflowOffer ? WORKFLOW_DOCTRINE : void 0,
             residentContext ? void 0 : palPromptBlock(),
             options.conversationSessions ? CONVERSATION_EVIDENCE_GUIDANCE : void 0,
@@ -12730,13 +13584,22 @@ async function createAgentSession(prefs, detected, options = {}) {
           }
           claimTurn(turnId);
           const turnTaskStore = selectTaskStore(turnScope);
-          const reminderSource = options.reminders ? createCliReminderSource({
+          const turnHypermode = !residentContext && (opts?.hypermode === true || hypermodeExitOwed(messages));
+          const reminderSource = options.reminders || turnHypermode ? createCliReminderSource({
             mode: /* @__PURE__ */ __name(() => modeControl.current(), "mode"),
-            ...planPath ? {
-              planPath: /* @__PURE__ */ __name(() => planPath, "planPath"),
-              canAsk: Boolean(options.askUser && subagentRuntime)
+            ...options.reminders ? {
+              ...planPath ? {
+                planPath: /* @__PURE__ */ __name(() => planPath, "planPath"),
+                canAsk: Boolean(options.askUser && subagentRuntime)
+              } : {},
+              tasks: /* @__PURE__ */ __name(() => turnTaskStore.list({ sessionId: turnScope.sessionId }), "tasks")
             } : {},
-            tasks: /* @__PURE__ */ __name(() => turnTaskStore.list({ sessionId: turnScope.sessionId }), "tasks")
+            ...residentContext ? {} : {
+              hypermode: /* @__PURE__ */ __name(() => ({
+                on: opts?.hypermode === true,
+                toolListed: workflowOffer
+              }), "hypermode")
+            }
           }) : void 0;
           let ephemeralLog;
           if (options.ephemeral) {
@@ -12890,6 +13753,7 @@ async function createAgentSession(prefs, detected, options = {}) {
             delegatedInputWaiters.delete(turnId2);
             delegationScopes.delete(turnId2);
             delegationLimits.delete(turnId2);
+            workflowTokenTargets.delete(turnId2);
             delegatedWorkflowAuth.delete(turnId2);
             await subagentRuntime?.releaseTurn(turnId2);
           }
@@ -13104,7 +13968,9 @@ async function describeProviderReasoning(preferences, detected, signal) {
     const model = primary.model ?? entry.defaultModel;
     const det = findDetected(detected, primary.id);
     if (requiresCredentialForModel(entry, model) && !hasApiCredential(entry, det?.apiKey)) {
-      return { notice: "Set up the selected provider to choose its reasoning effort." };
+      return {
+        notice: "Set up the selected provider to choose its reasoning effort."
+      };
     }
     await ensureRegistered(primary.id);
     signal?.throwIfAborted();
@@ -13122,7 +13988,9 @@ async function describeProviderReasoning(preferences, detected, signal) {
     );
   } catch (error) {
     if (signal?.aborted) throw signal.reason;
-    return { notice: explainFailure(error, "Reasoning effort could not be checked.") };
+    return {
+      notice: explainFailure(error, "Reasoning effort could not be checked.")
+    };
   }
 }
 __name(describeProviderReasoning, "describeProviderReasoning");
@@ -13496,7 +14364,7 @@ async function* runTurn({
           }
           continue;
         }
-        const mapped = toAgentEvent(event, presenter, readsOnly);
+        const mapped = toAgentEvent(event, presenter, readsOnly, workingDirectory);
         if (!mapped) continue;
         yield mapped;
       }
@@ -13507,7 +14375,7 @@ async function* runTurn({
     if (isTurnInProgressError(err)) {
       yield {
         kind: "error",
-        message: `This conversation already has a ${err.state} turn. ${err.state === "running" ? "Wait for it to finish." : "Resume it with /resume, or close it with /abandon."}`,
+        message: `This conversation already has a ${err.state} reply. ${err.state === "running" ? "Wait for it to finish." : "Resume it with /resume, or close it with /abandon."}`,
         turnInProgress: {
           sessionId: String(err.sessionId),
           activeTurnId: String(err.activeTurnId),
@@ -13555,7 +14423,9 @@ function reviewOptionsOf(mode, extras) {
     ...mode === "classify" && extras.classifier ? {
       classifier: extras.classifier,
       ...extras.onClassifierLimit ? { onClassifierLimit: extras.onClassifierLimit } : {},
-      ...extras.onClassifierTranscriptTooLong ? { onClassifierTranscriptTooLong: extras.onClassifierTranscriptTooLong } : {}
+      ...extras.onClassifierTranscriptTooLong ? {
+        onClassifierTranscriptTooLong: extras.onClassifierTranscriptTooLong
+      } : {}
     } : {}
   };
 }
@@ -13643,7 +14513,7 @@ function failedTurnMessage(event) {
   return event.error;
 }
 __name(failedTurnMessage, "failedTurnMessage");
-function toAgentEvent(event, presenter, readsOnly) {
+function toAgentEvent(event, presenter, readsOnly, cwd) {
   switch (event.type) {
     case "hosted_tool": {
       const common = {
@@ -13685,7 +14555,8 @@ function toAgentEvent(event, presenter, readsOnly) {
       if ((result.action === "continue" || result.action === "skip") && result.halt) {
         return {
           kind: "hook-notice",
-          text: `A hook stopped this turn: ${result.halt.reason}`
+          text: `A hook stopped this reply: ${result.halt.reason}`,
+          halted: true
         };
       }
       if ((result.action === "continue" || result.action === "skip") && result.notice) {
@@ -13710,9 +14581,8 @@ function toAgentEvent(event, presenter, readsOnly) {
         toolName: event.toolName,
         ...(() => {
           const view = presenter.presentCall(event.toolName, event.input);
-          if (view.kind === "diff") rememberCallDiff(event.toolUseId, view);
           return {
-            summary: viewToSummary(view),
+            summary: pathSummary(viewToSummary(view), event.input, cwd),
             ...(() => {
               const command = view.kind === "terminal" ? view.command : view.kind === "generic" && view.facts?.kind === "command" ? view.facts.command : void 0;
               return command ? { command } : {};
@@ -13726,6 +14596,10 @@ function toAgentEvent(event, presenter, readsOnly) {
           const web = webActivityFromInput(event.toolName, event.input);
           return web ? { web } : {};
         })(),
+        ...(() => {
+          const proposed = proposedFromInput(event.toolName, event.input);
+          return proposed ? { proposed } : {};
+        })(),
         ...readsOnly?.(event.toolName, event.input) ? { readOnly: true } : {}
       };
     case "tool_input_completed":
@@ -13769,12 +14643,13 @@ function toAgentEvent(event, presenter, readsOnly) {
       const view = presented.kind === "terminal" && tidy ? { ...presented, output: tidy.output } : presented;
       const unknownTool = event.isError ? unknownToolNotice(event.result) : void 0;
       const declined = view.kind === "generic" && view.declined !== void 0;
-      const classed = event.isError && event.facts?.kind === "failure" ? failureFactsLine(event.facts) : void 0;
-      const detail = unknownTool || declined || classed ? void 0 : viewToLines(view);
+      const classed = event.isError && event.facts?.kind === "failure" ? failureFactsLine(event.facts, cwd) : void 0;
+      const diffBody = event.isError ? void 0 : diffBodyFromFacts(event.facts, cwd);
+      const detail = unknownTool || declined || classed ? void 0 : diffBody?.rows ?? viewToLines(view);
       const first = view.kind === "terminal" && view.output.trim().length > 0 ? resultToLines(view.output)[0] : void 0;
       const summary = unknownTool ?? (first !== void 0 ? resultSummaryLine(first) : firstLine3(event.result));
       const plainFailure = unknownTool ?? classed ?? tidy?.failure;
-      const headline = event.isError ? void 0 : factsHeadline(event.facts, view.kind === "diff" ? view : takeCallDiff(event.toolUseId));
+      const headline = event.isError ? void 0 : factsHeadline(event.facts);
       const withoutRepeatedSummary = plainFailure === void 0 && first !== void 0 && detail?.[0] === first && summarySaysAll(first, summary) ? detail.slice(1) : detail;
       return {
         kind: "tool-end",
@@ -13793,6 +14668,7 @@ function toAgentEvent(event, presenter, readsOnly) {
         ...view.kind === "generic" && view.declined ? { declined: view.declined } : {},
         ...view.kind === "generic" && view.label.length > 0 ? { resultLabel: view.label } : {},
         ...withoutRepeatedSummary && withoutRepeatedSummary.length > 0 ? { detail: withoutRepeatedSummary } : {},
+        ...diffBody ? { diff: diffBody.diff } : {},
         ...(() => {
           const kind = webActivityKind(event.toolName);
           if (!kind) return {};
@@ -13902,10 +14778,20 @@ function toAgentEvent(event, presenter, readsOnly) {
         ...event.exitCode !== void 0 ? { exitCode: event.exitCode } : {},
         ...event.signal ? { signal: event.signal } : {}
       };
+    case "compaction_started":
+      return {
+        kind: "context",
+        text: COMPACTING_LABEL,
+        row: "hidden",
+        shed: false,
+        compacting: true
+      };
     case "compaction_completed":
       return {
         kind: "context",
-        text: describeCompaction(event),
+        text: COMPACTED_TEXT,
+        row: "compacted",
+        detail: compactionHistoryLines(event),
         shed: true,
         summarised: true,
         reclaimedTokens: Math.max(0, event.tokensBefore - event.tokensAfter)
@@ -13914,6 +14800,8 @@ function toAgentEvent(event, presenter, readsOnly) {
       return {
         kind: "context",
         text: `cleared ${event.clearedCount} tool result${event.clearedCount === 1 ? "" : "s"}${event.stubbedCount ? `, stubbed ${event.stubbedCount} narration${event.stubbedCount === 1 ? "" : "s"}` : ""} (~${event.reclaimedTokens.toLocaleString()} tokens)${event.reliefWasEnough ? "" : " \u2014 not enough, compacting"}`,
+        row: "hidden",
+        ...event.reliefWasEnough ? {} : { compacting: true },
         shed: true,
         cleared: event.clearedCount,
         stubbed: event.stubbedCount ?? 0,
@@ -13923,7 +14811,8 @@ function toAgentEvent(event, presenter, readsOnly) {
       if (event.cause === "breaker_open") return null;
       return {
         kind: "context",
-        text: describeCompactionFailure(event),
+        text: describeCompactionFailure(event, debugRequested()),
+        row: "warning",
         shed: false
       };
     default:
@@ -13931,46 +14820,22 @@ function toAgentEvent(event, presenter, readsOnly) {
   }
 }
 __name(toAgentEvent, "toAgentEvent");
-function describeCompaction(event) {
-  const k = /* @__PURE__ */ __name((n) => n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n), "k");
-  const qualifier = event.measuredBy === "estimate" ? " (estimated)" : "";
-  return `context compacted \u2014 ${event.messagesBefore} messages replaced by ${event.messagesAfter}, ~${k(event.tokensBefore)} \u2192 ~${k(event.tokensAfter)} tokens${qualifier}`;
-}
-__name(describeCompaction, "describeCompaction");
-function describeCompactionFailure(event) {
-  const held = `${event.messages} messages unchanged`;
-  switch (event.cause) {
-    case "reducer_threw":
-      return `context not compacted \u2014 the reducer failed${event.error ? `: ${event.error}` : ""}. ${held}; a later pass may succeed`;
-    case "shed_nothing":
-      return `context could not be reduced further \u2014 nothing left to shed. ${held}; later passes will answer the same`;
-    case "split_tool_pair":
-      return `context not compacted \u2014 the reducer produced a history splitting a tool call from its result, so it was refused. ${held}; this is a bug in the reducer`;
-    case "breaker_open":
-      return "automatic compaction paused for this reply after repeated attempts that shed nothing";
-    case "refilling":
-      return event.error ?? "The context filled up again right after being compacted, three times in a row. A file being read or a tool output is probably too large for the context window. Try reading it in smaller parts.";
-  }
-}
-__name(describeCompactionFailure, "describeCompactionFailure");
-var FALLBACK_REASONS = {
-  rate_limit: "it rate limited this reply and the retries did not clear it",
-  overloaded: "it was overloaded and the retries did not clear it",
-  server_error: "it kept failing and the retries did not clear it",
-  timeout: "it did not answer in time",
-  network: "it could not be reached",
-  auth: "it rejected the credential",
-  not_found: "it does not have that model",
-  unknown: "it failed in a way namzu could not classify"
-};
 function describeFallback(event) {
   const name = /* @__PURE__ */ __name((index, id, model) => {
     const label = PROVIDER_REGISTRY[id]?.label ?? id;
     return `${chainPositionName(index)} \u2014 ${label}${model ? `, ${model}` : ""}`;
   }, "name");
-  const why = FALLBACK_REASONS[event.code] ?? `it failed (${event.code})`;
-  const status = event.status !== void 0 ? ` HTTP ${event.status},` : "";
-  return `Provider chain: ${name(event.fromIndex, event.fromProviderId, event.fromModel)} \u2014 could not serve:${status} ${why} (${event.code}). ${name(event.toIndex, event.toProviderId, event.toModel)} \u2014 is serving the rest of this reply.`;
+  const status = event.status !== void 0 ? `HTTP ${event.status}, ` : "";
+  const raw = `Provider chain: ${name(event.fromIndex, event.fromProviderId, event.fromModel)} \u2014 could not serve: ${status}${event.code}. ${name(event.toIndex, event.toProviderId, event.toModel)} \u2014 is serving the rest of this reply.`;
+  return withDebugDetail(
+    describeProviderFallbackNotice({
+      fromProviderId: event.fromProviderId,
+      toProviderId: event.toProviderId,
+      reason: event.code
+    }),
+    raw,
+    debugRequested()
+  );
 }
 __name(describeFallback, "describeFallback");
 function viewToLines(view) {
@@ -13991,22 +14856,6 @@ function viewToLines(view) {
   }
 }
 __name(viewToLines, "viewToLines");
-var callDiffs = /* @__PURE__ */ new Map();
-var CALL_DIFFS_KEPT = 64;
-function rememberCallDiff(toolUseId, view) {
-  callDiffs.set(toolUseId, { before: view.before, after: view.after });
-  if (callDiffs.size > CALL_DIFFS_KEPT) {
-    const oldest = callDiffs.keys().next().value;
-    if (oldest !== void 0) callDiffs.delete(oldest);
-  }
-}
-__name(rememberCallDiff, "rememberCallDiff");
-function takeCallDiff(toolUseId) {
-  const diff = callDiffs.get(toolUseId);
-  callDiffs.delete(toolUseId);
-  return diff;
-}
-__name(takeCallDiff, "takeCallDiff");
 function viewToSummary(view) {
   switch (view.kind) {
     case "generic":
@@ -14029,10 +14878,14 @@ function summarySaysAll(line, summary) {
 }
 __name(summarySaysAll, "summarySaysAll");
 function truncate2(value, max) {
-  const oneLine3 = value.replace(/\s+/g, " ");
-  return oneLine3.length > max ? `${oneLine3.slice(0, max - 1)}\u2026` : oneLine3;
+  return clipText(value.replace(/\s+/g, " "), max);
 }
 __name(truncate2, "truncate");
+function pathSummary(summary, input, cwd) {
+  const path = typeof input === "object" && input !== null ? input.path : void 0;
+  return typeof path === "string" && path.length > 0 && summary === path ? displayPath(path, cwd) : summary;
+}
+__name(pathSummary, "pathSummary");
 function diffContentLines(value) {
   if (value === "") return [];
   const lines = value.split("\n");
@@ -14157,7 +15010,10 @@ function emptySession(errorHint, errorKind = "environment", rawDetail) {
   });
   return {
     hasProvider: false,
-    autoMode: { available: false, reason: "Choose a model before using auto mode." },
+    autoMode: {
+      available: false,
+      reason: "Choose a model before using auto mode."
+    },
     // A refused session ran nothing, so there is nothing confining anything.
     // Reporting an enforced control here would be a claim about a sandbox
     // this path never built.
@@ -14222,13 +15078,31 @@ export {
   createCurrentCredentialReader,
   createTaskContextStep,
   createLiveModeControl,
+  describeCapabilityNotice,
+  describeHistoryRepairNotice,
+  describeProviderFallbackNotice,
+  withDebugDetail,
+  COMPACTING_LABEL,
+  COMPACTED_HINT,
+  COMPACT_RESULT_TEXT,
+  COMPACT_RESULT_HINT,
+  NOTHING_TO_COMPACT_TEXT,
+  COMPACT_NOT_SAVED_TEXT,
+  compactionSummaryLines,
+  EXPAND_HINT,
+  hiddenLinesHint,
+  clipText,
+  WORKSPACE_PREVIEW_ROWS,
+  viewRowText,
+  diffViewBody,
+  plainDiffRows,
+  spansText,
+  proposedBody,
   StartupRefusal,
   isMachineError,
   explainFailure,
   NOT_SHOWN_LINE,
   declinedLine,
-  formatElapsed,
-  formatCompactCount,
   webCallTitle,
   webLiveStatus,
   webSettledLine,
@@ -14240,6 +15114,8 @@ export {
   liveBatches,
   combineBatches,
   NARRATION_TOOL_NAME,
+  WORKFLOW_TOOL_NAME,
+  WORKFLOW_BACKGROUND_NOTE,
   readMemory,
   appendMemoryWithStatus,
   renderMemoryReport,
@@ -14255,6 +15131,7 @@ export {
   resolveModelSwitch,
   SessionOperationOwner,
   probeAgentSession,
+  builtinToolPresenter,
   createAgentSession,
   constructProvider,
   modelListingCause,
@@ -14279,4 +15156,4 @@ export {
   RESULT_SUMMARY_WHOLE_MAX,
   resultSummaryLine
 };
-//# sourceMappingURL=chunk-WXMFE5SS.js.map
+//# sourceMappingURL=chunk-OXJEMOBQ.js.map