@ordewell/core 0.10.5 → 0.10.7

package/dist/plan-utils.js

@@ -36,6 +36,7 @@ __export(plan_utils_exports, {
   EMPTY_HOLD: () => EMPTY_HOLD,
   EMPTY_RUN: () => EMPTY_RUN,
   EMPTY_TASK_LOG: () => EMPTY_TASK_LOG,
+  EMPTY_TASK_LOG_FOLLOW: () => EMPTY_TASK_LOG_FOLLOW,
   NOT_STARTED: () => NOT_STARTED,
   NO_TURN: () => NO_TURN,
   SUPERVISOR_LEVEL_LABEL: () => SUPERVISOR_LEVEL_LABEL,
@@ -56,6 +57,7 @@ __export(plan_utils_exports, {
   canSetDependencies: () => canSetDependencies,
   canSplitTask: () => canSplitTask,
   capConflictFiles: () => capConflictFiles,
+  clampThinkingEffort: () => clampThinkingEffort,
   countedSessionCost: () => countedSessionCost,
   dependencyCandidates: () => dependencyCandidates,
   dependentsNotice: () => dependentsNotice,
@@ -65,6 +67,7 @@ __export(plan_utils_exports, {
   diffSummary: () => diffSummary,
   drainNext: () => drainNext,
   endAttemptUsage: () => endAttemptUsage,
+  followTaskLog: () => followTaskLog,
   followTurn: () => followTurn,
   fromTranscript: () => fromTranscript,
   hasHiddenDetail: () => hasHiddenDetail,
@@ -92,6 +95,7 @@ __export(plan_utils_exports, {
   reduceTaskLog: () => reduceTaskLog,
   replayTaskLog: () => replayTaskLog,
   resolveTaskRef: () => resolveTaskRef,
+  resolveUserTaskRef: () => resolveUserTaskRef,
   resumeLabel: () => resumeLabel,
   resumeTime: () => resumeTime,
   resumedSessionWindow: () => resumedSessionWindow,
@@ -100,9 +104,11 @@ __export(plan_utils_exports, {
   skippedLabel: () => skippedLabel,
   startAttemptUsage: () => startAttemptUsage,
   stopTurn: () => stopTurn,
+  subtreeIds: () => subtreeIds,
   summarizeToolCall: () => summarizeToolCall,
   takeAt: () => takeAt,
   taskOrderLabel: () => taskOrderLabel,
+  taskPlacement: () => taskPlacement,
   taskRef: () => taskRef,
   taskRefOf: () => taskRefOf,
   taskRowActions: () => taskRowActions,
@@ -117,7 +123,8 @@ __export(plan_utils_exports, {
   truncateCheckpointSummary: () => truncateCheckpointSummary,
   unsendAll: () => unsendAll,
   unsendLatest: () => unsendLatest,
-  usageLine: () => usageLine
+  usageLine: () => usageLine,
+  walkPlan: () => walkPlan
 });
 module.exports = __toCommonJS(plan_utils_exports);
 
@@ -143,6 +150,90 @@ function loadedSkillTokens(text2, loaded) {
   return skillTokens(text2).filter((t) => loaded.includes(t.name));
 }
 
+// src/services/PlanTree.ts
+function* walkPlan(tasks) {
+  function* walk(level, ancestors, parentLabel) {
+    for (const task of level) {
+      const label = parentLabel ? `${parentLabel}.${task.order}` : String(task.order);
+      yield { task, parent: ancestors.at(-1), ancestors, siblings: level, label };
+      yield* walk(task.subtasks ?? [], [...ancestors, task], label);
+    }
+  }
+  yield* walk(tasks, []);
+}
+function taskPlacement(tasks, id) {
+  for (const row of walkPlan(tasks)) if (row.task.id === id) return row;
+  return void 0;
+}
+function subtreeIds(tasks, id) {
+  const found = taskPlacement(tasks, id);
+  return new Set(found ? [...walkPlan([found.task])].map(({ task }) => task.id) : []);
+}
+function dependencyCandidates(tasks, taskId) {
+  if (!taskId) return [...tasks];
+  const found = taskPlacement(tasks, taskId);
+  return found ? found.siblings.filter((t) => t.order < found.task.order) : [];
+}
+function dependentsOf(tasks, taskId) {
+  const removed = subtreeIds(tasks, taskId);
+  return [...walkPlan(tasks)].map(({ task }) => task).filter((t) => !removed.has(t.id) && t.dependencies.some((id) => removed.has(id)));
+}
+function dependencyTargetErrors(tasks, taskId, dependencies) {
+  const found = taskPlacement(tasks, taskId);
+  if (!found) return ["Task not found"];
+  const descendants = subtreeIds(tasks, taskId);
+  const errors = [];
+  for (const dep of dependencies) {
+    if (dep === taskId) {
+      errors.push(`"${found.task.title}" cannot depend on itself`);
+      continue;
+    }
+    const target = taskPlacement(tasks, dep)?.task;
+    if (!target) {
+      errors.push(`Unknown dependency "${dep}"`);
+      continue;
+    }
+    if (found.ancestors.some((t) => t.id === dep) || descendants.has(dep)) {
+      errors.push(`"${found.task.title}" cannot depend on "${target.title}", its ancestor or descendant`);
+    }
+  }
+  return errors;
+}
+function findDependencyCycle(tasks) {
+  const byId = new Map([...walkPlan(tasks)].map(({ task }) => [task.id, task]));
+  const path = [];
+  const done = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (done.has(id)) return null;
+    const at = path.indexOf(id);
+    if (at >= 0) return path.slice(at);
+    path.push(id);
+    for (const dep of byId.get(id)?.dependencies ?? []) {
+      const hit = visit(dep);
+      if (hit) return hit;
+    }
+    path.pop();
+    done.add(id);
+    return null;
+  };
+  for (const id of byId.keys()) {
+    const hit = visit(id);
+    if (hit) return hit.map((key) => byId.get(key));
+  }
+  return null;
+}
+function canSetDependencies(tasks, taskId, dependencies) {
+  const [error] = dependencyTargetErrors(tasks, taskId, dependencies);
+  if (error) return { ok: false, error };
+  const replace = (level) => level.map((t) => ({
+    ...t,
+    dependencies: t.id === taskId ? dependencies : t.dependencies,
+    subtasks: replace(t.subtasks ?? [])
+  }));
+  const cycle = findDependencyCycle(replace(tasks));
+  return cycle ? { ok: false, error: `Dependency cycle detected: ${[...cycle, cycle[0]].map((t) => `"${t.title}"`).join(" \u2192 ")}` } : { ok: true };
+}
+
 // src/services/TaskRefs.ts
 function taskOrderLabel(task, parent) {
   return parent ? `${parent.label ?? parent.order}.${task.order}` : String(task.order);
@@ -153,16 +244,8 @@ function taskRef(task, parent) {
 function titledTaskRef(task, parent) {
   return `${taskRef(task, parent)} ${task.title}`;
 }
-function* depthFirst(tasks, parent, parentLabel) {
-  for (const task of tasks) {
-    const label = taskOrderLabel(task, parent ? { order: parent.order, label: parentLabel } : void 0);
-    yield { task, parent, label };
-    yield* depthFirst(task.subtasks ?? [], task, label);
-  }
-}
 function findTaskRef(tasks, id) {
-  for (const match of depthFirst(tasks)) if (match.task.id === id) return match;
-  return void 0;
+  return taskPlacement(tasks, id);
 }
 function taskRefOf(tasks, id) {
   const found = findTaskRef(tasks, id);
@@ -175,7 +258,7 @@ function titledTaskRefOf(tasks, id) {
 function resolveTaskRef(tasks, ref) {
   const s = String(ref).trim();
   if (!s) return void 0;
-  for (const { task } of depthFirst(tasks)) if (task.id === s) return task;
+  for (const { task } of walkPlan(tasks)) if (task.id === s) return task;
   const label = s.startsWith("#") ? s.slice(1) : s;
   if (/^\d+(\.\d+)*$/.test(label)) {
     let level = tasks;
@@ -186,9 +269,16 @@ function resolveTaskRef(tasks, ref) {
     }
     return found;
   }
-  for (const { task } of depthFirst(tasks)) if (task.title === s) return task;
+  for (const { task } of walkPlan(tasks)) if (task.title === s) return task;
   return void 0;
 }
+function resolveUserTaskRef(tasks, ref) {
+  const found = resolveTaskRef(tasks, ref);
+  if (found) return found;
+  const prefix = String(ref).trim();
+  const matches = prefix ? [...walkPlan(tasks)].filter(({ task }) => task.id.startsWith(prefix)) : [];
+  return matches.length === 1 ? matches[0].task : void 0;
+}
 
 // src/models/Task.ts
 var SKILL_NAME = new RegExp(`^${SKILL_NAME_PATTERN}$`);
@@ -200,20 +290,6 @@ function pausedOnLimit(task) {
 // src/services/TaskOps.ts
 var import_uuid3 = require("uuid");
 
-// src/services/ModelAllowlistResolver.ts
-function effectiveAllowlist(allowlist, runner, modelsByRunner) {
-  if (!allowlist || allowlist.length === 0) return void 0;
-  if (!modelsByRunner) return allowlist;
-  const own = new Set((modelsByRunner[runner] ?? []).map((m) => m.modelId));
-  const elsewhere = /* @__PURE__ */ new Set();
-  for (const [other, models] of Object.entries(modelsByRunner)) {
-    if (other === runner) continue;
-    for (const m of models ?? []) elsewhere.add(m.modelId);
-  }
-  const kept = allowlist.filter((id) => own.has(id) || !elsewhere.has(id));
-  return kept.length > 0 ? kept : void 0;
-}
-
 // src/taskRow/status.ts
 var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
 var NOT_STARTED = /* @__PURE__ */ new Set(["pending", "approved", "blocked"]);
@@ -267,28 +343,43 @@ function resumeLabel(task, now = /* @__PURE__ */ new Date()) {
 
 // src/services/PlannedTask.ts
 var import_uuid2 = require("uuid");
-function findCycle(tasks) {
-  const byId = new Map(tasks.map((t) => [t.id, t]));
-  const path = [];
-  const done = /* @__PURE__ */ new Set();
-  const visit = (id) => {
-    if (done.has(id)) return null;
-    const at = path.indexOf(id);
-    if (at >= 0) return path.slice(at);
-    path.push(id);
-    for (const dep of byId.get(id)?.dependencies ?? []) {
-      const hit = visit(dep);
-      if (hit) return hit;
-    }
-    path.pop();
-    done.add(id);
-    return null;
-  };
-  for (const t of tasks) {
-    const hit = visit(t.id);
-    if (hit) return hit.map((id) => byId.get(id));
+
+// src/services/ModelAllowlistResolver.ts
+function effectiveAllowlist(allowlist, runner, modelsByRunner) {
+  if (!allowlist || allowlist.length === 0) return void 0;
+  if (!modelsByRunner) return allowlist;
+  const own = new Set((modelsByRunner[runner] ?? []).map((m) => m.modelId));
+  const elsewhere = /* @__PURE__ */ new Set();
+  for (const [other, models] of Object.entries(modelsByRunner)) {
+    if (other === runner) continue;
+    for (const m of models ?? []) elsewhere.add(m.modelId);
   }
-  return null;
+  const kept = allowlist.filter((id) => own.has(id) || !elsewhere.has(id));
+  return kept.length > 0 ? kept : void 0;
+}
+var EFFORT_LADDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+var EFFORT_ALIASES = { disabled: "none", adaptive: "medium" };
+function clampThinkingEffort(effort, variants) {
+  if (!effort) return void 0;
+  if (variants.length === 0) return void 0;
+  const ids = new Set(variants.map((v) => v.id));
+  if (ids.has(effort)) return effort;
+  const canon = EFFORT_ALIASES[effort] ?? effort;
+  if (ids.has(canon)) return canon;
+  const idx = EFFORT_LADDER.indexOf(canon);
+  if (idx < 0) return void 0;
+  for (let d = 1; d < EFFORT_LADDER.length; d++) {
+    const lower = EFFORT_LADDER[idx - d];
+    if (lower && ids.has(lower)) return lower;
+    const higher = EFFORT_LADDER[idx + d];
+    if (higher && ids.has(higher)) return higher;
+  }
+  return void 0;
+}
+
+// src/services/PlannedTask.ts
+function findCycle(tasks) {
+  return findDependencyCycle(tasks);
 }
 function detectCycle(tasks) {
   return findCycle(tasks)?.[0].title ?? null;
@@ -313,28 +404,6 @@ function canMergeTasks(tasks, selectedIds) {
   if (cycle) return { ok: false, error: `Merging would create a dependency cycle involving "${cycle}"` };
   return { ok: true };
 }
-function dependentsOf(tasks, taskId) {
-  return tasks.filter((t) => t.id !== taskId && t.dependencies.includes(taskId));
-}
-function dependencyCandidates(tasks, taskId) {
-  if (!taskId) return [...tasks];
-  const target = tasks.find((t) => t.id === taskId);
-  return target ? tasks.filter((t) => t.order < target.order) : [];
-}
-function canSetDependencies(tasks, taskId, dependencies) {
-  const target = tasks.find((t) => t.id === taskId);
-  if (!target) return { ok: false, error: "Task not found" };
-  const allowed = new Set(dependencyCandidates(tasks, taskId).map((t) => t.id));
-  for (const dep of dependencies) {
-    if (dep === taskId) return { ok: false, error: `"${target.title}" cannot depend on itself` };
-    const found = tasks.find((t) => t.id === dep);
-    if (!found) return { ok: false, error: `Unknown dependency "${dep}"` };
-    if (!allowed.has(dep)) {
-      return { ok: false, error: `"${target.title}" cannot depend on "${found.title}", which comes after it in the plan` };
-    }
-  }
-  return { ok: true };
-}
 function canSplitTask(tasks, taskId) {
   const target = tasks.find((t) => t.id === taskId);
   if (!target) return { ok: false, error: "Task not found" };
@@ -657,7 +726,7 @@ function planMarker(content) {
 }
 
 // src/services/blocking.ts
-var UNSTARTED = /* @__PURE__ */ new Set(["pending", "approved", "blocked"]);
+var UNSTARTED = /* @__PURE__ */ new Set(["pending", "approved"]);
 function blockingFailures(tasks) {
   const byId = /* @__PURE__ */ new Map();
   const index = (list) => {
@@ -1032,8 +1101,9 @@ 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, supervisor }) {
+function settleReply(view, { content, turnId, supervisor, runs }) {
   const role = supervisor ? "supervisor" : "planner";
+  if (runs) return settleRuns(view, runs, role, turnId);
   if (turnId !== void 0) {
     const i = finalSegmentIndex(view.blocks, turnId);
     if (i >= 0) {
@@ -1042,6 +1112,25 @@ function settleReply(view, { content, turnId, supervisor }) {
   }
   return append(dropBuildingPlan(view, turnId), (id) => settledMessage(id, role, content, turnId));
 }
+function settleRuns(view, runs, role, turnId) {
+  const settled = /* @__PURE__ */ new Map();
+  let turn = turnId;
+  for (const run of runs) {
+    const i = view.blocks.findIndex((b) => b.type === "message" && b.segmentId === run.segmentId && b.turnId !== void 0 && (turnId === void 0 || b.turnId === turnId));
+    const segment = view.blocks[i];
+    if (segment?.type !== "message") continue;
+    settled.set(i, run);
+    turn ??= segment.turnId;
+  }
+  const contained = new Set(runs.map((run) => run.segmentId));
+  const blocks = view.blocks.flatMap((block, i) => {
+    const run = settled.get(i);
+    if (run) return [settledMessage(block.id, role, run.text, turn)];
+    return turn !== void 0 && isUnsettledSegment(block, turn) && !contained.has(block.segmentId) ? [] : [block];
+  });
+  const streamed = new Set(settled.values());
+  return runs.filter((run) => !streamed.has(run)).reduce((next, run) => append(next, (id) => settledMessage(id, role, run.text, turn)), dropBuildingPlan({ ...view, blocks }, turn));
+}
 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);
@@ -1318,7 +1407,7 @@ function fromTranscript(conversationHistory, researchLog, plannerUsage, pendingT
   const kept = compacted ? history.slice(1) : history;
   const cutoff = compacted ? kept[0]?.timestamp ?? compacted.timestamp : "";
   const placed = [
-    ...kept.map((entry, i) => ({ at: entry.timestamp, rank: rankOf(entry), build: fromEntry(entry, loadsAfter(kept, i)) })),
+    ...kept.flatMap((entry, i) => entry.runs ? entry.runs.map((run) => ({ at: run.startedAt, rank: SETTLED, build: (id2) => settledMessage(id2(), roleOf(entry), run.text) })) : [{ at: entry.timestamp, rank: rankOf(entry), build: fromEntry(entry, loadsAfter(kept, i)) }]),
     ...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);
@@ -1351,7 +1440,7 @@ function sameMessage(a, b) {
 
 // src/conversation/taskLog.ts
 var EMPTY_TASK_LOG = { blocks: [], nextId: 1, queued: [], working: false, streams: {} };
-var TEXT_STREAM = "text";
+var textStream = (runId) => runId === void 0 ? "text" : `text:${runId}`;
 var thinkingStream = (subagentId) => `thinking:${subagentId ?? ""}`;
 function withoutStream(view, key) {
   if (!(key in view.streams)) return view;
@@ -1368,35 +1457,43 @@ function openStream(view, lane, key) {
   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);
+function streamBlock(view, lane, key) {
+  const id = view.streams[key];
+  return id === void 0 ? -1 : findLastIndex(laneBlocks(view, lane), (b) => b.id === id);
+}
+function streamDelta(view, lane, key, text2, make, anywhere = false) {
+  const i = anywhere ? streamBlock(view, lane, key) : 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 i = streamBlock(view, lane, key);
+  const streamed = laneBlocks(view, lane)[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) {
-  const next = streamWhole(view, null, TEXT_STREAM, text2, (id) => settledMessage(id, "agent", blockText(text2)));
-  return { ...next, latestText: next.nextId > view.nextId ? `b${view.nextId}` : view.streams[TEXT_STREAM] };
+function openedText(view, next) {
+  return next.nextId > view.nextId ? { ...next, latestText: `b${view.nextId}` } : next;
 }
-function agentTextDelta(view, text2) {
-  const next = streamDelta(view, null, TEXT_STREAM, text2, (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true }));
-  return { ...next, latestText: next.streams[TEXT_STREAM] };
+function agentText(view, { runId, text: text2 }) {
+  return openedText(view, streamWhole(view, null, textStream(runId), text2, (id) => settledMessage(id, "agent", blockText(text2))));
+}
+function agentTextDelta(view, { runId, text: text2 }) {
+  const make = (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true });
+  return openedText(view, streamDelta(view, null, textStream(runId), text2, make, runId !== void 0));
 }
 function failTurn(view, message) {
   const repeated = view.blocks.find((b) => b.id === view.latestText);
-  const settled = repeated?.type === "message" && repeated.role === "agent" && sameMessage(repeated.text, message) ? withoutStream({ ...view, blocks: view.blocks.filter((b) => b !== repeated) }, TEXT_STREAM) : view;
+  const settled = repeated?.type === "message" && repeated.role === "agent" && sameMessage(repeated.text, message) ? {
+    ...view,
+    blocks: view.blocks.filter((b) => b !== repeated),
+    streams: Object.fromEntries(Object.entries(view.streams).filter(([, id]) => id !== repeated.id))
+  } : view;
   return appendOutput({ ...settled, latestText: void 0 }, null, (id) => settledMessage(id, "error", message));
 }
 function thinkingBlock(id, text2, streaming, subagentId) {
@@ -1577,7 +1674,7 @@ function endCall(block) {
 function endOpenCalls(view) {
   let changed = false;
   const blocks = view.blocks.map((block) => {
-    const ended = block.type === "subagent" ? block.children.some((c) => c.type === "tool" && c.status === "pending") ? { ...block, children: block.children.map(endCall) } : block : block.type === "tool" ? endCall(block) : block;
+    const ended = block.type === "subagent" ? block.children.some((c) => c.type === "tool" && c.status === "pending") ? { ...block, children: block.children.map(endCall) } : block : block.type === "tool" ? endCall(block) : block.type === "command" && block.status === "running" ? { ...block, status: "stopped" } : block;
     if (ended !== block) changed = true;
     return ended;
   });
@@ -1608,9 +1705,9 @@ function reduceTaskLog(view, event) {
     case "turn_end":
       return endTurn2(view, event);
     case "text_delta":
-      return agentTextDelta(view, event.text);
+      return agentTextDelta(view, event);
     case "text":
-      return agentText(view, event.text);
+      return agentText(view, event);
     case "thinking_delta":
       return thinkingDelta(view, event);
     case "thinking":
@@ -1644,7 +1741,7 @@ function reduceTaskLog(view, event) {
     case "approval_withdrawn":
       return settleApproval2(view, event.approvalId, (block) => ({ ...block, status: "withdrawn" }));
     case "runner_ended":
-      return endOpenCalls(view);
+      return closeOpenBlocks({ ...endOpenCalls(view), working: false, streams: {}, latestText: void 0 }, "stopped");
     default:
       return view;
   }
@@ -1699,16 +1796,16 @@ function cutOff(gate, input) {
   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 withGate(live2, gate) {
+  return gate.open === live2.gate.open && gate.stopped === live2.gate.stopped ? live2 : { ...live2, gate };
 }
 function followTurn(view, gate, input) {
-  const live = { view, gate };
+  const live2 = { 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;
+    return input.type === "planner_turn_ended" ? withGate(live2, { ...gate, stopped: null }) : live2;
   }
   const next = { view: reduceConversation(view, input), gate };
   return input.type === "planner_turn_ended" && input.turnId === gate.open ? withGate(next, { ...gate, open: null }) : next;
@@ -1761,6 +1858,60 @@ function markdownHtml(text2) {
   return md.render(text2);
 }
 
+// src/conversation/taskLogFollow.ts
+var EMPTY_TASK_LOG_FOLLOW = {
+  view: EMPTY_TASK_LOG,
+  attempts: [],
+  attempt: 0,
+  pending: [],
+  loaded: false,
+  followLatest: true
+};
+function covered(position, batch) {
+  return !!position && !!batch.position && position.stream === batch.position.stream && batch.position.seq <= position.seq;
+}
+function live(state, batch) {
+  if (batch.attempt <= 0 || batch.attempt < state.attempt) return state;
+  const attempts = state.attempts.includes(batch.attempt) ? state.attempts : [...state.attempts, batch.attempt].sort((a, b) => a - b);
+  if (batch.attempt > state.attempt) {
+    if (!state.followLatest) return attempts === state.attempts ? state : { ...state, attempts };
+    return { ...state, attempts, attempt: batch.attempt, position: void 0, view: batch.events.reduce(reduceTaskLog, EMPTY_TASK_LOG) };
+  }
+  if (covered(state.position, batch)) return state;
+  return { ...state, attempts, view: batch.events.reduce(reduceTaskLog, state.view) };
+}
+function followTaskLog(state, input) {
+  switch (input.type) {
+    case "opened":
+      return EMPTY_TASK_LOG_FOLLOW;
+    case "picked":
+      return { ...state, loaded: false, loadingAttempt: input.attempt, followLatest: input.attempt === state.attempts.at(-1) };
+    case "live":
+      return state.loaded ? live(state, input) : { ...state, pending: [...state.pending, input] };
+    case "loaded": {
+      if (state.loaded) return state;
+      if (!input.abandoned && state.loadingAttempt !== void 0 && input.attempt !== state.loadingAttempt) return state;
+      const attempts = [.../* @__PURE__ */ new Set([...input.attempts ?? state.attempts, ...state.pending.map((batch) => batch.attempt)])].filter((attempt) => attempt > 0).sort((a, b) => a - b);
+      let next = {
+        ...state,
+        attempts,
+        loaded: true,
+        pending: [],
+        loadingAttempt: void 0,
+        ...input.abandoned ? {} : { attempt: input.attempt, view: replayTaskLog(input.events), position: input.position }
+      };
+      for (const batch of state.pending) {
+        if (!input.abandoned && batch.attempt === input.attempt) {
+          if (covered(input.position, batch)) continue;
+          if (!input.position && !batch.position) continue;
+        }
+        next = live(next, batch);
+      }
+      return next;
+    }
+  }
+}
+
 // src/taskRow/actions.ts
 var UNSTARTED_AI = (t) => t.type === "ai" && NOT_STARTED.has(t.status);
 var QUEUED = (t) => t.status === "pending" || t.status === "approved";
@@ -1883,10 +2034,10 @@ function taskRowView(task, context = {}) {
 function titledRefs(ids, tasks) {
   return ids.map((id) => titledTaskRefOf(tasks, id) ?? id);
 }
-function dependentsNotice(dependents) {
+function dependentsNotice(dependents, tasks = []) {
   if (dependents.length === 0) return null;
   const subject = dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`;
-  return `${subject} on it and will lose that dependency: ${dependents.map((t) => titledTaskRef(t)).join(", ")}.`;
+  return `${subject} on it and will lose that dependency: ${dependents.map((t) => (t.id ? titledTaskRefOf(tasks, t.id) : void 0) ?? titledTaskRef(t)).join(", ")}.`;
 }
 function pastGateConfirmation(unmerged, subject = "This task") {
   return `${subject} waits for Merge all: the work of ${unmerged.join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task.`;
@@ -1907,6 +2058,7 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   EMPTY_HOLD,
   EMPTY_RUN,
   EMPTY_TASK_LOG,
+  EMPTY_TASK_LOG_FOLLOW,
   NOT_STARTED,
   NO_TURN,
   SUPERVISOR_LEVEL_LABEL,
@@ -1927,6 +2079,7 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   canSetDependencies,
   canSplitTask,
   capConflictFiles,
+  clampThinkingEffort,
   countedSessionCost,
   dependencyCandidates,
   dependentsNotice,
@@ -1936,6 +2089,7 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   diffSummary,
   drainNext,
   endAttemptUsage,
+  followTaskLog,
   followTurn,
   fromTranscript,
   hasHiddenDetail,
@@ -1963,6 +2117,7 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   reduceTaskLog,
   replayTaskLog,
   resolveTaskRef,
+  resolveUserTaskRef,
   resumeLabel,
   resumeTime,
   resumedSessionWindow,
@@ -1971,9 +2126,11 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   skippedLabel,
   startAttemptUsage,
   stopTurn,
+  subtreeIds,
   summarizeToolCall,
   takeAt,
   taskOrderLabel,
+  taskPlacement,
   taskRef,
   taskRefOf,
   taskRowActions,
@@ -1988,6 +2145,7 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   truncateCheckpointSummary,
   unsendAll,
   unsendLatest,
-  usageLine
+  usageLine,
+  walkPlan
 });
 //# sourceMappingURL=plan-utils.js.map