@cydm/pie 2.7.13 → 2.7.15

package/dist/cli.js

@@ -29,10 +29,7 @@ import {
   migrateConfigFromAgentDir,
   setYoloGrantListener,
   truncateHeadTail
-} from "./chunks/chunk-D7RMNFVM.js";
-import {
-  resolveCliProjectRoot
-} from "./chunks/chunk-WLFOBECN.js";
+} from "./chunks/chunk-CLEPSTWH.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -94,8 +91,8 @@ import {
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState,
   verifyPreparedCompactionCommit
-} from "./chunks/chunk-CIFC6QVB.js";
-import "./chunks/chunk-HGUYS5SF.js";
+} from "./chunks/chunk-C5UTDL3S.js";
+import "./chunks/chunk-TDHVB2FH.js";
 import {
   Deref,
   Errors,
@@ -118,7 +115,7 @@ import {
   sortToolModelCandidatesByCapability,
   streamSimple,
   type_exports
-} from "./chunks/chunk-R46YPPTU.js";
+} from "./chunks/chunk-NM2JLPJ6.js";
 import {
   IsArray,
   IsBigInt,
@@ -133,6 +130,12 @@ import {
   TypeBoxError,
   TypeSystemPolicy
 } from "./chunks/chunk-XXGYUYXI.js";
+import {
+  readImageFormat
+} from "./chunks/chunk-F7EBZTZO.js";
+import {
+  resolveCliProjectRoot
+} from "./chunks/chunk-WLFOBECN.js";
 import {
   __commonJS,
   __require,
@@ -34273,7 +34276,7 @@ var require_taggerscript = __commonJS({
         begin: /%[_a-zA-Z0-9:]*/,
         end: "%"
       };
-      const ESCAPE_SEQUENCE = {
+      const ESCAPE_SEQUENCE2 = {
         className: "symbol",
         begin: /\\./
       };
@@ -34283,7 +34286,7 @@ var require_taggerscript = __commonJS({
           COMMENT,
           FUNCTION,
           VARIABLE,
-          ESCAPE_SEQUENCE
+          ESCAPE_SEQUENCE2
         ]
       };
     }
@@ -56533,6 +56536,15 @@ function createExtensionContext(extension, cwd, uiContext, abortFn, isIdleFn, ha
     sendUserMessage(content) {
       actions?.sendUserMessage(content);
     },
+    ...actions?.attachLocalFile ? {
+      attachLocalFile: (path34, displayName) => actions.attachLocalFile(path34, displayName)
+    } : {},
+    ...actions?.beginUserInput ? {
+      beginUserInput: (isCurrent) => actions.beginUserInput(isCurrent)
+    } : {},
+    ...actions?.attachLocalFileAndSubmit ? {
+      attachLocalFileAndSubmit: (path34, displayName, submitText) => actions.attachLocalFileAndSubmit(path34, displayName, submitText)
+    } : {},
     setPlanMode(enabled, options) {
       actions?.setPlanMode(enabled, options);
     },
@@ -57136,9 +57148,6 @@ function parseExtensionFields(raw) {
   return requested;
 }
 
-// src/interactive-mode.ts
-import * as os8 from "os";
-
 // ../../packages/tui/src/fuzzy.ts
 function fuzzyMatch(query, text) {
   const queryLower = query.toLowerCase();
@@ -57357,6 +57366,41 @@ function graphemeWidth(segment) {
   }
   return width;
 }
+var ESCAPE_SEQUENCE = /\x1b\[[0-?]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[PX^_][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[ -\/]*[0-~]?/g;
+var CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+var HAS_CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/;
+var SANITIZE_SEQUENCE = new RegExp(`${ESCAPE_SEQUENCE.source}|${CONTROL_CHARS.source}`, "g");
+function stripEscapeSequences(text) {
+  return text.replace(ESCAPE_SEQUENCE, "");
+}
+var SGR_SEQUENCE = /^\x1b\[[0-9;:]*m$/;
+var OSC8_SEQUENCE = /^\x1b\]8;[^;\x07\x1b]*;[^\x07\x1b]*(?:\x07|\x1b\\)$/;
+var KITTY_IMAGE_SEQUENCE = /^\x1b_G[^\x07\x1b]*(?:\x07|\x1b\\)$/;
+var ITERM2_IMAGE_SEQUENCE = /^\x1b\]1337;[^\x07\x1b]*(?:\x07|\x1b\\)$/;
+var IMAGE_CURSOR_UP = /^\x1b\[\d*A$/;
+var CURSOR_MARKER_SEQUENCE = "\x1B_pi:c\x07";
+function sanitizeTerminalText(text, options = {}) {
+  const needsLayout = options.normalizeLayout === true && /[\r\n\t]/.test(text);
+  if (!HAS_CONTROL_CHARS.test(text) && !needsLayout) return text;
+  const normalize2 = (segment) => options.normalizeLayout ? segment.replace(/\r\n?/g, " ").replace(/\n/g, " ").replace(/\t/g, "   ") : segment;
+  let out = "";
+  let cursor = 0;
+  SANITIZE_SEQUENCE.lastIndex = 0;
+  for (let match = SANITIZE_SEQUENCE.exec(text); match; match = SANITIZE_SEQUENCE.exec(text)) {
+    out += normalize2(text.slice(cursor, match.index));
+    const sequence = match[0];
+    if (SGR_SEQUENCE.test(sequence) || OSC8_SEQUENCE.test(sequence)) {
+      out += sequence;
+    } else if (options.preserveCursorMarker === true && sequence === CURSOR_MARKER_SEQUENCE) {
+      out += sequence;
+    } else if (options.preserveImages && (KITTY_IMAGE_SEQUENCE.test(sequence) || ITERM2_IMAGE_SEQUENCE.test(sequence) || IMAGE_CURSOR_UP.test(sequence))) {
+      out += sequence;
+    }
+    cursor = match.index + sequence.length;
+  }
+  out += normalize2(text.slice(cursor));
+  return out;
+}
 function visibleWidth(str2) {
   if (str2.length === 0) {
     return 0;
@@ -57381,9 +57425,7 @@ function visibleWidth(str2) {
     clean = clean.replace(/\t/g, "   ");
   }
   if (clean.includes("\x1B")) {
-    clean = clean.replace(/\x1b\[[0-9;]*[mGKHJ]/g, "");
-    clean = clean.replace(/\x1b\]8;;[^\x07]*\x07/g, "");
-    clean = clean.replace(/\x1b_[^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
+    clean = stripEscapeSequences(clean);
   }
   let width = 0;
   for (const { segment } of segmenter.segment(clean)) {
@@ -58831,7 +58873,7 @@ var Container = class {
 function isFocusable(component) {
   return component !== null && "focused" in component;
 }
-var CURSOR_MARKER = "\x1B_pi:c\x07";
+var CURSOR_MARKER = CURSOR_MARKER_SEQUENCE;
 
 // ../../packages/tui/src/focus-manager.ts
 var FocusManager = class {
@@ -59166,6 +59208,50 @@ function findChangedRange(previousLines, newLines) {
   return { firstChanged, lastChanged, appendedLines, appendStart };
 }
 
+// ../../packages/tui/src/render-line-cache.ts
+function prepareRenderLines(rawLines, previous, width) {
+  let lines = rawLines;
+  const reusedFinal = new Uint8Array(rawLines.length);
+  let reusedLineCount = 0;
+  const canReuse = previous !== null && previous.width === width;
+  for (let index = 0; index < rawLines.length; index++) {
+    const rawLine = rawLines[index];
+    if (canReuse && index < previous.rawLines.length && index < previous.processedLines.length && !rawLine.includes(CURSOR_MARKER) && rawLine === previous.rawLines[index]) {
+      reusedFinal[index] = 1;
+      reusedLineCount++;
+      const processed = previous.processedLines[index];
+      if (processed !== rawLine) {
+        if (lines === rawLines) lines = rawLines.slice();
+        lines[index] = processed;
+      }
+      continue;
+    }
+    const image = isImageLine(rawLine);
+    const clean = sanitizeTerminalText(rawLine, {
+      preserveImages: image,
+      normalizeLayout: true,
+      preserveCursorMarker: true
+    });
+    if (clean !== rawLine) {
+      if (lines === rawLines) lines = rawLines.slice();
+      lines[index] = clean;
+    }
+  }
+  return { lines, reusedFinal, reusedLineCount };
+}
+function truncatePreparedLines(prepared, width, onOverflow) {
+  let lines = prepared.lines;
+  for (let index = 0; index < lines.length; index++) {
+    if (prepared.reusedFinal[index]) continue;
+    const line = lines[index];
+    if (isImageLine(line) || visibleWidth(line) <= width) continue;
+    onOverflow(index, line, lines);
+    if (lines === prepared.lines) lines = prepared.lines.slice();
+    lines[index] = truncateToWidth(line, width);
+  }
+  return lines;
+}
+
 // ../../packages/tui/src/terminal-protocol.ts
 var TerminalProtocol = class {
   constructor(terminal, onCellSizeChanged) {
@@ -59226,6 +59312,8 @@ function lineForWrite(line) {
 var TUI = class extends Container {
   terminal;
   previousLines = [];
+  /** Raw lines paired with previousLines after a successful frame commit. */
+  previousRawLines = null;
   previousWidth = 0;
   focusManager;
   inputRouter = new InputRouter();
@@ -59233,6 +59321,29 @@ var TUI = class extends Container {
   terminalProtocol;
   /** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
   onDebug;
+  reportOverflowed = false;
+  /** Record the first over-wide render of this process (evidence for the
+   * component bug), then stay quiet. The line is truncated, not fatal. */
+  reportOverflowOnce(lineIndex, line, width, lines) {
+    if (this.reportOverflowed) return;
+    this.reportOverflowed = true;
+    if (process.env.PIE_CRASH_LOG_DISABLED === "1") return;
+    try {
+      const crashLogPath = path9.join(os3.homedir(), ".pie", "pie-crash.log");
+      const crashData = [
+        `Over-wide render at ${(/* @__PURE__ */ new Date()).toISOString()} (truncated, not fatal)`,
+        `Terminal width: ${width}`,
+        `Line ${lineIndex} visible width: ${visibleWidth(line)}`,
+        "",
+        "=== All rendered lines (control sequences sanitized) ===",
+        ...lines.map((candidate, index) => `[${index}] (w=${visibleWidth(candidate)}) ${candidate}`),
+        ""
+      ].join("\n");
+      fs10.mkdirSync(path9.dirname(crashLogPath), { recursive: true });
+      fs10.writeFileSync(crashLogPath, crashData);
+    } catch {
+    }
+  }
   renderRequested = false;
   cursorRow = 0;
   // Logical cursor row (end of rendered content)
@@ -59344,6 +59455,7 @@ var TUI = class extends Container {
   requestRender(force = false) {
     if (force) {
       this.previousLines = [];
+      this.previousRawLines = null;
       this.previousWidth = -1;
       this.cursorRow = 0;
       this.hardwareCursorRow = 0;
@@ -59397,11 +59509,30 @@ var TUI = class extends Container {
     if (this.overlayManager.hasAny) {
       newLines = this.overlayManager.composite(newLines, width, height, this.maxLinesRendered);
     }
-    const cursorPos = extractCursorPosition(newLines, height);
+    const rawLines = newLines;
+    const previousFrame = this.previousRawLines === null ? null : {
+      rawLines: this.previousRawLines,
+      processedLines: this.previousLines,
+      width: this.previousWidth
+    };
+    const prepared = prepareRenderLines(rawLines, previousFrame, width);
+    newLines = prepared.lines;
+    let cursorPos = extractCursorPosition(newLines, height);
     if (cursorPos) {
       newLines = newLines.slice();
       newLines[cursorPos.row] = cursorPos.strippedLine;
     }
+    prepared.lines = newLines;
+    newLines = truncatePreparedLines(prepared, width, (lineIndex, line, lines) => {
+      this.reportOverflowOnce(lineIndex, line, width, lines);
+    });
+    if (cursorPos) {
+      const emitted = newLines[cursorPos.row];
+      if (emitted !== void 0) {
+        const maxCol = Math.max(0, Math.min(visibleWidth(emitted), width - 1));
+        if (cursorPos.col > maxCol) cursorPos = { ...cursorPos, col: maxCol };
+      }
+    }
     const widthChanged = this.previousWidth !== 0 && this.previousWidth !== width;
     const fullRender = (clear) => {
       this.fullRedrawCount += 1;
@@ -59423,6 +59554,7 @@ var TUI = class extends Container {
       this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
       this.positionHardwareCursor(cursorPos, newLines.length);
       this.previousLines = newLines;
+      this.previousRawLines = rawLines;
       this.previousWidth = width;
     };
     const debugRedraw = process.env.PIE_DEBUG_REDRAW === "1";
@@ -59452,6 +59584,9 @@ var TUI = class extends Container {
     const { firstChanged, lastChanged, appendStart } = findChangedRange(this.previousLines, newLines);
     if (firstChanged === -1) {
       this.positionHardwareCursor(cursorPos, newLines.length);
+      this.previousLines = newLines;
+      this.previousRawLines = rawLines;
+      this.previousWidth = width;
       this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
       return;
     }
@@ -59486,6 +59621,7 @@ var TUI = class extends Container {
       }
       this.positionHardwareCursor(cursorPos, newLines.length);
       this.previousLines = newLines;
+      this.previousRawLines = rawLines;
       this.previousWidth = width;
       this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
       return;
@@ -59522,33 +59658,7 @@ var TUI = class extends Container {
     for (let i = firstChanged; i <= renderEnd; i++) {
       if (i > firstChanged) buffer += "\r\n";
       buffer += "\x1B[2K";
-      const line = newLines[i];
-      const isImage = isImageLine(line);
-      if (!isImage && visibleWidth(line) > width) {
-        const crashLogPath = path9.join(os3.homedir(), ".pie", "pie-crash.log");
-        const crashData = [
-          `Crash at ${(/* @__PURE__ */ new Date()).toISOString()}`,
-          `Terminal width: ${width}`,
-          `Line ${i} visible width: ${visibleWidth(line)}`,
-          "",
-          "=== All rendered lines ===",
-          ...newLines.map((l, idx) => `[${idx}] (w=${visibleWidth(l)}) ${l}`),
-          ""
-        ].join("\n");
-        fs10.mkdirSync(path9.dirname(crashLogPath), { recursive: true });
-        fs10.writeFileSync(crashLogPath, crashData);
-        this.stop();
-        const errorMsg = [
-          `Rendered line ${i} exceeds terminal width (${visibleWidth(line)} > ${width}).`,
-          "",
-          "This is likely caused by a custom TUI component not truncating its output.",
-          "Use visibleWidth() to measure and truncateToWidth() to truncate lines.",
-          "",
-          `Debug log written to: ${crashLogPath}`
-        ].join("\n");
-        throw new Error(errorMsg);
-      }
-      buffer += lineForWrite(line);
+      buffer += lineForWrite(newLines[i]);
     }
     let finalCursorRow = renderEnd;
     if (this.previousLines.length > newLines.length) {
@@ -59599,6 +59709,7 @@ var TUI = class extends Container {
     this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
     this.positionHardwareCursor(cursorPos, newLines.length);
     this.previousLines = newLines;
+    this.previousRawLines = rawLines;
     this.previousWidth = width;
   }
   /**
@@ -64637,6 +64748,15 @@ var ExtensionRunner = class {
       setActiveTools: (toolNames) => this.actions.setActiveTools(toolNames),
       getActiveTools: () => this.actions.getActiveTools(),
       sendUserMessage: (content) => this.actions.sendUserMessage(content),
+      ...this.actions.attachLocalFile ? {
+        attachLocalFile: (path34, displayName) => this.actions.attachLocalFile(path34, displayName)
+      } : {},
+      ...this.actions.beginUserInput ? {
+        beginUserInput: (isCurrent) => this.actions.beginUserInput(isCurrent)
+      } : {},
+      ...this.actions.attachLocalFileAndSubmit ? {
+        attachLocalFileAndSubmit: (path34, displayName, submitText) => this.actions.attachLocalFileAndSubmit(path34, displayName, submitText)
+      } : {},
       setPlanMode: (enabled, options) => this.actions.setPlanMode(enabled, options),
       setExecutionReminder: (text) => this.actions.setExecutionReminder(text),
       getExecutionState: () => this.actions.getExecutionState(),
@@ -66470,6 +66590,11 @@ var theme = new Proxy({}, {
 });
 function setGlobalTheme(t) {
   globalThis[THEME_KEY] = t;
+  themeEpoch++;
+}
+var themeEpoch = 1;
+function getThemeEpoch() {
+  return themeEpoch;
 }
 var currentThemeName;
 var themeWatcher;
@@ -67016,9 +67141,6 @@ function validateSkillName(name) {
   return { valid: true };
 }
 
-// src/interactive-mode.ts
-import * as path30 from "path";
-
 // src/capabilities/read-file-understanding.ts
 import * as path21 from "node:path";
 import * as fs22 from "node:fs/promises";
@@ -68160,6 +68282,20 @@ var FileCache = class _FileCache {
   getByHash(hash) {
     return this.index.files[hash];
   }
+  /** Repair historical image MIME labels using the cached bytes. Content
+   *  deduplication must not keep an old .png-derived label when the same
+   *  Feishu JPEG is staged again with the corrected .jpg name. The hash,
+   *  bytes and platform upload records stay unchanged. */
+  refreshImageMimeType(hash) {
+    const entry = this.index.files[hash];
+    if (!entry || !entry.mimeType.startsWith("image/")) return;
+    const localPath = this.getLocalPath(hash);
+    if (!localPath) return;
+    const detected = readImageFormat(localPath);
+    if (detected.ext === ".bin" || detected.mime === entry.mimeType) return;
+    entry.mimeType = detected.mime;
+    this.saveIndex();
+  }
   getByFileId(fileId, platform2) {
     for (const entry of Object.values(this.index.files)) {
       const platformRecord = entry.platforms[platform2];
@@ -69263,6 +69399,7 @@ var FileManager = class {
     if (!cached) {
       await this.fileCache.storeFile(resolvedPath, sourceName, mimeType);
     }
+    this.fileCache.refreshImageMimeType(hash);
     this.fileCache.rememberPathHint(resolvedPath, hash, sourceName);
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     const entry = this.fileCache.getByHash(hash);
@@ -70681,20 +70818,27 @@ var ExecutionStateManager = class {
 // src/session-trace.ts
 import * as fs23 from "node:fs";
 import * as path23 from "node:path";
-function saveTraceFileBestEffort(tracePath, content) {
-  const tempPath = `${tracePath}.${process.pid}.${Date.now()}.tmp`;
+var traceTempSequence = 0;
+async function saveTraceFileBestEffort(tracePath, content) {
+  const tempPath = `${tracePath}.${process.pid}.${Date.now()}.${traceTempSequence++}.tmp`;
   try {
-    fs23.writeFileSync(tempPath, content, "utf8");
+    await fs23.promises.writeFile(tempPath, content, "utf8");
     try {
-      fs23.renameSync(tempPath, tracePath);
+      await fs23.promises.rename(tempPath, tracePath);
       return;
     } catch {
+      const stagedPath = `${tracePath}.${process.pid}.${Date.now()}.staged`;
       try {
-        fs23.copyFileSync(tempPath, tracePath);
+        await fs23.promises.copyFile(tempPath, stagedPath);
+        await fs23.promises.rename(stagedPath, tracePath);
       } catch {
+        try {
+          await fs23.promises.unlink(stagedPath);
+        } catch {
+        }
       } finally {
         try {
-          fs23.unlinkSync(tempPath);
+          await fs23.promises.unlink(tempPath);
         } catch {
         }
       }
@@ -70715,10 +70859,11 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
           return null;
         }
       },
-      saveTrace: (trace) => {
-        const tracePath = path23.join(sessionsDir, `${trace.sessionId}.trace.json`);
-        saveTraceFileBestEffort(tracePath, JSON.stringify(trace, null, 2));
-      }
+      saveTraceJson: (json, sessionId) => {
+        const tracePath = path23.join(sessionsDir, `${sessionId}.trace.json`);
+        return saveTraceFileBestEffort(tracePath, json);
+      },
+      saveTrace: () => void 0
     });
     this.sessionsDir = sessionsDir;
     this.sessionManager = sessionManager;
@@ -72127,10 +72272,30 @@ var AssistantMessageComponent = class extends Container {
   calmMode = false;
   markdownTheme;
   lastMessage;
+  streaming;
+  highlightCache = /* @__PURE__ */ new Map();
+  usedHighlightKeys = /* @__PURE__ */ new Set();
+  pruneHighlightCache = false;
   constructor(message, hideThinkingBlock = false, markdownTheme = getMarkdownTheme()) {
     super();
     this.hideThinkingBlock = hideThinkingBlock;
-    this.markdownTheme = markdownTheme;
+    this.streaming = !message;
+    const highlightCode2 = markdownTheme.highlightCode;
+    this.markdownTheme = highlightCode2 ? {
+      ...markdownTheme,
+      // Cache keys carry the theme epoch: highlighted lines embed theme
+      // colors, so a theme swap must miss instead of serving stale colors,
+      // even when a holder (calm-mode held component) skipped invalidate().
+      highlightCode: (code, lang) => {
+        const key = `${getThemeEpoch()}\0${lang ?? ""}\0${code}`;
+        this.usedHighlightKeys.add(key);
+        const cached = this.highlightCache.get(key);
+        if (cached) return cached;
+        const lines = highlightCode2(code, lang);
+        this.highlightCache.set(key, lines);
+        return lines;
+      }
+    } : markdownTheme;
     this.contentContainer = new Container();
     this.addChild(this.contentContainer);
     if (message) {
@@ -72138,6 +72303,8 @@ var AssistantMessageComponent = class extends Container {
     }
   }
   invalidate() {
+    this.highlightCache.clear();
+    this.usedHighlightKeys.clear();
     super.invalidate();
     if (this.lastMessage) {
       this.updateContent(this.lastMessage);
@@ -72160,8 +72327,35 @@ var AssistantMessageComponent = class extends Container {
   isCalmMode() {
     return this.calmMode;
   }
+  /** The final frame may reuse streamed highlights; afterwards only the
+   * Markdown line cache is needed, so release the duplicate code strings. */
+  finalizeStreaming() {
+    this.streaming = false;
+  }
+  render(width) {
+    this.usedHighlightKeys.clear();
+    try {
+      const lines = super.render(width);
+      if (!this.streaming) {
+        this.highlightCache.clear();
+      } else if (this.pruneHighlightCache) {
+        for (const key of this.highlightCache.keys()) {
+          if (!this.usedHighlightKeys.has(key)) this.highlightCache.delete(key);
+        }
+      }
+      this.pruneHighlightCache = false;
+      return lines;
+    } catch (error) {
+      this.highlightCache.clear();
+      this.pruneHighlightCache = false;
+      throw error;
+    } finally {
+      this.usedHighlightKeys.clear();
+    }
+  }
   updateContent(message) {
     this.lastMessage = message;
+    this.pruneHighlightCache = true;
     this.contentContainer.clear();
     const hasTextContent = message.content.some((c) => c.type === "text" && c.text.trim());
     const hasThinkingContent = message.content.some((c) => c.type === "thinking" && c.thinking.trim());
@@ -73426,6 +73620,7 @@ function renderChatHistory(host, messages) {
           content: contentBlocks,
           ...stopReason ? { stopReason, errorMessage: assistantMsg.errorMessage } : {}
         });
+        msgComponent.finalizeStreaming();
         host.chatContainer.addChild(msgComponent);
       }
       if (Array.isArray(assistantMsg.content) && !host.calmMode) {
@@ -74011,11 +74206,21 @@ function shutdownInteractiveHost(host, idleTimeoutMs = 5e3) {
     } finally {
       clearTimeout(timer);
     }
+    try {
+      await host.sessionTrace?.flushAsync();
+    } catch (error) {
+      errors.push(error);
+    }
     try {
       await host.extensionRunner?.dispose("shutdown");
     } catch (error) {
       errors.push(error);
     }
+    try {
+      await host.sessionTrace?.flushAsync();
+    } catch (error) {
+      errors.push(error);
+    }
     if (errors.length) throw new AggregateError(errors, "Interactive shutdown failed.");
   })().then(resolve7, reject);
   return shutdown;
@@ -74233,6 +74438,7 @@ function bindInteractiveRuntimeEvents(host) {
         }
         host.isProcessing = false;
         revealHeldCalmStreamingComponent(host);
+        host.streamingComponent?.finalizeStreaming?.();
         host.streamingComponent = void 0;
         removeCalmToolLines(host.chatContainer, host.pendingTools);
         host.pendingTools.clear();
@@ -74617,6 +74823,7 @@ function handleMessageEnd(host, event) {
       content: assistantDisplayBlocks(message.content)
     });
   }
+  streaming?.finalizeStreaming?.();
   host.streamingMessageHadToolCalls = false;
   host.streamingComponent = void 0;
   host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
@@ -76051,10 +76258,12 @@ function aggregateToolStats(turns) {
 }
 function buildToolStatRows(turns) {
   const stats = aggregateToolStats(turns);
+  const omitted = turns.reduce((sum, turn) => sum + (turn.toolCallsOmitted ?? 0), 0);
+  const partialRow = omitted > 0 ? [{ id: "tools:omitted", label: "tool statistics are partial", estTokens: 0, note: `${omitted} earlier calls omitted` }] : [];
   if (stats.length === 0) {
-    return [{ id: "tools:none", label: "no tool calls in recent turns", estTokens: 0 }];
+    return partialRow.length > 0 ? partialRow : [{ id: "tools:none", label: "no tool calls in recent turns", estTokens: 0 }];
   }
-  return stats.map((stat2) => ({
+  return [...partialRow, ...stats.map((stat2) => ({
     id: `toolstat:${stat2.name}`,
     label: stat2.name,
     estTokens: 0,
@@ -76066,7 +76275,7 @@ function buildToolStatRows(turns) {
       rowKind: "plain",
       rows: collectCalls(turns, stat2.name)
     }
-  }));
+  }))];
 }
 function collectCalls(turns, toolName) {
   const rows = [];
@@ -76109,7 +76318,7 @@ function buildTurnRows(turns) {
       label: `#${turn.turnIndex} ${turn.state}`,
       estTokens: 0,
       valueText: duration,
-      note: `${turn.toolCalls.length} tool calls`,
+      note: `${turn.toolCalls.length} tool calls${turn.toolCallsOmitted ? ` (+${turn.toolCallsOmitted} omitted)` : ""}`,
       detail: turn.userText?.slice(0, 80) || void 0,
       marker: turn.state === "failed" ? "\u2716" : void 0,
       drill: {
@@ -76135,6 +76344,11 @@ ${turn.assistantText.slice(0, 2e3)}`);
   if (turn.errorMessage) parts.push(`
 # error
 ${turn.errorMessage}`);
+  if (turn.toolCallsOmitted) {
+    parts.push(`
+# tool calls
+(${turn.toolCallsOmitted} earlier calls omitted from the retention window)`);
+  }
   if (turn.toolCalls.length > 0) {
     parts.push(
       `
@@ -76252,10 +76466,14 @@ function buildTraceOverviewText(snapshot, theme2) {
       lines.push(t.fg("dim", "  no retries, compactions, or guard events"));
     }
   }
-  const stats = aggregateToolStats([...snapshot.recentTurns, ...snapshot.activeTurn ? [snapshot.activeTurn] : []]);
+  const allTurns = [...snapshot.recentTurns, ...snapshot.activeTurn ? [snapshot.activeTurn] : []];
+  const stats = aggregateToolStats(allTurns);
+  const omitted = allTurns.reduce((sum, turn) => sum + (turn.toolCallsOmitted ?? 0), 0);
   if (stats.length > 0) {
     const top = stats.slice(0, 3).map((s) => `${s.name} ${formatDurationMs(s.totalMs)} (${s.calls})`);
-    lines.push(t.fg("dim", `  tools: ${top.join(" \xB7 ")}`));
+    lines.push(t.fg("dim", `  tools: ${top.join(" \xB7 ")}${omitted > 0 ? `  (+${omitted} earlier calls omitted)` : ""}`));
+  } else if (omitted > 0) {
+    lines.push(t.fg("dim", `  tools: (+${omitted} earlier calls omitted)`));
   }
   lines.push(t.fg("dim", "  /debugs/trace \xB7 Enter to drill, Esc to go back"));
   return lines.join("\n");
@@ -76565,6 +76783,7 @@ function handleInterrupt(host) {
       host.setSubmitLock(false);
       host.isInterrupting = false;
       revealHeldCalmStreamingComponent(host);
+      host.streamingComponent?.finalizeStreaming?.();
       host.streamingComponent = void 0;
       host.footer.setState({ status: "ready" });
       host.safeRequestRender();
@@ -77094,10 +77313,7 @@ function registerBuiltinCommands(host) {
   });
   commandTree.register(["settings", "quit"], {
     description: "Exit Pie",
-    handler: () => {
-      host.ui.stop();
-      process.exit(0);
-    }
+    handler: () => host.cleanupAndExit()
   });
 }
 
@@ -78889,7 +79105,23 @@ var MentionHandler = class {
    * behave identically.
    */
   async attachLocalFile(path34, displayName, pendingMention, isCurrent) {
-    await this.attachFileFromPath(path34, { sourceName: displayName, queryToken: pendingMention, isCurrent });
+    return this.attachFileFromPath(path34, { sourceName: displayName, queryToken: pendingMention, isCurrent });
+  }
+  /** Prepare a message-owned mention without reading or mutating the editor.
+   * Errors propagate to the caller; no caption-only submission on failure. */
+  async prepareLocalFile(filePath, displayName, isCurrent = () => true) {
+    if (!isCurrent()) return void 0;
+    const sourceName = displayName ?? path28.basename(filePath);
+    const result = await this.prepareFile(filePath, sourceName);
+    if (!isCurrent() || !result.success) return void 0;
+    return this.formatMention(result.name, result.fileId);
+  }
+  prepareFile(filePath, sourceName, onProgress) {
+    const mimeType = FileCache.getMimeType(filePath);
+    const isMedia = mimeType.startsWith("image/") || mimeType.startsWith("video/");
+    if (!isMedia || !this.fileManager.hasAdapter()) return this.fileManager.stageLocal(filePath, { sourceName });
+    if (mimeType.startsWith("video/")) return this.fileManager.uploadVideo(filePath, { sourceName, onProgress });
+    return this.fileManager.uploadPic(filePath, { sourceName, onProgress });
   }
   /** Reserve a real queue-replaceable token before asynchronous clipboard IO. */
   beginPendingAttachment(name) {
@@ -78942,29 +79174,22 @@ var MentionHandler = class {
           this.formatUploadProgress(sourceName, progress, stage)
         );
       };
-      const result = shouldStageLocally ? await this.fileManager.stageLocal(path34, { sourceName }) : mimeType.startsWith("video/") ? await this.fileManager.uploadVideo(path34, {
-        sourceName,
-        onProgress
-      }) : mimeType.startsWith("image/") ? await this.fileManager.uploadPic(path34, {
-        sourceName,
-        onProgress
-      }) : await this.fileManager.upload(path34, {
-        sourceName,
-        onProgress
-      });
-      if (options.isCurrent && !options.isCurrent()) return;
+      const result = await this.prepareFile(path34, sourceName, onProgress);
+      if (options.isCurrent && !options.isCurrent()) return false;
       if (result.success) {
         const mention = this.formatMention(result.name, result.fileId);
         this.onInsertMention(mention, pendingMention);
         this.clearPendingStatus(pendingStatusKey);
         this.onStatus?.(shouldStageLocally ? `Added local file ${result.name}` : `Added ${result.name}`);
+        return true;
       } else {
         this.onInsertMention("", pendingMention);
         this.clearPendingStatus(pendingStatusKey);
         this.onError?.("File upload failed. Please try again.");
+        return false;
       }
     } catch (err) {
-      if (options.isCurrent && !options.isCurrent()) return;
+      if (options.isCurrent && !options.isCurrent()) return false;
       this.onInsertMention("", pendingMention);
       this.clearPendingStatus(pendingStatusKey);
       const errorMessage5 = err instanceof Error ? err.message : String(err);
@@ -78979,6 +79204,7 @@ var MentionHandler = class {
       } else {
         this.onError?.(`Upload failed: ${errorMessage5}`);
       }
+      return false;
     } finally {
       this.clearPendingStatus(pendingStatusKey);
       this.pendingUploadCount = Math.max(0, this.pendingUploadCount - 1);
@@ -79746,13 +79972,22 @@ function setupInteractiveKeybindings(host) {
       host.handleFollowUp();
       return { consume: true };
     }
+    const shortcuts = host.getExtensionShortcuts?.();
+    if (shortcuts && shortcuts.size > 0 && mainEditorOwnsInput(host)) {
+      for (const shortcut of shortcuts.values()) {
+        if (matchesKey(data, shortcut.key)) {
+          void shortcut.handler();
+          return { consume: true };
+        }
+      }
+    }
     return { consume: false };
   });
 }
 
 // src/clipboard/read-clipboard-image.ts
 import { spawn as spawn2 } from "node:child_process";
-import { chmodSync as chmodSync2, closeSync as closeSync4, existsSync as existsSync18, fchmodSync, mkdtempSync, openSync as openSync4, readFileSync as readFileSync17, rmdirSync, statSync as statSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { chmodSync as chmodSync2, closeSync as closeSync4, existsSync as existsSync18, fchmodSync, mkdtempSync, openSync as openSync4, readFileSync as readFileSync17, rmdirSync, statSync as statSync12, unlinkSync as unlinkSync7, writeFileSync as writeFileSync11 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join20 } from "node:path";
 var MAX_IMAGE_BYTES = 50 * 1024 * 1024;
@@ -79843,7 +80078,7 @@ var TempImageResources = class {
   cleanup = () => {
     for (const path34 of this.files) {
       try {
-        unlinkSync8(path34);
+        unlinkSync7(path34);
         this.files.delete(path34);
       } catch (err) {
         if (err.code === "ENOENT") this.files.delete(path34);
@@ -80061,7 +80296,7 @@ function writeImageBytes(bytes, declaredMime, mkTempPath) {
   const mimeType = detectMimeFromMagic(bytes) ?? declaredMime;
   const targetPath = mkTempPath(extensionForMime(mimeType));
   try {
-    writeFileSync12(targetPath, bytes, { flag: "r+", mode: 384 });
+    writeFileSync11(targetPath, bytes, { flag: "r+", mode: 384 });
   } catch (err) {
     return { ok: false, kind: "failed", message: `Failed to write temp image: ${errorMessage4(err)}` };
   }
@@ -80132,7 +80367,7 @@ function formatBytes2(bytes) {
 }
 
 // src/input/image-paste.ts
-import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync13, rmSync as rmSync3 } from "node:fs";
+import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync12, rmSync as rmSync3 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join21 } from "node:path";
 var pastingHosts = /* @__PURE__ */ new WeakSet();
@@ -80161,7 +80396,7 @@ function terminalResultToClipboardResult(result) {
   try {
     dir = mkdtempSync2(join21(tmpdir2(), "pie-osc5522-"));
     const path34 = join21(dir, formatPastedImageName(/* @__PURE__ */ new Date(), ext));
-    writeFileSync13(path34, result.bytes);
+    writeFileSync12(path34, result.bytes);
     return {
       ok: true,
       path: path34,
@@ -80935,6 +81170,7 @@ function setupUI(host) {
     contextWindow: host.options.model?.contextWindow ?? 0
   });
   onThemeChange(() => {
+    host.streamingComponent?.invalidate();
     host.ui.invalidate();
     host.ui.requestRender();
   });
@@ -81492,6 +81728,7 @@ async function recoverHardStalledTurn(host, stalledMs) {
   host.isProcessing = false;
   host.setSubmitLock(false);
   revealHeldCalmStreamingComponent(host);
+  host.streamingComponent?.finalizeStreaming?.();
   host.streamingComponent = void 0;
   removeCalmToolLines(host.chatContainer, host.pendingTools);
   host.pendingTools.clear();
@@ -81839,6 +82076,11 @@ function createInteractiveAgentSessionController(host) {
         lastShownCompactionError = null;
         host.setControllerBusy(false);
       } else if (event.type === "turn_cancelled") {
+        host.emitExtensionEvent({
+          type: "turn:cancelled",
+          turnIndex: host._semanticTurnIndex,
+          reason: event.reason
+        });
         const outcome = host.executionState.abort();
         host.logDebug("execution:turn_cancelled", {
           turnIndex: host._semanticTurnIndex,
@@ -82747,6 +82989,51 @@ function summarizeToolNames(tools) {
   return tools.map((tool) => tool.name).join(", ");
 }
 
+// src/extensions/user-input-scope.ts
+function beginUserInput(host, extensionIsCurrent = () => true) {
+  const session = host.sessionManager.getActiveSession();
+  const controller = host.agentSessionController;
+  const runner = host.extensionRunner;
+  const handler = host.attachmentMentionHandler?.();
+  if (!session || !controller || !runner || !handler) return void 0;
+  let retired = false;
+  let used = false;
+  const unsubscribe = controller.subscribe((event) => {
+    if (event.type === "session_invalidated") retired = true;
+  });
+  const dispose = runner.trackUnregisterHandle(() => {
+    retired = true;
+    unsubscribe();
+  });
+  const isCurrent = () => !retired && host.sessionManager.getActiveSession() === session && host.agentSessionController === controller && host.extensionRunner === runner && host.attachmentMentionHandler?.() === handler && extensionIsCurrent();
+  return {
+    isCurrent,
+    dispose,
+    async submit(text, files = []) {
+      if (used || !isCurrent() || !text.trim() && !files.length) return false;
+      used = true;
+      try {
+        const mentions = [];
+        for (const file of files) {
+          if (!isCurrent()) return false;
+          const mention = await handler.prepareLocalFile(file.path, file.displayName, isCurrent);
+          if (!mention || !isCurrent()) return false;
+          mentions.push(mention.trim());
+        }
+        let content = [text.trim(), ...mentions].filter(Boolean).join("\n");
+        const decision = await runner.emitTerminalInput({ type: "terminal:input", text: content });
+        if (!isCurrent() || decision.action === "consume") return false;
+        if (decision.action === "transform") content = decision.text.trim();
+        if (!content || mentions.some((mention) => !content.includes(mention))) return false;
+        host.queueMessage(content, "followUp", { clearEditor: false, deliverWhileStreaming: false });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
 // src/extensions/interactive-extension-loader.ts
 async function loadInteractiveExtensions(host) {
   const extensionActions = {
@@ -82768,6 +83055,21 @@ async function loadInteractiveExtensions(host) {
         void host.editor.onSubmit(content);
       }
     },
+    attachLocalFile: async (path34, displayName) => {
+      const handler = host.attachmentMentionHandler?.();
+      if (!handler) return false;
+      return handler.attachLocalFile(path34, displayName);
+    },
+    beginUserInput: (isCurrent) => beginUserInput(host, isCurrent),
+    attachLocalFileAndSubmit: async (path34, displayName, submitText) => {
+      const scope = beginUserInput(host);
+      if (!scope) return false;
+      try {
+        return await scope.submit(submitText, [{ path: path34, displayName }]);
+      } finally {
+        scope.dispose();
+      }
+    },
     setPlanMode: (enabled, options) => {
       const shouldEmitTransition = host.planModeEnabled !== enabled || options?.forcePromptInjection;
       if (shouldEmitTransition) {
@@ -82936,6 +83238,74 @@ async function loadInteractiveExtensions(host) {
   }
 }
 
+// src/extensions/interactive-runtime-reload.ts
+import { AsyncLocalStorage } from "async_hooks";
+import * as os8 from "os";
+import * as path30 from "path";
+var runtimeReloadContext = new AsyncLocalStorage();
+var activeReloadTokens = /* @__PURE__ */ new WeakMap();
+async function reloadInteractiveRuntime(host) {
+  if (host.isProcessing) {
+    throw new Error("Cannot reload while a response is being processed. Wait for the turn to finish or abort it first.");
+  }
+  const ancestors = runtimeReloadContext.getStore();
+  const activeToken = ancestors ? activeReloadTokens.get(host) : void 0;
+  if (activeToken !== void 0 && ancestors?.get(host) === activeToken) {
+    throw new Error("Cannot reenter runtime reload from its own extension callbacks.");
+  }
+  if (host.runtimeReloadPromise) return host.runtimeReloadPromise;
+  const token = {};
+  const context = new Map(ancestors ?? []);
+  context.set(host, token);
+  const pending = Promise.resolve().then(() => runtimeReloadContext.run(context, async () => {
+    const acquiredReloadLock = !host.submitLock;
+    if (acquiredReloadLock) host.submitLock = true;
+    activeReloadTokens.set(host, token);
+    try {
+      await host.reloadRuntimeWhileLocked();
+    } finally {
+      if (activeReloadTokens.get(host) === token) activeReloadTokens.delete(host);
+      if (acquiredReloadLock) host.submitLock = false;
+    }
+  }));
+  host.runtimeReloadPromise = pending;
+  try {
+    await pending;
+  } finally {
+    if (host.runtimeReloadPromise === pending) host.runtimeReloadPromise = void 0;
+  }
+}
+async function reloadInteractiveRuntimeWhileLocked(host) {
+  const builtinDir = path30.join(getBuiltinDir(), "skills");
+  const userDir = path30.join(os8.homedir(), ".pie", "skills");
+  const projectDir = path30.join(host.options.cwd, ".pie", "skills");
+  const { skills, diagnostics } = loadSkills({
+    dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: host.options.cwd })
+  });
+  host.skills = skills;
+  host.skillsSection = formatSkillsForPrompt(skills);
+  for (const diag of diagnostics.filter((entry) => entry.type === "collision")) {
+    host.chatContainer.addChild(new Text(theme.fg("dim", `[reload] ${diag.message}`), 1, 0));
+  }
+  host.allTools = [...host.options.allTools];
+  host.originalTools = [...host.options.allTools];
+  host.pristineTools = [...host.options.allTools];
+  host.agent.state.tools = [...host.options.allTools];
+  resetCliHostEnvelopeRegistry();
+  const previousRunner = host.extensionRunner;
+  host.extensionRunner = void 0;
+  try {
+    await previousRunner?.dispose("reload");
+  } finally {
+    host.extensionWidgets?.clearAll();
+  }
+  await host.loadExtensions();
+  host.applyRuntimeToolMode();
+  host.noteRuntimeModeChanged("extension_reload");
+  await host.syncSessionScopedState();
+  host.ui.requestRender();
+}
+
 // src/interactive-mode.ts
 var InteractiveMode = class {
   agent;
@@ -83302,7 +83672,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-5JJZZ5H7.js");
+    const { Agent } = await import("./chunks/src-IY6TEIL7.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -83398,51 +83768,11 @@ var InteractiveMode = class {
     });
     await loadInteractiveExtensions(this.extensionLoaderHost);
   }
-  /**
-   * Full runtime reload (extension API `ctx.reload()`): re-discover skills
-   * and extensions from disk and rebuild the tool surface and system prompt.
-   * Rejects while a turn is processing. Listener lifecycle contract: the old
-   * extension instances are dropped entirely (handlers, tools, commands),
-   * the tool surface is reset to the pristine composition baseline, and the
-   * fresh ExtensionRunner re-wraps from that baseline — no stale handlers
-   * and no double-wrapped tools survive a reload.
-   */
   async reloadRuntime() {
-    if (this.isProcessing) {
-      throw new Error("Cannot reload while a response is being processed. Wait for the turn to finish or abort it first.");
-    }
-    const acquiredReloadLock = !this.submitLock;
-    if (acquiredReloadLock) this.submitLock = true;
-    try {
-      await this.reloadRuntimeWhileLocked();
-    } finally {
-      if (acquiredReloadLock) this.submitLock = false;
-    }
+    return reloadInteractiveRuntime(this);
   }
   async reloadRuntimeWhileLocked() {
-    const builtinDir = path30.join(getBuiltinDir(), "skills");
-    const userDir = path30.join(os8.homedir(), ".pie", "skills");
-    const projectDir = path30.join(this.options.cwd, ".pie", "skills");
-    const { skills, diagnostics } = loadSkills({
-      dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: this.options.cwd })
-    });
-    this.skills = skills;
-    this.skillsSection = formatSkillsForPrompt(skills);
-    for (const diag of diagnostics.filter((entry) => entry.type === "collision")) {
-      this.chatContainer.addChild(new Text(theme.fg("dim", `[reload] ${diag.message}`), 1, 0));
-    }
-    this.allTools = [...this.options.allTools];
-    this.originalTools = [...this.options.allTools];
-    this.pristineTools = [...this.options.allTools];
-    this.agent.state.tools = [...this.options.allTools];
-    resetCliHostEnvelopeRegistry();
-    await this.extensionRunner?.dispose("reload");
-    this.extensionWidgets?.clearAll();
-    await this.loadExtensions();
-    this.applyRuntimeToolMode();
-    this.noteRuntimeModeChanged("extension_reload");
-    await this.syncSessionScopedState();
-    this.ui.requestRender();
+    return reloadInteractiveRuntimeWhileLocked(this);
   }
   calculateContextUsage() {
     return calculateContextUsage(this.contextUiHost);
@@ -83669,9 +83999,41 @@ var InteractiveMode = class {
     return interactiveCommands.some((cmd) => commandPath.startsWith(cmd));
   }
   toggleToolsExpansion() {
+    if (this.calmMode) {
+      this.setCalmMode(false);
+      if (this.toolOutputExpanded) toggleToolsExpansion(this.uiHelperHost);
+      this.options.settingsManager.setToolOutputExpanded(this.toolOutputExpanded);
+      return;
+    }
+    if (this.toolOutputExpanded) {
+      this.setCalmMode(true);
+      return;
+    }
     toggleToolsExpansion(this.uiHelperHost);
     this.options.settingsManager.setToolOutputExpanded(this.toolOutputExpanded);
   }
+  /** Aggregated extension shortcut registrations for the keybinding
+   *  dispatcher (duck-typed onto InteractiveKeybindingsHost). Handlers are
+   *  bound to the extension runner context here. */
+  getExtensionShortcuts() {
+    const merged = /* @__PURE__ */ new Map();
+    for (const extension of this.extensions) {
+      for (const [key, shortcut] of extension.shortcuts) {
+        if (merged.has(key)) continue;
+        const context = this.extensionRunner?.createContext();
+        merged.set(key, {
+          key,
+          handler: () => shortcut.handler(context)
+        });
+      }
+    }
+    return merged;
+  }
+  /** Live mention handler for extension-driven attachments (duck-typed onto
+   *  InteractiveExtensionLoaderHost); undefined while attachments init. */
+  attachmentMentionHandler() {
+    return this.mentionHandler;
+  }
   showSelector(create) {
     return showSelector(this.uiHelperHost, create);
   }
@@ -84194,7 +84556,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-5JJZZ5H7.js");
+  const { Agent: AgentClass } = await import("./chunks/src-IY6TEIL7.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -84383,7 +84745,7 @@ async function runPrintMode(params) {
     if (!params.rawOutput && !params.jsonOutput) console.log("");
     agentSessionController.dispose();
     await runtime.sessionManager.save();
-    sessionTrace.flush();
+    await sessionTrace.flushAsync();
   } finally {
     await printModeExtensions.runner.dispose().catch((error) => {
       console.error("Extension cleanup failed:", error);
@@ -85089,7 +85451,7 @@ async function runJsonEventsMode(params) {
       const sideTrace = trace;
       const sideApiKey = runtime.apiKey;
       const snapshot = structuredClone(parent.state.messages);
-      const { Agent: AgentClass } = await import("./chunks/src-5JJZZ5H7.js");
+      const { Agent: AgentClass } = await import("./chunks/src-IY6TEIL7.js");
       const sideAgent = new AgentClass({
         initialState: {
           systemPrompt: parent.state.systemPrompt,
@@ -85398,7 +85760,7 @@ async function runJsonEventsMode(params) {
       await runtime?.sessionManager.save();
     } catch {
     }
-    trace?.flush();
+    await trace?.flushAsync();
     trace = void 0;
     cleanupBashOutputArtifacts();
   }
@@ -85453,7 +85815,7 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-5JJZZ5H7.js");
+    const { Agent: AgentClass } = await import("./chunks/src-IY6TEIL7.js");
     if (runtimeClosing) return;
     const compositionRegistry = createCliHostEnvelopeRegistry();
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, envelopeRegistry: compositionRegistry, getAgent: () => agent });
@@ -85820,7 +86182,7 @@ async function runJsonEventsMode(params) {
       if (activeTurn === turn) emitSettled(turn);
     } finally {
       clearInterval(progressTimer);
-      trace?.flush();
+      await trace?.flushAsync();
       await activeRuntime?.sessionManager.save();
       if (activeTurn === turn) activeTurn = null;
     }
@@ -86141,7 +86503,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-ZBTSPU7J.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-EXSL5TIO.js")).createTestStreamFnFromSequenceEnv();
 }
 function resolveJsonEventsDetailFlag() {
   for (let index = 0; index < process.argv.length; index += 1) {