@cydm/pie 2.7.11 → 2.7.13

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,11 +23,13 @@ import {
   getSessionsDir,
   getSettingsPath,
   getThemesDir,
+  isCliContextOverflowError,
+  isCliRetryableError,
   logTransportLifecycle,
   migrateConfigFromAgentDir,
   setYoloGrantListener,
   truncateHeadTail
-} from "./chunks/chunk-3NFKVBGY.js";
+} from "./chunks/chunk-D7RMNFVM.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-WLFOBECN.js";
@@ -89,17 +94,15 @@ import {
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState,
   verifyPreparedCompactionCommit
-} from "./chunks/chunk-XIRBNP2S.js";
-import "./chunks/chunk-XVF6V6Q5.js";
+} from "./chunks/chunk-CIFC6QVB.js";
+import "./chunks/chunk-HGUYS5SF.js";
 import {
   Deref,
-  EMPTY_ASSISTANT_CONTENT_ERROR,
   Errors,
   ExtendsUndefinedCheck,
   HasTransform,
   Hash,
   MODEL_CLASS_FALLBACK_ORDER,
-  OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
   TransformDecode,
   TransformDecodeCheckError,
   TransformEncode,
@@ -115,7 +118,7 @@ import {
   sortToolModelCandidatesByCapability,
   streamSimple,
   type_exports
-} from "./chunks/chunk-3VEIP2VY.js";
+} from "./chunks/chunk-R46YPPTU.js";
 import {
   IsArray,
   IsBigInt,
@@ -1937,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;
@@ -2241,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 */
@@ -52608,18 +52611,18 @@ function validateRemoteModel(profileId, model) {
   validateWebSearchCapability(model.webSearch, `Remote profile "${profileId}" model "${model.id}" webSearch`);
   validateFileCapabilities(model.fileCapabilities, `Remote profile "${profileId}" model "${model.id}" fileCapabilities`);
 }
-function assertHeadersShape(headers, label) {
-  if (headers === void 0) return;
-  if (!isPlainRecord(headers)) throw new Error(`${label} headers must be an object`);
-  for (const [name, value] of Object.entries(headers)) {
+function assertHeadersShape(headers2, label) {
+  if (headers2 === void 0) return;
+  if (!isPlainRecord(headers2)) throw new Error(`${label} headers must be an object`);
+  for (const [name, value] of Object.entries(headers2)) {
     if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) throw new Error(`${label} header name ${name || "(empty)"} is invalid`);
     if (typeof value !== "string") throw new Error(`${label} header ${name} must be a string`);
     if (/[\0-\x08\x0A-\x1F\x7F]/.test(value)) throw new Error(`${label} header ${name} contains an invalid control character`);
   }
 }
-function assertRemoteHeadersSafe(headers, label) {
-  assertHeadersShape(headers, label);
-  for (const name of Object.keys(headers || {})) {
+function assertRemoteHeadersSafe(headers2, label) {
+  assertHeadersShape(headers2, label);
+  for (const name of Object.keys(headers2 || {})) {
     if (/(?:authorization|cookie|api[-_]?key|token|secret|credential)/i.test(name)) {
       throw new Error(`${label} must not provide credential-bearing header ${name}`);
     }
@@ -53249,10 +53252,10 @@ var ModelRegistry = class {
       let payload = cached?.payload;
       let response;
       try {
-        const headers = { Authorization: `Bearer ${apiKey}` };
-        if (cached?.etag) headers["If-None-Match"] = cached.etag;
+        const headers2 = { Authorization: `Bearer ${apiKey}` };
+        if (cached?.etag) headers2["If-None-Match"] = cached.etag;
         response = await fetch(url, {
-          headers,
+          headers: headers2,
           redirect: "manual",
           signal: AbortSignal.timeout(3e3)
         });
@@ -58062,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 = {
@@ -58256,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) {
@@ -58267,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":
@@ -63652,9 +63659,38 @@ var Spacer = class {
 
 // ../../packages/tui/src/stdin-buffer.ts
 import { EventEmitter } from "events";
+
+// ../../packages/tui/src/clipboard-framing.ts
+var headers = [
+  { kind: "osc", prefix: "\x1B]5522" },
+  { kind: "csi", prefix: "\x1B[?5522" }
+];
+function clipboardFrameEnd(data, kind) {
+  const match = kind === "osc" ? /\x07|\x1b\\/.exec(data) : /[\x40-\x7e]/.exec(data);
+  return match ? match.index + match[0].length : void 0;
+}
+function classifyClipboardFragment(data, pending = false) {
+  if (!data) return void 0;
+  for (const { kind, prefix } of headers) {
+    if (prefix.startsWith(data)) {
+      const ambiguous = data === "\x1B" || data === "\x1B[";
+      if (!ambiguous || pending) return { kind, valid: false };
+    } else if (data.startsWith(prefix)) {
+      const end = clipboardFrameEnd(data.slice(2), kind);
+      const length = end === void 0 ? void 0 : end + 2;
+      const frame = length === void 0 ? data : data.slice(0, length);
+      const valid = kind === "osc" ? frame.startsWith(`${prefix};`) : /^\x1b\[\?5522;[0-4]\$y$/.test(frame);
+      return { kind, length, valid };
+    }
+  }
+  return void 0;
+}
+
+// ../../packages/tui/src/stdin-buffer.ts
 var ESC = "\x1B";
 var BRACKETED_PASTE_START = "\x1B[200~";
 var BRACKETED_PASTE_END = "\x1B[201~";
+var OSC_5522_MAX_FRAME = 70 * 1024 * 1024;
 function isCompleteSequence(data) {
   if (!data.startsWith(ESC)) {
     return "not-escape";
@@ -63741,11 +63777,32 @@ function isCompleteApcSequence(data) {
   }
   return "incomplete";
 }
-function extractCompleteSequences(buffer) {
+function extractCompleteSequences(buffer, maxClipboardFrame = OSC_5522_MAX_FRAME, pending = false) {
   const sequences = [];
   let pos = 0;
   while (pos < buffer.length) {
     const remaining = buffer.slice(pos);
+    const clipboard = classifyClipboardFragment(remaining, pending);
+    if (clipboard) {
+      if (clipboard.length === void 0) return { sequences, remainder: remaining };
+      if (clipboard.valid && clipboard.length <= Math.min(maxClipboardFrame, clipboard.kind === "csi" ? 64 : Infinity)) {
+        sequences.push(remaining.slice(0, clipboard.length));
+      }
+      pos += clipboard.length;
+      continue;
+    }
+    if (remaining.startsWith(BRACKETED_PASTE_START)) {
+      sequences.push(BRACKETED_PASTE_START);
+      return { sequences, remainder: remaining.slice(BRACKETED_PASTE_START.length) };
+    }
+    if (remaining.startsWith(`${ESC}]`)) {
+      const end = /\x07|\x1b\\/.exec(remaining);
+      if (!end) return { sequences, remainder: remaining };
+      const length = end.index + end[0].length;
+      sequences.push(remaining.slice(0, length));
+      pos += length;
+      continue;
+    }
     if (remaining.startsWith(ESC)) {
       let seqEnd = 1;
       while (seqEnd <= remaining.length) {
@@ -63779,9 +63836,14 @@ var StdinBuffer = class extends EventEmitter {
   timeoutMs;
   pasteMode = false;
   pasteBuffer = "";
+  discardingClipboard;
+  clipboardStarted = 0;
+  discardEsc = false;
+  options;
   constructor(options = {}) {
     super();
     this.timeoutMs = options.timeout ?? 10;
+    this.options = options;
   }
   process(data) {
     if (this.timeout) {
@@ -63803,6 +63865,28 @@ var StdinBuffer = class extends EventEmitter {
       this.emit("data", "");
       return;
     }
+    if (this.discardingClipboard) {
+      const kind = this.discardingClipboard;
+      const heldEscape = this.discardEsc;
+      const discarded = (heldEscape ? ESC : "") + str2;
+      const end = clipboardFrameEnd(discarded, kind);
+      const escape = discarded.indexOf(ESC, heldEscape && str2.startsWith(ESC) ? 1 : 0);
+      const resync = escape >= 0 && escape + 1 < discarded.length && (end === void 0 || escape < end - 1) && !(kind === "osc" && end !== void 0 && escape === end - 2 && discarded.startsWith(`${ESC}\\`, escape));
+      if (resync) {
+        this.discardingClipboard = void 0;
+        this.discardEsc = false;
+        str2 = discarded.slice(escape);
+      } else {
+        if (!end) {
+          this.discardEsc = discarded.endsWith(ESC);
+          this.scheduleDiscardRecovery();
+          return;
+        }
+        this.discardingClipboard = void 0;
+        this.discardEsc = false;
+        str2 = discarded.slice(end);
+      }
+    }
     this.buffer += str2;
     if (this.pasteMode) {
       this.pasteBuffer += this.buffer;
@@ -63820,16 +63904,13 @@ var StdinBuffer = class extends EventEmitter {
       }
       return;
     }
-    const startIndex = this.buffer.indexOf(BRACKETED_PASTE_START);
-    if (startIndex !== -1) {
-      if (startIndex > 0) {
-        const beforePaste = this.buffer.slice(0, startIndex);
-        const result2 = extractCompleteSequences(beforePaste);
-        for (const sequence of result2.sequences) {
-          this.emit("data", sequence);
-        }
-      }
-      this.buffer = this.buffer.slice(startIndex + BRACKETED_PASTE_START.length);
+    const result = extractCompleteSequences(this.buffer, this.options.clipboardMaxFrame, this.options.clipboardResponsePending?.());
+    if (result.remainder.length < this.buffer.length) this.clipboardStarted = 0;
+    this.buffer = result.remainder;
+    for (const sequence of result.sequences) {
+      if (sequence !== BRACKETED_PASTE_START) this.emit("data", sequence);
+    }
+    if (result.sequences.at(-1) === BRACKETED_PASTE_START) {
       this.pasteMode = true;
       this.pasteBuffer = this.buffer;
       this.buffer = "";
@@ -63846,12 +63927,29 @@ var StdinBuffer = class extends EventEmitter {
       }
       return;
     }
-    const result = extractCompleteSequences(this.buffer);
-    this.buffer = result.remainder;
-    for (const sequence of result.sequences) {
-      this.emit("data", sequence);
-    }
     if (this.buffer.length > 0) {
+      const fragment = classifyClipboardFragment(this.buffer, this.options.clipboardResponsePending?.());
+      if (fragment) {
+        this.clipboardStarted ||= Date.now();
+        const limit = Math.min(this.options.clipboardMaxFrame ?? OSC_5522_MAX_FRAME, fragment.kind === "csi" ? 64 : Infinity);
+        if (this.buffer.length > limit) {
+          this.discardClipboard(fragment.kind);
+          return;
+        }
+        const deadline = Math.min(
+          this.options.clipboardFrameTimeout ?? 1e3,
+          (this.options.clipboardFrameMaxDuration ?? 1e4) - (Date.now() - this.clipboardStarted)
+        );
+        this.timeout = setTimeout(() => {
+          if (this.buffer === ESC) {
+            this.buffer = "";
+            this.clipboardStarted = 0;
+            this.emit("data", ESC);
+          } else this.discardClipboard(fragment.kind);
+        }, Math.max(0, deadline));
+        return;
+      }
+      this.clipboardStarted = 0;
       this.timeout = setTimeout(() => {
         const flushed = this.flush();
         for (const sequence of flushed) {
@@ -63860,6 +63958,19 @@ var StdinBuffer = class extends EventEmitter {
       }, this.timeoutMs);
     }
   }
+  scheduleDiscardRecovery() {
+    this.timeout = setTimeout(() => {
+      this.discardingClipboard = void 0;
+      this.discardEsc = false;
+    }, this.options.clipboardFrameTimeout ?? 1e3);
+  }
+  discardClipboard(kind) {
+    this.discardEsc = this.buffer.endsWith(ESC);
+    this.buffer = "";
+    this.clipboardStarted = 0;
+    this.discardingClipboard = kind;
+    this.scheduleDiscardRecovery();
+  }
   flush() {
     if (this.timeout) {
       clearTimeout(this.timeout);
@@ -63868,7 +63979,13 @@ var StdinBuffer = class extends EventEmitter {
     if (this.buffer.length === 0) {
       return [];
     }
+    const fragment = classifyClipboardFragment(this.buffer, this.options.clipboardResponsePending?.());
+    if (fragment && this.buffer !== ESC) {
+      this.discardClipboard(fragment.kind);
+      return [];
+    }
     const sequences = [this.buffer];
+    this.clipboardStarted = 0;
     this.buffer = "";
     return sequences;
   }
@@ -63880,6 +63997,9 @@ var StdinBuffer = class extends EventEmitter {
     this.buffer = "";
     this.pasteMode = false;
     this.pasteBuffer = "";
+    this.clipboardStarted = 0;
+    this.discardingClipboard = void 0;
+    this.discardEsc = false;
   }
   getBuffer() {
     return this.buffer;
@@ -63892,8 +64012,196 @@ 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
+import { randomBytes as randomBytes2 } from "node:crypto";
+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 data.startsWith(`${OSC}5522;`);
+    const fields = parseMetadata(packet.metadata);
+    const type = fields.get("type") ?? "";
+    if (!type.startsWith("read")) return true;
+    const status = fields.get("status");
+    const session = this.session;
+    if (!session) return true;
+    if (fields.get("id") !== session.id) 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 = {
+      id: `pie-${randomBytes2(8).toString("hex")}`,
+      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;id=${session.id}: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;
@@ -63935,9 +64243,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) {
@@ -64196,11 +64507,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
@@ -64948,7 +65262,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: [],
@@ -65102,32 +65416,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";
@@ -65147,7 +65435,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 {
@@ -66034,8 +66322,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"))
@@ -66072,23 +66360,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;
 }
@@ -66115,7 +66403,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}`);
   }
@@ -66235,7 +66523,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;
   }
@@ -66436,7 +66724,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|$)/);
@@ -66460,8 +66748,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;
@@ -66486,7 +66774,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();
@@ -66501,7 +66789,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");
@@ -66533,7 +66821,7 @@ function loadSkillsFromDir(dir, source) {
           content,
           filePath: entryPath,
           source,
-          baseDir: path13.dirname(entryPath)
+          baseDir: path12.dirname(entryPath)
         });
       } catch (e) {
         diagnostics.push({
@@ -66547,18 +66835,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);
@@ -66732,7 +67020,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
@@ -66760,7 +67048,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 = {
@@ -66897,7 +67185,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);
@@ -66959,7 +67247,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":
@@ -67122,7 +67410,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";
@@ -67187,7 +67475,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}`,
       {
@@ -67423,7 +67711,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;
@@ -67449,7 +67737,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) {
@@ -67575,7 +67863,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";
@@ -67592,12 +67880,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
@@ -67692,7 +67980,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) {
@@ -67713,13 +68001,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;
 }
@@ -67747,8 +68035,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();
@@ -67814,15 +68102,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);
@@ -67884,7 +68172,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;
@@ -67964,7 +68252,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(),
@@ -68012,7 +68300,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);
     }
@@ -68028,7 +68316,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);
       }
@@ -68083,11 +68371,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;
     }
@@ -68127,7 +68415,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 {
@@ -68141,7 +68429,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();
@@ -68487,7 +68775,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);
@@ -68499,7 +68787,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";
@@ -68603,7 +68891,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",
@@ -68665,9 +68953,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,
@@ -68685,7 +68973,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 });
@@ -68704,7 +68992,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,
@@ -68728,7 +69016,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,
@@ -68903,8 +69191,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(
@@ -68915,7 +69203,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;
@@ -68962,7 +69250,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 */,
@@ -68992,7 +69280,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 */,
@@ -69082,7 +69370,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) {
@@ -69099,9 +69387,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);
@@ -69122,7 +69410,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) {
@@ -69172,9 +69460,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(
@@ -69466,7 +69754,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":
@@ -69648,7 +69936,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;
@@ -69689,7 +69977,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);
@@ -69738,8 +70026,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":
@@ -69779,7 +70067,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");
@@ -69818,7 +70106,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 });
@@ -69841,8 +70129,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") {
@@ -70012,18 +70300,74 @@ 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;
   }
+  remainingMs(now = Date.now()) {
+    return Math.max(0, this.untilMs - now);
+  }
   award(grantMs, now = Date.now()) {
     this.untilMs = now + Math.max(0, grantMs);
   }
   expire() {
     this.untilMs = 0;
   }
+  /** Revoke the active grant and report whether revocation changed live state. */
+  revoke() {
+    const wasActive = this.isActive();
+    this.expire();
+    return wasActive;
+  }
   /** Expiry timestamp (0 when no grant is held); useful for display. */
   get until() {
     return this.untilMs;
@@ -76298,7 +76642,9 @@ async function handleCalmCommand(host, args) {
 async function handleYoloCommand(host, args) {
   const mode = (args || "").trim().toLowerCase();
   if (mode === "status") {
-    host.showStatus(`YOLO mode is ${host.yoloMode ? "on" : "off"}`);
+    const persistent = `YOLO mode is ${host.yoloMode ? "on" : "off"}`;
+    const grantRemaining = host.getYoloGrantRemainingMs();
+    host.showStatus(grantRemaining > 0 ? `${persistent}; temporary high-risk shell grant active for ${Math.max(1, Math.ceil(grantRemaining / 6e4))} more min` : persistent);
     return;
   }
   if (mode && !["on", "off", "enable", "enabled", "disable", "disabled", "true", "false", "1", "0"].includes(mode)) {
@@ -76306,9 +76652,10 @@ async function handleYoloCommand(host, args) {
     return;
   }
   const nextYoloMode = mode ? ["on", "enable", "enabled", "true", "1"].includes(mode) : !host.yoloMode;
+  const revokedGrant = nextYoloMode ? false : host.revokeYoloGrant();
   if (host.yoloMode === nextYoloMode) {
     host.footer.setState({ yoloMode: host.yoloMode });
-    host.showStatus(`YOLO mode already ${host.yoloMode ? "on" : "off"}`);
+    host.showStatus(`YOLO mode already ${host.yoloMode ? "on" : "off"}${revokedGrant ? "; temporary grant revoked" : ""}`);
     return;
   }
   host.yoloMode = nextYoloMode;
@@ -76326,6 +76673,7 @@ async function handleYoloCommand(host, args) {
     host.chatContainer.addChild(new Spacer(1));
     host.chatContainer.addChild(new Text(theme.fg("accent", "\u2713 YOLO mode disabled"), 1, 0));
     host.chatContainer.addChild(new Text(theme.fg("dim", "  Sandbox directory restrictions restored."), 1, 0));
+    if (revokedGrant) host.chatContainer.addChild(new Text(theme.fg("dim", "  Temporary high-risk shell grant revoked."), 1, 0));
     host.chatContainer.addChild(new Spacer(1));
   }
   host.ui.requestRender();
@@ -77106,35 +77454,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,
@@ -77143,12 +77496,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 {
@@ -77163,8 +77516,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;
 }
 
@@ -77196,13 +77549,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,
@@ -78420,6 +78774,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;
@@ -78513,75 +78868,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.");
     }
@@ -78589,6 +78880,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
    */
@@ -79271,6 +79666,9 @@ async function selectMentionOption(host, option) {
 }
 
 // src/input/interactive-keybindings.ts
+function mainEditorOwnsInput(host) {
+  return host.editor.focused === true && host.editorContainer.children.includes(host.editor) && !host.ui.hasOverlay() && !host.mentionPickerComponent;
+}
 function setupInteractiveKeybindings(host) {
   host.ui.addInputListener((data) => {
     if (isKeyRelease(data)) {
@@ -79328,6 +79726,10 @@ function setupInteractiveKeybindings(host) {
       host.handleInterrupt();
       return { consume: true };
     }
+    if (host.keybindings.matches(data, "pasteImage") && mainEditorOwnsInput(host)) {
+      host.handlePasteImage();
+      return { consume: true };
+    }
     if (host.keybindings.matches(data, "expandTools")) {
       host.toggleToolsExpansion();
       return { consume: true };
@@ -79348,6 +79750,513 @@ function setupInteractiveKeybindings(host) {
   });
 }
 
+// src/clipboard/read-clipboard-image.ts
+import { spawn as spawn2 } from "node:child_process";
+import { chmodSync as chmodSync2, closeSync as closeSync4, existsSync as existsSync18, fchmodSync, mkdtempSync, openSync as openSync4, readFileSync as readFileSync17, rmdirSync, statSync as statSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { 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 } });
+    });
+  });
+}
+var TempImageResources = class {
+  constructor(injectedPath) {
+    this.injectedPath = injectedPath;
+  }
+  injectedPath;
+  directory;
+  files = /* @__PURE__ */ new Set();
+  create = (ext) => {
+    if (!this.injectedPath && !this.directory) {
+      this.directory = mkdtempSync(join20(tmpdir(), "pie-clipboard-"));
+      if (process.platform !== "win32") chmodSync2(this.directory, 448);
+    }
+    const path34 = this.injectedPath ? this.injectedPath(ext) : join20(this.directory, `image${ext}`);
+    const fd = openSync4(path34, "wx", 384);
+    this.files.add(path34);
+    try {
+      if (process.platform !== "win32") fchmodSync(fd, 384);
+    } finally {
+      closeSync4(fd);
+    }
+    return path34;
+  };
+  cleanup = () => {
+    for (const path34 of this.files) {
+      try {
+        unlinkSync8(path34);
+        this.files.delete(path34);
+      } catch (err) {
+        if (err.code === "ENOENT") this.files.delete(path34);
+      }
+    }
+    if (this.directory) {
+      try {
+        rmdirSync(this.directory);
+        this.directory = void 0;
+      } catch (err) {
+        if (err.code === "ENOENT") this.directory = void 0;
+      }
+    }
+  };
+};
+async function readClipboardImage(deps = {}) {
+  const platform2 = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const spawnImpl = deps.spawnImpl ?? defaultSpawnFn;
+  const resources = new TempImageResources(deps.mkTempPath);
+  let retained = false;
+  try {
+    const result = await readPlatformClipboard(platform2, env, spawnImpl, resources.create);
+    if (result.ok === true) {
+      retained = true;
+      return { ...result, cleanup: resources.cleanup };
+    }
+    return result;
+  } catch (err) {
+    return { ok: false, kind: "failed", message: `Failed to read clipboard image: ${errorMessage4(err)}` };
+  } finally {
+    if (!retained) resources.cleanup();
+  }
+}
+async function readPlatformClipboard(platform2, env, spawnImpl, mkTempPath) {
+  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, { flag: "r+", mode: 384 });
+  } catch (err) {
+    return { ok: false, kind: "failed", message: `Failed to write temp image: ${errorMessage4(err)}` };
+  }
+  return {
+    ok: true,
+    path: targetPath,
+    mimeType
+  };
+}
+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) {
+      return { ok: false, kind: "no-image", message: "Clipboard does not contain an image." };
+    }
+    if (size > MAX_IMAGE_BYTES) {
+      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) {
+    return { ok: false, kind: "no-image", message: "Clipboard does not contain a supported image (PNG/JPEG)." };
+  }
+  return { ok: true, path: path34, mimeType: detected };
+}
+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 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 as mkdtempSync2, 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 = mkdtempSync2(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();
@@ -79359,11 +80268,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";
@@ -79472,7 +80381,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) + "...";
 }
@@ -79572,6 +80481,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) */
@@ -79589,6 +80504,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;
@@ -79597,6 +80523,7 @@ var FooterComponent = class {
   }
   dispose() {
     this.stopSpinner();
+    this.stopWaitingTimer();
   }
   /** Start spinner animation */
   startSpinner() {
@@ -79614,6 +80541,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") {
@@ -79688,23 +80629,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";
@@ -79835,8 +80780,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) {
@@ -79890,7 +80835,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 };
   }
@@ -79898,7 +80843,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) {
@@ -79923,153 +80868,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 ?? [];
@@ -80246,23 +81044,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();
@@ -80280,7 +81078,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) => {
@@ -80574,9 +81372,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) {
@@ -80772,22 +81570,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) {
@@ -80807,6 +81625,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) {
@@ -80860,9 +81679,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",
@@ -81013,7 +81833,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();
@@ -81057,14 +81880,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;
         }
@@ -81080,7 +81906,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,
@@ -81323,8 +82149,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
   });
@@ -81363,15 +82189,14 @@ 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 {
@@ -81393,23 +82218,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();
@@ -81438,8 +82253,7 @@ function installInteractiveInteractionHandler(host) {
         resolution = interactionAttentionResolution(result);
         return result;
       } finally {
-        attention.resolve(attentionRequest, resolution);
-        endWaitingForUser();
+        endWaitingForUser(resolution);
       }
     };
     switch (request.type) {
@@ -81447,7 +82261,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": {
@@ -81536,6 +82351,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));
@@ -82300,6 +83139,12 @@ var InteractiveMode = class {
   get controllerSetupHost() {
     return this;
   }
+  getYoloGrantRemainingMs() {
+    return this.yoloGrant.remainingMs();
+  }
+  revokeYoloGrant() {
+    return this.yoloGrant.revoke();
+  }
   getPolicyContext = () => ({
     mode: this.planModeEnabled ? "plan" : "normal",
     yoloMode: this.yoloMode || this.yoloGrant.isActive(),
@@ -82313,24 +83158,21 @@ var InteractiveMode = class {
       isYoloMode: () => this.yoloMode || this.yoloGrant.isActive(),
       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 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 {
@@ -82460,7 +83302,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-2RCV3I3P.js");
+    const { Agent } = await import("./chunks/src-5JJZZ5H7.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -82637,20 +83479,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);
@@ -82661,6 +83503,9 @@ var InteractiveMode = class {
   setupKeybindings() {
     return setupInteractiveKeybindings(this.keybindingsHost);
   }
+  handlePasteImage() {
+    void handleImagePaste(this);
+  }
   async selectMentionOption(option) {
     return selectMentionOption(this.filePipelineHost, option);
   }
@@ -82836,8 +83681,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);
@@ -82888,8 +83733,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) {
@@ -82916,7 +83761,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;
@@ -83019,7 +83864,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()) {
@@ -83053,6 +83898,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,
@@ -83180,6 +84030,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",
@@ -83343,7 +84194,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-2RCV3I3P.js");
+  const { Agent: AgentClass } = await import("./chunks/src-5JJZZ5H7.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -83512,21 +84363,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("");
@@ -83643,7 +84494,6 @@ function parseInput(line) {
     };
   }
   if (parsed.type === "sidechat.request" && typeof parsed.requestId === "string" && typeof parsed.prompt === "string") {
-    if (parsed.hostContext !== void 0 && !isHostContextBlock(parsed.hostContext)) return null;
     return {
       type: "sidechat.request",
       sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
@@ -83653,7 +84503,6 @@ function parseInput(line) {
     };
   }
   if ((parsed.type === "turn.request" || parsed.type === "turn.input") && typeof parsed.turnId === "string" && typeof parsed.prompt === "string") {
-    if (parsed.hostContext !== void 0 && !isHostContextBlock(parsed.hostContext)) return null;
     const streamingBehavior = parsed.streamingBehavior;
     if (streamingBehavior !== void 0 && streamingBehavior !== "steer" && streamingBehavior !== "followUp") {
       return null;
@@ -83772,7 +84621,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) => {
@@ -83783,7 +84632,7 @@ async function loadJsonModeExtensions(params) {
     },
     yoloMode: false
   };
-  const { extensions } = await loadExtensions(
+  const { extensions, errors } = await loadExtensions(
     params.runtime.extensionPaths,
     params.runtime.cwd,
     uiContext,
@@ -83803,6 +84652,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);
@@ -83822,6 +84675,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;
@@ -83838,6 +84692,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;
@@ -83853,7 +84708,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;
@@ -83870,13 +84725,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();
@@ -84192,6 +85040,11 @@ async function runJsonEventsMode(params) {
     }
     const startedAt = Date.now();
     if (params.mockResponse !== void 0) {
+      const hostContextFailure = validateIntakeHostContext(message);
+      if (hostContextFailure) {
+        writeSidechatFailure(message, hostContextFailure.message, hostContextFailure.code);
+        return;
+      }
       writeEvent({ type: "sidechat.started", sessionId, requestId });
       const event = {
         type: "sidechat.completed",
@@ -84214,7 +85067,7 @@ async function runJsonEventsMode(params) {
       }
     };
     try {
-      await ensureRuntime();
+      await ensureRuntime(runtime?.cwd);
       const hostContextFailure = validateIntakeHostContext(message);
       if (hostContextFailure) {
         writeSidechatFailure(message, hostContextFailure.message, hostContextFailure.code);
@@ -84232,22 +85085,26 @@ async function runJsonEventsMode(params) {
         return;
       }
       const parent = agent;
-      const { Agent: AgentClass } = await import("./chunks/src-2RCV3I3P.js");
+      const sideRegistry = envelopeRegistry;
+      const sideTrace = trace;
+      const sideApiKey = runtime.apiKey;
+      const snapshot = structuredClone(parent.state.messages);
+      const { Agent: AgentClass } = await import("./chunks/src-5JJZZ5H7.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
@@ -84303,6 +85160,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,
@@ -84535,6 +85393,7 @@ async function runJsonEventsMode(params) {
       agent.releaseTransport();
     }
     agent = void 0;
+    envelopeRegistry = createCliHostEnvelopeRegistry();
     try {
       await runtime?.sessionManager.save();
     } catch {
@@ -84561,7 +85420,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(() => {
     });
@@ -84592,14 +85453,16 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-2RCV3I3P.js");
+    const { Agent: AgentClass } = await import("./chunks/src-5JJZZ5H7.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;
@@ -84635,7 +85498,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)
     });
@@ -84671,8 +85534,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,
@@ -84780,7 +85645,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 !== void 0 ? intakeHostContextFailure(message.hostContext, envelopeRegistry) : void 0;
   }
   async function runTurn(message) {
     if (isSessionMismatch(message)) {
@@ -84793,21 +85658,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,
@@ -84828,7 +85691,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;
@@ -84868,12 +85731,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;
@@ -84913,7 +85785,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();
@@ -84951,7 +85825,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",
@@ -84961,8 +85835,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,
@@ -84971,6 +85846,18 @@ async function runJsonEventsMode(params) {
       });
       return;
     }
+    const failure = validateIntakeHostContext(message);
+    if (failure) {
+      writeEvent({
+        type: "turn.failed",
+        sessionId,
+        turnId: message.turnId,
+        error: failure.message,
+        code: failure.code,
+        ...failure.code === "host_context_unknown_projector" ? { hostContextKinds: cliHostEnvelopeKinds(envelopeRegistry) } : {}
+      });
+      return;
+    }
     try {
       applyRuntimeSelection(message);
       trace?.notePendingUserText(message.prompt);
@@ -84989,7 +85876,7 @@ async function runJsonEventsMode(params) {
         sessionId,
         turnId: message.turnId,
         mode: message.streamingBehavior,
-        activeTurnId: activeTurn?.turnId
+        activeTurnId: owner.turnId
       });
     } catch (error) {
       writeEvent({
@@ -85254,7 +86141,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-Y2S3H7DK.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-ZBTSPU7J.js")).createTestStreamFnFromSequenceEnv();
 }
 function resolveJsonEventsDetailFlag() {
   for (let index = 0; index < process.argv.length; index += 1) {