@ordewell/core 0.10.8 → 0.10.10

package/dist/index.js

@@ -203,7 +203,10 @@ __export(index_exports, {
   collectProviderCredentials: () => collectProviderCredentials,
   commandAllowedBy: () => commandAllowedBy,
   configuredProviders: () => configuredProviders,
+  contextMeterText: () => contextMeterText,
+  contextMeterTitle: () => contextMeterTitle,
   continuability: () => continuability,
+  costText: () => costText,
   countedSessionCost: () => countedSessionCost,
   createAiService: () => createAiService,
   createEmptyPlan: () => createEmptyPlan,
@@ -246,7 +249,9 @@ __export(index_exports, {
   flattenTasksWithParents: () => flattenTasksWithParents,
   followTaskLog: () => followTaskLog,
   followTurn: () => followTurn,
+  formatCost: () => formatCost,
   formatSearchOutput: () => formatSearchOutput,
+  formatTokenCount: () => formatTokenCount,
   fromTranscript: () => fromTranscript,
   getLatestSession: () => getLatestSession,
   getProviderMeta: () => getProviderMeta,
@@ -298,6 +303,7 @@ __export(index_exports, {
   migratePlanState: () => migratePlanState,
   mintDaemonToken: () => mintDaemonToken,
   mintSessionId: () => mintSessionId,
+  modelCostTitle: () => modelCostTitle,
   namedRepos: () => namedRepos,
   newTaskFields: () => newTaskFields,
   normalizeAgentArgs: () => normalizeAgentArgs,
@@ -383,6 +389,7 @@ __export(index_exports, {
   stopTurn: () => stopTurn,
   stripAnsi: () => stripAnsi,
   stripModelPrefix: () => stripModelPrefix,
+  subagentCostTitle: () => subagentCostTitle,
   subtreeIds: () => subtreeIds,
   summarizeToolCall: () => summarizeToolCall,
   supervisorSummary: () => supervisorSummary,
@@ -401,6 +408,7 @@ __export(index_exports, {
   taskStartedNotice: () => taskStartedNotice,
   taskStatusKind: () => taskStatusKind,
   taskUsageSummary: () => taskUsageSummary,
+  tasksTotalText: () => tasksTotalText,
   textHasTaskOps: () => textHasTaskOps,
   textHasTaskQuery: () => textHasTaskQuery,
   titledRefs: () => titledRefs,
@@ -418,6 +426,7 @@ __export(index_exports, {
   unsendAll: () => unsendAll,
   unsendLatest: () => unsendLatest,
   usageLine: () => usageLine,
+  usageText: () => usageText,
   waitsForApproval: () => waitsForApproval,
   walkPlan: () => walkPlan,
   wellKnownBinDirs: () => wellKnownBinDirs,
@@ -880,25 +889,66 @@ function addUsage(totals, record) {
   }
   if (record.reportedCost) {
     const { amount, currency } = record.reportedCost;
-    next.reportedCost = { ...totals.reportedCost, [currency]: (totals.reportedCost?.[currency] ?? 0) + amount };
+    const provenance = record.reportedCost.kind || record.sessionBilling ? {
+      kind: record.reportedCost.kind ?? "unknown",
+      billing: record.sessionBilling?.type ?? "unknown",
+      ...record.reportedCost.basis ? { basis: record.reportedCost.basis } : {}
+    } : void 0;
+    addCost(next, currency, amount, provenance);
   }
   return next;
 }
+function addCost(totals, currency, amount, provenance) {
+  const hadCost = totals.reportedCost?.[currency] !== void 0;
+  const previous = totals.costProvenance?.[currency];
+  totals.reportedCost = { ...totals.reportedCost, [currency]: (totals.reportedCost?.[currency] ?? 0) + amount };
+  if (!previous && !provenance) return;
+  const unknown = { kind: "unknown", billing: "unknown" };
+  const a = previous ?? unknown;
+  const b = provenance ?? unknown;
+  const merged = !hadCost ? b : {
+    kind: a.kind === "estimate" || b.kind === "estimate" ? "estimate" : a.kind === "billed" && b.kind === "billed" ? "billed" : "unknown",
+    billing: a.billing === b.billing ? a.billing : "mixed",
+    ...a.basis && a.basis === b.basis ? { basis: a.basis } : {}
+  };
+  totals.costProvenance = { ...totals.costProvenance, [currency]: merged };
+}
 function addPlannerUsage(usage, record) {
-  const next = { ...usage, totals: addUsage(usage.totals, record), byModel: addModelUsage(usage.byModel ?? [], record) };
+  if (record.compacted) {
+    if (record.subagentId || record.aggregate) return usage;
+    const next2 = { ...usage };
+    if (record.source !== void 0) next2.source = record.source;
+    if (record.model !== void 0) {
+      if (record.source !== usage.source || record.model !== usage.model) delete next2.contextWindow;
+      next2.model = record.model;
+    }
+    if (record.contextTokens !== void 0) next2.lastPromptTokens = record.contextTokens;
+    else delete next2.lastPromptTokens;
+    if (record.contextWindow !== void 0) next2.contextWindow = record.contextWindow > 0 ? record.contextWindow : void 0;
+    return next2;
+  }
+  if (record.sessionBilling && !record.reportedCost && record.inputTokens === void 0 && record.outputTokens === void 0 && record.cachedInputTokens === void 0 && record.contextWindow === void 0) {
+    return record.subagentId ? usage : { ...usage, sessionBilling: record.sessionBilling, source: record.source };
+  }
+  record = { ...record, sessionBilling: record.sessionBilling ?? (usage.source === void 0 || record.source === usage.source ? usage.sessionBilling : void 0) };
+  const next = { ...usage, ...!record.subagentId && record.sessionBilling ? { sessionBilling: record.sessionBilling } : {}, totals: addUsage(usage.totals, record), byModel: addModelUsage(usage.byModel ?? [], record) };
   if (record.subagentId) {
     next.bySubagent = { ...usage.bySubagent, [record.subagentId]: addUsage(usage.bySubagent?.[record.subagentId] ?? {}, record) };
     return next;
   }
-  if (!record.aggregate) {
-    if (record.source !== usage.source || record.model !== usage.model) {
-      delete next.lastPromptTokens;
-      delete next.contextWindow;
-    }
-    next.source = record.source;
-    next.model = record.model;
+  if (record.aggregate) {
+    if (record.source !== usage.source && !record.sessionBilling) delete next.sessionBilling;
+    return next;
+  }
+  if (record.source !== usage.source || record.model !== usage.model) {
+    delete next.lastPromptTokens;
+    delete next.contextWindow;
   }
-  if (record.inputTokens !== void 0) next.lastPromptTokens = record.inputTokens;
+  if (record.source !== usage.source && !record.sessionBilling) delete next.sessionBilling;
+  next.source = record.source;
+  next.model = record.model;
+  const used = record.contextTokens ?? record.inputTokens;
+  if (used !== void 0) next.lastPromptTokens = used;
   if (record.contextWindow !== void 0) next.contextWindow = record.contextWindow > 0 ? record.contextWindow : void 0;
   return next;
 }
@@ -909,6 +959,7 @@ function usageLine(usage) {
   const contextFill = plannerContextFill(usage);
   return {
     totals: usage.totals,
+    ...usage.sessionBilling ? { sessionBilling: usage.sessionBilling } : {},
     ...usage.byModel ? { byModel: usage.byModel } : {},
     ...usage.model ? { model: usage.model } : {},
     ...usage.bySubagent ? { bySubagent: usage.bySubagent } : {},
@@ -916,8 +967,8 @@ function usageLine(usage) {
   };
 }
 function plannerContextFill(usage) {
-  if (usage.lastPromptTokens === void 0 || usage.contextWindow === void 0 || usage.contextWindow <= 0) return void 0;
-  return { usedTokens: usage.lastPromptTokens, windowTokens: usage.contextWindow };
+  if (usage.lastPromptTokens === void 0) return void 0;
+  return { usedTokens: usage.lastPromptTokens, ...usage.contextWindow !== void 0 && usage.contextWindow > 0 ? { windowTokens: usage.contextWindow } : {} };
 }
 function addModelUsage(models, record) {
   const index = models.findIndex((m) => m.source === record.source && m.model === record.model);
@@ -929,13 +980,14 @@ function startAttemptUsage(attempt, runner, startedAt) {
 }
 function addAttemptUsage(usage, record, now) {
   const folded = addPlannerUsage(usage, record);
-  return { ...usage, ...folded, lastPromptTokens: folded.lastPromptTokens, contextWindow: folded.contextWindow, wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)) };
+  return { ...usage, ...folded, lastPromptTokens: folded.lastPromptTokens, contextWindow: folded.contextWindow, wallTimeMs: Math.max(0, Date.parse(usage.endedAt ?? now) - Date.parse(usage.startedAt)) };
 }
 function endAttemptUsage(usage, now, runnerSessionCost, sessionId) {
+  const endedAt = usage.endedAt ?? now;
   return {
     ...usage,
-    endedAt: now,
-    wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)),
+    endedAt,
+    wallTimeMs: Math.max(0, Date.parse(endedAt) - Date.parse(usage.startedAt)),
     ...sessionId ? { sessionId } : {},
     ...runnerSessionCost ? { runnerSessionCost } : {}
   };
@@ -948,8 +1000,8 @@ function resumedSessionWindow(attempts, runner, attempt, sessionId) {
   return last ? { source: last.source, model: last.model, contextWindow: last.contextWindow } : void 0;
 }
 function addUsageTotals(totals, addition) {
-  let next = addUsage(totals, { source: "", inputTokens: addition.inputTokens, outputTokens: addition.outputTokens, cachedInputTokens: addition.cachedInputTokens });
-  for (const [currency, amount] of Object.entries(addition.reportedCost ?? {})) next = addUsage(next, { source: "", reportedCost: { currency, amount } });
+  const next = addUsage(totals, { source: "", inputTokens: addition.inputTokens, outputTokens: addition.outputTokens, cachedInputTokens: addition.cachedInputTokens });
+  for (const [currency, amount] of Object.entries(addition.reportedCost ?? {})) addCost(next, currency, amount, addition.costProvenance?.[currency]);
   return next;
 }
 function planUsage(tasks) {
@@ -984,6 +1036,71 @@ function taskUsageSummary(task) {
     ...contextFill ? { contextFill } : {}
   };
 }
+function formatTokenCount(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e4) return `${(n / 1e3).toFixed(1).replace(/\.0$/, "")}k`;
+  if (n < 999500) return `${Math.round(n / 1e3)}k`;
+  return `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M`;
+}
+function formatCost(currency, amount) {
+  const value = amount >= 1 ? amount.toFixed(2) : (([whole, frac = ""]) => `${whole}.${frac.padEnd(2, "0")}`)(amount.toFixed(4).replace(/0+$/, "").split("."));
+  return currency.toLowerCase() === "usd" ? `$${value}` : `${value} ${currency.toUpperCase()}`;
+}
+function contextMeterText(fill) {
+  if (!fill) return null;
+  const used = `ctx ${formatTokenCount(fill.usedTokens)}`;
+  if (!fill.windowTokens) return used;
+  const share = fill.usedTokens / fill.windowTokens * 100;
+  return `${used} (${share < 1 ? "<1" : Math.round(share)}%)`;
+}
+function contextMeterTitle(fill) {
+  const used = fill.usedTokens.toLocaleString("en-US");
+  return fill.windowTokens ? `${used} of ${fill.windowTokens.toLocaleString("en-US")} tokens` : `${used} tokens`;
+}
+function costParts(totals) {
+  const rank = (currency) => currency.toLowerCase() === "usd" ? "" : currency.toUpperCase();
+  return Object.entries(totals.reportedCost ?? {}).sort(([a], [b]) => rank(a).localeCompare(rank(b))).map(([currency, amount]) => {
+    const provenance = totals.costProvenance?.[currency];
+    const equivalent = provenance?.billing === "subscription";
+    return `${provenance?.kind === "estimate" || equivalent ? "\u2248" : ""}${formatCost(currency, amount)}${equivalent ? " API-equivalent" : ""}`;
+  });
+}
+function costText(totals) {
+  const parts = costParts(totals);
+  return parts.length > 0 ? parts.join(" \xB7 ") : null;
+}
+function usageText(usage) {
+  const parts = [contextMeterText(usage.contextFill), costText(usage.totals)].filter((p) => p !== null);
+  return parts.length > 0 ? parts.join(" \xB7 ") : null;
+}
+function modelCostTitle(byModel) {
+  const lines2 = byModel.flatMap((m) => {
+    const cost = costParts(m.totals);
+    const descriptions = [...new Set(Object.values(m.totals.costProvenance ?? {}).map((p) => {
+      const source = m.source === "claude-code" ? "Claude Code" : m.source === "opencode" ? "OpenCode" : m.source === "openrouter" ? "OpenRouter" : m.source;
+      const basis = p.basis === "list" ? " at list price" : p.basis === "managed" ? " at managed price" : "";
+      const kind = p.kind === "estimate" ? `${source}'s estimate${basis}` : p.kind === "billed" ? `Amount billed by ${source}` : "Reported cost";
+      return `${kind}${p.billing === "subscription" ? "; not billed on a subscription" : ""}`;
+    }))];
+    return cost.length > 0 ? [`${m.source} / ${m.model ?? "unattributed"}: ${cost.join(" \xB7 ")}${descriptions.length ? ` \u2014 ${descriptions.join("; ")}` : ""}`] : [];
+  });
+  return lines2.length > 0 ? lines2.join("\n") : void 0;
+}
+function subagentCostTitle(bySubagent) {
+  return Object.entries(bySubagent).map(([id, totals]) => `${id}: ${costParts(totals).join(" \xB7 ") || "reported no cost"}`).join("\n");
+}
+function runnersOf(tasks) {
+  return tasks.flatMap((task) => [...task.attemptUsage ?? [], ...runnersOf(task.subtasks ?? [])]);
+}
+function tasksTotalText(tasks) {
+  const attempts = runnersOf(tasks);
+  if (attempts.length === 0) return null;
+  const costed = (a) => Object.keys(a.totals.reportedCost ?? {}).length > 0;
+  const costless = [...new Set(attempts.filter((a) => a.endedAt !== void 0 && isMeasured(a.totals)).map((a) => a.runner))].filter((runner) => !attempts.some((a) => a.runner === runner && costed(a)));
+  const note = costless.length === 0 ? [] : [`${costless.length === 1 ? costless[0] : `${costless.slice(0, -1).join(", ")} and ${costless.at(-1)}`} ${costless.length === 1 ? "reports" : "report"} no cost`];
+  const parts = [...costParts(planUsage(tasks).totals), ...note];
+  return parts.length > 0 ? `Tasks total: ${parts.join(" \xB7 ")}` : null;
+}
 
 // src/models/TaskLog.ts
 var HEAD_LINES = 60;
@@ -7523,7 +7640,7 @@ var RunnerApprovals = class {
       },
       stop: (sessionId) => {
         this.denySession(sessionId);
-        runner.stop(sessionId);
+        return runner.stop(sessionId);
       },
       stopAll: () => {
         this.approvals.clear(isRunnerApproval);
@@ -10811,6 +10928,8 @@ var RunnerProcess = class {
   markEnded;
   child = null;
   exitStatus = null;
+  /** The process itself reported its end, before its pipes drained; see {@link hasExited}. */
+  exitReported = false;
   stderrTail = "";
   spawnEnv = {};
   /** Stdout readers' end-of-stream flushes, for an end the pipe itself never reports. */
@@ -10861,6 +10980,7 @@ var RunnerProcess = class {
     });
     child.on("close", (code, signal) => this.end({ code, signal }));
     child.once("exit", (code, signal) => {
+      this.exitReported = true;
       const grace = setTimeout(() => {
         for (const flush of [...this.stdoutEnds]) flush();
         this.end({ code, signal });
@@ -10915,6 +11035,15 @@ ${err.message}`);
   get exit() {
     return this.exitStatus;
   }
+  /**
+   * Whether the process has ended, for any reason. Unlike {@link exit} this is
+   * true from its own 'exit', not only once 'close' has drained the pipes: a
+   * runner that has exited can take no further turn even while a descendant
+   * holds its stdout or stderr.
+   */
+  get hasExited() {
+    return this.exitStatus !== null || this.exitReported;
+  }
   /** The exit code a listener is told: -1 for a signal or a spawn failure. */
   get exitCode() {
     return this.exitStatus?.code ?? -1;
@@ -11113,6 +11242,9 @@ var StdioAgentAdapter = class {
   nativeSessionId() {
     return this.sessionId;
   }
+  get exited() {
+    return this.runner.hasExited;
+  }
   onProcessExit(listener) {
     const fire = () => listener(this.runner.exitCode, this.exitMessage());
     if (this.runner.exit) queueMicrotask(fire);
@@ -11613,6 +11745,14 @@ function canUseToolAnswer({ input, suggestions }, decision) {
 }
 var MODEL_COMMAND = "model";
 var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var VARIANT_SUFFIX = /^(.*?)(\[[^\]]*\])?$/;
+function sameModel(a, b) {
+  if (a === void 0 || b === void 0) return false;
+  if (a === b) return true;
+  const [, aBase, aVariant] = VARIANT_SUFFIX.exec(a) ?? [];
+  const [, bBase, bVariant] = VARIANT_SUFFIX.exec(b) ?? [];
+  return aBase === bBase && (aVariant === void 0 || bVariant === void 0 || aVariant === bVariant);
+}
 function usageRecord(usage, model, subagentId) {
   const record = {
     source: "claude-code",
@@ -11621,6 +11761,7 @@ function usageRecord(usage, model, subagentId) {
   if (model) record.model = model;
   if (usage.output_tokens !== void 0) record.outputTokens = usage.output_tokens;
   if (subagentId) record.subagentId = subagentId;
+  else if (record.inputTokens !== void 0) record.contextTokens = record.inputTokens + (record.outputTokens ?? 0);
   return record;
 }
 function subagentFinalCall(result) {
@@ -11670,16 +11811,27 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
   replyRuns = new ReplyRuns();
   /** The model answering the planner's current message, and the message's id, as its `message_start` named them. */
   plannerModel;
+  /**
+   * The id the turn runs as, as `init` names it. A `[1m]` variant is the
+   * selected id, while a message names the API's canonical id without it.
+   */
+  sessionModel;
+  billing;
   streamingMessage;
   /** The message the last `assistant` line was part of, and how many of its blocks the lines have carried. */
   lineMessage = null;
   /**
-   * The session's `total_cost_usd` as last counted. A resume starts from what
-   * was counted of that session before, and is undefined without it: the CLI
-   * restores the session's running total, which holds turns counted earlier.
+   * What has been counted of the session's running cost: a resume starts from
+   * it, and it is undefined without a kept count — the next result then only
+   * sets the baseline, since the CLI restores spend from turns before it. It
+   * grows by what each result is counted for, never by a total that includes
+   * cost the runner marked unknown, so that spend can be counted when its basis
+   * is reported; and it never lowers, since counted dollars are not un-spent.
    */
   reportedCostUsd = 0;
   reportedModelCostUsd = /* @__PURE__ */ new Map();
+  /** What this turn's streamed calls already reported, so its result only adds what did not stream. */
+  turnCallUsage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 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.
@@ -11766,6 +11918,14 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
     if (!sessionId || this.reportedCostUsd === void 0) return null;
     return { sessionId, usd: this.reportedCostUsd, modelUsd: Object.fromEntries(this.reportedModelCostUsd) };
   }
+  /**
+   * A cleared conversation's totals start again from zero, so what follows is
+   * all new spend, even for a resume that had no count kept.
+   */
+  restartCount() {
+    this.reportedCostUsd = 0;
+    this.reportedModelCostUsd = /* @__PURE__ */ new Map();
+  }
   /** A count kept for another session says nothing of this one's. */
   countFrom(sessionId, counted) {
     const known = counted?.sessionId === sessionId ? counted : void 0;
@@ -11839,11 +11999,10 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
    * the alias resolves to now; that id is pinned before the first turn.
    */
   async handshake(opts) {
-    if (opts.kind !== "task") return;
     const initialized = (await this.control({ subtype: "initialize" }, MODEL_PIN_TIMEOUT_MS))?.response;
     this.listedCommands = initialized?.commands ?? [];
     this.listedModels = initialized?.models ?? [];
-    if (opts.flags.permissionMode !== "plan" || !opts.model) return;
+    if (opts.kind !== "task" || opts.flags.permissionMode !== "plan" || !opts.model) return;
     const resolved = initialized?.models?.find((m) => m.value === opts.model)?.resolvedModel;
     if (resolved && resolved !== opts.model) await this.control({ subtype: "set_model", model: resolved }, MODEL_PIN_TIMEOUT_MS);
   }
@@ -11884,6 +12043,15 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
     this.interruptRequested = true;
     return (await this.control({ subtype: "interrupt" }, timeoutMs))?.subtype === "success";
   }
+  /**
+   * On stdin's end the CLI exits by itself once its turn has closed, and only
+   * an exit of its own saves the session's running totals for a `--resume` to
+   * restore (checked on 2.1.303: about a second later, code 0, or 1 after an
+   * interrupted turn).
+   */
+  endInput() {
+    this.process?.stdin?.end();
+  }
   /**
    * A `user` line written mid-turn is Claude Code's own queue (ADR-0023): the
    * CLI attaches it to the next tool result, or runs it as a turn of its own
@@ -11971,6 +12139,7 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
     this.resultHeld = false;
     this.turnClosed = false;
     this.clearFollowOnTimer();
+    this.plannerModel = void 0;
   }
   /**
    * The echo of a steered message: the model has it. After a closed turn it
@@ -12025,6 +12194,8 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
         this.permissions.withdraw(msg.request_id, emit);
         return;
       case "control_response": {
+        const account = msg.response?.response?.account;
+        if (account) this.reportBilling(account.apiKeySource, account.subscriptionType, emit);
         const requestId = msg.response?.request_id;
         if (requestId) this.pendingControl.get(requestId)?.(msg.response ?? null);
         return;
@@ -12068,12 +12239,24 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
           emit({ type: "tool_result", id, name: "", output: diff || output, success: block.is_error !== true, subagentId });
         }
         return;
+      // `/clear` (and `/reset`, `/new`) emit this top-level line before their
+      // own result, and a task's chat can send them. The CLI's totals restart.
+      case "conversation_reset": {
+        if (subagentId) return;
+        this.restartCount();
+        const resetModel = this.sessionModel ?? (this.plannerModel !== "<synthetic>" ? this.plannerModel : void 0);
+        emit({ type: "usage", record: { source: "claude-code", ...resetModel ? { model: resetModel } : {}, compacted: true } });
+        return;
+      }
       case "system":
+        if (subagentId && (msg.subtype === "init" || msg.subtype === "compact_boundary")) return;
         if (msg.subtype === "init") {
           this.clearFollowOnTimer();
           if (this.refuseOtherMode(msg, emit)) return;
+          if (msg.model && msg.model !== "<synthetic>") this.sessionModel = msg.model;
           this.readLoaded(msg, emit);
           this.followModel(msg.model, emit);
+          this.reportBilling(msg.apiKeySource, void 0, emit);
         }
         if (msg.subtype === "commands_changed" && Array.isArray(msg.commands)) this.listedCommands = msg.commands;
         if (msg.subtype === "compact_boundary") {
@@ -12084,6 +12267,8 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
             ...typeof meta?.pre_tokens === "number" ? { preTokens: meta.pre_tokens } : {},
             ...typeof meta?.post_tokens === "number" ? { postTokens: meta.post_tokens } : {}
           });
+          const model = this.sessionModel ?? (this.plannerModel !== "<synthetic>" ? this.plannerModel : void 0);
+          emit({ type: "usage", record: { source: "claude-code", ...model ? { model } : {}, compacted: true, ...typeof meta?.post_tokens === "number" ? { contextTokens: meta.post_tokens } : {} } });
         }
         if (msg.subtype === "background_tasks_changed" && Array.isArray(msg.tasks)) {
           this.backgroundTaskCount = msg.tasks.length;
@@ -12095,6 +12280,7 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
         }
         return;
       case "result":
+        if (subagentId) return;
         this.reportSessionCost(msg, emit);
         for (const command of this.modelCommands) command.turnsLeft = Math.max(0, command.turnsLeft - 1);
         if (this.interruptRequested && (msg.is_error || msg.subtype !== "success")) {
@@ -12259,16 +12445,69 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
    */
   handleStreamEvent(event, emit) {
     if (event.type === "message_start") {
-      this.plannerModel = event.message?.model;
+      this.plannerModel = this.modelId(event.message?.model);
       this.streamingMessage = event.message?.id;
       this.followModel(this.plannerModel, emit);
-    } else if (event.type === "message_delta" && event.usage) emit({ type: "usage", record: usageRecord(event.usage, this.plannerModel) });
-    else if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+    } else if (event.type === "message_delta" && event.usage) {
+      const record = usageRecord(event.usage, this.plannerModel);
+      this.turnCallUsage.inputTokens += record.inputTokens ?? 0;
+      this.turnCallUsage.cachedInputTokens += record.cachedInputTokens ?? 0;
+      this.turnCallUsage.outputTokens += record.outputTokens ?? 0;
+      emit({ type: "usage", record });
+    } else if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
       this.replyRuns.delta(`${this.streamingMessage ?? ""}:${event.index ?? 0}`, event.delta.text, emit);
     } else if (event.type === "content_block_delta" && event.delta?.type === "thinking_delta" && event.delta.thinking) {
       emit({ type: "thinking_delta", text: event.delta.thinking });
     }
   }
+  /**
+   * The id a reported model runs as. `init` names the selected value — a
+   * `[1m]` variant included — while a message names the API's canonical id
+   * without it. Keeping the variant is what lets the meter find the window
+   * `modelUsage` keys it by, and keeps that window off the base model.
+   */
+  modelId(reported) {
+    if (!reported) return void 0;
+    if (!sameModel(this.sessionModel, reported)) return reported;
+    return this.sessionModel?.includes("[") ? this.sessionModel : reported;
+  }
+  reportBilling(apiKeySource, plan, emit) {
+    const type = apiKeySource ? apiKeySource === "none" ? "subscription" : "api-key" : plan ? "subscription" : void 0;
+    if (!type) return;
+    const knownPlan = plan ?? (this.billing?.type === type ? this.billing.plan : void 0);
+    this.billing = { type, ...knownPlan ? { plan: knownPlan } : {} };
+    emit({ type: "usage", record: { source: this.agentId, aggregate: true, sessionBilling: this.billing } });
+  }
+  /**
+   * A turn's `result` states its own token sum. Every call that streamed its
+   * `message_delta` usage has already reported, so only the remainder is added:
+   * all of it when nothing streamed (a recording without partial messages), or
+   * a lost call's share. It is a sum across calls, marked `aggregate` so it
+   * never moves the meter — only a call says what the context was left at.
+   */
+  reportUnstreamedUsage(msg, emit) {
+    const { inputTokens: streamedInput, cachedInputTokens: streamedCached, outputTokens: streamedOutput } = this.turnCallUsage;
+    this.turnCallUsage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
+    if (!msg.usage) return;
+    const models = Object.keys(msg.modelUsage ?? {});
+    const model = this.plannerModel ?? this.mainModel ?? (models.length === 1 ? models[0] : void 0);
+    const total = usageRecord(msg.usage, model);
+    const inputTokens = (total.inputTokens ?? 0) - streamedInput;
+    const cachedInputTokens = (total.cachedInputTokens ?? 0) - streamedCached;
+    const outputTokens = (total.outputTokens ?? 0) - streamedOutput;
+    if (inputTokens <= 0 && outputTokens <= 0) return;
+    emit({
+      type: "usage",
+      record: {
+        source: "claude-code",
+        ...model ? { model } : {},
+        aggregate: true,
+        ...inputTokens > 0 ? { inputTokens } : {},
+        ...inputTokens > 0 && cachedInputTokens > 0 ? { cachedInputTokens } : {},
+        ...outputTokens > 0 ? { outputTokens } : {}
+      }
+    });
+  }
   /**
    * What only the result line knows: the cost, which covers every call the
    * session made — subagents included, since none of their lines carries one —
@@ -12277,24 +12516,54 @@ var ClaudeCodeAdapter = class extends StdioAgentAdapter {
    * the session before; with no count kept, the first turn only sets the
    * baseline: its total includes turns counted before, and a turn's own share
    * cannot be told apart from them.
+   *
+   * The running total never lowers: money already reported and counted is not
+   * un-spent because a later or resumed process remembers less of it, and
+   * counting its return would count the same dollars twice. A zero is not a
+   * measurement at all — a crash can end with one — and only `/clear` restarts
+   * the count, through {@link restartCount}. Per-model baselines never lower
+   * either, for the same reason.
+   *
+   * A report without a model breakdown is counted as a session total; one with
+   * a breakdown is counted per model. A breakdown that would count more than
+   * the session total's own growth (the count before it had no model split, or
+   * a lossy report) is counted as that growth alone, so the two shapes
+   * together still add each dollar once.
    */
   reportSessionCost(msg, emit) {
+    this.reportUnstreamedUsage(msg, emit);
     const total = msg.total_cost_usd;
     const canReport = this.reportedCostUsd !== void 0;
-    const modelCosts = Object.entries(msg.modelUsage ?? {}).filter((entry) => typeof entry[1].costUSD === "number");
+    const modelCosts = Object.entries(msg.modelUsage ?? {}).filter((entry) => typeof entry[1].costUSD === "number" && entry[1].costUSD > 0 && entry[1].costBasis !== "unknown");
+    const growth = canReport && typeof total === "number" && total > 0 ? total - this.reportedCostUsd : void 0;
+    let emitted = 0;
+    const emitCost = (record) => {
+      if (!(record.amount > 0)) return;
+      emitted += record.amount;
+      emit({ type: "usage", record: { source: "claude-code", ...record.model ? { model: record.model } : {}, aggregate: true, ...this.billing ? { sessionBilling: this.billing } : {}, reportedCost: { amount: record.amount, currency: "USD", kind: "estimate", ...record.basis ? { basis: record.basis } : {} } } });
+    };
     if (modelCosts.length > 0) {
-      for (const [model, usage] of modelCosts) {
-        const previous = this.reportedModelCostUsd.get(model) ?? 0;
-        const amount = usage.costUSD - previous;
-        if (canReport && amount >= 0) emit({ type: "usage", record: { source: "claude-code", model, aggregate: true, reportedCost: { amount, currency: "USD" } } });
-        this.reportedModelCostUsd.set(model, usage.costUSD);
+      const modelGrowth = modelCosts.reduce((sum, [model2, usage]) => sum + Math.max(0, usage.costUSD - (this.reportedModelCostUsd.get(model2) ?? 0)), 0);
+      if (canReport) {
+        if (growth !== void 0 && modelGrowth > growth + 1e-9) {
+          emitCost({ amount: growth });
+        } else {
+          for (const [model2, usage] of modelCosts) emitCost({ model: model2, amount: usage.costUSD - (this.reportedModelCostUsd.get(model2) ?? 0), ...usage.costBasis ? { basis: usage.costBasis } : {} });
+        }
       }
-    } else if (typeof total === "number" && canReport && total >= this.reportedCostUsd) {
-      emit({ type: "usage", record: { source: "claude-code", aggregate: true, reportedCost: { amount: total - this.reportedCostUsd, currency: "USD" } } });
+      for (const [model2, usage] of modelCosts) this.reportedModelCostUsd.set(model2, Math.max(this.reportedModelCostUsd.get(model2) ?? 0, usage.costUSD));
+    } else if (!Object.values(msg.modelUsage ?? {}).some((usage) => usage.costBasis === "unknown") && typeof total === "number" && total > 0 && canReport && total >= this.reportedCostUsd) {
+      emitCost({ amount: total - this.reportedCostUsd });
     }
-    if (typeof total === "number") this.reportedCostUsd = total;
-    const contextWindow = this.plannerModel ? msg.modelUsage?.[this.plannerModel]?.contextWindow : void 0;
-    if (contextWindow !== void 0) emit({ type: "usage", record: { source: "claude-code", model: this.plannerModel, contextWindow } });
+    if (!canReport) {
+      if (typeof total === "number" && total > 0) this.reportedCostUsd = total;
+      else if (modelCosts.length > 0) this.reportedCostUsd = modelCosts.reduce((sum, [, usage]) => sum + usage.costUSD, 0);
+    } else {
+      this.reportedCostUsd = (this.reportedCostUsd ?? 0) + emitted;
+    }
+    const model = this.plannerModel && this.plannerModel !== "<synthetic>" ? this.plannerModel : this.sessionModel;
+    const contextWindow = model ? msg.modelUsage?.[model]?.contextWindow : void 0;
+    if (typeof contextWindow === "number" && contextWindow > 0) emit({ type: "usage", record: { source: "claude-code", model, contextWindow } });
   }
 };
 
@@ -12929,9 +13198,13 @@ function mergeCodexRateLimits(known, params) {
   const id = snapshot.limitId ?? "";
   const before = known.get(id);
   const next = new Map(known);
-  next.set(id, { limitId: id, primary: snapshot.primary ?? before?.primary, secondary: snapshot.secondary ?? before?.secondary });
+  next.set(id, { limitId: id, planType: snapshot.planType ?? before?.planType, primary: snapshot.primary ?? before?.primary, secondary: snapshot.secondary ?? before?.secondary });
   return next;
 }
+function codexSessionBilling(limits) {
+  const plan = [...limits.values()].find((snapshot) => snapshot.planType && snapshot.planType !== "unknown")?.planType;
+  return plan ? { type: "subscription", plan } : void 0;
+}
 function isCodexUsageLimit(error) {
   const info = error?.codexErrorInfo;
   if (info === void 0 || info === null || info === "other") return void 0;
@@ -13490,8 +13763,21 @@ ${this.exitMessage()}`);
       case "thread/tokenUsage/updated":
         this.emitUsage(msg.params, emit);
         return;
+      case "account/updated": {
+        const account = msg.params;
+        if (account?.authMode === "apikey") emit({ type: "usage", record: { source: this.agentId, aggregate: true, sessionBilling: { type: "api-key" } } });
+        else if (account?.authMode === "chatgpt" || account?.authMode === "chatgptAuthTokens") {
+          const plan = account.planType;
+          emit({ type: "usage", record: { source: this.agentId, aggregate: true, sessionBilling: { type: "subscription", ...plan && plan !== "unknown" ? { plan } : {} } } });
+        }
+        return;
+      }
       case "account/rateLimits/updated":
         this.rateLimits = mergeCodexRateLimits(this.rateLimits, msg.params);
+        {
+          const sessionBilling = codexSessionBilling(this.rateLimits);
+          if (sessionBilling) emit({ type: "usage", record: { source: this.agentId, aggregate: true, sessionBilling } });
+        }
         return;
       case "turn/started": {
         if (this.subagentOf(msg.params?.threadId)) return;
@@ -13620,6 +13906,13 @@ ${this.exitMessage()}`);
    * `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.
+   *
+   * The main thread's context is what Codex itself shows as in its window:
+   * `TokenUsage::tokens_in_context_window`, which is `total_tokens` over
+   * `last` as codex-rs defines it. `total_tokens` is input plus output, and
+   * reasoning is part of output, so this is not `input + output − reasoning`
+   * (checked against codex-rs and codex-cli 0.163.0's token_count events,
+   * where `total_tokens` is `input_tokens + output_tokens`).
    */
   emitUsage(params, emit) {
     const last = params?.tokenUsage?.last;
@@ -13647,6 +13940,8 @@ ${this.exitMessage()}`);
     } else {
       const window = params?.tokenUsage?.modelContextWindow;
       if (typeof window === "number" && window > 0) record.contextWindow = window;
+      const inContext = last.totalTokens !== void 0 && last.totalTokens > 0 ? last.totalTokens : last.inputTokens !== void 0 ? last.inputTokens + (last.outputTokens ?? 0) : void 0;
+      if (inContext !== void 0) record.contextTokens = Math.max(0, inContext);
     }
     emit({ type: "usage", record });
   }
@@ -13808,7 +14103,9 @@ ${this.exitMessage()}`);
     }
     switch (item.type) {
       case "contextCompaction":
-        if (!subagentId) emit({ type: "compaction", trigger: this.command === "compact" ? "manual" : "auto" });
+        if (subagentId) return;
+        emit({ type: "compaction", trigger: this.command === "compact" ? "manual" : "auto" });
+        emit({ type: "usage", record: { source: this.agentId, compacted: true } });
         return;
       // Codex announces the item started and completed; whichever lands first delivers.
       case "userMessage":
@@ -14104,8 +14401,9 @@ function usageRecord2(tokens, call) {
   if ((prompt.inputTokens ?? 0) + outputTokens === 0) return null;
   const record = { source: "opencode", ...prompt, outputTokens };
   if (call.model) record.model = call.model;
-  if (typeof call.cost === "number" && call.cost > 0) record.reportedCost = { amount: call.cost, currency: "USD" };
+  if (typeof call.cost === "number" && call.cost > 0) record.reportedCost = { amount: call.cost, currency: "USD", kind: "estimate" };
   if (call.subagentId) record.subagentId = call.subagentId;
+  else record.contextTokens = (prompt.inputTokens ?? 0) + outputTokens;
   return record;
 }
 function permissionReply(decision, key) {
@@ -14668,6 +14966,7 @@ var OpenCodeV2 = class {
       }
       if (frame.type === "session.compaction.ended") {
         onEvent({ type: "compaction", trigger: data.reason === "manual" ? "manual" : "auto" });
+        onEvent({ type: "usage", record: { source: "opencode", compacted: true } });
         return;
       }
       if (frame.type === "session.execution.started") {
@@ -14926,7 +15225,7 @@ var OpenCodeAdapter = class {
     return this.runner.ended;
   }
   get exited() {
-    return this.runner.exit !== null;
+    return this.runner.hasExited;
   }
   async start(opts) {
     try {
@@ -15533,6 +15832,7 @@ var OpenCodeAdapter = class {
     if (session && session !== this.sessionId && !turn.children.follows(session)) return;
     if (frame.type === "session.compacted" && session === this.sessionId) {
       onEvent({ type: "compaction", trigger: this.manualCompaction ? "manual" : "auto" });
+      onEvent({ type: "usage", record: { source: "opencode", compacted: true } });
       return;
     }
     if (session === this.sessionId && this.taskTurn) this.followTaskTurn(frame, this.taskTurn, onEvent);
@@ -20555,6 +20855,7 @@ var PlannerConversation = class {
     const request = summaryRequest(this.currentPlanLines());
     const onProgress = (p) => {
       if (p.type === "liveness") this.host.onProgress(p);
+      else if (p.type === "usage" && p.record) this.host.onProgress({ ...p, record: { ...p.record, aggregate: true } });
     };
     let turn;
     if (this.canContinueLive()) {
@@ -23103,10 +23404,21 @@ var GitWorktreeIsolation = class {
       const entry = record.repos[repo.path];
       if (!entry?.changed) continue;
       const merged = await this.tryGit(repo.root, ["merge-base", "--is-ancestor", entry.landedTip ?? repo.integrationBranch, "HEAD"]);
-      if (!merged.ok) return false;
+      if (!merged.ok && !await this.integrationGone(repo)) return false;
     }
     return true;
   }
+  /**
+   * The repo's integration branch is gone — deleted by hand, or by a squash
+   * merge's clean-up — in a repo git can read. Merge all merges that branch by
+   * name, so no merge can bring the work in again, and it is not offered as
+   * work to merge. A repo git cannot read at all (moved, or git failing)
+   * proves nothing either way and counts as not merged.
+   */
+  async integrationGone(repo) {
+    if (!(await this.tryGit(repo.root, ["rev-parse", "--verify", "-q", "HEAD"])).ok) return false;
+    return !(await this.tryGit(repo.root, ["rev-parse", "--verify", "-q", `refs/heads/${repo.integrationBranch}`])).ok;
+  }
   async snapshotTree(workspaceRoot, exclude) {
     const scan = await this.scanGroup(workspaceRoot);
     if ("refused" in scan) return null;
@@ -24234,6 +24546,9 @@ function nonPromptingFs(fs18) {
     }
   };
 }
+function withoutContext({ contextTokens: _context, ...record }) {
+  return record;
+}
 async function runLoop(prompt, deps) {
   if (deps.signal?.aborted) return "[research agent aborted before starting]";
   const fs18 = nonPromptingFs(deps.fs);
@@ -24241,7 +24556,8 @@ async function runLoop(prompt, deps) {
     (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 })
+    // The chat states the context its call leaves; a subagent's is no meter's.
+    (record) => deps.onProgress?.({ type: "usage", record: deps.subagentId ? { ...withoutContext(record), subagentId: deps.subagentId } : record })
   );
   let turn = await chat.sendMessage(prompt, deps.signal);
   for (let step = 0; turn.hasToolCalls && step < SUBAGENT_LIMITS.maxSteps; step++) {
@@ -24749,7 +25065,8 @@ function usageRecordFrom(usage, model) {
     model,
     ...inputTokens !== void 0 ? { inputTokens } : {},
     ...reportedOutput.length > 0 ? { outputTokens: reportedOutput.reduce((a, b) => a + b, 0) } : {},
-    ...tokenCount(usage.cachedContentTokenCount) !== void 0 ? { cachedInputTokens: tokenCount(usage.cachedContentTokenCount) } : {}
+    ...tokenCount(usage.cachedContentTokenCount) !== void 0 ? { cachedInputTokens: tokenCount(usage.cachedContentTokenCount) } : {},
+    ...inputTokens !== void 0 ? { contextTokens: inputTokens + (answerTokens ?? 0) } : {}
   };
   const anyReported = record.inputTokens !== void 0 || record.outputTokens !== void 0 || record.cachedInputTokens !== void 0;
   return anyReported ? record : void 0;
@@ -25152,7 +25469,9 @@ var OpenAiResearchChat = class {
   /**
    * 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.
+   * nothing is estimated. A field the provider left out stays absent. The
+   * context the call leaves is its prompt and its completion: the API's own
+   * `total_tokens`, and the reply the next call's prompt carries.
    */
   usageRecord(reported) {
     if (!reported) return void 0;
@@ -25171,9 +25490,10 @@ var OpenAiResearchChat = class {
       hasMeasure = true;
     }
     if (reported.cost !== void 0) {
-      record.reportedCost = { amount: reported.cost, currency: "USD" };
+      record.reportedCost = { amount: reported.cost, currency: "USD", ...record.source === "openrouter" ? { kind: "billed" } : {} };
       hasMeasure = true;
     }
+    if (record.inputTokens !== void 0) record.contextTokens = record.inputTokens + (record.outputTokens ?? 0);
     return hasMeasure ? record : void 0;
   }
 };
@@ -26321,6 +26641,8 @@ var IsolationRunController = class {
   listener;
   liveTasks;
   run = null;
+  /** An adoption stays scoped even while cleanup temporarily leaves no run record. */
+  adoptions = 0;
   /** Copied paths already reported for the current run: every task gets the same copies. */
   reportedCopies = /* @__PURE__ */ new Set();
   reportedSetupFailures = /* @__PURE__ */ new Set();
@@ -26396,18 +26718,27 @@ var IsolationRunController = class {
    * Take over a plan's persisted isolation, or none for a plan that has not
    * isolated yet. Whatever a crashed process left behind for the run — a
    * worktree still marked active, a directory no record owns — is pruned,
-   * while kept, failed and conflicted worktrees stay for the user.
+   * while kept, failed and conflicted worktrees stay for the user. Then git is
+   * asked which landed work the user has merged since the record was saved:
+   * a settled run whose landed work is all in HEAD has nothing left to hand
+   * over, so it is cleared up as Merge all would have, unless it still holds
+   * work that never landed (ADR-0013).
    *
-   * Deliberately not reported as a change: adopting is not a change to
-   * persist, and a host that adopts without persisting (VS Code's restore)
-   * would otherwise write a new session file on every reload.
+   * Deliberately not reported to the listener: adopting is not a change of the
+   * session's own, and a host that adopts without persisting (VS Code's
+   * restore) would otherwise write a new session file on every reload. What
+   * git changed is returned instead, for the caller to save where it can and
+   * announce. A plan loaded meanwhile supersedes this adoption, which then
+   * touches nothing and resolves `unchanged`.
    */
   async adopt(state) {
+    const adoption = ++this.adoptions;
     this.run = state?.run ?? null;
     this.resolvers = { ...state?.resolvers ?? {} };
-    if (!this.run) return;
+    const run = this.run;
+    if (!run) return "unchanged";
     try {
-      const pruned = await this.isolation.pruneOrphans(this.run);
+      const pruned = await this.isolation.pruneOrphans(run);
       for (const task of pruned.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.`);
       }
@@ -26415,6 +26746,24 @@ var IsolationRunController = class {
     } catch (err) {
       this.tell("warn", `Could not prune leftover worktrees: ${err instanceof Error ? err.message : String(err)}`);
     }
+    if (this.run !== run) return "unchanged";
+    const found = await this.findLanded(run);
+    if (this.run !== run) return "unchanged";
+    const outcome = found ? "changed" : "unchanged";
+    if (this.isOpen || !this.allMerged(run) || this.holdouts(run).length > 0) return outcome;
+    const resolvers = this.resolvers;
+    this.run = null;
+    this.resolvers = {};
+    const discarded = await this.discardMerged(run);
+    if (this.adoptions !== adoption) return "unchanged";
+    if (!discarded) {
+      if (this.run === null) {
+        this.run = run;
+        this.resolvers = resolvers;
+      }
+      return outcome;
+    }
+    return this.isOpen ? "changed" : "cleared";
   }
   /** Open a run if none is, leaving whether it isolates to its first change task. */
   open() {
@@ -26571,8 +26920,7 @@ var IsolationRunController = class {
     const run = this.run;
     if (mode !== "isolated" || !run) return;
     await this.refreshInHead();
-    const records = Object.values(run.tasks);
-    if (records.some((r) => r.status === "merged") && handoffOf(run).landed.length === 0) {
+    if (this.allMerged(run)) {
       this.tell("info", "Everything this run landed is merged into your branch already.");
       await this.clearMerged(run);
       return;
@@ -26599,11 +26947,21 @@ var IsolationRunController = class {
    */
   async refreshInHead() {
     const run = this.run;
-    if (!run || !Object.values(run.tasks).some((r) => r.status === "merged" && !r.inHead)) return false;
+    if (!run) return false;
+    const found = await this.findLanded(run);
+    if (found) this.listener.changed();
+    return found;
+  }
+  /** Mark the run's landed work git finds in HEAD; true when some was found. */
+  async findLanded(run) {
+    if (!Object.values(run.tasks).some((r) => r.status === "merged" && !r.inHead)) return false;
     const found = await this.isolation.findInHead(run).catch(() => []);
-    if (found.length > 0) this.listener.changed();
     return found.length > 0;
   }
+  /** The run landed something and every landing is in the user's HEAD. */
+  allMerged(run) {
+    return Object.values(run.tasks).some((r) => r.status === "merged") && handoffOf(run).landed.length === 0;
+  }
   /**
    * The tracked state of the workspace as an attempt whose tree is checked
    * starts (see `attemptKind.checksTree`), for {@link filesChangedSince}
@@ -26725,7 +27083,7 @@ var IsolationRunController = class {
    */
   async clearMerged(run) {
     const live2 = this.liveRecords(run);
-    const unlanded = Object.values(run.tasks).filter((r) => r.status !== "merged" && !live2.includes(r));
+    const unlanded = this.holdouts(run).filter((r) => !live2.includes(r));
     if (live2.length > 0 || unlanded.length > 0) {
       const why = [
         ...live2.length > 0 ? [`${tasksNamed(live2)} ${live2.length === 1 ? "is" : "are"} still running or waiting on you`] : [],
@@ -26735,13 +27093,22 @@ var IsolationRunController = class {
       this.tell("info", `The run is not cleared up: ${why.join(", and ")}, so ${one ? "its worktree stays" : "their worktrees stay"}, and so do the run's branches.`);
       return;
     }
+    if (await this.discardMerged(run)) this.forget();
+  }
+  /** The records that keep a settled run from being cleared up: live, or holding work that never landed. */
+  holdouts(run) {
+    const live2 = this.liveTasks();
+    return Object.values(run.tasks).filter((r) => live2.has(r.taskId) || r.status !== "merged");
+  }
+  /** The run's worktrees and merged branches go; false, said, when git would not let them. */
+  async discardMerged(run) {
     try {
       this.report(await this.isolation.discard(run, { integration: "delete-merged" }));
+      return true;
     } catch (err) {
       this.tell("warn", `Merged, but could not clean up the run's worktrees and branches: ${err instanceof Error ? err.message : String(err)}`);
-      return;
+      return false;
     }
-    this.forget();
   }
   /** Say what a removal kept back instead of deleting: where the work went, or which worktree stayed. */
   report(removal) {
@@ -27297,6 +27664,10 @@ var TaskOrchestrator = class _TaskOrchestrator {
   store;
   output;
   attempts = /* @__PURE__ */ new Map();
+  /** Bumped by every plan load: an ended attempt's wind-down belongs to the scope before it. */
+  planScope = 0;
+  /** Each task's runners still winding down once stopped: a continue waits for them (ADR-0018, L1). */
+  windDowns = /* @__PURE__ */ new Map();
   verifier = new VerdictEngine();
   /** Changed only by start, stop, a plan load, a usage-limit pause, a move off the limit, and {@link settleRun}. */
   runState = "idle";
@@ -27845,8 +28216,9 @@ var TaskOrchestrator = class _TaskOrchestrator {
     return blockingFailures(this.store.planTasks).get(taskId) ?? [];
   }
   loadPlan(tasks, planRunners = [...DEFAULT_RUNNERS]) {
-    this.store.load(tasks, planRunners);
     const repairs = this.endAllAttempts("load").filter((a) => a.kind.kind === "repair" && a.worktree);
+    this.planScope += 1;
+    this.store.load(tasks, planRunners);
     for (const a of repairs) this.unawaited(this.runs.release(a.taskId, { keep: true }, a.integration), `Could not keep the worktree of task "${this.store.get(a.taskId)?.title ?? a.taskId}"`);
     this.runs.interrupt({ keepOpen: this.isScheduling });
     if (this.runState !== "scheduling") this.runState = "idle";
@@ -27932,6 +28304,7 @@ var TaskOrchestrator = class _TaskOrchestrator {
     if (reason === "user") this.stopGeneration++;
     this.runState = "idle";
     this.verifier.reset();
+    for (const attempt of this.attempts.values()) this.stopRunner(attempt);
     this.runner.stopAll();
     const stopped = [];
     for (const a of this.endAllAttempts("stop")) {
@@ -28045,6 +28418,7 @@ var TaskOrchestrator = class _TaskOrchestrator {
     if (!task || !attempt) return;
     attempt.decided = true;
     const stoppedMidTurn = endedByExit(verdict) ? saidInFlight(attempt) : null;
+    this.stopRunner(attempt);
     console.error(`[TaskOrchestrator] Task ${taskRefOf(this.store.planTasks, task.id) ?? `#${task.order}`} "${task.title}" verdict=${verdict.outcome}`);
     console.error(`[TaskOrchestrator] Runner: ${task.assignedRunner}, Model: ${task.assignedModel?.modelId ?? "default"}`);
     console.error(`[TaskOrchestrator] Prompt preview: ${(task.prompt ?? "").slice(0, 200)}`);
@@ -28956,7 +29330,9 @@ ${now.message}` : LIMIT_RESET_MESSAGE;
       autoResumed: opts.autoResumed === true,
       turnError: null,
       turnOutputFrom: 0,
-      reminded: false
+      reminded: false,
+      runnerStopped: false,
+      planScope: this.planScope
     };
     this.spawnCounts.set(task.id, attempt.attempt);
     this.attempts.set(task.id, attempt);
@@ -28993,6 +29369,7 @@ ${now.message}` : LIMIT_RESET_MESSAGE;
       const manifest = this.registry?.get(attempt.runner)?.manifest;
       const unavailable = manifest && unavailableTaskModeMessage(manifest, task.taskMode);
       if (unavailable) throw new Error(unavailable);
+      if (kind.kind === "continuation") await this.windDowns.get(task.id);
       const { cwd, worktree, previousWork } = await attemptCwd(kind, task, this.runs);
       attempt.cwd = cwd;
       attempt.worktree = worktree;
@@ -29048,10 +29425,11 @@ ${now.message}` : LIMIT_RESET_MESSAGE;
       }
       if (takesSkills(kind)) this.store.setTaskAttemptSkills(task.id, [...attempt.skills]);
       session.onEvent((event) => {
-        if (event.type !== "usage" || this.attempts.get(task.id) !== attempt) return;
+        if (event.type !== "usage" || attempt.planScope !== this.planScope || this.attempts.get(task.id) !== attempt && !attempt.runnerStopped) return;
         this.store.recordAttemptUsage(task.id, attempt.attempt, event.record, (/* @__PURE__ */ new Date()).toISOString());
         this.emit("onUsageChanged");
       });
+      session.onExit(() => this.woundDown(attempt, session));
       this.output.attach(task.id, session);
       this.verifier.watch(task, session);
       session.onEvent((event) => {
@@ -29220,10 +29598,35 @@ ${now.message}` : LIMIT_RESET_MESSAGE;
     if (stopsRunner(reason)) {
       const task = this.store.get(taskId);
       if (task) this.verifier.clear(task);
-      if (session) this.runner.stop(session.id);
+      if (attempt) this.stopRunner(attempt);
     }
     return attempt;
   }
+  /**
+   * Let the attempt's runner go the way it ends a turn (ADR-0018, L1): it
+   * winds down on its own time, bounded by its interrupt grace, and nothing
+   * here waits on it but a continue of the same task.
+   */
+  stopRunner(attempt) {
+    const session = attempt.session;
+    if (!session || attempt.runnerStopped) return;
+    attempt.runnerStopped = true;
+    const { taskId } = attempt;
+    const windDown = Promise.all([this.windDowns.get(taskId), this.runner.stop(session.id)]).catch(() => void 0).then(() => {
+      if (this.windDowns.get(taskId) === windDown) this.windDowns.delete(taskId);
+    });
+    this.windDowns.set(taskId, windDown);
+  }
+  /**
+   * An ended attempt's runner is gone: the count its session ended on is the
+   * one a continue of that session counts from. One still current is ended
+   * with that count instead.
+   */
+  woundDown(attempt, session) {
+    if (attempt.planScope !== this.planScope || !attempt.runnerStopped || this.attempts.get(attempt.taskId) === attempt) return;
+    this.store.endAttemptUsage(attempt.taskId, attempt.attempt, (/* @__PURE__ */ new Date()).toISOString(), session.sessionCost?.() ?? void 0, session.nativeSessionId() ?? void 0);
+    this.emit("onUsageChanged");
+  }
   /** Kept on the task once the attempt ends, so a continue can resume it after a reload (ADR-0018, K1). */
   saveNativeSession(taskId, nativeSessionId, runner) {
     if (nativeSessionId) this.store.setTaskRunnerSessionId(taskId, nativeSessionId, runner);
@@ -29581,7 +29984,7 @@ function taskReadPage(text3, { lines: lines2, since }) {
 
 // src/services/plannerTools.ts
 var PLANNER_TURN_ENDED = "The planning turn this call was made in has ended, so nothing was submitted.";
-function runnersOf(tasks) {
+function runnersOf2(tasks) {
   return [...new Set(flattenTasks(tasks).filter((t) => t.type !== "user").map((t) => t.assignedRunner))];
 }
 function plannerToolHandler(host) {
@@ -30396,17 +30799,37 @@ var CliAgentAiService = class {
    * `startConversation` reseeds from Ordewell's transcript, which is the same
    * degradation `restoreChat` already performs on every surface.
    *
+   * A process can end while idle without Ordewell stopping it — the OS, the
+   * CLI itself, a sleeping machine, a signal sent to its group — and every
+   * path of ours that kills one also drops its adapter. So an adapter still
+   * held whose process has ended died on its own, and is restarted here
+   * rather than answering the next message with its exit code.
+   *
    * Also restarted when the policy's decision on the runner's own search has
    * changed since the process was spawned: the running thread would otherwise
    * keep searching unasked after Full turned Guarded. Codex 0.162 applies
    * `thread/resume`'s `config.web_search` either way (checked live).
    */
   async ensureAdapter(session) {
-    if (session.adapter && session.nativeSearch === this.nativeSearch(session)) return session.adapter;
+    const live2 = session.adapter;
+    if (live2 && !live2.exited && session.nativeSearch === this.nativeSearch(session)) return live2;
     session.stop();
     const start = session.start;
     if (!start) throw new Error("No active planner conversation.");
-    return this.startAdapter({ ...start.startOptions, resumeSessionId: session.nativeSessionId ?? void 0, resumeCost: session.sessionCost ?? void 0 }, start.tools, session);
+    const resumeSessionId = session.nativeSessionId ?? void 0;
+    try {
+      const adapter = await this.startAdapter({ ...start.startOptions, resumeSessionId, resumeCost: session.sessionCost ?? void 0 }, start.tools, session);
+      const resumed = adapter.nativeSessionId();
+      if (resumeSessionId && resumed && resumed !== resumeSessionId) {
+        throw new Error("The runner started a different session instead.");
+      }
+      return adapter;
+    } catch (err) {
+      if (!resumeSessionId || session.discarded.aborted) throw err;
+      if (this.session === session) this.session = null;
+      session.discard();
+      throw new Error(`The ${this.runner} planner's session could not be resumed (${err instanceof Error ? err.message : String(err)}). Send your message again: the planner picks the conversation up from its transcript.`);
+    }
   }
   /**
    * What the planner gets of the repository's config, its runner being
@@ -31532,6 +31955,12 @@ function withoutIsolation(tasks) {
 function handoffOf2({ type: _type, ...handoff }) {
   return handoff;
 }
+function stillToMerge(handoff, runMerge) {
+  if (!handoff?.landed.length) return handoff;
+  if (!runMerge) return null;
+  const same = runMerge.landed.length === handoff.landed.length && runMerge.landed.every((t, i) => t.taskId === handoff.landed[i].taskId);
+  return same ? handoff : { ...handoff, repos: runMerge.repos, landed: runMerge.landed };
+}
 function planTasks(plan) {
   if ("tasks" in plan) return plan.tasks;
   return rejoinPlanTree(plan.pendingTasks, plan.phase === "executing" ? plan.executionLog : []);
@@ -31552,6 +31981,7 @@ function reduceRun(view, input) {
         ...view,
         tasks: applyStatus(view.tasks, new Map(input.tasks.map((t) => [t.id, t]))),
         runMerge: input.runMerge ?? null,
+        handoff: stillToMerge(view.handoff, input.runMerge),
         usage: input.usage
       };
     case "task_started":
@@ -32104,19 +32534,50 @@ var TaskLogRecorder = class {
 };
 
 // src/services/ContextWindowFill.ts
-var ContextWindowFill = class {
-  constructor(catalog, last = {}) {
+var SessionWindows = class {
+  constructor(catalog = () => void 0) {
     this.catalog = catalog;
-    if (last.contextWindow !== void 0) this.known.set(modelKey(last.source, last.model), last.contextWindow);
   }
   catalog;
-  /** The window known for each model of the stream, by reporter and model. */
+  reported = /* @__PURE__ */ new Map();
+  report(source, model, contextWindow) {
+    if (contextWindow > 0) this.reported.set(modelKey(source, model), { source, model, contextWindow });
+  }
+  get(source, model) {
+    return this.reported.get(modelKey(source, model))?.contextWindow;
+  }
+  snapshot() {
+    return [...this.reported.values()];
+  }
+  restore(saved) {
+    this.reported.clear();
+    for (const { source, model, contextWindow } of saved ?? []) this.report(source, model, contextWindow);
+  }
+  clear() {
+    this.reported.clear();
+  }
+};
+var ContextWindowFill = class {
+  constructor(windows, last = {}) {
+    this.windows = windows;
+    if (last.contextWindow !== void 0) this.known.set(modelKey(last.source, last.model), last.contextWindow);
+  }
+  windows;
+  /** The window this stream used for each of its models, by reporter and model. */
   known = /* @__PURE__ */ new Map();
   fill(record) {
     if (record.subagentId || record.aggregate) return record;
     const key = modelKey(record.source, record.model);
+    if (record.compacted) {
+      if (!record.model) return record;
+      const known = this.windows.get(record.source, record.model) ?? this.known.get(key) ?? positive(this.windows.catalog(record.source, record.model));
+      if (known === void 0) return record;
+      this.known.set(key, known);
+      return { ...record, contextWindow: known };
+    }
     const reported = record.contextWindow !== void 0 && record.contextWindow > 0 ? record.contextWindow : void 0;
-    const window = reported ?? this.known.get(key) ?? (record.model ? positive(this.catalog(record.source, record.model)) : void 0);
+    if (reported !== void 0 && record.model) this.windows.report(record.source, record.model, reported);
+    const window = reported ?? (record.model ? this.windows.get(record.source, record.model) : void 0) ?? this.known.get(key) ?? (record.model ? positive(this.windows.catalog(record.source, record.model)) : void 0);
     if (window !== void 0) this.known.set(key, window);
     return window === void 0 || window === record.contextWindow ? record : { ...record, contextWindow: window };
   }
@@ -32124,9 +32585,9 @@ var ContextWindowFill = class {
 function modelKey(source, model) {
   return JSON.stringify([source ?? null, model ?? null]);
 }
-function withContextWindows(runner, catalog) {
+function withContextWindows(runner, windows) {
   return {
-    spawn: async (opts) => windowedSession(await runner.spawn(opts), new ContextWindowFill(catalog, opts.resumeWindow)),
+    spawn: async (opts) => windowedSession(await runner.spawn(opts), new ContextWindowFill(windows, opts.resumeWindow)),
     stop: (sessionId) => runner.stop(sessionId),
     stopAll: () => runner.stopAll(),
     get activeCount() {
@@ -32157,12 +32618,12 @@ function positive(n) {
 
 // src/services/PlannerUsage.ts
 var PlannerUsageLedger = class {
-  /** `catalogWindow` serves the window of a planner model whose backend reports none. */
-  constructor(catalogWindow = () => void 0) {
-    this.catalogWindow = catalogWindow;
-    this.windows = new ContextWindowFill(catalogWindow);
+  /** `sessionWindows` serves the window of a planner model whose backend reports none. */
+  constructor(sessionWindows = new SessionWindows()) {
+    this.sessionWindows = sessionWindows;
+    this.windows = new ContextWindowFill(sessionWindows);
   }
-  catalogWindow;
+  sessionWindows;
   usage = { totals: {} };
   windows;
   /** Fold one model call's record into the totals; returns the running ledger. */
@@ -32173,16 +32634,16 @@ var PlannerUsageLedger = class {
   /** Adopt a persisted ledger (a reopened session) or start from zero. */
   restore(usage) {
     this.usage = usage ?? { totals: {} };
-    this.windows = new ContextWindowFill(this.catalogWindow, this.usage);
+    this.windows = new ContextWindowFill(this.sessionWindows, this.usage);
   }
   /** Start a fresh session's ledger from zero. */
   clear() {
     this.usage = { totals: {} };
-    this.windows = new ContextWindowFill(this.catalogWindow);
+    this.windows = new ContextWindowFill(this.sessionWindows);
   }
-  /** Whether anything has been recorded — a plan with no usage says nothing. */
+  /** Whether the ledger has measures or session billing facts to broadcast. */
   get hasUsage() {
-    return isMeasured(this.usage.totals);
+    return isMeasured(this.usage.totals) || this.usage.sessionBilling !== void 0;
   }
   /** The value persisted onto the plan state. */
   snapshot() {
@@ -33631,7 +34092,7 @@ function createSession(deps) {
   const backend = new PlannerBackend(deps.aiService ? { pinned: deps.aiService, busy } : { provider: () => deps.config.aiProvider, create: () => createAiService(deps.config, { workspaceRoot: deps.workspaceRoot, mcpServer }), busy });
   const aiService = () => backend.current();
   const store = new PlanStore();
-  const catalogWindow = (source, model) => deps.modelResolver.contextWindowFor?.(source, model);
+  const windows = new SessionWindows((source, model) => deps.modelResolver.contextWindowFor?.(source, model));
   const taskLogs = new TaskLogRecorder({
     broadcast: deps.broadcast,
     // Read through the Session, whose id and workspace are the ones it saves
@@ -33664,7 +34125,7 @@ function createSession(deps) {
   const orchestrator = TaskOrchestrator.compose({
     config: deps.config,
     notifications: deps.notifications,
-    runner: taskLogs.wrap(runnerApprovals.wrap(withContextWindows(deps.runner, catalogWindow))),
+    runner: taskLogs.wrap(runnerApprovals.wrap(withContextWindows(deps.runner, windows))),
     store,
     output: deps.taskOutput,
     isolation: deps.isolation,
@@ -33676,7 +34137,7 @@ function createSession(deps) {
     runSettings: () => session.planState?.runSettings,
     isApproved: (taskId) => session.isApproved(taskId)
   });
-  const usage = new PlannerUsageLedger(catalogWindow);
+  const usage = new PlannerUsageLedger(windows);
   const events = new SessionEventRelay({
     broadcast: deps.broadcast,
     onNotice: deps.onNotice,
@@ -33746,6 +34207,7 @@ function createSession(deps) {
     runs: orchestrator.runs,
     events,
     usage,
+    windows,
     approvals,
     approvalPolicy,
     taskLogs,
@@ -33773,6 +34235,7 @@ function configSecrets(config) {
 var Session = class {
   backend;
   usage;
+  windows;
   events;
   planner;
   orchestrator;
@@ -33878,6 +34341,7 @@ var Session = class {
     this.runs = parts.runs;
     this.events = parts.events;
     this.usage = parts.usage;
+    this.windows = parts.windows;
     this.approvals = parts.approvals;
     this.approvalPolicy = parts.approvalPolicy;
     this.taskLogs = parts.taskLogs;
@@ -34356,6 +34820,7 @@ var Session = class {
     this.syncPlanTasks();
     this.plan.isolation = this.runs.planIsolation ?? void 0;
     this.plan.plannerUsage = this.usage.snapshot();
+    this.plan.contextWindows = this.windows.snapshot();
     this.plan.supervision = this.supervision.snapshot();
     this.plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     this.save(this.plan, this.goal, this.workspace, this.currentSessionId);
@@ -34385,6 +34850,7 @@ var Session = class {
     this.owingEffects.clear();
     this.conversation.reset();
     this.usage.clear();
+    this.windows.clear();
     this.approvals.clear(isPlannerApproval);
     if (!keepGrants) this.approvalPolicy.reset();
     this.store.clearLog();
@@ -34725,7 +35191,18 @@ var Session = class {
     if (!this.plan) throw new ConversationEditError("No planning conversation to condense");
     const opening = this.plannerTurnMayOpen(signal);
     if (opening) await opening;
-    return this.conversation.compact(signal);
+    const compaction = await this.conversation.compact(signal);
+    const usage = this.usage.snapshot();
+    if (usage.lastPromptTokens !== void 0) {
+      this.usage.record({
+        source: usage.source ?? this.config.aiProvider,
+        ...usage.model ? { model: usage.model } : {},
+        compacted: true
+      });
+      this.persist();
+      this.broadcast(this.usage.message());
+    }
+    return compaction;
   }
   rewindTargets() {
     return this.conversation.rewindTargets();
@@ -34812,7 +35289,7 @@ var Session = class {
    */
   adoptPlannerTasks(tasks, how) {
     this.turnEffects.landed(how);
-    for (const runner of runnersOf(tasks)) this.editor.admitRunner(runner, this.catalog.known(runner));
+    for (const runner of runnersOf2(tasks)) this.editor.admitRunner(runner, this.catalog.known(runner));
     const runners = this.plan.runners;
     const before = this.store.planTasks;
     let coerced = resolveAssignments(tasks, before, this.catalog.edit(runners)).tasks;
@@ -35035,9 +35512,9 @@ var Session = class {
   runSnapshot() {
     if (!this.plan) return EMPTY_RUN;
     const planned = reduceRun(EMPTY_RUN, { type: "plan_snapshot", plan: surfacePlan({ ...this.plan, tasks: this.store.snapshot() }) });
-    const view = reduceRun(planned, this.events.statusMessage());
-    const held2 = this.sentHeld ? reduceRun(view, { type: "plan_edit_held", held: this.sentHeld }) : view;
-    return this.sentHandoff ? reduceRun(held2, { type: "isolation_handoff", ...this.sentHandoff }) : held2;
+    const handed = this.sentHandoff ? reduceRun(planned, { type: "isolation_handoff", ...this.sentHandoff }) : planned;
+    const view = reduceRun(handed, this.events.statusMessage());
+    return this.sentHeld ? reduceRun(view, { type: "plan_edit_held", held: this.sentHeld }) : view;
   }
   /** The ancestors a task waits on at its merge gate (ADR-0020); empty when it waits for no Merge all. */
   mergeGate(taskId) {
@@ -35213,7 +35690,10 @@ var Session = class {
     if (!plan.approvedTasks && plan.approved) {
       plan.approvedTasks = flattenTasks(plan.tasks).map((t) => t.id);
     }
-    if (adopting) this.usage.restore(plan.plannerUsage);
+    if (adopting) {
+      this.usage.restore(plan.plannerUsage);
+      this.windows.restore(plan.contextWindows);
+    }
     if (opts?.sessionId) this.currentSessionId = opts.sessionId;
     if (adopting) {
       for (const task of flattenTasks(plan.tasks)) delete task.resumeAt;
@@ -35227,12 +35707,31 @@ var Session = class {
     }
     carryOverQueuedEdits(plan);
     if (adopting) {
-      void this.runs.adopt(plan.isolation ?? null);
+      void this.adoptRun(plan, opts?.persist !== false || opts?.sessionId !== void 0);
       this.sentHandoff = this.owedHandoff();
     }
     if (opts?.persist !== false) this.persist();
     if (this.usage.hasUsage) this.broadcast(this.usage.message());
   }
+  /**
+   * Take the loaded plan's run over, then correct what the surfaces were told
+   * by what git found: the saved record cannot know what the user merged
+   * since, and its handoff would offer Merge all for work already in their
+   * branch. The status update says what landed work is still unmerged, which
+   * a handoff folds to (see `reduceRun`), and `run_closed` that the run was
+   * cleared up. Saved only where the load itself may save (`persists`), so a
+   * restore with no session file to write keeps the correction in memory for
+   * its next save. A plan loaded meanwhile is not this one's to correct.
+   * Starts nothing (ADR-0044).
+   */
+  async adoptRun(plan, persists) {
+    const outcome = await this.runs.adopt(plan.isolation ?? null);
+    if (this.closed || this.plan !== plan || outcome === "unchanged") return;
+    plan.isolation = this.runs.planIsolation ?? void 0;
+    if (persists) this.persist();
+    this.events.status(plan);
+    if (outcome === "cleared") this.broadcast({ type: "run_closed" });
+  }
   destroy() {
     this.closed = true;
     this.dropPlanScope();
@@ -35276,7 +35775,7 @@ function openTurn(view, { turnId, prompt = "", skills = [], wakeUps = [], forced
   wakeUps = wakeUps.slice(adopted.wakeUps);
   if (wakeUps.length === 0) return adopted.prompt || prompt === "" && adopted.wakeUps > 0 ? view : promptLine(view, turnId, prompt, skills, forced);
   const said2 = prompt === "" || adopted.prompt ? view : promptLine(view, turnId, prompt, skills, forced);
-  const at = prompt === "" ? said2.blocks.length : findLastIndex(said2.blocks, (b) => b.type === "message" && b.role === "user" && b.turnId === turnId);
+  const at = prompt === "" ? said2.blocks.length - (said2.blocks.at(-1)?.type === "usage" ? 1 : 0) : findLastIndex(said2.blocks, (b) => b.type === "message" && b.role === "user" && b.turnId === turnId);
   const updates = wakeUps.map((text3, n) => settledMessage(`b${said2.nextId + n}`, "wake_up", text3, turnId));
   return { ...said2, blocks: [...said2.blocks.slice(0, at), ...updates, ...said2.blocks.slice(at)], nextId: said2.nextId + updates.length };
 }
@@ -35963,17 +36462,12 @@ var AbstractRunner = class {
   get activeCount() {
     return this.sessions.size;
   }
+  /** A session winding down stays registered until it exits, so a second stop gets the same wind-down. */
   stop(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    session.kill();
-    this.sessions.delete(sessionId);
+    return this.sessions.get(sessionId)?.stop() ?? Promise.resolve();
   }
   stopAll() {
-    for (const [, session] of this.sessions) {
-      session.kill();
-    }
-    this.sessions.clear();
+    for (const session of this.sessions.values()) void session.stop();
   }
   registerSession(id, session) {
     this.sessions.set(id, session);
@@ -36131,6 +36625,8 @@ var StructuredSession = class extends AbstractRunnerSession {
   queue = [];
   messageCount = 0;
   interrupting = null;
+  /** The wind-down once {@link stop} was asked for: the same for every caller, and nothing new is sent meanwhile. */
+  stopping = null;
   lastSessionId = null;
   lastSessionCost = null;
   structuredEmitter = new import_events2.EventEmitter();
@@ -36156,7 +36652,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     await this.startAttached(this.launch.startOptions);
     this.state = "working";
     setImmediate(() => {
-      if (!this.exited) this.deliver(prompt);
+      if (!this.exited && !this.stopping) this.deliver(prompt);
     });
   }
   getOutput() {
@@ -36236,6 +36732,53 @@ var StructuredSession = class extends AbstractRunnerSession {
     this.withdrawPermissions();
     this.baseHandleExit(-1);
   }
+  stop() {
+    if (this.stopping) return this.stopping;
+    if (this.exited) return Promise.resolve();
+    let woundDown;
+    this.stopping = new Promise((resolve9) => {
+      woundDown = resolve9;
+    });
+    void this.windDown().catch(() => this.kill()).then(woundDown);
+    return this.stopping;
+  }
+  /**
+   * The attempt is over (ADR-0018, L1), so what is still owed goes undelivered
+   * and every tool request unanswered at once. A turn still open is
+   * interrupted, and its close — where Claude Code reports the turn's cost and
+   * its model's window — is waited for; then the runner is told nothing more
+   * is coming and left to exit by itself. All of it within the interrupt
+   * grace: a runner still there once it runs out is killed.
+   */
+  async windDown() {
+    const adapter = this.adapterAttached ? this.adapter : null;
+    const deadline = Date.now() + this.launch.interruptGraceMs;
+    this.revokeTools();
+    this.undeliverQueued();
+    this.withdrawPermissions();
+    const open = this.turn && !this.turn.ended ? this.turn : null;
+    if (adapter && (!open || await this.turnClosed(open, adapter, deadline)) && adapter.endInput && !this.exited) {
+      adapter.endInput();
+      await this.within(this.gone(), deadline);
+    }
+    if (this.exited) adapter?.dispose();
+    else this.kill();
+  }
+  /** Whether `turn` closed within the deadline once interrupted. */
+  async turnClosed(turn, adapter, deadline) {
+    const closed = new Promise((resolve9) => this.structuredEmitter.once("turnEnd", () => resolve9()));
+    adapter.interrupt(Math.max(0, deadline - Date.now())).catch(() => false);
+    return await this.within(closed, deadline) && turn.ended;
+  }
+  /** Whether `done` settled before the deadline, or the session ended meanwhile. */
+  within(done, deadline) {
+    return settleWithin(done.then(() => true), { timeoutMs: Math.max(0, deadline - Date.now()), onTimeout: () => false, ended: this.gone(), onEnded: () => true });
+  }
+  gone() {
+    const { signal } = this.ended;
+    if (signal.aborted) return Promise.resolve();
+    return new Promise((resolve9) => signal.addEventListener("abort", () => resolve9(), { once: true }));
+  }
   turnState() {
     return this.state;
   }
@@ -36261,7 +36804,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     this.messageCount += 1;
     const id = `msg-${this.messageCount}`;
     const sender2 = opening.from ? { from: opening.from } : {};
-    if (this.exited) this.emitEvent({ type: "message_undelivered", messageId: id, text: text3, ...sender2 });
+    if (this.exited || this.stopping) this.emitEvent({ type: "message_undelivered", messageId: id, text: text3, ...sender2 });
     else if (this.state === "idle" && this.adapterStarted && !this.sending) this.deliver(text3, opening);
     else {
       this.state = "working";
@@ -36316,7 +36859,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     });
   }
   runningTurn() {
-    return !this.exited && this.adapter !== null && this.turn !== null && !this.turn.ended;
+    return !this.exited && !this.stopping && this.adapter !== null && this.turn !== null && !this.turn.ended;
   }
   /** No runner can recall a message once offered to it, so only a queued one comes back. */
   removeQueued(id) {
@@ -36377,7 +36920,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     if (this.interrupting) return this.interrupting;
     const turn = this.turn;
     const adapter = this.adapter;
-    if (!turn || turn.ended || !adapter) return Promise.resolve();
+    if (!turn || turn.ended || !adapter || this.stopping) return Promise.resolve();
     this.interrupting = this.interruptTurn(turn, adapter).finally(() => {
       this.interrupting = null;
       this.offerNext();
@@ -36391,7 +36934,7 @@ var StructuredSession = class extends AbstractRunnerSession {
       const settled = await settleWithin(ended.then(() => true), { timeoutMs: grace, onTimeout: () => false });
       if (settled) return;
     }
-    if (turn.ended || this.exited) return;
+    if (turn.ended || this.exited || this.stopping) return;
     await this.restartInterrupted(turn);
   }
   /**
@@ -36495,7 +37038,7 @@ var StructuredSession = class extends AbstractRunnerSession {
   offerNext() {
     const adapter = this.adapter;
     const turn = this.turn;
-    if (!adapter?.steer || !turn || turn.ended || turn.steerRefused || this.interrupting || this.exited) return;
+    if (!adapter?.steer || !turn || turn.ended || turn.steerRefused || this.interrupting || this.exited || this.stopping) return;
     if (this.queue.some((m) => m.stage === "steering")) return;
     const next = this.queue.find((m) => m.stage === "queued");
     if (!next || next.command) return;
@@ -36570,7 +37113,7 @@ var StructuredSession = class extends AbstractRunnerSession {
       }
       return;
     }
-    if (!turn && TURN_OPENING_EVENTS.has(event.type) && !("subagentId" in event && event.subagentId)) {
+    if (!turn && !this.stopping && TURN_OPENING_EVENTS.has(event.type) && !("subagentId" in event && event.subagentId)) {
       turn = this.openTurn("");
       this.offerNext();
     }
@@ -36641,7 +37184,7 @@ var StructuredSession = class extends AbstractRunnerSession {
    * back in Ordewell's hands: while it is on offer or owed, nothing overtakes it.
    */
   deliverNext() {
-    if (this.exited || this.sending || this.turn && !this.turn.ended) return;
+    if (this.exited || this.stopping || this.sending || this.turn && !this.turn.ended) return;
     const head = this.queue[0];
     if (!head || this.queue.some((message) => message.stage !== "queued")) return;
     this.queue.shift();
@@ -36810,11 +37353,13 @@ var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
   return path34.join(getStateDir(baseDir), STATE_FILE);
 }
-function saveState(plan, baseDir) {
+var SESSION_ID_KEY = "sessionId";
+function saveState(plan, baseDir, sessionId) {
   const statePath = getStatePath(baseDir ?? process.cwd());
   ensureDir(path34.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  fs17.writeFileSync(statePath, JSON.stringify(plan, null, 2));
+  const file = sessionId ? { ...plan, [SESSION_ID_KEY]: sessionId } : plan;
+  fs17.writeFileSync(statePath, JSON.stringify(file, null, 2));
 }
 function loadState(baseDir, logger = defaultLogger) {
   const dir = baseDir ?? process.cwd();
@@ -36827,10 +37372,12 @@ function loadState(baseDir, logger = defaultLogger) {
       logger.warn("stateStore", `rejecting state from ${statePath}: old format (scalar "runner" instead of "runners" array). Please re-plan.`);
       return null;
     }
+    const sessionId = parsed[SESSION_ID_KEY];
+    delete parsed[SESSION_ID_KEY];
     const plan = parsed;
     migratePlanStateIsolation(plan);
     migrateLoadedTasks(plan.tasks);
-    return plan;
+    return typeof sessionId === "string" && sessionId ? { plan, sessionId } : { plan };
   } catch (err) {
     logger.warn("stateStore", `failed to load state from ${statePath}; falling back to empty state`, err);
     return null;
@@ -37087,7 +37634,10 @@ var PlannerModelMemory = class {
   collectProviderCredentials,
   commandAllowedBy,
   configuredProviders,
+  contextMeterText,
+  contextMeterTitle,
   continuability,
+  costText,
   countedSessionCost,
   createAiService,
   createEmptyPlan,
@@ -37130,7 +37680,9 @@ var PlannerModelMemory = class {
   flattenTasksWithParents,
   followTaskLog,
   followTurn,
+  formatCost,
   formatSearchOutput,
+  formatTokenCount,
   fromTranscript,
   getLatestSession,
   getProviderMeta,
@@ -37182,6 +37734,7 @@ var PlannerModelMemory = class {
   migratePlanState,
   mintDaemonToken,
   mintSessionId,
+  modelCostTitle,
   namedRepos,
   newTaskFields,
   normalizeAgentArgs,
@@ -37267,6 +37820,7 @@ var PlannerModelMemory = class {
   stopTurn,
   stripAnsi,
   stripModelPrefix,
+  subagentCostTitle,
   subtreeIds,
   summarizeToolCall,
   supervisorSummary,
@@ -37285,6 +37839,7 @@ var PlannerModelMemory = class {
   taskStartedNotice,
   taskStatusKind,
   taskUsageSummary,
+  tasksTotalText,
   textHasTaskOps,
   textHasTaskQuery,
   titledRefs,
@@ -37302,6 +37857,7 @@ var PlannerModelMemory = class {
   unsendAll,
   unsendLatest,
   usageLine,
+  usageText,
   waitsForApproval,
   walkPlan,
   wellKnownBinDirs,