@ordewell/core 0.5.4 → 0.5.5

package/dist/{chunk-GWPIYDQW.mjs → chunk-KLN7ELXO.mjs}

@@ -10,7 +10,54 @@ import {
   renumberTasks,
   stripTrailingCommas,
   updateTaskInPlan
-} from "./chunk-JVMDEHRQ.mjs";
+} from "./chunk-HD2FWPRV.mjs";
+
+// src/models/Usage.ts
+function partedPromptUsage(parts) {
+  const reported = [parts.uncached, parts.cacheRead, parts.cacheWrite].filter((n) => n !== void 0);
+  return {
+    ...reported.length > 0 ? { inputTokens: reported.reduce((a, b) => a + b, 0) } : {},
+    ...parts.cacheRead !== void 0 ? { cachedInputTokens: parts.cacheRead } : {}
+  };
+}
+var TOKEN_FIELDS = ["inputTokens", "outputTokens", "cachedInputTokens"];
+function addUsage(totals, record) {
+  const next = { ...totals };
+  for (const field of TOKEN_FIELDS) {
+    const reported = record[field];
+    if (reported !== void 0) next[field] = (totals[field] ?? 0) + reported;
+  }
+  if (record.reportedCost) {
+    const { amount, currency } = record.reportedCost;
+    next.reportedCost = { ...totals.reportedCost, [currency]: (totals.reportedCost?.[currency] ?? 0) + amount };
+  }
+  return next;
+}
+function addPlannerUsage(usage, record) {
+  const next = { ...usage, totals: addUsage(usage.totals, record) };
+  if (record.subagentId) {
+    next.bySubagent = { ...usage.bySubagent, [record.subagentId]: addUsage(usage.bySubagent?.[record.subagentId] ?? {}, record) };
+    return next;
+  }
+  if (record.inputTokens !== void 0) next.lastPromptTokens = record.inputTokens;
+  if (record.contextWindow !== void 0 && record.contextWindow > 0) next.contextWindow = record.contextWindow;
+  return next;
+}
+function isMeasured(totals) {
+  return totals.inputTokens !== void 0 || totals.outputTokens !== void 0 || totals.cachedInputTokens !== void 0 || Object.keys(totals.reportedCost ?? {}).length > 0;
+}
+function usageLine(usage) {
+  const contextFill = plannerContextFill(usage);
+  return {
+    totals: usage.totals,
+    ...usage.bySubagent ? { bySubagent: usage.bySubagent } : {},
+    ...contextFill ? { contextFill } : {}
+  };
+}
+function plannerContextFill(usage) {
+  if (usage.lastPromptTokens === void 0 || usage.contextWindow === void 0 || usage.contextWindow <= 0) return void 0;
+  return { usedTokens: usage.lastPromptTokens, windowTokens: usage.contextWindow };
+}
 
 // src/services/ModelAllowlistResolver.ts
 function effectiveAllowlist(allowlist, runner, modelsByRunner) {
@@ -215,37 +262,37 @@ function taskOpsProtocol(executionNote = "") {
     '"rearm" puts a failed OR completed task back to pending \u2014 verdict and output summary are cleared, any dependents it had blocked are released, and it may carry field changes (e.g. a corrected "prompt") applied in the same op. A running task cannot be re-armed. Never rearm a task just to relabel it \u2014 only when it should actually run again.'
   ];
 }
