@datalabrotterdam/nova-ai-cli 1.1.0 → 1.2.0-alpha.2

package/dist/tui-NJWDD5X7.js

@@ -0,0 +1,4810 @@
+import {
+  cliVersion
+} from "./chunk-SKAW2KXC.js";
+import {
+  TuiAcpClient,
+  createStore,
+  readWorkspaceMcpConfiguration,
+  workspaceNeedsTrust
+} from "./chunk-NHGIUEIR.js";
+
+// src/tui/index.ts
+import { createInterface } from "readline/promises";
+import { readCredentials } from "@datalabrotterdam/nova-ai-agent/core/credentials.js";
+import { listStoredSessions as listStoredSessions2 } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
+import { setWorkspaceTrusted as setWorkspaceTrusted2 } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
+
+// src/tui/ink/app.tsx
+import { Box as Box6, render, Static, Text as Text6, useBoxMetrics, useWindowSize } from "ink";
+import { useEffect, useRef, useState as useState2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { savedPermissionMode } from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
+
+// src/tui/session/session-runner.ts
+import * as acp from "@agentclientprotocol/sdk";
+import {
+  NovaAIError
+} from "@datalabrotterdam/nova-sdk";
+import { createNovaClient } from "@datalabrotterdam/nova-ai-agent/core/nova-client.js";
+import { NovaAgent } from "@datalabrotterdam/nova-ai-agent/acp/agent.js";
+import { startInProcessAgent } from "@datalabrotterdam/nova-ai-agent/client/in-process.js";
+import { replayHistory } from "@datalabrotterdam/nova-ai-agent/core/history.js";
+import { saveDefaultModel } from "@datalabrotterdam/nova-ai-agent/core/credentials.js";
+import {
+  savePermissionMode
+} from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
+import { loadStoredSession } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
+import { discoverSkills } from "@datalabrotterdam/nova-ai-agent/core/skills.js";
+import {
+  resolveModelContextWindow
+} from "@datalabrotterdam/nova-ai-agent/core/context-compaction.js";
+import {
+  chatModels,
+  resolveDefaultModel,
+  resolveModelSupportsImageInput
+} from "@datalabrotterdam/nova-ai-agent/core/model-capabilities.js";
+
+// src/tui/files/file-mentions.ts
+import { statSync } from "fs";
+import { isAbsolute, relative, resolve, sep } from "path";
+var MENTION_RE = /@(?:"([^"]+)"|'([^']+)'|([^\s]+))/g;
+var TRAILING_PUNCTUATION = /[.,;:!?\)\]\}]+$/;
+function findWorkspaceFileMentions(text, cwd) {
+  const workspaceRoot = resolve(cwd);
+  const mentions = /* @__PURE__ */ new Map();
+  for (const match of text.matchAll(MENTION_RE)) {
+    const raw = match[1] ?? match[2] ?? match[3] ?? "";
+    const candidates = [raw, raw.replace(TRAILING_PUNCTUATION, "")].filter((value, index, all) => value && all.indexOf(value) === index);
+    for (const candidate of candidates) {
+      const normalized = candidate.replace(/[\\/]/g, sep);
+      const absolutePath = resolve(workspaceRoot, normalized);
+      const relativePath = relative(workspaceRoot, absolutePath);
+      if (relativePath.startsWith(`..${sep}`) || relativePath === ".." || isAbsolute(relativePath)) continue;
+      try {
+        if (!statSync(absolutePath).isFile()) continue;
+      } catch {
+        continue;
+      }
+      mentions.set(absolutePath.toLowerCase(), {
+        absolutePath,
+        relativePath: relativePath.split(sep).join("/")
+      });
+      break;
+    }
+  }
+  return [...mentions.values()];
+}
+
+// src/tui/files/prompt-pastes.ts
+var LARGE_PASTE_LINE_THRESHOLD = 10;
+var LARGE_PASTE_CHARACTER_THRESHOLD = 1e3;
+function normalizeClipboardPaste(value) {
+  const decoded = value.replace(/\u001b\[(\d+);5u/g, (match, code) => {
+    const point = Number(code);
+    if (point >= 97 && point <= 122) return String.fromCharCode(point - 96);
+    if (point >= 65 && point <= 90) return String.fromCharCode(point - 64);
+    return match;
+  });
+  return decoded.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "    ").split("").filter((character) => character === "\n" || character.charCodeAt(0) >= 32).join("");
+}
+function isLargeClipboardPaste(text) {
+  return text.split("\n").length > LARGE_PASTE_LINE_THRESHOLD || text.length > LARGE_PASTE_CHARACTER_THRESHOLD;
+}
+var DraftPasteAttachments = class {
+  nextPasteNumber = 1;
+  pastes = /* @__PURE__ */ new Map();
+  add(text) {
+    const lineCount = text.split("\n").length;
+    const characterCount = text.length;
+    const count = lineCount > LARGE_PASTE_LINE_THRESHOLD ? `${lineCount} lines` : `${characterCount} characters`;
+    const marker = `[Pasted from clipboard #${this.nextPasteNumber++}: ${count}]`;
+    const attachment = { marker, text, lineCount, characterCount };
+    this.pastes.set(marker, attachment);
+    return attachment;
+  }
+  referencedBy(text) {
+    return [...this.pastes.values()].filter(
+      (paste) => text.includes(paste.marker)
+    );
+  }
+  clear() {
+    this.pastes.clear();
+  }
+};
+function expandPromptPastes(text, pastes) {
+  if (pastes.length === 0) return text;
+  const byMarker = new Map(pastes.map((paste) => [paste.marker, paste.text]));
+  const markers = [...byMarker.keys()].sort((left, right) => right.length - left.length).map((marker) => marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return text.replace(
+    new RegExp(markers.join("|"), "g"),
+    (marker) => byMarker.get(marker) ?? marker
+  );
+}
+
+// src/tui/session/session-runner.ts
+var nextId = 0;
+function uid() {
+  nextId += 1;
+  return `history-${nextId}`;
+}
+var RESTORED_TOOL_METADATA = {
+  read_file: { kind: "read", mutating: false },
+  list_directory: { kind: "search", mutating: false },
+  search_text: { kind: "search", mutating: false },
+  inspect_environment: { kind: "read", mutating: false },
+  load_skill: { kind: "read", mutating: false },
+  memory_read: { kind: "read", mutating: false },
+  load_memory: { kind: "read", mutating: false },
+  list_background_jobs: { kind: "read", mutating: false },
+  read_background_output: { kind: "read", mutating: false },
+  wait_for_background_jobs: { kind: "think", mutating: false },
+  ask_user: { kind: "think", mutating: false },
+  update_plan: { kind: "think", mutating: false },
+  enter_plan_mode: { kind: "switch_mode", mutating: false },
+  write_file: { kind: "edit", mutating: true },
+  edit_file: { kind: "edit", mutating: true },
+  memory_write: { kind: "edit", mutating: true },
+  save_memory: { kind: "edit", mutating: true },
+  run_command: { kind: "execute", mutating: true },
+  run_package_script: { kind: "execute", mutating: true },
+  start_background_command: { kind: "execute", mutating: true },
+  start_background_agent: { kind: "think", mutating: true },
+  kill_background_job: { kind: "execute", mutating: true },
+  release_background_job: { kind: "execute", mutating: true }
+};
+function restoreSessionMessages(messages) {
+  return replayHistory(messages).flatMap((item) => {
+    if (item.kind === "user") return [{ id: uid(), role: "user", text: item.text }];
+    if (item.kind === "agent") {
+      return [{ id: uid(), role: "assistant", text: item.text, streaming: false }];
+    }
+    if (item.name === "update_plan") return [];
+    const metadata = RESTORED_TOOL_METADATA[item.name] ?? {
+      // Persisted ACP/MCP calls do not currently retain annotations. Keep
+      // unknown calls compact without falsely labelling them as changes.
+      kind: "execute",
+      mutating: false
+    };
+    return [
+      {
+        id: uid(),
+        role: "tool",
+        call: {
+          toolCallId: uid(),
+          name: item.name,
+          args: item.args,
+          kind: metadata.kind,
+          mutating: metadata.mutating,
+          status: item.status,
+          output: item.output,
+          diff: null
+        }
+      }
+    ];
+  });
+}
+var SessionRunner = class {
+  constructor(store, credentials, cwd) {
+    this.store = store;
+    this.credentials = credentials;
+    this.loadMcpConfiguration(cwd);
+    this.skills = discoverSkills(cwd).map(
+      ({ name, description, source, path }) => ({
+        name,
+        description,
+        source,
+        path
+      })
+    );
+    this.cwd = cwd;
+    this.acpClient = new TuiAcpClient(
+      store,
+      cwd,
+      (event, job) => this.handleBackgroundLifecycle(event, job),
+      (mode) => this.applyInteractionMode(mode, `Agent switched to ${mode} mode.`)
+    );
+    this.connection = startInProcessAgent(() => this.acpClient.asAcpClient(), this.agent);
+    this.nova = this.connection.client;
+    this.initialized = this.nova.initialize({
+      protocolVersion: acp.PROTOCOL_VERSION,
+      clientCapabilities: this.acpClient.capabilities,
+      clientInfo: { name: "nova-ai-cli-tui", version: "1" }
+    });
+    this.novaClient = createNovaClient(credentials.apiKey);
+    const model = credentials.defaultModel ?? process.env.NOVA_MODEL;
+    if (!model)
+      throw new Error(
+        "No Nova model configured. Re-run authentication or set NOVA_MODEL."
+      );
+    this.model = model;
+    this.sessionId = crypto.randomUUID();
+    this.sessionReady = Promise.resolve();
+  }
+  store;
+  credentials;
+  sessionId;
+  cwd;
+  title = null;
+  model;
+  interactionMode = "agent";
+  /** The agent, served in-process over a real ACP connection (tests may stub it). */
+  agent = new NovaAgent();
+  acpClient;
+  connection;
+  nova;
+  initialized;
+  novaClient;
+  mcpServers = [];
+  mcpConfigurationFailures = [];
+  mcpStatus = {
+    configured: [],
+    connected: [],
+    failures: []
+  };
+  skills;
+  sessionReady;
+  agentSessionLoaded = false;
+  promptActive = false;
+  completedBackgroundAgentJobs = /* @__PURE__ */ new Set();
+  handoffActive = false;
+  queuedAttachments = /* @__PURE__ */ new Map();
+  editingQueuedMessageId = null;
+  imageSupportByModel = /* @__PURE__ */ new Map();
+  contextWindow = null;
+  contextWindowModel = null;
+  contextWindowRequest = 0;
+  contextUsageRequest = 0;
+  modelCheck = null;
+  resumeFrom(storedSessionId) {
+    const stored = loadStoredSession(storedSessionId);
+    if (!stored) return false;
+    const previousSessionId = this.agentSessionLoaded ? this.sessionId : null;
+    if (previousSessionId) void this.nova.cancel({ sessionId: previousSessionId });
+    this.queuedAttachments.clear();
+    this.editingQueuedMessageId = null;
+    this.sessionId = stored.sessionId;
+    this.cwd = stored.cwd;
+    this.title = stored.title;
+    this.loadMcpConfiguration(stored.cwd);
+    this.skills = discoverSkills(stored.cwd).map(
+      ({ name, description, source, path }) => ({
+        name,
+        description,
+        source,
+        path
+      })
+    );
+    const messages = restoreSessionMessages(stored.messages);
+    this.store.setState({
+      messages,
+      plan: [],
+      sessionId: this.sessionId,
+      cwd: this.cwd,
+      queuedCount: 0,
+      contextUsage: null
+    });
+    this.agentSessionLoaded = false;
+    this.sessionReady = this.initialized.then(
+      () => previousSessionId ? this.nova.closeSession({ sessionId: previousSessionId }) : {}
+    ).then(async () => {
+      this.acpClient.muteSessionUpdates = true;
+      try {
+        return await this.nova.loadSession({
+          sessionId: stored.sessionId,
+          cwd: stored.cwd,
+          mcpServers: this.mcpServers
+        });
+      } finally {
+        this.acpClient.muteSessionUpdates = false;
+      }
+    }).then((response) => {
+      this.applyMcpStatus(response._meta);
+      this.applySkillStatus(response._meta);
+      this.agentSessionLoaded = true;
+      this.applyQueue([]);
+      void this.nova.setSessionMode({ sessionId: this.sessionId, modeId: this.interactionMode }).catch(() => {
+      });
+      this.applyPermissionMode(this.sessionId);
+      void this.updateContextUsage();
+      void this.refreshContextUsage().catch(() => {
+      });
+    });
+    void this.sessionReady.catch((err) => {
+      this.acpClient.appendError(
+        err instanceof Error ? err.message : "Failed to load session."
+      );
+    });
+    return true;
+  }
+  cancel() {
+    void this.nova.cancel({ sessionId: this.sessionId }).catch(() => {
+    });
+  }
+  queuedMessages() {
+    return this.promptQueueEntries().map((prompt) => prompt.text);
+  }
+  queuedMessageEntries() {
+    return this.promptQueueEntries().map(({ id, text, kind }) => ({
+      id,
+      text,
+      kind
+    }));
+  }
+  /**
+   * The editor needs an answer right away: it comes from the local queue
+   * mirror, and the agent's response reconciles it (an entry that already
+   * started running cannot be edited any more).
+   */
+  beginQueuedMessageEdit(id) {
+    if (!this.agentSessionLoaded) return false;
+    if (!this.promptQueueEntries().some((entry) => entry.id === id)) return false;
+    this.editingQueuedMessageId = id;
+    this.syncQueueTranscript();
+    this.store.setState({ statusLine: "Editing queued message." });
+    void this.nova.queueEditBegin({ sessionId: this.sessionId, id }).then(({ updated, entries }) => {
+      this.applyQueue(entries);
+      if (!updated && this.editingQueuedMessageId === id) {
+        this.editingQueuedMessageId = null;
+        this.syncQueueTranscript("That message was already sent.");
+      }
+    }).catch(() => {
+    });
+    return true;
+  }
+  updateQueuedMessage(id, text) {
+    if (!this.agentSessionLoaded) return false;
+    if (!this.promptQueueEntries().some((entry) => entry.id === id)) return false;
+    this.applyQueue(
+      this.promptQueueEntries().map((entry) => entry.id === id ? { ...entry, text } : entry)
+    );
+    void this.nova.queueUpdate({ sessionId: this.sessionId, id, text }).then(({ entries }) => this.applyQueue(entries)).catch(() => {
+    });
+    this.syncQueueTranscript();
+    return true;
+  }
+  finishQueuedMessageEdit(id, text, images = [], pastes = []) {
+    const entry = this.promptQueueEntries().find((prompt) => prompt.id === id);
+    if (!entry) {
+      if (this.editingQueuedMessageId === id)
+        this.editingQueuedMessageId = null;
+      return false;
+    }
+    const value = text.trim();
+    if (!value) {
+      this.applyQueue(this.promptQueueEntries().filter((queued) => queued.id !== id));
+      void this.nova.queueRemove({ sessionId: this.sessionId, id }).then(({ entries }) => this.applyQueue(entries)).catch(() => {
+      });
+      this.queuedAttachments.delete(id);
+      if (this.editingQueuedMessageId === id)
+        this.editingQueuedMessageId = null;
+      this.syncQueueTranscript("Queued message removed.");
+      if (!this.store.getState().busy && !this.promptActive)
+        void this.runNextQueuedPrompt();
+    } else {
+      const attachments = this.queuedAttachments.get(id) ?? {
+        images: [],
+        pastes: []
+      };
+      this.queuedAttachments.set(id, {
+        images: mergeReferencedImages(attachments.images, images, value),
+        pastes: mergeReferencedPastes(attachments.pastes, pastes, value)
+      });
+      void this.nova.queueUpdate({ sessionId: this.sessionId, id, text: value }).then(({ entries }) => this.applyQueue(entries)).catch(() => {
+      }).then(() => this.finalizeQueuedMessageEdit(id, value));
+    }
+    return true;
+  }
+  clearQueuedMessages() {
+    if (!this.agentSessionLoaded) return 0;
+    const count = this.promptQueueEntries().length;
+    this.applyQueue([]);
+    void this.nova.queueClear({ sessionId: this.sessionId }).then(({ entries }) => this.applyQueue(entries)).catch(() => {
+    });
+    this.queuedAttachments.clear();
+    this.editingQueuedMessageId = null;
+    this.syncQueueTranscript(
+      count ? `Cleared ${count} queued message${count === 1 ? "" : "s"}.` : "Queue already empty."
+    );
+    return count;
+  }
+  steer(text) {
+    const value = text.trim();
+    if (!value) return false;
+    if (!this.store.getState().busy && !this.promptActive) {
+      void this.submit(value);
+      return false;
+    }
+    void this.enqueueQueuedPrompt(value, [], [], "steer", true);
+    return true;
+  }
+  configuredMcpServers() {
+    return [...this.mcpServers];
+  }
+  mcpSessionStatus() {
+    return {
+      configured: this.mcpStatus.configured.map((server) => ({ ...server })),
+      connected: [...this.mcpStatus.connected],
+      failures: this.mcpStatus.failures.map((failure) => ({ ...failure }))
+    };
+  }
+  skillSessionStatus() {
+    return this.skills.map((skill) => ({ ...skill }));
+  }
+  contextUsageSnapshot() {
+    return this.store.getState().contextUsage;
+  }
+  async refreshContextUsage() {
+    await this.ensureSession();
+    const sessionId = this.sessionId;
+    const model = this.model;
+    if (this.contextWindowModel !== model) {
+      const request = ++this.contextWindowRequest;
+      const contextWindow = await resolveModelContextWindow(
+        this.novaClient,
+        model
+      );
+      if (request === this.contextWindowRequest && model === this.model) {
+        this.contextWindow = contextWindow;
+        this.contextWindowModel = model;
+      }
+    }
+    if (sessionId !== this.sessionId || !this.agentSessionLoaded) {
+      return this.refreshContextUsage();
+    }
+    const usage = await this.updateContextUsage();
+    if (!usage)
+      throw new Error(
+        "Context usage is unavailable before the session is ready."
+      );
+    return usage;
+  }
+  async close() {
+    await this.acpClient.releaseAllTerminals();
+    await this.nova.closeSession({ sessionId: this.sessionId }).catch(() => {
+    });
+    await this.connection.close();
+  }
+  setModel(model) {
+    this.model = model;
+    this.contextWindow = null;
+    this.contextWindowModel = null;
+    this.contextWindowRequest++;
+    saveDefaultModel(model);
+    if (this.agentSessionLoaded) void this.updateContextUsage();
+    void this.refreshContextUsage().catch(() => {
+    });
+  }
+  /**
+   * Hands the mode to the agent's permission policy (which decides) and
+   * remembers it in the private per-project settings; bypass is never stored.
+   */
+  setPermissionMode(mode) {
+    this.store.setState({ permissionMode: mode });
+    try {
+      savePermissionMode(this.cwd, toAgentPermissionMode(mode));
+    } catch {
+    }
+    if (this.agentSessionLoaded) this.applyPermissionMode(this.sessionId);
+  }
+  applyPermissionMode(sessionId) {
+    void this.nova.setSessionConfigOption({
+      sessionId,
+      configId: "permission_mode",
+      value: toAgentPermissionMode(this.store.getState().permissionMode)
+    }).catch(() => {
+      this.acpClient.appendError("Could not change the permission mode.");
+    });
+  }
+  setInteractionMode(mode) {
+    this.applyInteractionMode(mode, `Mode: ${mode}`);
+    if (this.agentSessionLoaded) {
+      void this.nova.setSessionMode({ sessionId: this.sessionId, modeId: mode }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Starts a brand-new session: aborts any in-flight prompt, drops the
+   * queued messages and server-side conversation history, and gets a fresh
+   * sessionId — unlike a transcript-only clear, the model has no memory of
+   * what came before.
+   */
+  async startNewSession() {
+    const previousSessionId = this.agentSessionLoaded ? this.sessionId : null;
+    this.cancel();
+    this.queuedAttachments.clear();
+    this.editingQueuedMessageId = null;
+    this.title = null;
+    this.promptActive = false;
+    this.agentSessionLoaded = false;
+    this.store.setState({ contextUsage: null, plan: [] });
+    if (previousSessionId)
+      await this.nova.closeSession({ sessionId: previousSessionId });
+    this.sessionReady = this.createSession();
+    await this.sessionReady;
+    this.store.setState({
+      messages: [],
+      statusLine: null,
+      queuedCount: 0,
+      busy: false
+    });
+  }
+  /** Chat models only: embedding, speech and transcription models can't run a session. */
+  async listModels() {
+    const { data } = await this.novaClient.models.list({ limit: 100 });
+    return chatModels(data).map((model) => ({
+      id: model.id,
+      name: model.name ?? null
+    }));
+  }
+  /**
+   * Replaces a saved model that cannot chat (older logins saved the first
+   * model of the list, e.g. an embedding model) and saves the replacement.
+   * Runs once; a failed lookup keeps the model and the prompt reports errors.
+   */
+  ensureUsableModel() {
+    this.modelCheck ??= (async () => {
+      try {
+        const { data } = await this.novaClient.models.list({ limit: 100 });
+        const model = resolveDefaultModel(data, this.model);
+        if (!model || model === this.model) return;
+        const previous = this.model;
+        this.setModel(model);
+        this.store.setState({
+          statusLine: `${previous} is not a chat model; switched to ${model} (Ctrl+P to pick another).`
+        });
+      } catch {
+      }
+    })();
+    return this.modelCheck;
+  }
+  async supportsImageInput(model = this.model) {
+    const cached = this.imageSupportByModel.get(model);
+    if (cached !== void 0) return cached;
+    const supported = await resolveModelSupportsImageInput(
+      this.novaClient,
+      model
+    );
+    this.imageSupportByModel.set(model, supported);
+    return supported;
+  }
+  async compactContext() {
+    if (this.store.getState().busy || this.promptActive) {
+      throw new Error(
+        "Wait for the active request to finish before compacting context."
+      );
+    }
+    await this.ensureSession();
+    this.store.setState({ busy: true, statusLine: "Compacting context..." });
+    try {
+      const result = await this.nova.sessionCompact({
+        sessionId: this.sessionId,
+        model: this.model
+      });
+      this.store.setState({
+        statusLine: result.compacted ? `Context compacted: ${result.removedMessages} older messages summarized.` : "Context is already compact."
+      });
+      void this.updateContextUsage();
+      return result;
+    } finally {
+      this.store.setState({ busy: false });
+    }
+  }
+  async rewind(turns = 1) {
+    if (this.promptActive || this.store.getState().busy) {
+      throw new Error("Cancel the active request before rewinding.");
+    }
+    await this.ensureSession();
+    const result = await this.nova.sessionRewind({
+      sessionId: this.sessionId,
+      turns
+    });
+    const stored = loadStoredSession(this.sessionId);
+    if (!stored) throw new Error("Rewound session could not be reloaded.");
+    this.queuedAttachments.clear();
+    this.editingQueuedMessageId = null;
+    this.title = stored.title;
+    this.acpClient.resetStreaming();
+    this.store.setState({
+      messages: restoreSessionMessages(stored.messages),
+      plan: [],
+      queuedCount: 0,
+      statusLine: `Rewound ${result.removedCheckpoints.length} turn${result.removedCheckpoints.length === 1 ? "" : "s"}.`
+    });
+    void this.updateContextUsage();
+    return result;
+  }
+  async startBackgroundShell(command) {
+    await this.ensureSession();
+    const { job } = await this.nova.backgroundStartTerminal({
+      sessionId: this.sessionId,
+      command
+    });
+    return job;
+  }
+  async startBackgroundAgent(prompt) {
+    await this.ensureSession();
+    const { job } = await this.nova.backgroundStartPrompt({
+      sessionId: this.sessionId,
+      prompt: [{ type: "text", text: prompt }]
+    });
+    return job;
+  }
+  async listBackgroundJobs(kind) {
+    await this.ensureSession();
+    const { jobs } = await this.nova.backgroundList({
+      sessionId: this.sessionId
+    });
+    return kind ? jobs.filter((job) => job.kind === kind) : jobs;
+  }
+  async backgroundOutput(jobId) {
+    await this.ensureSession();
+    return this.nova.backgroundOutput({ jobId });
+  }
+  async killBackgroundJob(jobId) {
+    await this.ensureSession();
+    const { job } = await this.nova.backgroundKill({ jobId });
+    return job;
+  }
+  async releaseBackgroundJob(jobId) {
+    await this.ensureSession();
+    const { job } = await this.nova.backgroundRelease({ jobId });
+    return job;
+  }
+  async handleBackgroundLifecycle(event, job) {
+    if (job.kind !== "prompt" || event !== "completed") return;
+    this.completedBackgroundAgentJobs.add(job.jobId);
+    await this.maybeHandoffBackgroundAgentOutputs();
+  }
+  async submit(text, images = [], pastes = []) {
+    const value = text.trim();
+    if (!value) return;
+    if (this.store.getState().busy || this.promptActive) {
+      await this.enqueueQueuedPrompt(value, images, pastes, "followup");
+      return;
+    }
+    await this.executePrompt(value, images, pastes);
+  }
+  async executePrompt(value, images = [], pastes = [], preparedPrompt) {
+    this.acpClient.appendUserMessage(value);
+    this.acpClient.resetStreaming();
+    this.promptActive = true;
+    this.store.setState({ busy: true, statusLine: null });
+    let pendingToolFailure = "Tool stopped before completion.";
+    try {
+      await this.ensureSession();
+      const prompt = preparedPrompt ?? await this.preparePrompt(value, images, pastes);
+      const response = await this.nova.prompt({
+        sessionId: this.sessionId,
+        prompt,
+        _meta: {
+          "nova-ai-cli/model": this.model
+        }
+      });
+      if (response.stopReason === "cancelled") {
+        pendingToolFailure = "Canceled.";
+        this.store.setState({ statusLine: "Request canceled." });
+      } else if (response.stopReason === "max_turn_requests") {
+        this.store.setState({
+          statusLine: "Tool-use safety limit reached; the final response uses the results gathered so far."
+        });
+      }
+    } catch (err) {
+      const message = err instanceof NovaAIError ? `Nova AI request failed (status ${err.status}, requestId ${err.requestId}): ${err.message}` : err instanceof Error ? err.message : "Unknown error.";
+      pendingToolFailure = `Request failed: ${message}`;
+      this.acpClient.appendError(message);
+      this.store.setState({ statusLine: "Request failed." });
+    } finally {
+      this.promptActive = false;
+      this.acpClient.failPendingTools(pendingToolFailure);
+      this.acpClient.resetStreaming();
+      void this.updateContextUsage();
+      this.store.setState({ busy: false });
+    }
+    await this.runNextQueuedPrompt();
+  }
+  async enqueueQueuedPrompt(text, images, pastes, kind, front = false) {
+    const provisionalId = `pending-${crypto.randomUUID()}`;
+    const provisional = {
+      id: provisionalId,
+      version: 0,
+      text,
+      kind,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      editing: false
+    };
+    if (this.agentSessionLoaded) {
+      const current = this.promptQueueEntries();
+      this.applyQueue(front ? [provisional, ...current] : [...current, provisional]);
+      this.syncQueueTranscript();
+    }
+    if (!this.agentSessionLoaded) await this.ensureSession();
+    const provisionalPrompt = this.promptBlocks(
+      expandPromptPastes(text, pastes),
+      images
+    );
+    const { entry, entries } = await this.nova.queueEnqueue({
+      sessionId: this.sessionId,
+      text,
+      prompt: provisionalPrompt,
+      kind,
+      front
+    });
+    this.applyQueue(entries);
+    this.queuedAttachments.set(entry.id, {
+      images: [...images],
+      pastes: [...pastes]
+    });
+    this.syncQueueTranscript(
+      kind === "steer" ? `Steering at the next tool boundary \xB7 queued:${entries.length}` : `Queued message ${entries.length}: ${summarizeQueueMessage(text)}`
+    );
+    if (kind === "followup") {
+      const locked = await this.nova.queueEditBegin({
+        sessionId: this.sessionId,
+        id: entry.id
+      });
+      this.applyQueue(locked.entries);
+      const expectedVersion = locked.entries.find(
+        (candidate) => candidate.id === entry.id
+      )?.version;
+      const prompt = await this.preparePrompt(text, images, pastes);
+      const updated = await this.nova.queueUpdate({
+        sessionId: this.sessionId,
+        id: entry.id,
+        prompt,
+        editing: false,
+        expectedVersion
+      });
+      this.applyQueue(updated.entries);
+    }
+    if (!this.store.getState().busy && !this.promptActive) {
+      await this.runNextQueuedPrompt();
+    }
+  }
+  syncQueueTranscript(statusLine) {
+    const entries = this.promptQueueEntries();
+    this.store.setState((state) => {
+      const transcript = state.messages.filter(
+        (message) => !(message.role === "user" && message.queued)
+      );
+      const queued = entries.map((prompt) => ({
+        id: prompt.id,
+        role: "user",
+        text: prompt.text,
+        queued: prompt.kind
+      }));
+      return {
+        messages: [...transcript, ...queued],
+        queuedCount: entries.length,
+        ...statusLine !== void 0 ? { statusLine } : {}
+      };
+    });
+  }
+  async runNextQueuedPrompt() {
+    if (this.store.getState().busy || this.promptActive) return;
+    if (!this.agentSessionLoaded) return;
+    const { entry: next } = await this.nova.queueTakeNext({
+      sessionId: this.sessionId
+    });
+    if (!next) return;
+    this.applyQueue(this.promptQueueEntries().filter((entry) => entry.id !== next.id));
+    this.queuedAttachments.delete(next.id);
+    if (this.editingQueuedMessageId === next.id)
+      this.editingQueuedMessageId = null;
+    this.syncQueueTranscript();
+    await this.executePrompt(next.text, [], [], next.prompt);
+  }
+  async finalizeQueuedMessageEdit(id, text) {
+    const attachments = this.queuedAttachments.get(id) ?? {
+      images: [],
+      pastes: []
+    };
+    const prompt = await this.preparePrompt(
+      text,
+      attachments.images,
+      attachments.pastes
+    );
+    const { updated, entries } = await this.nova.queueUpdate({
+      sessionId: this.sessionId,
+      id,
+      text,
+      prompt,
+      editing: false
+    });
+    this.applyQueue(entries);
+    if (!updated) return;
+    if (this.editingQueuedMessageId === id) this.editingQueuedMessageId = null;
+    this.syncQueueTranscript("Queued message updated.");
+    if (!this.store.getState().busy && !this.promptActive) {
+      await this.runNextQueuedPrompt();
+    }
+  }
+  /** The local mirror of the agent's queue (responses and _nova/queue/changed). */
+  promptQueueEntries() {
+    if (!this.agentSessionLoaded) return [];
+    return this.acpClient.queueSnapshot;
+  }
+  applyQueue(entries) {
+    this.acpClient.queueSnapshot = entries;
+  }
+  async preparePrompt(text, images, pastes) {
+    const modelText = await this.injectFileMentions(
+      expandPromptPastes(text, pastes)
+    );
+    return this.promptBlocks(modelText, images);
+  }
+  promptBlocks(text, images) {
+    return [
+      { type: "text", text },
+      ...images.map((image) => ({
+        type: "image",
+        data: image.data,
+        mimeType: image.mimeType
+      }))
+    ];
+  }
+  async createSession() {
+    this.loadMcpConfiguration(this.cwd);
+    await this.initialized;
+    const { sessionId, _meta } = await this.nova.newSession({
+      cwd: this.cwd,
+      mcpServers: this.mcpServers
+    });
+    this.sessionId = sessionId;
+    this.applyMcpStatus(_meta);
+    this.applySkillStatus(_meta);
+    this.agentSessionLoaded = true;
+    this.applyQueue([]);
+    void this.nova.setSessionMode({ sessionId, modeId: this.interactionMode }).catch(() => {
+    });
+    this.applyPermissionMode(sessionId);
+    void this.updateContextUsage();
+    void this.refreshContextUsage().catch(() => {
+    });
+    if (this.mcpStatus.failures.length > 0) {
+      this.store.setState({
+        statusLine: `MCP: ${this.mcpStatus.failures.length} server${this.mcpStatus.failures.length === 1 ? "" : "s"} failed to connect.`
+      });
+    }
+    this.store.setState({ sessionId });
+  }
+  applyMcpStatus(meta) {
+    const value = meta?.["nova-ai-cli/mcp"];
+    if (!value || typeof value !== "object") return;
+    const record = value;
+    const configured = Array.isArray(record.configured) ? record.configured.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const item = entry;
+      return typeof item.name === "string" && typeof item.transport === "string" ? [{ name: item.name, transport: item.transport }] : [];
+    }) : [];
+    const connected = Array.isArray(record.connected) ? record.connected.filter(
+      (entry) => typeof entry === "string"
+    ) : [];
+    const failures = Array.isArray(record.failures) ? record.failures.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const item = entry;
+      return typeof item.serverName === "string" && typeof item.message === "string" ? [{ serverName: item.serverName, message: item.message }] : [];
+    }) : [];
+    this.mcpStatus = {
+      configured,
+      connected,
+      failures: [...this.mcpConfigurationFailures, ...failures]
+    };
+  }
+  loadMcpConfiguration(cwd) {
+    const configuration = readWorkspaceMcpConfiguration(cwd);
+    this.mcpServers = configuration.servers;
+    this.mcpConfigurationFailures = configuration.failures;
+    this.mcpStatus = {
+      configured: this.mcpServers.map((server) => ({
+        name: server.name,
+        transport: "type" in server ? server.type : "stdio"
+      })),
+      connected: [],
+      failures: [...this.mcpConfigurationFailures]
+    };
+  }
+  applySkillStatus(meta) {
+    const value = meta?.["nova-ai-cli/skills"];
+    if (!Array.isArray(value)) return;
+    this.skills = value.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const skill = entry;
+      return typeof skill.name === "string" && typeof skill.description === "string" && (skill.source === "user" || skill.source === "workspace") && typeof skill.path === "string" ? [
+        {
+          name: skill.name,
+          description: skill.description,
+          source: skill.source,
+          path: skill.path
+        }
+      ] : [];
+    });
+  }
+  async ensureSession() {
+    await this.ensureUsableModel();
+    await this.sessionReady;
+    if (!this.agentSessionLoaded) {
+      this.sessionReady = this.createSession();
+      await this.sessionReady;
+    }
+  }
+  applyInteractionMode(mode, statusLine) {
+    this.interactionMode = mode;
+    this.store.setState({ interactionMode: mode, statusLine });
+    if (this.agentSessionLoaded) void this.updateContextUsage();
+  }
+  /** Asks the agent for the context estimate; only the newest answer is shown. */
+  async updateContextUsage() {
+    if (!this.agentSessionLoaded) return null;
+    const request = ++this.contextUsageRequest;
+    const sessionId = this.sessionId;
+    try {
+      const usage = await this.nova.sessionContextUsage({
+        sessionId,
+        contextWindow: this.contextWindow,
+        mode: this.interactionMode
+      });
+      if (request === this.contextUsageRequest && sessionId === this.sessionId) {
+        this.store.setState({ contextUsage: usage });
+      }
+      return usage;
+    } catch {
+      return null;
+    }
+  }
+  async maybeHandoffBackgroundAgentOutputs() {
+    if (this.handoffActive || this.promptActive || this.completedBackgroundAgentJobs.size === 0)
+      return;
+    const jobs = (await this.nova.backgroundList({ sessionId: this.sessionId })).jobs.filter((job) => job.kind === "prompt");
+    if (jobs.some((job) => job.status === "running")) return;
+    this.handoffActive = true;
+    const jobIds = [...this.completedBackgroundAgentJobs];
+    this.completedBackgroundAgentJobs.clear();
+    try {
+      await this.submit(
+        `Background agent jobs have finished (${jobIds.join(", ")}). Their handoff notes precede this message; use them to continue the main task, and call read_background_output with a jobId if you need a full transcript.`
+      );
+    } finally {
+      this.handoffActive = false;
+    }
+  }
+  async injectFileMentions(text) {
+    const mentioned = findWorkspaceFileMentions(text, this.cwd);
+    if (mentioned.length === 0) return text;
+    const blocks = await Promise.all(
+      mentioned.map(async ({ absolutePath, relativePath }) => {
+        try {
+          const { content } = await this.acpClient.readTextFile({
+            sessionId: this.sessionId,
+            path: absolutePath
+          });
+          return `
+--- file: ${relativePath} ---
+${content}
+---`;
+        } catch (err) {
+          return `
+[could not read @${relativePath}: ${err instanceof Error ? err.message : "unknown error"}]`;
+        }
+      })
+    );
+    return `${text}${blocks.join("")}`;
+  }
+};
+function summarizeQueueMessage(text) {
+  const oneLine = text.replace(/\s+/g, " ");
+  return oneLine.length > 60 ? `${oneLine.slice(0, 59)}\u2026` : oneLine;
+}
+function mergeReferencedImages(existing, added, text) {
+  const byMarker = new Map(
+    [...existing, ...added].map((image) => [image.marker, image])
+  );
+  return [...byMarker.values()].filter((image) => text.includes(image.marker));
+}
+function mergeReferencedPastes(existing, added, text) {
+  const byMarker = new Map(
+    [...existing, ...added].map((paste) => [paste.marker, paste])
+  );
+  return [...byMarker.values()].filter((paste) => text.includes(paste.marker));
+}
+function toAgentPermissionMode(mode) {
+  return mode === "bypassAll" ? "bypassPermissions" : mode === "acceptEdits" ? "acceptEdits" : "default";
+}
+function fromAgentPermissionMode(mode) {
+  return mode === "bypassPermissions" ? "bypassAll" : mode === "acceptEdits" ? "acceptEdits" : "ask";
+}
+
+// src/tui/update-check.ts
+var PACKAGE_NAME = "@datalabrotterdam/nova-ai-cli";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME.replace("/", "%2F")}/latest`;
+var DEFAULT_TIMEOUT_MS = 3e3;
+var UPDATE_COMMAND = "npm install -g @datalabrotterdam/nova-ai-cli@latest";
+async function checkForUpdate(options = {}) {
+  try {
+    const currentVersion = options.currentVersion ?? readInstalledVersion();
+    if (!currentVersion) return null;
+    const response = await (options.fetchImpl ?? fetch)(REGISTRY_URL, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(options.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!response.ok) return null;
+    const payload = await response.json();
+    if (!isVersionPayload(payload)) return null;
+    if (!isNewerVersion(payload.version, currentVersion)) return null;
+    return {
+      currentVersion,
+      latestVersion: payload.version,
+      command: UPDATE_COMMAND
+    };
+  } catch {
+    return null;
+  }
+}
+function readInstalledVersion() {
+  return cliVersion();
+}
+function isNewerVersion(candidate, current) {
+  const next = parseVersion(candidate);
+  const installed = parseVersion(current);
+  if (!next || !installed) return false;
+  for (let index = 0; index < 3; index++) {
+    const difference = next.core[index] - installed.core[index];
+    if (difference !== 0) return difference > 0;
+  }
+  return comparePrerelease(next.prerelease, installed.prerelease) > 0;
+}
+function isVersionPayload(value) {
+  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
+}
+function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(
+    value
+  );
+  if (!match) return null;
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4]?.split(".") ?? []
+  };
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 || right.length === 0) {
+    if (left.length === right.length) return 0;
+    return left.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      return leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : 1;
+    }
+    if (leftPart === rightPart) continue;
+    const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : null;
+    const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : null;
+    if (leftNumber !== null && rightNumber !== null)
+      return leftNumber - rightNumber;
+    if (leftNumber !== null || rightNumber !== null)
+      return leftNumber !== null ? -1 : 1;
+    return leftPart < rightPart ? -1 : 1;
+  }
+  return 0;
+}
+
+// src/tui/ink/terminal-keyboard.ts
+var KITTY_QUERY = "\x1B[?u";
+var DEVICE_ATTRIBUTES_QUERY = "\x1B[c";
+var KITTY_REPLY = /\u001b\[\?\d+u/g;
+var DEVICE_ATTRIBUTES_REPLY = /\u001b\[\?[\d;]*c/g;
+function detectKittyKeyboard(stdin, stdout, timeoutMs = 1e3) {
+  if (!stdin.isTTY || !stdout.isTTY || !stdin.setRawMode) return Promise.resolve(false);
+  const wasRaw = stdin.isRaw ?? false;
+  stdin.setRawMode(true);
+  return new Promise((resolve2) => {
+    let received = "";
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      stdin.off("data", onData);
+      stdin.pause();
+      const supported = new RegExp(KITTY_REPLY.source).test(received);
+      const typed = received.replace(KITTY_REPLY, "").replace(DEVICE_ATTRIBUTES_REPLY, "");
+      if (typed) stdin.unshift(Buffer.from(typed, "utf8"));
+      stdin.setRawMode?.(wasRaw);
+      resolve2(supported);
+    };
+    const onData = (chunk) => {
+      received += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      if (new RegExp(DEVICE_ATTRIBUTES_REPLY.source).test(received)) finish();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    stdin.on("data", onData);
+    stdout.write(`${KITTY_QUERY}${DEVICE_ATTRIBUTES_QUERY}`);
+  });
+}
+function kittyKeyboardOverride(env = process.env) {
+  if (env.NOVA_KITTY_KEYBOARD === "1") return true;
+  if (env.NOVA_KITTY_KEYBOARD === "0") return false;
+  return null;
+}
+function isLateTerminalReply(input) {
+  return /^\u001b?\[\?[\d;]*[uc]$/.test(input);
+}
+
+// src/tui/ink/components/prompt-input.tsx
+import { Box, Text, useInput, usePaste } from "ink";
+import { useSyncExternalStore } from "react";
+
+// src/tui/ink/theme.ts
+import chalk from "chalk";
+var palette = {
+  primary: "#7dd3fc",
+  accent: "#c4b5fd",
+  success: "#86efac",
+  warning: "#fbbf24",
+  danger: "#f87171",
+  muted: "#94a3b8",
+  faint: "#64748b",
+  code: "#fcd34d",
+  diffAddBg: "#1b3a24",
+  diffRemoveBg: "#3d1f1f"
+};
+var colors = {
+  primary: chalk.hex(palette.primary),
+  accent: chalk.hex(palette.accent),
+  success: chalk.hex(palette.success),
+  warning: chalk.hex(palette.warning),
+  danger: chalk.hex(palette.danger),
+  muted: chalk.hex(palette.muted),
+  faint: chalk.hex(palette.faint),
+  code: chalk.hex(palette.code)
+};
+var ASSISTANT_MARKER = String.fromCodePoint(10022);
+var WORKING_FRAMES = [ASSISTANT_MARKER, "\u2727", "\xB7", "\u2727"];
+
+// src/tui/ink/components/prompt-input.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var MAX_SUGGESTIONS = 8;
+function PromptInput({
+  editor,
+  busy,
+  maxRows,
+  onKey
+}) {
+  useSyncExternalStore(editor.subscribe, editor.getVersion);
+  useInput((input, key) => {
+    if (onKey(input, key)) return;
+    editor.handleKey(input, key);
+  });
+  usePaste((text) => editor.paste(text));
+  const lines = editor.buffer.lineList;
+  const { row, col } = editor.buffer.cursor;
+  const visibleRows = Math.max(1, maxRows);
+  const start = Math.min(
+    Math.max(0, row - visibleRows + 1),
+    Math.max(0, lines.length - visibleRows)
+  );
+  const shown = lines.slice(start, start + visibleRows);
+  const autocomplete = editor.autocomplete;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: busy ? palette.warning : palette.primary,
+        paddingRight: 1,
+        children: [
+          start > 0 ? /* @__PURE__ */ jsx(Text, { color: palette.faint, children: `  \u2191 ${start} more line${start === 1 ? "" : "s"}` }) : null,
+          shown.map((line, index) => {
+            const lineIndex = start + index;
+            return /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: palette.primary, children: lineIndex === 0 ? "> " : "  " }) }),
+              /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx(Text, { children: lineIndex === row ? withCursor(line, col) : line || " " }) })
+            ] }, lineIndex);
+          }),
+          start + shown.length < lines.length ? /* @__PURE__ */ jsx(Text, { color: palette.faint, children: `  \u2193 ${lines.length - start - shown.length} more line${lines.length - start - shown.length === 1 ? "" : "s"}` }) : null
+        ]
+      }
+    ),
+    autocomplete ? /* @__PURE__ */ jsx(Suggestions, { view: autocomplete }) : null
+  ] });
+}
+function Suggestions({ view }) {
+  const count = view.items.length;
+  const rows = Math.min(MAX_SUGGESTIONS, count);
+  const start = Math.max(0, Math.min(view.selected - Math.floor(rows / 2), count - rows));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [
+    view.items.slice(start, start + rows).map((item, index) => {
+      const selected = start + index === view.selected;
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: selected ? palette.primary : void 0, bold: selected, children: `${selected ? "\u203A " : "  "}${item.label}` }) }),
+        item.description ? /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexShrink: 1, marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: palette.muted, wrap: "truncate-end", children: item.description }) }) : null
+      ] }, `${item.value}:${start + index}`);
+    }),
+    count > rows ? /* @__PURE__ */ jsx(Text, { color: palette.faint, children: `  ${view.selected + 1}/${count} \xB7 Tab accept \xB7 Esc close` }) : null
+  ] });
+}
+function withCursor(line, col) {
+  const before = line.slice(0, col);
+  const rest = line.slice(col);
+  const first = segmenter.segment(rest)[Symbol.iterator]().next();
+  const current = first.done ? " " : first.value.segment;
+  const after = first.done ? "" : rest.slice(current.length);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    before,
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: current }),
+    after
+  ] });
+}
+
+// src/tui/ink/components/status-line.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/tui/ink/format.ts
+import { diffLines } from "diff";
+
+// src/tui/ink/highlight.ts
+import { highlight, supportsLanguage } from "cli-highlight";
+var LANGUAGE_ALIASES = {
+  mts: "typescript",
+  cts: "typescript",
+  mjs: "javascript",
+  cjs: "javascript",
+  sh: "bash",
+  zsh: "bash",
+  yml: "yaml"
+};
+function languageFromPath(path) {
+  const ext = path?.split(/[\\/]/).pop()?.split(".").pop()?.toLowerCase();
+  return ext ? supportedLanguage(ext) : void 0;
+}
+function supportedLanguage(name) {
+  if (!name) return void 0;
+  const candidate = LANGUAGE_ALIASES[name.toLowerCase()] ?? name.toLowerCase();
+  return supportsLanguage(candidate) ? candidate : void 0;
+}
+function highlightLines(text, language) {
+  if (!text) return [];
+  const trimmed = text.endsWith("\n") ? text.slice(0, -1) : text;
+  if (!language) return trimmed.split("\n");
+  try {
+    return highlight(trimmed, { language, ignoreIllegals: true }).split("\n");
+  } catch {
+    return trimmed.split("\n");
+  }
+}
+
+// src/tui/ink/format.ts
+function formatElapsedTime(elapsedMs) {
+  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+function formatTokenCount(value) {
+  if (value >= 1e6) {
+    const millions = value / 1e6;
+    return `${millions >= 10 ? Math.round(millions) : millions.toFixed(1).replace(/\.0$/, "")}m`;
+  }
+  if (value >= 1e3) {
+    const thousands = value / 1e3;
+    return `${thousands >= 10 ? Math.round(thousands) : thousands.toFixed(1).replace(/\.0$/, "")}k`;
+  }
+  return String(value);
+}
+function formatImageSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  return `${(bytes / 1024).toFixed(bytes < 10 * 1024 ? 1 : 0)} KiB`;
+}
+function toolCallSummary(call) {
+  const candidates = [
+    call.args.path,
+    call.args.command,
+    call.args.script,
+    call.args.query,
+    call.args.url
+  ];
+  return candidates.find((value) => typeof value === "string") ?? "";
+}
+function isCompactTool(call) {
+  return !call.mutating || call.kind === "read" || call.kind === "search";
+}
+function isActivityTool(call) {
+  return isCompactTool(call) || call.name === "run_command" || call.name === "run_package_script";
+}
+function activityStatus(calls) {
+  return calls.some((call) => call.status === "failed") ? "failed" : calls.some((call) => call.status === "pending") ? "pending" : "completed";
+}
+function activitySummary(calls, pending) {
+  const counts = { files: 0, directories: 0, searches: 0, shells: 0, other: 0 };
+  for (const call of calls) {
+    if (call.name === "read_file") counts.files++;
+    else if (call.name === "list_directory") counts.directories++;
+    else if (call.name === "search_text") counts.searches++;
+    else if (call.name === "run_command" || call.name === "run_package_script")
+      counts.shells++;
+    else counts.other++;
+  }
+  const phrases = [
+    activityPhrase(counts.files, pending ? "reading" : "read", "file"),
+    activityPhrase(
+      counts.directories,
+      pending ? "listing" : "listed",
+      "directory"
+    ),
+    activityPhrase(counts.searches, pending ? "searching" : "searched", "path"),
+    activityPhrase(counts.shells, pending ? "running" : "ran", "shell command"),
+    activityPhrase(counts.other, pending ? "using" : "used", "tool")
+  ].filter((phrase) => !!phrase);
+  if (phrases.length === 0) return pending ? "Working" : "Finished";
+  return phrases.map(
+    (phrase, index) => index === 0 ? phrase[0].toUpperCase() + phrase.slice(1) : phrase
+  ).join(", ");
+}
+function activityPhrase(count, verb, noun) {
+  if (count === 0) return null;
+  const plural = noun === "directory" ? "directories" : `${noun}s`;
+  return `${verb} ${count} ${count === 1 ? noun : plural}`;
+}
+function activityDetails(calls, limit = 3) {
+  return calls.flatMap(callActivityDetails).map(sanitizeTerminalText).filter(Boolean).slice(-limit);
+}
+function callActivityDetails(call) {
+  if (call.status === "failed") {
+    const output = outputLines(call.output).slice(-3);
+    if (output.length === 0) return ["Error: Tool failed."];
+    return output.map((line, index) => index === 0 ? `Error: ${line}` : line);
+  }
+  if (call.name === "run_command" || call.name === "run_package_script") {
+    const output = outputLines(call.output);
+    if (output.length > 0) return output;
+    const command = typeof call.args.command === "string" ? call.args.command : typeof call.args.script === "string" ? `npm run ${call.args.script}` : call.name;
+    return [`$ ${command}`];
+  }
+  const path = typeof call.args.path === "string" ? call.args.path : null;
+  return [path ?? call.name];
+}
+function outputLines(output) {
+  return (output ?? "").split(/\r?\n|\r/).map((line) => sanitizeTerminalText(line.trimEnd())).filter(Boolean);
+}
+function sanitizeTerminalText(value) {
+  return value.replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "").replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "");
+}
+function changedLines(oldText, newText, path) {
+  const language = languageFromPath(path);
+  const oldHighlighted = highlightLines(oldText, language);
+  const newHighlighted = highlightLines(newText, language);
+  let oldIndex = 0;
+  let newIndex = 0;
+  const result = [];
+  for (const change of diffLines(oldText, newText)) {
+    const value = change.value.endsWith("\n") ? change.value.slice(0, -1) : change.value;
+    const plainLines = value.split("\n");
+    if (change.added) {
+      plainLines.forEach((plain, index) => {
+        const text = newHighlighted[newIndex + index] ?? plain;
+        result.push({ kind: "added", text: text.replace(/\r$/, "") });
+      });
+      newIndex += plainLines.length;
+    } else if (change.removed) {
+      plainLines.forEach((plain, index) => {
+        const text = oldHighlighted[oldIndex + index] ?? plain;
+        result.push({ kind: "removed", text: text.replace(/\r$/, "") });
+      });
+      oldIndex += plainLines.length;
+    } else {
+      oldIndex += plainLines.length;
+      newIndex += plainLines.length;
+    }
+  }
+  return result;
+}
+function formatToolCallDetails(call) {
+  const rows = [
+    `${call.name} [${call.status}]`,
+    `kind: ${call.kind}`,
+    `mutating: ${call.mutating ? "yes" : "no"}`,
+    "",
+    "Arguments:",
+    JSON.stringify(call.args, null, 2)
+  ];
+  if (call.diff) {
+    rows.push("", `Diff: ${call.diff.path}`);
+    for (const line of changedLines(
+      call.diff.oldText ?? "",
+      call.diff.newText,
+      call.diff.path
+    )) {
+      rows.push(`${line.kind === "added" ? "+" : "-"} ${line.text}`);
+    }
+  }
+  if (call.output) rows.push("", "Output:", call.output);
+  return rows.join("\n");
+}
+function formatContextUsage(usage) {
+  const rows = [
+    ["System", usage.categories.system],
+    ["Conversation", usage.categories.conversation],
+    ["Agents", usage.categories.agents],
+    ["Thinking", usage.categories.thinking],
+    ["Tools", usage.categories.tools],
+    ["Skills", usage.categories.skills],
+    ["Memory", usage.categories.memory]
+  ];
+  const lines = rows.map(([label, tokens]) => {
+    const share = usage.totalTokens ? `${(tokens / usage.totalTokens * 100).toFixed(1)}%` : "0.0%";
+    return `${label.padEnd(14)} ${tokens.toLocaleString("en-US").padStart(10)}  ${share.padStart(6)}`;
+  });
+  const total = usage.contextWindow ? `${usage.totalTokens.toLocaleString("en-US")} / ${usage.contextWindow.toLocaleString("en-US")} (${usage.percentUsed?.toFixed(1) ?? "0.0"}%)` : usage.totalTokens.toLocaleString("en-US");
+  const remaining = usage.remainingTokens === null ? null : `Remaining      ${usage.remainingTokens.toLocaleString("en-US").padStart(10)}`;
+  return [
+    "Estimated tokens in the next model request",
+    "",
+    ...lines,
+    "",
+    `Total          ${total}`,
+    ...remaining ? [remaining] : [],
+    "",
+    `Footer: ctx:${formatTokenCount(usage.totalTokens)}${usage.contextWindow ? `/${formatTokenCount(usage.contextWindow)}` : ""}`,
+    "Counts are estimates because Nova models can use different tokenizers."
+  ].join("\n");
+}
+
+// src/tui/ink/components/status-line.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function StatusLine({
+  ui,
+  model,
+  mcp
+}) {
+  const separator = /* @__PURE__ */ jsx2(Text2, { color: palette.faint, children: " | " });
+  const usage = ui.contextUsage ? `ctx:${formatTokenCount(ui.contextUsage.totalTokens)}${ui.contextUsage.contextWindow ? `/${formatTokenCount(ui.contextUsage.contextWindow)}` : ""}` : null;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    ui.updateAvailable ? /* @__PURE__ */ jsx2(Text2, { color: palette.warning, children: `Update ${ui.updateAvailable.latestVersion} available (current ${ui.updateAvailable.currentVersion}). Run: ${ui.updateAvailable.command}` }) : null,
+    ui.statusLine ? /* @__PURE__ */ jsx2(Text2, { color: palette.muted, children: ui.statusLine }) : null,
+    /* @__PURE__ */ jsxs2(Text2, { wrap: "truncate-end", children: [
+      /* @__PURE__ */ jsx2(Text2, { color: palette.muted, children: model }),
+      separator,
+      ui.interactionMode,
+      separator,
+      ui.permissionMode,
+      separator,
+      ui.busy ? /* @__PURE__ */ jsx2(Text2, { color: palette.warning, children: "working" }) : /* @__PURE__ */ jsx2(Text2, { color: palette.success, children: "ready" }),
+      usage ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        separator,
+        usage
+      ] }) : null,
+      ui.queuedCount ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        separator,
+        `queued:${ui.queuedCount}`
+      ] }) : null,
+      mcp.configured ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        separator,
+        `mcp:${mcp.connected}/${mcp.configured}`,
+        mcp.failed ? /* @__PURE__ */ jsx2(Text2, { color: palette.danger, children: ` !${mcp.failed}` }) : null
+      ] }) : null,
+      mcp.skills ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        separator,
+        `skills:${mcp.skills}`
+      ] }) : null
+    ] })
+  ] });
+}
+
+// src/tui/ink/components/transcript.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+
+// src/tui/ink/components/markdown.tsx
+import chalk2 from "chalk";
+import { Box as Box3, Text as Text3 } from "ink";
+import { marked } from "marked";
+import stringWidth from "string-width";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Markdown({ text }) {
+  const tokens = marked.lexer(text, { gfm: true });
+  return /* @__PURE__ */ jsx3(Blocks, { tokens });
+}
+function Blocks({ tokens, tight = false }) {
+  const blocks = tokens.filter((token) => token.type !== "space");
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: blocks.map((token, index) => /* @__PURE__ */ jsx3(Box3, { marginTop: index > 0 && !tight ? 1 : 0, children: /* @__PURE__ */ jsx3(Block, { token }) }, index)) });
+}
+function Block({ token }) {
+  switch (token.type) {
+    case "heading": {
+      const heading = token;
+      return /* @__PURE__ */ jsx3(Text3, { bold: true, color: palette.primary, children: inline(heading.tokens) });
+    }
+    case "paragraph":
+      return /* @__PURE__ */ jsx3(Text3, { children: inline(token.tokens) });
+    case "text": {
+      const text = token;
+      return /* @__PURE__ */ jsx3(Text3, { children: text.tokens ? inline(text.tokens) : text.text });
+    }
+    case "code":
+      return /* @__PURE__ */ jsx3(CodeBlock, { code: token });
+    case "list":
+      return /* @__PURE__ */ jsx3(List, { list: token });
+    case "blockquote":
+      return /* @__PURE__ */ jsx3(
+        Box3,
+        {
+          borderStyle: "bold",
+          borderColor: palette.accent,
+          borderTop: false,
+          borderRight: false,
+          borderBottom: false,
+          paddingLeft: 1,
+          children: /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx3(Blocks, { tokens: token.tokens }) })
+        }
+      );
+    case "hr":
+      return /* @__PURE__ */ jsx3(
+        Box3,
+        {
+          flexGrow: 1,
+          borderStyle: "single",
+          borderColor: palette.faint,
+          borderTop: true,
+          borderRight: false,
+          borderBottom: false,
+          borderLeft: false
+        }
+      );
+    case "table":
+      return /* @__PURE__ */ jsx3(Table, { table: token });
+    case "html":
+      return /* @__PURE__ */ jsx3(Text3, { children: token.text.trimEnd() });
+    default:
+      return "raw" in token ? /* @__PURE__ */ jsx3(Text3, { children: String(token.raw).trimEnd() }) : null;
+  }
+}
+function CodeBlock({ code }) {
+  const language = supportedLanguage(code.lang);
+  const lines = highlightLines(code.text, language);
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", paddingLeft: 2, children: lines.map((line, index) => /* @__PURE__ */ jsx3(Text3, { children: language ? line : chalk2.white(line) }, index)) });
+}
+function List({ list }) {
+  const start = typeof list.start === "number" ? list.start : 1;
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: list.items.map((item, index) => {
+    const bullet = list.ordered ? `${start + index}.` : "\u2022";
+    const checkbox = item.task ? item.checked ? "[x] " : "[ ] " : "";
+    const content = item.tokens.filter((token) => token.type !== "checkbox");
+    return /* @__PURE__ */ jsxs3(Box3, { marginTop: index > 0 && list.loose ? 1 : 0, children: [
+      /* @__PURE__ */ jsx3(Box3, { flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { color: palette.accent, children: `${bullet} ` }) }),
+      /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: checkbox ? /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Box3, { flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { color: item.checked ? palette.success : palette.faint, children: checkbox }) }),
+        /* @__PURE__ */ jsx3(Box3, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx3(Blocks, { tokens: content, tight: !list.loose }) })
+      ] }) : /* @__PURE__ */ jsx3(Blocks, { tokens: content, tight: !list.loose }) })
+    ] }, index);
+  }) });
+}
+function Table({ table }) {
+  const header = table.header.map((cell) => chalk2.bold(inline(cell.tokens)));
+  const rows = table.rows.map((row) => row.map((cell) => inline(cell.tokens)));
+  const widths = header.map(
+    (cell, column) => Math.max(
+      stringWidth(cell),
+      ...rows.map((row) => stringWidth(row[column] ?? ""))
+    )
+  );
+  const pad = (value, column) => {
+    const space = Math.max(0, widths[column] - stringWidth(value));
+    const align = table.align[column];
+    if (align === "right") return " ".repeat(space) + value;
+    if (align === "center") {
+      const left = Math.floor(space / 2);
+      return " ".repeat(left) + value + " ".repeat(space - left);
+    }
+    return value + " ".repeat(space);
+  };
+  const line = (cells) => cells.map((cell, column) => pad(cell, column)).join(colors.faint(" \u2502 "));
+  const separator = colors.faint(
+    widths.map((width) => "\u2500".repeat(width)).join("\u2500\u253C\u2500")
+  );
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { children: line(header) }),
+    /* @__PURE__ */ jsx3(Text3, { children: separator }),
+    rows.map((row, index) => /* @__PURE__ */ jsx3(Text3, { children: line(row) }, index))
+  ] });
+}
+function inline(tokens) {
+  if (!tokens) return "";
+  return tokens.map((token) => {
+    switch (token.type) {
+      case "strong":
+        return chalk2.bold(inline(token.tokens));
+      case "em":
+        return chalk2.italic(inline(token.tokens));
+      case "del":
+        return chalk2.strikethrough(inline(token.tokens));
+      case "codespan":
+        return colors.code(token.text);
+      case "br":
+        return "\n";
+      case "link": {
+        const link = token;
+        const label = inline(link.tokens);
+        const plain = link.text.replace(/^mailto:/, "");
+        return plain === link.href || label === link.href ? colors.primary(chalk2.underline(link.href)) : `${colors.primary(chalk2.underline(label))} ${colors.faint(`(${link.href})`)}`;
+      }
+      case "image": {
+        const image = token;
+        return colors.faint(`[image: ${image.text || image.href}]`);
+      }
+      case "text": {
+        const text = token;
+        return text.tokens ? inline(text.tokens) : text.text;
+      }
+      case "escape":
+        return token.text;
+      case "html":
+        return token.text;
+      default:
+        return "text" in token ? String(token.text) : String(token.raw ?? "");
+    }
+  }).join("");
+}
+
+// src/tui/ink/components/transcript.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var COLLAPSED_DIFF_LINES = 40;
+function TranscriptBlockView({ block, frame = 0 }) {
+  switch (block.kind) {
+    case "header":
+      return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 2, children: [
+        /* @__PURE__ */ jsx4(Text4, { color: palette.primary, children: `${ASSISTANT_MARKER} Nova AI` }),
+        /* @__PURE__ */ jsx4(Text4, { color: palette.muted, children: `Workspace: ${block.cwd}` }),
+        /* @__PURE__ */ jsx4(Text4, { color: palette.faint, children: "Ask a question, use @file, or type /help." })
+      ] });
+    case "user":
+      return /* @__PURE__ */ jsx4(Prefixed, { prefix: "> ", color: palette.primary, children: /* @__PURE__ */ jsx4(Text4, { color: palette.primary, children: block.text }) });
+    case "queued": {
+      const label = block.queued === "steer" ? "steer" : "queued";
+      return /* @__PURE__ */ jsx4(Prefixed, { prefix: `${label}> `, color: palette.warning, children: /* @__PURE__ */ jsx4(Text4, { color: palette.muted, children: block.text || "(empty; press Enter to remove from queue)" }) });
+    }
+    case "assistant": {
+      const text = block.first ? block.text.replace(/^\s+/, "") : block.text;
+      return /* @__PURE__ */ jsx4(Prefixed, { prefix: block.first ? `${ASSISTANT_MARKER} ` : "  ", color: palette.accent, children: /* @__PURE__ */ jsx4(Markdown, { text: text.trimEnd() }) });
+    }
+    case "error":
+      return /* @__PURE__ */ jsx4(Prefixed, { prefix: "! ", color: palette.danger, children: /* @__PURE__ */ jsx4(Text4, { color: palette.danger, children: block.text }) });
+    case "tool":
+      return /* @__PURE__ */ jsx4(ToolCallBlock, { call: block.call, expanded: block.expanded, frame });
+    case "activity":
+      return /* @__PURE__ */ jsx4(ActivityBlock, { calls: block.calls, frame });
+    case "background": {
+      const { job } = block;
+      const color = job.status === "failed" || job.status === "killed" ? palette.danger : job.status === "completed" ? palette.success : palette.warning;
+      return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 1, children: [
+        /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: palette.accent, children: "background" }),
+          ` ${job.kind}: ${job.title} [`,
+          /* @__PURE__ */ jsx4(Text4, { color, children: job.status }),
+          "]"
+        ] }),
+        block.expanded && job.preview ? /* @__PURE__ */ jsx4(Box4, { paddingLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { color: palette.muted, children: job.preview }) }) : null
+      ] });
+    }
+    case "plan":
+      return /* @__PURE__ */ jsx4(PlanView, { entries: block.entries, frame });
+  }
+}
+function Prefixed({
+  prefix,
+  color,
+  children
+}) {
+  return /* @__PURE__ */ jsxs4(Box4, { paddingLeft: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { flexShrink: 0, children: /* @__PURE__ */ jsx4(Text4, { color, children: prefix }) }),
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children })
+  ] });
+}
+function StatusIcon({
+  status,
+  frame = 0
+}) {
+  if (status === "pending")
+    return /* @__PURE__ */ jsx4(Text4, { color: palette.warning, children: WORKING_FRAMES[frame % WORKING_FRAMES.length] });
+  if (status === "failed") return /* @__PURE__ */ jsx4(Text4, { color: palette.danger, children: "!" });
+  return /* @__PURE__ */ jsx4(Text4, { color: palette.success, children: "\u2713" });
+}
+function ToolCallBlock({
+  call,
+  expanded,
+  frame = 0
+}) {
+  const summary = toolCallSummary(call);
+  const failure = outputLines(call.output).slice(-3);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(StatusIcon, { status: call.status, frame }),
+      " ",
+      /* @__PURE__ */ jsx4(Text4, { color: palette.accent, children: call.name }),
+      call.mutating ? /* @__PURE__ */ jsx4(Text4, { color: palette.warning, children: " (changes)" }) : null,
+      summary ? `: ${summary}` : ""
+    ] }),
+    call.status === "failed" ? /* @__PURE__ */ jsx4(Box4, { paddingLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { color: palette.danger, children: failure.length ? failure.join("\n") : "Tool failed." }) }) : call.diff ? /* @__PURE__ */ jsx4(
+      DiffView,
+      {
+        oldText: call.diff.oldText ?? "",
+        newText: call.diff.newText,
+        path: call.diff.path,
+        limit: expanded ? void 0 : COLLAPSED_DIFF_LINES
+      }
+    ) : expanded && !isCompactTool(call) ? /* @__PURE__ */ jsx4(Box4, { paddingLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { color: palette.muted, children: formatToolCallDetails(call) }) }) : null
+  ] });
+}
+function ActivityBlock({
+  calls,
+  frame = 0
+}) {
+  const status = activityStatus(calls);
+  const pending = status === "pending";
+  const details = activityDetails(calls);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(StatusIcon, { status, frame }),
+      " ",
+      /* @__PURE__ */ jsx4(Text4, { color: palette.accent, children: activitySummary(calls, pending) }),
+      pending ? /* @__PURE__ */ jsx4(Text4, { color: palette.faint, children: "\u2026" }) : null
+    ] }),
+    details.map((detail, index) => /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { flexShrink: 0, children: /* @__PURE__ */ jsx4(Text4, { color: palette.faint, children: index === 0 ? "  \u23BF  " : "     " }) }),
+      /* @__PURE__ */ jsx4(Box4, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx4(Text4, { color: palette.muted, wrap: "truncate-end", children: detail }) })
+    ] }, index))
+  ] });
+}
+function DiffView({
+  oldText,
+  newText,
+  path,
+  limit
+}) {
+  const changes = changedLines(oldText, newText, path);
+  if (changes.length === 0)
+    return /* @__PURE__ */ jsx4(Box4, { paddingLeft: 3, children: /* @__PURE__ */ jsx4(Text4, { color: palette.faint, children: "no textual changes" }) });
+  const shown = limit === void 0 ? changes : changes.slice(0, limit);
+  const hidden = changes.length - shown.length;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    shown.map((line, index) => /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { flexShrink: 0, children: /* @__PURE__ */ jsxs4(Text4, { children: [
+        "   ",
+        /* @__PURE__ */ jsx4(Text4, { color: line.kind === "added" ? palette.success : palette.danger, children: line.kind === "added" ? "+" : "-" }),
+        " "
+      ] }) }),
+      /* @__PURE__ */ jsx4(
+        Box4,
+        {
+          flexGrow: 1,
+          flexShrink: 1,
+          backgroundColor: line.kind === "added" ? palette.diffAddBg : palette.diffRemoveBg,
+          children: /* @__PURE__ */ jsx4(Text4, { children: line.text || " " })
+        }
+      )
+    ] }, index)),
+    hidden > 0 ? /* @__PURE__ */ jsx4(Box4, { paddingLeft: 5, children: /* @__PURE__ */ jsx4(Text4, { color: palette.faint, children: `\u2026 ${hidden} more changed line${hidden === 1 ? "" : "s"} (ctrl+o to expand, ctrl+t to inspect)` }) }) : null
+  ] });
+}
+function PlanView({
+  entries,
+  frame = 0
+}) {
+  const completed = entries.filter((entry) => entry.status === "completed").length;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: palette.accent, children: "Tasks" }),
+      /* @__PURE__ */ jsx4(Text4, { color: palette.muted, children: ` (${completed}/${entries.length})` })
+    ] }),
+    entries.map((entry, index) => /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { flexShrink: 0, children: entry.status === "completed" ? /* @__PURE__ */ jsx4(Text4, { color: palette.success, children: "[\u2713] " }) : entry.status === "in_progress" ? /* @__PURE__ */ jsx4(Text4, { color: palette.warning, children: `[${WORKING_FRAMES[frame % WORKING_FRAMES.length]}] ` }) : /* @__PURE__ */ jsx4(Text4, { color: palette.faint, children: "[ ] " }) }),
+      /* @__PURE__ */ jsx4(Box4, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx4(Text4, { color: entry.status === "in_progress" ? palette.primary : palette.muted, children: entry.content }) })
+    ] }, index))
+  ] });
+}
+
+// src/tui/ink/controller.ts
+import { setWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
+import { INTERACTION_MODES } from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
+
+// src/tui/commands/builtins.ts
+import { isInteractionMode } from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
+var permissionModes = ["ask", "acceptEdits", "bypassAll"];
+var builtinCommands = [
+  {
+    name: "help",
+    description: "Show available commands",
+    run(ctx) {
+      const lines = builtinCommands.map((c) => `/${c.name} \u2014 ${c.description}`);
+      ctx.print(lines.join("\n"));
+    }
+  },
+  {
+    name: "clear",
+    description: "Start a new session (clears transcript and conversation history)",
+    run(ctx) {
+      return ctx.newSession();
+    }
+  },
+  {
+    name: "compact",
+    description: "Summarize older messages to reduce the model context",
+    async run(ctx) {
+      const result = await ctx.compactContext();
+      ctx.print(
+        result.compacted ? `Compacted context: summarized ${result.removedMessages} older messages and kept ${result.keptMessages} recent messages.` : "Context is already compact; there are not enough older messages to summarize."
+      );
+    }
+  },
+  {
+    name: "rewind",
+    description: "Rewind completed conversation turns (/rewind [count])",
+    async run(ctx, args) {
+      const value = args.trim();
+      const turns = value ? Number(value) : 1;
+      if (!Number.isSafeInteger(turns) || turns < 1) {
+        ctx.print("Usage: /rewind [positive-turn-count]");
+        return;
+      }
+      const result = await ctx.rewind(turns);
+      const labels = result.removedCheckpoints.map((checkpoint) => checkpoint.userText).join(" | ");
+      ctx.print(
+        `Rewound ${result.removedCheckpoints.length} turn${result.removedCheckpoints.length === 1 ? "" : "s"}${labels ? `: ${labels}` : "."}`
+      );
+    }
+  },
+  {
+    name: "resume",
+    description: "Resume the latest session, or /resume <session-id>",
+    run(ctx, args) {
+      const sessionId = args.trim() || void 0;
+      if (!ctx.resumeSession(sessionId)) {
+        ctx.print(
+          sessionId ? `Session not found: ${sessionId}` : "No saved sessions for this workspace."
+        );
+      }
+    }
+  },
+  {
+    name: "session",
+    description: "Browse and switch sessions",
+    run(ctx) {
+      ctx.openSessionSwitcher();
+    }
+  },
+  {
+    name: "sessions",
+    description: "Alias for /session",
+    run(ctx) {
+      ctx.openSessionSwitcher();
+    }
+  },
+  {
+    name: "exit",
+    description: "Exit nova-ai-cli",
+    run(ctx) {
+      ctx.exit();
+    }
+  },
+  {
+    name: "mode",
+    description: "Switch interaction mode (/mode agent|ask|plan)",
+    run(ctx, args) {
+      const mode = args.trim();
+      if (!mode) {
+        ctx.print(`Current mode: ${ctx.getInteractionMode()}`);
+        return;
+      }
+      if (!isInteractionMode(mode)) {
+        ctx.print("Usage: /mode agent|ask|plan");
+        return;
+      }
+      ctx.setInteractionMode(mode);
+    }
+  },
+  {
+    name: "permission",
+    description: "Switch permission mode (/permission ask|acceptEdits|bypassAll)",
+    run(ctx, args) {
+      const mode = args.trim();
+      if (!mode) {
+        ctx.openPermissionPicker();
+        return;
+      }
+      if (!permissionModes.includes(mode)) {
+        ctx.print("Usage: /permission ask|acceptEdits|bypassAll");
+        return;
+      }
+      ctx.setPermissionMode(mode);
+    }
+  },
+  {
+    name: "trust",
+    description: "Trust this workspace: start the MCP servers it declares and apply its .nova-ai allow rules",
+    run(ctx) {
+      ctx.print(ctx.trustWorkspace());
+    }
+  },
+  {
+    name: "model",
+    description: "Switch the active model (/model <id>, or no args to pick interactively)",
+    run(ctx, args) {
+      const id = args.trim();
+      if (id) {
+        ctx.setModel(id);
+        ctx.print(`Switched model to ${id}.`);
+        return;
+      }
+      ctx.openModelPicker();
+    }
+  },
+  {
+    name: "tools",
+    description: "Inspect tool calls from this session",
+    run(ctx) {
+      ctx.openToolInspector();
+    }
+  },
+  {
+    name: "mcp",
+    description: "Inspect configured MCP servers",
+    run(ctx) {
+      ctx.openMcpInspector();
+    }
+  },
+  {
+    name: "skills",
+    description: "Inspect discovered user and workspace skills",
+    run(ctx) {
+      ctx.openSkillInspector();
+    }
+  },
+  {
+    name: "usage",
+    description: "Inspect estimated context usage by category",
+    run(ctx) {
+      return ctx.openUsageInspector();
+    }
+  },
+  {
+    name: "queue",
+    description: "Inspect or clear the message queue (/queue [clear])",
+    run(ctx, args) {
+      const value = args.trim();
+      if (value === "clear") {
+        ctx.clearQueuedMessages();
+        return;
+      }
+      if (value) {
+        ctx.print(
+          "Usage: /queue [clear]. Submit text directly to queue it while the model is working."
+        );
+        return;
+      }
+      const queued = ctx.queuedMessages();
+      ctx.print(
+        queued.length ? queued.map((message, index) => `${index + 1}. ${message}`).join("\n") : "Message queue is empty. Submit text while the model is working to queue it."
+      );
+    }
+  },
+  {
+    name: "steer",
+    description: "Add guidance to the active turn at its next tool boundary (/steer <message>)",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value) {
+        ctx.print("Usage: /steer <message>");
+        return;
+      }
+      ctx.steerMessage(value);
+    }
+  },
+  {
+    name: "shell",
+    description: "Manage background shell jobs (/shell run|ps|output|kill|release)",
+    run(ctx, args) {
+      return runBackgroundCommand(ctx, "terminal", args, {
+        usage: "Usage: /shell run <command> | /shell ps | /shell output <jobId> | /shell kill <jobId|all> | /shell release <jobId|all>",
+        start: (command) => ctx.startBackgroundShell(command)
+      });
+    }
+  },
+  {
+    name: "agent",
+    description: "Manage background agent jobs (/agent run|ps|output|kill|release)",
+    run(ctx, args) {
+      return runBackgroundCommand(ctx, "prompt", args, {
+        usage: "Usage: /agent run <prompt> | /agent ps | /agent output <jobId> | /agent kill <jobId|all> | /agent release <jobId|all>",
+        start: (prompt) => ctx.startBackgroundAgent(prompt)
+      });
+    }
+  }
+];
+async function runBackgroundCommand(ctx, kind, args, options) {
+  const trimmed = args.trim();
+  const [subcommand, ...rest] = splitCommand(trimmed);
+  const value = rest.join(" ").trim();
+  try {
+    switch (subcommand) {
+      case "run": {
+        if (!value) {
+          ctx.print(options.usage);
+          return;
+        }
+        const job = await options.start(value);
+        ctx.print(
+          `Started background ${kind === "terminal" ? "shell" : "agent"} job.
+${formatJob(job)}`
+        );
+        return;
+      }
+      case "":
+      case "ps":
+      case "list": {
+        const jobs = await ctx.listBackgroundJobs(kind);
+        ctx.print(
+          jobs.length ? jobs.map(formatJob).join("\n\n") : `No background ${kind === "terminal" ? "shell" : "agent"} jobs.`
+        );
+        return;
+      }
+      case "output":
+      case "out": {
+        if (!value) {
+          ctx.print(options.usage);
+          return;
+        }
+        const result = await ctx.backgroundOutput(value);
+        ctx.print(
+          `${formatJob(result.job)}
+
+${result.output}${result.truncated ? "\n[output truncated]" : ""}`
+        );
+        return;
+      }
+      case "kill":
+      case "stop": {
+        await mutateJobs(ctx, kind, value, "kill");
+        return;
+      }
+      case "release": {
+        await mutateJobs(ctx, kind, value, "release");
+        return;
+      }
+      default:
+        ctx.print(options.usage);
+    }
+  } catch (err) {
+    ctx.print(
+      err instanceof Error ? err.message : "Background command failed."
+    );
+  }
+}
+async function mutateJobs(ctx, kind, target, action) {
+  if (!target) {
+    ctx.print(
+      `${action === "kill" ? "Kill" : "Release"} requires a job id or 'all'.`
+    );
+    return;
+  }
+  const jobs = target === "all" ? await ctx.listBackgroundJobs(kind) : (await ctx.listBackgroundJobs(kind)).filter(
+    (job) => job.jobId === target
+  );
+  if (jobs.length === 0) {
+    ctx.print(
+      target === "all" ? `No background ${kind === "terminal" ? "shell" : "agent"} jobs.` : `Background job not found: ${target}`
+    );
+    return;
+  }
+  const changed = [];
+  for (const job of jobs) {
+    changed.push(
+      action === "kill" ? await ctx.killBackgroundJob(job.jobId) : await ctx.releaseBackgroundJob(job.jobId)
+    );
+  }
+  ctx.print(changed.map(formatJob).join("\n\n"));
+}
+function splitCommand(input) {
+  if (!input) return [""];
+  const firstSpace = input.search(/\s/);
+  if (firstSpace === -1) return [input];
+  return [input.slice(0, firstSpace), input.slice(firstSpace + 1)];
+}
+function formatJob(job) {
+  return [
+    `jobId: ${job.jobId}`,
+    `kind: ${job.kind}`,
+    `title: ${job.title}`,
+    `status: ${job.status}`,
+    job.terminalId ? `terminalId: ${job.terminalId}` : null,
+    job.outputPath ? `outputPath: ${job.outputPath}` : null,
+    job.exitCode !== void 0 ? `exitCode: ${job.exitCode}` : null,
+    job.signal ? `signal: ${job.signal}` : null,
+    job.error ? `error: ${job.error}` : null
+  ].filter(Boolean).join("\n");
+}
+
+// src/tui/commands/index.ts
+var COMMANDS = [...builtinCommands];
+function allCommands() {
+  return COMMANDS;
+}
+function findCommand(name) {
+  return COMMANDS.find((c) => c.name === name);
+}
+
+// src/tui/files/clipboard-image.ts
+import { execFile } from "child_process";
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var MAX_COMMAND_OUTPUT = 15 * 1024 * 1024;
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+async function readClipboardImage(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const execute = options.execute ?? executeFile;
+  if (platform === "win32") {
+    let base64;
+    try {
+      base64 = await execute("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-STA",
+        "-Command",
+        WINDOWS_CLIPBOARD_SCRIPT
+      ]);
+    } catch {
+      throw new Error("No image was found on the clipboard.");
+    }
+    return fromBase64(base64.toString("utf8"));
+  }
+  if (platform === "darwin") {
+    let base64;
+    try {
+      base64 = await execute("osascript", [
+        "-l",
+        "JavaScript",
+        "-e",
+        MACOS_CLIPBOARD_SCRIPT
+      ]);
+    } catch {
+      throw new Error("No image was found on the clipboard.");
+    }
+    return fromBase64(base64.toString("utf8"));
+  }
+  if (platform === "linux") {
+    const attempts = [
+      ["wl-paste", ["--type", "image/png"]],
+      ["xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]]
+    ];
+    for (const [command, args] of attempts) {
+      try {
+        return fromPng(await execute(command, args));
+      } catch {
+      }
+    }
+    throw new Error(
+      "No PNG image was found on the clipboard. Install wl-clipboard (Wayland) or xclip (X11)."
+    );
+  }
+  throw new Error(`Clipboard image paste is not supported on ${platform}.`);
+}
+function fromBase64(value) {
+  const normalized = value.replace(/\s+/g, "");
+  if (!normalized || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) {
+    throw new Error("The clipboard does not contain an image.");
+  }
+  return fromPng(Buffer.from(normalized, "base64"));
+}
+function fromPng(buffer) {
+  if (buffer.length === 0 || !buffer.subarray(0, 8).equals(PNG_SIGNATURE)) {
+    throw new Error("The clipboard does not contain a PNG image.");
+  }
+  if (buffer.length > MAX_IMAGE_BYTES) {
+    throw new Error(
+      `Clipboard image is too large (${formatBytes(buffer.length)}); maximum is ${formatBytes(MAX_IMAGE_BYTES)}.`
+    );
+  }
+  return {
+    data: buffer.toString("base64"),
+    mimeType: "image/png",
+    byteLength: buffer.length
+  };
+}
+function executeFile(command, args) {
+  return new Promise((resolve2, reject) => {
+    execFile(
+      command,
+      args,
+      {
+        encoding: "buffer",
+        maxBuffer: MAX_COMMAND_OUTPUT,
+        timeout: 8e3,
+        windowsHide: true
+      },
+      (error, stdout) => {
+        if (error) reject(error);
+        else resolve2(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
+      }
+    );
+  });
+}
+function formatBytes(bytes) {
+  return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
+}
+var WINDOWS_CLIPBOARD_SCRIPT = [
+  "$image = Get-Clipboard -Format Image -ErrorAction Stop",
+  "if ($null -eq $image) { throw 'Clipboard does not contain an image.' }",
+  "$stream = [System.IO.MemoryStream]::new()",
+  "try {",
+  "  $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)",
+  "  [Console]::Out.Write([Convert]::ToBase64String($stream.ToArray()))",
+  "} finally {",
+  "  $stream.Dispose()",
+  "  $image.Dispose()",
+  "}"
+].join("\n");
+var MACOS_CLIPBOARD_SCRIPT = `
+ObjC.import('AppKit');
+const pasteboard = $.NSPasteboard.generalPasteboard;
+let data = pasteboard.dataForType('public.png');
+if (!data) data = pasteboard.dataForType('public.tiff');
+if (!data) throw new Error('Clipboard does not contain an image.');
+const image = $.NSImage.alloc.initWithData(data);
+const bitmap = $.NSBitmapImageRep.imageRepWithData(image.TIFFRepresentation);
+const png = bitmap.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $.NSDictionary.dictionary);
+console.log(ObjC.unwrap(png.base64EncodedStringWithOptions(0)));
+`;
+
+// src/tui/files/find-fd.ts
+import { spawnSync } from "child_process";
+var FD_CANDIDATES = ["fd", "fdfind"];
+var cachedPath;
+function resolveFdPath(run = (command, args) => spawnSync(command, args, { stdio: "ignore" })) {
+  if (cachedPath !== void 0) return cachedPath;
+  for (const candidate of FD_CANDIDATES) {
+    const result = run(candidate, ["--version"]);
+    if (!result.error && result.status === 0) {
+      cachedPath = candidate;
+      return cachedPath;
+    }
+  }
+  cachedPath = null;
+  return cachedPath;
+}
+
+// src/tui/files/list-workspace-files.ts
+import { readdirSync } from "fs";
+import { join, relative as relative2, sep as sep2 } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".nova-ai", "out", "coverage", ".next", ".turbo"]);
+function listWorkspaceFiles(cwd, max = 2e3) {
+  const results = [];
+  const stack = [cwd];
+  while (stack.length > 0 && results.length < max) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (results.length >= max) break;
+      if (entry.isSymbolicLink()) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        stack.push(full);
+      } else if (entry.isFile()) {
+        results.push(relative2(cwd, full).split(sep2).join("/"));
+      }
+    }
+  }
+  return results;
+}
+
+// src/tui/files/prompt-images.ts
+var DraftImageAttachments = class {
+  nextImageNumber = 1;
+  images = /* @__PURE__ */ new Map();
+  add(image) {
+    const marker = `[#Image${this.nextImageNumber++}]`;
+    const attachment = { ...image, marker };
+    this.images.set(marker, attachment);
+    return attachment;
+  }
+  referencedBy(text) {
+    return [...this.images.values()].filter(
+      (image) => text.includes(image.marker)
+    );
+  }
+  clear() {
+    this.images.clear();
+  }
+};
+
+// src/tui/files/workspace-autocomplete.ts
+import { spawn } from "child_process";
+import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir } from "os";
+import { basename, dirname, join as join2 } from "path";
+var PATH_DELIMITERS = /* @__PURE__ */ new Set([" ", "	", '"', "'", "="]);
+var MAX_SUGGESTIONS2 = 20;
+var WorkspaceAutocompleteProvider = class {
+  constructor(commands, cwd, files, fdPath = null) {
+    this.commands = commands;
+    this.cwd = cwd;
+    this.files = files;
+    this.fdPath = fdPath;
+  }
+  commands;
+  cwd;
+  files;
+  fdPath;
+  triggerCharacters = ["@", "/"];
+  async getSuggestions(lines, cursorLine, cursorCol, options) {
+    const before = (lines[cursorLine] ?? "").slice(0, cursorCol);
+    const mention = extractMentionPrefix(before);
+    if (mention) return this.mentionSuggestions(mention, options.signal);
+    if (cursorLine === 0 && before.startsWith("/") && !/\s/.test(before)) {
+      const items2 = filterCommands(this.commands, before.slice(1));
+      return items2.length ? { items: items2, prefix: before } : null;
+    }
+    if (!options.force) return null;
+    const pathPrefix = extractPathPrefix(before);
+    if (pathPrefix === null) return null;
+    const items = this.pathSuggestions(pathPrefix);
+    return items.length ? { items, prefix: pathPrefix } : null;
+  }
+  shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+    const before = (lines[cursorLine] ?? "").slice(0, cursorCol).trim();
+    return !(before.startsWith("/") && !before.includes(" "));
+  }
+  applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+    const line = lines[cursorLine] ?? "";
+    const beforePrefix = line.slice(0, cursorCol - prefix.length);
+    let after = line.slice(cursorCol);
+    if (prefix.includes('"') && item.value.endsWith('"') && after.startsWith('"'))
+      after = after.slice(1);
+    const isCommand = cursorLine === 0 && prefix.startsWith("/") && beforePrefix.trim() === "";
+    const isDirectory = item.value.replace(/"$/, "").endsWith("/");
+    let inserted;
+    let cursorOffset;
+    if (isCommand) {
+      inserted = `/${item.value} `;
+      cursorOffset = inserted.length;
+    } else {
+      const suffix = isDirectory || !prefix.startsWith("@") ? "" : " ";
+      inserted = `${item.value}${suffix}`;
+      cursorOffset = isDirectory && item.value.endsWith('"') ? item.value.length - 1 : inserted.length;
+    }
+    const next = [...lines];
+    next[cursorLine] = `${beforePrefix}${inserted}${after}`;
+    return {
+      lines: next,
+      cursorLine,
+      cursorCol: beforePrefix.length + cursorOffset
+    };
+  }
+  async mentionSuggestions(prefix, signal) {
+    if (signal.aborted) return null;
+    const quoted = prefix.startsWith('@"');
+    const query = prefix.slice(quoted ? 2 : 1).replace(/"$/, "").replace(/\\/g, "/");
+    if (this.fdPath) {
+      const entries = await walkWithFd(this.cwd, this.fdPath, query, signal);
+      if (signal.aborted) return null;
+      const items2 = entries.map((entry) => ({
+        ...entry,
+        score: query ? scorePath(entry.path, query.toLowerCase()) : 1
+      })).filter((entry) => entry.score > 0).sort((left, right) => right.score - left.score).slice(0, MAX_SUGGESTIONS2).map((entry) => mentionItem(entry.path, entry.isDirectory, quoted));
+      if (items2.length) return { items: items2, prefix };
+    }
+    const lowered = query.toLowerCase();
+    const items = this.files.map((path) => ({ path, score: scorePath(path, lowered) })).filter((entry) => entry.score > 0).sort(
+      (left, right) => right.score - left.score || left.path.localeCompare(right.path)
+    ).slice(0, MAX_SUGGESTIONS2).map(({ path }) => mentionItem(path, false, quoted));
+    return items.length ? { items, prefix } : null;
+  }
+  pathSuggestions(prefix) {
+    const quoted = prefix.startsWith('"');
+    const raw = quoted ? prefix.slice(1) : prefix;
+    const expanded = raw === "~" || raw.startsWith("~/") ? join2(homedir(), raw.slice(1)) : raw;
+    const absolute = expanded.startsWith("/") || /^[A-Za-z]:[\\/]/.test(expanded);
+    const separator = Math.max(raw.lastIndexOf("/"), raw.lastIndexOf("\\"));
+    const listsDirectory = raw === "" || raw === "~" || separator === raw.length - 1;
+    const directoryPart = listsDirectory ? expanded : dirname(expanded);
+    const namePrefix = listsDirectory ? "" : basename(expanded);
+    const displayDirectory = raw === "~" ? "~/" : separator >= 0 ? raw.slice(0, separator + 1) : "";
+    const searchDirectory = absolute ? directoryPart : join2(this.cwd, directoryPart);
+    let entries;
+    try {
+      entries = readdirSync2(searchDirectory, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter(
+      (entry) => entry.name.toLowerCase().startsWith(namePrefix.toLowerCase())
+    ).map((entry) => {
+      let isDirectory = entry.isDirectory();
+      if (!isDirectory && entry.isSymbolicLink()) {
+        try {
+          isDirectory = statSync2(
+            join2(searchDirectory, entry.name)
+          ).isDirectory();
+        } catch {
+        }
+      }
+      const path = `${displayDirectory}${entry.name}${isDirectory ? "/" : ""}`;
+      return {
+        value: quoted || path.includes(" ") ? `"${path}"` : path,
+        label: `${entry.name}${isDirectory ? "/" : ""}`,
+        isDirectory
+      };
+    }).sort(
+      (left, right) => Number(right.isDirectory) - Number(left.isDirectory) || left.label.localeCompare(right.label)
+    ).slice(0, 50).map(({ value, label }) => ({ value, label }));
+  }
+};
+function mentionItem(path, isDirectory, quoted) {
+  const plain = path.replace(/\/$/, "");
+  const completion = isDirectory ? `${plain}/` : plain;
+  return {
+    value: quoted || completion.includes(" ") ? `@"${completion}"` : `@${completion}`,
+    label: `${basename(plain)}${isDirectory ? "/" : ""}`,
+    description: plain
+  };
+}
+function filterCommands(commands, query) {
+  const lowered = query.toLowerCase();
+  const rank = (name) => {
+    const value = name.toLowerCase();
+    if (!lowered) return 1;
+    if (value.startsWith(lowered)) return 3;
+    if (value.includes(lowered)) return 2;
+    let cursor = 0;
+    for (const char of lowered) {
+      cursor = value.indexOf(char, cursor);
+      if (cursor === -1) return 0;
+      cursor++;
+    }
+    return 1;
+  };
+  return commands.map((command) => ({ command, score: rank(command.name) })).filter((entry) => entry.score > 0).sort((left, right) => right.score - left.score).map(({ command }) => ({
+    value: command.name,
+    label: command.name,
+    ...command.description ? { description: command.description } : {}
+  }));
+}
+function extractMentionPrefix(text) {
+  return /(?:^|\s)(@(?:"[^"]*|[^\s]*))$/.exec(text)?.[1] ?? null;
+}
+function extractPathPrefix(text) {
+  let quoteStart = -1;
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] === '"') quoteStart = quoteStart === -1 ? index : -1;
+  }
+  if (quoteStart >= 0) return text.slice(quoteStart);
+  for (let index = text.length - 1; index >= 0; index--) {
+    if (PATH_DELIMITERS.has(text[index])) return text.slice(index + 1);
+  }
+  return text;
+}
+function scorePath(path, query) {
+  if (!query) return 1;
+  const normalized = path.toLowerCase().replace(/\/$/, "");
+  const name = basename(normalized);
+  if (name === query) return 100;
+  if (name.startsWith(query)) return 80;
+  if (name.includes(query)) return 60;
+  if (normalized.includes(query)) return 40;
+  let cursor = 0;
+  for (const char of query) {
+    cursor = normalized.indexOf(char, cursor);
+    if (cursor === -1) return 0;
+    cursor++;
+  }
+  return 20;
+}
+function fdQuery(query) {
+  if (!query.includes("/")) return query;
+  const trailing = query.endsWith("/");
+  const segments = query.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean).map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  if (segments.length === 0) return query;
+  return `${segments.join("[\\\\/]")}${trailing ? "[\\\\/]" : ""}`;
+}
+function walkWithFd(cwd, fdPath, query, signal) {
+  const args = [
+    "--base-directory",
+    cwd,
+    "--max-results",
+    "100",
+    "--type",
+    "f",
+    "--type",
+    "d",
+    "--follow",
+    "--hidden",
+    "--exclude",
+    ".git"
+  ];
+  if (query.includes("/")) args.push("--full-path");
+  if (query) args.push(fdQuery(query));
+  return new Promise((resolve2) => {
+    if (signal.aborted) {
+      resolve2([]);
+      return;
+    }
+    const child = spawn(fdPath, args, { stdio: ["ignore", "pipe", "ignore"] });
+    let stdout = "";
+    let settled = false;
+    const finish = (entries) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve2(entries);
+    };
+    const onAbort = () => {
+      if (child.exitCode === null) child.kill("SIGKILL");
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.on("error", () => finish([]));
+    child.on("close", (code) => {
+      if (signal.aborted || code !== 0) {
+        finish([]);
+        return;
+      }
+      finish(
+        stdout.split("\n").filter(Boolean).map((line) => line.replace(/\\/g, "/")).filter((line) => !/(^|\/)\.git(\/|$)/.test(line)).map((line) => ({ path: line, isDirectory: line.endsWith("/") }))
+      );
+    });
+  });
+}
+
+// src/tui/session/session-picker.ts
+import { listStoredSessions } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
+function listSessionsForCwd(cwd) {
+  return listStoredSessions(cwd);
+}
+function listSessionPickerItems(cwd, now = Date.now()) {
+  return listSessionsForCwd(cwd).map(
+    (session) => toSessionPickerItem(session, now)
+  );
+}
+function toSessionPickerItem(session, now = Date.now()) {
+  const age = formatTimeAgo(session.updatedAt, now);
+  const title = oneLineTitle(session.title);
+  return {
+    value: session.sessionId,
+    label: age,
+    description: title,
+    columns: {
+      leading: age,
+      main: title,
+      trailing: formatDateTime(session.updatedAt)
+    }
+  };
+}
+function formatTimeAgo(updatedAt, now = Date.now()) {
+  const timestamp = Date.parse(updatedAt);
+  if (!Number.isFinite(timestamp)) return "unknown";
+  const seconds = Math.max(0, Math.floor((now - timestamp) / 1e3));
+  if (seconds < 5) return "just now";
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 14) return `${days}d ago`;
+  const weeks = Math.floor(days / 7);
+  if (days < 60) return `${weeks}w ago`;
+  const months = Math.floor(days / 30);
+  if (days < 730) return `${months}mo ago`;
+  return `${Math.floor(days / 365)}y ago`;
+}
+function oneLineTitle(title) {
+  return title?.replace(/\s+/g, " ").trim() || "(untitled)";
+}
+function formatDateTime(updatedAt) {
+  const timestamp = Date.parse(updatedAt);
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : "unknown";
+}
+
+// src/tui/ink/dialogs/state.ts
+import { OTHER_OPTION_ID } from "@datalabrotterdam/nova-ai-agent/core/user-questions.js";
+
+// src/tui/ink/editor/buffer.ts
+var segmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function boundaries(text) {
+  const result = [0];
+  for (const { index, segment } of segmenter2.segment(text)) {
+    result.push(index + segment.length);
+  }
+  return result;
+}
+function previousBoundary(text, offset) {
+  let previous = 0;
+  for (const boundary of boundaries(text)) {
+    if (boundary >= offset) return previous;
+    previous = boundary;
+  }
+  return previous;
+}
+function nextBoundary(text, offset) {
+  for (const boundary of boundaries(text)) {
+    if (boundary > offset) return boundary;
+  }
+  return text.length;
+}
+var WORD = /[\p{L}\p{N}_]/u;
+var TextBuffer = class {
+  lines = [""];
+  row = 0;
+  col = 0;
+  /** Column the cursor tries to keep while moving up and down. */
+  preferredCol = null;
+  get text() {
+    return this.lines.join("\n");
+  }
+  get cursor() {
+    return { row: this.row, col: this.col };
+  }
+  get lineList() {
+    return this.lines;
+  }
+  get isEmpty() {
+    return this.lines.length === 1 && this.lines[0] === "";
+  }
+  setText(text) {
+    this.lines = text.split("\n");
+    this.row = this.lines.length - 1;
+    this.col = this.lines[this.row].length;
+    this.preferredCol = null;
+  }
+  /** Replaces the lines and cursor at once (used by autocomplete). */
+  setState(lines, row, col) {
+    this.lines = lines.length ? [...lines] : [""];
+    this.row = Math.max(0, Math.min(row, this.lines.length - 1));
+    this.col = Math.max(0, Math.min(col, this.lines[this.row].length));
+    this.preferredCol = null;
+  }
+  insert(text) {
+    if (!text) return;
+    const line = this.lines[this.row];
+    const before = line.slice(0, this.col);
+    const after = line.slice(this.col);
+    const parts = text.split("\n");
+    if (parts.length === 1) {
+      this.lines[this.row] = before + text + after;
+      this.col += text.length;
+    } else {
+      const last = parts.at(-1);
+      const inserted = [before + parts[0], ...parts.slice(1, -1), last + after];
+      this.lines.splice(this.row, 1, ...inserted);
+      this.row += parts.length - 1;
+      this.col = last.length;
+    }
+    this.preferredCol = null;
+  }
+  newline() {
+    this.insert("\n");
+  }
+  backspace() {
+    if (this.col > 0) {
+      const line = this.lines[this.row];
+      const start = previousBoundary(line, this.col);
+      this.lines[this.row] = line.slice(0, start) + line.slice(this.col);
+      this.col = start;
+    } else if (this.row > 0) {
+      const previous = this.lines[this.row - 1];
+      this.lines.splice(this.row - 1, 2, previous + this.lines[this.row]);
+      this.row--;
+      this.col = previous.length;
+    } else {
+      return false;
+    }
+    this.preferredCol = null;
+    return true;
+  }
+  deleteForward() {
+    const line = this.lines[this.row];
+    if (this.col < line.length) {
+      const end = nextBoundary(line, this.col);
+      this.lines[this.row] = line.slice(0, this.col) + line.slice(end);
+    } else if (this.row < this.lines.length - 1) {
+      this.lines.splice(this.row, 2, line + this.lines[this.row + 1]);
+    } else {
+      return false;
+    }
+    this.preferredCol = null;
+    return true;
+  }
+  deleteWordBackward() {
+    if (this.col === 0) return this.backspace();
+    const line = this.lines[this.row];
+    const start = this.wordStartBefore(line, this.col);
+    this.lines[this.row] = line.slice(0, start) + line.slice(this.col);
+    this.col = start;
+    this.preferredCol = null;
+    return true;
+  }
+  deleteToLineStart() {
+    if (this.col === 0) return this.backspace();
+    const line = this.lines[this.row];
+    this.lines[this.row] = line.slice(this.col);
+    this.col = 0;
+    this.preferredCol = null;
+    return true;
+  }
+  deleteToLineEnd() {
+    const line = this.lines[this.row];
+    if (this.col === line.length) return this.deleteForward();
+    this.lines[this.row] = line.slice(0, this.col);
+    this.preferredCol = null;
+    return true;
+  }
+  left() {
+    if (this.col > 0) {
+      this.col = previousBoundary(this.lines[this.row], this.col);
+    } else if (this.row > 0) {
+      this.row--;
+      this.col = this.lines[this.row].length;
+    }
+    this.preferredCol = null;
+  }
+  right() {
+    const line = this.lines[this.row];
+    if (this.col < line.length) {
+      this.col = nextBoundary(line, this.col);
+    } else if (this.row < this.lines.length - 1) {
+      this.row++;
+      this.col = 0;
+    }
+    this.preferredCol = null;
+  }
+  wordLeft() {
+    if (this.col === 0) {
+      this.left();
+      return;
+    }
+    this.col = this.wordStartBefore(this.lines[this.row], this.col);
+    this.preferredCol = null;
+  }
+  wordRight() {
+    const line = this.lines[this.row];
+    if (this.col === line.length) {
+      this.right();
+      return;
+    }
+    let offset = this.col;
+    while (offset < line.length && !WORD.test(line[offset])) offset++;
+    while (offset < line.length && WORD.test(line[offset])) offset++;
+    this.col = offset;
+    this.preferredCol = null;
+  }
+  /** Moves up one line; false when already on the first line. */
+  up() {
+    if (this.row === 0) return false;
+    this.moveVertically(-1);
+    return true;
+  }
+  /** Moves down one line; false when already on the last line. */
+  down() {
+    if (this.row === this.lines.length - 1) return false;
+    this.moveVertically(1);
+    return true;
+  }
+  lineStart() {
+    this.col = 0;
+    this.preferredCol = null;
+  }
+  lineEnd() {
+    this.col = this.lines[this.row].length;
+    this.preferredCol = null;
+  }
+  moveVertically(delta) {
+    this.preferredCol ??= this.col;
+    this.row += delta;
+    const line = this.lines[this.row];
+    this.col = snapToBoundary(line, Math.min(this.preferredCol, line.length));
+  }
+  wordStartBefore(line, offset) {
+    let start = offset;
+    while (start > 0 && !WORD.test(line[start - 1])) start--;
+    while (start > 0 && WORD.test(line[start - 1])) start--;
+    return start;
+  }
+};
+function snapToBoundary(text, offset) {
+  let result = 0;
+  for (const boundary of boundaries(text)) {
+    if (boundary > offset) break;
+    result = boundary;
+  }
+  return result;
+}
+
+// src/tui/ink/dialogs/state.ts
+var isCancel = (input, key) => !!key.escape || !!key.ctrl && input === "c";
+function windowStart(selected, count, rows) {
+  const maximum = Math.max(0, count - rows);
+  return Math.max(0, Math.min(selected - Math.floor(rows / 2), maximum));
+}
+var SelectionState = class {
+  constructor(items, onSelect, onCancel) {
+    this.items = items;
+    this.onSelect = onSelect;
+    this.onCancel = onCancel;
+  }
+  items;
+  onSelect;
+  onCancel;
+  selected = 0;
+  handleKey(input, key, pageRows) {
+    const count = this.items.length;
+    if (isCancel(input, key)) {
+      this.onCancel();
+      return "closed";
+    }
+    if (key.return) {
+      const item = this.items[this.selected];
+      if (!item) return "ignored";
+      this.onSelect(item);
+      return "closed";
+    }
+    if (count === 0) return "ignored";
+    let next = this.selected;
+    if (key.upArrow) next = this.selected === 0 ? count - 1 : this.selected - 1;
+    else if (key.downArrow) next = this.selected === count - 1 ? 0 : this.selected + 1;
+    else if (key.pageUp) next = Math.max(0, this.selected - pageRows);
+    else if (key.pageDown) next = Math.min(count - 1, this.selected + pageRows);
+    else if (key.home) next = 0;
+    else if (key.end) next = count - 1;
+    else return "ignored";
+    if (next === this.selected) return "ignored";
+    this.selected = next;
+    return "changed";
+  }
+};
+var ScrollState = class {
+  constructor(onClose) {
+    this.onClose = onClose;
+  }
+  onClose;
+  offset = 0;
+  handleKey(input, key, pageRows) {
+    if (isCancel(input, key) || key.return && !key.meta) {
+      this.onClose();
+      return "closed";
+    }
+    const page = Math.max(1, pageRows);
+    const before = this.offset;
+    if (key.upArrow) this.offset = Math.max(0, this.offset - 1);
+    else if (key.downArrow) this.offset += 1;
+    else if (key.pageUp) this.offset = Math.max(0, this.offset - page);
+    else if (key.pageDown || input === " ") this.offset += page;
+    else if (key.home) this.offset = 0;
+    else if (key.end) this.offset = Number.MAX_SAFE_INTEGER;
+    else return "ignored";
+    return this.offset === before ? "ignored" : "changed";
+  }
+  /** Clamps the offset to the content; call before rendering. */
+  clamp(totalRows, visibleRows) {
+    this.offset = Math.max(0, Math.min(this.offset, totalRows - visibleRows));
+    return this.offset;
+  }
+};
+var ToolInspectorState = class {
+  constructor(getCalls, onClose) {
+    this.getCalls = getCalls;
+    this.onClose = onClose;
+  }
+  getCalls;
+  onClose;
+  selected = 0;
+  expanded = false;
+  detailOffset = 0;
+  calls() {
+    const calls = this.getCalls();
+    this.selected = Math.max(0, Math.min(this.selected, calls.length - 1));
+    return calls;
+  }
+  handleKey(input, key, pageRows) {
+    if (isCancel(input, key)) {
+      this.onClose();
+      return "closed";
+    }
+    const calls = this.calls();
+    if (calls.length === 0) return "ignored";
+    const before = `${this.selected}:${this.expanded}:${this.detailOffset}`;
+    if (key.upArrow) this.select(this.selected === 0 ? calls.length - 1 : this.selected - 1);
+    else if (key.downArrow)
+      this.select(this.selected === calls.length - 1 ? 0 : this.selected + 1);
+    else if (key.leftArrow) this.setExpanded(false);
+    else if (key.rightArrow) this.setExpanded(true);
+    else if (key.return || input === " ") this.setExpanded(!this.expanded);
+    else if (key.pageUp) {
+      if (this.expanded) this.detailOffset = Math.max(0, this.detailOffset - pageRows);
+      else this.select(Math.max(0, this.selected - pageRows));
+    } else if (key.pageDown) {
+      if (this.expanded) this.detailOffset += pageRows;
+      else this.select(Math.min(calls.length - 1, this.selected + pageRows));
+    } else if (key.home) {
+      if (this.expanded) this.detailOffset = 0;
+      else this.select(0);
+    } else if (key.end) {
+      if (this.expanded) this.detailOffset = Number.MAX_SAFE_INTEGER;
+      else this.select(calls.length - 1);
+    } else return "ignored";
+    return before === `${this.selected}:${this.expanded}:${this.detailOffset}` ? "ignored" : "changed";
+  }
+  select(index) {
+    if (index === this.selected) return;
+    this.selected = index;
+    this.detailOffset = 0;
+  }
+  setExpanded(expanded) {
+    if (expanded === this.expanded) return;
+    this.expanded = expanded;
+    this.detailOffset = 0;
+  }
+};
+var QuestionState = class {
+  constructor(pending, onClose) {
+    this.pending = pending;
+    this.onClose = onClose;
+  }
+  pending;
+  onClose;
+  questionIndex = 0;
+  selected = 0;
+  customMode = false;
+  validationMessage = "";
+  customInput = new TextBuffer();
+  selections = /* @__PURE__ */ new Map();
+  customAnswers = /* @__PURE__ */ new Map();
+  get question() {
+    return this.pending.request.questions[this.questionIndex];
+  }
+  isSelected(questionId, optionId) {
+    return this.selection(questionId).has(optionId);
+  }
+  customAnswer(questionId) {
+    return this.customAnswers.get(questionId);
+  }
+  handleKey(input, key) {
+    if (this.customMode) return this.handleCustomKey(input, key);
+    const question = this.question;
+    if (!question) return "ignored";
+    const count = question.options.length + 1;
+    if (isCancel(input, key)) {
+      this.pending.resolve({ action: "cancel", answers: [] });
+      this.onClose();
+      return "closed";
+    }
+    if (key.upArrow) return this.moveTo((this.selected - 1 + count) % count);
+    if (key.downArrow) return this.moveTo((this.selected + 1) % count);
+    if (key.home) return this.moveTo(0);
+    if (key.end) return this.moveTo(count - 1);
+    if (input === " " && question.type === "multiple") return this.toggleCurrent();
+    if (key.return) return this.submitCurrent();
+    return "ignored";
+  }
+  handleCustomKey(input, key) {
+    if (key.escape) {
+      this.customMode = false;
+      this.validationMessage = "";
+      return "changed";
+    }
+    if (key.ctrl && input === "c") {
+      this.pending.resolve({ action: "cancel", answers: [] });
+      this.onClose();
+      return "closed";
+    }
+    if (key.return) return this.submitCustom(this.customInput.text);
+    if (key.backspace) this.customInput.backspace();
+    else if (key.delete) this.customInput.deleteForward();
+    else if (key.leftArrow) this.customInput.left();
+    else if (key.rightArrow) this.customInput.right();
+    else if (key.home || key.ctrl && input === "a") this.customInput.lineStart();
+    else if (key.end || key.ctrl && input === "e") this.customInput.lineEnd();
+    else if (key.ctrl && input === "u") this.customInput.deleteToLineStart();
+    else if (key.ctrl || key.meta || key.tab || key.upArrow || key.downArrow) return "ignored";
+    else {
+      const text = input.replace(/[\u0000-\u001f\u007f]/g, "");
+      if (!text) return "ignored";
+      this.customInput.insert(text);
+    }
+    return "changed";
+  }
+  /** Typed text from a paste while writing an own answer. */
+  paste(text) {
+    if (!this.customMode) return "ignored";
+    this.customInput.insert(text.replace(/\s*\n\s*/g, " ").replace(/[\u0000-\u001f\u007f]/g, ""));
+    return "changed";
+  }
+  moveTo(index) {
+    if (index === this.selected) return "ignored";
+    this.selected = index;
+    this.validationMessage = "";
+    return "changed";
+  }
+  toggleCurrent() {
+    const question = this.question;
+    if (this.selected === question.options.length) return this.enterCustomMode();
+    const option = question.options[this.selected];
+    if (!option) return "ignored";
+    const selection = this.selection(question.id);
+    if (selection.has(option.id)) selection.delete(option.id);
+    else selection.add(option.id);
+    this.validationMessage = "";
+    return "changed";
+  }
+  submitCurrent() {
+    const question = this.question;
+    if (this.selected === question.options.length) return this.enterCustomMode();
+    if (question.type === "single") {
+      const option = question.options[this.selected];
+      if (!option) return "ignored";
+      this.selections.set(question.id, /* @__PURE__ */ new Set([option.id]));
+      return this.advance();
+    }
+    if (this.selection(question.id).size === 0) {
+      this.validationMessage = "Select at least one option before continuing.";
+      return "changed";
+    }
+    return this.advance();
+  }
+  enterCustomMode() {
+    const question = this.question;
+    this.customMode = true;
+    this.validationMessage = "";
+    this.customInput.setText(this.customAnswers.get(question.id) ?? "");
+    return "changed";
+  }
+  submitCustom(value) {
+    const question = this.question;
+    const answer = value.trim();
+    if (!answer) {
+      this.validationMessage = "Enter your own answer before continuing.";
+      return "changed";
+    }
+    if (question.type === "single") {
+      this.selections.set(question.id, /* @__PURE__ */ new Set([OTHER_OPTION_ID]));
+    } else {
+      this.selection(question.id).add(OTHER_OPTION_ID);
+    }
+    this.customAnswers.set(question.id, answer);
+    this.customMode = false;
+    return this.advance();
+  }
+  advance() {
+    this.validationMessage = "";
+    if (this.questionIndex < this.pending.request.questions.length - 1) {
+      this.questionIndex++;
+      this.selected = 0;
+      return "changed";
+    }
+    this.pending.resolve({
+      action: "accept",
+      answers: this.pending.request.questions.map((question) => ({
+        questionId: question.id,
+        selectedOptionIds: [...this.selection(question.id)],
+        customAnswer: this.customAnswers.get(question.id)
+      }))
+    });
+    this.onClose();
+    return "closed";
+  }
+  selection(questionId) {
+    let selected = this.selections.get(questionId);
+    if (!selected) {
+      selected = /* @__PURE__ */ new Set();
+      this.selections.set(questionId, selected);
+    }
+    return selected;
+  }
+};
+function permissionKey(request, input, key) {
+  if (input === "a" || key.return) request.resolve(true, "once");
+  else if (input === "s") request.resolve(true, "session");
+  else if (input === "w") request.resolve(true, "always");
+  else if (input === "d" || isCancel(input, key)) request.resolve(false, "once");
+  else return "ignored";
+  return "closed";
+}
+
+// src/tui/ink/editor/prompt-editor.ts
+var MAX_HISTORY = 200;
+var PromptEditor = class {
+  buffer = new TextBuffer();
+  history = [];
+  /** -1: the draft; otherwise an index into history, newest last. */
+  historyIndex = -1;
+  historyDraft = "";
+  queuedMessages = null;
+  editingQueueId = null;
+  queueDraft = "";
+  draftPastes = new DraftPasteAttachments();
+  autocompleteProvider = null;
+  autocompleteState = null;
+  autocompleteAbort = null;
+  autocompleteRequest = 0;
+  listeners = /* @__PURE__ */ new Set();
+  version = 0;
+  lastText = "";
+  onSubmit;
+  onChange;
+  onQueuedMessageEditStart;
+  onQueuedMessageEditFinish;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  /** Changes whenever anything visible changed (for useSyncExternalStore). */
+  getVersion = () => this.version;
+  getText() {
+    return this.buffer.text;
+  }
+  setText(text) {
+    this.buffer.setText(text);
+    this.closeAutocomplete();
+    this.changed();
+  }
+  insertTextAtCursor(text) {
+    this.buffer.insert(text);
+    this.changed();
+  }
+  get autocomplete() {
+    return this.autocompleteState;
+  }
+  setAutocompleteProvider(provider) {
+    this.autocompleteProvider = provider;
+  }
+  setQueuedMessageProvider(provider) {
+    this.queuedMessages = provider;
+  }
+  editingQueuedMessage() {
+    return this.editingQueueId;
+  }
+  referencedPastes(text) {
+    return this.draftPastes.referencedBy(text);
+  }
+  clearPastes() {
+    this.draftPastes.clear();
+  }
+  addToHistory(text) {
+    const value = text.trim();
+    if (!value || this.history.at(-1) === value) return;
+    this.history.push(value);
+    if (this.history.length > MAX_HISTORY) this.history.shift();
+  }
+  /** Text from the terminal's bracketed paste. */
+  paste(text) {
+    const normalized = normalizeClipboardPaste(text);
+    if (!normalized) return;
+    if (isLargeClipboardPaste(normalized)) {
+      this.buffer.insert(this.draftPastes.add(normalized).marker);
+    } else {
+      this.buffer.insert(normalized);
+    }
+    this.changed();
+    this.refreshAutocomplete();
+  }
+  /** Returns false when the key is not the editor's (global shortcuts). */
+  handleKey(input, key) {
+    if (isLateTerminalReply(input)) return true;
+    if (input.length > 1 && input.includes("\r") && !key.ctrl && !key.meta) {
+      const parts = input.split(/\r\n?/);
+      parts.forEach((part, index) => {
+        if (part) this.handleKey(part, {});
+        if (index < parts.length - 1) this.handleKey("\r", { return: true });
+      });
+      return true;
+    }
+    if (this.autocompleteState && this.handleAutocompleteKey(key))
+      return true;
+    if (key.return && (key.meta || key.shift)) return this.edit(() => this.buffer.newline());
+    if (input === "\n" && !key.return) return this.edit(() => this.buffer.newline());
+    if (key.return) {
+      this.submitOrContinue();
+      return true;
+    }
+    if (key.tab && !key.shift) {
+      this.refreshAutocomplete(true);
+      return true;
+    }
+    if (key.upArrow) {
+      if ((this.editingQueueId !== null || this.buffer.isEmpty) && this.navigateQueuedMessages(-1))
+        return true;
+      if (!this.buffer.up()) this.historyOlder();
+      this.closeAutocomplete();
+      this.changed();
+      return true;
+    }
+    if (key.downArrow) {
+      if (this.editingQueueId !== null && this.navigateQueuedMessages(1))
+        return true;
+      if (!this.buffer.down()) this.historyNewer();
+      this.closeAutocomplete();
+      this.changed();
+      return true;
+    }
+    if (key.backspace) {
+      return this.edit(
+        () => key.meta || key.ctrl ? this.buffer.deleteWordBackward() : this.buffer.backspace()
+      );
+    }
+    if (key.delete) return this.edit(() => this.buffer.deleteForward());
+    if (key.leftArrow) {
+      return this.move(
+        () => key.meta || key.ctrl ? this.buffer.wordLeft() : this.buffer.left()
+      );
+    }
+    if (key.rightArrow) {
+      return this.move(
+        () => key.meta || key.ctrl ? this.buffer.wordRight() : this.buffer.right()
+      );
+    }
+    if (key.home) return this.move(() => this.buffer.lineStart());
+    if (key.end) return this.move(() => this.buffer.lineEnd());
+    if (key.ctrl) {
+      switch (input) {
+        case "a":
+          return this.move(() => this.buffer.lineStart());
+        case "e":
+          return this.move(() => this.buffer.lineEnd());
+        case "u":
+          return this.edit(() => this.buffer.deleteToLineStart());
+        case "w":
+          return this.edit(() => this.buffer.deleteWordBackward());
+        case "j":
+          return this.edit(() => this.buffer.newline());
+        case "d":
+          if (this.buffer.isEmpty) return false;
+          return this.edit(() => this.buffer.deleteForward());
+        default:
+          return false;
+      }
+    }
+    if (key.meta) {
+      if (input === "b") return this.move(() => this.buffer.wordLeft());
+      if (input === "f") return this.move(() => this.buffer.wordRight());
+      return false;
+    }
+    if (key.escape || key.tab || key.pageUp || key.pageDown) return false;
+    const text = stripControlCharacters(input);
+    if (!text) return false;
+    return this.edit(() => this.buffer.insert(text));
+  }
+  handleAutocompleteKey(key) {
+    const state = this.autocompleteState;
+    if (key.upArrow || key.downArrow) {
+      const count = state.items.length;
+      const delta = key.upArrow ? -1 : 1;
+      this.autocompleteState = {
+        ...state,
+        selected: (state.selected + delta + count) % count
+      };
+      this.changed();
+      return true;
+    }
+    if (key.escape) {
+      this.closeAutocomplete();
+      this.changed();
+      return true;
+    }
+    if (key.tab && !key.shift) {
+      this.acceptAutocomplete();
+      return true;
+    }
+    if (key.return && !key.meta && !key.shift) {
+      const item = state.items[state.selected];
+      const { row, col } = this.buffer.cursor;
+      const before = (this.buffer.lineList[row] ?? "").slice(0, col);
+      if (item && before === `/${item.value}`) {
+        this.closeAutocomplete();
+        return false;
+      }
+      this.acceptAutocomplete();
+      return true;
+    }
+    return false;
+  }
+  acceptAutocomplete() {
+    const state = this.autocompleteState;
+    const provider = this.autocompleteProvider;
+    const item = state?.items[state.selected];
+    this.closeAutocomplete();
+    if (!state || !provider || !item) return;
+    const { row, col } = this.buffer.cursor;
+    const result = provider.applyCompletion(
+      [...this.buffer.lineList],
+      row,
+      col,
+      item,
+      state.prefix
+    );
+    this.buffer.setState(result.lines, result.cursorLine, result.cursorCol);
+    this.changed();
+    if (item.value.replace(/"$/, "").endsWith("/")) this.refreshAutocomplete();
+  }
+  closeAutocomplete() {
+    this.autocompleteRequest++;
+    this.autocompleteAbort?.abort();
+    this.autocompleteAbort = null;
+    this.autocompleteState = null;
+  }
+  /** Looks up suggestions for the text before the cursor; Tab forces paths. */
+  refreshAutocomplete(force = false) {
+    const provider = this.autocompleteProvider;
+    const { row, col } = this.buffer.cursor;
+    const lines = [...this.buffer.lineList];
+    const before = (lines[row] ?? "").slice(0, col);
+    const relevant = force || extractMentionPrefix(before) !== null || row === 0 && before.startsWith("/") && !/\s/.test(before);
+    if (!provider || !relevant) {
+      if (this.autocompleteState) {
+        this.closeAutocomplete();
+        this.changed();
+      }
+      return;
+    }
+    if (force && !provider.shouldTriggerFileCompletion(lines, row, col)) return;
+    this.autocompleteAbort?.abort();
+    const abort = new AbortController();
+    this.autocompleteAbort = abort;
+    const request = ++this.autocompleteRequest;
+    void provider.getSuggestions(lines, row, col, { signal: abort.signal, force }).then((suggestions) => {
+      if (request !== this.autocompleteRequest) return;
+      this.autocompleteAbort = null;
+      if (!suggestions || suggestions.items.length === 0) {
+        this.autocompleteState = null;
+      } else if (force && suggestions.items.length === 1) {
+        this.autocompleteState = { ...suggestions, selected: 0 };
+        this.acceptAutocomplete();
+        return;
+      } else {
+        this.autocompleteState = { ...suggestions, selected: 0 };
+      }
+      this.changed();
+    }).catch(() => {
+      if (request === this.autocompleteRequest) this.autocompleteState = null;
+    });
+  }
+  submitOrContinue() {
+    const { row, col } = this.buffer.cursor;
+    const line = this.buffer.lineList[row] ?? "";
+    if (col > 0 && line[col - 1] === "\\") {
+      this.buffer.backspace();
+      this.buffer.newline();
+      this.changed();
+      return;
+    }
+    if (this.editingQueueId) {
+      this.finishQueueEdit();
+      return;
+    }
+    const text = this.buffer.text;
+    this.buffer.setText("");
+    this.historyIndex = -1;
+    this.historyDraft = "";
+    this.closeAutocomplete();
+    this.changed();
+    this.onSubmit?.(text);
+  }
+  historyOlder() {
+    if (this.history.length === 0) return;
+    if (this.historyIndex === -1) {
+      this.historyDraft = this.buffer.text;
+      this.historyIndex = this.history.length - 1;
+    } else if (this.historyIndex > 0) {
+      this.historyIndex--;
+    } else {
+      return;
+    }
+    this.buffer.setText(this.history[this.historyIndex]);
+  }
+  historyNewer() {
+    if (this.historyIndex === -1) return;
+    if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex++;
+      this.buffer.setText(this.history[this.historyIndex]);
+    } else {
+      this.historyIndex = -1;
+      this.buffer.setText(this.historyDraft);
+    }
+  }
+  navigateQueuedMessages(direction) {
+    const items = this.queuedMessages?.() ?? [];
+    if (items.length === 0) {
+      if (this.editingQueueId) this.finishQueueEdit();
+      return false;
+    }
+    if (!this.editingQueueId) {
+      if (direction > 0) return false;
+      this.queueDraft = this.buffer.text;
+      this.selectQueuedMessage(items.at(-1));
+      return true;
+    }
+    const currentIndex = items.findIndex(
+      (item) => item.id === this.editingQueueId
+    );
+    if (currentIndex < 0) {
+      this.editingQueueId = null;
+      this.setText(this.queueDraft);
+      return true;
+    }
+    const nextIndex = currentIndex + direction;
+    if (nextIndex < 0) return true;
+    if (nextIndex >= items.length) {
+      this.finishQueueEdit();
+      return true;
+    }
+    const previousId = this.editingQueueId;
+    const previousText = this.buffer.text;
+    this.editingQueueId = null;
+    this.onQueuedMessageEditFinish?.(previousId, previousText);
+    this.selectQueuedMessage(items[nextIndex]);
+    return true;
+  }
+  selectQueuedMessage(item) {
+    this.editingQueueId = item.id;
+    this.onQueuedMessageEditStart?.(item.id);
+    this.setText(item.text);
+  }
+  finishQueueEdit() {
+    const id = this.editingQueueId;
+    if (!id) return;
+    const text = this.buffer.text;
+    const draft = this.queueDraft;
+    this.editingQueueId = null;
+    this.queueDraft = "";
+    this.onQueuedMessageEditFinish?.(id, text);
+    this.setText(draft);
+  }
+  edit(apply) {
+    apply();
+    this.historyIndex = -1;
+    this.changed();
+    this.refreshAutocomplete();
+    return true;
+  }
+  move(apply) {
+    apply();
+    this.closeAutocomplete();
+    this.changed();
+    return true;
+  }
+  changed() {
+    this.version++;
+    const text = this.buffer.text;
+    if (text !== this.lastText) {
+      this.lastText = text;
+      this.onChange?.(text);
+    }
+    for (const listener of this.listeners) listener();
+  }
+};
+function stripControlCharacters(input) {
+  return input.replace(/\r\n?/g, "\n").replace(/\t/g, "    ").replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, "");
+}
+
+// src/tui/ink/prompt-submission.ts
+function bindPromptSubmission({
+  editor,
+  draftImages,
+  runner,
+  store,
+  submit,
+  appendError
+}) {
+  let submissionPending = false;
+  editor.onSubmit = (text) => {
+    if (submissionPending) return;
+    submissionPending = true;
+    let ownsSubmissionLock = true;
+    const releaseSubmissionLock = () => {
+      if (!ownsSubmissionLock) return;
+      ownsSubmissionLock = false;
+      submissionPending = false;
+    };
+    void (async () => {
+      const images = text.trimStart().startsWith("/") ? [] : draftImages.referencedBy(text);
+      const pastes = editor.referencedPastes(text);
+      if (images.length > 0 && !await runner.supportsImageInput()) {
+        editor.setText(text);
+        store.setState({
+          statusLine: `Model ${runner.model} does not support image input; the draft was kept.`
+        });
+        return;
+      }
+      editor.setText("");
+      draftImages.clear();
+      editor.clearPastes();
+      const completion = submit(text, images, pastes);
+      releaseSubmissionLock();
+      await completion;
+    })().catch((error) => {
+      appendError(
+        error instanceof Error ? error.message : "Failed to submit input."
+      );
+      store.setState({ busy: false, statusLine: "Input failed." });
+    }).finally(releaseSubmissionLock);
+  };
+}
+
+// src/tui/ink/transcript/committer.ts
+var FINAL_JOB_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "killed", "released"]);
+var TranscriptCommitter = class {
+  epoch = 0;
+  committed = [];
+  committedView = [];
+  /** Ids of the messages whose blocks are all committed, in order. */
+  committedIds = [];
+  /** How much of a streaming assistant message is already committed. */
+  partial = null;
+  backgroundStatus = /* @__PURE__ */ new Map();
+  sessionId = null;
+  expanded = false;
+  planSignature = null;
+  snapshot = null;
+  lastState = null;
+  redrawRequested = false;
+  /** The next sync starts a new epoch, e.g. after the terminal width changed. */
+  requestRedraw() {
+    this.redrawRequested = true;
+    this.lastState = null;
+  }
+  sync(state, expanded) {
+    if (this.snapshot && state === this.lastState && expanded === this.expanded)
+      return this.snapshot;
+    this.lastState = state;
+    if (this.redrawRequested || state.sessionId !== this.sessionId || expanded !== this.expanded || !this.prefixIntact(state.messages)) {
+      this.startEpoch(state, expanded);
+    }
+    const messages = state.messages;
+    this.commitBackgroundChanges(messages);
+    const live = [];
+    let committing = true;
+    const emit = (block, final, consumed) => {
+      if (committing && final) {
+        this.committed.push(block);
+        this.committedIds.push(...consumed);
+      } else {
+        committing = false;
+        live.push(block);
+      }
+    };
+    let index = this.committedIds.length;
+    while (index < messages.length) {
+      const message = messages[index];
+      if (message.role === "tool" && !expanded && isActivityTool(message.call)) {
+        const calls = [];
+        const ids = [];
+        let end = index;
+        while (end < messages.length) {
+          const next = messages[end];
+          if (next.role !== "tool" || !isActivityTool(next.call)) break;
+          calls.push(next.call);
+          ids.push(next.id);
+          end++;
+        }
+        const following = messages[end];
+        const closed = calls.every((call) => call.status !== "pending") && (following !== void 0 && !isQueued(following) || !state.busy);
+        emit({ key: `activity:${message.id}`, kind: "activity", calls }, closed, ids);
+        index = end;
+        continue;
+      }
+      switch (message.role) {
+        case "user":
+          if (message.queued) {
+            emit(
+              { key: message.id, kind: "queued", text: message.text, queued: message.queued },
+              false,
+              []
+            );
+          } else {
+            emit({ key: message.id, kind: "user", text: message.text }, true, [message.id]);
+          }
+          break;
+        case "error":
+          emit({ key: message.id, kind: "error", text: message.text }, true, [message.id]);
+          break;
+        case "tool":
+          emit(
+            { key: message.id, kind: "tool", call: message.call, expanded },
+            message.call.status !== "pending",
+            [message.id]
+          );
+          break;
+        case "background":
+          if (committing) this.backgroundStatus.set(message.job.jobId, message.job.status);
+          emit(
+            { key: message.id, kind: "background", job: message.job, expanded },
+            true,
+            [message.id]
+          );
+          break;
+        case "assistant":
+          this.emitAssistant(message, committing, emit);
+          if (message.streaming) committing = false;
+          break;
+      }
+      index++;
+    }
+    this.emitPlan(state, committing, live);
+    if (this.committedView.length !== this.committed.length)
+      this.committedView = this.committed.slice();
+    this.snapshot = { epoch: this.epoch, committed: this.committedView, live };
+    return this.snapshot;
+  }
+  emitAssistant(message, committing, emit) {
+    let offset = this.partial?.id === message.id ? this.partial.offset : 0;
+    const block = (text, streaming) => ({
+      key: `${message.id}:${offset}`,
+      kind: "assistant",
+      text,
+      first: offset === 0,
+      streaming
+    });
+    if (!message.streaming) {
+      const rest2 = message.text.slice(offset);
+      if (committing && this.partial?.id === message.id) this.partial = null;
+      if (rest2.trim()) emit(block(rest2, false), true, [message.id]);
+      else if (committing) this.committedIds.push(message.id);
+      return;
+    }
+    if (committing) {
+      const split = safeSplitOffset(message.text, offset);
+      if (split > offset && message.text.slice(offset, split).trim()) {
+        emit(block(message.text.slice(offset, split), false), true, []);
+        offset = split;
+        this.partial = { id: message.id, offset };
+      }
+    }
+    const rest = message.text.slice(offset);
+    emit(block(rest, true), false, []);
+  }
+  emitPlan(state, committing, live) {
+    if (state.plan.length === 0) return;
+    const signature = JSON.stringify(state.plan);
+    if (signature === this.planSignature) return;
+    const block = {
+      key: `plan:${this.committed.length}:${signature.length}`,
+      kind: "plan",
+      entries: state.plan
+    };
+    if (committing && !state.busy) {
+      this.committed.push(block);
+      this.planSignature = signature;
+    } else {
+      live.push(block);
+    }
+  }
+  /** A background job that finishes after it was printed gets a new line. */
+  commitBackgroundChanges(messages) {
+    for (let index = 0; index < this.committedIds.length; index++) {
+      const message = messages[index];
+      if (message?.role !== "background") continue;
+      const { job } = message;
+      const previous = this.backgroundStatus.get(job.jobId);
+      if (previous === job.status) continue;
+      this.backgroundStatus.set(job.jobId, job.status);
+      if (!FINAL_JOB_STATUSES.has(job.status)) continue;
+      this.committed.push({
+        key: `${message.id}:${job.status}`,
+        kind: "background",
+        job,
+        expanded: this.expanded
+      });
+    }
+  }
+  prefixIntact(messages) {
+    if (messages.length < this.committedIds.length) return false;
+    for (let index = 0; index < this.committedIds.length; index++) {
+      if (messages[index].id !== this.committedIds[index]) return false;
+    }
+    if (this.partial) {
+      const message = messages[this.committedIds.length];
+      if (message?.id !== this.partial.id || message.role !== "assistant" || message.text.length < this.partial.offset)
+        return false;
+    }
+    return true;
+  }
+  startEpoch(state, expanded) {
+    this.redrawRequested = false;
+    this.epoch++;
+    this.sessionId = state.sessionId;
+    this.expanded = expanded;
+    this.committed = [{ key: `header:${this.epoch}`, kind: "header", cwd: state.cwd }];
+    this.committedView = [];
+    this.committedIds = [];
+    this.partial = null;
+    this.backgroundStatus.clear();
+    this.planSignature = null;
+  }
+};
+function isQueued(message) {
+  return message.role === "user" && message.queued !== void 0;
+}
+function safeSplitOffset(text, from) {
+  let inFence = false;
+  let fenceMarker = "";
+  let lineStart = 0;
+  let split = from;
+  let previousBlank = false;
+  while (lineStart <= text.length) {
+    const newline = text.indexOf("\n", lineStart);
+    if (newline === -1) break;
+    const line = text.slice(lineStart, newline);
+    const fence = /^\s{0,3}(`{3,}|~{3,})/.exec(line);
+    if (fence) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fence[1][0].repeat(fence[1].length);
+      } else if (line.trim().startsWith(fenceMarker)) {
+        inFence = false;
+      }
+    }
+    const blank = line.trim() === "";
+    const next = newline + 1;
+    if (!inFence && blank && !previousBlank && next > from && lineStart > from) {
+      split = next;
+    }
+    previousBlank = blank;
+    lineStart = next;
+  }
+  return split;
+}
+
+// src/tui/ink/controller.ts
+var CLEAR_SCREEN_AND_SCROLLBACK = "\x1B[2J\x1B[3J\x1B[H";
+var EXIT_CONFIRM_MS = 2e3;
+var TuiController = class {
+  constructor(store, runner, io) {
+    this.store = store;
+    this.runner = runner;
+    this.io = io;
+    this.view = this.buildView();
+    this.lastEpoch = this.view.transcript.epoch;
+    this.configureEditor();
+    this.unsubscribeStore = store.subscribe(() => this.refresh());
+  }
+  store;
+  runner;
+  io;
+  editor = new PromptEditor();
+  draftImages = new DraftImageAttachments();
+  committer = new TranscriptCommitter();
+  listeners = /* @__PURE__ */ new Set();
+  overlay = null;
+  question = null;
+  expandedTools = false;
+  exiting = false;
+  view;
+  lastEpoch = 0;
+  exitArmed = false;
+  exitTimer;
+  animationTimer;
+  windowTitle;
+  windowTitleBusy = false;
+  windowTitleFrame = 0;
+  imagePasteActive = false;
+  stopped = false;
+  unsubscribeStore;
+  resolveExit = () => {
+  };
+  /** Settles once the user asked to quit; `run` then tears the view down. */
+  exitRequested = new Promise((resolve2) => {
+    this.resolveExit = resolve2;
+  });
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getView = () => this.view;
+  start() {
+    void this.runner.ensureUsableModel().then(() => this.refresh());
+    this.syncWindowTitle();
+    this.animationTimer = setInterval(() => this.syncWindowTitle(true), 120);
+    this.animationTimer.unref?.();
+  }
+  /** Stops timers and the session; the caller unmounts the view afterwards. */
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.exitTimer) clearTimeout(this.exitTimer);
+    if (this.animationTimer) clearInterval(this.animationTimer);
+    this.setWindowTitle(`${ASSISTANT_MARKER} Nova AI`);
+    this.unsubscribeStore();
+    await this.runner.close().catch(() => {
+    });
+  }
+  requestExit() {
+    if (this.exiting) return;
+    this.exiting = true;
+    this.refresh();
+    this.resolveExit();
+  }
+  // ---------------------------------------------------------------- keys
+  /** Shortcuts that work while the prompt has focus; false lets the editor have the key. */
+  handlePromptKey(input, key) {
+    if (key.ctrl && input === "c") {
+      this.pressCtrlC();
+      return true;
+    }
+    if (key.escape) {
+      if (this.editor.autocomplete) return false;
+      if (this.store.getState().busy) {
+        this.runner.cancel();
+        return true;
+      }
+      return false;
+    }
+    if (key.tab && key.shift) {
+      this.cycleInteractionMode();
+      return true;
+    }
+    if (key.meta && input === "v") {
+      void this.pasteClipboardImage();
+      return true;
+    }
+    if (!key.ctrl) return false;
+    switch (input) {
+      case "r":
+        this.openSessions();
+        return true;
+      case "p":
+        void this.openModels();
+        return true;
+      case "k":
+        this.openPermissionModes();
+        return true;
+      case "b":
+        void this.openBackgroundTasks();
+        return true;
+      case "o":
+        this.toggleToolDetails();
+        return true;
+      case "t":
+        this.openToolInspector();
+        return true;
+      default:
+        return false;
+    }
+  }
+  pressCtrlC() {
+    if (this.exitArmed) {
+      this.requestExit();
+      return;
+    }
+    if (this.store.getState().busy) this.runner.cancel();
+    this.exitArmed = true;
+    this.store.setState({ statusLine: "Press Ctrl+C again within 2s to exit." });
+    if (this.exitTimer) clearTimeout(this.exitTimer);
+    this.exitTimer = setTimeout(() => {
+      this.exitArmed = false;
+      if (this.store.getState().statusLine?.startsWith("Press Ctrl+C"))
+        this.store.setState({ statusLine: null });
+    }, EXIT_CONFIRM_MS);
+    this.exitTimer.unref?.();
+  }
+  closeOverlay = () => {
+    this.overlay = null;
+    this.store.setState({ mode: "chat" });
+    this.refresh();
+  };
+  // ------------------------------------------------------------ overlays
+  showOverlay(overlay, mode = "chat") {
+    this.overlay = overlay;
+    this.store.setState({ mode });
+    this.refresh();
+  }
+  showText(title, content) {
+    this.showOverlay({
+      kind: "text",
+      title,
+      content: content || "(no output)",
+      state: new ScrollState(this.closeOverlay)
+    });
+  }
+  showSelection(title, items, mode, onSelect) {
+    if (items.length === 0) {
+      this.showText(title, "Nothing to show.");
+      return;
+    }
+    const state = new SelectionState(
+      items,
+      (item) => {
+        this.closeOverlay();
+        onSelect(item.value);
+      },
+      this.closeOverlay
+    );
+    this.showOverlay({ kind: "selection", title, state }, mode);
+  }
+  openSessions = () => {
+    this.showSelection(
+      "Sessions \xB7 age | prompt | datetime",
+      listSessionPickerItems(this.runner.cwd),
+      "session-switcher",
+      (sessionId) => {
+        if (!this.runner.resumeFrom(sessionId))
+          this.appendError(`Session not found: ${sessionId}`);
+      }
+    );
+  };
+  openModels = async () => {
+    this.showText("Models", "Loading models...");
+    try {
+      const models = await this.runner.listModels();
+      this.showSelection(
+        "Models",
+        models.map((model) => ({
+          value: model.id,
+          label: model.id,
+          description: model.name ?? void 0
+        })),
+        "model-picker",
+        (model) => this.setModel(model)
+      );
+    } catch (error) {
+      this.showText("Models", errorMessage(error, "Failed to list models."));
+    }
+  };
+  openPermissionModes = () => {
+    const modes = [
+      { value: "ask", label: "ask", description: "Prompt before tools make changes" },
+      { value: "acceptEdits", label: "acceptEdits", description: "Allow file edits automatically" },
+      { value: "bypassAll", label: "bypassAll", description: "Allow all tools automatically" }
+    ];
+    this.showSelection(
+      "Permission mode",
+      modes,
+      "permission-picker",
+      (value) => this.setPermissionMode(value)
+    );
+  };
+  openBackgroundTasks = async () => {
+    try {
+      const jobs = await this.runner.listBackgroundJobs();
+      this.showSelection(
+        "Background shells and agents",
+        jobs.map((job) => ({
+          value: job.jobId,
+          label: `${job.kind}: ${job.title}`,
+          description: job.status
+        })),
+        "background-tasks",
+        (jobId) => {
+          void this.runner.backgroundOutput(jobId).then(
+            (result) => this.showText(
+              `${result.job.kind}: ${result.job.title}`,
+              `jobId: ${jobId}
+status: ${result.job.status}
+outputPath: ${result.outputPath ?? result.job.outputPath ?? ""}
+
+${result.output}${result.truncated ? "\n\n[output truncated]" : ""}`
+            )
+          ).catch(
+            (error) => this.showText("Background job", errorMessage(error, "Failed to read output."))
+          );
+        }
+      );
+    } catch (error) {
+      this.showText("Background jobs", errorMessage(error, "Failed to list background jobs."));
+    }
+  };
+  openToolInspector = () => {
+    if (this.toolCalls().length === 0) {
+      this.showText("Tool calls", "No tool calls yet.");
+      return;
+    }
+    this.showOverlay({
+      kind: "tools",
+      state: new ToolInspectorState(() => this.toolCalls(), this.closeOverlay)
+    });
+  };
+  openMcpInspector = () => {
+    const servers = this.runner.configuredMcpServers();
+    const connection = this.runner.mcpSessionStatus();
+    const configuredNames = new Set(servers.map((server) => server.name));
+    const configurationFailures = connection.failures.filter((failure) => !configuredNames.has(failure.serverName)).map((failure) => `${failure.serverName}
+status: failed - ${failure.message}`);
+    const rows = [
+      ...servers.map((server) => formatMcpServer(server, connection)),
+      ...configurationFailures
+    ];
+    this.showText(
+      "MCP servers",
+      rows.length ? rows.join("\n\n") : "No MCP servers configured for this workspace.\n\nAdd a project .mcp.json or mcpServers to .nova-ai/settings.json; ACP connects them when the session starts."
+    );
+  };
+  openSkillInspector = () => {
+    const skills = this.runner.skillSessionStatus();
+    this.showText(
+      `Skills (${skills.length})`,
+      skills.length ? skills.map((skill) => `${skill.name} [${skill.source}]
+${skill.description}
+${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents/skills, .claude/skills, or .codex/skills in the workspace or user profile."
+    );
+  };
+  openUsageInspector = async () => {
+    this.showText("Context usage", "Calculating context usage...");
+    try {
+      const usage = await this.runner.refreshContextUsage();
+      this.showText("Context usage", formatContextUsage(usage));
+    } catch (error) {
+      this.showText("Context usage", errorMessage(error, "Failed to calculate context usage."));
+    }
+  };
+  /**
+   * Prints the whole transcript again. After the width changed, the terminal
+   * re-wrapped what is on screen on its own and the live area can't be
+   * erased exactly (Ink leaves stale prompt borders), and old scrollback keeps
+   * the old wrapping.
+   */
+  redrawAll() {
+    if (this.stopped || this.exiting) return;
+    this.committer.requestRedraw();
+    this.refresh();
+  }
+  toggleToolDetails() {
+    this.expandedTools = !this.expandedTools;
+    this.store.setState({
+      statusLine: this.expandedTools ? "Verbose tool details expanded; read/search stay compact." : "Verbose tool details collapsed."
+    });
+  }
+  toolCalls() {
+    return this.store.getState().messages.flatMap((message) => message.role === "tool" ? [message.call] : []);
+  }
+  // ------------------------------------------------------- session state
+  setModel(model) {
+    this.runner.setModel(model);
+    this.store.setState({ statusLine: `Model: ${model}` });
+  }
+  setPermissionMode(mode) {
+    this.runner.setPermissionMode(mode);
+    this.store.setState({ statusLine: `Permission mode: ${mode}` });
+  }
+  setInteractionMode(mode) {
+    this.runner.setInteractionMode(mode);
+  }
+  cycleInteractionMode() {
+    const current = INTERACTION_MODES.indexOf(this.runner.interactionMode);
+    this.setInteractionMode(INTERACTION_MODES[(current + 1) % INTERACTION_MODES.length]);
+  }
+  appendAssistant(text) {
+    this.store.setState((state) => ({
+      messages: [
+        ...state.messages,
+        { id: `command-${Date.now()}-${state.messages.length}`, role: "assistant", text, streaming: false }
+      ]
+    }));
+  }
+  appendError = (text) => {
+    this.store.setState((state) => ({
+      messages: [
+        ...state.messages,
+        { id: `error-${Date.now()}-${state.messages.length}`, role: "error", text }
+      ]
+    }));
+  };
+  commandContext = {
+    print: (text) => this.appendAssistant(text),
+    clear: () => void this.runner.startNewSession(),
+    newSession: () => this.runner.startNewSession(),
+    exit: () => this.requestExit(),
+    resumeSession: (sessionId) => {
+      const id = sessionId ?? listSessionsForCwd(this.runner.cwd)[0]?.sessionId;
+      return id ? this.runner.resumeFrom(id) : false;
+    },
+    openSessionSwitcher: this.openSessions,
+    openModelPicker: () => void this.openModels(),
+    getModel: () => this.runner.model,
+    setModel: (model) => this.setModel(model),
+    getInteractionMode: () => this.runner.interactionMode,
+    setInteractionMode: (mode) => this.setInteractionMode(mode),
+    getPermissionMode: () => this.store.getState().permissionMode,
+    setPermissionMode: (mode) => this.setPermissionMode(mode),
+    openPermissionPicker: this.openPermissionModes,
+    trustWorkspace: () => {
+      setWorkspaceTrusted(this.runner.cwd, true);
+      return "Workspace trusted: its allow rules apply now; MCP servers it declares start with the next session (/clear).";
+    },
+    openToolInspector: this.openToolInspector,
+    openMcpInspector: this.openMcpInspector,
+    openSkillInspector: this.openSkillInspector,
+    openUsageInspector: this.openUsageInspector,
+    steerMessage: (message) => this.runner.steer(message),
+    queuedMessages: () => this.runner.queuedMessages(),
+    clearQueuedMessages: () => this.runner.clearQueuedMessages(),
+    compactContext: () => this.runner.compactContext(),
+    rewind: (turns) => this.runner.rewind(turns),
+    listModels: () => this.runner.listModels(),
+    startBackgroundShell: (command) => this.runner.startBackgroundShell(command),
+    startBackgroundAgent: (prompt) => this.runner.startBackgroundAgent(prompt),
+    listBackgroundJobs: (kind) => this.runner.listBackgroundJobs(kind),
+    backgroundOutput: (jobId) => this.runner.backgroundOutput(jobId),
+    killBackgroundJob: (jobId) => this.runner.killBackgroundJob(jobId),
+    releaseBackgroundJob: (jobId) => this.runner.releaseBackgroundJob(jobId)
+  };
+  // ------------------------------------------------------------ prompt
+  submit = async (text, images = [], pastes = []) => {
+    const value = text.trim();
+    if (!value) return;
+    this.editor.addToHistory(value);
+    this.store.setState((state) => ({
+      inputHistory: [...state.inputHistory, value],
+      statusLine: null
+    }));
+    if (!value.startsWith("/")) {
+      await this.runner.submit(value, images, pastes);
+      return;
+    }
+    const commandValue = expandPromptPastes(value, pastes);
+    const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(commandValue);
+    const name = match?.[1] ?? "";
+    const command = findCommand(name);
+    if (!command) {
+      this.appendError(`Unknown command: /${name}`);
+      return;
+    }
+    try {
+      await command.run(this.commandContext, match?.[2] ?? "");
+    } catch (error) {
+      this.appendError(`Command /${name} failed: ${errorMessage(error, "Unknown error.")}`);
+      this.store.setState({ statusLine: `Command /${name} failed.` });
+    }
+  };
+  async pasteClipboardImage() {
+    if (this.imagePasteActive) return;
+    this.imagePasteActive = true;
+    const model = this.runner.model;
+    this.store.setState({ statusLine: "Reading clipboard image..." });
+    try {
+      if (!await this.runner.supportsImageInput(model)) {
+        this.store.setState({ statusLine: `Model ${model} does not support image input.` });
+        return;
+      }
+      if (this.runner.model !== model && !await this.runner.supportsImageInput()) {
+        this.store.setState({
+          statusLine: `Model ${this.runner.model} does not support image input.`
+        });
+        return;
+      }
+      const attachment = this.draftImages.add(await readClipboardImage());
+      this.editor.insertTextAtCursor(attachment.marker);
+      this.store.setState({
+        statusLine: `Attached ${attachment.marker} (${formatImageSize(attachment.byteLength)}).`
+      });
+    } catch (error) {
+      this.store.setState({
+        statusLine: `Image paste failed: ${errorMessage(error, "Unknown error.")}`
+      });
+    } finally {
+      this.imagePasteActive = false;
+    }
+  }
+  configureEditor() {
+    const { editor, runner, draftImages } = this;
+    editor.setQueuedMessageProvider(() => runner.queuedMessageEntries());
+    editor.onQueuedMessageEditStart = (id) => {
+      runner.beginQueuedMessageEdit(id);
+    };
+    editor.onQueuedMessageEditFinish = (id, text) => {
+      runner.finishQueuedMessageEdit(
+        id,
+        text,
+        draftImages.referencedBy(text),
+        editor.referencedPastes(text)
+      );
+      draftImages.clear();
+    };
+    editor.onChange = (text) => {
+      const id = editor.editingQueuedMessage();
+      if (id) runner.updateQueuedMessage(id, text);
+    };
+    const fdPath = resolveFdPath();
+    editor.setAutocompleteProvider(
+      new WorkspaceAutocompleteProvider(
+        allCommands().map((command) => ({
+          name: command.name,
+          description: command.description
+        })),
+        runner.cwd,
+        // fd (when available) walks the tree itself and respects .gitignore;
+        // the pre-scanned list is only its fallback.
+        fdPath ? [] : listWorkspaceFiles(runner.cwd, 1e4),
+        fdPath
+      )
+    );
+    bindPromptSubmission({
+      editor,
+      draftImages,
+      runner,
+      store: this.store,
+      submit: this.submit,
+      appendError: this.appendError
+    });
+  }
+  // -------------------------------------------------------------- view
+  refresh() {
+    this.syncWindowTitle();
+    this.view = this.buildView();
+    if (this.view.transcript.epoch !== this.lastEpoch) {
+      this.lastEpoch = this.view.transcript.epoch;
+      this.io.write(CLEAR_SCREEN_AND_SCROLLBACK);
+    }
+    for (const listener of this.listeners) listener();
+  }
+  buildView() {
+    const ui = this.store.getState();
+    return {
+      ui,
+      transcript: this.committer.sync(ui, this.expandedTools),
+      overlay: this.overlay,
+      question: this.questionState(ui.pendingQuestion),
+      model: this.runner.model,
+      mcp: mcpCounts(this.runner),
+      expandedTools: this.expandedTools,
+      exiting: this.exiting
+    };
+  }
+  questionState(pending) {
+    if (!pending) {
+      this.question = null;
+      return null;
+    }
+    if (this.question?.pending.id !== pending.id) {
+      this.question = new QuestionState(pending, () => {
+      });
+    }
+    return this.question;
+  }
+  syncWindowTitle(advance = false) {
+    const busy = this.store.getState().busy;
+    if (busy !== this.windowTitleBusy) {
+      this.windowTitleBusy = busy;
+      this.windowTitleFrame = 0;
+    } else if (busy && advance) {
+      this.windowTitleFrame = (this.windowTitleFrame + 1) % WORKING_FRAMES.length;
+    }
+    const marker = busy ? WORKING_FRAMES[this.windowTitleFrame] : ASSISTANT_MARKER;
+    this.setWindowTitle(`${marker} ${busy ? "Nova-AI" : "Nova AI"}`);
+  }
+  setWindowTitle(title) {
+    if (title === this.windowTitle) return;
+    this.windowTitle = title;
+    this.io.write(`\x1B]0;${title}\x07`);
+  }
+};
+function formatMcpServer(server, status) {
+  const type = "type" in server ? server.type : "stdio";
+  const lines = [`${server.name} [${type}]`];
+  if ("url" in server) lines.push(`url: ${server.url}`);
+  if ("command" in server) {
+    lines.push(`command: ${server.command}`);
+    if (server.args.length) lines.push(`args: ${server.args.join(" ")}`);
+    if (server.env.length)
+      lines.push(`env: ${server.env.map((entry) => entry.name).join(", ")} (values hidden)`);
+  }
+  const failure = status.failures.find((item) => item.serverName === server.name);
+  lines.push(
+    failure ? `status: failed - ${failure.message}` : status.connected.includes(server.name) ? "status: connected" : "status: configured; connection starts with the ACP session"
+  );
+  return lines.join("\n");
+}
+function mcpCounts(runner) {
+  const status = runner.mcpSessionStatus();
+  return {
+    configured: status.configured.length,
+    connected: status.connected.length,
+    failed: status.failures.length,
+    skills: runner.skillSessionStatus().length
+  };
+}
+function errorMessage(error, fallback) {
+  return error instanceof Error ? error.message : fallback;
+}
+
+// src/tui/ink/dialogs/views.tsx
+import { Box as Box5, Text as Text5, useInput as useInput2, usePaste as usePaste2 } from "ink";
+import stringWidth2 from "string-width";
+import { useMemo, useState } from "react";
+import { OTHER_OPTION_ID as OTHER_OPTION_ID2 } from "@datalabrotterdam/nova-ai-agent/core/user-questions.js";
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function useDialogInput(handle, isActive) {
+  const [, setTick] = useState(0);
+  useInput2(
+    (input, key) => {
+      if (handle(input, key) === "changed") setTick((tick) => tick + 1);
+    },
+    { isActive }
+  );
+}
+function Frame({ title, children, footer }) {
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: palette.primary, paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { color: palette.primary, wrap: "truncate-end", children: title }),
+    children,
+    footer ? /* @__PURE__ */ jsx5(Text5, { color: palette.faint, wrap: "truncate-end", children: footer }) : null
+  ] });
+}
+function SelectionDialog({
+  title,
+  state,
+  height,
+  isActive = true
+}) {
+  const rows = Math.max(1, Math.min(state.items.length, height - 5));
+  useDialogInput((input, key) => state.handleKey(input, key, rows), isActive);
+  const start = windowStart(state.selected, state.items.length, rows);
+  const visible = state.items.slice(start, start + rows);
+  const leadingWidth = Math.min(
+    14,
+    Math.max(0, ...state.items.map((item) => item.columns ? stringWidth2(item.columns.leading) : 0))
+  );
+  return /* @__PURE__ */ jsx5(
+    Frame,
+    {
+      title,
+      footer: `${state.selected + 1}/${state.items.length} \xB7 \u2191\u2193 PgUp/PgDn navigate \xB7 Enter select \xB7 Esc close`,
+      children: visible.map((item, index) => {
+        const selected = start + index === state.selected;
+        const marker = /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: selected ? "> " : "  " });
+        if (item.columns) {
+          return /* @__PURE__ */ jsxs5(Box5, { children: [
+            marker,
+            /* @__PURE__ */ jsx5(Box5, { width: leadingWidth, flexShrink: 0, children: /* @__PURE__ */ jsx5(Text5, { bold: selected, wrap: "truncate-end", children: item.columns.leading }) }),
+            /* @__PURE__ */ jsx5(Box5, { flexGrow: 1, flexShrink: 1, marginLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { bold: selected, wrap: "truncate-end", children: item.columns.main.replace(/\s+/g, " ").trim() }) }),
+            /* @__PURE__ */ jsx5(Box5, { flexShrink: 0, marginLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: palette.muted, children: item.columns.trailing }) })
+          ] }, item.value);
+        }
+        return /* @__PURE__ */ jsxs5(Box5, { children: [
+          marker,
+          /* @__PURE__ */ jsx5(Box5, { flexShrink: 0, minWidth: Math.min(32, stringWidth2(item.label)), children: /* @__PURE__ */ jsx5(Text5, { bold: selected, wrap: "truncate-end", children: item.label || item.value }) }),
+          item.description ? /* @__PURE__ */ jsx5(Box5, { flexGrow: 1, flexShrink: 1, marginLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: palette.muted, wrap: "truncate-end", children: item.description.replace(/[\r\n]+/g, " ").trim() }) }) : null
+        ] }, item.value);
+      })
+    }
+  );
+}
+function ScrollPanel({
+  title,
+  content,
+  height,
+  width,
+  state,
+  isActive = true
+}) {
+  const bodyRows = Math.max(1, height - 4);
+  useDialogInput((input, key) => state.handleKey(input, key, bodyRows), isActive);
+  const wrapWidth = Math.max(1, width - 4);
+  const lines = useMemo(
+    () => wrapPlain(sanitizeTerminalText(content.replace(/\r\n?/g, "\n").replace(/\t/g, "    ")) || "(no output)", wrapWidth),
+    [content, wrapWidth]
+  );
+  const offset = state.clamp(lines.length, bodyRows);
+  const visible = lines.slice(offset, offset + bodyRows);
+  return /* @__PURE__ */ jsx5(
+    Frame,
+    {
+      title,
+      footer: `${offset + 1}-${offset + visible.length} of ${lines.length} \xB7 \u2191\u2193 PgUp/PgDn Home/End \xB7 Esc close`,
+      children: /* @__PURE__ */ jsx5(Text5, { children: visible.join("\n") })
+    }
+  );
+}
+function ToolInspector({
+  state,
+  height,
+  width,
+  isActive = true
+}) {
+  const calls = state.calls();
+  const listRows = state.expanded ? Math.min(calls.length, Math.max(1, Math.min(6, height - 8))) : Math.min(calls.length, Math.max(1, height - 4));
+  const detailRows = Math.max(1, height - listRows - 5);
+  useDialogInput(
+    (input, key) => state.handleKey(input, key, state.expanded ? detailRows : listRows),
+    isActive
+  );
+  if (calls.length === 0) {
+    return /* @__PURE__ */ jsx5(Frame, { title: "Tool calls", footer: "Esc close", children: /* @__PURE__ */ jsx5(Text5, { color: palette.faint, children: "No tool calls yet." }) });
+  }
+  const start = windowStart(state.selected, calls.length, listRows);
+  const selected = calls[state.selected];
+  let details = [];
+  let detailStart = 0;
+  if (state.expanded) {
+    const all = wrapPlain(formatToolCallDetails(selected), Math.max(1, width - 6));
+    detailStart = Math.max(0, Math.min(state.detailOffset, all.length - detailRows));
+    state.detailOffset = detailStart;
+    details = all.slice(detailStart, detailStart + detailRows);
+    details.push(
+      `(${detailStart + 1}-${detailStart + details.length} of ${all.length})`
+    );
+  }
+  return /* @__PURE__ */ jsxs5(
+    Frame,
+    {
+      title: `Tool calls (${calls.length})`,
+      footer: `${state.selected + 1}/${calls.length} \xB7 \u2191\u2193 select \xB7 Enter/Space/\u2190\u2192 details \xB7 Esc close`,
+      children: [
+        calls.slice(start, start + listRows).map((call, index) => {
+          const isSelected = start + index === state.selected;
+          const summary = toolCallSummary(call);
+          return /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: isSelected ? "> " : "  " }),
+            /* @__PURE__ */ jsx5(Box5, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsxs5(Text5, { bold: isSelected, wrap: "truncate-end", children: [
+              isSelected && state.expanded ? "v " : "> ",
+              /* @__PURE__ */ jsx5(StatusIcon, { status: call.status }),
+              " ",
+              call.name,
+              summary ? `: ${summary}` : ""
+            ] }) }),
+            width >= 48 ? /* @__PURE__ */ jsx5(Box5, { flexShrink: 0, marginLeft: 2, children: /* @__PURE__ */ jsx5(Text5, { color: palette.muted, children: `${call.status} | ${call.kind}${call.mutating ? " | changes" : ""}` }) }) : null
+          ] }, call.toolCallId);
+        }),
+        state.expanded ? /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 2, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx5(Text5, { color: palette.muted, children: details.slice(0, -1).join("\n") }),
+          /* @__PURE__ */ jsx5(Text5, { color: palette.faint, children: details.at(-1) })
+        ] }) : null
+      ]
+    }
+  );
+}
+function QuestionDialog({
+  state,
+  isActive = true
+}) {
+  const [, setTick] = useState(0);
+  useInput2(
+    (input, key) => {
+      if (state.handleKey(input, key) === "changed") setTick((tick) => tick + 1);
+    },
+    { isActive }
+  );
+  usePaste2(
+    (text) => {
+      if (state.paste(text) === "changed") setTick((tick) => tick + 1);
+    },
+    { isActive }
+  );
+  const question = state.question;
+  if (!question) return null;
+  const total = state.pending.request.questions.length;
+  const heading = /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color: palette.faint, children: `Question ${state.questionIndex + 1}/${total} \xB7 ${state.customMode ? "own answer" : question.type === "multiple" ? "select one or more" : "select one"}` }),
+    /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: question.question }),
+      question.description ? /* @__PURE__ */ jsx5(Text5, { color: palette.muted, children: question.description }) : null
+    ] })
+  ] });
+  if (state.customMode) {
+    const { col } = state.customInput.cursor;
+    const text = state.customInput.text;
+    return /* @__PURE__ */ jsxs5(Frame, { title: state.pending.request.message, footer: "Enter submit \xB7 Esc back to choices", children: [
+      heading,
+      /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: "Your answer" }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "> ",
+          text.slice(0, col),
+          /* @__PURE__ */ jsx5(Text5, { inverse: true, children: text.slice(col, col + 1) || " " }),
+          text.slice(col + 1)
+        ] }),
+        state.validationMessage ? /* @__PURE__ */ jsx5(Text5, { color: palette.danger, children: state.validationMessage }) : null
+      ] })
+    ] });
+  }
+  const otherIndex = question.options.length;
+  const otherAnswer = state.customAnswer(question.id);
+  return /* @__PURE__ */ jsxs5(
+    Frame,
+    {
+      title: state.pending.request.message,
+      footer: question.type === "multiple" ? "\u2191\u2193 navigate \xB7 Space toggle \xB7 Enter continue \xB7 Esc cancel" : "\u2191\u2193 navigate \xB7 Enter select \xB7 Esc cancel",
+      children: [
+        heading,
+        /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
+          question.options.map((option, index) => {
+            const cursor = index === state.selected;
+            const mark = question.type === "multiple" ? state.isSelected(question.id, option.id) ? "[x]" : "[ ]" : cursor ? "(o)" : "( )";
+            return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs5(Text5, { wrap: "truncate-end", children: [
+                /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: cursor ? ">" : " " }),
+                " ",
+                /* @__PURE__ */ jsx5(Text5, { color: mark === "[x]" ? palette.success : cursor ? palette.primary : void 0, children: mark }),
+                " ",
+                option.label,
+                option.recommended ? /* @__PURE__ */ jsx5(Text5, { color: palette.success, children: " (recommended)" }) : null
+              ] }),
+              option.description ? /* @__PURE__ */ jsx5(Box5, { paddingLeft: 6, children: /* @__PURE__ */ jsx5(Text5, { color: palette.muted, wrap: "truncate-end", children: option.description.replace(/[\r\n]+/g, " ") }) }) : null
+            ] }, option.id);
+          }),
+          /* @__PURE__ */ jsxs5(Text5, { wrap: "truncate-end", children: [
+            /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: state.selected === otherIndex ? ">" : " " }),
+            " ",
+            state.isSelected(question.id, OTHER_OPTION_ID2) ? /* @__PURE__ */ jsx5(Text5, { color: palette.success, children: "[x]" }) : "[ ]",
+            " ",
+            otherAnswer ? `Other: ${otherAnswer}` : "Other... (write your own answer)"
+          ] }),
+          state.validationMessage ? /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: palette.danger, children: state.validationMessage }) }) : null
+        ] })
+      ]
+    }
+  );
+}
+function PermissionDialog({
+  request,
+  onClose,
+  isActive = true
+}) {
+  useInput2(
+    (input, key) => {
+      if (permissionKey(request, input, key) === "closed") onClose();
+    },
+    { isActive }
+  );
+  const args = JSON.stringify(request.args, null, 2).split("\n");
+  const shown = args.slice(0, 12);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: palette.warning, paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { color: palette.warning, bold: true, children: request.title ?? `Permission requested: ${request.toolName}` }),
+    /* @__PURE__ */ jsx5(Text5, { color: palette.muted, children: `${request.toolName} \xB7 ${request.kind} tool` }),
+    /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, paddingLeft: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { children: shown.join("\n") }),
+      args.length > shown.length ? /* @__PURE__ */ jsx5(Text5, { color: palette.faint, children: `\u2026 ${args.length - shown.length} more lines` }) : null
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: "[a]" }),
+      " once  ",
+      /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: "[s]" }),
+      " this session",
+      "  ",
+      /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: "[w]" }),
+      " always  ",
+      /* @__PURE__ */ jsx5(Text5, { color: palette.danger, children: "[d]" }),
+      " deny"
+    ] }) })
+  ] });
+}
+function wrapPlain(text, width) {
+  const rows = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (line === "") {
+      rows.push("");
+      continue;
+    }
+    let current = "";
+    let currentWidth = 0;
+    for (const character of line) {
+      const characterWidth = stringWidth2(character);
+      if (currentWidth + characterWidth > width && current) {
+        rows.push(current);
+        current = "";
+        currentWidth = 0;
+      }
+      current += character;
+      currentWidth += characterWidth;
+    }
+    rows.push(current);
+  }
+  return rows;
+}
+
+// src/tui/ink/app.tsx
+import { Fragment as Fragment4, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var FRAME_MS = 120;
+var RESIZE_SETTLE_MS = 100;
+async function runInkTui(credentials, cwd, args, options = {}) {
+  const store = createStore({
+    messages: [],
+    plan: [],
+    pendingPermission: null,
+    pendingQuestion: null,
+    inputHistory: [],
+    busy: false,
+    mode: "chat",
+    // Never from the repository's .nova-ai/settings.json: a cloned repo must
+    // not be able to start Nova with approvals switched off.
+    permissionMode: fromAgentPermissionMode(savedPermissionMode(cwd)),
+    interactionMode: "agent",
+    sessionId: "",
+    cwd,
+    statusLine: null,
+    queuedCount: 0,
+    contextUsage: null,
+    updateAvailable: null
+  });
+  const runner = options.createRunner?.(store) ?? new SessionRunner(store, credentials, cwd);
+  const resumeIndex = args.indexOf("--resume");
+  const resumeId = resumeIndex >= 0 ? args[resumeIndex + 1] : void 0;
+  if (resumeId) runner.resumeFrom(resumeId);
+  else store.setState({ sessionId: runner.sessionId });
+  const stdout = options.stdout ?? process.stdout;
+  const stdin = options.stdin ?? process.stdin;
+  const kittyKeyboard = options.kittyKeyboard ?? kittyKeyboardOverride() ?? await detectKittyKeyboard(stdin, stdout);
+  const controller = new TuiController(store, runner, {
+    write: (data) => {
+      stdout.write(data);
+    }
+  });
+  const instance = render(/* @__PURE__ */ jsx6(App, { controller }), {
+    stdout,
+    stdin,
+    exitOnCtrlC: false,
+    patchConsole: true,
+    // Ink otherwise turns non-interactive whenever CI is set in the
+    // environment; the TUI only runs on a terminal anyway.
+    interactive: Boolean(stdout.isTTY),
+    kittyKeyboard: { mode: kittyKeyboard ? "enabled" : "disabled" }
+  });
+  controller.start();
+  const onSignal = () => controller.requestExit();
+  process.once("SIGTERM", onSignal);
+  let printedColumns = stdout.columns;
+  let resizeTimer;
+  const onResize = () => {
+    if (resizeTimer) clearTimeout(resizeTimer);
+    resizeTimer = setTimeout(() => {
+      if (stdout.columns === printedColumns) return;
+      printedColumns = stdout.columns;
+      controller.redrawAll();
+    }, RESIZE_SETTLE_MS);
+  };
+  stdout.on("resize", onResize);
+  void (options.checkForUpdate ?? checkForUpdate)().then((updateAvailable) => {
+    if (updateAvailable) store.setState({ updateAvailable });
+  });
+  try {
+    await controller.exitRequested;
+    await instance.waitUntilRenderFlush();
+    await controller.stop();
+  } finally {
+    process.off("SIGTERM", onSignal);
+    stdout.off("resize", onResize);
+    if (resizeTimer) clearTimeout(resizeTimer);
+    instance.unmount();
+    await instance.waitUntilExit().catch(() => {
+    });
+  }
+  stdout.write(`Resume this session with: nova-ai --resume ${runner.sessionId}
+`);
+}
+function App({ controller }) {
+  const view = useSyncExternalStore2(controller.subscribe, controller.getView);
+  const { rows, columns } = useWindowSize();
+  const bottomRef = useRef(null);
+  const bottom = useBoxMetrics(bottomRef);
+  const working = useWorking(view);
+  const { transcript } = view;
+  const scrollback = (
+    // <Static> is laid out as an absolute box; without a width its text
+    // wraps against its content and runs past the terminal edge.
+    /* @__PURE__ */ jsx6(Static, { items: [...transcript.committed], style: { width: columns }, children: (block) => /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(TranscriptBlockView, { block }) }, block.key) }, transcript.epoch)
+  );
+  if (view.exiting) return scrollback;
+  const liveRows = Math.max(3, rows - (bottom.hasMeasured ? bottom.height : 6) - 2);
+  const dialogRows = Math.max(6, rows - 4);
+  return /* @__PURE__ */ jsxs6(Fragment4, { children: [
+    scrollback,
+    /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", maxHeight: liveRows, overflowY: "hidden", justifyContent: "flex-end", children: /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", flexShrink: 0, children: [
+      transcript.live.map((block) => /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(TranscriptBlockView, { block, frame: working.frame }) }, block.key)),
+      working.line ? /* @__PURE__ */ jsx6(Box6, { marginTop: 1, paddingLeft: 1, children: /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: palette.accent, children: WORKING_FRAMES[working.frame] }),
+        /* @__PURE__ */ jsx6(Text6, { color: palette.muted, children: ` ${working.line}` })
+      ] }) }) : null
+    ] }) }),
+    /* @__PURE__ */ jsxs6(Box6, { ref: bottomRef, flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Surface, { controller, view, rows: dialogRows, columns }),
+      /* @__PURE__ */ jsx6(StatusLine, { ui: view.ui, model: view.model, mcp: view.mcp })
+    ] })
+  ] });
+}
+function Surface({
+  controller,
+  view,
+  rows,
+  columns
+}) {
+  if (view.question) return /* @__PURE__ */ jsx6(QuestionDialog, { state: view.question }, view.question.pending.id);
+  const permission = view.ui.pendingPermission;
+  if (permission)
+    return /* @__PURE__ */ jsx6(PermissionDialog, { request: permission, onClose: () => {
+    } }, permission.toolCallId);
+  const overlay = view.overlay;
+  if (overlay?.kind === "selection")
+    return /* @__PURE__ */ jsx6(SelectionDialog, { title: overlay.title, state: overlay.state, height: rows });
+  if (overlay?.kind === "text")
+    return /* @__PURE__ */ jsx6(
+      ScrollPanel,
+      {
+        title: overlay.title,
+        content: overlay.content,
+        state: overlay.state,
+        height: rows,
+        width: columns
+      }
+    );
+  if (overlay?.kind === "tools") return /* @__PURE__ */ jsx6(ToolInspector, { state: overlay.state, height: rows, width: columns });
+  return /* @__PURE__ */ jsx6(
+    PromptInput,
+    {
+      editor: controller.editor,
+      busy: view.ui.busy,
+      maxRows: Math.max(3, Math.floor(rows / 3)),
+      onKey: (input, key) => controller.handlePromptKey(input, key)
+    }
+  );
+}
+function useWorking(view) {
+  const busy = view.ui.busy;
+  const pendingTool = view.ui.messages.some(
+    (message) => message.role === "tool" && message.call.status === "pending"
+  );
+  const animating = busy || pendingTool;
+  const [frame, setFrame] = useState2(0);
+  const startedAt = useRef(null);
+  if (busy && startedAt.current === null) startedAt.current = Date.now();
+  if (!busy) startedAt.current = null;
+  useEffect(() => {
+    if (!animating) {
+      setFrame(0);
+      return;
+    }
+    const timer = setInterval(() => setFrame((value) => (value + 1) % WORKING_FRAMES.length), FRAME_MS);
+    return () => clearInterval(timer);
+  }, [animating]);
+  if (!busy || pendingTool || view.ui.pendingPermission || view.question) return { frame, line: null };
+  const elapsed = formatElapsedTime(Date.now() - (startedAt.current ?? Date.now()));
+  return { frame, line: `Working (${elapsed} \u2022 esc to interrupt)` };
+}
+
+// src/tui/index.ts
+async function runChat(options) {
+  const stored = readCredentials();
+  if (!stored) {
+    console.error("nova-ai isn't connected to a Nova AI account yet. Run `nova-ai login` first.");
+    return 1;
+  }
+  const credentials = options.model ? { ...stored, defaultModel: options.model } : stored;
+  const cwd = process.cwd();
+  let resume = options.resume;
+  if (options.continueLast) {
+    resume = listStoredSessions2(cwd)[0]?.sessionId ?? null;
+    if (!resume) {
+      console.error(`No earlier session in ${cwd} to continue.`);
+      return 1;
+    }
+  }
+  if (workspaceNeedsTrust(cwd)) await askToTrust(cwd);
+  const args = resume ? ["--resume", resume] : [];
+  await runInkTui(credentials, cwd, args);
+  return 0;
+}
+async function askToTrust(cwd) {
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log(`
+${cwd}`);
+    console.log("This workspace declares MCP servers and/or permission allow rules in .mcp.json or .nova-ai/.");
+    console.log("Trusting it starts those servers and applies those rules. Only trust code you know.");
+    const answer = (await prompt.question("Trust this workspace? [y/N] ")).trim().toLowerCase();
+    if (answer === "y" || answer === "yes") {
+      setWorkspaceTrusted2(cwd, true);
+    } else {
+      console.log("Not trusted: its MCP servers stay off and its allow rules are ignored. Use /trust later to change this.");
+    }
+  } finally {
+    prompt.close();
+  }
+}
+var tui_default = runChat;
+export {
+  tui_default as default,
+  runChat
+};