@ordewell/core 0.10.4 → 0.10.6

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,
@@ -47,6 +48,8 @@ __export(plan_utils_exports, {
   addUsageTotals: () => addUsageTotals,
   aheadOfDraft: () => aheadOfDraft,
   approvalLabel: () => approvalLabel,
+  assignmentIssue: () => assignmentIssue,
+  assignmentIssueText: () => assignmentIssueText,
   awaitingLabel: () => awaitingLabel,
   blockedByLabel: () => blockedByLabel,
   blockingFailures: () => blockingFailures,
@@ -54,6 +57,8 @@ __export(plan_utils_exports, {
   canSetDependencies: () => canSetDependencies,
   canSplitTask: () => canSplitTask,
   capConflictFiles: () => capConflictFiles,
+  clampThinkingEffort: () => clampThinkingEffort,
+  countedSessionCost: () => countedSessionCost,
   dependencyCandidates: () => dependencyCandidates,
   dependentsNotice: () => dependentsNotice,
   dependentsOf: () => dependentsOf,
@@ -62,6 +67,7 @@ __export(plan_utils_exports, {
   diffSummary: () => diffSummary,
   drainNext: () => drainNext,
   endAttemptUsage: () => endAttemptUsage,
+  followTaskLog: () => followTaskLog,
   followTurn: () => followTurn,
   fromTranscript: () => fromTranscript,
   hasHiddenDetail: () => hasHiddenDetail,
@@ -89,22 +95,27 @@ __export(plan_utils_exports, {
   reduceTaskLog: () => reduceTaskLog,
   replayTaskLog: () => replayTaskLog,
   resolveTaskRef: () => resolveTaskRef,
+  resolveUserTaskRef: () => resolveUserTaskRef,
   resumeLabel: () => resumeLabel,
   resumeTime: () => resumeTime,
+  resumedSessionWindow: () => resumedSessionWindow,
   runnerToolSubject: () => runnerToolSubject,
   skillTokens: () => skillTokens,
   skippedLabel: () => skippedLabel,
   startAttemptUsage: () => startAttemptUsage,
   stopTurn: () => stopTurn,
+  subtreeIds: () => subtreeIds,
   summarizeToolCall: () => summarizeToolCall,
   takeAt: () => takeAt,
   taskOrderLabel: () => taskOrderLabel,
+  taskPlacement: () => taskPlacement,
   taskRef: () => taskRef,
   taskRefOf: () => taskRefOf,
   taskRowActions: () => taskRowActions,
   taskRowView: () => taskRowView,
   taskStartedNotice: () => taskStartedNotice,
   taskStatusKind: () => taskStatusKind,
+  taskUsageSummary: () => taskUsageSummary,
   titledRefs: () => titledRefs,
   titledTaskRef: () => titledTaskRef,
   titledTaskRefOf: () => titledTaskRefOf,
@@ -112,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);
 
@@ -138,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);
@@ -148,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);
@@ -170,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;
@@ -181,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}$`);
@@ -230,7 +325,7 @@ function blockedByLabel(refs) {
 function skippedLabel(reason) {
   return reason ? `Skipped: ${reason}` : "Skipped";
 }
-var WAITS_FOR_APPROVAL_LABEL = "Waiting for your approval to start";
+var WAITS_FOR_APPROVAL_LABEL = "Waits for your approval";
 function approvalLabel(count) {
   if (!count) return null;
   return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
@@ -248,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;
@@ -294,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" };
@@ -638,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) => {
@@ -764,8 +852,21 @@ function addAttemptUsage(usage, record, now) {
   const folded = addPlannerUsage(usage, record);
   return { ...usage, ...folded, lastPromptTokens: folded.lastPromptTokens, contextWindow: folded.contextWindow, wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)) };
 }
-function endAttemptUsage(usage, now) {
-  return { ...usage, endedAt: now, wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)) };
+function endAttemptUsage(usage, now, runnerSessionCost, sessionId) {
+  return {
+    ...usage,
+    endedAt: now,
+    wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)),
+    ...sessionId ? { sessionId } : {},
+    ...runnerSessionCost ? { runnerSessionCost } : {}
+  };
+}
+function countedSessionCost(attempts, sessionId) {
+  return [...attempts ?? []].reverse().find((usage) => usage.runnerSessionCost?.sessionId === sessionId)?.runnerSessionCost;
+}
+function resumedSessionWindow(attempts, runner, attempt, sessionId) {
+  const last = [...attempts ?? []].reverse().find((usage) => usage.attempt !== attempt && usage.runner === runner && usage.sessionId === sessionId && usage.contextWindow !== void 0);
+  return last ? { source: last.source, model: last.model, contextWindow: last.contextWindow } : void 0;
 }
 function addUsageTotals(totals, addition) {
   let next = addUsage(totals, { source: "", inputTokens: addition.inputTokens, outputTokens: addition.outputTokens, cachedInputTokens: addition.cachedInputTokens });
@@ -794,6 +895,16 @@ function planUsage(tasks) {
   }
   return result;
 }
+function taskUsageSummary(task) {
+  const attempts = task.attemptUsage ?? [];
+  const latest = attempts.at(-1);
+  const contextFill = latest ? plannerContextFill(latest) : void 0;
+  return {
+    totals: attempts.reduce((sum, attempt) => addUsageTotals(sum, attempt.totals), {}),
+    attempts: attempts.length,
+    ...contextFill ? { contextFill } : {}
+  };
+}
 
 // src/conversation/lanes.ts
 function findLastIndex(items, match) {
@@ -990,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) {
@@ -1000,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);
@@ -1116,6 +1247,7 @@ function syncTranscript(view, { plan, turnId }) {
     if (isNew && entry.kind === "wake_up") next = takePendingInputs(next, void 0, [entry.content]).view;
     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 === "error") next = append(next, (id) => settledMessage(id, "error", entry.content));
     if (isNew && entry.kind === "compaction") next = markCompaction(next, entry.content);
     if (latest === void 0 || entry.timestamp > latest) latest = entry.timestamp;
   }
@@ -1196,6 +1328,8 @@ function roleOf(entry) {
       return "wake_up";
     case "supervisor":
       return "supervisor";
+    case "error":
+      return "error";
     default:
       return entry.role === "user" ? "user" : "planner";
   }
@@ -1273,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);
@@ -1306,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;
@@ -1323,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 agentText(view, { runId, text: text2 }) {
+  return openedText(view, streamWhole(view, null, textStream(runId), text2, (id) => settledMessage(id, "agent", blockText(text2))));
 }
-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 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) {
@@ -1481,6 +1623,12 @@ function commandOutput(view, { text: text2 }) {
   return { ...view, blocks: replaceAt(view.blocks, i, { ...block, output: block.output ? `${block.output}
 ${text2}` : text2 }) };
 }
+function modelSwitchNotice({ from, to, plan, kept }) {
+  if (!plan) return `Model changed in the runner: ${from.label ?? from.model} \u2192 ${to.label ?? to.model}${kept ? ` (${kept})` : ""}`;
+  const planned = plan.model ? `${plan.model.label ?? plan.model.model}${plan.effort ? `, ${plan.effort}` : ""}` : void 0;
+  if (!kept) return `Model changed in the runner: ${from.label ?? from.model} \u2192 ${to.label ?? to.model}; the plan now says ${planned ?? to.label ?? to.model}`;
+  return `The runner now answers on ${to.label ?? to.model}; ${planned ? `the plan still says ${planned}` : "the plan names no model"} (${kept})`;
+}
 function appendStep(view, make) {
   const next = append(view, make);
   return sealLane(next, null, findLastIndex(next.blocks, (b) => b.type !== "usage"));
@@ -1526,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;
   });
@@ -1542,6 +1690,8 @@ function reduceTaskLog(view, event) {
       return startCommand(view, event);
     case "command_output":
       return commandOutput(view, event);
+    case "model_switched":
+      return append(view, (id) => settledMessage(id, "system", modelSwitchNotice(event)));
     case "compaction":
       return appendStep(view, (id) => ({
         type: "compaction",
@@ -1555,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":
@@ -1591,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;
   }
@@ -1646,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;
@@ -1708,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";
@@ -1752,6 +1956,31 @@ function opsEditable(task) {
   return UNSTARTED_AI(task);
 }
 
+// src/services/AssignmentScope.ts
+var OVER = /* @__PURE__ */ new Set(["completed", "skipped"]);
+function assignmentIssue(task, scope) {
+  if (task.type !== "ai" || OVER.has(task.status)) return null;
+  if (!scope.enabledRunners.includes(task.assignedRunner)) return { kind: "runner-off", runner: task.assignedRunner };
+  const model = task.assignedModel;
+  const allowed = effectiveAllowlist(scope.allowlist[task.assignedRunner], task.assignedRunner, scope.models);
+  if (model && allowed && !allowed.includes(model.modelId)) {
+    return { kind: "model-off-list", runner: task.assignedRunner, modelId: model.modelId, modelLabel: model.modelLabel || model.modelId };
+  }
+  return null;
+}
+function assignmentIssueText(issue) {
+  return issue.kind === "runner-off" ? `${issue.runner} is switched off` : `${issue.modelLabel} is not in the allowlist`;
+}
+function assignmentConsequence({ status, awaitingReason, resumeAt }) {
+  if (status === "failed") return "failed; a retry would run it there unless moved";
+  if (status === "awaiting_user" && awaitingReason === "usage-limit") {
+    return resumeAt ? "paused on a usage limit; resumes there at the reset unless moved" : "paused on a usage limit; a retry would run it there unless moved";
+  }
+  if (status === "awaiting_user" && (awaitingReason === "conflict" || awaitingReason === "files-changed")) return "waiting for the user; what runs next runs there unless moved";
+  if (status === "in_progress" || status === "awaiting_user") return "already running as assigned";
+  return "runs as assigned unless moved";
+}
+
 // src/taskRow/view.ts
 var refsOf = (ids, tasks) => ids.map((id) => tasks?.length ? taskRefOf(tasks, id) ?? id : id);
 var namedRepo = (repo) => repo && repo !== "." ? repo : null;
@@ -1762,13 +1991,18 @@ function blockedBy(task, tasks) {
   if (!tasks?.length || !NOT_STARTED.has(task.status)) return [];
   return blockingFailures(asBlocking(tasks)).get(task.id) ?? [];
 }
+function flagOf(task, scope) {
+  const issue = scope && task.assignedRunner !== void 0 ? assignmentIssue({ ...task, assignedRunner: task.assignedRunner }, scope) : null;
+  return issue ? { assignmentFlag: assignmentIssueText(issue), assignmentConsequence: assignmentConsequence(task) } : { assignmentFlag: null, assignmentConsequence: null };
+}
 function taskRowView(task, context = {}) {
   const parent = context.parent ?? void 0;
   const isolation = task.isolation && task.isolation.state !== "none" ? task.isolation : null;
-  const latestUsage = task.attemptUsage?.at(-1);
+  const spend = taskUsageSummary(task);
+  const latestAttempt = task.attemptUsage?.at(-1);
   const blocked = blockedBy(task, context.tasks);
   return {
-    usage: latestUsage ? { ...usageLine(latestUsage), attempt: latestUsage.attempt, wallTimeMs: latestUsage.wallTimeMs, byModel: latestUsage.byModel } : task.type === "ai" && ["completed", "failed", "in_progress", "awaiting_user"].includes(task.status) ? { totals: {}, attempt: 0, byModel: [] } : null,
+    usage: latestAttempt ? { totals: spend.totals, ...spend.contextFill ? { contextFill: spend.contextFill } : {}, attempt: latestAttempt.attempt } : task.type === "ai" && ["completed", "failed", "in_progress", "awaiting_user"].includes(task.status) ? { totals: {}, attempt: 0 } : null,
     orderLabel: taskOrderLabel(task, parent),
     kind: task.type === "user" ? "user" : task.ops ? "ops" : "ai",
     status: blocked.length > 0 ? "blocked" : taskStatusKind(task),
@@ -1777,6 +2011,7 @@ function taskRowView(task, context = {}) {
     resumes: resumeLabel(task, context.now),
     approvals: approvalLabel(task.awaitingApproval),
     waitsForApproval: task.waitsForApproval && NOT_STARTED.has(task.status) ? WAITS_FOR_APPROVAL_LABEL : null,
+    ...flagOf(task, context.runnerScope),
     autonomous: task.type === "ai" && context.modes?.find((m) => m.id === task.taskMode)?.autonomous === true,
     repos: namedRepos(isolation?.repos),
     conflict: isolation?.state === "conflict" ? { repo: namedRepo(isolation.conflictRepo), files: filesOf(isolation.conflictFiles) } : null,
@@ -1799,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.`;
@@ -1823,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,
@@ -1834,6 +2070,8 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   addUsageTotals,
   aheadOfDraft,
   approvalLabel,
+  assignmentIssue,
+  assignmentIssueText,
   awaitingLabel,
   blockedByLabel,
   blockingFailures,
@@ -1841,6 +2079,8 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   canSetDependencies,
   canSplitTask,
   capConflictFiles,
+  clampThinkingEffort,
+  countedSessionCost,
   dependencyCandidates,
   dependentsNotice,
   dependentsOf,
@@ -1849,6 +2089,7 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   diffSummary,
   drainNext,
   endAttemptUsage,
+  followTaskLog,
   followTurn,
   fromTranscript,
   hasHiddenDetail,
@@ -1876,22 +2117,27 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   reduceTaskLog,
   replayTaskLog,
   resolveTaskRef,
+  resolveUserTaskRef,
   resumeLabel,
   resumeTime,
+  resumedSessionWindow,
   runnerToolSubject,
   skillTokens,
   skippedLabel,
   startAttemptUsage,
   stopTurn,
+  subtreeIds,
   summarizeToolCall,
   takeAt,
   taskOrderLabel,
+  taskPlacement,
   taskRef,
   taskRefOf,
   taskRowActions,
   taskRowView,
   taskStartedNotice,
   taskStatusKind,
+  taskUsageSummary,
   titledRefs,
   titledTaskRef,
   titledTaskRefOf,
@@ -1899,6 +2145,7 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   truncateCheckpointSummary,
   unsendAll,
   unsendLatest,
-  usageLine
+  usageLine,
+  walkPlan
 });
 //# sourceMappingURL=plan-utils.js.map