@rind-ai/cli 0.4.1 → 0.6.1

package/lib/frontend-cli-implementation.js

@@ -1,1111 +1,656 @@
-#!/usr/bin/env node
-
-import { createInterface } from "node:readline";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
-
-import { AssistantRenderer } from "./assistant-renderer.js";
-import { createAssistantStreamBuffer } from "./assistant-stream-buffer.js";
-import { createCompactContextState } from "./compact-context-state.js";
-import { prepareComposerFrame } from "./composer-terminal.js";
-import { createLineEditor } from "./line-editor.js";
-import { createRuntimeClient, runHelpVersion } from "./runtime-client.js";
-import { createTurnController } from "./turn-controller.js";
-import { createCommandController } from "./command-controller.js";
-import { createBackgroundController } from "./background-controller.js";
-import { createEventController } from "./event-controller.js";
-import { createInputController } from "./input-controller.js";
-import { isInputClosed } from "./input-errors.js";
-import { sigintAction } from "./interrupt-state.js";
-import { createModelMenuState } from "./model-menu-state.js";
-import { createChoiceMenuState } from "./choice-menu-state.js";
-import { createSlashMenuState } from "./slash-menu-state.js";
-import { parseTerminalKey } from "./terminal-key.js";
-import { createTerminalUI } from "./terminal-ui.js";
-import {
-  answerPromptText,
-  answerPlaceholderText,
-  commandResultText,
-  goalCommandText,
-  assistantHeaderText,
-  inputHintText,
-  interruptText,
-  modelListErrorText,
-  modelMenuText,
-  choiceMenuText,
-  sessionMenuText,
-  sessionSwitchedText,
-  outputBlockText,
-  promptPlaceholderText,
-  promptText,
-  questionText,
-  queuedInputText,
-  slashMenuText,
-  startupText,
-  userInputText,
-} from "./rendering.js";
-
-export async function runFrontendCliApp(cliArgs = process.argv.slice(2)) {
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const repoRoot = path.resolve(scriptDir, "..", "..");
-const python = process.env.RIND_PYTHON || "python";
-const runtimePath = process.env.RIND_RUNTIME_PATH || resolveInstalledRuntime();
-
-function resolveInstalledRuntime() {
-  const packageNames = {
-    win32: "@rind-ai/runtime-win32-x64",
-    linux: "@rind-ai/runtime-linux-x64",
-    darwin: process.arch === "arm64" ? "@rind-ai/runtime-darwin-arm64" : "@rind-ai/runtime-darwin-x64",
-  };
-  const packageName = packageNames[process.platform];
-  if (!packageName) return "";
-  try {
-    const packageRoot = path.dirname(createRequire(import.meta.url).resolve(`${packageName}/package.json`));
-    return path.join(packageRoot, "bin", process.platform === "win32" ? "rind-runtime.exe" : "rind-runtime");
-  } catch {
-    return "";
-  }
-}
-
-if (cliArgs.some((arg) => arg === "--version" || arg === "--help" || arg === "-h")) {
-  process.exit(runHelpVersion({ python, repoRoot, runtimePath, cliArgs }));
-}
-
-let activeTurn = false;
-let activeCompact = false;
-let interruptRequested = false;
-let input = null;
-let inputActive = false;
-let runtimeClosing = false;
-let processExitTimer = null;
-let cancelActiveInput = null;
-let sessionInfo = {};
-let latestStats = {};
-let slashCommands = [];
-let turnTools = { completed: 0, failed: 0 };
-let pendingInputPrefill = "";
-let assistantOutputLineOpen = false;
-let assistantHeaderShown = false;
-let outputStarted = false;
-let promptPaused = false;
-let activityFrame = 0;
-let activityTimer = null;
-let activityStartedAt = 0;
-const assistantStreamBuffer = createAssistantStreamBuffer();
-const assistantRenderer = new AssistantRenderer((text) => writeOutput(text));
-const compactContextState = createCompactContextState();
-const terminalUi = process.stdin.isTTY && process.stdout.isTTY
-  ? createTerminalUI({ input: process.stdin, output: process.stdout, render: renderActiveInput })
-  : null;
-const promptEditor = createLineEditor();
-let activeInputSession = null;
-const runtimeClient = createRuntimeClient({
-  python,
-  repoRoot,
-  runtimePath,
-  cliArgs,
-  onMessage: (message) => void renderEvent(message).catch((error) => {
-    if (!runtimeClosing) {
-      writeErrorOutput(`${error instanceof Error ? error.message : String(error)}\n`);
-    }
-  }),
-  onStderr: (chunk) => writeErrorOutput(chunk),
-  onExit: (code, signal, { error }) => {
-    if (!runtimeClosing) {
-      writeErrorOutput(`Runtime stopped (${signal || (code ?? "startup failure")}): ${error.message}. Restart Rind to continue.\n`);
-    }
-    process.exitCode = runtimeClosing ? 0 : (code || 1);
-    closeInput();
-    if (runtimeClosing) {
-      scheduleProcessExit(process.exitCode ?? 0, 0);
-    }
-  },
-});
-const request = runtimeClient.request;
-const turnState = {
-  get activeTurn() {
-    return activeTurn;
-  },
-  set activeTurn(value) {
-    activeTurn = Boolean(value);
-  },
-  get interruptRequested() {
-    return interruptRequested;
-  },
-  set interruptRequested(value) {
-    interruptRequested = Boolean(value);
-  },
-  get turnTools() {
-    return turnTools;
-  },
-  set turnTools(value) {
-    turnTools = value;
-  },
-  get runtimeClosing() {
-    return runtimeClosing;
-  },
-};
-const turnController = createTurnController({
-  request,
-  state: turnState,
-  refreshGoalState,
-  onTurnStart: () => {
-    assistantHeaderShown = false;
-  },
-  output: {
-    logQueuedInput: (text) => logOutput(queuedInputText(text)),
-    restoreInputText,
-    writeError: (text) => writeErrorOutput(`${text}\n`),
-    refreshInputState,
-    resetTurnTools,
-    closeAssistant,
-    cancelInput,
-    logInterrupt: () => logOutput(interruptText()),
-  },
-});
-const commandController = createCommandController({
-  request,
-  turn: turnController,
-  input: {
-    isTerminal: Boolean(terminalUi),
-    runGoalCommand,
-    runModelSelector,
-    startCompactCommand,
-    runSessionsSelector,
-    startReadonlySlashCommand,
-  },
-  state: {
-    get slashCommands() {
-      return slashCommands;
-    },
-  },
-  output: {
-    log: logOutput,
-    clearScreen: () => withSuspendedPrompt(() => console.clear()),
-    resetContextUsage,
-    setInputPrefill: (value) => {
-      pendingInputPrefill = value;
-    },
-    shutdown: shutdownRuntime,
-    exit: () => process.exit(0),
-  },
-});
-const backgroundController = createBackgroundController({
-  request,
-  terminalUi: Boolean(terminalUi),
-  state: {
-    get runtimeClosing() {
-      return runtimeClosing;
-    },
-    get sessionInfo() {
-      return sessionInfo;
-    },
-    set sessionInfo(value) {
-      sessionInfo = value;
-    },
-    get inputActive() {
-      return inputActive;
-    },
-    set inputActive(value) {
-      inputActive = Boolean(value);
-    },
-  },
-  redraw: redrawInput,
-  log: logOutput,
-});
-const eventController = createEventController({
-  state: {
-    get runtimeClosing() {
-      return runtimeClosing;
-    },
-    get activeTurn() {
-      return activeTurn;
-    },
-    debug: cliArgs.includes("--debug"),
-  },
-  input: { answerQuestion },
-  background: backgroundController,
-  output: {
-    assistantAppend: (text) => assistantRenderer.append(text),
-    handleContextBuilt: (event) => compactContextState.handleContextBuilt(event),
-    resetContextUsage,
-    closeAssistant,
-    log: logOutput,
-    debug: (text) => writeErrorOutput(`${text}\n`),
-    updateGoal: updateGoalState,
-    setStats: (stats) => {
-      latestStats = stats;
-    },
-    redraw: redrawInput,
-    clearCompactContext: () => compactContextState.clear(),
-    resetTurnTools,
-  },
-});
-const inputController = createInputController({
-  terminalUi,
-  state: {
-    get runtimeClosing() {
-      return runtimeClosing;
-    },
-    get promptPaused() {
-      return Boolean(promptPaused);
-    },
-    set promptPaused(value) {
-      promptPaused = Boolean(value);
-    },
-  },
-  askInput: ask,
-  onSubmit: (text) => turnController.submit(text),
-  onCommand: (text) => commandController.handle(text),
-  onSigint: handleSigint,
-  onPaste: handleTerminalPaste,
-  onInput: handleTerminalInput,
-  cancelInput,
-  renderPrompt: redrawInput,
-  prompt: mainPromptText,
-  placeholder: promptPlaceholderText,
-});
-
-process.on("SIGINT", handleSigint);
-
-try {
-  const info = await request("initialize");
-  sessionInfo = { cwd: process.cwd(), ...(info || {}) };
-  slashCommands = commandController.normalizeCommands(info?.slash_commands);
-  if (terminalUi) {
-    inputController.start();
-  } else {
-    input = createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      historySize: 100,
-      removeHistoryDuplicates: true,
-    });
-    process.stdin.on("data", handleStdinData);
-  }
-  if (terminalUi) {
-    void backgroundController.refresh().catch(() => {});
-  }
-  logOutput(startupText(info));
-  await inputController.promptLoop();
-} catch (error) {
-  closeAssistant();
-  if (!isInputClosed(error)) {
-    writeErrorOutput(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-  }
-} finally {
-  closeRuntime();
-}
-
-async function runGoalCommand(command) {
-  if (command.action === "set" && turnState.activeTurn) {
-    logOutput(commandResultText("Goal not started", "pause or finish the active turn first"));
-    return;
-  }
-  try {
-    if (command.action === "set") {
-      const result = await request("goal.set", { objective: command.objective });
-      updateGoalState(result?.goal);
-      logOutput(goalCommandText(result?.goal, "set"));
-      turnController.submit(command.objective);
-      return;
-    }
-    if (command.action === "clear") {
-      const result = await request("goal.clear");
-      updateGoalState(result?.goal || null);
-      logOutput(goalCommandText(null, "clear"));
-      return;
-    }
-    if (command.action === "pause" || command.action === "resume") {
-      const result = await request("goal.status", { status: command.action === "resume" ? "active" : "paused" });
-      updateGoalState(result?.goal);
-      logOutput(goalCommandText(result?.goal, command.action));
-      if (command.action === "resume" && !turnState.activeTurn) {
-        turnController.submit("", { goal_continuation: true });
-      }
-      return;
-    }
-    const result = await request("goal.get");
-    updateGoalState(result?.goal || null);
-    logOutput(goalCommandText(result?.goal || null));
-  } catch (error) {
-    logOutput(`Goal command failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-function updateGoalState(goal) {
-  sessionInfo = { ...sessionInfo, goal: goal && typeof goal === "object" ? goal : null };
-  redrawInput();
-}
-
-async function refreshGoalState() {
-  if (!Array.isArray(sessionInfo.capabilities) || !sessionInfo.capabilities.includes("goals")) {
-    return;
-  }
-  try {
-    const result = await request("goal.get");
-    updateGoalState(result?.goal || null);
-  } catch {
-    // The turn result remains usable when a late state refresh races shutdown.
-  }
-}
-
-async function runSessionsSelector() {
-  let result;
-  try {
-    result = await request("slash.execute", { input: "/sessions" });
-  } catch (error) {
-    logOutput(`Command failed: ${error instanceof Error ? error.message : String(error)}`);
-    return;
-  }
-  const sessions = Array.isArray(result?.display?.sessions) ? result.display.sessions : [];
-  if (!sessions.length) {
-    await commandController.applyResult(result);
-    return;
-  }
-  const currentId = String(result?.display?.current_session_id || sessionInfo.session_id || "");
-  const options = sessions.map((session) => sessionMenuOption(session));
-  const currentIndex = sessions.findIndex((session) => String(session?.id || "") === currentId);
-  const selected = await askSessionMenu(options, sessions, currentIndex);
-  if (!selected || runtimeClosing || selected.id === currentId) {
-    return;
-  }
-  try {
-    const update = await request("session.switch", { session_id: selected.id });
-    backgroundController.clear();
-    sessionInfo = {
-      ...sessionInfo,
-      session_id: update?.session_id || selected.id,
-      model: update?.model || sessionInfo.model,
-      resume_preview: update?.resume_preview || "",
-      goal: update?.goal || null,
-      background_count: 0,
-    };
-    latestStats = update?.usage && typeof update.usage === "object" ? update.usage : {};
-    compactContextState.clear();
-    logOutput(sessionSwitchedText(sessionInfo));
-    redrawInput();
-    void backgroundController.refresh().catch(() => {});
-  } catch (error) {
-    logOutput(`Session switch failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-function sessionMenuOption(session) {
-  const id = singleLineText(session?.id) || "unknown";
-  const title = singleLineText(session?.title);
-  const updated = singleLineText(session?.updated_at);
-  const marker = session?.current ? "current" : "";
-  return [id, title, updated, marker].filter(Boolean).join(" · ");
-}
-
-function startReadonlySlashCommand(text) {
-  void runReadonlySlashCommand(text).catch((error) => {
-    if (!runtimeClosing) {
-      writeErrorOutput(`${error instanceof Error ? error.message : String(error)}\n`);
-    }
-  });
-}
-
-async function runReadonlySlashCommand(text) {
-  const result = await request("slash.execute", { input: text });
-  await commandController.applyResult(result);
-}
-
-function startCompactCommand() {
-  if (activeCompact) {
-    logOutput("Compact is already running.");
-    return;
-  }
-  activeCompact = true;
-  interruptRequested = false;
-  refreshInputState();
-  void runCompactCommand().catch((error) => {
-    if (!runtimeClosing) {
-      writeErrorOutput(`${error instanceof Error ? error.message : String(error)}\n`);
-    }
-  });
-}
-
-async function runCompactCommand() {
-  try {
-    const result = await request("slash.execute", { input: "/compact" });
-    await commandController.applyResult(result);
-  } finally {
-    activeCompact = false;
-    interruptRequested = false;
-    refreshInputState();
-  }
-}
-
-async function runModelSelector() {
-  let result;
-  try {
-    result = await request("models.list");
-  } catch (error) {
-    logOutput(modelListErrorText(error instanceof Error ? error.message : String(error), sessionInfo.model));
-    return;
-  }
-
-  const currentModel = result?.current_model || sessionInfo.model || result?.default_model || "";
-  const selected = await askModelMenu(result?.models || [], currentModel);
-  if (!selected || runtimeClosing) {
-    return;
-  }
-
-  try {
-    const update = await request("model.set", { model: selected });
-    sessionInfo = { ...sessionInfo, model: update?.model || selected };
-    logOutput(modelSetResultText(update, selected));
-  } catch (error) {
-    logOutput(`Command failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-function modelSetResultText(result, model) {
-  const sessionModel = singleLineText(result?.session_model || result?.model || model);
-  const defaultModel = singleLineText(result?.default_model);
-  const lines = ["Session model updated."];
-  if (sessionModel) {
-    lines.push(`- session model: ${sessionModel}`);
-  }
-  if (defaultModel) {
-    lines.push(`- default model: ${defaultModel} (unchanged)`);
-  }
-  if (result?.active_updated || result?.runtime || result?.session) {
-    lines.push("- active session: updated");
-  } else {
-    lines.push("- active session: unchanged; start a new session to use this model");
-  }
-  return commandResultText(lines[0], lines.slice(1).join(" · "));
-}
-
-function restoreInputText(text) {
-  pendingInputPrefill = String(text || "");
-  if (activeInputSession?.editor) {
-    activeInputSession.editor.setInput(pendingInputPrefill);
-    pendingInputPrefill = "";
-    redrawInput();
-  }
-}
-
-function inputState() {
-  const running = activeTurn || activeCompact;
-  return {
-    running,
-    label: activeCompact ? "Compacting" : "Working",
-    frame: activityFrame,
-    elapsedMs: running ? Date.now() - activityStartedAt : 0,
-  };
-}
-
-function mainPromptText() {
-  return promptText(sessionInfo, latestStats, inputState());
-}
-
-function refreshInputState() {
-  updateActivityTimer();
-  redrawInput();
-}
-
-function resetContextUsage() {
-  latestStats = { context_usage_percent: 0 };
-  redrawInput();
-}
-
-function redrawInput(force = false) {
-  if (!inputActive || runtimeClosing || !terminalUi) {
-    return;
-  }
-  terminalUi.requestRender(force);
-}
-
-function updateActivityTimer() {
-  if (activeTurn || activeCompact) {
-    if (!activityStartedAt) {
-      activityStartedAt = Date.now();
-    }
-    if (activityTimer) {
-      return;
-    }
-    activityTimer = setInterval(() => {
-      activityFrame += 1;
-      redrawInput();
-    }, 300);
-    activityTimer.unref?.();
-    return;
-  }
-  clearActivityTimer();
-}
-
-function clearActivityTimer() {
-  if (!activityTimer) {
-    return;
-  }
-  clearInterval(activityTimer);
-  activityTimer = null;
-  activityFrame = 0;
-  activityStartedAt = 0;
-}
-
-function logOutput(text) {
-  flushAssistantText(assistantStreamBuffer.flush(), { redraw: true });
-  withSuspendedPrompt(() => {
-    closeOpenAssistantOutputLine();
-    process.stdout.write(outputBlockText(text, outputStarted));
-    outputStarted = true;
-  });
-}
-
-function writeOutput(text) {
-  const holdPartialLine = inputActive && Boolean(terminalUi);
-  flushAssistantText(assistantStreamBuffer.push(text, holdPartialLine));
-}
-
-function flushAssistantText(text = "", options = {}) {
-  const output = String(text || "");
-  if (!output) {
-    return;
-  }
-  withSuspendedPrompt(() => {
-    writeAssistantHeader();
-    process.stdout.write(output);
-    assistantOutputLineOpen = output ? !output.endsWith("\n") : assistantOutputLineOpen;
-  }, { redraw: options.redraw !== false });
-}
-
-function writeUserInput(text) {
-  const line = userInputText(text);
-  if (!line) {
-    return;
-  }
-  flushAssistantText(assistantStreamBuffer.flush(), { redraw: false });
-  closeOpenAssistantOutputLine();
-  process.stdout.write(outputBlockText(line, outputStarted));
-  outputStarted = true;
-}
-
-function writeErrorOutput(text) {
-  flushAssistantText(assistantStreamBuffer.flush(), { redraw: true });
-  withSuspendedPrompt(() => process.stderr.write(String(text || "")));
-}
-
-function withSuspendedPrompt(action, options = {}) {
-  if (!terminalUi || !inputActive || runtimeClosing) {
-    action();
-    return;
-  }
-  terminalUi.withSuspended(action, { render: options.redraw !== false });
-}
-
-function closeOpenAssistantOutputLine() {
-  if (!assistantOutputLineOpen) {
-    return;
-  }
-  process.stdout.write("\n");
-  assistantOutputLineOpen = false;
-}
-
-function writeAssistantHeader() {
-  if (assistantHeaderShown) {
-    return;
-  }
-  process.stdout.write(outputBlockText(assistantHeaderText(), outputStarted));
-  outputStarted = true;
-  assistantHeaderShown = true;
-}
-
-async function renderEvent(message) {
-  return eventController.handle(message);
-}
-
-function resetTurnTools() {
-  turnTools = { completed: 0, failed: 0 };
-}
-
-async function answerQuestion(event) {
-  pausePrompt();
-  closeAssistant();
-  logOutput(questionText(event));
-  try {
-    const options = Array.isArray(event.options) ? event.options : [];
-    const answer = terminalUi && options.length
-      ? await askChoiceMenu(event)
-      : selectAnswer((await ask(answerPromptText(), answerPlaceholderText())).trim(), options);
-    if (interruptRequested || runtimeClosing) {
-      return;
-    }
-    await request("user_question.respond", {
-      tool_call_id: event.tool_call_id,
-      answer,
-    });
-  } finally {
-    resumePrompt();
-  }
-}
-
-function selectAnswer(raw, options) {
-  const index = Number(raw);
-  if (Number.isInteger(index) && index >= 1 && index <= options.length) {
-    return options[index - 1];
-  }
-  return raw;
-}
-
-function ask(prompt, placeholder = "") {
-  if (!terminalUi) {
-    if (!input) {
-      return Promise.reject(new Error("Input is not available"));
-    }
-    return askLine(promptValue(prompt));
-  }
-  return askTtyInput(prompt, placeholder);
-}
-
-function askLine(prompt) {
-  return new Promise((resolve, reject) => {
-    const cleanup = () => {
-      inputActive = false;
-      input.off("close", onClose);
-      if (cancelActiveInput === onCancel) {
-        cancelActiveInput = null;
-      }
-    };
-    const onClose = () => {
-      cleanup();
-      reject(new Error("Input closed"));
-    };
-    const onCancel = () => {
-      cleanup();
-      resolve("");
-    };
-    input.once("close", onClose);
-    cancelActiveInput = onCancel;
-    inputActive = true;
-    input.question(prompt, (answer) => {
-      cleanup();
-      resolve(answer);
-    });
-    applyInputPrefill();
-  });
-}
-
-function askTtyInput(prompt, placeholder) {
-  return new Promise((resolve) => {
-    clearAssistantLineForInput();
-    const mode = placeholder && placeholder !== answerPlaceholderText() ? "prompt" : "line";
-    const initialInput = pendingInputPrefill;
-    const editor = mode === "prompt" ? promptEditor : createLineEditor(initialInput);
-    if (mode === "prompt") {
-      editor.setInput(initialInput);
-    }
-    editor.setViewportWidth(process.stdout.columns || 80);
-    const menuState = mode === "prompt" ? createSlashMenuState(slashCommands) : null;
-    pendingInputPrefill = "";
-    const session = { mode, prompt, placeholder, editor, menuState, resolve };
-    activeInputSession = session;
-    inputActive = true;
-    cancelActiveInput = () => completeTtyInput(session, "", false);
-    redrawInput(true);
-  });
-}
-
-function clearAssistantLineForInput() {
-  if (!assistantOutputLineOpen) {
-    return;
-  }
-  if (terminalUi) {
-    terminalUi.withSuspended(closeOpenAssistantOutputLine, { render: false });
-  } else {
-    closeOpenAssistantOutputLine();
-  }
-}
-
-function renderActiveInput(width = process.stdout.columns || 80) {
-  if (backgroundController.isMonitoring()) {
-    return backgroundController.frame(width);
-  }
-  const session = activeInputSession;
-  if (!session) {
-    return { lines: [], cursorRow: 0, cursorColumn: 0 };
-  }
-  if (session.mode === "model") {
-    return prepareComposerFrame({
-      prompt: mainPromptText(),
-      inputText: session.inputText,
-      cursor: { line: 0, column: session.inputText.length },
-      menuText: modelMenuText(session.modelState.items(), session.modelState.selectedIndex()).trimEnd(),
-    }, width);
-  }
-  if (session.mode === "choice") {
-    return prepareComposerFrame({
-      prompt: mainPromptText(),
-      inputText: session.question,
-      cursor: { line: 0, column: session.question.length },
-      menuText: choiceMenuText(session.choiceState.options(), session.choiceState.selectedIndex(), session.recommended).trimEnd(),
-    }, width);
-  }
-  if (session.mode === "sessions") {
-    return prepareComposerFrame({
-      prompt: mainPromptText(),
-      inputText: session.inputText,
-      cursor: { line: 0, column: session.inputText.length },
-      menuText: sessionMenuText(session.choiceState.options(), session.choiceState.selectedIndex()).trimEnd(),
-    }, width);
-  }
-  session.editor.setViewportWidth(width);
-  const matches = session.menuState ? syncSlashMenu(session) : [];
-  return prepareComposerFrame({
-    prompt: promptValue(session.prompt),
-    inputText: session.editor.input(),
-    cursor: session.editor.cursorPosition(),
-    placeholder: session.mode === "prompt" ? inputHintText(session.placeholder) : "",
-    menuText: session.menuState ? slashMenuText(matches, session.menuState.selectedIndex()).trimEnd() : "",
-  }, width);
-}
-
-function syncSlashMenu(session) {
-  session.menuState.setInput(session.editor.input());
-  return session.menuState.matches();
-}
-
-function handleTerminalInput(raw = "") {
-  const event = parseTerminalKey(raw);
-  if (!event) {
-    return;
-  }
-  if (event.ctrl && event.name === "c") {
-    handleSigint();
-    return;
-  }
-  if (backgroundController.isMonitoring()) {
-    backgroundController.handleInput(event);
-    return;
-  }
-  if (event.ctrl && event.name === "b") {
-    backgroundController.enterMonitor();
-    return;
-  }
-  const session = activeInputSession;
-  if (!session) {
-    return;
-  }
-  if (session.mode === "model") {
-    handleModelInput(session, event);
-    return;
-  }
-  if (session.mode === "choice") {
-    handleChoiceInput(session, event);
-    return;
-  }
-  if (session.mode === "sessions") {
-    handleSessionInput(session, event);
-    return;
-  }
-  const key = event;
-  const matches = session.menuState ? syncSlashMenu(session) : [];
-  const menuKey = !key.ctrl && !key.alt && !key.shift && ["escape", "up", "down"].includes(key.name);
-  if (session.menuState && matches.length && menuKey) {
-    if (session.menuState.handleKey("", key)) {
-      redrawInput();
-      return;
-    }
-  }
-  const result = session.editor.handleInput(key);
-  if (result === "submit") {
-    submitTtyInput(session);
-    return;
-  }
-  if (result) {
-    redrawInput();
-  }
-}
-
-function handleTerminalPaste(text) {
-  if (backgroundController.isMonitoring()) {
-    return;
-  }
-  const session = activeInputSession;
-  if (!session || session.mode === "model" || session.mode === "choice" || session.mode === "sessions") {
-    return;
-  }
-  session.editor.handleInput({ kind: "paste", text });
-  redrawInput();
-}
-
-function handleModelInput(session, key) {
-  const modified = key.ctrl || key.alt || key.shift;
-  if (!modified && (key.name === "enter" || key.name === "return")) {
-    const model = session.modelState.selectedModel()?.name || "";
-    completeTtyInput(session, model, Boolean(model), "", model ? `/model set ${model}` : "");
-    return;
-  }
-  if (!modified && key.name === "escape") {
-    completeTtyInput(session, "", false);
-    return;
-  }
-  if (!modified && session.modelState.handleKey(key)) {
-    redrawInput();
-  }
-}
-
-function submitTtyInput(session) {
-  if (session.menuState) {
-    syncSlashMenu(session);
-  }
-  const command = session.menuState?.selectedCommand();
-  const value = command ? `/${command.name}` : session.editor.input();
-  if (session.mode === "prompt") {
-    session.editor.addToHistory(value);
-  }
-  completeTtyInput(session, value, session.mode === "prompt", session.mode === "line" ? "\n" : "");
-}
-
-function completeTtyInput(session, value, writeUser, lineText = "", displayValue = value) {
-  if (activeInputSession !== session) {
-    return;
-  }
-  activeInputSession = null;
-  inputActive = false;
-  if (cancelActiveInput) {
-    cancelActiveInput = null;
-  }
-  const writeAction = () => {
-    if (writeUser) {
-      writeUserInput(displayValue);
-    } else if (lineText && String(value || "").trim()) {
-      process.stdout.write("\n");
-    }
-  };
-  if (terminalUi) {
-    terminalUi.withSuspended(writeAction, { render: false });
-  } else {
-    writeAction();
-  }
-  session.resolve(value);
-}
-
-function askModelMenu(models, currentModel) {
-  return new Promise((resolve) => {
-    clearAssistantLineForInput();
-    const state = createModelMenuState(models, currentModel);
-    if (!state.items().length) {
-      resolve("");
-      return;
-    }
-    const session = {
-      mode: "model",
-      inputText: "/model",
-      modelState: state,
-      resolve,
-    };
-    activeInputSession = session;
-    inputActive = true;
-    cancelActiveInput = () => completeTtyInput(session, "", false);
-    redrawInput(true);
-  });
-}
-
-function askChoiceMenu(event) {
-  return new Promise((resolve) => {
-    clearAssistantLineForInput();
-    const state = createChoiceMenuState(event.options, event.recommended);
-    const session = {
-      mode: "choice",
-      question: String(event.question || "Input required"),
-      choiceState: state,
-      recommended: event.recommended || "",
-      resolve,
-    };
-    activeInputSession = session;
-    inputActive = true;
-    cancelActiveInput = () => completeTtyInput(session, "", false);
-    redrawInput(true);
-  });
-}
-
-function askSessionMenu(options, sessions, currentIndex) {
-  return new Promise((resolve) => {
-    clearAssistantLineForInput();
-    const state = createChoiceMenuState(options, options[currentIndex] || "");
-    const session = {
-      mode: "sessions",
-      inputText: "/sessions",
-      choiceState: state,
-      sessions,
-      resolve,
-    };
-    activeInputSession = session;
-    inputActive = true;
-    cancelActiveInput = () => completeTtyInput(session, null, false);
-    redrawInput(true);
-  });
-}
-
-function handleChoiceInput(session, key) {
-  const modified = key.ctrl || key.alt || key.shift;
-  if (!modified && (key.name === "enter" || key.name === "return")) {
-    completeTtyInput(session, session.choiceState.selectedOption(), false);
-    return;
-  }
-  if (!modified && key.name === "escape") {
-    completeTtyInput(session, "", false);
-    return;
-  }
-  if (!modified && session.choiceState.handleKey(key)) {
-    redrawInput();
-  }
-}
-
-function handleSessionInput(session, key) {
-  const modified = key.ctrl || key.alt || key.shift;
-  if (!modified && (key.name === "enter" || key.name === "return")) {
-    const index = session.choiceState.selectedIndex();
-    completeTtyInput(session, session.sessions[index] || null, false);
-    return;
-  }
-  if (!modified && key.name === "escape") {
-    completeTtyInput(session, null, false);
-    return;
-  }
-  if (!modified && session.choiceState.handleKey(key)) {
-    redrawInput();
-  }
-}
-
-function singleLineText(value) {
-  return String(value || "").replace(/\s+/g, " ").trim();
-}
-
-function pausePrompt() {
-  inputController.pause();
-}
-
-function resumePrompt() {
-  inputController.resume();
-}
-
-function applyInputPrefill() {
-  if (!pendingInputPrefill) {
-    return;
-  }
-  const text = pendingInputPrefill;
-  pendingInputPrefill = "";
-  input.write(text);
-}
-
-function promptValue(prompt) {
-  return typeof prompt === "function" ? prompt() : prompt;
-}
-
-
-
-function handleSigint() {
-  const action = sigintAction({ activeTurn: activeTurn || activeCompact, interruptRequested, runtimeClosing });
-  if (action === "interrupt") {
-    interruptTurn();
-  } else {
-    exitFromSignal();
-  }
-}
-
-function interruptTurn() {
-  turnController.interrupt();
-}
-
-function handleStdinData(chunk) {
-  if (Buffer.from(chunk).includes(3)) {
-    handleSigint();
-  }
-}
-
-function exitFromSignal() {
-  if (runtimeClosing) {
-    forceCloseRuntime();
-    scheduleProcessExit(0, 0);
-    return;
-  }
-  void shutdownRuntime();
-}
-
-function closeAssistant() {
-  assistantRenderer.finish();
-  flushAssistantText(assistantStreamBuffer.flush());
-  assistantHeaderShown = false;
-}
-
-function closeRuntime() {
-  if (runtimeClosing) {
-    return;
-  }
-  runtimeClosing = true;
-  clearActivityTimer();
-  backgroundController.stop();
-  void runtimeClient.shutdown();
-  closeInput();
-}
-
-function forceCloseRuntime() {
-  runtimeClosing = true;
-  clearActivityTimer();
-  backgroundController.stop();
-  closeInput();
-  runtimeClient.forceShutdown();
-}
-
-function cancelInput() {
-  const cancel = cancelActiveInput;
-  cancelActiveInput = null;
-  cancel?.();
-}
-
-async function shutdownRuntime() {
-  if (runtimeClosing) {
-    return;
-  }
-  runtimeClosing = true;
-  clearActivityTimer();
-  backgroundController.stop();
-  try {
-    await runtimeClient.shutdown();
-  } catch {
-    runtimeClient.forceShutdown();
-  } finally {
-    runtimeClient.closeInput();
-    closeInput();
-  }
-}
-
-function scheduleProcessExit(code, delayMs) {
-  if (processExitTimer) {
-    return;
-  }
-  process.exitCode = code;
-  processExitTimer = setTimeout(() => {
-    try {
-      closeInput();
-    } finally {
-      process.exit(code);
-    }
-  }, delayMs);
-}
-
-function closeInput() {
-  inputController.close();
-  process.stdin.off("data", handleStdinData);
-  if (input) {
-    const current = input;
-    input = null;
-    try {
-      current.close();
-    } catch {
-      // Ignore readline close races during signal shutdown.
-    }
-  }
-  if (!terminalUi) {
-    process.stdin.pause();
-  }
-}
-}
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+import { createCompactContextState } from "./compact-context-state.js";
+import { createRuntimeClient, runHelpVersion } from "./runtime-client.js";
+import {
+  requireRuntimeInitialization,
+  runtimeMethods,
+  sessionScopedMethods,
+  turnScopedMethods,
+  isRuntimeEventForTurn,
+} from "./runtime-protocol.js";
+import { executeLocalSlashCommand, loadLocalSettings } from "./local-slash-commands.js";
+import { loadCliState, saveCliState } from "./cli-state-store.js";
+import { setTheme } from "./theme.js";
+import { createTurnController } from "./turn-controller.js";
+import { createCommandController } from "./command-controller.js";
+import { createTaskMonitorController } from "./task-monitor-controller.js";
+import { createEventController } from "./event-controller.js";
+import { createInputController } from "./input-controller.js";
+import { isInputClosed } from "./input-errors.js";
+import { sigintAction } from "./interrupt-state.js";
+import { CUSTOM_ANSWER_LABEL } from "./question-menu-state.js";
+import { createCliState } from "./cli-state.js";
+import { createCliRuntimeController } from "./cli-runtime-controller.js";
+import { createCliOutputController } from "./cli-output-controller.js";
+import { createCliInputActions } from "./cli-input-actions.js";
+import { cliHelp, oneShotHelp, runOneShot } from "./one-shot.js";
+import { createTui } from "./tui/tui.js";
+import { Container } from "./tui/component.js";
+import { ComposerArea } from "./components/composer-area.js";
+import { MonitorStack } from "./components/monitor-stack.js";
+import {
+  inputHintText,
+  interruptText,
+  modelMenuText,
+  themeMenuText,
+  questionMenuFrame,
+  sessionMenuText,
+  promptPlaceholderText,
+  slashMenuText,
+  startupText,
+} from "./rendering.js";
+
+export async function runFrontendCliApp(cliArgs = process.argv.slice(2)) {
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(scriptDir, "..", "..");
+const python = process.env.RIND_PYTHON || "python";
+const runtimePath = process.env.RIND_RUNTIME_PATH || resolveInstalledRuntime();
+
+function resolveInstalledRuntime() {
+  const packageNames = {
+    win32: "@rind-ai/runtime-win32-x64",
+    linux: "@rind-ai/runtime-linux-x64",
+    darwin: process.arch === "arm64" ? "@rind-ai/runtime-darwin-arm64" : "@rind-ai/runtime-darwin-x64",
+  };
+  const packageName = packageNames[process.platform];
+  if (!packageName) return "";
+  try {
+    const packageRoot = path.dirname(createRequire(import.meta.url).resolve(`${packageName}/package.json`));
+    return path.join(packageRoot, "bin", process.platform === "win32" ? "rind-runtime.exe" : "rind-runtime");
+  } catch {
+    return "";
+  }
+}
+
+if (cliArgs[0] === "run" && cliArgs.some((arg) => arg === "--help" || arg === "-h")) {
+  process.stdout.write(`${oneShotHelp}\n`);
+  return;
+}
+if (cliArgs.some((arg) => arg === "--version" || arg === "--help" || arg === "-h")) {
+  if (cliArgs.includes("--help") || cliArgs.includes("-h")) {
+    process.stdout.write(`${cliHelp}\n\n`);
+  }
+  process.exit(runHelpVersion({ python, repoRoot, runtimePath, cliArgs }));
+}
+
+if (cliArgs[0] === "run") {
+  try {
+    await runOneShot({
+      args: cliArgs,
+      python,
+      repoRoot,
+      runtimePath,
+      stderr: (text) => process.stderr.write(text),
+      stdout: (text) => process.stdout.write(`${text}${String(text).endsWith("\n") ? "" : "\n"}`),
+    });
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 2;
+  }
+  return;
+}
+
+const cliState = createCliState();
+const runtimeState = cliState.runtime;
+const sessionState = cliState.session;
+const turnStateData = cliState.turn;
+const inputStateData = cliState.input;
+const displayState = cliState.display;
+let input = null;
+const compactContextState = createCompactContextState();
+const isTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const tui = isTty
+  ? createTui({ input: process.stdin, output: process.stdout })
+  : null;
+const transcriptContainer = new Container();
+const composerArea = new ComposerArea((width) => composeFrame(width));
+const monitorStack = new MonitorStack({
+  composer: composerArea,
+  monitor: {
+    isMonitoring: () => Boolean(taskMonitorController?.isMonitoring()),
+    frame: (width) => taskMonitorController?.frame(width),
+  },
+  rows: () => (tui ? tui.rows : 24),
+});
+if (tui) {
+  tui.addChild(transcriptContainer);
+  tui.addChild(monitorStack);
+}
+let inputActions;
+let inputController;
+let eventProcessing = Promise.resolve();
+
+tui?.onData((sequence) => inputActions?.handleTerminalInput(sequence));
+tui?.onPaste((text) => inputActions?.handleTerminalPaste(text));
+
+const outputController = createCliOutputController({
+  state: cliState,
+  terminalUi: tui,
+  transcript: transcriptContainer,
+});
+const {
+  redraw: redrawInput,
+  refreshInputState,
+  clearActivityTimer,
+  mainPromptText,
+  log: logOutput,
+  writeError: writeErrorOutput,
+  closeAssistant,
+  renderHistory,
+} = outputController;
+
+const runtimeClient = createRuntimeClient({
+  python,
+  repoRoot,
+  runtimePath,
+  cliArgs,
+  onMessage: (message) => {
+    eventProcessing = eventProcessing
+      .then(() => renderEvent(message))
+      .catch((error) => {
+        if (runtimeState.status !== "closing") {
+          writeErrorOutput(`${error instanceof Error ? error.message : String(error)}\n`);
+        }
+      });
+  },
+  onStderr: (chunk) => writeErrorOutput(chunk),
+  onExit: (code, signal, { error }) => {
+    const wasClosing = runtimeState.status === "closing";
+    runtimeState.status = "failed";
+    runtimeState.initialization = null;
+    turnStateData.id = "";
+    displayState.lastEventSequence = 0;
+    turnStateData.active = false;
+    turnStateData.interruptRequested = false;
+    inputActions?.clearPendingInputs();
+    if (!wasClosing) {
+      runtimeState.failure = error;
+      writeErrorOutput(`Runtime stopped (${signal || (code ?? "startup failure")}): ${error.message}. Runtime commands are unavailable until it restarts.\n`);
+    } else {
+      process.exitCode = 0;
+      scheduleProcessExit(0, 0);
+    }
+  },
+});
+const turnState = {
+  get activeTurn() {
+    return turnStateData.active;
+  },
+  set activeTurn(value) {
+    turnStateData.active = Boolean(value);
+  },
+  get interruptRequested() {
+    return turnStateData.interruptRequested;
+  },
+  set interruptRequested(value) {
+    turnStateData.interruptRequested = Boolean(value);
+  },
+  get runtimeClosing() {
+    return runtimeState.status === "closing";
+  },
+};
+let turnController;
+let commandController;
+let taskMonitorController;
+const runtimeController = createCliRuntimeController({
+  client: runtimeClient,
+  methods: runtimeMethods,
+  sessionScopedMethods,
+  turnScopedMethods,
+  requireInitialization: requireRuntimeInitialization,
+  state: cliState,
+  getCommands: () => commandController,
+  getTurnController: () => turnController,
+  getTaskMonitor: () => taskMonitorController,
+  getCompactContextState: () => compactContextState,
+  askModelMenu: (...args) => inputActions.askModelMenu(...args),
+  askEffortMenu: (...args) => inputActions.askEffortMenu(...args),
+  askSessionMenu: (...args) => inputActions.askSessionMenu(...args),
+  askTeamBlueprint: (...args) => inputActions.askTeamBlueprint(...args),
+  restoreLiveTurn,
+  renderHistory,
+  clearPendingInputs: (...args) => inputActions.clearPendingInputs(...args),
+  closeAssistant,
+  refreshInputState,
+  updateGoalState,
+  log: logOutput,
+  writeError: writeErrorOutput,
+  redraw: redrawInput,
+});
+const request = runtimeController.request;
+turnController = createTurnController({
+  request,
+  state: turnState,
+  refreshGoalState: runtimeController.refreshGoalState,
+  onTurnStart: () => {
+    displayState.assistantHeaderShown = false;
+  },
+  output: {
+    queueInput: (...args) => inputActions.addPendingInput(...args),
+    restoreInputText: (...args) => inputActions.restoreInputText(...args),
+    writeError: (text) => writeErrorOutput(`${text}\n`),
+    refreshInputState,
+    closeAssistant,
+    cancelInput,
+    logInterrupt: () => logOutput(() => interruptText()),
+  },
+});
+commandController = createCommandController({
+  request,
+  turn: turnController,
+  input: {
+    isTerminal: Boolean(tui),
+    runGoalCommand: runtimeController.runGoalCommand,
+    runModelSelector: runtimeController.runModelSelector,
+    runEffortCommand: (value) => runtimeController.runEffortCommand(value),
+    runThemeSelector: async () => {
+      const selected = await inputActions.askThemeMenu();
+      if (selected) {
+        await commandController.handle(`/theme ${selected}`);
+      }
+    },
+    startCompactCommand: runtimeController.startCompactCommand,
+    runSessionsSelector: runtimeController.runSessionsSelector,
+    runLocalCommand: async (text) => {
+      if (!Object.keys(sessionState.settings).length) {
+        sessionState.settings = await loadLocalSettings(undefined, sessionState.info.workspace_root || sessionState.info.cwd || process.cwd());
+      }
+      const result = await executeLocalSlashCommand(text, {
+        settings: sessionState.settings,
+        sessionInfo: sessionState.info,
+        cwd: sessionState.info.workspace_root || sessionState.info.cwd || process.cwd(),
+        runtimeStarted: runtimeState.status === "starting" || runtimeState.status === "ready",
+        runtimeInitialized: runtimeState.status === "ready",
+        interactive: Boolean(tui),
+        commands: sessionState.commands,
+        persistTheme: (name) => saveCliState({ theme: name }),
+      });
+      if (result?.display?.type === "theme" && result.display.changed) {
+        outputController.replayAll();
+      }
+      return result;
+    },
+  },
+  state: {
+    get slashCommands() {
+      return sessionState.commands;
+    },
+  },
+  output: {
+    log: logOutput,
+    setInputPrefill: (value) => {
+      inputStateData.prefill = String(value || "");
+    },
+    shutdown: shutdownRuntime,
+    exit: () => process.exit(0),
+  },
+});
+taskMonitorController = createTaskMonitorController({
+  request,
+  terminalUi: Boolean(tui),
+  state: {
+    get runtimeClosing() {
+      return runtimeState.status === "closing";
+    },
+    get sessionInfo() {
+      return sessionState.info;
+    },
+    set sessionInfo(value) {
+      sessionState.info = value;
+    },
+    get inputActive() {
+      return inputStateData.active;
+    },
+    set inputActive(value) {
+      inputStateData.active = Boolean(value);
+    },
+  },
+  redraw: redrawInput,
+  log: logOutput,
+});
+const eventController = createEventController({
+  state: {
+    get runtimeClosing() {
+      return runtimeState.status === "closing";
+    },
+    get activeTurn() {
+      return turnStateData.active;
+    },
+    debug: cliArgs.includes("--debug"),
+  },
+  input: { answerQuestion: (...args) => inputActions.answerQuestion(...args) },
+  monitor: taskMonitorController,
+  output: {
+    assistantAppend: outputController.assistantAppend,
+    beginTool: (...args) => outputController.beginTool(...args),
+    updateToolProgress: (...args) => outputController.updateToolProgress(...args),
+    finishTool: (...args) => outputController.finishTool(...args),
+    handleContextBuilt: (event) => compactContextState.handleContextBuilt(event),
+    resetContextUsage,
+    closeAssistant,
+    log: logOutput,
+    debug: (text) => writeErrorOutput(`${text}\n`),
+    updateGoal: updateGoalState,
+    setGoalChasing: (enabled) => {
+      displayState.goalChasing = Boolean(enabled);
+    },
+    setStats: (stats) => {
+      displayState.stats = stats;
+    },
+    redraw: redrawInput,
+    clearCompactContext: () => compactContextState.clear(),
+    deliverQueuedInput: (...args) => inputActions.deliverQueuedInput(...args),
+    clearQueuedInputs: (...args) => inputActions.clearPendingInputs(...args),
+  },
+});
+inputActions = createCliInputActions({
+  state: cliState,
+  request,
+  output: outputController,
+  getTurnController: () => turnController,
+  getTaskMonitor: () => taskMonitorController,
+  getLineInput: () => input,
+  pausePrompt: () => inputController.pause(),
+  resumePrompt: () => inputController.resume(),
+  handleSigint,
+});
+inputController = createInputController({
+  terminalUi: tui,
+  state: {
+    get runtimeClosing() {
+      return runtimeState.status === "closing";
+    },
+    get promptPaused() {
+      return inputStateData.paused;
+    },
+    set promptPaused(value) {
+      inputStateData.paused = Boolean(value);
+    },
+  },
+  askInput: (...args) => inputActions.ask(...args),
+  onSubmit: (text) => turnController.submit(text),
+  onCommand: (text) => commandController.handle(text),
+  onPaste: (...args) => inputActions.handleTerminalPaste(...args),
+  onInput: (...args) => inputActions.handleTerminalInput(...args),
+  cancelInput,
+  prompt: mainPromptText,
+  placeholder: promptPlaceholderText,
+});
+
+process.on("SIGINT", handleSigint);
+
+try {
+  const persistedState = loadCliState();
+  if (persistedState.theme) {
+    setTheme(persistedState.theme);
+  }
+  sessionState.settings = await loadLocalSettings(undefined, process.cwd());
+  sessionState.info = { cwd: process.cwd(), model: sessionState.settings.model };
+  sessionState.commands = commandController.localCommands();
+  await runtimeController.ensureRuntime();
+  const startupInfo = { ...sessionState.info, resume_preview: "" };
+  if (tui) {
+    outputController.showStartup(startupInfo);
+  } else {
+    logOutput(startupText(startupInfo));
+  }
+  await runtimeController.restoreSession();
+  if (tui) {
+    inputController.start();
+  } else {
+    input = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      historySize: 100,
+      removeHistoryDuplicates: true,
+    });
+    process.stdin.on("data", handleStdinData);
+  }
+  await inputController.promptLoop();
+} catch (error) {
+  closeAssistant();
+  if (!isInputClosed(error)) {
+    writeErrorOutput(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  }
+} finally {
+  closeRuntime();
+}
+
+function updateGoalState(goal) {
+  sessionState.info = { ...sessionState.info, goal: goal && typeof goal === "object" ? goal : null };
+  redrawInput();
+}
+function resetContextUsage() {
+  displayState.stats = { context_usage_percent: 0 };
+  redrawInput();
+}
+
+async function renderEvent(message) {
+  const sequence = Number(message?.sequence);
+  if (!Number.isInteger(sequence) || sequence <= displayState.lastEventSequence) {
+    return;
+  }
+  displayState.lastEventSequence = sequence;
+  if (!isRuntimeEventForTurn(message, sessionState.info.session_id, turnStateData.id)) {
+    return;
+  }
+  if (message?.event?.type === "turn_started") {
+    if (turnStateData.id && String(message.turn_id || "") !== turnStateData.id) {
+      return;
+    }
+    turnStateData.id = String(message.turn_id || "");
+    turnStateData.active = Boolean(turnStateData.id);
+  }
+  const result = await eventController.handle(message);
+  if (["turn_completed", "turn_failed", "turn_cancelled"].includes(message?.event?.type)) {
+    turnStateData.id = "";
+  }
+  return result;
+}
+
+function restoreLiveTurn(value) {
+  if (!value || typeof value !== "object") return;
+  const turnId = String(value.turn_id || "");
+  if (!turnId) return;
+  turnStateData.id = turnId;
+  turnStateData.active = true;
+  displayState.assistantHeaderShown = false;
+  const text = String(value.assistant_text || "");
+  if (text) outputController.assistantAppend(text);
+}
+
+function composeFrame(width = process.stdout.columns || 80) {
+  const session = inputStateData.session;
+  if (!session) {
+    return null;
+  }
+  const choiceMenu = ["model", "theme", "sessions", "team-blueprints"].includes(session.mode);
+  if (session.mode === "prompt" && session.menuState) {
+    session.menuState.setInput(session.editor.input());
+  }
+  const slashMenuOpen = session.mode === "prompt"
+    && session.menuState
+    && session.menuState.matches().length > 0;
+  const showCaret = (!displayState.activeCompact && !choiceMenu && !slashMenuOpen)
+    || (session.mode === "question" && session.questionState.isEditing());
+  if (session.mode === "model") {
+    return {
+      showCaret,
+      prompt: mainPromptText(width),
+      inputText: session.inputText,
+      cursor: { line: 0, column: session.inputText.length },
+      menuText: modelMenuText(session.modelState.items(), session.modelState.selectedIndex()).trimEnd(),
+    };
+  }
+  if (session.mode === "theme") {
+    return {
+      showCaret,
+      prompt: mainPromptText(width),
+      inputText: session.inputText,
+      cursor: { line: 0, column: session.inputText.length },
+      menuText: themeMenuText(session.themeState.items(), session.themeState.selectedIndex()).trimEnd(),
+    };
+  }
+  if (session.mode === "question") {
+    const editing = session.questionState.isEditing();
+    const menu = questionMenuFrame(
+      session.questionState.options(),
+      session.questionState.selectedIndex(),
+      editing ? session.editor.input() : "",
+      editing,
+      CUSTOM_ANSWER_LABEL,
+      width,
+    );
+    return {
+      showCaret,
+      prompt: mainPromptText(width),
+      inputText: session.question,
+      cursor: editing ? session.editor.cursorPosition() : { line: 0, column: session.question.length },
+      menuText: menu.text.trimEnd(),
+      menuCursor: editing ? menu.cursor : null,
+    };
+  }
+  if (session.mode === "sessions") {
+    return {
+      showCaret,
+      prompt: mainPromptText(width),
+      inputText: session.inputText,
+      cursor: { line: 0, column: session.inputText.length },
+      menuText: sessionMenuText(session.choiceState.options(), session.choiceState.selectedIndex()).trimEnd(),
+    };
+  }
+  if (session.mode === "team-blueprints") {
+    return {
+      showCaret,
+      prompt: mainPromptText(width),
+      inputText: session.inputText,
+      cursor: { line: 0, column: session.inputText.length },
+      menuText: sessionMenuText(session.choiceState.options(), session.choiceState.selectedIndex()).trimEnd(),
+    };
+  }
+  const matches = session.menuState
+    ? (session.menuState.setInput(session.editor.input()), session.menuState.matches())
+    : [];
+  if (typeof session.editor.setViewportWidth === "function") {
+    session.editor.setViewportWidth(width);
+  }
+  return {
+    showCaret,
+    prompt: typeof session.prompt === "function" ? session.prompt(width) : session.prompt,
+    inputText: session.editor.input(),
+    cursor: session.editor.cursorPosition(),
+    placeholder: session.mode === "prompt" ? inputHintText(session.placeholder) : "",
+    menuText: session.menuState ? slashMenuText(matches, session.menuState.selectedIndex()).trimEnd() : "",
+  };
+}
+
+function handleSigint() {
+  const action = sigintAction({
+    activeTurn: turnStateData.active || displayState.activeCompact,
+    interruptRequested: turnStateData.interruptRequested,
+    runtimeClosing: runtimeState.status === "closing",
+  });
+  if (action === "interrupt") {
+    interruptTurn();
+  } else {
+    exitFromSignal();
+  }
+}
+
+function interruptTurn() {
+  turnController.interrupt();
+}
+
+function handleStdinData(chunk) {
+  if (Buffer.from(chunk).includes(3)) {
+    handleSigint();
+  }
+}
+
+function exitFromSignal() {
+  if (runtimeState.status === "closing") {
+    forceCloseRuntime();
+    scheduleProcessExit(0, 0);
+    return;
+  }
+  void shutdownRuntime();
+}
+
+function closeRuntime() {
+  if (runtimeState.status === "closing") {
+    return;
+  }
+  runtimeState.status = "closing";
+  clearActivityTimer();
+  taskMonitorController.stop();
+  void runtimeClient.shutdown();
+  closeInput();
+}
+
+function forceCloseRuntime() {
+  runtimeState.status = "closing";
+  clearActivityTimer();
+  taskMonitorController.stop();
+  closeInput();
+  runtimeClient.forceShutdown();
+}
+
+function cancelInput() {
+  inputActions?.cancel();
+}
+
+async function shutdownRuntime() {
+  if (runtimeState.status === "closing") {
+    return;
+  }
+  runtimeState.status = "closing";
+  clearActivityTimer();
+  taskMonitorController.stop();
+  try {
+    await runtimeClient.shutdown();
+  } catch {
+    runtimeClient.forceShutdown();
+  } finally {
+    runtimeClient.closeInput();
+    closeInput();
+  }
+}
+
+function scheduleProcessExit(code, delayMs) {
+  if (displayState.processExitTimer) {
+    return;
+  }
+  process.exitCode = code;
+  displayState.processExitTimer = setTimeout(() => {
+    try {
+      closeInput();
+    } finally {
+      process.exit(code);
+    }
+  }, delayMs);
+}
+
+function closeInput() {
+  inputController.close();
+  process.stdin.off("data", handleStdinData);
+  if (input) {
+    const current = input;
+    input = null;
+    try {
+      current.close();
+    } catch {
+      // Ignore readline close races during signal shutdown.
+    }
+  }
+  if (!tui) {
+    process.stdin.pause();
+  }
+}
+}