@robota-sdk/agent-cli 3.0.0-beta.56 → 3.0.0-beta.58

package/dist/node/index.cjs

@@ -40,8 +40,8 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/cli.ts
-var import_node_fs6 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path10 = require("path");
 var import_node_url = require("url");
 var import_agent_sdk8 = require("@robota-sdk/agent-sdk");
 var import_agent_sessions = require("@robota-sdk/agent-sessions");
@@ -98,7 +98,9 @@ function parseCliArgs() {
       "api-key": { type: "string" },
       "api-key-env": { type: "string" },
       "set-current": { type: "boolean", default: false },
-      "settings-scope": { type: "string" }
+      "settings-scope": { type: "string" },
+      "check-update": { type: "boolean", default: false },
+      "disable-update-check": { type: "boolean", default: false }
     }
   });
   return {
@@ -129,7 +131,9 @@ function parseCliArgs() {
     apiKey: values["api-key"],
     apiKeyEnv: values["api-key-env"],
     setCurrent: values["set-current"] ?? false,
-    settingsScope: values["settings-scope"]
+    settingsScope: values["settings-scope"],
+    checkUpdate: values["check-update"] ?? false,
+    disableUpdateCheck: values["disable-update-check"] ?? false
   };
 }
 
@@ -193,16 +197,47 @@ var import_node_os = require("os");
 // src/utils/provider-default-definitions.ts
 var import_agent_provider_anthropic = require("@robota-sdk/agent-provider-anthropic");
 var import_agent_provider_gemma = require("@robota-sdk/agent-provider-gemma");
+var import_agent_provider_gemini = require("@robota-sdk/agent-provider-gemini");
 var import_agent_provider_openai = require("@robota-sdk/agent-provider-openai");
+var import_agent_provider_qwen = require("@robota-sdk/agent-provider-qwen");
 var DEFAULT_PROVIDER_DEFINITIONS = [
   (0, import_agent_provider_anthropic.createAnthropicProviderDefinition)(),
   (0, import_agent_provider_openai.createOpenAIProviderDefinition)(),
-  (0, import_agent_provider_gemma.createGemmaProviderDefinition)()
+  (0, import_agent_provider_gemini.createGeminiProviderDefinition)(),
+  (0, import_agent_provider_gemma.createGemmaProviderDefinition)(),
+  (0, import_agent_provider_qwen.createQwenProviderDefinition)()
 ];
 
 // src/utils/provider-definition.ts
 var import_agent_core = require("@robota-sdk/agent-core");
 
+// src/utils/env-ref.ts
+var ENV_REFERENCE_PREFIX = "$ENV:";
+function isEnvReference(value) {
+  return value.startsWith(ENV_REFERENCE_PREFIX);
+}
+function getEnvReferenceName(value) {
+  if (!isEnvReference(value)) {
+    return void 0;
+  }
+  const envName = value.slice(ENV_REFERENCE_PREFIX.length).trim();
+  return envName.length > 0 ? envName : void 0;
+}
+function resolveEnvReference(value) {
+  const envName = getEnvReferenceName(value);
+  if (envName === void 0) {
+    return value;
+  }
+  const resolved = process.env[envName];
+  return resolved !== void 0 && resolved.length > 0 ? resolved : void 0;
+}
+function hasUsableSecretReference(value) {
+  if (value === void 0 || value.length === 0) {
+    return false;
+  }
+  return resolveEnvReference(value) !== void 0;
+}
+
 // src/utils/provider-factory.ts
 function readProviderSettings(cwd, options = {}) {
   const merged = readMergedProviderSettings(cwd);
@@ -275,7 +310,8 @@ function resolveActiveProvider(settings, providerOverride, providerDefinitions =
         model: profile.model,
         apiKey: profile.apiKey,
         baseURL: profile.baseURL,
-        timeout: profile.timeout
+        timeout: profile.timeout,
+        options: profile.options
       },
       providerDefinitions
     );
@@ -288,7 +324,8 @@ function resolveActiveProvider(settings, providerOverride, providerDefinitions =
         model: provider.model,
         apiKey: provider.apiKey,
         baseURL: provider.baseURL,
-        timeout: provider.timeout
+        timeout: provider.timeout,
+        options: provider.options
       },
       providerDefinitions
     );
@@ -301,22 +338,17 @@ function normalizeProviderConfig(settings, providerDefinitions) {
   if (!model) {
     throw new Error(`Provider ${settings.name} requires model`);
   }
+  const apiKeyReference = settings.apiKey ?? defaults.apiKey;
+  const options = settings.options ?? defaults.options;
   return {
     name: settings.name,
     model,
-    apiKey: settings.apiKey !== void 0 ? resolveEnvRef(settings.apiKey) : defaults.apiKey,
+    apiKey: apiKeyReference !== void 0 ? resolveEnvReference(apiKeyReference) : void 0,
     baseURL: settings.baseURL ?? defaults.baseURL,
-    timeout: settings.timeout
+    timeout: settings.timeout,
+    ...options !== void 0 && { options }
   };
 }
