@ordewell/core 0.10.8 → 0.10.10

package/dist/index.mjs

@@ -2,7 +2,7 @@ import {
   looksLikePlanAttempt,
   parsePlanJson,
   validatePlanTasks
-} from "./chunk-LTHKFBKM.mjs";
+} from "./chunk-KWS3VEER.mjs";
 import {
   ACT_RISK,
   AUTORUN_RISK,
@@ -38,7 +38,10 @@ import {
   canSplitTask,
   capConflictFiles,
   classifyOutcome,
+  contextMeterText,
+  contextMeterTitle,
   continuability,
+  costText,
   countedSessionCost,
   dependentsNotice,
   diffRows,
@@ -49,6 +52,8 @@ import {
   executionSummary,
   followTaskLog,
   followTurn,
+  formatCost,
+  formatTokenCount,
   fromTranscript,
   hasHiddenDetail,
   holdPrompt,
@@ -59,6 +64,7 @@ import {
   markRequestFor,
   markdownHtml,
   markdownTokens,
+  modelCostTitle,
   namedRepos,
   newTaskFields,
   normalizeAgentArgs,
@@ -90,6 +96,7 @@ import {
   skippedLabel,
   startAttemptUsage,
   stopTurn,
+  subagentCostTitle,
   summarizeToolCall,
   supervisorSummary,
   surfacePlan,
@@ -103,6 +110,7 @@ import {
   taskStartedNotice,
   taskStatusKind,
   taskUsageSummary,
+  tasksTotalText,
   textHasTaskOps,
   titledRefs,
   toolHeadline,
@@ -110,8 +118,9 @@ import {
   unsendAll,
   unsendLatest,
   usageLine,
+  usageText,
   validateTaskEdit
-} from "./chunk-DMG4ISUG.mjs";
+} from "./chunk-ESKK5I4F.mjs";
 import {
   PLAN_ENVELOPE_KEY,
   PlanParseError,
@@ -137,7 +146,7 @@ import {
   runnerModesFrom,
   stripTrailingCommas,
   unavailableTaskModeMessage
-} from "./chunk-H7QX32BH.mjs";
+} from "./chunk-24EL4Z2W.mjs";
 import {
   SELF_REPO,
   absorbRemoval,
@@ -190,7 +199,7 @@ import {
   waitsForApproval,
   waitsForReset,
   walkPlan
-} from "./chunk-EEE2GBLG.mjs";
+} from "./chunk-PFH7WFIB.mjs";
 
 // src/models/TaskLog.ts
 var HEAD_LINES = 60;
@@ -6028,7 +6037,7 @@ var RunnerApprovals = class {
       },
       stop: (sessionId) => {
         this.denySession(sessionId);
-        runner.stop(sessionId);
+        return runner.stop(sessionId);
       },
       stopAll: () => {
         this.approvals.clear(isRunnerApproval);
@@ -9072,6 +9081,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. */
@@ -9122,6 +9133,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 });
@@ -9176,6 +9188,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;
@@ -9374,6 +9395,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);
@@ -9874,6 +9898,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",
@@ -9882,6 +9914,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) {
@@ -9931,16 +9964,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.
@@ -10027,6 +10071,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;
@@ -10100,11 +10152,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);
   }
@@ -10145,6 +10196,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
@@ -10232,6 +10292,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
@@ -10286,6 +10347,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;
@@ -10329,12 +10392,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") {
@@ -10345,6 +10420,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;
@@ -10356,6 +10433,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")) {
@@ -10520,16 +10598,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 —
@@ -10538,24 +10669,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 } });
   }
 };
 
@@ -11190,9 +11351,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;
@@ -11751,8 +11916,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;
@@ -11881,6 +12059,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;
@@ -11908,6 +12093,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 });
   }
@@ -12069,7 +12256,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":
@@ -12365,8 +12554,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) {
@@ -12929,6 +13119,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") {
@@ -13187,7 +13378,7 @@ var OpenCodeAdapter = class {
     return this.runner.ended;
   }
   get exited() {
-    return this.runner.exit !== null;
+    return this.runner.hasExited;
   }
   async start(opts) {
     try {
@@ -13794,6 +13985,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);
@@ -17348,6 +17540,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()) {
@@ -19891,10 +20084,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;
@@ -20953,6 +21157,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);
@@ -20960,7 +21167,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++) {
@@ -21470,7 +21678,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;
@@ -21873,7 +22082,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;
@@ -21892,9 +22103,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;
   }
 };
