@ordewell/core 0.10.9 → 0.10.11

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.inputTokens !== void 0) next.lastPromptTokens = record.inputTokens;
+  if (record.source !== usage.source || record.model !== usage.model) {
+    delete next.lastPromptTokens;
+    delete next.contextWindow;
+  }
+  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);
@@ -11628,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",
@@ -11636,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) {
@@ -11685,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.
@@ -11781,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;
@@ -11854,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);
   }
@@ -11899,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
@@ -11986,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
@@ -12040,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;
@@ -12083,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") {
@@ -12099,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;
@@ -12110,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")) {
@@ -12274,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 —
@@ -12292,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 (!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;
     }
-    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 } });
+    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 } });
   }
 };
 
@@ -12944,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;
@@ -13505,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;
@@ -13635,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;
@@ -13662,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 });
   }
@@ -13823,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":
@@ -14119,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) {
@@ -14683,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") {
@@ -15548,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);
@@ -20570,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()) {
@@ -24260,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);
@@ -24267,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++) {
@@ -24725,9 +25015,11 @@ function plannerNotReadyFor(config) {
 var TERMINAL_UI_COMMANDS = {
   pickPlanner: "/planner",
   setKey: () => "/key",
-  setModel: "/model"
+  // `/planner` walks harness, model and effort in one flow; there is no
+  // separate `/model` (or `/planner-effort`) to point at.
+  setModel: "/planner"
 };
-var CHAT_COMMANDS = { ...TERMINAL_UI_COMMANDS, setModel: "/model set" };
+var CHAT_COMMANDS = { ...TERMINAL_UI_COMMANDS };
 var HEADLESS_CLI_COMMANDS = {
   pickPlanner: "ordewell planner <id>",
   setKey: (provider) => `ordewell key set ${provider} <key>`,
@@ -24741,7 +25033,7 @@ function harnessPlannerNames() {
 var PLANNER_ESCAPE_HINT = `or pick a coding agent with ${TERMINAL_UI_COMMANDS.pickPlanner}: it plans with no API key`;
 function describePlannerNotReady(reason, commands) {
   if (reason.code === "no_model") {
-    return `No planner model selected for ${reason.label}. Pick one with ${commands.setModel}, or switch planner with ${commands.pickPlanner}.`;
+    return commands.setModel === commands.pickPlanner ? `No planner model selected for ${reason.label}. Pick one with ${commands.setModel}.` : `No planner model selected for ${reason.label}. Pick one with ${commands.setModel}, or switch planner with ${commands.pickPlanner}.`;
   }
   const lead = `No planner is ready. Pick one with ${commands.pickPlanner}: ${harnessPlannerNames()} plan with no API key.`;
   if (reason.code === "no_base_url") {
@@ -24775,7 +25067,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;
@@ -25178,7 +25471,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;
@@ -25197,9 +25492,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;
   }
 };
@@ -27370,6 +27666,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";
@@ -27918,8 +28218,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";
@@ -28005,6 +28306,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")) {
@@ -28118,6 +28420,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)}`);
@@ -29029,7 +29332,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);
@@ -29066,6 +29371,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;
@@ -29121,10 +29427,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) => {
@@ -29293,10 +29600,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);
@@ -29654,7 +29986,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) {
@@ -32204,19 +32536,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 };
   }
@@ -32224,9 +32587,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() {
@@ -32257,12 +32620,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. */
@@ -32273,16 +32636,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() {
@@ -33731,7 +34094,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
@@ -33764,7 +34127,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,
@@ -33776,7 +34139,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,
@@ -33846,6 +34209,7 @@ function createSession(deps) {
     runs: orchestrator.runs,
     events,
     usage,
+    windows,
     approvals,
     approvalPolicy,
     taskLogs,
@@ -33873,6 +34237,7 @@ function configSecrets(config) {
 var Session = class {
   backend;
   usage;
+  windows;
   events;
   planner;
   orchestrator;
@@ -33978,6 +34343,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;
@@ -34456,6 +34822,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);
@@ -34485,6 +34852,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();
@@ -34825,7 +35193,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();
@@ -34912,7 +35291,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;
@@ -35313,7 +35692,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;
@@ -35395,7 +35777,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 };
 }
@@ -36082,17 +36464,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);
@@ -36244,12 +36621,17 @@ var StructuredSession = class extends AbstractRunnerSession {
   text;
   state = "idle";
   turn = null;
+  /** A `task_complete` report waiting for its turn to close; the verdict is published then. */
+  completionReport = null;
+  completionTimer = null;
   /** A terminal event ends the turn before the adapter releases its send. */
   sending = null;
   turnCount = 0;
   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();
@@ -36275,7 +36657,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() {
@@ -36300,7 +36682,9 @@ var StructuredSession = class extends AbstractRunnerSession {
       create: () => this.launch.createAdapter(this.launch.runner, this.launch.deps),
       issueToken: () => server4.issueTaskToken(scope, {
         taskComplete: async (report) => {
-          this.structuredEmitter.emit("taskComplete", report);
+          this.completionReport = report;
+          if (this.completionTimer) clearTimeout(this.completionTimer);
+          this.completionTimer = setTimeout(() => this.flushCompletion(), this.launch.interruptGraceMs);
           return { text: "Recorded. End your turn now." };
         },
         checkpoint: async ({ question }, { signal }) => {
@@ -36332,6 +36716,8 @@ var StructuredSession = class extends AbstractRunnerSession {
     this.toolToken = null;
   }
   baseHandleExit(code) {
+    this.undeliverQueued();
+    this.flushCompletion();
     this.ended.abort();
     this.revokeTools();
     this.undeliverQueued();
@@ -36355,6 +36741,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;
   }
@@ -36380,7 +36813,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";
@@ -36425,6 +36858,7 @@ var StructuredSession = class extends AbstractRunnerSession {
    * "waiting for input" between the two (F3).
    */
   force(message) {
+    this.discardCompletion();
     message.forced = true;
     const at = this.queue.findIndex((m) => !m.forced);
     this.queue.splice(at < 0 ? this.queue.length : at, 0, message);
@@ -36435,7 +36869,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) {
@@ -36496,7 +36930,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();
@@ -36510,7 +36944,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);
   }
   /**
@@ -36566,6 +37000,7 @@ var StructuredSession = class extends AbstractRunnerSession {
   /** `message` is what opened the turn: a queued one has an id, one delivered straight from idle only its sender. */
   openTurn(text3, message) {
     this.turnCount += 1;
+    this.discardCompletion();
     const turn = { id: this.turnCount, abort: new AbortController(), ended: false, reason: "completed", steerRefused: false };
     this.turn = turn;
     this.state = "working";
@@ -36614,7 +37049,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;
@@ -36658,6 +37093,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     } else if (event.type === "permission_request") this.openPermission(adapter, event);
     else if (event.type === "permission_cancelled") this.cancelPermission(adapter, event.id);
     else if (event.type === "message_delivered") {
+      this.discardCompletion();
       const message = this.delivered(event.id);
       if (message) this.emitEvent({ type: "message_delivered", messageId: message.id, text: message.text, ...message.from ? { from: message.from } : {} });
     } else if (event.type === "message_dropped") {
@@ -36689,7 +37125,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();
     }
@@ -36738,6 +37174,24 @@ var StructuredSession = class extends AbstractRunnerSession {
     }
     this.emitEvent(event);
   }
+  /** Publish a `task_complete` report whose turn has closed, or that waited out the grace. */
+  flushCompletion() {
+    if (this.completionTimer) {
+      clearTimeout(this.completionTimer);
+      this.completionTimer = null;
+    }
+    const report = this.completionReport;
+    this.completionReport = null;
+    if (report) this.structuredEmitter.emit("taskComplete", report);
+  }
+  /** A message the runner reads, or a turn it opens, voids a report made before it (ADR-0023, D6). */
+  discardCompletion() {
+    if (this.completionTimer) {
+      clearTimeout(this.completionTimer);
+      this.completionTimer = null;
+    }
+    this.completionReport = null;
+  }
   /**
    * A queued message goes out as the turn closes, and the state never passes
    * through `idle` on the way, so a listener told the turn ended can already
@@ -36750,6 +37204,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     turn.ended = true;
     this.text.endTurn();
     this.emitEvent({ type: "turn_end", reason });
+    this.flushCompletion();
     if (reason === "failed") this.undeliverQueued();
     this.state = !this.exited && this.queue.length ? "working" : "idle";
     this.structuredEmitter.emit("turnEnd", reason);
@@ -36760,7 +37215,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();
@@ -37210,7 +37665,10 @@ var PlannerModelMemory = class {
   collectProviderCredentials,
   commandAllowedBy,
   configuredProviders,
+  contextMeterText,
+  contextMeterTitle,
   continuability,
+  costText,
   countedSessionCost,
   createAiService,
   createEmptyPlan,
@@ -37253,7 +37711,9 @@ var PlannerModelMemory = class {
   flattenTasksWithParents,
   followTaskLog,
   followTurn,
+  formatCost,
   formatSearchOutput,
+  formatTokenCount,
   fromTranscript,
   getLatestSession,
   getProviderMeta,
@@ -37305,6 +37765,7 @@ var PlannerModelMemory = class {
   migratePlanState,
   mintDaemonToken,
   mintSessionId,
+  modelCostTitle,
   namedRepos,
   newTaskFields,
   normalizeAgentArgs,
@@ -37390,6 +37851,7 @@ var PlannerModelMemory = class {
   stopTurn,
   stripAnsi,
   stripModelPrefix,
+  subagentCostTitle,
   subtreeIds,
   summarizeToolCall,
   supervisorSummary,
@@ -37408,6 +37870,7 @@ var PlannerModelMemory = class {
   taskStartedNotice,
   taskStatusKind,
   taskUsageSummary,
+  tasksTotalText,
   textHasTaskOps,
   textHasTaskQuery,
   titledRefs,
@@ -37425,6 +37888,7 @@ var PlannerModelMemory = class {
   unsendAll,
   unsendLatest,
   usageLine,
+  usageText,
   waitsForApproval,
   walkPlan,
   wellKnownBinDirs,