-function resolveEnvRef(value) {
-  const envPrefix = "$ENV:";
-  if (!value.startsWith(envPrefix)) {
-    return value;
-  }
-  const envName = value.slice(envPrefix.length);
-  return process.env[envName] ?? value;
-}
 function createProviderFromConfig(settings, providerDefinitions) {
   const definition = (0, import_agent_core.findProviderDefinition)(providerDefinitions, settings.name);
   if (definition === void 0) {
@@ -371,7 +403,7 @@ function isUsableProviderProfile(type, profile, providerDefinitions) {
   if (!profile) {
     return false;
   }
-  if (profile.apiKey) {
+  if (hasUsableSecretReference(profile.apiKey)) {
     return true;
   }
   if (!type) {
@@ -381,7 +413,7 @@ function isUsableProviderProfile(type, profile, providerDefinitions) {
   if (definition === void 0) {
     return false;
   }
-  return definition.requiresApiKey !== true || definition.defaults?.apiKey !== void 0;
+  return definition.requiresApiKey !== true || hasUsableSecretReference(definition.defaults?.apiKey);
 }
 
 // src/utils/provider-settings.ts
@@ -411,7 +443,7 @@ function validateProviderProfile(profileName, profile, options = {}) {
     throw new Error(`Provider profile "${profileName}" is missing model`);
   }
   const definition = (0, import_agent_core.findProviderDefinition)(options.providerDefinitions ?? [], profile.type);
-  if (definition?.requiresApiKey === true && !profile.apiKey && definition.defaults?.apiKey === void 0) {
+  if (definition?.requiresApiKey === true && !hasUsableSecretReference(profile.apiKey ?? definition.defaults?.apiKey)) {
     throw new Error(`Provider profile "${profileName}" is missing apiKey`);
   }
 }
@@ -478,6 +510,40 @@ function createProviderSetupFlow(type, providerDefinitions) {
     values: {}
   };
 }
+function formatProviderSetupSelectionPrompt(providerDefinitions) {
+  if (providerDefinitions.length === 0) {
+    return "  No providers are available.";
+  }
+  const lines = [
+    "  Select provider:",
+    ...providerDefinitions.map(
+      (definition, index) => `    ${index + 1}. ${formatProviderSetupChoiceLabel(definition)}`
+    ),
+    `  Provider [1-${providerDefinitions.length}] (default: 1): `
+  ];
+  return lines.join("\n");
+}
+function resolveProviderSetupSelection(rawValue, providerDefinitions) {
+  const value = rawValue.trim();
+  const selectedValue = value.length > 0 ? value : "1";
+  const index = parseProviderSelectionIndex(selectedValue);
+  if (index !== void 0) {
+    const definition2 = providerDefinitions[index];
+    if (definition2 !== void 0) {
+      return definition2.type;
+    }
+    throw new Error(
+      `Provider selection ${selectedValue} is out of range. Currently supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`
+    );
+  }
+  const definition = (0, import_agent_core.findProviderDefinition)(providerDefinitions, selectedValue);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${selectedValue}. Currently supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`
+    );
+  }
+  return definition.type;
+}
 function getProviderSetupStep(state) {
   const step = state.steps[state.stepIndex];
   if (step === void 0) {
@@ -523,6 +589,16 @@ function formatProviderSetupPromptLabel(step) {
   const suffix = step.defaultValue !== void 0 ? ` (default: ${step.defaultValue})` : "";
   return `  ${step.title}${suffix}: `;
 }
+function formatProviderSetupChoiceLabel(definition) {
+  const label = definition.displayName !== void 0 ? `${definition.displayName} (${definition.type})` : definition.type;
+  return definition.description !== void 0 ? `${label} - ${definition.description}` : label;
+}
+function parseProviderSelectionIndex(value) {
+  if (!/^\d+$/.test(value)) {
+    return void 0;
+  }
+  return Number(value) - 1;
+}
 function validateProviderSetupValue(step, value) {
   if (step.required === true && value.length === 0) {
     return "Required";
@@ -615,15 +691,13 @@ async function ensureConfig(cwd, args, promptInput2, providerDefinitions = DEFAU
     return;
   }
   if (!isInteractiveTerminal()) {
-    throw new Error(formatMissingProviderConfigMessage());
+    throw new Error(formatMissingProviderConfigMessage(providerDefinitions));
   }
   await runInteractiveProviderSetup(cwd, args, promptInput2, providerDefinitions);
 }
 async function runInteractiveProviderSetup(cwd, args, promptInput2, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
-  const defaultProviderType = providerDefinitions[0]?.type ?? "";
-  const supportedTypes = providerDefinitions.map((definition) => definition.type).join("/");
-  const providerChoice = await promptInput2(`  Provider (${supportedTypes}, default: ${defaultProviderType}): `) || defaultProviderType;
-  const type = parseProviderSetupType(providerChoice);
+  const providerChoice = await promptInput2(formatProviderSetupSelectionPrompt(providerDefinitions));
+  const type = resolveProviderSetupSelection(providerChoice, providerDefinitions);
   const settingsPath = getSettingsPathForScope(cwd, args.settingsScope);
   const input = await runProviderSetupPromptFlow(type, promptInput2, providerDefinitions);
   applyProviderConfiguration(settingsPath, input, {
@@ -640,9 +714,6 @@ async function runInteractiveProviderSetup(cwd, args, promptInput2, providerDefi
 
 `);
 }
-function parseProviderSetupType(value) {
-  return value.trim();
-}
 function buildSetupInputFromArgs(args) {
   const type = args.providerType ?? args.configureProvider;
   if (!args.configureProvider || !type) {
@@ -671,25 +742,36 @@ function getSettingsCheckPaths(cwd) {
 function isInteractiveTerminal() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
-function formatMissingProviderConfigMessage() {
+function formatMissingProviderConfigMessage(providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
   return [
     "No provider configuration found.",
     "Run `robota --configure` in an interactive terminal, or configure a provider:",
-    "  robota --configure-provider gemma --type gemma --base-url http://localhost:1234/v1 --model supergemma4-26b-uncensored-v2 --api-key lm-studio --set-current",
-    "  robota --configure-provider openai --type openai --model <openai-compatible-model> --api-key-env OPENAI_API_KEY --set-current"
+    `Supported providers: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`,
+    ...providerDefinitions.map(formatConfigureProviderExample)
   ].join("\n");
 }
+function formatConfigureProviderExample(definition) {
+  const flags = [
+    `robota --configure-provider ${definition.type}`,
+    `--type ${definition.type}`,
+    ...definition.defaults?.baseURL !== void 0 ? ["--base-url <url>"] : [],
+    "--model <model>",
+    ...definition.requiresApiKey === true ? ["--api-key-env <ENV_NAME>"] : [],
+    "--set-current"
+  ];
+  return `  ${flags.join(" ")}`;
+}
 
 // src/cli.ts
 var import_agent_transport_headless = require("@robota-sdk/agent-transport-headless");
 
 // src/ui/render.tsx
-var import_ink18 = require("ink");
+var import_ink22 = require("ink");
 
 // src/ui/App.tsx
-var import_react18 = require("react");
-var import_ink17 = require("ink");
-var import_agent_core7 = require("@robota-sdk/agent-core");
+var import_react19 = require("react");
+var import_ink21 = require("ink");
+var import_agent_core9 = require("@robota-sdk/agent-core");
 
 // src/ui/hooks/useInteractiveSession.ts
 var import_react2 = require("react");
@@ -718,7 +800,9 @@ function toBackgroundTaskViewModel(state, partialText) {
     errorPreview: trimBackgroundPreview(state.error?.message),
     startedAt: state.startedAt,
     lastActivityAt: state.lastActivityAt,
-    timeoutReason: state.timeoutReason
+    timeoutReason: state.timeoutReason,
+    exitCode: state.result?.exitCode,
+    signalCode: state.result?.signalCode
   };
 }
 function getBackgroundTaskStatusLabel(state) {
@@ -839,6 +923,13 @@ var TuiStateManager = class {
     this.activeTools = [];
     this.notify();
   };
+  onContextUpdate = (state) => {
+    this.setContextState({
+      percentage: state.usedPercentage,
+      usedTokens: state.usedTokens,
+      maxTokens: state.maxTokens
+    });
+  };
   onBackgroundTaskEvent = (event) => {
     if ("task" in event) {
       this.upsertBackgroundTask(event.task);
@@ -1013,7 +1104,14 @@ function buildProviderSwitch(providers, profileName) {
   };
 }
 function buildProviderSetup(type, providerDefinitions) {
-  if (!type || (0, import_agent_core.findProviderDefinition)(providerDefinitions, type) === void 0) {
+  if (!type) {
+    return {
+      message: "Provider setup requested. Select a provider to continue.",
+      success: true,
+      data: { providerSetup: {} }
+    };
+  }
+  if ((0, import_agent_core.findProviderDefinition)(providerDefinitions, type) === void 0) {
     return {
       message: `Usage: provider add <type>. Supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`,
       success: false
@@ -1101,8 +1199,8 @@ async function routeProviderCommand(cwd, args, interactiveSession, manager, prov
     getEffects(interactiveSession)._pendingProviderProfile = providerSwitch.profile;
   }
   const providerSetup = result.data?.providerSetup;
-  if (providerSetup?.type) {
-    getEffects(interactiveSession)._pendingProviderSetupType = providerSetup.type;
+  if (providerSetup !== void 0) {
+    getEffects(interactiveSession)._pendingProviderSetup = providerSetup;
   }
 }
 function applySystemCommandResult(result, interactiveSession, manager) {
@@ -1129,6 +1227,11 @@ function applySystemCommandResult(result, interactiveSession, manager) {
     effects._sessionName = data.name;
     return;
   }
+  const statusLinePatch = data?.statuslinePatch;
+  if (isStatusLineSettingsPatch(statusLinePatch)) {
+    effects._statusLinePatch = statusLinePatch;
+    return;
+  }
   const ctx = interactiveSession.getContextState();
   manager.setContextState({
     percentage: ctx.usedPercentage,
@@ -1173,6 +1276,13 @@ function routeTuiCommand(cmd, interactiveSession) {
 function getEffects(interactiveSession) {
   return interactiveSession;
 }
+function isStatusLineSettingsPatch(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Date) {
+    return false;
+  }
+  const candidate = value;
+  return (candidate.enabled === void 0 || typeof candidate.enabled === "boolean") && (candidate.gitBranch === void 0 || typeof candidate.gitBranch === "boolean");
+}
 
 // src/ui/hooks/useInteractiveSession.ts
 function initializeSession(props, permissionHandler) {
@@ -1235,8 +1345,8 @@ function useInteractiveSession(props) {
     });
   }, []);
   const permissionHandler = (0, import_react2.useCallback)(
-    (toolName, toolArgs) => new Promise((resolve) => {
-      permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+    (toolName, toolArgs) => new Promise((resolve2) => {
+      permissionQueueRef.current.push({ toolName, toolArgs, resolve: resolve2 });
       processNextPermission();
     }),
     [processNextPermission]
@@ -1261,6 +1371,7 @@ function useInteractiveSession(props) {
     interactiveSession.on("complete", manager.onComplete);
     interactiveSession.on("interrupted", manager.onInterrupted);
     interactiveSession.on("error", manager.onError);
+    interactiveSession.on("context_update", manager.onContextUpdate);
     interactiveSession.on("background_task_event", manager.onBackgroundTaskEvent);
     const initCheck = setInterval(() => {
       try {
@@ -1287,6 +1398,7 @@ function useInteractiveSession(props) {
       interactiveSession.off("complete", manager.onComplete);
       interactiveSession.off("interrupted", manager.onInterrupted);
       interactiveSession.off("error", manager.onError);
+      interactiveSession.off("context_update", manager.onContextUpdate);
       interactiveSession.off("background_task_event", manager.onBackgroundTaskEvent);
     };
   }, [interactiveSession, manager]);
@@ -1449,6 +1561,108 @@ function usePluginCallbacks(cwd) {
 var import_react4 = require("react");
 var import_ink = require("ink");
 var import_agent_core4 = require("@robota-sdk/agent-core");
+
+// src/utils/provider-setup-interaction.ts
+function startProviderSetupInteraction(providerDefinitions, type) {
+  if (type === void 0) {
+    const state2 = {
+      mode: "select-provider",
+      providerDefinitions
+    };
+    return { status: "prompt", state: state2, prompt: toProviderSelectionPrompt(providerDefinitions) };
+  }
+  const state = {
+    mode: "setup-fields",
+    providerDefinitions,
+    flow: createProviderSetupFlow(type, providerDefinitions)
+  };
+  return { status: "prompt", state, prompt: toProviderSetupStepPrompt(state.flow) };
+}
+function submitProviderSetupInteractionValue(state, value) {
+  if (state.mode === "select-provider") {
+    const nextState2 = {
+      mode: "setup-fields",
+      providerDefinitions: state.providerDefinitions,
+      flow: createProviderSetupFlow(value, state.providerDefinitions)
+    };
+    return {
+      status: "prompt",
+      state: nextState2,
+      prompt: toProviderSetupStepPrompt(nextState2.flow)
+    };
+  }
+  const result = submitProviderSetupValue(state.flow, value);
+  if (result.status === "complete") {
+    return { status: "complete", input: result.input };
+  }
+  const nextState = {
+    ...state,
+    flow: result.state
+  };
+  return { status: "prompt", state: nextState, prompt: toProviderSetupStepPrompt(result.state) };
+}
+function toProviderSelectionPrompt(providerDefinitions) {
+  return {
+    kind: "choice",
+    title: "Select provider",
+    options: providerDefinitions.map((definition) => ({
+      value: definition.type,
+      label: formatProviderSetupChoiceLabel(definition)
+    })),
+    maxVisible: 6
+  };
+}
+function toProviderSetupStepPrompt(flow) {
+  const step = getProviderSetupStep(flow);
+  return {
+    kind: "text",
+    title: step.title,
+    ...step.defaultValue !== void 0 ? { placeholder: step.defaultValue } : {},
+    ...step.defaultValue !== void 0 ? { allowEmpty: true } : {},
+    ...step.masked !== void 0 ? { masked: step.masked } : {},
+    validate: (value) => validateProviderSetupValue(step, value)
+  };
+}
+
+// src/utils/statusline-settings.ts
+var DEFAULT_STATUS_LINE_SETTINGS = {
+  enabled: true,
+  gitBranch: true
+};
+function readStatusLineSettings(settings) {
+  const raw = settings.statusline;
+  if (!isRecord(raw)) {
+    return { ...DEFAULT_STATUS_LINE_SETTINGS };
+  }
+  return {
+    enabled: typeof raw.enabled === "boolean" ? raw.enabled : DEFAULT_STATUS_LINE_SETTINGS.enabled,
+    gitBranch: typeof raw.gitBranch === "boolean" ? raw.gitBranch : DEFAULT_STATUS_LINE_SETTINGS.gitBranch
+  };
+}
+function applyStatusLineSettings(settingsPath, patch) {
+  const settings = readSettings(settingsPath);
+  const next = {
+    ...readStatusLineSettings(settings),
+    ...patch
+  };
+  settings.statusline = next;
+  writeSettings(settingsPath, settings);
+  return next;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+
+// src/ui/hooks/statusline-side-effect.ts
+function applyPendingStatusLinePatch(sideEffects, setStatusLineSettings) {
+  if (!sideEffects._statusLinePatch) return false;
+  const patch = sideEffects._statusLinePatch;
+  delete sideEffects._statusLinePatch;
+  setStatusLineSettings(applyStatusLineSettings(getUserSettingsPath(), patch));
+  return true;
+}
+
+// src/ui/hooks/useSideEffects.ts
 var EXIT_DELAY_MS = 500;
 function useSideEffects({
   cwd,
@@ -1456,6 +1670,7 @@ function useSideEffects({
   addEntry,
   baseHandleSubmit,
   setSessionName,
+  setStatusLineSettings,
   providerDefinitions
 }) {
   const { exit } = (0, import_ink.useApp)();
@@ -1463,7 +1678,8 @@ function useSideEffects({
   const pendingModelChangeRef = (0, import_react4.useRef)(null);
   const [pendingProviderProfile, setPendingProviderProfile] = (0, import_react4.useState)(null);
   const pendingProviderProfileRef = (0, import_react4.useRef)(null);
-  const [pendingProviderSetupType, setPendingProviderSetupType] = (0, import_react4.useState)(null);
+  const [pendingInteractionPrompt, setPendingInteractionPrompt] = (0, import_react4.useState)(null);
+  const providerSetupInteractionRef = (0, import_react4.useRef)(null);
   const [showPluginTUI, setShowPluginTUI] = (0, import_react4.useState)(false);
   const [showSessionPicker, setShowSessionPicker] = (0, import_react4.useState)(false);
   const requestShutdown = (0, import_react4.useCallback)(
@@ -1506,10 +1722,14 @@ function useSideEffects({
         setPendingProviderProfile(profile);
         return;
       }
-      if (sideEffects._pendingProviderSetupType) {
-        const type = sideEffects._pendingProviderSetupType;
-        delete sideEffects._pendingProviderSetupType;
-        setPendingProviderSetupType(type);
+      if (sideEffects._pendingProviderSetup !== void 0) {
+        const setup = sideEffects._pendingProviderSetup;
+        delete sideEffects._pendingProviderSetup;
+        const result = startProviderSetupInteraction(providerDefinitions, setup.type);
+        if (result.status === "prompt") {
+          providerSetupInteractionRef.current = result.state;
+          setPendingInteractionPrompt(result.prompt);
+        }
         return;
       }
       if (sideEffects._resetRequested) {
@@ -1547,8 +1767,17 @@ function useSideEffects({
         setSessionName(name);
         return;
       }
+      if (applyPendingStatusLinePatch(sideEffects, setStatusLineSettings)) return;
     },
-    [interactiveSession, baseHandleSubmit, addEntry, requestShutdown, setSessionName]
+    [
+      interactiveSession,
+      baseHandleSubmit,
+      addEntry,
+      requestShutdown,
+      setSessionName,
+      setStatusLineSettings,
+      providerDefinitions
+    ]
   );
   const handleModelConfirm = (0, import_react4.useCallback)(
     (index) => {
@@ -1608,9 +1837,10 @@ function useSideEffects({
     },
     [cwd, addEntry, requestShutdown]
   );
-  const handleProviderSetupSubmit = (0, import_react4.useCallback)(
+  const completeProviderSetup = (0, import_react4.useCallback)(
     (input) => {
-      setPendingProviderSetupType(null);
+      providerSetupInteractionRef.current = null;
+      setPendingInteractionPrompt(null);
       try {
         const settingsPath = getUserSettingsPath();
         applyProviderConfiguration(settingsPath, input, { providerDefinitions });
@@ -1630,15 +1860,43 @@ function useSideEffects({
     },
     [addEntry, requestShutdown, providerDefinitions]
   );
-  const handleProviderSetupCancel = (0, import_react4.useCallback)(() => {
-    setPendingProviderSetupType(null);
+  const handleInteractionSubmit = (0, import_react4.useCallback)(
+    (value) => {
+      const state = providerSetupInteractionRef.current;
+      if (state === null) {
+        setPendingInteractionPrompt(null);
+        return;
+      }
+      try {
+        const result = submitProviderSetupInteractionValue(state, value);
+        if (result.status === "complete") {
+          completeProviderSetup(result.input);
+          return;
+        }
+        providerSetupInteractionRef.current = result.state;
+        setPendingInteractionPrompt(result.prompt);
+      } catch (err) {
+        providerSetupInteractionRef.current = null;
+        setPendingInteractionPrompt(null);
+        addEntry(
+          (0, import_agent_core4.messageToHistoryEntry)(
+            (0, import_agent_core4.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+          )
+        );
+      }
+    },
+    [addEntry, completeProviderSetup]
+  );
+  const handleInteractionCancel = (0, import_react4.useCallback)(() => {
+    providerSetupInteractionRef.current = null;
+    setPendingInteractionPrompt(null);
     addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Provider setup cancelled.")));
   }, [addEntry]);
   return {
     handleSubmit,
     pendingModelId,
     pendingProviderProfile,
-    pendingProviderSetupType,
+    pendingInteractionPrompt,
     showPluginTUI,
     showSessionPicker,
     setPendingModelId,
@@ -1646,102 +1904,344 @@ function useSideEffects({
     setShowSessionPicker,
     handleModelConfirm,
     handleProviderConfirm,
-    handleProviderSetupSubmit,
-    handleProviderSetupCancel
+    handleInteractionSubmit,
+    handleInteractionCancel
   };
 }
 
+// src/ui/hooks/useStatusLineSettings.ts
+var import_react5 = require("react");
+function useStatusLineSettings() {
+  return (0, import_react5.useState)(
+    () => readStatusLineSettings(readSettings(getUserSettingsPath()))
+  );
+}
+
 // src/ui/MessageList.tsx
-var import_react5 = __toESM(require("react"), 1);
-var import_ink3 = require("ink");
-var import_agent_core5 = require("@robota-sdk/agent-core");
+var import_react6 = __toESM(require("react"), 1);
+var import_ink5 = require("ink");
+var import_agent_core6 = require("@robota-sdk/agent-core");
 
 // src/ui/render-markdown.ts
 var import_marked = require("marked");
 var import_marked_terminal = __toESM(require("marked-terminal"), 1);
-import_marked.marked.setOptions({
-  renderer: new import_marked_terminal.default()
-});
-function renderMarkdown(md) {
-  const result = import_marked.marked.parse(md);
+var ANSI_RED = "\x1B[31m";
+var ANSI_GREEN = "\x1B[32m";
+var ANSI_CYAN = "\x1B[36m";
+var ANSI_DIM = "\x1B[2m";
+var ANSI_RESET = "\x1B[0m";
+var CODE_BLOCK_INDENT = "    ";
+var ZERO_COLOR = "0";
+var TerminalRendererConstructor = import_marked_terminal.default;
+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 colorizeDiffLine(line, color) {
+  if (!color) {
+    return line;
+  }
+  if (line.startsWith("+")) {
+    return `${ANSI_GREEN}${line}${ANSI_RESET}`;
+  }
+  if (line.startsWith("-")) {
+    return `${ANSI_RED}${line}${ANSI_RESET}`;
+  }
+  if (line.startsWith("@@")) {
+    return `${ANSI_CYAN}${line}${ANSI_RESET}`;
+  }
+  if (line.startsWith("diff ") || line.startsWith("index ")) {
+    return `${ANSI_DIM}${line}${ANSI_RESET}`;
+  }
+  return line;
+}
+function renderDiffCodeBlock(code, color) {
+  const body = code.split("\n").map((line) => `${CODE_BLOCK_INDENT}${colorizeDiffLine(line, color)}`).join("\n");
+  return `${body}
+
+`;
+}
+function createTerminalRenderer(color) {
+  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);
+    }
+    return renderCode(code, language, escaped);
+  };
+  return renderer;
+}
+function renderMarkdown(md, options = {}) {
+  const result = import_marked.marked.parse(md, {
+    renderer: createTerminalRenderer(shouldUseColor(options.color))
+  });
   return typeof result === "string" ? result.trimEnd() : md;
 }
 
-// src/ui/DiffBlock.tsx
+// src/ui/ToolDiffBlock.tsx
 var import_ink2 = require("ink");
-var import_jsx_runtime = require("react/jsx-runtime");
+
+// src/utils/tool-diff-summary.ts
 var MAX_DIFF_LINES = 12;
 var TRUNCATED_SHOW = 10;
-function DiffBlock({ file, lines }) {
-  const truncated = lines.length > MAX_DIFF_LINES;
-  const visible = truncated ? lines.slice(0, TRUNCATED_SHOW) : lines;
-  const remaining = lines.length - TRUNCATED_SHOW;
-  const maxLineNum = Math.max(...visible.map((l) => l.lineNumber), 0);
-  const numWidth = String(maxLineNum).length;
+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/ui/ToolDiffBlock.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function ToolDiffBlock({ file, lines }) {
+  const summary = buildToolDiffSummary({ file, lines });
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Box, { flexDirection: "column", marginLeft: 4, children: [
-    file && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Text, { color: "white", dimColor: true, children: [
+    summary.file && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Text, { color: "white", dimColor: true, children: [
       "\u2502 ",
-      file
+      summary.file
     ] }),
-    visible.map((line, i) => {
-      const lineNum = String(line.lineNumber).padStart(numWidth, " ");
-      if (line.type === "context") {
-        return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Text, { color: "white", dimColor: true, children: [
-          "\u2502 ",
-          lineNum,
-          " ",
-          line.text
-        ] }, i);
-      }
-      const prefix = line.type === "remove" ? "-" : "+";
-      const bgColor = line.type === "remove" ? "#5c1a1a" : "#1a3d1a";
-      const fgColor = line.type === "remove" ? "#ff9999" : "#99ff99";
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Text, { color: fgColor, backgroundColor: bgColor, children: [
-        "\u2502 ",
-        lineNum,
-        " ",
-        prefix,
-        " ",
-        line.text
-      ] }, i);
-    }),
-    truncated && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Text, { color: "white", dimColor: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink2.Text, { children: renderMarkdown(summary.markdown) }),
+    summary.truncated && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Text, { color: "white", dimColor: true, children: [
       "\u2502 ... and ",
-      remaining,
+      summary.remainingLineCount,
       " more lines"
     ] })
   ] });
 }
 
-// src/ui/MessageList.tsx
+// src/ui/UsageSummaryEntry.tsx
+var import_ink3 = require("ink");
+var import_agent_core5 = require("@robota-sdk/agent-core");
 var import_jsx_runtime2 = require("react/jsx-runtime");
+var TOKEN_COMPACT_THRESHOLD = 1e3;
+function UsageSummaryEntry({ entry }) {
+  const usage = entry.data;
+  if (!usage) return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.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)}% (${(0, import_agent_core5.formatTokenCount)(
+    usage.contextUsedTokens
+  )}/${(0, import_agent_core5.formatTokenCount)(usage.contextMaxTokens)})`;
+  const costLabel = usage.costStatus === "unknown" ? "cost unknown" : `cost ${usage.costStatus}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", bold: true, children: [
+      "Usage:",
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { 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() : (0, import_agent_core5.formatTokenCount)(tokens);
+}
+
+// src/ui/command-output-summary.ts
+var MAX_PREVIEW_LINES = 4;
+var SUCCESS_EXIT_CODE2 = 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_CODE2;
+  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_CODE2) 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/ui/ToolCommandOutput.tsx
+var import_ink4 = require("ink");
+var import_jsx_runtime3 = require("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__ */ (0, import_jsx_runtime3.jsxs)(import_ink4.Box, { flexDirection: "column", marginLeft: 4, children: [
+    summary.statusLabel !== "ok" && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { color, dimColor: true, children: summary.statusLabel }),
+    summary.previewLines.map((line, index) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { color, dimColor: true, children: line }, `${line}-${index}`)),
+    summary.transcriptHint && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { dimColor: true, children: summary.transcriptHint })
+  ] });
+}
+
+// src/ui/MessageList.tsx
+var import_jsx_runtime4 = require("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__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "green", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "green", bold: true, children: [
         "You:",
         " "
       ] });
     case "assistant":
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "cyan", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "cyan", bold: true, children: [
         "Robota:",
         " "
       ] });
     case "system":
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "yellow", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "yellow", bold: true, children: [
         "System:",
         " "
       ] });
     case "tool":
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "white", bold: true, children: [
         "Tool:",
         " "
       ] });
   }
 }
 function ToolMessage({ message }) {
-  if (!(0, import_agent_core5.isToolMessage)(message)) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, {});
+  if (!(0, import_agent_core6.isToolMessage)(message)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, {});
   }
   const toolName = message.name;
   const content = message.content;
@@ -1754,45 +2254,45 @@ function ToolMessage({ message }) {
   } catch {
   }
   if (summaries) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", bold: true, children: [
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "white", bold: true, children: [
           "Tool:",
           " "
         ] }),
-        toolName && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", dimColor: true, children: [
+        toolName && /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "white", dimColor: true, children: [
           "[",
           toolName,
           "]"
         ] })
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: " " }),
-      summaries.map((s, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "green", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: " " }),
+      summaries.map((s, i) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "green", children: [
           "  ",
           "\u2713",
           " ",
           s.line
         ] }),
-        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(DiffBlock, { file: s.diffFile, lines: s.diffLines })
+        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ToolDiffBlock, { file: s.diffFile, lines: s.diffLines })
       ] }, i))
     ] });
   }
   const lines = content.split("\n").filter((l) => l.trim());
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", bold: true, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "white", bold: true, children: [
         "Tool:",
         " "
       ] }),
