@namzu/cli 38.2.0 → 39.0.0

package/dist/chunks/{chunk-LLZ32DHS.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-OA5772RG.js";
+} from "./chunk-LFVQSMJG.js";
 import {
   createSessionSkillCatalog
-} from "./chunk-Q6SF7T77.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,
@@ -22,16 +24,14 @@ import {
   reduceRunView,
   resolveTurnGuards,
   settledElapsed,
-  viewFromJournal,
-  workflowOffered,
-  workflowRefusal
-} from "./chunk-S5U4BG57.js";
+  viewFromJournal
+} from "./chunk-HV77F4SF.js";
 import {
   connectMcpServers
-} from "./chunk-Z56MZ7UW.js";
+} from "./chunk-W27ZDC4R.js";
 import {
   openInBrowser
-} from "./chunk-XNHYUV6G.js";
+} from "./chunk-EUU4TDTH.js";
 import {
   CredentialRefreshRejectedError,
   CredentialWithdrawnError,
@@ -39,25 +39,30 @@ import {
   ensureFreshStoredCodexCredential,
   readSubscriptionCredential,
   sameOAuthCredential
-} from "./chunk-M2EJQU3F.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-FMJCN6JZ.js";
+  unmatchedPassthroughTools,
+  workflowSizeAdvice,
+  workflowTokenCeiling
+} from "./chunk-GU5YARBU.js";
 import {
   formatSize,
   homePath,
   plural,
-  productName
+  productName,
+  stringWidth
 } from "./chunk-AXCOWIIH.js";
 import {
   createLazyCodeAnalysis
-} from "./chunk-JN6M424Z.js";
+} from "./chunk-N3FI7O4U.js";
 import {
   canSelectModel,
   chainCapabilityDisagreements,
@@ -80,7 +85,7 @@ import {
   requiresCredentialForModel,
   resolveChainCapabilities,
   unresolvedMembers
-} from "./chunk-HOOY63EB.js";
+} from "./chunk-XJ4IUCH6.js";
 import {
   PROVIDER_REGISTRY,
   missingCredentialMessage,
@@ -89,11 +94,11 @@ import {
 import {
   isPermissionMode,
   permissionModeLabel
-} from "./chunk-N57QO3AA.js";
+} from "./chunk-2VMMTC2V.js";
 import {
   conversationLogPath,
   ensureSessionStarted
-} from "./chunk-AHVF22PV.js";
+} from "./chunk-UBOPUGDN.js";
 import {
   INSTRUCTIONS_FILENAME,
   MAX_CHARS_PER_FILE,
@@ -104,26 +109,26 @@ import {
 import {
   compilePermissions,
   isPermissionEffect
-} from "./chunk-WLHI2QSC.js";
+} from "./chunk-CZEU2JYJ.js";
 import {
   cliLogger
-} from "./chunk-5G3VKTLZ.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-IG4O4UAL.js";
+} from "./chunk-4K2NRXHJ.js";
 import {
   restrictToOwner
-} from "./chunk-U75JG2RT.js";
+} from "./chunk-MCNEFI5Q.js";
 import {
   namzuHomePath
-} from "./chunk-EKMOETAY.js";
+} from "./chunk-AZ3YHVFA.js";
 import {
   AgentManager,
   AgentRegistry,
@@ -131,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,
@@ -221,11 +225,13 @@ import {
   createUserMessage,
   deferred,
   defineTool,
+  diffWords,
   discoverAgentDefinitions,
   discoverAllPluginDirs,
   ensureProject,
   external_exports,
   filtered,
+  formatCompletionNotification,
   formatMonitorEnd,
   formatMonitorEvent,
   generateSessionId,
@@ -269,6 +275,7 @@ import {
   selectAssistantText,
   selectTaskContext,
   slugifyMemoryName,
+  structuredPatch,
   toToolSourceRef,
   toolWireSchema,
   toolset,
@@ -277,7 +284,7 @@ import {
   windowsShellNotice,
   withProviderFallback,
   wrapUntrusted
-} from "./chunk-A64X23MU.js";
+} from "./chunk-RQBT4RVE.js";
 import {
   __name
 } from "./chunk-76FLAFCG.js";
@@ -432,10 +439,10 @@ var tail = Promise.resolve();
 var nextStart = 0;
 function cancelled(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const abort = /* @__PURE__ */ __name(() => reject(signal.reason), "abort");
     signal.addEventListener("abort", abort, { once: true });
-    promise.then(resolve12, reject).finally(() => signal.removeEventListener("abort", abort));
+    promise.then(resolve13, reject).finally(() => signal.removeEventListener("abort", abort));
   });
 }
 __name(cancelled, "cancelled");
