@ordewell/core 0.5.4 → 0.5.5

package/dist/index.mjs

@@ -13,9 +13,15 @@ import {
   resolveTaskMode,
   runnerModesFrom,
   validatePlanModification
-} from "./chunk-XWOUIA6A.mjs";
+} from "./chunk-UUBGVCGJ.mjs";
 import {
   CHECKPOINT_TRUNCATE_LENGTH,
+  EMPTY_CONVERSATION,
+  EMPTY_HOLD,
+  NO_TURN,
+  addPlannerUsage,
+  addUsage,
+  aheadOfDraft,
   applyTaskOps,
   canMergeTasks,
   canSetDependencies,
@@ -25,19 +31,41 @@ import {
   coerceAssignments,
   dependencyCandidates,
   dependentsOf,
+  drainNext,
   effectiveAllowlist,
   executionSummary,
   filterModelsForPrompt,
+  flattenTerminalOutput,
+  followTurn,
+  fromTranscript,
+  hasHiddenDetail,
+  holdPrompt,
+  isMeasured,
+  outputLines,
+  outputPreview,
   parseTaskOpsJson,
+  partedPromptUsage,
+  plannerContextFill,
+  reduceConversation,
+  refMatchesTask,
+  renderCleanCapture,
+  renderTerminalOutput,
   serializePlan,
   serializeTask,
   serializeTaskStatus,
+  stopTurn,
   summarizeToolCall,
+  taskOpRefs,
   taskOpsProtocol,
+  taskStartedNotice,
   textHasTaskOps,
+  toolHeadline,
   truncateCheckpointSummary,
+  unsendAll,
+  unsendLatest,
+  usageLine,
   validateTaskEdit
-} from "./chunk-GWPIYDQW.mjs";
+} from "./chunk-KLN7ELXO.mjs";
 import {
   PLAN_ENVELOPE_KEY,
   PlanParseError,
@@ -53,9 +81,11 @@ import {
   extractObjectsWithKey,
   flattenTasks,
   flattenTasksWithParents,
+  keepExecutionState,
   migrateLegacyPlan,
   migratePlanState,
   migrateTask,
+  opensWithJsonObject,
   removeTaskFromPlan,
   renumberTasks,
   stripModelNoise,
@@ -63,7 +93,7 @@ import {
   updateTaskInPlan,
   validateModifiedPlan,
   warningsText
-} from "./chunk-JVMDEHRQ.mjs";
+} from "./chunk-HD2FWPRV.mjs";
 import {
   resolveOrderLabel,
   taskOrderLabel
@@ -1628,7 +1658,9 @@ var POSIX_DIALECT = {
   escape: "\\",
   escapeInQuotes: true,
   quotes: ["'", '"'],
-  expansion: /^\$[A-Za-z_{]/,
+  // Positional and special parameters (`$1`, `$@`, `$$`, …) expand too.
+  expansion: /^\$[A-Za-z_{0-9@*#?$!-]/,
+  dollarQuotes: true,
   strippedExtensions: []
 };
 var CMD_DIALECT = {
@@ -1637,6 +1669,7 @@ var CMD_DIALECT = {
   quotes: ['"'],
   // `%VAR%` and delayed-expansion `!VAR!`.
   expansion: /^[%!][A-Za-z_]/,
+  dollarQuotes: false,
   // Without this, `del.exe` and `C:\bin\del.exe` both missed the refusal list.
   strippedExtensions: [".exe", ".cmd", ".bat", ".com", ".ps1", ".msc"]
 };
@@ -1675,7 +1708,11 @@ function lex(command, nested, dialect) {
   let quote = "";
   let redirectTargetMode = false;
   let redirectOperator = "";
+  let braceOpen = false;
+  let braceList = false;
   const endToken = (hardBoundary = true) => {
+    braceOpen = false;
+    braceList = false;
     if (redirectTargetMode) {
       if (!started && !hardBoundary) return;
       if (!unsafeRedirect && !isDevNullTarget(current)) {
@@ -1727,7 +1764,9 @@ function lex(command, nested, dialect) {
         break;
       }
       nested.push(command.slice(i + 2, close));
+      current += command.slice(i, close + 1);
       started = true;
+      expandable = true;
       i = close + 1;
       continue;
     }
@@ -1738,10 +1777,19 @@ function lex(command, nested, dialect) {
         break;
       }
       nested.push(command.slice(i + 1, close));
+      current += command.slice(i, close + 1);
       started = true;
+      expandable = true;
       i = close + 1;
       continue;
     }
+    if (dialect.dollarQuotes && quote === "" && c === "$" && (command[i + 1] === "'" || command[i + 1] === '"')) {
+      expandable = true;
+      current += c;
+      started = true;
+      i++;
+      continue;
+    }
     if (dialect.expansion.test(command.slice(i, i + 2))) {
       expandable = true;
       current += c;
@@ -1811,7 +1859,7 @@ function lex(command, nested, dialect) {
     if (c === "|") {
       const double = command[i + 1] === "|";
       endSegment(!double);
-      i += double ? 2 : 1;
+      i += double || command[i + 1] === "&" ? 2 : 1;
       continue;
     }
     if (c === "&" || c === ";" || c === "\n") {
@@ -1824,6 +1872,9 @@ function lex(command, nested, dialect) {
       i++;
       continue;
     }
+    if (c === "{") braceOpen = true;
+    else if (braceOpen && (c === "," || c === "." && command[i + 1] === ".")) braceList = true;
+    else if (braceOpen && braceList && c === "}") expandable = true;
     current += c;
     started = true;
     i++;
@@ -1839,6 +1890,11 @@ function binaryName(token, dialect) {
   return dialect.strippedExtensions.includes(base.slice(dot).toLowerCase()) ? base.slice(0, dot) : base;
 }
 var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+function isComputedWord(token, dialect) {
+  if (/[$`]/.test(token) || /\{[^{}]*(?:,|\.\.)[^{}]*\}/.test(token)) return true;
+  for (let i = 0; i < token.length; i++) if (dialect.expansion.test(token.slice(i, i + 2))) return true;
+  return false;
+}
 function toSegment(tokens, piped, dialect) {
   const rest = [...tokens];
   const assignments = [];
@@ -1848,7 +1904,8 @@ function toSegment(tokens, piped, dialect) {
     args: rest.slice(1),
     assignments,
     piped,
-    expandable: false
+    expandable: false,
+    ...rest.length > 0 && isComputedWord(rest[0], dialect) ? { computedBinary: rest[0] } : {}
   };
 }
 function joinedShortFlag(list, token) {
@@ -1940,7 +1997,7 @@ function lexAll(command, dialect) {
 }
 function looksLikePath(arg) {
   if (arg.startsWith("--") && arg.includes("=")) return looksLikePath(arg.slice(arg.indexOf("=") + 1));
-  return arg.startsWith("/") || arg.startsWith("~") || arg.startsWith("../") || arg === ".." || arg.startsWith("./") || /^[A-Za-z]:/.test(arg) || arg.startsWith("\\") || arg.startsWith("..\\") || arg.startsWith(".\\");
+  return arg.startsWith("/") || arg.startsWith("~") || arg.startsWith("../") || arg === ".." || arg.startsWith("./") || /^[A-Za-z]:/.test(arg) || arg.startsWith("\\") || arg.startsWith("..\\") || arg.startsWith(".\\") || /(^|[\\/])\.\.([\\/]|$)/.test(arg);
 }
 function pathLikeArgs(command, opts = {}) {
   const dialect = dialectFor(opts.dialect);
@@ -1949,9 +2006,18 @@ function pathLikeArgs(command, opts = {}) {
       const v = a.slice(a.indexOf("=") + 1);
       return looksLikePath(v) ? [v] : [];
     }
-    return !a.startsWith("-") && looksLikePath(a) ? [a] : [];
+    if (a.startsWith("-")) {
+      const glued = gluedValue(a);
+      return glued ? [glued] : [];
+    }
+    return looksLikePath(a) ? [a] : [];
   }));
 }
+function gluedValue(arg) {
+  if (arg.startsWith("--")) return void 0;
+  for (let i = 2; i < arg.length; i++) if (looksLikePath(arg.slice(i))) return arg.slice(i);
+  return void 0;
+}
 function matchFlag(spec, booleans, values, token) {
   if (token.startsWith("--")) {
     const eq = token.indexOf("=");
@@ -2028,6 +2094,9 @@ function isAuto(seg) {
   return sub !== void 0 && GIT_READONLY_SUBCOMMANDS.includes(sub);
 }
 function refusalFor(seg) {
+  if (seg.computedBinary !== void 0) {
+    return `"${seg.computedBinary}" is a command name the shell computes as it runs, so this classifier cannot tell what would run. Name the program directly.`;
+  }
   if (REFUSED_COMMANDS.includes(seg.binary)) {
     return `"${seg.binary}" modifies state. You are a read-only planner \u2014 describe the change as a task instead, and the runner executing the plan will make it.`;
   }
@@ -4482,13 +4551,52 @@ var GitWorktreeIsolation = class {
     return this.admin(run.workspaceRoot, async () => {
       await this.removeIntegrationWorktrees(run);
       await this.settleLanding(run);
+      const kept = [];
       for (const record of Object.values(run.tasks)) {
-        if (record.status === "active") await this.removeTask(run, record, { dropRecord: true });
-        else if (record.status === "merged") await this.removeTask(run, record, { dropRecord: false });
+        if (record.status === "active") {
+          if (await this.holdsUnlandedWork(run, record)) {
+            record.status = "kept";
+            kept.push({ taskId: record.taskId, order: record.order, title: record.title });
+          } else {
+            await this.removeTask(run, record, { dropRecord: true });
+          }
+        } else if (record.status === "merged") await this.removeTask(run, record, { dropRecord: false });
         else if (record.status === "repairing") settleStatus(record, "conflict");
       }
       await this.removeUnowned(run);
       for (const repo of run.repos) await this.tryGit(repo.root, ["worktree", "prune"]);
+      return { kept };
+    });
+  }
+  /**
+   * Whether an attempt record still holds work nobody else has: commits its
+   * branch carries that the integration branch does not, or edits in its
+   * worktree. Only an attempt that left neither behind is safe to prune.
+   */
+  async holdsUnlandedWork(run, record) {
+    for (const repo of run.repos) {
+      const entry = record.repos[repo.path];
+      if (!entry) continue;
+      if (await this.brings(repo, record.branch)) return true;
+      if (await this.worktreeHasChanges(entry, await this.prefixOf(repo))) return true;
+    }
+    return false;
+  }
+  /**
+   * Changes in a worktree, ignoring the artifacts Ordewell bootstrapped there
+   * so a prepared-but-untouched attempt still reads as empty. `prefix` is where
+   * the workspace sits in the repo, which is what the recorded link names are
+   * relative to. A worktree git cannot read is treated as holding work: it is
+   * out of sync, and deleting it is the one action that cannot be undone.
+   */
+  async worktreeHasChanges(entry, prefix) {
+    if (!fs4.existsSync(entry.worktree)) return false;
+    const status = await this.tryGit(entry.worktree, ["status", "--porcelain", "-z"]);
+    if (!status.ok) return true;
+    const linked = new Set(entry.linked);
+    return statusPaths(status.stdout).some((p) => {
+      const rel = (prefix && p.startsWith(prefix) ? p.slice(prefix.length) : p).replace(/\/+$/, "");
+      return !linked.has(rel) && !linked.has(rel.split("/")[0]);
     });
   }
   /**
@@ -4662,10 +4770,14 @@ var GitWorktreeIsolation = class {
     for (const repo of run.repos) {
       const entry = record.repos[repo.path];
       if (!entry) continue;
+      if (!fs4.existsSync(entry.worktree)) {
+        return this.stopLanding(record, "failed", repo, void 0, `its worktree is gone (${entry.worktree})`);
+      }
       try {
         await this.commitWorktree(repo, record, entry);
-      } catch {
-        return this.stopLanding(record, "failed", repo);
+      } catch (err) {
+        const detail = firstLine(err instanceof Error ? err.message : String(err));
+        return this.stopLanding(record, "failed", repo, void 0, `git could not commit its work (${detail})`);
       }
       if (await this.brings(repo, record.branch)) {
         entry.changed = true;
@@ -4694,11 +4806,14 @@ var GitWorktreeIsolation = class {
     settleStatus(record, "merged");
     delete record.conflictRepo;
     delete record.conflictFiles;
+    delete record.landingError;
     await this.admin(run.workspaceRoot, () => this.removeTask(run, record, { dropRecord: false })).catch(() => void 0);
     return "merged";
   }
-  stopLanding(record, outcome, repo, files) {
+  stopLanding(record, outcome, repo, files, error) {
     settleStatus(record, outcome);
+    if (error) record.landingError = error;
+    else delete record.landingError;
     if (repo) record.conflictRepo = repo.path;
     else delete record.conflictRepo;
     if (files && files.length > 0) record.conflictFiles = files;
@@ -5103,12 +5218,12 @@ function parseTaskQueryObject(json, text) {
     }
   }
   const catalog = rawCatalog === true;
-  let outputLines;
+  let outputLines2;
   if (rawLines !== void 0) {
     if (typeof rawLines !== "number" || !Number.isFinite(rawLines) || rawLines < 1) {
       throw new PlanParseError('"outputLines" in a taskQuery must be a positive number of lines', text);
     }
-    outputLines = rawLines;
+    outputLines2 = rawLines;
   }
   let outputSince;
   if (rawSince !== void 0) {
@@ -5120,7 +5235,7 @@ function parseTaskQueryObject(json, text) {
   if (tasks.length === 0 && !catalog) {
     throw new PlanParseError('A taskQuery must name at least one task or set "catalog": true', text);
   }
-  return { tasks, fields, catalog, outputLines, outputSince };
+  return { tasks, fields, catalog, outputLines: outputLines2, outputSince };
 }
 function taskQuerySignature(query) {
   return JSON.stringify([query.tasks, query.fields ?? null, query.catalog, query.outputLines ?? null, query.outputSince ?? null]);
@@ -5875,7 +5990,8 @@ async function repairLoop(opts) {
     if (repairs >= opts.maxRepairs) {
       return opts.onExhausted({ reply, errors: verdict.retry.errors, cause: verdict.retry.cause });
     }
-    reply = await opts.resend(verdict.retry.corrective);
+    const { corrective } = verdict.retry;
+    reply = await opts.resend(typeof corrective === "function" ? corrective() : corrective);
   }
 }
 var JSON_REPAIR_INSTRUCTION = "Your previous response could not be parsed as JSON. Re-send ONLY the JSON object \u2014 no prose before or after, no explanation, no markdown code fences.";
@@ -5958,6 +6074,81 @@ async function generatePlanWithRepair(generate, runners, maxAttempts = 2, runner
   });
 }
 
+// src/services/settleReply.ts
+var MAX_JSON_REPAIRS = 2;
+async function settleReply(opts) {
+  const researchLog = [];
+  const message = (text) => ({ kind: "message", text, researchLog });
+  const retract = () => opts.onProgress({ type: "text_retracted" });
+  const asProse = (attempt) => {
+    if (opts.replyJoinsSegments) retract();
+    return message(said(attempt));
+  };
+  let nudged = false;
+  const send = async (text) => {
+    const attempt = await opts.send(text);
+    researchLog.push(...attempt.researchLog);
+    if (attempt.text.trim() || attempt.aborted || attempt.failure !== void 0 || nudged) return attempt;
+    nudged = true;
+    retract();
+    return send(emptyReplyNudge(deniedStep(attempt)));
+  };
+  return repairLoop({
+    first: () => send(opts.message),
+    resend: (corrective) => {
+      retract();
+      return send(corrective);
+    },
+    interpret: (attempt) => {
+      if (attempt.aborted) {
+        const turn = asProse(attempt);
+        opts.onProgress({ type: "interrupted" });
+        return { done: turn };
+      }
+      if (attempt.failure !== void 0) return { done: message(attempt.failure) };
+      if (!attempt.text.trim()) return { done: message(emptyReplyReport(deniedStep(attempt))) };
+      const reply = classifyPlannerReply(attempt.text, opts.classify);
+      switch (reply.kind) {
+        case "plan":
+          return { done: { kind: "plan", tasks: reply.tasks, text: said(attempt), researchLog } };
+        case "task_ops":
+          return { done: { kind: "task_ops", ops: reply.ops, text: said(attempt), researchLog } };
+        // A read is answered by the conversation, which owns the plan and the
+        // catalog, so it leaves here the way a plan or an edit does.
+        case "task_query":
+          return { done: { kind: "task_query", query: reply.query, text: said(attempt), researchLog } };
+        case "prose":
+          return { done: asProse(attempt) };
+      }
+      if (opts.signal?.aborted) return { done: asProse(attempt) };
+      const errors = [reply.error.message];
+      switch (reply.kind) {
+        case "broken_task_ops":
+          return { retry: { errors, corrective: reEmitTaskOpsPrompt(reply.error.message), cause: reply.error } };
+        case "broken_task_query":
+          return { retry: { errors, corrective: reEmitTaskQueryPrompt(reply.error.message), cause: reply.error } };
+        case "broken_plan": {
+          const corrective = reply.error.truncated || attempt.cutOff ? () => truncatedPlanReEmitPrompt((opts.compactHistory?.() ?? 0) > 0) : reEmitPlanPrompt(reply.error.message);
+          return { retry: { errors, corrective, cause: reply.error } };
+        }
+      }
+    },
+    maxRepairs: MAX_JSON_REPAIRS,
+    onExhausted: ({ reply }) => asProse(reply)
+  });
+}
+var said = (attempt) => attempt.fullText ?? attempt.text;
+function deniedStep(attempt) {
+  return attempt.researchLog.find((e) => !("type" in e) && e.outcome === "denied");
+}
+var stepName = (step) => step.toolLabel ?? step.tool;
+function emptyReplyNudge(denied) {
+  return denied ? `Your last reply was empty after "${stepName(denied)}" was denied: ${denied.result} Do not retry it. Answer the user now with what you already know, or ask your next question.` : "Your last reply was empty. Respond to the user now: answer their last message directly, ask your next question, or emit the plan JSON.";
+}
+function emptyReplyReport(denied) {
+  return denied ? `The planner stopped without replying after "${stepName(denied)}" was denied: ${denied.result}` : "The planner returned an empty reply twice. Please rephrase or try again.";
+}
+
 // src/services/researchTools.ts
 import { SchemaType } from "@google/generative-ai";
 var SPAWN_RESEARCH_AGENT = "spawn_research_agent";
@@ -6305,7 +6496,12 @@ function nonPromptingFs(fs15) {
 async function runLoop(prompt, deps) {
   if (deps.signal?.aborted) return "[research agent aborted before starting]";
   const fs15 = nonPromptingFs(deps.fs);
-  const chat = deps.createChat((delta) => deps.onProgress?.({ type: "thinking", text: delta }));
+  const chat = deps.createChat(
+    (delta) => deps.onProgress?.({ type: "thinking", text: delta, subagentId: deps.subagentId }),
+    // The record says who made the call: unstamped, the ledger would read the
+    // subagent's prompt as the planner's own and measure its context by it.
+    (record) => deps.onProgress?.({ type: "usage", record: deps.subagentId ? { ...record, subagentId: deps.subagentId } : record })
+  );
   let turn = await chat.sendMessage(prompt, deps.signal);
   for (let step = 0; turn.hasToolCalls && step < SUBAGENT_LIMITS.maxSteps; step++) {
     if (deps.signal?.aborted) return `[research agent aborted] Partial findings:
@@ -6320,21 +6516,25 @@ ${turn.text}`;
       const args = { ...tc.args };
       if (tc.name === "read_file" && !("maxBytes" in args) && !("limit" in args)) args.limit = 2e3;
       const toolArgs = JSON.stringify(tc.args);
-      deps.onProgress?.({ type: "tool_call", tool: tc.name, toolArgs, toolCallId: tc.id });
+      deps.onProgress?.({ type: "tool_call", tool: tc.name, toolArgs, toolCallId: tc.id, subagentId: deps.subagentId });
       const res = await executeTool(tc.name, args, fs15, void 0, deps.signal);
       const output = res.output.length > SUBAGENT_LIMITS.toolOutputMaxChars ? res.output.slice(0, SUBAGENT_LIMITS.toolOutputMaxChars) + `
 [... truncated to ${SUBAGENT_LIMITS.toolOutputMaxChars} chars, total ${res.output.length}]` : res.output;
       const stepEntry = {
-        id: `subrs-${Date.now()}-${step}`,
+        // The subagentId in the id: two concurrent subagents run the same
+        // step numbers in the same millisecond, and an id collision would
+        // make their persisted steps indistinguishable on reload.
+        id: `subrs-${deps.subagentId ?? "local"}-${Date.now()}-${step}`,
         tool: tc.name,
         args: toolArgs,
         result: output,
         success: res.success,
         outcome: classifyOutcome(res.success, res.output),
+        subagentId: deps.subagentId,
         toolCallId: tc.id,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
-      deps.onProgress?.({ type: "tool_result", toolResult: output, step: stepEntry, toolCallId: tc.id });
+      deps.onProgress?.({ type: "tool_result", toolResult: output, step: stepEntry, toolCallId: tc.id, subagentId: deps.subagentId });
       results.push({ name: tc.name, output, truncated: res.truncated || output.length < res.output.length, totalChars: res.output.length, id: tc.id });
     }
     turn = await chat.sendToolResults(results, deps.signal);
@@ -6351,11 +6551,17 @@ ${turn.text}`;
 [... digest truncated to ${SUBAGENT_LIMITS.digestMaxChars} chars, total ${digest.length}]` : digest;
 }
 async function runResearchAgent(prompt, deps) {
+  deps.onProgress?.({ type: "subagent_started", subagentId: deps.subagentId, brief: prompt, model: deps.model });
   try {
-    return { success: true, output: await runLoop(prompt, deps), truncated: false };
+    const digest = await runLoop(prompt, deps);
+    const stopped = deps.signal?.aborted ?? false;
+    deps.onProgress?.({ type: "subagent_finished", subagentId: deps.subagentId, outcome: stopped ? "stopped" : "done", digest, usage: deps.usage?.() });
+    return { success: !stopped, output: digest, truncated: false };
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
-    return { success: false, output: `[research agent failed: ${reason}] Continue researching this area yourself with your own tools.`, truncated: false };
+    const output = `[research agent failed: ${reason}] Continue researching this area yourself with your own tools.`;
+    deps.onProgress?.({ type: "subagent_finished", subagentId: deps.subagentId, outcome: "failed", digest: output, usage: deps.usage?.() });
+    return { success: false, output, truncated: false };
   }
 }
 async function mapWithConcurrency(items, limit, fn) {
@@ -6369,6 +6575,14 @@ async function mapWithConcurrency(items, limit, fn) {
   return results;
 }
 
+// src/utils/abortScope.ts
+function abortScope(callerSignal) {
+  const scope = new AbortController();
+  if (callerSignal?.aborted) scope.abort();
+  else callerSignal?.addEventListener("abort", () => scope.abort(), { once: true });
+  return scope;
+}
+
 // src/services/BaseAiService.ts
 var PARALLEL_SAFE_TOOLS = /* @__PURE__ */ new Set(["read_file", "read_files", "glob", "grep", "find_symbol", "list_dir"]);
 var TOOL_ROUND_CONCURRENCY = 8;
@@ -6386,13 +6600,7 @@ var BaseAiService = class _BaseAiService {
     return this.conversation?.ctx.chat.compactHistory?.() ?? 0;
   }
   startAbortScope(callerSignal) {
-    this.activeAbort = new AbortController();
-    if (!callerSignal) return this.activeAbort.signal;
-    if (callerSignal.aborted) {
-      this.activeAbort.abort();
-      return this.activeAbort.signal;
-    }
-    callerSignal.addEventListener("abort", () => this.activeAbort?.abort(), { once: true });
+    this.activeAbort = abortScope(callerSignal);
     return this.activeAbort.signal;
   }
   stopAbortScope() {
@@ -6426,9 +6634,10 @@ var BaseAiService = class _BaseAiService {
    * Build a fresh chat for one research subagent (own history, subagent system
    * prompt, cheap model). Null means the provider does not support subagents —
    * the spawn tool then degrades to a steering message. `onReasoning` streams
-   * live reasoning deltas on models that expose them, same as the top-level loop.
+   * live reasoning deltas on models that expose them, same as the top-level loop;
+   * `onUsage` takes each call's usage, as the planner's own chat reports it.
    */
-  createSubagentChat(_onReasoning) {
+  createSubagentChat(_onReasoning, _onUsage) {
     return null;
   }
   /**
@@ -6442,15 +6651,22 @@ var BaseAiService = class _BaseAiService {
     if (!prompt) {
       return { success: false, output: 'spawn_research_agent requires a non-empty "prompt" string: a self-contained task for the agent, including what its digest must report back.', truncated: false };
     }
+    let usage;
     return runResearchAgent(prompt, {
-      createChat: (onReasoning) => {
-        const chat = this.createSubagentChat(onReasoning);
+      createChat: (onReasoning, onUsage) => {
+        const chat = this.createSubagentChat(onReasoning, onUsage);
         if (!chat) throw new Error("subagent chats are not available for this provider");
         return chat;
       },
       fs: fs15,
       signal,
-      onProgress: (progress) => onProgress({ ...progress, subagentId })
+      subagentId,
+      model: this.config.researchSubagentModel,
+      usage: () => usage,
+      onProgress: (progress) => {
+        if (progress.type === "usage" && progress.record) usage = addUsage(usage ?? {}, progress.record);
+        onProgress(progress);
+      }
     });
   }
   /** Collect project context for the planning phase. Shared with the harness backend. */
@@ -6539,138 +6755,80 @@ ${llmOutput}
   }
   /**
    * Run one planner conversation turn (ADR-0002): send the message, satisfy
-   * tool calls until the model answers in prose or JSON, then classify the
-   * result. The model decides transitions — there are no sentinels, no
-   * question tags, and no correction nags. A turn whose final text parses as
-   * a `{tasks:[...]}` object commits the plan; anything else is a message to
-   * the user.
+   * tool calls until the model answers in prose or JSON, and settle the reply
+   * through {@link settleReply}, which owns classification and every
+   * corrective retry. The model decides transitions — there are no sentinels
+   * and no question tags. A turn whose final text parses as a `{tasks:[...]}`
+   * object commits the plan; anything else is a message to the user.
    */
   async runConversationTurn(ctx, message, onProgress, signal) {
+    const chat = withProactiveCompaction(ctx.chat);
+    return settleReply({
+      message,
+      send: (text) => this.runToolRounds(chat, ctx, text, onProgress, signal),
+      classify: { runners: ctx.runners, runnerModes: ctx.runnerModes, autonomousDefault: ctx.autonomousDefault },
+      onProgress,
+      signal,
+      compactHistory: chat.compactHistory,
+      replyJoinsSegments: false
+    });
+  }
+  /** One model call of a conversation turn: the message, then tool rounds until the model replies without tools. */
+  async runToolRounds(chat, ctx, message, onProgress, signal) {
     const researchLog = [];
     const MAX_STEPS = this.config.researchMaxSteps;
-    const chat = withProactiveCompaction(ctx.chat);
-    let pending = message;
-    let emptyNudgeSent = false;
-    let jsonRepairAttempts = 0;
-    const MAX_JSON_REPAIRS2 = 2;
-    for (; ; ) {
-      let turn = await chat.sendMessage(pending, signal);
-      let wrapUpRounds = 0;
-      for (let step = 0; turn.hasToolCalls; step++) {
-        if (signal?.aborted) {
-          onProgress({ type: "interrupted" });
-          return { kind: "message", text: turn.text, researchLog };
-        }
-        if (step >= MAX_STEPS) {
-          if (wrapUpRounds >= 2) break;
-          wrapUpRounds++;
-          const notice = `Research tool budget for this turn is exhausted (${MAX_STEPS} rounds) \u2014 this call was NOT executed and no further tool calls will be. Reply to the user now using what you already learned: summarize your findings and ask how to proceed, ask your next question, or emit the plan JSON.`;
-          for (const tc of turn.toolCalls) {
-            const step2 = {
-              id: `rs-${Date.now()}-budget-${researchLog.length}`,
-              tool: tc.name,
-              args: JSON.stringify(tc.args),
-              result: notice,
-              success: false,
-              outcome: "not_executed",
-              toolCallId: tc.id,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            };
-            researchLog.push(step2);
-            onProgress({ type: "tool_call", tool: tc.name, toolArgs: step2.args, toolCallId: tc.id });
-            onProgress({ type: "tool_result", toolResult: notice, step: step2, toolCallId: tc.id });
-          }
-          turn = await chat.sendToolResults(
-            turn.toolCalls.map((tc) => ({ name: tc.name, output: notice, truncated: false, totalChars: notice.length, id: tc.id })),
-            signal
-          );
-          continue;
+    let turn = await chat.sendMessage(message, signal);
+    let wrapUpRounds = 0;
+    for (let step = 0; turn.hasToolCalls; step++) {
+      if (signal?.aborted) return { text: turn.text, researchLog, aborted: true };
+      if (step >= MAX_STEPS) {
+        if (wrapUpRounds >= 2) break;
+        wrapUpRounds++;
+        const notice = `Research tool budget for this turn is exhausted (${MAX_STEPS} rounds) \u2014 this call was NOT executed and no further tool calls will be. Reply to the user now using what you already learned: summarize your findings and ask how to proceed, ask your next question, or emit the plan JSON.`;
+        for (const tc of turn.toolCalls) {
+          const step2 = {
+            id: `rs-${Date.now()}-budget-${researchLog.length}`,
+            tool: tc.name,
+            args: JSON.stringify(tc.args),
+            result: notice,
+            success: false,
+            outcome: "not_executed",
+            toolCallId: tc.id,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          researchLog.push(step2);
+          onProgress({ type: "tool_call", tool: tc.name, toolArgs: step2.args, toolCallId: tc.id });
+          onProgress({ type: "tool_result", toolResult: notice, step: step2, toolCallId: tc.id });
         }
-        const thinking = turn.reasoning ? turn.reasoning.slice(-200) : "";
-        const { toolResults, logEntries } = await this.executeToolCalls(
-          turn.toolCalls,
-          ctx.fs,
-          onProgress,
-          ctx.fetcher,
-          step,
-          thinking,
+        turn = await chat.sendToolResults(
+          turn.toolCalls.map((tc) => ({ name: tc.name, output: notice, truncated: false, totalChars: notice.length, id: tc.id })),
           signal
         );
-        researchLog.push(...logEntries);
-        _BaseAiService.appendBudgetCountdown(toolResults, MAX_STEPS - step - 1, "reply to the user (summary, question, or plan JSON)");
-        turn = await chat.sendToolResults(toolResults, signal);
-      }
-      if (signal?.aborted) {
-        onProgress({ type: "interrupted" });
-        return { kind: "message", text: turn.text, researchLog };
-      }
-      if (turn.hasToolCalls && !turn.text.trim()) {
-        return {
-          kind: "message",
-          text: `I hit the research tool budget for this turn (${MAX_STEPS} rounds) before finishing. Tell me to continue, or narrow the request.`,
-          researchLog
-        };
-      }
-      if (!turn.text.trim()) {
-        if (!emptyNudgeSent && !signal?.aborted) {
-          emptyNudgeSent = true;
-          pending = "Your last reply was empty. Respond to the user now: answer their last message directly, ask your next question, or emit the plan JSON.";
-          continue;
-        }
-        return {
-          kind: "message",
-          text: "The planner returned an empty reply twice. Please rephrase or try again.",
-          researchLog
-        };
-      }
-      const reply = classifyPlannerReply(turn.text, {
-        runners: ctx.runners,
-        runnerModes: ctx.runnerModes,
-        autonomousDefault: ctx.autonomousDefault
-      });
-      switch (reply.kind) {
-        case "task_ops":
-          return { kind: "task_ops", ops: reply.ops, text: turn.text, researchLog };
-        // A read is settled by the Session (it owns the plan and the catalog),
-        // so it leaves this loop the same way a plan or an edit does.
-        case "task_query":
-          return { kind: "task_query", query: reply.query, text: turn.text, researchLog };
-        case "plan":
-          return { kind: "plan", tasks: reply.tasks, text: turn.text, researchLog };
-        // Botched attempts get a bounded corrective retry — otherwise the
-        // broken JSON would surface as a prose bubble and the edit or plan
-        // would silently fail to commit.
-        case "broken_task_ops":
-          if (jsonRepairAttempts < MAX_JSON_REPAIRS2 && !signal?.aborted) {
-            jsonRepairAttempts++;
-            pending = reEmitTaskOpsPrompt(reply.error.message);
-            continue;
-          }
-          break;
-        case "broken_task_query":
-          if (jsonRepairAttempts < MAX_JSON_REPAIRS2 && !signal?.aborted) {
-            jsonRepairAttempts++;
-            pending = reEmitTaskQueryPrompt(reply.error.message);
-            continue;
-          }
-          break;
-        case "broken_plan":
-          if (jsonRepairAttempts < MAX_JSON_REPAIRS2 && !signal?.aborted) {
-            jsonRepairAttempts++;
-            if (reply.error.truncated || turn.finishReason === "length") {
-              const removed = chat.compactHistory?.() ?? 0;
-              pending = truncatedPlanReEmitPrompt(removed > 0);
-            } else {
-              pending = reEmitPlanPrompt(reply.error.message);
-            }
-            continue;
-          }
-          break;
-        case "prose":
-          break;
+        continue;
       }
-      return { kind: "message", text: turn.text, researchLog };
+      const thinking = turn.reasoning ? turn.reasoning.slice(-200) : "";
+      const { toolResults, logEntries } = await this.executeToolCalls(
+        turn.toolCalls,
+        ctx.fs,
+        onProgress,
+        ctx.fetcher,
+        step,
+        thinking,
+        signal
+      );
+      researchLog.push(...logEntries);
+      _BaseAiService.appendBudgetCountdown(toolResults, MAX_STEPS - step - 1, "reply to the user (summary, question, or plan JSON)");
+      turn = await chat.sendToolResults(toolResults, signal);
+    }
+    if (signal?.aborted) return { text: turn.text, researchLog, aborted: true };
+    if (turn.hasToolCalls && !turn.text.trim()) {
+      return {
+        text: turn.text,
+        researchLog,
+        failure: `I hit the research tool budget for this turn (${MAX_STEPS} rounds) before finishing. Tell me to continue, or narrow the request.`
+      };
     }
+    return { text: turn.text, researchLog, cutOff: turn.finishReason === "length" };
   }
   /**
    * Run the LLM tool-calling research loop for one-shot planning. Returns
@@ -6744,45 +6902,40 @@ ${turn.text}
 };
 
 // src/services/GeminiService.ts
+import { v4 as uuidv42 } from "uuid";
 import {
   GoogleGenerativeAI
 } from "@google/generative-ai";
 var TOOL_DEFINITIONS = toGeminiToolDeclarations();
-function parseGeminiTurn(resultRaw) {
-  const result = resultRaw;
-  const candidate = result.response.candidates?.[0];
-  if (!candidate) return { text: "", toolCalls: [], hasToolCalls: false };
-  const parts = candidate.content?.parts || [];
-  let text = "";
-  let reasoning = "";
-  const toolCalls = [];
-  for (const part of parts) {
-    if ("text" in part) {
-      if (part.thought) reasoning += part.text;
-      else text += part.text;
-    }
-    if ("functionCall" in part) {
-      const fc = part.functionCall;
-      toolCalls.push({ name: fc.name, args: fc.args });
-    }
-  }
-  const finishReason = candidate.finishReason === "MAX_TOKENS" ? "length" : void 0;
-  const promptTokens = result.response.usageMetadata?.promptTokenCount;
-  return { text, toolCalls, hasToolCalls: toolCalls.length > 0, reasoning: reasoning || void 0, finishReason, promptTokens };
+function tokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function usageRecordFrom(usage) {
+  if (!usage) return void 0;
+  const inputTokens = tokenCount(usage.promptTokenCount);
+  const answerTokens = tokenCount(usage.candidatesTokenCount);
+  const thoughtTokens = tokenCount(usage.thoughtsTokenCount);
+  const reportedOutput = [answerTokens, thoughtTokens].filter((t) => t !== void 0);
+  const record = {
+    source: "google",
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...reportedOutput.length > 0 ? { outputTokens: reportedOutput.reduce((a, b) => a + b, 0) } : {},
+    ...tokenCount(usage.cachedContentTokenCount) !== void 0 ? { cachedInputTokens: tokenCount(usage.cachedContentTokenCount) } : {}
+  };
+  const anyReported = record.inputTokens !== void 0 || record.outputTokens !== void 0 || record.cachedInputTokens !== void 0;
+  return anyReported ? record : void 0;
 }
 var GeminiResearchChat = class {
-  constructor(chat, onReasoning, onContent) {
+  constructor(chat, hooks = {}) {
     this.chat = chat;
-    this.onReasoning = onReasoning;
-    this.onContent = onContent;
+    this.hooks = hooks;
   }
   chat;
-  onReasoning;
-  onContent;
+  hooks;
   async sendMessage(text, signal) {
     if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
-    const result = await this.chat.sendMessage(text);
-    return this.emit(parseGeminiTurn(result));
+    const result = await this.chat.sendMessageStream(text);
+    return this.consume(result.stream);
   }
   async sendToolResults(results, signal) {
     if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
@@ -6792,13 +6945,56 @@ var GeminiResearchChat = class {
         response: { output: r.output, truncated: r.truncated, totalChars: r.totalChars }
       }
     }));
-    const result = await this.chat.sendMessage(funcResponses);
-    return this.emit(parseGeminiTurn(result));
+    const result = await this.chat.sendMessageStream(funcResponses);
+    return this.consume(result.stream);
   }
-  emit(turn) {
-    if (turn.reasoning) this.onReasoning?.(turn.reasoning);
-    if (turn.text && !turn.hasToolCalls) this.onContent?.(turn.text);
-    return turn;
+  /**
+   * Drain one streaming chat call: thought parts answer on the reasoning
+   * channel, plain text on the reply channel, function calls accumulate into
+   * the turn exactly as the non-streaming parse used to produce. Each channel
+   * mints one fresh segmentId per call — thinking and reply never share, since
+   * a segment is one continuous run of model text — and the call produces
+   * exactly one usage record, from the final chunk: Gemini's streaming chunks
+   * each carry a running total, so the last one is the whole call's bill.
+   */
+  async consume(stream) {
+    const textSegmentId = uuidv42();
+    const thinkingSegmentId = uuidv42();
+    let text = "";
+    let reasoning = "";
+    let finishReason;
+    let usage;
+    const toolCalls = [];
+    for await (const chunkRaw of stream) {
+      const chunk = chunkRaw;
+      const candidate = chunk.candidates?.[0];
+      if (candidate?.finishReason) finishReason = candidate.finishReason;
+      if (chunk.usageMetadata) usage = chunk.usageMetadata;
+      for (const part of candidate?.content?.parts ?? []) {
+        if (part.text !== void 0) {
+          if (part.thought) {
+            reasoning += part.text;
+            this.hooks.onReasoning?.(part.text, thinkingSegmentId);
+          } else {
+            text += part.text;
+            this.hooks.onContent?.(part.text, textSegmentId);
+          }
+        }
+        if (part.functionCall) {
+          toolCalls.push({ name: part.functionCall.name, args: part.functionCall.args });
+        }
+      }
+    }
+    const usageRecord3 = usageRecordFrom(usage);
+    if (usageRecord3) this.hooks.onUsage?.(usageRecord3);
+    return {
+      text,
+      toolCalls,
+      hasToolCalls: toolCalls.length > 0,
+      reasoning: reasoning || void 0,
+      finishReason: finishReason === "MAX_TOKENS" ? "length" : void 0,
+      promptTokens: usageRecord3?.inputTokens
+    };
   }
 };
 var GeminiService = class extends BaseAiService {
@@ -6870,11 +7066,11 @@ ${m.content}` });
       generationConfig: { temperature: 0.3, topP: 0.95, maxOutputTokens: 16384 }
     });
     let currentProgress = req.onProgress;
-    const researchChat = new GeminiResearchChat(
-      chat,
-      (text) => currentProgress({ type: "thinking", text }),
-      (text) => currentProgress({ type: "plan_token", planToken: text })
-    );
+    const researchChat = new GeminiResearchChat(chat, {
+      onReasoning: (text, segmentId) => currentProgress({ type: "thinking", text, segmentId }),
+      onContent: (text, segmentId) => currentProgress({ type: "text_delta", text, segmentId }),
+      onUsage: (record) => currentProgress({ type: "usage", record })
+    });
     const ctx = {
       chat: researchChat,
       fs: req.fs,
@@ -6953,7 +7149,9 @@ Explore the workspace to understand the codebase, then generate the plan.`;
       tools: [{ functionDeclarations: TOOL_DEFINITIONS }],
       generationConfig: { temperature: 0.3, topP: 0.95, maxOutputTokens: 16384 }
     });
-    const researchChat = new GeminiResearchChat(chat);
+    const researchChat = new GeminiResearchChat(chat, {
+      onUsage: (record) => onProgress({ type: "usage", record })
+    });
     const result = await this.runResearchLoop(researchChat, firstMessage, fs15, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
     const fallback = await this.generatePlanFallback(userDescription, contextStr, result.researchResults, modelsByRunner, runners, onProgress, result.researchLog, runnerModes, autonomousDefault, signal, modes);
@@ -7010,14 +7208,18 @@ ${collected.aiflowContext}
 
 // src/services/OpenAiService.ts
 import OpenAI from "openai";
+import { v4 as uuidv43 } from "uuid";
 var OpenAiResearchChat = class {
-  constructor(messages, client, model, tools, onReasoning, onContent) {
+  constructor(messages, client, model, tools, onReasoning, onContent, source = "openai", onUsage, contextWindow) {
     this.messages = messages;
     this.client = client;
     this.model = model;
     this.tools = tools;
     this.onReasoning = onReasoning;
     this.onContent = onContent;
+    this.source = source;
+    this.onUsage = onUsage;
+    this.contextWindow = contextWindow;
   }
   messages;
   client;
@@ -7025,10 +7227,26 @@ var OpenAiResearchChat = class {
   tools;
   onReasoning;
   onContent;
+  source;
+  onUsage;
+  contextWindow;
   async sendMessage(text, signal) {
+    this.answerAbandonedCalls();
     this.messages.push({ role: "user", content: text });
     return this.callApi(signal);
   }
+  /**
+   * A turn that gave up on its tool budget, or was stopped, can end on calls
+   * nothing answered — and the API refuses every later request over a history
+   * like that. They are answered as never run before the next message.
+   */
+  answerAbandonedCalls() {
+    const last = this.messages[this.messages.length - 1];
+    if (last?.role !== "assistant" || !last.tool_calls?.length) return;
+    for (const call of last.tool_calls) {
+      this.messages.push({ role: "tool", tool_call_id: call.id, content: "Not executed: the turn that asked for this ended first." });
+    }
+  }
   async sendToolResults(results, signal) {
     for (const r of results) {
       this.messages.push({ role: "tool", tool_call_id: r.id, content: r.output });
@@ -7053,24 +7271,30 @@ var OpenAiResearchChat = class {
       // proactive history compaction keys on.
       stream_options: { include_usage: true }
     }, signal ? { signal } : void 0);
+    const segmentId = uuidv43();
     let content = "";
     let reasoning = "";
     let finishReason;
     let promptTokens;
+    let reported;
     const toolAcc = /* @__PURE__ */ new Map();
     for await (const chunk of stream) {
-      if (chunk.usage) promptTokens = chunk.usage.prompt_tokens;
+      const usage2 = chunk.usage;
+      if (usage2) {
+        reported = usage2;
+        promptTokens = usage2.prompt_tokens;
+      }
       const fr = chunk.choices[0]?.finish_reason;
       if (fr) finishReason = fr;
       const delta = chunk.choices[0]?.delta;
       if (!delta) continue;
       if (delta.reasoning) {
         reasoning += delta.reasoning;
-        this.onReasoning?.(delta.reasoning);
+        this.onReasoning?.(delta.reasoning, segmentId);
       }
       if (delta.content) {
         content += delta.content;
-        this.onContent?.(delta.content);
+        this.onContent?.(delta.content, segmentId);
       }
       for (const tc of delta.tool_calls ?? []) {
         const acc = toolAcc.get(tc.index) ?? { id: "", name: "", args: "" };
@@ -7080,6 +7304,8 @@ var OpenAiResearchChat = class {
         toolAcc.set(tc.index, acc);
       }
     }
+    const usage = this.usageRecord(reported);
+    if (usage) this.onUsage?.(usage);
     const accepted = [...toolAcc.entries()].sort((a, b) => a[0] - b[0]).map(([, v]) => v).filter((v) => v.name);
     const assistantMsg = accepted.length > 0 ? { role: "assistant", content: content || null, tool_calls: accepted.map((v) => ({ id: v.id, type: "function", function: { name: v.name, arguments: v.args } })) } : { role: "assistant", content };
     this.messages.push(assistantMsg);
@@ -7093,6 +7319,34 @@ var OpenAiResearchChat = class {
     });
     return { text: content, toolCalls, hasToolCalls: toolCalls.length > 0, reasoning: reasoning || void 0, finishReason, promptTokens };
   }
+  /**
+   * The one record for this API call, built only from what the provider
+   * reported. OpenRouter's `cost` is in USD (its credits are dollar-pegged);
+   * nothing is estimated. A field the provider left out stays absent.
+   */
+  usageRecord(reported) {
+    if (!reported) return void 0;
+    const record = { source: this.source, model: this.model };
+    let hasMeasure = false;
+    if (reported.prompt_tokens !== void 0) {
+      record.inputTokens = reported.prompt_tokens;
+      hasMeasure = true;
+    }
+    if (reported.completion_tokens !== void 0) {
+      record.outputTokens = reported.completion_tokens;
+      hasMeasure = true;
+    }
+    if (reported.prompt_tokens_details?.cached_tokens !== void 0) {
+      record.cachedInputTokens = reported.prompt_tokens_details.cached_tokens;
+      hasMeasure = true;
+    }
+    if (reported.cost !== void 0) {
+      record.reportedCost = { amount: reported.cost, currency: "USD" };
+      hasMeasure = true;
+    }
+    if (this.contextWindow && this.contextWindow > 0) record.contextWindow = this.contextWindow;
+    return hasMeasure ? record : void 0;
+  }
 };
 var OpenAiService = class extends BaseAiService {
   client = null;
@@ -7151,7 +7405,7 @@ var OpenAiService = class extends BaseAiService {
     return fullResponse;
   }
   /** A research subagent: fresh history, digest contract, cheap model, read-only tools. */
-  createSubagentChat(onReasoning) {
+  createSubagentChat(onReasoning, onUsage) {
     const client = this.getClient();
     const messages = [
       { role: "system", content: buildSubagentSystemPrompt() }
@@ -7161,7 +7415,10 @@ var OpenAiService = class extends BaseAiService {
       client,
       this.requireModel("researchSubagentModel", this.config.researchSubagentModel),
       toOpenAiSubagentTools(),
-      onReasoning
+      onReasoning,
+      void 0,
+      this.config.aiProvider,
+      onUsage
     );
   }
   // --- Conversation loop (ADR-0002) ---
@@ -7194,8 +7451,11 @@ ${buildResearchToolsPrompt()}` }
       client,
       this.requireModel("orchestratorModel", this.config.orchestratorModel),
       toOpenAiTools(),
-      (delta) => currentProgress({ type: "thinking", text: delta }),
-      (delta) => currentProgress({ type: "plan_token", planToken: delta })
+      (delta, segmentId) => currentProgress({ type: "thinking", text: delta, segmentId }),
+      (delta, segmentId) => currentProgress({ type: "text_delta", text: delta, segmentId }),
+      this.config.aiProvider,
+      (record) => currentProgress({ type: "usage", record }),
+      req.contextWindow
     );
     const ctx = {
       chat,
@@ -7241,7 +7501,10 @@ ${userText}`;
       client,
       this.requireModel("orchestratorModel", this.config.orchestratorModel),
       toOpenAiTools(),
-      (delta) => onProgress({ type: "thinking", text: delta })
+      (delta) => onProgress({ type: "thinking", text: delta }),
+      void 0,
+      this.config.aiProvider,
+      (record) => onProgress({ type: "usage", record })
     );
     const result = await this.runResearchLoop(researchChat, firstMessage, fs15, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
@@ -7468,182 +7731,6 @@ function composeAugmentedPrompt(task, allTasks, opts) {
 ${basePrompt}${marker2}`;
 }
 
-// src/services/terminalRender.ts
-var ANSI_OR_CTRL_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[()][AB012]|\x1b[=>]|[\x00-\x08\x0b-\x1f\x7f]/g;
-function flattenTerminalOutput(raw) {
-  return raw.replace(ANSI_OR_CTRL_RE, "").replace(/[─-▟]/g, "").replace(/\s+/g, "");
-}
-function renderTerminalOutput(raw) {
-  const rows = /* @__PURE__ */ new Map();
-  let row = 1;
-  let col = 1;
-  let savedRow = 1;
-  let savedCol = 1;
-  const cells = (r) => {
-    let line = rows.get(r);
-    if (!line) {
-      line = [];
-      rows.set(r, line);
-    }
-    return line;
-  };
-  const firstParam = (params, fallback = 1) => params[0] || fallback;
-  const eraseLine = (mode) => {
-    const line = cells(row);
-    if (mode === 2) {
-      rows.set(row, []);
-    } else if (mode === 1) {
-      for (let c = 0; c < col; c++) line[c] = " ";
-    } else {
-      line.length = Math.max(0, col - 1);
-    }
-  };
-  for (let i = 0; i < raw.length; ) {
-    const ch = raw[i];
-    if (ch === "\x1B") {
-      const kind = raw[i + 1];
-      if (kind === "[") {
-        let end = i + 2;
-        while (end < raw.length) {
-          const code = raw.charCodeAt(end);
-          if (code >= 64 && code <= 126) break;
-          end++;
-        }
-        if (end >= raw.length) break;
-        const final = raw[end];
-        const body = raw.slice(i + 2, end).replace(/^[?<>=!]+/, "");
-        const params = body.split(";").map((p) => Number.parseInt(p, 10) || 0);
-        switch (final) {
-          case "H":
-          case "f":
-            row = params[0] || 1;
-            col = params[1] || 1;
-            break;
-          case "G":
-            col = firstParam(params);
-            break;
-          case "d":
-            row = firstParam(params);
-            break;
-          case "A":
-            row = Math.max(1, row - firstParam(params));
-            break;
-          case "B":
-            row += firstParam(params);
-            break;
-          case "C":
-            col += firstParam(params);
-            break;
-          case "D":
-            col = Math.max(1, col - firstParam(params));
-            break;
-          case "E":
-            row += firstParam(params);
-            col = 1;
-            break;
-          case "F":
-            row = Math.max(1, row - firstParam(params));
-            col = 1;
-            break;
-          case "s":
-            savedRow = row;
-            savedCol = col;
-            break;
-          case "u":
-            row = savedRow;
-            col = savedCol;
-            break;
-          case "K":
-            eraseLine(params[0] || 0);
-            break;
-          case "J":
-            if ((params[0] || 0) === 2 || (params[0] || 0) === 3) rows.clear();
-            break;
-          case "X": {
-            const line = cells(row);
-            for (let c = 0; c < firstParam(params); c++) line[col - 1 + c] = " ";
-            break;
-          }
-          case "P": {
-            cells(row).splice(col - 1, firstParam(params));
-            break;
-          }
-          case "@": {
-            cells(row).splice(col - 1, 0, ...Array(firstParam(params)).fill(" "));
-            break;
-          }
-          default:
-            break;
-        }
-        i = end + 1;
-        continue;
-      }
-      if (kind === "]" || kind === "P" || kind === "^" || kind === "_") {
-        let end = i + 2;
-        while (end < raw.length && raw[end] !== "\x07" && !(raw[end] === "\x1B" && raw[end + 1] === "\\")) end++;
-        if (end >= raw.length) break;
-        i = raw[end] === "\x07" ? end + 1 : end + 2;
-        continue;
-      }
-      if (kind === "7") {
-        savedRow = row;
-        savedCol = col;
-      } else if (kind === "8") {
-        row = savedRow;
-        col = savedCol;
-      } else if (kind === "c") {
-        rows.clear();
-        row = 1;
-        col = 1;
-      }
-      i += kind === "(" || kind === ")" ? 3 : 2;
-      continue;
-    }
-    if (ch === "\r") {
-      col = 1;
-      i++;
-      continue;
-    }
-    if (ch === "\n") {
-      row++;
-      i++;
-      continue;
-    }
-    if (ch === "\b") {
-      col = Math.max(1, col - 1);
-      i++;
-      continue;
-    }
-    if (ch === "	") {
-      col += 8 - (col - 1) % 8;
-      i++;
-      continue;
-    }
-    if (ch < " " || ch === "\x7F") {
-      i++;
-      continue;
-    }
-    cells(row)[col - 1] = ch;
-    col++;
-    i++;
-  }
-  const populated = [...rows.keys()].sort((a, b) => a - b);
-  return populated.map((r) => cells(r).join("")).join("\n");
-}
-function renderCleanCapture(raw, doneToken) {
-  const rendered = renderTerminalOutput(raw).replace(/[\s─-▟]+$/gm, "");
-  if (!doneToken) return rendered.trim();
-  const lines = rendered.split("\n");
-  const flat = (s) => flattenTerminalOutput(s);
-  for (let i = 0; i < lines.length; i++) {
-    const own = flat(lines[i]).includes(doneToken);
-    if (own) return lines.slice(0, i).join("\n").trim();
-    const window = flat(lines[i]) + (i + 1 < lines.length ? flat(lines[i + 1]) : "");
-    if (window.includes(doneToken)) return lines.slice(0, i + 1).join("\n").trim();
-  }
-  return rendered.trim();
-}
-
 // src/services/VerdictEngine.ts
 var CHECKPOINT_RE = /<<<ORDEWELL_CHECKPOINT:\s*(.*?)>>>/gs;
 function markerVisible(raw, doneToken) {
@@ -8719,6 +8806,8 @@ function watchBlockingPrompts(session, prompts, onPrompt) {
 
 // src/services/TaskOrchestrator.ts
 var SHARED_ROOT_TAIL = "tasks run in the workspace root without worktree isolation.";
+var USAGE_LIMIT_RE = /\b(?:usage|session|weekly|daily|monthly) limit\b|\brate limit (?:exceeded|reached)\b|\brate[- ]limited\b|\blimit (?:will )?reset\b|\bquota (?:exceeded|reached)\b|\btoo many requests\b/i;
+var USAGE_LIMIT_TAIL = 4096;
 function sharedRootNotice(reason, repos) {
   switch (reason) {
     case "disabled":
@@ -8772,6 +8861,7 @@ var TaskOrchestrator = class {
   running = false;
   planStatus = "approved";
   messageQueue = [];
+  queueSeq = 0;
   reviewApproved = false;
   /*
    * Retry counts, spawn counts and holds describe a task across attempts, so
@@ -8986,7 +9076,10 @@ var TaskOrchestrator = class {
     this.resolvers = { ...state?.resolvers ?? {} };
     if (!this.isolationRun) return;
     try {
-      await this.isolation.pruneOrphans(this.isolationRun);
+      const { kept } = await this.isolation.pruneOrphans(this.isolationRun);
+      for (const task of kept) {
+        this.tell("warn", `Task "${task.title}" was still holding unlanded work when this plan was re-opened, so its worktree and branch were kept. Retry it to land the work, or review it by hand.`);
+      }
     } catch (err) {
       this.tell("warn", `Could not prune leftover worktrees: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -9007,7 +9100,7 @@ var TaskOrchestrator = class {
     const group = run.repos.some((r) => r.path !== SELF_REPO);
     const repaired = handoffOf(run).landed.filter((t) => t.repairedFiles?.length);
     const { level, message } = describeMergeResult(result, branch, group, repaired);
-    this.notifications[level](message);
+    this.tell(level, message);
     if (result.outcome === "merged") await this.clearMergedRun(run);
     return result;
   }
@@ -9064,7 +9157,9 @@ var TaskOrchestrator = class {
   }
   queueMessage(text) {
     this.messageQueue.push({
-      id: `q-${Date.now()}`,
+      // A sequence, not just the clock: two sends inside one millisecond must
+      // stay distinguishable, since a surface removes one by id.
+      id: `q-${Date.now()}-${++this.queueSeq}`,
       text,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -9073,6 +9168,14 @@ var TaskOrchestrator = class {
   getQueuedMessages() {
     return [...this.messageQueue];
   }
+  /** Take one unsent message back out of the queue; false when it was never there (or already drained). */
+  removeQueuedMessage(id) {
+    const index = this.messageQueue.findIndex((m) => m.id === id);
+    if (index < 0) return false;
+    this.messageQueue.splice(index, 1);
+    this.emit("onTaskChanged");
+    return true;
+  }
   setQueuedMessages(messages) {
     this.messageQueue = [...messages];
   }
@@ -9182,6 +9285,11 @@ var TaskOrchestrator = class {
 ${summary || "(empty \u2014 no output captured)"}`);
     if (verdict.outcome === "pass") {
       await this.landPassed(task, landing);
+    } else if (this.stoppedOnUsageLimit(attempt)) {
+      this.store.markAwaitingUser(taskId);
+      this.haltOnFailure();
+      this.tell("warn", `Task "${task.title}" stopped before its completion marker: ${attempt.runner} hit its usage limit. Retry it once the limit resets \u2014 its worktree is kept.`);
+      if (attempt.worktree) await this.releaseWorktree(taskId, { keep: true });
     } else {
       this.store.markFailed(taskId);
       this.haltOnFailure();
@@ -9192,6 +9300,11 @@ ${summary || "(empty \u2014 no output captured)"}`);
     this.logAndArchive(task, verdict);
     await this.afterVerdict();
   }
+  /** Whether a stopped runner's own tail says its account, not the task, ran out. */
+  stoppedOnUsageLimit(attempt) {
+    const tail = attempt.session?.getOutput().slice(-USAGE_LIMIT_TAIL) ?? "";
+    return USAGE_LIMIT_RE.test(tail);
+  }
   async afterVerdict() {
     this.emit("onTaskChanged");
     if (!this.running) {
@@ -9323,9 +9436,9 @@ ${summary || "(empty \u2014 no output captured)"}`);
       const whyNot = this.noRepairReason(task);
       if (whyNot) this.tell("info", whyNot);
     } else {
-      this.store.markFailed(task.id);
-      this.haltOnFailure();
-      this.notifications.error(inRepo ? `Task "${task.title}" passed, but git could not integrate its work in ${inRepo}, so none of it landed. Its worktrees are kept for inspection.` : `Task "${task.title}" passed, but git could not integrate its work. Its worktree is kept for inspection.`);
+      const why = record?.landingError ? ` (${record.landingError})` : "";
+      this.store.markAwaitingUser(task.id);
+      this.notifications.error(inRepo ? `Task "${task.title}" passed, but git could not integrate its work in ${inRepo}${why}, so none of it landed. Its worktrees are kept for inspection.` : `Task "${task.title}" passed, but git could not integrate its work${why}. Its worktree is kept for inspection.`);
     }
   }
   /** The repair a conflicted task is owed next; null when repair is off, used up, or there is no isolated run to repair it in. */
@@ -9432,27 +9545,35 @@ ${summary || "(empty \u2014 no output captured)"}`);
    * Cancel a running (or scheduled) task: kill its session and return it to
    * 'pending' — "not executed". The task is put on hold so the scheduler
    * doesn't immediately restart it; Retry / Force Start release the hold.
+   *
+   * The attempt's worktree is kept, as a stopped or failed one is: a runner is
+   * often cancelled because it looked stuck after doing the work, and Mark
+   * complete can still land that work. The next attempt replaces it.
    */
   async cancelTask(taskId) {
+    await this.cancelAttempt(taskId, { keep: true });
+  }
+  async cancelAttempt(taskId, worktree) {
     const task = this.store.get(taskId);
     if (!task) return;
     const ended = this.endAttempt(taskId, "cancel");
     this.store.markPending(taskId);
     this.onHold.add(taskId);
     this.emit("onTaskChanged");
-    await this.releaseWorktree(taskId, { keep: false }, ended?.integration);
+    await this.releaseWorktree(taskId, worktree, ended?.integration);
     await this.tick();
   }
   /**
    * Let go of a task that is leaving the plan. A live runner is cancelled
-   * through {@link cancelTask}; a spawn still in flight just loses its attempt,
+   * as {@link cancelTask} does, but its worktree goes: no task is left to land
+   * it into. A spawn still in flight just loses its attempt,
    * which is what makes {@link startTask} kill the session it is about to
    * receive. The id's cross-attempt bookkeeping goes too — a hold or retry
    * count kept for a task that no longer exists would be inherited by nothing.
    */
   async releaseTask(taskId) {
     const phase = this.attempts.get(taskId)?.phase;
-    if (phase === "running" || phase === "integrating") await this.cancelTask(taskId);
+    if (phase === "running" || phase === "integrating") await this.cancelAttempt(taskId, { keep: false });
     else {
       this.endAttempt(taskId, "release");
       await this.releaseWorktree(taskId, { keep: false });
@@ -9544,12 +9665,12 @@ ${summary || "(empty \u2014 no output captured)"}`);
   }
   /**
    * Run exactly one task outside full-plan scheduling. The active/starting
-   * session still contributes to isRunning so every surface exposes Stop and
-   * disables Execute Plan, but onVerdict cannot auto-schedule other tasks
-   * because the plan scheduler's `running` flag remains false.
+   * session still contributes to {@link hasLiveWork} so every surface exposes
+   * Stop and disables Execute Plan, but onVerdict cannot auto-schedule other
+   * tasks because the plan scheduler's `running` flag remains false.
    */
   async runTask(taskId) {
-    if (this.isRunning) return;
+    if (this.hasLiveWork) return;
     const task = this.store.get(taskId);
     if (!task || task.type !== "ai") return;
     if (!await this.openRun(() => this.runTask(taskId))) return;
@@ -9691,7 +9812,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
       await this.releaseWorktree(task.id, { keep: false });
       this.store.markPending(task.id);
       this.onHold.add(task.id);
-      this.notifications.error(`Failed to start task "${task.title}": ${err}`);
+      this.tell("error", `Failed to start task "${task.title}": ${err}`);
       this.emit("onTaskChanged");
       await this.tick();
     }
@@ -9830,19 +9951,21 @@ ${summary || "(empty \u2014 no output captured)"}`);
     }
   }
   /**
-   * The plan's run carries on while anything has landed on its integration
-   * branch: a resumed plan's dependents must start from a tip that holds their
-   * predecessors' work, and a fresh branch from the checked-out commit does not.
+   * The plan's run carries on while it still has any record: anything landed
+   * means a resumed plan's dependents must start from a tip that holds their
+   * predecessors' work, and anything held — a kept attempt, a conflict, a
+   * repair — is work the user may still want, which a fresh run's mint would
+   * delete. Only a run with no records at all is superseded.
    */
   continuableRun(root) {
     const run = this.isolationRun;
-    return run && run.workspaceRoot === root && Object.values(run.tasks).some((r) => r.status === "merged") ? run : null;
+    return run && run.workspaceRoot === root && Object.values(run.tasks).some((r) => r.status !== "active") ? run : null;
   }
   /**
-   * A run with nothing landed holds only superseded attempts, so it goes whole.
-   * One that cannot be continued for another reason — it ran from a different
-   * workspace path — keeps its integration branch in each repo that has not
-   * merged it: only the user gives landed work up.
+   * A run with no records at all holds only superseded attempts, so it goes
+   * whole. One that cannot be continued for another reason — it ran from a
+   * different workspace path — keeps its integration branch in each repo that
+   * has not merged it: only the user gives landed work up.
    */
   async mintRun(root) {
     const previous = this.isolationRun;
@@ -10020,11 +10143,12 @@ var Planner = class {
       req.runnerModes,
       req.autonomousDefault ?? true
     );
+    const finished = new Set(req.executionLog.filter((t) => t.status === "completed").map((t) => t.id));
     return repairLoop({
       first: () => send(),
       resend: (corrective) => send(corrective),
       interpret: (tasks) => {
-        const coerced = coerceAssignments(tasks, allowlist, req.runners, req.modelsByRunner);
+        const coerced = coerceAssignments(tasks.filter((t) => !finished.has(t.id)), allowlist, req.runners, req.modelsByRunner);
         const validation = validatePlanModification({
           executionLog: req.executionLog,
           oldPending: req.pendingTasks,
@@ -11072,7 +11196,7 @@ function discoveredToCatalog(m) {
     name: m.modelLabel,
     description: "",
     pricing: { prompt: "?", completion: "?" },
-    contextLength: 0
+    contextLength: m.contextWindow ?? 0
   };
 }
 async function fetchAllProviderModels(opts) {
@@ -11177,7 +11301,8 @@ function toOrchestratorOptions(providerModels, shortcuts) {
         provider: providerLabel,
         apiProvider: provider,
         description: s?.description || m.description || void 0,
-        pricing
+        pricing,
+        ...m.contextLength > 0 ? { contextWindow: m.contextLength } : {}
       });
     }
   }
@@ -11260,6 +11385,23 @@ var ModelResolver = class {
   getCachedPickerOptions() {
     return this.cachedPickerOptions ?? [];
   }
+  /**
+   * The planner model's context window, from whatever catalog is already
+   * cached (#49): a vendor model comes from the picker catalog, a harness
+   * planner's model from the runner's own discovered models. Reads only —
+   * never triggers a fetch or discovery of its own, so an unknown window stays
+   * unknown and context fill is omitted rather than guessed.
+   */
+  contextWindowFor(modelId) {
+    if (!modelId) return void 0;
+    const picker = this.cachedPickerOptions?.find((o) => o.id === modelId)?.contextWindow;
+    if (picker && picker > 0) return picker;
+    for (const runner of this.config.enabledRunners ?? []) {
+      const found = this.discovery.getCached(runner)?.find((m) => m.modelId === modelId)?.contextWindow;
+      if (found && found > 0) return found;
+    }
+    return void 0;
+  }
   invalidate() {
     this.discovery.clear();
     this.cachedPickerOptions = null;
@@ -11386,6 +11528,81 @@ var RunnerInstallation = class {
 
 // src/services/harness/CliAgentAiService.ts
 import { spawn as nodeSpawn } from "child_process";
+import { v4 as uuidv44 } from "uuid";
+
+// src/services/replyStream.ts
+var ReplySplitter = class {
+  segments = /* @__PURE__ */ new Map();
+  push(segmentId, text) {
+    const state = this.segments.get(segmentId);
+    if (state === "text" || state === "plan") return { route: state, text };
+    const held = (state?.held ?? "") + text;
+    const opensWithObject = opensWithJsonObject(held);
+    if (opensWithObject === void 0) {
+      this.segments.set(segmentId, { held });
+      return null;
+    }
+    const route = opensWithObject ? "plan" : "text";
+    this.segments.set(segmentId, route);
+    return { route, text: held };
+  }
+};
+var TurnStream = class {
+  constructor(turnId, emit) {
+    this.turnId = turnId;
+    this.emit = emit;
+  }
+  turnId;
+  emit;
+  splitter = new ReplySplitter();
+  /**
+   * Segments streamed and not taken back, to the chat or to the plan display,
+   * each with the sink it came through. A botched envelope streams to the plan
+   * display, and its retry must not build on top of it.
+   */
+  shown = /* @__PURE__ */ new Map();
+  /**
+   * Progress for one backend call. A backend that takes back its attempt
+   * without naming a segment means the text of that call only — not what an
+   * earlier call of the same turn streamed, such as a read it answered.
+   */
+  sink() {
+    const call = {};
+    return (progress) => {
+      if (progress.type === "text_delta" && progress.segmentId && progress.text) {
+        const routed = this.splitter.push(progress.segmentId, progress.text);
+        if (!routed) return;
+        this.shown.set(progress.segmentId, call);
+        if (routed.route === "plan") {
+          this.emit({ type: "plan_token", planToken: routed.text, segmentId: progress.segmentId, turnId: this.turnId });
+          return;
+        }
+        this.emit({ ...progress, text: routed.text, turnId: this.turnId });
+        return;
+      }
+      if (progress.type === "text_retracted") {
+        const { segmentId } = progress;
+        this.retractWhere((id, owner) => segmentId ? id === segmentId : owner === call);
+        return;
+      }
+      this.emit({ ...progress, turnId: this.turnId });
+    };
+  }
+  /**
+   * Take back every segment the turn still shows: the owner is discarding the
+   * whole attempt, which spans every call since the last one it discarded.
+   */
+  retract() {
+    this.retractWhere(() => true);
+  }
+  retractWhere(matches) {
+    for (const [segmentId, owner] of this.shown) {
+      if (!matches(segmentId, owner)) continue;
+      this.shown.delete(segmentId);
+      this.emit({ type: "text_retracted", segmentId, turnId: this.turnId });
+    }
+  }
+};
 
 // src/utils/workspace.ts
 import * as fs8 from "fs";
@@ -11654,6 +11871,31 @@ ${tail}` : ""}`;
 // src/services/harness/ClaudeCodeAdapter.ts
 var DISALLOWED_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit", "KillShell"];
 var ASYNC_LAUNCH_MARKER = "Async agent launched successfully";
+var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+function usageRecord(usage, model, subagentId) {
+  const record = {
+    source: "claude-code",
+    ...partedPromptUsage({ uncached: usage.input_tokens, cacheRead: usage.cache_read_input_tokens, cacheWrite: usage.cache_creation_input_tokens })
+  };
+  if (model) record.model = model;
+  if (usage.output_tokens !== void 0) record.outputTokens = usage.output_tokens;
+  if (subagentId) record.subagentId = subagentId;
+  return record;
+}
+function subagentFinalCall(result) {
+  if (typeof result !== "object" || result === null) return null;
+  const { usage, resolvedModel } = result;
+  if (typeof usage !== "object" || usage === null) return null;
+  return { usage, model: typeof resolvedModel === "string" ? resolvedModel : void 0 };
+}
+function notificationOutcome(status) {
+  if (status === "completed") return "done";
+  if (status === "killed" || status === "stopped") return "stopped";
+  return "failed";
+}
+function blocksOf(msg) {
+  return Array.isArray(msg.message?.content) ? msg.message.content : [];
+}
 function flattenContent(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -11665,6 +11907,23 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
   agentId = "claude-code";
   /** Whether this turn has already emitted reply text — see {@link handleLine}. */
   turnHasText = false;
+  /** The text block streaming now follows earlier reply text, so its first delta opens the paragraph. */
+  pendingBreak = false;
+  /** The model answering the planner's current message, as its `message_start` named it. */
+  plannerModel;
+  /**
+   * The session's `total_cost_usd` as last reported. Undefined after a resume:
+   * the CLI restores the resumed session's running total, and what Ordewell
+   * already counted of it is not ours to know here.
+   */
+  reportedCostUsd = 0;
+  /**
+   * Subagents started and not yet finished, keyed by the `Agent` call's id.
+   * Kept across turns: a backgrounded one reports after its turn has ended.
+   */
+  openSubagents = /* @__PURE__ */ new Map();
+  /** Subagent messages already counted. A message arrives as one line per content block, each repeating its usage. */
+  countedSubagentMessages = /* @__PURE__ */ new Set();
   spawnSpec(opts) {
     const args = [
       "-p",
@@ -11685,7 +11944,10 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
     ];
     if (opts.model) args.push("--model", opts.model);
     if (opts.effort && opts.effort !== "adaptive") args.push("--effort", opts.effort);
-    if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+    if (opts.resumeSessionId) {
+      args.push("--resume", opts.resumeSessionId);
+      this.reportedCostUsd = void 0;
+    }
     return { command: "claude", args };
   }
   turnPayload(message) {
@@ -11700,7 +11962,7 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
     const msg = StdioAgentAdapter.parse(line);
     if (!msg) return;
     if (msg.session_id) this.sessionId = msg.session_id;
-    if (msg.parent_tool_use_id) return;
+    const subagentId = msg.parent_tool_use_id ?? void 0;
     switch (msg.type) {
       // The control channel: Claude asks whether a tool may run when its mode
       // cannot decide alone. A read-only planner answers "deny", every time —
@@ -11724,7 +11986,11 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
         return;
       }
       case "assistant":
-        for (const block of Array.isArray(msg.message?.content) ? msg.message.content : []) {
+        if (subagentId) {
+          this.handleSubagentMessage(msg, subagentId, emit);
+          return;
+        }
+        for (const block of blocksOf(msg)) {
           if (block.type === "text" && block.text) {
             emit({ type: "assistant_text", text: this.turnHasText ? `
 
@@ -11732,40 +11998,122 @@ ${block.text}` : block.text });
             this.turnHasText = true;
           } else if (block.type === "thinking" && block.thinking) emit({ type: "thinking", text: block.thinking });
           else if (block.type === "tool_use" && block.name) {
-            emit({ type: "tool_call", id: block.id ?? block.name, name: block.name, args: block.input ?? {} });
+            const id = block.id ?? block.name;
+            emit({ type: "tool_call", id, name: block.name, args: block.input ?? {} });
+            if (SUBAGENT_TOOLS.has(block.name) && block.id) this.startSubagent(block.id, block.input ?? {}, emit);
           }
         }
         return;
       case "user":
-        for (const block of Array.isArray(msg.message?.content) ? msg.message.content : []) {
+        for (const block of blocksOf(msg)) {
           if (block.type !== "tool_result") continue;
+          const id = block.tool_use_id ?? "";
           const output = flattenContent(block.content);
-          if (output.includes(ASYNC_LAUNCH_MARKER)) {
-            emit({ type: "background_agent", id: block.tool_use_id ?? "" });
+          const subagent = subagentId ? void 0 : this.openSubagents.get(id);
+          if (!subagentId && output.includes(ASYNC_LAUNCH_MARKER)) {
+            emit({ type: "background_agent", id });
+            if (subagent) subagent.background = true;
+          } else if (subagent) {
+            this.finishForegroundSubagent(id, msg.tool_use_result, output, block.is_error === true, emit);
           }
-          emit({
-            type: "tool_result",
-            id: block.tool_use_id ?? "",
-            name: "",
-            output,
-            success: block.is_error !== true
-          });
+          emit({ type: "tool_result", id, name: "", output, success: block.is_error !== true, subagentId });
+        }
+        return;
+      case "system":
+        if (msg.subtype === "task_notification" && msg.tool_use_id && this.openSubagents.get(msg.tool_use_id)?.background) {
+          this.openSubagents.delete(msg.tool_use_id);
+          emit({ type: "subagent_finished", subagentId: msg.tool_use_id, outcome: notificationOutcome(msg.status), digest: msg.summary ?? "" });
         }
         return;
       case "result":
+        this.reportSessionCost(msg, emit);
         if (msg.is_error || msg.subtype && msg.subtype !== "success") {
           emit({ type: "error", message: msg.result?.trim() || `Claude Code ended the turn: ${msg.subtype ?? "error"}` });
         } else {
           emit({ type: "turn_end" });
         }
         return;
-      // `system`/`stream_event` carry init metadata and partial deltas. The
-      // session id is picked up above; partials are ignored because the
-      // complete blocks follow and would otherwise be counted twice.
+      case "stream_event":
+        if (msg.event && !subagentId) this.handleStreamEvent(msg.event, emit);
+        return;
       default:
         return;
     }
   }
+  startSubagent(id, input, emit) {
+    this.openSubagents.set(id, { background: false });
+    const brief = typeof input.description === "string" ? input.description : typeof input.prompt === "string" ? input.prompt : "";
+    emit({ type: "subagent_started", subagentId: id, brief, model: typeof input.model === "string" ? input.model : void 0 });
+  }
+  /**
+   * A subagent's messages do not stream, so each line's usage is the snapshot
+   * taken before generation: the prompt is real, the output a placeholder.
+   * Only the prompt side is reported — an absent output count reads as "not
+   * reported", a placeholder would read as a measurement.
+   */
+  handleSubagentMessage(msg, subagentId, emit) {
+    const messageId = msg.message?.id;
+    if (msg.message?.usage && messageId && !this.countedSubagentMessages.has(messageId)) {
+      this.countedSubagentMessages.add(messageId);
+      emit({ type: "usage", record: usageRecord({ ...msg.message.usage, output_tokens: void 0 }, msg.message.model, subagentId) });
+    }
+    for (const block of blocksOf(msg)) {
+      if (block.type === "thinking" && block.thinking) emit({ type: "thinking", text: block.thinking, subagentId });
+      else if (block.type === "tool_use" && block.name) {
+        emit({ type: "tool_call", id: block.id ?? block.name, name: block.name, args: block.input ?? {}, subagentId });
+      }
+    }
+  }
+  /**
+   * The `Agent` call returned, so the subagent is done. Its last call — the
+   * report — never appears as a line of its own; the result carries its
+   * complete usage instead.
+   */
+  finishForegroundSubagent(id, result, output, failed, emit) {
+    this.openSubagents.delete(id);
+    const finalCall = subagentFinalCall(result);
+    if (finalCall) emit({ type: "usage", record: usageRecord(finalCall.usage, finalCall.model, id) });
+    emit({ type: "subagent_finished", subagentId: id, outcome: failed ? "failed" : "done", digest: output });
+  }
+  /**
+   * Partial output of the planner's own message. The complete `assistant` line
+   * for each block follows its deltas and is authoritative for that block (see
+   * {@link AgentEvent}), so nothing here has to reconcile with it.
+   */
+  handleStreamEvent(event, emit) {
+    if (event.type === "message_start") this.plannerModel = event.message?.model;
+    else if (event.type === "message_delta" && event.usage) emit({ type: "usage", record: usageRecord(event.usage, this.plannerModel) });
+    else if (event.type === "content_block_start" && event.content_block?.type === "text") {
+      this.pendingBreak = this.turnHasText;
+    } else if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+      if (this.pendingBreak) emit({ type: "assistant_text_delta", text: "\n\n" });
+      this.pendingBreak = false;
+      emit({ type: "assistant_text_delta", text: event.delta.text });
+    } else if (event.type === "content_block_delta" && event.delta?.type === "thinking_delta" && event.delta.thinking) {
+      emit({ type: "thinking_delta", text: event.delta.thinking });
+    }
+  }
+  /**
+   * What only the result line knows: the cost, which covers every call the
+   * session made — subagents included, since none of their lines carries one —
+   * and the planner model's window. `total_cost_usd` is a running total, so a
+   * turn reports its growth. The first turn after a resume only sets the
+   * baseline: its total includes turns counted before, and a turn's own share
+   * cannot be told apart from them.
+   */
+  reportSessionCost(msg, emit) {
+    const record = { source: "claude-code" };
+    const total = msg.total_cost_usd;
+    if (typeof total === "number") {
+      if (this.reportedCostUsd !== void 0 && total > this.reportedCostUsd) {
+        record.reportedCost = { amount: total - this.reportedCostUsd, currency: "USD" };
+      }
+      this.reportedCostUsd = total;
+    }
+    const contextWindow = this.plannerModel ? msg.modelUsage?.[this.plannerModel]?.contextWindow : void 0;
+    if (contextWindow !== void 0) record.contextWindow = contextWindow;
+    if (record.reportedCost || record.contextWindow !== void 0) emit({ type: "usage", record });
+  }
 };
 
 // src/services/harness/codexSandbox.ts
@@ -11827,6 +12175,20 @@ function runProbe(deps, cwd, env, flags) {
 
 // src/services/harness/CodexAdapter.ts
 var HANDSHAKE_TIMEOUT_MS = 3e4;
+function subagentOutcome(status) {
+  switch (status) {
+    case "completed":
+      return "done";
+    case "errored":
+    case "notFound":
+      return "failed";
+    case "interrupted":
+    case "shutdown":
+      return "stopped";
+    default:
+      return void 0;
+  }
+}
 function flattenText(value) {
   if (typeof value === "string") return value;
   if (Array.isArray(value)) return value.map(flattenText).filter(Boolean).join("\n");
@@ -11860,6 +12222,8 @@ var ANNOUNCED_REQUESTS = /* @__PURE__ */ new Set([
 var CodexAdapter = class extends StdioAgentAdapter {
   agentId = "codex";
   threadId = null;
+  /** The model Codex opened the thread with — usage records name it. */
+  threadModel = null;
   nextRequestId = 100;
   settleHandshake = null;
   handshakeError = null;
@@ -11869,6 +12233,12 @@ var CodexAdapter = class extends StdioAgentAdapter {
   resumeAttempted = false;
   resumeFallbackSent = false;
   sandbox = "default";
+  /**
+   * Subagent threads this session has spawned, keyed by the child thread id.
+   * Codex runs a subagent in its own thread and replays both threads' events on
+   * one stream; the thread id is what tells them apart (see {@link subagentOf}).
+   */
+  subagents = /* @__PURE__ */ new Map();
   spawnSpec(opts) {
     this.startOpts = opts;
     return { command: "codex", args: ["app-server"] };
@@ -11979,6 +12349,8 @@ ${this.exitMessage()}`);
       }
       this.threadId = thread.id;
       this.sessionId = thread.id;
+      const model = msg.result?.model;
+      this.threadModel = typeof model === "string" ? model : null;
       this.settleHandshake?.(true);
       return;
     }
@@ -11988,13 +12360,40 @@ ${this.exitMessage()}`);
     }
     switch (msg.method) {
       case "item/started":
-        this.emitItemStart(msg.params?.item, emit);
+        this.emitItemStart(msg.params?.item, emit, this.subagentOf(msg.params?.threadId));
         return;
       case "item/completed":
-        this.emitItemDone(msg.params?.item, emit);
+        this.emitItemDone(msg.params?.item, emit, this.subagentOf(msg.params?.threadId));
+        return;
+      // Reply text streams before its completed item. The completed item is
+      // authoritative — the service replaces the deltas with it — so both are
+      // forwarded and no run is counted twice.
+      case "item/agentMessage/delta": {
+        const params = msg.params;
+        if (!params?.delta || this.subagentOf(params.threadId)) return;
+        emit({ type: "assistant_text_delta", text: params.delta });
+        return;
+      }
+      // `summaryTextDelta` streams a reasoning summary part, `textDelta` the raw
+      // reasoning. Both are thinking; the completed item repeats whichever it
+      // carries and is superseded by what streamed.
+      case "item/reasoning/summaryTextDelta":
+      case "item/reasoning/textDelta": {
+        const params = msg.params;
+        if (!params?.delta) return;
+        const subagentId = this.subagentOf(params.threadId);
+        emit({ type: "thinking_delta", text: params.delta, ...subagentId ? { subagentId } : {} });
+        return;
+      }
+      // Marks where one summary part ends and the next begins. The text arrives
+      // as deltas; the boundary carries none of its own.
+      case "item/reasoning/summaryPartAdded":
+        return;
+      case "thread/tokenUsage/updated":
+        this.emitUsage(msg.params, emit);
         return;
       case "turn/started":
-        this.turnHasText = false;
+        if (!this.subagentOf(msg.params?.threadId)) this.turnHasText = false;
         return;
       // Codex reports a setup problem once, at startup, and then plans anyway.
       // Surfacing it is enough: the warning is not always fatal, and refusing to
@@ -12013,12 +12412,14 @@ ${this.exitMessage()}`);
       // rate limit or an exhausted context window would otherwise hang until
       // the process died.
       case "error": {
+        if (this.subagentOf(msg.params?.threadId)) return;
         const failure = msg.params;
         if (failure?.willRetry) return;
         emit({ type: "error", message: failure?.error?.message || "Codex ended the turn with an error." });
         return;
       }
       case "turn/completed": {
+        if (this.subagentOf(msg.params?.threadId)) return;
         const turn = msg.params?.turn;
         if (turn?.status === "failed") {
           emit({ type: "error", message: turn.error?.message || "Codex ended the turn with an error." });
@@ -12027,12 +12428,64 @@ ${this.exitMessage()}`);
         }
         return;
       }
-      // Deltas (`item/agentMessage/delta`, `item/reasoning/*Delta`) are skipped:
-      // the completed item follows and would otherwise be counted twice.
+      // Deltas for command output and MCP progress are skipped: the completed
+      // item follows and would otherwise be counted twice.
       default:
         return;
     }
   }
+  /**
+   * The child thread id when `threadId` names a subagent's thread, or undefined
+   * for the planner's own. Codex replays both threads on one stream and only
+   * the thread id separates them; the first time a thread is seen it is
+   * registered so its usage and steps can be tagged with it as a subagent id.
+   */
+  subagentOf(threadId) {
+    if (typeof threadId !== "string" || !this.threadId || threadId === this.threadId) return void 0;
+    this.subagents.set(threadId, this.subagents.get(threadId) ?? {});
+    return threadId;
+  }
+  /**
+   * One usage record per model call, from `thread/tokenUsage/updated`.
+   *
+   * The notification carries two breakdowns: `total` is cumulative for the
+   * thread and `last` is the model call that just finished (verified against
+   * the installed binary — a two-call turn ends with `last` equal to the second
+   * call and `total` equal to both summed). Emitting `total` on each update
+   * would count every earlier call again, so `last` is the record. Mapping
+   * `last.outputTokens` already includes `reasoningOutputTokens` — the thread
+   * total is `inputTokens + outputTokens`, not a sum of three — so reasoning is
+   * not added a second time. Codex reports no price.
+   */
+  emitUsage(params, emit) {
+    const last = params?.tokenUsage?.last;
+    if (!last) return;
+    const subagentId = this.subagentOf(params?.threadId);
+    const record = { source: this.agentId };
+    const model = subagentId ? this.subagents.get(subagentId)?.model : this.threadModel ?? this.startOpts?.model;
+    if (model) record.model = model;
+    let hasMeasure = false;
+    if (last.inputTokens !== void 0) {
+      record.inputTokens = last.inputTokens;
+      hasMeasure = true;
+    }
+    if (last.outputTokens !== void 0) {
+      record.outputTokens = last.outputTokens;
+      hasMeasure = true;
+    }
+    if (last.cachedInputTokens !== void 0) {
+      record.cachedInputTokens = last.cachedInputTokens;
+      hasMeasure = true;
+    }
+    if (!hasMeasure) return;
+    if (subagentId) {
+      record.subagentId = subagentId;
+    } else {
+      const window = params?.tokenUsage?.modelContextWindow;
+      if (typeof window === "number" && window > 0) record.contextWindow = window;
+    }
+    emit({ type: "usage", record });
+  }
   /**
    * Refuse one server→client request. Requests whose result schema can express
    * a refusal get that payload; everything else — a permission grant, a
@@ -12064,35 +12517,49 @@ ${this.exitMessage()}`);
     });
   }
   /** A tool item entering `inProgress` — announce the call so the timeline moves. */
-  emitItemStart(item, emit) {
+  emitItemStart(item, emit, subagentId) {
     if (!item?.id) return;
     switch (item.type) {
       case "commandExecution":
-        emit({ type: "tool_call", id: item.id, name: "shell", args: { command: item.command, cwd: item.cwd } });
+        emit({ type: "tool_call", id: item.id, name: "shell", args: { command: item.command, cwd: item.cwd }, ...subagentId ? { subagentId } : {} });
         return;
       case "mcpToolCall":
-        emit({ type: "tool_call", id: item.id, name: item.tool ?? "mcp_tool", args: item.arguments ?? {} });
+        emit({ type: "tool_call", id: item.id, name: item.tool ?? "mcp_tool", args: item.arguments ?? {}, ...subagentId ? { subagentId } : {} });
         return;
       case "dynamicToolCall":
-        emit({ type: "tool_call", id: item.id, name: item.tool ?? "tool", args: item.arguments ?? {} });
+        emit({ type: "tool_call", id: item.id, name: item.tool ?? "tool", args: item.arguments ?? {}, ...subagentId ? { subagentId } : {} });
         return;
       case "webSearch":
-        emit({ type: "tool_call", id: item.id, name: "web_search", args: { query: item.query } });
+        emit({ type: "tool_call", id: item.id, name: "web_search", args: { query: item.query }, ...subagentId ? { subagentId } : {} });
+        return;
+      // Delegation is a tool call like any other: the planner's own call is
+      // unparented, and shows in the timeline as the agent tool it really is.
+      case "collabAgentToolCall":
+        emit({
+          type: "tool_call",
+          id: item.id,
+          name: item.tool ?? "collab",
+          args: { prompt: item.prompt, model: item.model, receiverThreadIds: item.receiverThreadIds }
+        });
         return;
       default:
         return;
     }
   }
-  emitItemDone(item, emit) {
+  emitItemDone(item, emit, subagentId) {
     if (!item?.type) return;
     const id = item.id ?? "";
+    if (item.type === "collabAgentToolCall") {
+      this.emitCollabItem(item, id, emit);
+      return;
+    }
     switch (item.type) {
       // A Codex turn is several whole messages — progress commentary, then the
       // final answer — not a token stream. Concatenated raw they run together
       // ("…as requested.`head` failed because…"), so each one after the first
       // opens a paragraph.
       case "agentMessage":
-        if (!item.text) return;
+        if (subagentId || !item.text) return;
         emit({ type: "assistant_text", text: this.turnHasText ? `
 
 ${item.text}` : item.text });
@@ -12100,7 +12567,7 @@ ${item.text}` : item.text });
         return;
       case "reasoning": {
         const text = flattenText(item.summary) || flattenText(item.content) || item.text || "";
-        if (text.trim()) emit({ type: "thinking", text });
+        if (text.trim()) emit({ type: "thinking", text, ...subagentId ? { subagentId } : {} });
         return;
       }
       case "commandExecution":
@@ -12109,7 +12576,8 @@ ${item.text}` : item.text });
           id,
           name: "shell",
           output: item.aggregatedOutput ?? "",
-          success: (item.exitCode ?? 0) === 0
+          success: (item.exitCode ?? 0) === 0,
+          ...subagentId ? { subagentId } : {}
         });
         return;
       case "mcpToolCall":
@@ -12119,23 +12587,60 @@ ${item.text}` : item.text });
           id,
           name: item.tool ?? "tool",
           output: item.error ?? flattenText(item.result) ?? "",
-          success: item.status !== "error" && item.success !== false && !item.error
+          success: item.status !== "error" && item.success !== false && !item.error,
+          ...subagentId ? { subagentId } : {}
         });
         return;
       // The query is empty when the search starts and filled when it lands, so
       // the result — not the call — is what carries what was actually searched.
       case "webSearch":
-        emit({ type: "tool_result", id, name: "web_search", output: item.query ?? "", success: true });
+        emit({ type: "tool_result", id, name: "web_search", output: item.query ?? "", success: true, ...subagentId ? { subagentId } : {} });
         return;
       // `fileChange` can only appear if the read-only sandbox was bypassed;
       // reporting it keeps that visible rather than silent.
       case "fileChange":
-        emit({ type: "tool_result", id, name: "file_change", output: JSON.stringify(item), success: false });
+        emit({ type: "tool_result", id, name: "file_change", output: JSON.stringify(item), success: false, ...subagentId ? { subagentId } : {} });
         return;
       default:
         return;
     }
   }
+  /**
+   * A `collabAgentToolCall` — the planner spawning, waiting on or messaging a
+   * subagent. The call itself is planner-level tool activity; the lifecycle it
+   * carries becomes `subagent_started` / `subagent_finished`, restated as
+   * often as Codex restates it — the service reports each once. Codex tags
+   * every collab item with the parent thread, so this one never runs for a
+   * subagent.
+   */
+  emitCollabItem(item, id, emit) {
+    if (item.tool === "spawnAgent") {
+      for (const child of item.receiverThreadIds ?? []) {
+        const model = item.model || void 0;
+        this.subagents.set(child, { model });
+        emit({ type: "subagent_started", subagentId: child, brief: item.prompt ?? "", ...model ? { model } : {} });
+      }
+    }
+    for (const [child, state] of Object.entries(item.agentsStates ?? {})) {
+      const outcome = subagentOutcome(state?.status);
+      if (!outcome) continue;
+      this.subagents.set(child, this.subagents.get(child) ?? {});
+      emit({ type: "subagent_finished", subagentId: child, outcome, digest: state?.message ?? "" });
+    }
+    emit({
+      type: "tool_result",
+      id,
+      name: item.tool ?? "collab",
+      output: this.collabSummary(item),
+      success: item.status !== "failed" && item.status !== "interrupted"
+    });
+  }
+  /** The readable result of a collab call: the brief it sent, or what came back. */
+  collabSummary(item) {
+    const agents = Object.values(item.agentsStates ?? {}).map((state) => state?.message).filter((message) => !!message);
+    if (agents.length) return agents.join("\n");
+    return item.prompt ?? "";
+  }
 };
 
 // src/services/harness/OpenCodeAdapter.ts
@@ -12173,6 +12678,30 @@ function describeError(err) {
   }
   return lines.join(": ");
 }
+function flatModelId(providerID, modelID) {
+  return providerID && modelID ? `${providerID}/${modelID}` : void 0;
+}
+function usageRecord2(info, subagentId) {
+  const tokens = info.tokens;
+  if (!tokens) return null;
+  const prompt = partedPromptUsage({ uncached: tokens.input, cacheRead: tokens.cache?.read, cacheWrite: tokens.cache?.write });
+  const outputTokens = (tokens.output ?? 0) + (tokens.reasoning ?? 0);
+  if ((prompt.inputTokens ?? 0) + outputTokens === 0) return null;
+  const record = { source: "opencode", ...prompt, outputTokens };
+  const model = flatModelId(info.providerID, info.modelID);
+  if (model) record.model = model;
+  if (typeof info.cost === "number" && info.cost > 0) record.reportedCost = { amount: info.cost, currency: "USD" };
+  if (subagentId) record.subagentId = subagentId;
+  return record;
+}
+function taskDigest(output) {
+  const inner = output.match(/<task_result>\n?([\s\S]*?)\n?<\/task_result>/);
+  return inner ? inner[1] : output;
+}
+function unwrapFileToolOutput(output) {
+  const inner = output.match(/<content>\n?([\s\S]*?)\n?<\/content>/);
+  return inner ? inner[1] : output;
+}
 function delay(ms, signal) {
   return new Promise((resolve7) => {
     const timer = setTimeout(resolve7, ms);
@@ -12268,7 +12797,14 @@ ${this.stderrTail.trim()}` : ""}`);
       onEvent({ type: "error", message: this.exitMessage() });
       return;
     }
-    const seen = /* @__PURE__ */ new Set();
+    const turn = {
+      seen: /* @__PURE__ */ new Set(),
+      assistantMessages: /* @__PURE__ */ new Set(),
+      partTypes: /* @__PURE__ */ new Map(),
+      textRuns: /* @__PURE__ */ new Map(),
+      children: /* @__PURE__ */ new Map(),
+      heldFrames: /* @__PURE__ */ new Map()
+    };
     this.turnHasText = false;
     const streamAbort = new AbortController();
     let connected = () => {
@@ -12276,15 +12812,7 @@ ${this.stderrTail.trim()}` : ""}`);
     const streamReady = new Promise((resolve7) => {
       connected = resolve7;
     });
-    const live = this.streamEvents(
-      streamAbort.signal,
-      (part) => {
-        if (part.type === "tool") this.emitPart(part, seen, onEvent);
-      },
-      (ask) => this.denyPermission(ask, seen, onEvent),
-      connected,
-      onActivity
-    );
+    const live = this.streamEvents(streamAbort.signal, (frame) => this.onFrame(frame, turn, onEvent), connected, onActivity);
     await Promise.race([streamReady, new Promise((r) => {
       const t = setTimeout(r, STREAM_CONNECT_TIMEOUT_MS);
       t.unref?.();
@@ -12305,7 +12833,7 @@ ${this.stderrTail.trim()}` : ""}`);
         this.dispose();
         return;
       }
-      this.settle(reply, seen, onEvent);
+      this.settle(reply, turn, onEvent);
     } catch (err) {
       if (signal?.aborted) {
         this.dispose();
@@ -12313,7 +12841,7 @@ ${this.stderrTail.trim()}` : ""}`);
       }
       const recovered = this.exited ? null : await this.recoverReply(signal, onActivity);
       if (recovered) {
-        this.settle(recovered, seen, onEvent);
+        this.settle(recovered, turn, onEvent);
         return;
       }
       onEvent({ type: "error", message: `The OpenCode planner turn failed: ${describeError(err)}` });
@@ -12326,11 +12854,16 @@ ${this.stderrTail.trim()}` : ""}`);
   /**
    * Turn one settled assistant message into events. The settled response is
    * authoritative: it names the assistant message, so its parts are the ones
-   * that make up the reply. Tool parts already seen live are deduplicated by
-   * call id; anything the stream missed (including a stream that never
-   * connected) arrives here.
+   * that make up the reply. Parts already completed live are deduplicated;
+   * anything the stream missed (including a stream that never connected)
+   * arrives here.
+   *
+   * It is only the turn's *last* message, though. OpenCode writes one
+   * assistant message per model call, so the calls before the final one —
+   * their text, reasoning and usage — reach Ordewell over the stream or not at
+   * all.
    */
-  settle(reply, seen, onEvent) {
+  settle(reply, turn, onEvent) {
     const failure = typeof reply?.error === "string" ? reply.error : reply?.error?.message ?? reply?.info?.error?.data?.message;
     if (failure) {
       onEvent({ type: "error", message: failure });
@@ -12339,8 +12872,9 @@ ${this.stderrTail.trim()}` : ""}`);
     const assistantId = reply?.info?.id;
     for (const part of reply?.parts ?? []) {
       if (part.type !== "tool" && assistantId && part.messageID !== assistantId) continue;
-      this.emitPart(part, seen, onEvent);
+      this.emitPart(part, turn, onEvent);
     }
+    if (reply?.info) this.countUsage(reply.info, turn, onEvent);
     if (assistantId) this.lastAssistantId = assistantId;
     onEvent({ type: "turn_end" });
   }
@@ -12376,26 +12910,29 @@ ${this.stderrTail.trim()}` : ""}`);
     return null;
   }
   /**
-   * Emit one message part, once. OpenCode reports a tool part repeatedly as it
-   * moves through pending → running → completed, so parts are keyed by id and
-   * only the terminal state produces a result.
+   * Emit one complete message part, once. OpenCode reports a tool part
+   * repeatedly as it moves through pending → running → completed, so parts are
+   * keyed by id and only the terminal state produces a result. A subagent's
+   * text is its report to the planner, not the reply, so it is dropped; the
+   * `task` call's result carries it.
    */
-  emitPart(part, seen, onEvent) {
+  emitPart(part, turn, onEvent, subagentId) {
     if (!part?.type) return;
+    const { seen } = turn;
     const id = part.id ?? part.callID ?? "";
-    if (part.type === "text" && part.text) {
+    if (part.type === "text" && part.text && !subagentId) {
       if (seen.has(`text:${id}`)) return;
       seen.add(`text:${id}`);
-      onEvent({ type: "assistant_text", text: this.turnHasText ? `
-
-${part.text}` : part.text });
+      if (!part.text.trim()) return;
+      const lead = turn.textRuns.get(id)?.lead ?? (this.turnHasText ? "\n\n" : "");
+      onEvent({ type: "assistant_text", text: `${lead}${part.text}` });
       this.turnHasText = true;
       return;
     }
     if (part.type === "reasoning" && part.text) {
       if (seen.has(`reasoning:${id}`)) return;
       seen.add(`reasoning:${id}`);
-      onEvent({ type: "thinking", text: part.text });
+      onEvent({ type: "thinking", text: part.text, subagentId });
       return;
     }
     if (part.type !== "tool") return;
@@ -12405,19 +12942,131 @@ ${part.text}` : part.text });
     const input = part.state?.input;
     if (!seen.has(`call:${callId}`) && (status !== "pending" || input && Object.keys(input).length > 0)) {
       seen.add(`call:${callId}`);
-      onEvent({ type: "tool_call", id: callId, name, args: input ?? {} });
+      onEvent({ type: "tool_call", id: callId, name, args: input ?? {}, subagentId });
     }
+    if (name === "task" && !subagentId) this.trackSubagent(part, callId, turn, onEvent);
     if ((status === "completed" || status === "error") && !seen.has(`result:${callId}`)) {
       seen.add(`result:${callId}`);
       onEvent({
         type: "tool_result",
         id: callId,
         name,
-        output: part.state?.output ?? part.state?.error ?? "",
-        success: status === "completed"
+        output: unwrapFileToolOutput(part.state?.output ?? part.state?.error ?? ""),
+        success: status === "completed",
+        subagentId
       });
     }
   }
+  /**
+   * A `task` call runs a subagent in a child session. The call's part names
+   * that session once it exists, which is what ties the child's frames to the
+   * call; the subagent ends when the call does. The part is restated at every
+   * status change, and so is what it says here — the service reports each
+   * start and finish once, and no finish for a call that never had a child.
+   */
+  trackSubagent(part, callId, turn, onEvent) {
+    const state = part.state;
+    const child = state?.metadata?.sessionId;
+    if (child && !turn.children.get(child)) {
+      const input = state?.input ?? {};
+      const brief = typeof input.description === "string" ? input.description : typeof input.prompt === "string" ? input.prompt : "";
+      const model = flatModelId(state?.metadata?.model?.providerID, state?.metadata?.model?.modelID);
+      onEvent({ type: "subagent_started", subagentId: callId, brief, ...model ? { model } : {} });
+      turn.children.set(child, callId);
+      const held = turn.heldFrames.get(child) ?? [];
+      turn.heldFrames.delete(child);
+      for (const frame of held) this.onFrame(frame, turn, onEvent);
+    }
+    const status = state?.status;
+    if (status === "completed" || status === "error") {
+      onEvent({
+        type: "subagent_finished",
+        subagentId: callId,
+        outcome: status === "completed" ? "done" : "failed",
+        digest: taskDigest(state?.output ?? state?.error ?? "")
+      });
+    }
+  }
+  /**
+   * One message's usage, once, when it has completed. Every assistant message
+   * is one model call; until it completes its counts are zeros.
+   */
+  countUsage(info, turn, onEvent, subagentId) {
+    if (info.role !== "assistant" || !info.id || !info.time?.completed || turn.seen.has(`usage:${info.id}`)) return;
+    turn.seen.add(`usage:${info.id}`);
+    const record = usageRecord2(info, subagentId);
+    if (record) onEvent({ type: "usage", record });
+  }
+  /**
+   * One `/event` frame. Only the planner's session and its children are
+   * followed: the server's stream is global, and another client's session is
+   * none of this turn's business.
+   */
+  onFrame(frame, turn, onEvent) {
+    const props = frame.properties;
+    if (!props) return;
+    if (frame.type === "session.created") {
+      if (props.info?.parentID === this.sessionId && props.info.id && !turn.children.has(props.info.id)) turn.children.set(props.info.id, null);
+      return;
+    }
+    const session = props.sessionID;
+    if (session && session !== this.sessionId && !turn.children.has(session)) return;
+    if (frame.type === "permission.asked" || frame.type === "permission.v2.asked") {
+      this.denyPermission(props, turn.seen, onEvent);
+      return;
+    }
+    let subagentId;
+    if (session && session !== this.sessionId) {
+      const owner = turn.children.get(session);
+      if (!owner) {
+        turn.heldFrames.set(session, [...turn.heldFrames.get(session) ?? [], frame]);
+        return;
+      }
+      subagentId = owner;
+    }
+    if (frame.type === "message.updated" && props.info) {
+      if (props.info.role === "assistant" && props.info.id) turn.assistantMessages.add(props.info.id);
+      this.countUsage(props.info, turn, onEvent, subagentId);
+      return;
+    }
+    if (frame.type === "message.part.delta") {
+      if (props.field !== "text" || !props.partID || !props.delta) return;
+      if (!props.messageID || !turn.assistantMessages.has(props.messageID)) return;
+      const type = turn.partTypes.get(props.partID);
+      if (type === "reasoning") onEvent({ type: "thinking_delta", text: props.delta, subagentId });
+      else if (type === "text" && !subagentId) this.onTextDelta(props.partID, props.delta, turn, onEvent);
+      return;
+    }
+    const part = props.part;
+    if (!part) return;
+    if (part.type === "tool") {
+      this.emitPart(part, turn, onEvent, subagentId);
+      return;
+    }
+    if (!part.id || !part.messageID || !turn.assistantMessages.has(part.messageID)) return;
+    if (part.type === "text" || part.type === "reasoning") turn.partTypes.set(part.id, part.type);
+    if (part.time?.end) this.emitPart(part, turn, onEvent, subagentId);
+  }
+  /**
+   * Stream one piece of a reply text part. The part's paragraph break goes out
+   * with its first visible delta, so the deltas add up to exactly the text the
+   * completed part then re-sends; a part that is only whitespace so far is
+   * held back, for the reason {@link emitPart} drops one.
+   */
+  onTextDelta(partId, delta, turn, onEvent) {
+    if (turn.seen.has(`text:${partId}`)) return;
+    const run = turn.textRuns.get(partId) ?? { held: "", lead: null };
+    turn.textRuns.set(partId, run);
+    if (run.lead !== null) {
+      onEvent({ type: "assistant_text_delta", text: delta });
+      return;
+    }
+    run.held += delta;
+    if (!run.held.trim()) return;
+    run.lead = this.turnHasText ? "\n\n" : "";
+    this.turnHasText = true;
+    onEvent({ type: "assistant_text_delta", text: `${run.lead}${run.held}` });
+  }
   /**
    * Deny one permission request (T1). OpenCode blocks the turn until the
    * request is answered, so this must answer — `reject` rather than a silent
@@ -12441,11 +13090,11 @@ ${part.text}` : part.text });
     });
   }
   /**
-   * Server-sent events from `/event`. Tool activity on it is liveness only —
-   * the settled POST repeats it — but permission requests arrive nowhere else,
+   * Server-sent events from `/event`: the turn's live text, reasoning, tool
+   * activity and usage, and the only channel permission requests arrive on —
    * so the stream is load-bearing for {@link denyPermission}.
    */
-  async streamEvents(signal, onPart, onPermission, onConnected, onActivity) {
+  async streamEvents(signal, onFrame, onConnected, onActivity) {
     const response = await this.deps.fetch(`${this.baseUrl}/event`, { signal }).catch(() => null);
     const body = response?.body;
     if (!body) {
@@ -12467,12 +13116,7 @@ ${part.text}` : part.text });
         buffer = buffer.slice(newline + 1);
         if (!line.startsWith("data:")) continue;
         try {
-          const event = JSON.parse(line.slice(5).trim());
-          const props = event.properties;
-          if (!props) continue;
-          if (props.sessionID && props.sessionID !== this.sessionId) continue;
-          if (event.type === "permission.asked" || event.type === "permission.v2.asked") onPermission(props);
-          else if (props.part) onPart(props.part);
+          onFrame(JSON.parse(line.slice(5).trim()));
         } catch {
         }
       }
@@ -12556,8 +13200,16 @@ function normalizeAgentArgs(tool, args) {
 }
 
 // src/services/harness/CliAgentAiService.ts
-var MAX_JSON_REPAIRS = 2;
 var MAX_AGENT_WAITS = 2;
+function waitForAgentsPrompt(running) {
+  return [
+    `You ended your turn with ${running} subagent(s) still running in the background.`,
+    "Ordewell hands the conversation back to the user when your turn ends, so anything you say after it never reaches them \u2014",
+    "the results you promised to report would be lost.",
+    "Wait for those agents to finish NOW, in this reply, and do not end your turn until you have their results.",
+    "Then give the user your synthesis. In future replies, await your agents inside the turn rather than backgrounding them."
+  ].join(" ");
+}
 var LOG_MAX_CHARS = 1e4;
 function defaultAdapter(runner, deps) {
   switch (runner) {
@@ -12602,6 +13254,12 @@ var CliAgentAiService = class {
   lastNativeSessionId = null;
   conversation = null;
   activeAbort = null;
+  /**
+   * Every subagent this conversation has reported starting, and finishing.
+   * Agents restate a subagent's state as it changes, and one can finish a turn
+   * or a process restart after it started; surfaces get each once, in order.
+   */
+  subagents = { started: /* @__PURE__ */ new Set(), finished: /* @__PURE__ */ new Set() };
   hasActiveConversation() {
     return this.conversation !== null;
   }
@@ -12628,6 +13286,8 @@ var CliAgentAiService = class {
     this.adapter = null;
     this.lastNativeSessionId = null;
     this.conversation = null;
+    this.subagents.started.clear();
+    this.subagents.finished.clear();
   }
   // --- Conversation (ADR-0002) ---
   async startConversation(req) {
@@ -12680,98 +13340,50 @@ var CliAgentAiService = class {
     ].join("\n");
   }
   /**
-   * Drive one user message to a settled planner turn. Same shape as the API
-   * backend's conversation loop minus the tool rounds — those belong to the
-   * agent now — and with the same two policies layered on top: the
-   * empty-reply nudge, and a bounded corrective re-emit for botched JSON.
+   * Drive one user message to a settled planner turn through
+   * {@link settleReply}, the loop the API backend settles through too. The
+   * tool rounds belong to the agent now, so one call is one agent turn —
+   * continued while it left subagents running in the background.
    */
   async runConversation(message, onProgress, signal) {
     const conversation = this.conversation;
-    const combined = this.startAbortScope(signal);
-    const researchLog = [];
-    let pending = message;
-    let emptyNudgeSent = false;
-    let jsonRepairAttempts = 0;
+    this.activeAbort = abortScope(signal);
+    const combined = this.activeAbort.signal;
     let agentWaits = 0;
     const carried = [];
-    const replyText = (text) => [...carried, text].filter((part) => part.trim()).join("\n\n");
-    try {
-      for (; ; ) {
-        const turn = await this.runTurn(pending, onProgress, combined);
+    const send = async (text) => {
+      let turn = await this.runTurn(text, onProgress, combined);
+      const researchLog = [...turn.researchLog];
+      while (turn.backgroundAgents > 0 && agentWaits < MAX_AGENT_WAITS && turn.text.trim() && !turn.error && !turn.aborted && !combined?.aborted) {
+        agentWaits++;
+        carried.push(turn.text);
+        turn = await this.runTurn(waitForAgentsPrompt(turn.backgroundAgents), onProgress, combined);
         researchLog.push(...turn.researchLog);
-        if (turn.aborted || combined?.aborted) {
-          onProgress({ type: "interrupted" });
-          return { kind: "message", text: replyText(turn.text), researchLog };
-        }
-        if (turn.error) {
-          return { kind: "message", text: turn.error, researchLog };
-        }
-        if (!turn.text.trim()) {
-          const refused2 = turn.researchLog.find((step) => step.outcome === "denied");
-          if (!emptyNudgeSent) {
-            emptyNudgeSent = true;
-            pending = refused2 ? `Your last reply was empty because "${refused2.toolLabel ?? refused2.tool}" was refused: you are planning read-only and confined to this workspace. Do not retry it. Answer the user now with what you already know, or ask your next question.` : "Your last reply was empty. Respond to the user now: answer their last message directly, ask your next question, or emit the plan JSON.";
-            continue;
-          }
-          return {
-            kind: "message",
-            text: refused2 ? `The planner stopped without replying: "${refused2.toolLabel ?? refused2.tool}" was refused because planning is read-only and confined to this workspace.` : "The planner returned an empty reply twice. Please rephrase or try again.",
-            researchLog
-          };
-        }
-        if (turn.backgroundAgents > 0 && agentWaits < MAX_AGENT_WAITS && !combined?.aborted) {
-          agentWaits++;
-          carried.push(turn.text);
-          pending = [
-            `You ended your turn with ${turn.backgroundAgents} subagent(s) still running in the background.`,
-            "Ordewell hands the conversation back to the user when your turn ends, so anything you say after it never reaches them \u2014",
-            "the results you promised to report would be lost.",
-            "Wait for those agents to finish NOW, in this reply, and do not end your turn until you have their results.",
-            "Then give the user your synthesis. In future replies, await your agents inside the turn rather than backgrounding them."
-          ].join(" ");
-          continue;
-        }
-        const reply = classifyPlannerReply(turn.text, {
-          runners: conversation.runners,
-          runnerModes: conversation.runnerModes,
-          autonomousDefault: conversation.autonomousDefault
-        });
-        switch (reply.kind) {
-          case "task_ops":
-            return { kind: "task_ops", ops: reply.ops, text: replyText(turn.text), researchLog };
-          // The read channel is a text envelope precisely so it reaches here
-          // too: a harness planner has no Ordewell tool loop to call into.
-          case "task_query":
-            return { kind: "task_query", query: reply.query, text: replyText(turn.text), researchLog };
-          case "plan":
-            this.conversation = null;
-            return { kind: "plan", tasks: reply.tasks, text: replyText(turn.text), researchLog };
-          case "broken_task_ops":
-            if (jsonRepairAttempts < MAX_JSON_REPAIRS && !combined?.aborted) {
-              jsonRepairAttempts++;
-              pending = reEmitTaskOpsPrompt(reply.error.message);
-              continue;
-            }
-            break;
-          case "broken_task_query":
-            if (jsonRepairAttempts < MAX_JSON_REPAIRS && !combined?.aborted) {
-              jsonRepairAttempts++;
-              pending = reEmitTaskQueryPrompt(reply.error.message);
-              continue;
-            }
-            break;
-          case "broken_plan":
-            if (jsonRepairAttempts < MAX_JSON_REPAIRS && !combined?.aborted) {
-              jsonRepairAttempts++;
-              pending = reEmitPlanPrompt(reply.error.message);
-              continue;
-            }
-            break;
-          case "prose":
-            break;
-        }
-        return { kind: "message", text: replyText(turn.text), researchLog };
       }
+      return {
+        text: turn.text,
+        researchLog,
+        aborted: turn.aborted || combined?.aborted,
+        // Fail visibly, per the repo's fail-safe contract: an agent that died,
+        // hit its rate limit, or lost its login must say so in the chat rather
+        // than leave an empty planner bubble.
+        failure: turn.error,
+        fullText: [...carried, turn.text].filter((part) => part.trim()).join("\n\n")
+      };
+    };
+    try {
+      const turn = await settleReply({
+        message,
+        send,
+        classify: { runners: conversation.runners, runnerModes: conversation.runnerModes, autonomousDefault: conversation.autonomousDefault },
+        onProgress,
+        signal: combined,
+        // `runTurn` folds every run of text the agent's turn produced into its
+        // reply, a tool call's earlier segment included.
+        replyJoinsSegments: true
+      });
+      if (turn.kind === "plan") this.conversation = null;
+      return turn;
     } finally {
       this.activeAbort = null;
     }
@@ -12788,15 +13400,25 @@ var CliAgentAiService = class {
     const pendingCalls = /* @__PURE__ */ new Map();
     const researchLog = [];
     let text = "";
+    let streamedRun = "";
+    let segmentId = uuidv44();
+    const commitRun = () => {
+      text += streamedRun;
+      streamedRun = "";
+      segmentId = uuidv44();
+    };
+    const streamedThinking = /* @__PURE__ */ new Set();
+    const subagentUsage = /* @__PURE__ */ new Map();
     let error;
     let stepIndex = 0;
     let backgroundAgents = 0;
     const truncate = (value) => value.length > LOG_MAX_CHARS ? `${value.slice(0, LOG_MAX_CHARS)}
 [... truncated, total ${value.length} chars]` : value;
-    const settle = (id, rawOutput, success, outcome) => {
+    const settle = (id, rawOutput, success, outcome, reportedBy) => {
       const output = redactSecrets(rawOutput);
       const call = pendingCalls.get(id);
       pendingCalls.delete(id);
+      const subagentId = call?.subagentId ?? reportedBy;
       const step = {
         id: `rs-${Date.now()}-${stepIndex++}`,
         tool: call?.tool ?? "agent_tool",
@@ -12806,29 +13428,63 @@ var CliAgentAiService = class {
         success,
         outcome,
         toolCallId: id,
+        subagentId,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       researchLog.push(step);
-      onProgress({ type: "tool_result", toolResult: output, step, toolCallId: id });
+      onProgress({ type: "tool_result", toolResult: output, step, toolCallId: id, subagentId });
     };
     await adapter.send(message, (event) => {
       switch (event.type) {
+        case "assistant_text_delta":
+          streamedRun += event.text;
+          onProgress({ type: "text_delta", text: event.text, segmentId });
+          return;
         case "assistant_text":
           text += event.text;
-          onProgress({ type: "plan_token", planToken: event.text });
+          if (streamedRun) streamedRun = "";
+          else onProgress({ type: "text_delta", text: event.text, segmentId });
+          return;
+        case "thinking_delta":
+          streamedThinking.add(event.subagentId ?? "");
+          onProgress({ type: "thinking", text: event.text, subagentId: event.subagentId });
           return;
         case "thinking":
-          onProgress({ type: "thinking", text: event.text });
+          if (!streamedThinking.delete(event.subagentId ?? "")) onProgress({ type: "thinking", text: event.text, subagentId: event.subagentId });
           return;
         case "tool_call": {
+          if (!event.subagentId) commitRun();
           const mapped = mapAgentTool(event.name);
           const args = JSON.stringify(normalizeAgentArgs(mapped.tool, event.args));
-          pendingCalls.set(event.id, { tool: mapped.tool, toolLabel: mapped.toolLabel, args });
-          onProgress({ type: "tool_call", tool: mapped.tool, toolLabel: mapped.toolLabel, toolArgs: args, toolCallId: event.id });
+          const subagentId = event.subagentId;
+          pendingCalls.set(event.id, { tool: mapped.tool, toolLabel: mapped.toolLabel, args, subagentId });
+          onProgress({ type: "tool_call", tool: mapped.tool, toolLabel: mapped.toolLabel, toolArgs: args, toolCallId: event.id, subagentId });
           return;
         }
         case "tool_result":
-          settle(event.id, event.output, event.success, event.success ? "success" : "failure");
+          settle(event.id, event.output, event.success, event.success ? "success" : "failure", event.subagentId);
+          return;
+        case "usage": {
+          const { subagentId } = event.record;
+          if (subagentId) subagentUsage.set(subagentId, addUsage(subagentUsage.get(subagentId) ?? {}, event.record));
+          onProgress({ type: "usage", record: event.record });
+          return;
+        }
+        case "subagent_started":
+          if (this.subagents.started.has(event.subagentId)) return;
+          this.subagents.started.add(event.subagentId);
+          onProgress({ type: "subagent_started", subagentId: event.subagentId, brief: event.brief, model: event.model });
+          return;
+        case "subagent_finished":
+          if (!this.subagents.started.has(event.subagentId) || this.subagents.finished.has(event.subagentId)) return;
+          this.subagents.finished.add(event.subagentId);
+          onProgress({
+            type: "subagent_finished",
+            subagentId: event.subagentId,
+            outcome: event.outcome,
+            digest: event.digest,
+            usage: subagentUsage.get(event.subagentId)
+          });
           return;
         case "background_agent":
           backgroundAgents++;
@@ -12855,6 +13511,7 @@ var CliAgentAiService = class {
           return;
       }
     }, signal, () => onProgress({ type: "liveness" }));
+    commitRun();
     for (const id of [...pendingCalls.keys()]) {
       settle(id, "The agent ended the turn without reporting this call's result.", false, "not_executed");
     }
@@ -12886,16 +13543,6 @@ var CliAgentAiService = class {
     await this.startAdapter({ ...conversation.startOptions, resumeSessionId: this.lastNativeSessionId ?? void 0 });
     return this.adapter;
   }
-  startAbortScope(callerSignal) {
-    this.activeAbort = new AbortController();
-    if (!callerSignal) return this.activeAbort.signal;
-    if (callerSignal.aborted) {
-      this.activeAbort.abort();
-      return this.activeAbort.signal;
-    }
-    callerSignal.addEventListener("abort", () => this.activeAbort?.abort(), { once: true });
-    return this.activeAbort.signal;
-  }
   plannerModel() {
     const id = (this.config.orchestratorModel ?? "").trim();
     return id || void 0;
@@ -12904,7 +13551,9 @@ var CliAgentAiService = class {
   /**
    * A single agent session that answers one prompt and exits. Used by every
    * non-conversational entry point; the plan is parsed from the reply text by
-   * the same extractor the conversational path uses.
+   * the same extractor the conversational path uses. Its envelope streams to
+   * the plan display, as a vendor planner's one-shot does, and the prose
+   * around it is not streamed at all, since no turn is open to show it in.
    */
   async oneShot(prompt, onProgress, signal) {
     const previous = this.adapter;
@@ -12924,10 +13573,14 @@ var CliAgentAiService = class {
         startOptions,
         runners: []
       };
+      const splitter = new ReplySplitter();
       const turn = await this.runTurn(
         "Follow the instructions in your system prompt and produce the plan now.",
-        onProgress ?? (() => {
-        }),
+        (p) => {
+          if (p.type !== "text_delta") return onProgress?.(p);
+          const routed = p.segmentId && p.text ? splitter.push(p.segmentId, p.text) : null;
+          if (routed?.route === "plan") onProgress?.({ type: "plan_token", planToken: routed.text, segmentId: p.segmentId });
+        },
         signal
       );
       if (turn.error) throw new Error(turn.error);
@@ -13030,6 +13683,9 @@ function createAiService(config, deps) {
   return new OpenAiService(config);
 }
 
+// src/services/PlannerConversation.ts
+import { v4 as uuidv45 } from "uuid";
+
 // src/services/conversationSummary.ts
 var KEPT_USER_MESSAGES = 2;
 var SUMMARY_OPEN = "<conversation_summary>";
@@ -13090,6 +13746,7 @@ var PlannerConversation = class {
   persisted = 0;
   turnsInFlight = 0;
   compacting = false;
+  openTurnId = null;
   get transcript() {
     return this.host.plan()?.conversationHistory ?? [];
   }
@@ -13097,6 +13754,10 @@ var PlannerConversation = class {
   get isTurnInFlight() {
     return this.turnsInFlight > 0;
   }
+  /** The user turn being answered, for what the host raises during it — an approval the turn's research asks for. */
+  get currentTurnId() {
+    return this.openTurnId ?? void 0;
+  }
   /** Whether the model still holds this conversation in memory. */
   get isActive() {
     return this.host.aiService().hasActiveConversation();
@@ -13272,17 +13933,29 @@ var PlannerConversation = class {
       `The plan now has ${taskCount} task${taskCount === 1 ? "" : "s"}.`
     ].join("\n"), { kind: "system" });
   }
+  /**
+   * Queued edits the between-batches drain could not apply. Recorded so the
+   * transcript does not go on promising a change that never landed. Call
+   * inside the host's mutation ritual.
+   */
+  recordQueuedEditsFailed(messages, reason) {
+    this.append("assistant", [
+      "Queued change NOT applied \u2014 the plan is unchanged:",
+      ...messages.map((m) => `- ${m}`),
+      `Reason: ${reason}`
+    ].join("\n"), { kind: "system" });
+  }
   /** Open the conversation on a fresh plan: the goal is its first message. */
   async start(goal, opening, signal) {
-    return this.inTurn(async () => {
+    return this.userTurn(goal, signal, async (userTurn) => {
       this.recordUser(goal, (/* @__PURE__ */ new Date()).toISOString());
       const turn = await this.host.aiService().startConversation({
         ...opening,
         goal,
-        onProgress: (p) => this.host.onProgress(p),
+        onProgress: userTurn.stream.sink(),
         signal
       });
-      return this.settle(turn, signal);
+      return this.settle(turn, userTurn);
     });
   }
   /**
@@ -13292,9 +13965,9 @@ var PlannerConversation = class {
    */
   async reply(message, options = {}) {
     if (this.compacting) throw new ConversationBusyError("send a message");
-    return this.inTurn(() => this.replyTurn(message, options));
+    return this.userTurn(options.verbatim ?? message, options.signal, (userTurn) => this.replyTurn(message, options, userTurn));
   }
-  async replyTurn(message, options) {
+  async replyTurn(message, options, userTurn) {
     const { signal } = options;
     const plan = this.requirePlan();
     const priorHistory = plan.conversationHistory ?? [];
@@ -13307,10 +13980,9 @@ ${message}` : message;
     const ai = this.host.aiService();
     const canContinueLive = ai.hasActiveConversation() && (ai.conversationMatchesConfig?.() ?? true);
     try {
-      const turn = canContinueLive ? await ai.continueConversation(outgoing, (p) => this.host.onProgress(p), signal) : await this.resume(outgoing, priorHistory, signal);
-      const reads = freshReadBudget();
-      let settleable = await this.drainTaskQueries(turn, reads, signal);
-      if ((settleable.kind === "task_ops" || settleable.kind === "plan") && this.host.hasLiveWork()) {
+      const turn = canContinueLive ? await ai.continueConversation(outgoing, userTurn.stream.sink(), signal) : await this.resume(outgoing, priorHistory, signal, userTurn.stream.sink());
+      let settleable = await this.drainTaskQueries(turn, userTurn);
+      if (this.editTouchesLiveWork(settleable)) {
         const queued = this.host.queueEdit(options.verbatim ?? message);
         settleable = {
           kind: "message",
@@ -13318,12 +13990,26 @@ ${message}` : message;
           researchLog: settleable.researchLog
         };
       }
-      return await this.settle(settleable, signal, reads);
+      return await this.settle(settleable, userTurn);
     } catch (err) {
       if (checkpoint) this.restore(checkpoint);
       throw err;
     }
   }
+  /**
+   * Whether a settled structural edit reaches work a runner is executing. Only
+   * these are queued: a whole-plan commit replaces the plan and would reset the
+   * run, and a task-ops batch that names an in-progress task changes it under
+   * the runner. An add, or an edit to any other task, is reconciled into the
+   * plan in place while the running batch keeps going.
+   */
+  editTouchesLiveWork(turn) {
+    if (turn.kind === "plan") return this.host.hasLiveWork();
+    if (turn.kind !== "task_ops") return false;
+    const running = flattenTasks(this.host.tasks()).filter((t) => t.status === "in_progress");
+    if (running.length === 0) return false;
+    return turn.ops.some((op) => taskOpRefs(op).some((ref) => running.some((task) => refMatchesTask(ref, task))));
+  }
   assertIdle(operation) {
     if (this.isTurnInFlight) throw new ConversationBusyError(operation);
   }
@@ -13335,6 +14021,26 @@ ${message}` : message;
       this.turnsInFlight--;
     }
   }
+  /**
+   * Bracket one user turn with its start and end, under an id minted here:
+   * the turn is where the stream a surface draws begins and ends, and only the
+   * conversation sees all of it — every backend call, read and retry.
+   */
+  async userTurn(prompt, signal, run) {
+    const turnId = uuidv45();
+    const stream = new TurnStream(turnId, (p) => this.host.onProgress(p));
+    this.openTurnId = turnId;
+    this.host.broadcast({ type: "planner_turn_started", turnId, prompt });
+    let outcome = "error";
+    try {
+      const settled = await this.inTurn(() => run({ stream, signal, reads: freshReadBudget() }));
+      outcome = settled.outcome;
+      return settled.plan;
+    } finally {
+      if (this.openTurnId === turnId) this.openTurnId = null;
+      this.host.broadcast({ type: "planner_turn_ended", turnId, outcome: signal?.aborted ? "stopped" : outcome });
+    }
+  }
   requirePlan() {
     const plan = this.host.plan();
     if (!plan) throw new Error("No active plan state");
@@ -13354,7 +14060,7 @@ ${message}` : message;
    * against the planner config now in effect. No LLM call happens for the
    * replayed turns; the first call is the one the user's message opens.
    */
-  async resume(message, priorHistory, signal, onProgress = (p) => this.host.onProgress(p)) {
+  async resume(message, priorHistory, signal, onProgress) {
     const runners = this.requirePlan().runners;
     const opening = await this.host.opening(runners);
     const goal = this.host.goal() || priorHistory.find((m) => m.role === "user")?.content || message;
@@ -13382,7 +14088,7 @@ ${message}` : message;
    * ops JSON still gets its two corrective retries; charging it for the read
    * would cost it the chance to fix the edit.
    */
-  async drainTaskQueries(turn, reads, signal) {
+  async drainTaskQueries(turn, { reads, signal, stream }) {
     const ai = this.host.aiService();
     const carried = [];
     let current = turn;
@@ -13404,7 +14110,7 @@ ${message}` : message;
         insist ? `${answer}
 
 ${TASK_QUERY_ANSWER_OR_OPS}` : answer,
-        (p) => this.host.onProgress(p),
+        stream.sink(),
         signal
       );
     }
@@ -13424,7 +14130,8 @@ ${TASK_QUERY_ANSWER_OR_OPS}` : answer,
    * silent retries, then surfaced as a message with the plan untouched. The
    * first turn and every later turn route through here — one path, not two.
    */
-  async settle(turn, signal, reads = freshReadBudget()) {
+  async settle(turn, userTurn) {
+    const { signal, stream } = userTurn;
     const ai = this.host.aiService();
     const invalidOps = (errors, researchLog) => ({
       turn: {
@@ -13437,15 +14144,14 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
       }
     });
     const settled = await repairLoop({
-      first: () => this.drainTaskQueries(turn, reads, signal),
-      resend: async (corrective) => this.drainTaskQueries(
-        await ai.continueConversation(corrective, (p) => this.host.onProgress(p), signal),
-        reads,
-        signal
-      ),
+      first: () => this.drainTaskQueries(turn, userTurn),
+      resend: async (corrective) => {
+        stream.retract();
+        return this.drainTaskQueries(await ai.continueConversation(corrective, stream.sink(), signal), userTurn);
+      },
       interpret: (t) => {
         if (t.kind !== "task_ops") return { done: { turn: t } };
-        const applied = this.applyTaskOps(t);
+        const applied = this.applyTaskOps(t, stream.turnId);
         if ("plan" in applied) return { done: { plan: applied.plan } };
         if (!ai.hasActiveConversation() || signal?.aborted) {
           return { done: invalidOps(applied.errors, t.researchLog) };
@@ -13457,12 +14163,12 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
     });
     if ("plan" in settled) {
       await this.host.afterEdit();
-      return settled.plan;
+      return { plan: settled.plan, outcome: "task_ops" };
     }
-    return this.commit(settled.turn);
+    return { plan: this.commit(settled.turn, stream.turnId), outcome: settled.turn.kind };
   }
   /** Validate + commit a task_ops turn atomically. Returns the errors on rejection (plan untouched). */
-  applyTaskOps(turn) {
+  applyTaskOps(turn, turnId) {
     this.requirePlan();
     const result = this.host.validateOps(turn.ops);
     if (!result.ok) return { errors: result.errors };
@@ -13477,14 +14183,14 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
         return true;
       },
       () => {
-        this.host.broadcast({ type: "planner_message", content, timestamp: now });
+        this.host.broadcast({ type: "planner_message", content, timestamp: now, turnId });
         this.host.broadcastPlan();
       }
     );
     return { plan };
   }
   /** Commit a settled (non-task_ops) turn through the host's mutation ritual. */
-  commit(turn) {
+  commit(turn, turnId) {
     this.requirePlan();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (turn.kind === "plan") {
@@ -13494,7 +14200,7 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
         const count = this.host.adoptTasks(turn.tasks, "commit");
         this.append("assistant", `Plan generated with ${count} task${count === 1 ? "" : "s"}.`, { timestamp: now, kind: "plan_generated" });
         return true;
-      });
+      }, () => this.host.broadcastPlan(turnId));
     }
     const text = turn.text.trim() ? turn.text : "(The planner returned an empty response. Reply to continue, or rephrase your goal.)";
     return this.host.mutate(
@@ -13504,7 +14210,7 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
         this.host.capturePrd(text);
         return true;
       },
-      () => this.host.broadcast({ type: "planner_message", content: text, timestamp: now })
+      () => this.host.broadcast({ type: "planner_message", content: text, timestamp: now, turnId })
     );
   }
   /**
@@ -14162,6 +14868,36 @@ function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   return false;
 }
 
+// src/services/PlannerUsage.ts
+var PlannerUsageLedger = class {
+  usage = { totals: {} };
+  /** Fold one model call's record into the totals; returns the running ledger. */
+  record(record) {
+    this.usage = addPlannerUsage(this.usage, record);
+    return this.usage;
+  }
+  /** Adopt a persisted ledger (a reopened session) or start from zero. */
+  restore(usage) {
+    this.usage = usage ?? { totals: {} };
+  }
+  /** Start a fresh session's ledger from zero. */
+  clear() {
+    this.usage = { totals: {} };
+  }
+  /** Whether anything has been recorded — a plan with no usage says nothing. */
+  get hasUsage() {
+    return isMeasured(this.usage.totals);
+  }
+  /** The value persisted onto the plan state. */
+  snapshot() {
+    return { ...this.usage };
+  }
+  /** The broadcast message for the totals as they stand now. */
+  message(turnId) {
+    return { type: "planner_usage", ...turnId ? { turnId } : {}, ...usageLine(this.usage) };
+  }
+};
+
 // src/services/createSession.ts
 var PlanEditError = class extends Error {
   constructor(message) {
@@ -14198,6 +14934,13 @@ var Session = class {
   /** Injected by a test; when present it is the service, forever. */
   pinnedAiService;
   liveAiService = null;
+  usageLedger = new PlannerUsageLedger();
+  /**
+   * The in-flight turn's subagent activity, grouped one run per subagent so a
+   * replay nests each step under its own brief/result. Flushed into the plan's
+   * researchLog at persist — see {@link flushSubagentRuns}.
+   */
+  pendingSubagents = [];
   liveAiProvider = null;
   workspaceRootFn;
   planner;
@@ -14250,7 +14993,8 @@ var Session = class {
         kind: request.kind,
         subject: request.subject,
         scope: request.scope,
-        detail: request.detail
+        detail: request.detail,
+        turnId: this.conversation.currentTurnId
       }),
       onSettled: (id, granted) => this.broadcast({ type: "approval_settled", id, granted })
     });
@@ -14298,7 +15042,7 @@ var Session = class {
       hasLiveWork: () => this.hasLiveWork,
       mutate: (op, notify) => this.mutatePlan(op, notify),
       broadcast: (msg) => this.broadcast(msg),
-      broadcastPlan: () => this.broadcastPlan(),
+      broadcastPlan: (turnId) => this.broadcastPlan(turnId),
       validateOps: (ops) => applyTaskOps(this.store.planTasks, ops, this.plan.runners, this.editCatalog()),
       adoptTasks: (tasks, how) => this.adoptPlannerTasks(tasks, how),
       capturePrd: (text) => this.capturePrd(text),
@@ -14418,28 +15162,110 @@ var Session = class {
     });
   }
   translateProgress(progress) {
-    if (progress.type === "liveness") {
-      this.broadcast({ type: "planner_liveness" });
-    }
-    if (progress.type === "thinking" && progress.text) {
-      this.broadcast({ type: "plan_thinking", text: progress.text });
-    }
-    if (progress.type === "tool_call" && progress.tool) {
-      this.broadcast({ type: "research_step", tool: progress.tool, toolLabel: progress.toolLabel, args: progress.toolArgs || "", subagentId: progress.subagentId, toolCallId: progress.toolCallId });
-    }
-    if (progress.type === "plan_token" && progress.planToken) {
-      this.broadcast({ type: "plan_token", token: progress.planToken });
+    const { turnId, subagentId, segmentId } = progress;
+    switch (progress.type) {
+      case "liveness":
+        this.broadcast({ type: "planner_liveness" });
+        return;
+      case "thinking":
+        if (!progress.text) return;
+        this.broadcast({ type: "planner_thinking_delta", turnId, segmentId, subagentId, text: progress.text });
+        return;
+      case "tool_call":
+        if (progress.tool) this.broadcast({ type: "research_step", tool: progress.tool, toolLabel: progress.toolLabel, args: progress.toolArgs || "", subagentId, toolCallId: progress.toolCallId, turnId });
+        return;
+      case "plan_token":
+        if (progress.planToken) this.broadcast({ type: "plan_token", token: progress.planToken, turnId, segmentId });
+        return;
+      case "tool_result":
+        if (progress.step) {
+          if (progress.step.subagentId) this.subagentRun(progress.step.subagentId).steps.push(progress.step);
+          this.broadcast({ type: "research_step_done", step: progress.step, subagentId, turnId });
+        }
+        return;
+      case "text_delta":
+        if (!progress.text) return;
+        if (turnId && segmentId) this.broadcast({ type: "planner_text_delta", turnId, segmentId, text: progress.text });
+        return;
+      case "text_retracted":
+        if (turnId) this.broadcast({ type: "planner_text_retracted", turnId, segmentId });
+        return;
+      case "subagent_started":
+        if (subagentId) {
+          const run = this.subagentRun(subagentId);
+          run.entry.brief = progress.brief ?? run.entry.brief;
+          if (progress.model) run.entry.model = progress.model;
+          this.broadcast({ type: "subagent_started", turnId, subagentId, brief: progress.brief ?? "", model: progress.model });
+        }
+        return;
+      case "subagent_finished":
+        if (subagentId) {
+          const run = this.subagentRun(subagentId);
+          run.entry.outcome = progress.outcome ?? "failed";
+          run.entry.digest = progress.digest ?? "";
+          if (progress.usage) run.entry.usage = progress.usage;
+          this.broadcast({
+            type: "subagent_finished",
+            turnId,
+            subagentId,
+            outcome: progress.outcome ?? "failed",
+            digest: progress.digest ?? "",
+            usage: progress.usage
+          });
+        }
+        return;
+      case "usage": {
+        if (!progress.record) return;
+        this.usageLedger.record(progress.record);
+        this.broadcast(this.usageLedger.message(turnId));
+        return;
+      }
+      case "interrupted":
+        return;
     }
-    if (progress.type === "tool_result" && progress.step) {
-      this.broadcast({ type: "research_step_done", step: progress.step, subagentId: progress.subagentId });
+  }
+  /** The run for `subagentId`, created on first sighting so a step arriving
+   * before (or without) its started event still gets a home. */
+  subagentRun(subagentId) {
+    let run = this.pendingSubagents.find((r) => r.entry.subagentId === subagentId);
+    if (!run) {
+      run = {
+        entry: { id: `sa-${subagentId}`, type: "subagent", subagentId, brief: "", outcome: "failed", digest: "", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+        steps: []
+      };
+      this.pendingSubagents.push(run);
     }
+    return run;
+  }
+  /**
+   * Fold the turn's subagent runs into the plan's researchLog as one contiguous
+   * group per subagent — its entry then its steps, in the order they started —
+   * so a replay nests each step under its own subagent however the live stream
+   * interleaved. A harness planner already logs its child steps through the
+   * turn's researchLog; they are pulled out of that position and re-grouped
+   * rather than duplicated.
+   */
+  flushSubagentRuns() {
+    if (!this.plan || this.pendingSubagents.length === 0) return;
+    const childStepIds = new Set(this.pendingSubagents.flatMap((r) => r.steps.map((s) => s.id)));
+    const additions = [];
+    for (const run of this.pendingSubagents) {
+      additions.push(run.entry, ...run.steps);
+    }
+    this.plan.researchLog = [
+      ...(this.plan.researchLog ?? []).filter((e) => !childStepIds.has(e.id)),
+      ...additions
+    ];
+    this.pendingSubagents = [];
   }
   /** Persists PlanStore state to disk. PlanStore is the single authority;
    * LegacyPlanState.tasks is populated only here, at persist time. */
   persist() {
     if (!this.plan) return;
+    this.flushSubagentRuns();
     this.plan.tasks = this.store.planTasks;
     this.plan.isolation = this.orchestrator.isolationRecord ?? void 0;
+    this.plan.plannerUsage = this.usageLedger.snapshot();
     this.plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     saveSession(this.plan, this.goal, this.workspace, this.currentSessionId);
     this.conversation.markPersisted();
@@ -14457,7 +15283,9 @@ var Session = class {
    */
   beginFreshPlan() {
     if (this.isExecuting) this.stopExecution();
+    this.pendingSubagents = [];
     this.conversation.reset();
+    this.usageLedger.clear();
     this.approvals.clear();
     this.orchestrator.clearQueuedMessages();
     this.store.clearLog();
@@ -14555,8 +15383,14 @@ var Session = class {
   get isPlanning() {
     return !this.orchestrator.isRunning;
   }
+  /**
+   * A task is running right now. Deliberately live work, not the scheduler's
+   * armed flag: a run paused on a user task, a hold or a cancellation has
+   * nothing executing, and reporting it as executing is what left the plan
+   * unstartable after its last live task was cancelled.
+   */
   get isExecuting() {
-    return this.orchestrator.isRunning;
+    return this.orchestrator.hasLiveWork;
   }
   /** See {@link TaskOrchestrator.hasLiveWork} — a spawned runner, not merely an armed scheduler. */
   get hasLiveWork() {
@@ -14666,6 +15500,7 @@ var Session = class {
    */
   async continueConversation(userMessage, options) {
     if (!this.plan) throw new Error("No planning conversation to continue");
+    this.pendingSubagents = [];
     const releaseAbort = this.denyApprovalsOnAbort(options?.signal);
     try {
       return await this.conversation.reply(this.resolveSkillInvocation(userMessage), {
@@ -14765,25 +15600,35 @@ var Session = class {
       autonomousDefault: this.config.autonomousMode,
       verificationEnabled: settings.verificationEnabled ?? false,
       isolatedExecution: await this.orchestrator.plannerIsolation(),
+      // The planner's own model window, when a cached catalog knows it, so the
+      // usage line can show context fill (#49). Unknown stays absent.
+      contextWindow: this.modelResolver.contextWindowFor?.(this.config.orchestratorModel),
       fs: this.fsAdapter,
       fetcher: this.fetcher
     };
   }
   /**
    * Load planner-produced tasks, coerced to the allowlist read live — it may
-   * have changed since planning started. An edit on an armed scheduler is
+   * have changed since planning started. Tasks adopted on an armed scheduler are
    * reconciled rather than reloaded: `loadPlan` clears the on-hold set and the
    * review approval, so a task the user cancelled would be re-armed and
    * re-spawned by the re-tick that follows.
+   *
+   * A whole-plan commit is the planner restating every task, so it is laid
+   * over the plan's execution state rather than replacing it: a planner that
+   * answers "add a task" with the full plan must not undo the work already
+   * done. Task ops need no overlay — their applier refuses to touch settled
+   * tasks, and `rearm`, the one op meant to change a status, must stand.
    */
   adoptPlannerTasks(tasks, how) {
     const runners = this.plan.runners;
-    const coerced = coerceAssignments(tasks, this.allowlist(), runners, this.models());
-    if (how === "edit" && this.orchestrator.isRunning) {
+    let coerced = coerceAssignments(tasks, this.allowlist(), runners, this.models());
+    if (how === "commit") coerced = keepExecutionState(this.store.planTasks, coerced);
+    if (this.orchestrator.isRunning) {
       this.orchestrator.reconcilePlan(coerced, runners);
     } else {
       this.orchestrator.loadPlan(coerced, runners);
-      this.store.resetForRun(how === "commit" ? { preserveCompleted: false } : void 0);
+      this.store.resetForRun();
     }
     return coerced.length;
   }
@@ -14803,7 +15648,8 @@ var Session = class {
   }
   async executePlan() {
     if (!this.plan || !this.store.planTasks.length) throw new Error("No plan to execute");
-    if (this.orchestrator.isRunning) throw new Error("Session already executing");
+    if (this.orchestrator.hasLiveWork) throw new Error("Session already executing");
+    this.orchestrator.stop();
     this.plan.status = "approved";
     this.store.clearLog();
     this.store.resetForRun();
@@ -14866,39 +15712,62 @@ var Session = class {
     const messages = this.orchestrator.getQueuedMessages();
     if (messages.length === 0) return;
     this.orchestrator.clearQueuedMessages();
+    if (this.plan) this.plan.queuedMessages = [];
     const batchText = messages.map((m) => m.text).join("\n");
+    const texts = messages.map((m) => m.text);
     const activeSessions = new Map(
       [...this.orchestrator.activeSessionMap.entries()].map(([taskId, sessionId]) => [
         taskId,
         { id: sessionId, taskId }
       ])
     );
-    const modelsByRunner = await this.modelResolver.modelsForRunners(this.config.enabledRunners);
-    const runnerModes = this.runnerModesFor(this.plan?.runners ?? ["claude-code"]);
-    const { modelAllowlist } = this.settingsFn();
-    const result = await this.planner.modifyDuringExecution({
-      executionLog: this.store.getExecutionLog(),
-      pendingTasks: this.store.planTasks,
-      activeSessions,
-      userMessage: batchText,
-      modelsByRunner,
-      runners: this.plan?.runners ?? ["claude-code"],
-      runnerModes,
-      autonomousDefault: this.config.autonomousMode,
-      perRunnerAllowlist: modelAllowlist,
-      isolatedExecution: await this.orchestrator.plannerIsolation()
-    });
-    this.mutatePlan(() => {
-      this.orchestrator.reconcilePlan(result.pendingTasks, this.plan.runners);
-      this.conversation.recordQueuedEdits(messages.map((m) => m.text), result.pendingTasks.length);
-      return true;
-    });
+    try {
+      const modelsByRunner = await this.modelResolver.modelsForRunners(this.config.enabledRunners);
+      const runnerModes = this.runnerModesFor(this.plan?.runners ?? ["claude-code"]);
+      const { modelAllowlist } = this.settingsFn();
+      const result = await this.planner.modifyDuringExecution({
+        executionLog: this.finishedWork(),
+        pendingTasks: this.store.planTasks.filter((t) => t.status !== "completed"),
+        activeSessions,
+        userMessage: batchText,
+        modelsByRunner,
+        runners: this.plan?.runners ?? ["claude-code"],
+        runnerModes,
+        autonomousDefault: this.config.autonomousMode,
+        perRunnerAllowlist: modelAllowlist,
+        isolatedExecution: await this.orchestrator.plannerIsolation()
+      });
+      this.mutatePlan(() => {
+        const tasks = keepExecutionState(this.store.planTasks, result.pendingTasks);
+        this.orchestrator.reconcilePlan(tasks, this.plan.runners);
+        this.conversation.recordQueuedEdits(texts, tasks.length);
+        return true;
+      });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      this.mutatePlan(() => {
+        this.conversation.recordQueuedEditsFailed(texts, reason);
+        return true;
+      });
+      this.onNotice?.({ type: "notice", level: "error", message: `Your queued change could not be applied, so the plan is unchanged: ${reason}. Send it again to retry.` });
+    }
     if (this.orchestrator.isRunning) {
       await this.orchestrator.tick();
     } else {
       await this.orchestrator.start();
     }
   }
+  /**
+   * Every finished task as the log records it: this run's own entries, plus
+   * the tasks earlier runs completed, which the log dropped when this run
+   * began but which dependents still count on.
+   */
+  finishedWork() {
+    const log = this.store.getExecutionLog();
+    const logged = new Set(log.map((s) => s.id));
+    const earlier = flattenTasks(this.store.planTasks).filter((t) => t.status === "completed" && !logged.has(t.id)).map((t) => ({ ...t, completedAt: 0, retryCount: 0, finalized: true }));
+    return [...log, ...earlier];
+  }
   approveCheckpoint(taskId) {
     this.orchestrator.approveCheckpoint(taskId);
   }
@@ -14911,6 +15780,12 @@ var Session = class {
   getQueuedMessages() {
     return this.orchestrator.getQueuedMessages();
   }
+  /** Take back one unsent message; the plan's persisted queue follows so a reload cannot resurrect it. */
+  removeQueuedMessage(id) {
+    const removed = this.orchestrator.removeQueuedMessage(id);
+    if (removed && this.plan) this.plan.queuedMessages = this.getQueuedMessages();
+    return removed;
+  }
   setQueuedMessages(msgs) {
     this.orchestrator.setQueuedMessages(msgs);
   }
@@ -15233,11 +16108,13 @@ var Session = class {
     this.plan = plan;
     this.goal = goal;
     this.workspace = workspace;
+    this.usageLedger.restore(plan.plannerUsage);
     if (opts?.sessionId) this.currentSessionId = opts.sessionId;
     this.orchestrator.loadPlan(plan.tasks, plan.runners);
     migratePlanStateIsolation(plan);
     if (adopting) void this.orchestrator.adoptIsolation(plan.isolation ?? null);
     if (opts?.persist !== false) this.persist();
+    if (this.usageLedger.hasUsage) this.broadcast(this.usageLedger.message());
   }
   async modifyPlan(userRequest) {
     if (!this.plan) throw new Error("No plan to modify");
@@ -15268,13 +16145,14 @@ var Session = class {
     this.unsubObserver?.();
     this.unsubObserver = null;
   }
-  broadcastPlan() {
+  broadcastPlan(turnId) {
     if (!this.plan) return;
     this.broadcast({
       type: "plan_generated",
       plan: serializePlan(this.plan),
       goal: this.goal,
-      runners: this.plan.runners
+      runners: this.plan.runners,
+      ...turnId ? { turnId } : {}
     });
   }
   get aiServiceInstance() {
@@ -15792,6 +16670,8 @@ function clipboardCopyCommand(hasBin = defaultHasBin, platform = process.platfor
 
 // src/services/TmuxRunner.ts
 var EXIT_RE = /<<<ORDEWELL_TMUX_EXIT:(\d+)>>>/;
+var LIVENESS_INTERVAL_MS = 5e3;
+var LIVENESS_MISSES = 2;
 var execFileAsync2 = promisify5(execFile4);
 var defaultExecFile3 = async (command, args) => {
   const { stdout, stderr } = await execFileAsync2(command, args);
@@ -15818,6 +16698,9 @@ var TmuxSession = class extends AbstractTerminalSession {
   outputBuffer = "";
   offset = 0;
   timer = null;
+  quietPolls = 0;
+  misses = 0;
+  looking = false;
   get target() {
     return `${this.tmuxSession}:${this.windowName}`;
   }
@@ -15846,19 +16729,57 @@ var TmuxSession = class extends AbstractTerminalSession {
   }
   poll() {
     if (this.exited) return;
+    if (this.readLog()) {
+      this.quietPolls = 0;
+      this.misses = 0;
+      return;
+    }
+    if (++this.quietPolls % Math.max(1, Math.round(LIVENESS_INTERVAL_MS / this.pollIntervalMs)) === 0) void this.checkWindow();
+  }
+  /** Emit what the log gained since the last read; false when it gained nothing. */
+  readLog() {
     let content;
     try {
       content = existsSync11(this.logPath) ? readFileSync8(this.logPath, "utf8") : "";
     } catch {
-      return;
+      return false;
     }
-    if (content.length <= this.offset) return;
+    if (content.length <= this.offset) return false;
     const diff = content.slice(this.offset);
     this.offset = content.length;
     this.outputBuffer += stripAnsi(diff);
     this.outputEmitter.emit("output", diff);
     const match = this.outputBuffer.slice(-4096).match(EXIT_RE);
     if (match) this.finish(Number(match[1]));
+    return true;
+  }
+  /**
+   * The sentinel is printed by the wrapper shell, so a window closed from
+   * outside — killed by the user, or with the whole tmux server — never prints
+   * it, and the session would count as running forever. A silent window is
+   * therefore looked up by exact name (a `-t` target falls back to another
+   * window once its own is gone), and once it is confirmed missing the session
+   * ends as a kill does. Whatever the log still held is read first, so a
+   * completion marker printed just before the close still counts.
+   */
+  async checkWindow() {
+    if (this.looking) return;
+    this.looking = true;
+    let listed = false;
+    try {
+      const { stdout } = await this.tmux(["list-windows", "-t", this.tmuxSession, "-F", "#{window_name}"]);
+      listed = stdout.split("\n").includes(this.windowName);
+    } catch {
+    }
+    this.looking = false;
+    if (this.exited) return;
+    if (listed) {
+      this.misses = 0;
+      return;
+    }
+    if (++this.misses < LIVENESS_MISSES) return;
+    this.readLog();
+    if (!this.exited) this.finish(-1);
   }
   /**
    * A task finishing (or being killed) stops observation, but never the
@@ -17071,6 +17992,8 @@ export {
   DAEMON_TOKEN_SUBPROTOCOL_PREFIX,
   DEFAULT_MAX_PARALLEL,
   DENY_ALL,
+  EMPTY_CONVERSATION,
+  EMPTY_HOLD,
   EmbeddedNewlineError,
   EnvConfig,
   ExecutableNotFoundError,
@@ -17085,6 +18008,7 @@ export {
   LineBuffer,
   ModelCatalog,
   ModelResolver,
+  NO_TURN,
   OPENCODE_MANIFEST,
   ORCHESTRATOR_SHORTCUTS,
   ORDEWELL_SETTABLE_ENV,
@@ -17132,8 +18056,11 @@ export {
   WINDOWS_MAX_COMMAND_LINE,
   WorkspaceNotAProjectError,
   WorkspaceNotFoundError,
+  addPlannerUsage,
   addTaskToPlan,
+  addUsage,
   admitSettingsEnv,
+  aheadOfDraft,
   applyHeadLimit,
   applyTaskOps,
   assertInstallablePluginUrl,
@@ -17197,6 +18124,7 @@ export {
   dependentsOf,
   describeMergeResult,
   discoverGeminiModels,
+  drainNext,
   effectiveAllowlist,
   emptyWarnings,
   enabledRunners,
@@ -17216,7 +18144,9 @@ export {
   filteredBuildModes,
   flattenTasks,
   flattenTasksWithParents,
+  followTurn,
   formatSearchOutput,
+  fromTranscript,
   generatePlanWithRepair,
   getLatestSession,
   getProviderMeta,
@@ -17224,14 +18154,18 @@ export {
   getStateDir,
   globalDataDir,
   grantScopeFor,
+  hasHiddenDetail,
   hasTmux,
+  holdPrompt,
   includeGlobFor,
   isCliProvider,
   isExecutableResolved,
+  isMeasured,
   isOpenAiProvider,
   isPlainPluginName,
   isReservedRunnerName,
   isValidManifest,
+  keepExecutionState,
   killTree,
   knownModelId,
   languageForId,
@@ -17252,14 +18186,19 @@ export {
   modifyValidationFeedback,
   normalizeAgentArgs,
   normalizeGeminiModel,
+  opensWithJsonObject,
+  outputLines,
+  outputPreview,
   parseMaxParallel,
   parsePartialPlan,
   parsePlanJson,
   parseTaskOpsJson,
   parseTaskQueryJson,
+  partedPromptUsage,
   pendingEditRulesBlock,
   planDirectLaunch,
   planShellLaunch,
+  plannerContextFill,
   posixShellQuote,
   prefixModelId,
   providerForRunner,
@@ -17267,6 +18206,7 @@ export {
   reEmitTaskOpsPrompt,
   reEmitTaskQueryPrompt,
   readDaemonToken,
+  reduceConversation,
   referencePattern,
   removeTaskFromPlan,
   renderPlanMap,
@@ -17300,6 +18240,7 @@ export {
   serializeTaskStatus,
   sessionRuntimeSettings,
   stateExists,
+  stopTurn,
   stripAnsi,
   stripModelNoise,
   stripModelPrefix,
@@ -17309,6 +18250,7 @@ export {
   taskOpsRejectedPrompt,
   taskOrderLabel,
   taskQuerySignature,
+  taskStartedNotice,
   textHasTaskOps,
   textHasTaskQuery,
   tmuxSessionName,
@@ -17317,9 +18259,13 @@ export {
   toOrchestratorOptions,
   tokenSubprotocols,
   tokensMatch,
+  toolHeadline,
   truncateCheckpointSummary,
   truncatedPlanReEmitPrompt,
+  unsendAll,
+  unsendLatest,
   updateTaskInPlan,
+  usageLine,
   validateModifiedPlan,
   validatePlanModification,
   warningsText,