nervous-cli 1.0.0

package/dist/app.js

@@ -0,0 +1,2547 @@
+#!/usr/bin/env node
+
+// src/app.tsx
+import { FullScreenBox as FullScreenBox2, useScreenSize, withFullScreen } from "fullscreen-ink";
+import { Box as Box9, Text as Text8, useInput as useInput2 } from "ink";
+import { useEffect as useEffect4, useMemo as useMemo2, useRef as useRef3, useState as useState2 } from "react";
+
+// src/command/command_list.ts
+var COMMANDS = [
+  { name: "/model", description: "choose a model" },
+  { name: "/key", description: "change a model API key" },
+  { name: "/session", description: "continue a saved session" },
+  { name: "/exit", description: "save and quit" },
+  { name: "/restart", description: "restart UI and connection" }
+];
+function filterCommands(input) {
+  if (!input.startsWith("/")) return [];
+  return COMMANDS.filter((entry) => entry.name.startsWith(input));
+}
+function isCommand(input, name) {
+  return input.trim() === name;
+}
+function isSlashCommand(input) {
+  return input.trim().startsWith("/");
+}
+
+// src/save/config_writer.ts
+import { readFile, writeFile } from "fs/promises";
+
+// src/session/user_data.ts
+var user_data = null;
+function setUserData(data) {
+  user_data = data;
+}
+function commitSession() {
+  if (user_data) user_data.session_committed = true;
+}
+
+// src/save/config_path.ts
+import { join } from "path";
+
+// src/systemconfig/file.ts
+var CONFIG_FILE_PATH_DIR = "user_config/";
+var CONFIG_FILE_NAME = "config.json";
+var DEFAULT_CONFIG = {
+  api_key: {},
+  main_agent_id: 1,
+  session: {}
+};
+
+// src/save/config_path.ts
+function configFilePath() {
+  return join(process.cwd(), CONFIG_FILE_PATH_DIR, CONFIG_FILE_NAME);
+}
+function configDirPath() {
+  return join(process.cwd(), CONFIG_FILE_PATH_DIR);
+}
+
+// src/save/config_writer.ts
+var WRITE_DEBOUNCE_MS = 50;
+var write_queue = Promise.resolve();
+var debounce_timer = null;
+var pending_resolvers = [];
+function flushDebouncedWrite() {
+  if (debounce_timer) {
+    clearTimeout(debounce_timer);
+    debounce_timer = null;
+  }
+  const resolvers = pending_resolvers;
+  pending_resolvers = [];
+  if (resolvers.length === 0) {
+    return write_queue;
+  }
+  write_queue = write_queue.catch(() => {
+  }).then(() => writeUserDataToFile()).catch(() => {
+  }).finally(() => {
+    for (const resolve3 of resolvers) resolve3();
+  });
+  return write_queue;
+}
+function enqueueWrite() {
+  return new Promise((resolve3) => {
+    pending_resolvers.push(resolve3);
+    if (debounce_timer) clearTimeout(debounce_timer);
+    debounce_timer = setTimeout(() => {
+      debounce_timer = null;
+      void flushDebouncedWrite();
+    }, WRITE_DEBOUNCE_MS);
+  });
+}
+async function waitForWrites() {
+  if (debounce_timer || pending_resolvers.length > 0) {
+    await flushDebouncedWrite();
+  }
+  await write_queue;
+}
+function saveAPIKeyForModel(model_id, api_key) {
+  if (!user_data) return;
+  user_data.api_keys[model_id] = api_key;
+  void enqueueWrite();
+}
+function saveMainAgentId(model_id) {
+  if (!user_data) return;
+  user_data.main_agent_id = model_id;
+  void enqueueWrite();
+}
+function saveTaskUpdate(data) {
+  if (!user_data) return;
+  user_data.categories = [...data.categories];
+  void enqueueWrite();
+}
+function saveDisplayHistory(entry) {
+  if (!user_data) return;
+  user_data.history.push(entry);
+  void enqueueWrite();
+}
+async function writeUserDataToFile() {
+  if (!user_data) return;
+  const file_path = configFilePath();
+  let config;
+  try {
+    const raw = await readFile(file_path, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  config.api_key = { ...user_data.api_keys };
+  config.main_agent_id = user_data.main_agent_id;
+  if (user_data.session_committed) {
+    config.session[user_data.session_id] = {
+      categories: user_data.categories,
+      history: user_data.history,
+      last_updated: Date.now()
+    };
+  }
+  await writeFile(file_path, JSON.stringify(config, null, "	"));
+}
+
+// src/socket/client.ts
+import { io } from "socket.io-client";
+var BACKEND_URL = process.env.NERVE_BACKEND_URL ?? "https://nerve-boq5.onrender.com";
+var socket = io(BACKEND_URL, {
+  autoConnect: false,
+  auth: (cb) => cb(
+    user_data ? {
+      client_kind: "cli",
+      api_keys: user_data.api_keys,
+      main_agent_id: user_data.main_agent_id,
+      categories: user_data.categories,
+      history: user_data.history,
+      api_key: user_data.api_keys[user_data.main_agent_id] ?? ""
+    } : {}
+  )
+});
+function connectSocket() {
+  socket.connect();
+}
+
+// src/command/exit_command.ts
+function isExitCommand(input) {
+  return isCommand(input, "/exit");
+}
+async function exitApp() {
+  try {
+    await writeUserDataToFile();
+  } catch {
+  }
+  socket.disconnect();
+  process.exit(0);
+}
+
+// src/command/key_command.ts
+function isKeyCommand(input) {
+  return isCommand(input, "/key");
+}
+async function applyApiKeyChange(model_id, api_key) {
+  if (!user_data) return;
+  saveAPIKeyForModel(model_id, api_key);
+  if (model_id === user_data.main_agent_id) {
+    socket.disconnect();
+    socket.connect();
+  }
+  await waitForWrites();
+}
+
+// src/systemconfig/model.ts
+var WATSONX_MODEL_ID = 1;
+var MODEL_OPTIONS = [
+  { id: WATSONX_MODEL_ID, label: "IBM Granite (watsonx.ai)" },
+  { id: 2, label: "Groq GPT-OSS 120B" },
+  { id: 3, label: "Claude Fable 5" },
+  { id: 4, label: "Kimi K2.6" },
+  { id: 5, label: "DeepSeek Chat" },
+  { id: 7, label: "OpenRouter Auto" }
+];
+function isFundedModel(model_id) {
+  return model_id === WATSONX_MODEL_ID;
+}
+
+// src/command/model_command.ts
+function isModelCommand(input) {
+  return isCommand(input, "/model");
+}
+function getModelLabel(model_id) {
+  return MODEL_OPTIONS.find((m) => m.id === model_id)?.label ?? `Unknown model (${model_id})`;
+}
+function hasApiKeyForModel(model_id) {
+  if (!user_data) return false;
+  return Boolean(user_data.api_keys[model_id]);
+}
+function applyModelChoice(model_id, api_key) {
+  saveMainAgentId(model_id);
+  saveAPIKeyForModel(model_id, api_key);
+  socket.disconnect();
+  socket.connect();
+}
+async function persistModelChoice(model_id, api_key) {
+  applyModelChoice(model_id, api_key);
+  await waitForWrites();
+}
+
+// src/command/model_options.ts
+function buildModelSelectOptions() {
+  const current_id = user_data?.main_agent_id;
+  const ordered = [
+    ...MODEL_OPTIONS.filter((m) => m.id === current_id),
+    ...MODEL_OPTIONS.filter((m) => m.id !== current_id)
+  ];
+  return ordered.map((m) => ({
+    modelId: m.id,
+    label: m.id === current_id ? `${m.label} (current)` : m.label,
+    value: String(m.id)
+  }));
+}
+
+// src/command/questionnaire_box.tsx
+import { Select } from "@inkjs/ui";
+import { Box, Text } from "ink";
+
+// src/ui/display_entry.ts
+var QUESTION_PREFIX = "Q: ";
+function isQuestionnaireEntry(role, content) {
+  return role === "system" && content.startsWith(QUESTION_PREFIX);
+}
+
+// src/ui/theme.ts
+var BG_BLACK = "black";
+var BG_PANEL = "#111111";
+var BG_USER = "white";
+var ROLE_COLOR = {
+  user: "black",
+  assistant: "white",
+  system: "yellow",
+  error: "red"
+};
+function roleColor(role) {
+  return ROLE_COLOR[role] ?? ROLE_COLOR.assistant;
+}
+function entryPanelBg(role, content) {
+  if (role === "user") {
+    return BG_USER;
+  }
+  if (isQuestionnaireEntry(role, content)) {
+    return BG_PANEL;
+  }
+  return void 0;
+}
+
+// src/command/questionnaire_box.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var OTHER_OPTION_VALUE = "__other__";
+var OTHER_OPTION_LABEL = "other";
+var OTHER_LIKE_PATTERN = /^(other|others|other option|none of the above|none of these|something else|custom|my own answer)$/i;
+function isOtherLikeOption(value) {
+  return OTHER_LIKE_PATTERN.test(value.trim());
+}
+function buildQuestionOptions(raw_options) {
+  const cleaned = raw_options.map((opt) => opt.trim()).filter((opt) => opt.length > 0 && !isOtherLikeOption(opt));
+  return [
+    ...cleaned.map((label) => ({ label, value: label })),
+    { label: OTHER_OPTION_LABEL, value: OTHER_OPTION_VALUE }
+  ];
+}
+function QuestionnaireBox({
+  question,
+  current,
+  total,
+  onSelect,
+  freeText,
+  onOther
+}) {
+  const options = buildQuestionOptions(question.options);
+  const handleChange = (value) => {
+    if (value === OTHER_OPTION_VALUE || isOtherLikeOption(value)) {
+      onOther();
+      return;
+    }
+    onSelect(value);
+  };
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      width: "100%",
+      flexDirection: "column",
+      display: "flex",
+      backgroundColor: BG_PANEL,
+      paddingX: 1,
+      paddingY: 1,
+      flexShrink: 0,
+      children: [
+        /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+          "Question ",
+          current + 1,
+          "/",
+          total,
+          ": ",
+          question.question
+        ] }),
+        !freeText && /* @__PURE__ */ jsx(Select, { options, visibleOptionCount: options.length, onChange: handleChange })
+      ]
+    }
+  );
+}
+
+// src/command/restart_command.ts
+function isRestartCommand(input) {
+  return isCommand(input, "/restart");
+}
+async function restartConnection() {
+  try {
+    await writeUserDataToFile();
+    await waitForWrites();
+  } catch {
+  }
+  socket.disconnect();
+  socket.connect();
+}
+
+// src/command/session_command.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/dto/migrate_session.ts
+function migrateSessionCategories(data) {
+  if (!data) return [];
+  const raw = data;
+  if (Array.isArray(raw.categories)) return raw.categories;
+  const descriptions = [];
+  for (const item of [...raw.running_task ?? [], ...raw.pending_task ?? []]) {
+    const description = (item?.description ?? "").trim();
+    if (description) descriptions.push(description);
+  }
+  if (descriptions.length === 0) return [];
+  return [
+    {
+      name: "tasks",
+      status: "pending",
+      depends_on: [],
+      tasks: descriptions.map((description) => ({
+        description,
+        status: "pending",
+        result: ""
+      }))
+    }
+  ];
+}
+
+// src/save/config_reader.ts
+import { randomUUID } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+async function readConfig() {
+  const raw = await readFile2(configFilePath(), "utf-8");
+  const config = JSON.parse(raw);
+  const valid_model = MODEL_OPTIONS.some((m) => m.id === config.main_agent_id);
+  const main_agent_id = valid_model ? config.main_agent_id : 1;
+  return {
+    api_keys: { ...config.api_key },
+    main_agent_id,
+    session_id: randomUUID(),
+    session_committed: false,
+    categories: [],
+    history: []
+  };
+}
+async function readSessionData() {
+  try {
+    const raw = await readFile2(configFilePath(), "utf-8");
+    const config = JSON.parse(raw);
+    return config.session ?? {};
+  } catch {
+    return {};
+  }
+}
+
+// src/command/session_command.ts
+var NEW_SESSION_VALUE = "__new_session__";
+function isSessionCommand(input) {
+  return isCommand(input, "/session");
+}
+function buildHistoryPreview(history) {
+  const first = history.find((entry) => entry.role === "user") ?? history[0];
+  if (!first) return "";
+  const text = first.content.replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  const clipped = text.length > 40 ? `${text.slice(0, 40)}...` : text;
+  return ` \u2014 "${clipped}"`;
+}
+async function loadSessionOptions() {
+  const sessions = await readSessionData();
+  const options = [
+    {
+      value: NEW_SESSION_VALUE,
+      label: "new session",
+      session_id: null,
+      data: null
+    }
+  ];
+  const sorted = Object.entries(sessions).sort(
+    ([, a], [, b]) => (b.last_updated ?? 0) - (a.last_updated ?? 0)
+  );
+  for (const [id, data] of sorted) {
+    const history = data.history ?? [];
+    const count = history.length;
+    const count_label = count === 0 ? "empty" : `${count} message${count === 1 ? "" : "s"}`;
+    options.push({
+      value: id,
+      label: `${id} \u2014 ${count_label}${buildHistoryPreview(history)}`,
+      session_id: id,
+      data: {
+        categories: migrateSessionCategories(data),
+        history,
+        last_updated: data.last_updated
+      }
+    });
+  }
+  return options;
+}
+async function applySessionChoice(session_id, data) {
+  if (!user_data) return;
+  await writeUserDataToFile();
+  user_data.session_id = session_id;
+  user_data.session_committed = true;
+  user_data.categories = [...data.categories];
+  user_data.history = [...data.history];
+  socket.disconnect();
+  socket.connect();
+}
+async function startNewSession() {
+  if (!user_data) return;
+  await writeUserDataToFile();
+  user_data.session_id = randomUUID2();
+  user_data.session_committed = false;
+  user_data.categories = [];
+  user_data.history = [];
+  socket.disconnect();
+  socket.connect();
+}
+
+// src/command/suggestion_box.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function SuggestionBox({ commands, selectedIndex }) {
+  if (commands.length === 0) return null;
+  return /* @__PURE__ */ jsx2(
+    Box2,
+    {
+      width: "100%",
+      flexDirection: "column",
+      display: "flex",
+      paddingX: 1,
+      paddingY: 1,
+      flexShrink: 0,
+      children: commands.map((entry, index) => /* @__PURE__ */ jsxs2(
+        Text2,
+        {
+          inverse: index === selectedIndex,
+          color: index === selectedIndex ? void 0 : "cyan",
+          children: [
+            entry.name,
+            " \u2014 ",
+            entry.description
+          ]
+        },
+        entry.name
+      ))
+    }
+  );
+}
+
+// src/hooks/use_bracketed_paste.ts
+import { useStdin, useStdout } from "ink";
+import { useEffect } from "react";
+var ESC = String.fromCharCode(27);
+var PASTE_START = `${ESC}[200~`;
+var PASTE_END = `${ESC}[201~`;
+var ENABLE_PASTE = `${ESC}[?2004h`;
+var DISABLE_PASTE = `${ESC}[?2004l`;
+var paste_active = false;
+function isPasteActive() {
+  return paste_active;
+}
+function notePasteMarker(input) {
+  if (input === "[200~") {
+    paste_active = true;
+    return true;
+  }
+  if (input === "[201~") {
+    paste_active = false;
+    return true;
+  }
+  return false;
+}
+function normalizeChunk(data) {
+  let chunk = data;
+  if (chunk.includes(PASTE_START)) {
+    paste_active = true;
+    chunk = chunk.split(PASTE_START).join("");
+  }
+  const was_pasting = paste_active;
+  if (chunk.includes(PASTE_END)) {
+    chunk = chunk.split(PASTE_END).join("");
+    paste_active = false;
+  }
+  if (was_pasting) {
+    chunk = chunk.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  }
+  return chunk;
+}
+function useBracketedPaste() {
+  const { stdout } = useStdout();
+  const { internal_eventEmitter } = useStdin();
+  useEffect(() => {
+    if (!internal_eventEmitter) {
+      return;
+    }
+    stdout.write(ENABLE_PASTE);
+    paste_active = false;
+    const original_emit = internal_eventEmitter.emit.bind(internal_eventEmitter);
+    const patched_emit = (event, ...args) => {
+      if (event === "input" && typeof args[0] === "string") {
+        const chunk = normalizeChunk(args[0]);
+        if (chunk.length === 0) {
+          return true;
+        }
+        return original_emit(event, chunk, ...args.slice(1));
+      }
+      return original_emit(event, ...args);
+    };
+    internal_eventEmitter.emit = patched_emit;
+    return () => {
+      stdout.write(DISABLE_PASTE);
+      internal_eventEmitter.emit = original_emit;
+      paste_active = false;
+    };
+  }, [internal_eventEmitter, stdout]);
+}
+
+// src/ui/prompt_box.tsx
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { useCallback, useEffect as useEffect2, useMemo, useRef, useState } from "react";
+
+// src/ui/text_window.ts
+import wrapAnsi from "wrap-ansi";
+var DISPLAY_ENTRY_PAD = 1;
+function wrapLines(text, width) {
+  if (width < 1) {
+    return [text];
+  }
+  return wrapAnsi(text, width, { hard: true, trim: false }).split("\n");
+}
+function flattenDisplayEntries(entries, width) {
+  return entries.map((entry, entryIndex) => {
+    const prefix = entry.role === "user" ? "You: " : entry.role === "system" || entry.role === "error" ? "" : "Agent: ";
+    const wrapped = wrapLines(`${prefix}${entry.content}`, width);
+    return {
+      entryIndex,
+      role: entry.role,
+      content: entry.content,
+      lines: wrapped
+    };
+  });
+}
+function displayRowsFromEntries(blocks) {
+  const rows = [];
+  for (const block of blocks) {
+    for (let pad = 0; pad < DISPLAY_ENTRY_PAD; pad++) {
+      rows.push({
+        kind: "pad",
+        entryIndex: block.entryIndex,
+        role: block.role,
+        content: block.content
+      });
+    }
+    block.lines.forEach((text, lineIndex) => {
+      rows.push({
+        kind: "text",
+        entryIndex: block.entryIndex,
+        role: block.role,
+        content: block.content,
+        lineIndex,
+        text
+      });
+    });
+    for (let pad = 0; pad < DISPLAY_ENTRY_PAD; pad++) {
+      rows.push({
+        kind: "pad",
+        entryIndex: block.entryIndex,
+        role: block.role,
+        content: block.content
+      });
+    }
+  }
+  return rows;
+}
+function groupRowsIntoBlocks(rows) {
+  const groups = [];
+  let current = null;
+  const flush = () => {
+    if (current) {
+      groups.push(current);
+      current = null;
+    }
+  };
+  for (const row of rows) {
+    if (!current || current.entryIndex !== row.entryIndex) {
+      flush();
+      current = {
+        entryIndex: row.entryIndex,
+        role: row.role,
+        content: row.content,
+        paddingTop: 0,
+        paddingBottom: 0,
+        lines: []
+      };
+    }
+    if (row.kind === "pad") {
+      if (current.lines.length === 0) {
+        current.paddingTop += 1;
+      } else {
+        current.paddingBottom += 1;
+      }
+    } else {
+      current.lines.push({ lineIndex: row.lineIndex, text: row.text });
+      current.paddingBottom = 0;
+    }
+  }
+  flush();
+  return groups;
+}
+function windowFromBottom(lines, viewport_rows, scroll_from_bottom) {
+  const maxScroll = Math.max(0, lines.length - viewport_rows);
+  const scroll = Math.min(Math.max(0, scroll_from_bottom), maxScroll);
+  const startIndex = Math.max(0, lines.length - scroll - viewport_rows);
+  const end_index = Math.min(lines.length, startIndex + viewport_rows);
+  return { visible: lines.slice(startIndex, end_index), startIndex, maxScroll };
+}
+function windowFromTop(lines, viewport_rows, scroll_top) {
+  const maxScroll = Math.max(0, lines.length - viewport_rows);
+  const scroll = Math.min(Math.max(0, scroll_top), maxScroll);
+  const start = Math.max(0, scroll);
+  const end = Math.min(lines.length, start + viewport_rows);
+  return { visible: lines.slice(start, end), startIndex: start, maxScroll };
+}
+
+// src/ui/prompt_box.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var MAX_PROMPT_CONTENT_ROWS = 5;
+var PASTE_SUBMIT_DELAY_MS = 20;
+var ESC2 = String.fromCharCode(27);
+var CSI_SEQUENCE_PATTERN = new RegExp(`${ESC2}\\[[0-9;?]*[ -/]*[@-~]`, "g");
+var FE_SEQUENCE_PATTERN = new RegExp(`${ESC2}[@-Z\\\\^_]`, "g");
+var ESC_SEQUENCE_PATTERN = new RegExp(`${ESC2}.`, "g");
+function sanitizeInputText(text) {
+  return text.replace(CSI_SEQUENCE_PATTERN, "").replace(FE_SEQUENCE_PATTERN, "").replace(ESC_SEQUENCE_PATTERN, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function promptContentRows(value, width, max_rows = MAX_PROMPT_CONTENT_ROWS) {
+  const n = value ? wrapLines(value, Math.max(1, width)).length : 1;
+  return Math.min(max_rows, Math.max(1, n));
+}
+function promptHiddenLineCount(value, width, max_rows = MAX_PROMPT_CONTENT_ROWS) {
+  if (!value) return 0;
+  return Math.max(0, wrapLines(value, Math.max(1, width)).length - max_rows);
+}
+function measureCursor(value, cursor_offset, width, content_rows) {
+  const safe_width = Math.max(1, width);
+  const lines = value ? wrapLines(value, safe_width) : [""];
+  const prefix = value.slice(0, cursor_offset);
+  const prefix_lines = prefix ? wrapLines(prefix, safe_width) : [""];
+  const raw_cursor_line = Math.max(0, prefix_lines.length - 1);
+  const cursor_line = Math.min(raw_cursor_line, Math.max(0, lines.length - 1));
+  const display_line = lines[cursor_line] ?? "";
+  const last_prefix = prefix_lines[prefix_lines.length - 1] ?? "";
+  let cursor_col;
+  if (cursor_offset >= value.length) {
+    cursor_col = display_line.length;
+  } else if (display_line.startsWith(last_prefix)) {
+    cursor_col = last_prefix.length;
+  } else {
+    cursor_col = Math.min(last_prefix.length, display_line.length);
+  }
+  const max_scroll = Math.max(0, lines.length - content_rows);
+  const scroll = Math.min(cursor_line, max_scroll);
+  return {
+    lines,
+    cursor_line,
+    cursor_col,
+    scroll,
+    max_scroll,
+    scrollable: lines.length > content_rows
+  };
+}
+function prefixLineCount(value, offset, width) {
+  const prefix = value.slice(0, offset);
+  return prefix ? wrapLines(prefix, width).length : 1;
+}
+function firstOffsetBeyondLine(value, line_index, width) {
+  let lo = 0;
+  let hi = value.length + 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (prefixLineCount(value, mid, width) > line_index) {
+      hi = mid;
+    } else {
+      lo = mid + 1;
+    }
+  }
+  return lo;
+}
+function findOffsetForVisualLine(value, target_line, desired_col, width) {
+  const safe_width = Math.max(1, width);
+  if (!value) return 0;
+  const lines = wrapLines(value, safe_width);
+  if (target_line >= lines.length) return value.length;
+  const start = firstOffsetBeyondLine(value, target_line, safe_width);
+  const end = firstOffsetBeyondLine(value, target_line + 1, safe_width);
+  if (start >= end || start > value.length) return value.length;
+  const display_line = lines[target_line] ?? "";
+  let best_offset = start;
+  let best_score = Number.POSITIVE_INFINITY;
+  for (let offset = start; offset < end && offset <= value.length; offset++) {
+    const prefix = value.slice(0, offset);
+    const prefix_lines = prefix ? wrapLines(prefix, safe_width) : [""];
+    const last_prefix = prefix_lines[prefix_lines.length - 1] ?? "";
+    let col;
+    if (offset >= value.length) {
+      col = display_line.length;
+    } else if (display_line.startsWith(last_prefix)) {
+      col = last_prefix.length;
+    } else {
+      col = Math.min(last_prefix.length, display_line.length);
+    }
+    const score = Math.abs(col - desired_col);
+    if (score < best_score) {
+      best_score = score;
+      best_offset = offset;
+    }
+  }
+  return best_offset;
+}
+function moveCursorVertical(value, cursor_offset, width, direction, metrics) {
+  const target_line = metrics.cursor_line + direction;
+  if (target_line < 0 || target_line >= metrics.lines.length) {
+    return cursor_offset;
+  }
+  return findOffsetForVisualLine(value, target_line, metrics.cursor_col, width);
+}
+function PromptBox({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = "",
+  width,
+  maxContentRows = MAX_PROMPT_CONTENT_ROWS,
+  bordered = true
+}) {
+  const [cursor_offset, setCursorOffset] = useState(() => value.length);
+  const draft_ref = useRef(value);
+  const cursor_ref = useRef(cursor_offset);
+  const submit_timer_ref = useRef(null);
+  const on_change_ref = useRef(onChange);
+  const on_submit_ref = useRef(onSubmit);
+  const handle_key_ref = useRef(() => {
+  });
+  draft_ref.current = value;
+  cursor_ref.current = Math.min(cursor_offset, value.length);
+  on_change_ref.current = onChange;
+  on_submit_ref.current = onSubmit;
+  useEffect2(() => {
+    if (cursor_offset > value.length) {
+      setCursorOffset(value.length);
+    }
+  }, [value, cursor_offset]);
+  useEffect2(
+    () => () => {
+      if (submit_timer_ref.current !== null) {
+        clearTimeout(submit_timer_ref.current);
+        submit_timer_ref.current = null;
+      }
+    },
+    []
+  );
+  const content_rows = useMemo(
+    () => promptContentRows(value, width, maxContentRows),
+    [maxContentRows, value, width]
+  );
+  const metrics = useMemo(
+    () => measureCursor(value, cursor_offset, width, content_rows),
+    [value, cursor_offset, width, content_rows]
+  );
+  const multi_row_draft = metrics.lines.length > 1;
+  const writeDraft = (next, next_cursor) => {
+    const clamped = Math.max(0, Math.min(next.length, next_cursor));
+    draft_ref.current = next;
+    cursor_ref.current = clamped;
+    on_change_ref.current(next);
+    setCursorOffset(clamped);
+  };
+  const insertText = (text) => {
+    const clean = sanitizeInputText(text);
+    if (!clean) return;
+    const current = draft_ref.current;
+    const at = cursor_ref.current;
+    const next = current.slice(0, at) + clean + current.slice(at);
+    writeDraft(next, at + clean.length);
+  };
+  const deleteBackward = () => {
+    const current = draft_ref.current;
+    const at = cursor_ref.current;
+    if (at <= 0) return;
+    const next = current.slice(0, at - 1) + current.slice(at);
+    writeDraft(next, at - 1);
+  };
+  const moveCursor = (next) => {
+    const clamped = Math.max(0, Math.min(draft_ref.current.length, next));
+    cursor_ref.current = clamped;
+    setCursorOffset(clamped);
+  };
+  const clearSubmitTimer = () => {
+    if (submit_timer_ref.current === null) return false;
+    clearTimeout(submit_timer_ref.current);
+    submit_timer_ref.current = null;
+    return true;
+  };
+  const handleKey = (input, key) => {
+    if (notePasteMarker(input)) {
+      return;
+    }
+    if (key.tab || key.shift && key.tab || key.ctrl && input === "c") {
+      return;
+    }
+    if (clearSubmitTimer()) {
+      insertText("\n");
+    }
+    if (key.upArrow) {
+      if (multi_row_draft) {
+        moveCursor(moveCursorVertical(draft_ref.current, cursor_ref.current, width, -1, metrics));
+      }
+      return;
+    }
+    if (key.downArrow) {
+      if (multi_row_draft) {
+        moveCursor(moveCursorVertical(draft_ref.current, cursor_ref.current, width, 1, metrics));
+      }
+      return;
+    }
+    if (key.return) {
+      if (key.shift || key.meta || isPasteActive()) {
+        insertText("\n");
+        return;
+      }
+      submit_timer_ref.current = setTimeout(() => {
+        submit_timer_ref.current = null;
+        on_submit_ref.current(draft_ref.current);
+      }, PASTE_SUBMIT_DELAY_MS);
+      return;
+    }
+    if (key.leftArrow) {
+      moveCursor(cursor_ref.current - 1);
+      return;
+    }
+    if (key.rightArrow) {
+      moveCursor(cursor_ref.current + 1);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      deleteBackward();
+      return;
+    }
+    insertText(input);
+  };
+  handle_key_ref.current = handleKey;
+  const stableInputHandler = useCallback(
+    (input, key) => handle_key_ref.current(input, key),
+    []
+  );
+  useInput(stableInputHandler);
+  const height = content_rows + 2;
+  const placeholder_line = wrapLines(placeholder, Math.max(1, width))[0] ?? "";
+  const visible_lines = metrics.lines.slice(metrics.scroll, metrics.scroll + content_rows);
+  const body = value ? visible_lines.map((line, index) => {
+    const absolute_line = metrics.scroll + index;
+    if (absolute_line === metrics.cursor_line) {
+      const col = Math.max(0, Math.min(metrics.cursor_col, line.length));
+      const before = line.slice(0, col);
+      const at = line.slice(col, col + 1);
+      const after = line.slice(col + 1);
+      return /* @__PURE__ */ jsxs3(Text3, { children: [
+        before,
+        /* @__PURE__ */ jsx3(Text3, { inverse: true, children: at === "" ? " " : at }),
+        after
+      ] }, `line-${absolute_line}`);
+    }
+    return /* @__PURE__ */ jsx3(Text3, { children: line }, `line-${absolute_line}`);
+  }) : /* @__PURE__ */ jsxs3(Text3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { inverse: true, children: placeholder_line.charAt(0) || " " }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: placeholder_line.slice(1) })
+  ] });
+  const indicator = metrics.max_scroll > 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+    metrics.scroll > 0 ? `\u2191 ${metrics.scroll} ` : "",
+    metrics.scroll < metrics.max_scroll ? `\u2193 ${metrics.max_scroll - metrics.scroll}` : ""
+  ] }) : null;
+  const outer_width = Math.max(3, width + 2);
+  const outer_height = height + (indicator ? 1 : 0);
+  if (!bordered) {
+    return /* @__PURE__ */ jsxs3(
+      Box3,
+      {
+        width: outer_width,
+        flexDirection: "column",
+        display: "flex",
+        backgroundColor: BG_PANEL,
+        paddingX: 1,
+        paddingY: 1,
+        children: [
+          body,
+          indicator
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3(
+    Box3,
+    {
+      width: outer_width,
+      height: outer_height,
+      display: "flex",
+      flexDirection: "column",
+      flexShrink: 0,
+      children: /* @__PURE__ */ jsx3(Box3, { width: "100%", display: "flex", backgroundColor: BG_PANEL, paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", display: "flex", width: "100%", children: [
+        body,
+        indicator
+      ] }) })
+    }
+  );
+}
+
+// src/ui/status_footer.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var STATUS_FOOTER_TOP_PAD = 1;
+function truncatePathEnd(path, width) {
+  if (width < 1) return "";
+  if (path.length <= width) return path;
+  if (width === 1) return "\u2026";
+  return `\u2026${path.slice(-(width - 1))}`;
+}
+function statusFooterRows() {
+  return STATUS_FOOTER_TOP_PAD + 1 + 1 + 1;
+}
+function StatusFooter({ width, cwd, modelLabel }) {
+  const content_width = Math.max(1, width - 2);
+  const path_display = truncatePathEnd(cwd.toUpperCase(), content_width);
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      width,
+      flexDirection: "column",
+      display: "flex",
+      flexShrink: 0,
+      paddingX: 1,
+      paddingTop: STATUS_FOOTER_TOP_PAD,
+      children: [
+        /* @__PURE__ */ jsx4(Box4, { width: "100%", display: "flex", flexDirection: "column", flexShrink: 0, children: /* @__PURE__ */ jsx4(Text4, { bold: true, color: "white", wrap: "truncate", children: "NERVE" }) }),
+        /* @__PURE__ */ jsx4(Box4, { width: "100%", display: "flex", flexDirection: "column", flexShrink: 0, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, wrap: "truncate", children: path_display }) }),
+        /* @__PURE__ */ jsx4(Box4, { width: "100%", display: "flex", flexDirection: "column", flexShrink: 0, children: /* @__PURE__ */ jsx4(Text4, { color: "yellow", wrap: "truncate", children: modelLabel }) })
+      ]
+    }
+  );
+}
+
+// src/hooks/use_layout.ts
+var LOGO_PROMPT_WIDTH = 60;
+var MIN_TASK_W = 20;
+var MAX_TASK_W = 40;
+var WINDOW_PAD = 1;
+function useLayout({
+  screen_width,
+  screen_height,
+  command_matches,
+  questionnaire_active,
+  questions,
+  current_question,
+  input_value,
+  questionnaire_free_text,
+  questionnaire_draft
+}) {
+  const inner_width = Math.max(1, screen_width - WINDOW_PAD * 2);
+  const inner_height = Math.max(1, screen_height - WINDOW_PAD * 2);
+  const show_task_bar = inner_width >= MIN_TASK_W;
+  const task_pane_width = show_task_bar ? Math.min(MAX_TASK_W, Math.max(MIN_TASK_W, Math.floor(inner_width * 0.25))) : 0;
+  const chat_gap = show_task_bar ? 1 : 0;
+  const chat_pane_width = Math.max(1, inner_width - task_pane_width - chat_gap);
+  const chat_border = 2;
+  const chat_content_width = Math.max(1, chat_pane_width - chat_border);
+  const task_gutter_width = 2;
+  const task_content_width = Math.max(1, task_pane_width - chat_border);
+  const task_text_width = Math.max(1, task_content_width - task_gutter_width);
+  const logo_prompt_width = Math.max(3, Math.min(LOGO_PROMPT_WIDTH, inner_width - 2));
+  const status_footer_height = show_task_bar ? statusFooterRows() : 0;
+  const task_viewport_rows = Math.max(1, inner_height - 4 - status_footer_height);
+  const suggestion_open = command_matches.length > 0;
+  const suggestion_rows = suggestion_open ? 2 + command_matches.reduce(
+    (n, e) => n + wrapLines(`${e.name} \u2014 ${e.description}`, chat_content_width).length,
+    0
+  ) : 0;
+  const questionnaire_rows = questionnaire_active ? 2 + wrapLines(
+    `Question ${current_question + 1}/${questions.length}: ${questions[current_question].question}`,
+    chat_content_width
+  ).length + buildQuestionOptions(questions[current_question].options).length : 0;
+  const prompt_max_rows = Math.min(10, Math.max(5, Math.floor(inner_height / 4)));
+  const active_draft = questionnaire_active ? questionnaire_free_text ? questionnaire_draft : "" : input_value;
+  const prompt_content_row_count = promptContentRows(
+    active_draft,
+    chat_content_width,
+    prompt_max_rows
+  );
+  const prompt_hidden_rows = promptHiddenLineCount(
+    active_draft,
+    chat_content_width,
+    prompt_max_rows
+  );
+  const prompt_box_height = prompt_content_row_count + 2 + (prompt_hidden_rows > 0 ? 1 : 0);
+  const overflow_rows_raw = suggestion_rows + questionnaire_rows;
+  const overflow_rows = Math.min(
+    overflow_rows_raw,
+    Math.max(0, inner_height - prompt_box_height - 3)
+  );
+  const display_viewport_rows = Math.max(1, inner_height - prompt_box_height - overflow_rows - 1);
+  const prompt_scrollable = input_value.length > 0 && wrapLines(input_value, chat_content_width).length > 1;
+  const entry_content_width = Math.max(1, chat_pane_width - 4);
+  return {
+    inner_width,
+    inner_height,
+    show_task_bar,
+    task_pane_width,
+    chat_gap,
+    chat_pane_width,
+    chat_content_width,
+    task_gutter_width,
+    task_text_width,
+    logo_prompt_width,
+    task_viewport_rows,
+    prompt_max_rows,
+    prompt_box_height,
+    display_viewport_rows,
+    prompt_scrollable,
+    entry_content_width
+  };
+}
+
+// src/hooks/use_mouse_wheel.ts
+import { useStdin as useStdin2, useStdout as useStdout2 } from "ink";
+import { useEffect as useEffect3, useRef as useRef2 } from "react";
+var ESC3 = String.fromCharCode(27);
+var MOUSE_PREFIX = `${ESC3}[<`;
+function parseMouseSgr(input) {
+  if (!input.startsWith(MOUSE_PREFIX)) {
+    return null;
+  }
+  const last = input.at(-1);
+  if (last !== "M" && last !== "m") {
+    return null;
+  }
+  const parts = input.slice(MOUSE_PREFIX.length, -1).split(";");
+  if (parts.length !== 3) {
+    return null;
+  }
+  const button = Number(parts[0]);
+  const x = Number(parts[1]);
+  const y = Number(parts[2]);
+  if (!Number.isFinite(button) || !Number.isFinite(x) || !Number.isFinite(y)) {
+    return null;
+  }
+  return { button, x, y };
+}
+var ENABLE_MOUSE = `${ESC3}[?1000h${ESC3}[?1006h`;
+var DISABLE_MOUSE = `${ESC3}[?1000l${ESC3}[?1006l`;
+function useMouseWheel(enabled, on_wheel) {
+  const { stdout } = useStdout2();
+  const { internal_eventEmitter } = useStdin2();
+  const on_wheel_ref = useRef2(on_wheel);
+  on_wheel_ref.current = on_wheel;
+  useEffect3(() => {
+    if (!enabled || !internal_eventEmitter) {
+      return;
+    }
+    stdout.write(ENABLE_MOUSE);
+    const original_emit = internal_eventEmitter.emit.bind(internal_eventEmitter);
+    const patched_emit = (event, ...args) => {
+      if (event === "input" && typeof args[0] === "string") {
+        const match = parseMouseSgr(args[0]);
+        if (match) {
+          if ((match.button & 64) !== 0) {
+            const direction = (match.button & 1) === 0 ? "up" : "down";
+            on_wheel_ref.current(direction, match.x, match.y);
+          }
+          return true;
+        }
+      }
+      return original_emit(event, ...args);
+    };
+    internal_eventEmitter.emit = patched_emit;
+    return () => {
+      stdout.write(DISABLE_MOUSE);
+      internal_eventEmitter.emit = original_emit;
+    };
+  }, [enabled, internal_eventEmitter, stdout]);
+}
+
+// src/save/create_config_file.ts
+import { access, mkdir, writeFile as writeFile2 } from "fs/promises";
+async function ensureConfigFile() {
+  const dir_path = configDirPath();
+  const file_path = configFilePath();
+  try {
+    await access(file_path);
+  } catch {
+    await mkdir(dir_path, { recursive: true });
+    await writeFile2(file_path, JSON.stringify(DEFAULT_CONFIG, null, "	"));
+  }
+}
+
+// src/socket/emitters.ts
+function emitUserPrompt(prompt) {
+  commitSession();
+  saveDisplayHistory({ role: "user", content: prompt });
+  socket.emit("user_prompt", prompt);
+}
+function emitQuestionnaireAnswers(answers) {
+  socket.emit("questionnaire_answers", answers);
+}
+function emitAgentErrorResponse(message) {
+  socket.emit("agent_error_response", message);
+}
+function emitToolResult(result) {
+  socket.emit("tool_result", result);
+}
+
+// src/socket/handler_registry.ts
+var display_handler = null;
+var task_update_handler = null;
+var subagent_response_handler = null;
+var connection_status_handler = null;
+var questionnaire_handler = null;
+var error_handler = null;
+var rate_limited_handler = null;
+function onDisplay(handler) {
+  display_handler = handler;
+}
+function onTaskUpdate(handler) {
+  task_update_handler = handler;
+}
+function onSubagentResponse(handler) {
+  subagent_response_handler = handler;
+}
+function onConnectionStatus(handler) {
+  connection_status_handler = handler;
+}
+function onQuestionnaire(handler) {
+  questionnaire_handler = handler;
+}
+function onError(handler) {
+  error_handler = handler;
+}
+function onRateLimited(handler) {
+  rate_limited_handler = handler;
+}
+
+// src/ui/chat_viewport.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ChatViewport({ chatBlocks, displayScroll, viewportRows }) {
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      width: "100%",
+      height: viewportRows,
+      flexDirection: "column",
+      display: "flex",
+      paddingX: 1,
+      justifyContent: "flex-end",
+      overflow: "hidden",
+      flexShrink: 0,
+      marginBottom: 1,
+      children: [
+        displayScroll > 0 && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, wrap: "truncate", children: [
+          "\u2014 scrolled up (",
+          displayScroll,
+          " lines, End for live) \u2014"
+        ] }),
+        chatBlocks.length === 0 ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "No messages yet" }) : chatBlocks.map((block) => /* @__PURE__ */ jsx5(
+          Box5,
+          {
+            width: "100%",
+            display: "flex",
+            flexDirection: "column",
+            paddingTop: block.paddingTop,
+            paddingBottom: block.paddingBottom,
+            paddingX: 1,
+            backgroundColor: entryPanelBg(block.role, block.content),
+            children: block.lines.map((line) => /* @__PURE__ */ jsx5(Text5, { color: roleColor(block.role), children: line.text }, line.lineIndex))
+          },
+          block.entryIndex
+        ))
+      ]
+    }
+  );
+}
+
+// src/ui/command_overlay.tsx
+import { PasswordInput, Select as Select2 } from "@inkjs/ui";
+
+// src/command/command_picker_box.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var COMMAND_PICKER_WIDTH = 60;
+function CommandPickerBox({ title, width, children }) {
+  const card_width = Math.min(COMMAND_PICKER_WIDTH, Math.max(1, width));
+  return /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      position: "absolute",
+      width: card_width,
+      display: "flex",
+      flexDirection: "column",
+      borderStyle: "round",
+      backgroundColor: BG_PANEL,
+      paddingX: 1,
+      flexShrink: 0,
+      children: [
+        /* @__PURE__ */ jsx6(Text6, { bold: true, children: title }),
+        children
+      ]
+    }
+  );
+}
+function CommandPickerOverlay({
+  screenWidth,
+  screenHeight,
+  children
+}) {
+  return /* @__PURE__ */ jsx6(
+    Box6,
+    {
+      position: "absolute",
+      width: Math.max(1, screenWidth),
+      height: Math.max(1, screenHeight),
+      display: "flex",
+      flexDirection: "column",
+      justifyContent: "center",
+      alignItems: "center",
+      children
+    }
+  );
+}
+
+// src/ui/command_overlay.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function CommandOverlay({
+  commandMode,
+  screenWidth,
+  screenHeight,
+  onModelSelect,
+  onKeyModelSelect,
+  onSessionSelect,
+  onApiKeySubmit
+}) {
+  if (commandMode.type === "select_model") {
+    return /* @__PURE__ */ jsx7(CommandPickerOverlay, { screenWidth, screenHeight, children: /* @__PURE__ */ jsx7(CommandPickerBox, { title: "Select a model:", width: screenWidth, children: /* @__PURE__ */ jsx7(
+      Select2,
+      {
+        options: buildModelSelectOptions().map((o) => ({
+          label: o.label,
+          value: o.value
+        })),
+        onChange: onModelSelect
+      }
+    ) }) });
+  }
+  if (commandMode.type === "select_key_model") {
+    return /* @__PURE__ */ jsx7(CommandPickerOverlay, { screenWidth, screenHeight, children: /* @__PURE__ */ jsx7(CommandPickerBox, { title: "Select a model to update its API key:", width: screenWidth, children: /* @__PURE__ */ jsx7(
+      Select2,
+      {
+        options: buildModelSelectOptions().map((o) => ({
+          label: o.label,
+          value: o.value
+        })),
+        onChange: onKeyModelSelect
+      }
+    ) }) });
+  }
+  if (commandMode.type === "select_session") {
+    return /* @__PURE__ */ jsx7(CommandPickerOverlay, { screenWidth, screenHeight, children: /* @__PURE__ */ jsx7(CommandPickerBox, { title: "Select a session:", width: screenWidth, children: /* @__PURE__ */ jsx7(
+      Select2,
+      {
+        options: commandMode.sessions.map((s) => ({
+          label: s.label,
+          value: s.value
+        })),
+        onChange: onSessionSelect
+      }
+    ) }) });
+  }
+  if (commandMode.type === "enter_api_key") {
+    return /* @__PURE__ */ jsx7(CommandPickerOverlay, { screenWidth, screenHeight, children: /* @__PURE__ */ jsx7(
+      CommandPickerBox,
+      {
+        title: commandMode.flow === "key" ? `Enter new API key for ${commandMode.modelLabel}:` : `Enter API key for ${commandMode.modelLabel} (id=${commandMode.modelId}):`,
+        width: screenWidth,
+        children: /* @__PURE__ */ jsx7(PasswordInput, { placeholder: "API key...", onSubmit: onApiKeySubmit })
+      }
+    ) });
+  }
+  return null;
+}
+
+// src/ui/logo_view.tsx
+import { FullScreenBox } from "fullscreen-ink";
+import { Box as Box7 } from "ink";
+import BigText from "ink-big-text";
+import { Fragment, jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function LogoView({
+  innerWidth,
+  logoPromptWidth,
+  promptMaxRows,
+  suggestionOpen,
+  commandMatches,
+  selectedIdx,
+  questionnaireActive,
+  question,
+  currentQuestion,
+  totalQuestions,
+  questionnaireFreeText,
+  questionnaireDraft,
+  onQuestionnaireDraftChange,
+  onQuestionnaireSelect,
+  onQuestionnaireOther,
+  onQuestionnaireDraftSubmit,
+  inputKey,
+  inputValue,
+  promptPlaceholder,
+  onInputChange,
+  onPromptSubmit,
+  commandOverlay
+}) {
+  return /* @__PURE__ */ jsxs7(
+    FullScreenBox,
+    {
+      flexDirection: "column",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "flex-start",
+      backgroundColor: BG_BLACK,
+      padding: WINDOW_PAD,
+      children: [
+        /* @__PURE__ */ jsxs7(
+          Box7,
+          {
+            width: "100%",
+            height: "100%",
+            display: "flex",
+            flexDirection: "column",
+            justifyContent: "center",
+            alignItems: "center",
+            children: [
+              /* @__PURE__ */ jsx8(BigText, { text: "Nerve" }),
+              questionnaireActive ? /* @__PURE__ */ jsxs7(Box7, { width: "100%", display: "flex", flexDirection: "column", alignItems: "center", children: [
+                /* @__PURE__ */ jsx8(
+                  QuestionnaireBox,
+                  {
+                    question,
+                    current: currentQuestion,
+                    total: totalQuestions,
+                    onSelect: onQuestionnaireSelect,
+                    freeText: questionnaireFreeText,
+                    onOther: onQuestionnaireOther
+                  }
+                ),
+                questionnaireFreeText && /* @__PURE__ */ jsx8(
+                  PromptBox,
+                  {
+                    value: questionnaireDraft,
+                    onChange: onQuestionnaireDraftChange,
+                    onSubmit: onQuestionnaireDraftSubmit,
+                    placeholder: "Type your answer\u2026 (Esc to go back)",
+                    width: logoPromptWidth,
+                    maxContentRows: promptMaxRows,
+                    bordered: true
+                  },
+                  `q-other-logo-${currentQuestion}`
+                )
+              ] }) : /* @__PURE__ */ jsxs7(Fragment, { children: [
+                suggestionOpen && /* @__PURE__ */ jsx8(
+                  Box7,
+                  {
+                    width: Math.min(LOGO_PROMPT_WIDTH, innerWidth),
+                    display: "flex",
+                    flexDirection: "column",
+                    children: /* @__PURE__ */ jsx8(SuggestionBox, { commands: commandMatches, selectedIndex: selectedIdx })
+                  }
+                ),
+                /* @__PURE__ */ jsx8(
+                  PromptBox,
+                  {
+                    value: inputValue,
+                    onChange: onInputChange,
+                    onSubmit: onPromptSubmit,
+                    placeholder: promptPlaceholder,
+                    width: logoPromptWidth,
+                    maxContentRows: promptMaxRows,
+                    bordered: false
+                  },
+                  inputKey
+                )
+              ] })
+            ]
+          }
+        ),
+        commandOverlay
+      ]
+    }
+  );
+}
+
+// src/ui/task_pane.tsx
+import { Spinner } from "@inkjs/ui";
+import { Box as Box8, Text as Text7 } from "ink";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function buildTaskLines(tasks, task_text_width) {
+  if (tasks.length === 0) {
+    return [];
+  }
+  const lines = [];
+  tasks.forEach((category, category_index) => {
+    lines.push({
+      type: "category",
+      key: `c-${category_index}`,
+      label: category.name,
+      status: category.status,
+      waitsOn: category.status === "pending" && category.depends_on.length > 0 ? category.depends_on.join(", ") : ""
+    });
+    category.tasks.forEach((task, task_index) => {
+      const wrapped = wrapLines(task.description, task_text_width);
+      wrapped.forEach((text, line_index) => {
+        lines.push({
+          type: "task_line",
+          key: `t-${category_index}-${task_index}:${line_index}`,
+          status: task.status,
+          text,
+          showGutter: line_index === 0
+        });
+      });
+    });
+    lines.push({ type: "blank", key: `b-${category_index}` });
+  });
+  return lines;
+}
+function TaskPane({
+  taskWindow,
+  taskScroll,
+  taskGutterWidth,
+  width,
+  cwd,
+  modelLabel
+}) {
+  return /* @__PURE__ */ jsxs8(Box8, { width, height: "100%", flexDirection: "column", display: "flex", flexShrink: 0, children: [
+    /* @__PURE__ */ jsxs8(
+      Box8,
+      {
+        width: "100%",
+        flexGrow: 1,
+        flexShrink: 1,
+        minHeight: 0,
+        flexDirection: "column",
+        display: "flex",
+        backgroundColor: BG_PANEL,
+        paddingX: 1,
+        paddingY: 1,
+        overflow: "hidden",
+        children: [
+          /* @__PURE__ */ jsx9(Text7, { bold: true, children: "Tasks" }),
+          taskWindow.visible.length === 0 ? /* @__PURE__ */ jsx9(Text7, { dimColor: true, children: "No tasks yet" }) : taskWindow.visible.map((line) => {
+            if (line.type === "blank") {
+              return /* @__PURE__ */ jsx9(Text7, { children: " " }, line.key);
+            }
+            if (line.type === "category") {
+              const marker = line.status === "done" ? "\u2713 " : line.status === "failed" ? "\u2717 " : line.status === "blocked" ? "\u2298 " : "\u25B6 ";
+              const color = line.status === "done" ? "green" : line.status === "failed" ? "red" : line.status === "blocked" ? "yellow" : void 0;
+              return /* @__PURE__ */ jsxs8(Text7, { bold: true, color, children: [
+                marker,
+                line.label,
+                line.status === "running" ? " \u2026" : "",
+                line.waitsOn ? /* @__PURE__ */ jsx9(Text7, { dimColor: true, children: ` (waits: ${line.waitsOn})` }) : null
+              ] }, line.key);
+            }
+            if (line.status === "running") {
+              return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
+                /* @__PURE__ */ jsx9(Box8, { width: taskGutterWidth, flexShrink: 0, children: line.showGutter ? /* @__PURE__ */ jsx9(Spinner, {}) : null }),
+                /* @__PURE__ */ jsx9(Text7, { color: "green", children: line.text })
+              ] }, line.key);
+            }
+            if (line.status === "done" || line.status === "failed") {
+              const failed = line.status === "failed";
+              return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
+                /* @__PURE__ */ jsx9(Box8, { width: taskGutterWidth, flexShrink: 0, children: /* @__PURE__ */ jsx9(Text7, { color: failed ? "red" : "green", children: line.showGutter ? failed ? "\u2717" : "\u2713" : " " }) }),
+                /* @__PURE__ */ jsx9(Text7, { dimColor: failed ? void 0 : true, color: failed ? "red" : void 0, children: line.text })
+              ] }, line.key);
+            }
+            return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
+              /* @__PURE__ */ jsx9(Box8, { width: taskGutterWidth, flexShrink: 0, children: /* @__PURE__ */ jsx9(Text7, { children: " " }) }),
+              /* @__PURE__ */ jsx9(Text7, { dimColor: true, children: line.text })
+            ] }, line.key);
+          }),
+          taskWindow.maxScroll > 0 && /* @__PURE__ */ jsxs8(Text7, { dimColor: true, children: [
+            taskScroll > 0 ? `\u2191 ${taskScroll} ` : "",
+            taskScroll < taskWindow.maxScroll ? "\u2193" : ""
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx9(StatusFooter, { width, cwd, modelLabel })
+  ] });
+}
+
+// src/systemconfig/limits.ts
+var COMMAND_TIMEOUT_MS = 3e4;
+var OUTPUT_CHAR_CAP = 8e3;
+var MAX_READ_BYTES = 1e5;
+var DEFAULT_READ_LIMIT = 500;
+var GREP_MAX_MATCHES = 50;
+var GLOB_MAX_RESULTS = 100;
+var IGNORED_DIR_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+  ".next",
+  ".pytest_cache",
+  ".ruff_cache"
+]);
+
+// src/tool/args.ts
+function asString(value) {
+  return typeof value === "string" ? value : "";
+}
+function asOptionalString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+// src/tool/file_ops.ts
+import { lstat, mkdir as mkdir2, readdir, readFile as readFile3, stat, writeFile as writeFile3 } from "fs/promises";
+import { basename, dirname, join as join2 } from "path";
+
+// src/tool/workspace.ts
+import { homedir } from "os";
+import { isAbsolute, resolve, sep } from "path";
+function getWorkspaceRoot() {
+  return resolve(process.cwd());
+}
+function resolveSafePath(user_path) {
+  if (!user_path?.trim()) {
+    return { error: "Error: path must be a non-empty string" };
+  }
+  const root = getWorkspaceRoot();
+  let candidate = user_path;
+  if (candidate === "~") {
+    candidate = homedir();
+  } else if (candidate.startsWith("~/") || candidate.startsWith(`~${sep}`)) {
+    candidate = `${homedir()}/${candidate.slice(2)}`;
+  }
+  try {
+    const resolved = isAbsolute(candidate) ? resolve(candidate) : resolve(root, candidate);
+    if (resolved !== root && !resolved.startsWith(`${root}${sep}`)) {
+      return { error: `Error: path outside workspace: ${user_path}` };
+    }
+    return { path: resolved };
+  } catch (e) {
+    return {
+      error: `Error: cannot resolve path '${user_path}': ${String(e)}`
+    };
+  }
+}
+
+// src/tool/file_ops.ts
+async function writeFileTool(file_path, content, mode) {
+  if (mode !== "overwrite" && mode !== "append") {
+    return `Error: mode must be 'overwrite' or 'append', got: ${mode}`;
+  }
+  const safe = resolveSafePath(file_path);
+  if ("error" in safe) return safe.error;
+  await mkdir2(dirname(safe.path), { recursive: true });
+  await writeFile3(safe.path, content, {
+    encoding: "utf8",
+    flag: mode === "overwrite" ? "w" : "a"
+  });
+  return `Successfully ${mode === "overwrite" ? "overwritten" : "appended to"} file: ${file_path}`;
+}
+async function editTool(file_path, old_string, new_string) {
+  if (!old_string) return "Error: old_string must be non-empty";
+  const safe = resolveSafePath(file_path);
+  if ("error" in safe) return safe.error;
+  try {
+    await lstat(safe.path);
+  } catch {
+    return `Error: Path does not exist: ${file_path}`;
+  }
+  if ((await stat(safe.path)).isDirectory()) {
+    return `Error: Path is a directory, not a file: ${file_path}`;
+  }
+  const content = await readFile3(safe.path, "utf8");
+  const count = content.split(old_string).length - 1;
+  if (count === 0) return "Error: old_string not found in file";
+  if (count > 1) {
+    return `Error: old_string found ${count} times; add more context to make it unique`;
+  }
+  await writeFile3(safe.path, content.replace(old_string, new_string), "utf8");
+  return `Successfully edited file: ${file_path}`;
+}
+function splitLines(text) {
+  const lines = text.split(/\r\n|\r|\n/);
+  if (text.endsWith("\n") || text.endsWith("\r")) lines.pop();
+  return lines;
+}
+async function readFileTool(file_path, offset, limit) {
+  const safe = resolveSafePath(file_path);
+  if ("error" in safe) return safe.error;
+  try {
+    await lstat(safe.path);
+  } catch {
+    return `Error: Path does not exist: ${file_path}`;
+  }
+  if ((await stat(safe.path)).isDirectory()) {
+    return `Error: Path is a directory, not a file: ${file_path}`;
+  }
+  if (offset < 1) return "Error: offset must be >= 1";
+  if (limit < 1) return "Error: limit must be >= 1";
+  const size = (await stat(safe.path)).size;
+  const truncated_file = size > MAX_READ_BYTES;
+  let raw = await readFile3(safe.path, "utf8");
+  if (truncated_file) raw = raw.slice(0, MAX_READ_BYTES);
+  const lines = splitLines(raw);
+  const window = lines.slice(offset - 1, offset - 1 + limit);
+  if (window.length === 0) {
+    return `Error: offset ${offset} is past end of file (${lines.length} lines)`;
+  }
+  let numbered = window.map((line, i) => `${offset + i}: ${line}`).join("\n");
+  const notes = [];
+  if (truncated_file) {
+    notes.push(`Note: file truncated at ${MAX_READ_BYTES} bytes for reading.`);
+  }
+  const end = offset - 1 + window.length;
+  if (end < lines.length) {
+    notes.push(`Note: showed lines ${offset}-${end}; more lines remain (use offset/limit).`);
+  }
+  if (notes.length > 0) numbered = `${numbered}
+${notes.join("\n")}`;
+  return numbered;
+}
+var TREE_ELBOW = "\u2514\u2500\u2500 ";
+var TREE_TEE = "\u251C\u2500\u2500 ";
+var TREE_PIPE_PREFIX = "\u2502   ";
+var TREE_SPACE_PREFIX = "    ";
+async function walkTree(directory, prefix, lines) {
+  let names;
+  try {
+    names = await readdir(directory);
+  } catch {
+    return;
+  }
+  const entries = names.filter((name) => !IGNORED_DIR_NAMES.has(name)).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+  if (entries.length === 0) return;
+  const last_index = entries.length - 1;
+  for (const [index, name] of entries.entries()) {
+    const is_last = index === last_index;
+    const entry_path = join2(directory, name);
+    let is_dir = false;
+    try {
+      is_dir = (await lstat(entry_path)).isDirectory();
+    } catch {
+      continue;
+    }
+    const connector = is_last ? TREE_ELBOW : TREE_TEE;
+    lines.push(`${prefix}${connector}${name}${is_dir ? "/" : ""}`);
+    if (is_dir) {
+      const child_prefix = is_last ? TREE_SPACE_PREFIX : TREE_PIPE_PREFIX;
+      await walkTree(entry_path, `${prefix}${child_prefix}`, lines);
+      if (!is_last) lines.push(`${prefix}\u2502`);
+    }
+  }
+}
+async function listDirTool(directory_path) {
+  const safe = resolveSafePath(directory_path);
+  if ("error" in safe) return safe.error;
+  try {
+    await lstat(safe.path);
+  } catch {
+    return `Error: Path does not exist: ${directory_path}`;
+  }
+  if (!(await stat(safe.path)).isDirectory()) {
+    return `Error: Path is not a directory: ${directory_path}`;
+  }
+  const root_name = basename(safe.path) || safe.path;
+  const lines = [`${root_name}/`];
+  let names = [];
+  try {
+    names = await readdir(safe.path);
+  } catch {
+    names = [];
+  }
+  if (names.some((name) => !IGNORED_DIR_NAMES.has(name))) lines.push("\u2502");
+  await walkTree(safe.path, "", lines);
+  return lines.join("\n");
+}
+
+// src/tool/search_ops.ts
+import { glob as fsGlob, readFile as readFile4, stat as stat2 } from "fs/promises";
+import { basename as basename2, relative, resolve as resolve2, sep as sep2 } from "path";
+function hasIgnoredPart(relative_path) {
+  return relative_path.split(sep2).some((part) => IGNORED_DIR_NAMES.has(part));
+}
+function recursivePattern(pattern) {
+  return pattern.startsWith("**/") ? pattern : `**/${pattern}`;
+}
+async function collectMatchingFiles(root, pattern) {
+  const matches = [];
+  for await (const entry of fsGlob(recursivePattern(pattern), { cwd: root })) {
+    const full = resolve2(root, entry);
+    if (hasIgnoredPart(relative(root, full))) continue;
+    try {
+      if ((await stat2(full)).isFile()) matches.push(full);
+    } catch {
+    }
+  }
+  return matches.sort();
+}
+async function grepTool(pattern, path, file_glob) {
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch (e) {
+    return `Error: invalid regex pattern: ${e instanceof Error ? e.message : String(e)}`;
+  }
+  const safe = resolveSafePath(path);
+  if ("error" in safe) return safe.error;
+  let root_stat;
+  try {
+    root_stat = await stat2(safe.path);
+  } catch {
+    return `Error: Path does not exist: ${path}`;
+  }
+  let files;
+  if (root_stat.isFile()) {
+    files = [safe.path];
+  } else if (root_stat.isDirectory()) {
+    files = await collectMatchingFiles(safe.path, file_glob ?? "*");
+  } else {
+    return `Error: Path does not exist: ${path}`;
+  }
+  const matches = [];
+  for (const file_path of files) {
+    let text;
+    try {
+      text = await readFile4(file_path, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = text.split(/\r\n|\r|\n/);
+    if (text.endsWith("\n") || text.endsWith("\r")) lines.pop();
+    for (const [index, line] of lines.entries()) {
+      if (!regex.test(line)) continue;
+      const label = root_stat.isFile() ? basename2(file_path) : relative(safe.path, file_path);
+      matches.push(`${label}:${index + 1}: ${line.trimEnd()}`);
+      if (matches.length >= GREP_MAX_MATCHES) {
+        return `${matches.join("\n")}
+... [stopped at ${GREP_MAX_MATCHES} matches]`;
+      }
+    }
+  }
+  return matches.length > 0 ? matches.join("\n") : "No matches found";
+}
+async function globTool(pattern, path) {
+  const safe = resolveSafePath(path);
+  if ("error" in safe) return safe.error;
+  let root_stat;
+  try {
+    root_stat = await stat2(safe.path);
+  } catch {
+    return `Error: Path is not a directory: ${path}`;
+  }
+  if (!root_stat.isDirectory()) {
+    return `Error: Path is not a directory: ${path}`;
+  }
+  const results = [];
+  for await (const entry of fsGlob(pattern, { cwd: safe.path })) {
+    const full = resolve2(safe.path, entry);
+    if (hasIgnoredPart(relative(safe.path, full))) continue;
+    try {
+      const entry_stat = await stat2(full);
+      if (entry_stat.isFile()) {
+        results.push({ path: full, modified: entry_stat.mtimeMs });
+      }
+    } catch {
+    }
+  }
+  if (results.length === 0) return "No files matched";
+  results.sort((a, b) => b.modified - a.modified);
+  const shown = results.slice(0, GLOB_MAX_RESULTS);
+  const lines = shown.map((entry) => entry.path);
+  if (results.length > GLOB_MAX_RESULTS) {
+    lines.push(`... [showing ${GLOB_MAX_RESULTS} of ${results.length} matches]`);
+  }
+  return lines.join("\n");
+}
+
+// src/tool/shell.ts
+import { exec } from "child_process";
+function truncateOutput(text, cap) {
+  if (text.length <= cap) return text;
+  return `${text.slice(0, cap)}
+... [truncated, ${text.length - cap} more characters]`;
+}
+function runTerminalCommand(bash_command) {
+  return new Promise((resolve_promise) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve_promise(result);
+    };
+    const child = exec(
+      bash_command,
+      { cwd: process.cwd(), maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (settled) return;
+        if (error && typeof error.code !== "number") {
+          finish(`Failed to execute the command: ${error.message}`);
+          return;
+        }
+        const exit_code = error ? error.code : 0;
+        const parts = [`Exit code: ${exit_code}`];
+        if (stdout) {
+          parts.push(`stdout:
+${truncateOutput(stdout, OUTPUT_CHAR_CAP)}`);
+        }
+        if (stderr) {
+          parts.push(`stderr:
+${truncateOutput(stderr, OUTPUT_CHAR_CAP)}`);
+        }
+        if (!stdout && !stderr) parts.push("(no output)");
+        finish(parts.join("\n"));
+      }
+    );
+    const timer = setTimeout(() => {
+      child.kill();
+      finish(`Error: command timed out after ${COMMAND_TIMEOUT_MS / 1e3}s`);
+    }, COMMAND_TIMEOUT_MS);
+    child.on("close", () => clearTimeout(timer));
+  });
+}
+
+// src/tool/executor.ts
+async function executeToolRequest(request) {
+  const args = request.args ?? {};
+  try {
+    switch (request.tool) {
+      case "write":
+        return await writeFileTool(
+          asString(args.file_path),
+          asString(args.content),
+          args.mode === void 0 ? "overwrite" : asString(args.mode)
+        );
+      case "edit":
+        return await editTool(
+          asString(args.file_path),
+          asString(args.old_string),
+          asString(args.new_string)
+        );
+      case "readFile":
+        return await readFileTool(
+          asString(args.file_path),
+          asNumber(args.offset, 1),
+          asNumber(args.limit, DEFAULT_READ_LIMIT)
+        );
+      case "listDir":
+        return await listDirTool(asString(args.directory_path));
+      case "grep":
+        return await grepTool(
+          asString(args.pattern),
+          asString(args.path) || ".",
+          asOptionalString(args.file_glob)
+        );
+      case "glob":
+        return await globTool(asString(args.pattern), asString(args.path) || ".");
+      case "terminalCommand":
+        return await runTerminalCommand(asString(args.bash_command));
+      default:
+        return `Error: unknown tool: ${request.tool}`;
+    }
+  } catch (e) {
+    return `Error: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
+// src/socket/listener.ts
+socket.on("main_agent_response", (data) => {
+  const entry = { role: "assistant", content: data };
+  saveDisplayHistory(entry);
+  display_handler?.(entry);
+});
+socket.on("task_update", (data) => {
+  saveTaskUpdate(data);
+  task_update_handler?.(data);
+});
+socket.on("subagent_response", (data) => {
+  subagent_response_handler?.(data);
+});
+socket.on("connection_status", (data) => {
+  connection_status_handler?.(data);
+});
+socket.on("questionnaire", (data) => {
+  questionnaire_handler?.(data);
+});
+socket.on("agent_error", (data) => {
+  error_handler?.(data);
+  emitAgentErrorResponse(data);
+});
+socket.on("rate_limited", (data) => {
+  rate_limited_handler?.(data);
+});
+socket.on("tool_request", (data) => {
+  void executeToolRequest(data).catch((e) => `Error: ${e instanceof Error ? e.message : String(e)}`).then((output) => {
+    emitToolResult({ id: data.id, ok: !output.startsWith("Error:"), output });
+  });
+});
+socket.on("disconnect", async () => {
+  await writeUserDataToFile();
+});
+
+// src/app.tsx
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var PROMPT_PLACEHOLDER = "SPAM your prompts here... (or /model, /session)";
+function App() {
+  const [logo_show, setLogoShow] = useState2(true);
+  const [displays, setDisplays] = useState2([]);
+  const [tasks, setTasks] = useState2([]);
+  const [display_scroll, setDisplayScroll] = useState2(0);
+  const [task_scroll, setTaskScroll] = useState2(0);
+  const [, setConnectionStatus] = useState2(false);
+  const [questions, setQuestions] = useState2([]);
+  const [current_question, setCurrentQuestion] = useState2(0);
+  const [answers, setAnswers] = useState2([]);
+  const [questionnaire_free_text, setQuestionnaireFreeText] = useState2(false);
+  const [questionnaire_draft, setQuestionnaireDraft] = useState2("");
+  const questions_ref = useRef3([]);
+  const questionnaire_active = questions.length > 0 && current_question < questions.length;
+  const [command_mode, setCommandMode] = useState2({
+    type: "none"
+  });
+  const [input_value, setInputValue] = useState2("");
+  const [selected_idx, setSelectedIdx] = useState2(0);
+  const [input_key, setInputKey] = useState2(0);
+  const { height: screen_height, width: screen_width } = useScreenSize();
+  const command_matches = command_mode.type === "none" && !questionnaire_active ? filterCommands(input_value) : [];
+  const suggestion_open = command_matches.length > 0;
+  const {
+    inner_width,
+    inner_height,
+    show_task_bar,
+    task_pane_width,
+    chat_gap,
+    chat_pane_width,
+    chat_content_width,
+    task_gutter_width,
+    task_text_width,
+    logo_prompt_width,
+    task_viewport_rows,
+    prompt_max_rows,
+    prompt_box_height,
+    display_viewport_rows,
+    prompt_scrollable,
+    entry_content_width
+  } = useLayout({
+    screen_width,
+    screen_height,
+    command_matches,
+    questionnaire_active,
+    questions,
+    current_question,
+    input_value,
+    questionnaire_free_text,
+    questionnaire_draft
+  });
+  const status_cwd = process.cwd();
+  const status_model_label = user_data ? getModelLabel(user_data.main_agent_id) : "\u2014";
+  useEffect4(() => {
+    questions_ref.current = questions;
+  }, [questions]);
+  const chat_lines = useMemo2(
+    () => flattenDisplayEntries(displays, entry_content_width),
+    [displays, entry_content_width]
+  );
+  const chat_rows = useMemo2(() => displayRowsFromEntries(chat_lines), [chat_lines]);
+  const task_lines = useMemo2(
+    () => buildTaskLines(tasks, task_text_width),
+    [tasks, task_text_width]
+  );
+  const chat_window = windowFromBottom(
+    chat_rows,
+    display_viewport_rows - (display_scroll > 0 ? 1 : 0),
+    display_scroll
+  );
+  const chat_blocks = groupRowsIntoBlocks(chat_window.visible);
+  const task_window = windowFromTop(task_lines, task_viewport_rows, task_scroll);
+  const scrollChat = (delta) => {
+    setDisplayScroll((prev) => Math.max(0, Math.min(chat_window.maxScroll, prev + delta)));
+  };
+  const scrollTasks = (delta) => {
+    setTaskScroll((prev) => Math.max(0, Math.min(task_window.maxScroll, prev + delta)));
+  };
+  const cancelActiveCommand = () => {
+    setCommandMode({ type: "none" });
+    setLogoShow(false);
+    setInputValue("");
+    setSelectedIdx(0);
+    setInputKey((prev) => prev + 1);
+  };
+  useInput2(
+    (input, key) => {
+      void input;
+      if (key.escape && questionnaire_free_text) {
+        setQuestionnaireFreeText(false);
+        setQuestionnaireDraft("");
+        return;
+      }
+      if (key.escape && command_mode.type !== "none") {
+        cancelActiveCommand();
+        return;
+      }
+      if (suggestion_open) {
+        if (key.upArrow) {
+          setSelectedIdx((prev) => prev <= 0 ? command_matches.length - 1 : prev - 1);
+        } else if (key.downArrow) {
+          setSelectedIdx((prev) => prev >= command_matches.length - 1 ? 0 : prev + 1);
+        } else if (key.tab) {
+          const entry = command_matches[selected_idx];
+          if (entry) {
+            setInputValue(entry.name);
+            setInputKey((prev) => prev + 1);
+          }
+        }
+        return;
+      }
+      if (command_mode.type !== "none" || logo_show || questionnaire_active) {
+        return;
+      }
+      if (key.ctrl && key.upArrow) {
+        scrollTasks(-1);
+      } else if (key.ctrl && key.downArrow) {
+        scrollTasks(1);
+      } else if (key.pageUp) {
+        scrollChat(display_viewport_rows);
+      } else if (key.pageDown) {
+        scrollChat(-display_viewport_rows);
+      } else if (key.home) {
+        scrollChat(chat_window.maxScroll);
+      } else if (key.end) {
+        scrollChat(-chat_window.maxScroll);
+      } else if (key.upArrow) {
+        if (prompt_scrollable) return;
+        scrollChat(1);
+      } else if (key.downArrow) {
+        if (prompt_scrollable) return;
+        scrollChat(-1);
+      }
+    },
+    { isActive: true }
+  );
+  useBracketedPaste();
+  useMouseWheel(!logo_show, (direction, x) => {
+    if (command_mode.type !== "none") {
+      return;
+    }
+    const over_tasks = show_task_bar && x > chat_pane_width;
+    const delta = direction === "up" ? 3 : -3;
+    if (over_tasks) {
+      scrollTasks(-delta);
+    } else {
+      scrollChat(delta);
+    }
+  });
+  const handleInputChange = (value) => {
+    setInputValue(value);
+    setSelectedIdx(0);
+  };
+  const completeToSelectedCommand = (value) => {
+    if (!value.startsWith("/")) return value;
+    const exact = command_matches.find((entry) => entry.name === value);
+    if (exact) return exact.name;
+    const selected = command_matches[selected_idx] ?? command_matches[0];
+    return selected ? selected.name : value;
+  };
+  useEffect4(() => {
+    const flushAndExit = async () => {
+      try {
+        await writeUserDataToFile();
+      } finally {
+        process.exit(0);
+      }
+    };
+    process.on("SIGINT", flushAndExit);
+    process.on("SIGTERM", flushAndExit);
+    (async () => {
+      await ensureConfigFile();
+      const data = await readConfig();
+      setUserData(data);
+      setTasks(user_data?.categories ?? []);
+      setDisplayScroll(0);
+      setTaskScroll(0);
+      connectSocket();
+    })();
+    return () => {
+      process.off("SIGINT", flushAndExit);
+      process.off("SIGTERM", flushAndExit);
+    };
+  }, []);
+  useEffect4(() => {
+    onDisplay((entry) => {
+      setDisplays((prev) => [...prev, entry]);
+    });
+    onTaskUpdate(() => {
+      setTasks(user_data?.categories ?? []);
+    });
+    onSubagentResponse((data) => {
+      const entry = {
+        role: "system",
+        content: `${data.status === "done" ? "\u2713" : "\u2717"} [${data.category}] ${data.report}`
+      };
+      saveDisplayHistory(entry);
+      setDisplays((prev) => [...prev, entry]);
+    });
+    onConnectionStatus((connected) => {
+      setConnectionStatus(connected);
+      if (!connected) {
+        setDisplays((prev) => [
+          ...prev,
+          {
+            role: "system",
+            content: "Cannot connect to model \u2014 set API key with /model"
+          }
+        ]);
+      }
+    });
+    onQuestionnaire((qs) => {
+      const prev = questions_ref.current;
+      if (prev.length > 0 && prev.length === qs.length && JSON.stringify(prev) === JSON.stringify(qs)) {
+        return;
+      }
+      questions_ref.current = qs;
+      setQuestions(qs);
+      setCurrentQuestion(0);
+      setAnswers([]);
+      setQuestionnaireFreeText(false);
+      setQuestionnaireDraft("");
+    });
+    onError((message) => {
+      setDisplays((prev) => [...prev, { role: "error", content: message }]);
+    });
+    onRateLimited((data) => {
+      setDisplays((prev) => [
+        ...prev,
+        { role: "error", content: `Rate limited \u2014 try again in ${data.retry_after}s` }
+      ]);
+    });
+  }, []);
+  const appendSystemNote = (content) => {
+    setDisplays((prev) => [...prev, { role: "system", content }]);
+  };
+  const finishModelSwitch = async (model_id, api_key) => {
+    await persistModelChoice(model_id, api_key);
+    appendSystemNote(`Switched model to ${getModelLabel(model_id)} (id=${model_id})`);
+    setCommandMode({ type: "none" });
+    setLogoShow(false);
+    setInputValue("");
+    setSelectedIdx(0);
+    setInputKey((prev) => prev + 1);
+  };
+  const handleModelSelect = async (value) => {
+    const option = buildModelSelectOptions().find((o) => o.value === value);
+    if (!option) return;
+    const model = MODEL_OPTIONS.find((m) => m.id === option.modelId);
+    if (!model) return;
+    if (isFundedModel(model.id)) {
+      await finishModelSwitch(model.id, "");
+      return;
+    }
+    if (hasApiKeyForModel(model.id)) {
+      const existing_key = user_data?.api_keys[model.id];
+      if (existing_key) {
+        await finishModelSwitch(model.id, existing_key);
+      }
+    } else {
+      setCommandMode({
+        type: "enter_api_key",
+        modelId: model.id,
+        modelLabel: model.label,
+        flow: "model"
+      });
+    }
+  };
+  const handleKeyModelSelect = (value) => {
+    const option = buildModelSelectOptions().find((o) => o.value === value);
+    if (!option) return;
+    const model = MODEL_OPTIONS.find((m) => m.id === option.modelId);
+    if (!model) return;
+    if (isFundedModel(model.id)) {
+      appendSystemNote(`${model.label} is funded by the operator and needs no API key`);
+      setCommandMode({ type: "none" });
+      setInputValue("");
+      setSelectedIdx(0);
+      setInputKey((prev) => prev + 1);
+      return;
+    }
+    setCommandMode({
+      type: "enter_api_key",
+      modelId: model.id,
+      modelLabel: model.label,
+      flow: "key"
+    });
+  };
+  const handleApiKeySubmit = async (value) => {
+    if (command_mode.type !== "enter_api_key") return;
+    const trimmed = value.trim();
+    if (!trimmed) {
+      appendSystemNote(
+        `API key cannot be empty. Try ${command_mode.flow === "key" ? "/key" : "/model"} again.`
+      );
+      setCommandMode({ type: "none" });
+      return;
+    }
+    if (command_mode.flow === "key") {
+      await applyApiKeyChange(command_mode.modelId, trimmed);
+      appendSystemNote(`Updated API key for ${command_mode.modelLabel}`);
+      setCommandMode({ type: "none" });
+    } else {
+      await finishModelSwitch(command_mode.modelId, trimmed);
+    }
+    setInputValue("");
+    setSelectedIdx(0);
+    setInputKey((prev) => prev + 1);
+  };
+  const finishSessionSwitch = () => {
+    setCommandMode({ type: "none" });
+    setLogoShow(false);
+    setInputValue("");
+    setSelectedIdx(0);
+    setInputKey((prev) => prev + 1);
+  };
+  const handleSessionSelect = async (value) => {
+    if (command_mode.type !== "select_session") return;
+    const option = command_mode.sessions.find((s) => s.value === value);
+    if (!option) return;
+    if (option.session_id === null || !option.data) {
+      await startNewSession();
+      setDisplays([]);
+      setTasks([]);
+      setDisplayScroll(0);
+      setTaskScroll(0);
+      appendSystemNote("Started new session");
+    } else {
+      await applySessionChoice(option.session_id, option.data);
+      setDisplays(option.data.history);
+      setTasks(user_data?.categories ?? []);
+      setDisplayScroll(0);
+      setTaskScroll(0);
+      appendSystemNote(`Loaded session ${option.session_id}`);
+    }
+    finishSessionSwitch();
+  };
+  const handlePromptSubmit = (value) => {
+    const trimmed = completeToSelectedCommand(value.trim());
+    setInputValue("");
+    setSelectedIdx(0);
+    setInputKey((prev) => prev + 1);
+    if (command_mode.type === "none" && isModelCommand(trimmed)) {
+      appendSystemNote("/model \u2014 choose a model");
+      setCommandMode({ type: "select_model" });
+      setLogoShow(false);
+      return;
+    }
+    if (command_mode.type === "none" && isKeyCommand(trimmed)) {
+      appendSystemNote("/key \u2014 choose a model to update its API key");
+      setCommandMode({ type: "select_key_model" });
+      setLogoShow(false);
+      return;
+    }
+    if (command_mode.type === "none" && isSessionCommand(trimmed)) {
+      appendSystemNote("/session \u2014 choose a session");
+      setLogoShow(false);
+      void (async () => {
+        const sessions = await loadSessionOptions();
+        const saved_count = sessions.filter((s) => s.session_id !== null).length;
+        if (saved_count === 0) {
+          appendSystemNote("No saved sessions, starting fresh");
+        }
+        setCommandMode({ type: "select_session", sessions });
+      })();
+      return;
+    }
+    if (command_mode.type === "none" && isExitCommand(trimmed)) {
+      void exitApp();
+      return;
+    }
+    if (command_mode.type === "none" && isRestartCommand(trimmed)) {
+      void (async () => {
+        await restartConnection();
+        setDisplays([]);
+        setTasks([]);
+        setDisplayScroll(0);
+        setTaskScroll(0);
+        setQuestions([]);
+        setAnswers([]);
+        setCurrentQuestion(0);
+        setQuestionnaireFreeText(false);
+        setQuestionnaireDraft("");
+        setCommandMode({ type: "none" });
+        setLogoShow(true);
+        setInputValue("");
+        setSelectedIdx(0);
+        setInputKey((prev) => prev + 1);
+      })();
+      return;
+    }
+    if (command_mode.type === "none" && isSlashCommand(trimmed)) {
+      appendSystemNote(
+        `Unknown command: ${trimmed}. Try /model, /key, /session, /exit, or /restart`
+      );
+      setLogoShow(false);
+      return;
+    }
+    if (trimmed) {
+      emitUserPrompt(trimmed);
+      setDisplays((prev) => [...prev, { role: "user", content: trimmed }]);
+    }
+    setLogoShow(false);
+  };
+  const handleQuestionnaireSelect = (value) => {
+    if (!questionnaire_active) return;
+    const q = questions[current_question];
+    const updated = [...answers, { question: q.question, answer: value }];
+    setQuestionnaireFreeText(false);
+    setQuestionnaireDraft("");
+    if (current_question + 1 >= questions.length) {
+      emitQuestionnaireAnswers(updated);
+      for (const a of updated) {
+        const entry = {
+          role: "system",
+          content: `${QUESTION_PREFIX}${a.question}
+A: ${a.answer}`
+        };
+        setDisplays((prev) => [...prev, entry]);
+        saveDisplayHistory(entry);
+      }
+      setQuestions([]);
+      setAnswers([]);
+      setCurrentQuestion(0);
+      return;
+    }
+    setAnswers(updated);
+    setCurrentQuestion((prev) => prev + 1);
+  };
+  const handleQuestionnaireOther = () => {
+    if (!questionnaire_active) return;
+    setQuestionnaireDraft("");
+    setQuestionnaireFreeText(true);
+  };
+  const handleQuestionnaireDraftSubmit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    handleQuestionnaireSelect(trimmed);
+  };
+  const command_active = command_mode.type !== "none";
+  const command_overlay = /* @__PURE__ */ jsx10(
+    CommandOverlay,
+    {
+      commandMode: command_mode,
+      screenWidth: inner_width,
+      screenHeight: inner_height,
+      onModelSelect: (val) => {
+        void handleModelSelect(val);
+      },
+      onKeyModelSelect: handleKeyModelSelect,
+      onSessionSelect: (val) => {
+        void handleSessionSelect(val);
+      },
+      onApiKeySubmit: (val) => {
+        void handleApiKeySubmit(val);
+      }
+    }
+  );
+  if (!logo_show) {
+    return /* @__PURE__ */ jsxs9(
+      FullScreenBox2,
+      {
+        flexDirection: "row",
+        display: "flex",
+        backgroundColor: BG_BLACK,
+        padding: WINDOW_PAD,
+        children: [
+          /* @__PURE__ */ jsxs9(
+            Box9,
+            {
+              width: chat_pane_width,
+              height: "100%",
+              flexDirection: "column",
+              display: "flex",
+              marginRight: chat_gap,
+              children: [
+                /* @__PURE__ */ jsx10(
+                  ChatViewport,
+                  {
+                    chatBlocks: chat_blocks,
+                    displayScroll: display_scroll,
+                    viewportRows: display_viewport_rows
+                  }
+                ),
+                suggestion_open && /* @__PURE__ */ jsx10(SuggestionBox, { commands: command_matches, selectedIndex: selected_idx }),
+                questionnaire_active && /* @__PURE__ */ jsx10(
+                  QuestionnaireBox,
+                  {
+                    question: questions[current_question],
+                    current: current_question,
+                    total: questions.length,
+                    onSelect: handleQuestionnaireSelect,
+                    freeText: questionnaire_free_text,
+                    onOther: handleQuestionnaireOther
+                  }
+                ),
+                /* @__PURE__ */ jsx10(
+                  Box9,
+                  {
+                    width: "100%",
+                    height: prompt_box_height,
+                    display: "flex",
+                    flexDirection: "column",
+                    flexShrink: 0,
+                    children: questionnaire_active && questionnaire_free_text ? /* @__PURE__ */ jsx10(
+                      PromptBox,
+                      {
+                        value: questionnaire_draft,
+                        onChange: setQuestionnaireDraft,
+                        onSubmit: handleQuestionnaireDraftSubmit,
+                        placeholder: "Type your answer\u2026 (Esc to go back)",
+                        width: chat_content_width,
+                        maxContentRows: prompt_max_rows,
+                        bordered: true
+                      },
+                      `q-other-${current_question}`
+                    ) : questionnaire_active ? /* @__PURE__ */ jsx10(Box9, { width: "100%", display: "flex", backgroundColor: BG_PANEL, paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx10(Text8, { dimColor: true, children: "Answer the question above\u2026" }) }) : command_active ? /* @__PURE__ */ jsx10(Box9, { width: "100%", display: "flex", backgroundColor: BG_PANEL, paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx10(Text8, { dimColor: true, children: "Esc to cancel\u2026" }) }) : /* @__PURE__ */ jsx10(
+                      PromptBox,
+                      {
+                        value: input_value,
+                        onChange: handleInputChange,
+                        onSubmit: handlePromptSubmit,
+                        placeholder: PROMPT_PLACEHOLDER,
+                        width: chat_content_width,
+                        maxContentRows: prompt_max_rows,
+                        bordered: true
+                      },
+                      input_key
+                    )
+                  }
+                )
+              ]
+            }
+          ),
+          show_task_bar && /* @__PURE__ */ jsx10(
+            TaskPane,
+            {
+              taskWindow: task_window,
+              taskScroll: task_scroll,
+              taskGutterWidth: task_gutter_width,
+              width: task_pane_width,
+              cwd: status_cwd,
+              modelLabel: status_model_label
+            }
+          ),
+          command_overlay
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx10(
+    LogoView,
+    {
+      innerWidth: inner_width,
+      logoPromptWidth: logo_prompt_width,
+      promptMaxRows: prompt_max_rows,
+      suggestionOpen: suggestion_open,
+      commandMatches: command_matches,
+      selectedIdx: selected_idx,
+      questionnaireActive: questionnaire_active,
+      question: questions[current_question],
+      currentQuestion: current_question,
+      totalQuestions: questions.length,
+      questionnaireFreeText: questionnaire_free_text,
+      questionnaireDraft: questionnaire_draft,
+      onQuestionnaireDraftChange: setQuestionnaireDraft,
+      onQuestionnaireSelect: handleQuestionnaireSelect,
+      onQuestionnaireOther: handleQuestionnaireOther,
+      onQuestionnaireDraftSubmit: handleQuestionnaireDraftSubmit,
+      inputKey: input_key,
+      inputValue: input_value,
+      promptPlaceholder: PROMPT_PLACEHOLDER,
+      onInputChange: handleInputChange,
+      onPromptSubmit: handlePromptSubmit,
+      commandOverlay: command_overlay
+    }
+  );
+}
+withFullScreen(/* @__PURE__ */ jsx10(App, {}), {
+  kittyKeyboard: { flags: ["disambiguateEscapeCodes"] }
+}).start();