@@ -476,8 +483,8 @@ async function searchExa(query2, limit, context) {
   const deadline = Date.now() + DEADLINE_MS;
   const previous = tail;
   let release;
-  tail = new Promise((resolve12) => {
-    release = resolve12;
+  tail = new Promise((resolve13) => {
+    release = resolve13;
   });
   let acquired = false;
   try {
@@ -747,6 +754,10 @@ function describeCompactionFailure(event, 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;
@@ -767,54 +778,350 @@ function clipText(text, max) {
 }
 __name(clipText, "clipText");
 
-// src/tui/diff-rows.ts
+// src/tui/diff-view.ts
 var CREATE_PREVIEW_ROWS = 10;
-var EDIT_PREVIEW_ROWS = 40;
+var WORKSPACE_PREVIEW_ROWS = 40;
+var MAX_LINE_CHARS = 2e3;
+var WORD_DIFF_RATIO = 0.4;
+var TAB_STOP = 8;
 var HUNK_GAP = "...";
-var ROW = /^\s*\d+ ([+-]) /;
-function diffRowMarker(row) {
-  const marker = ROW.exec(row)?.[1];
-  return marker === "+" || marker === "-" ? marker : void 0;
-}
-__name(diffRowMarker, "diffRowMarker");
-function diffRows(hunks) {
-  const last = hunks.reduce(
-    (most, hunk) => Math.max(most, hunk.oldStart + hunk.oldLines, hunk.newStart + hunk.newLines),
-    1
-  );
-  const width = String(last).length;
+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 = [];
-  hunks.forEach((hunk, index) => {
-    if (index > 0) rows.push(HUNK_GAP);
-    let oldLine = hunk.oldStart;
-    let newLine = hunk.newStart;
-    for (const row of hunk.lines) {
-      const marker = row[0] ?? " ";
-      const text = row.slice(1);
-      const number = marker === "-" ? oldLine : newLine;
-      if (marker === "-") oldLine += 1;
-      else if (marker === "+") newLine += 1;
-      else {
-        oldLine += 1;
-        newLine += 1;
+  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 } : {}
       }
-      rows.push(`${String(number).padStart(width)} ${marker} ${text}`);
+    ];
+    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(diffRows, "diffRows");
-function diffBodyFromFacts(facts) {
-  if (!facts || facts.kind !== "edit" && facts.kind !== "write") return void 0;
-  const hunks = facts.hunks;
-  if (!hunks || hunks.length === 0) return void 0;
-  const created = facts.kind === "write" && facts.operation === "created";
-  return {
-    rows: diffRows(hunks).map((row) => clipText(row, 600)),
-    preview: created ? CREATE_PREVIEW_ROWS : EDIT_PREVIEW_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(diffBodyFromFacts, "diffBodyFromFacts");
+__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";
@@ -831,6 +1138,149 @@ function displayPath(path, cwd, 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 {
@@ -1171,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 resolve11 } 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";
@@ -1187,7 +1637,7 @@ import {
   unlink as unlink2,
   writeFile
 } from "node:fs/promises";
-import { basename, dirname, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2, 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";
@@ -1586,7 +2036,7 @@ var FileCheckpointStore = class {
   // -- paths ------------------------------------------------------------------
   realCwdPromise;
   realCwd() {
-    this.realCwdPromise ??= realExisting(resolve2(this.cwd)).catch(() => resolve2(this.cwd));
+    this.realCwdPromise ??= realExisting(resolve3(this.cwd)).catch(() => resolve3(this.cwd));
     return this.realCwdPromise;
   }
   /**
@@ -1605,12 +2055,12 @@ var FileCheckpointStore = class {
   }
   insideReal(real, root) {
     const rel = relative2(root, real);
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute2(rel);
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute3(rel);
   }
   /** Whether a host path is one this store would cover. */
   covers(hostPath) {
-    const rel = relative2(this.cwd, resolve2(this.cwd, hostPath));
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute2(rel);
+    const rel = relative2(this.cwd, resolve3(this.cwd, hostPath));
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute3(rel);
   }
   // -- turns ------------------------------------------------------------------
   /**
@@ -1818,7 +2268,7 @@ var FileCheckpointStore = class {
     });
   }
   async snapshotNow(history, rec, hostPath, meta) {
-    const lexical = resolve2(this.cwd, hostPath);
+    const lexical = resolve3(this.cwd, hostPath);
     if (!this.covers(lexical)) {
       await this.skipNow(history, rec, lexical, "outside-cwd");
       return "outside";
@@ -1871,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 = resolve2(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;
@@ -1894,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), resolve2(this.cwd, hostPath), reason);
+      await this.skipNow(history, this.resolveRec(turnId), resolve3(this.cwd, hostPath), reason);
     });
   }
   async skipNow(history, rec, path, reason) {
@@ -2529,18 +2979,18 @@ __name(withShellNote, "withShellNote");
 
 // src/context/directories.ts
 import { realpath as realpath2, stat as stat3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
+import { isAbsolute as isAbsolute4, relative as relative3, resolve as resolve4 } from "node:path";
 function isInside(root, candidate) {
   const rel = relative3(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
 }
 __name(isInside, "isInside");
 function createSessionDirectories(cwd, directories) {
-  const root = resolve3(cwd);
+  const root = resolve4(cwd);
   return {
     list: /* @__PURE__ */ __name(() => [...directories], "list"),
     add: /* @__PURE__ */ __name(async (path, options) => {
-      const absolute = resolve3(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))
@@ -2583,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 isAbsolute4, join as join3, relative as relative4, resolve as resolve4, 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) {
@@ -2601,13 +3051,13 @@ function canonicalRoot(path) {
   try {
     return realpathSync(path);
   } catch {
-    return resolve4(path);
+    return resolve5(path);
   }
 }
 __name(canonicalRoot, "canonicalRoot");
 function contained(root, candidate) {
   const rel = relative4(root, candidate);
-  return rel === "" || !isAbsolute4(rel) && rel !== ".." && !rel.startsWith(`..${sep2}`);
+  return rel === "" || !isAbsolute5(rel) && rel !== ".." && !rel.startsWith(`..${sep2}`);
 }
 __name(contained, "contained");
 function relativeInstructionPath(root, file) {
@@ -2665,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 = resolve4(this.root, file);
+        const absolute = resolve5(this.root, file);
         if (!contained(this.root, absolute)) continue;
         this.registerPath(dirname2(absolute));
       }
@@ -2702,7 +3152,7 @@ var ProjectInstructionTracker = class {
       return;
     }
     const rawPath = observation.input.path;
-    const lexical = resolve4(this.cwd, rawPath);
+    const lexical = resolve5(this.cwd, rawPath);
     let target;
     try {
       target = realpathSync(lexical);
@@ -2714,7 +3164,7 @@ var ProjectInstructionTracker = class {
     this.refreshDirectories(this.scopes.keys());
   }
   registerPath(directory) {
-    const target = resolve4(directory);
+    const target = resolve5(directory);
     if (!contained(this.root, target)) return;
     const rel = relative4(this.root, target);
     let current = this.root;
@@ -2857,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], {
@@ -2873,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) {
@@ -3997,7 +4447,7 @@ __name(createContextInventoryStep, "createContextInventoryStep");
 
 // src/integrations/sessions/conversation-search.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { resolve as resolve5 } 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");
@@ -4083,7 +4533,7 @@ function parseQueryIdentity(identity) {
 }
 __name(parseQueryIdentity, "parseQueryIdentity");
 function conversationScope(sessions, sessionId) {
-  return JSON.stringify([resolve5(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();
@@ -4597,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");
@@ -4630,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) {
@@ -4642,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
@@ -4678,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"),
@@ -4688,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,
@@ -4848,7 +5298,7 @@ function estimateTokens(text) {
 __name(estimateTokens, "estimateTokens");
 function createSideModel(deps) {
   const routes = /* @__PURE__ */ new Map();
-  const resolve12 = /* @__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);
@@ -4885,7 +5335,7 @@ ${active.model}
 ${deps.configured ?? ""}`;
     let pending = routes.get(key);
     if (pending === void 0) {
-      pending = resolve12(sessionId, signal);
+      pending = resolve13(sessionId, signal);
       routes.set(key, pending);
       void pending.then((value) => {
         if (signal.aborted && value.source === "main" && routes.get(key) === pending) {
@@ -4942,49 +5392,15 @@ __name(createSideModel, "createSideModel");
 // src/integrations/state/retention.ts
 var CLI_CHECKPOINT_RETENTION = 10;
 
-// src/integrations/subagents/failure-text.ts
-var CAUSES = [
-  [
-    /rate limited by the provider/i,
-    "The provider was too busy for this agent. Wait a moment, then message the agent to try again."
-  ],
-  [
-    /could not reach the provider/i,
-    "Namzu could not reach the provider. Check the connection, then message the agent to try again."
-  ],
-  [
-    /the provider rejected the request credentials/i,
-    "The provider did not accept the sign-in. Sign in again, then start the task again."
-  ],
-  [
-    /exceeded the model context window/i,
-    "The task was too large for the model. Start it again with a smaller task."
-  ],
-  [
-    /the provider rejected the request as invalid/i,
-    "The provider could not use this request. Start the task again, or choose another model."
-  ],
-  [
-    /the provider failed to complete the request/i,
-    "The provider ran into a problem. Wait a moment, then message the agent to try again."
-  ]
-];
-var GENERIC = "This agent stopped because of an error. Run with --debug for details.";
-function isPlainSentence(text) {
-  if (text.length < 8 || text.length > 220) return false;
-  if (!/^[A-Z]/u.test(text) || !/[.!?]$/u.test(text)) return false;
-  return !/[\n\r{}[\]\\]|\w\/\w|~\/|\bat \S+:\d+|\b(?:undefined|null|NaN)\b|\bHTTP \d{3}\b/u.test(
-    text
-  );
-}
-__name(isPlainSentence, "isPlainSentence");
-function plainAgentFailure(raw, debug = debugRequested()) {
-  const text = raw.trim();
-  const plain = CAUSES.find(([pattern]) => pattern.test(text))?.[1] ?? (isPlainSentence(text) ? text : GENERIC);
-  return debug && text !== "" && text !== plain ? `${plain}
-${text}` : plain;
+// 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(plainAgentFailure, "plainAgentFailure");
+__name(stepTaskOnly, "stepTaskOnly");
 
 // src/integrations/subagents/activity.ts
 var MAX_RETAINED_AGENTS = 80;
@@ -5080,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,
@@ -5138,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(plainAgentFailure(errorMessage(error)), MAX_ROW_CODE_UNITS)
-        });
+        pushFailure(owned, `${owned.viewId}:failure`, errorMessage(error));
         owned.closed = true;
         this.prune();
         this.notifyNow();
@@ -5347,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 })))
     });
   }
@@ -5614,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(plainAgentFailure(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(plainAgentFailure(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) {
@@ -6450,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 isAbsolute5, relative as relative5, resolve as resolve6, 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 {
@@ -6469,9 +6891,9 @@ var DelegatedWorktreeDriver = class {
     this.ready ??= openManagedWorktrees(this.cwd, {
       stateRoot: this.stateRoot
     }).then(async (managed) => {
-      const selectedDirectory = await realpath3(resolve6(this.cwd));
+      const selectedDirectory = await realpath3(resolve7(this.cwd));
       const subdirectory = relative5(managed.sourceRoot, selectedDirectory);
-      if (isAbsolute5(subdirectory) || subdirectory === ".." || subdirectory.startsWith(`..${sep3}`)) {
+      if (isAbsolute6(subdirectory) || subdirectory === ".." || subdirectory.startsWith(`..${sep3}`)) {
         throw new Error("Selected directory is outside its Git checkout");
       }
       return {
@@ -6514,7 +6936,6 @@ var DelegatedWorktreeDriver = class {
 // src/integrations/subagents/runtime.ts
 var NARRATION_TOOL_NAME = "narrate_work";
 var MAX_NARRATION_INPUT_CODE_UNITS = MAX_NARRATION_CODE_UNITS * 2;
-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.";
 var GENERAL_PURPOSE_SUBAGENT = "general-purpose";
 var EXPLORE_SUBAGENT = EXPLORE_AGENT_ID;
 var EXPLORE_PROMPT = [EXPLORE_AGENT_PROMPT, "", CODING_AGENT_WORKING_DOCTRINE].join("\n");
@@ -6591,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")
@@ -6794,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;
@@ -6892,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);
@@ -7129,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.',
@@ -7156,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",
@@ -7223,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 {
@@ -7373,7 +7855,12 @@ ${step}`;
         };
       }
       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) => ({
@@ -7420,7 +7907,7 @@ ${step}`;
     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())) {
@@ -7439,6 +7926,7 @@ ${step}`;
           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 {
@@ -7510,7 +7998,7 @@ ${step}`;
           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 {
@@ -7574,7 +8062,7 @@ ${step}`;
     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 {
@@ -7944,6 +8432,12 @@ ${step}`;
         childMessageListeners.delete(listener);
       };
     },
+    onBackgroundCompletion(listener) {
+      backgroundCompletionListeners.add(listener);
+      return () => {
+        backgroundCompletionListeners.delete(listener);
+      };
+    },
     cancelAgentTool,
     modelCatalogueTool,
     messageChild,
@@ -8194,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
@@ -8250,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 {
@@ -8349,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((resolve12) => {
+    return new Promise((resolve13) => {
       const done = /* @__PURE__ */ __name(() => {
         off();
         signal?.removeEventListener("abort", done);
-        resolve12();
+        resolve13();
       }, "done");
       const off = this.subscribe(() => {
         if (!going()) done();
@@ -8502,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: {
@@ -8566,8 +9101,8 @@ function createWorkflowHost(options) {
       let launching = true;
       let settleLaunch = /* @__PURE__ */ __name(() => {
       }, "settleLaunch");
-      const launch = new Promise((resolve12) => {
-        settleLaunch = resolve12;
+      const launch = new Promise((resolve13) => {
+        settleLaunch = resolve13;
       });
       const detach = /* @__PURE__ */ __name(() => {
         if (!launching) return;
@@ -8666,7 +9201,7 @@ __name(createWorkflowHost, "createWorkflowHost");
 
 // src/memory/store.ts
 import { realpathSync as realpathSync3 } from "node:fs";
-import { join as join11, resolve as resolve8 } from "node:path";
+import { join as join11, resolve as resolve9 } from "node:path";
 
 // src/memory/io.ts
 import {
@@ -8680,7 +9215,7 @@ import {
   realpathSync as realpathSync2,
   writeSync
 } from "node:fs";
-import { isAbsolute as isAbsolute6, join as join10, relative as relative6, resolve as resolve7, 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";
@@ -8688,12 +9223,12 @@ function missing(error) {
 __name(missing, "missing");
 function within(path, root) {
   const part = relative6(root, path);
-  return !isAbsolute6(part) && part !== ".." && !part.startsWith(`..${sep4}`);
+  return !isAbsolute7(part) && part !== ".." && !part.startsWith(`..${sep4}`);
 }
 __name(within, "within");
 function resolveMemoryPath(location, createParents = false) {
-  const root = resolve7(location.root);
-  const path = resolve7(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 {
@@ -8851,7 +9386,7 @@ function memoryFilePath(home) {
 }
 __name(memoryFilePath, "memoryFilePath");
 function projectMemoryFilePath(cwd) {
-  let directory = resolve8(cwd);
+  let directory = resolve9(cwd);
   try {
     directory = realpathSync3(directory);
   } catch (error) {
@@ -8868,7 +9403,7 @@ function projectMemoryLocation(cwd) {
 }
 __name(projectMemoryLocation, "projectMemoryLocation");
 function projectLocation(cwd) {
-  const directory = realpathSync3(resolve8(cwd));
+  const directory = realpathSync3(resolve9(cwd));
   return { path: projectMemoryFilePath(directory), root: cliProjectRoot(directory) };
 }
 __name(projectLocation, "projectLocation");
@@ -8898,7 +9433,7 @@ function readMemory(home, cwd) {
     root: userRoot,
     path: join11(userRoot, "MEMORY.md")
   }));
-  const project = cwd && !isUserMemoryFile(join11(resolve8(cwd), ".namzu", "MEMORY.md"), userRoot) ? read(join11(resolve8(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");
@@ -8907,7 +9442,7 @@ function isUserMemoryFile(projectPath, userRoot) {
     try {
       return realpathSync3(path);
     } catch {
-      return resolve8(path);
+      return resolve9(path);
     }
   }, "canonical");
   return canonical(projectPath) === canonical(join11(userRoot, "MEMORY.md"));
@@ -9114,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 {};
@@ -9130,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 }
@@ -9312,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");
 
@@ -9470,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 isAbsolute7, join as join13, resolve as resolve9 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute8, join as join13, resolve as resolve10 } from "node:path";
 function localConfigPath(cwd) {
-  return resolve9(cwd, LOCAL_CONFIG_FILE);
+  return resolve10(cwd, LOCAL_CONFIG_FILE);
 }
 __name(localConfigPath, "localConfigPath");
 function isRecord2(value) {
@@ -9510,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,
@@ -9554,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 !== "" && isAbsolute7(value)) return value;
+  if (value !== "" && isAbsolute8(value)) return value;
   const xdg = env.XDG_CONFIG_HOME;
-  if (xdg && isAbsolute7(xdg)) return join13(xdg, "git", "ignore");
+  if (xdg && isAbsolute8(xdg)) return join13(xdg, "git", "ignore");
   return join13(home, ".config", "git", "ignore");
 }
 __name(globalIgnorePath, "globalIgnorePath");
@@ -9874,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 isAbsolute8, resolve as resolve10 } 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 = resolve10(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 resolve10(isAbsolute8(path) ? path : resolve10(cwd, path)) === target;
+    return resolve11(isAbsolute9(path) ? path : resolve11(cwd, path)) === target;
   };
 }
 __name(isPlanFileWrite, "isPlanFileWrite");
@@ -10028,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) {
@@ -10038,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;
@@ -10064,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.";
@@ -10092,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))] : [];
   }
@@ -10173,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()));
@@ -10331,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 resolve12 = /* @__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 resolve12(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 resolve12(uniqueMatch);
+  if (uniqueMatch) return resolve13(uniqueMatch);
   if (matches.length > 1) {
     return {
       kind: "rejected",
@@ -10499,8 +11078,8 @@ var SessionOperationOwner = class {
     })()[Symbol.asyncIterator]();
     let settled = false;
     let settle;
-    const settlement = new Promise((resolve12) => {
-      settle = resolve12;
+    const settlement = new Promise((resolve13) => {
+      settle = resolve13;
     });
     let operationTail = Promise.resolve();
     let returnStarted = false;
@@ -10777,10 +11356,10 @@ function clipRequestContext(prompt, limit, kind) {
 __name(clipRequestContext, "clipRequestContext");
 async function createAgentSession(prefs, detected, options = {}) {
   if (options.palEnvironment) {
-    const { createPalAgentSession } = await import("./agent-session-YS3JWF6Z.js");
+    const { createPalAgentSession } = await import("./agent-session-HFOLAFFL.js");
     return createPalAgentSession(prefs, detected, options);
   }
-  const { palAtWorkspace } = await import("./store-TO65IAIZ.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();
@@ -10816,7 +11395,7 @@ async function createAgentSession(prefs, detected, options = {}) {
     }
     return seeded;
   }, "observationsFor");
-  const requestedCwd = resolve11(options.cwd ?? process.cwd());
+  const requestedCwd = resolve12(options.cwd ?? process.cwd());
   let cwd;
   try {
     const entry2 = await stat4(requestedCwd);
@@ -10848,13 +11427,13 @@ async function createAgentSession(prefs, detected, options = {}) {
       paths = options.conversationSessions.paths;
       projectId = options.conversationSessions.projectId;
     } else {
-      const home = resolve11(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(resolve11(paths.projectDir(), ".."), paths.slug);
+    ensurePrivateStateDirectory(resolve12(paths.projectDir(), ".."), paths.slug);
     ensurePrivateStateDirectory(paths.projectDir(), "memory");
   } catch (error) {
     return emptySession(
@@ -11139,8 +11718,8 @@ async function createAgentSession(prefs, detected, options = {}) {
   }
   const directories = [];
   for (const dir of options.additionalDirectories ?? []) {
-    const absolute = resolve11(cwd, dir);
-    if (absolute !== resolve11(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(
@@ -11344,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
@@ -11365,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) {
@@ -11469,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,
@@ -11693,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) => {
@@ -11847,7 +12436,7 @@ async function createAgentSession(prefs, detected, options = {}) {
     );
     toolsets.push(options.toolLoading === "eager" ? monitorToolset : deferred(monitorToolset));
   }
-  const operatorPals = await import("./operator-tools-C57ZIYRG.js");
+  const operatorPals = await import("./operator-tools-6RYAHVSL.js");
   toolsets.push(
     readyWhen(
       toolset(
@@ -12369,8 +12958,8 @@ async function createAgentSession(prefs, detected, options = {}) {
           if (mapped) yield mapped;
         }
         if (settled) break;
-        await new Promise((resolve12) => {
-          wake = resolve12;
+        await new Promise((resolve13) => {
+          wake = resolve13;
         });
         wake = void 0;
       }
@@ -12523,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;
@@ -12797,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"),
@@ -12924,11 +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,
-            workflow: opts?.workflow === 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();
@@ -12962,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,
@@ -12996,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) {
@@ -13156,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);
           }
@@ -13998,6 +14596,10 @@ function toAgentEvent(event, presenter, readsOnly, cwd) {
           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":
@@ -14042,7 +14644,7 @@ function toAgentEvent(event, presenter, readsOnly, cwd) {
       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, cwd) : void 0;
-      const diffBody = event.isError ? void 0 : diffBodyFromFacts(event.facts);
+      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));
@@ -14066,7 +14668,7 @@ function toAgentEvent(event, presenter, readsOnly, cwd) {
         ...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: { preview: diffBody.preview } } : {},
+        ...diffBody ? { diff: diffBody.diff } : {},
         ...(() => {
           const kind = webActivityKind(event.toolName);
           if (!kind) return {};
@@ -14490,9 +15092,12 @@ export {
   EXPAND_HINT,
   hiddenLinesHint,
   clipText,
-  EDIT_PREVIEW_ROWS,
-  diffRowMarker,
-  diffRows,
+  WORKSPACE_PREVIEW_ROWS,
+  viewRowText,
+  diffViewBody,
+  plainDiffRows,
+  spansText,
+  proposedBody,
   StartupRefusal,
   isMachineError,
   explainFailure,
@@ -14509,6 +15114,8 @@ export {
   liveBatches,
   combineBatches,
   NARRATION_TOOL_NAME,
+  WORKFLOW_TOOL_NAME,
+  WORKFLOW_BACKGROUND_NOTE,
   readMemory,
   appendMemoryWithStatus,
   renderMemoryReport,
@@ -14549,4 +15156,4 @@ export {
   RESULT_SUMMARY_WHOLE_MAX,
   resultSummaryLine
 };
-//# sourceMappingURL=chunk-LLZ32DHS.js.map
+//# sourceMappingURL=chunk-OXJEMOBQ.js.map