@cydm/pie 2.7.10 → 2.7.12

package/dist/cli.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
+  CLI_RETRY_MAX_RETRIES,
   VERSION,
+  classifyCliFailure,
   cleanupBashOutputArtifacts,
   createBashTool,
   createCliHostCapabilities,
+  createCliRetryPolicy,
   createCliWebResearchHealthStore,
   createTraceTransportSink,
   createTransportDiagnosticsStreamFn,
@@ -20,10 +23,13 @@ import {
   getSessionsDir,
   getSettingsPath,
   getThemesDir,
+  isCliContextOverflowError,
+  isCliRetryableError,
   logTransportLifecycle,
   migrateConfigFromAgentDir,
+  setYoloGrantListener,
   truncateHeadTail
-} from "./chunks/chunk-5GUPRFNP.js";
+} from "./chunks/chunk-YI3CSQGD.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-WLFOBECN.js";
@@ -88,17 +94,15 @@ import {
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState,
   verifyPreparedCompactionCommit
-} from "./chunks/chunk-C4LXD56O.js";
-import "./chunks/chunk-JO6EDWHP.js";
+} from "./chunks/chunk-AFPRX5XI.js";
+import "./chunks/chunk-2NBUFVUQ.js";
 import {
   Deref,
-  EMPTY_ASSISTANT_CONTENT_ERROR,
   Errors,
   ExtendsUndefinedCheck,
   HasTransform,
   Hash,
   MODEL_CLASS_FALLBACK_ORDER,
-  OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
   TransformDecode,
   TransformDecodeCheckError,
   TransformEncode,
@@ -114,7 +118,7 @@ import {
   sortToolModelCandidatesByCapability,
   streamSimple,
   type_exports
-} from "./chunks/chunk-2B6VS2NH.js";
+} from "./chunks/chunk-EN47TIBG.js";
 import {
   IsArray,
   IsBigInt,
@@ -1936,7 +1940,7 @@ var require_core = __commonJS({
       return match && match.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join22(regexps, separator = "|") {
+    function join24(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex) => {
         numCaptures += 1;
@@ -2240,7 +2244,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join22(terminators), true);
+          this.matcherRe = langRe(join24(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -58061,7 +58065,9 @@ var SYMBOL_KEYS = /* @__PURE__ */ new Set([
 var MODIFIERS = {
   shift: 1,
   alt: 2,
-  ctrl: 4
+  ctrl: 4,
+  /** Kitty keyboard protocol bit 8: Super (macOS Command / Windows/Linux Super). */
+  super: 8
 };
 var LOCK_MASK = 64 + 128;
 var CODEPOINTS = {
@@ -58255,7 +58261,8 @@ function parseKeyId(keyId) {
     key,
     ctrl: parts.includes("ctrl"),
     shift: parts.includes("shift"),
-    alt: parts.includes("alt")
+    alt: parts.includes("alt"),
+    super: parts.includes("super") || parts.includes("cmd") || parts.includes("meta")
   };
 }
 function matchesKey(data, keyId) {
@@ -58266,6 +58273,7 @@ function matchesKey(data, keyId) {
   if (shift) modifier |= MODIFIERS.shift;
   if (alt) modifier |= MODIFIERS.alt;
   if (ctrl) modifier |= MODIFIERS.ctrl;
+  if (parsed.super) modifier |= MODIFIERS.super;
   switch (key) {
     case "escape":
     case "esc":
@@ -59666,6 +59674,13 @@ var SelectList = class {
     this.filteredItems = this.items.filter((item) => item.value.toLowerCase().startsWith(filter.toLowerCase()));
     this.selectedIndex = 0;
   }
+  /** Replace the item set (e.g. a scope toggle) and reset the cursor. */
+  setItems(items) {
+    this.items = items;
+    this.filteredItems = items;
+    this.selectedIndex = 0;
+    if (items[0]) this.onSelectionChange?.(items[0]);
+  }
   getVisibleRange() {
     const startIndex = Math.max(
       0,
@@ -63647,6 +63662,8 @@ import { EventEmitter } from "events";
 var ESC = "\x1B";
 var BRACKETED_PASTE_START = "\x1B[200~";
 var BRACKETED_PASTE_END = "\x1B[201~";
+var OSC_5522_PREFIX = "\x1B]5522;";
+var OSC_5522_MAX_FRAME = 70 * 1024 * 1024;
 function isCompleteSequence(data) {
   if (!data.startsWith(ESC)) {
     return "not-escape";
@@ -63733,11 +63750,19 @@ function isCompleteApcSequence(data) {
   }
   return "incomplete";
 }
-function extractCompleteSequences(buffer) {
+function extractCompleteSequences(buffer, maxClipboardFrame = OSC_5522_MAX_FRAME) {
   const sequences = [];
   let pos = 0;
   while (pos < buffer.length) {
     const remaining = buffer.slice(pos);
+    if (remaining.startsWith(`${ESC}]`)) {
+      const end = /\x07|\x1b\\/.exec(remaining);
+      if (!end) return { sequences, remainder: remaining };
+      const length = end.index + end[0].length;
+      if (!remaining.startsWith(OSC_5522_PREFIX) || length <= maxClipboardFrame) sequences.push(remaining.slice(0, length));
+      pos += length;
+      continue;
+    }
     if (remaining.startsWith(ESC)) {
       let seqEnd = 1;
       while (seqEnd <= remaining.length) {
@@ -63771,9 +63796,13 @@ var StdinBuffer = class extends EventEmitter {
   timeoutMs;
   pasteMode = false;
   pasteBuffer = "";
+  discardingClipboard = false;
+  discardEsc = false;
+  options;
   constructor(options = {}) {
     super();
     this.timeoutMs = options.timeout ?? 10;
+    this.options = options;
   }
   process(data) {
     if (this.timeout) {
@@ -63795,6 +63824,21 @@ var StdinBuffer = class extends EventEmitter {
       this.emit("data", "");
       return;
     }
+    if (this.discardingClipboard) {
+      const discarded = (this.discardEsc ? ESC : "") + str2;
+      const end = /\x07|\x1b\\/.exec(discarded);
+      if (!end) {
+        this.discardEsc = discarded.endsWith(ESC);
+        this.timeout = setTimeout(() => {
+          this.discardingClipboard = false;
+          this.discardEsc = false;
+        }, this.options.clipboardFrameTimeout ?? 1e3);
+        return;
+      }
+      this.discardingClipboard = false;
+      this.discardEsc = false;
+      str2 = discarded.slice(end.index + end[0].length);
+    }
     this.buffer += str2;
     if (this.pasteMode) {
       this.pasteBuffer += this.buffer;
@@ -63838,12 +63882,40 @@ var StdinBuffer = class extends EventEmitter {
       }
       return;
     }
-    const result = extractCompleteSequences(this.buffer);
+    const result = extractCompleteSequences(this.buffer, this.options.clipboardMaxFrame);
     this.buffer = result.remainder;
     for (const sequence of result.sequences) {
       this.emit("data", sequence);
     }
     if (this.buffer.length > 0) {
+      const heldFor5522 = this.buffer.startsWith(OSC_5522_PREFIX) || this.buffer.length >= 2 && OSC_5522_PREFIX.startsWith(this.buffer) || this.buffer === ESC && this.options.clipboardResponsePending?.();
+      if (heldFor5522 && this.buffer.length <= (this.options.clipboardMaxFrame ?? OSC_5522_MAX_FRAME)) {
+        this.timeout = setTimeout(() => {
+          const ambiguousEscape = this.buffer === ESC;
+          this.discardEsc = this.buffer.endsWith(ESC);
+          this.buffer = "";
+          if (ambiguousEscape) {
+            this.emit("data", ESC);
+            return;
+          }
+          this.discardingClipboard = true;
+          this.timeout = setTimeout(() => {
+            this.discardingClipboard = false;
+            this.discardEsc = false;
+          }, this.options.clipboardFrameTimeout ?? 1e3);
+        }, this.options.clipboardFrameTimeout ?? 1e3);
+        return;
+      }
+      if (heldFor5522) {
+        this.discardEsc = this.buffer.endsWith(ESC);
+        this.buffer = "";
+        this.discardingClipboard = true;
+        this.timeout = setTimeout(() => {
+          this.discardingClipboard = false;
+          this.discardEsc = false;
+        }, this.options.clipboardFrameTimeout ?? 1e3);
+        return;
+      }
       this.timeout = setTimeout(() => {
         const flushed = this.flush();
         for (const sequence of flushed) {
@@ -63860,7 +63932,7 @@ var StdinBuffer = class extends EventEmitter {
     if (this.buffer.length === 0) {
       return [];
     }
-    const sequences = [this.buffer];
+    const sequences = this.buffer.startsWith(OSC_5522_PREFIX) || this.buffer.length >= 2 && OSC_5522_PREFIX.startsWith(this.buffer) ? [] : [this.buffer];
     this.buffer = "";
     return sequences;
   }
@@ -63872,6 +63944,8 @@ var StdinBuffer = class extends EventEmitter {
     this.buffer = "";
     this.pasteMode = false;
     this.pasteBuffer = "";
+    this.discardingClipboard = false;
+    this.discardEsc = false;
   }
   getBuffer() {
     return this.buffer;
@@ -63884,8 +63958,193 @@ var StdinBuffer = class extends EventEmitter {
 // ../../packages/tui/src/terminal.ts
 import * as fs11 from "node:fs";
 import koffi from "koffi";
+
+// ../../packages/tui/src/osc-5522.ts
+var OSC = "\x1B]";
+var ST = "\x1B\\";
+var READ_TIMEOUT_MS = 8e3;
+var SUPPORT_TIMEOUT_MS = 1200;
+var MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+function parseOsc5522Packet(data) {
+  const match = data.match(/^\x1b\]5522;([^;]*);?([^\x1b\x07]*)(?:\x1b\\|\x07)$/);
+  if (!match) return void 0;
+  return { metadata: match[1] ?? "", payload: match[2] ?? "" };
+}
+function isStrictBase64(value) {
+  if (value.length % 4 !== 0) return false;
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(value)) return false;
+  const padding = value.length - value.replace(/=+$/, "").length;
+  if (padding > 2) return false;
+  if (padding > 0 && value.slice(0, -padding).includes("=")) return false;
+  return true;
+}
+function parseMetadata(metadata) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const part of metadata.split(":")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) {
+      if (part) fields.set(part, "");
+    } else {
+      fields.set(part.slice(0, eq), part.slice(eq + 1));
+    }
+  }
+  return fields;
+}
+var Osc5522Client = class {
+  constructor(write = (data) => process.stdout.write(data)) {
+    this.write = write;
+  }
+  write;
+  session;
+  supportMode = "unknown";
+  pendingSupportResolve;
+  get responsePending() {
+    return this.session !== void 0 || this.pendingSupportResolve !== void 0;
+  }
+  /**
+   * Feed one stdin sequence. Returns true when the packet was consumed as
+   * part of this protocol, so the caller can drop it before normal routing.
+   */
+  feed(data) {
+    const support = data.match(/^\x1b\[\?5522;(\d+)\$y$/);
+    if (support) {
+      const ps = Number(support[1]);
+      const supported = ps !== 0 && ps !== 4;
+      this.supportMode = supported ? "supported" : "unsupported";
+      this.pendingSupportResolve?.(supported);
+      this.pendingSupportResolve = void 0;
+      return true;
+    }
+    const packet = parseOsc5522Packet(data);
+    if (!packet) return false;
+    const fields = parseMetadata(packet.metadata);
+    const type = fields.get("type") ?? "";
+    if (!type.startsWith("read")) return false;
+    const status = fields.get("status");
+    const session = this.session;
+    if (!session) return true;
+    if (status === void 0) {
+      this.finishFor(session, { ok: false, kind: "malformed", message: `OSC 5522 read packet without status: ${packet.metadata}` });
+      return true;
+    }
+    if (status === "OK") {
+      return true;
+    }
+    if (status === "DATA") {
+      const mimeEncoded = fields.get("mime");
+      if (mimeEncoded === void 0 || mimeEncoded === "") {
+        this.finishFor(session, { ok: false, kind: "malformed", message: `DATA packet without mime field: ${packet.metadata}` });
+        return true;
+      }
+      if (!isStrictBase64(mimeEncoded)) {
+        this.finishFor(session, { ok: false, kind: "malformed", message: "Invalid base64 MIME in DATA packet" });
+        return true;
+      }
+      const mimeType = Buffer.from(mimeEncoded, "base64").toString("utf8");
+      if (session.mimeType !== void 0 && session.mimeType !== mimeType) {
+        return true;
+      }
+      if (session.mimeType === void 0) {
+        session.mimeType = mimeType;
+      }
+      if (!isStrictBase64(packet.payload)) {
+        this.finishFor(session, { ok: false, kind: "malformed", message: "Invalid base64 payload in DATA packet" });
+        return true;
+      }
+      const chunk = Buffer.from(packet.payload, "base64");
+      session.totalBytes += chunk.length;
+      if (session.totalBytes > MAX_TOTAL_BYTES) {
+        this.finishFor(session, { ok: false, kind: "too-large", message: `Clipboard image exceeds the ${Math.floor(MAX_TOTAL_BYTES / (1024 * 1024))}MB limit.` });
+        return true;
+      }
+      session.chunks.push(chunk);
+      return true;
+    }
+    if (status === "DONE") {
+      const mimeType = session.mimeType;
+      if (!mimeType || session.chunks.length === 0) {
+        this.finishFor(session, { ok: false, kind: "unavailable", message: "Clipboard read completed without data." });
+        return true;
+      }
+      this.finishFor(session, { ok: true, mimeType, bytes: Buffer.concat(session.chunks) });
+      return true;
+    }
+    const kind = status === "EPERM" ? "denied" : status === "EBUSY" ? "busy" : status === "ENOSYS" ? "unavailable" : "malformed";
+    const message = status === "EPERM" ? "Terminal denied the clipboard read (permission)." : status === "EBUSY" ? "Clipboard is busy (another client is using it)." : status === "ENOSYS" ? "Requested clipboard type is not available." : `Unexpected OSC 5522 status: ${status}`;
+    this.finishFor(session, { ok: false, kind, message });
+    return true;
+  }
+  /**
+   * Query DECRQM support (CSI ? 5522 $ p). Resolves false on timeout —
+   * terminals that do not know the mode never reply.
+   */
+  async querySupport(timeoutMs = SUPPORT_TIMEOUT_MS) {
+    if (this.supportMode !== "unknown") return this.supportMode === "supported";
+    return new Promise((resolve7) => {
+      let settled = false;
+      const settle = (supported) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this.pendingSupportResolve = void 0;
+        resolve7(supported);
+      };
+      const timer = setTimeout(() => settle(false), timeoutMs);
+      this.pendingSupportResolve = settle;
+      this.write(`\x1B[?5522$p`);
+    });
+  }
+  /**
+   * Read the clipboard's image data. The first offered representation of
+   * the requested types is returned (png preferred over jpeg by request
+   * order). Resolves unsupported when the terminal never replies to the
+   * DECRQM probe.
+   */
+  async readImage(timeoutMs = READ_TIMEOUT_MS, supportTimeoutMs = SUPPORT_TIMEOUT_MS) {
+    if (this.session) {
+      return { ok: false, kind: "busy", message: "Another OSC 5522 read is already in flight." };
+    }
+    const session = {
+      resolve: void 0,
+      timer: void 0,
+      chunks: [],
+      totalBytes: 0
+    };
+    const promise = new Promise((resolve7) => {
+      session.resolve = resolve7;
+    });
+    session.timer = setTimeout(() => {
+      this.finishFor(session, { ok: false, kind: "timeout", message: "Terminal did not respond to the clipboard read in time." });
+    }, timeoutMs);
+    this.session = session;
+    const supported = await this.querySupport(supportTimeoutMs);
+    if (!supported) {
+      this.finishFor(session, { ok: false, kind: "unsupported", message: "Terminal does not support the OSC 5522 clipboard protocol." });
+      return promise;
+    }
+    if (this.session !== session) return promise;
+    const mimeList = Buffer.from("image/png image/jpeg").toString("base64");
+    this.write(`${OSC}5522;type=read;${mimeList}${ST}`);
+    return promise;
+  }
+  /** Finish only if `session` is still the live session (identity-bound). */
+  finishFor(session, result) {
+    if (this.session !== session) return;
+    this.session = void 0;
+    clearTimeout(session.timer);
+    session.resolve(result);
+  }
+};
+
+// ../../packages/tui/src/terminal.ts
 var ProcessTerminal = class {
   wasRaw = false;
+  /** Client for the Kitty OSC 5522 clipboard protocol (read side). */
+  osc5522Client = new Osc5522Client();
+  /** Access the OSC 5522 clipboard client (terminal-level clipboard reads). */
+  get clipboard() {
+    return this.osc5522Client;
+  }
   inputHandler;
   resizeHandler;
   _kittyProtocolActive = false;
@@ -63927,9 +64186,12 @@ var ProcessTerminal = class {
    * to handle the case where the response arrives split across multiple events.
    */
   setupStdinBuffer() {
-    this.stdinBuffer = new StdinBuffer({ timeout: 10 });
+    this.stdinBuffer = new StdinBuffer({ timeout: 10, clipboardResponsePending: () => this.osc5522Client.responsePending });
     const kittyResponsePattern = /^\x1b\[\?(\d+)u$/;
     this.stdinBuffer.on("data", (sequence) => {
+      if (this.osc5522Client.feed(sequence)) {
+        return;
+      }
       if (!this._kittyProtocolActive) {
         const match = sequence.match(kittyResponsePattern);
         if (match) {
@@ -64188,11 +64450,14 @@ var ExtensionRunner = class {
     };
   }
   /**
-   * Set the UI context for interactive mode.
+   * Set the UI context for interactive mode. Does NOT change hasUI: the
+   * constructor's hasUI argument (host-provided: true for interactive, false
+   * for print/json-events no-op contexts) is the single source of truth.
+   * Flipping it here used to make headless hosts report ctx.hasUI === true
+   * while their ui.* methods silently no-op'd.
    */
   setUIContext(uiContext) {
     this.uiContext = uiContext;
-    this.hasUI = true;
   }
   /**
    * Wrap an unregister handle so this runner can revoke it during
@@ -64940,7 +65205,7 @@ var DEFAULT_APP_KEYBINDINGS = {
   steer: "alt+enter",
   followUp: [],
   dequeue: ["alt+up", "ctrl+shift+up"],
-  pasteImage: "ctrl+v",
+  pasteImage: ["ctrl+v", "alt+v", "super+v"],
   newSession: [],
   tree: [],
   fork: [],
@@ -65094,32 +65359,6 @@ function buildCliProjectContextSection(cwd) {
   return buildProjectContextSection(collectAncestorAgentsFiles(cwd));
 }
 
-// src/file-access-context.ts
-import * as path11 from "node:path";
-function uniqueNormalizedPaths(paths) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const entry of paths) {
-    const trimmed = String(entry || "").trim();
-    if (!trimmed) continue;
-    const normalized = path11.normalize(trimmed);
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    result.push(normalized);
-  }
-  return result;
-}
-function buildCliFileAccessOptions(params) {
-  return {
-    accessRoots: uniqueNormalizedPaths([
-      resolveCliProjectRoot(params.cwd),
-      params.configDir,
-      ...params.skills.map((skill) => skill.baseDir)
-    ]),
-    allowlistedDirs: params.allowlistedDirs
-  };
-}
-
 // src/runtime/computer-use-owner.ts
 var COMPUTER_USE_OWNER_ENV = "PIE_COMPUTER_USE_OWNER_ID";
 var COMPUTER_USE_EXECUTION_ENV = "PIE_COMPUTER_USE_EXECUTION_ID";
@@ -65139,7 +65378,7 @@ function computerUseOwnerEnv(ownerId, executionId) {
 
 // src/theme/theme.ts
 import * as fs13 from "node:fs";
-import * as path12 from "node:path";
+import * as path11 from "node:path";
 
 // ../../node_modules/@sinclair/typebox/build/esm/compiler/compiler.mjs
 var TypeCheck = class {
@@ -66026,8 +66265,8 @@ var BUILTIN_THEMES;
 function getBuiltinThemes() {
   if (!BUILTIN_THEMES) {
     const themesDir = getThemesDir();
-    const darkPath = path12.join(themesDir, "dark.json");
-    const lightPath = path12.join(themesDir, "light.json");
+    const darkPath = path11.join(themesDir, "dark.json");
+    const lightPath = path11.join(themesDir, "light.json");
     BUILTIN_THEMES = {
       dark: JSON.parse(fs13.readFileSync(darkPath, "utf-8")),
       light: JSON.parse(fs13.readFileSync(lightPath, "utf-8"))
@@ -66064,23 +66303,23 @@ function parseThemeJson(label, json) {
         otherErrors.push(`  - ${e.path}: ${e.message}`);
       }
     }
-    let errorMessage4 = `Invalid theme "${label}":
+    let errorMessage5 = `Invalid theme "${label}":
 `;
     if (missingColors.length > 0) {
-      errorMessage4 += "\nMissing required color tokens:\n";
-      errorMessage4 += missingColors.map((c) => `  - ${c}`).join("\n");
-      errorMessage4 += `
+      errorMessage5 += "\nMissing required color tokens:\n";
+      errorMessage5 += missingColors.map((c) => `  - ${c}`).join("\n");
+      errorMessage5 += `
 
 Please add these colors to your theme's "colors" object.`;
-      errorMessage4 += "\nSee the built-in themes (dark.json, light.json) for reference values.";
+      errorMessage5 += "\nSee the built-in themes (dark.json, light.json) for reference values.";
     }
     if (otherErrors.length > 0) {
-      errorMessage4 += `
+      errorMessage5 += `
 
 Other errors:
 ${otherErrors.join("\n")}`;
     }
-    throw new Error(errorMessage4);
+    throw new Error(errorMessage5);
   }
   return json;
 }
@@ -66107,7 +66346,7 @@ function loadThemeJson(name) {
     throw new Error(`Theme "${name}" does not have a source path for export`);
   }
   const customThemesDir = getCustomThemesDir();
-  const themePath = path12.join(customThemesDir, `${name}.json`);
+  const themePath = path11.join(customThemesDir, `${name}.json`);
   if (!fs13.existsSync(themePath)) {
     throw new Error(`Theme not found: ${name}`);
   }
@@ -66227,7 +66466,7 @@ function startThemeWatcher() {
     return;
   }
   const customThemesDir = getCustomThemesDir();
-  const themeFile = path12.join(customThemesDir, `${currentThemeName}.json`);
+  const themeFile = path11.join(customThemesDir, `${currentThemeName}.json`);
   if (!fs13.existsSync(themeFile)) {
     return;
   }
@@ -66428,7 +66667,7 @@ function getSettingsListTheme() {
 var import_yaml = __toESM(require_dist2(), 1);
 import * as fs14 from "fs";
 import * as os4 from "os";
-import * as path13 from "path";
+import * as path12 from "path";
 function parseSkillDescription(content) {
   content = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
@@ -66452,8 +66691,8 @@ function parseSkillDescription(content) {
 }
 var USER_CONTROLLED_SOURCES = /* @__PURE__ */ new Set(["user-agents", "user"]);
 function pathIsInside(child, parent) {
-  const relative3 = path13.relative(parent, child);
-  return relative3 !== "" && !relative3.startsWith(`..${path13.sep}`) && relative3 !== ".." && !path13.isAbsolute(relative3);
+  const relative3 = path12.relative(parent, child);
+  return relative3 !== "" && !relative3.startsWith(`..${path12.sep}`) && relative3 !== ".." && !path12.isAbsolute(relative3);
 }
 function resolveSkillSymlink(fullPath, dir, source) {
   let target;
@@ -66478,7 +66717,7 @@ function loadSkillsFromDir(dir, source) {
   const entries = fs14.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const fullPath = path13.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     let entryPath = fullPath;
     let entryIsDirectory = entry.isDirectory();
     let entryIsFile = entry.isFile();
@@ -66493,7 +66732,7 @@ function loadSkillsFromDir(dir, source) {
       entryIsFile = resolved.isFile;
     }
     if (entryIsDirectory) {
-      const skillMdPath = path13.join(entryPath, "SKILL.md");
+      const skillMdPath = path12.join(entryPath, "SKILL.md");
       if (fs14.existsSync(skillMdPath)) {
         try {
           const content = fs14.readFileSync(skillMdPath, "utf-8");
@@ -66525,7 +66764,7 @@ function loadSkillsFromDir(dir, source) {
           content,
           filePath: entryPath,
           source,
-          baseDir: path13.dirname(entryPath)
+          baseDir: path12.dirname(entryPath)
         });
       } catch (e) {
         diagnostics.push({
@@ -66539,18 +66778,18 @@ function loadSkillsFromDir(dir, source) {
   return { skills, diagnostics };
 }
 function discoverAgentsSkillsDirs(cwd) {
-  const resolvedCwd = path13.resolve(cwd || process.cwd());
+  const resolvedCwd = path12.resolve(cwd || process.cwd());
   const projectRoot = resolveCliProjectRoot(resolvedCwd);
   const projectAgentsDirs = [];
   let current = projectRoot;
   while (true) {
-    projectAgentsDirs.push(path13.join(current, ".agents", "skills"));
+    projectAgentsDirs.push(path12.join(current, ".agents", "skills"));
     if (current === resolvedCwd) break;
-    const child = path13.relative(current, resolvedCwd).split(path13.sep)[0];
+    const child = path12.relative(current, resolvedCwd).split(path12.sep)[0];
     if (!child) break;
-    current = path13.join(current, child);
+    current = path12.join(current, child);
   }
-  return { userAgentsDir: path13.join(os4.homedir(), ".agents", "skills"), projectAgentsDirs };
+  return { userAgentsDir: path12.join(os4.homedir(), ".agents", "skills"), projectAgentsDirs };
 }
 function buildSkillDirs(options) {
   const { userAgentsDir, projectAgentsDirs } = discoverAgentsSkillsDirs(options.cwd);
@@ -66724,7 +66963,7 @@ function validateSkillName(name) {
 import * as path30 from "path";
 
 // src/capabilities/read-file-understanding.ts
-import * as path22 from "node:path";
+import * as path21 from "node:path";
 import * as fs22 from "node:fs/promises";
 
 // src/core/provider-capabilities.ts
@@ -66752,7 +66991,7 @@ function getProviderDisplayName(platform2) {
 
 // src/files/adapters/kimi-adapter.ts
 import * as fs15 from "node:fs";
-import * as path14 from "node:path";
+import * as path13 from "node:path";
 
 // src/files/errors.ts
 var FileErrorMessages = {
@@ -66889,7 +67128,7 @@ var KimiFileAdapter = class {
   // Upload
   // ============================================================================
   async upload(filePath, options = {}) {
-    const fileName = options.sourceName || path14.basename(filePath);
+    const fileName = options.sourceName || path13.basename(filePath);
     const mimeType = options.mimeType || this.guessMimeType(fileName);
     const purpose = this.detectPurpose(filePath, options.purpose, mimeType);
     const stats = fs15.statSync(filePath);
@@ -66951,7 +67190,7 @@ var KimiFileAdapter = class {
     return "file-extract";
   }
   guessMimeType(filename) {
-    const ext = path14.extname(filename).toLowerCase();
+    const ext = path13.extname(filename).toLowerCase();
     switch (ext) {
       case ".jpg":
       case ".jpeg":
@@ -67114,7 +67353,7 @@ var KimiFileAdapter = class {
 
 // src/files/adapters/gemini-adapter.ts
 import * as fs16 from "node:fs";
-import * as path15 from "node:path";
+import * as path14 from "node:path";
 import { Readable } from "node:stream";
 var GeminiFileAdapter = class {
   platform = "gemini";
@@ -67179,7 +67418,7 @@ var GeminiFileAdapter = class {
       );
     }
     const mimeType = options.mimeType || this.guessMimeType(filePath);
-    const displayName = options.sourceName || path15.basename(filePath);
+    const displayName = options.sourceName || path14.basename(filePath);
     const startResponse = await fetch(
       `${this.baseUrl}/upload/v1beta/files?key=${this.apiKey}`,
       {
@@ -67415,7 +67654,7 @@ var GeminiFileAdapter = class {
 
 // src/files/adapters/openai-compatible-files-adapter.ts
 import * as fs17 from "node:fs";
-import * as path16 from "node:path";
+import * as path15 from "node:path";
 var OpenAICompatibleFilesAdapter = class {
   constructor(apiKey, baseUrl, extraHeaders = {}) {
     this.apiKey = apiKey;
@@ -67441,7 +67680,7 @@ var OpenAICompatibleFilesAdapter = class {
     ]
   };
   async upload(filePath, options = {}) {
-    const fileName = options.sourceName || path16.basename(filePath);
+    const fileName = options.sourceName || path15.basename(filePath);
     const mimeType = options.mimeType || guessMimeType(fileName);
     const stats = fs17.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
@@ -67567,7 +67806,7 @@ function extractContentText(raw) {
   return raw;
 }
 function guessMimeType(filename) {
-  const ext = path16.extname(filename).toLowerCase();
+  const ext = path15.extname(filename).toLowerCase();
   switch (ext) {
     case ".pdf":
       return "application/pdf";
@@ -67584,12 +67823,12 @@ function guessMimeType(filename) {
 
 // src/files/file-manager.ts
 import * as fs21 from "node:fs";
-import * as path21 from "node:path";
+import * as path20 from "node:path";
 import * as crypto2 from "node:crypto";
 
 // src/files/file-cache.ts
 import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as path17 from "node:path";
 import * as crypto from "node:crypto";
 
 // src/files/logger.ts
@@ -67684,7 +67923,7 @@ var DEFAULT_PIC_OPTIONS = {
 };
 
 // src/files/utils.ts
-import * as path17 from "node:path";
+import * as path16 from "node:path";
 import { homedir as homedir5 } from "node:os";
 var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[a-zA-Z]:[\\/]|[\\/]{2}[^\\/]+[\\/][^\\/]+)/;
 function isWindowsAbsolutePath(filePath) {
@@ -67705,13 +67944,13 @@ function formatBytes(bytes) {
 }
 function resolvePath2(inputPath) {
   if (inputPath.startsWith("~")) {
-    return path17.join(getHomeDirectory(), inputPath.slice(1));
+    return path16.join(getHomeDirectory(), inputPath.slice(1));
   }
   if (isWindowsAbsolutePath(inputPath)) {
     return inputPath;
   }
-  if (!path17.isAbsolute(inputPath)) {
-    return path17.resolve(process.cwd(), inputPath);
+  if (!path16.isAbsolute(inputPath)) {
+    return path16.resolve(process.cwd(), inputPath);
   }
   return inputPath;
 }
@@ -67739,8 +67978,8 @@ var FileCache = class _FileCache {
   maxEntries;
   constructor(baseDir, maxEntries = DEFAULT_MAX_CACHE_ENTRIES) {
     this.baseDir = baseDir;
-    this.dataDir = path18.join(baseDir, "data");
-    this.indexPath = path18.join(baseDir, "index.json");
+    this.dataDir = path17.join(baseDir, "data");
+    this.indexPath = path17.join(baseDir, "index.json");
     this.maxEntries = maxEntries;
     this.index = this.loadIndex();
     this.ensureDirectories();
@@ -67806,15 +68045,15 @@ var FileCache = class _FileCache {
   // ============================================================================
   getStoragePath(hash) {
     const subdir = hash.slice(0, 2);
-    const fullDir = path18.join(this.dataDir, subdir);
+    const fullDir = path17.join(this.dataDir, subdir);
     if (!fs18.existsSync(fullDir)) {
       fs18.mkdirSync(fullDir, { recursive: true });
     }
-    return path18.join(fullDir, hash);
+    return path17.join(fullDir, hash);
   }
   getStorageRelativePath(hash) {
     const subdir = hash.slice(0, 2);
-    return path18.join(subdir, hash);
+    return path17.join(subdir, hash);
   }
   async storeFile(sourcePath, name, mimeType) {
     const hash = await this.computeHash(sourcePath);
@@ -67876,7 +68115,7 @@ var FileCache = class _FileCache {
   getLocalPath(hash) {
     const entry = this.index.files[hash];
     if (!entry) return void 0;
-    return path18.join(this.dataDir, entry.localPath);
+    return path17.join(this.dataDir, entry.localPath);
   }
   exists(hash) {
     return hash in this.index.files;
@@ -67956,7 +68195,7 @@ var FileCache = class _FileCache {
       this.index.pathHints[this.getPathHintKey(resolvedPath)] = {
         path: resolvedPath,
         hash,
-        name: name || entry?.name || path18.basename(resolvedPath),
+        name: name || entry?.name || path17.basename(resolvedPath),
         size: stat2.size,
         mtimeMs: normalizedMtimeMs,
         lastSeenAt: Date.now(),
@@ -68004,7 +68243,7 @@ var FileCache = class _FileCache {
   deleteEntry(hash, entry) {
     entry = entry || this.index.files[hash];
     if (!entry) return;
-    const localPath = path18.join(this.dataDir, entry.localPath);
+    const localPath = path17.join(this.dataDir, entry.localPath);
     if (fs18.existsSync(localPath)) {
       fs18.unlinkSync(localPath);
     }
@@ -68020,7 +68259,7 @@ var FileCache = class _FileCache {
   }
   clear() {
     for (const entry of Object.values(this.index.files)) {
-      const localPath = path18.join(this.dataDir, entry.localPath);
+      const localPath = path17.join(this.dataDir, entry.localPath);
       if (fs18.existsSync(localPath)) {
         fs18.unlinkSync(localPath);
       }
@@ -68075,11 +68314,11 @@ var FileCache = class _FileCache {
     };
   }
   static getMimeType(fileName) {
-    const ext = path18.extname(fileName).toLowerCase();
+    const ext = path17.extname(fileName).toLowerCase();
     return MIME_TYPES[ext] || "application/octet-stream";
   }
   static getFileTypeFromName(fileName) {
-    const baseName = path18.basename(fileName);
+    const baseName = path17.basename(fileName);
     if (!baseName || baseName.startsWith(".")) {
       return void 0;
     }
@@ -68119,7 +68358,7 @@ var FileCache = class _FileCache {
 
 // src/files/session-file-manager.ts
 import * as fs19 from "node:fs";
-import * as path19 from "node:path";
+import * as path18 from "node:path";
 var INITIAL_REFRESH_BACKOFF_MS = 6e4;
 var MAX_REFRESH_BACKOFF_MS = 60 * 60 * 1e3;
 var SessionFileManager = class {
@@ -68133,7 +68372,7 @@ var SessionFileManager = class {
   constructor(sessionId, sessionsDir, fileCache, authFingerprint) {
     this.sessionId = sessionId;
     this.sessionsDir = sessionsDir;
-    this.statePath = path19.join(this.sessionsDir, `${sessionId}-files.json`);
+    this.statePath = path18.join(this.sessionsDir, `${sessionId}-files.json`);
     this.fileCache = fileCache;
     this.authFingerprint = authFingerprint;
     this.state = this.loadState();
@@ -68479,7 +68718,7 @@ var SessionFileManager = class {
     const files = fs19.readdirSync(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
-      const filePath = path19.join(sessionsDir, file);
+      const filePath = path18.join(sessionsDir, file);
       const stat2 = fs19.statSync(filePath);
       if (now - stat2.mtime.getTime() > maxAge) {
         fs19.unlinkSync(filePath);
@@ -68491,7 +68730,7 @@ var SessionFileManager = class {
 
 // src/files/ffmpeg-processor.ts
 import * as fs20 from "node:fs";
-import * as path20 from "node:path";
+import * as path19 from "node:path";
 import { spawn } from "node:child_process";
 var FFmpegProcessor = class {
   ffmpegPath = "ffmpeg";
@@ -68595,7 +68834,7 @@ var FFmpegProcessor = class {
   }
   async compressVideo(inputPath, outputDir, info, opts, onProgress) {
     const outputName = `compressed_${Date.now()}.mp4`;
-    const outputPath = path20.join(outputDir, outputName);
+    const outputPath = path19.join(outputDir, outputName);
     const adaptiveParams = this.calculateAdaptiveParams(info.duration, opts);
     const args = [
       "-i",
@@ -68657,9 +68896,9 @@ var FFmpegProcessor = class {
   }
   async extractKeyframes(inputPath, outputDir, info, opts, onProgress) {
     const interval = Math.floor(info.duration / opts.keyframeCount);
-    const framesDir = path20.join(outputDir, `keyframes_${Date.now()}`);
+    const framesDir = path19.join(outputDir, `keyframes_${Date.now()}`);
     fs20.mkdirSync(framesDir, { recursive: true });
-    const outputPattern = path20.join(framesDir, "frame_%03d.jpg");
+    const outputPattern = path19.join(framesDir, "frame_%03d.jpg");
     const args = [
       "-i",
       inputPath,
@@ -68677,7 +68916,7 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    let frames = fs20.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path20.join(framesDir, f));
+    let frames = fs20.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path19.join(framesDir, f));
     if (frames.length < opts.keyframeCount / 2) {
       fs20.rmSync(framesDir, { recursive: true, force: true });
       fs20.mkdirSync(framesDir, { recursive: true });
@@ -68696,7 +68935,7 @@ var FFmpegProcessor = class {
           onProgress?.(percent);
         }
       });
-      frames = fs20.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path20.join(framesDir, f));
+      frames = fs20.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path19.join(framesDir, f));
     }
     const totalOutputSize = frames.reduce(
       (sum, f) => sum + fs20.statSync(f).size,
@@ -68720,7 +68959,7 @@ var FFmpegProcessor = class {
     const opts = { ...DEFAULT_PIC_OPTIONS, ...options };
     const ext = opts.format === "webp" ? ".webp" : ".jpg";
     const outputName = `optimized_${Date.now()}${ext}`;
-    const outputPath = path20.join(outputDir, outputName);
+    const outputPath = path19.join(outputDir, outputName);
     const args = [
       "-i",
       inputPath,
@@ -68895,8 +69134,8 @@ var DIRECTORY_LISTING_TTL_MS = 1500;
 var FileManager = class {
   constructor(options) {
     this.options = options;
-    const baseDir = options.baseDir || path21.join(process.env.HOME || ".", ".pie", "files");
-    const sessionsDir = options.sessionsDir || path21.join(process.env.HOME || ".", ".pie", "sessions");
+    const baseDir = options.baseDir || path20.join(process.env.HOME || ".", ".pie", "files");
+    const sessionsDir = options.sessionsDir || path20.join(process.env.HOME || ".", ".pie", "sessions");
     this.fileCache = new FileCache(baseDir);
     this.authFingerprint = options.apiKey ? this.buildAuthFingerprint(options.apiKey) : void 0;
     this.sessionManager = new SessionFileManager(
@@ -68907,7 +69146,7 @@ var FileManager = class {
     );
     this.ffmpeg = new FFmpegProcessor(options.ffmpegPath);
     this.platform = normalizeFileManagerPlatform(options.platform);
-    this.tempDir = path21.join(baseDir, "temp");
+    this.tempDir = path20.join(baseDir, "temp");
     this.ensureDirectories();
   }
   options;
@@ -68954,7 +69193,7 @@ var FileManager = class {
   // ============================================================================
   async stageLocal(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    const sourceName = options.sourceName || path21.basename(resolvedPath);
+    const sourceName = options.sourceName || path20.basename(resolvedPath);
     if (!fs21.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
@@ -68984,7 +69223,7 @@ var FileManager = class {
   }
   async upload(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    const sourceName = options.sourceName || path21.basename(resolvedPath);
+    const sourceName = options.sourceName || path20.basename(resolvedPath);
     if (!fs21.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
@@ -69074,7 +69313,7 @@ var FileManager = class {
     }
     const cachedResult = await this.tryReuseCachedSourceUpload(
       resolvedPath,
-      options.sourceName || path21.basename(resolvedPath),
+      options.sourceName || path20.basename(resolvedPath),
       options.platform || this.platform
     );
     if (cachedResult) {
@@ -69091,9 +69330,9 @@ var FileManager = class {
     const result = await this.upload(optimizedPath, {
       ...options,
       purpose: "image",
-      sourceName: path21.basename(resolvedPath)
+      sourceName: path20.basename(resolvedPath)
     });
-    this.fileCache.rememberPathHint(resolvedPath, result.hash, path21.basename(resolvedPath));
+    this.fileCache.rememberPathHint(resolvedPath, result.hash, path20.basename(resolvedPath));
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     try {
       fs21.unlinkSync(optimizedPath);
@@ -69114,7 +69353,7 @@ var FileManager = class {
     }
     const cachedResult = await this.tryReuseCachedSourceUpload(
       resolvedPath,
-      options.sourceName || path21.basename(resolvedPath),
+      options.sourceName || path20.basename(resolvedPath),
       options.platform || this.platform
     );
     if (cachedResult) {
@@ -69164,9 +69403,9 @@ var FileManager = class {
       result = await this.upload(preprocessResult.output, {
         ...options,
         purpose: "video",
-        sourceName: path21.basename(resolvedPath)
+        sourceName: path20.basename(resolvedPath)
       });
-      this.fileCache.rememberPathHint(resolvedPath, result.hash, path21.basename(resolvedPath));
+      this.fileCache.rememberPathHint(resolvedPath, result.hash, path20.basename(resolvedPath));
       this.invalidateDirectoryListingCacheForPath(resolvedPath);
     } else {
       throw new FileManagerError(
@@ -69458,7 +69697,7 @@ var FileManager = class {
    * Detect purpose from file path based on extension
    */
   detectPurpose(filePath) {
-    const ext = path21.extname(filePath).toLowerCase();
+    const ext = path20.extname(filePath).toLowerCase();
     switch (ext) {
       case ".mp4":
       case ".mov":
@@ -69640,7 +69879,7 @@ var FileManager = class {
         if (!entry.name || entry.name.startsWith(".")) {
           continue;
         }
-        const fullPath = path21.join(resolvedDir, entry.name);
+        const fullPath = path20.join(resolvedDir, entry.name);
         if (entry.isDirectory()) {
           listing.directories.push({ name: entry.name, path: fullPath });
           continue;
@@ -69681,7 +69920,7 @@ var FileManager = class {
     return listing;
   }
   invalidateDirectoryListingCacheForPath(filePath) {
-    this.directoryListingCache.delete(path21.dirname(resolvePath2(filePath)));
+    this.directoryListingCache.delete(path20.dirname(resolvePath2(filePath)));
   }
   buildAuthFingerprint(apiKey) {
     return crypto2.createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
@@ -69730,8 +69969,8 @@ function createFileManagerForModel(params) {
     sessionId: params.sessionId,
     platform: platform2,
     apiKey: params.apiKey,
-    baseDir: path22.join(params.configDir, "files"),
-    sessionsDir: path22.join(params.configDir, "sessions")
+    baseDir: path21.join(params.configDir, "files"),
+    sessionsDir: path21.join(params.configDir, "sessions")
   });
   switch (getFileManagerAdapterKind(platform2)) {
     case "kimi":
@@ -69771,7 +70010,7 @@ async function prepareInlineMediaContent(params) {
   const limitBytes = limitMb * 1024 * 1024;
   if (stat2.size > limitBytes) {
     throw new Error(
-      `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path22.basename(params.request.displayPath)} is ${(stat2.size / 1024 / 1024).toFixed(1)}MB. Configure a model with a file upload adapter, or compress/trim the file before reading it.`
+      `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path21.basename(params.request.displayPath)} is ${(stat2.size / 1024 / 1024).toFixed(1)}MB. Configure a model with a file upload adapter, or compress/trim the file before reading it.`
     );
   }
   const data = await fs22.readFile(params.request.absolutePath, "base64");
@@ -69810,7 +70049,7 @@ async function prepareFileContent(configDir, params) {
   });
   if (params.request.kind === "document") {
     const upload2 = await manager.upload(params.request.absolutePath, {
-      sourceName: path22.basename(params.request.displayPath),
+      sourceName: path21.basename(params.request.displayPath),
       purpose: "file-extract"
     });
     await waitForReady({ manager, fileId: upload2.fileId, timeoutMs: 12e4, signal: params.request.signal });
@@ -69833,8 +70072,8 @@ async function prepareFileContent(configDir, params) {
       }
     };
   }
-  const upload = params.request.kind === "video" ? await manager.uploadVideo(params.request.absolutePath, { sourceName: path22.basename(params.request.displayPath), strategy: "compress" }) : await manager.upload(params.request.absolutePath, {
-    sourceName: path22.basename(params.request.displayPath),
+  const upload = params.request.kind === "video" ? await manager.uploadVideo(params.request.absolutePath, { sourceName: path21.basename(params.request.displayPath), strategy: "compress" }) : await manager.upload(params.request.absolutePath, {
+    sourceName: path21.basename(params.request.displayPath),
     purpose: params.request.kind === "image" ? "image" : "file-extract"
   });
   if (params.request.kind !== "video") {
@@ -70004,6 +70243,86 @@ function createCliFileSystemTools(cwd, options) {
   });
 }
 
+// src/file-access-context.ts
+import * as path22 from "node:path";
+function uniqueNormalizedPaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of paths) {
+    const trimmed = String(entry || "").trim();
+    if (!trimmed) continue;
+    const normalized = path22.normalize(trimmed);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+function buildCliFileAccessOptions(params) {
+  return {
+    accessRoots: uniqueNormalizedPaths([
+      resolveCliProjectRoot(params.cwd),
+      params.configDir,
+      ...params.skills.map((skill) => skill.baseDir)
+    ]),
+    allowlistedDirs: params.allowlistedDirs,
+    descriptionAllowlistedDirs: params.descriptionAllowlistedDirs
+  };
+}
+
+// src/interactive-filesystem-tools.ts
+function buildInteractiveFilesystemToolOptions(host, allowlistedDirs) {
+  return {
+    ...buildCliFileAccessOptions({
+      cwd: host.cwd,
+      configDir: host.configDir,
+      skills: host.skills,
+      allowlistedDirs,
+      descriptionAllowlistedDirs: []
+    }),
+    configDir: host.configDir,
+    fileObservationState: host.fileObservationState,
+    getAgentModel: host.getAgentModel,
+    getSessionId: () => host.getActiveSessionId() || void 0,
+    resolveToolModel: host.resolveToolModel,
+    resolveToolModelCandidates: host.resolveToolModelCandidates,
+    getPolicyContext: host.getPlanPolicyContext
+  };
+}
+
+// src/runtime/yolo-grant.ts
+var YoloGrantTracker = class {
+  untilMs = 0;
+  isActive(now = Date.now()) {
+    return this.untilMs > now;
+  }
+  award(grantMs, now = Date.now()) {
+    this.untilMs = now + Math.max(0, grantMs);
+  }
+  expire() {
+    this.untilMs = 0;
+  }
+  /** Expiry timestamp (0 when no grant is held); useful for display. */
+  get until() {
+    return this.untilMs;
+  }
+};
+function renderYoloGrantBanner(grantMs, sink) {
+  const minutes = Math.max(1, Math.round(grantMs / 6e4));
+  sink.addChild(new Spacer(1));
+  sink.addChild(
+    new Text(theme.fg("warning", `\u26A0\uFE0F YOLO granted for ${minutes} min (high-risk commands skip confirmation)`), 1, 0)
+  );
+  sink.addChild(new Spacer(1));
+}
+function parseYoloGrantMs(options, selected) {
+  const yoloOption = options.find((option) => /^\s*yolo(\s*\(|\s|$)/i.test(option));
+  if (!yoloOption || selected !== yoloOption) return void 0;
+  const minutesMatch = /\(\s*(\d+(?:\.\d+)?)\s*min/i.exec(yoloOption);
+  const minutes = minutesMatch ? Number(minutesMatch[1]) : 5;
+  return Math.round(minutes * 6e4);
+}
+
 // src/execution/state-manager.ts
 function getTextFromMessageContent(content) {
   if (typeof content === "string") {
@@ -70502,6 +70821,14 @@ function normalizeForComparison(value, flavor) {
   const withoutTrailingSeparators = normalized.length > root.length ? normalized.replace(flavor === "windows" ? /[\\/]+$/ : /\/+$/, "") : normalized;
   return flavor === "windows" ? withoutTrailingSeparators.toLowerCase() : withoutTrailingSeparators;
 }
+function sessionBelongsToCwd(sessionCwd, currentCwd) {
+  if (typeof sessionCwd !== "string" || sessionCwd.length === 0) return true;
+  if (!currentCwd) return true;
+  const sessionFlavor = getPathFlavor(sessionCwd, currentCwd);
+  const currentFlavor = getPathFlavor(currentCwd, sessionCwd);
+  if (sessionFlavor !== currentFlavor) return false;
+  return normalizeForComparison(sessionCwd, sessionFlavor) === normalizeForComparison(currentCwd, currentFlavor);
+}
 function formatSessionCwdTag(sessionCwd, currentCwd, homeDir) {
   if (typeof sessionCwd !== "string" || sessionCwd.length === 0 || !currentCwd) return void 0;
   const sessionFlavor = getPathFlavor(sessionCwd, currentCwd);
@@ -70527,31 +70854,47 @@ var SessionSelectorComponent = class extends Container {
   callbacks;
   options;
   items;
+  /** All sessions ever handed to the selector; the visible list is the current scope's filter. */
+  allSessions;
+  globalScope;
   refreshAttempted = /* @__PURE__ */ new Set();
   refreshInFlight = false;
   refreshQueue = [];
   refreshQueued = /* @__PURE__ */ new Set();
   refreshTimer;
   destroyed = false;
+  titleText;
+  hintText;
   constructor(sessions, callbacks, options = {}) {
     super();
     this.sessions = sessions;
+    this.allSessions = sessions;
+    this.globalScope = options.globalScope ?? false;
     this.callbacks = callbacks;
     this.options = options;
-    const truncated = options.totalCount !== void 0 && options.totalCount > sessions.length;
-    const title = truncated ? `Resume Session (recent ${sessions.length} of ${options.totalCount})` : "Resume Session";
-    this.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
+    const scoped = this.globalScope ? sessions : sessions.filter((session) => sessionBelongsToCwd(session.cwd, options.currentCwd));
+    this.sessions = scoped;
+    const title = this.isWindowTruncated() ? `Resume Session (recent ${scoped.length} of ${options.totalCount})` : "Resume Session";
+    this.titleText = new Text(theme.bold(theme.fg("accent", title)), 0, 0);
+    this.addChild(this.titleText);
     this.addChild(new Spacer(1));
-    this.items = sessions.map((session) => this.createItem(session));
+    this.items = scoped.map((session) => this.createItem(session));
     this.selectList = new SelectList(
       this.items,
-      Math.min(this.items.length, 8),
+      8,
       {
         selectedPrefix: (text) => theme.fg("accent", text),
         selectedText: (text) => theme.fg("accent", text),
         description: (text) => theme.fg("muted", text),
         scrollInfo: (text) => theme.fg("dim", text),
-        noMatch: (text) => theme.fg("dim", text)
+        // The noMatch hook carries the empty-directory-scope copy (SelectList
+        // hardcodes "No matching commands", which is wrong for sessions).
+        // When the loaded list is a truncated recent window, `g` cannot show
+        // this directory's older sessions either — promise nothing it can't do.
+        noMatch: () => theme.fg(
+          "dim",
+          this.options.totalCount !== void 0 && this.options.totalCount > this.allSessions.length ? "  No recent sessions in this directory" : "  No sessions in this directory \xB7 g shows all sessions"
+        )
       }
     );
     this.selectList.onSelect = (item) => {
@@ -70569,14 +70912,49 @@ var SessionSelectorComponent = class extends Container {
     };
     this.addChild(this.selectList);
     this.addChild(new Spacer(1));
-    this.addChild(
-      new Text(theme.fg("dim", "  \u2191\u2193 to navigate \xB7 \u2190\u2192 to page \xB7 Enter to select \xB7 Esc to cancel"), 0, 0)
-    );
+    this.hintText = new Text(theme.fg("dim", this.buildHintLine()), 0, 0);
+    this.addChild(this.hintText);
     this.scheduleVisibleRefreshes();
   }
+  /** True when the visible list is the unfiltered window AND that window is
+   * truncated vs the disk total (only then does "recent N of M" describe it). */
+  isWindowTruncated() {
+    return this.sessions.length === this.allSessions.length && this.options.totalCount !== void 0 && this.options.totalCount > this.allSessions.length;
+  }
+  /** Shared count expression so the title and the `g` hint never disagree. */
+  scopeCountText(count) {
+    return this.options.totalCount !== void 0 && this.options.totalCount > count ? `recent ${count} of ${this.options.totalCount}` : `all ${count}`;
+  }
+  buildHintLine() {
+    const scopeNote = this.globalScope ? `${this.scopeCountText(this.allSessions.length)} sessions` : `${this.sessions.length} in this directory`;
+    return `  \u2191\u2193 navigate \xB7 \u2190\u2192 page \xB7 g global (${scopeNote}) \xB7 Enter select \xB7 Esc cancel`;
+  }
   handleInput(data) {
+    if (this.destroyed) return;
+    if (data === "g" || data === "G") {
+      this.toggleScope();
+      return;
+    }
     this.selectList.handleInput(data);
   }
+  /** Toggle between current-directory sessions and the full loaded recent list. */
+  toggleScope() {
+    if (this.destroyed) return;
+    this.globalScope = !this.globalScope;
+    this.sessions = this.globalScope ? this.allSessions : this.allSessions.filter((session) => sessionBelongsToCwd(session.cwd, this.options.currentCwd));
+    this.items = this.sessions.map((session) => this.createItem(session));
+    this.selectList.setItems(this.items);
+    this.updateTitle();
+    this.updateHint();
+    this.scheduleVisibleRefreshes();
+  }
+  updateTitle() {
+    const windowText = this.isWindowTruncated() ? ` (recent ${this.sessions.length} of ${this.options.totalCount})` : "";
+    this.titleText.setText(theme.bold(theme.fg("accent", `Resume Session${windowText}`)));
+  }
+  updateHint() {
+    this.hintText.setText(theme.fg("dim", this.buildHintLine()));
+  }
   getSelectList() {
     return this.selectList;
   }
@@ -70584,10 +70962,11 @@ var SessionSelectorComponent = class extends Container {
     const cwdTag = formatSessionCwdTag(session.cwd, this.options.currentCwd, this.options.homeDir);
     const unknownTag = cwdTag === void 0 && this.options.currentCwd && !(typeof session.cwd === "string" && session.cwd.length > 0) ? "unknown path" : void 0;
     const tag = cwdTag ?? unknownTag;
+    const meta = `${session.id} \xB7 ${session.messageCount} messages \xB7 ${formatDate(session.updatedAt)}`;
     return {
       value: session.id,
       label: session.name || `Session ${session.id.slice(0, 8)}`,
-      description: tag ? `${tag} \xB7 ${session.messageCount} messages \xB7 ${formatDate(session.updatedAt)}` : `${session.messageCount} messages \xB7 ${formatDate(session.updatedAt)}`
+      description: tag ? `${tag} \xB7 ${meta}` : meta
     };
   }
   clearRefreshTimer() {
@@ -70634,6 +71013,8 @@ var SessionSelectorComponent = class extends Container {
   updateItem(metadata) {
     const sessionIndex = this.sessions.findIndex((session) => session.id === metadata.id);
     if (sessionIndex >= 0) this.sessions[sessionIndex] = metadata;
+    const allIndex = this.allSessions.findIndex((session) => session.id === metadata.id);
+    if (allIndex >= 0) this.allSessions[allIndex] = metadata;
     const itemIndex = this.items.findIndex((item2) => item2.value === metadata.id);
     if (itemIndex < 0) return;
     const nextItem = this.createItem(metadata);
@@ -72622,8 +73003,8 @@ async function handleResumeCommand(host) {
   host.showSelector((done) => {
     const selector = new SessionSelectorComponent(sessions, {
       onSelect: async (sessionId) => {
-        await host.loadSession(sessionId);
         done();
+        await host.loadSession(sessionId);
       },
       onCancel: () => {
         done();
@@ -72635,7 +73016,7 @@ async function handleResumeCommand(host) {
       requestRender: () => host.ui.requestRender(),
       totalCount
     });
-    return { component: selector, focus: selector.getSelectList() };
+    return { component: selector, focus: selector };
   });
 }
 async function loadSession(host, sessionId) {
@@ -76373,6 +76754,7 @@ function cleanupAndExit(host) {
   exitingHosts.add(host);
   console.log("\n[Cleanup] Stopping file status monitor...");
   const shutdown = shutdownInteractiveHost(host);
+  const sessionId = host.sessionManager?.getActiveSessionId();
   void (async () => {
     try {
       await shutdown;
@@ -76380,7 +76762,7 @@ function cleanupAndExit(host) {
       console.error("Interactive shutdown failed:", error);
       process.exitCode = 1;
     }
-    console.log("[Cleanup] Goodbye!");
+    console.log(`[Cleanup] Goodbye!${sessionId ? ` session: ${sessionId}` : ""}`);
     process.exit(process.exitCode || 0);
   })();
 }
@@ -77002,35 +77384,40 @@ var RuntimeModeBlockInjector = class {
 // src/runtime/host-envelope-registry.ts
 var sharedCliEnvelopeRegistry;
 function cliHostEnvelopeRegistry() {
-  if (sharedCliEnvelopeRegistry) return sharedCliEnvelopeRegistry;
-  sharedCliEnvelopeRegistry = createHostEnvelopeProjectorRegistry();
+  return sharedCliEnvelopeRegistry ??= createCliHostEnvelopeRegistry();
+}
+function createCliHostEnvelopeRegistry() {
+  const registry = createHostEnvelopeProjectorRegistry();
   for (const { kind, version } of runtimeModeEnvelopeRegistry().listPins()) {
-    sharedCliEnvelopeRegistry.register({
+    registry.register({
       kind,
       version,
       project: (data) => runtimeModeEnvelopeRegistry().resolve(kind, version).project(data)
     });
   }
-  return sharedCliEnvelopeRegistry;
+  return registry;
 }
-function registerExternalHostEnvelopeProjector(projector) {
-  cliHostEnvelopeRegistry().register(projector);
+function registerExternalHostEnvelopeProjector(projector, registry = cliHostEnvelopeRegistry()) {
+  registry.register(projector);
   return () => {
   };
 }
 function resetCliHostEnvelopeRegistry() {
   sharedCliEnvelopeRegistry = void 0;
 }
-function cliHostEnvelopeKinds() {
-  return cliHostEnvelopeRegistry().listPins().map(({ kind, version }) => `${kind}@${version}`).sort();
+function cliHostEnvelopeKinds(registry = cliHostEnvelopeRegistry()) {
+  return registry.listPins().map(({ kind, version }) => `${kind}@${version}`).sort();
+}
+function projectCliHostEnvelopes(messages, onProjection, registry = cliHostEnvelopeRegistry()) {
+  return projectHostEnvelopes(messages, registry, onProjection);
 }
-function projectCliHostEnvelopes(messages, onProjection) {
-  return projectHostEnvelopes(messages, cliHostEnvelopeRegistry(), onProjection);
+function cliCompactionModelView(message) {
+  return projectCliHostEnvelopes([message])[0];
 }
 function isIntakeHostContextError(value) {
   return value.code !== void 0;
 }
-function intakeHostContextBlock(value) {
+function intakeHostContextBlock(value, registry = cliHostEnvelopeRegistry()) {
   if (!isHostContextBlock(value)) {
     return {
       ok: false,
@@ -77039,12 +77426,12 @@ function intakeHostContextBlock(value) {
     };
   }
   const block = value;
-  const projector = cliHostEnvelopeRegistry().resolve(block.kind, block.version);
+  const projector = registry.resolve(block.kind, block.version);
   if (!projector) {
     return {
       ok: false,
       code: "host_context_unknown_projector",
-      message: `no projector for ${block.kind}@${block.version}; this build supports: ${cliHostEnvelopeKinds().join(", ")}`
+      message: `no projector for ${block.kind}@${block.version}; this build supports: ${cliHostEnvelopeKinds(registry).join(", ")}`
     };
   }
   try {
@@ -77059,8 +77446,8 @@ function intakeHostContextBlock(value) {
   }
   return { ok: true, block };
 }
-function intakeHostContextFailure(value) {
-  const result = intakeHostContextBlock(value);
+function intakeHostContextFailure(value, registry = cliHostEnvelopeRegistry()) {
+  const result = intakeHostContextBlock(value, registry);
   return isIntakeHostContextError(result) ? { code: result.code, message: result.message } : void 0;
 }
 
@@ -77092,13 +77479,14 @@ async function handleCompactCommand(host) {
     const preparation = prepareSessionCompaction({
       sessionManager: host.sessionManager,
       messages: existingMessages,
+      modelView: cliCompactionModelView,
       budgetTokens: host.options.model?.contextWindow
     });
     if (preparation.entries.length === 0) {
       host.showStatus("Need at least one real user message before compacting");
       return;
     }
-    const tokensBefore = calculateTotalTokens(preparation.messages);
+    const tokensBefore = preparation.inputTokens;
     const compactOptions = {
       model: host.options.model,
       apiKey: host.options.apiKey,
@@ -78316,6 +78704,7 @@ var FileStatusMonitor = class {
 
 // src/files/mention/mention-handler.ts
 import * as fs26 from "node:fs";
+import { randomUUID } from "node:crypto";
 import * as path28 from "node:path";
 var MentionHandler = class {
   fileManager;
@@ -78409,75 +78798,11 @@ var MentionHandler = class {
       this.onInsertMention(mention, queryToken);
       this.onStatus?.(`Added ${option.name} (already uploaded to ${this.fileManager.getPlatformDisplayName()})`);
     } else if (option.type === "upload" && option.path) {
-      this.pendingUploadCount += 1;
-      const pendingMention = this.formatPendingMention(option.name);
-      this.onInsertMention(pendingMention, queryToken);
-      const pendingStatusKey = `${option.path}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
-      try {
-        if (option.cacheStatus === "uploaded") {
-          this.pushPendingStatus(
-            pendingStatusKey,
-            `Preparing ${option.name} (reusing upload from ${this.fileManager.getPlatformDisplayName()})...`
-          );
-        } else if (option.cacheStatus === "cached") {
-          this.pushPendingStatus(
-            pendingStatusKey,
-            `Preparing ${option.name} (reusing local cache)...`
-          );
-        } else {
-          this.pushPendingStatus(pendingStatusKey, `Preparing ${option.name}...`);
-        }
-        const mimeType = FileCache.getMimeType(option.path);
-        const isMedia = mimeType.startsWith("image/") || mimeType.startsWith("video/");
-        const shouldStageLocally = !isMedia || !this.fileManager.hasAdapter();
-        if (isMedia && shouldStageLocally) {
-          this.pushPendingStatus(pendingStatusKey, `Staging ${option.name} locally (no upload API for this provider)...`);
-        }
-        const onProgress = (progress, stage) => {
-          this.pushPendingStatus(
-            pendingStatusKey,
-            this.formatUploadProgress(option.name, progress, stage)
-          );
-        };
-        const result = shouldStageLocally ? await this.fileManager.stageLocal(option.path, { sourceName: option.name }) : mimeType.startsWith("video/") ? await this.fileManager.uploadVideo(option.path, {
-          sourceName: option.name,
-          onProgress
-        }) : mimeType.startsWith("image/") ? await this.fileManager.uploadPic(option.path, {
-          sourceName: option.name,
-          onProgress
-        }) : await this.fileManager.upload(option.path, {
-          sourceName: option.name,
-          onProgress
-        });
-        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}`);
-        } else {
-          this.onInsertMention("", pendingMention);
-          this.clearPendingStatus(pendingStatusKey);
-          this.onError?.("File upload failed. Please try again.");
-        }
-      } catch (err) {
-        this.onInsertMention("", pendingMention);
-        this.clearPendingStatus(pendingStatusKey);
-        const errorMessage4 = err instanceof Error ? err.message : String(err);
-        if (errorMessage4.includes("PLATFORM_NOT_SUPPORTED")) {
-          this.onError?.("The current AI model does not support file uploads.");
-        } else if (errorMessage4.includes("ENOENT")) {
-          this.onError?.("File does not exist or cannot be accessed.");
-        } else if (errorMessage4.includes("EACCES") || errorMessage4.includes("PERMISSION")) {
-          this.onError?.("Permission denied while accessing the file.");
-        } else if (errorMessage4.includes("network") || errorMessage4.includes("ETIMEDOUT") || errorMessage4.includes("ECONNREFUSED")) {
-          this.onError?.("Network error. Check the connection and try again.");
-        } else {
-          this.onError?.(`Upload failed: ${errorMessage4}`);
-        }
-      } finally {
-        this.clearPendingStatus(pendingStatusKey);
-        this.pendingUploadCount = Math.max(0, this.pendingUploadCount - 1);
-      }
+      await this.attachFileFromPath(option.path, {
+        sourceName: option.name,
+        queryToken,
+        cacheStatus: option.cacheStatus
+      });
     } else {
       this.onError?.("Invalid file option.");
     }
@@ -78485,6 +78810,110 @@ var MentionHandler = class {
     this.onHidePicker();
     this.isPickerVisible = false;
   }
+  /**
+   * Attach a local file from disk without going through the mention picker.
+   *
+   * Used by the clipboard image paste flow: the file goes through the exact
+   * same pending-mention → stage/upload → final-mention lifecycle as a
+   * picker-selected file, so submit-time queueing and attachment resolution
+   * behave identically.
+   */
+  async attachLocalFile(path34, displayName, pendingMention, isCurrent) {
+    await this.attachFileFromPath(path34, { sourceName: displayName, queryToken: pendingMention, isCurrent });
+  }
+  /** Reserve a real queue-replaceable token before asynchronous clipboard IO. */
+  beginPendingAttachment(name) {
+    const token = `@[${name}](pending:clipboard-${randomUUID()})`;
+    this.pendingUploadCount++;
+    this.onInsertMention(`${token} `);
+    let finished = false;
+    return { token, finish: () => {
+      if (finished) return;
+      finished = true;
+      this.onInsertMention("", token);
+      this.pendingUploadCount = Math.max(0, this.pendingUploadCount - 1);
+    } };
+  }
+  /**
+   * Shared core of "attach a file from a local path": insert a pending
+   * mention, stage or upload the file, then replace the pending mention with
+   * the final one (or remove it on failure).
+   */
+  async attachFileFromPath(path34, options) {
+    const sourceName = options.sourceName ?? path34.split(/[\\/]/).pop() ?? path34;
+    this.pendingUploadCount += 1;
+    const pendingMention = options.queryToken?.includes("pending:clipboard-") ? options.queryToken : this.formatPendingMention(sourceName);
+    this.onInsertMention(pendingMention, options.queryToken);
+    const pendingStatusKey = `${path34}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+    try {
+      if (options.cacheStatus === "uploaded") {
+        this.pushPendingStatus(
+          pendingStatusKey,
+          `Preparing ${sourceName} (reusing upload from ${this.fileManager.getPlatformDisplayName()})...`
+        );
+      } else if (options.cacheStatus === "cached") {
+        this.pushPendingStatus(
+          pendingStatusKey,
+          `Preparing ${sourceName} (reusing local cache)...`
+        );
+      } else {
+        this.pushPendingStatus(pendingStatusKey, `Preparing ${sourceName}...`);
+      }
+      const mimeType = FileCache.getMimeType(path34);
+      const isMedia = mimeType.startsWith("image/") || mimeType.startsWith("video/");
+      const shouldStageLocally = !isMedia || !this.fileManager.hasAdapter();
+      if (isMedia && shouldStageLocally) {
+        this.pushPendingStatus(pendingStatusKey, `Staging ${sourceName} locally (no upload API for this provider)...`);
+      }
+      const onProgress = (progress, stage) => {
+        if (options.isCurrent && !options.isCurrent()) return;
+        this.pushPendingStatus(
+          pendingStatusKey,
+          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;
+      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}`);
+      } else {
+        this.onInsertMention("", pendingMention);
+        this.clearPendingStatus(pendingStatusKey);
+        this.onError?.("File upload failed. Please try again.");
+      }
+    } catch (err) {
+      if (options.isCurrent && !options.isCurrent()) return;
+      this.onInsertMention("", pendingMention);
+      this.clearPendingStatus(pendingStatusKey);
+      const errorMessage5 = err instanceof Error ? err.message : String(err);
+      if (errorMessage5.includes("PLATFORM_NOT_SUPPORTED")) {
+        this.onError?.("The current AI model does not support file uploads.");
+      } else if (errorMessage5.includes("ENOENT")) {
+        this.onError?.("File does not exist or cannot be accessed.");
+      } else if (errorMessage5.includes("EACCES") || errorMessage5.includes("PERMISSION")) {
+        this.onError?.("Permission denied while accessing the file.");
+      } else if (errorMessage5.includes("network") || errorMessage5.includes("ETIMEDOUT") || errorMessage5.includes("ECONNREFUSED")) {
+        this.onError?.("Network error. Check the connection and try again.");
+      } else {
+        this.onError?.(`Upload failed: ${errorMessage5}`);
+      }
+    } finally {
+      this.clearPendingStatus(pendingStatusKey);
+      this.pendingUploadCount = Math.max(0, this.pendingUploadCount - 1);
+    }
+  }
   /**
    * Parse mentions in text and convert to platform format
    */
@@ -79224,6 +79653,10 @@ function setupInteractiveKeybindings(host) {
       host.handleInterrupt();
       return { consume: true };
     }
+    if (!host.mentionPickerComponent && host.keybindings.matches(data, "pasteImage")) {
+      host.handlePasteImage();
+      return { consume: true };
+    }
     if (host.keybindings.matches(data, "expandTools")) {
       host.toggleToolsExpansion();
       return { consume: true };
@@ -79244,6 +79677,473 @@ function setupInteractiveKeybindings(host) {
   });
 }
 
+// src/clipboard/read-clipboard-image.ts
+import { spawn as spawn2 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync18, readFileSync as readFileSync17, statSync as statSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join20 } from "node:path";
+var MAX_IMAGE_BYTES = 50 * 1024 * 1024;
+var COMMAND_TIMEOUT_MS = 1e4;
+function isSpawnFailure(outcome) {
+  return !outcome.ok;
+}
+function defaultSpawnFn(file, args, spawnImpl = spawn2, maxBytes = MAX_IMAGE_BYTES, timeoutMs = COMMAND_TIMEOUT_MS) {
+  return new Promise((resolve7) => {
+    let child;
+    try {
+      child = spawnImpl(file, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (err) {
+      resolve7({ ok: false, error: "spawn-failed", message: err instanceof Error ? err.message : String(err) });
+      return;
+    }
+    let settled = false;
+    const stdoutChunks = [];
+    let stderrText = "";
+    let stdoutBytes = 0;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      resolve7({ ok: false, error: "timeout" });
+    }, timeoutMs);
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve7({ ok: false, error: err.code === "ENOENT" ? "not-found" : "spawn-failed", message: err.message });
+    });
+    child.stdout?.on("data", (chunk) => {
+      if (settled) return;
+      if (chunk.length > maxBytes - stdoutBytes) {
+        settled = true;
+        clearTimeout(timer);
+        stdoutChunks.length = 0;
+        resolve7({ ok: false, error: "too-large" });
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        return;
+      }
+      stdoutBytes += chunk.length;
+      stdoutChunks.push(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (!settled && stderrText.length < 4e3) stderrText += chunk.subarray(0, 4e3 - stderrText.length).toString("utf8");
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve7({ ok: true, result: { code: code ?? -1, stdout: Buffer.concat(stdoutChunks, stdoutBytes), stderr: stderrText } });
+    });
+  });
+}
+function defaultMkTempPath(ext) {
+  return join20(tmpdir(), `pie-clipboard-${randomBytes2(6).toString("hex")}${ext}`);
+}
+async function readClipboardImage(deps = {}) {
+  const platform2 = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const spawnImpl = deps.spawnImpl ?? defaultSpawnFn;
+  const mkTempPath = deps.mkTempPath ?? defaultMkTempPath;
+  switch (platform2) {
+    case "darwin":
+      return readMacClipboard(spawnImpl, mkTempPath);
+    case "win32":
+      return readWindowsClipboard(spawnImpl, mkTempPath);
+    case "linux":
+    case "freebsd":
+    case "openbsd":
+    case "netbsd":
+      return readLinuxClipboard(spawnImpl, mkTempPath, env);
+    default:
+      return {
+        ok: false,
+        kind: "unsupported-platform",
+        message: `Clipboard image paste is not supported on ${platform2}.`
+      };
+  }
+}
+function escapeAppleScriptString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function readMacClipboard(spawnImpl, mkTempPath) {
+  const targetPath = mkTempPath(".png");
+  const outcome = await spawnImpl("osascript", [
+    "-e",
+    "set pngData to (the clipboard as \xABclass PNGf\xBB)",
+    "-e",
+    `set fp to open for access POSIX file "${escapeAppleScriptString(targetPath)}" with write permission`,
+    "-e",
+    "write pngData to fp",
+    "-e",
+    "close access fp"
+  ]);
+  if (isSpawnFailure(outcome)) {
+    return spawnFailure(outcome, "osascript");
+  }
+  if (outcome.result.code !== 0) {
+    const stderr = outcome.result.stderr.trim();
+    if (/PNGf|Can't|can’t/i.test(stderr)) {
+      return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+    }
+    return {
+      ok: false,
+      kind: "failed",
+      message: `osascript failed: ${truncate(stderr) || `exit ${outcome.result.code}`}`
+    };
+  }
+  return finalizeTempImage(targetPath, "image/png");
+}
+function escapePowerShellSingleQuoted(value) {
+  return value.replace(/'/g, "''");
+}
+async function readWindowsClipboard(spawnImpl, mkTempPath) {
+  const targetPath = mkTempPath(".png");
+  const script = [
+    "Add-Type -AssemblyName System.Windows.Forms",
+    "Add-Type -AssemblyName System.Drawing",
+    "$img = [System.Windows.Forms.Clipboard]::GetImage()",
+    "if ($null -eq $img) { exit 2 }",
+    `$img.Save('${escapePowerShellSingleQuoted(targetPath)}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    "exit 0"
+  ].join("\n");
+  const outcome = await spawnImpl("powershell", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-STA",
+    "-Command",
+    script
+  ]);
+  if (isSpawnFailure(outcome)) {
+    return spawnFailure(outcome, "powershell");
+  }
+  if (outcome.result.code === 2) {
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+  }
+  if (outcome.result.code !== 0) {
+    return {
+      ok: false,
+      kind: "failed",
+      message: `powershell failed: ${truncate(outcome.result.stderr.trim()) || `exit ${outcome.result.code}`}`
+    };
+  }
+  return finalizeTempImage(targetPath, "image/png");
+}
+var PREFERRED_IMAGE_MIMES = ["image/png", "image/jpeg"];
+function extensionForMime(mimeType) {
+  switch (mimeType) {
+    case "image/png":
+      return ".png";
+    case "image/jpeg":
+      return ".jpg";
+    case "image/gif":
+      return ".gif";
+    case "image/webp":
+      return ".webp";
+    case "image/bmp":
+      return ".bmp";
+    default:
+      return ".png";
+  }
+}
+function pickImageMime(advertised) {
+  for (const mime of PREFERRED_IMAGE_MIMES) {
+    if (advertised.includes(mime)) return mime;
+  }
+  return advertised.find((mime) => mime.startsWith("image/"));
+}
+async function readLinuxClipboard(spawnImpl, mkTempPath, env) {
+  if (env.WAYLAND_DISPLAY) {
+    return readWaylandClipboard(spawnImpl, mkTempPath);
+  }
+  if (env.DISPLAY) {
+    return readX11Clipboard(spawnImpl, mkTempPath);
+  }
+  return {
+    ok: false,
+    kind: "failed",
+    message: "No graphical session detected (neither WAYLAND_DISPLAY nor DISPLAY is set)."
+  };
+}
+async function readWaylandClipboard(spawnImpl, mkTempPath) {
+  const listOutcome = await spawnImpl("wl-paste", ["--list-types"]);
+  if (isSpawnFailure(listOutcome)) {
+    return spawnFailure(listOutcome, "wl-paste");
+  }
+  if (listOutcome.result.code !== 0) {
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+  }
+  const advertised = listOutcome.result.stdout.toString("utf8").split("\n").map((line) => line.trim()).filter(Boolean);
+  const mime = pickImageMime(advertised);
+  if (!mime) {
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+  }
+  const dataOutcome = await spawnImpl("wl-paste", ["--type", mime]);
+  if (isSpawnFailure(dataOutcome)) {
+    return spawnFailure(dataOutcome, "wl-paste");
+  }
+  if (dataOutcome.result.code !== 0) {
+    return {
+      ok: false,
+      kind: "failed",
+      message: `wl-paste failed: ${truncate(dataOutcome.result.stderr.trim()) || `exit ${dataOutcome.result.code}`}`
+    };
+  }
+  return writeImageBytes(dataOutcome.result.stdout, mime, mkTempPath);
+}
+async function readX11Clipboard(spawnImpl, mkTempPath) {
+  const listOutcome = await spawnImpl("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"]);
+  if (isSpawnFailure(listOutcome)) {
+    return spawnFailure(listOutcome, "xclip");
+  }
+  if (listOutcome.result.code !== 0) {
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+  }
+  const advertised = listOutcome.result.stdout.toString("utf8").split("\n").map((line) => line.trim()).filter(Boolean);
+  const mime = pickImageMime(advertised);
+  if (!mime) {
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+  }
+  const dataOutcome = await spawnImpl("xclip", ["-selection", "clipboard", "-t", mime, "-o"]);
+  if (isSpawnFailure(dataOutcome)) {
+    return spawnFailure(dataOutcome, "xclip");
+  }
+  if (dataOutcome.result.code !== 0) {
+    return {
+      ok: false,
+      kind: "failed",
+      message: `xclip failed: ${truncate(dataOutcome.result.stderr.trim()) || `exit ${dataOutcome.result.code}`}`
+    };
+  }
+  return writeImageBytes(dataOutcome.result.stdout, mime, mkTempPath);
+}
+function writeImageBytes(bytes, declaredMime, mkTempPath) {
+  if (bytes.length === 0) {
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+  }
+  if (bytes.length > MAX_IMAGE_BYTES) {
+    return { ok: false, kind: "too-large", message: `Clipboard image is too large (${formatBytes2(bytes.length)}).` };
+  }
+  const mimeType = detectMimeFromMagic(bytes) ?? declaredMime;
+  const targetPath = mkTempPath(extensionForMime(mimeType));
+  try {
+    writeFileSync12(targetPath, bytes);
+  } catch (err) {
+    return { ok: false, kind: "failed", message: `Failed to write temp image: ${errorMessage4(err)}` };
+  }
+  return {
+    ok: true,
+    path: targetPath,
+    mimeType,
+    cleanup: makeCleanup(targetPath)
+  };
+}
+function finalizeTempImage(path34, mimeType) {
+  let bytes;
+  try {
+    if (!existsSync18(path34)) {
+      return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+    }
+    const size = statSync12(path34).size;
+    if (size === 0) {
+      makeCleanup(path34)();
+      return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+    }
+    if (size > MAX_IMAGE_BYTES) {
+      makeCleanup(path34)();
+      return { ok: false, kind: "too-large", message: `Clipboard image is too large (${formatBytes2(size)}).` };
+    }
+    bytes = readFileSync17(path34);
+  } catch (err) {
+    return { ok: false, kind: "failed", message: `Failed to read clipboard image: ${errorMessage4(err)}` };
+  }
+  const detected = detectMimeFromMagic(bytes);
+  if (!detected) {
+    makeCleanup(path34)();
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain a supported image (PNG/JPEG)." };
+  }
+  return { ok: true, path: path34, mimeType: detected, cleanup: makeCleanup(path34) };
+}
+function detectMimeFromMagic(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  return void 0;
+}
+function makeCleanup(path34) {
+  return () => {
+    try {
+      unlinkSync8(path34);
+    } catch {
+    }
+  };
+}
+function spawnFailure(outcome, tool) {
+  if (outcome.error === "too-large") {
+    return { ok: false, kind: "too-large", message: "Clipboard image is too large." };
+  }
+  if (outcome.error === "not-found") {
+    return {
+      ok: false,
+      kind: "missing-tool",
+      message: `${tool} is not installed; it is required to read clipboard images on this platform.`
+    };
+  }
+  if (outcome.error === "timeout") {
+    return { ok: false, kind: "timeout", message: `Reading the clipboard with ${tool} timed out.` };
+  }
+  return { ok: false, kind: "failed", message: `Failed to run ${tool}: ${outcome.message ?? "unknown error"}` };
+}
+function truncate(text, max = 200) {
+  const trimmed = text.trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max)}\u2026` : trimmed;
+}
+function errorMessage4(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function formatBytes2(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${Math.max(1, Math.round(bytes / 1024))}KB`;
+}
+
+// src/input/image-paste.ts
+import { mkdtempSync, writeFileSync as writeFileSync13, 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();
+function formatPastedImageName(date, extension = ".png") {
+  const pad = (value) => String(value).padStart(2, "0");
+  const hh = pad(date.getHours());
+  const mm = pad(date.getMinutes());
+  const ss = pad(date.getSeconds());
+  return `pasted-${hh}${mm}${ss}${extension}`;
+}
+function terminalResultToClipboardResult(result) {
+  if (result.ok !== true) {
+    const kindMap = {
+      unsupported: "failed",
+      timeout: "timeout",
+      denied: "failed",
+      busy: "failed",
+      unavailable: "no-image",
+      "too-large": "too-large",
+      malformed: "failed"
+    };
+    return { ok: false, kind: kindMap[result.kind], message: result.message };
+  }
+  const ext = result.mimeType === "image/jpeg" ? ".jpg" : ".png";
+  let dir;
+  try {
+    dir = mkdtempSync(join21(tmpdir2(), "pie-osc5522-"));
+    const path34 = join21(dir, formatPastedImageName(/* @__PURE__ */ new Date(), ext));
+    writeFileSync13(path34, result.bytes);
+    return {
+      ok: true,
+      path: path34,
+      mimeType: result.mimeType,
+      cleanup: () => {
+        try {
+          rmSync3(dir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    };
+  } catch (err) {
+    if (dir) {
+      try {
+        rmSync3(dir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    return { ok: false, kind: "failed", message: `Failed to materialize clipboard image: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+async function handleImagePaste(host, options = {}) {
+  if (pastingHosts.has(host)) {
+    host.showStatus("Still reading the clipboard\u2026");
+    return;
+  }
+  if (!host.mentionHandler) {
+    host.showStatus("File attachments are not available yet (still initializing).");
+    return;
+  }
+  pastingHosts.add(host);
+  const handler = host.mentionHandler;
+  const sessionId = host.sessionManager?.getActiveSessionId();
+  const controller = host.agentSessionController;
+  let invalidated = false;
+  const unsubscribe = controller?.subscribe((event) => {
+    if (event.type === "session_invalidated") invalidated = true;
+  });
+  const isCurrent = () => host.mentionHandler === handler && host.sessionManager?.getActiveSessionId() === sessionId && host.agentSessionController === controller && !invalidated;
+  const displayName = formatPastedImageName(options.now?.() ?? /* @__PURE__ */ new Date());
+  let pending;
+  try {
+    pending = handler.beginPendingAttachment(displayName);
+    let result;
+    const terminal = host.ui?.terminal;
+    const readTerminal = options.readTerminalClipboardImage ?? (terminal?.clipboard ? () => terminal.clipboard.readImage() : void 0);
+    if (readTerminal) {
+      host.showStatus("Reading clipboard via terminal\u2026");
+      const terminalResult = await readTerminal();
+      if (terminalResult.ok === true) {
+        result = terminalResultToClipboardResult(terminalResult);
+      } else if (terminalResult.kind === "unsupported") {
+        result = await (options.readClipboardImage ?? readClipboardImage)();
+      } else {
+        result = terminalResultToClipboardResult(terminalResult);
+      }
+    } else {
+      result = await (options.readClipboardImage ?? readClipboardImage)();
+    }
+    if (result.ok === false) {
+      switch (result.kind) {
+        case "no-image":
+          host.showStatus("Clipboard does not contain an image.");
+          break;
+        case "missing-tool":
+          host.showWarning(result.message);
+          break;
+        case "too-large":
+          host.showError(result.message);
+          break;
+        default:
+          host.showError(result.message);
+          break;
+      }
+      return;
+    }
+    try {
+      if (!isCurrent()) return;
+      await handler.attachLocalFile(result.path, displayName, pending.token, isCurrent);
+    } finally {
+      result.cleanup();
+    }
+  } catch (err) {
+    host.showError(`Paste failed: ${err instanceof Error ? err.message : String(err)}`);
+  } finally {
+    try {
+      pending?.finish();
+      if (isCurrent()) controller?.requestQueueDispatch?.();
+    } finally {
+      unsubscribe?.();
+      pastingHosts.delete(host);
+    }
+  }
+}
+
 // src/runtime/interactive-queue-ui.ts
 function updatePendingMessagesDisplay(host) {
   host.pendingMessagesContainer.clear();
@@ -79255,11 +80155,11 @@ function updatePendingMessagesDisplay(host) {
   const steerMessages = queuedInputs.filter((m2) => m2.mode === "steer");
   const followUpMessages = queuedInputs.filter((m2) => m2.mode === "followUp");
   for (const msg of steerMessages) {
-    const text = theme.fg("dim", `  [steer] ${truncate(msg.displayText, 50)}`);
+    const text = theme.fg("dim", `  [steer] ${truncate2(msg.displayText, 50)}`);
     host.pendingMessagesContainer.addChild(new Text(text, 1, 0));
   }
   for (const msg of followUpMessages) {
-    const text = theme.fg("dim", `  [followUp] ${truncate(msg.displayText, 50)}`);
+    const text = theme.fg("dim", `  [followUp] ${truncate2(msg.displayText, 50)}`);
     host.pendingMessagesContainer.addChild(new Text(text, 1, 0));
   }
   const dequeueHint = host.keybindings.getKeys("dequeue")[0] || "alt+up";
@@ -79368,7 +80268,7 @@ function handleSteer(host) {
     void host.editor.onSubmit(text);
   }
 }
-function truncate(text, maxLength) {
+function truncate2(text, maxLength) {
   if (text.length <= maxLength) return text;
   return text.slice(0, maxLength) + "...";
 }
@@ -79468,6 +80368,12 @@ var FooterComponent = class {
    *  derived from this at render time so long silent tool runs (e.g.
    *  subagents) still visibly tick — a moving elapsed says "alive". */
   busySince = null;
+  /** When the footer last started waiting for the user. Same derived-at-render
+   *  approach: the wait elapsed ticks only while a wait timer runs. */
+  waitingSince = null;
+  /** Animation timer for the waiting state (drives the wait elapsed ticker
+   *  in place of the stopped busy spinner). */
+  waitingTimer = null;
   /** Keyed ambient status slots for extensions (ctx.ui.setStatus). */
   extensionStatuses = new ExtensionStatusSlots();
   /** Set callback to request re-render when animation updates (pass true to force) */
@@ -79485,6 +80391,17 @@ var FooterComponent = class {
       this.busySince = null;
       this.stopSpinner();
     }
+    if (state.waitingForUser === true) {
+      if (this.waitingSince === null) this.waitingSince = performance.now();
+      this.startWaitingTimer();
+      this.stopSpinner();
+    } else if (state.waitingForUser === false) {
+      this.waitingSince = null;
+      this.stopWaitingTimer();
+      if (this.state.status === "thinking" || this.state.status === "processing") {
+        this.startSpinner();
+      }
+    }
   }
   setAutoCompactEnabled(enabled) {
     this.autoCompactEnabled = enabled;
@@ -79493,6 +80410,7 @@ var FooterComponent = class {
   }
   dispose() {
     this.stopSpinner();
+    this.stopWaitingTimer();
   }
   /** Start spinner animation */
   startSpinner() {
@@ -79510,6 +80428,20 @@ var FooterComponent = class {
       this.spinnerTimer = null;
     }
   }
+  /** Ticker for the waiting state: no spinner animation (nothing is
+   *  progressing), just a render tick so the wait elapsed updates. */
+  startWaitingTimer() {
+    if (this.waitingTimer) return;
+    this.waitingTimer = setInterval(() => {
+      this.onRequestRender?.();
+    }, SPINNER_INTERVAL);
+  }
+  stopWaitingTimer() {
+    if (this.waitingTimer) {
+      clearInterval(this.waitingTimer);
+      this.waitingTimer = null;
+    }
+  }
   /** Get current spinner character */
   getSpinner() {
     if (this.state.status !== "thinking" && this.state.status !== "processing") {
@@ -79584,23 +80516,27 @@ var FooterComponent = class {
       processing: "warning",
       error: "error"
     };
-    const spinner = this.getSpinner();
-    let statusText;
-    if (state.lifecycleEvent && state.status !== "ready") {
-      statusText = state.lifecycleEvent;
-    } else {
-      const statusDisplayMap = {
-        ready: "Ready",
-        thinking: "Thinking",
-        processing: "Processing",
-        error: "Error"
-      };
-      statusText = statusDisplayMap[state.status] || state.status;
-    }
-    const isBusy = state.status === "thinking" || state.status === "processing";
-    const busyElapsed = this.busySince !== null && isBusy ? ` \xB7 ${formatElapsed(performance.now() - this.busySince)}` : "";
-    const statusWithSpinner = `${spinner ? `${spinner} ` : ""}${statusText}${busyElapsed}`;
-    statsParts.push(theme.fg(statusColor[state.status], statusWithSpinner));
+    const isWaitingForUser2 = state.waitingForUser === true;
+    const waitingElapsed = this.waitingSince !== null && isWaitingForUser2 ? ` \xB7 ${formatElapsed(performance.now() - this.waitingSince)}` : "";
+    const statusWithSpinner = isWaitingForUser2 ? theme.fg("accent", `\u23F8 Waiting for you${waitingElapsed}`) : (() => {
+      const spinner = this.getSpinner();
+      let statusText;
+      if (state.lifecycleEvent && state.status !== "ready") {
+        statusText = state.lifecycleEvent;
+      } else {
+        const statusDisplayMap = {
+          ready: "Ready",
+          thinking: "Thinking",
+          processing: "Processing",
+          error: "Error"
+        };
+        statusText = statusDisplayMap[state.status] || state.status;
+      }
+      const isBusy = state.status === "thinking" || state.status === "processing";
+      const busyElapsed = this.busySince !== null && isBusy ? ` \xB7 ${formatElapsed(performance.now() - this.busySince)}` : "";
+      return theme.fg(statusColor[state.status], `${spinner ? `${spinner} ` : ""}${statusText}${busyElapsed}`);
+    })();
+    statsParts.push(statusWithSpinner);
     let statsLeft = statsParts.join(" ");
     statsLeft += this.extensionStatuses.format();
     const modelName = state.modelName || "no-model";
@@ -79731,8 +80667,8 @@ function calculateCliContextUsage(params) {
   };
 }
 function createCliAutoCompactDecision(params) {
-  const errorMessage4 = params.message?.role === "assistant" ? params.message.errorMessage : void 0;
-  if (errorMessage4 && params.isContextOverflowError(errorMessage4)) {
+  const errorMessage5 = params.message?.role === "assistant" ? params.message.errorMessage : void 0;
+  if (errorMessage5 && params.isContextOverflowError(errorMessage5)) {
     return { reason: "overflow", willRetry: true };
   }
   if (!params.autoCompactEnabled || params.contextWindow <= 0) {
@@ -79786,7 +80722,7 @@ async function createCliAutoCompactionResult(params) {
     systemPrompt: params.systemPrompt,
     signal: params.context.signal
   };
-  const summary = await createCompactionSummary(projectCliHostEnvelopes(params.context.messages, params.onProjection), compactOptions);
+  const summary = await createCompactionSummary(projectCliHostEnvelopes(params.context.messages, params.onProjection, params.envelopeRegistry), compactOptions);
   if (params.context.signal?.aborted) {
     return { aborted: true };
   }
@@ -79794,7 +80730,7 @@ async function createCliAutoCompactionResult(params) {
     summary,
     retainedTail,
     ...retainedTail.kind === "from-entry" ? { firstKeptEntryId: retainedTail.entryId } : {},
-    tokensBefore: calculateTotalTokens(params.context.messages)
+    tokensBefore: params.context.preparation?.inputTokens ?? calculateTotalTokens(projectCliHostEnvelopes(params.context.messages, void 0, params.envelopeRegistry))
   };
 }
 function stripStaleUsageBeforeCompaction(messages, latestCompactionTimestamp) {
@@ -79819,153 +80755,6 @@ function stripStaleUsageBeforeCompaction(messages, latestCompactionTimestamp) {
   });
 }
 
-// src/runtime/retry-policy.ts
-var TRANSIENT_NETWORK_ERROR_PATTERN = /sse stream aborted|sse stream closed before end|sse stream ended before response completed|responses stream ended without a terminal event|(?:read\s+)?ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|(?:read\s+|write\s+)?EPIPE|socket hang up|request timeout|websocket upgrade refused|websocket handshake|websocket connection failed|websocket transport failed|connection closed before opening|client network socket disconnected before secure TLS connection was established|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated/i;
-var TLS_VALIDATION_ERROR_PATTERN = /certificate (?:has )?expired|certificate is not yet valid|unable to verify (?:the first certificate|certificate)|unable to get (?:local )?issuer certificate|self[-_ ]signed cert(?:ificate)?|CERT_HAS_EXPIRED|SELF_SIGNED_CERT|does not match certificate's altnames|ERR_TLS_CERT_ALTNAME_INVALID/i;
-var PROVIDER_TRANSIENT_ERROR_PATTERN = /overloaded|rate.?limit|too many requests|\b429\b|\b500\b|\b502\b|\b503\b|\b504\b|service.?unavailable|server error|internal error|retry delay|quota (?:has been |is )?exhausted/i;
-var USER_ABORT_PATTERN = /request was aborted|local abort signal|user abort|user_interrupt|interrupted by user|esc pressed|ctrl\+c/i;
-var AUTH_CONFIG_PATTERN = /missing api key|invalid api key|api key.*invalid|unauthorized|\b401\b|\b403\b|forbidden|authentication failed|no configured model|no models? are configured/i;
-var QUOTA_EXHAUSTED_PATTERN = /insufficient[_ ]quota|exceeded[_ ]current[_ ]quota|exceeded your current quota|billing[_ ]hard[_ ]limit|insufficient[_ ]balance|credit balance is too low|\barrearage\b|余额不足|\b(?:account|monthly|billing) quota (?:has been |is )?exhausted/i;
-var INVALID_FILE_REFERENCE_PATTERN = /not the owner of this file|owner of this file|invalid_authentication_error/i;
-var INVALID_REQUEST_PATTERN = /bad request|\b400\b|invalid request|invalid schema|schema validation|invalid parameter|unsupported parameter|malformed/i;
-var CLI_RETRY_MAX_RETRIES = 3;
-var CLI_RETRY_BASE_DELAY_MS = 2e3;
-var CLI_TRANSIENT_NETWORK_MAX_RETRIES = 10;
-var CLI_RETRY_TOTAL_MAX_RETRIES = 12;
-var CLI_RETRY_MAX_DELAY_MS = 6e4;
-function isCliContextOverflowError(errorMessage4) {
-  return /context length exceeded|context_length_exceeded|maximum context length|maximum context size|too many tokens|input.*too long|prompt.*too long|context window|token limit exceeded|exceeds.{0,20}context/i.test(
-    errorMessage4
-  );
-}
-function createClassification(kind, message, overrides) {
-  return {
-    kind,
-    message,
-    retryable: false,
-    compactable: false,
-    userAbort: false,
-    terminal: true,
-    ...overrides
-  };
-}
-function classifyCliFailure(context) {
-  const errorMessage4 = typeof context === "string" ? context : context.errorMessage;
-  const structuredReplayClass = typeof context === "string" ? void 0 : context.message?.role === "assistant" ? context.message.replayClass : void 0;
-  if (isCliContextOverflowError(errorMessage4)) {
-    return createClassification("context_overflow", errorMessage4, {
-      compactable: true,
-      terminal: false
-    });
-  }
-  if (USER_ABORT_PATTERN.test(errorMessage4)) {
-    return createClassification("user_abort", errorMessage4, {
-      userAbort: true,
-      terminal: false
-    });
-  }
-  if (INVALID_FILE_REFERENCE_PATTERN.test(errorMessage4)) {
-    return createClassification("invalid_file_reference", errorMessage4);
-  }
-  if (AUTH_CONFIG_PATTERN.test(errorMessage4) || QUOTA_EXHAUSTED_PATTERN.test(errorMessage4)) {
-    return createClassification("auth_config", errorMessage4);
-  }
-  if (TLS_VALIDATION_ERROR_PATTERN.test(errorMessage4)) {
-    return createClassification("tls_config", errorMessage4, {
-      retryable: true,
-      terminal: false
-    });
-  }
-  if (structuredReplayClass === "stream_lost" || structuredReplayClass === "stream_lost_partial" || TRANSIENT_NETWORK_ERROR_PATTERN.test(errorMessage4)) {
-    return createClassification("transient_network", errorMessage4, {
-      retryable: true,
-      terminal: false
-    });
-  }
-  if (errorMessage4.includes(EMPTY_ASSISTANT_CONTENT_ERROR)) {
-    return createClassification("provider_transient", errorMessage4, {
-      retryable: true,
-      terminal: false
-    });
-  }
-  if (errorMessage4.includes(OPENAI_COMPAT_PROTOCOL_ERROR_CODE)) {
-    return createClassification("provider_transient", errorMessage4, {
-      retryable: true,
-      terminal: false
-    });
-  }
-  if (PROVIDER_TRANSIENT_ERROR_PATTERN.test(errorMessage4)) {
-    return createClassification("provider_transient", errorMessage4, {
-      retryable: true,
-      terminal: false
-    });
-  }
-  if (INVALID_REQUEST_PATTERN.test(errorMessage4)) {
-    return createClassification("invalid_request", errorMessage4);
-  }
-  return createClassification("unknown", errorMessage4);
-}
-function isCliRetryableError(errorMessage4) {
-  return classifyCliFailure(errorMessage4).retryable;
-}
-function getCliRetryBaseDelayMs() {
-  const override = process.env.PIE_TEST_CLI_RETRY_BASE_DELAY_MS;
-  if (!override) {
-    return CLI_RETRY_BASE_DELAY_MS;
-  }
-  const parsed = Number(override);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : CLI_RETRY_BASE_DELAY_MS;
-}
-function getCliTransientNetworkMaxRetries() {
-  const override = process.env.PIE_RETRY_TRANSIENT_NETWORK_MAX_RETRIES;
-  if (!override) {
-    return CLI_TRANSIENT_NETWORK_MAX_RETRIES;
-  }
-  const parsed = Number(override);
-  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : CLI_TRANSIENT_NETWORK_MAX_RETRIES;
-}
-function getCliRetryMaxDelayMs() {
-  const override = process.env.PIE_RETRY_MAX_DELAY_MS;
-  if (!override) {
-    return CLI_RETRY_MAX_DELAY_MS;
-  }
-  const parsed = Number(override);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : CLI_RETRY_MAX_DELAY_MS;
-}
-function getCliRetryTotalMaxRetries() {
-  const override = process.env.PIE_RETRY_TOTAL_MAX_RETRIES;
-  if (!override) {
-    return CLI_RETRY_TOTAL_MAX_RETRIES;
-  }
-  const parsed = Number(override);
-  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : CLI_RETRY_TOTAL_MAX_RETRIES;
-}
-function createCliRetryPolicy(isRetryableErrorOverride) {
-  return {
-    isRetryableError: isRetryableErrorOverride ?? isCliRetryableError,
-    maxRetries: CLI_RETRY_MAX_RETRIES,
-    baseDelayMs: getCliRetryBaseDelayMs(),
-    maxDelayMs: getCliRetryMaxDelayMs(),
-    maxRetriesForFailure: (failure) => failure.kind === "transient_network" ? getCliTransientNetworkMaxRetries() : failure.replayExempt === true ? getCliTimeoutReplayMaxRetries() : CLI_RETRY_MAX_RETRIES,
-    maxTotalRetries: getCliRetryTotalMaxRetries(),
-    systemicReplayStallLimit: getCliSystemicReplayStallLimit()
-  };
-}
-var CLI_TIMEOUT_REPLAY_MAX_RETRIES = 5;
-function getCliTimeoutReplayMaxRetries() {
-  const override = process.env.PIE_TIMEOUT_REPLAY_MAX_RETRIES;
-  if (!override) return CLI_TIMEOUT_REPLAY_MAX_RETRIES;
-  const parsed = Number(override);
-  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : CLI_TIMEOUT_REPLAY_MAX_RETRIES;
-}
-var CLI_SYSTEMIC_REPLAY_STALL_LIMIT = 3;
-function getCliSystemicReplayStallLimit() {
-  const override = process.env.PIE_SYSTEMIC_REPLAY_STALL_LIMIT;
-  if (!override) return CLI_SYSTEMIC_REPLAY_STALL_LIMIT;
-  const parsed = Number(override);
-  return Number.isFinite(parsed) && parsed >= 1 ? Math.floor(parsed) : CLI_SYSTEMIC_REPLAY_STALL_LIMIT;
-}
-
 // src/runtime/interactive-context-ui.ts
 function calculateContextUsage(host) {
   const messages = host.agent?.state.messages ?? [];
@@ -80142,23 +80931,23 @@ function setupAutocomplete(host) {
   };
   host.editor.setAutocompleteProvider(provider);
 }
-function isContextOverflowError(errorMessage4) {
-  return isCliContextOverflowError(errorMessage4);
+function isContextOverflowError(errorMessage5) {
+  return isCliContextOverflowError(errorMessage5);
 }
 function shouldAutoCompact(host, contextTokens, contextWindow) {
   if (!host.options.settingsManager.getAutoCompactEnabled()) return false;
   const reserveTokens = host.options.settingsManager.getAutoCompactReserveTokens();
   return shouldCliAutoCompactTokens({ tokens: contextTokens, contextWindow, reserveTokens });
 }
-function isRetryableError(errorMessage4) {
-  return isCliRetryableError(errorMessage4);
+function isRetryableError(errorMessage5) {
+  return isCliRetryableError(errorMessage5);
 }
-function isInvalidFileReferenceError(errorMessage4) {
+function isInvalidFileReferenceError(errorMessage5) {
   return /not the owner of this file|owner of this file|invalid_authentication_error/i.test(
-    errorMessage4
+    errorMessage5
   );
 }
-function recoverFromInvalidFileReferenceError(host, errorMessage4) {
+function recoverFromInvalidFileReferenceError(host, errorMessage5) {
   if (!host.fileManager || !host.agent) return;
   const messages = host.agent.state.messages.slice();
   const invalidFileIds = /* @__PURE__ */ new Set();
@@ -80176,7 +80965,7 @@ function recoverFromInvalidFileReferenceError(host, errorMessage4) {
   }
   if (invalidFileIds.size === 0) return;
   for (const fileId of invalidFileIds) {
-    host.fileManager.markFileReferenceError(fileId, errorMessage4);
+    host.fileManager.markFileReferenceError(fileId, errorMessage5);
   }
   let changed = false;
   const sanitizedMessages = messages.map((message) => {
@@ -80470,9 +81259,9 @@ function clearStatusLine(host) {
   }
   if (removed) host.ui.requestRender();
 }
-function showError(host, errorMessage4) {
+function showError(host, errorMessage5) {
   host.chatContainer.addChild(new Spacer(1));
-  host.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage4}`), 1, 0));
+  host.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage5}`), 1, 0));
   host.ui.requestRender();
 }
 async function executeCommand(host, command) {
@@ -80502,6 +81291,13 @@ function restoreEditor(host) {
   host.ui.invalidate();
   host.ui.requestRender();
 }
+function showMissingModelConfigurationNotice(host) {
+  const message = "No model configured. Add one in ~/.pie/models.json, then use /settings/model.";
+  host.chatContainer.addChild(new Spacer(1));
+  host.chatContainer.addChild(new Text(theme.fg("warning", `\u26A0 ${message}`), 1, 0));
+  host.chatContainer.addChild(new Spacer(1));
+  host.showStatus(message);
+}
 
 // src/runtime/interactive-continuation.ts
 function getContinuationTimeoutMs() {
@@ -80661,22 +81457,42 @@ function scheduleContinuationTimeout(host) {
 
 // src/runtime/interactive-controller-setup.ts
 async function prepareAgentTurn(host, context) {
+  let messages = context.messages;
+  if (context.source === "interactive" && context.streamingBehavior && host.tryBuildAttachmentContentFromExtensions) {
+    messages = await Promise.all(messages.map(async (message) => {
+      if (message.role !== "user") return message;
+      const blocks = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+      if (blocks.some((block) => block.type !== "text" && block.type !== "hostContext")) return message;
+      const content = [];
+      for (const block of blocks) {
+        if (block.type !== "text" || !/@\[[^\]]+\]\(file:/.test(block.text)) {
+          content.push(block);
+          continue;
+        }
+        const resolved = await host.tryBuildAttachmentContentFromExtensions(block.text);
+        if (resolved.handled && resolved.content.length) content.push(...resolved.content);
+        else content.push(block);
+        if (resolved.warnings.length) host.showStatus(resolved.warnings.join(" | "));
+      }
+      return { ...message, content };
+    }));
+  }
   if (!host.extensionRunner) {
-    return void 0;
+    return messages === context.messages ? void 0 : { messages };
   }
   const baseSystemPrompt = context.baseSystemPrompt ?? host.buildSystemPrompt();
   const result = await host.extensionRunner.emitBeforeAgentStart({
     type: "before_agent_start",
-    messages: context.messages,
+    messages,
     baseSystemPrompt,
     source: context.source
   });
   if (!result) {
-    return { systemPrompt: baseSystemPrompt };
+    return { systemPrompt: baseSystemPrompt, messages };
   }
   return {
     systemPrompt: result.systemPrompt ?? baseSystemPrompt,
-    messages: result.messages?.length ? [...context.messages, ...result.messages] : context.messages
+    messages: result.messages?.length ? [...messages, ...result.messages] : messages
   };
 }
 function createInteractiveAgentSessionController(host) {
@@ -80696,6 +81512,7 @@ function createInteractiveAgentSessionController(host) {
   let retryElapsedStartedAt = 0;
   let executionWork;
   let autoCompactBeforeStats = null;
+  let lastShownCompactionError = null;
   const attention = cliAttention(host);
   const stopRetryElapsedTicker = () => {
     if (retryElapsedTicker !== void 0) {
@@ -80749,9 +81566,10 @@ function createInteractiveAgentSessionController(host) {
     getAutoContinueMessage: () => host.getTodoAutoContinueMessage(),
     classifyFailure: (context) => classifyCliFailure(context),
     retry: createCliRetryPolicy(
-      (errorMessage4) => !host._isContextOverflowError(errorMessage4) && isCliRetryableError(errorMessage4)
+      (errorMessage5) => !host._isContextOverflowError(errorMessage5) && isCliRetryableError(errorMessage5)
     ),
     compaction: {
+      modelView: cliCompactionModelView,
       compact: async (context) => {
         const beforeCompact = await host.extensionRunner?.emitSessionBeforeCompact({
           type: "session:before_compact",
@@ -80902,7 +81720,10 @@ function createInteractiveAgentSessionController(host) {
         if (state.mode === "todo" && state.lifecycle === "paused" && state.steps.length > 0) {
           host.showStatus("Todo list preserved. Send 'continue' when you want to resume it.");
         }
-        host.showError(event.failure.message);
+        if (event.failure.message !== lastShownCompactionError) {
+          host.showError(event.failure.message);
+        }
+        lastShownCompactionError = null;
         host.setControllerBusy(false);
       } else if (event.type === "turn_cancelled") {
         const outcome = host.executionState.abort();
@@ -80946,14 +81767,17 @@ function createInteractiveAgentSessionController(host) {
           willRetry: event.willRetry
         });
       } else if (event.type === "auto_compaction_end") {
+        const stillRunning = host.agent.state.isStreaming;
         host.isCompacting = false;
-        host.isProcessing = false;
+        host.isProcessing = stillRunning;
+        if (stillRunning) host.setControllerBusy(true);
         host.setSubmitLock(false);
         if (event.errorMessage) {
           const prefix = event.reason === "overflow" ? "Context overflow recovery failed" : "Auto-compaction failed";
           host.showError(`${prefix}: ${event.errorMessage}`);
-          host.footer.setState({ status: "ready" });
-          host.setControllerBusy(false);
+          lastShownCompactionError = event.willRetry || stillRunning ? event.errorMessage : null;
+          host.footer.setState({ status: stillRunning ? "processing" : "ready" });
+          host.setControllerBusy(stillRunning);
           autoCompactBeforeStats = null;
           return;
         }
@@ -80969,7 +81793,7 @@ function createInteractiveAgentSessionController(host) {
         const contextWindow = host.options.model?.contextWindow ?? 0;
         const contextPercent = contextWindow > 0 && contextUsage.tokens !== null ? contextUsage.tokens / contextWindow * 100 : 0;
         host.footer.setState({
-          status: "ready",
+          status: stillRunning ? "processing" : "ready",
           lifecycleEvent: "auto_compact",
           inputTokens: contextUsage.input,
           outputTokens: contextUsage.output,
@@ -81212,8 +82036,8 @@ async function handleDirectBash(host, command) {
   outputContainer.addChild(new Spacer(1));
   host.chatContainer.addChild(outputContainer);
   host.ui.requestRender();
-  const { spawn: spawn2 } = await import("child_process");
-  const child = spawn2(shellCommand.file, shellCommand.args, {
+  const { spawn: spawn3 } = await import("child_process");
+  const child = spawn3(shellCommand.file, shellCommand.args, {
     cwd: process.cwd(),
     env: process.env
   });
@@ -81252,21 +82076,20 @@ async function handleDirectBash(host, command) {
 // src/extensions/interactive-extension-ui.ts
 function createInteractiveExtensionUIContext(host) {
   const interact = async (run) => {
-    const attention = cliAttention(host);
-    const request = attention.request("input-required");
+    const request = beginExtensionWaiting(host, "input-required");
     let resolution = "cancelled";
     try {
       const value = await run();
       resolution = interactionAttentionResolution({ value });
       return value;
     } finally {
-      attention.resolve(request, resolution);
+      endExtensionWaiting(host, request, resolution);
     }
   };
   return {
     notify: (message, type = "info", opts) => showExtensionNotification(host, message, type, opts),
     select: (title, options, opts) => interact(() => showExtensionSelector2(host, title, options, opts)),
-    confirm: async (title, message, opts) => await interact(() => showExtensionConfirm(host, title, message, opts)) === true,
+    confirm: async (title, message, opts) => (await interact(() => showExtensionConfirm(host, title, message, opts)))?.confirmed === true,
     input: (title, placeholder, opts) => interact(() => showExtensionInput(host, title, placeholder, opts)),
     editor: (title, prefill) => interact(() => showExtensionEditor(host, title, prefill)),
     custom: (factory, options) => interact(() => showExtensionCustom(host, factory, options)),
@@ -81282,23 +82105,13 @@ function createInteractiveExtensionUIContext(host) {
 }
 function installInteractiveInteractionHandler(host) {
   registerInteractionHandler(async (request) => {
-    const attention = cliAttention(host);
     let attentionRequest;
     const beginWaitingForUser = () => {
-      host.activeInteractionCount++;
-      host.setWaitingForUser(true);
-      host.footer.setState({ lifecycleEvent: "waiting_for_user_input" });
       const reason = interactionAttentionReason(request);
-      if (reason) attentionRequest = attention.request(reason, "id" in request ? request.id : void 0);
-      host.safeRequestRender();
+      attentionRequest = beginExtensionWaiting(host, reason, "id" in request ? request.id : void 0);
     };
-    const endWaitingForUser = () => {
-      host.activeInteractionCount = Math.max(0, host.activeInteractionCount - 1);
-      if (host.activeInteractionCount === 0) {
-        host.setWaitingForUser(false);
-      }
-      host.footer.setState({ lifecycleEvent: "\u25B6 resuming" });
-      host.safeRequestRender();
+    const endWaitingForUser = (resolution) => {
+      endExtensionWaiting(host, attentionRequest, resolution);
     };
     const withTimeout2 = async (createPromise) => {
       const controller = new AbortController();
@@ -81327,8 +82140,7 @@ function installInteractiveInteractionHandler(host) {
         resolution = interactionAttentionResolution(result);
         return result;
       } finally {
-        attention.resolve(attentionRequest, resolution);
-        endWaitingForUser();
+        endWaitingForUser(resolution);
       }
     };
     switch (request.type) {
@@ -81336,7 +82148,8 @@ function installInteractiveInteractionHandler(host) {
         showExtensionNotification(
           host,
           request.message,
-          request.level === "success" ? "info" : request.level
+          request.level === "success" ? "info" : request.level,
+          { markdown: request.markdown === true }
         );
         return { type: "notify", acknowledged: true };
       case "select_one": {
@@ -81365,15 +82178,28 @@ function installInteractiveInteractionHandler(host) {
           prompt: request.prompt,
           detail: request.detail
         });
-        const { value: confirmed, timedOut } = await waitForUser(
-          (signal) => showExtensionConfirm(host, request.prompt, request.detail ?? "", { signal })
+        const { value, timedOut } = await waitForUser(
+          (signal) => showExtensionConfirm(host, request.prompt, request.detail ?? "", {
+            signal,
+            options: request.options
+          })
         );
+        const confirmed = value?.confirmed;
+        const yoloGrantMs = value?.yoloGrantMs;
         host.logDebug("interaction:confirm:end", {
           id: request.id,
           confirmed,
+          yoloGrantMs,
           timedOut
         });
-        return { type: "confirm", id: request.id, confirmed: confirmed === true, timedOut, skipped: timedOut || confirmed === void 0 };
+        return {
+          type: "confirm",
+          id: request.id,
+          confirmed: confirmed === true,
+          timedOut,
+          skipped: timedOut || confirmed === void 0,
+          yoloGrantMs
+        };
       }
       case "text_input": {
         host.logDebug("interaction:text_input:start", {
@@ -81412,6 +82238,30 @@ function installInteractiveInteractionHandler(host) {
     }
   });
 }
+function beginExtensionWaiting(host, reason, id) {
+  host.activeInteractionCount++;
+  try {
+    host.setWaitingForUser(true);
+    host.footer.setState({ lifecycleEvent: "waiting_for_user_input", waitingForUser: true });
+    const attention = reason ? cliAttention(host).request(reason, id) : void 0;
+    host.safeRequestRender();
+    return attention;
+  } catch (error) {
+    host.activeInteractionCount = Math.max(0, host.activeInteractionCount - 1);
+    throw error;
+  }
+}
+function endExtensionWaiting(host, attentionRequest, resolution) {
+  host.activeInteractionCount = Math.max(0, host.activeInteractionCount - 1);
+  if (host.activeInteractionCount === 0) {
+    host.setWaitingForUser(false);
+    host.footer.setState({ lifecycleEvent: "\u25B6 resuming", waitingForUser: false });
+  } else {
+    host.footer.setState({ lifecycleEvent: "waiting_for_user_input", waitingForUser: true });
+  }
+  if (attentionRequest) cliAttention(host).resolve(attentionRequest, resolution);
+  host.safeRequestRender();
+}
 function showExtensionNotification(host, message, type = "info", opts) {
   const prefix = type === "error" ? "Error: " : type === "warning" ? "Warning: " : "";
   host.chatContainer.addChild(new Spacer(1));
@@ -81467,9 +82317,15 @@ function showExtensionSelector2(host, title, options, opts) {
   });
 }
 async function showExtensionConfirm(host, title, message, opts) {
+  const options = opts?.options?.length ? opts.options : ["Yes", "No"];
   const result = await showExtensionSelector2(host, `${title}
-${message}`, ["Yes", "No"], opts);
-  return result === void 0 ? void 0 : result === "Yes";
+${message}`, options, opts);
+  if (result === void 0) return void 0;
+  const yoloGrantMs = parseYoloGrantMs(options, result);
+  if (yoloGrantMs !== void 0) {
+    return { confirmed: true, yoloGrantMs };
+  }
+  return { confirmed: result === "Yes" };
 }
 function showExtensionInput(host, title, placeholder, opts) {
   return new Promise((resolve7) => {
@@ -82017,6 +82873,8 @@ var InteractiveMode = class {
   mentionPickerOptions = [];
   attachmentResolver;
   yoloMode = false;
+  yoloGrant = new YoloGrantTracker();
+  // time-boxed confirm-dialog grant ("Yolo (5 min)")
   pristineTools = [];
   // Pristine (extension-unwrapped) tool assembly: the mode-rebuild source.
   /** Calm mode: render only questions and answers (display-only; persisted). */
@@ -82108,16 +82966,9 @@ var InteractiveMode = class {
   hasConfiguredModel() {
     return Boolean(this.options.apiKey) && this.options.model?.provider !== "unconfigured";
   }
-  showMissingModelConfigurationNotice() {
-    const message = "No model configured. Add one in ~/.pie/models.json, then use /settings/model.";
-    this.chatContainer.addChild(new Spacer(1));
-    this.chatContainer.addChild(new Text(theme.fg("warning", `\u26A0 ${message}`), 1, 0));
-    this.chatContainer.addChild(new Spacer(1));
-    this.showStatus(message);
-  }
   ensureAgentPromptReady() {
     if (this.hasConfiguredModel()) return true;
-    this.showMissingModelConfigurationNotice();
+    showMissingModelConfigurationNotice(this.filePipelineHost);
     this.safeRequestRender();
     return false;
   }
@@ -82177,32 +83028,32 @@ var InteractiveMode = class {
   }
   getPolicyContext = () => ({
     mode: this.planModeEnabled ? "plan" : "normal",
-    yoloMode: this.yoloMode,
+    yoloMode: this.yoloMode || this.yoloGrant.isActive(),
     confirmationPolicy: "allow"
   });
   rebuildSkillAwareTools(sourceTools) {
     const preservedTools = sourceTools.filter(
       (tool) => !CLI_FILESYSTEM_TOOL_NAMES.includes(tool.name) && tool.name !== "bash" && tool.name !== "shell"
     );
-    const bashTool = createBashTool(this.options.cwd, { isYoloMode: () => this.yoloMode, getEnv: () => computerUseOwnerEnv(this.sessionManager.getActiveSessionId() || COMPUTER_USE_STANDALONE_OWNER, String(process.pid)) });
-    const fileSystemToolOptions = (allowlistedDirs) => ({
-      ...buildCliFileAccessOptions({
-        cwd: this.options.cwd,
-        configDir: this.options.configDir,
-        skills: this.skills,
-        allowlistedDirs
-      }),
+    const bashTool = createBashTool(this.options.cwd, {
+      isYoloMode: () => this.yoloMode || this.yoloGrant.isActive(),
+      getEnv: () => computerUseOwnerEnv(this.sessionManager.getActiveSessionId() || COMPUTER_USE_STANDALONE_OWNER, String(process.pid))
+    });
+    const fileSystemToolOptions = (allowlistedDirs) => buildInteractiveFilesystemToolOptions({
+      cwd: this.options.cwd,
       configDir: this.options.configDir,
       fileObservationState: this.options.fileObservationState,
+      skills: this.skills,
+      getActiveSessionId: () => this.sessionManager.getActiveSessionId(),
       getAgentModel: () => this.options.model,
-      getSessionId: () => this.sessionManager.getActiveSessionId() || void 0,
       resolveToolModel: (purpose) => this.options.modelRegistry.resolveToolModel(purpose, this.options.model),
-      getPolicyContext: () => ({
+      resolveToolModelCandidates: this.options.modelRegistry.resolveToolModelCandidates ? (purpose) => this.options.modelRegistry.resolveToolModelCandidates(purpose, this.options.model) : void 0,
+      getPlanPolicyContext: () => ({
         mode: this.planModeEnabled ? "plan" : "normal",
         yoloMode: this.yoloMode,
         confirmationPolicy: "allow"
       })
-    });
+    }, allowlistedDirs);
     const normalFsTools = createCliFileSystemTools(this.options.cwd, fileSystemToolOptions([this.options.configDir]));
     const currentFsTools = this.yoloMode ? createCliFileSystemTools(this.options.cwd, fileSystemToolOptions(["/"])) : normalFsTools;
     return {
@@ -82332,7 +83183,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-WFN4JWLE.js");
+    const { Agent } = await import("./chunks/src-XDNJ3PHL.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -82376,7 +83227,7 @@ var InteractiveMode = class {
     await this.initializeFileManager();
     this.syncSessionModelMetadata();
     if (!this.hasConfiguredModel()) {
-      this.showMissingModelConfigurationNotice();
+      showMissingModelConfigurationNotice(this.filePipelineHost);
     }
   }
   createExtensionContextForCommands() {
@@ -82421,6 +83272,11 @@ var InteractiveMode = class {
   async loadExtensions() {
     this.extensionUIContext = createInteractiveExtensionUIContext(this);
     installInteractiveInteractionHandler(this);
+    setYoloGrantListener((grantMs) => {
+      this.yoloGrant.award(grantMs);
+      renderYoloGrantBanner(grantMs, this.chatContainer);
+      this.ui.requestRender();
+    });
     await loadInteractiveExtensions(this.extensionLoaderHost);
   }
   /**
@@ -82504,20 +83360,20 @@ var InteractiveMode = class {
   setupAgentSubscription() {
     bindInteractiveRuntimeEvents(this.runtimeEventHost);
   }
-  _isContextOverflowError(errorMessage4) {
-    return isContextOverflowError(errorMessage4);
+  _isContextOverflowError(errorMessage5) {
+    return isContextOverflowError(errorMessage5);
   }
   _shouldAutoCompact(contextTokens, contextWindow) {
     return shouldAutoCompact(this.contextUiHost, contextTokens, contextWindow);
   }
-  _isRetryableError(errorMessage4) {
-    return isRetryableError(errorMessage4);
+  _isRetryableError(errorMessage5) {
+    return isRetryableError(errorMessage5);
   }
-  _isInvalidFileReferenceError(errorMessage4) {
-    return isInvalidFileReferenceError(errorMessage4);
+  _isInvalidFileReferenceError(errorMessage5) {
+    return isInvalidFileReferenceError(errorMessage5);
   }
-  _recoverFromInvalidFileReferenceError(errorMessage4) {
-    return recoverFromInvalidFileReferenceError(this.contextUiHost, errorMessage4);
+  _recoverFromInvalidFileReferenceError(errorMessage5) {
+    return recoverFromInvalidFileReferenceError(this.contextUiHost, errorMessage5);
   }
   async handleCompactCommand() {
     return handleCompactCommand(this.compactCommandHost);
@@ -82528,6 +83384,9 @@ var InteractiveMode = class {
   setupKeybindings() {
     return setupInteractiveKeybindings(this.keybindingsHost);
   }
+  handlePasteImage() {
+    void handleImagePaste(this);
+  }
   async selectMentionOption(option) {
     return selectMentionOption(this.filePipelineHost, option);
   }
@@ -82703,8 +83562,8 @@ var InteractiveMode = class {
   clearStatusLine() {
     return clearStatusLine(this.uiHelperHost);
   }
-  showError(errorMessage4) {
-    return showError(this.uiHelperHost, errorMessage4);
+  showError(errorMessage5) {
+    return showError(this.uiHelperHost, errorMessage5);
   }
   async handleDirectBash(command) {
     return handleDirectBash(this.directBashHost, command);
@@ -82755,8 +83614,8 @@ var InteractiveMode = class {
 };
 
 // src/app/runtime-composition.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync13 } from "fs";
-import { randomUUID } from "crypto";
+import { existsSync as existsSync19, mkdirSync as mkdirSync13 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
 import * as path31 from "path";
 var CliMissingApiKeyError = class extends Error {
   constructor(message) {
@@ -82783,7 +83642,7 @@ function getCliRuntimePaths() {
   return { configDir, sessionsDir, skillsDir, builtinSkillsDir };
 }
 function ensureCliRuntimePaths(paths = getCliRuntimePaths()) {
-  if (!existsSync18(paths.skillsDir)) {
+  if (!existsSync19(paths.skillsDir)) {
     mkdirSync13(paths.skillsDir, { recursive: true });
   }
   return paths;
@@ -82886,7 +83745,7 @@ async function composeCliRuntime(params) {
     await sessionManager.save();
   }
   const sessionId = sessionManager.getActiveSession()?.id;
-  const computerUseExecutionId = randomUUID();
+  const computerUseExecutionId = randomUUID2();
   const fileObservationState = createFileObservationState();
   if (sessionId) {
     if (process.env.PIE_DEBUG && !fileLogger.isEnabled()) {
@@ -82920,6 +83779,11 @@ async function composeCliRuntime(params) {
   });
   const fileSystemToolOptions = {
     ...buildCliFileAccessOptions({ cwd, configDir: paths.configDir, skills, allowlistedDirs: [paths.configDir] }),
+    // Must match interactive-mode's rebuild view byte-for-byte: the rebuilt
+    // tool surface replaces this composition-time set on the first mode
+    // toggle/skill reload, and any description drift there would invalidate
+    // the prompt-cache prefix exactly like the /yolo scope flip did.
+    descriptionAllowlistedDirs: [],
     configDir: paths.configDir,
     fileObservationState,
     getAgentModel: getCurrentModel,
@@ -83047,6 +83911,7 @@ function createPrintModeRetryStatusReporter() {
 // src/app/print-mode-compaction.ts
 function createPrintModeCompactionHandler(params) {
   return {
+    modelView: cliCompactionModelView,
     compact: async (context) => {
       const beforeCompact = await params.runner.emitSessionBeforeCompact({
         type: "session:before_compact",
@@ -83210,7 +84075,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-WFN4JWLE.js");
+  const { Agent: AgentClass } = await import("./chunks/src-XDNJ3PHL.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -83379,21 +84244,21 @@ async function runPrintMode(params) {
       console.log(assistantText);
     }
   } catch (err) {
-    const errorMessage4 = err instanceof Error ? err.message : String(err);
-    sessionTrace.noteStalled(errorMessage4, { mode: "print" });
+    const errorMessage5 = err instanceof Error ? err.message : String(err);
+    sessionTrace.noteStalled(errorMessage5, { mode: "print" });
     process.exitCode = 1;
     if (params.jsonOutput) {
       console.log(
         JSON.stringify({
           ok: false,
-          error: errorMessage4,
+          error: errorMessage5,
           sessionId: runtime.sessionManager.getActiveSession()?.id,
           provider: runtime.provider,
           modelId: runtime.modelId
         })
       );
     }
-    console.error("Error:", errorMessage4);
+    console.error("Error:", errorMessage5);
   }
   try {
     if (!params.rawOutput && !params.jsonOutput) console.log("");
@@ -83639,7 +84504,7 @@ async function loadJsonModeExtensions(params) {
     getRuntimeTools: () => params.getAgent()?.state.tools ?? [],
     resolveModelClass: (modelClass) => params.runtime.modelRegistry.resolveModelClass(modelClass),
     resolveModelRef: (modelRef) => params.runtime.modelRegistry.resolveModelRef(modelRef),
-    registerHostEnvelopeProjector: (projector) => registerExternalHostEnvelopeProjector(projector),
+    registerHostEnvelopeProjector: (projector) => registerExternalHostEnvelopeProjector(projector, params.envelopeRegistry),
     getMessages: () => params.getAgent()?.state.messages ?? [],
     getSessionMetadata: () => ({ ...params.runtime.sessionManager.getActiveSession()?.metadata ?? {} }),
     setSessionMetadata: (key, value) => {
@@ -83650,7 +84515,7 @@ async function loadJsonModeExtensions(params) {
     },
     yoloMode: false
   };
-  const { extensions } = await loadExtensions(
+  const { extensions, errors } = await loadExtensions(
     params.runtime.extensionPaths,
     params.runtime.cwd,
     uiContext,
@@ -83670,6 +84535,10 @@ async function loadJsonModeExtensions(params) {
     false
   );
   runner.setUIContext(uiContext);
+  if (errors.length) {
+    await runner.dispose("shutdown");
+    throw new Error(errors.map(({ path: path34, error }) => `${path34}: ${error}`).join("\n"));
+  }
   try {
     await restoreExtensionProviderCredentials(params.runtime.modelRegistry);
     const extensionTools = filterEnabledTools(convertExtensionTools(extensions), params.runtime.settingsManager);
@@ -83689,6 +84558,7 @@ async function runJsonEventsMode(params) {
   const sessionId = params.explicitSessionId || params.runtime?.sessionManager.getActiveSession()?.id || `pie-json-${Date.now()}`;
   let activeTurn = null;
   let runtime = params.runtime;
+  let envelopeRegistry = createCliHostEnvelopeRegistry();
   let agent;
   let controller;
   let disposeAgentSubscription;
@@ -83705,6 +84575,7 @@ async function runJsonEventsMode(params) {
   const completedSessionControlRequests = /* @__PURE__ */ new Map();
   const completedSidechatRequests = /* @__PURE__ */ new Map();
   const ensureRuntimeInFlight = /* @__PURE__ */ new Map();
+  let compositionChain = Promise.resolve();
   let runtimeClosing = false;
   let activeSidechat = null;
   let activeSidechatPromise = null;
@@ -83720,7 +84591,7 @@ async function runJsonEventsMode(params) {
     // Capability broadcast: the envelope kinds THIS build can project at
     // intake (embedded external kinds included), so embedders can probe
     // before their first turn instead of learning mismatches from failures.
-    capabilities: { hostContextKinds: cliHostEnvelopeKinds() }
+    capabilities: { hostContextKinds: cliHostEnvelopeKinds(envelopeRegistry) }
   });
   function trackSidechatPromise(promise) {
     activeSidechatPromise = promise;
@@ -83737,13 +84608,6 @@ async function runJsonEventsMode(params) {
   function delay(ms) {
     return new Promise((resolve7) => setTimeout(resolve7, Math.max(0, ms)));
   }
-  async function waitForActiveController(timeoutMs = 1e3) {
-    const deadline = Date.now() + timeoutMs;
-    while (!controller && activeTurn && !activeTurn.finalized && Date.now() < deadline) {
-      await delay(5);
-    }
-    return controller;
-  }
   function touch() {
     if (activeTurn) {
       activeTurn.lastActivityAt = Date.now();
@@ -84081,7 +84945,7 @@ async function runJsonEventsMode(params) {
       }
     };
     try {
-      await ensureRuntime();
+      await ensureRuntime(runtime?.cwd);
       const hostContextFailure = validateIntakeHostContext(message);
       if (hostContextFailure) {
         writeSidechatFailure(message, hostContextFailure.message, hostContextFailure.code);
@@ -84099,22 +84963,26 @@ async function runJsonEventsMode(params) {
         return;
       }
       const parent = agent;
-      const { Agent: AgentClass } = await import("./chunks/src-WFN4JWLE.js");
+      const sideRegistry = envelopeRegistry;
+      const sideTrace = trace;
+      const sideApiKey = runtime.apiKey;
+      const snapshot = structuredClone(parent.state.messages);
+      const { Agent: AgentClass } = await import("./chunks/src-XDNJ3PHL.js");
       const sideAgent = new AgentClass({
         initialState: {
           systemPrompt: parent.state.systemPrompt,
           model: parent.state.model,
           thinkingLevel: parent.state.thinkingLevel,
           tools: [],
-          messages: structuredClone(parent.state.messages)
+          messages: snapshot
         },
-        apiKey: runtime.apiKey,
+        apiKey: sideApiKey,
         // The sidechat snapshot clones the parent's stored history, including
         // persisted hostContext facts; project them like the main agent does.
-        transformContext: async (messages) => projectCliHostEnvelopes(messages, (outcome) => trace?.noteRuntimeEvent(
+        transformContext: async (messages) => projectCliHostEnvelopes(messages, (outcome) => sideTrace?.noteRuntimeEvent(
           outcome.degraded ? "host_envelope_degraded" : "host_envelope_projected",
           outcome.audit
-        )),
+        ), sideRegistry),
         // Same body-free transport timeline as the main agent: a sidechat is
         // an independent Responses request and previously had no record at all
         // when it stalled. `streamSimple` matches the host default when the
@@ -84170,6 +85038,7 @@ async function runJsonEventsMode(params) {
     const turn = activeTurn;
     if (!turn || turn.finalized) return;
     turn.finalized = true;
+    turn.releaseReady();
     const activeEntryId = activeHeadEntryId();
     const base = {
       sessionId: turn.sessionId,
@@ -84402,6 +85271,7 @@ async function runJsonEventsMode(params) {
       agent.releaseTransport();
     }
     agent = void 0;
+    envelopeRegistry = createCliHostEnvelopeRegistry();
     try {
       await runtime?.sessionManager.save();
     } catch {
@@ -84428,7 +85298,9 @@ async function runJsonEventsMode(params) {
     const effectiveCwd = requestedCwd ?? process.cwd();
     const inFlight = ensureRuntimeInFlight.get(effectiveCwd);
     if (inFlight) return inFlight;
-    const composed = composeRuntime(effectiveCwd);
+    const composed = compositionChain.then(() => composeRuntime(effectiveCwd));
+    compositionChain = composed.catch(() => {
+    });
     ensureRuntimeInFlight.set(effectiveCwd, composed);
     void composed.finally(() => ensureRuntimeInFlight.delete(effectiveCwd)).catch(() => {
     });
@@ -84459,14 +85331,16 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-WFN4JWLE.js");
+    const { Agent: AgentClass } = await import("./chunks/src-XDNJ3PHL.js");
     if (runtimeClosing) return;
-    const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
+    const compositionRegistry = createCliHostEnvelopeRegistry();
+    const jsonModeExtensions = await loadJsonModeExtensions({ runtime, envelopeRegistry: compositionRegistry, getAgent: () => agent });
     if (runtimeClosing) {
       await jsonModeExtensions.runner.dispose("shutdown");
       return;
     }
     extensionRunner = jsonModeExtensions.runner;
+    envelopeRegistry = compositionRegistry;
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
     const restoredApiKey = runtime.modelRegistry.getApiKey(runtime.model);
     if (restoredApiKey) runtime.apiKey = restoredApiKey;
@@ -84502,7 +85376,7 @@ async function runJsonEventsMode(params) {
       transformContext: async (messages) => projectCliHostEnvelopes(messages, (outcome) => trace?.noteRuntimeEvent(
         outcome.degraded ? "host_envelope_degraded" : "host_envelope_projected",
         outcome.audit
-      )),
+      ), compositionRegistry),
       // Body-free transport timeline for the main (JSON-events) agent.
       streamFn: createJsonEventsTransportStreamFn(params.streamFn)
     });
@@ -84538,8 +85412,10 @@ async function runJsonEventsMode(params) {
         reserveTokens: runtime.settingsManager.getAutoCompactReserveTokens()
       })),
       compaction: {
+        modelView: (message) => projectCliHostEnvelopes([message], void 0, compositionRegistry)[0],
         compact: async (context) => createCliAutoCompactionResult({
           context,
+          envelopeRegistry: compositionRegistry,
           model: runtime.model,
           apiKey: runtime.apiKey,
           systemPrompt: agent?.state.systemPrompt ?? baseSystemPrompt,
@@ -84647,7 +85523,7 @@ async function runJsonEventsMode(params) {
     return message.hostContext ? [message.hostContext, { type: "text", text: message.prompt }] : [{ type: "text", text: message.prompt }];
   }
   function validateIntakeHostContext(message) {
-    return message.hostContext ? intakeHostContextFailure(message.hostContext) : void 0;
+    return message.hostContext ? intakeHostContextFailure(message.hostContext, envelopeRegistry) : void 0;
   }
   async function runTurn(message) {
     if (isSessionMismatch(message)) {
@@ -84660,21 +85536,19 @@ async function runJsonEventsMode(params) {
       return;
     }
     if (activeTurn && !activeTurn.finalized) {
-      const queuedHostContextFailure = validateIntakeHostContext(message);
-      if (queuedHostContextFailure) {
-        writeEvent({
-          type: "turn.failed",
-          sessionId,
-          turnId: message.turnId,
-          error: queuedHostContextFailure.message,
-          ...queuedHostContextFailure.code === "host_context_unknown_projector" ? { hostContextKinds: cliHostEnvelopeKinds() } : {}
-        });
-        return;
-      }
-      await queueActiveTurnInput(message);
+      const owner = activeTurn;
+      owner.queue = owner.queue.then(() => queueActiveTurnInput(message, owner));
+      await owner.queue;
       return;
     }
+    let releaseReady;
+    const ready = new Promise((resolve7) => {
+      releaseReady = resolve7;
+    });
     activeTurn = {
+      ready,
+      releaseReady,
+      queue: Promise.resolve(),
       sessionId,
       turnId: message.turnId,
       prompt: message.prompt,
@@ -84695,7 +85569,7 @@ async function runJsonEventsMode(params) {
         finalize("failed", {
           code: mockHostContextFailure.code,
           message: mockHostContextFailure.message,
-          ...mockHostContextFailure.code === "host_context_unknown_projector" ? { hostContextKinds: cliHostEnvelopeKinds() } : {}
+          ...mockHostContextFailure.code === "host_context_unknown_projector" ? { hostContextKinds: cliHostEnvelopeKinds(envelopeRegistry) } : {}
         });
         if (activeTurn === turn) emitSettled(turn);
         if (activeTurn === turn) activeTurn = null;
@@ -84735,12 +85609,21 @@ async function runJsonEventsMode(params) {
       if (activeTurn === turn) activeTurn = null;
       return;
     }
+    if (activeTurn !== turn || turn.finalized || turn.interrupted) {
+      if (activeTurn === turn && !turn.finalized) finalize("cancelled", "user_interrupt");
+      turn.releaseReady();
+      if (activeTurn === turn) {
+        emitSettled(turn);
+        activeTurn = null;
+      }
+      return;
+    }
     const hostContextFailure = validateIntakeHostContext(message);
     if (hostContextFailure) {
       finalize("failed", {
         code: hostContextFailure.code,
         message: hostContextFailure.message,
-        ...hostContextFailure.code === "host_context_unknown_projector" ? { hostContextKinds: cliHostEnvelopeKinds() } : {}
+        ...hostContextFailure.code === "host_context_unknown_projector" ? { hostContextKinds: cliHostEnvelopeKinds(envelopeRegistry) } : {}
       });
       if (activeTurn === turn) emitSettled(turn);
       if (activeTurn === turn) activeTurn = null;
@@ -84780,7 +85663,9 @@ async function runJsonEventsMode(params) {
     try {
       trace?.notePendingUserText(message.prompt);
       trace?.noteDispatchStart({ mode: "json-events" });
-      await controller.prompt(promptInputFor(message), { source: "json-events" });
+      const dispatched = controller.prompt(promptInputFor(message), { source: "json-events" });
+      turn.releaseReady();
+      await dispatched;
       trace?.noteDispatchSettled({ mode: "json-events" });
       trace?.noteWaitForIdleStart({ mode: "json-events" });
       await controller.waitForSettled();
@@ -84818,7 +85703,7 @@ async function runJsonEventsMode(params) {
       if (activeTurn === turn) activeTurn = null;
     }
   }
-  async function queueActiveTurnInput(message) {
+  async function queueActiveTurnInput(message, owner) {
     if (!message.streamingBehavior) {
       writeEvent({
         type: "turn.failed",
@@ -84828,8 +85713,9 @@ async function runJsonEventsMode(params) {
       });
       return;
     }
-    const activeController = await waitForActiveController();
-    if (!activeController) {
+    await owner.ready;
+    const activeController = controller;
+    if (!activeController || activeTurn !== owner || owner.finalized || owner.interrupted || runtimeClosing) {
       writeEvent({
         type: "turn.failed",
         sessionId,
@@ -84838,6 +85724,17 @@ async function runJsonEventsMode(params) {
       });
       return;
     }
+    const failure = validateIntakeHostContext(message);
+    if (failure) {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: failure.message,
+        hostContextKinds: cliHostEnvelopeKinds(envelopeRegistry)
+      });
+      return;
+    }
     try {
       applyRuntimeSelection(message);
       trace?.notePendingUserText(message.prompt);
@@ -84856,7 +85753,7 @@ async function runJsonEventsMode(params) {
         sessionId,
         turnId: message.turnId,
         mode: message.streamingBehavior,
-        activeTurnId: activeTurn?.turnId
+        activeTurnId: owner.turnId
       });
     } catch (error) {
       writeEvent({
@@ -85121,7 +86018,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-GXZ7NT4H.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-LUUGOJMP.js")).createTestStreamFnFromSequenceEnv();
 }
 function resolveJsonEventsDetailFlag() {
   for (let index = 0; index < process.argv.length; index += 1) {