@ordewell/core 0.5.4 → 0.5.6

package/dist/plan-utils.js

@@ -21,14 +21,35 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var plan_utils_exports = {};
 __export(plan_utils_exports, {
   CHECKPOINT_TRUNCATE_LENGTH: () => CHECKPOINT_TRUNCATE_LENGTH,
+  EMPTY_CONVERSATION: () => EMPTY_CONVERSATION,
+  EMPTY_HOLD: () => EMPTY_HOLD,
+  EMPTY_TASK_LOG: () => EMPTY_TASK_LOG,
+  NO_TURN: () => NO_TURN,
+  aheadOfDraft: () => aheadOfDraft,
   canMergeTasks: () => canMergeTasks,
   canSetDependencies: () => canSetDependencies,
   canSplitTask: () => canSplitTask,
   capConflictFiles: () => capConflictFiles,
   dependencyCandidates: () => dependencyCandidates,
   dependentsOf: () => dependentsOf,
+  drainNext: () => drainNext,
+  followTurn: () => followTurn,
+  fromTranscript: () => fromTranscript,
+  hasHiddenDetail: () => hasHiddenDetail,
+  holdPrompt: () => holdPrompt,
+  outputLines: () => outputLines,
+  outputPreview: () => outputPreview,
+  reduceConversation: () => reduceConversation,
+  reduceTaskLog: () => reduceTaskLog,
+  replayTaskLog: () => replayTaskLog,
+  runnerToolSubject: () => runnerToolSubject,
+  stopTurn: () => stopTurn,
   summarizeToolCall: () => summarizeToolCall,
-  truncateCheckpointSummary: () => truncateCheckpointSummary
+  taskStartedNotice: () => taskStartedNotice,
+  toolHeadline: () => toolHeadline,
+  truncateCheckpointSummary: () => truncateCheckpointSummary,
+  unsendAll: () => unsendAll,
+  unsendLatest: () => unsendLatest
 });
 module.exports = __toCommonJS(plan_utils_exports);
 
@@ -105,9 +126,9 @@ function canSplitTask(tasks, taskId) {
 }
 
 // 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;
@@ -124,8 +145,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";
     }
@@ -173,20 +194,947 @@ function truncateCheckpointSummary(summary) {
   return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
 }
 
-// src/services/isolationRecord.ts
+// src/services/conflictFiles.ts
 function capConflictFiles(files, max = 5) {
   return files.length <= max ? files.join(", ") : `${files.slice(0, max).join(", ")}, +${files.length - max} more`;
 }
+
+// src/models/Usage.ts
+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/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;
+
+// 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 finishedTool(call, output, outcome) {
+  return { ...call, status: STATUS_OF_OUTCOME[outcome], outcome, output, outputLineCount: outputLines(output).length };
+}
+function settledTool(call, step) {
+  return finishedTool(call, step.result, step.outcome);
+}
+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/lanes.ts
+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 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 laneOf(view, subagentId, turnId) {
+  return subagentId ? subagentLane(view, subagentId, turnId) : [view, null];
+}
+function think(view, text2, turnId, segmentId, subagentId) {
+  const [placed, lane] = laneOf(view, subagentId, turnId);
+  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 setUsageLine(view, line) {
+  const last = view.blocks[view.blocks.length - 1];
+  const block = usageBlock(last?.type === "usage" ? last.id : `b${view.nextId}`, line);
+  if (last?.type === "usage") return { ...view, blocks: replaceAt(view.blocks, view.blocks.length - 1, block) };
+  return { ...view, blocks: [...view.blocks, block], 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 closeOpenBlocks(view, cut) {
+  const blocks = view.blocks.map((b) => b.type === "subagent" ? closeSubagent(b, cut) : closeBlock(b, cut !== null));
+  return blocks.every((b, i) => b === view.blocks[i]) ? view : { ...view, blocks };
+}
+
+// src/conversation/reduce.ts
+var EMPTY_CONVERSATION = { blocks: [], nextId: 1 };
+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 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 announceTool(view, call) {
+  const spawns = call.tool === "spawn_research_agent" ? call.subagentId : void 0;
+  const [placed, lane] = laneOf(view, spawns ? void 0 : call.subagentId, call.turnId);
+  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] = laneOf(view, step.subagentId, turnId);
+  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) {
+  return isMeasured(message.totals) ? setUsageLine(view, message) : view;
+}
+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) };
+  return closeOpenBlocks(next, outcome === "stopped" ? "stopped" : outcome === "error" ? "failed" : null);
+}
+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/services/harness/agentTools.ts
+var KNOWN_TOOLS = {
+  // Claude Code
+  read: "read_file",
+  grep: "grep",
+  glob: "glob",
+  bash: "bash",
+  ls: "list_dir",
+  webfetch: "fetch",
+  websearch: "web_search",
+  // Codex — its sandboxed command tool is a shell by another name
+  shell: "bash",
+  exec_command: "bash",
+  local_shell: "bash",
+  // OpenCode
+  list: "list_dir",
+  fetch: "fetch"
+};
+function mapAgentTool(name) {
+  const normalized = name.trim().toLowerCase().replace(/[_-]/g, "");
+  const direct = KNOWN_TOOLS[normalized] ?? KNOWN_TOOLS[name.trim().toLowerCase()];
+  if (direct) {
+    return { tool: direct, toolLabel: name };
+  }
+  return { tool: "agent_tool", toolLabel: name };
+}
+function normalizeAgentArgs(tool, args) {
+  const out = { ...args };
+  const alias = (from, to) => {
+    if (out[to] === void 0 && out[from] !== void 0) out[to] = out[from];
+  };
+  if (tool === "read_file" || tool === "list_dir") {
+    alias("filePath", "path");
+    alias("file_path", "path");
+    alias("target", "path");
+  }
+  if (tool === "bash") {
+    alias("cmd", "command");
+    alias("script", "command");
+    if (typeof out.command !== "string" && Array.isArray(out.command)) {
+      out.command = out.command.join(" ");
+    }
+  }
+  if (tool === "fetch") alias("uri", "url");
+  if (tool === "web_search") alias("q", "query");
+  return out;
+}
+
+// src/conversation/taskLog.ts
+var EMPTY_TASK_LOG = { blocks: [], nextId: 1, queued: [], working: false, streams: {} };
+var TEXT_STREAM = "text";
+var thinkingStream = (subagentId) => `thinking:${subagentId ?? ""}`;
+function withoutStream(view, key) {
+  if (!(key in view.streams)) return view;
+  return { ...view, streams: Object.fromEntries(Object.entries(view.streams).filter(([k]) => k !== key)) };
+}
+function blockText(text2) {
+  return text2.replace(/^\n+/, "");
+}
+function openStream(view, lane, key) {
+  const id = view.streams[key];
+  if (id === void 0) return -1;
+  const blocks = laneBlocks(view, lane);
+  const i = findLastIndex(blocks, (b) => b.type !== "usage");
+  const block = blocks[i];
+  return block?.id === id && (block.type === "message" || block.type === "thinking") && block.streaming ? i : -1;
+}
+function streamDelta(view, lane, key, text2, make) {
+  const i = openStream(view, lane, key);
+  const open = laneBlocks(view, lane)[i];
+  if (open?.type === "message" || open?.type === "thinking") return laneReplace(view, lane, i, { ...open, text: open.text + text2 });
+  const next = appendOutput(view, lane, (id) => make(id, blockText(text2)));
+  return { ...next, streams: { ...next.streams, [key]: `b${view.nextId}` } };
+}
+function streamWhole(view, lane, key, text2, make) {
+  const id = view.streams[key];
+  const blocks = laneBlocks(view, lane);
+  const i = id === void 0 ? -1 : findLastIndex(blocks, (b) => b.id === id);
+  const streamed = blocks[i];
+  const next = withoutStream(view, key);
+  if (streamed?.type === "message" || streamed?.type === "thinking") {
+    return laneReplace(next, lane, i, { ...streamed, text: blockText(text2), streaming: false });
+  }
+  return appendOutput(next, lane, make);
+}
+function agentText(view, text2) {
+  return streamWhole(view, null, TEXT_STREAM, text2, (id) => settledMessage(id, "agent", blockText(text2)));
+}
+function agentTextDelta(view, text2) {
+  return streamDelta(view, null, TEXT_STREAM, text2, (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true }));
+}
+function thinkingBlock(id, text2, streaming, subagentId) {
+  return { type: "thinking", id, text: text2, streaming, ...subagentId ? { subagentId } : {} };
+}
+function thinkingDelta(view, { text: text2, subagentId }) {
+  const [placed, lane] = laneOf(view, subagentId);
+  return streamDelta(placed, lane, thinkingStream(subagentId), text2, (id, t) => thinkingBlock(id, t, true, subagentId));
+}
+function thinkingWhole(view, { text: text2, subagentId }) {
+  const [placed, lane] = laneOf(view, subagentId);
+  return streamWhole(placed, lane, thinkingStream(subagentId), text2, (id) => thinkingBlock(id, blockText(text2), false, subagentId));
+}
+function announceTool2(view, { id: toolCallId, name, args, subagentId }) {
+  const { tool, toolLabel } = mapAgentTool(name);
+  const [placed, lane] = laneOf(view, subagentId);
+  return appendOutput(placed, lane, (id) => {
+    const call = pendingTool(id, { tool, toolLabel, args, toolCallId });
+    const parsed = parseArgs2(args);
+    return parsed ? { ...call, headline: toolHeadline(tool, JSON.stringify(normalizeAgentArgs(tool, parsed)), toolLabel) } : call;
+  });
+}
+function parseArgs2(args) {
+  try {
+    const parsed = JSON.parse(args);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function settleTool2(view, { id: toolCallId, output, success, subagentId }) {
+  const [placed, lane] = laneOf(view, subagentId);
+  const blocks = laneBlocks(placed, lane);
+  const i = findLastIndex(blocks, (b) => b.type === "tool" && b.status === "pending" && b.toolCallId === toolCallId);
+  const pending = blocks[i];
+  const outcome = success ? "success" : "failure";
+  if (pending?.type === "tool") return laneReplace(placed, lane, i, finishedTool(pending, output, outcome));
+  if (lane === null && blocks.some((b) => b.type === "subagent" && b.toolCallId === toolCallId)) return view;
+  return laneAppend(placed, lane, (id) => finishedTool(pendingTool(id, { tool: "agent_tool", toolLabel: "Tool", args: "", toolCallId }), output, outcome));
+}
+function startSubagent2(view, { subagentId, brief, model }) {
+  return updateSubagent(view, subagentId, void 0, (block) => ({ ...block, ...brief ? { brief } : {}, ...model ? { model } : {} }));
+}
+function finishSubagent2(view, { subagentId, outcome, digest }) {
+  const usage = view.usage?.bySubagent?.[subagentId];
+  const next = updateSubagent(view, subagentId, void 0, (block) => ({
+    ...block,
+    status: outcome,
+    digest,
+    children: block.children.map(sealed),
+    ...usage ? { usage } : {}
+  }));
+  return withoutStream(next, thinkingStream(subagentId));
+}
+function reportUsage2(view, { record }) {
+  const usage = addPlannerUsage(view.usage ?? { totals: {} }, record);
+  const next = { ...view, usage };
+  return isMeasured(usage.totals) ? setUsageLine(next, usageLine(usage)) : next;
+}
+function runnerToolSubject(tool, args) {
+  const { tool: mapped, toolLabel } = mapAgentTool(tool);
+  const parsed = parseArgs2(args);
+  const headline = toolHeadline(mapped, parsed ? JSON.stringify(normalizeAgentArgs(mapped, parsed)) : args, toolLabel);
+  return headline.keyArg ? `${headline.name}(${headline.keyArg})` : headline.name;
+}
+function requestApproval2(view, { approvalId, tool, args, allowForTask, toolCallId }) {
+  if (view.blocks.some((b) => b.type === "approval" && b.approvalId === approvalId)) return view;
+  return append(view, (id) => ({
+    type: "approval",
+    id,
+    approvalId,
+    kind: "runner_tool",
+    subject: runnerToolSubject(tool, args),
+    scope: tool,
+    status: "pending",
+    ...allowForTask ? { allowForTask } : {},
+    ...toolCallId ? { toolCallId } : {}
+  }));
+}
+function settleApproval2(view, approvalId, settle) {
+  const i = findLastIndex(view.blocks, (b) => b.type === "approval" && b.approvalId === approvalId);
+  const block = view.blocks[i];
+  if (block?.type !== "approval" || block.status !== "pending") return view;
+  return { ...view, blocks: replaceAt(view.blocks, i, settle(block)) };
+}
+function decideApproval2(view, { approvalId, decision, note }) {
+  return settleApproval2(view, approvalId, (block) => ({
+    ...block,
+    status: decision === "deny" ? "denied" : "granted",
+    decidedBy: "asked",
+    ...decision === "allowForTask" ? { forTask: true } : {},
+    ...note ? { note } : {}
+  }));
+}
+function startTurn(view, { message, messageId }) {
+  const queued = messageId ? view.queued.filter((m) => m.id !== messageId) : view.queued;
+  return append({ ...view, queued, working: true }, (id) => settledMessage(id, "user", message));
+}
+var CUT = { completed: null, interrupted: "stopped", failed: "failed" };
+function endTurn2(view, { reason }) {
+  const closed = closeOpenBlocks({ ...view, working: false, lastTurnEnd: reason, streams: {} }, CUT[reason]);
+  return reason === "interrupted" ? append(closed, (id) => settledMessage(id, "system", "Interrupted.")) : closed;
+}
+function queueMessage(view, { messageId, text: text2 }) {
+  if (view.queued.some((m) => m.id === messageId)) return view;
+  return { ...view, queued: [...view.queued, { id: messageId, text: text2 }] };
+}
+function unqueueMessage(view, { messageId }) {
+  const queued = view.queued.filter((m) => m.id !== messageId);
+  return queued.length === view.queued.length ? view : { ...view, queued };
+}
+function reduceTaskLog(view, event) {
+  switch (event.type) {
+    case "turn_start":
+      return startTurn(view, event);
+    case "turn_end":
+      return endTurn2(view, event);
+    case "text_delta":
+      return agentTextDelta(view, event.text);
+    case "text":
+      return agentText(view, event.text);
+    case "thinking_delta":
+      return thinkingDelta(view, event);
+    case "thinking":
+      return thinkingWhole(view, event);
+    case "tool_call":
+      return announceTool2(view, event);
+    case "tool_result":
+      return settleTool2(view, event);
+    case "subagent_started":
+      return startSubagent2(view, event);
+    case "subagent_finished":
+      return finishSubagent2(view, event);
+    case "usage":
+      return reportUsage2(view, event);
+    case "message_queued":
+      return queueMessage(view, event);
+    case "message_removed":
+      return unqueueMessage(view, event);
+    case "error":
+      return appendOutput(view, null, (id) => settledMessage(id, "error", event.message));
+    case "approval_requested":
+      return requestApproval2(view, event);
+    case "approval_decided":
+      return decideApproval2(view, event);
+    case "approval_withdrawn":
+      return settleApproval2(view, event.approvalId, (block) => ({ ...block, status: "withdrawn" }));
+    default:
+      return view;
+  }
+}
+function replayTaskLog(events, from = EMPTY_TASK_LOG) {
+  return events.reduce(reduceTaskLog, from);
+}
+
+// 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}"`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CHECKPOINT_TRUNCATE_LENGTH,
+  EMPTY_CONVERSATION,
+  EMPTY_HOLD,
+  EMPTY_TASK_LOG,
+  NO_TURN,
+  aheadOfDraft,
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
   capConflictFiles,
   dependencyCandidates,
   dependentsOf,
+  drainNext,
+  followTurn,
+  fromTranscript,
+  hasHiddenDetail,
+  holdPrompt,
+  outputLines,
+  outputPreview,
+  reduceConversation,
+  reduceTaskLog,
+  replayTaskLog,
+  runnerToolSubject,
+  stopTurn,
   summarizeToolCall,
-  truncateCheckpointSummary
+  taskStartedNotice,
+  toolHeadline,
+  truncateCheckpointSummary,
+  unsendAll,
+  unsendLatest
 });
 //# sourceMappingURL=plan-utils.js.map