-      toolName && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", dimColor: true, children: [
+      toolName && /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "white", dimColor: true, children: [
         "[",
         toolName,
         "]"
       ] })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: " " }),
-    lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "green", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "green", children: [
       "  ",
       "\u2713",
       " ",
@@ -1800,30 +2300,48 @@ function ToolMessage({ message }) {
     ] }, i))
   ] });
 }
-var MessageItem = import_react5.default.memo(function MessageItem2({
+var MessageItem = import_react6.default.memo(function MessageItem2({
   message
 }) {
-  if ((0, import_agent_core5.isToolMessage)(message)) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ToolMessage, { message });
+  if ((0, import_agent_core6.isToolMessage)(message)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ToolMessage, { message });
   }
   const content = message.content ?? "";
   const isInterrupted = message.state === "interrupted";
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RoleLabel, { role: message.role }) }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: " " }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { wrap: "wrap", children: (0, import_agent_core5.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RoleLabel, { role: message.role }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: " " }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { wrap: "wrap", children: (0, import_agent_core6.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") ?? [];
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", bold: true, children: [
+  if (tools && tools.length > 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: " " }),
+      tools.map((tool, i) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: getToolSummaryColor(tool), children: [
+          "  ",
+          getToolSummaryLabel(tool)
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ToolCommandOutput, { tool }),
+        tool.diffLines && tool.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ToolDiffBlock, { file: tool.diffFile, lines: tool.diffLines })
+      ] }, i))
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "white", bold: true, children: [
       "Tool:",
       " "
     ] }) }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: " " }),
-    lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "green", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "green", children: [
       "  ",
       line
     ] }, i))
@@ -1832,36 +2350,134 @@ function ToolSummaryEntry({ entry }) {
 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__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "yellow", bold: true, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { color: "yellow", bold: true, children: [
       "System:",
       " "
     ] }) }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: " " }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { wrap: "wrap", children: eventMessage }) })
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: " " }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { wrap: "wrap", children: eventMessage }) })
   ] });
 }
 function EntryItem({ entry }) {
   if (entry.category === "chat") {
     const message = entry.data;
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MessageItem, { message });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MessageItem, { message });
   }
   if (entry.type === "tool-summary") {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ToolSummaryEntry, { entry });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ToolSummaryEntry, { entry });
+  }
+  if (entry.type === "usage-summary") {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(UsageSummaryEntry, { entry });
   }
   if (entry.type === "tool-start" || entry.type === "tool-end") {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, {});
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, {});
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(EventEntry, { entry });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(EventEntry, { entry });
 }
 function MessageList({ history }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(EntryItem, { entry }, entry.id)) });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(EntryItem, { entry }, entry.id)) });
+}
+
+// src/ui/SessionStatusBar.tsx
+var import_react7 = require("react");
+var import_agent_core8 = require("@robota-sdk/agent-core");
+
+// src/utils/git-branch.ts
+var import_node_fs4 = require("fs");
+var import_node_path6 = require("path");
+var DETACHED_HEAD_LENGTH = 7;
+function resolveGitBranch(cwd) {
+  try {
+    const gitDir = findGitDir(cwd);
+    if (!gitDir) return void 0;
+    const head = (0, import_node_fs4.readFileSync)((0, import_node_path6.join)(gitDir, "HEAD"), "utf8").trim();
+    if (!head) return void 0;
+    if (head.startsWith("ref: ")) {
+      const ref = head.slice("ref: ".length).trim();
+      const branchPrefix = "refs/heads/";
+      return ref.startsWith(branchPrefix) ? ref.slice(branchPrefix.length) : ref;
+    }
+    return head.slice(0, DETACHED_HEAD_LENGTH);
+  } catch {
+    return void 0;
+  }
+}
+function findGitDir(start) {
+  let current = (0, import_node_path6.resolve)(start);
+  let parent = (0, import_node_path6.dirname)(current);
+  while (parent !== current) {
+    const candidate = (0, import_node_path6.join)(current, ".git");
+    const resolved = resolveGitMetadata(candidate, current);
+    if (resolved) return resolved;
+    current = parent;
+    parent = (0, import_node_path6.dirname)(current);
+  }
+  const rootCandidate = (0, import_node_path6.join)(current, ".git");
+  return resolveGitMetadata(rootCandidate, current);
+}
+function resolveGitMetadata(candidate, repoDir) {
+  if (!(0, import_node_fs4.existsSync)(candidate)) return void 0;
+  const stat = (0, import_node_fs4.lstatSync)(candidate);
+  if (stat.isDirectory()) return candidate;
+  if (!stat.isFile()) return void 0;
+  const content = (0, import_node_fs4.readFileSync)(candidate, "utf8").trim();
+  const prefix = "gitdir:";
+  if (!content.startsWith(prefix)) return void 0;
+  const rawPath = content.slice(prefix.length).trim();
+  return (0, import_node_path6.isAbsolute)(rawPath) ? rawPath : (0, import_node_path6.resolve)(repoDir, rawPath);
 }
 
 // src/ui/StatusBar.tsx
-var import_ink4 = require("ink");
-var import_agent_core6 = require("@robota-sdk/agent-core");
-var import_jsx_runtime3 = require("react/jsx-runtime");
+var import_ink6 = require("ink");
+var import_agent_core7 = require("@robota-sdk/agent-core");
+
+// src/ui/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/ui/StatusBar.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
 var CONTEXT_YELLOW_THRESHOLD = 70;
 var CONTEXT_RED_THRESHOLD = 90;
 function getContextColor(percentage) {
@@ -1869,67 +2485,194 @@ function getContextColor(percentage) {
   if (percentage >= CONTEXT_YELLOW_THRESHOLD) return "yellow";
   return "green";
 }
-function StatusBar({
+function StatusActivityText({
+  isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt
+}) {
+  const activity = formatStatusActivity({
+    isThinking,
+    activeToolCount,
+    activeBackgroundTaskCount,
+    hasPendingPrompt
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: "cyan", bold: true, children: "Activity:" }),
+    " ",
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: activity.color, bold: activity.kind !== "idle", children: activity.text })
+  ] });
+}
+function ContextText({
+  percentage,
+  usedTokens,
+  maxTokens
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { color: getContextColor(percentage), children: [
+    "Context: ",
+    Math.round(percentage),
+    "% (",
+    (0, import_agent_core7.formatTokenCount)(usedTokens),
+    "/",
+    (0, import_agent_core7.formatTokenCount)(maxTokens),
+    ")"
+  ] });
+}
+function ModeText({ permissionMode }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: "cyan", bold: true, children: "Mode:" }),
+    " ",
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { children: permissionMode })
+  ] });
+}
+function StatusLeft({
   permissionMode,
   modelName,
-  sessionId: _sessionId,
-  messageCount,
   isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt,
   contextPercentage,
   contextUsedTokens,
   contextMaxTokens,
-  sessionName
+  sessionName,
+  gitBranch,
+  showGitBranch
 }) {
-  const contextColor = getContextColor(contextPercentage);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
-    import_ink4.Box,
-    {
-      borderStyle: "single",
-      borderColor: "gray",
-      paddingLeft: 1,
-      paddingRight: 1,
-      justifyContent: "space-between",
-      children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink4.Text, { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { color: "cyan", bold: true, children: "Mode:" }),
-          " ",
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { children: permissionMode }),
-          sessionName && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
-            "  |  ",
-            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { color: "magenta", children: sessionName })
-          ] }),
-          "  |  ",
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { dimColor: true, children: modelName }),
-          "  |  ",
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink4.Text, { color: contextColor, children: [
-            "Context: ",
-            Math.round(contextPercentage),
-            "% (",
-            (0, import_agent_core6.formatTokenCount)(contextUsedTokens),
-            "/",
-            (0, import_agent_core6.formatTokenCount)(contextMaxTokens),
-            ")"
-          ] })
-        ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink4.Text, { children: [
-          isThinking && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { color: "yellow", children: "Thinking... " }),
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink4.Text, { dimColor: true, children: [
-            "msgs: ",
-            messageCount
-          ] })
-        ] })
+  const shouldShowGitBranch = showGitBranch && gitBranch !== void 0 && gitBranch.length > 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      StatusActivityText,
+      {
+        isThinking,
+        activeToolCount,
+        activeBackgroundTaskCount,
+        hasPendingPrompt
+      }
+    ),
+    "  |  ",
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ModeText, { permissionMode }),
+    sessionName && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+      "  |  ",
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: "magenta", children: sessionName })
+    ] }),
+    shouldShowGitBranch && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+      "  |  ",
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { dimColor: true, children: [
+        "git: ",
+        gitBranch
+      ] })
+    ] }),
+    "  |  ",
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { dimColor: true, children: modelName }),
+    "  |  ",
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      ContextText,
+      {
+        percentage: contextPercentage,
+        usedTokens: contextUsedTokens,
+        maxTokens: contextMaxTokens
+      }
+    )
+  ] });
+}
+function StatusBar({
+  permissionMode,
+  modelName,
+  sessionId: _sessionId,
+  messageCount,
+  isThinking,
+  activeToolCount = 0,
+  activeBackgroundTaskCount = 0,
+  hasPendingPrompt = false,
+  contextPercentage,
+  contextUsedTokens,
+  contextMaxTokens,
+  sessionName,
+  gitBranch,
+  showGitBranch = true
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+    import_ink6.Box,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingLeft: 1,
+      paddingRight: 1,
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          StatusLeft,
+          {
+            permissionMode,
+            modelName,
+            isThinking,
+            activeToolCount,
+            activeBackgroundTaskCount,
+            hasPendingPrompt,
+            contextPercentage,
+            contextUsedTokens,
+            contextMaxTokens,
+            sessionName,
+            gitBranch,
+            showGitBranch
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { dimColor: true, children: [
+          "msgs: ",
+          messageCount
+        ] }) })
       ]
     }
   );
 }
 
+// src/ui/SessionStatusBar.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function SessionStatusBar({
+  cwd,
+  permissionMode,
+  modelId,
+  sessionId,
+  messageCount,
+  isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt,
+  contextState,
+  sessionName,
+  settings
+}) {
+  const gitBranch = (0, import_react7.useMemo)(() => resolveGitBranch(cwd), [cwd]);
+  if (!settings.enabled) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    StatusBar,
+    {
+      permissionMode,
+      modelName: modelId ? (0, import_agent_core8.getModelName)(modelId) : "",
+      sessionId,
+      messageCount,
+      isThinking,
+      activeToolCount,
+      activeBackgroundTaskCount,
+      hasPendingPrompt,
+      contextPercentage: contextState.percentage,
+      contextUsedTokens: contextState.usedTokens,
+      contextMaxTokens: contextState.maxTokens,
+      sessionName,
+      gitBranch,
+      showGitBranch: settings.gitBranch
+    }
+  );
+}
+
 // src/ui/InputArea.tsx
-var import_react9 = require("react");
-var import_ink8 = require("ink");
+var import_react11 = require("react");
+var import_ink10 = require("ink");
 
 // src/ui/CjkTextInput.tsx
-var import_react6 = require("react");
-var import_ink5 = require("ink");
+var import_react8 = require("react");
+var import_ink7 = require("ink");
 var import_chalk = __toESM(require("chalk"), 1);
 
 // src/ui/flows/cjk-text-input-flow.ts
