@qodalis/cli 2.0.0-beta.7 → 2.0.0-beta.8

package/public-api.js

@@ -411,7 +411,7 @@ var CliBackgroundServiceRegistry_TOKEN = "cli-background-service-registry";
 var CliPackageManagerService_TOKEN = "cli-package-manager-service";
 
 // src/lib/version.ts
-var LIBRARY_VERSION = "2.0.0-beta.7";
+var LIBRARY_VERSION = "2.0.0-beta.8";
 var API_VERSION = 2;
 var CliAliasCommandProcessor = class {
   constructor() {
@@ -2551,10 +2551,8 @@ var CliUptimeCommandProcessor = class {
       icon: "\u23F1\uFE0F",
       module: "misc"
     };
-    this.sessionStartTimes = /* @__PURE__ */ new WeakMap();
   }
   async initialize(context2) {
-    this.sessionStartTimes.set(context2.terminal, Date.now());
     try {
       context2.backgroundServices.register({
         name: "uptime-tracker",
@@ -2562,6 +2560,10 @@ var CliUptimeCommandProcessor = class {
         type: "daemon",
         onStart: async (ctx) => {
           ctx.log("Uptime tracking started");
+          await new Promise((resolve) => {
+            ctx.signal.addEventListener("abort", () => resolve(), { once: true });
+          });
+          ctx.log("Uptime tracking stopped");
         }
       });
       await context2.backgroundServices.start("uptime-tracker");
@@ -2570,9 +2572,16 @@ var CliUptimeCommandProcessor = class {
   }
   async processCommand(_, context2) {
     const svcInfo = context2.backgroundServices.getStatus("uptime-tracker");
-    const startTime = svcInfo?.status === "running" && svcInfo.startedAt ? svcInfo.startedAt.getTime() : this.sessionStartTimes.get(context2.terminal) ?? Date.now();
-    const elapsed = Date.now() - startTime;
     const { writer } = context2;
+    if (!svcInfo || svcInfo.status !== "running") {
+      writer.writeError("Uptime tracker is not running.");
+      writer.writeInfo(
+        `Use ${writer.wrapInColor("services start uptime-tracker", cliCore.CliForegroundColor.Cyan)} to restart.`
+      );
+      return;
+    }
+    const startTime = svcInfo.startedAt.getTime();
+    const elapsed = Date.now() - startTime;
     const seconds = Math.floor(elapsed / 1e3) % 60;
     const minutes = Math.floor(elapsed / (1e3 * 60)) % 60;
     const hours = Math.floor(elapsed / (1e3 * 60 * 60)) % 24;
@@ -6218,6 +6227,9 @@ var CliServerManager = class {
 
 // src/lib/wasm/fallback.ts
 var JsFallbackAccelerator = class {
+  constructor() {
+    this.ruleSets = /* @__PURE__ */ new Map();
+  }
   textSearch(text, needle, startRow, startCol, caseSensitive, wrap) {
     if (!needle) return [-1, -1];
     const lines = text.split("\n");
@@ -6277,6 +6289,60 @@ var JsFallbackAccelerator = class {
     }
     return matches.sort();
   }
+  registerRuleSet(ruleSetId, rules) {
+    const parsed = [];
+    for (const line of rules.split("\n")) {
+      if (!line) continue;
+      const parts = line.split("	");
+      if (parts.length < 2) continue;
+      try {
+        parsed.push({
+          pattern: new RegExp(parts[0]),
+          tokenType: parts[1],
+          captureGroup: parts[2] ? parseInt(parts[2], 10) : 0
+        });
+      } catch {
+      }
+    }
+    this.ruleSets.set(ruleSetId, parsed);
+  }
+  tokenizeLine(line, ruleSetId) {
+    const rules = this.ruleSets.get(ruleSetId);
+    if (!rules || !line) return "";
+    const tokens = [];
+    let pos = 0;
+    while (pos < line.length) {
+      let matched = false;
+      for (const rule of rules) {
+        rule.pattern.lastIndex = 0;
+        const sliced = line.slice(pos);
+        const m = rule.pattern.exec(sliced);
+        if (m) {
+          let start;
+          let end;
+          if (rule.captureGroup > 0 && m[rule.captureGroup] !== void 0) {
+            const groupText = m[rule.captureGroup];
+            const groupOffset = m[0].indexOf(groupText);
+            start = pos + m.index + groupOffset;
+            end = start + groupText.length;
+          } else {
+            start = pos + m.index;
+            end = pos + m.index + m[0].length;
+          }
+          if (pos + m.index + m[0].length > pos) {
+            tokens.push(`${start},${end},${rule.tokenType}`);
+            pos = pos + m.index + m[0].length;
+            matched = true;
+            break;
+          }
+        }
+      }
+      if (!matched) {
+        pos++;
+      }
+    }
+    return tokens.join("\n");
+  }
   commonPrefix(strings) {
     if (strings.length === 0) return "";
     let prefix = strings[0];
@@ -6449,6 +6515,30 @@ function wasmCommonPrefix(strings) {
     wasm.__wbindgen_export3(d0, d1, 1);
   }
 }
+function wasmRegisterRuleSet(ruleSetId, rules) {
+  const ptr0 = passStringToWasm0(ruleSetId, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(rules, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+  const len1 = WASM_VECTOR_LEN;
+  wasm.register_rule_set(ptr0, len0, ptr1, len1);
+}
+function wasmTokenizeLine(line, ruleSetId) {
+  let d0, d1;
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm0(line, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(ruleSetId, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    wasm.tokenize_line(retptr, ptr0, len0, ptr1, len1);
+    d0 = getDataViewMemory0().getInt32(retptr + 0, true);
+    d1 = getDataViewMemory0().getInt32(retptr + 4, true);
+    return getStringFromWasm0(d0, d1);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    wasm.__wbindgen_export3(d0, d1, 1);
+  }
+}
 async function instantiateWasm(wasmBytes) {
   const imports = { __proto__: null, "./qodalis_cli_wasm_bg.js": { __proto__: null } };
   const { instance } = await WebAssembly.instantiate(wasmBytes, imports);
@@ -6489,6 +6579,12 @@ function createWasmAccelerator() {
     },
     commonPrefix(strings) {
       return wasmCommonPrefix(strings.join("\n"));
+    },
+    registerRuleSet(ruleSetId, rules) {
+      wasmRegisterRuleSet(ruleSetId, rules);
+    },
+    tokenizeLine(line, ruleSetId) {
+      return wasmTokenizeLine(line, ruleSetId);
     }
   };
 }
@@ -7415,7 +7511,11 @@ var NanoEditorRenderer = class {
       output2 += "\x1B[2K";
       if (lineIdx < buffer.lines.length) {
         const line = buffer.lines[lineIdx];
-        output2 += line.length > cols ? line.slice(0, cols) : line;
+        if (this.highlightEngine) {
+          output2 += this.highlightEngine.renderLine(lineIdx, line, cols);
+        } else {
+          output2 += line.length > cols ? line.slice(0, cols) : line;
+        }
       }
     }
     output2 += `\x1B[${rows - 1};1H`;
@@ -7494,6 +7594,135 @@ var NanoEditorRenderer = class {
   }
 };
 
+// src/lib/editor/syntax/utils.ts
+function truncateAnsi(str, maxCols) {
+  let visible = 0;
+  let i = 0;
+  let result = "";
+  let hasActiveColor = false;
+  while (i < str.length && visible < maxCols) {
+    if (str[i] === "\x1B" && i + 1 < str.length && str[i + 1] === "[") {
+      let j = i + 2;
+      while (j < str.length && !(str.charCodeAt(j) >= 64 && str.charCodeAt(j) <= 126)) {
+        j++;
+      }
+      if (j < str.length) {
+        const seq = str.slice(i, j + 1);
+        result += seq;
+        if (seq === "\x1B[0m") {
+          hasActiveColor = false;
+        } else {
+          hasActiveColor = true;
+        }
+        i = j + 1;
+      } else {
+        break;
+      }
+    } else {
+      result += str[i];
+      visible++;
+      i++;
+    }
+  }
+  if (hasActiveColor) {
+    result += "\x1B[0m";
+  }
+  return result;
+}
+function parseTokens(raw) {
+  if (!raw) return [];
+  return raw.split("\n").map((entry) => {
+    const [s, e, ...rest] = entry.split(",");
+    return { start: parseInt(s, 10), end: parseInt(e, 10), tokenType: rest.join(",") };
+  });
+}
+
+// src/lib/editor/syntax/engine.ts
+var SyntaxHighlightEngine = class {
+  constructor(highlighter, theme, accelerator2) {
+    this.highlighter = highlighter;
+    this.theme = theme;
+    this.accelerator = accelerator2;
+    this.cache = /* @__PURE__ */ new Map();
+    this.registeredRuleSets = /* @__PURE__ */ new Set();
+  }
+  invalidate(fromLine) {
+    for (const key of this.cache.keys()) {
+      if (key >= fromLine) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  renderLine(lineIdx, line, cols) {
+    const entryState = lineIdx === 0 ? this.highlighter.initialState : this.cache.get(lineIdx - 1)?.exitState ?? this.highlighter.initialState;
+    const cached = this.cache.get(lineIdx);
+    if (cached && cached.lineContent === line && cached.entryState === entryState) {
+      return truncateAnsi(cached.rendered, cols);
+    }
+    try {
+      const ruleSetId = `${this.highlighter.id}:${entryState}`;
+      if (!this.registeredRuleSets.has(ruleSetId)) {
+        const rules = this.highlighter.getRules(entryState);
+        const serialized = rules.map(
+          (r) => `${r.pattern.source}	${r.tokenType}	${r.captureGroup ?? 0}`
+        ).join("\n");
+        this.accelerator.registerRuleSet(ruleSetId, serialized);
+        this.registeredRuleSets.add(ruleSetId);
+      }
+      const raw = this.accelerator.tokenizeLine(line, ruleSetId);
+      const tokens = parseTokens(raw);
+      const exitState = this.highlighter.getNextLineState(line, entryState);
+      const rendered = this.applyTheme(line, tokens);
+      this.cache.set(lineIdx, { lineContent: line, entryState, exitState, rendered });
+      return truncateAnsi(rendered, cols);
+    } catch {
+      return line.length > cols ? line.slice(0, cols) : line;
+    }
+  }
+  applyTheme(line, tokens) {
+    if (tokens.length === 0) return line;
+    let result = "";
+    let pos = 0;
+    for (const token of tokens) {
+      if (token.start > pos) {
+        result += line.slice(pos, token.start);
+      }
+      const color = this.theme.colors[token.tokenType];
+      const text = line.slice(token.start, token.end);
+      if (color) {
+        result += color + text + "\x1B[0m";
+      } else {
+        result += text;
+      }
+      pos = token.end;
+    }
+    if (pos < line.length) {
+      result += line.slice(pos);
+    }
+    return result;
+  }
+};
+
+// src/lib/editor/syntax/theme.ts
+var defaultSyntaxTheme = {
+  name: "default",
+  colors: {
+    keyword: "\x1B[93m",
+    string: "\x1B[32m",
+    number: "\x1B[36m",
+    comment: "\x1B[90m",
+    tag: "\x1B[91m",
+    attribute: "\x1B[33m",
+    value: "\x1B[36m",
+    punctuation: "\x1B[97m",
+    heading: "\x1B[1;93m",
+    link: "\x1B[4;36m",
+    bold: "\x1B[1m",
+    italic: "\x1B[3m",
+    code: "\x1B[90;47m"
+  }
+};
+
 // src/lib/processors/system/cli-nano-command-processor.ts
 var FS_TOKEN = "cli-file-system-service";
 var CliNanoCommandProcessor = class {
@@ -7561,6 +7790,7 @@ var CliNanoCommandProcessor = class {
     } else {
       this.filePath = null;
     }
+    this.setupHighlighting(this.filePath);
     context2.enterFullScreenMode(this);
     this.renderer.render(this.buffer, this.filePath || "New Buffer");
     this.resizeDisposable = context2.terminal.onResize(() => {
@@ -7689,11 +7919,13 @@ var CliNanoCommandProcessor = class {
     }
     if (data === "\v") {
       this.buffer.deleteLine();
+      this.renderer.highlightEngine?.invalidate(this.buffer.cursorRow);
       this.render();
       return;
     }
     if (data === "") {
       if (this.buffer.uncutLines()) {
+        this.renderer.highlightEngine?.invalidate(this.buffer.cursorRow);
         this.render();
       } else {
         this.showStatus("Clipboard is empty");
@@ -7754,11 +7986,16 @@ var CliNanoCommandProcessor = class {
     }
     if (data === "\r") {
       this.buffer.insertNewline();
+      this.renderer.highlightEngine?.invalidate(this.buffer.cursorRow - 1);
       this.render();
       return;
     }
     if (data === "\x7F") {
+      const wasMerge = this.buffer.cursorCol === 0 && this.buffer.cursorRow > 0;
       this.buffer.deleteCharBefore();
+      if (wasMerge) {
+        this.renderer.highlightEngine?.invalidate(this.buffer.cursorRow);
+      }
       this.render();
       return;
     }
@@ -7851,6 +8088,31 @@ var CliNanoCommandProcessor = class {
       `  ${writer.wrapInColor("^Y", cliCore.CliForegroundColor.Yellow)}  Page Up           ${writer.wrapInColor("^V", cliCore.CliForegroundColor.Yellow)}  Page Down`
     );
   }
+  // ── Syntax highlighting ──
+  setupHighlighting(filePath) {
+    if (!filePath) {
+      this.renderer.highlightEngine = void 0;
+      return;
+    }
+    try {
+      const registry = this.context.services.get(
+        "syntax-highlighter-registry"
+      );
+      const ext = "." + filePath.split(".").pop()?.toLowerCase();
+      const highlighter = registry.getByExtension(ext);
+      if (highlighter) {
+        this.renderer.highlightEngine = new SyntaxHighlightEngine(
+          highlighter,
+          defaultSyntaxTheme,
+          getAccelerator()
+        );
+      } else {
+        this.renderer.highlightEngine = void 0;
+      }
+    } catch {
+      this.renderer.highlightEngine = void 0;
+    }
+  }
   // ── Rendering helpers ──
   render() {
     this.renderer.render(
@@ -8388,17 +8650,23 @@ var CliProcessRegistry = class {
   get currentPid() {
     return this._currentPid;
   }
-  register(command2) {
+  register(command2, options) {
     const pid = this.nextPid++;
     const abortController = new AbortController();
+    const type = options?.type ?? "command";
     this.processes.set(pid, {
       pid,
+      name: options?.name ?? command2,
+      type,
       command: command2,
       startTime: Date.now(),
       status: "running",
-      abortController
+      abortController,
+      onKill: options?.onKill
     });
-    this._currentPid = pid;
+    if (type === "command") {
+      this._currentPid = pid;
+    }
     this.pruneHistory();
     return { pid, abortController };
   }
@@ -8425,6 +8693,10 @@ var CliProcessRegistry = class {
   kill(pid) {
     const entry = this.processes.get(pid);
     if (!entry || entry.status !== "running") return false;
+    if (entry.onKill) {
+      Promise.resolve(entry.onKill()).catch(() => {
+      });
+    }
     entry.abortController.abort();
     entry.status = "killed";
     entry.exitCode = -9;
@@ -8434,7 +8706,9 @@ var CliProcessRegistry = class {
     return true;
   }
   list() {
-    return Array.from(this.processes.values()).map(({ abortController, ...entry }) => entry);
+    return Array.from(this.processes.values()).map(
+      ({ abortController, onKill, ...entry }) => entry
+    );
   }
   pruneHistory() {
     const entries = Array.from(this.processes.entries());
@@ -8471,11 +8745,13 @@ var CliPsCommandProcessor = class {
       context2.writer.writeInfo("No processes");
       return;
     }
-    const headers = ["PID", "STATUS", "EXIT", "TIME", "COMMAND"];
+    const headers = ["PID", "NAME", "TYPE", "STATUS", "EXIT", "TIME", "COMMAND"];
     const rows = processes.map((p) => {
       const elapsed = `${Math.round((Date.now() - p.startTime) / 1e3)}s`;
       return [
         String(p.pid),
+        p.name,
+        p.type,
         p.status,
         p.exitCode !== void 0 ? String(p.exitCode) : "-",
         elapsed,
@@ -8520,6 +8796,553 @@ var CliKillCommandProcessor = class {
     }
   }
 };
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var ansi = {
+  clearScreen: `${CSI}2J`,
+  cursorHome: `${CSI}H`,
+  hideCursor: `${CSI}?25l`,
+  cursorTo: (row, col) => `${CSI}${row};${col}H`,
+  fg: {
+    green: `${CSI}32m`,
+    cyan: `${CSI}36m`,
+    yellow: `${CSI}93m`,
+    white: `${CSI}97m`,
+    red: `${CSI}91m`,
+    gray: `${CSI}90m`
+  },
+  bg: {
+    blue: `${CSI}44m`
+  },
+  bold: `${CSI}1m`,
+  dim: `${CSI}2m`,
+  inverse: `${CSI}7m`,
+  reset: `${CSI}0m`
+};
+var BOX = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502"
+};
+function formatElapsed(ms) {
+  const seconds = Math.floor(ms / 1e3) % 60;
+  const minutes = Math.floor(ms / (1e3 * 60)) % 60;
+  const hours = Math.floor(ms / (1e3 * 60 * 60)) % 24;
+  const days = Math.floor(ms / (1e3 * 60 * 60 * 24));
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  parts.push(`${seconds}s`);
+  return parts.join(" ");
+}
+function statusColor(status) {
+  switch (status) {
+    case "running":
+      return ansi.fg.green;
+    case "completed":
+    case "done":
+      return ansi.fg.cyan;
+    case "pending":
+      return ansi.fg.yellow;
+    case "stopped":
+      return ansi.fg.white;
+    case "failed":
+    case "killed":
+      return ansi.fg.red;
+    default:
+      return ansi.fg.white;
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 1) + "\u2026";
+}
+function pad(str, len) {
+  return str.length >= len ? str.substring(0, len) : str + " ".repeat(len - str.length);
+}
+var CliHtopCommandProcessor = class {
+  constructor() {
+    this.command = "htop";
+    this.description = "Interactive process and service monitor";
+    this.author = cliCore.DefaultLibraryAuthor;
+    this.metadata = {
+      icon: "\u{1F4CA}",
+      sealed: true,
+      module: "system"
+    };
+    this.context = null;
+    this.registry = null;
+    this.refreshTimer = null;
+    this.rows = [];
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.termCols = 80;
+    this.termRows = 24;
+    this.showingLogs = false;
+    this.errorMessage = null;
+    this.errorTimeout = null;
+  }
+  async processCommand(_command, context2) {
+    try {
+      this.registry = context2.services.get(
+        CliProcessRegistry_TOKEN
+      );
+    } catch {
+      context2.writer.writeError("Process registry not available");
+      return;
+    }
+    this.context = context2;
+    this.termCols = context2.terminal.cols || 80;
+    this.termRows = context2.terminal.rows || 24;
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.showingLogs = false;
+    this.errorMessage = null;
+    context2.enterFullScreenMode(this);
+    this.refreshData();
+    this.render();
+    this.refreshTimer = context2.createInterval(() => {
+      if (!this.showingLogs) {
+        this.refreshData();
+        this.render();
+      }
+    }, 1e3);
+  }
+  async onData(data, context2) {
+    if (this.showingLogs) {
+      this.showingLogs = false;
+      this.render();
+      return;
+    }
+    switch (data) {
+      case `${ESC}[A`:
+        this.moveSelection(-1);
+        this.render();
+        break;
+      case `${ESC}[B`:
+        this.moveSelection(1);
+        this.render();
+        break;
+      case "q":
+      case ESC:
+        this.exit(context2);
+        break;
+      case "k":
+        this.actionKill();
+        break;
+      case "s":
+        await this.actionStart();
+        break;
+      case "t":
+        await this.actionStop();
+        break;
+      case "r":
+        await this.actionRestart();
+        break;
+      case "l":
+        this.actionLogs();
+        break;
+    }
+  }
+  onResize(cols, rows, _context) {
+    this.termCols = cols;
+    this.termRows = rows;
+    this.clampScroll();
+    this.render();
+  }
+  onDispose(_context) {
+    this.refreshTimer = null;
+    this.context = null;
+    this.registry = null;
+    this.rows = [];
+  }
+  writeDescription(context2) {
+    const { writer } = context2;
+    writer.writeln("Interactive process and service monitor");
+    writer.writeln();
+    writer.writeln("Usage:");
+    writer.writeln(`  ${writer.wrapInColor("htop", 36)}`);
+  }
+  // ── Data ─────────────────────────────────────────────────────────
+  refreshData() {
+    if (!this.registry || !this.context) return;
+    const processEntries = this.registry.list();
+    const serviceEntries = this.context.backgroundServices.list();
+    const servicePids = /* @__PURE__ */ new Set();
+    for (const svc of serviceEntries) {
+      if (svc.pid !== void 0) {
+        servicePids.add(svc.pid);
+      }
+    }
+    const unified = [];
+    for (const p of processEntries) {
+      if (servicePids.has(p.pid)) continue;
+      unified.push({
+        pid: p.pid,
+        name: p.name,
+        type: p.type,
+        status: p.status,
+        time: formatElapsed(Date.now() - p.startTime),
+        mode: "main",
+        source: "process"
+      });
+    }
+    for (const svc of serviceEntries) {
+      let time = "-";
+      if (svc.status === "running" && svc.startedAt) {
+        time = formatElapsed(Date.now() - new Date(svc.startedAt).getTime());
+      }
+      unified.push({
+        pid: svc.pid ?? 0,
+        name: svc.name,
+        type: svc.type,
+        status: svc.status,
+        time,
+        mode: svc.executionMode === "worker" ? "worker" : "main",
+        source: "service",
+        serviceInfo: svc
+      });
+    }
+    unified.sort((a, b) => {
+      const aRunning = a.status === "running" ? 0 : 1;
+      const bRunning = b.status === "running" ? 0 : 1;
+      if (aRunning !== bRunning) return aRunning - bRunning;
+      return b.pid - a.pid;
+    });
+    this.rows = unified;
+    if (this.rows.length === 0) {
+      this.selectedIndex = 0;
+    } else {
+      this.selectedIndex = Math.min(this.selectedIndex, this.rows.length - 1);
+    }
+    this.clampScroll();
+  }
+  // ── Actions ──────────────────────────────────────────────────────
+  actionKill() {
+    const row = this.rows[this.selectedIndex];
+    if (!row || row.status !== "running") return;
+    if (row.name === "htop" && row.source === "process") {
+      if (this.context) this.exit(this.context);
+      return;
+    }
+    try {
+      if (this.registry) {
+        this.registry.kill(row.pid);
+      }
+    } catch (e) {
+      this.showError(e?.message || "Kill failed");
+    }
+    this.refreshData();
+    this.render();
+  }
+  async actionStart() {
+    const row = this.rows[this.selectedIndex];
+    if (!row || row.source !== "service") return;
+    if (row.status !== "stopped" && row.status !== "pending" && row.status !== "failed") return;
+    try {
+      await this.context.backgroundServices.start(row.name);
+    } catch (e) {
+      this.showError(e?.message || "Start failed");
+    }
+    this.refreshData();
+    this.render();
+  }
+  async actionStop() {
+    const row = this.rows[this.selectedIndex];
+    if (!row || row.source !== "service" || row.status !== "running") return;
+    try {
+      await this.context.backgroundServices.stop(row.name);
+    } catch (e) {
+      this.showError(e?.message || "Stop failed");
+    }
+    this.refreshData();
+    this.render();
+  }
+  async actionRestart() {
+    const row = this.rows[this.selectedIndex];
+    if (!row || row.source !== "service") return;
+    try {
+      await this.context.backgroundServices.restart(row.name);
+    } catch (e) {
+      this.showError(e?.message || "Restart failed");
+    }
+    this.refreshData();
+    this.render();
+  }
+  actionLogs() {
+    const row = this.rows[this.selectedIndex];
+    if (!row || row.source !== "service" || !this.context) return;
+    this.showingLogs = true;
+    this.renderLogsOverlay(row.name);
+  }
+  // ── Navigation ───────────────────────────────────────────────────
+  moveSelection(delta) {
+    if (this.rows.length === 0) return;
+    this.selectedIndex += delta;
+    if (this.selectedIndex < 0) {
+      this.selectedIndex = this.rows.length - 1;
+    } else if (this.selectedIndex >= this.rows.length) {
+      this.selectedIndex = 0;
+    }
+    this.clampScroll();
+  }
+  get visibleRows() {
+    return Math.max(1, this.termRows - 4);
+  }
+  clampScroll() {
+    if (this.selectedIndex < this.scrollOffset) {
+      this.scrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.scrollOffset + this.visibleRows) {
+      this.scrollOffset = this.selectedIndex - this.visibleRows + 1;
+    }
+    this.scrollOffset = Math.max(0, this.scrollOffset);
+  }
+  // ── Rendering ────────────────────────────────────────────────────
+  render() {
+    if (!this.context) return;
+    const buf = [];
+    const cols = this.termCols;
+    buf.push(ansi.clearScreen, ansi.cursorHome, ansi.hideCursor);
+    const runningCount = this.rows.filter((r) => r.status === "running").length;
+    const totalCount = this.rows.length;
+    let headerLeft;
+    if (this.errorMessage) {
+      headerLeft = `${ansi.bold}${ansi.fg.red} htop ${ansi.reset}${ansi.fg.red}${ansi.dim} ${this.errorMessage}${ansi.reset}`;
+    } else {
+      headerLeft = `${ansi.bold}${ansi.fg.cyan} htop${ansi.reset}${ansi.fg.gray} \u2014 ${runningCount} running / ${totalCount} total${ansi.reset}`;
+    }
+    const headerRight = `${ansi.fg.gray}Refresh: 1s${ansi.reset}`;
+    buf.push(ansi.cursorTo(1, 1));
+    buf.push(headerLeft);
+    buf.push(ansi.cursorTo(1, Math.max(1, cols - 11)));
+    buf.push(headerRight);
+    buf.push(ansi.cursorTo(2, 1));
+    buf.push(ansi.fg.gray, BOX.horizontal.repeat(cols), ansi.reset);
+    const colPid = 6;
+    const colType = 9;
+    const colStatus = 11;
+    const colMode = 8;
+    const colTime = 9;
+    const colName = Math.max(10, cols - colPid - colType - colStatus - colMode - colTime - 2);
+    buf.push(ansi.cursorTo(3, 1));
+    buf.push(
+      ansi.bold,
+      ansi.fg.white,
+      " ",
+      pad("PID", colPid),
+      pad("NAME", colName),
+      pad("TYPE", colType),
+      pad("STATUS", colStatus),
+      pad("MODE", colMode),
+      pad("TIME", colTime),
+      ansi.reset
+    );
+    if (this.rows.length === 0) {
+      const emptyMsg = "No processes";
+      const emptyRow = Math.floor(this.visibleRows / 2) + 4;
+      const emptyCol = Math.max(1, Math.floor((cols - emptyMsg.length) / 2));
+      buf.push(ansi.cursorTo(emptyRow, emptyCol));
+      buf.push(ansi.fg.gray, emptyMsg, ansi.reset);
+    } else {
+      const endIdx = Math.min(
+        this.scrollOffset + this.visibleRows,
+        this.rows.length
+      );
+      for (let i = this.scrollOffset; i < endIdx; i++) {
+        const row = this.rows[i];
+        const screenRow = 4 + (i - this.scrollOffset);
+        const isSelected = i === this.selectedIndex;
+        const prefix = isSelected ? ">" : " ";
+        const pidStr = pad(String(row.pid), colPid);
+        const nameStr = pad(truncate(row.name, colName - 1), colName);
+        const typeStr = pad(row.type, colType);
+        const statusStr = pad(row.status, colStatus);
+        const modeStr = pad(row.mode, colMode);
+        const timeStr = pad(row.time, colTime);
+        buf.push(ansi.cursorTo(screenRow, 1));
+        if (isSelected) {
+          buf.push(ansi.inverse);
+        }
+        buf.push(
+          prefix,
+          pidStr,
+          nameStr,
+          typeStr,
+          isSelected ? "" : statusColor(row.status),
+          statusStr,
+          isSelected ? "" : ansi.reset,
+          modeStr,
+          timeStr
+        );
+        const contentLen = 1 + colPid + colName + colType + colStatus + colMode + colTime;
+        if (contentLen < cols) {
+          buf.push(" ".repeat(cols - contentLen));
+        }
+        if (isSelected) {
+          buf.push(ansi.reset);
+        }
+      }
+      if (this.scrollOffset > 0) {
+        buf.push(ansi.cursorTo(4, cols));
+        buf.push(ansi.fg.gray, "\u2191", ansi.reset);
+      }
+      if (endIdx < this.rows.length) {
+        buf.push(ansi.cursorTo(3 + this.visibleRows, cols));
+        buf.push(ansi.fg.gray, "\u2193", ansi.reset);
+      }
+    }
+    const footerSepRow = this.termRows - 1;
+    buf.push(ansi.cursorTo(footerSepRow, 1));
+    buf.push(ansi.fg.gray, BOX.horizontal.repeat(cols), ansi.reset);
+    buf.push(ansi.cursorTo(this.termRows, 1));
+    buf.push(ansi.dim, " ", this.buildFooter(), ansi.reset);
+    this.context.terminal.write(buf.join(""));
+  }
+  buildFooter() {
+    const selected = this.rows[this.selectedIndex];
+    const parts = [];
+    if (selected) {
+      if (selected.status === "running") {
+        parts.push("k:Kill");
+      }
+      if (selected.source === "service" && (selected.status === "stopped" || selected.status === "pending" || selected.status === "failed")) {
+        parts.push("s:Start");
+      }
+      if (selected.source === "service" && selected.status === "running") {
+        parts.push("t:Stop");
+      }
+      if (selected.source === "service") {
+        parts.push("r:Restart");
+        parts.push("l:Logs");
+      }
+    }
+    parts.push("q:Quit");
+    parts.push("\u2191\u2193:Navigate");
+    return parts.join("  ");
+  }
+  // ── Logs overlay ─────────────────────────────────────────────
+  renderLogsOverlay(serviceName) {
+    if (!this.context) return;
+    const logs = this.context.backgroundServices.getLogs(serviceName, 15);
+    const buf = [];
+    const boxWidth = Math.min(this.termCols - 4, 70);
+    const boxHeight = Math.min(this.termRows - 4, logs.length + 4);
+    const startCol = Math.max(1, Math.floor((this.termCols - boxWidth) / 2));
+    const startRow = Math.max(1, Math.floor((this.termRows - boxHeight) / 2));
+    const innerWidth = boxWidth - 2;
+    const title = ` Logs: ${truncate(serviceName, innerWidth - 10)} `;
+    const topBorder = BOX.topLeft + BOX.horizontal + title + BOX.horizontal.repeat(Math.max(0, boxWidth - title.length - 3)) + BOX.topRight;
+    buf.push(ansi.cursorTo(startRow, startCol));
+    buf.push(ansi.fg.cyan, topBorder, ansi.reset);
+    const contentRows = boxHeight - 3;
+    if (logs.length === 0) {
+      const noLogs = "No log entries";
+      buf.push(ansi.cursorTo(startRow + 1, startCol));
+      buf.push(
+        ansi.fg.cyan,
+        BOX.vertical,
+        ansi.reset,
+        " ",
+        ansi.fg.gray,
+        pad(noLogs, innerWidth - 1),
+        ansi.reset,
+        ansi.fg.cyan,
+        BOX.vertical,
+        ansi.reset
+      );
+      for (let r = 2; r <= contentRows; r++) {
+        buf.push(ansi.cursorTo(startRow + r, startCol));
+        buf.push(
+          ansi.fg.cyan,
+          BOX.vertical,
+          ansi.reset,
+          " ".repeat(innerWidth),
+          ansi.fg.cyan,
+          BOX.vertical,
+          ansi.reset
+        );
+      }
+    } else {
+      const displayLogs = logs.slice(-contentRows);
+      let lineIdx = 0;
+      for (const entry of displayLogs) {
+        const ts = new Date(entry.timestamp).toLocaleTimeString();
+        const levelTag = entry.level === "error" ? `${ansi.fg.red}ERR${ansi.reset}` : entry.level === "warn" ? `${ansi.fg.yellow}WRN${ansi.reset}` : `${ansi.fg.cyan}INF${ansi.reset}`;
+        const line = `[${ts}] ${levelTag} ${truncate(entry.message, innerWidth - 18)}`;
+        buf.push(ansi.cursorTo(startRow + 1 + lineIdx, startCol));
+        buf.push(
+          ansi.fg.cyan,
+          BOX.vertical,
+          ansi.reset,
+          " ",
+          line
+        );
+        buf.push(ansi.cursorTo(startRow + 1 + lineIdx, startCol + boxWidth - 1));
+        buf.push(ansi.fg.cyan, BOX.vertical, ansi.reset);
+        lineIdx++;
+      }
+      for (let r = lineIdx; r < contentRows; r++) {
+        buf.push(ansi.cursorTo(startRow + 1 + r, startCol));
+        buf.push(
+          ansi.fg.cyan,
+          BOX.vertical,
+          ansi.reset,
+          " ".repeat(innerWidth),
+          ansi.fg.cyan,
+          BOX.vertical,
+          ansi.reset
+        );
+      }
+    }
+    const pressMsg = "Press any key to close";
+    const pressPad = Math.max(0, Math.floor((innerWidth - pressMsg.length) / 2));
+    buf.push(ansi.cursorTo(startRow + contentRows + 1, startCol));
+    buf.push(
+      ansi.fg.cyan,
+      BOX.vertical,
+      ansi.reset,
+      " ".repeat(pressPad),
+      ansi.fg.gray,
+      pressMsg,
+      ansi.reset,
+      " ".repeat(Math.max(0, innerWidth - pressPad - pressMsg.length)),
+      ansi.fg.cyan,
+      BOX.vertical,
+      ansi.reset
+    );
+    buf.push(ansi.cursorTo(startRow + contentRows + 2, startCol));
+    buf.push(
+      ansi.fg.cyan,
+      BOX.bottomLeft,
+      BOX.horizontal.repeat(boxWidth - 2),
+      BOX.bottomRight,
+      ansi.reset
+    );
+    this.context.terminal.write(buf.join(""));
+  }
+  // ── Utilities ────────────────────────────────────────────────
+  showError(msg) {
+    this.errorMessage = msg;
+    if (this.errorTimeout) {
+      this.errorTimeout.clear();
+    }
+    if (this.context) {
+      this.errorTimeout = this.context.createInterval(() => {
+        this.errorMessage = null;
+        this.errorTimeout?.clear();
+        this.errorTimeout = null;
+      }, 3e3);
+    }
+  }
+  exit(context2) {
+    context2.exitFullScreenMode();
+    this.context = null;
+  }
+};
 
 // src/lib/processors/system/index.ts
 var systemProcessors = [
@@ -8533,7 +9356,8 @@ var systemProcessors = [
   new CliNanoCommandProcessor(),
   new CliServicesCommandProcessor(),
   new CliPsCommandProcessor(),
-  new CliKillCommandProcessor()
+  new CliKillCommandProcessor(),
+  new CliHtopCommandProcessor()
 ];
 var themes = {
   ...cliCore.DefaultThemes
@@ -8729,10 +9553,12 @@ var CliThemeCommandProcessor = class {
             const selected = await context2.reader.readSelect(
               "Select a theme (live preview):",
               options,
-              (value) => {
-                if (themes[value]) {
-                  context2.terminal.options.theme = themes[value];
-                  this.applyStyles(context2);
+              {
+                onChange: (value) => {
+                  if (themes[value]) {
+                    context2.terminal.options.theme = themes[value];
+                    this.applyStyles(context2);
+                  }
                 }
               }
             );
@@ -9917,6 +10743,10 @@ var CliBackgroundServiceRegistry = class {
     this.isFullScreen = false;
     this.notificationQueue = [];
   }
+  /** Attach the process registry so background services get PIDs */
+  setProcessRegistry(registry) {
+    this.processRegistry = registry;
+  }
   register(service) {
     if (this.entries.has(service.name)) {
       throw new Error(`Service "${service.name}" is already registered`);
@@ -9937,7 +10767,17 @@ var CliBackgroundServiceRegistry = class {
     if (entry.status === "running") {
       throw new Error(`Service "${name}" is already running`);
     }
+    if (this.processRegistry) {
+      const svcType = entry.service.type === "daemon" ? "daemon" : entry.service.type === "job" ? "job" : "service";
+      const proc = this.processRegistry.register(name, {
+        name,
+        type: svcType,
+        onKill: () => this.stop(name)
+      });
+      entry.pid = proc.pid;
+    }
     const useWorker = entry.service.workerCompatible && entry.service.workerFactory && typeof Worker !== "undefined";
+    const isDaemon = entry.service.type === "daemon";
     if (useWorker) {
       const workerRunner = new CliWorkerServiceRunner(
         entry.service,
@@ -9951,15 +10791,19 @@ var CliBackgroundServiceRegistry = class {
       entry.startedAt = /* @__PURE__ */ new Date();
       entry.stoppedAt = void 0;
       entry.error = void 0;
-      try {
-        await workerRunner.start();
-        this.emitLifecycleEvent("service-started", name, {
-          name,
-          mode: "worker"
-        });
-      } catch (e) {
-        this.handleStartError(entry, name, e);
+      if (isDaemon) {
+        workerRunner.start().catch((e) => this.handleStartError(entry, name, e));
+      } else {
+        try {
+          await workerRunner.start();
+        } catch (e) {
+          this.handleStartError(entry, name, e);
+        }
       }
+      this.emitLifecycleEvent("service-started", name, {
+        name,
+        mode: "worker"
+      });
     } else {
       const mainRunner = new CliMainThreadServiceRunner(
         entry.service,
@@ -9973,21 +10817,25 @@ var CliBackgroundServiceRegistry = class {
       entry.startedAt = /* @__PURE__ */ new Date();
       entry.stoppedAt = void 0;
       entry.error = void 0;
-      try {
-        await mainRunner.start();
-        this.emitLifecycleEvent("service-started", name, {
-          name,
-          mode: "main-thread"
-        });
-      } catch (e) {
-        this.handleStartError(entry, name, e);
+      if (isDaemon) {
+        mainRunner.start().catch((e) => this.handleStartError(entry, name, e));
+      } else {
+        try {
+          await mainRunner.start();
+        } catch (e) {
+          this.handleStartError(entry, name, e);
+        }
       }
+      this.emitLifecycleEvent("service-started", name, {
+        name,
+        mode: "main-thread"
+      });
     }
   }
   async stop(name) {
     const entry = this.getEntry(name);
     if (entry.status !== "running") {
-      throw new Error(`Service "${name}" is not running (status: ${entry.status})`);
+      return;
     }
     if (entry.runner) {
       await entry.runner.stop();
@@ -9995,6 +10843,7 @@ var CliBackgroundServiceRegistry = class {
     entry.status = "stopped";
     entry.stoppedAt = /* @__PURE__ */ new Date();
     entry.runner = null;
+    this.completeInProcessRegistry(entry, 0);
     this.emitLifecycleEvent("service-stopped", name, { name });
   }
   async restart(name) {
@@ -10023,6 +10872,7 @@ var CliBackgroundServiceRegistry = class {
         entry.status = "done";
         entry.stoppedAt = /* @__PURE__ */ new Date();
         entry.runner = null;
+        this.completeInProcessRegistry(entry, 0);
         this.emitLifecycleEvent("service-completed", name, {
           name,
           duration
@@ -10036,6 +10886,7 @@ var CliBackgroundServiceRegistry = class {
         entry.error = error.message;
         entry.stoppedAt = /* @__PURE__ */ new Date();
         entry.runner = null;
+        this.failInProcessRegistry(entry);
         this.emitLifecycleEvent("service-failed", name, {
           name,
           error: error.message
@@ -10110,6 +10961,7 @@ var CliBackgroundServiceRegistry = class {
     const executionMode = entry.runner ? entry.runner.mode : "main-thread";
     const uptime = entry.status === "running" && entry.startedAt ? Date.now() - entry.startedAt.getTime() : void 0;
     return {
+      pid: entry.pid,
       name: entry.service.name,
       description: entry.service.description,
       type: entry.service.type,
@@ -10126,9 +10978,14 @@ var CliBackgroundServiceRegistry = class {
     if (!entry) return;
     const from = entry.status;
     entry.status = status;
-    if (status === "stopped" || status === "failed" || status === "done") {
+    if (status === "stopped" || status === "done") {
+      entry.stoppedAt = /* @__PURE__ */ new Date();
+      entry.runner = null;
+      this.completeInProcessRegistry(entry, 0);
+    } else if (status === "failed") {
       entry.stoppedAt = /* @__PURE__ */ new Date();
       entry.runner = null;
+      this.failInProcessRegistry(entry);
     }
     this.emitLifecycleEvent("status-change", name, { name, from, to: status });
   }
@@ -10139,6 +10996,7 @@ var CliBackgroundServiceRegistry = class {
     entry.stoppedAt = /* @__PURE__ */ new Date();
     entry.runner = null;
     entry.logBuffer.add(`Failed to start: ${error.message}`, "error");
+    this.failInProcessRegistry(entry);
     if (entry.service.onError) {
       entry.service.onError(error, {});
     }
@@ -10191,6 +11049,16 @@ var CliBackgroundServiceRegistry = class {
     this.writer.writeln(`\u250C\u2500 [${event.source}] ${message}`);
     this.writer.writeln("\u2514" + "\u2500".repeat(40));
   }
+  completeInProcessRegistry(entry, exitCode) {
+    if (entry.pid !== void 0 && this.processRegistry) {
+      this.processRegistry.complete(entry.pid, exitCode);
+    }
+  }
+  failInProcessRegistry(entry) {
+    if (entry.pid !== void 0 && this.processRegistry) {
+      this.processRegistry.fail(entry.pid);
+    }
+  }
 };
 var ANSI_RE = /\x1b\[[0-9;]*m/g;
 function visibleLength(text) {
@@ -10287,8 +11155,8 @@ var CliTerminalWriter = class {
   }
   writeColumns(items, options) {
     const cols = options?.columns ?? 3;
-    const pad = options?.padding ?? 2;
-    const colWidth = Math.max(...items.map((s) => s.length)) + pad;
+    const pad2 = options?.padding ?? 2;
+    const colWidth = Math.max(...items.map((s) => s.length)) + pad2;
     for (let i = 0; i < items.length; i += cols) {
       const row = items.slice(i, i + cols);
       this.writeln(row.map((item) => item.padEnd(colWidth)).join(""));
@@ -10516,51 +11384,34 @@ var CliTerminalProgressBar = class {
   }
   updateProgressBar() {
     const displayProgress = Math.round(this.progress);
-    const totalBars = 50;
+    const totalBars = 30;
     const filledBars = Math.round(
       displayProgress / this.total * totalBars
     );
     const emptyBars = totalBars - filledBars;
     const RESET4 = "\x1B[0m";
+    const CYAN = "\x1B[36m";
+    const BRIGHT_CYAN = "\x1B[1;36m";
     const DIM4 = "\x1B[2m";
+    const shimmerPos = this.tickCount % (filledBars + 4);
     let filledStr = "";
-    const shimmerPos = this.tickCount % (filledBars + 6);
     for (let i = 0; i < filledBars; i++) {
-      const ratio = filledBars > 1 ? i / (filledBars - 1) : 1;
-      const color = this.progressGradientColor(ratio);
-      const isShimmer = i >= shimmerPos - 2 && i <= shimmerPos;
-      const bright = isShimmer ? "\x1B[1m" : "";
-      filledStr += `${color}${bright}#${RESET4}`;
-    }
-    const emptyStr = `${DIM4}${".".repeat(emptyBars)}${RESET4}`;
-    const progressBar = `[${filledStr}${emptyStr}]`;
-    const percentage = `${displayProgress}%`.padStart(4, " ");
-    const text = this.text.length > 0 ? ` ${this.text}` : "";
+      const isShimmer = i >= shimmerPos - 1 && i <= shimmerPos;
+      filledStr += `${isShimmer ? BRIGHT_CYAN : CYAN}\u2501${RESET4}`;
+    }
+    const emptyStr = `${DIM4}${"\u2500".repeat(emptyBars)}${RESET4}`;
+    const progressBar = `${CYAN}[${RESET4}${filledStr}${emptyStr}${CYAN}]${RESET4}`;
+    const percentage = `${CYAN}${displayProgress}%${RESET4}`.padStart(4, " ");
+    const text = this.text.length > 0 ? ` ${DIM4}${this.text}${RESET4}` : "";
     this.clearCurrentLine();
     this.progressText = `${progressBar} ${percentage} ${text}`;
-    this.progressTextPlainLength = 1 + totalBars + 1 + 1 + 4 + 1 + text.length;
+    this.progressTextPlainLength = 1 + totalBars + 1 + 1 + 4 + 1 + this.text.length + 1;
     this.terminal.write(this.progressText);
     this.lastLineCount = this.calcLineCount(this.progressTextPlainLength);
     if (this.context) {
       this.context.setCurrentLine(this.progressText);
     }
   }
-  /**
-   * Returns an ANSI 256-color escape for a position in the progress bar.
-   * Gradient: red (0%) -> yellow (50%) -> green (100%).
-   */
-  progressGradientColor(ratio) {
-    let r, g;
-    if (ratio < 0.5) {
-      r = 5;
-      g = Math.round(ratio / 0.5 * 5);
-    } else {
-      r = Math.round((1 - ratio) / 0.5 * 5);
-      g = 5;
-    }
-    const colorIndex = 16 + 36 * r + 6 * g + 0;
-    return `\x1B[38;5;${colorIndex}m`;
-  }
   clearCurrentLine() {
     const lines = Math.max(
       this.lastLineCount,
@@ -10673,243 +11524,1779 @@ var CliClipboard = class {
   }
 };
 
-// src/lib/services/cli-input-reader.ts
-var CliInputReader = class {
-  constructor(host) {
+// src/lib/input/modes/input-mode-base.ts
+var InputModeBase = class {
+  constructor(host, resolve) {
     this.host = host;
+    this.resolve = resolve;
+    this._resolved = false;
+    /** Number of extra lines rendered below the prompt (help bar, error, etc.) */
+    this.extraLines = 0;
   }
-  readLine(prompt) {
-    return this.createInputRequest("line", prompt);
+  /** Whether this mode has already resolved (prevents double-resolve from async operations) */
+  get isResolved() {
+    return this._resolved;
   }
-  readPassword(prompt) {
-    return this.createInputRequest("password", prompt);
+  /**
+   * Default key event handler. Aborts on Ctrl+C or Escape.
+   * Subclasses may override for custom behavior (e.g., search-enabled modes
+   * clear the filter first, abort on second press).
+   */
+  handleKeyEvent(event) {
+    if (event.code === "KeyC" && event.ctrlKey || event.code === "Escape") {
+      this.abort();
+      return false;
+    }
+    return true;
   }
-  readConfirm(prompt, defaultValue = false) {
-    const hint = defaultValue ? "(Y/n)" : "(y/N)";
-    const displayPrompt = `${prompt} ${hint}: `;
-    return new Promise((resolve) => {
-      if (this.host.activeInputRequest) {
-        throw new Error("Another input request is already active");
-      }
-      this.host.writeToTerminal(displayPrompt);
-      this.host.setActiveInputRequest({
-        type: "confirm",
-        promptText: displayPrompt,
-        resolve,
-        buffer: "",
-        cursorPosition: 0,
-        defaultValue
-      });
-    });
+  /**
+   * Resolve the input promise with a value and pop this mode from the stack.
+   */
+  resolveAndPop(value) {
+    if (this._resolved) return;
+    this._resolved = true;
+    this.host.terminal.write("\r\n");
+    this.host.popMode();
+    this.resolve(value);
   }
-  readSelect(prompt, options, onChange) {
-    if (!options || options.length === 0) {
-      return Promise.reject(
-        new Error("readSelect requires at least one option")
+  /**
+   * Abort the input — resolve with null and pop.
+   */
+  abort() {
+    if (this._resolved) return;
+    this._resolved = true;
+    this.host.terminal.write("\r\n");
+    this.host.popMode();
+    this.resolve(null);
+  }
+  /**
+   * Clear the current line and redraw prompt + display text, positioning
+   * the cursor at the given position.
+   *
+   * All writes are batched into a single `terminal.write()` call to
+   * eliminate visible flicker between clear and redraw.
+   */
+  redrawLine(promptText, displayText, cursorPosition) {
+    let buf = "";
+    if (this.extraLines > 0) {
+      buf += "\x1B[s";
+      for (let i = 0; i < this.extraLines; i++) {
+        buf += "\x1B[B\x1B[2K";
+      }
+      buf += "\x1B[u";
+      this.extraLines = 0;
+    }
+    buf += "\x1B[2K\r" + promptText + displayText;
+    const cursorOffset = displayText.length - cursorPosition;
+    if (cursorOffset > 0) {
+      buf += `\x1B[${cursorOffset}D`;
+    }
+    this.host.terminal.write(buf);
+  }
+  /**
+   * Render a dimmed help bar below the current line.
+   */
+  writeHelp(text) {
+    this.extraLines++;
+    this.host.terminal.write(
+      `\r
+    \x1B[2m${text}\x1B[0m\x1B[${this.extraLines}A`
+    );
+  }
+  /**
+   * Write a validation error below the current line.
+   */
+  writeError(message) {
+    this.extraLines++;
+    this.host.terminal.write(
+      `\r
+  \x1B[31m\u2718 ${message}\x1B[0m\x1B[${this.extraLines}A`
+    );
+  }
+  /**
+   * Clear any extra lines (help bar, errors) rendered below the prompt.
+   */
+  clearExtraLines() {
+    if (this.extraLines > 0) {
+      let buf = "\x1B[s";
+      for (let i = 0; i < this.extraLines; i++) {
+        buf += "\x1B[B\x1B[2K";
+      }
+      buf += "\x1B[u";
+      this.host.terminal.write(buf);
+      this.extraLines = 0;
+    }
+  }
+};
+
+// src/lib/input/modes/line-input-mode.ts
+var LineInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, options) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.options = options;
+    this.hasError = false;
+    this.buffer = options?.default ?? "";
+    this.cursorPosition = this.buffer.length;
+  }
+  activate() {
+    const prompt = `\x1B[36m?\x1B[0m ${this.promptText}`;
+    this.host.writeToTerminal(prompt);
+    if (this.buffer) {
+      this.host.writeToTerminal(this.buffer);
+    } else if (this.options?.placeholder) {
+      this.host.writeToTerminal(`\x1B[2m${this.options.placeholder}\x1B[0m`);
+      this.host.terminal.write(`\x1B[${this.options.placeholder.length}D`);
+    }
+  }
+  async handleInput(data) {
+    if (this.hasError) {
+      this.hasError = false;
+      this.clearExtraLines();
+    }
+    if (data === "\r") {
+      if (this.options?.validate) {
+        const error = this.options.validate(this.buffer);
+        if (error) {
+          this.hasError = true;
+          this.writeError(error);
+          return;
+        }
+      }
+      this.resolveAndPop(this.buffer);
+    } else if (data === "\x7F") {
+      if (this.cursorPosition > 0) {
+        this.buffer = this.buffer.slice(0, this.cursorPosition - 1) + this.buffer.slice(this.cursorPosition);
+        this.cursorPosition--;
+        this.renderLine();
+      }
+    } else if (data === "\x1B[D") {
+      if (this.cursorPosition > 0) {
+        this.cursorPosition--;
+        this.host.terminal.write(data);
+      }
+    } else if (data === "\x1B[C") {
+      if (this.cursorPosition < this.buffer.length) {
+        this.cursorPosition++;
+        this.host.terminal.write(data);
+      }
+    } else if (data.startsWith("\x1B")) ; else {
+      const text = data.replace(/[\r\n]+/g, "");
+      this.buffer = this.buffer.slice(0, this.cursorPosition) + text + this.buffer.slice(this.cursorPosition);
+      this.cursorPosition += text.length;
+      if (this.cursorPosition === this.buffer.length && this.extraLines === 0 && !this.hasError && !(this.options?.placeholder && this.buffer.length === text.length)) {
+        this.host.terminal.write(text);
+      } else {
+        this.renderLine();
+      }
+    }
+  }
+  onResize() {
+    this.renderLine();
+  }
+  renderLine() {
+    const prompt = `\x1B[36m?\x1B[0m ${this.promptText}`;
+    if (this.buffer.length === 0 && this.options?.placeholder) {
+      const placeholder = `\x1B[2m${this.options.placeholder}\x1B[0m`;
+      this.redrawLine(prompt, placeholder, 0);
+    } else {
+      this.redrawLine(prompt, this.buffer, this.cursorPosition);
+    }
+  }
+};
+
+// src/lib/input/modes/password-input-mode.ts
+var PasswordInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.buffer = "";
+  }
+  activate() {
+    const prompt = `\x1B[36m?\x1B[0m ${this.promptText}`;
+    this.host.writeToTerminal(prompt);
+  }
+  async handleInput(data) {
+    if (data === "\r") {
+      this.resolveAndPop(this.buffer);
+    } else if (data === "\x7F") {
+      if (this.buffer.length > 0) {
+        this.buffer = this.buffer.slice(0, -1);
+        this.renderLine();
+      }
+    } else if (data.startsWith("\x1B")) ; else {
+      const text = data.replace(/[\r\n]+/g, "");
+      this.buffer += text;
+      if (this.extraLines === 0) {
+        this.host.terminal.write("*".repeat(text.length));
+      } else {
+        this.renderLine();
+      }
+    }
+  }
+  onResize() {
+    this.renderLine();
+  }
+  renderLine() {
+    const prompt = `\x1B[36m?\x1B[0m ${this.promptText}`;
+    const masked = "*".repeat(this.buffer.length);
+    this.redrawLine(prompt, masked, masked.length);
+  }
+};
+
+// src/lib/input/modes/confirm-input-mode.ts
+var ConfirmInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, defaultValue = false) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.defaultValue = defaultValue;
+    this.buffer = "";
+  }
+  activate() {
+    const hint = this.defaultValue ? "(Y/n)" : "(y/N)";
+    const prompt = `\x1B[36m?\x1B[0m ${this.promptText} ${hint}: `;
+    this.host.writeToTerminal(prompt);
+  }
+  async handleInput(data) {
+    if (data === "\r") {
+      if (this.buffer === "") {
+        this.resolveAndPop(this.defaultValue);
+      } else {
+        const lower = this.buffer.toLowerCase();
+        if (lower === "y") {
+          this.resolveAndPop(true);
+        } else if (lower === "n") {
+          this.resolveAndPop(false);
+        }
+      }
+    } else if (data === "\x7F") {
+      if (this.buffer.length > 0) {
+        this.buffer = this.buffer.slice(0, -1);
+        this.renderLine();
+      }
+    } else if (data.startsWith("\x1B")) ; else {
+      const lower = data.toLowerCase();
+      if (lower === "y" || lower === "n") {
+        this.buffer = lower;
+        this.renderLine();
+      }
+    }
+  }
+  onResize() {
+    this.renderLine();
+  }
+  renderLine() {
+    const hint = this.defaultValue ? "(Y/n)" : "(y/N)";
+    const prompt = `\x1B[36m?\x1B[0m ${this.promptText} ${hint}: `;
+    this.redrawLine(prompt, this.buffer, this.buffer.length);
+  }
+};
+
+// src/lib/input/modes/number-input-mode.ts
+var NumberInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, options) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.options = options;
+    this.hasError = false;
+    this.buffer = options?.default != null ? String(options.default) : "";
+    this.cursorPosition = this.buffer.length;
+  }
+  activate() {
+    const prompt = this.buildPrompt();
+    this.host.writeToTerminal(prompt);
+    if (this.buffer) {
+      this.host.writeToTerminal(this.buffer);
+    }
+  }
+  async handleInput(data) {
+    if (this.hasError) {
+      this.hasError = false;
+      this.clearExtraLines();
+    }
+    if (data === "\r") {
+      if (this.buffer === "" || this.buffer === "-") {
+        if (this.options?.default != null) {
+          this.resolveAndPop(this.options.default);
+        }
+        return;
+      }
+      const value = parseInt(this.buffer, 10);
+      if (isNaN(value)) {
+        this.hasError = true;
+        this.writeError("Please enter a valid number");
+        return;
+      }
+      if (this.options?.min != null && value < this.options.min) {
+        this.hasError = true;
+        this.writeError(`Value must be at least ${this.options.min}`);
+        return;
+      }
+      if (this.options?.max != null && value > this.options.max) {
+        this.hasError = true;
+        this.writeError(`Value must be at most ${this.options.max}`);
+        return;
+      }
+      this.resolveAndPop(value);
+    } else if (data === "\x7F") {
+      if (this.cursorPosition > 0) {
+        this.buffer = this.buffer.slice(0, this.cursorPosition - 1) + this.buffer.slice(this.cursorPosition);
+        this.cursorPosition--;
+        this.renderLine();
+      }
+    } else if (data === "\x1B[D") {
+      if (this.cursorPosition > 0) {
+        this.cursorPosition--;
+        this.host.terminal.write(data);
+      }
+    } else if (data === "\x1B[C") {
+      if (this.cursorPosition < this.buffer.length) {
+        this.cursorPosition++;
+        this.host.terminal.write(data);
+      }
+    } else if (data.startsWith("\x1B")) ; else {
+      for (const ch of data) {
+        if (ch >= "0" && ch <= "9") {
+          this.buffer = this.buffer.slice(0, this.cursorPosition) + ch + this.buffer.slice(this.cursorPosition);
+          this.cursorPosition++;
+        } else if (ch === "-" && this.cursorPosition === 0 && !this.buffer.startsWith("-")) {
+          this.buffer = "-" + this.buffer;
+          this.cursorPosition++;
+        }
+      }
+      this.renderLine();
+    }
+  }
+  onResize() {
+    this.renderLine();
+  }
+  buildPrompt() {
+    const { min, max } = this.options ?? {};
+    let hint = "";
+    if (min != null && max != null) {
+      hint = ` \x1B[2m(${min}\u2013${max})\x1B[0m`;
+    } else if (min != null) {
+      hint = ` \x1B[2m(min: ${min})\x1B[0m`;
+    } else if (max != null) {
+      hint = ` \x1B[2m(max: ${max})\x1B[0m`;
+    }
+    return `\x1B[36m?\x1B[0m ${this.promptText}${hint}`;
+  }
+  renderLine() {
+    const prompt = this.buildPrompt();
+    this.redrawLine(prompt, this.buffer, this.cursorPosition);
+  }
+};
+
+// src/lib/input/modes/select-input-mode.ts
+var SelectInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, options, selectOptions) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.options = options;
+    this.selectOptions = selectOptions;
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.filter = "";
+    /** Number of lines rendered for the option list + help bar (for clearing) */
+    this.renderedLines = 0;
+    this.filteredOptions = [...options];
+    this.maxVisible = Math.min(options.length, host.getTerminalRows() - 4);
+  }
+  activate() {
+    this.host.terminal.write("\x1B[?25l");
+    if (this.selectOptions?.default) {
+      const idx = this.filteredOptions.findIndex(
+        (o) => o.value === this.selectOptions.default
       );
+      if (idx >= 0) {
+        this.selectedIndex = idx;
+        if (this.selectedIndex >= this.maxVisible) {
+          this.scrollOffset = this.selectedIndex - this.maxVisible + 1;
+        }
+      }
+    } else {
+      this.selectedIndex = this.findNextSelectable(-1, 1);
     }
-    return new Promise((resolve) => {
-      if (this.host.activeInputRequest) {
-        throw new Error("Another input request is already active");
-      }
-      const termRows = this.host.getTerminalRows?.() ?? 24;
-      const maxVisible = Math.max(3, termRows - 2);
-      this.host.writeToTerminal(prompt + "\r\n");
-      const displayLines = this.renderSelectOptions(options, 0, 0, maxVisible);
-      onChange?.(options[0].value);
-      this.host.setActiveInputRequest({
-        type: "select",
-        promptText: prompt,
-        resolve,
-        buffer: "",
-        cursorPosition: 0,
-        options,
-        selectedIndex: 0,
-        onChange,
-        scrollOffset: 0,
-        maxVisible,
-        displayLines
-      });
-    });
+    this.renderAll();
   }
-  readSelectInline(prompt, options, onChange) {
-    if (!options || options.length === 0) {
-      return Promise.reject(
-        new Error("readSelectInline requires at least one option")
+  /**
+   * Handle keyboard events. When searchable and filter is non-empty,
+   * Escape clears the filter instead of aborting.
+   */
+  handleKeyEvent(event) {
+    if (this.selectOptions?.searchable && this.filter.length > 0) {
+      if (event.code === "Escape") {
+        this.clearFilter();
+        return false;
+      }
+    }
+    return super.handleKeyEvent(event);
+  }
+  /**
+   * Clear rendered option lines and show final answer before resolving.
+   */
+  resolveAndPop(value) {
+    this.clearRenderedLines();
+    const selectedOpt = this.options.find((o) => o.value === value);
+    const label = selectedOpt ? selectedOpt.label : value;
+    this.host.terminal.write("\x1B[2K\r");
+    this.host.terminal.write(`\x1B[32m\u2714\x1B[0m ${this.promptText} \x1B[36m${label}\x1B[0m`);
+    this.host.terminal.write("\x1B[?25h");
+    super.resolveAndPop(value);
+  }
+  /**
+   * Clear rendered option lines before aborting.
+   */
+  abort() {
+    this.clearRenderedLines();
+    this.host.terminal.write("\x1B[2K\r");
+    this.host.terminal.write(`\x1B[33m\u2718\x1B[0m ${this.promptText} \x1B[2mcancelled\x1B[0m`);
+    this.host.terminal.write("\x1B[?25h");
+    super.abort();
+  }
+  async handleInput(data) {
+    if (data === "\x1B[A") {
+      this.moveSelection(-1);
+    } else if (data === "\x1B[B") {
+      this.moveSelection(1);
+    } else if (data === "\r") {
+      const items = this.buildDisplayList();
+      const selectableItems = items.filter(
+        (i) => i.type === "option" && !i.option.disabled
       );
+      if (selectableItems.length > 0 && this.selectedIndex < selectableItems.length) {
+        const selected = selectableItems[this.selectedIndex];
+        this.resolveAndPop(selected.option.value);
+      }
+    } else if (data === "\x7F") {
+      if (this.selectOptions?.searchable && this.filter.length > 0) {
+        this.filter = this.filter.slice(0, -1);
+        this.applyFilter();
+        this.renderAll();
+      }
+    } else if (data.startsWith("\x1B")) ; else if (this.selectOptions?.searchable && data.length === 1 && data >= " ") {
+      this.filter += data;
+      this.applyFilter();
+      this.renderAll();
     }
-    return new Promise((resolve) => {
-      if (this.host.activeInputRequest) {
-        throw new Error("Another input request is already active");
-      }
-      const inlineText = this.renderInlineSelectOptions(options, 0);
-      this.host.writeToTerminal(`${prompt} ${inlineText}`);
-      onChange?.(options[0].value);
-      this.host.setActiveInputRequest({
-        type: "select-inline",
-        promptText: prompt,
-        resolve,
-        buffer: "",
-        cursorPosition: 0,
-        options,
-        selectedIndex: 0,
-        onChange
+  }
+  onResize(cols, rows) {
+    this.maxVisible = Math.min(this.filteredOptions.length, rows - 4);
+    if (this.scrollOffset + this.maxVisible > this.getSelectableCount()) {
+      this.scrollOffset = Math.max(0, this.getSelectableCount() - this.maxVisible);
+    }
+    this.renderAll();
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  /**
+   * Build flattened display list with group headers inserted.
+   */
+  buildDisplayList() {
+    const items = [];
+    let lastGroup;
+    for (const opt of this.filteredOptions) {
+      if (opt.group && opt.group !== lastGroup) {
+        items.push({ type: "group-header", groupName: opt.group });
+        lastGroup = opt.group;
+      }
+      items.push({ type: "option", option: opt });
+    }
+    return items;
+  }
+  /**
+   * Get the total count of selectable items (non-disabled options).
+   */
+  getSelectableCount() {
+    return this.filteredOptions.filter((o) => !o.disabled).length;
+  }
+  /**
+   * Move selection in the given direction (+1 or -1), skipping disabled options.
+   * Wraps around at boundaries.
+   */
+  moveSelection(direction) {
+    const selectableCount = this.getSelectableCount();
+    if (selectableCount === 0) return;
+    let next = this.selectedIndex + direction;
+    if (next < 0) next = selectableCount - 1;
+    if (next >= selectableCount) next = 0;
+    this.selectedIndex = next;
+    if (this.selectedIndex < this.scrollOffset) {
+      this.scrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.scrollOffset + this.maxVisible) {
+      this.scrollOffset = this.selectedIndex - this.maxVisible + 1;
+    }
+    const selectables = this.filteredOptions.filter((o) => !o.disabled);
+    if (this.selectOptions?.onChange && selectables[this.selectedIndex]) {
+      this.selectOptions.onChange(selectables[this.selectedIndex].value);
+    }
+    this.renderAll();
+  }
+  /**
+   * Find the next selectable (non-disabled) option index starting from `from`.
+   * Returns 0 if none found.
+   */
+  findNextSelectable(from, direction) {
+    const len = this.filteredOptions.length;
+    if (len === 0) return 0;
+    let idx = from + direction;
+    for (let i = 0; i < len; i++) {
+      if (idx < 0) idx = len - 1;
+      if (idx >= len) idx = 0;
+      if (!this.filteredOptions[idx].disabled) return idx;
+      idx += direction;
+    }
+    return 0;
+  }
+  /**
+   * Apply the current filter text to the options list.
+   */
+  applyFilter() {
+    if (this.filter.length === 0) {
+      this.filteredOptions = [...this.options];
+    } else {
+      const lower = this.filter.toLowerCase();
+      this.filteredOptions = this.options.filter(
+        (o) => o.label.toLowerCase().includes(lower)
+      );
+    }
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.maxVisible = Math.min(
+      this.filteredOptions.length,
+      this.host.getTerminalRows() - 4
+    );
+    const selectables = this.filteredOptions.filter((o) => !o.disabled);
+    if (selectables.length > 0) {
+      this.selectedIndex = 0;
+    }
+  }
+  /**
+   * Clear the filter and restore full option list.
+   */
+  clearFilter() {
+    this.filter = "";
+    this.applyFilter();
+    this.renderAll();
+  }
+  /**
+   * Clear all previously rendered lines and re-render everything.
+   */
+  renderAll() {
+    this.clearRenderedLines();
+    this.renderPrompt();
+    this.renderOptions();
+    this.renderHelpBar();
+    if (this.renderedLines > 0) {
+      this.host.terminal.write(`\x1B[${this.renderedLines}A`);
+    }
+  }
+  /**
+   * Clear all lines we previously rendered (below the cursor).
+   */
+  clearRenderedLines() {
+    if (this.renderedLines > 0) {
+      this.host.terminal.write("\x1B[s");
+      for (let i = 0; i < this.renderedLines; i++) {
+        this.host.terminal.write("\x1B[B\x1B[2K");
+      }
+      this.host.terminal.write("\x1B[u");
+      this.renderedLines = 0;
+    }
+  }
+  /**
+   * Render the prompt line.
+   */
+  renderPrompt() {
+    this.host.terminal.write("\x1B[2K\r");
+    if (this.selectOptions?.searchable) {
+      if (this.filter.length > 0) {
+        this.host.terminal.write(
+          `\x1B[36m?\x1B[0m ${this.promptText}: ${this.filter}`
+        );
+      } else {
+        this.host.terminal.write(
+          `\x1B[36m?\x1B[0m ${this.promptText}: \x1B[2mType to filter...\x1B[0m`
+        );
+      }
+    } else {
+      this.host.terminal.write(`\x1B[36m?\x1B[0m ${this.promptText}:`);
+    }
+  }
+  /**
+   * Render the visible slice of the option list.
+   */
+  renderOptions() {
+    const items = this.buildDisplayList();
+    const selectables = this.filteredOptions.filter((o) => !o.disabled);
+    const visibleStart = this.scrollOffset;
+    const visibleEnd = Math.min(
+      selectables.length,
+      this.scrollOffset + this.maxVisible
+    );
+    if (visibleStart > 0) {
+      this.host.terminal.write(`\r
+\x1B[2m  \u2191 ${visibleStart} more above\x1B[0m`);
+      this.renderedLines++;
+    }
+    let selectableIdx = 0;
+    for (const item of items) {
+      if (item.type === "group-header") {
+        if (this.isGroupVisible(item.groupName, items, visibleStart, visibleEnd)) {
+          this.host.terminal.write(
+            `\r
+\x1B[35m\u2500\u2500 ${item.groupName} \u2500\u2500\x1B[0m`
+          );
+          this.renderedLines++;
+        }
+      } else {
+        const opt = item.option;
+        if (opt.disabled) {
+          if (this.isDisabledOptionVisible(items, item, visibleStart, visibleEnd)) {
+            this.renderOptionLine(opt, false, false);
+            this.renderedLines++;
+          }
+        } else {
+          if (selectableIdx >= visibleStart && selectableIdx < visibleEnd) {
+            const isSelected = selectableIdx === this.selectedIndex;
+            this.renderOptionLine(opt, isSelected, false);
+            this.renderedLines++;
+          }
+          selectableIdx++;
+        }
+      }
+    }
+    const remaining = selectables.length - visibleEnd;
+    if (remaining > 0) {
+      this.host.terminal.write(`\r
+\x1B[2m  \u2193 ${remaining} more below\x1B[0m`);
+      this.renderedLines++;
+    }
+  }
+  /**
+   * Check if a group header should be visible given the current visible range.
+   */
+  isGroupVisible(groupName, items, visibleStart, visibleEnd) {
+    let selectableIdx = 0;
+    for (const item of items) {
+      if (item.type === "option" && !item.option.disabled) {
+        if (item.option.group === groupName && selectableIdx >= visibleStart && selectableIdx < visibleEnd) {
+          return true;
+        }
+        selectableIdx++;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a disabled option should be visible (adjacent to visible selectables).
+   */
+  isDisabledOptionVisible(items, disabledItem, visibleStart, visibleEnd) {
+    const idx = items.indexOf(disabledItem);
+    let selectableIdx = 0;
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].type === "option" && !items[i].option.disabled) {
+        if (i > idx) {
+          return selectableIdx >= visibleStart && selectableIdx < visibleEnd;
+        }
+        selectableIdx++;
+      }
+    }
+    return selectableIdx > 0 && selectableIdx - 1 >= visibleStart && selectableIdx - 1 < visibleEnd;
+  }
+  /**
+   * Render a single option line.
+   */
+  renderOptionLine(opt, isSelected, _isGroupHeader) {
+    const label = this.highlightMatch(opt.label);
+    const desc = opt.description ? ` \x1B[2;3m\u2014 ${opt.description}\x1B[0m` : "";
+    if (opt.disabled) {
+      this.host.terminal.write(
+        `\r
+    \x1B[2m${opt.label}${desc} (disabled)\x1B[0m`
+      );
+    } else if (isSelected) {
+      this.host.terminal.write(
+        `\r
+  \x1B[48;5;24m\x1B[38;5;117m\u276F ${label}${desc}\x1B[0m`
+      );
+    } else {
+      this.host.terminal.write(
+        `\r
+    ${label}${desc}`
+      );
+    }
+  }
+  /**
+   * Highlight the matched filter text in yellow within the label.
+   */
+  highlightMatch(label) {
+    if (!this.filter || this.filter.length === 0) return label;
+    const lower = label.toLowerCase();
+    const filterLower = this.filter.toLowerCase();
+    const idx = lower.indexOf(filterLower);
+    if (idx < 0) return label;
+    const before = label.substring(0, idx);
+    const match = label.substring(idx, idx + this.filter.length);
+    const after = label.substring(idx + this.filter.length);
+    return `${before}\x1B[33m${match}\x1B[0m${after}`;
+  }
+  /**
+   * Render the help bar at the bottom.
+   */
+  renderHelpBar() {
+    let help;
+    if (this.selectOptions?.searchable) {
+      if (this.filter.length > 0) {
+        const matchCount = this.filteredOptions.filter((o) => !o.disabled).length;
+        const totalCount = this.options.filter((o) => !o.disabled).length;
+        help = `${matchCount} of ${totalCount} matches \xB7 backspace to clear filter \xB7 enter to select \xB7 esc to cancel`;
+      } else {
+        help = "\u2191/\u2193 navigate \xB7 type to filter \xB7 enter to select \xB7 esc to cancel";
+      }
+    } else {
+      help = "\u2191/\u2193 navigate \xB7 enter to select \xB7 esc to cancel";
+    }
+    this.host.terminal.write(`\r
+    \x1B[2m${help}\x1B[0m`);
+    this.renderedLines++;
+  }
+};
+
+// src/lib/input/modes/inline-select-input-mode.ts
+var InlineSelectInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, options, selectOptions) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.options = options;
+    this.selectOptions = selectOptions;
+    /** Index into the selectable (non-disabled) options */
+    this.selectedIndex = 0;
+    /** Start index of the visible window (into selectable options) */
+    this.visibleStart = 0;
+    /** End index (exclusive) of the visible window */
+    this.visibleEnd = 0;
+    this.selectableOptions = options.filter((o) => !o.disabled);
+  }
+  activate() {
+    this.host.terminal.write("\x1B[?25l");
+    if (this.selectOptions?.default) {
+      const idx = this.selectableOptions.findIndex(
+        (o) => o.value === this.selectOptions.default
+      );
+      if (idx >= 0) {
+        this.selectedIndex = idx;
+      }
+    }
+    this.calculateVisibleWindow();
+    this.render();
+  }
+  /**
+   * Clear the inline options and help bar, then show final answer before resolving.
+   */
+  resolveAndPop(value) {
+    this.clearExtraLines();
+    const selectedOpt = this.selectableOptions.find((o) => o.value === value);
+    const label = selectedOpt ? selectedOpt.label : value;
+    this.host.terminal.write("\x1B[2K\r");
+    this.host.terminal.write(`\x1B[32m\u2714\x1B[0m ${this.promptText}: \x1B[36m${label}\x1B[0m`);
+    this.host.terminal.write("\x1B[?25h");
+    super.resolveAndPop(value);
+  }
+  /**
+   * Clear the inline options and help bar before aborting.
+   */
+  abort() {
+    this.clearExtraLines();
+    this.host.terminal.write("\x1B[2K\r");
+    this.host.terminal.write(`\x1B[33m\u2718\x1B[0m ${this.promptText}: \x1B[2mcancelled\x1B[0m`);
+    this.host.terminal.write("\x1B[?25h");
+    super.abort();
+  }
+  async handleInput(data) {
+    if (data === "\x1B[C") {
+      this.moveSelection(1);
+    } else if (data === "\x1B[D") {
+      this.moveSelection(-1);
+    } else if (data === "\r") {
+      if (this.selectableOptions.length > 0) {
+        this.resolveAndPop(this.selectableOptions[this.selectedIndex].value);
+      }
+    }
+  }
+  onResize(cols, rows) {
+    this.calculateVisibleWindow();
+    this.render();
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  /**
+   * Move selection in the given direction, skipping disabled options.
+   * Wraps around at boundaries.
+   */
+  moveSelection(direction) {
+    if (this.selectableOptions.length === 0) return;
+    let next = this.selectedIndex + direction;
+    if (next < 0) next = this.selectableOptions.length - 1;
+    if (next >= this.selectableOptions.length) next = 0;
+    this.selectedIndex = next;
+    this.adjustVisibleWindow();
+    if (this.selectOptions?.onChange) {
+      this.selectOptions.onChange(this.selectableOptions[this.selectedIndex].value);
+    }
+    this.render();
+  }
+  /**
+   * Get the prompt prefix string (without ANSI escapes for width calculation).
+   */
+  getPromptPrefix() {
+    return `? ${this.promptText}: `;
+  }
+  /**
+   * Get the rendered prompt prefix (with ANSI color codes).
+   */
+  getRenderedPromptPrefix() {
+    return `\x1B[36m?\x1B[0m ${this.promptText}: `;
+  }
+  /**
+   * Calculate the width needed for a single option.
+   * Selected option: `[ label ]` (label.length + 4)
+   * Unselected option: ` label ` (label.length + 2)
+   */
+  getOptionWidth(opt, isSelected) {
+    return isSelected ? opt.label.length + 4 : opt.label.length + 2;
+  }
+  /**
+   * Calculate how many options fit in the visible window starting from a given index.
+   */
+  calculateVisibleWindow() {
+    const cols = this.host.getTerminalCols();
+    const promptWidth = this.getPromptPrefix().length;
+    const available = cols - promptWidth;
+    if (this.selectableOptions.length === 0) {
+      this.visibleStart = 0;
+      this.visibleEnd = 0;
+      return;
+    }
+    let totalWidth = 0;
+    for (let i = 0; i < this.selectableOptions.length; i++) {
+      totalWidth += this.getOptionWidth(this.selectableOptions[i], i === this.selectedIndex);
+    }
+    if (totalWidth <= available) {
+      this.visibleStart = 0;
+      this.visibleEnd = this.selectableOptions.length;
+      return;
+    }
+    this.adjustVisibleWindow();
+  }
+  /**
+   * Adjust the visible window so the selected option is visible.
+   * Accounts for scroll indicator widths.
+   */
+  adjustVisibleWindow() {
+    const cols = this.host.getTerminalCols();
+    const promptWidth = this.getPromptPrefix().length;
+    const available = cols - promptWidth;
+    if (this.selectableOptions.length === 0) return;
+    let totalWidth = 0;
+    for (let i = 0; i < this.selectableOptions.length; i++) {
+      totalWidth += this.getOptionWidth(this.selectableOptions[i], i === this.selectedIndex);
+    }
+    if (totalWidth <= available) {
+      this.visibleStart = 0;
+      this.visibleEnd = this.selectableOptions.length;
+      return;
+    }
+    const indicatorWidth = 2;
+    if (this.selectedIndex < this.visibleStart) {
+      this.visibleStart = this.selectedIndex;
+    }
+    let usedWidth = 0;
+    const hasLeftIndicator = this.visibleStart > 0;
+    if (hasLeftIndicator) {
+      usedWidth += indicatorWidth;
+    }
+    let end = this.visibleStart;
+    for (let i = this.visibleStart; i < this.selectableOptions.length; i++) {
+      const optWidth = this.getOptionWidth(this.selectableOptions[i], i === this.selectedIndex);
+      const needsRightIndicator = i < this.selectableOptions.length - 1;
+      const rightReserve = needsRightIndicator ? indicatorWidth : 0;
+      if (usedWidth + optWidth + rightReserve <= available) {
+        usedWidth += optWidth;
+        end = i + 1;
+      } else {
+        break;
+      }
+    }
+    if (this.selectedIndex >= end) {
+      end = this.selectedIndex + 1;
+      usedWidth = this.getOptionWidth(
+        this.selectableOptions[this.selectedIndex],
+        true
+      );
+      const hasRightIndicator = end < this.selectableOptions.length;
+      if (hasRightIndicator) {
+        usedWidth += indicatorWidth;
+      }
+      let start = this.selectedIndex;
+      for (let i = this.selectedIndex - 1; i >= 0; i--) {
+        const optWidth = this.getOptionWidth(this.selectableOptions[i], false);
+        const needsLeftIndicator = i > 0;
+        const leftReserve = needsLeftIndicator ? indicatorWidth : 0;
+        const currentLeftReserve = start > 0 ? indicatorWidth : 0;
+        if (usedWidth - currentLeftReserve + optWidth + leftReserve <= available) {
+          usedWidth = usedWidth - currentLeftReserve + optWidth + leftReserve;
+          start = i;
+        } else {
+          break;
+        }
+      }
+      this.visibleStart = start;
+      end = this.selectedIndex + 1;
+      usedWidth = 0;
+      if (this.visibleStart > 0) usedWidth += indicatorWidth;
+      for (let i = this.visibleStart; i < end; i++) {
+        usedWidth += this.getOptionWidth(this.selectableOptions[i], i === this.selectedIndex);
+      }
+      for (let i = end; i < this.selectableOptions.length; i++) {
+        const optWidth = this.getOptionWidth(this.selectableOptions[i], false);
+        const needsRightIndicator = i < this.selectableOptions.length - 1;
+        const rightReserve = needsRightIndicator ? indicatorWidth : 0;
+        if (usedWidth + optWidth + rightReserve <= available) {
+          usedWidth += optWidth;
+          end = i + 1;
+        } else {
+          break;
+        }
+      }
+    }
+    this.visibleEnd = end;
+  }
+  /**
+   * Render the complete inline select display.
+   */
+  render() {
+    this.clearExtraLines();
+    this.host.terminal.write("\x1B[2K\r");
+    this.host.terminal.write(this.getRenderedPromptPrefix());
+    if (this.selectableOptions.length === 0) return;
+    const hasLeftOverflow = this.visibleStart > 0;
+    const hasRightOverflow = this.visibleEnd < this.selectableOptions.length;
+    if (hasLeftOverflow) {
+      this.host.terminal.write("\x1B[2m\u25C2\x1B[0m ");
+    }
+    for (let i = this.visibleStart; i < this.visibleEnd; i++) {
+      const opt = this.selectableOptions[i];
+      const isSelected = i === this.selectedIndex;
+      if (isSelected) {
+        this.host.terminal.write(`\x1B[36m[ ${opt.label} ]\x1B[0m`);
+      } else {
+        this.host.terminal.write(` ${opt.label} `);
+      }
+    }
+    if (hasRightOverflow) {
+      this.host.terminal.write(" \x1B[2m\u25B8\x1B[0m");
+    }
+    this.writeHelp("\u2190/\u2192 navigate \xB7 enter to select \xB7 esc to cancel");
+  }
+};
+
+// src/lib/input/modes/multi-select-input-mode.ts
+var MultiSelectInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, options, selectOptions) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.options = options;
+    this.selectOptions = selectOptions;
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.filter = "";
+    /** Number of lines rendered for the option list + help bar (for clearing) */
+    this.renderedLines = 0;
+    this.filteredOptions = [...options];
+    this.maxVisible = Math.min(options.length, host.getTerminalRows() - 4);
+    this.checkedState = /* @__PURE__ */ new Map();
+    for (const opt of options) {
+      this.checkedState.set(opt.value, opt.checked === true);
+    }
+  }
+  activate() {
+    this.host.terminal.write("\x1B[?25l");
+    this.selectedIndex = 0;
+    const selectables = this.filteredOptions.filter((o) => !o.disabled);
+    if (selectables.length > 0) {
+      this.selectedIndex = 0;
+    }
+    this.renderAll();
+  }
+  /**
+   * Handle keyboard events. When searchable and filter is non-empty,
+   * Escape clears the filter instead of aborting.
+   */
+  handleKeyEvent(event) {
+    if (this.selectOptions?.searchable && this.filter.length > 0) {
+      if (event.code === "Escape") {
+        this.clearFilter();
+        return false;
+      }
+    }
+    return super.handleKeyEvent(event);
+  }
+  /**
+   * Clear rendered option lines and show final answer before resolving.
+   */
+  resolveAndPop(value) {
+    this.clearRenderedLines();
+    const labels = value.map((v) => {
+      const opt = this.options.find((o) => o.value === v);
+      return opt ? opt.label : v;
+    });
+    const summary = labels.length > 0 ? labels.join(", ") : "none";
+    this.host.terminal.write("\x1B[2K\r");
+    this.host.terminal.write(`\x1B[32m\u2714\x1B[0m ${this.promptText} \x1B[36m${summary}\x1B[0m`);
+    this.host.terminal.write("\x1B[?25h");
+    super.resolveAndPop(value);
+  }
+  /**
+   * Clear rendered option lines before aborting.
+   */
+  abort() {
+    this.clearRenderedLines();
+    this.host.terminal.write("\x1B[2K\r");
+    this.host.terminal.write(`\x1B[33m\u2718\x1B[0m ${this.promptText} \x1B[2mcancelled\x1B[0m`);
+    this.host.terminal.write("\x1B[?25h");
+    super.abort();
+  }
+  async handleInput(data) {
+    if (data === "\x1B[A") {
+      this.moveSelection(-1);
+    } else if (data === "\x1B[B") {
+      this.moveSelection(1);
+    } else if (data === " ") {
+      this.toggleCurrent();
+    } else if (data === "a" && (!this.selectOptions?.searchable || this.filter.length === 0)) {
+      this.toggleAll();
+    } else if (data === "\r") {
+      this.resolveAndPop(this.getCheckedValues());
+    } else if (data === "\x7F") {
+      if (this.selectOptions?.searchable && this.filter.length > 0) {
+        this.filter = this.filter.slice(0, -1);
+        this.applyFilter();
+        this.renderAll();
+      }
+    } else if (data.startsWith("\x1B")) ; else if (this.selectOptions?.searchable && data.length === 1 && data >= " ") {
+      this.filter += data;
+      this.applyFilter();
+      this.renderAll();
+    }
+  }
+  onResize(cols, rows) {
+    this.maxVisible = Math.min(this.filteredOptions.length, rows - 4);
+    if (this.scrollOffset + this.maxVisible > this.getSelectableCount()) {
+      this.scrollOffset = Math.max(0, this.getSelectableCount() - this.maxVisible);
+    }
+    this.renderAll();
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  /**
+   * Build flattened display list with group headers inserted.
+   */
+  buildDisplayList() {
+    const items = [];
+    let lastGroup;
+    for (const opt of this.filteredOptions) {
+      if (opt.group && opt.group !== lastGroup) {
+        items.push({ type: "group-header", groupName: opt.group });
+        lastGroup = opt.group;
+      }
+      items.push({ type: "option", option: opt });
+    }
+    return items;
+  }
+  /**
+   * Get the total count of selectable items (non-disabled options).
+   */
+  getSelectableCount() {
+    return this.filteredOptions.filter((o) => !o.disabled).length;
+  }
+  /**
+   * Get an array of currently checked values (preserving original order).
+   */
+  getCheckedValues() {
+    const result = [];
+    for (const opt of this.options) {
+      if (this.checkedState.get(opt.value) === true) {
+        result.push(opt.value);
+      }
+    }
+    return result;
+  }
+  /**
+   * Move selection in the given direction (+1 or -1), skipping disabled options.
+   * Wraps around at boundaries.
+   */
+  moveSelection(direction) {
+    const selectableCount = this.getSelectableCount();
+    if (selectableCount === 0) return;
+    let next = this.selectedIndex + direction;
+    if (next < 0) next = selectableCount - 1;
+    if (next >= selectableCount) next = 0;
+    this.selectedIndex = next;
+    if (this.selectedIndex < this.scrollOffset) {
+      this.scrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.scrollOffset + this.maxVisible) {
+      this.scrollOffset = this.selectedIndex - this.maxVisible + 1;
+    }
+    this.renderAll();
+  }
+  /**
+   * Toggle the checked state of the currently selected option.
+   */
+  toggleCurrent() {
+    const selectables = this.filteredOptions.filter((o) => !o.disabled);
+    if (selectables.length === 0 || this.selectedIndex >= selectables.length) return;
+    const opt = selectables[this.selectedIndex];
+    const current = this.checkedState.get(opt.value) === true;
+    this.checkedState.set(opt.value, !current);
+    if (this.selectOptions?.onChange) {
+      this.selectOptions.onChange(this.getCheckedValues());
+    }
+    this.renderAll();
+  }
+  /**
+   * Toggle all non-disabled options: if all are checked, uncheck all; otherwise check all.
+   */
+  toggleAll() {
+    const nonDisabled = this.options.filter((o) => !o.disabled);
+    const allChecked = nonDisabled.every((o) => this.checkedState.get(o.value) === true);
+    for (const opt of nonDisabled) {
+      this.checkedState.set(opt.value, !allChecked);
+    }
+    if (this.selectOptions?.onChange) {
+      this.selectOptions.onChange(this.getCheckedValues());
+    }
+    this.renderAll();
+  }
+  /**
+   * Apply the current filter text to the options list.
+   */
+  applyFilter() {
+    if (this.filter.length === 0) {
+      this.filteredOptions = [...this.options];
+    } else {
+      const lower = this.filter.toLowerCase();
+      this.filteredOptions = this.options.filter(
+        (o) => o.label.toLowerCase().includes(lower)
+      );
+    }
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.maxVisible = Math.min(
+      this.filteredOptions.length,
+      this.host.getTerminalRows() - 4
+    );
+  }
+  /**
+   * Clear the filter and restore full option list.
+   */
+  clearFilter() {
+    this.filter = "";
+    this.applyFilter();
+    this.renderAll();
+  }
+  /**
+   * Clear all previously rendered lines and re-render everything.
+   */
+  renderAll() {
+    this.clearRenderedLines();
+    this.renderPrompt();
+    this.renderOptions();
+    this.renderHelpBar();
+    if (this.renderedLines > 0) {
+      this.host.terminal.write(`\x1B[${this.renderedLines}A`);
+    }
+  }
+  /**
+   * Clear all lines we previously rendered (below the cursor).
+   */
+  clearRenderedLines() {
+    if (this.renderedLines > 0) {
+      this.host.terminal.write("\x1B[s");
+      for (let i = 0; i < this.renderedLines; i++) {
+        this.host.terminal.write("\x1B[B\x1B[2K");
+      }
+      this.host.terminal.write("\x1B[u");
+      this.renderedLines = 0;
+    }
+  }
+  /**
+   * Render the prompt line.
+   */
+  renderPrompt() {
+    this.host.terminal.write("\x1B[2K\r");
+    if (this.selectOptions?.searchable) {
+      if (this.filter.length > 0) {
+        this.host.terminal.write(
+          `\x1B[36m?\x1B[0m ${this.promptText}: ${this.filter}`
+        );
+      } else {
+        this.host.terminal.write(
+          `\x1B[36m?\x1B[0m ${this.promptText}: \x1B[2mType to filter...\x1B[0m`
+        );
+      }
+    } else {
+      this.host.terminal.write(`\x1B[36m?\x1B[0m ${this.promptText}:`);
+    }
+  }
+  /**
+   * Render the visible slice of the option list.
+   */
+  renderOptions() {
+    const items = this.buildDisplayList();
+    const selectables = this.filteredOptions.filter((o) => !o.disabled);
+    const visibleStart = this.scrollOffset;
+    const visibleEnd = Math.min(
+      selectables.length,
+      this.scrollOffset + this.maxVisible
+    );
+    if (visibleStart > 0) {
+      this.host.terminal.write(`\r
+\x1B[2m  \u2191 ${visibleStart} more above\x1B[0m`);
+      this.renderedLines++;
+    }
+    let selectableIdx = 0;
+    for (const item of items) {
+      if (item.type === "group-header") {
+        if (this.isGroupVisible(item.groupName, items, visibleStart, visibleEnd)) {
+          this.host.terminal.write(
+            `\r
+\x1B[35m\u2500\u2500 ${item.groupName} \u2500\u2500\x1B[0m`
+          );
+          this.renderedLines++;
+        }
+      } else {
+        const opt = item.option;
+        if (opt.disabled) {
+          if (this.isDisabledOptionVisible(items, item, visibleStart, visibleEnd)) {
+            this.renderOptionLine(opt, false);
+            this.renderedLines++;
+          }
+        } else {
+          if (selectableIdx >= visibleStart && selectableIdx < visibleEnd) {
+            const isSelected = selectableIdx === this.selectedIndex;
+            this.renderOptionLine(opt, isSelected);
+            this.renderedLines++;
+          }
+          selectableIdx++;
+        }
+      }
+    }
+    const remaining = selectables.length - visibleEnd;
+    if (remaining > 0) {
+      this.host.terminal.write(`\r
+\x1B[2m  \u2193 ${remaining} more below\x1B[0m`);
+      this.renderedLines++;
+    }
+  }
+  /**
+   * Check if a group header should be visible given the current visible range.
+   */
+  isGroupVisible(groupName, items, visibleStart, visibleEnd) {
+    let selectableIdx = 0;
+    for (const item of items) {
+      if (item.type === "option" && !item.option.disabled) {
+        if (item.option.group === groupName && selectableIdx >= visibleStart && selectableIdx < visibleEnd) {
+          return true;
+        }
+        selectableIdx++;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a disabled option should be visible (adjacent to visible selectables).
+   */
+  isDisabledOptionVisible(items, disabledItem, visibleStart, visibleEnd) {
+    const idx = items.indexOf(disabledItem);
+    let selectableIdx = 0;
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].type === "option" && !items[i].option.disabled) {
+        if (i > idx) {
+          return selectableIdx >= visibleStart && selectableIdx < visibleEnd;
+        }
+        selectableIdx++;
+      }
+    }
+    return selectableIdx > 0 && selectableIdx - 1 >= visibleStart && selectableIdx - 1 < visibleEnd;
+  }
+  /**
+   * Render a single option line with checkbox indicator.
+   */
+  renderOptionLine(opt, isSelected) {
+    const isChecked = this.checkedState.get(opt.value) === true;
+    const label = this.highlightMatch(opt.label);
+    const desc = opt.description ? ` \x1B[2;3m\u2014 ${opt.description}\x1B[0m` : "";
+    const checkbox = isChecked ? "\x1B[32m\u25C9\x1B[0m" : "\x1B[2m\u25CB\x1B[0m";
+    if (opt.disabled) {
+      const disabledCheckbox = isChecked ? "\x1B[2m\u25C9\x1B[0m" : "\x1B[2m\u25CB\x1B[0m";
+      this.host.terminal.write(
+        `\r
+    ${disabledCheckbox} \x1B[2m${opt.label}${desc} (disabled)\x1B[0m`
+      );
+    } else if (isSelected) {
+      this.host.terminal.write(
+        `\r
+  \x1B[48;5;24m\x1B[38;5;117m\u276F ${checkbox} ${label}${desc}\x1B[0m`
+      );
+    } else {
+      this.host.terminal.write(
+        `\r
+    ${checkbox} ${label}${desc}`
+      );
+    }
+  }
+  /**
+   * Highlight the matched filter text in yellow within the label.
+   */
+  highlightMatch(label) {
+    if (!this.filter || this.filter.length === 0) return label;
+    const lower = label.toLowerCase();
+    const filterLower = this.filter.toLowerCase();
+    const idx = lower.indexOf(filterLower);
+    if (idx < 0) return label;
+    const before = label.substring(0, idx);
+    const match = label.substring(idx, idx + this.filter.length);
+    const after = label.substring(idx + this.filter.length);
+    return `${before}\x1B[33m${match}\x1B[0m${after}`;
+  }
+  /**
+   * Render the help bar at the bottom.
+   */
+  renderHelpBar() {
+    const checkedCount = this.getCheckedValues().length;
+    let help;
+    if (this.selectOptions?.searchable) {
+      if (this.filter.length > 0) {
+        const matchCount = this.filteredOptions.filter((o) => !o.disabled).length;
+        const totalCount = this.options.filter((o) => !o.disabled).length;
+        help = `${checkedCount} selected \xB7 ${matchCount} of ${totalCount} matches \xB7 space to toggle \xB7 enter to confirm`;
+      } else {
+        help = `${checkedCount} selected \xB7 space to toggle \xB7 a to select all \xB7 type to filter \xB7 enter to confirm`;
+      }
+    } else {
+      help = `${checkedCount} selected \xB7 space to toggle \xB7 a to select all \xB7 enter to confirm`;
+    }
+    this.host.terminal.write(`\r
+    \x1B[2m${help}\x1B[0m`);
+    this.renderedLines++;
+  }
+};
+
+// src/lib/input/modes/date-input-mode.ts
+var DateInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, options) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.options = options;
+    this.hasError = false;
+    this.format = options?.format ?? "YYYY-MM-DD";
+    this.separator = this.extractSeparator(this.format);
+    this.buffer = options?.default ?? "";
+    this.cursorPosition = this.buffer.length;
+  }
+  activate() {
+    const prompt = this.buildPrompt();
+    this.host.writeToTerminal(prompt);
+    if (this.buffer) {
+      this.host.writeToTerminal(this.buffer);
+    }
+  }
+  async handleInput(data) {
+    if (this.hasError) {
+      this.hasError = false;
+      this.clearExtraLines();
+    }
+    if (data === "\r") {
+      const error = this.validateBuffer();
+      if (error) {
+        this.hasError = true;
+        this.writeError(error);
+        return;
+      }
+      this.resolveAndPop(this.buffer);
+    } else if (data === "\x7F") {
+      if (this.cursorPosition > 0) {
+        this.buffer = this.buffer.slice(0, this.cursorPosition - 1) + this.buffer.slice(this.cursorPosition);
+        this.cursorPosition--;
+        this.renderLine();
+      }
+    } else if (data === "\x1B[D") {
+      if (this.cursorPosition > 0) {
+        this.cursorPosition--;
+        this.host.terminal.write(data);
+      }
+    } else if (data === "\x1B[C") {
+      if (this.cursorPosition < this.buffer.length) {
+        this.cursorPosition++;
+        this.host.terminal.write(data);
+      }
+    } else if (data.startsWith("\x1B")) ; else {
+      for (const ch of data) {
+        if (ch >= "0" && ch <= "9" || ch === this.separator) {
+          this.buffer = this.buffer.slice(0, this.cursorPosition) + ch + this.buffer.slice(this.cursorPosition);
+          this.cursorPosition++;
+        }
+      }
+      this.renderLine();
+    }
+  }
+  onResize() {
+    this.renderLine();
+  }
+  buildPrompt() {
+    return `\x1B[36m?\x1B[0m ${this.promptText} \x1B[2m(${this.format})\x1B[0m`;
+  }
+  renderLine() {
+    const prompt = this.buildPrompt();
+    this.redrawLine(prompt, this.buffer, this.cursorPosition);
+  }
+  /**
+   * Extract the separator character from a format string.
+   * Returns the first non-alphabetic character found (e.g., '-' from 'YYYY-MM-DD').
+   * Defaults to '-' if none is found.
+   */
+  extractSeparator(format) {
+    for (const ch of format) {
+      if (ch < "A" || ch > "z" || ch > "Z" && ch < "a") {
+        return ch;
+      }
+    }
+    return "-";
+  }
+  /**
+   * Parse the buffer according to the current format string.
+   * Returns { year, month, day } or null if parsing fails.
+   */
+  parseBuffer() {
+    const parts = this.buffer.split(this.separator);
+    const formatParts = this.format.split(this.separator);
+    if (parts.length !== formatParts.length) return null;
+    let year = 0, month = 0, day = 0;
+    for (let i = 0; i < formatParts.length; i++) {
+      const token = formatParts[i].toUpperCase();
+      const value = parseInt(parts[i], 10);
+      if (isNaN(value)) return null;
+      if (token === "YYYY") year = value;
+      else if (token === "MM") month = value;
+      else if (token === "DD") day = value;
+    }
+    return { year, month, day };
+  }
+  /**
+   * Validate the buffer as a real calendar date.
+   * Returns an error message string or null if valid.
+   */
+  validateBuffer() {
+    if (!this.buffer) {
+      return `Please enter a date in ${this.format} format`;
+    }
+    const parsed = this.parseBuffer();
+    if (!parsed) {
+      return `Invalid date format, expected ${this.format}`;
+    }
+    const { year, month, day } = parsed;
+    if (month < 1 || month > 12) {
+      return "Month must be between 1 and 12";
+    }
+    const maxDay = this.daysInMonth(year, month);
+    if (day < 1 || day > maxDay) {
+      return `Day must be between 1 and ${maxDay} for the given month`;
+    }
+    if (this.options?.min) {
+      const minDate = this.parseDate(this.options.min);
+      const current = new Date(year, month - 1, day);
+      if (minDate && current < minDate) {
+        return `Date must not be before ${this.options.min}`;
+      }
+    }
+    if (this.options?.max) {
+      const maxDate = this.parseDate(this.options.max);
+      const current = new Date(year, month - 1, day);
+      if (maxDate && current > maxDate) {
+        return `Date must not be after ${this.options.max}`;
+      }
+    }
+    return null;
+  }
+  /**
+   * Returns the number of days in a given month (accounting for leap years).
+   */
+  daysInMonth(year, month) {
+    return new Date(year, month, 0).getDate();
+  }
+  /**
+   * Parse a date string (in the same format as this mode) into a Date object.
+   */
+  parseDate(dateStr) {
+    const parts = dateStr.split(this.separator);
+    const formatParts = this.format.split(this.separator);
+    if (parts.length !== formatParts.length) return null;
+    let year = 0, month = 0, day = 0;
+    for (let i = 0; i < formatParts.length; i++) {
+      const token = formatParts[i].toUpperCase();
+      const value = parseInt(parts[i], 10);
+      if (isNaN(value)) return null;
+      if (token === "YYYY") year = value;
+      else if (token === "MM") month = value;
+      else if (token === "DD") day = value;
+    }
+    return new Date(year, month - 1, day);
+  }
+};
+
+// src/lib/input/modes/file-input-mode.ts
+var FileInputMode = class extends InputModeBase {
+  constructor(host, resolve, promptText, options) {
+    super(host, resolve);
+    this.promptText = promptText;
+    this.options = options;
+    this.waiting = false;
+  }
+  activate() {
+    const provider = this.host.filePickerProvider;
+    const acceptHint = this.options?.accept ? ` \x1B[2m(${this.options.accept})\x1B[0m` : "";
+    this.host.writeToTerminal(`\x1B[36m?\x1B[0m ${this.promptText}${acceptHint}: `);
+    if (!provider.isSupported) {
+      this.host.writeToTerminal("\x1B[2m(file picker not available)\x1B[0m");
+      this.abort();
+      return;
+    }
+    this.host.writeToTerminal("\x1B[33mOpening file picker...\x1B[0m");
+    this.waiting = true;
+    this.pickFiles(provider);
+  }
+  async pickFiles(provider) {
+    try {
+      let results;
+      if (this.options?.directory) {
+        const dir = await provider.pickDirectory();
+        results = dir ? [dir] : null;
+      } else {
+        results = await provider.pickFiles(this.options);
+      }
+      this.waiting = false;
+      if (!results || this.isResolved) {
+        this.host.terminal.write("\x1B[2K\r");
+        this.host.writeToTerminal(`\x1B[36m?\x1B[0m ${this.promptText}: \x1B[2m(cancelled)\x1B[0m\r
+`);
+        if (!this.isResolved) this.abort();
+        return;
+      }
+      this.host.terminal.write("\x1B[2K\r");
+      this.host.writeToTerminal(`\x1B[36m?\x1B[0m ${this.promptText}:\r
+`);
+      let totalSize = 0;
+      for (const file of results) {
+        const sizeStr = this.formatSize(file.size);
+        this.host.writeToTerminal(`  \x1B[32m\u2714\x1B[0m ${file.name} \x1B[2m(${sizeStr})\x1B[0m\r
+`);
+        totalSize += file.size;
+      }
+      if (results.length > 1) {
+        this.host.writeToTerminal(`    \x1B[2m${results.length} files selected \xB7 ${this.formatSize(totalSize)} total\x1B[0m\r
+`);
+      }
+      this.resolveAndPop(results);
+    } catch {
+      this.waiting = false;
+      if (this.isResolved) return;
+      this.host.terminal.write("\x1B[2K\r");
+      this.host.writeToTerminal(`\x1B[36m?\x1B[0m ${this.promptText}: \x1B[31m(error)\x1B[0m\r
+`);
+      this.abort();
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async handleInput(_data) {
+  }
+  formatSize(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+};
+
+// src/lib/services/cli-input-reader.ts
+var CliInputReader = class {
+  constructor(host) {
+    this.host = host;
+  }
+  readLine(prompt, options) {
+    return new Promise((resolve) => {
+      const mode = new LineInputMode(this.host, resolve, prompt, options);
+      this.host.pushMode(mode);
+    });
+  }
+  readPassword(prompt) {
+    return new Promise((resolve) => {
+      const mode = new PasswordInputMode(this.host, resolve, prompt);
+      this.host.pushMode(mode);
+    });
+  }
+  readConfirm(prompt, defaultValue = false) {
+    return new Promise((resolve) => {
+      const mode = new ConfirmInputMode(this.host, resolve, prompt, defaultValue);
+      this.host.pushMode(mode);
+    });
+  }
+  readSelect(prompt, options, selectOptions) {
+    if (!options || options.length === 0) {
+      return Promise.reject(new Error("readSelect requires at least one option"));
+    }
+    return new Promise((resolve) => {
+      const mode = new SelectInputMode(this.host, resolve, prompt, options, selectOptions);
+      this.host.pushMode(mode);
+    });
+  }
+  readSelectInline(prompt, options, selectOptions) {
+    if (!options || options.length === 0) {
+      return Promise.reject(new Error("readSelectInline requires at least one option"));
+    }
+    return new Promise((resolve) => {
+      const mode = new InlineSelectInputMode(this.host, resolve, prompt, options, selectOptions);
+      this.host.pushMode(mode);
+    });
+  }
+  readMultiSelect(prompt, options, selectOptions) {
+    if (!options || options.length === 0) {
+      return Promise.reject(new Error("readMultiSelect requires at least one option"));
+    }
+    return new Promise((resolve) => {
+      const mode = new MultiSelectInputMode(this.host, resolve, prompt, options, selectOptions);
+      this.host.pushMode(mode);
+    });
+  }
+  readNumber(prompt, options) {
+    return new Promise((resolve) => {
+      const mode = new NumberInputMode(this.host, resolve, prompt, options);
+      this.host.pushMode(mode);
+    });
+  }
+  readDate(prompt, options) {
+    return new Promise((resolve) => {
+      const mode = new DateInputMode(this.host, resolve, prompt, options);
+      this.host.pushMode(mode);
+    });
+  }
+  readFile(prompt, options) {
+    return new Promise((resolve) => {
+      const mode = new FileInputMode(this.host, resolve, prompt, options);
+      this.host.pushMode(mode);
+    });
+  }
+};
+
+// src/lib/services/file-picker/browser-file-picker-provider.ts
+var BrowserFilePickerProvider = class {
+  constructor() {
+    this.isSupported = typeof document !== "undefined";
+  }
+  async pickFiles(options) {
+    if (!this.isSupported) return null;
+    if (options?.directory) {
+      const dir = await this.pickDirectory();
+      return dir ? [dir] : null;
+    }
+    return new Promise((resolve) => {
+      const input = document.createElement("input");
+      input.type = "file";
+      input.style.display = "none";
+      if (options?.accept) input.accept = options.accept;
+      if (options?.multiple) input.multiple = true;
+      input.addEventListener("change", async () => {
+        const files = input.files;
+        if (!files || files.length === 0) {
+          resolve(null);
+          input.remove();
+          return;
+        }
+        const readAs = options?.readAs ?? "text";
+        const results = [];
+        for (let i = 0; i < files.length; i++) {
+          const file = files[i];
+          const content = await this.readFile(file, readAs);
+          results.push({
+            name: file.name,
+            content,
+            size: file.size,
+            type: file.type || "application/octet-stream"
+          });
+        }
+        resolve(results);
+        input.remove();
+      });
+      input.addEventListener("cancel", () => {
+        resolve(null);
+        input.remove();
       });
+      document.body.appendChild(input);
+      input.click();
     });
   }
-  readMultiSelect(prompt, options) {
-    if (!options || options.length === 0) {
-      return Promise.reject(
-        new Error("readMultiSelect requires at least one option")
-      );
-    }
+  async pickDirectory() {
+    if (!this.isSupported) return null;
     return new Promise((resolve) => {
-      if (this.host.activeInputRequest) {
-        throw new Error("Another input request is already active");
-      }
-      const checkedIndices = /* @__PURE__ */ new Set();
-      options.forEach((opt, i) => {
-        if (opt.checked) {
-          checkedIndices.add(i);
+      const input = document.createElement("input");
+      input.type = "file";
+      input.style.display = "none";
+      input.webkitdirectory = true;
+      input.addEventListener("change", () => {
+        const files = input.files;
+        if (!files || files.length === 0) {
+          resolve(null);
+        } else {
+          const pathParts = files[0].webkitRelativePath?.split("/") ?? [];
+          resolve({
+            name: pathParts[0] || "selected-directory",
+            content: "",
+            size: 0,
+            type: "inode/directory"
+          });
         }
+        input.remove();
       });
-      const termRows = this.host.getTerminalRows?.() ?? 24;
-      const maxVisible = Math.max(3, termRows - 2);
-      this.host.writeToTerminal(prompt + "\r\n");
-      const displayLines = this.renderMultiSelectOptions(options, 0, checkedIndices, 0, maxVisible);
-      this.host.setActiveInputRequest({
-        type: "multi-select",
-        promptText: prompt,
-        resolve,
-        buffer: "",
-        cursorPosition: 0,
-        options,
-        selectedIndex: 0,
-        checkedIndices,
-        scrollOffset: 0,
-        maxVisible,
-        displayLines
+      input.addEventListener("cancel", () => {
+        resolve(null);
+        input.remove();
       });
+      document.body.appendChild(input);
+      input.click();
     });
   }
-  readNumber(prompt, options) {
-    return new Promise((resolve) => {
-      if (this.host.activeInputRequest) {
-        throw new Error("Another input request is already active");
-      }
-      let displayPrompt = prompt;
-      const hints = [];
-      if (options?.min !== void 0 || options?.max !== void 0) {
-        const minStr = options?.min !== void 0 ? String(options.min) : "";
-        const maxStr = options?.max !== void 0 ? String(options.max) : "";
-        if (minStr && maxStr) {
-          hints.push(`${minStr}-${maxStr}`);
-        } else if (minStr) {
-          hints.push(`>=${minStr}`);
-        } else if (maxStr) {
-          hints.push(`<=${maxStr}`);
-        }
-      }
-      if (options?.default !== void 0) {
-        hints.push(`default: ${options.default}`);
-      }
-      if (hints.length > 0) {
-        displayPrompt += ` (${hints.join(", ")}): `;
+  readFile(file, readAs) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = () => reject(reader.error);
+      if (readAs === "arraybuffer") {
+        reader.readAsArrayBuffer(file);
       } else {
-        displayPrompt += ": ";
+        reader.readAsText(file);
       }
-      this.host.writeToTerminal(displayPrompt);
-      this.host.setActiveInputRequest({
-        type: "number",
-        promptText: displayPrompt,
-        resolve,
-        buffer: "",
-        cursorPosition: 0,
-        numberOptions: options
-      });
     });
   }
-  renderSelectOptions(options, selectedIndex, scrollOffset = 0, maxVisible = options.length) {
-    const needsScroll = options.length > maxVisible;
-    const itemSlots = needsScroll ? maxVisible - 2 : options.length;
-    const visibleCount = Math.max(1, Math.min(itemSlots, options.length));
-    const end = Math.min(scrollOffset + visibleCount, options.length);
-    let lines = 0;
-    if (needsScroll) {
-      const upLabel = scrollOffset > 0 ? "\u2191 more" : "";
-      this.host.writeToTerminal(`    \x1B[2m${upLabel}\x1B[0m\r
-`);
-      lines++;
-    }
-    for (let i = scrollOffset; i < end; i++) {
-      const prefix = i === selectedIndex ? "  \x1B[36m> " : "    ";
-      const suffix = i === selectedIndex ? "\x1B[0m" : "";
-      this.host.writeToTerminal(
-        `${prefix}${options[i].label}${suffix}\r
-`
-      );
-      lines++;
-    }
-    if (needsScroll) {
-      const downLabel = end < options.length ? "\u2193 more" : "";
-      this.host.writeToTerminal(`    \x1B[2m${downLabel}\x1B[0m\r
-`);
-      lines++;
-    }
-    return lines;
-  }
-  renderInlineSelectOptions(options, selectedIndex) {
-    return options.map((opt, i) => {
-      if (i === selectedIndex) {
-        return `\x1B[36m[ ${opt.label} ]\x1B[0m`;
-      }
-      return `  ${opt.label}  `;
-    }).join("");
-  }
-  renderMultiSelectOptions(options, selectedIndex, checkedIndices, scrollOffset = 0, maxVisible = options.length) {
-    const needsScroll = options.length > maxVisible;
-    const itemSlots = needsScroll ? maxVisible - 2 : options.length;
-    const visibleCount = Math.max(1, Math.min(itemSlots, options.length));
-    const end = Math.min(scrollOffset + visibleCount, options.length);
-    let lines = 0;
-    if (needsScroll) {
-      const upLabel = scrollOffset > 0 ? "\u2191 more" : "";
-      this.host.writeToTerminal(`    \x1B[2m${upLabel}\x1B[0m\r
-`);
-      lines++;
-    }
-    for (let i = scrollOffset; i < end; i++) {
-      const checkbox = checkedIndices.has(i) ? "[x]" : "[ ]";
-      const prefix = i === selectedIndex ? `  \x1B[36m> ${checkbox} ` : `    ${checkbox} `;
-      const suffix = i === selectedIndex ? "\x1B[0m" : "";
-      this.host.writeToTerminal(
-        `${prefix}${options[i].label}${suffix}\r
-`
-      );
-      lines++;
-    }
-    if (needsScroll) {
-      const downLabel = end < options.length ? "\u2193 more" : "";
-      this.host.writeToTerminal(`    \x1B[2m${downLabel}\x1B[0m\r
-`);
-      lines++;
-    }
-    return lines;
+};
+
+// src/lib/services/file-picker/noop-file-picker-provider.ts
+var NoopFilePickerProvider = class {
+  constructor() {
+    this.isSupported = false;
   }
-  createInputRequest(type, prompt) {
-    return new Promise((resolve) => {
-      if (this.host.activeInputRequest) {
-        throw new Error("Another input request is already active");
-      }
-      this.host.writeToTerminal(prompt);
-      this.host.setActiveInputRequest({
-        type,
-        promptText: prompt,
-        resolve,
-        buffer: "",
-        cursorPosition: 0
-      });
-    });
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async pickFiles(_options) {
+    return null;
+  }
+  async pickDirectory() {
+    return null;
   }
 };
 
@@ -11434,400 +13821,6 @@ var CommandLineMode = class {
   }
 };
 
-// src/lib/input/reader-mode.ts
-var ReaderMode = class {
-  constructor(host) {
-    this.host = host;
-  }
-  async handleInput(data) {
-    const request = this.host.getActiveInputRequest();
-    if (!request) {
-      return;
-    }
-    switch (request.type) {
-      case "line":
-        this.handleLineInput(request, data);
-        break;
-      case "password":
-        this.handlePasswordInput(request, data);
-        break;
-      case "confirm":
-        this.handleConfirmInput(request, data);
-        break;
-      case "select":
-        this.handleSelectInput(request, data);
-        break;
-      case "select-inline":
-        this.handleSelectInlineInput(request, data);
-        break;
-      case "multi-select":
-        this.handleMultiSelectInput(request, data);
-        break;
-      case "number":
-        this.handleNumberInput(request, data);
-        break;
-    }
-  }
-  handleKeyEvent(event) {
-    if (event.code === "KeyC" && event.ctrlKey) {
-      const request = this.host.getActiveInputRequest();
-      if (request) {
-        request.resolve(null);
-        this.host.setActiveInputRequest(null);
-        this.host.terminal.writeln("");
-        this.host.popMode();
-      }
-      return false;
-    }
-    if (event.code === "Escape") {
-      const request = this.host.getActiveInputRequest();
-      if (request) {
-        request.resolve(null);
-        this.host.setActiveInputRequest(null);
-        this.host.terminal.writeln("");
-        this.host.popMode();
-      }
-      return false;
-    }
-    return true;
-  }
-  handleLineInput(request, data) {
-    if (data === "\r") {
-      this.host.terminal.write("\r\n");
-      const value = request.buffer;
-      this.host.setActiveInputRequest(null);
-      this.host.popMode();
-      request.resolve(value);
-    } else if (data === "\x7F") {
-      if (request.cursorPosition > 0) {
-        request.buffer = request.buffer.slice(0, request.cursorPosition - 1) + request.buffer.slice(request.cursorPosition);
-        request.cursorPosition--;
-        this.redrawReaderLine(request, request.buffer);
-      }
-    } else if (data === "\x1B[D") {
-      if (request.cursorPosition > 0) {
-        request.cursorPosition--;
-        this.host.terminal.write(data);
-      }
-    } else if (data === "\x1B[C") {
-      if (request.cursorPosition < request.buffer.length) {
-        request.cursorPosition++;
-        this.host.terminal.write(data);
-      }
-    } else if (data.startsWith("\x1B")) ; else {
-      const text = data.replace(/[\r\n]+/g, "");
-      request.buffer = request.buffer.slice(0, request.cursorPosition) + text + request.buffer.slice(request.cursorPosition);
-      request.cursorPosition += text.length;
-      this.redrawReaderLine(request, request.buffer);
-    }
-  }
-  handlePasswordInput(request, data) {
-    if (data === "\r") {
-      this.host.terminal.write("\r\n");
-      const value = request.buffer;
-      this.host.setActiveInputRequest(null);
-      this.host.popMode();
-      request.resolve(value);
-    } else if (data === "\x7F") {
-      if (request.cursorPosition > 0) {
-        request.buffer = request.buffer.slice(0, request.cursorPosition - 1) + request.buffer.slice(request.cursorPosition);
-        request.cursorPosition--;
-        this.redrawReaderLine(
-          request,
-          "*".repeat(request.buffer.length)
-        );
-      }
-    } else if (data.startsWith("\x1B")) ; else {
-      const text = data.replace(/[\r\n]+/g, "");
-      request.buffer = request.buffer.slice(0, request.cursorPosition) + text + request.buffer.slice(request.cursorPosition);
-      request.cursorPosition += text.length;
-      this.redrawReaderLine(request, "*".repeat(request.buffer.length));
-    }
-  }
-  handleConfirmInput(request, data) {
-    if (data === "\r") {
-      this.host.terminal.write("\r\n");
-      this.host.setActiveInputRequest(null);
-      this.host.popMode();
-      const buf = request.buffer.toLowerCase();
-      if (buf === "y") {
-        request.resolve(true);
-      } else if (buf === "n") {
-        request.resolve(false);
-      } else {
-        request.resolve(request.defaultValue ?? false);
-      }
-    } else if (data === "\x7F") {
-      if (request.cursorPosition > 0) {
-        request.buffer = request.buffer.slice(0, -1);
-        request.cursorPosition--;
-        this.redrawReaderLine(request, request.buffer);
-      }
-    } else if (data.startsWith("\x1B")) ; else {
-      const char = data.toLowerCase();
-      if (char === "y" || char === "n") {
-        request.buffer = data;
-        request.cursorPosition = 1;
-        this.redrawReaderLine(request, request.buffer);
-      }
-    }
-  }
-  handleSelectInput(request, data) {
-    const options = request.options;
-    const selectedIndex = request.selectedIndex;
-    if (data === "\r") {
-      this.host.terminal.write("\r\n");
-      this.host.setActiveInputRequest(null);
-      this.host.popMode();
-      request.resolve(options[selectedIndex].value);
-    } else if (data === "\x1B[A") {
-      if (selectedIndex > 0) {
-        request.selectedIndex = selectedIndex - 1;
-        this.adjustScrollOffset(request);
-        this.redrawSelectOptions(request);
-        request.onChange?.(options[request.selectedIndex].value);
-      }
-    } else if (data === "\x1B[B") {
-      if (selectedIndex < options.length - 1) {
-        request.selectedIndex = selectedIndex + 1;
-        this.adjustScrollOffset(request);
-        this.redrawSelectOptions(request);
-        request.onChange?.(options[request.selectedIndex].value);
-      }
-    }
-  }
-  adjustScrollOffset(request) {
-    const options = request.options;
-    const maxVisible = request.maxVisible ?? options.length;
-    const needsScroll = options.length > maxVisible;
-    const itemSlots = needsScroll ? maxVisible - 2 : options.length;
-    const visibleCount = Math.max(1, Math.min(itemSlots, options.length));
-    const scrollOffset = request.scrollOffset ?? 0;
-    const selectedIndex = request.selectedIndex;
-    if (selectedIndex < scrollOffset) {
-      request.scrollOffset = selectedIndex;
-    } else if (selectedIndex >= scrollOffset + visibleCount) {
-      request.scrollOffset = selectedIndex - visibleCount + 1;
-    }
-  }
-  redrawReaderLine(request, displayText) {
-    this.host.terminal.write("\x1B[2K\r");
-    this.host.terminal.write(request.promptText + displayText);
-    const cursorOffset = request.buffer.length - request.cursorPosition;
-    if (cursorOffset > 0) {
-      this.host.terminal.write(`\x1B[${cursorOffset}D`);
-    }
-  }
-  redrawSelectOptions(request) {
-    const options = request.options;
-    const selectedIndex = request.selectedIndex;
-    const maxVisible = request.maxVisible ?? options.length;
-    const scrollOffset = request.scrollOffset ?? 0;
-    const displayLines = request.displayLines ?? options.length;
-    const needsScroll = options.length > maxVisible;
-    const itemSlots = needsScroll ? maxVisible - 2 : options.length;
-    const visibleCount = Math.max(1, Math.min(itemSlots, options.length));
-    const end = Math.min(scrollOffset + visibleCount, options.length);
-    if (displayLines > 0) {
-      this.host.terminal.write(`\x1B[${displayLines}A`);
-    }
-    if (needsScroll) {
-      this.host.terminal.write("\x1B[2K\r");
-      const upLabel = scrollOffset > 0 ? "\u2191 more" : "";
-      this.host.terminal.write(`    \x1B[2m${upLabel}\x1B[0m\r
-`);
-    }
-    for (let i = scrollOffset; i < end; i++) {
-      this.host.terminal.write("\x1B[2K\r");
-      const prefix = i === selectedIndex ? "  \x1B[36m> " : "    ";
-      const suffix = i === selectedIndex ? "\x1B[0m" : "";
-      this.host.terminal.write(
-        `${prefix}${options[i].label}${suffix}\r
-`
-      );
-    }
-    if (needsScroll) {
-      this.host.terminal.write("\x1B[2K\r");
-      const downLabel = end < options.length ? "\u2193 more" : "";
-      this.host.terminal.write(`    \x1B[2m${downLabel}\x1B[0m\r
-`);
-    }
-  }
-  handleSelectInlineInput(request, data) {
-    const options = request.options;
-    const selectedIndex = request.selectedIndex;
-    if (data === "\r") {
-      this.host.terminal.write("\r\n");
-      this.host.setActiveInputRequest(null);
-      this.host.popMode();
-      request.resolve(options[selectedIndex].value);
-    } else if (data === "\x1B[D") {
-      if (selectedIndex > 0) {
-        request.selectedIndex = selectedIndex - 1;
-        this.redrawInlineSelectOptions(request);
-        request.onChange?.(options[request.selectedIndex].value);
-      }
-    } else if (data === "\x1B[C") {
-      if (selectedIndex < options.length - 1) {
-        request.selectedIndex = selectedIndex + 1;
-        this.redrawInlineSelectOptions(request);
-        request.onChange?.(options[request.selectedIndex].value);
-      }
-    }
-  }
-  redrawInlineSelectOptions(request) {
-    const options = request.options;
-    const selectedIndex = request.selectedIndex;
-    this.host.terminal.write("\x1B[2K\r");
-    const inlineText = options.map((opt, i) => {
-      if (i === selectedIndex) {
-        return `\x1B[36m[ ${opt.label} ]\x1B[0m`;
-      }
-      return `  ${opt.label}  `;
-    }).join("");
-    this.host.terminal.write(`${request.promptText} ${inlineText}`);
-  }
-  handleMultiSelectInput(request, data) {
-    const options = request.options;
-    const selectedIndex = request.selectedIndex;
-    const checkedIndices = request.checkedIndices;
-    if (data === "\r") {
-      this.host.terminal.write("\r\n");
-      this.host.setActiveInputRequest(null);
-      this.host.popMode();
-      const selected = options.filter((_, i) => checkedIndices.has(i)).map((opt) => opt.value);
-      request.resolve(selected);
-    } else if (data === " ") {
-      if (checkedIndices.has(selectedIndex)) {
-        checkedIndices.delete(selectedIndex);
-      } else {
-        checkedIndices.add(selectedIndex);
-      }
-      this.redrawMultiSelectOptions(request);
-    } else if (data === "\x1B[A") {
-      if (selectedIndex > 0) {
-        request.selectedIndex = selectedIndex - 1;
-        this.adjustScrollOffset(request);
-        this.redrawMultiSelectOptions(request);
-      }
-    } else if (data === "\x1B[B") {
-      if (selectedIndex < options.length - 1) {
-        request.selectedIndex = selectedIndex + 1;
-        this.adjustScrollOffset(request);
-        this.redrawMultiSelectOptions(request);
-      }
-    }
-  }
-  redrawMultiSelectOptions(request) {
-    const options = request.options;
-    const selectedIndex = request.selectedIndex;
-    const checkedIndices = request.checkedIndices;
-    const maxVisible = request.maxVisible ?? options.length;
-    const scrollOffset = request.scrollOffset ?? 0;
-    const displayLines = request.displayLines ?? options.length;
-    const needsScroll = options.length > maxVisible;
-    const itemSlots = needsScroll ? maxVisible - 2 : options.length;
-    const visibleCount = Math.max(1, Math.min(itemSlots, options.length));
-    const end = Math.min(scrollOffset + visibleCount, options.length);
-    if (displayLines > 0) {
-      this.host.terminal.write(`\x1B[${displayLines}A`);
-    }
-    if (needsScroll) {
-      this.host.terminal.write("\x1B[2K\r");
-      const upLabel = scrollOffset > 0 ? "\u2191 more" : "";
-      this.host.terminal.write(`    \x1B[2m${upLabel}\x1B[0m\r
-`);
-    }
-    for (let i = scrollOffset; i < end; i++) {
-      this.host.terminal.write("\x1B[2K\r");
-      const checkbox = checkedIndices.has(i) ? "[x]" : "[ ]";
-      const prefix = i === selectedIndex ? `  \x1B[36m> ${checkbox} ` : `    ${checkbox} `;
-      const suffix = i === selectedIndex ? "\x1B[0m" : "";
-      this.host.terminal.write(
-        `${prefix}${options[i].label}${suffix}\r
-`
-      );
-    }
-    if (needsScroll) {
-      this.host.terminal.write("\x1B[2K\r");
-      const downLabel = end < options.length ? "\u2193 more" : "";
-      this.host.terminal.write(`    \x1B[2m${downLabel}\x1B[0m\r
-`);
-    }
-  }
-  handleNumberInput(request, data) {
-    if (data === "\r") {
-      const numOptions = request.numberOptions;
-      if (request.buffer === "") {
-        if (numOptions?.default !== void 0) {
-          this.host.terminal.write("\r\n");
-          this.host.setActiveInputRequest(null);
-          this.host.popMode();
-          request.resolve(numOptions.default);
-        } else {
-          this.host.terminal.write("\r\n");
-          this.host.terminal.write(
-            "\x1B[31mPlease enter a number.\x1B[0m\r\n"
-          );
-          this.host.terminal.write(request.promptText);
-        }
-        return;
-      }
-      const value = Number(request.buffer);
-      if (isNaN(value)) {
-        this.host.terminal.write("\r\n");
-        this.host.terminal.write("\x1B[31mInvalid number.\x1B[0m\r\n");
-        request.buffer = "";
-        request.cursorPosition = 0;
-        this.host.terminal.write(request.promptText);
-        return;
-      }
-      if (numOptions?.min !== void 0 && value < numOptions.min) {
-        this.host.terminal.write("\r\n");
-        this.host.terminal.write(
-          `\x1B[31mValue must be at least ${numOptions.min}.\x1B[0m\r
-`
-        );
-        request.buffer = "";
-        request.cursorPosition = 0;
-        this.host.terminal.write(request.promptText);
-        return;
-      }
-      if (numOptions?.max !== void 0 && value > numOptions.max) {
-        this.host.terminal.write("\r\n");
-        this.host.terminal.write(
-          `\x1B[31mValue must be at most ${numOptions.max}.\x1B[0m\r
-`
-        );
-        request.buffer = "";
-        request.cursorPosition = 0;
-        this.host.terminal.write(request.promptText);
-        return;
-      }
-      this.host.terminal.write("\r\n");
-      this.host.setActiveInputRequest(null);
-      this.host.popMode();
-      request.resolve(value);
-    } else if (data === "\x7F") {
-      if (request.cursorPosition > 0) {
-        request.buffer = request.buffer.slice(0, request.cursorPosition - 1) + request.buffer.slice(request.cursorPosition);
-        request.cursorPosition--;
-        this.redrawReaderLine(request, request.buffer);
-      }
-    } else if (data === "-") {
-      if (request.cursorPosition === 0 && !request.buffer.includes("-")) {
-        request.buffer = "-" + request.buffer;
-        request.cursorPosition = 1;
-        this.redrawReaderLine(request, request.buffer);
-      }
-    } else if (/^\d$/.test(data)) {
-      request.buffer = request.buffer.slice(0, request.cursorPosition) + data + request.buffer.slice(request.cursorPosition);
-      request.cursorPosition += 1;
-      this.redrawReaderLine(request, request.buffer);
-    }
-  }
-};
-
 // src/lib/input/raw-mode.ts
 var RawMode = class {
   constructor(processor, context2, fullScreen = false) {
@@ -11920,7 +13913,6 @@ var CliExecutionContext = class {
     this.completionEngine = new CliCompletionEngine();
     this.promptLength = 0;
     this.lineBuffer = new CliLineBuffer();
-    this._activeInputRequest = null;
     this.modeStack = [];
     this.managedTimers = /* @__PURE__ */ new Set();
     this.resizeDisposable = null;
@@ -11959,6 +13951,7 @@ var CliExecutionContext = class {
     this.textAnimator = textAnimator;
     this.clipboard = new CliClipboard(this);
     this.process = new CliExecutionProcess(this);
+    this.filePickerProvider = typeof document !== "undefined" ? new BrowserFilePickerProvider() : new NoopFilePickerProvider();
     this.reader = new CliInputReader(this);
     this.logger = deps.logger;
     this.logger.setCliLogLevel(cliOptions?.logLevel || cliCore.CliLogLevel.ERROR);
@@ -11971,26 +13964,15 @@ var CliExecutionContext = class {
     );
   }
   // -- Public API (ICliExecutionContext) --
-  get activeInputRequest() {
-    return this._activeInputRequest;
-  }
-  /**
-   * Sets the active input request. When a non-null request is provided,
-   * pushes ReaderMode onto the mode stack. ReaderMode pops itself on
-   * completion, so passing null here does NOT pop the mode.
-   */
-  setActiveInputRequest(request) {
-    this._activeInputRequest = request;
-    if (request !== null) {
-      this.pushMode(new ReaderMode(this));
-    }
-  }
   writeToTerminal(text) {
     this.terminal.write(text);
   }
   getTerminalRows() {
     return this.terminal.rows;
   }
+  getTerminalCols() {
+    return this.terminal.cols;
+  }
   get currentLine() {
     return this.lineBuffer.text;
   }
@@ -12095,7 +14077,12 @@ var CliExecutionContext = class {
       );
       return;
     }
-    if (this.isProgressRunning() || this.isRawModeActive() || this._activeInputRequest) {
+    if (this.isProgressRunning() || this.isRawModeActive()) {
+      return;
+    }
+    const mode = this.currentMode;
+    if (mode?.onResize) {
+      mode.onResize(this.terminal.cols, this.terminal.rows);
       return;
     }
     const buf = this.terminal.buffer.active;
@@ -12209,10 +14196,6 @@ var CliExecutionContext = class {
   getExecutionContext() {
     return this;
   }
-  // -- ReaderModeHost interface --
-  getActiveInputRequest() {
-    return this._activeInputRequest;
-  }
   // -- Managed timer cleanup --
   clearAllManagedTimers() {
     for (const timer of this.managedTimers) {
@@ -12655,6 +14638,7 @@ var CliCommandExecutor = class {
       const aliasProcessor = this.registry.findProcessor("alias", []);
       const aliases = aliasProcessor?.userAliases ?? {};
       if (aliases[mainCommand]) {
+        this.completeProcess(processEntry, context2, 0);
         return await this.executeSingleCommand(
           aliases[mainCommand],
           data,
@@ -12667,6 +14651,7 @@ var CliCommandExecutor = class {
           context2
         );
         if (executed) {
+          this.completeProcess(processEntry, context2, 0);
           process.end();
           return;
         }
@@ -12681,6 +14666,7 @@ var CliCommandExecutor = class {
       context2.writer.writeInfo(
         `\u{1F4E6} Use ${context2.writer.wrapInColor("pkg add <name>", cliCore.CliForegroundColor.Cyan)} to install additional commands`
       );
+      this.failProcess(processEntry, context2);
       context2.process.exit(-1, {
         silent: true
       });
@@ -12699,6 +14685,7 @@ var CliCommandExecutor = class {
         continue;
       }
       if (await handler.handle(args, processor, commandToProcess, context2)) {
+        this.completeProcess(processEntry, context2, 0);
         process.end();
         return;
       }
@@ -12767,26 +14754,18 @@ var CliCommandExecutor = class {
       if (!process.outputCalled && capturingWriter.hasOutput()) {
         process.data = capturingWriter.getCapturedData();
       }
-      if (processEntry) {
-        try {
-          const procRegistry = context2.services.get(CliProcessRegistry_TOKEN);
-          procRegistry.complete(processEntry.pid, context2.process.exitCode ?? 0);
-        } catch {
-        }
-      }
+      this.completeProcess(processEntry, context2, context2.process.exitCode ?? 0);
       if (!process.exited) {
         process.end();
       }
     } catch (e) {
       context2.spinner?.hide();
-      if (processEntry) {
-        try {
-          const procRegistry = context2.services.get(CliProcessRegistry_TOKEN);
-          procRegistry.fail(processEntry.pid);
-        } catch {
-        }
-      }
       if (e instanceof ProcessExitedError) {
+        if (e.code === 0) {
+          this.completeProcess(processEntry, context2, 0);
+        } else {
+          this.failProcess(processEntry, context2);
+        }
         cancellable?.cancel();
         context2.abort?.();
         if (e.code !== 0) {
@@ -12799,6 +14778,7 @@ var CliCommandExecutor = class {
           );
         }
       } else {
+        this.failProcess(processEntry, context2);
         context2.writer.writeError(`Error executing command: ${e}`);
         context2.process.exit(-1);
       }
@@ -12806,6 +14786,22 @@ var CliCommandExecutor = class {
       abortSub.unsubscribe();
     }
   }
+  completeProcess(processEntry, context2, exitCode) {
+    if (!processEntry) return;
+    try {
+      const procRegistry = context2.services.get(CliProcessRegistry_TOKEN);
+      procRegistry.complete(processEntry.pid, exitCode);
+    } catch {
+    }
+  }
+  failProcess(processEntry, context2) {
+    if (!processEntry) return;
+    try {
+      const procRegistry = context2.services.get(CliProcessRegistry_TOKEN);
+      procRegistry.fail(processEntry.pid);
+    } catch {
+    }
+  }
   async writeStderrToFile(filePath, context2) {
     const stderr = this.lastCapturingWriter?.getCapturedStderr();
     if (!stderr) return;
@@ -13886,6 +15882,167 @@ var CliStateStoreManager = class {
   }
 };
 
+// src/lib/editor/syntax/registry.ts
+var SyntaxHighlighterRegistry = class {
+  constructor() {
+    this.highlighters = /* @__PURE__ */ new Map();
+    this.extensionMap = /* @__PURE__ */ new Map();
+  }
+  register(highlighter) {
+    this.highlighters.set(highlighter.id, highlighter);
+    for (const ext of highlighter.extensions) {
+      this.extensionMap.set(ext, highlighter.id);
+    }
+  }
+  unregister(id) {
+    const h = this.highlighters.get(id);
+    if (h) {
+      for (const ext of h.extensions) {
+        this.extensionMap.delete(ext);
+      }
+      this.highlighters.delete(id);
+    }
+  }
+  getByExtension(ext) {
+    const id = this.extensionMap.get(ext);
+    return id ? this.highlighters.get(id) ?? null : null;
+  }
+  getRegisteredLanguages() {
+    return Array.from(this.highlighters.keys());
+  }
+};
+
+// src/lib/editor/syntax/highlighters/json-highlighter.ts
+var JsonHighlighter = class {
+  constructor() {
+    this.id = "json";
+    this.extensions = [".json", ".jsonc"];
+    this.initialState = 0;
+  }
+  getRules(state) {
+    if (state === 1) {
+      return [
+        { pattern: /.*?\*\//, tokenType: "comment" },
+        { pattern: /.*/, tokenType: "comment" }
+      ];
+    }
+    return [
+      { pattern: /\/\/.*$/, tokenType: "comment" },
+      { pattern: /\/\*.*?\*\//, tokenType: "comment" },
+      { pattern: /\/\*.*$/, tokenType: "comment" },
+      { pattern: /"(?:[^"\\]|\\.)*"/, tokenType: "string" },
+      { pattern: /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/, tokenType: "number" },
+      { pattern: /\b(?:true|false|null)\b/, tokenType: "keyword" },
+      { pattern: /[{}\[\]:,]/, tokenType: "punctuation" }
+    ];
+  }
+  getNextLineState(line, currentState) {
+    if (currentState === 1) {
+      return line.includes("*/") ? 0 : 1;
+    }
+    const stripped = line.replace(/"(?:[^"\\]|\\.)*"/g, "").replace(/\/\/.*$/, "");
+    const openIdx = stripped.lastIndexOf("/*");
+    if (openIdx === -1) return 0;
+    const closeIdx = stripped.indexOf("*/", openIdx);
+    return closeIdx === -1 ? 1 : 0;
+  }
+};
+
+// src/lib/editor/syntax/highlighters/html-highlighter.ts
+var HtmlHighlighter = class {
+  constructor() {
+    this.id = "html";
+    this.extensions = [".html", ".htm", ".xml", ".svg"];
+    this.initialState = 0;
+  }
+  getRules(state) {
+    if (state === 1) {
+      return [
+        { pattern: /.*?-->/, tokenType: "comment" },
+        { pattern: /.*/, tokenType: "comment" }
+      ];
+    }
+    return [
+      { pattern: /<!--.*?-->/, tokenType: "comment" },
+      { pattern: /<!--.*$/, tokenType: "comment" },
+      { pattern: /(<\/?)([\w-]+)/, tokenType: "tag", captureGroup: 2 },
+      { pattern: /"[^"]*"/, tokenType: "value" },
+      { pattern: /'[^']*'/, tokenType: "value" },
+      { pattern: /([\w-]+)(\s*=)/, tokenType: "attribute", captureGroup: 1 },
+      { pattern: /\/?>/, tokenType: "punctuation" },
+      { pattern: /<\/?/, tokenType: "punctuation" },
+      { pattern: /=/, tokenType: "punctuation" }
+    ];
+  }
+  getNextLineState(line, currentState) {
+    if (currentState === 1) {
+      return line.includes("-->") ? 0 : 1;
+    }
+    const openIdx = line.lastIndexOf("<!--");
+    if (openIdx === -1) return 0;
+    const closeIdx = line.indexOf("-->", openIdx);
+    return closeIdx === -1 ? 1 : 0;
+  }
+};
+
+// src/lib/editor/syntax/highlighters/markdown-highlighter.ts
+var MarkdownHighlighter = class {
+  constructor() {
+    this.id = "markdown";
+    this.extensions = [".md", ".mdx", ".markdown"];
+    this.initialState = 0;
+  }
+  getRules(state) {
+    if (state === 1) {
+      return [
+        { pattern: /^```/, tokenType: "string" },
+        { pattern: /.*/, tokenType: "code" }
+      ];
+    }
+    return [
+      { pattern: /^#{1,6}\s+.*$/, tokenType: "heading" },
+      { pattern: /^```/, tokenType: "string" },
+      { pattern: /`[^`]+`/, tokenType: "code" },
+      { pattern: /\[[^\]]+\]\([^)]+\)/, tokenType: "link" },
+      { pattern: /\*\*[^*]+\*\*/, tokenType: "bold" },
+      { pattern: /__[^_]+__/, tokenType: "bold" },
+      { pattern: /\*[^*]+\*/, tokenType: "italic" },
+      { pattern: /_[^_]+_/, tokenType: "italic" },
+      { pattern: /^[-*>]\s/, tokenType: "punctuation" }
+    ];
+  }
+  getNextLineState(line, currentState) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("```")) {
+      return currentState === 0 ? 1 : 0;
+    }
+    return currentState;
+  }
+};
+
+// src/lib/editor/syntax/highlighters/yaml-highlighter.ts
+var YamlHighlighter = class {
+  constructor() {
+    this.id = "yaml";
+    this.extensions = [".yaml", ".yml"];
+    this.initialState = 0;
+  }
+  getRules() {
+    return [
+      { pattern: /#.*$/, tokenType: "comment" },
+      { pattern: /"(?:[^"\\]|\\.)*"/, tokenType: "string" },
+      { pattern: /'[^']*'/, tokenType: "string" },
+      { pattern: /\b(?:true|false|null|~)\b/, tokenType: "keyword" },
+      { pattern: /-?\d+(?:\.\d+)?/, tokenType: "number" },
+      { pattern: /([\w][\w.\-]*)(\s*:)/, tokenType: "tag", captureGroup: 1 },
+      { pattern: /[-:\[\]{}]/, tokenType: "punctuation" }
+    ];
+  }
+  getNextLineState() {
+    return 0;
+  }
+};
+
 // src/lib/services/cli-translation-service.ts
 var CliTranslationService = class {
   constructor() {
@@ -14864,6 +17021,12 @@ var CliEngine = class {
         }
       ]);
     }
+    const syntaxRegistry = new SyntaxHighlighterRegistry();
+    syntaxRegistry.register(new JsonHighlighter());
+    syntaxRegistry.register(new HtmlHighlighter());
+    syntaxRegistry.register(new MarkdownHighlighter());
+    syntaxRegistry.register(new YamlHighlighter());
+    services.set([{ provide: "syntax-highlighter-registry", useValue: syntaxRegistry }]);
     if (!pendingTokens.has(ICliEnvironment_TOKEN)) {
       services.set([
         {
@@ -14896,6 +17059,7 @@ var CliEngine = class {
       { ...this.options ?? {}, terminalOptions }
     );
     this.executionContext.initializeTerminalListeners();
+    this.executionContext.backgroundServices.setProcessRegistry(processRegistry);
     services.set([{
       provide: CliBackgroundServiceRegistry_TOKEN,
       useValue: this.executionContext.backgroundServices
@@ -15452,7 +17616,9 @@ function createQueuedReader(queue) {
     readSelect: async () => next() ?? "",
     readSelectInline: async () => next() ?? "",
     readMultiSelect: async () => next() ?? [],
-    readNumber: async () => next() ?? 0
+    readNumber: async () => next() ?? 0,
+    readDate: async () => next() ?? null,
+    readFile: async () => next() ?? null
   };
 }
 function createNoopBackgroundServices() {
@@ -15528,6 +17694,7 @@ exports.CliFontSizeCommandProcessor = CliFontSizeCommandProcessor;
 exports.CliHelpCommandProcessor = CliHelpCommandProcessor;
 exports.CliHistoryCommandProcessor = CliHistoryCommandProcessor;
 exports.CliHotKeysCommandProcessor = CliHotKeysCommandProcessor;
+exports.CliHtopCommandProcessor = CliHtopCommandProcessor;
 exports.CliInputReader = CliInputReader;
 exports.CliJsonCommandProcessor = CliJsonCommandProcessor;
 exports.CliKeyValueStore = CliKeyValueStore;