@robota-sdk/agent-transport-tui 3.0.0-beta.63

package/dist/node/index.js

@@ -0,0 +1,4008 @@
+// src/render.tsx
+import { render } from "ink";
+
+// src/App.tsx
+import { useState as useState17, useEffect as useEffect6, useMemo as useMemo5 } from "react";
+import { Box as Box21, Text as Text23, useApp as useApp2, useInput as useInput10 } from "ink";
+import { listResumableSessionSummaries } from "@robota-sdk/agent-sdk";
+import { createSystemMessage as createSystemMessage6, messageToHistoryEntry as messageToHistoryEntry6 } from "@robota-sdk/agent-core";
+
+// src/hooks/useInteractiveSession.ts
+import { useState, useRef, useCallback as useCallback2, useEffect } from "react";
+import { InteractiveSession, CommandRegistry } from "@robota-sdk/agent-sdk";
+import { createSystemMessage as createSystemMessage2, messageToHistoryEntry as messageToHistoryEntry2 } from "@robota-sdk/agent-core";
+
+// src/tui-state-manager.ts
+var MAX_RENDERED_MESSAGES = 100;
+var STREAMING_DEBOUNCE_MS = 300;
+function createDebouncedNotify(notify, ms) {
+  let timer = null;
+  return {
+    schedule() {
+      if (!timer) {
+        timer = setTimeout(() => {
+          timer = null;
+          notify();
+        }, ms);
+      }
+    },
+    flush() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+var TuiStateManager = class {
+  // ── Rendering state ───────────────────────────────────────────
+  history = [];
+  streamingText = "";
+  activeTools = [];
+  isThinking = false;
+  isAborting = false;
+  pendingPrompt = null;
+  contextState = { percentage: 0, usedTokens: 0, maxTokens: 0 };
+  executionWorkspaceSnapshot = null;
+  selectedExecutionEntryId;
+  /** Called after any state change. React hook sets this to trigger re-render. */
+  onChange = null;
+  // ── Internal ──────────────────────────────────────────────────
+  streamBuf = "";
+  debouncedStreamNotify = createDebouncedNotify(() => this.notify(), STREAMING_DEBOUNCE_MS);
+  notify() {
+    this.onChange?.();
+  }
+  // ── Event handlers (InteractiveSession → state) ───────────────
+  onTextDelta = (delta) => {
+    this.streamBuf += delta;
+    this.streamingText = this.streamBuf;
+    this.debouncedStreamNotify.schedule();
+  };
+  onToolStart = (state) => {
+    this.activeTools = [...this.activeTools, state];
+    this.notify();
+  };
+  onToolEnd = (state) => {
+    const idx = this.activeTools.findLastIndex((t) => t.toolName === state.toolName && t.isRunning);
+    if (idx !== -1) {
+      const updated = [...this.activeTools];
+      updated[idx] = state;
+      this.activeTools = updated;
+    }
+    this.notify();
+  };
+  onThinking = (thinking) => {
+    this.isThinking = thinking;
+    if (thinking) {
+      this.debouncedStreamNotify.flush();
+      this.streamBuf = "";
+      this.streamingText = "";
+      this.activeTools = [];
+    } else {
+      this.isAborting = false;
+    }
+    this.notify();
+  };
+  onComplete = (result) => {
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.contextState = {
+      percentage: result.contextState.usedPercentage,
+      usedTokens: result.contextState.usedTokens,
+      maxTokens: result.contextState.maxTokens
+    };
+    this.notify();
+  };
+  onInterrupted = () => {
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  };
+  onError = () => {
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  };
+  onContextUpdate = (state) => {
+    this.setContextState({
+      percentage: state.usedPercentage,
+      usedTokens: state.usedTokens,
+      maxTokens: state.maxTokens
+    });
+  };
+  // ── State updates from external sources ───────────────────────
+  /** Sync history from InteractiveSession */
+  syncHistory(entries) {
+    if (entries.length === 0) return;
+    this.history = entries.length > MAX_RENDERED_MESSAGES ? entries.slice(-MAX_RENDERED_MESSAGES) : [...entries];
+    this.notify();
+  }
+  /** Add a single history entry */
+  addEntry(entry) {
+    const updated = [...this.history, entry];
+    this.history = updated.length > MAX_RENDERED_MESSAGES ? updated.slice(-MAX_RENDERED_MESSAGES) : updated;
+    this.notify();
+  }
+  clearHistory() {
+    this.history = [];
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  }
+  /** Update pending prompt state */
+  setPendingPrompt(prompt) {
+    this.pendingPrompt = prompt;
+    this.notify();
+  }
+  /** Set aborting flag */
+  setAborting(aborting) {
+    this.isAborting = aborting;
+    this.notify();
+  }
+  /** Update context state */
+  setContextState(state) {
+    this.contextState = state;
+    this.notify();
+  }
+  syncExecutionWorkspaceSnapshot(snapshot) {
+    const currentSelection = this.selectedExecutionEntryId;
+    const hasCurrentSelection = currentSelection !== void 0 && snapshot.entries.some((entry) => entry.id === currentSelection);
+    const selectedExecutionEntryId = hasCurrentSelection ? currentSelection : snapshot.selectedEntryId ?? snapshot.entries[0]?.id;
+    this.executionWorkspaceSnapshot = {
+      ...snapshot,
+      ...selectedExecutionEntryId ? { selectedEntryId: selectedExecutionEntryId } : {}
+    };
+    this.selectedExecutionEntryId = selectedExecutionEntryId;
+    this.notify();
+  }
+  selectExecutionWorkspaceEntry(entryId) {
+    if (!this.executionWorkspaceSnapshot?.entries.some((entry) => entry.id === entryId)) return;
+    this.selectedExecutionEntryId = entryId;
+    this.executionWorkspaceSnapshot = {
+      ...this.executionWorkspaceSnapshot,
+      selectedEntryId: entryId
+    };
+    this.notify();
+  }
+};
+
+// src/hooks/useSlashRouting.ts
+import { useCallback } from "react";
+import { createSystemMessage, messageToHistoryEntry } from "@robota-sdk/agent-core";
+function useSlashRouting(interactiveSession, registry, manager, commandEffectQueue, reloadPluginCommandSource) {
+  return useCallback(
+    async (input) => {
+      if (!input.startsWith("/")) {
+        await interactiveSession.submit(input);
+        manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+        return;
+      }
+      const parts = input.slice(1).split(/\s+/);
+      const cmd = parts[0]?.toLowerCase() ?? "";
+      const args = parts.slice(1).join(" ");
+      const result = await interactiveSession.executeCommand(cmd, args);
+      if (result) {
+        if (result.effects?.some((effect) => effect.type === "session-execution-started")) {
+          manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+          return;
+        }
+        applySystemCommandResult(
+          result,
+          interactiveSession,
+          registry,
+          manager,
+          commandEffectQueue,
+          reloadPluginCommandSource
+        );
+        return;
+      }
+      manager.addEntry(
+        messageToHistoryEntry(
+          createSystemMessage(`Unknown command "/${cmd}". Type /help for help.`)
+        )
+      );
+    },
+    [interactiveSession, registry, manager, commandEffectQueue, reloadPluginCommandSource]
+  );
+}
+function applySystemCommandResult(result, interactiveSession, registry, manager, commandEffectQueue, reloadPluginCommandSource) {
+  const pendingEffects = applyImmediateCommandEffects(
+    result.effects,
+    registry,
+    manager,
+    reloadPluginCommandSource
+  );
+  manager.addEntry(messageToHistoryEntry(createSystemMessage(result.message)));
+  if (result.interaction !== void 0) {
+    commandEffectQueue.enqueueInteraction(result.interaction);
+  }
+  if (pendingEffects.length > 0) {
+    commandEffectQueue.enqueueEffects(pendingEffects);
+  }
+  if (interactiveSession.isInitialized) {
+    const ctx = interactiveSession.getContextState();
+    manager.setContextState({
+      percentage: ctx.usedPercentage,
+      usedTokens: ctx.usedTokens,
+      maxTokens: ctx.maxTokens
+    });
+  }
+}
+function applyImmediateCommandEffects(effects, registry, manager, reloadPluginCommandSource) {
+  if (effects === void 0 || effects.length === 0) return [];
+  const pendingEffects = [];
+  for (const effect of effects) {
+    if (effect.type === "conversation-history-cleared") {
+      manager.clearHistory();
+      continue;
+    }
+    if (effect.type === "plugin-registry-reload-requested") {
+      reloadPluginCommandSource?.(registry);
+      continue;
+    }
+    pendingEffects.push(effect);
+  }
+  return pendingEffects;
+}
+
+// src/hooks/command-effect-queue.ts
+var CommandEffectQueue = class {
+  queue = [];
+  enqueueInteraction(interaction) {
+    this.queue.push({ type: "interaction", interaction });
+  }
+  enqueueEffects(effects) {
+    if (effects.length === 0) return;
+    this.queue.push({ type: "effects", effects: [...effects] });
+  }
+  drain() {
+    return this.queue.shift();
+  }
+  clear() {
+    this.queue.length = 0;
+  }
+};
+
+// src/hooks/useInteractiveSession.ts
+var SESSION_INIT_POLL_MS = 200;
+function applyCompactEventToManager(interactiveSession, manager) {
+  manager.syncHistory(interactiveSession.getFullHistory());
+}
+function applySkillActivationEventToManager(interactiveSession, manager) {
+  manager.syncHistory(interactiveSession.getFullHistory());
+}
+function syncExecutionWorkspaceFromSession(interactiveSession, manager) {
+  try {
+    manager.syncExecutionWorkspaceSnapshot(
+      interactiveSession.getExecutionWorkspaceSnapshot({
+        selectedEntryId: manager.selectedExecutionEntryId
+      })
+    );
+  } catch {
+  }
+}
+function initializeSession(props, permissionHandler) {
+  const interactiveSession = new InteractiveSession({
+    cwd: props.cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    permissionHandler,
+    sessionStore: props.sessionStore,
+    resumeSessionId: props.resumeSessionId,
+    forkSession: props.forkSession,
+    sessionName: props.sessionName,
+    backgroundTaskRunners: props.backgroundTaskRunners,
+    subagentRunnerFactory: props.subagentRunnerFactory,
+    commandModules: props.commandModules,
+    commandHostAdapters: props.commandHostAdapters,
+    language: props.language
+  });
+  const registry = new CommandRegistry();
+  for (const module of props.commandModules ?? []) {
+    registry.addModule(module);
+  }
+  props.reloadPluginCommandSource?.(registry);
+  const manager = new TuiStateManager();
+  const commandEffectQueue = new CommandEffectQueue();
+  return { interactiveSession, registry, manager, commandEffectQueue };
+}
+function useInteractiveSession(props) {
+  const [, forceRender] = useState(0);
+  const [permissionRequest, setPermissionRequest] = useState(null);
+  const [isShuttingDown, setIsShuttingDown] = useState(false);
+  const permissionQueueRef = useRef([]);
+  const processingRef = useRef(false);
+  const processNextPermission = useCallback2(() => {
+    if (processingRef.current) return;
+    const next = permissionQueueRef.current[0];
+    if (!next) {
+      setPermissionRequest(null);
+      return;
+    }
+    processingRef.current = true;
+    setPermissionRequest({
+      toolName: next.toolName,
+      toolArgs: next.toolArgs,
+      resolve: (result) => {
+        permissionQueueRef.current.shift();
+        processingRef.current = false;
+        setPermissionRequest(null);
+        next.resolve(result);
+        setTimeout(() => processNextPermission(), 0);
+      }
+    });
+  }, []);
+  const permissionHandler = useCallback2(
+    (toolName, toolArgs) => new Promise((resolve) => {
+      permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+      processNextPermission();
+    }),
+    [processNextPermission]
+  );
+  const [initState] = useState(() => initializeSession(props, permissionHandler));
+  const { interactiveSession, registry, manager, commandEffectQueue } = initState;
+  manager.onChange = () => forceRender((n) => n + 1);
+  if (manager.history.length === 0) {
+    const restored = interactiveSession.getFullHistory();
+    if (restored.length > 0) {
+      manager.syncHistory(restored);
+    }
+  }
+  useEffect(() => {
+    if (!props.transportRegistry) return;
+    const reg = props.transportRegistry;
+    reg.startAll(interactiveSession).catch(() => void 0);
+    return () => {
+      reg.stopAll().catch(() => void 0);
+    };
+  }, [interactiveSession, props.transportRegistry]);
+  useEffect(() => {
+    const onCompact = () => applyCompactEventToManager(interactiveSession, manager);
+    const onSkillActivation = () => applySkillActivationEventToManager(interactiveSession, manager);
+    const onExecutionWorkspaceEvent = (event) => manager.syncExecutionWorkspaceSnapshot(event.snapshot);
+    interactiveSession.on("text_delta", manager.onTextDelta);
+    interactiveSession.on("tool_start", manager.onToolStart);
+    interactiveSession.on("tool_end", manager.onToolEnd);
+    interactiveSession.on("thinking", manager.onThinking);
+    interactiveSession.on("complete", manager.onComplete);
+    interactiveSession.on("interrupted", manager.onInterrupted);
+    interactiveSession.on("error", manager.onError);
+    interactiveSession.on("context_update", manager.onContextUpdate);
+    interactiveSession.on("compact", onCompact);
+    interactiveSession.on("skill_activation", onSkillActivation);
+    interactiveSession.on("execution_workspace_event", onExecutionWorkspaceEvent);
+    const initCheck = setInterval(() => {
+      try {
+        const ctx = interactiveSession.getContextState();
+        manager.setContextState({
+          percentage: ctx.usedPercentage,
+          usedTokens: ctx.usedTokens,
+          maxTokens: ctx.maxTokens
+        });
+        const restored = interactiveSession.getFullHistory();
+        if (restored.length > 0) {
+          manager.syncHistory(restored);
+        }
+        syncExecutionWorkspaceFromSession(interactiveSession, manager);
+        clearInterval(initCheck);
+      } catch {
+      }
+    }, SESSION_INIT_POLL_MS);
+    return () => {
+      clearInterval(initCheck);
+      interactiveSession.off("text_delta", manager.onTextDelta);
+      interactiveSession.off("tool_start", manager.onToolStart);
+      interactiveSession.off("tool_end", manager.onToolEnd);
+      interactiveSession.off("thinking", manager.onThinking);
+      interactiveSession.off("complete", manager.onComplete);
+      interactiveSession.off("interrupted", manager.onInterrupted);
+      interactiveSession.off("error", manager.onError);
+      interactiveSession.off("context_update", manager.onContextUpdate);
+      interactiveSession.off("compact", onCompact);
+      interactiveSession.off("skill_activation", onSkillActivation);
+      interactiveSession.off("execution_workspace_event", onExecutionWorkspaceEvent);
+    };
+  }, [interactiveSession, manager]);
+  useEffect(() => {
+    manager.syncHistory(interactiveSession.getFullHistory());
+    syncExecutionWorkspaceFromSession(interactiveSession, manager);
+    if (!manager.isThinking) {
+      manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+    }
+  }, [manager.isThinking, interactiveSession, manager]);
+  const handleSubmit = useSlashRouting(
+    interactiveSession,
+    registry,
+    manager,
+    commandEffectQueue,
+    props.reloadPluginCommandSource
+  );
+  const handleAbort = useCallback2(() => {
+    manager.setAborting(true);
+    interactiveSession.abort();
+  }, [interactiveSession, manager]);
+  const handleCancelQueue = useCallback2(() => {
+    interactiveSession.cancelQueue();
+    manager.setPendingPrompt(null);
+  }, [interactiveSession, manager]);
+  const handleShutdown = useCallback2(
+    async (reason = "prompt_input_exit") => {
+      if (isShuttingDown) return;
+      setIsShuttingDown(true);
+      manager.addEntry(messageToHistoryEntry2(createSystemMessage2("Shutting down...")));
+      await interactiveSession.shutdown({ reason, message: "CLI shutdown" });
+    },
+    [interactiveSession, manager, isShuttingDown]
+  );
+  const selectExecutionWorkspaceEntry = useCallback2(
+    (entryId) => manager.selectExecutionWorkspaceEntry(entryId),
+    [manager]
+  );
+  const readExecutionWorkspaceDetail = useCallback2(
+    (entryId) => interactiveSession.readExecutionWorkspaceDetail(entryId),
+    [interactiveSession]
+  );
+  return {
+    interactiveSession,
+    registry,
+    commandEffectQueue,
+    history: manager.history,
+    addEntry: (entry) => manager.addEntry(entry),
+    streamingText: manager.streamingText,
+    activeTools: manager.activeTools,
+    isThinking: manager.isThinking,
+    isAborting: manager.isAborting,
+    isShuttingDown,
+    pendingPrompt: manager.pendingPrompt,
+    executionWorkspaceSnapshot: manager.executionWorkspaceSnapshot,
+    selectedExecutionEntryId: manager.selectedExecutionEntryId,
+    permissionRequest,
+    contextState: manager.contextState,
+    handleSubmit,
+    handleAbort,
+    handleCancelQueue,
+    handleShutdown,
+    selectExecutionWorkspaceEntry,
+    readExecutionWorkspaceDetail
+  };
+}
+
+// src/hooks/usePluginCallbacks.ts
+import { useMemo } from "react";
+function createNoOpPluginAdapter() {
+  return {
+    listInstalled: async () => [],
+    listAvailablePlugins: async () => [],
+    install: async () => void 0,
+    uninstall: async () => void 0,
+    enable: async () => void 0,
+    disable: async () => void 0,
+    marketplaceAdd: async () => "",
+    marketplaceRemove: async () => void 0,
+    marketplaceUpdate: async () => void 0,
+    marketplaceList: async () => [],
+    reloadPlugins: async () => ({ loadedPluginCount: 0 })
+  };
+}
+function usePluginCallbacks(_cwd) {
+  return useMemo(() => createNoOpPluginAdapter(), []);
+}
+
+// src/hooks/useSideEffects.ts
+import { useState as useState2, useRef as useRef2, useCallback as useCallback3 } from "react";
+import { useApp } from "ink";
+import { createSystemMessage as createSystemMessage5, messageToHistoryEntry as messageToHistoryEntry5 } from "@robota-sdk/agent-core";
+
+// src/hooks/command-effect-handler.ts
+import { isStatusLineCommandSettingsPatch } from "@robota-sdk/agent-sdk";
+import { createSystemMessage as createSystemMessage3, messageToHistoryEntry as messageToHistoryEntry3 } from "@robota-sdk/agent-core";
+function applyCommandEffects(effects, deps) {
+  for (const effect of effects) {
+    if (effect.type === "model-change-requested") {
+      deps.requestModelChange(effect.modelId);
+      return true;
+    }
+    if (effect.type === "language-change-requested") {
+      applyLanguageEffect(effect.language, deps);
+      return true;
+    }
+    if (effect.type === "settings-reset-requested") {
+      applySettingsResetEffect(deps);
+      return true;
+    }
+    if (effect.type === "session-exit-requested") {
+      deps.requestShutdown(
+        effect.reason ?? "prompt_input_exit",
+        effect.message ?? "User requested exit"
+      );
+      return true;
+    }
+    if (effect.type === "session-restart-requested") {
+      deps.requestShutdown(effect.reason, effect.message);
+      return true;
+    }
+    if (effect.type === "plugin-tui-requested") {
+      deps.openPluginTUI();
+      return true;
+    }
+    if (effect.type === "settings-tui-requested") {
+      deps.openTransportTUI();
+      return true;
+    }
+    if (effect.type === "session-picker-requested") {
+      deps.openSessionPicker();
+      return true;
+    }
+    if (effect.type === "session-renamed") {
+      deps.renameSession(effect.name);
+      return true;
+    }
+    if (effect.type === "statusline-settings-patch") {
+      if (isStatusLineCommandSettingsPatch(effect.patch)) {
+        return deps.applyStatusLinePatch(effect.patch);
+      }
+    }
+  }
+  return false;
+}
+function applyLanguageEffect(language, deps) {
+  const settingsPath = deps.cliAdapter.getUserSettingsPath();
+  const settings = deps.cliAdapter.readSettings(settingsPath);
+  settings.language = language;
+  deps.cliAdapter.writeSettings(settingsPath, settings);
+  deps.addEntry(
+    messageToHistoryEntry3(createSystemMessage3(`Language set to "${language}". Restarting...`))
+  );
+  deps.requestShutdown("other", "Language change restart");
+}
+function applySettingsResetEffect(deps) {
+  const settingsPath = deps.cliAdapter.getUserSettingsPath();
+  if (deps.cliAdapter.deleteSettings(settingsPath)) {
+    deps.addEntry(
+      messageToHistoryEntry3(createSystemMessage3(`Deleted ${settingsPath}. Exiting...`))
+    );
+  } else {
+    deps.addEntry(messageToHistoryEntry3(createSystemMessage3("No user settings found.")));
+  }
+  deps.requestShutdown("other", "Reset settings restart");
+}
+
+// src/tui-cli-adapter-context.tsx
+import { createContext, useContext } from "react";
+var TuiCliAdapterContext = createContext(null);
+var TuiCliAdapterProvider = TuiCliAdapterContext.Provider;
+function useTuiCliAdapter() {
+  const adapter = useContext(TuiCliAdapterContext);
+  if (!adapter) throw new Error("TuiCliAdapterContext not provided");
+  return adapter;
+}
+
+// src/hooks/model-change-side-effect.ts
+import {
+  createSystemMessage as createSystemMessage4,
+  getModelName,
+  messageToHistoryEntry as messageToHistoryEntry4
+} from "@robota-sdk/agent-core";
+function formatModelChangeConfirmationMessage(modelId) {
+  return `Change model to ${getModelName(modelId)}? This will exit the current session so the next session uses it.`;
+}
+function formatModelChangeExitMessage(modelId) {
+  return `Model changed to ${getModelName(modelId)}. Exiting so the next session uses it.`;
+}
+function applyConfirmedModelChange(deps) {
+  const applyModelChange = deps.applyModelChange;
+  if (!applyModelChange) {
+    deps.addEntry(
+      messageToHistoryEntry4(createSystemMessage4("Model change unavailable: no adapter provided."))
+    );
+    return;
+  }
+  const options = deps.providerOverride !== void 0 ? { providerOverride: deps.providerOverride } : void 0;
+  try {
+    applyModelChange(deps.cwd, deps.modelId, options);
+    deps.addEntry(
+      messageToHistoryEntry4(createSystemMessage4(formatModelChangeExitMessage(deps.modelId)))
+    );
+    deps.requestShutdown("other", "Model change applied");
+  } catch (error) {
+    deps.addEntry(
+      messageToHistoryEntry4(
+        createSystemMessage4(`Failed: ${error instanceof Error ? error.message : String(error)}`)
+      )
+    );
+  }
+}
+function addModelChangeCancelledMessage(addEntry) {
+  addEntry(messageToHistoryEntry4(createSystemMessage4("Model change cancelled.")));
+}
+
+// src/hooks/useSideEffects.ts
+var EXIT_DELAY_MS = 500;
+function useSideEffects({
+  cwd,
+  providerOverride,
+  interactiveSession,
+  commandEffectQueue,
+  addEntry,
+  baseHandleSubmit,
+  setSessionName,
+  setStatusLineSettings,
+  showSessionPickerOnStart
+}) {
+  const { exit } = useApp();
+  const cliAdapter = useTuiCliAdapter();
+  const [pendingModelId, setPendingModelId] = useState2(null);
+  const pendingModelChangeRef = useRef2(null);
+  const [pendingInteractionPrompt, setPendingInteractionPrompt] = useState2(null);
+  const commandInteractionRef = useRef2(null);
+  const [showPluginTUI, setShowPluginTUI] = useState2(false);
+  const [showSessionPicker, setShowSessionPicker] = useState2(showSessionPickerOnStart ?? false);
+  const [showTransportTUI, setShowTransportTUI] = useState2(false);
+  const requestShutdown = useCallback3(
+    (reason, message) => {
+      addEntry(messageToHistoryEntry5(createSystemMessage5("Shutting down...")));
+      setTimeout(() => {
+        void interactiveSession.shutdown({ reason, message }).finally(() => exit());
+      }, EXIT_DELAY_MS);
+    },
+    [interactiveSession, addEntry, exit]
+  );
+  const applyEffects = useCallback3(
+    (effects) => applyCommandEffects(effects, {
+      addEntry,
+      requestShutdown,
+      requestModelChange: (modelId) => {
+        pendingModelChangeRef.current = modelId;
+        setPendingModelId(modelId);
+      },
+      openPluginTUI: () => setShowPluginTUI(true),
+      openSessionPicker: () => setShowSessionPicker(true),
+      openTransportTUI: () => setShowTransportTUI(true),
+      renameSession: (name) => {
+        interactiveSession.setName(name);
+        setSessionName(name);
+      },
+      applyStatusLinePatch: (patch) => {
+        setStatusLineSettings(
+          cliAdapter.applyStatusLineSettings(cliAdapter.getUserSettingsPath(), patch)
+        );
+        return true;
+      },
+      cliAdapter
+    }),
+    [
+      addEntry,
+      cliAdapter,
+      interactiveSession,
+      requestShutdown,
+      setSessionName,
+      setStatusLineSettings
+    ]
+  );
+  const applyCommandResult = useCallback3(
+    (result) => {
+      if (result.message.length > 0) {
+        addEntry(messageToHistoryEntry5(createSystemMessage5(result.message)));
+      }
+      if (result.interaction !== void 0) {
+        commandInteractionRef.current = result.interaction;
+        setPendingInteractionPrompt(result.interaction.prompt);
+        return;
+      }
+      commandInteractionRef.current = null;
+      setPendingInteractionPrompt(null);
+      if (result.effects !== void 0 && result.effects.length > 0) {
+        applyEffects(result.effects);
+      }
+    },
+    [addEntry, applyEffects]
+  );
+  const applyQueuedCommandState = useCallback3(() => {
+    const queued = commandEffectQueue.drain();
+    if (queued === void 0) {
+      return false;
+    }
+    if (queued.type === "interaction") {
+      const { interaction } = queued;
+      commandInteractionRef.current = interaction;
+      setPendingInteractionPrompt(interaction.prompt);
+      return true;
+    }
+    return applyEffects(queued.effects);
+  }, [applyEffects, commandEffectQueue]);
+  const handleSubmit = useCallback3(
+    async (input) => {
+      await baseHandleSubmit(input);
+      applyQueuedCommandState();
+    },
+    [baseHandleSubmit, applyQueuedCommandState]
+  );
+  const handleModelConfirm = useCallback3(
+    (index) => {
+      const modelId = pendingModelChangeRef.current;
+      setPendingModelId(null);
+      pendingModelChangeRef.current = null;
+      if (index === 0 && modelId) {
+        applyConfirmedModelChange({
+          cwd,
+          modelId,
+          providerOverride,
+          addEntry,
+          requestShutdown,
+          applyModelChange: (c, m, opts) => {
+            cliAdapter.applyActiveModelChange(c, m, opts);
+            return { applied: true };
+          }
+        });
+      } else {
+        addModelChangeCancelledMessage(addEntry);
+      }
+    },
+    [cwd, providerOverride, addEntry, cliAdapter, requestShutdown]
+  );
+  const handleInteractionSubmit = useCallback3(
+    async (value) => {
+      const interaction = commandInteractionRef.current;
+      if (interaction === null) {
+        setPendingInteractionPrompt(null);
+        return;
+      }
+      try {
+        const result = await interaction.submit(value);
+        applyCommandResult(result);
+      } catch (err) {
+        commandInteractionRef.current = null;
+        setPendingInteractionPrompt(null);
+        addEntry(
+          messageToHistoryEntry5(
+            createSystemMessage5(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+          )
+        );
+      }
+    },
+    [addEntry, applyCommandResult]
+  );
+  const handleInteractionCancel = useCallback3(() => {
+    const interaction = commandInteractionRef.current;
+    commandInteractionRef.current = null;
+    setPendingInteractionPrompt(null);
+    if (interaction?.cancel === void 0) {
+      addEntry(messageToHistoryEntry5(createSystemMessage5("Command interaction cancelled.")));
+      return;
+    }
+    Promise.resolve(interaction.cancel()).then((result) => applyCommandResult(result)).catch((err) => {
+      addEntry(
+        messageToHistoryEntry5(
+          createSystemMessage5(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+        )
+      );
+    });
+  }, [addEntry, applyCommandResult]);
+  return {
+    handleSubmit,
+    pendingModelId,
+    pendingInteractionPrompt,
+    showPluginTUI,
+    showSessionPicker,
+    showTransportTUI,
+    setPendingModelId,
+    setShowPluginTUI,
+    setShowSessionPicker,
+    setShowTransportTUI,
+    handleModelConfirm,
+    handleInteractionSubmit,
+    handleInteractionCancel
+  };
+}
+
+// src/hooks/useStatusLineSettings.ts
+import { useState as useState3 } from "react";
+import { DEFAULT_STATUS_LINE_COMMAND_SETTINGS } from "@robota-sdk/agent-sdk";
+function readStatusLineSettings(settings) {
+  const defaults = { ...DEFAULT_STATUS_LINE_COMMAND_SETTINGS };
+  const raw = settings.statusline;
+  if (!isRecord(raw)) {
+    return defaults;
+  }
+  return {
+    enabled: typeof raw.enabled === "boolean" ? raw.enabled : defaults.enabled,
+    gitBranch: typeof raw.gitBranch === "boolean" ? raw.gitBranch : defaults.gitBranch
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+function useStatusLineSettings() {
+  const cliAdapter = useTuiCliAdapter();
+  return useState3(
+    () => readStatusLineSettings(cliAdapter.readSettings(cliAdapter.getUserSettingsPath()))
+  );
+}
+
+// src/MessageList.tsx
+import React from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import { isToolMessage, isAssistantMessage } from "@robota-sdk/agent-core";
+
+// src/render-markdown.ts
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+var ANSI_LIGHT_RED = "\x1B[38;5;210m";
+var ANSI_LIGHT_GREEN = "\x1B[38;5;120m";
+var ANSI_CYAN = "\x1B[36m";
+var ANSI_DIM = "\x1B[2m";
+var ANSI_DARK_RED_BACKGROUND = "\x1B[48;5;52m";
+var ANSI_DARK_GREEN_BACKGROUND = "\x1B[48;5;22m";
+var ANSI_RESET = "\x1B[0m";
+var CODE_BLOCK_INDENT = "    ";
+var ZERO_COLOR = "0";
+var TerminalRendererConstructor = TerminalRenderer;
+function shouldUseColor(option) {
+  if (option !== void 0) {
+    return option;
+  }
+  if (process.env.NO_COLOR || process.env.FORCE_COLOR === ZERO_COLOR) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR) {
+    return true;
+  }
+  return Boolean(process.stdout.isTTY);
+}
+function isDiffLanguage(language) {
+  return language?.trim().toLowerCase() === "diff";
+}
+function styleAddedOrRemovedDiffRow(line, rowWidth, color) {
+  const row = `${CODE_BLOCK_INDENT}${line}`.padEnd(rowWidth);
+  if (!color) {
+    return row.trimEnd();
+  }
+  if (line.startsWith("+")) {
+    return `${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}${row}${ANSI_RESET}`;
+  }
+  if (line.startsWith("-")) {
+    return `${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}${row}${ANSI_RESET}`;
+  }
+  return row.trimEnd();
+}
+function colorizeDiffLine(line, color, rowWidth) {
+  if (line.startsWith("+") || line.startsWith("-")) {
+    return styleAddedOrRemovedDiffRow(line, rowWidth, color);
+  }
+  const row = `${CODE_BLOCK_INDENT}${line}`;
+  if (!color) {
+    return row;
+  }
+  if (line.startsWith("@@")) {
+    return `${ANSI_CYAN}${row}${ANSI_RESET}`;
+  }
+  if (line.startsWith("diff ") || line.startsWith("index ")) {
+    return `${ANSI_DIM}${row}${ANSI_RESET}`;
+  }
+  return row;
+}
+function resolveDiffRowWidth(lines, requestedWidth) {
+  const minimumWidth = lines.reduce(
+    (maxWidth, line) => Math.max(maxWidth, CODE_BLOCK_INDENT.length + line.length),
+    0
+  );
+  if (requestedWidth === void 0) {
+    return minimumWidth;
+  }
+  return Math.max(minimumWidth, requestedWidth);
+}
+function renderDiffCodeBlock(code, color, codeBlockWidth) {
+  const lines = code.split("\n");
+  const rowWidth = resolveDiffRowWidth(lines, codeBlockWidth);
+  const body = lines.map((line) => colorizeDiffLine(line, color, rowWidth)).join("\n");
+  return `${body}
+
+`;
+}
+function createTerminalRenderer(color, codeBlockWidth) {
+  const renderer = new TerminalRendererConstructor(void 0, { ignoreIllegals: true });
+  const renderCode = renderer.code.bind(renderer);
+  renderer.code = (code, language, escaped) => {
+    if (isDiffLanguage(language)) {
+      return renderDiffCodeBlock(code, color, codeBlockWidth);
+    }
+    return renderCode(code, language, escaped);
+  };
+  return renderer;
+}
+function renderMarkdown(md, options = {}) {
+  const result = marked.parse(md, {
+    renderer: createTerminalRenderer(shouldUseColor(options.color), options.codeBlockWidth)
+  });
+  return typeof result === "string" ? result.trimEnd() : md;
+}
+
+// src/ToolDiffBlock.tsx
+import { Box, Text } from "ink";
+
+// src/utils/tool-diff-summary.ts
+var MAX_DIFF_LINES = 12;
+var TRUNCATED_SHOW = 10;
+function buildToolDiffSummary(input) {
+  const visibleLines = input.lines.length > MAX_DIFF_LINES ? selectVisibleDiffLines(input.lines) : input.lines;
+  const lineNumberWidth = Math.max(...visibleLines.map((line) => line.lineNumber), 0).toString().length;
+  const body = visibleLines.map((line) => formatDiffLine(line, lineNumberWidth));
+  const truncated = input.lines.length > MAX_DIFF_LINES;
+  return {
+    file: input.file,
+    markdown: ["```diff", ...body, "```"].join("\n"),
+    truncated,
+    remainingLineCount: truncated ? input.lines.length - visibleLines.length : 0
+  };
+}
+function formatDiffLine(line, lineNumberWidth) {
+  if (line.type === "hunk") return line.text;
+  const lineNumber = line.lineNumber.toString().padStart(lineNumberWidth, " ");
+  if (line.type === "remove") return `- ${lineNumber} | ${line.text}`;
+  if (line.type === "add") return `+ ${lineNumber} | ${line.text}`;
+  return `  ${lineNumber} | ${line.text}`;
+}
+function selectVisibleDiffLines(lines) {
+  const groups = groupByHunk(lines);
+  const visible = [];
+  for (const group of groups) {
+    if (visible.length === 0 && group.length > TRUNCATED_SHOW) {
+      return group.slice(0, TRUNCATED_SHOW);
+    }
+    if (visible.length + group.length > TRUNCATED_SHOW) break;
+    visible.push(...group);
+  }
+  return visible.length > 0 ? visible : lines.slice(0, TRUNCATED_SHOW);
+}
+function groupByHunk(lines) {
+  const groups = [];
+  let current = [];
+  for (const line of lines) {
+    if (line.type === "hunk" && current.length > 0) {
+      groups.push(current);
+      current = [line];
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length > 0) {
+    groups.push(current);
+  }
+  return groups;
+}
+
+// src/ToolDiffBlock.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function ToolDiffBlock({ file, lines }) {
+  const summary = buildToolDiffSummary({ file, lines });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 4, children: [
+    summary.file && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+      "\u2502 ",
+      summary.file
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: renderMarkdown(summary.markdown) }),
+    summary.truncated && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+      "\u2502 ... and ",
+      summary.remainingLineCount,
+      " more lines"
+    ] })
+  ] });
+}
+
+// src/UsageSummaryEntry.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { formatTokenCount } from "@robota-sdk/agent-core";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TOKEN_COMPACT_THRESHOLD = 1e3;
+function UsageSummaryEntry({ entry }) {
+  const usage = entry.data;
+  if (!usage) return /* @__PURE__ */ jsx2(Fragment, {});
+  const prompt = usage.promptTokens !== void 0 ? formatUsageTokenCount(usage.promptTokens) : "?";
+  const completion = usage.completionTokens !== void 0 ? formatUsageTokenCount(usage.completionTokens) : "?";
+  const total = formatUsageTokenCount(usage.totalTokens);
+  const context = `${Math.round(usage.contextUsedPercentage)}% (${formatTokenCount(
+    usage.contextUsedTokens
+  )}/${formatTokenCount(usage.contextMaxTokens)})`;
+  const costLabel = usage.costStatus === "unknown" ? "cost unknown" : `cost ${usage.costStatus}`;
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+      "Usage:",
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      usage.kind,
+      " ",
+      total,
+      " tokens (in ",
+      prompt,
+      " / out ",
+      completion,
+      ") \xB7 Context ",
+      context,
+      " \xB7",
+      " ",
+      costLabel
+    ] })
+  ] }) });
+}
+function formatUsageTokenCount(tokens) {
+  return tokens < TOKEN_COMPACT_THRESHOLD ? tokens.toLocaleString() : formatTokenCount(tokens);
+}
+
+// src/command-output-summary.ts
+var MAX_PREVIEW_LINES = 4;
+var SUCCESS_EXIT_CODE = 0;
+var COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set(["Bash", "BackgroundProcess"]);
+function formatCommandOutputSummary(tool) {
+  if (!COMMAND_TOOL_NAMES.has(tool.toolName) || !tool.toolResultData) return void 0;
+  const parsed = parseToolResultData(tool.toolResultData);
+  const exitCode = getNumberValue(parsed, "exitCode");
+  const successValue = getBooleanValue(parsed, "success");
+  const output = buildOutputText(tool.toolResultData, parsed);
+  const lines = trimTrailingBlankLines(splitOutputLines(output));
+  const previewLines = lines.slice(0, MAX_PREVIEW_LINES);
+  const omittedLineCount = Math.max(0, lines.length - previewLines.length);
+  const isFailed = tool.result === "error" || successValue === false || exitCode !== void 0 && exitCode !== SUCCESS_EXIT_CODE;
+  return {
+    status: isFailed ? "error" : "success",
+    statusLabel: formatStatusLabel(isFailed, exitCode),
+    previewLines,
+    omittedLineCount,
+    transcriptHint: omittedLineCount > 0 ? `... +${omittedLineCount} lines (full output in session transcript)` : void 0
+  };
+}
+function parseToolResultData(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function buildOutputText(raw, parsed) {
+  if (!isUniversalObject(parsed)) return raw;
+  const output = getStringValue(parsed, "output");
+  if (output !== void 0) return output;
+  const stdout = getStringValue(parsed, "stdout");
+  const stderr = getStringValue(parsed, "stderr");
+  const error = getStringValue(parsed, "error");
+  const lines = [];
+  if (stdout) lines.push(stdout);
+  if (stderr) lines.push(prefixLines(stderr, "[stderr] "));
+  if (!stdout && !stderr && error) lines.push(error);
+  return lines.join("\n");
+}
+function formatStatusLabel(isFailed, exitCode) {
+  if (exitCode !== void 0 && exitCode !== SUCCESS_EXIT_CODE) return `exit ${exitCode}`;
+  return isFailed ? "error" : "ok";
+}
+function splitOutputLines(output) {
+  if (!output) return [];
+  return output.replace(/\r\n/g, "\n").split("\n");
+}
+function trimTrailingBlankLines(lines) {
+  let end = lines.length;
+  while (end > 0 && lines[end - 1].trim().length === 0) {
+    end -= 1;
+  }
+  return lines.slice(0, end);
+}
+function prefixLines(value, prefix) {
+  return splitOutputLines(value).map((line) => `${prefix}${line}`).join("\n");
+}
+function isUniversalObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function getStringValue(source, key) {
+  if (!isUniversalObject(source)) return void 0;
+  const value = source[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getNumberValue(source, key) {
+  if (!isUniversalObject(source)) return void 0;
+  const value = source[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getBooleanValue(source, key) {
+  if (!isUniversalObject(source)) return void 0;
+  const value = source[key];
+  return typeof value === "boolean" ? value : void 0;
+}
+
+// src/ToolCommandOutput.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ToolCommandOutput({ tool }) {
+  const summary = formatCommandOutputSummary(tool);
+  if (!summary) return null;
+  if (summary.statusLabel === "ok" && summary.previewLines.length === 0 && !summary.transcriptHint) {
+    return null;
+  }
+  const color = summary.status === "error" ? "red" : "white";
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginLeft: 4, children: [
+    summary.statusLabel !== "ok" && /* @__PURE__ */ jsx3(Text3, { color, dimColor: true, children: summary.statusLabel }),
+    summary.previewLines.map((line, index) => /* @__PURE__ */ jsx3(Text3, { color, dimColor: true, children: line }, `${line}-${index}`)),
+    summary.transcriptHint && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: summary.transcriptHint })
+  ] });
+}
+
+// src/MessageList.tsx
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function getToolSummaryStatus(tool) {
+  if (formatCommandOutputSummary(tool)?.status === "error") return "\u2717";
+  if (tool.isRunning) return "\u27F3";
+  if (tool.result === "error") return "\u2717";
+  if (tool.result === "denied") return "\u2298";
+  return "\u2713";
+}
+function getToolSummaryColor(tool) {
+  if (formatCommandOutputSummary(tool)?.status === "error" || tool.result === "error") return "red";
+  if (tool.isRunning || tool.result === "denied") return "yellow";
+  return "green";
+}
+function getToolSummaryLabel(tool) {
+  return `${getToolSummaryStatus(tool)} ${tool.toolName}${tool.firstArg ? `(${tool.firstArg})` : ""}`;
+}
+function RoleLabel({ role }) {
+  switch (role) {
+    case "user":
+      return /* @__PURE__ */ jsxs4(Text4, { color: "green", bold: true, children: [
+        "You:",
+        " "
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsxs4(Text4, { color: "cyan", bold: true, children: [
+        "Robota:",
+        " "
+      ] });
+    case "system":
+      return /* @__PURE__ */ jsxs4(Text4, { color: "yellow", bold: true, children: [
+        "System:",
+        " "
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] });
+  }
+}
+function ToolMessage({ message }) {
+  if (!isToolMessage(message)) {
+    return /* @__PURE__ */ jsx4(Fragment2, {});
+  }
+  const toolName = message.name;
+  const content = message.content;
+  let summaries = null;
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed) && parsed.length > 0 && typeof parsed[0].line === "string") {
+      summaries = parsed;
+    }
+  } catch {
+  }
+  if (summaries) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
+          "Tool:",
+          " "
+        ] }),
+        toolName && /* @__PURE__ */ jsxs4(Text4, { color: "white", dimColor: true, children: [
+          "[",
+          toolName,
+          "]"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { children: " " }),
+      summaries.map((s, i) => /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
+          "  ",
+          "\u2713",
+          " ",
+          s.line
+        ] }),
+        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ jsx4(ToolDiffBlock, { file: s.diffFile, lines: s.diffLines })
+      ] }, i))
+    ] });
+  }
+  const lines = content.split("\n").filter((l) => l.trim());
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] }),
+      toolName && /* @__PURE__ */ jsxs4(Text4, { color: "white", dimColor: true, children: [
+        "[",
+        toolName,
+        "]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
+      "  ",
+      "\u2713",
+      " ",
+      line
+    ] }, i))
+  ] });
+}
+var MessageItem = React.memo(function MessageItem2({
+  message
+}) {
+  if (isToolMessage(message)) {
+    return /* @__PURE__ */ jsx4(ToolMessage, { message });
+  }
+  const content = message.content ?? "";
+  const isInterrupted = message.state === "interrupted";
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(RoleLabel, { role: message.role }) }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: isAssistantMessage(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+  ] });
+});
+function ToolSummaryEntry({ entry }) {
+  const data = entry.data;
+  const tools = data?.tools;
+  const lines = data?.summary?.split("\n") ?? [];
+  if (tools && tools.length > 0) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] }) }),
+      /* @__PURE__ */ jsx4(Text4, { children: " " }),
+      tools.map((tool, i) => /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: getToolSummaryColor(tool), children: [
+          "  ",
+          getToolSummaryLabel(tool)
+        ] }),
+        /* @__PURE__ */ jsx4(ToolCommandOutput, { tool }),
+        tool.diffLines && tool.diffLines.length > 0 && /* @__PURE__ */ jsx4(ToolDiffBlock, { file: tool.diffFile, lines: tool.diffLines })
+      ] }, i))
+    ] });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
+      "Tool:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
+      "  ",
+      line
+    ] }, i))
+  ] });
+}
+function EventEntry({ entry }) {
+  const eventData = entry.data;
+  const eventMessage = typeof eventData?.message === "string" ? eventData.message : typeof eventData?.content === "string" ? eventData.content : entry.type;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: "yellow", bold: true, children: [
+      "System:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: eventMessage }) })
+  ] });
+}
+function EntryItem({ entry }) {
+  if (entry.category === "chat") {
+    const message = entry.data;
+    return /* @__PURE__ */ jsx4(MessageItem, { message });
+  }
+  if (entry.type === "tool-summary") {
+    return /* @__PURE__ */ jsx4(ToolSummaryEntry, { entry });
+  }
+  if (entry.type === "usage-summary") {
+    return /* @__PURE__ */ jsx4(UsageSummaryEntry, { entry });
+  }
+  if (entry.type === "tool-start" || entry.type === "tool-end") {
+    return /* @__PURE__ */ jsx4(Fragment2, {});
+  }
+  return /* @__PURE__ */ jsx4(EventEntry, { entry });
+}
+function MessageList({ history }) {
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ jsx4(EntryItem, { entry }, entry.id)) });
+}
+
+// src/SessionStatusBar.tsx
+import { useMemo as useMemo2 } from "react";
+import { getModelName as getModelName2 } from "@robota-sdk/agent-core";
+
+// src/StatusBar.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { formatTokenCount as formatTokenCount2 } from "@robota-sdk/agent-core";
+
+// src/status-activity.ts
+var NO_ACTIVE_ITEMS = 0;
+function formatStatusActivity(input) {
+  const base = getPrimaryActivity(input);
+  const segments = input.hasPendingPrompt && base.kind !== "queued" ? ["queued"] : [];
+  const text = [base.label, ...segments].join(" \xB7 ");
+  return { ...base, segments, text };
+}
+function getPrimaryActivity(input) {
+  if (input.activeToolCount > NO_ACTIVE_ITEMS) {
+    return {
+      kind: "tools",
+      label: `Tools x${input.activeToolCount}`,
+      color: "cyan"
+    };
+  }
+  if (input.isThinking) {
+    return {
+      kind: "thinking",
+      label: "Thinking",
+      color: "yellow"
+    };
+  }
+  if (input.activeBackgroundTaskCount > NO_ACTIVE_ITEMS) {
+    return {
+      kind: "background",
+      label: `Background x${input.activeBackgroundTaskCount}`,
+      color: "cyan"
+    };
+  }
+  if (input.hasPendingPrompt) {
+    return {
+      kind: "queued",
+      label: "Queued",
+      color: "yellow"
+    };
+  }
+  return {
+    kind: "idle",
+    label: "Idle",
+    color: "gray"
+  };
+}
+
+// src/StatusBar.tsx
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var CONTEXT_YELLOW_THRESHOLD = 70;
+var CONTEXT_RED_THRESHOLD = 90;
+function getContextColor(percentage) {
+  if (percentage >= CONTEXT_RED_THRESHOLD) return "red";
+  if (percentage >= CONTEXT_YELLOW_THRESHOLD) return "yellow";
+  return "green";
+}
+function StatusActivityText({
+  isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt
+}) {
+  const activity = formatStatusActivity({
+    isThinking,
+    activeToolCount,
+    activeBackgroundTaskCount,
+    hasPendingPrompt
+  });
+  return /* @__PURE__ */ jsx5(Text5, { color: activity.color, bold: activity.kind !== "idle", children: activity.text });
+}
+function ContextText({
+  percentage,
+  usedTokens,
+  maxTokens
+}) {
+  return /* @__PURE__ */ jsxs5(Text5, { color: getContextColor(percentage), children: [
+    "Context: ",
+    Math.round(percentage),
+    "% (",
+    formatTokenCount2(usedTokens),
+    "/",
+    formatTokenCount2(maxTokens),
+    ")"
+  ] });
+}
+function ModeText({ permissionMode }) {
+  return /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "cyan", bold: true, children: "Mode:" }),
+    " ",
+    /* @__PURE__ */ jsx5(Text5, { children: permissionMode })
+  ] });
+}
+function shouldShowPermissionMode(permissionMode) {
+  return permissionMode !== "default";
+}
+function ProviderText({
+  modelName,
+  providerProfileName,
+  providerType
+}) {
+  if (providerProfileName !== void 0 && providerType !== void 0) {
+    return /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      providerProfileName,
+      " (",
+      providerType,
+      ") ",
+      modelName
+    ] });
+  }
+  return /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: modelName });
+}
+function StatusLeft(props) {
+  const shouldShowGitBranch = props.showGitBranch && props.gitBranch !== void 0 && props.gitBranch.length > 0;
+  const showPermissionMode = shouldShowPermissionMode(props.permissionMode);
+  return /* @__PURE__ */ jsxs5(Text5, { children: [
+    /* @__PURE__ */ jsx5(
+      StatusActivityText,
+      {
+        isThinking: props.isThinking,
+        activeToolCount: props.activeToolCount,
+        activeBackgroundTaskCount: props.activeBackgroundTaskCount,
+        hasPendingPrompt: props.hasPendingPrompt
+      }
+    ),
+    showPermissionMode && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      "  |  ",
+      /* @__PURE__ */ jsx5(ModeText, { permissionMode: props.permissionMode })
+    ] }),
+    props.sessionName && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      "  |  ",
+      /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: props.sessionName })
+    ] }),
+    shouldShowGitBranch && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      "  |  ",
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "git: ",
+        props.gitBranch
+      ] })
+    ] }),
+    "  |  ",
+    /* @__PURE__ */ jsx5(
+      ProviderText,
+      {
+        modelName: props.modelName,
+        providerProfileName: props.providerProfileName,
+        providerType: props.providerType
+      }
+    ),
+    "  |  ",
+    /* @__PURE__ */ jsx5(
+      ContextText,
+      {
+        percentage: props.contextPercentage,
+        usedTokens: props.contextUsedTokens,
+        maxTokens: props.contextMaxTokens
+      }
+    )
+  ] });
+}
+function StatusBar({
+  permissionMode,
+  modelName,
+  providerProfileName,
+  providerType,
+  sessionId: _sessionId,
+  isThinking,
+  activeToolCount = 0,
+  activeBackgroundTaskCount = 0,
+  hasPendingPrompt = false,
+  contextPercentage,
+  contextUsedTokens,
+  contextMaxTokens,
+  sessionName,
+  gitBranch,
+  showGitBranch = true
+}) {
+  return /* @__PURE__ */ jsx5(
+    Box5,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingLeft: 1,
+      paddingRight: 1,
+      justifyContent: "space-between",
+      children: /* @__PURE__ */ jsx5(
+        StatusLeft,
+        {
+          permissionMode,
+          modelName,
+          providerProfileName,
+          providerType,
+          isThinking,
+          activeToolCount,
+          activeBackgroundTaskCount,
+          hasPendingPrompt,
+          contextPercentage,
+          contextUsedTokens,
+          contextMaxTokens,
+          sessionName,
+          gitBranch,
+          showGitBranch
+        }
+      )
+    }
+  );
+}
+
+// src/SessionStatusBar.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function SessionStatusBar({
+  cwd,
+  permissionMode,
+  modelId,
+  providerProfileName,
+  providerType,
+  sessionId,
+  isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt,
+  contextState,
+  sessionName,
+  settings
+}) {
+  const cliAdapter = useTuiCliAdapter();
+  const gitBranch = useMemo2(() => cliAdapter.getGitBranch(cwd), [cliAdapter, cwd]);
+  if (!settings.enabled) return null;
+  return /* @__PURE__ */ jsx6(
+    StatusBar,
+    {
+      permissionMode,
+      modelName: modelId ? getModelName2(modelId) : "",
+      providerProfileName,
+      providerType,
+      sessionId,
+      isThinking,
+      activeToolCount,
+      activeBackgroundTaskCount,
+      hasPendingPrompt,
+      contextPercentage: contextState.percentage,
+      contextUsedTokens: contextState.usedTokens,
+      contextMaxTokens: contextState.maxTokens,
+      sessionName,
+      gitBranch,
+      showGitBranch: settings.gitBranch
+    }
+  );
+}
+
+// src/InputArea.tsx
+import { useState as useState8, useCallback as useCallback4, useRef as useRef4, useMemo as useMemo4 } from "react";
+import { Box as Box7, Text as Text9, useInput as useInput2, useWindowSize } from "ink";
+
+// src/CjkTextInput.tsx
+import { useRef as useRef3, useState as useState4 } from "react";
+import { Text as Text6, useInput, usePaste } from "ink";
+import chalk from "chalk";
+
+// src/flows/cjk-text-input-flow.ts
+import stringWidth from "string-width";
+var PASTE_START = "[200~";
+var PASTE_END = "[201~";
+var LAST_ASCII_CONTROL_CODE = 31;
+var DELETE_CONTROL_CODE = 127;
+function createCjkTextInputFlowState(value) {
+  return { value, cursor: value.length, isPasting: false, pasteBuffer: "" };
+}
+function syncCjkTextInputFlowState(state, value, cursorHint) {
+  if (value === state.value) {
+    return state;
+  }
+  return {
+    ...state,
+    value,
+    cursor: cursorHint != null ? Math.min(cursorHint, value.length) : value.length
+  };
+}
+function applyCjkTextInput(state, input, key, options) {
+  const pasteResult = applyPasteBoundaryInput(state, input, options);
+  if (pasteResult !== void 0) return pasteResult;
+  const controlResult = applyControlInput(state, input, key, options);
+  if (controlResult !== void 0) return controlResult;
+  const cursorResult = applyCursorInput(state, key, options);
+  if (cursorResult !== void 0) return cursorResult;
+  return insertPrintableInput(state, input);
+}
+function applyCjkTextPaste(state, text, options) {
+  const normalizedText = text.replace(/\r\n?/g, "\n");
+  if (normalizedText.length === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  if (normalizedText.includes("\n") && options.canPaste) {
+    return { state, effect: { type: "paste", text: normalizedText, cursor: state.cursor } };
+  }
+  return insertPrintableInput(state, normalizedText);
+}
+function applyPasteBoundaryInput(state, input, options) {
+  if (input === PASTE_START || input.startsWith(PASTE_START)) {
+    return startBracketedPaste(state, input);
+  }
+  if (state.isPasting) {
+    return continueBracketedPaste(state, input, options);
+  }
+  return void 0;
+}
+function applyControlInput(state, input, key, options) {
+  if (key.ctrl === true && input === "c" || key.tab === true) {
+    return { state, effect: { type: "none" } };
+  }
+  if (key.return === true) {
+    return { state, effect: { type: "submit", value: state.value } };
+  }
+  if (input.length > 1 && (input.includes("\n") || input.includes("\r")) && options.canPaste) {
+    return {
+      state,
+      effect: { type: "paste", text: input.replace(/\r\n?/g, "\n"), cursor: state.cursor }
+    };
+  }
+  return void 0;
+}
+function applyCursorInput(state, key, options) {
+  if (key.upArrow === true || key.downArrow === true) {
+    if (options.enableVerticalNavigation === false) {
+      return { state, effect: { type: "none" } };
+    }
+    return moveCursorVertically(
+      state,
+      key.upArrow === true ? "up" : "down",
+      options.availableWidth
+    );
+  }
+  if (key.leftArrow === true) {
+    return moveCursorHorizontally(state, "left");
+  }
+  if (key.rightArrow === true) {
+    return moveCursorHorizontally(state, "right");
+  }
+  if (key.backspace === true || key.delete === true) {
+    return deleteBeforeCursor(state);
+  }
+  return void 0;
+}
+function filterPrintable(input) {
+  if (!input || input.length === 0) return "";
+  let output = "";
+  for (const char of input) {
+    const code = char.charCodeAt(0);
+    if (code > LAST_ASCII_CONTROL_CODE && code !== DELETE_CONTROL_CODE) {
+      output += char;
+    }
+  }
+  return output;
+}
+function insertAtCursor(value, cursor, input) {
+  const next = value.slice(0, cursor) + input + value.slice(cursor);
+  return { value: next, cursor: cursor + input.length };
+}
+function displayOffset(chars, charIndex, width) {
+  let offset = 0;
+  for (let i = 0; i < charIndex && i < chars.length; i++) {
+    const w = stringWidth(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return offset;
+}
+function charIndexAtDisplayOffset(chars, target, width) {
+  let offset = 0;
+  for (let i = 0; i < chars.length; i++) {
+    if (offset >= target) return i;
+    const w = stringWidth(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return chars.length;
+}
+function startBracketedPaste(state, input) {
+  return {
+    state: { ...state, isPasting: true, pasteBuffer: input.slice(PASTE_START.length) },
+    effect: { type: "none" }
+  };
+}
+function continueBracketedPaste(state, input, options) {
+  if (input !== PASTE_END && !input.includes(PASTE_END)) {
+    return {
+      state: { ...state, pasteBuffer: state.pasteBuffer + input },
+      effect: { type: "none" }
+    };
+  }
+  const beforeMarker = input.split(PASTE_END)[0] ?? "";
+  const nextState = { ...state, isPasting: false, pasteBuffer: "" };
+  return applyCjkTextPaste(nextState, state.pasteBuffer + beforeMarker, options);
+}
+function moveCursorVertically(state, direction, availableWidth) {
+  if (!availableWidth || availableWidth <= 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const chars = [...state.value];
+  const offset = displayOffset(chars, state.cursor, availableWidth);
+  const target = direction === "up" ? offset - availableWidth : offset + availableWidth;
+  if (target < 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const cursor = charIndexAtDisplayOffset(chars, target, availableWidth);
+  if (cursor === state.cursor) {
+    return { state, effect: { type: "none" } };
+  }
+  return { state: { ...state, cursor }, effect: { type: "render" } };
+}
+function moveCursorHorizontally(state, direction) {
+  if (direction === "left" && state.cursor > 0) {
+    return { state: { ...state, cursor: state.cursor - 1 }, effect: { type: "render" } };
+  }
+  if (direction === "right" && state.cursor < state.value.length) {
+    return { state: { ...state, cursor: state.cursor + 1 }, effect: { type: "render" } };
+  }
+  return { state, effect: { type: "none" } };
+}
+function deleteBeforeCursor(state) {
+  if (state.cursor === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const value = state.value.slice(0, state.cursor - 1) + state.value.slice(state.cursor);
+  return {
+    state: { ...state, value, cursor: state.cursor - 1 },
+    effect: { type: "change", value }
+  };
+}
+function insertPrintableInput(state, input) {
+  const printable = filterPrintable(input);
+  if (printable.length === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const result = insertAtCursor(state.value, state.cursor, printable);
+  return {
+    state: { ...state, value: result.value, cursor: result.cursor },
+    effect: { type: "change", value: result.value }
+  };
+}
+
+// src/CjkTextInput.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function CjkTextInput({
+  value,
+  onChange,
+  onSubmit,
+  onPaste,
+  placeholder = "",
+  focus = true,
+  showCursor = true,
+  availableWidth,
+  cursorHint = null,
+  enableVerticalNavigation = true
+}) {
+  const stateRef = useRef3(createCjkTextInputFlowState(value));
+  const [, forceRender] = useState4(0);
+  stateRef.current = syncCjkTextInputFlowState(stateRef.current, value, cursorHint);
+  useCjkTextInputHandlers({
+    stateRef,
+    onChange,
+    onSubmit,
+    onPaste,
+    availableWidth,
+    focus,
+    enableVerticalNavigation,
+    forceRender
+  });
+  return /* @__PURE__ */ jsx7(Text6, { children: renderWithCursor(
+    stateRef.current.value,
+    stateRef.current.cursor,
+    placeholder,
+    showCursor && focus
+  ) });
+}
+function useCjkTextInputHandlers(options) {
+  usePaste(
+    (text) => {
+      applyCjkFlowSafely(
+        options,
+        () => applyCjkTextPaste(options.stateRef.current, text, createFlowOptions(options))
+      );
+    },
+    { isActive: options.focus }
+  );
+  useInput(
+    (input, key) => {
+      applyCjkFlowSafely(
+        options,
+        () => applyCjkTextInput(options.stateRef.current, input, key, createFlowOptions(options))
+      );
+    },
+    { isActive: options.focus }
+  );
+}
+function createFlowOptions(options) {
+  return {
+    availableWidth: options.availableWidth,
+    canPaste: options.onPaste !== void 0,
+    enableVerticalNavigation: options.enableVerticalNavigation
+  };
+}
+function applyCjkFlowSafely(options, run) {
+  try {
+    const result = run();
+    options.stateRef.current = result.state;
+    applyCjkTextInputEffect(
+      result.effect,
+      options.onChange,
+      options.onSubmit,
+      options.onPaste,
+      options.forceRender
+    );
+  } catch {
+  }
+}
+function applyCjkTextInputEffect(effect, onChange, onSubmit, onPaste, forceRender) {
+  if (effect.type === "change") {
+    onChange(effect.value);
+  } else if (effect.type === "submit") {
+    onSubmit?.(effect.value);
+  } else if (effect.type === "paste") {
+    onPaste?.(effect.text, effect.cursor);
+  } else if (effect.type === "render") {
+    forceRender((n) => n + 1);
+  }
+}
+function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
+  if (!showCursor) {
+    return value.length > 0 ? value : placeholder ? chalk.gray(placeholder) : "";
+  }
+  if (value.length === 0) {
+    if (placeholder.length > 0) {
+      return chalk.inverse(placeholder[0]) + chalk.gray(placeholder.slice(1));
+    }
+    return chalk.inverse(" ");
+  }
+  const chars = [...value];
+  let rendered = "";
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i] ?? "";
+    rendered += i === cursorOffset ? chalk.inverse(char) : char;
+  }
+  if (cursorOffset >= chars.length) {
+    rendered += chalk.inverse(" ");
+  }
+  return rendered;
+}
+
+// src/WaveText.tsx
+import { useState as useState5, useEffect as useEffect2 } from "react";
+import { Text as Text7 } from "ink";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
+var INTERVAL_MS = 400;
+var CHARS_PER_GROUP = 4;
+function WaveText({ text }) {
+  const [tick, setTick] = useState5(0);
+  useEffect2(() => {
+    const timer = setInterval(() => {
+      setTick((prev) => prev + 1);
+    }, INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, []);
+  const chars = [...text];
+  return /* @__PURE__ */ jsx8(Text7, { children: chars.map((char, i) => {
+    const group = Math.floor(i / CHARS_PER_GROUP);
+    const colorIndex = (tick + group) % WAVE_COLORS.length;
+    return /* @__PURE__ */ jsx8(Text7, { color: WAVE_COLORS[colorIndex], children: char }, i);
+  }) });
+}
+
+// src/SlashAutocomplete.tsx
+import { useState as useState6, useEffect as useEffect3 } from "react";
+import { Box as Box6, Text as Text8, useStdout } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var MAX_VISIBLE = 8;
+var OUTER_CHROME = 4;
+var MIN_ROW_WIDTH = 40;
+var NAME_COL_MAX = 20;
+function useRowWidth() {
+  const { stdout } = useStdout();
+  const measure = () => Math.max(MIN_ROW_WIDTH, (stdout.columns ?? 80) - OUTER_CHROME);
+  const [width, setWidth] = useState6(measure);
+  useEffect3(() => {
+    const onResize = () => setWidth(measure());
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return width;
+}
+function capName(name, colWidth) {
+  return name.length > colWidth ? `${name.slice(0, colWidth - 1)}\u2026` : name.padEnd(colWidth);
+}
+function CommandRow(props) {
+  const { cmd, isSelected, showSlash, rowWidth, nameColWidth } = props;
+  const indicator = isSelected ? "\u25B8 " : "  ";
+  const nameColor = isSelected ? "cyan" : void 0;
+  const dimmed = !isSelected;
+  const namePart = capName(cmd.name, nameColWidth);
+  const text = showSlash ? `${indicator}/${namePart}  ${cmd.description ?? ""}` : `${indicator}${namePart}  ${cmd.description ?? ""}`;
+  return /* @__PURE__ */ jsx9(Box6, { width: rowWidth, children: /* @__PURE__ */ jsx9(Text8, { color: nameColor, dimColor: dimmed, wrap: "truncate-end", children: text }) });
+}
+function SlashAutocomplete({
+  commands,
+  selectedIndex,
+  visible,
+  isSubcommandMode
+}) {
+  const rowWidth = useRowWidth();
+  if (!visible || commands.length === 0) return null;
+  const scrollOffset = computeScrollOffset(selectedIndex, commands.length);
+  const visibleCommands = commands.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
+  const nameColWidth = Math.min(
+    NAME_COL_MAX,
+    Math.max(...visibleCommands.map((c) => c.name.length))
+  );
+  return /* @__PURE__ */ jsx9(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ jsx9(
+    CommandRow,
+    {
+      cmd,
+      isSelected: scrollOffset + i === selectedIndex,
+      showSlash: !isSubcommandMode,
+      rowWidth,
+      nameColWidth
+    },
+    cmd.name
+  )) });
+}
+function computeScrollOffset(selectedIndex, total) {
+  if (total <= MAX_VISIBLE) return 0;
+  if (selectedIndex < MAX_VISIBLE) return 0;
+  const maxOffset = total - MAX_VISIBLE;
+  return Math.min(selectedIndex - MAX_VISIBLE + 1, maxOffset);
+}
+
+// src/utils/paste-labels.ts
+var PASTE_LABEL_RE = /\[Pasted text #(\d+)(?: \+\d+ lines)?\]/g;
+function expandPasteLabels(text, store) {
+  return text.replace(PASTE_LABEL_RE, (_, id) => store.get(Number(id)) ?? "");
+}
+
+// src/hooks/useAutocomplete.ts
+import React6, { useState as useState7, useMemo as useMemo3 } from "react";
+function parseSlashInput(value) {
+  if (!value.startsWith("/")) return { isSlash: false, parentCommand: "", filter: "" };
+  const afterSlash = value.slice(1);
+  const spaceIndex = afterSlash.indexOf(" ");
+  if (spaceIndex === -1) return { isSlash: true, parentCommand: "", filter: afterSlash };
+  const parent = afterSlash.slice(0, spaceIndex);
+  const rest = afterSlash.slice(spaceIndex + 1);
+  return { isSlash: true, parentCommand: parent, filter: rest };
+}
+function useAutocomplete(value, registry) {
+  const [selectedIndex, setSelectedIndex] = useState7(0);
+  const [dismissed, setDismissed] = useState7(false);
+  const prevValueRef = React6.useRef(value);
+  if (prevValueRef.current !== value) {
+    prevValueRef.current = value;
+    if (dismissed) setDismissed(false);
+  }
+  const parsed = parseSlashInput(value);
+  const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
+  const filteredCommands = useMemo3(() => {
+    if (!registry || !parsed.isSlash || dismissed) return [];
+    if (isSubcommandMode) {
+      const subs = registry.getSubcommands(parsed.parentCommand);
+      if (subs.length === 0) return [];
+      if (!parsed.filter) return subs;
+      const lower = parsed.filter.toLowerCase();
+      return subs.filter((c) => c.name.toLowerCase().startsWith(lower));
+    }
+    return registry.getCommands(parsed.filter);
+  }, [registry, parsed.isSlash, parsed.parentCommand, parsed.filter, dismissed, isSubcommandMode]);
+  const showPopup = parsed.isSlash && filteredCommands.length > 0 && !dismissed;
+  if (selectedIndex >= filteredCommands.length && filteredCommands.length > 0) {
+    setSelectedIndex(filteredCommands.length - 1);
+  }
+  return {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup: (val) => {
+      if (typeof val === "function") {
+        setDismissed((prev) => {
+          const nextVal = val(!prev);
+          return !nextVal;
+        });
+      } else {
+        setDismissed(!val);
+      }
+    }
+  };
+}
+
+// src/flows/input-area-flow.ts
+function getAutocompletePopupAction(key) {
+  if (key.upArrow === true) return "previous";
+  if (key.downArrow === true) return "next";
+  if (key.escape === true) return "close";
+  if (key.tab === true) return "complete";
+  return void 0;
+}
+function getPendingPromptInputAction(key) {
+  if (key.backspace === true || key.delete === true) {
+    return "cancelQueue";
+  }
+  return void 0;
+}
+function getPromptHistoryInputAction(key) {
+  if (key.upArrow === true) return "previous";
+  if (key.downArrow === true) return "next";
+  return void 0;
+}
+function createPromptHistoryNavigationState() {
+  return { selectedIndex: null, draft: "" };
+}
+function navigatePromptHistory(value, history, state, action) {
+  if (history.length === 0) {
+    return { value, cursorHint: value.length, state };
+  }
+  if (action === "previous") {
+    const selectedIndex = state.selectedIndex === null ? history.length - 1 : Math.max(0, state.selectedIndex - 1);
+    const nextValue = history[selectedIndex] ?? value;
+    return {
+      value: nextValue,
+      cursorHint: nextValue.length,
+      state: { selectedIndex, draft: state.selectedIndex === null ? value : state.draft }
+    };
+  }
+  if (state.selectedIndex === null) {
+    return { value, cursorHint: value.length, state };
+  }
+  if (state.selectedIndex < history.length - 1) {
+    const selectedIndex = state.selectedIndex + 1;
+    const nextValue = history[selectedIndex] ?? value;
+    return {
+      value: nextValue,
+      cursorHint: nextValue.length,
+      state: { ...state, selectedIndex }
+    };
+  }
+  return {
+    value: state.draft,
+    cursorHint: state.draft.length,
+    state: createPromptHistoryNavigationState()
+  };
+}
+function appendPromptHistory(history, value) {
+  const prompt = value.trim();
+  if (prompt.length === 0) return [...history];
+  if (history[history.length - 1] === prompt) return [...history];
+  return [...history, prompt];
+}
+function extractPromptHistory(entries) {
+  let prompts = [];
+  for (const entry of entries) {
+    if (entry.category !== "chat" || entry.type !== "user") continue;
+    const data = entry.data;
+    if (typeof data?.content !== "string") continue;
+    prompts = appendPromptHistory(prompts, data.content);
+  }
+  return prompts;
+}
+function moveAutocompleteSelection(selectedIndex, commandCount, direction) {
+  if (commandCount === 0) return 0;
+  if (direction === "previous") {
+    return selectedIndex > 0 ? selectedIndex - 1 : commandCount - 1;
+  }
+  return selectedIndex < commandCount - 1 ? selectedIndex + 1 : 0;
+}
+function resolveTabCompletion(value, command) {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: "insert", value: `/${parsed.parentCommand} ${command.name} ` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: "insert", value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: "insert", value: `/${command.name} ` };
+}
+function resolveEnterCommandSelection(value, command) {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: "submit", value: `/${parsed.parentCommand} ${command.name}` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: "insert", value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: "submit", value: `/${command.name}` };
+}
+function createPasteLabelChange(value, cursorPosition, pasteId, text) {
+  const lineCount = text.split("\n").length;
+  const label = `[Pasted text #${pasteId} +${lineCount} lines]`;
+  return {
+    value: value.slice(0, cursorPosition) + label + value.slice(cursorPosition),
+    cursorHint: cursorPosition + label.length,
+    label,
+    lineCount
+  };
+}
+function shouldSubmitInput(text) {
+  return text.trim().length > 0;
+}
+
+// src/InputArea.tsx
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var PENDING_PROMPT_DISPLAY_MAX = 50;
+var PENDING_PROMPT_TAIL_KEEP = 47;
+var BORDER_HORIZONTAL = 2;
+var PADDING_LEFT = 1;
+var PROMPT_WIDTH = 2;
+var INPUT_AREA_OVERHEAD = BORDER_HORIZONTAL + PADDING_LEFT + PROMPT_WIDTH;
+var DEFAULT_TERMINAL_COLUMNS = 80;
+function InputArea({
+  onSubmit,
+  onCancelQueue,
+  isDisabled,
+  isAborting,
+  pendingPrompt,
+  registry,
+  sessionName,
+  history
+}) {
+  const [value, setValue] = useState8("");
+  const [cursorHint, setCursorHint] = useState8(null);
+  const [historyState, setHistoryState] = useState8(createPromptHistoryNavigationState);
+  const [localPromptHistory, setLocalPromptHistory] = useState8([]);
+  const restoredPromptHistory = useMemo4(() => extractPromptHistory(history ?? []), [history]);
+  const promptHistory = useMemo4(
+    () => localPromptHistory.reduce(
+      (prompts, prompt) => appendPromptHistory(prompts, prompt),
+      restoredPromptHistory
+    ),
+    [restoredPromptHistory, localPromptHistory]
+  );
+  const pasteStore = useRef4(/* @__PURE__ */ new Map());
+  const { columns } = useWindowSize();
+  const terminalColumns = columns > 0 ? columns : DEFAULT_TERMINAL_COLUMNS;
+  const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
+  const pasteIdRef = useRef4(0);
+  const {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup
+  } = useAutocomplete(value, registry);
+  const handlePaste = useCallback4((text, cursorPosition) => {
+    pasteIdRef.current += 1;
+    const id = pasteIdRef.current;
+    pasteStore.current.set(id, text);
+    setValue((prev) => {
+      const change = createPasteLabelChange(prev, cursorPosition, id, text);
+      setCursorHint(change.cursorHint);
+      return change.value;
+    });
+  }, []);
+  const resetHistoryNavigation = useCallback4(() => {
+    setHistoryState(createPromptHistoryNavigationState());
+  }, []);
+  const recordPromptHistory = useCallback4((prompt) => {
+    setLocalPromptHistory((prev) => appendPromptHistory(prev, prompt));
+  }, []);
+  const submitPrompt = useCallback4(
+    (prompt) => {
+      recordPromptHistory(prompt);
+      resetHistoryNavigation();
+      onSubmit(prompt);
+    },
+    [onSubmit, recordPromptHistory, resetHistoryNavigation]
+  );
+  const tabCompleteCommand = useCallback4(
+    (cmd) => {
+      const result = resolveTabCompletion(value, cmd);
+      if (result.type === "insert") {
+        setValue(result.value);
+        if (result.selectedIndex !== void 0) {
+          setSelectedIndex(result.selectedIndex);
+        }
+      }
+    },
+    [value, setSelectedIndex]
+  );
+  const enterSelectCommand = useCallback4(
+    (cmd) => {
+      const result = resolveEnterCommandSelection(value, cmd);
+      if (result.type === "insert") {
+        setValue(result.value);
+        if (result.selectedIndex !== void 0) {
+          setSelectedIndex(result.selectedIndex);
+        }
+        return;
+      }
+      setValue("");
+      submitPrompt(result.value);
+    },
+    [value, submitPrompt, setSelectedIndex]
+  );
+  const handleSubmit = useCallback4(
+    (text) => {
+      if (!shouldSubmitInput(text)) return;
+      if (showPopup && filteredCommands[selectedIndex]) {
+        enterSelectCommand(filteredCommands[selectedIndex]);
+        return;
+      }
+      const expanded = expandPasteLabels(text.trim(), pasteStore.current);
+      setValue("");
+      pasteStore.current.clear();
+      pasteIdRef.current = 0;
+      submitPrompt(expanded);
+    },
+    [showPopup, filteredCommands, selectedIndex, enterSelectCommand, submitPrompt]
+  );
+  useInput2(
+    (_input, key) => {
+      if (!showPopup) return;
+      const action = getAutocompletePopupAction(key);
+      if (action === "previous" || action === "next") {
+        setSelectedIndex(
+          (prev) => moveAutocompleteSelection(prev, filteredCommands.length, action)
+        );
+      } else if (action === "close") {
+        setShowPopup(false);
+      } else if (action === "complete") {
+        const cmd = filteredCommands[selectedIndex];
+        if (cmd) tabCompleteCommand(cmd);
+      }
+    },
+    { isActive: showPopup && !isDisabled }
+  );
+  useInput2(
+    (_input, key) => {
+      const action = getPromptHistoryInputAction(key);
+      if (!action) return;
+      const result = navigatePromptHistory(value, promptHistory, historyState, action);
+      setValue(result.value);
+      setCursorHint(result.cursorHint);
+      setHistoryState(result.state);
+    },
+    { isActive: !showPopup && !isDisabled && !pendingPrompt }
+  );
+  useInput2(
+    (_input, key) => {
+      if (getPendingPromptInputAction(key) === "cancelQueue" && pendingPrompt) {
+        onCancelQueue?.();
+      }
+    },
+    { isActive: !!pendingPrompt }
+  );
+  const borderColor = isAborting ? "yellow" : pendingPrompt ? "cyan" : isDisabled ? "gray" : "green";
+  const innerWidth = Math.max(1, terminalColumns - BORDER_HORIZONTAL);
+  const topBorder = (() => {
+    if (sessionName) {
+      const label = ` "${sessionName}" `;
+      const rightPad = 2;
+      const leftLen = Math.max(0, innerWidth - label.length - rightPad);
+      return { left: "\u250C" + "\u2500".repeat(leftLen), label, right: "\u2500".repeat(rightPad) + "\u2510" };
+    }
+    return { left: "\u250C" + "\u2500".repeat(innerWidth), label: "", right: "\u2510" };
+  })();
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ jsx10(
+      SlashAutocomplete,
+      {
+        commands: filteredCommands,
+        selectedIndex,
+        visible: showPopup,
+        isSubcommandMode
+      }
+    ),
+    /* @__PURE__ */ jsxs6(Text9, { color: borderColor, children: [
+      topBorder.left,
+      topBorder.label ? /* @__PURE__ */ jsx10(Text9, { backgroundColor: borderColor, color: "black", bold: true, children: topBorder.label }) : null,
+      topBorder.right
+    ] }),
+    /* @__PURE__ */ jsx10(Box7, { borderStyle: "single", borderTop: false, borderColor, paddingLeft: 1, children: isAborting ? /* @__PURE__ */ jsx10(Text9, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ jsxs6(Text9, { color: "cyan", children: [
+      " ",
+      "Queued:",
+      " ",
+      pendingPrompt.length > PENDING_PROMPT_DISPLAY_MAX ? pendingPrompt.slice(0, PENDING_PROMPT_TAIL_KEEP) + "..." : pendingPrompt,
+      " ",
+      /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "(Backspace to cancel)" })
+    ] }) : isDisabled ? /* @__PURE__ */ jsx10(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsx10(Text9, { color: "green", bold: true, children: "> " }),
+      /* @__PURE__ */ jsx10(
+        CjkTextInput,
+        {
+          value,
+          onChange: (v) => {
+            setValue(v);
+            resetHistoryNavigation();
+            setCursorHint(null);
+          },
+          onSubmit: handleSubmit,
+          onPaste: handlePaste,
+          placeholder: "Type a message or /help",
+          availableWidth,
+          cursorHint,
+          enableVerticalNavigation: false
+        }
+      )
+    ] }) })
+  ] });
+}
+
+// src/ConfirmPrompt.tsx
+import { useState as useState9, useRef as useRef5, useCallback as useCallback5 } from "react";
+import { Box as Box8, Text as Text10, useInput as useInput3 } from "ink";
+
+// src/flows/selection-flow.ts
+function createSelectionFlowState() {
+  return { selectedIndex: 0, scrollOffset: 0, resolved: false };
+}
+function getVerticalSelectionInputAction(key) {
+  if (key.escape === true) return "cancel";
+  if (key.upArrow === true) return "previous";
+  if (key.downArrow === true) return "next";
+  if (key.return === true) return "select";
+  return void 0;
+}
+function getDirectionalSelectionInputAction(key) {
+  if (key.escape === true) return "cancel";
+  if (key.leftArrow === true || key.upArrow === true) return "previous";
+  if (key.rightArrow === true || key.downArrow === true) return "next";
+  if (key.return === true) return "select";
+  return void 0;
+}
+function applySelectionInput(state, action, options) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action === "cancel") {
+    return { state: { ...state, resolved: true }, effect: { type: "cancel" } };
+  }
+  if (options.enabled === false || options.itemCount === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action === "select") {
+    const index = clampIndex(state.selectedIndex, options.itemCount);
+    return {
+      state: { ...state, selectedIndex: index, resolved: true },
+      effect: { type: "select", index }
+    };
+  }
+  const selectedIndex = moveSelection(state.selectedIndex, action, options);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  return { state: { ...state, selectedIndex, scrollOffset }, effect: { type: "none" } };
+}
+function normalizeSelectionState(state, options) {
+  if (options.itemCount === 0) {
+    return { ...state, selectedIndex: 0, scrollOffset: 0 };
+  }
+  const selectedIndex = clampIndex(state.selectedIndex, options.itemCount);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  if (selectedIndex === state.selectedIndex && scrollOffset === state.scrollOffset) {
+    return state;
+  }
+  return {
+    ...state,
+    selectedIndex,
+    scrollOffset
+  };
+}
+function moveSelection(selectedIndex, action, options) {
+  if (action === "previous") {
+    if (options.wrap === true && selectedIndex === 0) return options.itemCount - 1;
+    return Math.max(0, selectedIndex - 1);
+  }
+  if (options.wrap === true && selectedIndex === options.itemCount - 1) return 0;
+  return Math.min(options.itemCount - 1, selectedIndex + 1);
+}
+function resolveScrollOffset(selectedIndex, scrollOffset, options) {
+  const maxVisible = options.maxVisible ?? options.itemCount;
+  if (maxVisible <= 0) return 0;
+  if (selectedIndex < scrollOffset) return selectedIndex;
+  if (selectedIndex >= scrollOffset + maxVisible) return selectedIndex - maxVisible + 1;
+  return Math.max(0, scrollOffset);
+}
+function clampIndex(index, itemCount) {
+  return Math.min(Math.max(index, 0), itemCount - 1);
+}
+
+// src/flows/confirm-prompt-flow.ts
+function getConfirmPromptInputAction(input, key, optionCount) {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== void 0) {
+    return action;
+  }
+  if (optionCount === 2 && input === "y") {
+    return { type: "shortcut", index: 0 };
+  }
+  if (optionCount === 2 && input === "n") {
+    return { type: "shortcut", index: 1 };
+  }
+  return void 0;
+}
+function applyConfirmPromptInput(state, action, optionCount) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (typeof action !== "string") {
+    return {
+      state: { ...state, selectedIndex: action.index, resolved: true },
+      effect: { type: "select", index: action.index }
+    };
+  }
+  return applySelectionInput(state, action, { itemCount: optionCount });
+}
+
+// src/ConfirmPrompt.tsx
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+function ConfirmPrompt({
+  message,
+  options = ["Yes", "No"],
+  onSelect
+}) {
+  const [state, setState] = useState9(() => createSelectionFlowState());
+  const stateRef = useRef5(state);
+  const applyAction = useCallback5(
+    (action) => {
+      const result = applyConfirmPromptInput(stateRef.current, action, options.length);
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "select") {
+        onSelect(result.effect.index);
+      }
+    },
+    [onSelect, options.length]
+  );
+  useInput3((input, key) => {
+    const action = getConfirmPromptInputAction(input, key, options.length);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx11(Text10, { color: "yellow", children: message }),
+    /* @__PURE__ */ jsx11(Box8, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ jsx11(Box8, { marginRight: 2, children: /* @__PURE__ */ jsxs7(
+      Text10,
+      {
+        color: i === state.selectedIndex ? "cyan" : void 0,
+        bold: i === state.selectedIndex,
+        children: [
+          i === state.selectedIndex ? "> " : "  ",
+          opt
+        ]
+      }
+    ) }, opt)) }),
+    /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
+  ] });
+}
+
+// src/InteractivePrompt.tsx
+import { Box as Box11, Text as Text13 } from "ink";
+
+// src/ListPicker.tsx
+import { useState as useState10, useRef as useRef6, useCallback as useCallback6 } from "react";
+import { Box as Box9, Text as Text11, useInput as useInput4 } from "ink";
+import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+var DEFAULT_MAX_VISIBLE = 3;
+function ListPicker({
+  items,
+  renderItem,
+  onSelect,
+  onCancel,
+  maxVisible = DEFAULT_MAX_VISIBLE
+}) {
+  const [state, setState] = useState10(() => createSelectionFlowState());
+  const stateRef = useRef6(state);
+  const applyAction = useCallback6(
+    (action) => {
+      const result = applySelectionInput(stateRef.current, action, {
+        itemCount: items.length,
+        maxVisible
+      });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onCancel();
+      } else if (result.effect.type === "select") {
+        const item = items[result.effect.index];
+        if (item !== void 0) {
+          onSelect(item);
+        }
+      }
+    },
+    [items, maxVisible, onCancel, onSelect]
+  );
+  useInput4((_input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx12(Box9, {});
+  }
+  const normalizedState = normalizeSelectionState(state, { itemCount: items.length, maxVisible });
+  if (normalizedState !== state) {
+    stateRef.current = normalizedState;
+  }
+  const { selectedIndex, scrollOffset } = normalizedState;
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxVisible);
+  const hasMore = scrollOffset + maxVisible < items.length;
+  const hasLess = scrollOffset > 0;
+  return /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", children: [
+    hasLess && /* @__PURE__ */ jsxs8(Text11, { dimColor: true, children: [
+      " \u2191 ",
+      scrollOffset,
+      " more above"
+    ] }),
+    visibleItems.map((item, index) => /* @__PURE__ */ jsx12(Box9, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
+    hasMore && /* @__PURE__ */ jsxs8(Text11, { dimColor: true, children: [
+      " \u2193 ",
+      items.length - scrollOffset - maxVisible,
+      " more below"
+    ] })
+  ] });
+}
+
+// src/TextPrompt.tsx
+import { useState as useState11, useRef as useRef7, useCallback as useCallback7 } from "react";
+import { Box as Box10, Text as Text12, useInput as useInput5 } from "ink";
+
+// src/flows/text-prompt-flow.ts
+function createTextPromptFlowState() {
+  return { value: "", resolved: false };
+}
+function getTextPromptInputAction(input, key) {
+  if (key.escape === true) {
+    return { type: "cancel" };
+  }
+  if (key.return === true) {
+    return { type: "submit" };
+  }
+  if (key.backspace === true || key.delete === true) {
+    return { type: "delete" };
+  }
+  if (input && key.ctrl !== true && key.meta !== true) {
+    return { type: "insert", value: input };
+  }
+  return void 0;
+}
+function applyTextPromptInput(state, action, options) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action.type === "cancel") {
+    return { state: { ...state, resolved: true }, effect: { type: "cancel" } };
+  }
+  if (action.type === "delete") {
+    return {
+      state: { ...state, value: state.value.slice(0, -1), error: void 0 },
+      effect: { type: "none" }
+    };
+  }
+  if (action.type === "insert") {
+    return {
+      state: { ...state, value: state.value + action.value, error: void 0 },
+      effect: { type: "none" }
+    };
+  }
+  return submitTextPromptValue(state, options);
+}
+function submitTextPromptValue(state, options) {
+  const trimmed = state.value.trim();
+  if (!trimmed && !options.allowEmpty) {
+    const emptyError = options.validate?.(trimmed);
+    return {
+      state: emptyError ? { ...state, error: emptyError } : state,
+      effect: { type: "none" }
+    };
+  }
+  const error = options.validate?.(trimmed);
+  if (error !== void 0) {
+    return { state: { ...state, error }, effect: { type: "none" } };
+  }
+  return { state: { ...state, resolved: true }, effect: { type: "submit", value: trimmed } };
+}
+
+// src/TextPrompt.tsx
+import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+function TextPrompt({
+  title,
+  description,
+  placeholder,
+  onSubmit,
+  onCancel,
+  validate,
+  allowEmpty = false,
+  masked = false
+}) {
+  const [state, setState] = useState11(() => createTextPromptFlowState());
+  const stateRef = useRef7(state);
+  const applyAction = useCallback7(
+    (action) => {
+      const result = applyTextPromptInput(stateRef.current, action, { allowEmpty, validate });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onCancel();
+      } else if (result.effect.type === "submit") {
+        onSubmit(result.effect.value);
+      }
+    },
+    [allowEmpty, validate, onCancel, onSubmit]
+  );
+  useInput5((input, key) => {
+    const action = getTextPromptInputAction(input, key);
+    if (action !== void 0) applyAction(action);
+  });
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx13(Text12, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ jsx13(PromptDescription, { description }),
+    /* @__PURE__ */ jsxs9(Box10, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx13(Text12, { color: "cyan", children: "> " }),
+      state.value ? /* @__PURE__ */ jsx13(Text12, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ jsx13(Text12, { dimColor: true, children: placeholder }) : null,
+      /* @__PURE__ */ jsx13(Text12, { color: "cyan", children: "\u2588" })
+    ] }),
+    state.error && /* @__PURE__ */ jsx13(Text12, { color: "red", children: state.error }),
+    /* @__PURE__ */ jsx13(Text12, { dimColor: true, children: " Enter Submit Esc Cancel" })
+  ] });
+}
+function PromptDescription({ description }) {
+  if (description === void 0 || description.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx13(Text12, { dimColor: true, children: description });
+}
+
+// src/InteractivePrompt.tsx
+import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+function InteractivePrompt({
+  prompt,
+  onSubmit,
+  onCancel
+}) {
+  if (prompt.kind === "text") {
+    return /* @__PURE__ */ jsx14(
+      TextPrompt,
+      {
+        title: prompt.title,
+        description: prompt.description,
+        placeholder: prompt.placeholder,
+        allowEmpty: prompt.allowEmpty,
+        masked: prompt.masked,
+        validate: prompt.validate,
+        onSubmit,
+        onCancel
+      },
+      `text:${prompt.title}`
+    );
+  }
+  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx14(Text13, { bold: true, children: prompt.title }),
+    prompt.description !== void 0 && prompt.description.length > 0 && /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: prompt.description }),
+    /* @__PURE__ */ jsx14(
+      ListPicker,
+      {
+        items: [...prompt.options],
+        maxVisible: prompt.maxVisible,
+        renderItem: (option, isSelected) => /* @__PURE__ */ jsxs10(Text13, { color: isSelected ? "cyan" : void 0, children: [
+          isSelected ? "> " : "  ",
+          option.label
+        ] }),
+        onSelect: (option) => onSubmit(option.value),
+        onCancel
+      }
+    )
+  ] });
+}
+
+// src/PermissionPrompt.tsx
+import React11 from "react";
+import { Box as Box12, Text as Text14, useInput as useInput6 } from "ink";
+
+// src/flows/permission-prompt-flow.ts
+var PERMISSION_PROMPT_OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
+function getPermissionPromptInputAction(input, key) {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== void 0) {
+    return action;
+  }
+  if (input === "y" || input === "1") {
+    return { type: "shortcut", index: 0 };
+  }
+  if (input === "a" || input === "2") {
+    return { type: "shortcut", index: 1 };
+  }
+  if (input === "n" || input === "d" || input === "3") {
+    return { type: "shortcut", index: 2 };
+  }
+  return void 0;
+}
+function applyPermissionPromptInput(state, action) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (typeof action !== "string") {
+    return resolvePermissionIndex(state, action.index);
+  }
+  const result = applySelectionInput(state, action, {
+    itemCount: PERMISSION_PROMPT_OPTIONS.length
+  });
+  if (result.effect.type !== "select") {
+    return { state: result.state, effect: { type: "none" } };
+  }
+  return {
+    state: result.state,
+    effect: { type: "resolve", decision: getPermissionDecision(result.effect.index) }
+  };
+}
+function getPermissionDecision(index) {
+  if (index === 0) return true;
+  if (index === 1) return "allow-session";
+  return false;
+}
+function resolvePermissionIndex(state, index) {
+  return {
+    state: { ...state, selectedIndex: index, resolved: true },
+    effect: { type: "resolve", decision: getPermissionDecision(index) }
+  };
+}
+
+// src/PermissionPrompt.tsx
+import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+function formatArgs(args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "(no arguments)";
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+function PermissionPrompt({ request }) {
+  const [state, setState] = React11.useState(() => createSelectionFlowState());
+  const stateRef = React11.useRef(state);
+  const prevRequestRef = React11.useRef(request);
+  if (prevRequestRef.current !== request) {
+    prevRequestRef.current = request;
+    const nextState = createSelectionFlowState();
+    stateRef.current = nextState;
+    setState(nextState);
+  }
+  const applyAction = React11.useCallback(
+    (action) => {
+      const result = applyPermissionPromptInput(stateRef.current, action);
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "resolve") {
+        request.resolve(result.effect.decision);
+      }
+    },
+    [request]
+  );
+  useInput6((input, key) => {
+    const action = getPermissionPromptInputAction(input, key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx15(Text14, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ jsxs11(Text14, { children: [
+      "Tool:",
+      " ",
+      /* @__PURE__ */ jsx15(Text14, { color: "cyan", bold: true, children: request.toolName })
+    ] }),
+    /* @__PURE__ */ jsxs11(Text14, { dimColor: true, children: [
+      " ",
+      formatArgs(request.toolArgs)
+    ] }),
+    /* @__PURE__ */ jsx15(Box12, { marginTop: 1, children: PERMISSION_PROMPT_OPTIONS.map((opt, i) => /* @__PURE__ */ jsx15(Box12, { marginRight: 2, children: /* @__PURE__ */ jsxs11(
+      Text14,
+      {
+        color: i === state.selectedIndex ? "cyan" : void 0,
+        bold: i === state.selectedIndex,
+        children: [
+          i === state.selectedIndex ? "> " : "  ",
+          opt
+        ]
+      }
+    ) }, opt)) }),
+    /* @__PURE__ */ jsx15(Text14, { dimColor: true, children: " left/right to select, Enter to confirm" })
+  ] });
+}
+
+// src/StreamingIndicator.tsx
+import { Box as Box13, Text as Text15 } from "ink";
+import { Fragment as Fragment4, jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+function getToolStyle(t) {
+  if (t.isRunning) return { color: "yellow", icon: "\u27F3", strikethrough: false };
+  if (t.result === "error") return { color: "red", icon: "\u2717", strikethrough: true };
+  if (t.result === "denied") return { color: "yellowBright", icon: "\u2298", strikethrough: true };
+  return { color: "green", icon: "\u2713", strikethrough: false };
+}
+function renderThinkingFallback(isThinking) {
+  if (!isThinking) return /* @__PURE__ */ jsx16(Fragment4, {});
+  return /* @__PURE__ */ jsx16(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text15, { color: "yellow", children: "Thinking..." }) });
+}
+function renderTools(activeTools) {
+  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "Tools:" }),
+    /* @__PURE__ */ jsx16(Text15, { children: " " }),
+    activeTools.map((t, i) => {
+      const { color, icon, strikethrough } = getToolStyle(t);
+      return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs12(Text15, { color, strikethrough, children: [
+          "  ",
+          icon,
+          " ",
+          t.toolName,
+          "(",
+          t.firstArg,
+          ")"
+        ] }),
+        t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ jsx16(ToolDiffBlock, { file: t.diffFile, lines: t.diffLines })
+      ] }, `${t.toolName}-${i}`);
+    })
+  ] });
+}
+function StreamingIndicator({
+  text,
+  activeTools,
+  isThinking = false
+}) {
+  const hasTools = activeTools.length > 0;
+  const hasText = text.length > 0;
+  if (!hasTools && !hasText) {
+    return renderThinkingFallback(isThinking);
+  }
+  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
+    hasTools && renderTools(activeTools),
+    hasText && /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text15, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ jsx16(Text15, { children: " " }),
+      /* @__PURE__ */ jsx16(Box13, { marginLeft: 2, children: /* @__PURE__ */ jsx16(Text15, { wrap: "wrap", children: renderMarkdown(text) }) })
+    ] })
+  ] });
+}
+
+// src/PluginTUI.tsx
+import { useState as useState14, useCallback as useCallback9 } from "react";
+
+// src/MenuSelect.tsx
+import { useState as useState12, useCallback as useCallback8, useRef as useRef8 } from "react";
+import { Box as Box14, Text as Text16, useInput as useInput7 } from "ink";
+import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+function MenuSelect({
+  title,
+  items,
+  onSelect,
+  onBack,
+  loading,
+  error
+}) {
+  const [state, setState] = useState12(() => createSelectionFlowState());
+  const stateRef = useRef8(state);
+  const isEnabled = !loading && !error;
+  const applyAction = useCallback8(
+    (action) => {
+      const result = applySelectionInput(stateRef.current, action, {
+        itemCount: items.length,
+        enabled: isEnabled
+      });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onBack();
+      } else if (result.effect.type === "select") {
+        const item = items[result.effect.index];
+        if (item !== void 0) {
+          onSelect(item.value);
+        }
+      }
+    },
+    [isEnabled, items, onBack, onSelect]
+  );
+  useInput7((input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  const normalizedState = normalizeSelectionState(state, { itemCount: items.length });
+  if (normalizedState !== state) {
+    stateRef.current = normalizedState;
+  }
+  const selected = normalizedState.selectedIndex;
+  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx17(Text16, { color: "yellow", bold: true, children: title }),
+    loading && /* @__PURE__ */ jsx17(Box14, { marginTop: 1, children: /* @__PURE__ */ jsx17(Text16, { dimColor: true, children: "Loading..." }) }),
+    error && /* @__PURE__ */ jsxs13(Box14, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx17(Text16, { color: "red", children: error }),
+      /* @__PURE__ */ jsx17(Text16, { dimColor: true, children: "Press Esc to go back" })
+    ] }),
+    !loading && !error && /* @__PURE__ */ jsx17(Box14, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ jsxs13(Box14, { children: [
+      /* @__PURE__ */ jsxs13(Text16, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+        i === selected ? "> " : "  ",
+        item.label
+      ] }),
+      item.hint && /* @__PURE__ */ jsxs13(Text16, { dimColor: true, children: [
+        " ",
+        item.hint
+      ] })
+    ] }, item.value)) }),
+    /* @__PURE__ */ jsx17(Text16, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
+  ] });
+}
+
+// src/plugin-tui-handlers.ts
+function handleMainSelect(value, nav) {
+  if (value === "marketplace") {
+    nav.push({ screen: "marketplace-list" });
+  } else if (value === "installed") {
+    nav.push({ screen: "installed-list" });
+  }
+}
+function handleMarketplaceListSelect(value, nav) {
+  if (value === "__add__") {
+    nav.push({ screen: "marketplace-add" });
+  } else {
+    nav.push({ screen: "marketplace-action", context: { marketplace: value } });
+  }
+}
+function handleMarketplaceActionSelect(value, marketplace, callbacks, nav) {
+  if (value === "browse") {
+    nav.push({ screen: "marketplace-browse", context: { marketplace } });
+  } else if (value === "update") {
+    callbacks.marketplaceUpdate(marketplace).then(() => {
+      nav.notify(`Updated marketplace "${marketplace}".`);
+      nav.pop();
+    }).catch((err) => {
+      nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  } else if (value === "remove") {
+    nav.setConfirm({
+      message: `Remove marketplace "${marketplace}" and all its plugins?`,
+      onConfirm: () => {
+        nav.setConfirm(void 0);
+        callbacks.marketplaceRemove(marketplace).then(() => {
+          nav.notify(`Removed marketplace "${marketplace}".`);
+          nav.popN(2);
+        }).catch((err) => {
+          nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      },
+      onCancel: () => nav.setConfirm(void 0)
+    });
+  }
+}
+function handleMarketplaceBrowseSelect(value, marketplace, items, nav) {
+  const fullId = `${value}@${marketplace}`;
+  const item = items.find((i) => i.value === value);
+  if (item?.hint === "installed") {
+    nav.push({ screen: "installed-action", context: { pluginId: fullId } });
+  } else {
+    nav.push({ screen: "marketplace-install-scope", context: { marketplace, pluginId: fullId } });
+  }
+}
+function handleInstallScopeSelect(value, pluginId, callbacks, nav) {
+  const scope = value;
+  callbacks.install(pluginId, scope).then(() => {
+    nav.notify(`Installed plugin "${pluginId}" (${scope} scope).`);
+    nav.popN(2);
+  }).catch((err) => {
+    nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
+function handleInstalledListSelect(value, callbacks, nav) {
+  nav.setConfirm({
+    message: `Uninstall plugin "${value}"?`,
+    onConfirm: () => {
+      nav.setConfirm(void 0);
+      callbacks.uninstall(value).then(() => {
+        nav.notify(`Uninstalled plugin "${value}".`);
+        nav.refresh();
+      }).catch((err) => {
+        nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    },
+    onCancel: () => nav.setConfirm(void 0)
+  });
+}
+function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
+  if (value === "uninstall") {
+    nav.setConfirm({
+      message: `Uninstall plugin "${pluginId}"?`,
+      onConfirm: () => {
+        nav.setConfirm(void 0);
+        callbacks.uninstall(pluginId).then(() => {
+          nav.notify(`Uninstalled plugin "${pluginId}".`);
+          nav.popN(2);
+        }).catch((err) => {
+          nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      },
+      onCancel: () => nav.setConfirm(void 0)
+    });
+  }
+}
+
+// src/hooks/usePluginScreenData.ts
+import { useState as useState13, useEffect as useEffect4 } from "react";
+function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, stackLength) {
+  const [items, setItems] = useState13([]);
+  const [loading, setLoading] = useState13(false);
+  const [error, setError] = useState13();
+  useEffect4(() => {
+    setItems([]);
+    setError(void 0);
+    if (screen === "marketplace-list") {
+      setLoading(true);
+      callbacks.marketplaceList().then((sources) => {
+        const baseItems = [{ label: "Add Marketplace", value: "__add__" }];
+        const sourceItems = sources.map((s) => ({
+          label: s.name,
+          value: s.name,
+          hint: s.type
+        }));
+        setItems([...baseItems, ...sourceItems]);
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    } else if (screen === "marketplace-browse") {
+      const mp = marketplace ?? "";
+      setLoading(true);
+      callbacks.listAvailablePlugins(mp).then((plugins) => {
+        setItems(
+          plugins.map((p) => ({
+            label: p.name,
+            value: p.name,
+            hint: p.installed ? "installed" : p.description
+          }))
+        );
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    } else if (screen === "installed-list") {
+      setLoading(true);
+      callbacks.listInstalled().then((plugins) => {
+        setItems(
+          plugins.map((p) => ({
+            label: p.name,
+            value: p.name,
+            hint: p.description
+          }))
+        );
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    }
+  }, [stackLength, screen, marketplace, callbacks, refreshCounter]);
+  return { items, loading, error };
+}
+
+// src/PluginTUI.tsx
+import { jsx as jsx18 } from "react/jsx-runtime";
+function PluginTUI({ callbacks, onClose, addMessage }) {
+  const [stack, setStack] = useState14([{ screen: "main" }]);
+  const [confirm, setConfirm] = useState14();
+  const [refreshCounter, setRefreshCounter] = useState14(0);
+  const current = stack[stack.length - 1] ?? { screen: "main" };
+  const push = useCallback9((state) => {
+    setStack((prev) => [...prev, state]);
+  }, []);
+  const pop = useCallback9(() => {
+    setStack((prev) => {
+      if (prev.length <= 1) {
+        onClose();
+        return prev;
+      }
+      return prev.slice(0, -1);
+    });
+  }, [onClose]);
+  const popN = useCallback9(
+    (n) => {
+      setStack((prev) => {
+        const next = prev.slice(0, Math.max(1, prev.length - n));
+        if (next.length === 0) {
+          onClose();
+          return prev;
+        }
+        return next;
+      });
+    },
+    [onClose]
+  );
+  const notify = useCallback9(
+    (content) => {
+      addMessage?.({ role: "system", content });
+    },
+    [addMessage]
+  );
+  const refresh = useCallback9(() => {
+    setRefreshCounter((c) => c + 1);
+  }, []);
+  const setConfirmNav = useCallback9(
+    (state) => setConfirm(state),
+    [setConfirm]
+  );
+  const pushNav = useCallback9(
+    (state) => push({ screen: state.screen, context: state.context }),
+    [push]
+  );
+  const nav = { push: pushNav, pop, popN, notify, setConfirm: setConfirmNav, refresh };
+  const { items, loading, error } = usePluginScreenData(
+    current.screen,
+    current.context?.marketplace,
+    callbacks,
+    refreshCounter,
+    stack.length
+  );
+  const handleSelect = useCallback9(
+    (value) => {
+      const screen2 = current.screen;
+      const ctx = current.context;
+      if (screen2 === "main") handleMainSelect(value, nav);
+      else if (screen2 === "marketplace-list") handleMarketplaceListSelect(value, nav);
+      else if (screen2 === "marketplace-action")
+        handleMarketplaceActionSelect(value, ctx?.marketplace ?? "", callbacks, nav);
+      else if (screen2 === "marketplace-browse")
+        handleMarketplaceBrowseSelect(value, ctx?.marketplace ?? "", items, nav);
+      else if (screen2 === "marketplace-install-scope")
+        handleInstallScopeSelect(value, ctx?.pluginId ?? "", callbacks, nav);
+      else if (screen2 === "installed-list") handleInstalledListSelect(value, callbacks, nav);
+      else if (screen2 === "installed-action")
+        handleInstalledActionSelect(value, ctx?.pluginId ?? "", callbacks, nav);
+    },
+    [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
+  );
+  const handleTextSubmit = useCallback9(
+    (value) => {
+      if (current.screen === "marketplace-add") {
+        callbacks.marketplaceAdd(value).then((name) => {
+          notify(`Added marketplace "${name}" from ${value}.`);
+          pop();
+        }).catch((err) => {
+          notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+          pop();
+        });
+      }
+    },
+    [current.screen, callbacks, notify, pop]
+  );
+  if (confirm) {
+    return /* @__PURE__ */ jsx18(
+      ConfirmPrompt,
+      {
+        message: confirm.message,
+        onSelect: (index) => {
+          if (index === 0) confirm.onConfirm();
+          else confirm.onCancel();
+        }
+      }
+    );
+  }
+  const screen = current.screen;
+  if (screen === "marketplace-add") {
+    return /* @__PURE__ */ jsx18(
+      TextPrompt,
+      {
+        title: "Add Marketplace Source",
+        placeholder: "owner/repo or git URL",
+        onSubmit: handleTextSubmit,
+        onCancel: pop,
+        validate: (v) => !v.includes("/") ? "Must be owner/repo or a git URL" : void 0
+      }
+    );
+  }
+  if (screen === "marketplace-action") {
+    return /* @__PURE__ */ jsx18(
+      MenuSelect,
+      {
+        title: `Marketplace: ${current.context?.marketplace ?? ""}`,
+        items: [
+          { label: "Browse plugins", value: "browse" },
+          { label: "Update", value: "update" },
+          { label: "Remove", value: "remove" }
+        ],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  if (screen === "marketplace-install-scope") {
+    return /* @__PURE__ */ jsx18(
+      MenuSelect,
+      {
+        title: `Install scope for "${current.context?.pluginId ?? ""}"`,
+        items: [
+          { label: "User scope", value: "user" },
+          { label: "Project scope", value: "project" }
+        ],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  if (screen === "installed-action") {
+    return /* @__PURE__ */ jsx18(
+      MenuSelect,
+      {
+        title: `Plugin: ${current.context?.pluginId ?? ""}`,
+        items: [{ label: "Uninstall", value: "uninstall" }],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  const titleMap = {
+    main: "Plugin Management",
+    "marketplace-list": "Marketplace",
+    "marketplace-browse": `Browse: ${current.context?.marketplace ?? ""}`,
+    "installed-list": "Installed Plugins"
+  };
+  const staticItemsMap = {
+    main: [
+      { label: "Marketplace", value: "marketplace" },
+      { label: "Installed Plugins", value: "installed" }
+    ]
+  };
+  return /* @__PURE__ */ jsx18(
+    MenuSelect,
+    {
+      title: titleMap[screen] ?? "Plugin Management",
+      items: staticItemsMap[screen] ?? items,
+      onSelect: handleSelect,
+      onBack: pop,
+      loading,
+      error
+    },
+    `${screen}-${stack.length}-${refreshCounter}`
+  );
+}
+
+// src/TransportTUI.tsx
+import { useState as useState15, useCallback as useCallback10 } from "react";
+import { Box as Box15, Text as Text17, useInput as useInput8 } from "ink";
+import { jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
+var TRANSPORT_NAME_WIDTH = 18;
+function TransportEntryRow({ entry, selected }) {
+  const enabled = entry.config.enabled;
+  const dot = enabled ? "\u25CF" : "\u25CB";
+  const badge = enabled ? "[enabled] " : "[disabled]";
+  const portOpt = entry.config.options?.port;
+  const portHint = typeof portOpt === "number" ? `port: ${portOpt}` : "";
+  return /* @__PURE__ */ jsx19(Box15, { children: /* @__PURE__ */ jsx19(Text17, { color: selected ? "cyan" : void 0, bold: selected, children: `${dot} ${entry.transport.name.padEnd(TRANSPORT_NAME_WIDTH)} ${badge}  ${portHint}` }) });
+}
+function useTransportInput(entries, cursor, saving, registry, setCursor, setSaving, onClose, refresh) {
+  useInput8(
+    useCallback10(
+      (_input, key) => {
+        if (saving) return;
+        if (key.upArrow) {
+          setCursor((c) => Math.max(0, c - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setCursor((c) => Math.min(entries.length - 1, c + 1));
+          return;
+        }
+        if (key.escape || key.return) {
+          onClose();
+          return;
+        }
+        if (_input === " ") {
+          const entry = entries[cursor];
+          if (!entry) return;
+          setSaving(true);
+          registry.setEnabled(entry.transport.name, !entry.config.enabled).then(() => {
+            refresh();
+            setSaving(false);
+          }).catch(() => setSaving(false));
+        }
+      },
+      [saving, entries, cursor, registry, onClose, refresh, setCursor, setSaving]
+    )
+  );
+}
+function TransportTUI({ registry, onClose }) {
+  const [entries, setEntries] = useState15(() => registry.getAll());
+  const [cursor, setCursor] = useState15(0);
+  const [saving, setSaving] = useState15(false);
+  const refresh = useCallback10(() => {
+    setEntries(registry.getAll());
+  }, [registry]);
+  useTransportInput(entries, cursor, saving, registry, setCursor, setSaving, onClose, refresh);
+  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx19(Text17, { bold: true, children: "Settings \u203A Transports" }),
+    /* @__PURE__ */ jsx19(Box15, { marginTop: 1, flexDirection: "column", children: entries.map((entry, i) => /* @__PURE__ */ jsx19(TransportEntryRow, { entry, selected: i === cursor }, entry.transport.name)) }),
+    /* @__PURE__ */ jsx19(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx19(Text17, { dimColor: true, children: "\u2191\u2193 select space toggle enter/esc close" }) }),
+    saving && /* @__PURE__ */ jsx19(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx19(Text17, { color: "yellow", children: "Saving\u2026" }) })
+  ] });
+}
+
+// src/SessionPicker.tsx
+import { Box as Box16, Text as Text18 } from "ink";
+import { Fragment as Fragment5, jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
+var SESSION_ID_DISPLAY_LENGTH = 8;
+var SESSION_PREVIEW_DISPLAY_LENGTH = 60;
+function SessionPicker({
+  sessions,
+  onSelect,
+  onCancel
+}) {
+  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx20(Text18, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
+    /* @__PURE__ */ jsx20(
+      ListPicker,
+      {
+        items: [...sessions],
+        renderItem: (session, isSelected) => {
+          const preview = session.preview ? session.preview.slice(0, SESSION_PREVIEW_DISPLAY_LENGTH) + (session.preview.length > SESSION_PREVIEW_DISPLAY_LENGTH ? "..." : "") : "";
+          return /* @__PURE__ */ jsxs15(Text18, { children: [
+            isSelected ? "> " : "  ",
+            /* @__PURE__ */ jsx20(Text18, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
+            "  ",
+            /* @__PURE__ */ jsx20(Text18, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
+              month: "short",
+              day: "numeric",
+              hour: "2-digit",
+              minute: "2-digit"
+            }) }),
+            "  ",
+            /* @__PURE__ */ jsxs15(Text18, { dimColor: true, children: [
+              "msgs: ",
+              session.messageCount
+            ] }),
+            preview ? /* @__PURE__ */ jsxs15(Fragment5, { children: [
+              "\n    ",
+              /* @__PURE__ */ jsx20(Text18, { color: "gray", children: preview })
+            ] }) : null
+          ] });
+        },
+        onSelect: (session) => onSelect(session.id),
+        onCancel
+      }
+    )
+  ] });
+}
+
+// src/BackgroundTaskPanel.tsx
+import { Box as Box17, Text as Text19 } from "ink";
+
+// src/execution-workspace-view-model.ts
+var ACTIVE_STATUSES = [
+  "active",
+  "queued",
+  "running",
+  "waiting_permission"
+];
+var DETAIL_RECORD_TEXT_LIMIT = 160;
+var PREVIEW_WHITESPACE = /\s+/g;
+var PREVIEW_SEPARATOR = " ";
+function getDefaultBackgroundWorkspaceEntries(snapshot) {
+  return (snapshot?.entries ?? []).filter(
+    (entry) => entry.kind === "background_task" && entry.visibility === "default"
+  );
+}
+function countActiveBackgroundWorkspaceEntries(snapshot) {
+  return getDefaultBackgroundWorkspaceEntries(snapshot).filter(
+    (entry) => ACTIVE_STATUSES.includes(entry.status)
+  ).length;
+}
+function formatExecutionWorkspaceEntryRow(entry, options = {}) {
+  const isSelected = entry.id === options.selectedEntryId;
+  const row = {
+    id: entry.id,
+    radio: isSelected ? "\u25CF" : "\u25CB",
+    title: formatEntryTitle(entry),
+    subtitle: formatEntrySubtitle(entry),
+    statusLabel: formatStatusLabel2(entry.status),
+    preview: trimPreview(entry.preview ?? entry.currentAction),
+    color: getEntryColor(entry),
+    isSelected
+  };
+  return { ...row, accessibleText: formatAccessibleText(row) };
+}
+function formatExecutionDetailRecord(record) {
+  const text = record.text.trim().replace(PREVIEW_WHITESPACE, PREVIEW_SEPARATOR);
+  if (!text) return record.kind;
+  return text.length > DETAIL_RECORD_TEXT_LIMIT ? `${text.slice(0, DETAIL_RECORD_TEXT_LIMIT)}...` : text;
+}
+function formatEntryTitle(entry) {
+  if (entry.kind === "main_thread") return entry.title;
+  if (entry.kind === "background_group") return `${entry.title} group`;
+  if (entry.taskKind === "agent") return `${entry.title} agent`;
+  if (entry.taskKind === "process") return entry.title || "Process";
+  return entry.title;
+}
+function formatEntrySubtitle(entry) {
+  if (entry.kind === "main_thread") return entry.subtitle;
+  const parts = [
+    entry.taskKind,
+    entry.subtitle,
+    entry.attention === "none" ? void 0 : entry.attention
+  ];
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" \xB7 ") || void 0;
+}
+function formatStatusLabel2(status) {
+  return status.replace(/_/g, " ");
+}
+function getEntryColor(entry) {
+  if (entry.attention === "failed" || entry.status === "failed") return "red";
+  if (entry.attention === "permission" || entry.status === "waiting_permission") return "yellow";
+  if (entry.status === "completed") return "green";
+  if (entry.status === "cancelled") return "yellow";
+  if (ACTIVE_STATUSES.includes(entry.status)) return "cyan";
+  return "white";
+}
+function trimPreview(value) {
+  const preview = value?.trim().replace(PREVIEW_WHITESPACE, PREVIEW_SEPARATOR);
+  return preview || void 0;
+}
+function formatAccessibleText(row) {
+  const parts = [row.radio, row.title, row.statusLabel, row.subtitle, row.preview];
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" \xB7 ");
+}
+
+// src/background-task-row-format.ts
+function formatBackgroundTaskRow(entry, options = {}) {
+  const row = formatExecutionWorkspaceEntryRow(entry);
+  const marker = isActiveEntry(entry) ? "\u25A1" : "\u25A0";
+  const segments = [row.statusLabel, row.subtitle].filter(
+    (segment) => typeof segment === "string" && segment.length > 0
+  );
+  return {
+    connector: options.isLast === false ? "\u251C" : "\u2514",
+    marker,
+    color: row.color,
+    label: row.title,
+    segments,
+    preview: row.preview,
+    accessibleText: [
+      `${options.isLast === false ? "\u251C" : "\u2514"} ${marker} ${row.title}`,
+      ...segments,
+      row.preview
+    ].filter((part) => typeof part === "string" && part.length > 0).join(" \xB7 ")
+  };
+}
+function isActiveEntry(entry) {
+  return entry.status === "active" || entry.status === "queued" || entry.status === "running" || entry.status === "waiting_permission";
+}
+
+// src/BackgroundTaskPanel.tsx
+import { jsx as jsx21, jsxs as jsxs16 } from "react/jsx-runtime";
+function BackgroundTaskPanel({ entries }) {
+  if (entries.length === 0) return null;
+  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx21(Text19, { color: "cyan", bold: true, children: "Background work" }),
+    entries.map((entry, index) => {
+      const row = formatBackgroundTaskRow(entry, { isLast: index === entries.length - 1 });
+      return /* @__PURE__ */ jsxs16(Text19, { children: [
+        `${row.connector} `,
+        /* @__PURE__ */ jsx21(Text19, { color: row.color, children: row.marker }),
+        ` ${row.label}`,
+        row.segments.map((segment, segmentIndex) => /* @__PURE__ */ jsx21(Text19, { dimColor: true, children: ` \xB7 ${segment}` }, `${segment}-${segmentIndex}`)),
+        row.preview ? /* @__PURE__ */ jsx21(Text19, { dimColor: true, children: ` \xB7 ${row.preview}` }) : null
+      ] }, entry.id);
+    })
+  ] });
+}
+
+// src/ExecutionWorkspaceSwitcher.tsx
+import { useEffect as useEffect5, useRef as useRef9, useState as useState16 } from "react";
+import { Box as Box18, Text as Text20, useInput as useInput9 } from "ink";
+import { jsx as jsx22, jsxs as jsxs17 } from "react/jsx-runtime";
+var MAX_VISIBLE_WORKSPACE_ENTRIES = 8;
+function ExecutionWorkspaceSwitcher({
+  snapshot,
+  selectedEntryId,
+  onSelect,
+  onClose
+}) {
+  const entries = [...snapshot?.entries ?? []];
+  const { normalized, visibleEntries, applyAction } = useWorkspaceSwitcherSelection({
+    entries,
+    selectedEntryId,
+    onSelect,
+    onClose
+  });
+  useInput9((_input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) applyAction(action);
+  });
+  return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsx22(Text20, { color: "cyan", bold: true, children: "Execution workspace" }),
+    /* @__PURE__ */ jsx22(Box18, { flexDirection: "column", marginTop: 1, children: visibleEntries.length === 0 ? /* @__PURE__ */ jsx22(Text20, { dimColor: true, children: "No workspace entries" }) : visibleEntries.map((entry, index) => /* @__PURE__ */ jsx22(
+      ExecutionWorkspaceSwitcherRow,
+      {
+        entry,
+        isFocused: normalized.scrollOffset + index === normalized.selectedIndex,
+        selectedEntryId
+      },
+      entry.id
+    )) }),
+    /* @__PURE__ */ jsx22(Text20, { dimColor: true, children: "Ctrl+B Close \u2191\u2193 Navigate Enter Switch Esc Close" })
+  ] });
+}
+function useWorkspaceSwitcherSelection({
+  entries,
+  selectedEntryId,
+  onSelect,
+  onClose
+}) {
+  const [state, setState] = useState16(() => createSelectionFlowState());
+  const stateRef = useRef9(state);
+  useEffect5(() => {
+    const selectedIndex = Math.max(
+      0,
+      entries.findIndex((entry) => entry.id === selectedEntryId)
+    );
+    const nextState = createNormalizedSelection({ selectedIndex, itemCount: entries.length });
+    stateRef.current = nextState;
+    setState(nextState);
+  }, [entries.length, selectedEntryId]);
+  const normalized = createNormalizedSelection({
+    selectedIndex: state.selectedIndex,
+    scrollOffset: state.scrollOffset,
+    itemCount: entries.length
+  });
+  if (normalized !== state) stateRef.current = normalized;
+  return {
+    normalized,
+    visibleEntries: entries.slice(
+      normalized.scrollOffset,
+      normalized.scrollOffset + MAX_VISIBLE_WORKSPACE_ENTRIES
+    ),
+    applyAction: createApplyAction({ entries, stateRef, setState, onSelect, onClose })
+  };
+}
+function createApplyAction({
+  entries,
+  stateRef,
+  setState,
+  onSelect,
+  onClose
+}) {
+  return (action) => {
+    const result = applySelectionInput(stateRef.current, action, {
+      itemCount: entries.length,
+      maxVisible: MAX_VISIBLE_WORKSPACE_ENTRIES
+    });
+    const nextState = result.effect.type === "select" || result.effect.type === "cancel" ? { ...result.state, resolved: false } : result.state;
+    stateRef.current = nextState;
+    setState(nextState);
+    if (result.effect.type === "cancel") {
+      onClose();
+    } else if (result.effect.type === "select") {
+      const entry = entries[result.effect.index];
+      if (entry) onSelect(entry.id);
+    }
+  };
+}
+function createNormalizedSelection(input) {
+  return normalizeSelectionState(
+    {
+      selectedIndex: input.selectedIndex,
+      scrollOffset: input.scrollOffset ?? 0,
+      resolved: false
+    },
+    { itemCount: input.itemCount, maxVisible: MAX_VISIBLE_WORKSPACE_ENTRIES }
+  );
+}
+function ExecutionWorkspaceSwitcherRow({
+  entry,
+  isFocused,
+  selectedEntryId
+}) {
+  const row = formatExecutionWorkspaceEntryRow(entry, { selectedEntryId });
+  return /* @__PURE__ */ jsxs17(Text20, { children: [
+    /* @__PURE__ */ jsx22(Text20, { color: isFocused ? "cyan" : void 0, bold: isFocused, children: isFocused ? "> " : "  " }),
+    /* @__PURE__ */ jsx22(Text20, { color: row.color, children: row.radio }),
+    /* @__PURE__ */ jsx22(Text20, { color: isFocused ? "cyan" : void 0, bold: isFocused, children: ` ${row.title}` }),
+    /* @__PURE__ */ jsx22(Text20, { dimColor: true, children: ` \xB7 ${row.statusLabel}` }),
+    row.subtitle ? /* @__PURE__ */ jsx22(Text20, { dimColor: true, children: ` \xB7 ${row.subtitle}` }) : null,
+    row.preview ? /* @__PURE__ */ jsx22(Text20, { dimColor: true, children: ` \xB7 ${row.preview}` }) : null
+  ] });
+}
+
+// src/ExecutionWorkspaceDetailPane.tsx
+import { Box as Box19, Text as Text21 } from "ink";
+import { jsx as jsx23, jsxs as jsxs18 } from "react/jsx-runtime";
+var MAX_VISIBLE_DETAIL_RECORDS = 12;
+function ExecutionWorkspaceDetailPane({
+  entry,
+  page,
+  loading,
+  error
+}) {
+  const row = formatExecutionWorkspaceEntryRow(entry, { selectedEntryId: entry.id });
+  const records = page?.records.slice(-MAX_VISIBLE_DETAIL_RECORDS) ?? [];
+  return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx23(Text21, { color: "cyan", bold: true, children: `Viewing ${row.title}` }),
+    /* @__PURE__ */ jsxs18(Text21, { dimColor: true, children: [
+      row.statusLabel,
+      row.subtitle ? ` \xB7 ${row.subtitle}` : "",
+      row.preview ? ` \xB7 ${row.preview}` : ""
+    ] }),
+    loading ? /* @__PURE__ */ jsx23(Text21, { dimColor: true, children: "Loading workspace detail..." }) : null,
+    error ? /* @__PURE__ */ jsx23(Text21, { color: "red", children: error }) : null,
+    !loading && !error && records.length === 0 ? /* @__PURE__ */ jsx23(Text21, { dimColor: true, children: "No detail yet" }) : null,
+    !loading && !error && records.map((record) => /* @__PURE__ */ jsx23(Text21, { color: getDetailRecordColor(record.kind), children: formatExecutionDetailRecord(record) }, record.id)),
+    page?.nextCursor ? /* @__PURE__ */ jsx23(Text21, { dimColor: true, children: "... more detail available" }) : null
+  ] });
+}
+function getDetailRecordColor(kind) {
+  if (kind === "error") return "red";
+  if (kind === "result") return "green";
+  if (kind === "process_output") return "white";
+  if (kind === "group_summary") return "cyan";
+  return void 0;
+}
+
+// src/UpdateNotice.tsx
+import { Box as Box20, Text as Text22 } from "ink";
+import { jsx as jsx24 } from "react/jsx-runtime";
+function UpdateNotice({ message }) {
+  return /* @__PURE__ */ jsx24(Box20, { paddingX: 1, marginBottom: 1, children: /* @__PURE__ */ jsx24(Text22, { color: "yellow", children: message }) });
+}
+
+// src/App.tsx
+import { jsx as jsx25, jsxs as jsxs19 } from "react/jsx-runtime";
+function App(props) {
+  const [activeSessionId, setActiveSessionId] = useState17(props.resumeSessionId);
+  const [showInitialSessionPicker, setShowInitialSessionPicker] = useState17(
+    props.showSessionPickerOnStart ?? false
+  );
+  return /* @__PURE__ */ jsx25(TuiCliAdapterProvider, { value: props.cliAdapter, children: /* @__PURE__ */ jsx25(
+    AppInner,
+    {
+      ...props,
+      showSessionPickerOnStart: showInitialSessionPicker,
+      resumeSessionId: activeSessionId,
+      onSessionSwitch: (sessionId) => {
+        setShowInitialSessionPicker(false);
+        setActiveSessionId(sessionId);
+      }
+    },
+    activeSessionId ?? "__new__"
+  ) });
+}
+function AppInner(props) {
+  const cwd = props.cwd;
+  const {
+    interactiveSession,
+    registry,
+    commandEffectQueue,
+    history,
+    addEntry,
+    streamingText,
+    activeTools,
+    isThinking,
+    isAborting,
+    isShuttingDown,
+    pendingPrompt,
+    executionWorkspaceSnapshot,
+    selectedExecutionEntryId,
+    selectExecutionWorkspaceEntry,
+    readExecutionWorkspaceDetail,
+    permissionRequest,
+    contextState,
+    handleSubmit: baseHandleSubmit,
+    handleAbort,
+    handleCancelQueue,
+    handleShutdown
+  } = useInteractiveSession({
+    cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    sessionStore: props.sessionStore,
+    resumeSessionId: props.resumeSessionId,
+    forkSession: props.forkSession,
+    sessionName: props.sessionName,
+    backgroundTaskRunners: props.backgroundTaskRunners,
+    subagentRunnerFactory: props.subagentRunnerFactory,
+    commandModules: props.commandModules,
+    commandHostAdapters: props.commandHostAdapters,
+    transportRegistry: props.transportRegistry,
+    language: props.language,
+    reloadPluginCommandSource: props.reloadPluginCommandSource
+  });
+  const fallbackPluginCallbacks = usePluginCallbacks(cwd);
+  const pluginCallbacks = props.commandHostAdapters?.plugin ?? fallbackPluginCallbacks;
+  const { exit } = useApp2();
+  const [sessionName, setSessionName] = useState17(props.sessionName);
+  const [updateNotice, setUpdateNotice] = useState17();
+  const [showExecutionWorkspaceSwitcher, setShowExecutionWorkspaceSwitcher] = useState17(false);
+  const [executionDetailPage, setExecutionDetailPage] = useState17(null);
+  const [executionDetailError, setExecutionDetailError] = useState17();
+  const [isExecutionDetailLoading, setIsExecutionDetailLoading] = useState17(false);
+  const [statusLineSettings, setStatusLineSettings] = useStatusLineSettings();
+  const backgroundWorkspaceEntries = useMemo5(
+    () => getDefaultBackgroundWorkspaceEntries(executionWorkspaceSnapshot),
+    [executionWorkspaceSnapshot]
+  );
+  const activeBackgroundTaskCount = countActiveBackgroundWorkspaceEntries(
+    executionWorkspaceSnapshot
+  );
+  const selectedExecutionEntry = useMemo5(
+    () => executionWorkspaceSnapshot?.entries.find((entry) => entry.id === selectedExecutionEntryId),
+    [executionWorkspaceSnapshot, selectedExecutionEntryId]
+  );
+  const {
+    handleSubmit,
+    pendingModelId,
+    pendingInteractionPrompt,
+    showPluginTUI,
+    showSessionPicker,
+    showTransportTUI,
+    setShowPluginTUI,
+    setShowSessionPicker,
+    setShowTransportTUI,
+    handleModelConfirm,
+    handleInteractionSubmit,
+    handleInteractionCancel
+  } = useSideEffects({
+    cwd,
+    providerOverride: props.providerOverride,
+    interactiveSession,
+    commandEffectQueue,
+    addEntry,
+    baseHandleSubmit,
+    setSessionName,
+    setStatusLineSettings,
+    showSessionPickerOnStart: props.showSessionPickerOnStart
+  });
+  useEffect6(() => {
+    const name = interactiveSession?.getName?.();
+    if (name && !sessionName) setSessionName(name);
+  }, [interactiveSession, sessionName]);
+  useEffect6(() => {
+    let isMounted = true;
+    props.startupUpdateNotice?.then((notice) => {
+      if (isMounted && notice !== void 0) {
+        setUpdateNotice(notice);
+      }
+    }).catch(() => {
+    });
+    return () => {
+      isMounted = false;
+    };
+  }, [props.startupUpdateNotice]);
+  useEffect6(() => {
+    const title = sessionName ? `Robota \u2014 ${sessionName}` : "Robota";
+    process.stdout.write(`\x1B]0;${title}\x07`);
+  }, [sessionName]);
+  useInput10((_input, key) => {
+    if (!key.escape || !isThinking) return;
+    if (permissionRequest || showPluginTUI || showTransportTUI || showSessionPicker || showExecutionWorkspaceSwitcher) {
+      return;
+    }
+    handleAbort();
+  });
+  useInput10((input, key) => {
+    if (!key.ctrl || input !== "b") return;
+    if (permissionRequest || showPluginTUI || showSessionPicker || isShuttingDown) return;
+    setShowExecutionWorkspaceSwitcher((shown) => !shown);
+  });
+  useInput10((input, key) => {
+    if (!key.ctrl || input !== "c" || isShuttingDown) return;
+    void handleShutdown("prompt_input_exit").finally(() => exit());
+  });
+  useEffect6(() => {
+    const onSigterm = () => {
+      if (isShuttingDown) return;
+      void handleShutdown("other").finally(() => exit());
+    };
+    process.once("SIGINT", onSigterm);
+    process.once("SIGTERM", onSigterm);
+    return () => {
+      process.off("SIGINT", onSigterm);
+      process.off("SIGTERM", onSigterm);
+    };
+  }, [handleShutdown, exit, isShuttingDown]);
+  useEffect6(() => {
+    if (!selectedExecutionEntry || selectedExecutionEntry.kind === "main_thread") {
+      setExecutionDetailPage(null);
+      setExecutionDetailError(void 0);
+      setIsExecutionDetailLoading(false);
+      return;
+    }
+    let isCurrent = true;
+    setIsExecutionDetailLoading(true);
+    setExecutionDetailError(void 0);
+    readExecutionWorkspaceDetail(selectedExecutionEntry.id).then((page) => {
+      if (!isCurrent) return;
+      setExecutionDetailPage(page);
+      setIsExecutionDetailLoading(false);
+    }).catch((error) => {
+      if (!isCurrent) return;
+      setExecutionDetailError(error.message);
+      setIsExecutionDetailLoading(false);
+    });
+    return () => {
+      isCurrent = false;
+    };
+  }, [executionWorkspaceSnapshot, readExecutionWorkspaceDetail, selectedExecutionEntry]);
+  let permissionMode = props.permissionMode ?? "default";
+  let sessionId = "";
+  try {
+    const session = interactiveSession.getSession();
+    permissionMode = session.getPermissionMode();
+    sessionId = session.getSessionId();
+  } catch {
+  }
+  return /* @__PURE__ */ jsxs19(Box21, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs19(Box21, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx25(Text23, { color: "cyan", bold: true, children: `
+  ____   ___  ____   ___ _____  _
+ |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
+ | |_) | | | |  _ \\| | | || | / _ \\
+ |  _ <| |_| | |_) | |_| || |/ ___ \\
+ |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
+` }),
+      /* @__PURE__ */ jsxs19(Text23, { dimColor: true, children: [
+        " v",
+        props.version ?? "0.0.0"
+      ] })
+    ] }),
+    updateNotice && /* @__PURE__ */ jsx25(UpdateNotice, { message: updateNotice }),
+    /* @__PURE__ */ jsxs19(Box21, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      selectedExecutionEntry && selectedExecutionEntry.kind !== "main_thread" ? /* @__PURE__ */ jsx25(
+        ExecutionWorkspaceDetailPane,
+        {
+          entry: selectedExecutionEntry,
+          page: executionDetailPage,
+          loading: isExecutionDetailLoading,
+          error: executionDetailError
+        }
+      ) : /* @__PURE__ */ jsx25(MessageList, { history }),
+      isShuttingDown && /* @__PURE__ */ jsx25(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsx25(Text23, { color: "yellow", children: "Shutting down..." }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ jsx25(Box21, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx25(
+        StreamingIndicator,
+        {
+          text: streamingText,
+          activeTools,
+          isThinking
+        }
+      ) }),
+      /* @__PURE__ */ jsx25(BackgroundTaskPanel, { entries: backgroundWorkspaceEntries })
+    ] }),
+    showExecutionWorkspaceSwitcher && /* @__PURE__ */ jsx25(
+      ExecutionWorkspaceSwitcher,
+      {
+        snapshot: executionWorkspaceSnapshot,
+        selectedEntryId: selectedExecutionEntryId,
+        onSelect: selectExecutionWorkspaceEntry,
+        onClose: () => setShowExecutionWorkspaceSwitcher(false)
+      }
+    ),
+    permissionRequest && /* @__PURE__ */ jsx25(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ jsx25(
+      ConfirmPrompt,
+      {
+        message: formatModelChangeConfirmationMessage(pendingModelId),
+        onSelect: handleModelConfirm
+      }
+    ),
+    pendingInteractionPrompt && /* @__PURE__ */ jsx25(
+      InteractivePrompt,
+      {
+        prompt: pendingInteractionPrompt,
+        onSubmit: handleInteractionSubmit,
+        onCancel: handleInteractionCancel
+      }
+    ),
+    showPluginTUI && /* @__PURE__ */ jsx25(
+      PluginTUI,
+      {
+        callbacks: pluginCallbacks,
+        onClose: () => setShowPluginTUI(false),
+        addMessage: (msg) => addEntry(messageToHistoryEntry6(createSystemMessage6(msg.content)))
+      }
+    ),
+    showTransportTUI && props.transportRegistry && /* @__PURE__ */ jsx25(
+      TransportTUI,
+      {
+        registry: props.transportRegistry,
+        onClose: () => setShowTransportTUI(false)
+      }
+    ),
+    showSessionPicker && /* @__PURE__ */ jsx25(
+      SessionPicker,
+      {
+        sessions: listResumableSessionSummaries(props.sessionStore, props.cwd),
+        onSelect: (id) => {
+          setShowSessionPicker(false);
+          props.onSessionSwitch(id);
+        },
+        onCancel: () => {
+          setShowSessionPicker(false);
+          addEntry(messageToHistoryEntry6(createSystemMessage6("Session resume cancelled.")));
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx25(
+      SessionStatusBar,
+      {
+        cwd,
+        permissionMode,
+        modelId: props.modelId,
+        providerProfileName: props.providerProfileName,
+        providerType: props.providerType,
+        sessionId,
+        isThinking,
+        activeToolCount: activeTools.length,
+        activeBackgroundTaskCount,
+        hasPendingPrompt: pendingPrompt !== null,
+        contextState,
+        sessionName,
+        settings: statusLineSettings
+      }
+    ),
+    /* @__PURE__ */ jsx25(
+      InputArea,
+      {
+        onSubmit: handleSubmit,
+        onCancelQueue: handleCancelQueue,
+        isDisabled: !!permissionRequest || showPluginTUI || showTransportTUI || showSessionPicker || showExecutionWorkspaceSwitcher || isShuttingDown || pendingInteractionPrompt !== null || isThinking && !!pendingPrompt,
+        isAborting,
+        pendingPrompt,
+        registry,
+        sessionName,
+        history
+      }
+    ),
+    /* @__PURE__ */ jsx25(Text23, { children: " " })
+  ] });
+}
+
+// src/render.tsx
+import { jsx as jsx26 } from "react/jsx-runtime";
+async function renderApp(options) {
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`
+[UNHANDLED REJECTION] ${reason}
+`);
+    if (reason instanceof Error) {
+      process.stderr.write(`${reason.stack}
+`);
+    }
+  });
+  const instance = render(/* @__PURE__ */ jsx26(App, { ...options }), { exitOnCtrlC: false });
+  await instance.waitUntilExit();
+}
+
+// src/tui-transport.ts
+var TuiTransport = class {
+  name = "tui";
+  defaultEnabled = true;
+  optionsSchema = {};
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  attach(_session) {
+  }
+  async start() {
+    await renderApp(this.options);
+  }
+  async stop() {
+  }
+  validateOptions(_options) {
+    return true;
+  }
+};
+export {
+  TuiTransport
+};