@@ -1956,10 +2699,20 @@ function applyCjkTextInput(state, input, key, 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.availableWidth);
+  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);
@@ -1984,9 +2737,16 @@ function applyControlInput(state, input, key, options) {
   }
   return void 0;
 }
-function applyCursorInput(state, key, availableWidth) {
+function applyCursorInput(state, key, options) {
   if (key.upArrow === true || key.downArrow === true) {
-    return moveCursorVertically(state, key.upArrow === true ? "up" : "down", availableWidth);
+    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");
@@ -2049,15 +2809,8 @@ function continueBracketedPaste(state, input, options) {
     };
   }
   const beforeMarker = input.split(PASTE_END)[0] ?? "";
-  const text = (state.pasteBuffer + beforeMarker).replace(/\r\n?/g, "\n");
   const nextState = { ...state, isPasting: false, pasteBuffer: "" };
-  if (text.length === 0) {
-    return { state: nextState, effect: { type: "none" } };
-  }
-  if (text.includes("\n") && options.canPaste) {
-    return { state: nextState, effect: { type: "paste", text, cursor: state.cursor } };
-  }
-  return insertPrintableInput(nextState, text);
+  return applyCjkTextPaste(nextState, state.pasteBuffer + beforeMarker, options);
 }
 function moveCursorVertically(state, direction, availableWidth) {
   if (!availableWidth || availableWidth <= 0) {
@@ -2107,7 +2860,7 @@ function insertPrintableInput(state, input) {
 }
 
 // src/ui/CjkTextInput.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
+var import_jsx_runtime7 = require("react/jsx-runtime");
 function CjkTextInput({
   value,
   onChange,
@@ -2117,32 +2870,70 @@ function CjkTextInput({
   focus = true,
   showCursor = true,
   availableWidth,
-  cursorHint = null
+  cursorHint = null,
+  enableVerticalNavigation = true
 }) {
-  const stateRef = (0, import_react6.useRef)(createCjkTextInputFlowState(value));
-  const [, forceRender] = (0, import_react6.useState)(0);
+  const stateRef = (0, import_react8.useRef)(createCjkTextInputFlowState(value));
+  const [, forceRender] = (0, import_react8.useState)(0);
   stateRef.current = syncCjkTextInputFlowState(stateRef.current, value, cursorHint);
-  (0, import_ink5.useInput)(
-    (input, key) => {
-      try {
-        const result = applyCjkTextInput(stateRef.current, input, key, {
-          availableWidth,
-          canPaste: onPaste !== void 0
-        });
-        stateRef.current = result.state;
-        applyCjkTextInputEffect(result.effect, onChange, onSubmit, onPaste, forceRender);
-      } catch {
-      }
-    },
-    { isActive: focus }
-  );
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: renderWithCursor(
+  useCjkTextInputHandlers({
+    stateRef,
+    onChange,
+    onSubmit,
+    onPaste,
+    availableWidth,
+    focus,
+    enableVerticalNavigation,
+    forceRender
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { children: renderWithCursor(
     stateRef.current.value,
     stateRef.current.cursor,
     placeholder,
     showCursor && focus
   ) });
 }
+function useCjkTextInputHandlers(options) {
+  (0, import_ink7.usePaste)(
+    (text) => {
+      applyCjkFlowSafely(
+        options,
+        () => applyCjkTextPaste(options.stateRef.current, text, createFlowOptions(options))
+      );
+    },
+    { isActive: options.focus }
+  );
+  (0, import_ink7.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);
@@ -2177,38 +2968,38 @@ function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
 }
 
 // src/ui/WaveText.tsx
-var import_react7 = require("react");
-var import_ink6 = require("ink");
-var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_react9 = require("react");
+var import_ink8 = require("ink");
+var import_jsx_runtime8 = require("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] = (0, import_react7.useState)(0);
-  (0, import_react7.useEffect)(() => {
+  const [tick, setTick] = (0, import_react9.useState)(0);
+  (0, import_react9.useEffect)(() => {
     const timer = setInterval(() => {
       setTick((prev) => prev + 1);
     }, INTERVAL_MS);
     return () => clearInterval(timer);
   }, []);
   const chars = [...text];
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { children: chars.map((char, i) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { children: chars.map((char, i) => {
     const group = Math.floor(i / CHARS_PER_GROUP);
     const colorIndex = (tick + group) % WAVE_COLORS.length;
-    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: WAVE_COLORS[colorIndex], children: char }, i);
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { color: WAVE_COLORS[colorIndex], children: char }, i);
   }) });
 }
 
 // src/ui/SlashAutocomplete.tsx
-var import_ink7 = require("ink");
-var import_jsx_runtime6 = require("react/jsx-runtime");
+var import_ink9 = require("ink");
+var import_jsx_runtime9 = require("react/jsx-runtime");
 var MAX_VISIBLE = 8;
 function CommandRow(props) {
   const { cmd, isSelected, showSlash } = props;
   const indicator = isSelected ? "\u25B8 " : "  ";
   const nameColor = isSelected ? "cyan" : void 0;
   const dimmed = !isSelected;
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink7.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_ink7.Text, { color: nameColor, dimColor: dimmed, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Text, { color: nameColor, dimColor: dimmed, children: [
     indicator,
     showSlash ? `/${cmd.name}  ${cmd.description}` : cmd.description
   ] }) });
@@ -2222,7 +3013,7 @@ function SlashAutocomplete({
   if (!visible || commands.length === 0) return null;
   const scrollOffset = computeScrollOffset(selectedIndex, commands.length);
   const visibleCommands = commands.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink7.Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
     CommandRow,
     {
       cmd,
@@ -2246,7 +3037,7 @@ function expandPasteLabels(text, store) {
 }
 
 // src/ui/hooks/useAutocomplete.ts
-var import_react8 = __toESM(require("react"), 1);
+var import_react10 = __toESM(require("react"), 1);
 function parseSlashInput(value) {
   if (!value.startsWith("/")) return { isSlash: false, parentCommand: "", filter: "" };
   const afterSlash = value.slice(1);
@@ -2257,16 +3048,16 @@ function parseSlashInput(value) {
   return { isSlash: true, parentCommand: parent, filter: rest };
 }
 function useAutocomplete(value, registry) {
-  const [selectedIndex, setSelectedIndex] = (0, import_react8.useState)(0);
-  const [dismissed, setDismissed] = (0, import_react8.useState)(false);
-  const prevValueRef = import_react8.default.useRef(value);
+  const [selectedIndex, setSelectedIndex] = (0, import_react10.useState)(0);
+  const [dismissed, setDismissed] = (0, import_react10.useState)(false);
+  const prevValueRef = import_react10.default.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 = (0, import_react8.useMemo)(() => {
+  const filteredCommands = (0, import_react10.useMemo)(() => {
     if (!registry || !parsed.isSlash || dismissed) return [];
     if (isSubcommandMode) {
       const subs = registry.getSubcommands(parsed.parentCommand);
@@ -2314,6 +3105,61 @@ function getPendingPromptInputAction(key) {
   }
   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") {
@@ -2356,11 +3202,12 @@ function shouldSubmitInput(text) {
 }
 
 // src/ui/InputArea.tsx
-var import_jsx_runtime7 = require("react/jsx-runtime");
+var import_jsx_runtime10 = require("react/jsx-runtime");
 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,
@@ -2368,15 +3215,26 @@ function InputArea({
   isAborting,
   pendingPrompt,
   registry,
-  sessionName
+  sessionName,
+  history
 }) {
-  const [value, setValue] = (0, import_react9.useState)("");
-  const [cursorHint, setCursorHint] = (0, import_react9.useState)(null);
-  const pasteStore = (0, import_react9.useRef)(/* @__PURE__ */ new Map());
-  const { stdout } = (0, import_ink8.useStdout)();
-  const terminalColumns = stdout?.columns ?? 80;
+  const [value, setValue] = (0, import_react11.useState)("");
+  const [cursorHint, setCursorHint] = (0, import_react11.useState)(null);
+  const [historyState, setHistoryState] = (0, import_react11.useState)(createPromptHistoryNavigationState);
+  const [localPromptHistory, setLocalPromptHistory] = (0, import_react11.useState)([]);
+  const restoredPromptHistory = (0, import_react11.useMemo)(() => extractPromptHistory(history ?? []), [history]);
+  const promptHistory = (0, import_react11.useMemo)(
+    () => localPromptHistory.reduce(
+      (prompts, prompt) => appendPromptHistory(prompts, prompt),
+      restoredPromptHistory
+    ),
+    [restoredPromptHistory, localPromptHistory]
+  );
+  const pasteStore = (0, import_react11.useRef)(/* @__PURE__ */ new Map());
+  const { columns } = (0, import_ink10.useWindowSize)();
+  const terminalColumns = columns > 0 ? columns : DEFAULT_TERMINAL_COLUMNS;
   const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
-  const pasteIdRef = (0, import_react9.useRef)(0);
+  const pasteIdRef = (0, import_react11.useRef)(0);
   const {
     showPopup,
     filteredCommands,
@@ -2385,7 +3243,7 @@ function InputArea({
     isSubcommandMode,
     setShowPopup
   } = useAutocomplete(value, registry);
-  const handlePaste = (0, import_react9.useCallback)((text, cursorPosition) => {
+  const handlePaste = (0, import_react11.useCallback)((text, cursorPosition) => {
     pasteIdRef.current += 1;
     const id = pasteIdRef.current;
     pasteStore.current.set(id, text);
@@ -2395,7 +3253,21 @@ function InputArea({
       return change.value;
     });
   }, []);
-  const tabCompleteCommand = (0, import_react9.useCallback)(
+  const resetHistoryNavigation = (0, import_react11.useCallback)(() => {
+    setHistoryState(createPromptHistoryNavigationState());
+  }, []);
+  const recordPromptHistory = (0, import_react11.useCallback)((prompt) => {
+    setLocalPromptHistory((prev) => appendPromptHistory(prev, prompt));
+  }, []);
+  const submitPrompt = (0, import_react11.useCallback)(
+    (prompt) => {
+      recordPromptHistory(prompt);
+      resetHistoryNavigation();
+      onSubmit(prompt);
+    },
+    [onSubmit, recordPromptHistory, resetHistoryNavigation]
+  );
+  const tabCompleteCommand = (0, import_react11.useCallback)(
     (cmd) => {
       const result = resolveTabCompletion(value, cmd);
       if (result.type === "insert") {
@@ -2407,7 +3279,7 @@ function InputArea({
     },
     [value, setSelectedIndex]
   );
-  const enterSelectCommand = (0, import_react9.useCallback)(
+  const enterSelectCommand = (0, import_react11.useCallback)(
     (cmd) => {
       const result = resolveEnterCommandSelection(value, cmd);
       if (result.type === "insert") {
@@ -2418,11 +3290,11 @@ function InputArea({
         return;
       }
       setValue("");
-      onSubmit(result.value);
+      submitPrompt(result.value);
     },
-    [value, onSubmit, setSelectedIndex]
+    [value, submitPrompt, setSelectedIndex]
   );
-  const handleSubmit = (0, import_react9.useCallback)(
+  const handleSubmit = (0, import_react11.useCallback)(
     (text) => {
       if (!shouldSubmitInput(text)) return;
       if (showPopup && filteredCommands[selectedIndex]) {
@@ -2433,11 +3305,11 @@ function InputArea({
       setValue("");
       pasteStore.current.clear();
       pasteIdRef.current = 0;
-      onSubmit(expanded);
+      submitPrompt(expanded);
     },
-    [showPopup, filteredCommands, selectedIndex, onSubmit, enterSelectCommand]
+    [showPopup, filteredCommands, selectedIndex, enterSelectCommand, submitPrompt]
   );
-  (0, import_ink8.useInput)(
+  (0, import_ink10.useInput)(
     (_input, key) => {
       if (!showPopup) return;
       const action = getAutocompletePopupAction(key);
@@ -2454,7 +3326,18 @@ function InputArea({
     },
     { isActive: showPopup && !isDisabled }
   );
-  (0, import_ink8.useInput)(
+  (0, import_ink10.useInput)(
+    (_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 }
+  );
+  (0, import_ink10.useInput)(
     (_input, key) => {
       if (getPendingPromptInputAction(key) === "cancelQueue" && pendingPrompt) {
         onCancelQueue?.();
@@ -2473,8 +3356,8 @@ function InputArea({
     }
     return { left: "\u250C" + "\u2500".repeat(innerWidth), label: "", right: "\u2510" };
   })();
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink8.Box, { flexDirection: "column", children: [
-    showPopup && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
       SlashAutocomplete,
       {
         commands: filteredCommands,
@@ -2483,32 +3366,34 @@ function InputArea({
         isSubcommandMode
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink8.Text, { color: borderColor, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Text, { color: borderColor, children: [
       topBorder.left,
-      topBorder.label ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink8.Text, { backgroundColor: borderColor, color: "black", bold: true, children: topBorder.label }) : null,
+      topBorder.label ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { backgroundColor: borderColor, color: "black", bold: true, children: topBorder.label }) : null,
       topBorder.right
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink8.Box, { borderStyle: "single", borderTop: false, borderColor, paddingLeft: 1, children: isAborting ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink8.Text, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink8.Text, { color: "cyan", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Box, { borderStyle: "single", borderTop: false, borderColor, paddingLeft: 1, children: isAborting ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Text, { color: "cyan", children: [
       " ",
       "Queued: ",
       pendingPrompt.length > 50 ? pendingPrompt.slice(0, 47) + "..." : pendingPrompt,
       " ",
-      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink8.Text, { dimColor: true, children: "(Backspace to cancel)" })
-    ] }) : isDisabled ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink8.Box, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink8.Text, { color: "green", bold: true, children: "> " }),
-      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { dimColor: true, children: "(Backspace to cancel)" })
+    ] }) : isDisabled ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { color: "green", bold: true, children: "> " }),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
         CjkTextInput,
         {
           value,
           onChange: (v) => {
             setValue(v);
+            resetHistoryNavigation();
             setCursorHint(null);
           },
           onSubmit: handleSubmit,
           onPaste: handlePaste,
           placeholder: "Type a message or /help",
           availableWidth,
-          cursorHint
+          cursorHint,
+          enableVerticalNavigation: false
         }
       )
     ] }) })
@@ -2516,8 +3401,8 @@ function InputArea({
 }
 
 // src/ui/ConfirmPrompt.tsx
-var import_react10 = require("react");
-var import_ink9 = require("ink");
+var import_react12 = require("react");
+var import_ink11 = require("ink");
 
 // src/ui/flows/selection-flow.ts
 function createSelectionFlowState() {
@@ -2620,15 +3505,15 @@ function applyConfirmPromptInput(state, action, optionCount) {
 }
 
 // src/ui/ConfirmPrompt.tsx
-var import_jsx_runtime8 = require("react/jsx-runtime");
+var import_jsx_runtime11 = require("react/jsx-runtime");
 function ConfirmPrompt({
   message,
   options = ["Yes", "No"],
   onSelect
 }) {
-  const [state, setState] = (0, import_react10.useState)(() => createSelectionFlowState());
-  const stateRef = (0, import_react10.useRef)(state);
-  const applyAction = (0, import_react10.useCallback)(
+  const [state, setState] = (0, import_react12.useState)(() => createSelectionFlowState());
+  const stateRef = (0, import_react12.useRef)(state);
+  const applyAction = (0, import_react12.useCallback)(
     (action) => {
       const result = applyConfirmPromptInput(stateRef.current, action, options.length);
       stateRef.current = result.state;
@@ -2639,16 +3524,16 @@ function ConfirmPrompt({
     },
     [onSelect, options.length]
   );
-  (0, import_ink9.useInput)((input, key) => {
+  (0, import_ink11.useInput)((input, key) => {
     const action = getConfirmPromptInputAction(input, key, options.length);
     if (action !== void 0) {
       applyAction(action);
     }
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink9.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Text, { color: "yellow", children: message }),
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Box, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
-      import_ink9.Text,
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { color: "yellow", children: message }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(
+      import_ink11.Text,
       {
         color: i === state.selectedIndex ? "cyan" : void 0,
         bold: i === state.selectedIndex,
@@ -2658,16 +3543,81 @@ function ConfirmPrompt({
         ]
       }
     ) }, opt)) }),
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Text, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
   ] });
 }
 
-// src/ui/ProviderSetupPrompt.tsx
-var import_react12 = require("react");
+// src/ui/InteractivePrompt.tsx
+var import_ink14 = require("ink");
+
+// src/ui/ListPicker.tsx
+var import_react13 = require("react");
+var import_ink12 = require("ink");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var DEFAULT_MAX_VISIBLE = 3;
+function ListPicker({
+  items,
+  renderItem,
+  onSelect,
+  onCancel,
+  maxVisible = DEFAULT_MAX_VISIBLE
+}) {
+  const [state, setState] = (0, import_react13.useState)(() => createSelectionFlowState());
+  const stateRef = (0, import_react13.useRef)(state);
+  const applyAction = (0, import_react13.useCallback)(
+    (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]
+  );
+  (0, import_ink12.useInput)((_input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  if (items.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Box, {});
+  }
+  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__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", children: [
+    hasLess && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Text, { dimColor: true, children: [
+      " \u2191 ",
+      scrollOffset,
+      " more above"
+    ] }),
+    visibleItems.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Box, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
+    hasMore && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Text, { dimColor: true, children: [
+      " \u2193 ",
+      items.length - scrollOffset - maxVisible,
+      " more below"
+    ] })
+  ] });
+}
 
 // src/ui/TextPrompt.tsx
-var import_react11 = require("react");
-var import_ink10 = require("ink");
+var import_react14 = require("react");
+var import_ink13 = require("ink");
 
 // src/ui/flows/text-prompt-flow.ts
 function createTextPromptFlowState() {
@@ -2726,7 +3676,7 @@ function submitTextPromptValue(state, options) {
 }
 
 // src/ui/TextPrompt.tsx
-var import_jsx_runtime9 = require("react/jsx-runtime");
+var import_jsx_runtime13 = require("react/jsx-runtime");
 function TextPrompt({
   title,
   placeholder,
@@ -2736,9 +3686,9 @@ function TextPrompt({
   allowEmpty = false,
   masked = false
 }) {
-  const [state, setState] = (0, import_react11.useState)(() => createTextPromptFlowState());
-  const stateRef = (0, import_react11.useRef)(state);
-  const applyAction = (0, import_react11.useCallback)(
+  const [state, setState] = (0, import_react14.useState)(() => createTextPromptFlowState());
+  const stateRef = (0, import_react14.useRef)(state);
+  const applyAction = (0, import_react14.useCallback)(
     (action) => {
       const result = applyTextPromptInput(stateRef.current, action, { allowEmpty, validate });
       stateRef.current = result.state;
@@ -2751,64 +3701,67 @@ function TextPrompt({
     },
     [allowEmpty, validate, onCancel, onSubmit]
   );
-  (0, import_ink10.useInput)((input, key) => {
+  (0, import_ink13.useInput)((input, key) => {
     const action = getTextPromptInputAction(input, key);
     if (action !== void 0) {
       applyAction(action);
     }
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "yellow", bold: true, children: title }),
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Box, { marginTop: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "cyan", children: "> " }),
-      state.value ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { dimColor: true, children: placeholder }) : null,
-      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "cyan", children: "\u2588" })
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { marginTop: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "cyan", children: "> " }),
+      state.value ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: placeholder }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "cyan", children: "\u2588" })
     ] }),
-    state.error && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "red", children: state.error }),
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { dimColor: true, children: " Enter Submit Esc Cancel" })
+    state.error && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "red", children: state.error }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: " Enter Submit Esc Cancel" })
   ] });
 }
 
-// src/ui/ProviderSetupPrompt.tsx
-var import_jsx_runtime10 = require("react/jsx-runtime");
-function ProviderSetupPrompt({
-  type,
-  providerDefinitions,
+// src/ui/InteractivePrompt.tsx
+var import_jsx_runtime14 = require("react/jsx-runtime");
+function InteractivePrompt({
+  prompt,
   onSubmit,
   onCancel
 }) {
-  const [state, setState] = (0, import_react12.useState)(
-    () => createProviderSetupFlow(type, providerDefinitions)
-  );
-  const step = getProviderSetupStep(state);
-  const handleStepSubmit = (rawValue) => {
-    const result = submitProviderSetupValue(state, rawValue);
-    if (result.status === "next") {
-      setState(result.state);
-      return;
-    }
-    if (result.status === "complete") {
-      onSubmit(result.input);
-    }
-  };
-  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
-    TextPrompt,
-    {
-      title: step.title,
-      placeholder: step.defaultValue,
-      allowEmpty: step.defaultValue !== void 0,
-      masked: step.masked,
-      validate: (value) => validateProviderSetupValue(step, value),
-      onSubmit: handleStepSubmit,
-      onCancel
-    },
-    `${type}-${step.key}`
-  );
+  if (prompt.kind === "text") {
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+      TextPrompt,
+      {
+        title: prompt.title,
+        placeholder: prompt.placeholder,
+        allowEmpty: prompt.allowEmpty,
+        masked: prompt.masked,
+        validate: prompt.validate,
+        onSubmit,
+        onCancel
+      },
+      `text:${prompt.title}`
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink14.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink14.Text, { bold: true, children: prompt.title }),
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+      ListPicker,
+      {
+        items: [...prompt.options],
+        maxVisible: prompt.maxVisible,
+        renderItem: (option, isSelected) => /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink14.Text, { color: isSelected ? "cyan" : void 0, children: [
+          isSelected ? "> " : "  ",
+          option.label
+        ] }),
+        onSelect: (option) => onSubmit(option.value),
+        onCancel
+      }
+    )
+  ] });
 }
 
 // src/ui/PermissionPrompt.tsx
-var import_react13 = __toESM(require("react"), 1);
-var import_ink11 = require("ink");
+var import_react15 = __toESM(require("react"), 1);
+var import_ink15 = require("ink");
 
 // src/ui/flows/permission-prompt-flow.ts
 var PERMISSION_PROMPT_OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
@@ -2859,23 +3812,23 @@ function resolvePermissionIndex(state, index) {
 }
 
 // src/ui/PermissionPrompt.tsx
-var import_jsx_runtime11 = require("react/jsx-runtime");
+var import_jsx_runtime15 = require("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] = import_react13.default.useState(() => createSelectionFlowState());
-  const stateRef = import_react13.default.useRef(state);
-  const prevRequestRef = import_react13.default.useRef(request);
+  const [state, setState] = import_react15.default.useState(() => createSelectionFlowState());
+  const stateRef = import_react15.default.useRef(state);
+  const prevRequestRef = import_react15.default.useRef(request);
   if (prevRequestRef.current !== request) {
     prevRequestRef.current = request;
     const nextState = createSelectionFlowState();
     stateRef.current = nextState;
     setState(nextState);
   }
-  const applyAction = import_react13.default.useCallback(
+  const applyAction = import_react15.default.useCallback(
     (action) => {
       const result = applyPermissionPromptInput(stateRef.current, action);
       stateRef.current = result.state;
@@ -2886,25 +3839,25 @@ function PermissionPrompt({ request }) {
     },
     [request]
   );
-  (0, import_ink11.useInput)((input, key) => {
+  (0, import_ink15.useInput)((input, key) => {
     const action = getPermissionPromptInputAction(input, key);
     if (action !== void 0) {
       applyAction(action);
     }
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { color: "yellow", bold: true, children: "[Permission Required]" }),
-    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink15.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Text, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink15.Text, { children: [
       "Tool:",
       " ",
-      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { color: "cyan", bold: true, children: request.toolName })
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Text, { color: "cyan", bold: true, children: request.toolName })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { dimColor: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink15.Text, { dimColor: true, children: [
       " ",
       formatArgs(request.toolArgs)
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginTop: 1, children: PERMISSION_PROMPT_OPTIONS.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(
-      import_ink11.Text,
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Box, { marginTop: 1, children: PERMISSION_PROMPT_OPTIONS.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+      import_ink15.Text,
       {
         color: i === state.selectedIndex ? "cyan" : void 0,
         bold: i === state.selectedIndex,
@@ -2914,13 +3867,13 @@ function PermissionPrompt({ request }) {
         ]
       }
     ) }, opt)) }),
-    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { dimColor: true, children: " left/right to select, Enter to confirm" })
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Text, { dimColor: true, children: " left/right to select, Enter to confirm" })
   ] });
 }
 
 // src/ui/StreamingIndicator.tsx
-var import_ink12 = require("ink");
-var import_jsx_runtime12 = require("react/jsx-runtime");
+var import_ink16 = require("ink");
+var import_jsx_runtime16 = require("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 };
@@ -2931,16 +3884,16 @@ function StreamingIndicator({ text, activeTools }) {
   const hasTools = activeTools.length > 0;
   const hasText = text.length > 0;
   if (!hasTools && !hasText) {
-    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_jsx_runtime12.Fragment, {});
+    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_jsx_runtime16.Fragment, {});
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", children: [
-    hasTools && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "white", bold: true, children: "Tools:" }),
-      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { children: " " }),
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", children: [
+    hasTools && /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { color: "white", bold: true, children: "Tools:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { children: " " }),
       activeTools.map((t, i) => {
         const { color, icon, strikethrough } = getToolStyle(t);
-        return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", children: [
-          /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Text, { color, strikethrough, children: [
+        return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Text, { color, strikethrough, children: [
             "  ",
             icon,
             " ",
@@ -2949,25 +3902,25 @@ function StreamingIndicator({ text, activeTools }) {
             t.firstArg,
             ")"
           ] }),
-          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(DiffBlock, { file: t.diffFile, lines: t.diffLines })
+          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ToolDiffBlock, { file: t.diffFile, lines: t.diffLines })
         ] }, `${t.toolName}-${i}`);
       })
     ] }),
-    hasText && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "cyan", bold: true, children: "Robota:" }),
-      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { children: " " }),
-      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { wrap: "wrap", children: renderMarkdown(text) }) })
+    hasText && /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { children: " " }),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { wrap: "wrap", children: renderMarkdown(text) }) })
     ] })
   ] });
 }
 
 // src/ui/PluginTUI.tsx
