autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-MANJ67D3.js

@@ -0,0 +1,3897 @@
+import {
+  executeShellCommandAsync,
+  getPrimaryShellCommandSuggestion,
+  getShellCommandSuggestions,
+  isShellCommand,
+  parseShellCommand
+} from "./chunk-VUGOOGHB.js";
+import {
+  formatPlanModeToggleMessage,
+  getPlanModeManager
+} from "./chunk-LUMV3DB2.js";
+import {
+  safeSetRawMode
+} from "./chunk-BQU3HAE7.js";
+import {
+  disableBracketedPaste,
+  enableBracketedPaste,
+  getContentDisplay,
+  stripAnsiCodes
+} from "./chunk-CSTUTDTH.js";
+import {
+  getTheme,
+  hexToRgb,
+  isThemeInitialized,
+  themedFg
+} from "./chunk-JAQO6XDB.js";
+import {
+  __require
+} from "./chunk-QGM4M3NI.js";
+
+// src/ui/inputPrompt.ts
+import chalk2 from "chalk";
+import readline2 from "readline";
+import { EventEmitter } from "events";
+import { existsSync, readFileSync } from "fs";
+import { basename, extname } from "path";
+import os from "os";
+
+// src/ui/terminalResize.ts
+var TerminalResizeWatcher = class {
+  stream;
+  handler;
+  disposed = false;
+  debounceTimer;
+  constructor(stream, callback, debounceMs = 80) {
+    this.stream = stream;
+    this.handler = () => {
+      if (this.disposed) {
+        return;
+      }
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+      }
+      this.debounceTimer = setTimeout(() => {
+        this.debounceTimer = void 0;
+        if (!this.disposed) {
+          callback();
+        }
+      }, debounceMs);
+    };
+    if (this.stream && typeof this.stream.on === "function") {
+      this.stream.on("resize", this.handler);
+    }
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = void 0;
+    }
+    if (this.stream && typeof this.stream.off === "function") {
+      this.stream.off("resize", this.handler);
+    }
+  }
+};
+
+// src/ui/mentionPreview.ts
+import chalk from "chalk";
+import readline from "readline";
+
+// src/ui/mentionFilter.ts
+var MENTION_SUGGESTION_LIMIT = 8;
+function buildFileMentionSuggestions(files, seed, limit = MENTION_SUGGESTION_LIMIT) {
+  const trimmedSeed = seed.trim();
+  if (!trimmedSeed) {
+    return files.slice(0, limit);
+  }
+  const normalizedSeed = trimmedSeed.toLowerCase().replace(/\\/g, "/");
+  const wantsPathPrefix = normalizedSeed.includes("/");
+  const ranked = [];
+  files.forEach((file, index) => {
+    const normalizedPath = file.toLowerCase().replace(/\\/g, "/");
+    const filenameLower = normalizedPath.split("/").pop() ?? normalizedPath;
+    const pathStartsWith = normalizedPath.startsWith(normalizedSeed);
+    const pathContains = normalizedPath.includes(normalizedSeed);
+    const filenameContains = filenameLower.includes(normalizedSeed);
+    const exactFilename = filenameLower === normalizedSeed;
+    if (wantsPathPrefix && !pathContains) {
+      return;
+    }
+    if (!pathContains && !filenameContains) {
+      return;
+    }
+    let rank;
+    if (exactFilename) {
+      rank = 0;
+    } else if (filenameContains) {
+      rank = 1;
+    } else if (pathStartsWith) {
+      rank = 2;
+    } else {
+      rank = 3;
+    }
+    ranked.push({ file, rank, index });
+  });
+  return ranked.sort((a, b) => a.rank - b.rank || a.index - b.index).slice(0, limit).map((entry) => entry.file);
+}
+function buildSkillMentionSuggestions(skills, seed, limit = MENTION_SUGGESTION_LIMIT) {
+  const trimmedSeed = seed.trim();
+  if (!trimmedSeed) {
+    const sorted = [...skills].sort((a, b) => {
+      if (a.isActive !== b.isActive) return a.isActive ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return sorted.slice(0, limit).map((skill) => skill.name);
+  }
+  const normalizedSeed = trimmedSeed.toLowerCase();
+  const ranked = [];
+  skills.forEach((skill, index) => {
+    const nameLower = skill.name.toLowerCase();
+    const descLower = skill.description.toLowerCase();
+    const nameStartsWith = nameLower.startsWith(normalizedSeed);
+    const nameContains = nameLower.includes(normalizedSeed);
+    const descContains = descLower.includes(normalizedSeed);
+    if (!nameContains && !descContains) {
+      return;
+    }
+    let rank;
+    if (nameStartsWith) {
+      rank = 0;
+    } else if (nameContains) {
+      rank = 1;
+    } else {
+      rank = 2;
+    }
+    if (skill.isActive) {
+      rank -= 0.5;
+    }
+    ranked.push({ name: skill.name, rank, index });
+  });
+  return ranked.sort((a, b) => a.rank - b.rank || a.index - b.index).slice(0, limit).map((entry) => entry.name);
+}
+
+// src/ui/mentionPreview.ts
+function padVisibleRight(text, width) {
+  if (width <= 0) {
+    return "";
+  }
+  const visibleLength = text.replace(/\u001b\[[0-9;]*m/g, "").length;
+  if (visibleLength >= width) {
+    return text;
+  }
+  return `${text}${" ".repeat(width - visibleLength)}`;
+}
+function truncateVisible(text, width) {
+  if (width <= 0) {
+    return "";
+  }
+  const plain = text.replace(/\u001b\[[0-9;]*m/g, "");
+  if (plain.length <= width) {
+    return text;
+  }
+  if (width === 1) {
+    return "\u2026";
+  }
+  return `${plain.slice(0, width - 1)}\u2026`;
+}
+function getFilenameColumnWidth(entries, width) {
+  const longestFilename = entries.reduce((max, entry) => {
+    const normalized = entry.replace(/\\/g, "/");
+    const filename = normalized.split("/").pop() || normalized;
+    return Math.max(max, filename.length);
+  }, 0);
+  const availableWidth = Math.max(12, width - 2);
+  return Math.max(12, Math.min(longestFilename, Math.floor(availableWidth * 0.32), 24));
+}
+function formatFileSuggestionLine(entry, isSelected, width, filenameColumnWidth) {
+  const normalized = entry.replace(/\\/g, "/");
+  const parts = normalized.split("/");
+  const filename = parts.pop() || normalized;
+  const dir = parts.join("/");
+  const pointer = isSelected ? chalk.cyan("\u25B8") : " ";
+  const basePrefix = `${pointer} `;
+  const gap = "  ";
+  const availableWidth = Math.max(12, width - basePrefix.length);
+  const filenameWidth = Math.min(filenameColumnWidth, Math.max(1, availableWidth - gap.length));
+  const pathWidth = Math.max(0, availableWidth - gap.length - filenameWidth);
+  const visibleFilename = truncateVisible(filename, filenameWidth);
+  const visiblePath = truncateVisible(dir, pathWidth);
+  const styledFilename = isSelected ? chalk.cyan(visibleFilename) : chalk.white(visibleFilename);
+  const styledPath = visiblePath ? chalk.gray(visiblePath) : "";
+  return `${basePrefix}${padVisibleRight(styledFilename, filenameWidth)}${styledPath ? `${gap}${styledPath}` : ""}`;
+}
+function formatSkillSuggestionLine(skill, isSelected, width) {
+  const name = `$${skill.name}`;
+  const description = skill.description;
+  const pointer = isSelected ? chalk.cyan("\u25B8") : " ";
+  const basePrefix = `${pointer} `;
+  const gap = "  ";
+  const availableWidth = Math.max(12, width - basePrefix.length);
+  const nameWidth = Math.max(12, Math.min(Math.floor(availableWidth * 0.32), 30));
+  const descWidth = Math.max(0, availableWidth - gap.length - nameWidth);
+  const visibleName = truncateVisible(name, nameWidth);
+  const visibleDesc = description ? truncateVisible(description, descWidth) : "";
+  const styledName = isSelected ? chalk.cyan(visibleName) : chalk.white(visibleName);
+  const styledDesc = visibleDesc ? chalk.gray(visibleDesc) : "";
+  return `${basePrefix}${padVisibleRight(styledName, nameWidth)}${styledDesc ? `${gap}${styledDesc}` : ""}`;
+}
+var MentionPreview = class {
+  constructor(rl, filesProvider, slashCommands, output, skillsProvider, onFileSuggestionAccepted) {
+    this.rl = rl;
+    this.filesProvider = filesProvider;
+    this.slashCommands = slashCommands;
+    this.output = output;
+    this.onFileSuggestionAccepted = onFileSuggestionAccepted;
+    const input = rl.input;
+    safeEmitKeypressEvents(input);
+    this.keypressHandler = this.handleKeypress.bind(this);
+    this.skillsProvider = skillsProvider;
+    input.prependListener("keypress", this.keypressHandler);
+  }
+  rl;
+  filesProvider;
+  slashCommands;
+  output;
+  onFileSuggestionAccepted;
+  suggestionLines = 0;
+  keypressHandler = null;
+  slashMatches = [];
+  skillMatches = [];
+  fileSuggestions = [];
+  mode = null;
+  activeIndex = 0;
+  disposed = false;
+  suspended = false;
+  lastSuggestions = [];
+  tabJustHandled = false;
+  completionJustHandled = false;
+  skillsProvider;
+  // Dynamic offset from cursor to suggestion area, accounting for multi-line content
+  get suggestionOffset() {
+    const contentLines = getLastRenderedContentLines();
+    const cursorRow = getLastRenderedCursorRow();
+    const contentLinesBelow = contentLines - 1 - cursorRow;
+    return contentLinesBelow + PROMPT_LINES_BELOW_INPUT + STATUS_LINE_COUNT + 1;
+  }
+  dispose() {
+    const input = this.rl.input;
+    if (this.keypressHandler) {
+      input.off("keypress", this.keypressHandler);
+    }
+    this.disposed = true;
+    this.clear();
+  }
+  reset() {
+    this.clear();
+    this.tabJustHandled = false;
+  }
+  handleResize() {
+    if (this.disposed || this.suspended || !this.suggestionLines) {
+      return;
+    }
+    this.clear(false);
+    this.render(this.lastSuggestions);
+  }
+  setSuspended(suspended) {
+    if (this.suspended === suspended) {
+      return;
+    }
+    this.suspended = suspended;
+    if (suspended) {
+      this.clear();
+    }
+  }
+  handleKeypress(_str, key) {
+    if (this.disposed || this.suspended) {
+      return;
+    }
+    const isAcceptKey = this.isTabKey(_str, key) || key?.name === "right" || key?.name === "return" || key?.name === "enter";
+    const beforeCursor = this.rl.line.slice(0, this.rl.cursor);
+    if ((key?.name === "return" || key?.name === "enter") && this.slashCommands.some((command) => command.command === beforeCursor.trim())) {
+      return;
+    }
+    if (isAcceptKey || key?.name === "down" || key?.name === "up") {
+      this.updateSuggestions();
+    }
+    if (key?.name === "escape") {
+      this.reset();
+      return;
+    }
+    if (isAcceptKey && (key?.name !== "right" || this.rl.cursor === this.rl.line.length)) {
+      if (this.mode === "file" && this.fileSuggestions.length) {
+        this.tabJustHandled = true;
+        this.completionJustHandled = true;
+        this.insertFileSuggestion(beforeCursor, this.fileSuggestions[this.activeIndex]);
+        return;
+      }
+      if (this.mode === "slash" && this.slashMatches.length) {
+        const selected = this.slashMatches[this.activeIndex];
+        if ((key?.name === "return" || key?.name === "enter") && selected && beforeCursor.trim() === selected.command) {
+          return;
+        }
+        this.tabJustHandled = true;
+        this.completionJustHandled = true;
+        this.insertSlashSuggestion(beforeCursor, selected ?? this.slashMatches[0]);
+        return;
+      }
+      if (this.mode === "skill" && this.skillMatches.length) {
+        this.tabJustHandled = true;
+        this.completionJustHandled = true;
+        this.insertSkillSuggestion(beforeCursor, this.skillMatches[this.activeIndex]);
+        return;
+      }
+      const mentionMatch = this.isTabKey(_str, key) ? this.matchMention(beforeCursor) : null;
+      if (mentionMatch) {
+        const seed = mentionMatch[1] ?? "";
+        const suggestions = this.filter(seed);
+        if (suggestions.length) {
+          this.mode = "file";
+          this.fileSuggestions = suggestions;
+          this.activeIndex = this.getPreservedSelectionIndex(
+            this.lastSuggestions,
+            suggestions,
+            this.activeIndex
+          );
+          this.tabJustHandled = true;
+          this.completionJustHandled = true;
+          this.insertFileSuggestion(beforeCursor, suggestions[this.activeIndex] ?? suggestions[0]);
+        }
+      }
+      return;
+    }
+    if ((key?.name === "down" || key?.name === "up") && this.mode && this.lastSuggestions.length) {
+      const delta = key.name === "down" ? 1 : -1;
+      const length = this.lastSuggestions.length;
+      this.activeIndex = (this.activeIndex + delta + length) % length;
+      this.render(this.lastSuggestions);
+      return;
+    }
+    setImmediate(() => this.updateSuggestions());
+  }
+  updateSuggestions() {
+    if (this.disposed || this.suspended) {
+      return;
+    }
+    const beforeCursor = this.rl.line.slice(0, this.rl.cursor);
+    if (beforeCursor.startsWith("/")) {
+      const seed2 = beforeCursor.slice(1);
+      const slashSuggestions = this.filterSlash(seed2);
+      if (slashSuggestions.length) {
+        this.mode = "slash";
+        this.activeIndex = this.getPreservedSelectionIndex(
+          this.lastSuggestions,
+          slashSuggestions,
+          this.activeIndex
+        );
+      } else {
+        this.mode = null;
+      }
+      this.render(slashSuggestions);
+      return;
+    }
+    this.slashMatches = [];
+    const skillMatch = /\$([A-Za-z0-9_-]*)$/.exec(beforeCursor);
+    if (skillMatch) {
+      this.fileSuggestions = [];
+      const seed2 = skillMatch[1] ?? "";
+      const skillNames = this.filterSkills(seed2);
+      if (skillNames.length) {
+        this.mode = "skill";
+        this.skillMatches = this.filterSkillsInfo(seed2);
+        this.activeIndex = Math.min(this.activeIndex, this.skillMatches.length - 1);
+      } else {
+        this.mode = null;
+        this.skillMatches = [];
+      }
+      this.render(skillNames);
+      return;
+    }
+    this.skillMatches = [];
+    const match = this.matchMention(beforeCursor);
+    if (!match) {
+      this.mode = null;
+      this.fileSuggestions = [];
+      this.render([]);
+      return;
+    }
+    const seed = match[1];
+    const suggestions = this.filter(seed ?? "");
+    if (suggestions.length) {
+      this.mode = "file";
+      this.fileSuggestions = suggestions;
+      this.activeIndex = this.getPreservedSelectionIndex(
+        this.lastSuggestions,
+        suggestions,
+        this.activeIndex
+      );
+    } else {
+      this.mode = null;
+      this.fileSuggestions = [];
+    }
+    this.render(suggestions);
+  }
+  filter(seed) {
+    return buildFileMentionSuggestions(this.filesProvider(), seed, MENTION_SUGGESTION_LIMIT);
+  }
+  filterSkills(seed) {
+    return buildSkillMentionSuggestions(this.skillsProvider(), seed, MENTION_SUGGESTION_LIMIT);
+  }
+  filterSkillsInfo(seed) {
+    const allSkills = this.skillsProvider();
+    const skillNames = buildSkillMentionSuggestions(allSkills, seed, MENTION_SUGGESTION_LIMIT);
+    return allSkills.filter((s) => skillNames.includes(s.name));
+  }
+  consumeHandledTab() {
+    const handled = this.tabJustHandled;
+    this.tabJustHandled = false;
+    return handled;
+  }
+  consumeHandledCompletion() {
+    const handled = this.completionJustHandled;
+    this.completionJustHandled = false;
+    this.tabJustHandled = false;
+    return handled;
+  }
+  getPreservedSelectionIndex(previousSuggestions, nextSuggestions, previousIndex) {
+    if (!nextSuggestions.length) {
+      return 0;
+    }
+    const previousSelection = previousSuggestions[previousIndex];
+    if (!previousSelection) {
+      return 0;
+    }
+    const nextIndex = nextSuggestions.indexOf(previousSelection);
+    if (nextIndex >= 0) {
+      return nextIndex;
+    }
+    return Math.min(previousIndex, nextSuggestions.length - 1);
+  }
+  matchMention(beforeCursor) {
+    return /@([A-Za-z0-9_./\\-]*)$/.exec(beforeCursor);
+  }
+  isTabKey(str, key) {
+    if (key?.name === "backtab" || key?.sequence === "\x1B[Z" || str === "\x1B[Z" || key?.shift) {
+      return false;
+    }
+    return key?.name === "tab" || key?.sequence === "	" || str === "	";
+  }
+  filterSlash(seed) {
+    const normalized = seed.toLowerCase();
+    let matches = this.slashCommands.filter((cmd) => cmd.command.replace("/", "").toLowerCase().startsWith(normalized));
+    if (matches.length === 0) {
+      matches = this.slashCommands.filter((cmd) => cmd.command.replace("/", "").toLowerCase().includes(normalized));
+    }
+    this.slashMatches = matches.slice(0, 5);
+    return this.slashMatches.map((cmd) => {
+      const detail = cmd.description ? chalk.gray(` - ${cmd.description}`) : "";
+      return `${cmd.command}${detail}`;
+    });
+  }
+  render(suggestions) {
+    if (this.disposed || this.suspended) {
+      return;
+    }
+    this.lastSuggestions = [...suggestions];
+    this.clear(false);
+    if (!suggestions.length) {
+      return;
+    }
+    const filenameColumnWidth = this.mode === "file" ? getFilenameColumnWidth(suggestions, getPromptBlockWidth(this.output.columns)) : 0;
+    const suggestionLines = suggestions.map((entry, idx) => {
+      const isSelected = this.mode && idx === this.activeIndex;
+      if (this.mode === "file") {
+        return formatFileSuggestionLine(
+          entry,
+          Boolean(isSelected),
+          getPromptBlockWidth(this.output.columns),
+          filenameColumnWidth
+        );
+      }
+      if (this.mode === "skill") {
+        const skills = this.skillsProvider();
+        const skillInfo = skills.find((s) => s.name === entry);
+        if (skillInfo) {
+          return formatSkillSuggestionLine(skillInfo, Boolean(isSelected), getPromptBlockWidth(this.output.columns));
+        }
+      }
+      const pointer = isSelected ? chalk.cyan("\u25B8") : " ";
+      const text = isSelected ? chalk.cyan(entry) : entry;
+      return `${pointer} ${text}`;
+    });
+    const lines = suggestionLines;
+    readline.moveCursor(this.output, 0, this.suggestionOffset);
+    readline.cursorTo(this.output, 0);
+    for (const line of lines) {
+      readline.clearLine(this.output, 0);
+      this.output.write(`${line}
+`);
+    }
+    this.suggestionLines = lines.length;
+    readline.moveCursor(this.output, 0, -(this.suggestionLines + this.suggestionOffset));
+    readline.cursorTo(this.output, 0);
+    const rlAny = this.rl;
+    const cursorPos = rlAny.cursor ?? rlAny.line.length;
+    const width = getPromptBlockWidth(this.output.columns);
+    const state = buildPromptRenderState(rlAny.line, cursorPos, width);
+    this.output.write(state.lineText);
+    readline.cursorTo(this.output, state.cursorColumn);
+  }
+  clear(reprompt = true) {
+    if (!this.suggestionLines) {
+      return;
+    }
+    readline.moveCursor(this.output, 0, this.suggestionOffset);
+    for (let i = 0; i < this.suggestionLines; i++) {
+      readline.clearLine(this.output, 0);
+      if (i < this.suggestionLines - 1) {
+        readline.moveCursor(this.output, 0, 1);
+      }
+    }
+    readline.moveCursor(this.output, 0, -(this.suggestionLines + this.suggestionOffset - 1));
+    this.suggestionLines = 0;
+    if (reprompt && !this.disposed) {
+      const rlAny = this.rl;
+      readline.cursorTo(this.output, 0);
+      const cursorPos = rlAny.cursor ?? rlAny.line.length;
+      const width = getPromptBlockWidth(this.output.columns);
+      const state = buildPromptRenderState(rlAny.line, cursorPos, width);
+      this.output.write(state.lineText);
+      readline.cursorTo(this.output, state.cursorColumn);
+    }
+  }
+  insertFileSuggestion(beforeCursor, file) {
+    const match = /@([A-Za-z0-9_./\\-]*)$/.exec(beforeCursor);
+    if (!match) {
+      return;
+    }
+    const start = match.index;
+    const afterCursor = this.rl.line.slice(this.rl.cursor);
+    const prefix = this.rl.line.slice(0, start);
+    const replacement = `@${file} `;
+    const newLine = prefix + replacement + afterCursor;
+    const newCursorPos = prefix.length + replacement.length;
+    if (this.onFileSuggestionAccepted) {
+      this.onFileSuggestionAccepted(newLine, newCursorPos);
+    } else {
+      this.rl.line = newLine;
+      this.rl.cursor = newCursorPos;
+    }
+    this.mode = null;
+    this.fileSuggestions = [];
+    this.lastSuggestions = [];
+    this.clear();
+    if (typeof this.rl._refreshLine === "function") {
+      this.rl._refreshLine();
+    } else {
+      readline.cursorTo(this.output, 0);
+      const width = getPromptBlockWidth(this.output.columns);
+      const state = buildPromptRenderState(newLine, newCursorPos, width);
+      this.output.write(state.lineText);
+      readline.cursorTo(this.output, state.cursorColumn);
+    }
+  }
+  insertSlashSuggestion(beforeCursor, command) {
+    const afterCursor = this.rl.line.slice(this.rl.cursor);
+    const replacement = `${command.command} `;
+    const newLine = replacement + afterCursor;
+    const newCursorPos = replacement.length;
+    if (this.onFileSuggestionAccepted) {
+      this.onFileSuggestionAccepted(newLine, newCursorPos);
+    } else {
+      this.rl.line = newLine;
+      this.rl.cursor = newCursorPos;
+    }
+    this.mode = null;
+    this.slashMatches = [];
+    this.lastSuggestions = [];
+    this.clear();
+  }
+  insertSkillSuggestion(beforeCursor, skill) {
+    const match = /\$([A-Za-z0-9_-]*)$/.exec(beforeCursor);
+    if (!match) {
+      return;
+    }
+    const start = match.index;
+    const afterCursor = this.rl.line.slice(this.rl.cursor);
+    const prefix = this.rl.line.slice(0, start);
+    const replacement = `$${skill.name} `;
+    const newLine = prefix + replacement + afterCursor;
+    const newCursorPos = prefix.length + replacement.length;
+    if (this.onFileSuggestionAccepted) {
+      this.onFileSuggestionAccepted(newLine, newCursorPos);
+    } else {
+      this.rl.line = newLine;
+      this.rl.cursor = newCursorPos;
+    }
+    this.mode = null;
+    this.skillMatches = [];
+    this.lastSuggestions = [];
+    this.clear();
+    if (typeof this.rl._refreshLine === "function") {
+      this.rl._refreshLine();
+    } else {
+      readline.cursorTo(this.output, 0);
+      const width = getPromptBlockWidth(this.output.columns);
+      const state = buildPromptRenderState(newLine, newCursorPos, width);
+      this.output.write(state.lineText);
+      readline.cursorTo(this.output, state.cursorColumn);
+    }
+  }
+};
+
+// src/utils/imageCompression.ts
+var sharpConstructor;
+async function getSharp() {
+  if (!sharpConstructor) {
+    const mod = await import("sharp");
+    sharpConstructor = mod.default;
+  }
+  return sharpConstructor;
+}
+var IMAGE_TARGET_RAW_SIZE = 3.75 * 1024 * 1024;
+var IMAGE_MAX_DIMENSION = 2e3;
+async function compressImageBuffer(imageBuffer, maxBytes = IMAGE_TARGET_RAW_SIZE, originalMediaType) {
+  if (imageBuffer.length === 0) {
+    throw new Error("Image buffer is empty");
+  }
+  const sharp = await getSharp();
+  const fallbackFormat = (originalMediaType?.split("/")[1] || "jpeg").replace("jpg", "jpeg");
+  const metadata = await sharp(imageBuffer).metadata();
+  const format = metadata.format || fallbackFormat;
+  if (imageBuffer.length <= maxBytes) {
+    return {
+      base64: imageBuffer.toString("base64"),
+      mediaType: `image/${format === "jpg" ? "jpeg" : format}`,
+      originalSize: imageBuffer.length
+    };
+  }
+  if (maxBytes <= 1024 * 1024) {
+    const budgetDimension2 = Math.max(300, Math.min(1200, Math.round(Math.sqrt(maxBytes))));
+    for (const quality of [70, 50, 35, 20]) {
+      const jpegBuf = await sharp(imageBuffer).resize(budgetDimension2, budgetDimension2, { fit: "inside", withoutEnlargement: true }).jpeg({ quality }).toBuffer();
+      if (jpegBuf.length <= maxBytes) {
+        return {
+          base64: jpegBuf.toString("base64"),
+          mediaType: "image/jpeg",
+          originalSize: imageBuffer.length
+        };
+      }
+    }
+  }
+  const budgetDimension = Math.max(400, Math.min(IMAGE_MAX_DIMENSION, Math.round(Math.sqrt(maxBytes * 1.5))));
+  const estimatedScale = Math.min(
+    Math.sqrt(Math.max(maxBytes, 1) / imageBuffer.length),
+    budgetDimension / Math.max(metadata.width ?? budgetDimension, metadata.height ?? budgetDimension)
+  );
+  const preferredStart = Math.min(1, Math.max(0.1, estimatedScale * 1.1));
+  const scalingFactors = Array.from(/* @__PURE__ */ new Set([
+    preferredStart,
+    Math.max(0.1, preferredStart * 0.75),
+    Math.max(0.1, preferredStart * 0.5)
+  ])).sort((a, b) => b - a);
+  const w = metadata.width ?? IMAGE_MAX_DIMENSION;
+  const h = metadata.height ?? IMAGE_MAX_DIMENSION;
+  for (const factor of scalingFactors) {
+    const newW = Math.round(w * factor);
+    const newH = Math.round(h * factor);
+    const resized = sharp(imageBuffer).resize(newW, newH, { fit: "inside", withoutEnlargement: true });
+    if (format === "png") {
+      resized.png({ compressionLevel: 9, palette: true });
+    } else if (format === "jpeg" || format === "jpg") {
+      resized.jpeg({ quality: 80 });
+    } else if (format === "webp") {
+      resized.webp({ quality: 80 });
+    }
+    const buf = await resized.toBuffer();
+    if (buf.length <= maxBytes) {
+      return {
+        base64: buf.toString("base64"),
+        mediaType: `image/${format === "jpg" ? "jpeg" : format}`,
+        originalSize: imageBuffer.length
+      };
+    }
+  }
+  const palettePng = await sharp(imageBuffer).resize(800, 800, { fit: "inside", withoutEnlargement: true }).png({ compressionLevel: 9, palette: true, colors: 64 }).toBuffer();
+  if (palettePng.length <= maxBytes) {
+    return {
+      base64: palettePng.toString("base64"),
+      mediaType: "image/png",
+      originalSize: imageBuffer.length
+    };
+  }
+  const jpeg = await sharp(imageBuffer).resize(600, 600, { fit: "inside", withoutEnlargement: true }).jpeg({ quality: 50 }).toBuffer();
+  if (jpeg.length <= maxBytes) {
+    return {
+      base64: jpeg.toString("base64"),
+      mediaType: "image/jpeg",
+      originalSize: imageBuffer.length
+    };
+  }
+  const ultra = await sharp(imageBuffer).resize(400, 400, { fit: "inside", withoutEnlargement: true }).jpeg({ quality: 20 }).toBuffer();
+  return {
+    base64: ultra.toString("base64"),
+    mediaType: "image/jpeg",
+    originalSize: imageBuffer.length
+  };
+}
+async function compressImageBufferWithTargetLimit(imageBuffer, maxTokens, originalMediaType) {
+  const maxBase64Chars = Math.floor(maxTokens / 0.125);
+  const maxBytes = Math.floor(maxBase64Chars * 0.75);
+  return compressImageBuffer(imageBuffer, maxBytes, originalMediaType);
+}
+
+// src/core/ImageManager.ts
+var ImageManager = class _ImageManager {
+  images = /* @__PURE__ */ new Map();
+  counter = 0;
+  /**
+   * Maximum image size before compression (3.75MB raw target, cc-src's IMAGE_TARGET_RAW_SIZE).
+   * Accounts for base64 4/3 expansion to stay under 5MB API limit.
+   */
+  static MAX_IMAGE_SIZE = IMAGE_TARGET_RAW_SIZE;
+  /**
+   * Add a new image attachment (sync — compression happens lazily in toOpenAIFormat).
+   * @param data - Raw image data as Buffer
+   * @param mimeType - Image MIME type
+   * @param filename - Optional original filename
+   * @returns Sequential image ID starting from 1
+   */
+  add(data, mimeType, filename) {
+    const id = ++this.counter;
+    this.images.set(id, {
+      id,
+      data,
+      mimeType,
+      filename
+    });
+    return id;
+  }
+  /**
+   * Add a new image attachment without compression (for internal use)
+   * @param data - Raw image data as Buffer
+   * @param mimeType - Image MIME type
+   * @param filename - Optional original filename
+   * @returns Sequential image ID starting from 1
+   */
+  addRaw(data, mimeType, filename) {
+    const id = ++this.counter;
+    this.images.set(id, {
+      id,
+      data,
+      mimeType,
+      filename
+    });
+    return id;
+  }
+  /**
+   * Get image by ID
+   * @param id - Image ID
+   * @returns Image attachment or undefined if not found
+   */
+  get(id) {
+    return this.images.get(id);
+  }
+  /**
+   * Get all images in order they were added
+   * @returns Array of image attachments sorted by ID
+   */
+  getAll() {
+    return Array.from(this.images.values()).sort((a, b) => a.id - b.id);
+  }
+  /**
+   * Clear all images and reset counter (called on /new or session end)
+   */
+  clear() {
+    this.images.clear();
+    this.counter = 0;
+  }
+  /**
+   * Get number of images currently stored
+   */
+  count() {
+    return this.images.size;
+  }
+  /**
+   * Convert all images to Claude vision API format
+   * @returns Array of Claude image content objects
+   */
+  toClaudeFormat() {
+    return this.getAll().map((img) => ({
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: img.mimeType,
+        data: img.data.toString("base64")
+      }
+    }));
+  }
+  /**
+   * Convert all images to OpenAI vision API format.
+   * Images exceeding the target size are properly compressed (not truncated).
+   * @param tokenLimit - Optional token budget for image compression
+   * @returns Array of OpenAI image content objects
+   */
+  async toOpenAIFormat(tokenLimit) {
+    const allImages = this.getAll();
+    const results = [];
+    for (const img of allImages) {
+      let base64Data;
+      if (tokenLimit) {
+        const compressed = await compressImageBufferWithTargetLimit(
+          img.data,
+          tokenLimit,
+          img.mimeType
+        );
+        base64Data = compressed.base64;
+      } else {
+        if (img.data.length > _ImageManager.MAX_IMAGE_SIZE) {
+          const compressed = await compressImageBufferWithTargetLimit(
+            img.data,
+            Math.floor(IMAGE_TARGET_RAW_SIZE),
+            img.mimeType
+          );
+          base64Data = compressed.base64;
+        } else {
+          base64Data = img.data.toString("base64");
+        }
+      }
+      results.push({
+        type: "image_url",
+        image_url: {
+          url: `data:${img.mimeType};base64,${base64Data}`
+        }
+      });
+    }
+    return results;
+  }
+  /**
+   * Format placeholder text for display
+   * @param id - Image ID
+   * @returns Placeholder string like "[Image #1] filename.png" or empty string if not found
+   */
+  formatPlaceholder(id) {
+    const image = this.get(id);
+    if (!image) {
+      return "";
+    }
+    if (image.filename) {
+      return `[Image #${id}] ${image.filename}`;
+    }
+    return `[Image #${id}]`;
+  }
+};
+function isBase64Image(str) {
+  return str.startsWith("data:image/") && str.includes(";base64,");
+}
+function getMimeTypeFromExtension(ext) {
+  const normalized = ext.toLowerCase().replace(/^\./, "");
+  switch (normalized) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    default:
+      return void 0;
+  }
+}
+function parseBase64DataUrl(dataUrl) {
+  if (!isBase64Image(dataUrl)) {
+    return void 0;
+  }
+  const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+  if (!match) {
+    return void 0;
+  }
+  const [, mimeType, base64Data] = match;
+  if (mimeType !== "image/png" && mimeType !== "image/jpeg" && mimeType !== "image/gif" && mimeType !== "image/webp") {
+    return void 0;
+  }
+  try {
+    const data = Buffer.from(base64Data, "base64");
+    return { mimeType, data };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/ui/box.ts
+var DEFAULT_BORDER_COLOR = "#8a8a8a";
+var PLAN_BORDER_COLOR = "#ff9d3f";
+var SHELL_BORDER_COLOR = "#000000";
+var SHELL_BOX_BG = "#ffffff";
+var SHELL_BOX_FG = "#000000";
+var FALLBACK_BOX_BG = "#2b2b2b";
+var FALLBACK_BOX_FG = "#a0a0a0";
+var cachedBoxBg = null;
+var cachedBoxFg = null;
+var cachedShellBoxBg = null;
+var cachedShellBoxFg = null;
+var cachedBorderFg = /* @__PURE__ */ new Map();
+var cachedThemeRef = null;
+function ensureCacheValid() {
+  const currentTheme = isThemeInitialized() ? getTheme() : null;
+  if (currentTheme !== cachedThemeRef) {
+    cachedBoxBg = null;
+    cachedBoxFg = null;
+    cachedShellBoxBg = null;
+    cachedShellBoxFg = null;
+    cachedBorderFg.clear();
+    cachedThemeRef = currentTheme;
+  }
+}
+function invalidateBoxColorCache() {
+  cachedBoxBg = null;
+  cachedBoxFg = null;
+  cachedShellBoxBg = null;
+  cachedShellBoxFg = null;
+  cachedBorderFg.clear();
+}
+function resolveBorderToken(style) {
+  if (style === "plan") {
+    return "warning";
+  }
+  if (style === "shell") {
+    return "dim";
+  }
+  return "borderAccent";
+}
+function resolveBorderFallback(style) {
+  if (style === "plan") {
+    return PLAN_BORDER_COLOR;
+  }
+  if (style === "shell") {
+    return SHELL_BORDER_COLOR;
+  }
+  return DEFAULT_BORDER_COLOR;
+}
+function hexToAnsiRgb(hex, type) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return "";
+  const base = type === "fg" ? 38 : 48;
+  return `\x1B[${base};2;${rgb.r};${rgb.g};${rgb.b}m`;
+}
+function resolveBoxBg(style = "default") {
+  if (style === "shell") {
+    if (cachedShellBoxBg !== null) return cachedShellBoxBg;
+    const result2 = hexToAnsiRgb(SHELL_BOX_BG, "bg");
+    cachedShellBoxBg = result2;
+    return result2;
+  }
+  ensureCacheValid();
+  if (cachedBoxBg !== null) return cachedBoxBg;
+  if (isThemeInitialized()) {
+    try {
+      const hex = getTheme().getColor("userMessageBg");
+      if (hex) {
+        const code = hexToAnsiRgb(hex, "bg");
+        if (code) {
+          cachedBoxBg = code;
+          return code;
+        }
+      }
+    } catch {
+    }
+  }
+  const result = hexToAnsiRgb(FALLBACK_BOX_BG, "bg");
+  cachedBoxBg = result;
+  return result;
+}
+function resolveBoxFg(style = "default") {
+  if (style === "shell") {
+    if (cachedShellBoxFg !== null) return cachedShellBoxFg;
+    const result2 = hexToAnsiRgb(SHELL_BOX_FG, "fg");
+    cachedShellBoxFg = result2;
+    return result2;
+  }
+  ensureCacheValid();
+  if (cachedBoxFg !== null) return cachedBoxFg;
+  if (isThemeInitialized()) {
+    try {
+      const hex = getTheme().getColor("userMessageText");
+      if (hex) {
+        const code = hexToAnsiRgb(hex, "fg");
+        if (code) {
+          cachedBoxFg = code;
+          return code;
+        }
+      }
+    } catch {
+    }
+  }
+  const result = hexToAnsiRgb(FALLBACK_BOX_FG, "fg");
+  cachedBoxFg = result;
+  return result;
+}
+function resolveBorderFg(style) {
+  if (style === "shell") {
+    const cached2 = cachedBorderFg.get(style);
+    if (cached2 !== void 0) return cached2;
+    const result2 = hexToAnsiRgb(SHELL_BORDER_COLOR, "fg");
+    cachedBorderFg.set(style, result2);
+    return result2;
+  }
+  ensureCacheValid();
+  const cached = cachedBorderFg.get(style);
+  if (cached !== void 0) return cached;
+  if (isThemeInitialized()) {
+    try {
+      const hex = getTheme().getColor(resolveBorderToken(style));
+      if (hex) {
+        const code = hexToAnsiRgb(hex, "fg");
+        if (code) {
+          cachedBorderFg.set(style, code);
+          return code;
+        }
+      }
+    } catch {
+    }
+  }
+  const result = hexToAnsiRgb(resolveBorderFallback(style), "fg");
+  cachedBorderFg.set(style, result);
+  return result;
+}
+function drawInputTopBorder(width, style = "default") {
+  const innerWidth = Math.max(0, width - 2);
+  const border = `\u250C${"\u2500".repeat(innerWidth)}\u2510`;
+  return resolveBoxBg(style) + resolveBorderFg(style) + border + RESET_ALL + CLEAR_TO_EOL;
+}
+function drawInputBottomBorder(width, style = "default") {
+  const innerWidth = Math.max(0, width - 2);
+  const border = `\u2514${"\u2500".repeat(innerWidth)}\u2518`;
+  return resolveBoxBg(style) + resolveBorderFg(style) + border + RESET_ALL + CLEAR_TO_EOL;
+}
+var ANSI_OR_CHAR_PATTERN = /(?:\u001b\[[0-9;]*m)|[\s\S]/g;
+function getVisibleLength(value) {
+  return stripAnsiCodes(value).length;
+}
+function truncateVisible2(value, maxVisible) {
+  if (maxVisible <= 0 || value.length === 0) {
+    return "";
+  }
+  let visible = 0;
+  let out = "";
+  const tokens = value.match(ANSI_OR_CHAR_PATTERN) ?? [];
+  for (const token of tokens) {
+    if (token.startsWith("\x1B[")) {
+      out += token;
+      continue;
+    }
+    if (visible >= maxVisible) {
+      break;
+    }
+    out += token;
+    visible += 1;
+  }
+  return out;
+}
+var RESET_ALL = "\x1B[0m";
+var CLEAR_TO_EOL = "\x1B[K";
+function stabilizeBoxAnsi(text, bg, fg) {
+  const base = bg + fg;
+  return text.replace(/\x1b\[0m/g, RESET_ALL + base).replace(/\x1b\[49m/g, bg).replace(/\x1b\[39m/g, fg);
+}
+function drawInputBox(left, width, right, style = "default") {
+  const normalizedLeft = style === "shell" ? stripAnsiCodes(left) : left;
+  const normalizedRight = style === "shell" && right ? stripAnsiCodes(right) : right;
+  const bg = resolveBoxBg(style);
+  const fg = resolveBoxFg(style);
+  const borderFg = resolveBorderFg(style);
+  const base = bg + fg;
+  const innerWidth = Math.max(0, width - 2);
+  const visLeft = getVisibleLength(normalizedLeft);
+  const lBorder = borderFg + "\u2502" + fg;
+  const rBorder = borderFg + "\u2502";
+  const END = RESET_ALL + CLEAR_TO_EOL;
+  if (!normalizedRight) {
+    const pad = Math.max(0, innerWidth - visLeft);
+    return base + lBorder + stabilizeBoxAnsi(normalizedLeft, bg, fg) + " ".repeat(pad) + rBorder + END;
+  }
+  const visRight = getVisibleLength(normalizedRight);
+  const minGap = 2;
+  const available = innerWidth - visLeft - minGap;
+  if (available <= 0) {
+    const pad = Math.max(0, innerWidth - visLeft);
+    return base + lBorder + stabilizeBoxAnsi(normalizedLeft, bg, fg) + " ".repeat(pad) + rBorder + END;
+  }
+  const clippedRight = visRight > available ? truncateVisible2(normalizedRight, available) : normalizedRight;
+  const clippedRightVis = getVisibleLength(clippedRight);
+  const gap = Math.max(0, innerWidth - visLeft - clippedRightVis);
+  const line = stabilizeBoxAnsi(normalizedLeft, bg, fg) + " ".repeat(gap) + stabilizeBoxAnsi(clippedRight, bg, fg);
+  return base + lBorder + line + rBorder + END;
+}
+
+// src/ui/textBufferLayout.ts
+import stringWidth from "string-width";
+function calculateLayout(lines, viewportWidth) {
+  const visualLines = [];
+  const logicalToVisualMap = [];
+  const visualToLogicalMap = [];
+  const width = Math.max(viewportWidth, 1);
+  for (let logRow = 0; logRow < lines.length; logRow++) {
+    const line = lines[logRow];
+    const visRows = [];
+    if (line.length === 0) {
+      const visIdx = visualLines.length;
+      visualLines.push("");
+      visRows.push([visIdx, 0]);
+      visualToLogicalMap.push([logRow, 0]);
+    } else {
+      let pos = 0;
+      while (pos < line.length) {
+        const segStart = pos;
+        const visIdx = visualLines.length;
+        let currentWidth = 0;
+        let lastSpacePos = -1;
+        let endPos = pos;
+        while (endPos < line.length) {
+          const ch = line[endPos];
+          const chWidth = stringWidth(ch);
+          if (currentWidth + chWidth > width) {
+            break;
+          }
+          currentWidth += chWidth;
+          endPos++;
+          if (ch === " ") {
+            lastSpacePos = endPos;
+          }
+        }
+        if (endPos < line.length) {
+          if (lastSpacePos > pos) {
+            const segment = line.slice(segStart, lastSpacePos);
+            visualLines.push(segment);
+            visRows.push([visIdx, segStart]);
+            visualToLogicalMap.push([logRow, segStart]);
+            pos = lastSpacePos;
+          } else {
+            const segment = line.slice(segStart, endPos);
+            visualLines.push(segment);
+            visRows.push([visIdx, segStart]);
+            visualToLogicalMap.push([logRow, segStart]);
+            pos = endPos;
+          }
+        } else {
+          const segment = line.slice(segStart, endPos);
+          visualLines.push(segment);
+          visRows.push([visIdx, segStart]);
+          visualToLogicalMap.push([logRow, segStart]);
+          pos = endPos;
+        }
+      }
+    }
+    logicalToVisualMap.push(visRows);
+  }
+  return {
+    visualLines,
+    logicalToVisual: logicalToVisualMap,
+    visualToLogical: visualToLogicalMap
+  };
+}
+function logicalToVisual(layout, logRow, logCol) {
+  const spans = layout.logicalToVisual[logRow];
+  if (!spans || spans.length === 0) {
+    return [0, 0];
+  }
+  for (let i = spans.length - 1; i >= 0; i--) {
+    const [visRow2, logColStart2] = spans[i];
+    if (logCol >= logColStart2) {
+      return [visRow2, logCol - logColStart2];
+    }
+  }
+  const [visRow, logColStart] = spans[0];
+  return [visRow, logCol - logColStart];
+}
+function visualToLogical(layout, visRow, visCol) {
+  const mapping = layout.visualToLogical[visRow];
+  if (!mapping) {
+    return [0, 0];
+  }
+  const [logRow, logColStart] = mapping;
+  return [logRow, logColStart + visCol];
+}
+
+// src/ui/textBuffer.ts
+function cpLen(s) {
+  return Array.from(s).length;
+}
+function cpSlice(s, start, end) {
+  return Array.from(s).slice(start, end).join("");
+}
+var CONTROL_CHAR_RE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+var TextBuffer = class {
+  lines;
+  cursorRow;
+  cursorCol;
+  viewportWidth;
+  viewportHeight;
+  preferredCol = null;
+  /** Cached layout result; recomputed lazily when dirty. */
+  cachedLayout = null;
+  /** Becomes `true` when lines or viewport dimensions change. */
+  layoutDirty = true;
+  /** Visual row offset for viewport scrolling. */
+  scrollRow = 0;
+  constructor(viewportWidth, viewportHeight, initialText) {
+    this.viewportWidth = viewportWidth;
+    this.viewportHeight = viewportHeight;
+    if (initialText !== void 0 && initialText !== "") {
+      const normalized = normalizeNewlines(initialText);
+      this.lines = normalized.split("\n");
+      this.cursorRow = this.lines.length - 1;
+      this.cursorCol = cpLen(this.lines[this.cursorRow]);
+    } else {
+      this.lines = [""];
+      this.cursorRow = 0;
+      this.cursorCol = 0;
+    }
+    this.ensureCursorVisible();
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  /** Returns a shallow copy of the logical lines array. */
+  getLines() {
+    return [...this.lines];
+  }
+  /** Returns the current cursor row (0-based logical line index). */
+  getCursorRow() {
+    return this.cursorRow;
+  }
+  /** Returns the current cursor column (0-based code-point offset). */
+  getCursorCol() {
+    return this.cursorCol;
+  }
+  /** Returns the number of logical lines. */
+  getLineCount() {
+    return this.lines.length;
+  }
+  /** Returns all lines joined with `\n`. Empty single-line buffer returns `''`. */
+  getText() {
+    if (this.lines.length === 1 && this.lines[0] === "") {
+      return "";
+    }
+    return this.lines.join("\n");
+  }
+  /** Returns `true` when the buffer holds no text (single empty line). */
+  isEmpty() {
+    return this.lines.length === 1 && this.lines[0] === "";
+  }
+  // ---------------------------------------------------------------------------
+  // Cursor positioning
+  // ---------------------------------------------------------------------------
+  /**
+   * Sets the cursor to (row, col), clamping both to valid ranges.
+   * Row is clamped to [0, lineCount-1]. Col is clamped to [0, lineLen].
+   */
+  setCursor(row, col) {
+    row = Math.max(0, Math.min(row, this.lines.length - 1));
+    const lineLen = cpLen(this.lines[row]);
+    col = Math.max(0, Math.min(col, lineLen));
+    this.cursorRow = row;
+    this.cursorCol = col;
+    this.ensureCursorVisible();
+  }
+  // ---------------------------------------------------------------------------
+  // Cursor movement
+  // ---------------------------------------------------------------------------
+  /** Moves cursor left by one code point. Wraps to end of previous line at col 0. */
+  moveLeft() {
+    this.preferredCol = null;
+    if (this.cursorCol > 0) {
+      this.cursorCol--;
+    } else if (this.cursorRow > 0) {
+      this.cursorRow--;
+      this.cursorCol = cpLen(this.lines[this.cursorRow]);
+    }
+  }
+  /** Moves cursor right by one code point. Wraps to start of next line at end of line. */
+  moveRight() {
+    this.preferredCol = null;
+    const lineLen = cpLen(this.lines[this.cursorRow]);
+    if (this.cursorCol < lineLen) {
+      this.cursorCol++;
+    } else if (this.cursorRow < this.lines.length - 1) {
+      this.cursorRow++;
+      this.cursorCol = 0;
+    }
+  }
+  /**
+   * Moves cursor up one visual row. Navigates within wrapped lines as well
+   * as across logical line boundaries. Preserves preferred visual column.
+   */
+  moveUp() {
+    const layout = this.getVisualLayout();
+    const strCol = cpToStrIndex(this.lines[this.cursorRow], this.cursorCol);
+    const [visRow, visCol] = logicalToVisual(layout, this.cursorRow, strCol);
+    if (visRow <= 0) return;
+    if (this.preferredCol === null) {
+      this.preferredCol = visCol;
+    }
+    const targetVisRow = visRow - 1;
+    const targetVisLine = layout.visualLines[targetVisRow];
+    const clampedVisCol = Math.min(this.preferredCol, targetVisLine.length);
+    const [logRow, logStrCol] = visualToLogical(layout, targetVisRow, clampedVisCol);
+    this.cursorRow = logRow;
+    this.cursorCol = strToCpIndex(this.lines[logRow], logStrCol);
+    this.ensureCursorVisible();
+  }
+  /**
+   * Moves cursor down one visual row. Navigates within wrapped lines as well
+   * as across logical line boundaries. Preserves preferred visual column.
+   */
+  moveDown() {
+    const layout = this.getVisualLayout();
+    const strCol = cpToStrIndex(this.lines[this.cursorRow], this.cursorCol);
+    const [visRow, visCol] = logicalToVisual(layout, this.cursorRow, strCol);
+    if (visRow >= layout.visualLines.length - 1) return;
+    if (this.preferredCol === null) {
+      this.preferredCol = visCol;
+    }
+    const targetVisRow = visRow + 1;
+    const targetVisLine = layout.visualLines[targetVisRow];
+    const clampedVisCol = Math.min(this.preferredCol, targetVisLine.length);
+    const [logRow, logStrCol] = visualToLogical(layout, targetVisRow, clampedVisCol);
+    this.cursorRow = logRow;
+    this.cursorCol = strToCpIndex(this.lines[logRow], logStrCol);
+    this.ensureCursorVisible();
+  }
+  /**
+   * Moves cursor left by one word boundary using `Intl.Segmenter`.
+   * Jumps to the start of the previous word-like segment. At column 0,
+   * wraps to the end of the previous logical line.
+   */
+  moveWordLeft() {
+    this.preferredCol = null;
+    if (this.cursorCol === 0) {
+      if (this.cursorRow > 0) {
+        this.cursorRow--;
+        this.cursorCol = cpLen(this.lines[this.cursorRow]);
+      }
+      return;
+    }
+    const line = this.lines[this.cursorRow];
+    const codePoints = Array.from(line);
+    const strCursor = codePoints.slice(0, this.cursorCol).join("").length;
+    const segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+    const segments = Array.from(segmenter.segment(line));
+    let target = null;
+    for (const seg of segments) {
+      if (seg.isWordLike && seg.index < strCursor) {
+        target = seg;
+      }
+    }
+    if (target !== null) {
+      this.cursorCol = strToCpIndex(line, target.index);
+    } else {
+      this.cursorCol = 0;
+    }
+    this.ensureCursorVisible();
+  }
+  /**
+   * Moves cursor right by one word boundary using `Intl.Segmenter`.
+   * Jumps to the end of the current/next word-like segment. At end of line,
+   * wraps to the start of the next logical line.
+   */
+  moveWordRight() {
+    this.preferredCol = null;
+    const line = this.lines[this.cursorRow];
+    const lineLen = cpLen(line);
+    if (this.cursorCol >= lineLen) {
+      if (this.cursorRow < this.lines.length - 1) {
+        this.cursorRow++;
+        this.cursorCol = 0;
+      }
+      return;
+    }
+    const codePoints = Array.from(line);
+    const strCursor = codePoints.slice(0, this.cursorCol).join("").length;
+    const segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+    const segments = Array.from(segmenter.segment(line));
+    for (const seg of segments) {
+      const segEnd = seg.index + seg.segment.length;
+      if (seg.isWordLike && segEnd > strCursor) {
+        this.cursorCol = strToCpIndex(line, segEnd);
+        this.ensureCursorVisible();
+        return;
+      }
+    }
+    this.cursorCol = lineLen;
+    this.ensureCursorVisible();
+  }
+  /** Moves cursor to the start of the current line. */
+  moveHome() {
+    this.preferredCol = null;
+    this.cursorCol = 0;
+  }
+  /** Moves cursor to the end of the current line. */
+  moveEnd() {
+    this.preferredCol = null;
+    this.cursorCol = cpLen(this.lines[this.cursorRow]);
+  }
+  // ---------------------------------------------------------------------------
+  // Mutations
+  // ---------------------------------------------------------------------------
+  /**
+   * Inserts text at the current cursor position.
+   *
+   * - Control characters (except `\n`, `\r`, `\t`) are stripped.
+   * - `\r\n` and `\r` are normalized to `\n`.
+   * - Newlines split the current line.
+   * - Cursor advances to the end of the inserted text.
+   */
+  insert(text) {
+    if (text === "") return;
+    this.preferredCol = null;
+    this.layoutDirty = true;
+    const cleaned = text.replace(CONTROL_CHAR_RE, "");
+    const normalized = normalizeNewlines(cleaned);
+    const insertLines = normalized.split("\n");
+    const currentLine = this.lines[this.cursorRow];
+    const before = cpSlice(currentLine, 0, this.cursorCol);
+    const after = cpSlice(currentLine, this.cursorCol);
+    if (insertLines.length === 1) {
+      this.lines[this.cursorRow] = before + insertLines[0] + after;
+      this.cursorCol += cpLen(insertLines[0]);
+    } else {
+      const firstLine = before + insertLines[0];
+      const lastLine = insertLines[insertLines.length - 1] + after;
+      const newLines = [
+        firstLine,
+        ...insertLines.slice(1, -1),
+        lastLine
+      ];
+      this.lines.splice(this.cursorRow, 1, ...newLines);
+      this.cursorRow += insertLines.length - 1;
+      this.cursorCol = cpLen(insertLines[insertLines.length - 1]);
+    }
+    this.ensureCursorVisible();
+  }
+  /**
+   * Deletes the character before the cursor (backspace behavior).
+   *
+   * - At column 0 of a line, merges with the previous line.
+   * - At the start of the buffer, does nothing.
+   */
+  backspace() {
+    this.preferredCol = null;
+    this.layoutDirty = true;
+    if (this.cursorCol > 0) {
+      const line = this.lines[this.cursorRow];
+      this.lines[this.cursorRow] = cpSlice(line, 0, this.cursorCol - 1) + cpSlice(line, this.cursorCol);
+      this.cursorCol--;
+    } else if (this.cursorRow > 0) {
+      const prevLine = this.lines[this.cursorRow - 1];
+      const prevLen = cpLen(prevLine);
+      this.lines[this.cursorRow - 1] = prevLine + this.lines[this.cursorRow];
+      this.lines.splice(this.cursorRow, 1);
+      this.cursorRow--;
+      this.cursorCol = prevLen;
+    }
+    this.ensureCursorVisible();
+  }
+  /**
+   * Deletes the character at the cursor position (forward delete behavior).
+   *
+   * - At the end of a line, merges with the next line.
+   * - At the end of the buffer, does nothing.
+   */
+  delete() {
+    this.preferredCol = null;
+    this.layoutDirty = true;
+    const line = this.lines[this.cursorRow];
+    const lineLen = cpLen(line);
+    if (this.cursorCol < lineLen) {
+      this.lines[this.cursorRow] = cpSlice(line, 0, this.cursorCol) + cpSlice(line, this.cursorCol + 1);
+    } else if (this.cursorRow < this.lines.length - 1) {
+      this.lines[this.cursorRow] = line + this.lines[this.cursorRow + 1];
+      this.lines.splice(this.cursorRow + 1, 1);
+    }
+    this.ensureCursorVisible();
+  }
+  /**
+   * Deletes from cursor to end of current line.
+   * If cursor is already at end of line, merges with the next line (like Delete at EOL).
+   */
+  deleteToEnd() {
+    this.preferredCol = null;
+    this.layoutDirty = true;
+    const line = this.lines[this.cursorRow];
+    const lineLen = cpLen(line);
+    if (this.cursorCol < lineLen) {
+      this.lines[this.cursorRow] = cpSlice(line, 0, this.cursorCol);
+    } else if (this.cursorRow < this.lines.length - 1) {
+      this.lines[this.cursorRow] = line + this.lines[this.cursorRow + 1];
+      this.lines.splice(this.cursorRow + 1, 1);
+    }
+    this.ensureCursorVisible();
+  }
+  /**
+   * Deletes from cursor to start of current line.
+   * Cursor moves to column 0.
+   */
+  deleteToStart() {
+    this.preferredCol = null;
+    this.layoutDirty = true;
+    const line = this.lines[this.cursorRow];
+    if (this.cursorCol > 0) {
+      this.lines[this.cursorRow] = cpSlice(line, this.cursorCol);
+      this.cursorCol = 0;
+    }
+    this.ensureCursorVisible();
+  }
+  /**
+   * Deletes the previous word before the cursor.
+   * Skips trailing spaces, then skips non-space characters.
+   * Uses code-point-safe string indexing.
+   */
+  deletePreviousWord() {
+    this.preferredCol = null;
+    this.layoutDirty = true;
+    if (this.cursorCol === 0) return;
+    const line = this.lines[this.cursorRow];
+    const beforeCursor = cpSlice(line, 0, this.cursorCol);
+    const chars = Array.from(beforeCursor);
+    let i = chars.length;
+    while (i > 0 && chars[i - 1] === " ") {
+      i--;
+    }
+    while (i > 0 && chars[i - 1] !== " ") {
+      i--;
+    }
+    const after = cpSlice(line, this.cursorCol);
+    this.lines[this.cursorRow] = chars.slice(0, i).join("") + after;
+    this.cursorCol = i;
+    this.ensureCursorVisible();
+  }
+  /**
+   * Sets cursor to (row, col) with bounds clamping.
+   * Row is clamped to [0, lineCount-1]. Col is clamped to [0, lineLen].
+   */
+  setCursorPosition(row, col) {
+    row = Math.max(0, Math.min(row, this.lines.length - 1));
+    const lineLen = cpLen(this.lines[row]);
+    col = Math.max(0, Math.min(col, lineLen));
+    this.cursorRow = row;
+    this.cursorCol = col;
+    this.preferredCol = null;
+    this.ensureCursorVisible();
+  }
+  /**
+   * Replaces all buffer content and moves the cursor to the end.
+   */
+  setText(text) {
+    this.layoutDirty = true;
+    const normalized = normalizeNewlines(text);
+    if (normalized === "") {
+      this.lines = [""];
+      this.cursorRow = 0;
+      this.cursorCol = 0;
+    } else {
+      this.lines = normalized.split("\n");
+      this.cursorRow = this.lines.length - 1;
+      this.cursorCol = cpLen(this.lines[this.cursorRow]);
+    }
+    this.ensureCursorVisible();
+  }
+  // ---------------------------------------------------------------------------
+  // Visual layout integration
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns the cached visual layout, recomputing it if dirty.
+   * The layout maps logical lines to word-wrapped visual lines.
+   */
+  getVisualLayout() {
+    if (this.layoutDirty || this.cachedLayout === null) {
+      this.cachedLayout = calculateLayout(this.lines, this.viewportWidth);
+      this.layoutDirty = false;
+    }
+    return this.cachedLayout;
+  }
+  /**
+   * Returns the visual (row, col) position of the cursor after wrapping.
+   * The visual row accounts for word-wrapped lines.
+   */
+  getVisualCursor() {
+    const layout = this.getVisualLayout();
+    const strCol = cpToStrIndex(this.lines[this.cursorRow], this.cursorCol);
+    return logicalToVisual(layout, this.cursorRow, strCol);
+  }
+  /** Returns the total number of visual lines after wrapping. */
+  getVisualLineCount() {
+    return this.getVisualLayout().visualLines.length;
+  }
+  /** Returns the current scroll row offset. */
+  getScrollRow() {
+    return this.scrollRow;
+  }
+  /**
+   * Returns the visual lines currently visible within the viewport.
+   * This is the slice `visualLines[scrollRow .. scrollRow + viewportHeight)`.
+   */
+  getRenderedLines() {
+    const layout = this.getVisualLayout();
+    return layout.visualLines.slice(
+      this.scrollRow,
+      this.scrollRow + this.viewportHeight
+    );
+  }
+  /**
+   * Updates viewport dimensions and marks the layout for recomputation.
+   */
+  setViewport(width, height) {
+    if (this.viewportWidth === width && this.viewportHeight === height) {
+      return;
+    }
+    this.viewportWidth = width;
+    this.viewportHeight = height;
+    this.layoutDirty = true;
+    this.ensureCursorVisible();
+  }
+  // ---------------------------------------------------------------------------
+  // Private: scroll management
+  // ---------------------------------------------------------------------------
+  /**
+   * Adjusts `scrollRow` so the visual cursor is within the visible viewport.
+   * Called after any cursor movement or layout change.
+   */
+  ensureCursorVisible() {
+    const layout = this.getVisualLayout();
+    const strCol = cpToStrIndex(this.lines[this.cursorRow], this.cursorCol);
+    const [visRow] = logicalToVisual(layout, this.cursorRow, strCol);
+    if (visRow < this.scrollRow) {
+      this.scrollRow = visRow;
+    } else if (visRow >= this.scrollRow + this.viewportHeight) {
+      this.scrollRow = visRow - this.viewportHeight + 1;
+    }
+  }
+};
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function cpToStrIndex(s, cpCol) {
+  const codePoints = Array.from(s);
+  const clamped = Math.min(cpCol, codePoints.length);
+  return codePoints.slice(0, clamped).join("").length;
+}
+function strToCpIndex(s, strIdx) {
+  const prefix = s.slice(0, strIdx);
+  return Array.from(prefix).length;
+}
+
+// src/ui/textBufferKeyHandler.ts
+var CONTROL_CHAR_RE2 = /^[\x00-\x1f\x7f]/;
+var CSI_ENTER_RESIDUAL_RE = /^(?:\x1b\[|\x1b|\[)?(?:13;?[234]?\d*[u~]|27;[234];13~)$/;
+function handleTextBufferKey(buffer, str, key) {
+  const name = key.name;
+  const ctrl = key.ctrl === true;
+  const meta = key.meta === true;
+  const shift = key.shift === true;
+  if (name === "return") {
+    if (shift || meta) {
+      buffer.insert("\n");
+      return "handled";
+    }
+    return "submit";
+  }
+  if (name === "backspace") {
+    buffer.backspace();
+    return "handled";
+  }
+  if (name === "delete") {
+    buffer.delete();
+    return "handled";
+  }
+  if (name === "left" && (ctrl || meta)) {
+    buffer.moveWordLeft();
+    return "handled";
+  }
+  if (name === "right" && (ctrl || meta)) {
+    buffer.moveWordRight();
+    return "handled";
+  }
+  if (name === "left") {
+    buffer.moveLeft();
+    return "handled";
+  }
+  if (name === "right") {
+    buffer.moveRight();
+    return "handled";
+  }
+  if (name === "up") {
+    buffer.moveUp();
+    return "handled";
+  }
+  if (name === "down") {
+    buffer.moveDown();
+    return "handled";
+  }
+  if (name === "home") {
+    buffer.moveHome();
+    return "handled";
+  }
+  if (name === "end") {
+    buffer.moveEnd();
+    return "handled";
+  }
+  if (ctrl && name === "a") {
+    buffer.moveHome();
+    return "handled";
+  }
+  if (ctrl && name === "e") {
+    buffer.moveEnd();
+    return "handled";
+  }
+  if (str && !CONTROL_CHAR_RE2.test(str) && !CSI_ENTER_RESIDUAL_RE.test(str)) {
+    buffer.insert(str);
+    return "handled";
+  }
+  return "unhandled";
+}
+
+// src/ui/inputPrompt.ts
+var promptEvents = new EventEmitter();
+function promptNotify(message) {
+  promptEvents.emit("notify", message);
+}
+function promptInterrupt(value) {
+  promptEvents.emit("interrupt", value);
+}
+function writePromptShellCommandHeader(output, command) {
+  output.write(`${chalk2.cyan(`You ran ${command}`)}
+`);
+}
+function createPromptShellCommandBlockWriter(output) {
+  let pending = "";
+  let pendingStream = "stdout";
+  let lineIndex = 0;
+  const flushLine = (line, stream) => {
+    const prefix = lineIndex === 0 ? "  \u2514 " : "    ";
+    output.write(`${prefix}${stream === "stderr" ? chalk2.red(line) : line}
+`);
+    lineIndex += 1;
+  };
+  const push = (chunk, stream) => {
+    pendingStream = stream;
+    pending += chunk;
+    while (true) {
+      const newlineIndex = pending.indexOf("\n");
+      const carriageIndex = pending.indexOf("\r");
+      const boundaryCandidates = [newlineIndex, carriageIndex].filter((value) => value >= 0);
+      if (boundaryCandidates.length === 0) {
+        break;
+      }
+      const boundaryIndex = Math.min(...boundaryCandidates);
+      const boundaryWidth = pending[boundaryIndex] === "\r" && pending[boundaryIndex + 1] === "\n" ? 2 : 1;
+      const line = pending.slice(0, boundaryIndex);
+      pending = pending.slice(boundaryIndex + boundaryWidth);
+      flushLine(line, stream);
+    }
+  };
+  return {
+    pushStdout(chunk) {
+      push(chunk, "stdout");
+    },
+    pushStderr(chunk) {
+      push(chunk, "stderr");
+    },
+    flush() {
+      if (!pending) {
+        return;
+      }
+      flushLine(pending, pendingStream);
+      pending = "";
+    }
+  };
+}
+var PROMPT_PREFIX = `${chalk2.gray("\u203A")} `;
+var STATUS_LINE_COUNT = 1;
+var PROMPT_LINES_ABOVE_INPUT = 1;
+var PROMPT_LINES_BELOW_INPUT = 1;
+var PROMPT_PLACEHOLDER = "Plan, search, build anything";
+var PROMPT_INPUT_PREFIX = "\u276F ";
+var SHIFT_ENTER_RESIDUAL_PATTERN = /^(?:\x1b\[|\x1b|\[)?(?:13;?[234]?\d*[u~]|27;[234];13~)$/;
+var HOT_TIP_LIMIT = 5;
+var SLASH_MATCH_EXACT = 0;
+var SLASH_MATCH_PREFIX = 1;
+var SLASH_MATCH_WORD_PREFIX = 2;
+var SLASH_MATCH_SUBSTRING = 3;
+var SLASH_MATCH_FUZZY = 4;
+function getHelpOrderedSlashCommands(slashCommands) {
+  return slashCommands.filter((cmd) => cmd.implemented && cmd.command !== "/?").sort((a, b) => a.command.localeCompare(b.command));
+}
+function getRankedSlashCommandMatches(seed, slashCommands) {
+  const normalizedSeed = seed.toLowerCase().trim();
+  const orderedCommands = getHelpOrderedSlashCommands(slashCommands);
+  if (!normalizedSeed) {
+    return orderedCommands;
+  }
+  return orderedCommands.map((command, helpOrder) => {
+    const commandName = command.command.slice(1).toLowerCase();
+    const match = rankSlashCommand(commandName, normalizedSeed);
+    return match ? { command, helpOrder, ...match } : null;
+  }).filter((match) => match !== null).sort(
+    (a, b) => a.rank - b.rank || a.firstIndex - b.firstIndex || a.spread - b.spread || a.helpOrder - b.helpOrder
+  ).map((match) => match.command);
+}
+function rankSlashCommand(commandName, seed) {
+  if (commandName === seed) {
+    return { rank: SLASH_MATCH_EXACT, firstIndex: 0, spread: seed.length };
+  }
+  if (commandName.startsWith(seed)) {
+    return { rank: SLASH_MATCH_PREFIX, firstIndex: 0, spread: seed.length };
+  }
+  const wordPrefixIndex = findSlashCommandWordPrefix(commandName, seed);
+  if (wordPrefixIndex !== -1) {
+    return { rank: SLASH_MATCH_WORD_PREFIX, firstIndex: wordPrefixIndex, spread: seed.length };
+  }
+  const substringIndex = commandName.indexOf(seed);
+  if (substringIndex !== -1) {
+    return { rank: SLASH_MATCH_SUBSTRING, firstIndex: substringIndex, spread: seed.length };
+  }
+  const fuzzyMatch = findSlashCommandFuzzyMatch(commandName, seed);
+  if (fuzzyMatch) {
+    return { rank: SLASH_MATCH_FUZZY, ...fuzzyMatch };
+  }
+  return null;
+}
+function findSlashCommandWordPrefix(commandName, seed) {
+  for (let index = 1; index < commandName.length; index++) {
+    const previous = commandName[index - 1];
+    if ((previous === "-" || previous === "_" || previous === "?") && commandName.startsWith(seed, index)) {
+      return index;
+    }
+  }
+  return -1;
+}
+function findSlashCommandFuzzyMatch(commandName, seed) {
+  let searchFrom = 0;
+  let firstIndex = -1;
+  let lastIndex = -1;
+  for (const char of seed) {
+    const index = commandName.indexOf(char, searchFrom);
+    if (index === -1) {
+      return null;
+    }
+    if (firstIndex === -1) {
+      firstIndex = index;
+    }
+    lastIndex = index;
+    searchFrom = index + 1;
+  }
+  return {
+    firstIndex,
+    spread: lastIndex - firstIndex + 1
+  };
+}
+var cachedSkillMentions;
+function resetCachedSkillMentions() {
+  cachedSkillMentions = void 0;
+}
+var CONTEXTUAL_HELP_ROWS = [
+  { left: "/ for commands", right: "! for shell commands" },
+  { left: "@ for file paths", right: "tab accepts suggestion" },
+  { left: "$ for skills", right: "tab accepts suggestion" },
+  { left: "? toggles this shortcuts panel", right: "shift + tab toggles plan mode" },
+  { left: "shift + enter inserts newline", right: "alt + enter inserts newline" },
+  { left: "enter submits prompt", right: "ctrl + c clears input / exits" },
+  { left: "esc interrupts active turn", right: "type /, @, or ! to switch mode" }
+];
+function truncatePlainText(value, width) {
+  if (width <= 0) {
+    return "";
+  }
+  if (value.length <= width) {
+    return value;
+  }
+  if (width === 1) {
+    return "\u2026";
+  }
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function buildPromptHotTips(currentLine, files, slashCommands, workspaceRoot, skillsProvider) {
+  const trimmed = currentLine.trim();
+  const mentionMatch = /@([A-Za-z0-9_./\\-]*)$/.exec(currentLine);
+  if (mentionMatch) {
+    const seed = mentionMatch[1] ?? "";
+    const suggestions = buildFileMentionSuggestions(files, seed, HOT_TIP_LIMIT);
+    const mentionTips = suggestions.map((file) => ({
+      label: `Tab -> @${file}`
+    }));
+    return mentionTips.length > 0 ? mentionTips : [{ label: "Type more after @ to filter file paths" }];
+  }
+  const skillMatch = /\$([A-Za-z0-9_-]*)$/.exec(currentLine);
+  if (skillMatch && skillsProvider) {
+    const seed = skillMatch[1] ?? "";
+    const skills = cachedSkillMentions ?? skillsProvider();
+    if (cachedSkillMentions === void 0) {
+      cachedSkillMentions = skills;
+    }
+    const suggestions = buildSkillMentionSuggestions(skills, seed, HOT_TIP_LIMIT);
+    const skillTips = suggestions.map((name) => ({
+      label: `Tab -> $${name}`
+    }));
+    return skillTips.length > 0 ? skillTips : [{ label: "Type more after $ to filter skills" }];
+  }
+  if (trimmed.startsWith("/")) {
+    const slashInput = currentLine.replace(/^\s+/, "");
+    const spaceIdx = slashInput.indexOf(" ");
+    if (spaceIdx !== -1) {
+      const cmdPart = slashInput.slice(0, spaceIdx).toLowerCase();
+      const subSeed = slashInput.slice(spaceIdx + 1).toLowerCase().trim();
+      const parent = slashCommands.find((cmd) => cmd.command.toLowerCase() === cmdPart);
+      if (parent?.subcommands && parent.subcommands.length > 0) {
+        const subMatches = parent.subcommands.filter(
+          (sub) => subSeed === "" ? true : sub.name.toLowerCase().startsWith(subSeed)
+        ).slice(0, HOT_TIP_LIMIT).map((sub) => ({
+          label: `Tab -> ${parent.command} ${sub.name} (${sub.description})`
+        }));
+        if (subMatches.length > 0) {
+          return subMatches;
+        }
+      }
+    }
+    const seed = trimmed.slice(1).toLowerCase();
+    const matches = getRankedSlashCommandMatches(seed, slashCommands).slice(0, HOT_TIP_LIMIT).map((cmd) => ({
+      label: `Tab -> ${cmd.command}${cmd.description ? ` (${cmd.description})` : ""}`
+    }));
+    return matches.length > 0 ? matches : [{ label: "No slash command match. Try /help" }];
+  }
+  if (trimmed.startsWith("!")) {
+    const shellSuggestions = getShellCommandSuggestions(trimmed, {
+      cwd: workspaceRoot,
+      limit: HOT_TIP_LIMIT
+    });
+    return shellSuggestions.length > 0 ? shellSuggestions.map((value) => ({ label: `Tab -> ${value}` })) : [{ label: "Type a shell command after ! (e.g. ! git status)" }];
+  }
+  const defaultFileTip = files.length > 0 ? { label: `Tab -> @${files[0]}` } : { label: "Type @ to mention files" };
+  return [
+    { label: "Tab -> /help" },
+    { label: "Tab -> ! git status" },
+    defaultFileTip,
+    { label: "Type $ for skills" },
+    { label: "Type /, @, or ! to switch suggestion mode" },
+    { label: "Shift+Tab toggles plan mode" }
+  ];
+}
+function getPrimaryHotTipSuggestion(currentLine, files, slashCommands, options, workspaceRoot, skillsProvider) {
+  const normalizedOptions = normalizePromptSuggestionOptions(options, workspaceRoot, skillsProvider);
+  const mentionMatch = /@([A-Za-z0-9_./\\-]*)$/.exec(currentLine);
+  if (mentionMatch) {
+    const seed = mentionMatch[1] ?? "";
+    const suggestions = buildFileMentionSuggestions(files, seed, 1);
+    if (suggestions.length === 0) {
+      return null;
+    }
+    const prefix = currentLine.slice(0, mentionMatch.index);
+    const line = `${prefix}@${suggestions[0]} `;
+    return { line, cursor: line.length };
+  }
+  const skillMatch = /\$([A-Za-z0-9_-]*)$/.exec(currentLine);
+  if (skillMatch && normalizedOptions.skillsProvider) {
+    const seed = skillMatch[1] ?? "";
+    const skills = cachedSkillMentions ?? normalizedOptions.skillsProvider();
+    if (cachedSkillMentions === void 0) {
+      cachedSkillMentions = skills;
+    }
+    const suggestions = buildSkillMentionSuggestions(skills, seed, 1);
+    if (suggestions.length === 0) {
+      return null;
+    }
+    const prefix = currentLine.slice(0, skillMatch.index);
+    const line = `${prefix}$${suggestions[0]} `;
+    return { line, cursor: line.length };
+  }
+  const trimmed = currentLine.trim();
+  if (!trimmed) {
+    const nextPromptSuggestion = normalizedOptions.nextPromptSuggestion?.trim();
+    if (nextPromptSuggestion) {
+      return { line: nextPromptSuggestion, cursor: nextPromptSuggestion.length };
+    }
+    return null;
+  }
+  if (trimmed.startsWith("/")) {
+    const slashInput = currentLine.replace(/^\s+/, "");
+    const spaceIdx = slashInput.indexOf(" ");
+    if (spaceIdx !== -1) {
+      const cmdPart = slashInput.slice(0, spaceIdx).toLowerCase();
+      const subSeed = slashInput.slice(spaceIdx + 1).toLowerCase().trim();
+      const parent = slashCommands.find((cmd) => cmd.command.toLowerCase() === cmdPart);
+      if (parent?.subcommands && parent.subcommands.length > 0) {
+        const subMatch = parent.subcommands.find(
+          (sub) => subSeed === "" ? true : sub.name.toLowerCase().startsWith(subSeed)
+        );
+        if (subMatch) {
+          const line2 = `${parent.command} ${subMatch.name} `;
+          return { line: line2, cursor: line2.length };
+        }
+      }
+      return null;
+    }
+    const seed = trimmed.slice(1).toLowerCase();
+    const match = getRankedSlashCommandMatches(seed, slashCommands)[0];
+    if (!match) {
+      return null;
+    }
+    const line = `${match.command} `;
+    return { line, cursor: line.length };
+  }
+  if (trimmed.startsWith("!")) {
+    const suggestion = getPrimaryShellCommandSuggestion(trimmed, { cwd: normalizedOptions.workspaceRoot });
+    if (!suggestion) {
+      return null;
+    }
+    return { line: suggestion, cursor: suggestion.length };
+  }
+  return null;
+}
+function normalizePromptSuggestionOptions(options, workspaceRoot, skillsProvider) {
+  if (typeof options === "string") {
+    return {
+      nextPromptSuggestion: options,
+      workspaceRoot,
+      skillsProvider
+    };
+  }
+  return {
+    ...options,
+    workspaceRoot: options?.workspaceRoot ?? workspaceRoot,
+    skillsProvider: options?.skillsProvider ?? skillsProvider
+  };
+}
+function getInlineGhostCompletionSuffix(currentLine, files, slashCommands, workspaceRoot, llmSuggestion, skillsProvider) {
+  const trimmed = currentLine.trim();
+  if (!trimmed.startsWith("/") && !trimmed.startsWith("@") && !trimmed.startsWith("!") && !trimmed.startsWith("$")) {
+    return null;
+  }
+  const cleanLlmSuggestion = sanitizeRenderLine(llmSuggestion ?? "");
+  if (cleanLlmSuggestion && cleanLlmSuggestion.startsWith(currentLine) && cleanLlmSuggestion !== currentLine) {
+    return cleanLlmSuggestion.slice(currentLine.length);
+  }
+  const suggestion = getPrimaryHotTipSuggestion(
+    currentLine,
+    files,
+    slashCommands,
+    { workspaceRoot, skillsProvider }
+  );
+  if (!suggestion) {
+    return null;
+  }
+  if (!suggestion.line.startsWith(currentLine)) {
+    return null;
+  }
+  const suffix = suggestion.line.slice(currentLine.length);
+  return suffix.length > 0 ? suffix : null;
+}
+function buildContextualHelpPanelLines(currentLine, width, files, slashCommands, skillsProvider) {
+  const panelWidth = Math.max(20, width);
+  const gap = 3;
+  const leftWidth = Math.max(12, Math.floor((panelWidth - gap) / 2));
+  const rightWidth = Math.max(12, panelWidth - leftWidth - gap);
+  const tips = buildPromptHotTips(currentLine, files, slashCommands, void 0, skillsProvider);
+  const primaryTip = tips[0]?.label ?? "Tab -> /help";
+  const secondaryTip = tips[1]?.label ?? "Type /, @, or ! to switch suggestion mode";
+  const formatCell = (value, cellWidth) => {
+    const plain = sanitizeRenderLine(value);
+    return truncatePlainText(plain, cellWidth).padEnd(cellWidth, " ");
+  };
+  const rowLines = CONTEXTUAL_HELP_ROWS.map((row) => {
+    const left = formatCell(row.left, leftWidth);
+    const right = formatCell(row.right, rightWidth);
+    return `${left}${" ".repeat(gap)}${right}`;
+  });
+  const lines = [
+    " ? shortcuts",
+    ...rowLines,
+    "",
+    ` hot tip: ${primaryTip}`,
+    ` tab applies suggestion: ${secondaryTip}`
+  ];
+  return lines.map(
+    (line) => chalk2.bgHex("#2b2b2b").hex("#a8a8a8")(truncatePlainText(line, panelWidth).padEnd(panelWidth, " "))
+  );
+}
+function buildContextualPromptStatusLine(currentLine, files, slashCommands, skillsProvider) {
+  const tips = buildPromptHotTips(currentLine, files, slashCommands, void 0, skillsProvider);
+  const primaryTip = tips[0]?.label ?? "Tab -> /help";
+  return `hot tip: ${primaryTip}`;
+}
+function buildSlashSuggestionLines(currentLine, width, slashCommands) {
+  const input = currentLine.replace(/^\s+/, "");
+  if (!input.startsWith("/")) {
+    return [];
+  }
+  const panelWidth = Math.max(20, width);
+  const subcommandResult = buildSubcommandSuggestions(input, panelWidth, slashCommands);
+  if (subcommandResult !== null) {
+    return subcommandResult;
+  }
+  const seed = input.slice(1).toLowerCase();
+  const matches = getRankedSlashCommandMatches(seed, slashCommands).slice(0, HOT_TIP_LIMIT);
+  if (matches.length === 0) {
+    return [];
+  }
+  return formatSuggestionLines(
+    matches.map((m) => ({ name: m.command, description: m.description ?? "" })),
+    panelWidth
+  );
+}
+function buildSubcommandSuggestions(input, panelWidth, slashCommands) {
+  const spaceIdx = input.indexOf(" ");
+  if (spaceIdx === -1) {
+    return null;
+  }
+  const cmdPart = input.slice(0, spaceIdx).toLowerCase();
+  const subSeed = input.slice(spaceIdx + 1).toLowerCase().trim();
+  const parent = slashCommands.find(
+    (cmd) => cmd.command.toLowerCase() === cmdPart
+  );
+  if (!parent) {
+    return null;
+  }
+  if (!parent.subcommands || parent.subcommands.length === 0) {
+    return [];
+  }
+  const matches = parent.subcommands.filter(
+    (sub) => subSeed === "" ? true : sub.name.toLowerCase().startsWith(subSeed)
+  ).slice(0, HOT_TIP_LIMIT);
+  if (matches.length === 0) {
+    return [];
+  }
+  return formatSuggestionLines(
+    matches.map((m) => ({ name: `${parent.command} ${m.name}`, description: m.description })),
+    panelWidth
+  );
+}
+function formatSuggestionLines(entries, panelWidth) {
+  const maxNameLen = Math.min(
+    24,
+    Math.max(...entries.map((e) => e.name.length))
+  );
+  return entries.map((entry, i) => {
+    const prefix = i === 0 ? " \u25B8 " : "   ";
+    const namePadded = entry.name.padEnd(maxNameLen + 1);
+    const content = `${prefix}${namePadded}${entry.description}`;
+    return chalk2.bgHex("#1e1e2e").hex("#cdd6f4")(
+      truncatePlainText(content, panelWidth).padEnd(panelWidth, " ")
+    );
+  });
+}
+var PASTED_REFERENCE_PATTERN = /\[Text [Pp]asted(?:\s+\+?\d+\s+(?:chars|lines)|:\s*\d+\s+lines)\]/;
+function removePastedReferenceFromLine(line) {
+  const match = PASTED_REFERENCE_PATTERN.exec(line);
+  if (!match) {
+    return null;
+  }
+  const start = match.index;
+  const end = start + match[0].length;
+  return {
+    line: `${line.slice(0, start)}${line.slice(end)}`,
+    cursor: start
+  };
+}
+function isShiftTabShortcut(str, key) {
+  const sequence = key?.sequence ?? str;
+  return key?.name === "backtab" || key?.name === "tab" && key.shift === true || sequence === "\x1B[Z";
+}
+function isPlainTabShortcut(str, key) {
+  if (isShiftTabShortcut(str, key)) {
+    return false;
+  }
+  return key?.name === "tab" || key?.sequence === "	" || str === "	";
+}
+function isRightArrowAcceptShortcut(key) {
+  return key?.name === "right";
+}
+function isShiftEnterSequence(str, key) {
+  if (key?.name === "return" && (key.shift || key.meta)) {
+    return true;
+  }
+  const seq = key?.sequence ?? str ?? "";
+  if (/^\x1b\[13;?[234]?\d*[u~]$/.test(seq)) {
+    return true;
+  }
+  if (/^\x1b\[27;[234];13~$/.test(seq)) {
+    return true;
+  }
+  if (seq === "\x1B\r" || seq === "\x1B\n") {
+    return true;
+  }
+  return false;
+}
+function isShiftEnterResidualSequence(sequence) {
+  return SHIFT_ENTER_RESIDUAL_PATTERN.test(sequence ?? "");
+}
+function countResidualModifiedEnterSequences(chunk) {
+  if (!chunk) {
+    return 0;
+  }
+  const matches = chunk.match(/(?:13;?[234]?\d*[u~]|27;[234];13~)/g);
+  if (!matches || matches.length === 0) {
+    return 0;
+  }
+  return matches.join("") === chunk ? matches.length : 0;
+}
+function countRawModifiedEnterSequences(chunk) {
+  if (!chunk) {
+    return 0;
+  }
+  const matches = chunk.match(/\x1b(?:\[13;?[234]?\d*[u~]|\[27;[234];13~|\r|\n)/g);
+  return matches?.length ?? 0;
+}
+function shouldAutoHideShortcutHelp(str, key) {
+  if (isPlainTabShortcut(str, key) || isShiftTabShortcut(str, key)) {
+    return false;
+  }
+  if (key?.ctrl || key?.meta) {
+    return false;
+  }
+  if (key?.name === "escape") {
+    return false;
+  }
+  if (key?.name === "up" || key?.name === "down" || key?.name === "left" || key?.name === "right") {
+    return false;
+  }
+  if (key?.name === "backspace" || key?.name === "delete") {
+    return true;
+  }
+  if (!str) {
+    return false;
+  }
+  return str !== "\r" && str !== "\n";
+}
+function sanitizeRenderLine(line) {
+  if (!line) return "";
+  const withoutAnsi = line.replace(/\u001b\[[0-9;]*[A-Za-z]/g, "");
+  return withoutAnsi.replace(/[\x00-\x1F\x7F]/g, "");
+}
+function getPromptBlockWidth(columns) {
+  const terminalWidth = Math.max(10, columns ?? 80);
+  return Math.max(10, terminalWidth - 1);
+}
+function renderSegment(rawSegment, cursorPos, width, prefix, showPlaceholder, renderOptions, legacyInlineGhostSuffix) {
+  const {
+    placeholderText,
+    nextPromptSuggestion,
+    inlineGhostSuffix
+  } = normalizePromptRenderOptions(renderOptions, legacyInlineGhostSuffix);
+  const sanitizedLine = sanitizeRenderLine(rawSegment);
+  const normalizedLine = sanitizedLine.trim().length === 0 ? "" : sanitizedLine;
+  const innerWidth = Math.max(1, width - 2);
+  const effectiveCursor = Math.max(0, Math.min(normalizedLine.length, cursorPos));
+  const fullInput = `${prefix}${normalizedLine}`;
+  const safeGhostSuffix = sanitizeRenderLine(inlineGhostSuffix ?? "");
+  let visibleText = fullInput;
+  let cursorColumn = prefix.length + effectiveCursor;
+  const fullCursor = prefix.length + effectiveCursor;
+  let ghostFragment = "";
+  if (showPlaceholder && !normalizedLine) {
+    const placeholder = `${prefix}${placeholderText}`;
+    const displayPlaceholder = nextPromptSuggestion?.trim() ? `${prefix}${nextPromptSuggestion}` : placeholder;
+    visibleText = chalk2.gray(displayPlaceholder);
+    cursorColumn = prefix.length;
+  } else if (!normalizedLine) {
+    visibleText = prefix;
+    cursorColumn = prefix.length;
+  } else if (fullInput.length > innerWidth) {
+    const ellipsis = "\u2026";
+    const nearStartThreshold = innerWidth - 1;
+    const nearEndThreshold = innerWidth - 1;
+    if (fullCursor <= nearStartThreshold) {
+      const body = fullInput.slice(0, Math.max(1, innerWidth - 1));
+      visibleText = `${body}${ellipsis}`;
+      cursorColumn = fullCursor;
+    } else if (fullInput.length - fullCursor <= nearEndThreshold) {
+      const start = Math.max(0, fullInput.length - Math.max(1, innerWidth - 1));
+      const body = fullInput.slice(start);
+      visibleText = `${ellipsis}${body}`;
+      cursorColumn = 1 + (fullCursor - start);
+    } else {
+      const windowSize = Math.max(1, innerWidth - 2);
+      const half = Math.floor(windowSize / 2);
+      const minStart = 1;
+      const maxStart = Math.max(minStart, fullInput.length - windowSize - 1);
+      const start = Math.max(minStart, Math.min(maxStart, fullCursor - half));
+      const body = fullInput.slice(start, start + windowSize);
+      visibleText = `${ellipsis}${body}${ellipsis}`;
+      cursorColumn = 1 + (fullCursor - start);
+    }
+  }
+  let styledText = visibleText;
+  if (showPlaceholder && !normalizedLine) {
+    styledText = themedFg("muted", visibleText, (value) => chalk2.gray(value));
+  } else if (visibleText.startsWith(prefix)) {
+    const prefixStyled = themedFg("accent", prefix, (value) => chalk2.gray(value));
+    styledText = `${prefixStyled}${visibleText.slice(prefix.length)}`;
+  } else if (visibleText.startsWith(`\u2026${prefix}`)) {
+    const prefixStyled = themedFg("accent", prefix, (value) => chalk2.gray(value));
+    styledText = `\u2026${prefixStyled}${visibleText.slice(`\u2026${prefix}`.length)}`;
+  }
+  if (normalizedLine && safeGhostSuffix && fullInput.length <= innerWidth && effectiveCursor === normalizedLine.length) {
+    const availableGhostWidth = Math.max(0, innerWidth - fullInput.length);
+    if (availableGhostWidth > 0) {
+      ghostFragment = safeGhostSuffix.slice(0, availableGhostWidth);
+    }
+  }
+  if (ghostFragment) {
+    styledText += themedFg("muted", ghostFragment, (value) => chalk2.gray(value));
+  }
+  return { styledText, cursorColumn };
+}
+function normalizePromptRenderOptions(options, legacyInlineGhostSuffix) {
+  if (typeof options === "string") {
+    return {
+      placeholderText: PROMPT_PLACEHOLDER,
+      nextPromptSuggestion: options,
+      inlineGhostSuffix: legacyInlineGhostSuffix ?? ""
+    };
+  }
+  return {
+    placeholderText: options?.placeholderText ?? PROMPT_PLACEHOLDER,
+    nextPromptSuggestion: options?.nextPromptSuggestion ?? "",
+    inlineGhostSuffix: options?.inlineGhostSuffix ?? legacyInlineGhostSuffix ?? ""
+  };
+}
+function buildPromptRenderState(currentLine, cursorPos, width, options, inlineGhostSuffix) {
+  const segment = renderSegment(
+    currentLine,
+    cursorPos,
+    width,
+    PROMPT_INPUT_PREFIX,
+    true,
+    options,
+    inlineGhostSuffix
+  );
+  const lineText = drawInputBox(segment.styledText, width);
+  const clampedCursor = Math.max(0, Math.min(width - 1, segment.cursorColumn + 1));
+  return { lineText, cursorColumn: clampedCursor };
+}
+function buildMultiLineRenderState(currentLine, cursorPos, width, borderStyle = "default", options, inlineGhostSuffix) {
+  const renderOptions = normalizePromptRenderOptions(options, inlineGhostSuffix);
+  const { segments, separatorLengths } = splitMultilineSegments(currentLine);
+  const innerWidth = Math.max(1, width - 2);
+  const continuationPrefix = "  ";
+  const contentWidth = Math.max(1, innerWidth - continuationPrefix.length);
+  if (segments.length <= 1) {
+    const singleSegment = sanitizeRenderLine(segments[0] ?? "");
+    const singleLayout = calculateLayout([singleSegment], contentWidth);
+    if (singleLayout.visualLines.length <= 1) {
+      const seg = renderSegment(
+        currentLine,
+        cursorPos,
+        width,
+        PROMPT_INPUT_PREFIX,
+        true,
+        renderOptions
+      );
+      const lineText = drawInputBox(seg.styledText, width, void 0, borderStyle);
+      const clampedCursor = Math.max(0, Math.min(width - 1, seg.cursorColumn + 1));
+      return { lines: [lineText], cursorRow: 0, cursorColumn: clampedCursor, lineCount: 1 };
+    }
+  }
+  if (currentLine.length === 0) {
+    const seg = renderSegment(
+      currentLine,
+      cursorPos,
+      width,
+      PROMPT_INPUT_PREFIX,
+      true,
+      renderOptions
+    );
+    const lineText = drawInputBox(seg.styledText, width, void 0, borderStyle);
+    const clampedCursor = Math.max(0, Math.min(width - 1, seg.cursorColumn + 1));
+    return { lines: [lineText], cursorRow: 0, cursorColumn: clampedCursor, lineCount: 1 };
+  }
+  let cursorRow = 0;
+  let cursorInSegment = 0;
+  let pos = 0;
+  for (let i = 0; i < segments.length; i++) {
+    const segEnd = pos + segments[i].length;
+    if (cursorPos <= segEnd || i === segments.length - 1) {
+      cursorRow = i;
+      cursorInSegment = Math.max(0, cursorPos - pos);
+      break;
+    }
+    pos = segEnd + (separatorLengths[i] ?? 0);
+  }
+  const lines = [];
+  let visualRowOffset = 0;
+  let overallVisualRow = 0;
+  let hasPromptPrefix = false;
+  let finalCursorColumn = 0;
+  for (let i = 0; i < segments.length; i++) {
+    const sanitizedSegment = sanitizeRenderLine(segments[i] ?? "");
+    const layout = calculateLayout([sanitizedSegment], contentWidth);
+    const wrappedLines = layout.visualLines.length > 0 ? layout.visualLines : [""];
+    if (i === cursorRow) {
+      const [wrappedCursorRow, wrappedCursorCol] = logicalToVisual(
+        layout,
+        0,
+        Math.max(0, Math.min(sanitizedSegment.length, cursorInSegment))
+      );
+      cursorRow = visualRowOffset + wrappedCursorRow;
+      finalCursorColumn = Math.max(
+        0,
+        Math.min(width - 1, continuationPrefix.length + wrappedCursorCol + 1)
+      );
+    }
+    for (let j = 0; j < wrappedLines.length; j++) {
+      const prefix = !hasPromptPrefix ? PROMPT_INPUT_PREFIX : continuationPrefix;
+      const prefixStyled = themedFg("accent", prefix, (value) => chalk2.gray(value));
+      const styledText = `${prefixStyled}${wrappedLines[j] ?? ""}`;
+      lines.push(drawInputBox(styledText, width, void 0, borderStyle));
+      hasPromptPrefix = true;
+      overallVisualRow += 1;
+    }
+    visualRowOffset += wrappedLines.length;
+  }
+  return {
+    lines,
+    cursorRow,
+    cursorColumn: finalCursorColumn,
+    lineCount: overallVisualRow
+  };
+}
+function splitMultilineSegments(value) {
+  const segments = [];
+  const separatorLengths = [];
+  let segmentStart = 0;
+  let i = 0;
+  while (i < value.length) {
+    if (value.startsWith(NEWLINE_MARKER, i)) {
+      segments.push(value.slice(segmentStart, i));
+      separatorLengths.push(NEWLINE_MARKER.length);
+      i += NEWLINE_MARKER.length;
+      segmentStart = i;
+      continue;
+    }
+    const ch = value[i];
+    if (ch === "\n") {
+      segments.push(value.slice(segmentStart, i));
+      separatorLengths.push(1);
+      i += 1;
+      segmentStart = i;
+      continue;
+    }
+    if (ch === "\r") {
+      const separatorLength = value[i + 1] === "\n" ? 2 : 1;
+      segments.push(value.slice(segmentStart, i));
+      separatorLengths.push(separatorLength);
+      i += separatorLength;
+      segmentStart = i;
+      continue;
+    }
+    i += 1;
+  }
+  segments.push(value.slice(segmentStart));
+  return { segments, separatorLengths };
+}
+function formatPromptStatusRow(statusLine, width) {
+  let left;
+  let right;
+  if (typeof statusLine === "object" && statusLine !== null) {
+    left = statusLine.left ?? "";
+    right = statusLine.right || void 0;
+  } else {
+    left = statusLine ?? " ";
+  }
+  const plainLeft = stripAnsiCodes(left);
+  let plainRight = right ? stripAnsiCodes(right) : "";
+  if (plainRight.length > width) {
+    plainRight = truncatePlainText(plainRight, width);
+  }
+  const minGap = plainRight ? 2 : 0;
+  const availableForLeft = Math.max(0, width - plainRight.length - minGap);
+  const clippedLeft = truncatePlainText(plainLeft, availableForLeft);
+  const gap = Math.max(0, width - clippedLeft.length - plainRight.length);
+  const row = `${clippedLeft}${" ".repeat(gap)}${plainRight}`;
+  return themedFg("muted", row.padEnd(width), (value) => chalk2.gray(value));
+}
+function createPasteState() {
+  return {
+    isInPaste: false,
+    buffer: "",
+    outputSuppressed: false
+  };
+}
+function installReadlineOutputGuard(rl) {
+  const rlWriter = rl;
+  const originalWriteToOutput = typeof rlWriter._writeToOutput === "function" ? rlWriter._writeToOutput.bind(rlWriter) : void 0;
+  if (!originalWriteToOutput) {
+    return {
+      setSuppressed: () => {
+      },
+      restore: () => {
+      }
+    };
+  }
+  let suppressed = false;
+  rlWriter._writeToOutput = (chunk) => {
+    if (!suppressed) {
+      originalWriteToOutput(chunk);
+    }
+  };
+  return {
+    setSuppressed: (nextSuppressed) => {
+      suppressed = nextSuppressed;
+    },
+    restore: () => {
+      rlWriter._writeToOutput = originalWriteToOutput;
+    }
+  };
+}
+var IMAGE_FILE_EXTENSIONS = "(?:png|jpg|jpeg|gif|webp)";
+var IMAGE_FILE_SUFFIX_REGEX = new RegExp(`\\.${IMAGE_FILE_EXTENSIONS}$`, "i");
+var ASCII_WHITESPACE = "[ \\t\\r\\n]";
+function createEscapedImagePathRegex(flags) {
+  return new RegExp(
+    `(?:^|${ASCII_WHITESPACE})((\\/|~)(?:[^ \\t\\r\\n\\\\]|\\\\.)+\\.${IMAGE_FILE_EXTENSIONS})(?=${ASCII_WHITESPACE}|$)`,
+    flags
+  );
+}
+function createSimpleImagePathRegex(flags) {
+  return new RegExp(
+    `(?:^|${ASCII_WHITESPACE})([^ \\t\\r\\n"']+\\.${IMAGE_FILE_EXTENSIONS})(?=${ASCII_WHITESPACE}|$)`,
+    flags
+  );
+}
+function hasPotentialImagePath(text) {
+  return createEscapedImagePathRegex("i").test(text) || createSimpleImagePathRegex("i").test(text);
+}
+function writeImageNotice(output, message, announce) {
+  if (!announce || !output) {
+    return;
+  }
+  output.write(chalk2.cyan(`
+${message}
+`));
+}
+function normalizeDragPathCandidates(rawPath) {
+  const trimmed = rawPath.trim();
+  if (!trimmed) return [];
+  const unquoted = trimmed.replace(/^"(.*)"$/s, "$1").replace(/^'(.*)'$/s, "$1");
+  const unescaped = unquoted.replace(/\\([ \t\r\n\u00a0\u202f])/g, "$1").replace(/\\([\\'"()])/g, "$1");
+  const broadlyUnescaped = unquoted.replace(/\\(.)/g, "$1");
+  const withHomeExpanded = (value) => {
+    if (value.startsWith("~/")) {
+      return `${os.homedir()}/${value.slice(2)}`;
+    }
+    return value;
+  };
+  const candidates = /* @__PURE__ */ new Set();
+  const push = (value) => {
+    if (!value) return;
+    candidates.add(value);
+    candidates.add(withHomeExpanded(value));
+    candidates.add(value.replace(/\u202f/g, " "));
+    candidates.add(withHomeExpanded(value.replace(/\u202f/g, " ")));
+    candidates.add(value.replace(/\u00a0/g, " "));
+    candidates.add(withHomeExpanded(value.replace(/\u00a0/g, " ")));
+    const withNNBSP = value.replace(/ (?=(?:AM|PM)\.)/gi, "\u202F");
+    if (withNNBSP !== value) {
+      candidates.add(withNNBSP);
+      candidates.add(withHomeExpanded(withNNBSP));
+    }
+  };
+  push(unquoted);
+  push(unescaped);
+  push(broadlyUnescaped);
+  return Array.from(candidates).filter(Boolean);
+}
+function processImagesInText(text, onImageDetected, options = {}) {
+  if (!onImageDetected) {
+    return text;
+  }
+  const announce = options.announce ?? true;
+  const output = options.output;
+  let result = text;
+  const replaceImagePath = (rawMatch) => {
+    const candidates = normalizeDragPathCandidates(rawMatch);
+    for (const candidatePath of candidates) {
+      if (!existsSync(candidatePath)) continue;
+      try {
+        const data = readFileSync(candidatePath);
+        const ext = extname(candidatePath);
+        const mimeType = getMimeTypeFromExtension(ext);
+        if (!mimeType) continue;
+        const id = onImageDetected(data, mimeType, basename(candidatePath));
+        result = result.replace(rawMatch, `[Image #${id}]`);
+        writeImageNotice(output, `\u{1F4F7} Loaded image: ${candidatePath} -> [Image #${id}]`, announce);
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  };
+  const base64Regex = /data:image\/[a-z]+;base64,[A-Za-z0-9+/=]+/g;
+  const base64Matches = result.match(base64Regex) || [];
+  for (const dataUrl of base64Matches) {
+    const parsed = parseBase64DataUrl(dataUrl);
+    if (!parsed) continue;
+    const id = onImageDetected(parsed.data, parsed.mimeType);
+    result = result.replace(dataUrl, `[Image #${id}]`);
+    writeImageNotice(output, `\u{1F4F7} Detected base64 image -> [Image #${id}]`, announce);
+  }
+  const quotedPathRegex = new RegExp(`["']([^"']+\\.${IMAGE_FILE_EXTENSIONS})["']`, "gi");
+  let quotedMatch;
+  while ((quotedMatch = quotedPathRegex.exec(text)) !== null) {
+    const fullMatch = quotedMatch[0];
+    if (!result.includes(fullMatch)) continue;
+    replaceImagePath(quotedMatch[1]) || replaceImagePath(fullMatch);
+  }
+  const escapedPathRegex = createEscapedImagePathRegex("gi");
+  let escapedMatch;
+  if (process.env.DEBUG_IMAGES && output) {
+    output.write(chalk2.gray(`
+[DEBUG] processImagesInText called
+`));
+    output.write(chalk2.gray(`[DEBUG] Input text: ${JSON.stringify(text)}
+`));
+    output.write(chalk2.gray(`[DEBUG] Has backslash: ${text.includes("\\")}
+`));
+    output.write(chalk2.gray(`[DEBUG] Char codes: ${text.slice(0, 50).split("").map((c) => c.charCodeAt(0)).join(",")}
+`));
+  }
+  while ((escapedMatch = escapedPathRegex.exec(text)) !== null) {
+    const rawPath = escapedMatch[1];
+    if (process.env.DEBUG_IMAGES && output) {
+      output.write(chalk2.gray(`[DEBUG] Regex matched: ${JSON.stringify(rawPath)}
+`));
+      const candidates = normalizeDragPathCandidates(rawPath);
+      output.write(chalk2.gray(`[DEBUG] Candidate paths: ${JSON.stringify(candidates)}
+`));
+    }
+    if (!result.includes(rawPath)) continue;
+    replaceImagePath(rawPath);
+  }
+  const simplePathRegex = createSimpleImagePathRegex("gi");
+  let simpleMatch;
+  while ((simpleMatch = simplePathRegex.exec(text)) !== null) {
+    const filePath = simpleMatch[1];
+    if (!result.includes(filePath)) {
+      continue;
+    }
+    replaceImagePath(filePath);
+  }
+  if (!result.includes("[Image #")) {
+    const trimmed = result.trim();
+    if (IMAGE_FILE_SUFFIX_REGEX.test(trimmed)) {
+      replaceImagePath(trimmed);
+    }
+  }
+  return result;
+}
+var NEWLINE_MARKER = " \u21B5 ";
+var NEWLINE_MARKER_REGEX = new RegExp(escapeRegex(NEWLINE_MARKER), "g");
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var instrumentedStreams = /* @__PURE__ */ new WeakSet();
+function safeEmitKeypressEvents(stream) {
+  if (!instrumentedStreams.has(stream)) {
+    readline2.emitKeypressEvents(stream);
+    instrumentedStreams.add(stream);
+  }
+}
+function convertNewlineMarkersToNewlines(text) {
+  return text.replace(NEWLINE_MARKER_REGEX, "\n").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+async function readInstruction(filesProvider, slashCommands, statusLine, io = {}, onImageDetected, workspaceRoot, initialValue = "", nextPromptSuggestionProvider, resolveShellSuggestion, pendingSuggestion, skillsProvider) {
+  const stdInput = io.input ?? process.stdin;
+  const stdOutput = io.output ?? process.stdout;
+  const keepAlive = setInterval(() => {
+  }, 1e4);
+  try {
+    while (true) {
+      await new Promise((resolve) => process.nextTick(resolve));
+      const result = await promptOnce({
+        filesProvider,
+        slashCommands,
+        statusLine,
+        initialValue,
+        stdInput,
+        stdOutput,
+        onImageDetected,
+        workspaceRoot,
+        nextPromptSuggestionProvider,
+        resolveShellSuggestion,
+        pendingSuggestion,
+        skillsProvider
+      });
+      if (result.kind === "abort") {
+        return "ABORT";
+      }
+      return result.value;
+    }
+  } finally {
+    clearInterval(keepAlive);
+  }
+}
+function drainStdin(input) {
+  let chunk;
+  do {
+    chunk = input.read();
+  } while (chunk !== null);
+}
+function createReadline(stdInput, stdOutput) {
+  stdOutput.write("\r");
+  safeEmitKeypressEvents(stdInput);
+  try {
+    stdInput.resume();
+    drainStdin(stdInput);
+  } catch {
+  }
+  enableBracketedPaste(stdOutput);
+  try {
+    stdInput.resume();
+  } catch {
+  }
+  let rl;
+  try {
+    rl = readline2.createInterface({
+      input: stdInput,
+      output: stdOutput,
+      prompt: PROMPT_PREFIX,
+      terminal: true,
+      crlfDelay: Infinity,
+      historySize: 100,
+      tabSize: 2
+    });
+  } catch {
+    rl = readline2.createInterface({
+      input: stdInput,
+      output: stdOutput,
+      prompt: PROMPT_PREFIX,
+      terminal: false,
+      crlfDelay: Infinity,
+      historySize: 100,
+      tabSize: 2
+    });
+  }
+  disableReadlineTabBehavior(rl);
+  const input = rl.input;
+  const supportsRawMode = typeof input.setRawMode === "function";
+  if (supportsRawMode && input.isTTY) {
+    safeSetRawMode(input, true);
+  }
+  input.resume();
+  input.setEncoding("utf8");
+  return { rl, input, supportsRawMode };
+}
+function leavePromptSurface(output, statusLineCount = STATUS_LINE_COUNT, fromLineEvent = false) {
+  const numContentLines = lastRenderedContentLines;
+  const cursorRow = lastRenderedCursorRow;
+  if (fromLineEvent) {
+    const normalizationRows = PROMPT_LINES_BELOW_INPUT;
+    for (let i = 0; i < normalizationRows; i++) {
+      readline2.moveCursor(output, 0, -1);
+    }
+  }
+  readline2.cursorTo(output, 0);
+  readline2.clearLine(output, 0);
+  for (let i = 0; i < cursorRow + PROMPT_LINES_ABOVE_INPUT; i++) {
+    readline2.moveCursor(output, 0, -1);
+    readline2.clearLine(output, 0);
+  }
+  for (let i = 0; i < cursorRow + PROMPT_LINES_ABOVE_INPUT; i++) {
+    readline2.moveCursor(output, 0, 1);
+  }
+  const belowCount = numContentLines - 1 - cursorRow + PROMPT_LINES_BELOW_INPUT + lastRenderedHelpLines + statusLineCount + lastRenderedSlashLines;
+  for (let i = 0; i < belowCount; i++) {
+    readline2.moveCursor(output, 0, 1);
+    readline2.clearLine(output, 0);
+  }
+  const upToTop = PROMPT_LINES_ABOVE_INPUT + cursorRow + belowCount;
+  readline2.moveCursor(output, 0, -upToTop);
+  readline2.cursorTo(output, 0);
+}
+function handlePasteComplete(pasteState, rl, output, renderActivePrompt) {
+  const display = getContentDisplay(pasteState.buffer);
+  const rlAny = rl;
+  const prefix = pasteState.prefixContent || "";
+  if (!pasteState.outputSuppressed) {
+    const newlineCount = (pasteState.buffer.match(/\n/g) || []).length;
+    for (let i = 0; i < newlineCount; i++) {
+      readline2.moveCursor(output, 0, -1);
+      readline2.clearLine(output, 0);
+    }
+    readline2.cursorTo(output, 0);
+    readline2.clearLine(output, 0);
+  }
+  if (display.isPasted) {
+    pasteState.hiddenContent = prefix + display.actual;
+    rlAny.line = prefix + display.visual;
+    rlAny.cursor = rlAny.line.length;
+  } else {
+    rlAny.line = prefix + display.actual;
+    rlAny.cursor = rlAny.line.length;
+  }
+  renderActivePrompt();
+  pasteState.buffer = "";
+  pasteState.outputSuppressed = false;
+  pasteState.prefixContent = void 0;
+}
+async function promptOnce(options) {
+  const {
+    filesProvider,
+    slashCommands,
+    statusLine,
+    initialValue,
+    stdInput,
+    stdOutput,
+    onImageDetected,
+    workspaceRoot,
+    nextPromptSuggestionProvider,
+    resolveShellSuggestion,
+    pendingSuggestion,
+    skillsProvider
+  } = options;
+  resetPromptRenderState();
+  const { rl, input, supportsRawMode } = createReadline(stdInput, stdOutput);
+  const tbWidth = Math.max(1, getPromptBlockWidth(stdOutput.columns) - 2);
+  const tbMaxVisibleLines = 10;
+  const initialLine = sanitizeRenderLine(initialValue ?? "");
+  const textBuffer = new TextBuffer(tbWidth, tbMaxVisibleLines, initialLine || void 0);
+  activeTextBuffer = textBuffer;
+  const mentionPreview = new MentionPreview(
+    rl,
+    filesProvider,
+    slashCommands,
+    stdOutput,
+    skillsProvider ?? (() => []),
+    (line, cursorPos) => {
+      textBuffer.setText(line);
+      textBuffer.setCursorPosition(0, cursorPos);
+      syncReadlineFromBuffer();
+    }
+  );
+  const pasteState = createPasteState();
+  let contextualHelpVisible = false;
+  let llmInlineShellSuggestion = null;
+  let chordState = "none";
+  let chordTimeout = null;
+  const applyPlanModePrefix = (line) => {
+    const planPrefix = getPlanModeManager().isEnabled() ? "plan:on" : "plan:off";
+    if (!line) {
+      return planPrefix;
+    }
+    if (line.startsWith("plan:on \xB7 ") || line.startsWith("plan:off \xB7 ")) {
+      const separatorIndex = line.indexOf(" \xB7 ");
+      return `${planPrefix}${line.slice(separatorIndex)}`;
+    }
+    return `${planPrefix} \xB7 ${line}`;
+  };
+  const getActiveStatusLine = () => {
+    if (typeof statusLine === "object" && statusLine !== null) {
+      return statusLine;
+    }
+    return applyPlanModePrefix(statusLine ?? "");
+  };
+  const getCurrentText = () => textBuffer.getText();
+  const syncReadlineFromBuffer = () => {
+    const rlAny = rl;
+    const text = textBuffer.getText();
+    const flat = text.replace(/\n/g, NEWLINE_MARKER);
+    rlAny.line = flat;
+    rlAny.cursor = flat.length;
+  };
+  const getInlineGhostSuffix = () => {
+    if (contextualHelpVisible) {
+      return void 0;
+    }
+    const currentText = getCurrentText();
+    if (!currentText || currentText.includes("\n") || currentText.includes(NEWLINE_MARKER)) {
+      return void 0;
+    }
+    return getInlineGhostCompletionSuffix(
+      currentText,
+      filesProvider(),
+      slashCommands,
+      workspaceRoot,
+      llmInlineShellSuggestion,
+      skillsProvider
+    ) ?? void 0;
+  };
+  const getHelpPanelLines = () => {
+    if (!contextualHelpVisible) {
+      return void 0;
+    }
+    const width = getPromptBlockWidth(stdOutput.columns);
+    return buildContextualHelpPanelLines(getCurrentText(), width, filesProvider(), slashCommands, skillsProvider);
+  };
+  const getSlashSuggestionLines = () => {
+    if (contextualHelpVisible) {
+      return void 0;
+    }
+    const width = getPromptBlockWidth(stdOutput.columns);
+    const lines = buildSlashSuggestionLines(getCurrentText(), width, slashCommands);
+    return lines.length > 0 ? lines : void 0;
+  };
+  let resizeDetectedAt = 0;
+  const renderPromptSurface = (isResize = false, hasExistingPromptBlock = true) => {
+    renderPromptLine(
+      rl,
+      getActiveStatusLine(),
+      stdOutput,
+      isResize,
+      hasExistingPromptBlock,
+      nextPromptSuggestionProvider?.(),
+      getInlineGhostSuffix(),
+      getHelpPanelLines(),
+      getSlashSuggestionLines()
+    );
+  };
+  const resizeWatcher = new TerminalResizeWatcher(stdOutput, () => {
+    resizeDetectedAt = Date.now();
+    const newWidth = Math.max(1, getPromptBlockWidth(stdOutput.columns) - 2);
+    textBuffer.setViewport(newWidth, tbMaxVisibleLines);
+    renderPromptSurface(true, true);
+    mentionPreview.handleResize();
+  });
+  syncReadlineFromBuffer();
+  renderPromptSurface(false, false);
+  if (initialLine.length > 0) {
+    renderPromptSurface(false, true);
+  }
+  return new Promise((resolve) => {
+    let ctrlCCount = 0;
+    let closed = false;
+    let suppressResidualShiftEnterCharsUntil = 0;
+    let inlineImageScanTimeout;
+    let inlineImageRetryCount = 0;
+    const MAX_INLINE_IMAGE_RETRIES = 12;
+    let shellSuggestionRequestId = 0;
+    let inlineShellSuggestionTimeout;
+    let inlineShellSuggestionRequestId = 0;
+    const rlInternal = rl;
+    const originalRefreshLine = typeof rlInternal._refreshLine === "function" ? rlInternal._refreshLine.bind(rlInternal) : void 0;
+    const originalMoveCursor = typeof rlInternal._moveCursor === "function" ? rlInternal._moveCursor.bind(rlInternal) : void 0;
+    const RESIZE_COOLDOWN_MS = 200;
+    const outputGuard = installReadlineOutputGuard(rl);
+    const setContextualHelpVisible = (visible) => {
+      if (contextualHelpVisible === visible) {
+        return;
+      }
+      contextualHelpVisible = visible;
+      mentionPreview.setSuspended(visible);
+      if (visible) {
+        mentionPreview.reset();
+      }
+      if (!closed) {
+        renderPromptSurface(false, true);
+      }
+    };
+    function renderActivePrompt() {
+      renderPromptSurface(false, true);
+    }
+    function isTextBufferCursorAtEnd() {
+      const lines = textBuffer.getLines();
+      const lastLine = lines[lines.length - 1] ?? "";
+      return textBuffer.getCursorRow() === lines.length - 1 && textBuffer.getCursorCol() === Array.from(lastLine).length;
+    }
+    function applyPromptSuggestion(suggestion) {
+      if (!suggestion) {
+        return false;
+      }
+      textBuffer.setText(suggestion.line);
+      syncReadlineFromBuffer();
+      renderActivePrompt();
+      return true;
+    }
+    function getCurrentPrimarySuggestion() {
+      return getPrimaryHotTipSuggestion(
+        getCurrentText(),
+        filesProvider(),
+        slashCommands,
+        {
+          nextPromptSuggestion: nextPromptSuggestionProvider?.(),
+          workspaceRoot,
+          skillsProvider
+        }
+      );
+    }
+    let renderScheduled = false;
+    function scheduleRender() {
+      if (renderScheduled) return;
+      renderScheduled = true;
+      setImmediate(() => {
+        renderScheduled = false;
+        if (!closed && !pasteState.isInPaste) {
+          renderActivePrompt();
+        }
+      });
+    }
+    if (pendingSuggestion) {
+      pendingSuggestion.then(() => {
+        if (!closed && getCurrentText() === "" && nextPromptSuggestionProvider?.()) {
+          scheduleRender();
+        }
+      }).catch(() => {
+      });
+    }
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      activeTextBuffer = null;
+      if (pasteState.timeout) {
+        clearTimeout(pasteState.timeout);
+        pasteState.timeout = void 0;
+      }
+      if (inlineImageScanTimeout) {
+        clearTimeout(inlineImageScanTimeout);
+        inlineImageScanTimeout = void 0;
+      }
+      if (inlineShellSuggestionTimeout) {
+        clearTimeout(inlineShellSuggestionTimeout);
+        inlineShellSuggestionTimeout = void 0;
+      }
+      disableBracketedPaste(stdOutput);
+      stdOutput.write("\x1B[?25h");
+      if (contextualHelpVisible) {
+        contextualHelpVisible = false;
+      }
+      mentionPreview.dispose();
+      resizeWatcher.dispose();
+      promptEvents.off("notify", onPromptNotify);
+      promptEvents.off("interrupt", onPromptInterrupt);
+      input.off("keypress", handleKeypress);
+      input.off("data", handleInputData);
+      if (originalRefreshLine) {
+        rlInternal._refreshLine = originalRefreshLine;
+      }
+      if (originalMoveCursor) {
+        rlInternal._moveCursor = originalMoveCursor;
+      }
+      outputGuard.restore();
+      if (supportsRawMode && input.isTTY) {
+        safeSetRawMode(input, false);
+      }
+      input.pause();
+      rl.close();
+    };
+    const showPromptMessage = (message) => {
+      mentionPreview.reset();
+      if (contextualHelpVisible) {
+        setContextualHelpVisible(false);
+      }
+      leavePromptSurface(stdOutput);
+      stdOutput.write(`${message.replace(/\n+$/g, "")}
+`);
+      renderPromptSurface(false, false);
+    };
+    const onPromptNotify = (msg) => showPromptMessage(msg);
+    promptEvents.on("notify", onPromptNotify);
+    const onPromptInterrupt = (value) => {
+      if (closed) return;
+      mentionPreview.reset();
+      if (contextualHelpVisible) {
+        setContextualHelpVisible(false);
+      }
+      leavePromptSurface(stdOutput, STATUS_LINE_COUNT);
+      cleanup();
+      resolve({ kind: "submit", value });
+    };
+    promptEvents.on("interrupt", onPromptInterrupt);
+    const refreshLine = () => {
+      renderActivePrompt();
+    };
+    if (typeof rlInternal._refreshLine === "function") {
+      rlInternal._refreshLine = () => {
+        if (!closed && !pasteState.isInPaste) {
+          if (resizeDetectedAt > 0 && Date.now() - resizeDetectedAt < RESIZE_COOLDOWN_MS) {
+            return;
+          }
+          scheduleRender();
+        }
+      };
+    }
+    if (typeof rlInternal._moveCursor === "function") {
+      rlInternal._moveCursor = (...args) => {
+        originalMoveCursor?.(...args);
+        if (!closed && !pasteState.isInPaste) {
+          scheduleRender();
+        }
+      };
+    }
+    const rlTtyWrite = rl;
+    const originalTtyWrite = rlTtyWrite._ttyWrite?.bind(rl);
+    if (originalTtyWrite) {
+      rlTtyWrite._ttyWrite = (s, _key) => {
+        if (pasteState.isInPaste) {
+          return;
+        }
+        if (/^(?:13;?[234]?\d*[u~]|27;[234];13~)$/.test(s)) {
+          textBuffer.insert("\n");
+          syncReadlineFromBuffer();
+          renderActivePrompt();
+          return;
+        }
+        return;
+      };
+    }
+    const applyDetectedImagesToLine = (processedText) => {
+      const display = getContentDisplay(processedText);
+      if (display.isPasted) {
+        pasteState.hiddenContent = display.actual;
+        textBuffer.setText(display.visual);
+      } else {
+        pasteState.hiddenContent = void 0;
+        textBuffer.setText(display.actual);
+      }
+      syncReadlineFromBuffer();
+      refreshLine();
+    };
+    const replaceDroppedImagesInline = () => {
+      if (!onImageDetected) {
+        return false;
+      }
+      const sourceText = pasteState.hiddenContent ?? getCurrentText();
+      if (!sourceText) {
+        inlineImageRetryCount = 0;
+        return false;
+      }
+      const processed = processImagesInText(sourceText, onImageDetected, {
+        announce: false,
+        output: stdOutput
+      });
+      if (processed !== sourceText) {
+        inlineImageRetryCount = 0;
+        applyDetectedImagesToLine(processed);
+        return true;
+      }
+      if (hasPotentialImagePath(sourceText) && inlineImageRetryCount < MAX_INLINE_IMAGE_RETRIES) {
+        inlineImageRetryCount += 1;
+        scheduleInlineImageScan(180);
+      } else if (!hasPotentialImagePath(sourceText)) {
+        inlineImageRetryCount = 0;
+      }
+      return false;
+    };
+    const scheduleInlineImageScan = (delayMs = 75) => {
+      if (!onImageDetected || pasteState.isInPaste) {
+        return;
+      }
+      if (inlineImageScanTimeout) {
+        clearTimeout(inlineImageScanTimeout);
+      }
+      inlineImageScanTimeout = setTimeout(() => {
+        inlineImageScanTimeout = void 0;
+        if (!closed && !pasteState.isInPaste) {
+          replaceDroppedImagesInline();
+        }
+      }, delayMs);
+    };
+    const scheduleInlineShellSuggestion = (delayMs = 120) => {
+      if (!resolveShellSuggestion || pasteState.isInPaste || contextualHelpVisible) {
+        return;
+      }
+      const sourceLine = getCurrentText();
+      const trimmedSource = sourceLine.trim();
+      if (!trimmedSource.startsWith("!") || !trimmedSource.slice(1).trim()) {
+        if (llmInlineShellSuggestion !== null) {
+          llmInlineShellSuggestion = null;
+          renderActivePrompt();
+        }
+        return;
+      }
+      if (inlineShellSuggestionTimeout) {
+        clearTimeout(inlineShellSuggestionTimeout);
+      }
+      inlineShellSuggestionTimeout = setTimeout(() => {
+        inlineShellSuggestionTimeout = void 0;
+        const requestId = ++inlineShellSuggestionRequestId;
+        const lineAtRequest = getCurrentText();
+        resolveShellSuggestion(lineAtRequest).then((suggestion) => {
+          if (closed || requestId !== inlineShellSuggestionRequestId) {
+            return;
+          }
+          const latest = getCurrentText();
+          if (latest !== lineAtRequest) {
+            return;
+          }
+          llmInlineShellSuggestion = suggestion ?? null;
+          renderActivePrompt();
+        }).catch(() => {
+        });
+      }, delayMs);
+    };
+    const handleInputData = (chunk) => {
+      if (closed || pasteState.isInPaste) {
+        return;
+      }
+      const rawText = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk ?? "");
+      const modifiedEnterCount = countRawModifiedEnterSequences(rawText);
+      const residualModifiedEnterCount = countResidualModifiedEnterSequences(rawText);
+      if (modifiedEnterCount > 0) {
+        for (let i = 0; i < modifiedEnterCount; i++) {
+          textBuffer.insert("\n");
+        }
+        suppressResidualShiftEnterCharsUntil = Date.now() + 200;
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (residualModifiedEnterCount > 0) {
+        for (let i = 0; i < residualModifiedEnterCount; i++) {
+          textBuffer.insert("\n");
+        }
+        suppressResidualShiftEnterCharsUntil = Date.now() + 200;
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      scheduleInlineImageScan();
+    };
+    const handleKeypress = (_str, key) => {
+      if (closed) return;
+      const rawSeq = key?.sequence ?? _str ?? "";
+      if (chordState === "ctrl-x") {
+        chordState = "none";
+        if (chordTimeout) {
+          clearTimeout(chordTimeout);
+          chordTimeout = null;
+        }
+        if (_str === "/") {
+          const currentText = textBuffer.getText();
+          textBuffer.setText("/" + currentText);
+          textBuffer.setCursorPosition(0, 1);
+          syncReadlineFromBuffer();
+          renderActivePrompt();
+          return;
+        }
+      }
+      if (Date.now() < suppressResidualShiftEnterCharsUntil) {
+        if (isShiftEnterSequence(_str, key) || isShiftEnterResidualSequence(rawSeq) || _str && _str.length > 0 && /^[\d;~u]+$/.test(_str)) {
+          return;
+        }
+      }
+      if (key?.sequence === "\x1B[13~") {
+        textBuffer.insert("\n");
+        suppressResidualShiftEnterCharsUntil = Date.now() + 200;
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "paste-start") {
+        pasteState.isInPaste = true;
+        pasteState.buffer = "";
+        pasteState.outputSuppressed = true;
+        outputGuard.setSuppressed(true);
+        if (pasteState.timeout) {
+          clearTimeout(pasteState.timeout);
+        }
+        pasteState.prefixContent = getCurrentText();
+        return;
+      }
+      if (key?.name === "paste-end") {
+        if (pasteState.timeout) {
+          clearTimeout(pasteState.timeout);
+          pasteState.timeout = void 0;
+        }
+        if (pasteState.isInPaste) {
+          pasteState.isInPaste = false;
+          outputGuard.setSuppressed(false);
+          if (onImageDetected && pasteState.buffer) {
+            pasteState.buffer = processImagesInText(
+              pasteState.buffer,
+              onImageDetected,
+              { announce: false, output: stdOutput }
+            );
+          }
+          handlePasteComplete(pasteState, rl, stdOutput, () => {
+            const rlAny = rl;
+            textBuffer.setText(rlAny.line ?? "");
+            syncReadlineFromBuffer();
+            renderActivePrompt();
+          });
+          scheduleInlineImageScan(10);
+        }
+        return;
+      }
+      if (pasteState.isInPaste) {
+        if (_str) {
+          pasteState.buffer += _str;
+        }
+        if (key?.name === "return" || key?.name === "enter") {
+          pasteState.buffer += "\n";
+        }
+        if (pasteState.timeout) {
+          clearTimeout(pasteState.timeout);
+        }
+        pasteState.timeout = setTimeout(() => {
+          if (pasteState.isInPaste && pasteState.buffer) {
+            pasteState.isInPaste = false;
+            outputGuard.setSuppressed(false);
+            if (onImageDetected) {
+              pasteState.buffer = processImagesInText(
+                pasteState.buffer,
+                onImageDetected,
+                { announce: false, output: stdOutput }
+              );
+            }
+            handlePasteComplete(pasteState, rl, stdOutput, () => {
+              const rlAny = rl;
+              textBuffer.setText(rlAny.line ?? "");
+              syncReadlineFromBuffer();
+              renderActivePrompt();
+            });
+            scheduleInlineImageScan(10);
+          }
+        }, 50);
+        return;
+      }
+      if ((key?.name === "backspace" || key?.name === "delete") && pasteState.hiddenContent) {
+        const currentText = getCurrentText();
+        const stripped = removePastedReferenceFromLine(currentText);
+        if (stripped) {
+          textBuffer.setText(stripped.line);
+        } else {
+          textBuffer.setText("");
+        }
+        pasteState.hiddenContent = void 0;
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (!(key?.name === "c" && key.ctrl)) {
+        ctrlCCount = 0;
+      }
+      if (key?.name === "c" && key.ctrl) {
+        const currentInput = getCurrentText();
+        if (currentInput.length > 0) {
+          mentionPreview.reset();
+          if (contextualHelpVisible) {
+            setContextualHelpVisible(false);
+          }
+          textBuffer.setText("");
+          syncReadlineFromBuffer();
+          renderActivePrompt();
+          ctrlCCount = 0;
+          return;
+        }
+        if (ctrlCCount === 0) {
+          ctrlCCount = 1;
+          mentionPreview.reset();
+          if (contextualHelpVisible) {
+            setContextualHelpVisible(false);
+          }
+          showPromptMessage(chalk2.gray("Press Ctrl+C again to exit."));
+          return;
+        }
+        mentionPreview.reset();
+        if (contextualHelpVisible) {
+          setContextualHelpVisible(false);
+        }
+        leavePromptSurface(stdOutput);
+        cleanup();
+        resolve({ kind: "abort" });
+        return;
+      }
+      if (mentionPreview.consumeHandledCompletion()) {
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (isShiftTabShortcut(_str, key)) {
+        const planModeManager = getPlanModeManager();
+        const wasEnabled = planModeManager.isEnabled();
+        planModeManager.handleShiftTab();
+        showPromptMessage(formatPlanModeToggleMessage(!wasEnabled));
+        return;
+      }
+      if (isPlainTabShortcut(_str, key)) {
+        if (mentionPreview.consumeHandledTab()) {
+          return;
+        }
+        const currentInput = getCurrentText();
+        const trimmedInput = currentInput.trim();
+        if (trimmedInput.startsWith("!") && resolveShellSuggestion) {
+          if (llmInlineShellSuggestion && llmInlineShellSuggestion.startsWith(currentInput) && llmInlineShellSuggestion !== currentInput) {
+            textBuffer.setText(llmInlineShellSuggestion);
+            syncReadlineFromBuffer();
+            renderActivePrompt();
+            return;
+          }
+          const requestId = ++shellSuggestionRequestId;
+          const immediateFallback = getPrimaryHotTipSuggestion(
+            currentInput,
+            filesProvider(),
+            slashCommands,
+            {
+              nextPromptSuggestion: nextPromptSuggestionProvider?.(),
+              workspaceRoot,
+              skillsProvider
+            }
+          );
+          let expectedInputAtResponse = currentInput;
+          if (immediateFallback) {
+            textBuffer.setText(immediateFallback.line);
+            syncReadlineFromBuffer();
+            expectedInputAtResponse = immediateFallback.line;
+            renderActivePrompt();
+          }
+          resolveShellSuggestion(currentInput).then((llmSuggestion) => {
+            if (closed || requestId !== shellSuggestionRequestId) {
+              return;
+            }
+            const latest = getCurrentText();
+            if (latest !== expectedInputAtResponse) {
+              return;
+            }
+            if (llmSuggestion) {
+              textBuffer.setText(llmSuggestion);
+              syncReadlineFromBuffer();
+              renderActivePrompt();
+            }
+          }).catch(() => {
+            if (closed || requestId !== shellSuggestionRequestId) {
+              return;
+            }
+          });
+          return;
+        }
+        applyPromptSuggestion(getCurrentPrimarySuggestion());
+        return;
+      }
+      if (isRightArrowAcceptShortcut(key) && isTextBufferCursorAtEnd()) {
+        const currentInput = getCurrentText();
+        const trimmedInput = currentInput.trim();
+        if (!trimmedInput) {
+          applyPromptSuggestion(getCurrentPrimarySuggestion());
+          return;
+        }
+        const inlineGhostSuffix = getInlineGhostSuffix();
+        if (inlineGhostSuffix) {
+          textBuffer.setText(`${currentInput}${inlineGhostSuffix}`);
+          syncReadlineFromBuffer();
+          renderActivePrompt();
+          return;
+        }
+        return;
+      }
+      if (_str === "?" && !key?.ctrl && !key?.meta) {
+        const currentText = getCurrentText();
+        if (currentText.trim() === "" || currentText.trim() === "?") {
+          setContextualHelpVisible(!contextualHelpVisible);
+          return;
+        }
+      }
+      const residualModifiedEnterCount = countResidualModifiedEnterSequences(rawSeq);
+      if (isShiftEnterSequence(_str, key) || isShiftEnterResidualSequence(rawSeq)) {
+        textBuffer.insert("\n");
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        scheduleInlineImageScan();
+        scheduleInlineShellSuggestion();
+        return;
+      }
+      if (residualModifiedEnterCount > 0) {
+        for (let i = 0; i < residualModifiedEnterCount; i++) {
+          textBuffer.insert("\n");
+        }
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        scheduleInlineImageScan();
+        scheduleInlineShellSuggestion();
+        return;
+      }
+      if (key?.name === "k" && key.ctrl) {
+        textBuffer.deleteToEnd();
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "u" && key.ctrl) {
+        textBuffer.deleteToStart();
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "w" && key.ctrl) {
+        textBuffer.deletePreviousWord();
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "d" && key.ctrl) {
+        if (textBuffer.getText().length === 0) {
+          process.emit("SIGTERM");
+          return;
+        }
+        textBuffer.delete();
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "l" && key.ctrl) {
+        process.stdout.write("\x1B[2J\x1B[H");
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "b" && key.ctrl) {
+        handleTextBufferKey(textBuffer, "", { name: "left" });
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "f" && key.ctrl) {
+        handleTextBufferKey(textBuffer, "", { name: "right" });
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "h" && key.ctrl) {
+        textBuffer.backspace();
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "g" && key.ctrl) {
+        const { writeFileSync, unlinkSync } = __require("fs");
+        const { spawnSync } = __require("child_process");
+        const { tmpdir } = __require("os");
+        const { join } = __require("path");
+        const tmpFile = join(tmpdir(), `autohand-edit-${Date.now()}.txt`);
+        writeFileSync(tmpFile, textBuffer.getText());
+        const editor = process.env.VISUAL || process.env.EDITOR || "vi";
+        spawnSync(editor, [tmpFile], { stdio: "inherit" });
+        try {
+          const content = readFileSync(tmpFile, "utf-8");
+          textBuffer.setText(content.trimEnd());
+          unlinkSync(tmpFile);
+        } catch {
+        }
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        return;
+      }
+      if (key?.name === "x" && key.ctrl) {
+        chordState = "ctrl-x";
+        chordTimeout = setTimeout(() => {
+          chordState = "none";
+          chordTimeout = null;
+        }, 1e3);
+        return;
+      }
+      const tbResult = handleTextBufferKey(textBuffer, _str, key);
+      if (tbResult === "submit") {
+        const text = textBuffer.getText().trim();
+        if (!text) return;
+        syncReadlineFromBuffer();
+        rl.emit("line", text);
+        return;
+      }
+      if (tbResult === "handled") {
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        scheduleInlineImageScan();
+        scheduleInlineShellSuggestion();
+        if (contextualHelpVisible && shouldAutoHideShortcutHelp(_str, key)) {
+          setContextualHelpVisible(false);
+        }
+        return;
+      }
+      scheduleInlineImageScan();
+      scheduleInlineShellSuggestion();
+      if (contextualHelpVisible && shouldAutoHideShortcutHelp(_str, key)) {
+        setContextualHelpVisible(false);
+      }
+      scheduleRender();
+    };
+    input.prependListener("data", handleInputData);
+    input.on("keypress", handleKeypress);
+    rl.on("line", (value) => {
+      if (pasteState.isInPaste) {
+        return;
+      }
+      let finalValue = pasteState.hiddenContent || value;
+      pasteState.hiddenContent = void 0;
+      finalValue = convertNewlineMarkersToNewlines(finalValue).trim();
+      finalValue = processImagesInText(finalValue, onImageDetected, {
+        announce: true,
+        output: stdOutput
+      });
+      if (contextualHelpVisible) {
+        setContextualHelpVisible(false);
+      }
+      if (isShellCommand(finalValue)) {
+        const shellCmd = parseShellCommand(finalValue);
+        mentionPreview.reset();
+        leavePromptSurface(stdOutput, STATUS_LINE_COUNT, true);
+        writePromptShellCommandHeader(stdOutput, shellCmd);
+        const writer = createPromptShellCommandBlockWriter(stdOutput);
+        executeShellCommandAsync(shellCmd, workspaceRoot, void 0, {
+          onStdout: (chunk) => writer.pushStdout(chunk),
+          onStderr: (chunk) => writer.pushStderr(chunk)
+        }).then((result) => {
+          writer.flush();
+          if (!result.success && result.error && !result.output) {
+            stdOutput.write(`  \u2514 ${chalk2.red(result.error)}
+`);
+          }
+          textBuffer.setText("");
+          syncReadlineFromBuffer();
+          stdOutput.write("\n");
+          renderPromptLine(rl, getActiveStatusLine(), stdOutput, false, false, nextPromptSuggestionProvider?.());
+        }).catch((error) => {
+          writer.flush();
+          stdOutput.write(`  \u2514 ${chalk2.red(error.message)}
+
+`);
+          textBuffer.setText("");
+          syncReadlineFromBuffer();
+          renderPromptLine(rl, getActiveStatusLine(), stdOutput, false, false, nextPromptSuggestionProvider?.());
+        });
+        return;
+      }
+      mentionPreview.reset();
+      leavePromptSurface(stdOutput, STATUS_LINE_COUNT, true);
+      if (finalValue && !finalValue.startsWith("/")) {
+        stdOutput.write(`${chalk2.gray("press ESC to interrupt")}
+`);
+      }
+      cleanup();
+      resolve({ kind: "submit", value: finalValue });
+    });
+    rl.on("SIGINT", () => {
+      const currentInput = getCurrentText();
+      if (currentInput.length > 0) {
+        mentionPreview.reset();
+        if (contextualHelpVisible) {
+          setContextualHelpVisible(false);
+        }
+        textBuffer.setText("");
+        syncReadlineFromBuffer();
+        renderActivePrompt();
+        ctrlCCount = 0;
+        return;
+      }
+      if (ctrlCCount === 0) {
+        ctrlCCount = 1;
+        mentionPreview.reset();
+        if (contextualHelpVisible) {
+          setContextualHelpVisible(false);
+        }
+        showPromptMessage(chalk2.gray("Press Ctrl+C again to exit."));
+        return;
+      }
+      mentionPreview.reset();
+      if (contextualHelpVisible) {
+        setContextualHelpVisible(false);
+      }
+      leavePromptSurface(stdOutput);
+      cleanup();
+      resolve({ kind: "abort" });
+    });
+  });
+}
+function disableReadlineTabBehavior(rl) {
+  const anyRl = rl;
+  anyRl.completer = (line) => [[], line];
+  if (typeof anyRl._tabComplete === "function") {
+    anyRl._tabComplete = () => {
+    };
+  }
+}
+function getComposerBorderStyle(line) {
+  if (/^[\s\u200B-\u200D\uFEFF]*!/u.test(line)) {
+    return "shell";
+  }
+  if (getPlanModeManager().isEnabled()) {
+    return "plan";
+  }
+  return "default";
+}
+var lastRenderedContentLines = 1;
+var lastRenderedCursorRow = 0;
+var activeTextBuffer = null;
+function getActiveTextBuffer() {
+  return activeTextBuffer;
+}
+function getLastRenderedContentLines() {
+  return lastRenderedContentLines;
+}
+function getLastRenderedCursorRow() {
+  return lastRenderedCursorRow;
+}
+var lastRenderedPromptWidth = 0;
+var lastRenderedHelpLines = 0;
+var lastRenderedSlashLines = 0;
+function resetPromptRenderState() {
+  lastRenderedContentLines = 1;
+  lastRenderedCursorRow = 0;
+  lastRenderedPromptWidth = 0;
+  lastRenderedHelpLines = 0;
+  lastRenderedSlashLines = 0;
+}
+function renderPromptLine(rl, statusLine, output, isResize = false, hasExistingPromptBlock = true, nextPromptSuggestion, inlineGhostSuffix, helpPanelLines, slashSuggestionLines) {
+  invalidateBoxColorCache();
+  const width = getPromptBlockWidth(output.columns);
+  let currentLine;
+  let cursorPos;
+  if (activeTextBuffer) {
+    currentLine = activeTextBuffer.getText();
+    const lines = activeTextBuffer.getLines();
+    const row = activeTextBuffer.getCursorRow();
+    const col = activeTextBuffer.getCursorCol();
+    let flat = 0;
+    for (let i = 0; i < row; i++) {
+      flat += lines[i].length + 1;
+    }
+    flat += col;
+    cursorPos = flat;
+  } else {
+    const rlAny = rl;
+    currentLine = rlAny.line ?? "";
+    cursorPos = rlAny.cursor ?? currentLine.length;
+  }
+  const borderStyle = getComposerBorderStyle(currentLine);
+  const state = buildMultiLineRenderState(
+    currentLine,
+    cursorPos,
+    width,
+    borderStyle,
+    {
+      placeholderText: PROMPT_PLACEHOLDER,
+      nextPromptSuggestion,
+      inlineGhostSuffix
+    }
+  );
+  const topBorder = drawInputTopBorder(width, borderStyle);
+  const bottomBorder = drawInputBottomBorder(width, borderStyle);
+  const statusRow = formatPromptStatusRow(statusLine, width);
+  const widthChanged = lastRenderedPromptWidth > 0 && width !== lastRenderedPromptWidth;
+  const effectiveResize = isResize || widthChanged;
+  rl.setPrompt(PROMPT_PREFIX);
+  output.write("\x1B[?25l");
+  if (effectiveResize && hasExistingPromptBlock) {
+    readline2.cursorTo(output, 0);
+    readline2.clearLine(output, 0);
+    const prevContentLines = lastRenderedContentLines;
+    const prevCursorRow = lastRenderedCursorRow;
+    const upCount = prevCursorRow + PROMPT_LINES_ABOVE_INPUT;
+    for (let i = 0; i < upCount; i++) {
+      readline2.moveCursor(output, 0, -1);
+      readline2.clearLine(output, 0);
+    }
+    const clearContentLines = Math.max(prevContentLines, state.lineCount);
+    const downCount = clearContentLines + PROMPT_LINES_BELOW_INPUT + lastRenderedHelpLines + STATUS_LINE_COUNT + lastRenderedSlashLines;
+    for (let i = 0; i < downCount; i++) {
+      readline2.moveCursor(output, 0, 1);
+      readline2.clearLine(output, 0);
+    }
+    readline2.moveCursor(output, 0, -downCount);
+    readline2.cursorTo(output, 0);
+  } else if (hasExistingPromptBlock) {
+    const prevContentLines = lastRenderedContentLines;
+    const prevCursorRow = lastRenderedCursorRow;
+    readline2.cursorTo(output, 0);
+    readline2.clearLine(output, 0);
+    const upCount = prevCursorRow + PROMPT_LINES_ABOVE_INPUT;
+    for (let i = 0; i < upCount; i++) {
+      readline2.moveCursor(output, 0, -1);
+      readline2.clearLine(output, 0);
+    }
+    const clearContentLines = Math.max(prevContentLines, state.lineCount);
+    const downCount = clearContentLines + PROMPT_LINES_BELOW_INPUT + lastRenderedHelpLines + STATUS_LINE_COUNT + lastRenderedSlashLines;
+    for (let i = 0; i < downCount; i++) {
+      readline2.moveCursor(output, 0, 1);
+      readline2.clearLine(output, 0);
+    }
+    for (let i = 0; i < downCount; i++) {
+      readline2.moveCursor(output, 0, -1);
+    }
+    readline2.cursorTo(output, 0);
+  } else {
+    readline2.cursorTo(output, 0);
+    const blockSize = PROMPT_LINES_ABOVE_INPUT + state.lineCount + PROMPT_LINES_BELOW_INPUT + (helpPanelLines?.length ?? 0) + STATUS_LINE_COUNT + (slashSuggestionLines?.length ?? 0);
+    for (let i = 0; i < blockSize; i++) {
+      readline2.clearLine(output, 0);
+      if (i < blockSize - 1) {
+        readline2.moveCursor(output, 0, 1);
+      }
+    }
+    readline2.moveCursor(output, 0, -(blockSize - 1));
+    readline2.cursorTo(output, 0);
+  }
+  const helpLines = helpPanelLines ?? [];
+  const slashLines = slashSuggestionLines ?? [];
+  let buf = `${topBorder}
+`;
+  for (const line of state.lines) {
+    buf += `${line}
+`;
+  }
+  buf += `${bottomBorder}
+`;
+  for (const hl of helpLines) {
+    buf += `${hl}
+`;
+  }
+  buf += statusRow;
+  for (const sl of slashLines) {
+    buf += `
+${sl}`;
+  }
+  output.write(buf);
+  const moveUp = PROMPT_LINES_BELOW_INPUT + helpLines.length + STATUS_LINE_COUNT + slashLines.length + (state.lineCount - 1 - state.cursorRow);
+  readline2.moveCursor(output, 0, -moveUp);
+  readline2.cursorTo(output, state.cursorColumn);
+  output.write("\x1B[?25h");
+  lastRenderedContentLines = state.lineCount;
+  lastRenderedCursorRow = state.cursorRow;
+  lastRenderedPromptWidth = width;
+  lastRenderedHelpLines = helpLines.length;
+  lastRenderedSlashLines = slashLines.length;
+}
+
+export {
+  buildFileMentionSuggestions,
+  buildSkillMentionSuggestions,
+  ImageManager,
+  drawInputTopBorder,
+  drawInputBottomBorder,
+  drawInputBox,
+  TextBuffer,
+  handleTextBufferKey,
+  promptNotify,
+  promptInterrupt,
+  STATUS_LINE_COUNT,
+  PROMPT_LINES_ABOVE_INPUT,
+  PROMPT_LINES_BELOW_INPUT,
+  PROMPT_PLACEHOLDER,
+  PROMPT_INPUT_PREFIX,
+  getHelpOrderedSlashCommands,
+  getRankedSlashCommandMatches,
+  resetCachedSkillMentions,
+  buildPromptHotTips,
+  getPrimaryHotTipSuggestion,
+  getInlineGhostCompletionSuffix,
+  buildContextualHelpPanelLines,
+  buildContextualPromptStatusLine,
+  buildSlashSuggestionLines,
+  removePastedReferenceFromLine,
+  isShiftTabShortcut,
+  isPlainTabShortcut,
+  isShiftEnterSequence,
+  isShiftEnterResidualSequence,
+  countResidualModifiedEnterSequences,
+  countRawModifiedEnterSequences,
+  shouldAutoHideShortcutHelp,
+  getPromptBlockWidth,
+  buildPromptRenderState,
+  buildMultiLineRenderState,
+  formatPromptStatusRow,
+  installReadlineOutputGuard,
+  processImagesInText,
+  NEWLINE_MARKER,
+  safeEmitKeypressEvents,
+  convertNewlineMarkersToNewlines,
+  readInstruction,
+  leavePromptSurface,
+  getActiveTextBuffer,
+  getLastRenderedContentLines,
+  getLastRenderedCursorRow,
+  resetPromptRenderState
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Visual layout engine for TextBuffer.
+ * Wraps logical lines to visual lines based on viewport width and builds
+ * bidirectional mapping tables between logical and visual positions.
+ */