@@ -23042,6 +23254,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();
@@ -23117,18 +23331,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.`);
       }
@@ -23136,6 +23359,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() {
@@ -23292,8 +23533,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;
@@ -23320,11 +23560,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}
@@ -23446,7 +23696,7 @@ var IsolationRunController = class {
    */
   async clearMerged(run) {
     const live = this.liveRecords(run);
-    const unlanded = Object.values(run.tasks).filter((r) => r.status !== "merged" && !live.includes(r));
+    const unlanded = this.holdouts(run).filter((r) => !live.includes(r));
     if (live.length > 0 || unlanded.length > 0) {
       const why = [
         ...live.length > 0 ? [`${tasksNamed(live)} ${live.length === 1 ? "is" : "are"} still running or waiting on you`] : [],
@@ -23456,13 +23706,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 live = this.liveTasks();
+    return Object.values(run.tasks).filter((r) => live.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) {
@@ -24018,6 +24277,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";
@@ -24566,8 +24829,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";
@@ -24653,6 +24917,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")) {
@@ -24766,6 +25031,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)}`);
@@ -25677,7 +25943,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);
@@ -25714,6 +25982,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;
@@ -25769,10 +26038,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) => {
@@ -25941,10 +26211,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);
@@ -27117,17 +27412,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 live = session.adapter;
+    if (live && !live.exited && session.nativeSearch === this.nativeSearch(session)) return live;
     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
@@ -28659,19 +28974,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 };
   }
@@ -28679,9 +29025,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() {
@@ -28712,12 +29058,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. */
@@ -28728,16 +29074,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() {
@@ -30186,7 +30532,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
@@ -30219,7 +30565,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,
@@ -30231,7 +30577,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,
@@ -30301,6 +30647,7 @@ function createSession(deps) {
     runs: orchestrator.runs,
     events,
     usage,
+    windows,
     approvals,
     approvalPolicy,
     taskLogs,
@@ -30328,6 +30675,7 @@ function configSecrets(config) {
 var Session = class {
   backend;
   usage;
+  windows;
   events;
   planner;
   orchestrator;
@@ -30433,6 +30781,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;
@@ -30911,6 +31260,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);
@@ -30940,6 +31290,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();
@@ -31280,7 +31631,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();
@@ -31590,9 +31952,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) {
@@ -31768,7 +32130,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;
@@ -31782,12 +32147,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();
@@ -31836,17 +32220,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);
@@ -32004,6 +32383,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 EventEmitter2();
@@ -32029,7 +32410,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() {
@@ -32109,6 +32490,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;
   }
@@ -32134,7 +32562,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, ...sender2 });
+    if (this.exited || this.stopping) this.emitEvent({ type: "message_undelivered", messageId: id, text, ...sender2 });
     else if (this.state === "idle" && this.adapterStarted && !this.sending) this.deliver(text, opening);
     else {
       this.state = "working";
@@ -32189,7 +32617,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) {
@@ -32250,7 +32678,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();
@@ -32264,7 +32692,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);
   }
   /**
@@ -32368,7 +32796,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;
@@ -32443,7 +32871,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();
     }
@@ -32514,7 +32942,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();
@@ -32683,11 +33111,13 @@ var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
   return path33.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(path33.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();
@@ -32700,10 +33130,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;
@@ -32959,7 +33391,10 @@ export {
   collectProviderCredentials,
   commandAllowedBy,
   configuredProviders,
+  contextMeterText,
+  contextMeterTitle,
   continuability,
+  costText,
   countedSessionCost,
   createAiService,
   createEmptyPlan,
@@ -33002,7 +33437,9 @@ export {
   flattenTasksWithParents,
   followTaskLog,
   followTurn,
+  formatCost,
   formatSearchOutput,
+  formatTokenCount,
   fromTranscript,
   getLatestSession,
   getProviderMeta,
@@ -33054,6 +33491,7 @@ export {
   migratePlanState,
   mintDaemonToken,
   mintSessionId,
+  modelCostTitle,
   namedRepos,
   newTaskFields,
   normalizeAgentArgs,
@@ -33139,6 +33577,7 @@ export {
   stopTurn,
   stripAnsi,
   stripModelPrefix,
+  subagentCostTitle,
   subtreeIds,
   summarizeToolCall,
   supervisorSummary,
@@ -33157,6 +33596,7 @@ export {
   taskStartedNotice,
   taskStatusKind,
   taskUsageSummary,
+  tasksTotalText,
   textHasTaskOps,
   textHasTaskQuery,
   titledRefs,
@@ -33174,6 +33614,7 @@ export {
   unsendAll,
   unsendLatest,
   usageLine,
+  usageText,
   waitsForApproval,
   walkPlan,
   wellKnownBinDirs,