-var import_react16 = require("react");
+var import_react18 = require("react");
 
 // src/ui/MenuSelect.tsx
-var import_react14 = require("react");
-var import_ink13 = require("ink");
-var import_jsx_runtime13 = require("react/jsx-runtime");
+var import_react16 = require("react");
+var import_ink17 = require("ink");
+var import_jsx_runtime17 = require("react/jsx-runtime");
 function MenuSelect({
   title,
   items,
@@ -2976,10 +3929,10 @@ function MenuSelect({
   loading,
   error
 }) {
-  const [state, setState] = (0, import_react14.useState)(() => createSelectionFlowState());
-  const stateRef = (0, import_react14.useRef)(state);
+  const [state, setState] = (0, import_react16.useState)(() => createSelectionFlowState());
+  const stateRef = (0, import_react16.useRef)(state);
   const isEnabled = !loading && !error;
-  const applyAction = (0, import_react14.useCallback)(
+  const applyAction = (0, import_react16.useCallback)(
     (action) => {
       const result = applySelectionInput(stateRef.current, action, {
         itemCount: items.length,
@@ -2998,7 +3951,7 @@ function MenuSelect({
     },
     [isEnabled, items, onBack, onSelect]
   );
-  (0, import_ink13.useInput)((input, key) => {
+  (0, import_ink17.useInput)((input, key) => {
     const action = getVerticalSelectionInputAction(key);
     if (action !== void 0) {
       applyAction(action);
@@ -3009,24 +3962,24 @@ function MenuSelect({
     stateRef.current = normalizedState;
   }
   const selected = normalizedState.selectedIndex;
-  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "yellow", bold: true, children: title }),
-    loading && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: "Loading..." }) }),
-    error && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "red", children: error }),
-      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: "Press Esc to go back" })
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink17.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink17.Text, { color: "yellow", bold: true, children: title }),
+    loading && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink17.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink17.Text, { dimColor: true, children: "Loading..." }) }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink17.Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink17.Text, { color: "red", children: error }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink17.Text, { dimColor: true, children: "Press Esc to go back" })
     ] }),
-    !loading && !error && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Box, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+    !loading && !error && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink17.Box, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink17.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink17.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
         i === selected ? "> " : "  ",
         item.label
       ] }),
-      item.hint && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Text, { dimColor: true, children: [
+      item.hint && /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink17.Text, { dimColor: true, children: [
         " ",
         item.hint
       ] })
     ] }, item.value)) }),
-    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink17.Text, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
   ] });
 }
 
@@ -3123,12 +4076,12 @@ function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
 }
 
 // src/ui/hooks/usePluginScreenData.ts