-function textHasTaskOps(text) {
-  return text.includes(`"${TASK_OPS_ENVELOPE_KEY}"`);
+function textHasTaskOps(text2) {
+  return text2.includes(`"${TASK_OPS_ENVELOPE_KEY}"`);
 }
-function parseTaskOpsJson(text) {
-  const { matches, fallback } = extractObjectsWithKey(text, TASK_OPS_ENVELOPE_KEY);
+function parseTaskOpsJson(text2) {
+  const { matches, fallback } = extractObjectsWithKey(text2, TASK_OPS_ENVELOPE_KEY);
   const candidates = matches.length > 0 ? [...matches].reverse() : [fallback.json];
   let lastError = null;
   for (const json of candidates) {
     try {
-      return parseTaskOpsObject(json, text);
+      return parseTaskOpsObject(json, text2);
     } catch (err) {
       if (!(err instanceof PlanParseError)) throw err;
       if (!lastError) lastError = err;
     }
   }
-  throw lastError ?? new PlanParseError("No JSON object found in task-ops reply", text);
+  throw lastError ?? new PlanParseError("No JSON object found in task-ops reply", text2);
 }
-function parseTaskOpsObject(json, text) {
+function parseTaskOpsObject(json, text2) {
   let parsed;
   try {
     parsed = JSON.parse(escapeControlCharsInStrings(stripTrailingCommas(json)));
   } catch (err) {
-    throw new PlanParseError(`Task-ops JSON is invalid: ${err instanceof Error ? err.message : String(err)}`, text);
+    throw new PlanParseError(`Task-ops JSON is invalid: ${err instanceof Error ? err.message : String(err)}`, text2);
   }
   const ops = parsed.taskOps;
   if (!Array.isArray(ops) || ops.length === 0) {
-    throw new PlanParseError('"taskOps" must be a non-empty array', text);
+    throw new PlanParseError('"taskOps" must be a non-empty array', text2);
   }
   for (const op of ops) {
     if (typeof op !== "object" || op === null || typeof op.op !== "string") {
-      throw new PlanParseError('Every task op needs an "op" field (update | add | remove | reorder | merge | split)', text);
+      throw new PlanParseError('Every task op needs an "op" field (update | add | remove | reorder | merge | split)', text2);
     }
   }
   return ops;
@@ -274,6 +321,27 @@ function resolveRef(ref, originalScope, liveScope, handleOwner, handleId, opInde
   if (byTitle) return { id: byTitle.id };
   return { error: `task "${s}" not found` };
 }
+function taskOpRefs(op) {
+  switch (op.op) {
+    case "update":
+    case "remove":
+    case "split":
+    case "rearm":
+      return [op.taskId];
+    case "merge":
+    case "reorder":
+      return op.taskIds;
+    case "add":
+      return [];
+  }
+}
+function refMatchesTask(ref, task) {
+  if (typeof ref !== "string" && typeof ref !== "number") return false;
+  const s = String(ref).trim();
+  if (task.id === s) return true;
+  const orderStr = s.startsWith("#") ? s.slice(1) : s;
+  return /^\d+$/.test(orderStr) && task.order === Number(orderStr) || task.title === s;
+}
 function refCollidesWithExisting(name, originalFlatAll) {
   if (originalFlatAll.some((t) => t.id === name)) return true;
   const orderStr = name.startsWith("#") ? name.slice(1) : name;
@@ -796,9 +864,9 @@ function applyTaskOps(currentTasks, ops, runners, catalog) {
 }
 
 // src/services/researchStepSummary.ts
-function ellipsize(text, max) {
-  const oneLine = text.replace(/\s+/g, " ").trim();
-  return oneLine.length > max ? `${oneLine.slice(0, max)}\u2026` : oneLine;
+function ellipsize(text2, max) {
+  const oneLine2 = text2.replace(/\s+/g, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max)}\u2026` : oneLine2;
 }
 function summarizeToolCall(tool, argsJson, toolLabel) {
   const display = toolLabel?.trim() || tool;
@@ -815,8 +883,8 @@ function summarizeToolCall(tool, argsJson, toolLabel) {
     try {
       const args = JSON.parse(argsJson);
       const prompt = typeof args.prompt === "string" ? args.prompt : "";
-      const oneLine = prompt.replace(/\s+/g, " ").trim();
-      return `spawn: "${oneLine.slice(0, 60)}${oneLine.length > 60 ? "\u2026" : ""}"`;
+      const oneLine2 = prompt.replace(/\s+/g, " ").trim();
+      return `spawn: "${oneLine2.slice(0, 60)}${oneLine2.length > 60 ? "\u2026" : ""}"`;
     } catch {
       return "spawn_research_agent";
     }
@@ -918,7 +986,796 @@ function truncateCheckpointSummary(summary) {
   return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
 }
 
+// src/services/terminalRender.ts
+var ANSI_OR_CTRL_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[()][AB012]|\x1b[=>]|[\x00-\x08\x0b-\x1f\x7f]/g;
+function flattenTerminalOutput(raw) {
+  return raw.replace(ANSI_OR_CTRL_RE, "").replace(/[─-▟]/g, "").replace(/\s+/g, "");
+}
+function renderTerminalOutput(raw) {
+  const rows = /* @__PURE__ */ new Map();
+  let row = 1;
+  let col = 1;
+  let savedRow = 1;
+  let savedCol = 1;
+  const cells = (r) => {
+    let line = rows.get(r);
+    if (!line) {
+      line = [];
+      rows.set(r, line);
+    }
+    return line;
+  };
+  const firstParam = (params, fallback = 1) => params[0] || fallback;
+  const eraseLine = (mode) => {
+    const line = cells(row);
+    if (mode === 2) {
+      rows.set(row, []);
+    } else if (mode === 1) {
+      for (let c = 0; c < col; c++) line[c] = " ";
+    } else {
+      line.length = Math.max(0, col - 1);
+    }
+  };
+  for (let i = 0; i < raw.length; ) {
+    const ch = raw[i];
+    if (ch === "\x1B") {
+      const kind = raw[i + 1];
+      if (kind === "[") {
+        let end = i + 2;
+        while (end < raw.length) {
+          const code = raw.charCodeAt(end);
+          if (code >= 64 && code <= 126) break;
+          end++;
+        }
+        if (end >= raw.length) break;
+        const final = raw[end];
+        const body = raw.slice(i + 2, end).replace(/^[?<>=!]+/, "");
+        const params = body.split(";").map((p) => Number.parseInt(p, 10) || 0);
+        switch (final) {
+          case "H":
+          case "f":
+            row = params[0] || 1;
+            col = params[1] || 1;
+            break;
+          case "G":
+            col = firstParam(params);
+            break;
+          case "d":
+            row = firstParam(params);
+            break;
+          case "A":
+            row = Math.max(1, row - firstParam(params));
+            break;
+          case "B":
+            row += firstParam(params);
+            break;
+          case "C":
+            col += firstParam(params);
+            break;
+          case "D":
+            col = Math.max(1, col - firstParam(params));
+            break;
+          case "E":
+            row += firstParam(params);
+            col = 1;
+            break;
+          case "F":
+            row = Math.max(1, row - firstParam(params));
+            col = 1;
+            break;
+          case "s":
+            savedRow = row;
+            savedCol = col;
+            break;
+          case "u":
+            row = savedRow;
+            col = savedCol;
+            break;
+          case "K":
+            eraseLine(params[0] || 0);
+            break;
+          case "J":
+            if ((params[0] || 0) === 2 || (params[0] || 0) === 3) rows.clear();
+            break;
+          case "X": {
+            const line = cells(row);
+            for (let c = 0; c < firstParam(params); c++) line[col - 1 + c] = " ";
+            break;
+          }
+          case "P": {
+            cells(row).splice(col - 1, firstParam(params));
+            break;
+          }
+          case "@": {
+            cells(row).splice(col - 1, 0, ...Array(firstParam(params)).fill(" "));
+            break;
+          }
+          default:
+            break;
+        }
+        i = end + 1;
+        continue;
+      }
+      if (kind === "]" || kind === "P" || kind === "^" || kind === "_") {
+        let end = i + 2;
+        while (end < raw.length && raw[end] !== "\x07" && !(raw[end] === "\x1B" && raw[end + 1] === "\\")) end++;
+        if (end >= raw.length) break;
+        i = raw[end] === "\x07" ? end + 1 : end + 2;
+        continue;
+      }
+      if (kind === "7") {
+        savedRow = row;
+        savedCol = col;
+      } else if (kind === "8") {
+        row = savedRow;
+        col = savedCol;
+      } else if (kind === "c") {
+        rows.clear();
+        row = 1;
+        col = 1;
+      }
+      i += kind === "(" || kind === ")" ? 3 : 2;
+      continue;
+    }
+    if (ch === "\r") {
+      col = 1;
+      i++;
+      continue;
+    }
+    if (ch === "\n") {
+      row++;
+      i++;
+      continue;
+    }
+    if (ch === "\b") {
+      col = Math.max(1, col - 1);
+      i++;
+      continue;
+    }
+    if (ch === "	") {
+      col += 8 - (col - 1) % 8;
+      i++;
+      continue;
+    }
+    if (ch < " " || ch === "\x7F") {
+      i++;
+      continue;
+    }
+    cells(row)[col - 1] = ch;
+    col++;
+    i++;
+  }
+  const populated = [...rows.keys()].sort((a, b) => a - b);
+  return populated.map((r) => cells(r).join("")).join("\n");
+}
+function renderCleanCapture(raw, doneToken) {
+  const rendered = renderTerminalOutput(raw).replace(/[\s─-▟]+$/gm, "");
+  if (!doneToken) return rendered.trim();
+  const lines = rendered.split("\n");
+  const flat = (s) => flattenTerminalOutput(s);
+  for (let i = 0; i < lines.length; i++) {
+    const own = flat(lines[i]).includes(doneToken);
+    if (own) return lines.slice(0, i).join("\n").trim();
+    const window = flat(lines[i]) + (i + 1 < lines.length ? flat(lines[i + 1]) : "");
+    if (window.includes(doneToken)) return lines.slice(0, i + 1).join("\n").trim();
+  }
+  return rendered.trim();
+}
+
+// src/conversation/format.ts
+var DISPLAY_NAMES = {
+  read_file: "Read",
+  read_files: "Read",
+  list_dir: "List",
+  glob: "Glob",
+  grep: "Grep",
+  find_symbol: "Symbol",
+  bash: "Bash",
+  fetch: "Fetch",
+  web_search: "WebSearch",
+  spawn_research_agent: "Agent"
+};
+var HINT_FIELDS = ["file_path", "filePath", "path", "url", "pattern", "query", "command", "description", "prompt"];
+function parseArgs(args) {
+  try {
+    const parsed = JSON.parse(args);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function oneLine(text2) {
+  return text2.replace(/\s+/g, " ").trim();
+}
+function firstLineOf(command) {
+  const lines = command.trim().split(/\r?\n/);
+  const more = lines.length - 1;
+  return more > 0 ? `${lines[0]} \u2026 +${more} line${more === 1 ? "" : "s"}` : lines[0];
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function searchArg(pattern, path, include = "") {
+  return `${pattern}${path ? ` in ${path}` : ""}${include ? ` (${include})` : ""}`;
+}
+function hintArg(args) {
+  for (const field of HINT_FIELDS) {
+    const value = text(args[field]);
+    if (value) return field === "command" ? firstLineOf(value) : oneLine(value);
+  }
+  const firstText = Object.values(args).find((v) => typeof v === "string" && v.trim() !== "");
+  return firstText ? oneLine(firstText) : "";
+}
+function keyArgOf(tool, args) {
+  switch (tool) {
+    case "bash":
+      return firstLineOf(text(args.command));
+    case "read_file":
+    case "list_dir":
+      return text(args.path);
+    case "read_files":
+      return Array.isArray(args.paths) ? args.paths.map(String).join(", ") : "";
+    case "glob":
+      return searchArg(text(args.pattern), text(args.path));
+    case "grep":
+      return searchArg(text(args.pattern), text(args.path), text(args.include));
+    case "find_symbol":
+      return `${text(args.symbol)}${text(args.language) ? ` [${text(args.language)}]` : ""}`;
+    case "fetch":
+      return text(args.url);
+    case "web_search":
+      return oneLine(text(args.query));
+    case "spawn_research_agent":
+      return oneLine(text(args.prompt));
+    default:
+      return hintArg(args);
+  }
+}
+function toolHeadline(tool, args, toolLabel) {
+  const name = toolLabel?.trim() || DISPLAY_NAMES[tool] || tool;
+  const parsed = parseArgs(args);
+  return { name, keyArg: parsed ? keyArgOf(tool, parsed) : oneLine(args) };
+}
+function outputLines(output) {
+  const lines = output.replace(/\r\n?/g, "\n").replace(ANSI_OR_CTRL_RE, "").split("\n");
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+  return lines;
+}
+function outputPreview(output, maxLines) {
+  const lines = outputLines(output);
+  const shown = lines.slice(0, Math.max(0, maxLines));
+  return { lines: shown, hiddenLineCount: lines.length - shown.length };
+}
+
+// src/conversation/records.ts
+function settledMessage(id, role, text2, turnId) {
+  return { type: "message", id, role, text: text2, streaming: false, ...turnId ? { turnId } : {} };
+}
+function subagentBlock(id, { toolCallId, model, usage, turnId, ...fields }) {
+  return {
+    type: "subagent",
+    id,
+    ...fields,
+    ...toolCallId ? { toolCallId } : {},
+    ...model ? { model } : {},
+    ...usage ? { usage } : {},
+    ...turnId ? { turnId } : {}
+  };
+}
+function usageBlock(id, { totals, bySubagent, contextFill }) {
+  return { type: "usage", id, totals, ...bySubagent ? { bySubagent } : {}, ...contextFill ? { contextFill } : {} };
+}
+var STATUS_OF_OUTCOME = {
+  success: "ok",
+  failure: "error",
+  refused: "denied",
+  denied: "denied",
+  not_executed: "interrupted"
+};
+function settledTool(call, step) {
+  return { ...call, status: STATUS_OF_OUTCOME[step.outcome], outcome: step.outcome, output: step.result, outputLineCount: outputLines(step.result).length };
+}
+function pendingTool(id, { tool, toolLabel, args, toolCallId, turnId }) {
+  return {
+    type: "tool",
+    id,
+    tool,
+    headline: toolHeadline(tool, args, toolLabel),
+    args,
+    status: "pending",
+    output: "",
+    outputLineCount: 0,
+    ...toolCallId ? { toolCallId } : {},
+    ...toolLabel ? { toolLabel } : {},
+    ...turnId ? { turnId } : {}
+  };
+}
+function toolFromStep(id, step, turnId) {
+  return settledTool(pendingTool(id, { ...step, turnId }), step);
+}
+function planMarker(content) {
+  const count = /(\d+) tasks?\b/.exec(content);
+  return { status: content.startsWith("Plan updated") ? "updated" : "generated", ...count ? { taskCount: Number(count[1]) } : {} };
+}
+
+// src/conversation/reduce.ts
+var EMPTY_CONVERSATION = { blocks: [], nextId: 1 };
+function findLastIndex(items, match) {
+  for (let i = items.length - 1; i >= 0; i--) if (match(items[i])) return i;
+  return -1;
+}
+function replaceAt(items, index, item) {
+  const next = items.slice();
+  next[index] = item;
+  return next;
+}
+function insertTop(blocks, block) {
+  const last = blocks[blocks.length - 1];
+  return last?.type === "usage" ? [...blocks.slice(0, -1), block, last] : [...blocks, block];
+}
+function append(view, make) {
+  return { ...view, blocks: insertTop(view.blocks, make(`b${view.nextId}`)), nextId: view.nextId + 1 };
+}
+function subagentAt(view, lane) {
+  const block = view.blocks[lane];
+  if (block.type !== "subagent") throw new Error(`block ${lane} is not a subagent`);
+  return block;
+}
+function laneBlocks(view, lane) {
+  return lane === null ? view.blocks : subagentAt(view, lane).children;
+}
+function setChildren(view, lane, children) {
+  return { ...view, blocks: replaceAt(view.blocks, lane, { ...subagentAt(view, lane), children }) };
+}
+function laneReplace(view, lane, index, block) {
+  if (lane === null) return { ...view, blocks: replaceAt(view.blocks, index, block) };
+  return setChildren(view, lane, replaceAt(subagentAt(view, lane).children, index, block));
+}
+function laneAppend(view, lane, make) {
+  if (lane === null) return append(view, make);
+  const children = [...subagentAt(view, lane).children, make(`b${view.nextId}`)];
+  return { ...setChildren(view, lane, children), nextId: view.nextId + 1 };
+}
+function isStreaming(block) {
+  return (block.type === "message" || block.type === "thinking") && block.streaming;
+}
+function sealed(block) {
+  return isStreaming(block) ? { ...block, streaming: false } : block;
+}
+function sealLane(view, lane, keep) {
+  const blocks = laneBlocks(view, lane);
+  if (!blocks.some((b, i) => i !== keep && isStreaming(b))) return view;
+  if (lane === null) return { ...view, blocks: view.blocks.map((b, i) => i === keep ? b : sealed(b)) };
+  return setChildren(view, lane, subagentAt(view, lane).children.map((b, i) => i === keep ? b : sealed(b)));
+}
+function appendOutput(view, lane, make) {
+  const next = laneAppend(view, lane, make);
+  return sealLane(next, lane, findLastIndex(laneBlocks(next, lane), (b) => b.type !== "usage"));
+}
+function isUnsettledSegment(block, turnId) {
+  return block.type === "message" && block.turnId === turnId && block.segmentId !== void 0;
+}
+function isBuildingPlan(block, turnId) {
+  return block.type === "plan" && block.status === "building" && block.turnId === turnId;
+}
+function finalSegmentIndex(blocks, turnId, pastPlan = false) {
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const block = blocks[i];
+    if (block.type === "usage" || block.type === "thinking" || block.type === "approval" || pastPlan && block.type === "plan") continue;
+    if (block.turnId !== turnId) continue;
+    return isUnsettledSegment(block, turnId) ? i : -1;
+  }
+  return -1;
+}
+function openTurn(view, turnId, prompt) {
+  const i = findLastIndex(view.blocks, (b) => b.type === "message" && b.role === "user");
+  const sent = view.blocks[i];
+  if (sent?.type === "message" && sent.turnId === void 0 && sent.text === prompt) {
+    return { ...view, blocks: replaceAt(view.blocks, i, { ...sent, turnId }) };
+  }
+  return append(view, (id) => settledMessage(id, "user", prompt, turnId));
+}
+function streamText(view, { turnId, segmentId, text: text2 }) {
+  const i = findLastIndex(view.blocks, (b) => isUnsettledSegment(b, turnId) && b.segmentId === segmentId);
+  const segment = view.blocks[i];
+  if (segment?.type === "message") {
+    return sealLane(laneReplace(view, null, i, { ...segment, text: segment.text + text2, streaming: true }), null, i);
+  }
+  return appendOutput(view, null, (id) => ({ type: "message", id, role: "planner", text: text2, streaming: true, turnId, segmentId }));
+}
+function dropBuildingPlan(view, turnId, segmentId) {
+  const blocks = view.blocks.filter((b) => !(isBuildingPlan(b, turnId) && (segmentId === void 0 || b.segmentId === segmentId)));
+  return blocks.length === view.blocks.length ? view : { ...view, blocks };
+}
+function settleReply(view, { content, turnId }) {
+  if (turnId !== void 0) {
+    const i = finalSegmentIndex(view.blocks, turnId);
+    if (i >= 0) {
+      return dropBuildingPlan({ ...view, blocks: replaceAt(view.blocks, i, settledMessage(view.blocks[i].id, "planner", content, turnId)) }, turnId);
+    }
+  }
+  return append(dropBuildingPlan(view, turnId), (id) => settledMessage(id, "planner", content, turnId));
+}
+function retractText(view, { turnId, segmentId }) {
+  const blocks = view.blocks.filter((b) => !(isUnsettledSegment(b, turnId) && (segmentId === void 0 || b.segmentId === segmentId)));
+  return dropBuildingPlan(blocks.length === view.blocks.length ? view : { ...view, blocks }, turnId, segmentId);
+}
+function subagentLane(view, subagentId, turnId) {
+  const existing = findLastIndex(view.blocks, (b) => b.type === "subagent" && b.subagentId === subagentId);
+  if (existing >= 0) return [view, existing];
+  const spawn = findLastIndex(view.blocks, (b) => b.type === "tool" && (b.spawns === subagentId || b.toolCallId === subagentId));
+  const call = view.blocks[spawn];
+  if (call?.type === "tool") {
+    const block = subagentBlock(call.id, {
+      subagentId,
+      brief: call.headline.keyArg,
+      status: "running",
+      children: [],
+      digest: "",
+      toolCallId: call.toolCallId,
+      turnId: call.turnId
+    });
+    return [{ ...view, blocks: replaceAt(view.blocks, spawn, block) }, spawn];
+  }
+  const next = append(view, (id) => subagentBlock(id, { subagentId, brief: "", status: "running", children: [], digest: "", turnId }));
+  return [next, findLastIndex(next.blocks, (b) => b.type === "subagent" && b.subagentId === subagentId)];
+}
+function updateSubagent(view, subagentId, turnId, update) {
+  const [next, lane] = subagentLane(view, subagentId, turnId);
+  return { ...next, blocks: replaceAt(next.blocks, lane, update(subagentAt(next, lane))) };
+}
+function startSubagent(view, { subagentId, brief, model, turnId }) {
+  return updateSubagent(view, subagentId, turnId, (block) => ({ ...block, ...brief ? { brief } : {}, ...model ? { model } : {} }));
+}
+function finishSubagent(view, { subagentId, outcome, digest, usage, turnId }) {
+  return updateSubagent(view, subagentId, turnId, (block) => ({
+    ...block,
+    status: outcome,
+    digest,
+    children: block.children.map(sealed),
+    ...usage ? { usage } : {}
+  }));
+}
+function think(view, text2, turnId, segmentId, subagentId) {
+  const [placed, lane] = subagentId ? subagentLane(view, subagentId, turnId) : [view, null];
+  const blocks = laneBlocks(placed, lane);
+  const lastIndex = findLastIndex(blocks, (b) => b.type !== "usage");
+  const last = blocks[lastIndex];
+  if (last?.type === "thinking" && last.streaming && last.segmentId === segmentId) {
+    return laneReplace(placed, lane, lastIndex, { ...last, text: last.text + text2 });
+  }
+  return appendOutput(placed, lane, (id) => ({
+    type: "thinking",
+    id,
+    text: text2,
+    streaming: true,
+    ...turnId ? { turnId } : {},
+    ...segmentId ? { segmentId } : {},
+    ...subagentId ? { subagentId } : {}
+  }));
+}
+function announceTool(view, call) {
+  const spawns = call.tool === "spawn_research_agent" ? call.subagentId : void 0;
+  const [placed, lane] = call.subagentId && !spawns ? subagentLane(view, call.subagentId, call.turnId) : [view, null];
+  return appendOutput(placed, lane, (id) => ({ ...pendingTool(id, call), ...spawns ? { spawns } : {} }));
+}
+function isPendingCallOf(block, step) {
+  if (block.type !== "tool" || block.status !== "pending") return false;
+  return step.toolCallId ? block.toolCallId === step.toolCallId : block.toolCallId === void 0 && block.tool === step.tool;
+}
+function settleTool(view, { step, turnId }) {
+  const [placed, lane] = step.subagentId ? subagentLane(view, step.subagentId, turnId) : [view, null];
+  const blocks = laneBlocks(placed, lane);
+  const i = findLastIndex(blocks, (b) => isPendingCallOf(b, step));
+  const pending = blocks[i];
+  if (pending?.type === "tool") return laneReplace(placed, lane, i, settledTool(pending, step));
+  if (lane === null && step.toolCallId && blocks.some((b) => b.type === "subagent" && b.toolCallId === step.toolCallId)) return view;
+  return laneAppend(placed, lane, (id) => toolFromStep(id, step, turnId));
+}
+function streamPlan(view, { token, turnId, segmentId }) {
+  const i = findLastIndex(view.blocks, (b) => isBuildingPlan(b, turnId));
+  const building = view.blocks[i];
+  if (building?.type === "plan" && building.segmentId === segmentId) {
+    return { ...view, blocks: replaceAt(view.blocks, i, { ...building, text: building.text + token }) };
+  }
+  return append(dropBuildingPlan(view, turnId), (id) => ({
+    type: "plan",
+    id,
+    status: "building",
+    text: token,
+    ...turnId ? { turnId } : {},
+    ...segmentId ? { segmentId } : {}
+  }));
+}
+function markPlan(view, content, turnId) {
+  const marker = planMarker(content);
+  const i = findLastIndex(view.blocks, (b) => isBuildingPlan(b, turnId));
+  const building = view.blocks[i];
+  if (building?.type === "plan") {
+    const settled = { type: "plan", id: building.id, ...marker, text: "", ...building.turnId ? { turnId: building.turnId } : {} };
+    return { ...view, blocks: replaceAt(view.blocks, i, settled) };
+  }
+  return append(view, (id) => ({ type: "plan", id, text: "", ...marker }));
+}
+function requestApproval(view, { id: approvalId, kind, subject, scope, detail, turnId }) {
+  return append(view, (id) => ({
+    type: "approval",
+    id,
+    approvalId,
+    kind,
+    subject,
+    scope,
+    status: "pending",
+    ...detail ? { detail } : {},
+    ...turnId ? { turnId } : {}
+  }));
+}
+function settleApproval(view, { id, granted }) {
+  const i = findLastIndex(view.blocks, (b) => b.type === "approval" && b.approvalId === id);
+  const request = view.blocks[i];
+  if (request?.type !== "approval") return view;
+  return { ...view, blocks: replaceAt(view.blocks, i, { ...request, status: granted ? "granted" : "denied", decidedBy: "asked" }) };
+}
+function decideApproval(view, { kind, subject, scope, detail, granted, source }) {
+  return append(view, (id) => ({
+    type: "approval",
+    id,
+    kind,
+    subject,
+    scope,
+    status: granted ? "granted" : "denied",
+    decidedBy: source,
+    ...detail ? { detail } : {}
+  }));
+}
+function reportUsage(view, message) {
+  if (!isMeasured(message.totals)) return view;
+  const last = view.blocks[view.blocks.length - 1];
+  const line = usageBlock(last?.type === "usage" ? last.id : `b${view.nextId}`, message);
+  if (last?.type === "usage") return { ...view, blocks: replaceAt(view.blocks, view.blocks.length - 1, line) };
+  return { ...view, blocks: [...view.blocks, line], nextId: view.nextId + 1 };
+}
+function closeBlock(block, interrupted) {
+  return interrupted && block.type === "tool" && block.status === "pending" ? { ...block, status: "interrupted" } : sealed(block);
+}
+function closeSubagent(block, cut) {
+  const children = block.children.map((c) => closeBlock(c, cut !== null));
+  const status = cut && block.status === "running" ? cut : block.status;
+  return status === block.status && children.every((c, i) => c === block.children[i]) ? block : { ...block, status, children };
+}
+function endTurn(view, { turnId, outcome }) {
+  let next = dropBuildingPlan(view, turnId);
+  const planText = outcome === "plan" ? finalSegmentIndex(next.blocks, turnId, true) : -1;
+  if (planText >= 0) next = { ...next, blocks: next.blocks.filter((_, i) => i !== planText) };
+  const cut = outcome === "stopped" ? "stopped" : outcome === "error" ? "failed" : null;
+  const blocks = next.blocks.map((b) => b.type === "subagent" ? closeSubagent(b, cut) : closeBlock(b, cut !== null));
+  return blocks.every((b, i) => b === next.blocks[i]) ? next : { ...next, blocks };
+}
+function markCompaction(view, summary) {
+  const i = findLastIndex(view.blocks, (b) => b.type === "message" && b.role === "planner" && b.turnId === void 0 && b.text === summary);
+  const announced = view.blocks[i];
+  if (announced?.type === "message") return { ...view, blocks: replaceAt(view.blocks, i, { ...announced, role: "system" }) };
+  return append(view, (id) => settledMessage(id, "system", summary));
+}
+function syncTranscript(view, { plan, turnId }) {
+  const history = plan.conversationHistory ?? [];
+  const committed = findLastIndex(history, (e) => e.kind === "plan_generated");
+  let next = view;
+  let latest = view.transcriptAt;
+  for (const [i, entry] of history.entries()) {
+    const isNew = view.transcriptAt === void 0 || entry.timestamp > view.transcriptAt;
+    if (isNew && entry.kind === "plan_generated") next = markPlan(next, entry.content, i === committed ? turnId : void 0);
+    if (isNew && entry.kind === "system") next = append(next, (id) => settledMessage(id, "system", entry.content));
+    if (isNew && entry.kind === "compaction") next = markCompaction(next, entry.content);
+    if (latest === void 0 || entry.timestamp > latest) latest = entry.timestamp;
+  }
+  return next === view && latest === view.transcriptAt ? view : { ...next, transcriptAt: latest };
+}
+function reduceConversation(view, input) {
+  switch (input.type) {
+    case "local_entry":
+      return append(view, (id) => settledMessage(id, input.role, input.text));
+    case "planner_turn_started":
+      return input.prompt === void 0 ? view : openTurn(view, input.turnId, input.prompt);
+    case "planner_text_delta":
+      return streamText(view, input);
+    case "planner_message":
+      return settleReply(view, input);
+    case "planner_text_retracted":
+      return retractText(view, input);
+    case "planner_thinking_delta":
+      return think(view, input.text, input.turnId, input.segmentId, input.subagentId);
+    case "research_step":
+      return announceTool(view, input);
+    case "research_step_done":
+      return settleTool(view, input);
+    case "subagent_started":
+      return startSubagent(view, input);
+    case "subagent_finished":
+      return finishSubagent(view, input);
+    case "plan_token":
+      return streamPlan(view, input);
+    case "plan_generated":
+      return syncTranscript(view, input);
+    case "planner_turn_ended":
+      return endTurn(view, input);
+    case "approval_request":
+      return requestApproval(view, input);
+    case "approval_settled":
+      return settleApproval(view, input);
+    case "approval_decided":
+      return decideApproval(view, input);
+    case "planner_usage":
+      return reportUsage(view, input);
+    default:
+      return view;
+  }
+}
+
+// src/conversation/transcript.ts
+var USER = 0;
+var RESEARCH = 1;
+var SETTLED = 2;
+function fromEntry(entry) {
+  if (entry.kind === "plan_generated") return (id) => ({ type: "plan", id: id(), text: "", ...planMarker(entry.content) });
+  const role = entry.kind === "system" || entry.kind === "compaction" ? "system" : entry.role === "user" ? "user" : "planner";
+  return (id) => settledMessage(id(), role, entry.content);
+}
+function spawnBrief(step) {
+  try {
+    const args = JSON.parse(step.args);
+    const prompt = args && typeof args === "object" ? args.prompt : void 0;
+    return typeof prompt === "string" ? prompt.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function spawnedBy(step, unclaimed) {
+  const byId = unclaimed.find((e) => e.subagentId === step.toolCallId);
+  if (byId) return byId;
+  if (step.tool !== "spawn_research_agent") return void 0;
+  const brief = spawnBrief(step);
+  return brief === void 0 ? void 0 : unclaimed.find((e) => e.brief === brief);
+}
+function research(log) {
+  const subagents = log.filter((e) => "type" in e && e.type === "subagent");
+  const ownSubagent = new Set(subagents.map((e) => e.subagentId));
+  const unclaimed = [...subagents];
+  const spawnCall = /* @__PURE__ */ new Map();
+  const placed = [];
+  for (const entry of log) {
+    if ("type" in entry) {
+      if (entry.type === "system") placed.push({ at: entry.timestamp, rank: RESEARCH, build: (id) => settledMessage(id(), "system", entry.content) });
+      continue;
+    }
+    if (entry.subagentId && ownSubagent.has(entry.subagentId)) continue;
+    const spawned = spawnedBy(entry, unclaimed);
+    if (spawned) {
+      unclaimed.splice(unclaimed.indexOf(spawned), 1);
+      spawnCall.set(spawned.subagentId, entry.toolCallId);
+      continue;
+    }
+    placed.push({ at: entry.timestamp, rank: RESEARCH, build: (id) => toolFromStep(id(), entry) });
+  }
+  for (const entry of subagents) {
+    const toolCallId = spawnCall.get(entry.subagentId);
+    const steps = log.filter((e) => !("type" in e) && e.subagentId === entry.subagentId);
+    placed.push({
+      at: entry.timestamp,
+      rank: RESEARCH,
+      build: (id) => subagentBlock(id(), {
+        subagentId: entry.subagentId,
+        brief: entry.brief,
+        status: entry.outcome,
+        digest: entry.digest,
+        children: steps.map((step) => toolFromStep(id(), step)),
+        toolCallId,
+        model: entry.model,
+        usage: entry.usage
+      })
+    });
+  }
+  return placed;
+}
+function fromTranscript(conversationHistory, researchLog, plannerUsage) {
+  const history = conversationHistory ?? [];
+  const compacted = history[0]?.kind === "compaction" ? history[0] : void 0;
+  const kept = compacted ? history.slice(1) : history;
+  const cutoff = compacted ? kept[0]?.timestamp ?? compacted.timestamp : "";
+  const placed = [
+    ...kept.map((entry) => ({ at: entry.timestamp, rank: entry.role === "user" && !entry.kind ? USER : SETTLED, build: fromEntry(entry) })),
+    ...research(researchLog ?? []).filter((item) => item.at >= cutoff)
+  ];
+  placed.sort((a, b) => a.at < b.at ? -1 : a.at > b.at ? 1 : a.rank - b.rank);
+  if (compacted) placed.unshift({ at: "", rank: SETTLED, build: fromEntry(compacted) });
+  let nextId = 1;
+  const id = () => `b${nextId++}`;
+  const blocks = placed.map((item) => item.build(id));
+  if (plannerUsage && isMeasured(plannerUsage.totals)) blocks.push(usageBlock(id(), usageLine(plannerUsage)));
+  const transcriptAt = history.reduce((latest, e) => latest === void 0 || e.timestamp > latest ? e.timestamp : latest, void 0);
+  return { blocks, nextId, ...transcriptAt ? { transcriptAt } : {} };
+}
+
+// src/conversation/promptHold.ts
+var EMPTY_HOLD = [];
+function holdPrompt(hold, text2) {
+  return [...hold, text2];
+}
+function drainNext(hold) {
+  const [text2, ...rest] = hold;
+  return text2 === void 0 ? void 0 : { text: text2, rest };
+}
+function unsendLatest(hold) {
+  if (hold.length === 0) return void 0;
+  return { text: hold[hold.length - 1], rest: hold.slice(0, -1) };
+}
+function unsendAll(hold) {
+  if (hold.length === 0) return void 0;
+  return { text: hold.join("\n"), rest: EMPTY_HOLD };
+}
+function aheadOfDraft(text2, draft) {
+  return draft ? `${text2}
+${draft}` : text2;
+}
+
+// src/conversation/turnGate.ts
+var NO_TURN = { open: null, stopped: null };
+var TURN_STREAM = /* @__PURE__ */ new Set([
+  "planner_text_delta",
+  "planner_thinking_delta",
+  "planner_text_retracted",
+  "planner_message",
+  "plan_token",
+  "research_step",
+  "research_step_done",
+  "subagent_started",
+  "subagent_finished",
+  "planner_turn_ended"
+]);
+function cutOff(gate, input) {
+  if (gate.stopped === null || !TURN_STREAM.has(input.type)) return false;
+  const turnId = "turnId" in input ? input.turnId : void 0;
+  return turnId === void 0 || turnId === gate.stopped;
+}
+function withGate(live, gate) {
+  return gate.open === live.gate.open && gate.stopped === live.gate.stopped ? live : { ...live, gate };
+}
+function followTurn(view, gate, input) {
+  const live = { view, gate };
+  if (input.type === "planner_turn_started") {
+    return withGate({ view: reduceConversation(view, input), gate }, { open: input.turnId, stopped: null });
+  }
+  if (cutOff(gate, input)) {
+    return input.type === "planner_turn_ended" ? withGate(live, { ...gate, stopped: null }) : live;
+  }
+  const next = { view: reduceConversation(view, input), gate };
+  return input.type === "planner_turn_ended" && input.turnId === gate.open ? withGate(next, { ...gate, open: null }) : next;
+}
+function stopTurn(view, gate) {
+  if (gate.open === null) return { view, gate };
+  return {
+    view: reduceConversation(view, { type: "planner_turn_ended", turnId: gate.open, outcome: "stopped" }),
+    gate: { open: null, stopped: gate.open }
+  };
+}
+
+// src/conversation/detail.ts
+function hasHiddenDetail(blocks) {
+  return blocks.some((b) => b.type === "thinking" || b.type === "tool" || b.type === "subagent");
+}
+
+// src/conversation/notices.ts
+function taskStartedNotice(title, runner) {
+  return runner ? `Started "${title}" \xB7 ${runner}` : `Started "${title}"`;
+}
+
 export {
+  partedPromptUsage,
+  addUsage,
+  addPlannerUsage,
+  isMeasured,
+  usageLine,
+  plannerContextFill,
   effectiveAllowlist,
   filterModelsForPrompt,
   clampThinkingEffort,
@@ -927,6 +1784,8 @@ export {
   taskOpsProtocol,
   textHasTaskOps,
   parseTaskOpsJson,
+  taskOpRefs,
+  refMatchesTask,
   canMergeTasks,
   dependentsOf,
   dependencyCandidates,
@@ -935,11 +1794,31 @@ export {
   applyTaskOps,
   summarizeToolCall,
   classifyOutcome,
+  flattenTerminalOutput,
+  renderTerminalOutput,
+  renderCleanCapture,
   serializeTask,
   serializeTaskStatus,
   serializePlan,
   executionSummary,
   CHECKPOINT_TRUNCATE_LENGTH,
-  truncateCheckpointSummary
+  truncateCheckpointSummary,
+  toolHeadline,
+  outputLines,
+  outputPreview,
+  EMPTY_CONVERSATION,
+  reduceConversation,
+  fromTranscript,
+  EMPTY_HOLD,
+  holdPrompt,
+  drainNext,
+  unsendLatest,
+  unsendAll,
+  aheadOfDraft,
+  NO_TURN,
+  followTurn,
+  stopTurn,
+  hasHiddenDetail,
+  taskStartedNotice
 };
-//# sourceMappingURL=chunk-GWPIYDQW.mjs.map
+//# sourceMappingURL=chunk-KLN7ELXO.mjs.map