@cydm/pie 2.7.4 → 2.7.5

package/dist/cli.js

@@ -23,7 +23,7 @@ import {
   logTransportLifecycle,
   migrateConfigFromAgentDir,
   truncateHeadTail
-} from "./chunks/chunk-VGVCDW7P.js";
+} from "./chunks/chunk-OOUL3DRE.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-WLFOBECN.js";
@@ -45,7 +45,6 @@ import {
   continueExecutionState,
   createCompactionSummary,
   createEmptyExecutionState,
-  createExecutionStateFromTodos,
   createExecutionStateStore,
   createFileObservationState,
   createPolicyEnforcedTools,
@@ -55,9 +54,9 @@ import {
   createSharedFileSystemTools,
   createSharedWebSearchTool,
   createTodoWidgetView,
+  createTwoFilesPatch,
   estimateContextTokens,
   estimateTokens,
-  evaluateTodoClosureAfterAbort,
   evaluateTodoClosureAfterCompletedTurn,
   evaluateTodoClosureAfterFailedTurn,
   extensionFallbackName,
@@ -86,8 +85,8 @@ import {
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState,
   verifyPreparedCompactionCommit
-} from "./chunks/chunk-FIE3SSLW.js";
-import "./chunks/chunk-P2B62ZPU.js";
+} from "./chunks/chunk-BFHCZVNO.js";
+import "./chunks/chunk-MLRF72MK.js";
 import {
   Deref,
   EMPTY_ASSISTANT_CONTENT_ERROR,
@@ -112,7 +111,7 @@ import {
   sortToolModelCandidatesByCapability,
   streamSimple,
   type_exports
-} from "./chunks/chunk-Z4EIBY2E.js";
+} from "./chunks/chunk-SUPAWIKP.js";
 import {
   IsArray,
   IsBigInt,
@@ -48383,7 +48382,7 @@ var require_resolve_block_scalar = __commonJS({
       if (!header)
         return { value: "", type: null, comment: "", range: [start, start, start] };
       const type = header.mode === ">" ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
-      const lines = scalar.source ? splitLines2(scalar.source) : [];
+      const lines = scalar.source ? splitLines(scalar.source) : [];
       let chompStart = lines.length;
       for (let i = lines.length - 1; i >= 0; --i) {
         const content = lines[i][1];
@@ -48541,7 +48540,7 @@ var require_resolve_block_scalar = __commonJS({
       }
       return { mode, indent, chomp, comment, length };
     }
-    function splitLines2(source) {
+    function splitLines(source) {
       const split = source.split(/\n( *)/);
       const first = split[0];
       const m2 = first.match(/^( *)/);
@@ -52591,7 +52590,8 @@ function validateRemoteModel(profileId, model) {
   }
   if (!isPlainRecord(model.cost)) throw new Error(`Remote profile "${profileId}" model "${model.id}" has invalid cost values`);
   assertOnlyKeys(model.cost, ["input", "output", "cacheRead", "cacheWrite", "cacheWriteLong"], `Remote profile "${profileId}" model "${model.id}" cost`);
-  if ([model.cost.input, model.cost.output, model.cost.cacheRead, model.cost.cacheWrite, model.cost.cacheWriteLong].some((value) => value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < 0))) {
+  const invalidRate = (value) => typeof value !== "number" || !Number.isFinite(value) || value < 0;
+  if ([model.cost.input, model.cost.output, model.cost.cacheRead, model.cost.cacheWrite].some(invalidRate) || model.cost.cacheWriteLong !== void 0 && invalidRate(model.cost.cacheWriteLong)) {
     throw new Error(`Remote profile "${profileId}" model "${model.id}" has invalid cost values`);
   }
   if (!Number.isSafeInteger(model.contextWindow) || Number(model.contextWindow) <= 0 || !Number.isSafeInteger(model.maxTokens) || Number(model.maxTokens) <= 0 || Number(model.maxTokens) > Number(model.contextWindow)) {
@@ -56524,11 +56524,12 @@ function createExtensionContext(extension, cwd, uiContext, abortFn, isIdleFn, ha
     setExecutionReminder(text) {
       actions?.setExecutionReminder(text);
     },
+    getExecutionStateExplanation: () => actions?.getExecutionStateExplanation?.(),
     getExecutionState() {
       return actions?.getExecutionState?.() ?? createEmptyExecutionState();
     },
-    setExecutionState(state) {
-      return actions?.setExecutionState?.(state) ?? createEmptyExecutionState();
+    setExecutionState(state, reason) {
+      return actions?.setExecutionState?.(state, reason) ?? createEmptyExecutionState();
     },
     // Extended properties for subagent creation
     get apiKey() {
@@ -59306,11 +59307,11 @@ var TUI = class extends Container {
     this.stopped = true;
     if (this.previousLines.length > 0) {
       const targetRow = this.previousLines.length;
-      const lineDiff2 = targetRow - this.hardwareCursorRow;
-      if (lineDiff2 > 0) {
-        this.terminal.write(`\x1B[${lineDiff2}B`);
-      } else if (lineDiff2 < 0) {
-        this.terminal.write(`\x1B[${-lineDiff2}A`);
+      const lineDiff = targetRow - this.hardwareCursorRow;
+      if (lineDiff > 0) {
+        this.terminal.write(`\x1B[${lineDiff}B`);
+      } else if (lineDiff < 0) {
+        this.terminal.write(`\x1B[${-lineDiff}A`);
       }
       this.terminal.write("\r\n");
     }
@@ -59435,9 +59436,9 @@ var TUI = class extends Container {
       if (this.previousLines.length > newLines.length) {
         let buffer2 = "\x1B[?2026h";
         const targetRow = Math.max(0, newLines.length - 1);
-        const lineDiff3 = computeLineDiff(targetRow);
-        if (lineDiff3 > 0) buffer2 += `\x1B[${lineDiff3}B`;
-        else if (lineDiff3 < 0) buffer2 += `\x1B[${-lineDiff3}A`;
+        const lineDiff2 = computeLineDiff(targetRow);
+        if (lineDiff2 > 0) buffer2 += `\x1B[${lineDiff2}B`;
+        else if (lineDiff2 < 0) buffer2 += `\x1B[${-lineDiff2}A`;
         buffer2 += "\r";
         const extraLines = this.previousLines.length - newLines.length;
         if (extraLines > height) {
@@ -59487,11 +59488,11 @@ var TUI = class extends Container {
       viewportTop += scroll;
       hardwareCursorRow = moveTargetRow;
     }
-    const lineDiff2 = computeLineDiff(moveTargetRow);
-    if (lineDiff2 > 0) {
-      buffer += `\x1B[${lineDiff2}B`;
-    } else if (lineDiff2 < 0) {
-      buffer += `\x1B[${-lineDiff2}A`;
+    const lineDiff = computeLineDiff(moveTargetRow);
+    if (lineDiff > 0) {
+      buffer += `\x1B[${lineDiff}B`;
+    } else if (lineDiff < 0) {
+      buffer += `\x1B[${-lineDiff}A`;
     }
     buffer += appendStart ? "\r\n" : "\r";
     const renderEnd = Math.min(lastChanged, newLines.length - 1);
@@ -59549,7 +59550,7 @@ var TUI = class extends Container {
         `viewportTop: ${viewportTop}`,
         `cursorRow: ${this.cursorRow}`,
         `height: ${height}`,
-        `lineDiff: ${lineDiff2}`,
+        `lineDiff: ${lineDiff}`,
         `hardwareCursorRow: ${hardwareCursorRow}`,
         `renderEnd: ${renderEnd}`,
         `finalCursorRow: ${finalCursorRow}`,
@@ -64302,7 +64303,8 @@ var ExtensionRunner = class {
       setPlanMode: (enabled, options) => this.actions.setPlanMode(enabled, options),
       setExecutionReminder: (text) => this.actions.setExecutionReminder(text),
       getExecutionState: () => this.actions.getExecutionState(),
-      setExecutionState: (state) => this.actions.setExecutionState(state),
+      getExecutionStateExplanation: () => this.actions.getExecutionStateExplanation?.(),
+      setExecutionState: (state, reason) => this.actions.setExecutionState(state, reason),
       get apiKey() {
         return runner.actions.apiKey;
       },
@@ -69997,16 +69999,42 @@ function getTextFromMessageContent(content) {
 }
 var ExecutionStateManager = class {
   store = createExecutionStateStore();
+  work;
+  beginWork() {
+    const token = { identity: {} };
+    this.work = { token, fence: this.capture() };
+    return token;
+  }
+  isWorkCurrent(token) {
+    return this.work?.token === token && this.isCurrent(this.work.fence);
+  }
+  completeWork(token, message, toolResults = []) {
+    if (!this.isWorkCurrent(token)) return { changed: false };
+    return this.advanceFromCompletedTurn(message, toolResults, this.work.fence);
+  }
+  failWork(token) {
+    if (!this.isWorkCurrent(token)) return { changed: false };
+    return this.handleTurnFailed(this.work.fence);
+  }
+  /** Only synchronous tool mutations may move the current work to a newly-created list. */
+  applyToolState(state, reason) {
+    const work = this.work;
+    const current = work && this.isWorkCurrent(work.token);
+    const mutation = { source: "todo_tool", reason };
+    const next = reason === "advance" ? this.store.write({ ...state, loop: this.read().loop }, mutation) : state ? this.store.replace(state, mutation) : this.store.clear(mutation);
+    if (current && work && reason !== "session_restore") work.fence = this.capture();
+    return next;
+  }
   completeCount(state) {
     return state.steps.filter((step) => step.status === "completed").length;
   }
   isCompletionText(text) {
     return /完成|已完成|done|finished|completed|wrap[\s-]?up|all set|success/i.test(text);
   }
-  clearWithSummary(summary = null) {
+  clearWithSummary(summary = null, reason = summary ? "failed_clear" : "completed_clear") {
     const cleared = createEmptyExecutionState();
     cleared.failureSummary = summary;
-    return this.store.replace(cleared);
+    return this.store.replace(cleared, { source: "runtime", reason });
   }
   summarizeFailure(reason) {
     switch (reason) {
@@ -70027,7 +70055,7 @@ var ExecutionStateManager = class {
   }
   evaluateCompletedTurnLoop(previous, next, toolResults, assistantText) {
     if (next.mode !== "todo" || !next.loop) {
-      this.store.replace(next);
+      this.store.write(next);
       return { changed: !this.unchanged(previous, next) };
     }
     const decision = evaluateTodoClosureAfterCompletedTurn(next, next.loop, {
@@ -70055,11 +70083,26 @@ var ExecutionStateManager = class {
       ...next,
       loop: decision.loop
     };
-    this.store.replace(updated);
+    this.store.write(updated);
     return {
       changed: !this.unchanged(previous, updated)
     };
   }
+  capture() {
+    return this.store.capture();
+  }
+  isCurrent(fence) {
+    return this.store.isCurrent(fence);
+  }
+  diagnostics() {
+    return this.store.diagnostics();
+  }
+  inactiveExplanation() {
+    if (this.read().steps.length) return void 0;
+    const last = this.diagnostics().audit.at(-1);
+    if (!last || !["explicit_clear", "completed_clear", "failed_clear", "stalled_clear", "topic_switch"].includes(last.reason)) return void 0;
+    return `Last known clear: ${last.reason} (revision ${last.revision}).`;
+  }
   read() {
     return this.store.read();
   }
@@ -70084,9 +70127,9 @@ var ExecutionStateManager = class {
       return this.store.replace(pauseExecutionState({
         ...restored,
         awaitingContinuation: false
-      }, "Previous todo turn was interrupted while a tool was running. Send 'continue' to resume the remaining items."));
+      }, "Previous todo turn was interrupted while a tool was running. Send 'continue' to resume the remaining items."), { source: "session", reason: "session_restore" });
     }
-    return this.store.replace(restored);
+    return this.store.replace(restored, { source: "session", reason: "session_restore" });
   }
   getReminder() {
     return buildExecutionReminder(this.store.read());
@@ -70102,17 +70145,18 @@ var ExecutionStateManager = class {
     if (previous.awaitingContinuation) {
       return false;
     }
-    this.store.replace({
+    this.store.write({
       ...previous,
       awaitingContinuation: true
     });
     return true;
   }
-  advanceFromCompletedTurn(message, toolResults = []) {
-    if (!message || message.role !== "assistant") {
+  advanceFromCompletedTurn(message, toolResults = [], fence) {
+    if (!this.store.isCurrent(fence) || !message || message.role !== "assistant") {
       return { changed: false };
     }
     const previous = this.store.read();
+    if (previous.steps.length === 0) return { changed: false };
     const assistantText = getTextFromMessageContent(message.content);
     const next = maybeAdvanceTodoExecutionState(previous, {
       assistantText,
@@ -70132,7 +70176,8 @@ var ExecutionStateManager = class {
     }
     return state.loop.continuePrompt || void 0;
   }
-  handleTurnFailed() {
+  handleTurnFailed(fence) {
+    if (!this.store.isCurrent(fence)) return { changed: false };
     const previous = this.store.read();
     if (previous.mode !== "todo" || !previous.loop && previous.steps.length === 0) {
       return { changed: false };
@@ -70143,7 +70188,7 @@ var ExecutionStateManager = class {
         ...previous,
         loop: decision.loop
       }, this.summarizeFailure(decision.reason));
-      this.store.replace(paused);
+      this.store.write(paused, { source: "runtime", reason: "pause_failed" });
       return {
         changed: true,
         terminalStatus: "paused",
@@ -70166,7 +70211,7 @@ var ExecutionStateManager = class {
     if (previous.mode !== "todo" || previous.lifecycle !== "paused" || previous.steps.length === 0) {
       return { changed: false };
     }
-    const next = this.store.replace(continueExecutionState(previous));
+    const next = this.store.write(continueExecutionState(previous), { source: "runtime", reason: "advance" });
     return { changed: !this.unchanged(previous, next) };
   }
   markAwaitingContinuationStalled() {
@@ -70174,7 +70219,7 @@ var ExecutionStateManager = class {
     if (previous.mode !== "todo" || !previous.awaitingContinuation) {
       return { changed: false };
     }
-    this.clearWithSummary(this.summarizeFailure("stagnated"));
+    this.clearWithSummary(this.summarizeFailure("stagnated"), "stalled_clear");
     return {
       changed: true,
       cleared: true,
@@ -70184,20 +70229,14 @@ var ExecutionStateManager = class {
   }
   abort() {
     const previous = this.store.read();
-    const decision = evaluateTodoClosureAfterAbort(previous.loop);
-    if (decision.action === "clear_aborted") {
-      return {
-        state: this.clearWithSummary(this.summarizeFailure(decision.reason)),
-        cleared: true,
-        terminalSummary: this.read().failureSummary || void 0
-      };
-    }
-    return { state: this.store.replace(abortExecutionState(previous)), cleared: false };
+    return { state: this.store.replace(abortExecutionState(previous), { source: "runtime", reason: "abort" }), cleared: false };
   }
   continue() {
     return this.store.replace(continueExecutionState(this.store.read()));
   }
   applyUserTextLifecycle(text) {
+    const work = this.work;
+    const current = work && this.isWorkCurrent(work.token);
     const state = this.store.read();
     if (state.steps.length === 0) {
       return null;
@@ -70208,11 +70247,13 @@ var ExecutionStateManager = class {
     if (shouldPreserveExecutionStateForUserText(text)) {
       if (state.lifecycle === "paused" || state.lifecycle === "aborted") {
         this.store.replace(continueExecutionState(state));
+        if (current && work) work.fence = this.capture();
         return "continued";
       }
       return null;
     }
-    this.store.replace(supersedeExecutionState());
+    this.store.replace(supersedeExecutionState(), { source: "user", reason: "topic_switch" });
+    if (current && work) work.fence = this.capture();
     return "cleared";
   }
   clearIfSupersededByUserMessage(messages) {
@@ -71711,436 +71752,6 @@ var AssistantMessageComponent = class extends Container {
 // src/components/tool-execution.ts
 import * as os5 from "node:os";
 
-// ../../node_modules/diff/libesm/diff/base.js
-var Diff = class {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return void 0;
-      } else {
-        return value;
-      }
-    };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = void 0;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = void 0;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
-      }
-      editLength++;
-    };
-    if (callback) {
-      (function exec() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(void 0);
-          }
-          if (!execEditLength()) {
-            exec();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
-    }
-  }
-  addToPath(path34, added, removed, oldPosInc, options) {
-    const last = path34.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path34.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path34.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
-    }
-  }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-      }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  }
-  removeEmpty(array) {
-    const ret = [];
-    for (let i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  castInput(value, options) {
-    return value;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
-  }
-  postProcess(changeObjects, options) {
-    return changeObjects;
-  }
-  get useLongestToken() {
-    return false;
-  }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (; componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i) {
-            const oldValue = oldTokens[oldPos + i];
-            return oldValue.length > value2.length ? oldValue : value2;
-          });
-          component.value = this.join(value);
-        } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
-        }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
-      }
-    }
-    return components;
-  }
-};
-
-// ../../node_modules/diff/libesm/diff/line.js
-var LineDiff = class extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  equals(left, right, options) {
-    if (options.ignoreWhitespace) {
-      if (!options.newlineIsToken || !left.includes("\n")) {
-        left = left.trim();
-      }
-      if (!options.newlineIsToken || !right.includes("\n")) {
-        right = right.trim();
-      }
-    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-      if (left.endsWith("\n")) {
-        left = left.slice(0, -1);
-      }
-      if (right.endsWith("\n")) {
-        right = right.slice(0, -1);
-      }
-    }
-    return super.equals(left, right, options);
-  }
-};
-var lineDiff = new LineDiff();
-function diffLines(oldStr, newStr, options) {
-  return lineDiff.diff(oldStr, newStr, options);
-}
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, "\n");
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i = 0; i < linesAndNewlines.length; i++) {
-    const line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
-    }
-  }
-  return retLines;
-}
-
-// ../../node_modules/diff/libesm/patch/create.js
-var INCLUDE_HEADERS = {
-  includeIndex: true,
-  includeUnderline: true,
-  includeFileHeaders: true
-};
-function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  let optionsObj;
-  if (!options) {
-    optionsObj = {};
-  } else if (typeof options === "function") {
-    optionsObj = { callback: options };
-  } else {
-    optionsObj = options;
-  }
-  if (typeof optionsObj.context === "undefined") {
-    optionsObj.context = 4;
-  }
-  const context = optionsObj.context;
-  if (optionsObj.newlineIsToken) {
-    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
-  }
-  if (!optionsObj.callback) {
-    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
-  } else {
-    const { callback } = optionsObj;
-    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
-      const patch = diffLinesResultToPatch(diff);
-      callback(patch);
-    } }));
-  }
-  function diffLinesResultToPatch(diff) {
-    if (!diff) {
-      return;
-    }
-    diff.push({ value: "", lines: [] });
-    function contextLines(lines) {
-      return lines.map(function(entry) {
-        return " " + entry;
-      });
-    }
-    const hunks = [];
-    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-    for (let i = 0; i < diff.length; i++) {
-      const current = diff[i], lines = current.lines || splitLines(current.value);
-      current.lines = lines;
-      if (current.added || current.removed) {
-        if (!oldRangeStart) {
-          const prev = diff[i - 1];
-          oldRangeStart = oldLine;
-          newRangeStart = newLine;
-          if (prev) {
-            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
-            oldRangeStart -= curRange.length;
-            newRangeStart -= curRange.length;
-          }
-        }
-        for (const line of lines) {
-          curRange.push((current.added ? "+" : "-") + line);
-        }
-        if (current.added) {
-          newLine += lines.length;
-        } else {
-          oldLine += lines.length;
-        }
-      } else {
-        if (oldRangeStart) {
-          if (lines.length <= context * 2 && i < diff.length - 2) {
-            for (const line of contextLines(lines)) {
-              curRange.push(line);
-            }
-          } else {
-            const contextSize = Math.min(lines.length, context);
-            for (const line of contextLines(lines.slice(0, contextSize))) {
-              curRange.push(line);
-            }
-            const hunk = {
-              oldStart: oldRangeStart,
-              oldLines: oldLine - oldRangeStart + contextSize,
-              newStart: newRangeStart,
-              newLines: newLine - newRangeStart + contextSize,
-              lines: curRange
-            };
-            hunks.push(hunk);
-            oldRangeStart = 0;
-            newRangeStart = 0;
-            curRange = [];
-          }
-        }
-        oldLine += lines.length;
-        newLine += lines.length;
-      }
-    }
-    for (const hunk of hunks) {
-      for (let i = 0; i < hunk.lines.length; i++) {
-        if (hunk.lines[i].endsWith("\n")) {
-          hunk.lines[i] = hunk.lines[i].slice(0, -1);
-        } else {
-          hunk.lines.splice(i + 1, 0, "\");
-          i++;
-        }
-      }
-    }
-    return {
-      oldFileName,
-      newFileName,
-      oldHeader,
-      newHeader,
-      hunks
-    };
-  }
-}
-function formatPatch(patch, headerOptions) {
-  if (!headerOptions) {
-    headerOptions = INCLUDE_HEADERS;
-  }
-  if (Array.isArray(patch)) {
-    if (patch.length > 1 && !headerOptions.includeFileHeaders) {
-      throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
-    }
-    return patch.map((p) => formatPatch(p, headerOptions)).join("\n");
-  }
-  const ret = [];
-  if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
-    ret.push("Index: " + patch.oldFileName);
-  }
-  if (headerOptions.includeUnderline) {
-    ret.push("===================================================================");
-  }
-  if (headerOptions.includeFileHeaders) {
-    ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
-    ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
-  }
-  for (let i = 0; i < patch.hunks.length; i++) {
-    const hunk = patch.hunks[i];
-    if (hunk.oldLines === 0) {
-      hunk.oldStart -= 1;
-    }
-    if (hunk.newLines === 0) {
-      hunk.newStart -= 1;
-    }
-    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
-    for (const line of hunk.lines) {
-      ret.push(line);
-    }
-  }
-  return ret.join("\n") + "\n";
-}
-function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  if (typeof options === "function") {
-    options = { callback: options };
-  }
-  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
-    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
-    if (!patchObj) {
-      return;
-    }
-    return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
-  } else {
-    const { callback } = options;
-    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
-      if (!patchObj) {
-        callback(void 0);
-      } else {
-        callback(formatPatch(patchObj, options.headerOptions));
-      }
-    } }));
-  }
-}
-function splitLines(text) {
-  const hasTrailingNl = text.endsWith("\n");
-  const result = text.split("\n").map((line) => line + "\n");
-  if (hasTrailingNl) {
-    result.pop();
-  } else {
-    result.push(result.pop().slice(0, -1));
-  }
-  return result;
-}
-
 // src/utils/edit-diff.ts
 function generateEditDiff(oldText, newText, filePath) {
   const patch = createTwoFilesPatch(
@@ -74052,7 +73663,9 @@ function takeAttentionRing(host) {
   return attention;
 }
 function bindInteractiveRuntimeEvents(host) {
+  let executionWork;
   host.agent.subscribe((event) => {
+    if (event.type === "agent_start" && !hasControllerTurnAuthority(host)) executionWork = host.executionState.beginWork();
     switch (event.type) {
       case "message_start":
         host.logDebug("message:start", { role: event.message?.role });
@@ -74172,10 +73785,10 @@ function bindInteractiveRuntimeEvents(host) {
     }
   });
   host.agent.subscribeSemantic((event) => {
-    handleSemanticAgentEvent(host, event);
+    handleSemanticAgentEvent(host, event, executionWork);
   });
 }
-function handleSemanticAgentEvent(host, event) {
+function handleSemanticAgentEvent(host, event, work) {
   switch (event.type) {
     case "turn_continues": {
       host.emitExtensionEvent({
@@ -74216,7 +73829,7 @@ function handleSemanticAgentEvent(host, event) {
         message: event.message,
         toolResults: event.toolResults
       });
-      const outcome = host.executionState.advanceFromCompletedTurn(event.message, event.toolResults || []);
+      const outcome = work ? host.executionState.completeWork(work, event.message, event.toolResults || []) : { changed: false };
       host.logDebug("execution:turn_completed", {
         turnIndex: host._semanticTurnIndex,
         changed: outcome.changed,
@@ -74251,7 +73864,7 @@ function handleSemanticAgentEvent(host, event) {
         message: event.message,
         toolResults: event.toolResults
       });
-      const outcome = host.executionState.handleTurnFailed();
+      const outcome = work ? host.executionState.failWork(work) : { changed: false };
       host.logDebug("execution:turn_failed", {
         turnIndex: host._semanticTurnIndex,
         changed: outcome.changed,
@@ -74496,14 +74109,6 @@ function handleToolEnd(host, event) {
       false
     );
   }
-  if (event.toolName === "manage_todo_list") {
-    const details = event.result?.details;
-    if (details?.todos) {
-      host.executionState.replace(createExecutionStateFromTodos(details.todos));
-      host.persistExecutionState();
-      void host.refreshTodoWidget();
-    }
-  }
   host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
   host.emitExtensionEvent({
     type: "tool:execution:end",
@@ -76836,8 +76441,9 @@ function createExtensionContextForCommands(host) {
       host.executionReminder = text || null;
     },
     getExecutionState: () => host.executionState.read(),
-    setExecutionState: (state) => {
-      const next = state ? host.executionState.replace(state) : host.executionState.clear();
+    getExecutionStateExplanation: () => host.executionState.inactiveExplanation(),
+    setExecutionState: (state, reason) => {
+      const next = reason ? host.executionState.applyToolState(state, reason) : host.executionState.replace(state);
       host.persistExecutionState();
       void host.refreshTodoWidget();
       return next;
@@ -79647,7 +79253,7 @@ function buildCodingAgentGuidelinesSection(tools = []) {
   const guidelines = [
     "Handle coding tasks by analyzing, planning, or making changes as the available tools and user request allow; do not stop at analysis when execution is expected.",
     `Keep going until the user's task is completely resolved before ending your turn. If you announce a next step (for example, "now run the tests"), execute it in the same turn instead of describing it; only end your turn when the task is done or you genuinely need user input.`,
-    ...hasTodoTool ? ["For multi-step tasks, set up progress tracking with manage_todo_list before starting, and keep exactly one step in progress until every step is complete."] : [],
+    ...hasTodoTool ? ["Use manage_todo_list only when the user explicitly requests todo/task tracking, never for internal planning or runtime subagent progress."] : [],
     "Work in the current workspace, preserve user changes, and keep edits focused.",
     "Inspect the relevant code before changing it. Use file tools for workspace writes; do not use shell redirection or heredocs to bypass write_file/edit_file guards.",
     "Run the most relevant existing test, build, or check after file changes when practical.",
@@ -79739,10 +79345,14 @@ function shouldCliAutoCompactTokens(params) {
   const tokenLimit = getAutoCompactTokenLimit(params.contextWindow, params.reserveTokens);
   return tokenLimit !== void 0 && params.tokens > tokenLimit;
 }
-function createCliCompactionBudget(params) {
-  const contextWindow = params.contextWindow ?? 0;
-  const reserveTokens = params.reserveTokens ?? DEFAULT_COMPACTION_CONFIG.reserveTokens;
-  return () => getAutoCompactTokenLimit(contextWindow, reserveTokens);
+function createCliCompactionBudget(getCurrent) {
+  return () => {
+    const current = getCurrent();
+    return getAutoCompactTokenLimit(
+      current.contextWindow ?? 0,
+      current.reserveTokens ?? DEFAULT_COMPACTION_CONFIG.reserveTokens
+    );
+  };
 }
 async function createCliAutoCompactionResult(params) {
   if (params.context.signal?.aborted) {
@@ -80539,9 +80149,12 @@ function appendWarningSummary(host, message) {
   host.safeRequestRender();
 }
 async function recoverHardStalledTurn(host, stalledMs) {
+  const controller = host.agentSessionController;
   host.continuationStallSinceMs = void 0;
   host.logDebug("continuation_timeout:hard_stall_recovery", { stalledMs });
-  host.agentSessionController?.abort();
+  controller?.abort();
+  const work = controller?.workIdentity;
+  const fence = host.executionState.capture();
   try {
     await Promise.race([
       host.agentSessionController?.waitForIdle() ?? Promise.resolve(),
@@ -80552,6 +80165,9 @@ async function recoverHardStalledTurn(host, stalledMs) {
       error: error instanceof Error ? error.message : String(error)
     });
   }
+  if (host.agentSessionController !== controller || !host.executionState.isCurrent(fence)) return;
+  const currentWork = controller?.workIdentity;
+  if (work?.sessionId !== currentWork?.sessionId || work?.generation !== currentWork?.generation) return;
   host.agent.resetProcessingState();
   host.isProcessing = false;
   host.setSubmitLock(false);
@@ -80572,6 +80188,7 @@ async function recoverHardStalledTurn(host, stalledMs) {
 }
 function scheduleContinuationTimeout(host) {
   host.clearContinuationTimeout("reschedule");
+  const fence = host.executionState.capture();
   const timeoutMs = getContinuationTimeoutMs();
   host.logDebug("continuation_timeout:start", {
     timeoutMs,
@@ -80579,6 +80196,7 @@ function scheduleContinuationTimeout(host) {
     queueLength: host.agentSessionController?.pendingMessageCount ?? 0
   });
   const check = () => {
+    if (!host.executionState.isCurrent(fence)) return;
     host.continuationTimeoutHandle = void 0;
     const state = host.executionState.read();
     if (!state.awaitingContinuation || isWaitingForUserInteraction(host)) {
@@ -80665,6 +80283,7 @@ function createInteractiveAgentSessionController(host) {
   }
   let retryElapsedTicker;
   let retryElapsedStartedAt = 0;
+  let executionWork;
   let autoCompactBeforeStats = null;
   const attention = cliAttention(host);
   const stopRetryElapsedTicker = () => {
@@ -80712,7 +80331,10 @@ function createInteractiveAgentSessionController(host) {
     },
     // Same auto-compact limit the threshold decision uses; a checkpoint whose
     // summary + retained tail would still exceed it is refused.
-    getCompactionBudgetTokens: createCliCompactionBudget({ contextWindow: host.options.model?.contextWindow }),
+    getCompactionBudgetTokens: createCliCompactionBudget(() => ({
+      contextWindow: host.options.model?.contextWindow,
+      reserveTokens: host.options.settingsManager.getAutoCompactReserveTokens()
+    })),
     getAutoContinueMessage: () => host.getTodoAutoContinueMessage(),
     classifyFailure: (context) => classifyCliFailure(context),
     retry: createCliRetryPolicy(
@@ -80752,6 +80374,8 @@ function createInteractiveAgentSessionController(host) {
     },
     onEvent: (event) => {
       stopRetryElapsedTicker();
+      if (event.type === "session_work_started") executionWork = host.executionState.beginWork();
+      if (event.type === "session_invalidated") executionWork = void 0;
       host.sessionTrace.noteRuntimeEvent(event.type, event);
       if (event.type === "session_work_started" || event.type === "session_invalidated" || event.type === "session_quiescent") {
         if (event.type === "session_quiescent") host.setControllerBusy(false);
@@ -80811,7 +80435,7 @@ function createInteractiveAgentSessionController(host) {
           message: event.message,
           toolResults: event.toolResults
         });
-        const outcome = host.executionState.advanceFromCompletedTurn(event.message, event.toolResults || []);
+        const outcome = executionWork ? host.executionState.completeWork(executionWork, event.message, event.toolResults || []) : { changed: false };
         host.logDebug("execution:turn_completed", {
           turnIndex: host._semanticTurnIndex,
           changed: outcome.changed,
@@ -80840,7 +80464,7 @@ function createInteractiveAgentSessionController(host) {
             toolResults: []
           });
         }
-        const outcome = host.executionState.handleTurnFailed();
+        const outcome = executionWork ? host.executionState.failWork(executionWork) : { changed: false };
         host.logDebug("execution:turn_failed_terminal", {
           turnIndex: host._semanticTurnIndex,
           changed: outcome.changed,
@@ -80873,10 +80497,8 @@ function createInteractiveAgentSessionController(host) {
           lifecycle: host.executionState.read().lifecycle,
           reason: event.reason
         });
-        if (outcome.cleared || outcome.terminalSummary) {
-          host.persistExecutionState();
-          void host.refreshTodoWidget();
-        }
+        host.persistExecutionState();
+        void host.refreshTodoWidget();
         if (outcome.terminalSummary) {
           host.appendWarningSummary(outcome.terminalSummary);
         }
@@ -81179,6 +80801,8 @@ var RuntimeModeBlockInjector = class {
   }
   options;
   lastKey = null;
+  /** Exact frozen block, including its consumed one-shot transition. */
+  lastFrozenBlock = null;
   /**
    * Request-view overlay. While active, the CURRENT block is re-derived on
    * every request from the live message snapshot and applied to the latest
@@ -81190,6 +80814,7 @@ var RuntimeModeBlockInjector = class {
   overlayActive = false;
   reset() {
     this.lastKey = null;
+    this.lastFrozenBlock = null;
     this.overlayActive = true;
   }
   /**
@@ -81222,7 +80847,8 @@ var RuntimeModeBlockInjector = class {
     if (!this.overlayActive) return null;
     const state = this.options.getState();
     const block = buildRuntimeModeContext(state);
-    if (messages && lastUserMessageCarriesRuntimeBlock(messages, block)) {
+    const frozenCurrent = this.lastKey === runtimeModeBlockKey(state) ? this.lastFrozenBlock : null;
+    if (messages && (lastUserMessageCarriesRuntimeBlock(messages, block) || frozenCurrent !== null && lastUserMessageCarriesRuntimeBlock(messages, frozenCurrent))) {
       this.overlayActive = false;
       return null;
     }
@@ -81234,7 +80860,8 @@ var RuntimeModeBlockInjector = class {
     this.lastKey = runtimeModeBlockKey(state);
     if (state.pendingTransition) this.options.consumeTransition();
     this.options.noteTrace(state);
-    return buildRuntimeModeContext(state);
+    this.lastFrozenBlock = buildRuntimeModeContext(state);
+    return this.lastFrozenBlock;
   }
 };
 
@@ -82047,8 +81674,9 @@ async function loadInteractiveExtensions(host) {
       host.executionReminder = text || null;
     },
     getExecutionState: () => host.executionState.read(),
-    setExecutionState: (state) => {
-      const next = state ? host.executionState.replace(state) : host.executionState.clear();
+    getExecutionStateExplanation: () => host.executionState.inactiveExplanation(),
+    setExecutionState: (state, reason) => {
+      const next = reason ? host.executionState.applyToolState(state, reason) : host.executionState.replace(state);
       host.persistExecutionState();
       void host.refreshTodoWidget();
       return next;
@@ -82562,7 +82190,7 @@ var InteractiveMode = class {
   async init() {
     const activeSession = this.sessionManager.getActiveSession();
     this.thinkingLevel = resolveInitialThinkingLevel({ session: activeSession, settingsManager: this.options.settingsManager });
-    const { Agent } = await import("./chunks/src-EVCOTFBU.js");
+    const { Agent } = await import("./chunks/src-DV4UYUNJ.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -83333,8 +82961,9 @@ async function loadPrintModeExtensions(params) {
       }
     },
     getExecutionState: () => executionState.read(),
-    setExecutionState: (state) => {
-      const nextState = executionState.replace(state);
+    getExecutionStateExplanation: () => executionState.inactiveExplanation(),
+    setExecutionState: (state, reason) => {
+      const nextState = reason ? executionState.applyToolState(state, reason) : executionState.replace(state);
       const session = params.sessionManager.getActiveSession();
       if (session) {
         session.metadata.executionState = executionState.createMetadata();
@@ -83420,7 +83049,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-EVCOTFBU.js");
+  const { Agent: AgentClass } = await import("./chunks/src-DV4UYUNJ.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -83499,10 +83128,10 @@ async function runPrintMode(params) {
       latestCompactionTimestamp: runtime.sessionManager.getLatestCompactionTimestamp(),
       isContextOverflowError: isCliContextOverflowError
     }),
-    getCompactionBudgetTokens: createCliCompactionBudget({
+    getCompactionBudgetTokens: createCliCompactionBudget(() => ({
       contextWindow: runtime.model.contextWindow,
       reserveTokens: runtime.settingsManager.getAutoCompactReserveTokens()
-    }),
+    })),
     compaction: createPrintModeCompactionHandler({
       runner: printModeExtensions.runner,
       model: runtime.model,
@@ -83807,8 +83436,9 @@ async function loadJsonModeExtensions(params) {
       }
     },
     getExecutionState: () => executionState.read(),
-    setExecutionState: (state) => {
-      const nextState = executionState.replace(state);
+    getExecutionStateExplanation: () => executionState.inactiveExplanation(),
+    setExecutionState: (state, reason) => {
+      const nextState = reason ? executionState.applyToolState(state, reason) : executionState.replace(state);
       const session = params.runtime.sessionManager.getActiveSession();
       if (session) {
         session.metadata.executionState = executionState.createMetadata();
@@ -83861,14 +83491,15 @@ async function loadJsonModeExtensions(params) {
     false
   );
   runner.setUIContext(uiContext);
-  await restoreExtensionProviderCredentials(params.runtime.modelRegistry);
-  const extensionTools = filterEnabledTools(convertExtensionTools(extensions), params.runtime.settingsManager);
-  availableTools = [...availableTools, ...extensionTools];
-  return {
-    runner,
-    extensionTools,
-    extensionCount: extensions.length
-  };
+  try {
+    await restoreExtensionProviderCredentials(params.runtime.modelRegistry);
+    const extensionTools = filterEnabledTools(convertExtensionTools(extensions), params.runtime.settingsManager);
+    availableTools = [...availableTools, ...extensionTools];
+    return { runner, extensionTools, extensionCount: extensions.length };
+  } catch (error) {
+    await runner.dispose("shutdown");
+    throw error;
+  }
 }
 function createJsonEventsTransportStreamFn(streamFn) {
   return createTransportDiagnosticsStreamFn(streamFn ?? streamSimple, logTransportLifecycle);
@@ -83895,6 +83526,7 @@ async function runJsonEventsMode(params) {
   const completedSessionControlRequests = /* @__PURE__ */ new Map();
   const completedSidechatRequests = /* @__PURE__ */ new Map();
   const ensureRuntimeInFlight = /* @__PURE__ */ new Map();
+  let runtimeClosing = false;
   let activeSidechat = null;
   let activeSidechatPromise = null;
   let sidechatChainStopped = false;
@@ -84273,7 +83905,7 @@ async function runJsonEventsMode(params) {
         return;
       }
       const parent = agent;
-      const { Agent: AgentClass } = await import("./chunks/src-EVCOTFBU.js");
+      const { Agent: AgentClass } = await import("./chunks/src-DV4UYUNJ.js");
       const sideAgent = new AgentClass({
         initialState: {
           systemPrompt: parent.state.systemPrompt,
@@ -84564,6 +84196,11 @@ async function runJsonEventsMode(params) {
     disposeSemanticSubscription = void 0;
     controller?.dispose();
     controller = void 0;
+    if (agent) {
+      agent.abort();
+      await agent.waitForIdle();
+      agent.releaseTransport();
+    }
     agent = void 0;
     try {
       await runtime?.sessionManager.save();
@@ -84586,6 +84223,7 @@ async function runJsonEventsMode(params) {
     }
   }
   async function ensureRuntime(requestedCwd) {
+    if (runtimeClosing) throw new Error("JSON events runtime is shutting down");
     if (params.mockResponse !== void 0) return;
     const effectiveCwd = requestedCwd ?? process.cwd();
     const inFlight = ensureRuntimeInFlight.get(effectiveCwd);
@@ -84621,8 +84259,13 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-EVCOTFBU.js");
+    const { Agent: AgentClass } = await import("./chunks/src-DV4UYUNJ.js");
+    if (runtimeClosing) return;
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
+    if (runtimeClosing) {
+      await jsonModeExtensions.runner.dispose("shutdown");
+      return;
+    }
     extensionRunner = jsonModeExtensions.runner;
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
     const restoredApiKey = runtime.modelRegistry.getApiKey(runtime.model);
@@ -84683,10 +84326,10 @@ async function runJsonEventsMode(params) {
         latestCompactionTimestamp: runtime.sessionManager.getLatestCompactionTimestamp(),
         isContextOverflowError: isCliContextOverflowError
       }),
-      getCompactionBudgetTokens: createCliCompactionBudget({
+      getCompactionBudgetTokens: createCliCompactionBudget(() => ({
         contextWindow: runtime.model.contextWindow,
         reserveTokens: runtime.settingsManager.getAutoCompactReserveTokens()
-      }),
+      })),
       compaction: {
         compact: async (context) => createCliAutoCompactionResult({
           context,
@@ -85034,6 +84677,7 @@ async function runJsonEventsMode(params) {
         continue;
       }
       if (message.type === "shutdown") {
+        runtimeClosing = true;
         shutdownActiveTurn(message.reason);
         sidechatChainStopped = true;
         activeSidechat?.abort();
@@ -85089,6 +84733,8 @@ async function runJsonEventsMode(params) {
   } finally {
     await activeTurnPromise;
     await activeSidechatPromise;
+    runtimeClosing = true;
+    await Promise.allSettled([...ensureRuntimeInFlight.values()]);
     await disposeRuntime("shutdown");
   }
 }
@@ -85220,7 +84866,7 @@ async function runWithJsonEventsConsoleIsolation(fn) {
 }
 async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) return void 0;
-  return (await import("./chunks/test-stream-24BCZPP5.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-SWO34GSS.js")).createTestStreamFnFromSequenceEnv();
 }
 function resolveJsonEventsDetailFlag() {
   for (let index = 0; index < process.argv.length; index += 1) {