-var import_react15 = require("react");
+var import_react17 = require("react");
 function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, stackLength) {
-  const [items, setItems] = (0, import_react15.useState)([]);
-  const [loading, setLoading] = (0, import_react15.useState)(false);
-  const [error, setError] = (0, import_react15.useState)();
-  (0, import_react15.useEffect)(() => {
+  const [items, setItems] = (0, import_react17.useState)([]);
+  const [loading, setLoading] = (0, import_react17.useState)(false);
+  const [error, setError] = (0, import_react17.useState)();
+  (0, import_react17.useEffect)(() => {
     setItems([]);
     setError(void 0);
     if (screen === "marketplace-list") {
@@ -3183,16 +4136,16 @@ function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, sta
 }
 
 // src/ui/PluginTUI.tsx
-var import_jsx_runtime14 = require("react/jsx-runtime");
+var import_jsx_runtime18 = require("react/jsx-runtime");
 function PluginTUI({ callbacks, onClose, addMessage }) {
-  const [stack, setStack] = (0, import_react16.useState)([{ screen: "main" }]);
-  const [confirm, setConfirm] = (0, import_react16.useState)();
-  const [refreshCounter, setRefreshCounter] = (0, import_react16.useState)(0);
+  const [stack, setStack] = (0, import_react18.useState)([{ screen: "main" }]);
+  const [confirm, setConfirm] = (0, import_react18.useState)();
+  const [refreshCounter, setRefreshCounter] = (0, import_react18.useState)(0);
   const current = stack[stack.length - 1] ?? { screen: "main" };
-  const push = (0, import_react16.useCallback)((state) => {
+  const push = (0, import_react18.useCallback)((state) => {
     setStack((prev) => [...prev, state]);
   }, []);
-  const pop = (0, import_react16.useCallback)(() => {
+  const pop = (0, import_react18.useCallback)(() => {
     setStack((prev) => {
       if (prev.length <= 1) {
         onClose();
@@ -3201,7 +4154,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       return prev.slice(0, -1);
     });
   }, [onClose]);
-  const popN = (0, import_react16.useCallback)(
+  const popN = (0, import_react18.useCallback)(
     (n) => {
       setStack((prev) => {
         const next = prev.slice(0, Math.max(1, prev.length - n));
@@ -3214,20 +4167,20 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [onClose]
   );
-  const notify = (0, import_react16.useCallback)(
+  const notify = (0, import_react18.useCallback)(
     (content) => {
       addMessage?.({ role: "system", content });
     },
     [addMessage]
   );
-  const refresh = (0, import_react16.useCallback)(() => {
+  const refresh = (0, import_react18.useCallback)(() => {
     setRefreshCounter((c) => c + 1);
   }, []);
-  const setConfirmNav = (0, import_react16.useCallback)(
+  const setConfirmNav = (0, import_react18.useCallback)(
     (state) => setConfirm(state),
     [setConfirm]
   );
-  const pushNav = (0, import_react16.useCallback)(
+  const pushNav = (0, import_react18.useCallback)(
     (state) => push({ screen: state.screen, context: state.context }),
     [push]
   );
@@ -3239,7 +4192,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     refreshCounter,
     stack.length
   );
-  const handleSelect = (0, import_react16.useCallback)(
+  const handleSelect = (0, import_react18.useCallback)(
     (value) => {
       const screen2 = current.screen;
       const ctx = current.context;
@@ -3257,7 +4210,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
   );
-  const handleTextSubmit = (0, import_react16.useCallback)(
+  const handleTextSubmit = (0, import_react18.useCallback)(
     (value) => {
       if (current.screen === "marketplace-add") {
         callbacks.marketplaceAdd(value).then((name) => {
@@ -3272,7 +4225,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     [current.screen, callbacks, notify, pop]
   );
   if (confirm) {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       ConfirmPrompt,
       {
         message: confirm.message,
@@ -3285,7 +4238,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
   }
   const screen = current.screen;
   if (screen === "marketplace-add") {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       TextPrompt,
       {
         title: "Add Marketplace Source",
@@ -3297,7 +4250,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "marketplace-action") {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       MenuSelect,
       {
         title: `Marketplace: ${current.context?.marketplace ?? ""}`,
@@ -3313,7 +4266,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "marketplace-install-scope") {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       MenuSelect,
       {
         title: `Install scope for "${current.context?.pluginId ?? ""}"`,
@@ -3328,7 +4281,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "installed-action") {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       MenuSelect,
       {
         title: `Plugin: ${current.context?.pluginId ?? ""}`,
@@ -3351,7 +4304,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       { label: "Installed Plugins", value: "installed" }
     ]
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
     MenuSelect,
     {
       title: titleMap[screen] ?? "Plugin Management",
@@ -3366,75 +4319,8 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
 }
 
 // src/ui/SessionPicker.tsx
-var import_ink15 = require("ink");
-
-// src/ui/ListPicker.tsx
-var import_react17 = require("react");
-var import_ink14 = require("ink");
-var import_jsx_runtime15 = require("react/jsx-runtime");
-var DEFAULT_MAX_VISIBLE = 3;
-function ListPicker({
-  items,
-  renderItem,
-  onSelect,
-  onCancel,
-  maxVisible = DEFAULT_MAX_VISIBLE
-}) {
-  const [state, setState] = (0, import_react17.useState)(() => createSelectionFlowState());
-  const stateRef = (0, import_react17.useRef)(state);
-  const applyAction = (0, import_react17.useCallback)(
-    (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]
-  );
-  (0, import_ink14.useInput)((_input, key) => {
-    const action = getVerticalSelectionInputAction(key);
-    if (action !== void 0) {
-      applyAction(action);
-    }
-  });
-  if (items.length === 0) {
-    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, {});
-  }
-  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__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Box, { flexDirection: "column", children: [
-    hasLess && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { dimColor: true, children: [
-      " \u2191 ",
-      scrollOffset,
-      " more above"
-    ] }),
-    visibleItems.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
-    hasMore && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { dimColor: true, children: [
-      " \u2193 ",
-      items.length - scrollOffset - maxVisible,
-      " more below"
-    ] })
-  ] });
-}
-
-// src/ui/SessionPicker.tsx
-var import_jsx_runtime16 = require("react/jsx-runtime");
+var import_ink18 = require("ink");
+var import_jsx_runtime19 = require("react/jsx-runtime");
 var SESSION_ID_DISPLAY_LENGTH = 8;
 function SessionPicker({
   sessionStore,
@@ -3443,9 +4329,9 @@ function SessionPicker({
   onCancel
 }) {
   const sessions = (sessionStore?.list() ?? []).filter((s) => s.cwd === cwd);
-  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink15.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_ink18.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_ink18.Text, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
       ListPicker,
       {
         items: sessions,
@@ -3456,24 +4342,24 @@ function SessionPicker({
           });
           const rawPreview = lastMsg?.content?.replace(/[\n\r]+/g, " ").trim() ?? "";
           const preview = rawPreview ? rawPreview.slice(0, 60) + (rawPreview.length > 60 ? "..." : "") : "";
-          return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink15.Text, { children: [
+          return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_ink18.Text, { children: [
             isSelected ? "> " : "  ",
-            /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
+            /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_ink18.Text, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
             "  ",
-            /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
+            /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_ink18.Text, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
               month: "short",
               day: "numeric",
               hour: "2-digit",
               minute: "2-digit"
             }) }),
             "  ",
-            /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink15.Text, { dimColor: true, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_ink18.Text, { dimColor: true, children: [
               "msgs: ",
               session.messages.length
             ] }),
-            preview ? /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_jsx_runtime16.Fragment, { children: [
+            preview ? /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_jsx_runtime19.Fragment, { children: [
               "\n    ",
-              /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { color: "gray", children: preview })
+              /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_ink18.Text, { color: "gray", children: preview })
             ] }) : null
           ] });
         },
@@ -3485,54 +4371,382 @@ function SessionPicker({
 }
 
 // src/ui/BackgroundTaskPanel.tsx
-var import_ink16 = require("ink");
-var import_jsx_runtime17 = require("react/jsx-runtime");
+var import_ink19 = require("ink");
+
+// src/ui/background-task-row-format.ts
 var MS_PER_SECOND = 1e3;
 var SECONDS_PER_MINUTE = 60;
 var MINUTES_PER_HOUR = 60;
-function getStatusColor(status) {
-  if (status === "completed") return "green";
-  if (status === "failed") return "red";
-  if (status === "cancelled") return "yellow";
+var SUCCESS_EXIT_CODE3 = 0;
+function formatBackgroundTaskRow(task, options = {}) {
+  const row = {
+    connector: options.isLast === false ? "\u251C" : "\u2514",
+    marker: getStatusMarker(task),
+    color: getStatusColor(task),
+    label: getTaskLabel(task),
+    segments: getTaskSegments(task, options.now ?? Date.now()),
+    preview: getTaskPreview(task)
+  };
+  return {
+    ...row,
+    accessibleText: formatAccessibleText(row)
+  };
+}
+function getStatusColor(task) {
+  if (isFailedTask(task)) return "red";
+  if (task.status === "completed") return "green";
+  if (task.status === "cancelled") return "yellow";
   return "cyan";
 }
-function getStatusMarker(status) {
-  if (status === "queued" || status === "running") return "\u25A1";
+function getStatusMarker(task) {
+  if (task.status === "queued" || task.status === "running") return "\u25A1";
   return "\u25A0";
 }
+function getTaskLabel(task) {
+  if (task.kind === "agent") return `${task.label} agent`;
+  if (task.kind === "process") return task.label || "Process";
+  return task.label;
+}
+function getTaskSegments(task, now) {
+  const segments = [];
+  if (task.status === "running") {
+    const idle = formatAge(task.lastActivityAt, now);
+    if (idle) segments.push(`idle ${idle}`);
+  }
+  if (task.status === "failed") {
+    segments.push(task.statusLabel === "timed out" ? "timed out" : "failed");
+  }
+  if (task.status === "cancelled") {
+    segments.push("cancelled");
+  }
+  if (task.timeoutReason) {
+    segments.push(task.timeoutReason);
+  }
+  if (task.status === "completed" && task.exitCode !== void 0 && task.exitCode !== SUCCESS_EXIT_CODE3) {
+    segments.push(`exit ${task.exitCode}`);
+  }
+  if (task.signalCode) {
+    segments.push(`signal ${task.signalCode}`);
+  }
+  return segments;
+}
 function getTaskPreview(task) {
-  return task.errorPreview ?? task.resultPreview ?? task.currentAction ?? task.preview;
+  const preview = task.errorPreview ?? task.resultPreview ?? task.currentAction ?? task.preview;
+  return preview || void 0;
 }
-function formatAge(iso) {
+function formatAge(iso, now) {
   if (!iso) return void 0;
   const timestamp = Date.parse(iso);
   if (Number.isNaN(timestamp)) return void 0;
-  const seconds = Math.max(0, Math.floor((Date.now() - timestamp) / MS_PER_SECOND));
+  const seconds = Math.max(0, Math.floor((now - timestamp) / MS_PER_SECOND));
   if (seconds < SECONDS_PER_MINUTE) return `${seconds}s`;
   const minutes = Math.floor(seconds / SECONDS_PER_MINUTE);
   if (minutes < MINUTES_PER_HOUR) return `${minutes}m`;
   return `${Math.floor(minutes / MINUTES_PER_HOUR)}h`;
 }
+function isFailedTask(task) {
+  return task.status === "failed" || task.status === "completed" && (task.exitCode !== void 0 && task.exitCode !== SUCCESS_EXIT_CODE3 || !!task.signalCode);
+}
+function formatAccessibleText(row) {
+  const parts = [`${row.connector} ${row.marker} ${row.label}`, ...row.segments];
+  if (row.preview) parts.push(row.preview);
+  return parts.join(" \xB7 ");
+}
+
+// src/ui/BackgroundTaskPanel.tsx
+var import_jsx_runtime20 = require("react/jsx-runtime");
 function BackgroundTaskPanel({ tasks }) {
   if (tasks.length === 0) return null;
-  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { color: "cyan", bold: true, children: "Background" }),
-    tasks.map((task) => /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink16.Text, { children: [
-      "- ",
-      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { color: getStatusColor(task.status), children: getStatusMarker(task.status) }),
-      ` ${task.kind}:${task.label} ${task.id}`,
-      task.status === "running" && formatAge(task.lastActivityAt) ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { dimColor: true, children: ` idle ${formatAge(task.lastActivityAt)}` }) : null,
-      task.timeoutReason ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { dimColor: true, children: ` (${task.timeoutReason})` }) : null,
-      getTaskPreview(task) ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { dimColor: true, children: ` - ${getTaskPreview(task)}` }) : null
-    ] }, task.id))
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_ink19.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { color: "cyan", bold: true, children: "Background work" }),
+    tasks.map((task, index) => {
+      const row = formatBackgroundTaskRow(task, { isLast: index === tasks.length - 1 });
+      return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_ink19.Text, { children: [
+        `${row.connector} `,
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { color: row.color, children: row.marker }),
+        ` ${row.label}`,
+        row.segments.map((segment, segmentIndex) => /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { dimColor: true, children: ` \xB7 ${segment}` }, `${segment}-${segmentIndex}`)),
+        row.preview ? /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { dimColor: true, children: ` \xB7 ${row.preview}` }) : null
+      ] }, task.id);
+    })
   ] });
 }
 
+// src/ui/UpdateNotice.tsx
+var import_ink20 = require("ink");
+var import_jsx_runtime21 = require("react/jsx-runtime");
+function UpdateNotice({ message }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Box, { paddingX: 1, marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { color: "yellow", children: message }) });
+}
+
+// src/utils/update-check.ts
+var import_node_fs5 = require("fs");
+var import_node_path7 = require("path");
+
+// src/utils/semver-compare.ts
+function compareSemverVersions(left, right) {
+  const parsedLeft = parseSemver(left);
+  const parsedRight = parseSemver(right);
+  if (parsedLeft === void 0 || parsedRight === void 0) {
+    return Math.sign(left.localeCompare(right));
+  }
+  const coreCompare = compareNumber(parsedLeft.major, parsedRight.major) || compareNumber(parsedLeft.minor, parsedRight.minor) || compareNumber(parsedLeft.patch, parsedRight.patch);
+  if (coreCompare !== 0) {
+    return coreCompare;
+  }
+  return comparePrerelease(parsedLeft.prerelease, parsedRight.prerelease);
+}
+function isNewerSemverVersion(candidate, current) {
+  return compareSemverVersions(candidate, current) > 0;
+}
+function parseSemver(value) {
+  const normalized = value.trim().replace(/^v/, "").split("+")[0] ?? "";
+  const [core, prereleaseText] = normalized.split("-", 2);
+  const [majorText, minorText, patchText] = core.split(".");
+  const major = parseNumericIdentifier(majorText);
+  const minor = parseNumericIdentifier(minorText);
+  const patch = parseNumericIdentifier(patchText);
+  if (major === void 0 || minor === void 0 || patch === void 0) {
+    return void 0;
+  }
+  return {
+    major,
+    minor,
+    patch,
+    prerelease: prereleaseText ? prereleaseText.split(".") : []
+  };
+}
+function parseNumericIdentifier(value) {
+  if (value === void 0 || !/^\d+$/.test(value)) {
+    return void 0;
+  }
+  return Number(value);
+}
+function compareNumber(left, right) {
+  return Math.sign(left - right);
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 && right.length === 0) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return 1;
+  }
+  if (right.length === 0) {
+    return -1;
+  }
+  const max = Math.max(left.length, right.length);
+  for (let index = 0; index < max; index += 1) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+    if (leftPart === void 0) {
+      return -1;
+    }
+    if (rightPart === void 0) {
+      return 1;
+    }
+    const partCompare = comparePrereleaseIdentifier(leftPart, rightPart);
+    if (partCompare !== 0) {
+      return partCompare;
+    }
+  }
+  return 0;
+}
+function comparePrereleaseIdentifier(left, right) {
+  const leftNumber = parseNumericIdentifier(left);
+  const rightNumber = parseNumericIdentifier(right);
+  if (leftNumber !== void 0 && rightNumber !== void 0) {
+    return compareNumber(leftNumber, rightNumber);
+  }
+  if (leftNumber !== void 0) {
+    return -1;
+  }
+  if (rightNumber !== void 0) {
+    return 1;
+  }
+  return Math.sign(left.localeCompare(right));
+}
+
+// src/utils/update-check.ts
+var CLI_UPDATE_PACKAGE_NAME = "@robota-sdk/agent-cli";
+var CLI_UPDATE_REGISTRY_URL = "https://registry.npmjs.org";
+var HOURS_PER_DAY = 24;
+var MINUTES_PER_HOUR2 = 60;
+var SECONDS_PER_MINUTE2 = 60;
+var MS_PER_SECOND2 = 1e3;
+var CLI_UPDATE_CACHE_TTL_MS = HOURS_PER_DAY * MINUTES_PER_HOUR2 * SECONDS_PER_MINUTE2 * MS_PER_SECOND2;
+var CLI_UPDATE_TIMEOUT_MS = 1500;
+var DEFAULT_INSTALL_COMMAND = "npm install -g '@robota-sdk/agent-cli@latest'";
+function getUserUpdateCheckCachePath(home = process.env.HOME ?? process.env.USERPROFILE ?? "/") {
+  return (0, import_node_path7.join)(home, ".robota", "update-check.json");
+}
+function readUpdateCheckCache(path) {
+  if (!(0, import_node_fs5.existsSync)(path)) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(path, "utf8"));
+    return parseUpdateCheckCache(parsed);
+  } catch {
+    return void 0;
+  }
+}
+function writeUpdateCheckCache(path, cache) {
+  (0, import_node_fs5.mkdirSync)((0, import_node_path7.dirname)(path), { recursive: true });
+  (0, import_node_fs5.writeFileSync)(path, JSON.stringify(cache, null, 2) + "\n", "utf8");
+}
+async function checkForCliUpdate(options) {
+  if (options.disabled === true) {
+    return { status: "skipped", reason: "disabled" };
+  }
+  const packageName = options.packageName ?? CLI_UPDATE_PACKAGE_NAME;
+  const cachePath = options.cachePath ?? getUserUpdateCheckCachePath();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const ttlMs = options.ttlMs ?? CLI_UPDATE_CACHE_TTL_MS;
+  if (options.force !== true) {
+    const cached = readUpdateCheckCache(cachePath);
+    if (cached !== void 0 && isFreshCache(cached, now, ttlMs, packageName)) {
+      return resultFromCache(cached, options.currentVersion);
+    }
+  }
+  try {
+    const latestVersion = await fetchLatestVersion({
+      fetchImpl: options.fetchImpl ?? fetch,
+      packageName,
+      registryUrl: options.registryUrl ?? CLI_UPDATE_REGISTRY_URL,
+      timeoutMs: options.timeoutMs ?? CLI_UPDATE_TIMEOUT_MS
+    });
+    tryWriteUpdateCheckCache(cachePath, {
+      packageName,
+      checkedAt: now.toISOString(),
+      currentVersion: options.currentVersion,
+      latestVersion
+    });
+    return resultFromLatestVersion(options.currentVersion, latestVersion);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    tryWriteUpdateCheckCache(cachePath, {
+      packageName,
+      checkedAt: now.toISOString(),
+      currentVersion: options.currentVersion,
+      errorMessage
+    });
+    return { status: "error", errorMessage };
+  }
+}
+function tryWriteUpdateCheckCache(path, cache) {
+  try {
+    writeUpdateCheckCache(path, cache);
+  } catch {
+  }
+}
+async function getStartupCliUpdateNotice(options) {
+  const result = await checkForCliUpdate(options);
+  return result.status === "update_available" ? result.notice : void 0;
+}
+function shouldRunStartupCliUpdateCheck(input) {
+  return input.printMode === false && input.disableUpdateCheck === false;
+}
+function formatCliUpdateNotice(notice) {
+  return [
+    `Robota update available: ${notice.currentVersion} -> ${notice.latestVersion}.`,
+    `Run ${notice.installCommand}`
+  ].join(" ");
+}
+function formatCliUpdateCheckMessage(result) {
+  if (result.status === "update_available") {
+    return formatCliUpdateNotice(result.notice);
+  }
+  if (result.status === "current") {
+    return `Robota is up to date (${result.currentVersion}).`;
+  }
+  if (result.status === "skipped") {
+    return "Robota update check skipped.";
+  }
+  return `Robota update check failed: ${result.errorMessage}`;
+}
+function resultFromCache(cache, currentVersion) {
+  if (cache.errorMessage !== void 0) {
+    return { status: "error", errorMessage: cache.errorMessage };
+  }
+  if (cache.latestVersion === void 0) {
+    return { status: "error", errorMessage: "Cached update check has no latest version" };
+  }
+  return resultFromLatestVersion(currentVersion, cache.latestVersion);
+}
+function resultFromLatestVersion(currentVersion, latestVersion) {
+  if (isNewerSemverVersion(latestVersion, currentVersion)) {
+    return {
+      status: "update_available",
+      notice: {
+        currentVersion,
+        latestVersion,
+        installCommand: DEFAULT_INSTALL_COMMAND
+      }
+    };
+  }
+  return { status: "current", currentVersion, latestVersion };
+}
+function isFreshCache(cache, now, ttlMs, packageName) {
+  if (cache.packageName !== packageName) {
+    return false;
+  }
+  const checkedAt = Date.parse(cache.checkedAt);
+  if (!Number.isFinite(checkedAt)) {
+    return false;
+  }
+  return now.getTime() - checkedAt < ttlMs;
+}
+async function fetchLatestVersion(options) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+  try {
+    const packageUrl = buildPackageMetadataUrl(options.registryUrl, options.packageName);
+    const response = await options.fetchImpl(packageUrl, {
+      headers: { accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`registry responded with HTTP ${response.status}`);
+    }
+    const metadata = await response.json();
+    const latest = metadata["dist-tags"]?.latest;
+    if (typeof latest !== "string" || latest.trim().length === 0) {
+      throw new Error("registry metadata is missing dist-tags.latest");
+    }
+    return latest;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function buildPackageMetadataUrl(registryUrl, packageName) {
+  return `${registryUrl.replace(/\/+$/, "")}/${encodeURIComponent(packageName)}`;
+}
+function parseUpdateCheckCache(value) {
+  if (!isJsonObject(value)) {
+    return void 0;
+  }
+  const candidate = value;
+  if (typeof candidate.packageName === "string" && typeof candidate.checkedAt === "string" && typeof candidate.currentVersion === "string" && (candidate.latestVersion === void 0 || typeof candidate.latestVersion === "string") && (candidate.errorMessage === void 0 || typeof candidate.errorMessage === "string")) {
+    return {
+      packageName: candidate.packageName,
+      checkedAt: candidate.checkedAt,
+      currentVersion: candidate.currentVersion,
+      ...candidate.latestVersion !== void 0 && { latestVersion: candidate.latestVersion },
+      ...candidate.errorMessage !== void 0 && { errorMessage: candidate.errorMessage }
+    };
+  }
+  return void 0;
+}
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/ui/App.tsx
-var import_jsx_runtime18 = require("react/jsx-runtime");
+var import_jsx_runtime22 = require("react/jsx-runtime");
 function App(props) {
-  const [activeSessionId, setActiveSessionId] = (0, import_react18.useState)(props.resumeSessionId);
-  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+  const [activeSessionId, setActiveSessionId] = (0, import_react19.useState)(props.resumeSessionId);
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
     AppInner,
     {
       ...props,
@@ -3544,7 +4758,7 @@ function App(props) {
 }
 function AppInner(props) {
   const cwd = props.cwd;
-  const providerDefinitions = props.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  const providerDefinitions = props.providerDefinitions ?? [];
   const {
     interactiveSession,
     registry,
@@ -3578,47 +4792,65 @@ function AppInner(props) {
     providerDefinitions
   });
   const pluginCallbacks = usePluginCallbacks(cwd);
-  const { exit } = (0, import_ink17.useApp)();
-  const [sessionName, setSessionName] = (0, import_react18.useState)(props.sessionName);
+  const { exit } = (0, import_ink21.useApp)();
+  const [sessionName, setSessionName] = (0, import_react19.useState)(props.sessionName);
+  const [updateNotice, setUpdateNotice] = (0, import_react19.useState)();
+  const [statusLineSettings, setStatusLineSettings] = useStatusLineSettings();
+  const activeBackgroundTaskCount = backgroundTasks.filter(
+    (task) => task.status === "queued" || task.status === "running"
+  ).length;
   const {
     handleSubmit,
     pendingModelId,
     pendingProviderProfile,
-    pendingProviderSetupType,
+    pendingInteractionPrompt,
     showPluginTUI,
     showSessionPicker,
     setShowPluginTUI,
     setShowSessionPicker,
     handleModelConfirm,
     handleProviderConfirm,
-    handleProviderSetupSubmit,
-    handleProviderSetupCancel
+    handleInteractionSubmit,
+    handleInteractionCancel
   } = useSideEffects({
     cwd,
     interactiveSession,
     addEntry,
     baseHandleSubmit,
     setSessionName,
+    setStatusLineSettings,
     providerDefinitions
   });
-  (0, import_react18.useEffect)(() => {
+  (0, import_react19.useEffect)(() => {
     const name = interactiveSession?.getName?.();
     if (name && !sessionName) setSessionName(name);
   }, [interactiveSession, sessionName]);
-  (0, import_react18.useEffect)(() => {
+  (0, import_react19.useEffect)(() => {
+    let isMounted = true;
+    props.startupUpdateNoticePromise?.then((notice) => {
+      if (isMounted && notice !== void 0) {
+        setUpdateNotice(notice);
+      }
+    }).catch(() => {
+    });
+    return () => {
+      isMounted = false;
+    };
+  }, [props.startupUpdateNoticePromise]);
+  (0, import_react19.useEffect)(() => {
     const title = sessionName ? `Robota \u2014 ${sessionName}` : "Robota";
     process.stdout.write(`\x1B]0;${title}\x07`);
   }, [sessionName]);
-  (0, import_ink17.useInput)((_input, key) => {
+  (0, import_ink21.useInput)((_input, key) => {
     if (!key.escape || !isThinking) return;
     if (permissionRequest || showPluginTUI || showSessionPicker) return;
     handleAbort();
   });
-  (0, import_ink17.useInput)((input, key) => {
+  (0, import_ink21.useInput)((input, key) => {
     if (!key.ctrl || input !== "c" || isShuttingDown) return;
     void handleShutdown("prompt_input_exit").finally(() => exit());
   });
-  (0, import_react18.useEffect)(() => {
+  (0, import_react19.useEffect)(() => {
     const onSigterm = () => {
       if (isShuttingDown) return;
       void handleShutdown("other").finally(() => exit());
@@ -3638,59 +4870,59 @@ function AppInner(props) {
     sessionId = session.getSessionId();
   } catch {
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Text, { color: "cyan", bold: true, children: `
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: "cyan", bold: true, children: `
   ____   ___  ____   ___ _____  _
  |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
  | |_) | | | |  _ \\| | | || | / _ \\
  |  _ <| |_| | |_) | |_| || |/ ___ \\
  |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
 ` }),
-      /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Text, { dimColor: true, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Text, { dimColor: true, children: [
         " v",
         props.version ?? "0.0.0"
       ] })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(MessageList, { history }),
-      isShuttingDown && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Text, { color: "yellow", children: "Shutting down..." }) }),
-      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(StreamingIndicator, { text: streamingText, activeTools }) }),
-      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(BackgroundTaskPanel, { tasks: backgroundTasks })
+    updateNotice && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(UpdateNotice, { message: formatCliUpdateNotice(updateNotice) }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(MessageList, { history }),
+      isShuttingDown && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: "yellow", children: "Shutting down..." }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(StreamingIndicator, { text: streamingText, activeTools }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(BackgroundTaskPanel, { tasks: backgroundTasks })
     ] }),
-    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(PermissionPrompt, { request: permissionRequest }),
-    pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
       ConfirmPrompt,
       {
-        message: `Change model to ${(0, import_agent_core7.getModelName)(pendingModelId)}? This will restart the session.`,
+        message: `Change model to ${(0, import_agent_core9.getModelName)(pendingModelId)}? This will restart the session.`,
         onSelect: handleModelConfirm
       }
     ),
-    pendingProviderProfile && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    pendingProviderProfile && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
       ConfirmPrompt,
       {
         message: `Change provider to ${pendingProviderProfile}? This will restart the session.`,
         onSelect: handleProviderConfirm
       }
     ),
-    pendingProviderSetupType && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
-      ProviderSetupPrompt,
+    pendingInteractionPrompt && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+      InteractivePrompt,
       {
-        type: pendingProviderSetupType,
-        providerDefinitions,
-        onSubmit: handleProviderSetupSubmit,
-        onCancel: handleProviderSetupCancel
+        prompt: pendingInteractionPrompt,
+        onSubmit: handleInteractionSubmit,
+        onCancel: handleInteractionCancel
       }
     ),
-    showPluginTUI && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    showPluginTUI && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
       PluginTUI,
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addEntry((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(msg.content)))
+        addMessage: (msg) => addEntry((0, import_agent_core9.messageToHistoryEntry)((0, import_agent_core9.createSystemMessage)(msg.content)))
       }
     ),
-    showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
       SessionPicker,
       {
         sessionStore: props.sessionStore,
@@ -3701,42 +4933,46 @@ function AppInner(props) {
         },
         onCancel: () => {
           setShowSessionPicker(false);
-          addEntry((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)("Session resume cancelled.")));
+          addEntry((0, import_agent_core9.messageToHistoryEntry)((0, import_agent_core9.createSystemMessage)("Session resume cancelled.")));
         }
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
-      StatusBar,
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+      SessionStatusBar,
       {
+        cwd,
         permissionMode,
-        modelName: props.modelId ? (0, import_agent_core7.getModelName)(props.modelId) : "",
+        modelId: props.modelId,
         sessionId,
         messageCount: history.length,
         isThinking,
-        contextPercentage: contextState.percentage,
-        contextUsedTokens: contextState.usedTokens,
-        contextMaxTokens: contextState.maxTokens,
-        sessionName
+        activeToolCount: activeTools.length,
+        activeBackgroundTaskCount,
+        hasPendingPrompt: pendingPrompt !== null,
+        contextState,
+        sessionName,
+        settings: statusLineSettings
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
       InputArea,
       {
         onSubmit: handleSubmit,
         onCancelQueue: handleCancelQueue,
-        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || isShuttingDown || !!pendingProviderSetupType || isThinking && !!pendingPrompt,
+        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || isShuttingDown || pendingInteractionPrompt !== null || isThinking && !!pendingPrompt,
         isAborting,
         pendingPrompt,
         registry,
-        sessionName
+        sessionName,
+        history
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Text, { children: " " })
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { children: " " })
   ] });
 }
 
 // src/ui/render.tsx
-var import_jsx_runtime19 = require("react/jsx-runtime");
+var import_jsx_runtime23 = require("react/jsx-runtime");
 function renderApp(options) {
   process.on("unhandledRejection", (reason) => {
     process.stderr.write(`
@@ -3747,16 +4983,10 @@ function renderApp(options) {
 `);
     }
   });
-  if (process.stdin.isTTY && process.stdout.isTTY) {
-    process.stdout.write("\x1B[?2004h");
-  }
-  const instance = (0, import_ink18.render)(/* @__PURE__ */ (0, import_jsx_runtime19.jsx)(App, { ...options }), {
+  const instance = (0, import_ink22.render)(/* @__PURE__ */ (0, import_jsx_runtime23.jsx)(App, { ...options }), {
     exitOnCtrlC: false
   });
   instance.waitUntilExit().then(() => {
-    if (process.stdout.isTTY) {
-      process.stdout.write("\x1B[?2004l");
-    }
     process.exit(0);
   }).catch((err) => {
     if (err) {
@@ -3806,7 +5036,7 @@ function resolveShell(request) {
   return { command: request.shell ?? "sh", args: ["-c", request.command] };
 }
 function sendInput(child, input) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const onError = (error) => {
       child.stdin.off("error", onError);
       reject(error);
@@ -3814,7 +5044,7 @@ function sendInput(child, input) {
     child.stdin.once("error", onError);
     child.stdin.end(input, () => {
       child.stdin.off("error", onError);
-      resolve();
+      resolve2();
     });
   });
 }
@@ -3849,7 +5079,7 @@ function startProcessTask(taskId, request, killGraceMs) {
 }
 function createProcessResult(runtime) {
   let settled = false;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const timeoutTimer = runtime.request.timeoutMs ? setTimeout(() => {
       appendLog(runtime.logs, "system", `timed out after ${runtime.request.timeoutMs}ms`);
       runtime.child.kill("SIGTERM");
@@ -3863,7 +5093,7 @@ function createProcessResult(runtime) {
       if (settled) return;
       settled = true;
       clearTimers();
-      resolve({
+      resolve2({
         taskId: runtime.taskId,
         kind: "process",
         output: runtime.capture.getOutput(),
@@ -3938,22 +5168,22 @@ function readProcessLog(runtime, cursor) {
 
 // src/subagents/child-process-subagent-runner.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs5 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path9 = require("path");
 var import_agent_sdk7 = require("@robota-sdk/agent-sdk");
 
 // src/subagents/child-process-subagent-runner-result.ts
 var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
 
 // src/subagents/child-process-subagent-ipc.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function hasString(value, key) {
   return typeof value[key] === "string";
 }
 function isSubagentWorkerChildMessage(value) {
-  if (!isRecord(value) || !hasString(value, "type")) return false;
+  if (!isRecord2(value) || !hasString(value, "type")) return false;
   switch (value.type) {
     case "ready":
       return true;
@@ -4018,7 +5248,7 @@ function extractFirstArg(toolArgs) {
   return typeof firstValue === "object" ? JSON.stringify(firstValue) : String(firstValue);
 }
 function sendWorkerMessage(child, message) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (!child.connected) {
       reject(new import_agent_sdk4.BackgroundTaskError("crash", "Subagent worker IPC channel is closed"));
       return;
@@ -4028,7 +5258,7 @@ function sendWorkerMessage(child, message) {
         reject(error);
         return;
       }
-      resolve();
+      resolve2();
     });
   });
 }
@@ -4045,14 +5275,14 @@ async function cancelChildProcess(runtime, reason) {
 
 // src/subagents/child-process-subagent-runner-result.ts
 function createChildProcessSubagentResult(options) {
-  return new Promise((resolve, reject) => {
-    new ChildProcessSubagentResultController(options, resolve, reject).start();
+  return new Promise((resolve2, reject) => {
+    new ChildProcessSubagentResultController(options, resolve2, reject).start();
   });
 }
 var ChildProcessSubagentResultController = class {
-  constructor(options, resolve, reject) {
+  constructor(options, resolve2, reject) {
     this.options = options;
-    this.resolve = resolve;
+    this.resolve = resolve2;
     this.reject = reject;
     this.timeoutTimer = createTimeoutTimer(this.options.runtime, (error) => this.rejectOnce(error));
   }
@@ -4160,8 +5390,8 @@ function formatEarlyExitMessage(code, signal) {
 // src/subagents/git-worktree-isolation-adapter.ts
 var import_node_child_process2 = require("child_process");
 var import_node_crypto2 = require("crypto");
-var import_node_fs4 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path8 = require("path");
 var import_agent_sdk6 = require("@robota-sdk/agent-sdk");
 var WORKTREE_DIR = ".robota/worktrees";
 var BRANCH_PREFIX = "robota";
@@ -4181,9 +5411,9 @@ var GitWorktreeIsolationAdapter = class {
     const repoRoot = runGit(request.cwd, ["rev-parse", "--show-toplevel"]).trim();
     const shortId = (0, import_node_crypto2.randomUUID)().slice(0, SHORT_ID_LENGTH);
     const branchName = `${this.branchPrefix}/${request.jobId}-${shortId}`;
-    const worktreeRoot = (0, import_node_path6.join)(repoRoot, this.worktreeDir);
-    const worktreePath = (0, import_node_path6.join)(worktreeRoot, `${request.jobId}-${shortId}`);
-    (0, import_node_fs4.mkdirSync)(worktreeRoot, { recursive: true });
+    const worktreeRoot = (0, import_node_path8.join)(repoRoot, this.worktreeDir);
+    const worktreePath = (0, import_node_path8.join)(worktreeRoot, `${request.jobId}-${shortId}`);
+    (0, import_node_fs6.mkdirSync)(worktreeRoot, { recursive: true });
     runGit(repoRoot, ["worktree", "add", "-b", branchName, worktreePath, "HEAD"]);
     return { repoRoot, worktreePath, branchName };
   }
@@ -4293,7 +5523,7 @@ var ChildProcessSubagentRunner = class {
   }
   resolveTranscriptPath(job) {
     if (!this.logsDir) return void 0;
-    return (0, import_node_path7.join)(this.logsDir, job.request.parentSessionId, "subagents", `${job.jobId}.jsonl`);
+    return (0, import_node_path9.join)(this.logsDir, job.request.parentSessionId, "subagents", `${job.jobId}.jsonl`);
   }
 };
 function resolveAgentDefinition(agentType, customRegistry) {
@@ -4319,19 +5549,20 @@ function createProviderProfile(providerConfig, deps, job) {
     model: job.request.model ?? provider.model,
     apiKey: provider.apiKey,
     baseURL: provider.baseURL,
-    timeout: provider.timeout
+    timeout: provider.timeout,
+    options: provider.options
   };
 }
 function resolveDefaultWorkerPath() {
   const entryPoint = process.argv[1] ?? "";
-  const entryDir = entryPoint ? (0, import_node_path7.dirname)(entryPoint) : process.cwd();
+  const entryDir = entryPoint ? (0, import_node_path9.dirname)(entryPoint) : process.cwd();
   const extension = entryPoint.endsWith(".ts") || entryPoint.endsWith(".tsx") ? ".ts" : ".js";
   const candidates = [
-    (0, import_node_path7.join)(entryDir, "subagents", `child-process-subagent-worker${extension}`),
-    (0, import_node_path7.join)(entryDir, `child-process-subagent-worker${extension}`)
+    (0, import_node_path9.join)(entryDir, "subagents", `child-process-subagent-worker${extension}`),
+    (0, import_node_path9.join)(entryDir, `child-process-subagent-worker${extension}`)
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs5.existsSync)(candidate)) {
+    if ((0, import_node_fs7.existsSync)(candidate)) {
       return candidate;
     }
   }
@@ -4348,14 +5579,14 @@ function resolveDefaultExecArgv(workerPath) {
 }
 function readTranscriptLog(jobId, transcriptPath, cursor) {
   const offset = cursor?.offset ?? 0;
-  if (!(0, import_node_fs5.existsSync)(transcriptPath)) {
+  if (!(0, import_node_fs7.existsSync)(transcriptPath)) {
     return {
       taskId: jobId,
       cursor,
       lines: []
     };
   }
-  const lines = (0, import_node_fs5.readFileSync)(transcriptPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const lines = (0, import_node_fs7.readFileSync)(transcriptPath, "utf8").split(/\r?\n/).filter(Boolean);
   const nextOffset = Math.min(offset + LOG_PAGE_SIZE2, lines.length);
   return {
     taskId: jobId,
@@ -4365,16 +5596,103 @@ function readTranscriptLog(jobId, transcriptPath, cursor) {
   };
 }
 
+// src/commands/statusline-command-module.ts
+var USAGE = [
+  "Usage: /statusline on | off | reset | git on | git off",
+  "Fields: model, context, permission mode, message count, session name, thinking state, git branch."
+].join("\n");
+function createStatusLineEntry() {
+  return {
+    name: "statusline",
+    description: "Configure TUI status-line visibility and fields such as model, context, tokens, session, and git branch.",
+    source: "cli",
+    modelInvocable: false,
+    argumentHint: "on | off | reset | git on | git off",
+    subcommands: [
+      { name: "on", description: "Show the status line", source: "cli" },
+      { name: "off", description: "Hide the status line", source: "cli" },
+      { name: "reset", description: "Restore default status-line fields", source: "cli" },
+      { name: "git", description: "Show or hide git branch field", source: "cli" }
+    ]
+  };
+}
+function parseStatusLineArgs(args) {
+  const parts = args.trim().toLowerCase().split(/\s+/).filter((part) => part.length > 0);
+  const [first, second] = parts;
+  if (first === "on" && second === void 0) {
+    return { success: true, message: "Status line enabled.", patch: { enabled: true } };
+  }
+  if (first === "off" && second === void 0) {
+    return { success: true, message: "Status line disabled.", patch: { enabled: false } };
+  }
+  if (first === "reset" && second === void 0) {
+    return {
+      success: true,
+      message: "Status line settings reset.",
+      patch: { enabled: true, gitBranch: true }
+    };
+  }
+  if (first === "git" && second === "on" && parts.length === 2) {
+    return {
+      success: true,
+      message: "Status line git branch shown.",
+      patch: { gitBranch: true }
+    };
+  }
+  if (first === "git" && second === "off" && parts.length === 2) {
+    return {
+      success: true,
+      message: "Status line git branch hidden.",
+      patch: { gitBranch: false }
+    };
+  }
+  return { success: false, message: USAGE };
+}
+function createStatusLineSystemCommand() {
+  const entry = createStatusLineEntry();
+  return {
+    name: entry.name,
+    description: entry.description,
+    modelInvocable: false,
+    userInvocable: true,
+    argumentHint: entry.argumentHint,
+    execute: (_session, args) => {
+      const action = parseStatusLineArgs(args);
+      if (!action.success) {
+        return { success: false, message: action.message };
+      }
+      return {
+        success: true,
+        message: action.message,
+        data: { statuslinePatch: action.patch }
+      };
+    }
+  };
+}
+var StatusLineCommandSource = class {
+  name = "cli-statusline";
+  getCommands() {
+    return [createStatusLineEntry()];
+  }
+};
+function createStatusLineCommandModule() {
+  return {
+    name: "cli-statusline",
+    commandSources: [new StatusLineCommandSource()],
+    systemCommands: [createStatusLineSystemCommand()]
+  };
+}
+
 // src/cli.ts
 var import_meta = {};
 function readVersion() {
   try {
     const thisFile = (0, import_node_url.fileURLToPath)(import_meta.url);
-    const dir = (0, import_node_path8.dirname)(thisFile);
-    const candidates = [(0, import_node_path8.join)(dir, "..", "..", "package.json"), (0, import_node_path8.join)(dir, "..", "package.json")];
+    const dir = (0, import_node_path10.dirname)(thisFile);
+    const candidates = [(0, import_node_path10.join)(dir, "..", "..", "package.json"), (0, import_node_path10.join)(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = (0, import_node_fs6.readFileSync)(pkgPath, "utf-8");
+        const raw = (0, import_node_fs8.readFileSync)(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version !== void 0 && pkg.name !== void 0) {
           return pkg.version;
@@ -4388,7 +5706,7 @@ function readVersion() {
   }
 }
 function promptInput(label, masked = false) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     process.stdout.write(label);
     let input = "";
     const stdin = process.stdin;
@@ -4403,7 +5721,7 @@ function promptInput(label, masked = false) {
           stdin.setRawMode(wasRaw ?? false);
           stdin.pause();
           process.stdout.write("\n");
-          resolve(input.trim());
+          resolve2(input.trim());
           return;
         } else if (ch === "\x7F" || ch === "\b") {
           if (input.length > 0) {
@@ -4433,8 +5751,21 @@ function resetConfig() {
 }
 async function startCli(options = {}) {
   const args = parseCliArgs();
+  const version = readVersion();
   if (args.version) {
-    process.stdout.write(`robota ${readVersion()}
+    process.stdout.write(`robota ${version}
+`);
+    return;
+  }
+  if (args.checkUpdate) {
+    const result = await checkForCliUpdate({ currentVersion: version, force: true });
+    const message = formatCliUpdateCheckMessage(result);
+    if (result.status === "error") {
+      process.stderr.write(`${message}
+`);
+      process.exit(1);
+    }
+    process.stdout.write(`${message}
 `);
     return;
   }
@@ -4444,6 +5775,11 @@ async function startCli(options = {}) {
   }
   const cwd = process.cwd();
   const providerDefinitions = options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  const commandModules = [
+    createStatusLineCommandModule(),
+    ...options.commandModules ?? []
+  ];
+  const startupUpdateNoticePromise = shouldRunStartupCliUpdateCheck(args) ? getStartupCliUpdateNotice({ currentVersion: version }) : void 0;
   if (args.configure) {
     await runInteractiveProviderSetup(cwd, args, promptInput, providerDefinitions);
     return;
@@ -4523,7 +5859,7 @@ ${args.jsonSchema}`
       appendSystemPrompt,
       backgroundTaskRunners,
       subagentRunnerFactory,
-      commandModules: options.commandModules
+      commandModules
     });
     const transport = (0, import_agent_transport_headless.createHeadlessTransport)({
       outputFormat: args.outputFormat ?? "text",
@@ -4541,15 +5877,16 @@ ${args.jsonSchema}`
     language: args.language,
     permissionMode: args.permissionMode,
     maxTurns: args.maxTurns,
-    version: readVersion(),
+    version,
     sessionStore,
     resumeSessionId,
     forkSession: args.forkSession,
     sessionName: args.sessionName,
     backgroundTaskRunners,
     subagentRunnerFactory,
-    commandModules: options.commandModules,
-    providerDefinitions
+    commandModules,
+    providerDefinitions,
+    startupUpdateNoticePromise
   });
 }
 // Annotate the CommonJS export names for ESM import in node: