@ordewell/core 0.5.5 → 0.6.0

package/dist/plan-utils.js

@@ -23,6 +23,7 @@ __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,
@@ -39,6 +40,9 @@ __export(plan_utils_exports, {
   outputLines: () => outputLines,
   outputPreview: () => outputPreview,
   reduceConversation: () => reduceConversation,
+  reduceTaskLog: () => reduceTaskLog,
+  replayTaskLog: () => replayTaskLog,
+  runnerToolSubject: () => runnerToolSubject,
   stopTurn: () => stopTurn,
   summarizeToolCall: () => summarizeToolCall,
   taskStartedNotice: () => taskStartedNotice,
@@ -190,12 +194,35 @@ 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;
 }
@@ -325,8 +352,11 @@ var STATUS_OF_OUTCOME = {
   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 { ...call, status: STATUS_OF_OUTCOME[step.outcome], outcome: step.outcome, output: step.result, outputLineCount: outputLines(step.result).length };
+  return finishedTool(call, step.result, step.outcome);
 }
 function pendingTool(id, { tool, toolLabel, args, toolCallId, turnId }) {
   return {
@@ -351,8 +381,7 @@ function planMarker(content) {
   return { status: content.startsWith("Plan updated") ? "updated" : "generated", ...count ? { taskCount: Number(count[1]) } : {} };
 }
 
-// src/conversation/reduce.ts
-var EMPTY_CONVERSATION = { blocks: [], nextId: 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;
@@ -405,6 +434,72 @@ 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;
 }
@@ -453,30 +548,6 @@ 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 } : {} }));
 }
@@ -489,27 +560,9 @@ function finishSubagent(view, { subagentId, outcome, digest, usage, turnId }) {
     ...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];
+  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) {
@@ -517,7 +570,7 @@ function isPendingCallOf(block, step) {
   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 [placed, lane] = laneOf(view, step.subagentId, turnId);
   const blocks = laneBlocks(placed, lane);
   const i = findLastIndex(blocks, (b) => isPendingCallOf(b, step));
   const pending = blocks[i];
@@ -582,27 +635,13 @@ function decideApproval(view, { kind, subject, scope, detail, granted, source })
   }));
 }
 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 };
+  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) };
-  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 };
+  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);
@@ -749,6 +788,251 @@ function fromTranscript(conversationHistory, researchLog, plannerUsage) {
   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;
+  const working = { ...view, queued, working: true };
+  return message ? append(working, (id) => settledMessage(id, "user", message)) : working;
+}
+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) {
@@ -826,6 +1110,7 @@ function taskStartedNotice(title, runner) {
   CHECKPOINT_TRUNCATE_LENGTH,
   EMPTY_CONVERSATION,
   EMPTY_HOLD,
+  EMPTY_TASK_LOG,
   NO_TURN,
   aheadOfDraft,
   canMergeTasks,
@@ -842,6 +1127,9 @@ function taskStartedNotice(title, runner) {
   outputLines,
   outputPreview,
   reduceConversation,
+  reduceTaskLog,
+  replayTaskLog,
+  runnerToolSubject,
   stopTurn,
   summarizeToolCall,
   taskStartedNotice,