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

package/dist/node/{chunk-H3NRW5FW.js → chunk-B522YHTK.js}

@@ -3,10 +3,11 @@ import {
   createProviderFromSettings,
   findProviderDefinition,
   formatSupportedProviderTypes,
+  hasUsableSecretReference,
   isSubagentWorkerChildMessage,
   readMergedProviderSettings,
   readProviderSettings
-} from "./chunk-2JAZDNYT.js";
+} from "./chunk-4ZX5RLIX.js";
 
 // src/background/managed-shell-process-runner.ts
 import { spawn } from "child_process";
@@ -48,7 +49,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);
@@ -56,7 +57,7 @@ function sendInput(child, input) {
     child.stdin.once("error", onError);
     child.stdin.end(input, () => {
       child.stdin.off("error", onError);
-      resolve();
+      resolve2();
     });
   });
 }
@@ -91,7 +92,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");
@@ -105,7 +106,7 @@ function createProcessResult(runtime) {
       if (settled) return;
       settled = true;
       clearTimers();
-      resolve({
+      resolve2({
         taskId: runtime.taskId,
         kind: "process",
         output: runtime.capture.getOutput(),
@@ -292,7 +293,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 BackgroundTaskError3("crash", "Subagent worker IPC channel is closed"));
       return;
@@ -302,7 +303,7 @@ function sendWorkerMessage(child, message) {
         reject(error);
         return;
       }
-      resolve();
+      resolve2();
     });
   });
 }
@@ -319,14 +320,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));
   }
@@ -542,7 +543,8 @@ 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() {
@@ -589,8 +591,8 @@ function readTranscriptLog(jobId, transcriptPath, cursor) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join9, dirname as dirname5 } from "path";
 import { fileURLToPath } from "url";
 import { InteractiveSession as InteractiveSession2, projectPaths } from "@robota-sdk/agent-sdk";
 import { SessionStore } from "@robota-sdk/agent-sessions";
@@ -647,7 +649,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 {
@@ -678,7 +682,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
   };
 }
 
@@ -766,7 +772,7 @@ function isUsableProviderProfile(type, profile, providerDefinitions) {
   if (!profile) {
     return false;
   }
-  if (profile.apiKey) {
+  if (hasUsableSecretReference(profile.apiKey)) {
     return true;
   }
   if (!type) {
@@ -776,7 +782,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
@@ -806,7 +812,7 @@ function validateProviderProfile(profileName, profile, options = {}) {
     throw new Error(`Provider profile "${profileName}" is missing model`);
   }
   const definition = 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`);
   }
 }
@@ -873,6 +879,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: ${formatSupportedProviderTypes(providerDefinitions)}`
+    );
+  }
+  const definition = findProviderDefinition(providerDefinitions, selectedValue);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${selectedValue}. Currently supported: ${formatSupportedProviderTypes(providerDefinitions)}`
+    );
+  }
+  return definition.type;
+}
 function getProviderSetupStep(state) {
   const step = state.steps[state.stepIndex];
   if (step === void 0) {
@@ -918,6 +958,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";
@@ -1010,15 +1060,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, {
@@ -1035,9 +1083,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) {
@@ -1066,14 +1111,25 @@ 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: ${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
 import { createHeadlessTransport } from "@robota-sdk/agent-transport-headless";
@@ -1083,8 +1139,8 @@ import { render } from "ink";
 
 // src/ui/App.tsx
 import { useState as useState14, useEffect as useEffect4 } from "react";
-import { Box as Box14, Text as Text16, useApp as useApp2, useInput as useInput8 } from "ink";
-import { getModelName as getModelName2, createSystemMessage as createSystemMessage4, messageToHistoryEntry as messageToHistoryEntry4 } from "@robota-sdk/agent-core";
+import { Box as Box18, Text as Text20, useApp as useApp2, useInput as useInput8 } from "ink";
+import { getModelName as getModelName3, createSystemMessage as createSystemMessage4, messageToHistoryEntry as messageToHistoryEntry4 } from "@robota-sdk/agent-core";
 
 // src/ui/hooks/useInteractiveSession.ts
 import { useState, useRef, useCallback as useCallback2, useEffect } from "react";
@@ -1120,7 +1176,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) {
@@ -1241,6 +1299,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);
@@ -1343,7 +1408,10 @@ var TuiStateManager = class {
 // src/ui/hooks/useSlashRouting.ts
 import { useCallback } from "react";
 import { randomUUID as randomUUID2 } from "crypto";
-import { createSystemMessage, messageToHistoryEntry } from "@robota-sdk/agent-core";
+import {
+  createSystemMessage,
+  messageToHistoryEntry
+} from "@robota-sdk/agent-core";
 
 // src/utils/provider-command.ts
 async function handleProviderCommand(cwd, args, deps = {}) {
@@ -1415,7 +1483,14 @@ function buildProviderSwitch(providers, profileName) {
   };
 }
 function buildProviderSetup(type, providerDefinitions) {
-  if (!type || findProviderDefinition(providerDefinitions, type) === void 0) {
+  if (!type) {
+    return {
+      message: "Provider setup requested. Select a provider to continue.",
+      success: true,
+      data: { providerSetup: {} }
+    };
+  }
+  if (findProviderDefinition(providerDefinitions, type) === void 0) {
     return {
       message: `Usage: provider add <type>. Supported: ${formatSupportedProviderTypes(providerDefinitions)}`,
       success: false
@@ -1503,8 +1578,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) {
@@ -1531,6 +1606,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,
@@ -1575,6 +1655,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) {
@@ -1637,8 +1724,8 @@ function useInteractiveSession(props) {
     });
   }, []);
   const permissionHandler = useCallback2(
-    (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]
@@ -1663,6 +1750,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 {
@@ -1689,6 +1777,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]);
@@ -1856,6 +1945,108 @@ function usePluginCallbacks(cwd) {
 import { useState as useState2, useRef as useRef2, useCallback as useCallback3 } from "react";
 import { useApp } from "ink";
 import { createSystemMessage as createSystemMessage3, messageToHistoryEntry as messageToHistoryEntry3, getModelName } from "@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,
@@ -1863,6 +2054,7 @@ function useSideEffects({
   addEntry,
   baseHandleSubmit,
   setSessionName,
+  setStatusLineSettings,
   providerDefinitions
 }) {
   const { exit } = useApp();
@@ -1870,7 +2062,8 @@ function useSideEffects({
   const pendingModelChangeRef = useRef2(null);
   const [pendingProviderProfile, setPendingProviderProfile] = useState2(null);
   const pendingProviderProfileRef = useRef2(null);
-  const [pendingProviderSetupType, setPendingProviderSetupType] = useState2(null);
+  const [pendingInteractionPrompt, setPendingInteractionPrompt] = useState2(null);
+  const providerSetupInteractionRef = useRef2(null);
   const [showPluginTUI, setShowPluginTUI] = useState2(false);
   const [showSessionPicker, setShowSessionPicker] = useState2(false);
   const requestShutdown = useCallback3(
@@ -1913,10 +2106,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) {
@@ -1954,8 +2151,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 = useCallback3(
     (index) => {
@@ -2015,9 +2221,10 @@ function useSideEffects({
     },
     [cwd, addEntry, requestShutdown]
   );
-  const handleProviderSetupSubmit = useCallback3(
+  const completeProviderSetup = useCallback3(
     (input) => {
-      setPendingProviderSetupType(null);
+      providerSetupInteractionRef.current = null;
+      setPendingInteractionPrompt(null);
       try {
         const settingsPath = getUserSettingsPath();
         applyProviderConfiguration(settingsPath, input, { providerDefinitions });
@@ -2037,15 +2244,43 @@ function useSideEffects({
     },
     [addEntry, requestShutdown, providerDefinitions]
   );
-  const handleProviderSetupCancel = useCallback3(() => {
-    setPendingProviderSetupType(null);
+  const handleInteractionSubmit = useCallback3(
+    (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(
+          messageToHistoryEntry3(
+            createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+          )
+        );
+      }
+    },
+    [addEntry, completeProviderSetup]
+  );
+  const handleInteractionCancel = useCallback3(() => {
+    providerSetupInteractionRef.current = null;
+    setPendingInteractionPrompt(null);
     addEntry(messageToHistoryEntry3(createSystemMessage3("Provider setup cancelled.")));
   }, [addEntry]);
   return {
     handleSubmit,
     pendingModelId,
     pendingProviderProfile,
-    pendingProviderSetupType,
+    pendingInteractionPrompt,
     showPluginTUI,
     showSessionPicker,
     setPendingModelId,
@@ -2053,94 +2288,336 @@ function useSideEffects({
     setShowSessionPicker,
     handleModelConfirm,
     handleProviderConfirm,
-    handleProviderSetupSubmit,
-    handleProviderSetupCancel
+    handleInteractionSubmit,
+    handleInteractionCancel
   };
 }
 
+// src/ui/hooks/useStatusLineSettings.ts
+import { useState as useState3 } from "react";
+function useStatusLineSettings() {
+  return useState3(
+    () => readStatusLineSettings(readSettings(getUserSettingsPath()))
+  );
+}
+
 // src/ui/MessageList.tsx
 import React from "react";
-import { Box as Box2, Text as Text2 } from "ink";
+import { Box as Box4, Text as Text4 } from "ink";
 import { isToolMessage, isAssistantMessage } from "@robota-sdk/agent-core";
 
 // src/ui/render-markdown.ts
 import { marked } from "marked";
 import TerminalRenderer from "marked-terminal";
-marked.setOptions({
-  renderer: new TerminalRenderer()
-});
-function renderMarkdown(md) {
-  const result = 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 = TerminalRenderer;
+function shouldUseColor(option) {
+  if (option !== void 0) {
+    return option;
+  }
+  if (process.env.NO_COLOR || process.env.FORCE_COLOR === ZERO_COLOR) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR) {
+    return true;
+  }
+  return Boolean(process.stdout.isTTY);
+}
+function isDiffLanguage(language) {
+  return language?.trim().toLowerCase() === "diff";
+}
+function 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 = marked.parse(md, {
+    renderer: createTerminalRenderer(shouldUseColor(options.color))
+  });
   return typeof result === "string" ? result.trimEnd() : md;
 }
 
-// src/ui/DiffBlock.tsx
+// src/ui/ToolDiffBlock.tsx
 import { Box, Text } from "ink";
-import { jsxs } from "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
+import { jsx, jsxs } from "react/jsx-runtime";
+function ToolDiffBlock({ file, lines }) {
+  const summary = buildToolDiffSummary({ file, lines });
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 4, children: [
-    file && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+    summary.file && /* @__PURE__ */ jsxs(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__ */ jsxs(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__ */ jsxs(Text, { color: fgColor, backgroundColor: bgColor, children: [
-        "\u2502 ",
-        lineNum,
-        " ",
-        prefix,
-        " ",
-        line.text
-      ] }, i);
-    }),
-    truncated && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+    /* @__PURE__ */ jsx(Text, { children: renderMarkdown(summary.markdown) }),
+    summary.truncated && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
       "\u2502 ... and ",
-      remaining,
+      summary.remainingLineCount,
       " more lines"
     ] })
   ] });
 }
 
+// src/ui/UsageSummaryEntry.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { formatTokenCount } from "@robota-sdk/agent-core";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TOKEN_COMPACT_THRESHOLD = 1e3;
+function UsageSummaryEntry({ entry }) {
+  const usage = entry.data;
+  if (!usage) return /* @__PURE__ */ jsx2(Fragment, {});
+  const prompt = usage.promptTokens !== void 0 ? formatUsageTokenCount(usage.promptTokens) : "?";
+  const completion = usage.completionTokens !== void 0 ? formatUsageTokenCount(usage.completionTokens) : "?";
+  const total = formatUsageTokenCount(usage.totalTokens);
+  const context = `${Math.round(usage.contextUsedPercentage)}% (${formatTokenCount(
+    usage.contextUsedTokens
+  )}/${formatTokenCount(usage.contextMaxTokens)})`;
+  const costLabel = usage.costStatus === "unknown" ? "cost unknown" : `cost ${usage.costStatus}`;
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+      "Usage:",
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      usage.kind,
+      " ",
+      total,
+      " tokens (in ",
+      prompt,
+      " / out ",
+      completion,
+      ") \xB7 Context ",
+      context,
+      " \xB7",
+      " ",
+      costLabel
+    ] })
+  ] }) });
+}
+function formatUsageTokenCount(tokens) {
+  return tokens < TOKEN_COMPACT_THRESHOLD ? tokens.toLocaleString() : formatTokenCount(tokens);
+}
+
+// src/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
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ToolCommandOutput({ tool }) {
+  const summary = formatCommandOutputSummary(tool);
+  if (!summary) return null;
+  if (summary.statusLabel === "ok" && summary.previewLines.length === 0 && !summary.transcriptHint) {
+    return null;
+  }
+  const color = summary.status === "error" ? "red" : "white";
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginLeft: 4, children: [
+    summary.statusLabel !== "ok" && /* @__PURE__ */ jsx3(Text3, { color, dimColor: true, children: summary.statusLabel }),
+    summary.previewLines.map((line, index) => /* @__PURE__ */ jsx3(Text3, { color, dimColor: true, children: line }, `${line}-${index}`)),
+    summary.transcriptHint && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: summary.transcriptHint })
+  ] });
+}
+
 // src/ui/MessageList.tsx
-import { Fragment, jsx, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function getToolSummaryStatus(tool) {
+  if (formatCommandOutputSummary(tool)?.status === "error") return "\u2717";
+  if (tool.isRunning) return "\u27F3";
+  if (tool.result === "error") return "\u2717";
+  if (tool.result === "denied") return "\u2298";
+  return "\u2713";
+}
+function getToolSummaryColor(tool) {
+  if (formatCommandOutputSummary(tool)?.status === "error" || tool.result === "error") return "red";
+  if (tool.isRunning || tool.result === "denied") return "yellow";
+  return "green";
+}
+function getToolSummaryLabel(tool) {
+  return `${getToolSummaryStatus(tool)} ${tool.toolName}${tool.firstArg ? `(${tool.firstArg})` : ""}`;
+}
 function RoleLabel({ role }) {
   switch (role) {
     case "user":
-      return /* @__PURE__ */ jsxs2(Text2, { color: "green", bold: true, children: [
+      return /* @__PURE__ */ jsxs4(Text4, { color: "green", bold: true, children: [
         "You:",
         " "
       ] });
     case "assistant":
-      return /* @__PURE__ */ jsxs2(Text2, { color: "cyan", bold: true, children: [
+      return /* @__PURE__ */ jsxs4(Text4, { color: "cyan", bold: true, children: [
         "Robota:",
         " "
       ] });
     case "system":
-      return /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
+      return /* @__PURE__ */ jsxs4(Text4, { color: "yellow", bold: true, children: [
         "System:",
         " "
       ] });
     case "tool":
-      return /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+      return /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
         "Tool:",
         " "
       ] });
@@ -2148,7 +2625,7 @@ function RoleLabel({ role }) {
 }
 function ToolMessage({ message }) {
   if (!isToolMessage(message)) {
-    return /* @__PURE__ */ jsx(Fragment, {});
+    return /* @__PURE__ */ jsx4(Fragment2, {});
   }
   const toolName = message.name;
   const content = message.content;
@@ -2161,45 +2638,45 @@ function ToolMessage({ message }) {
   } catch {
   }
   if (summaries) {
-    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs2(Box2, { children: [
-        /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
           "Tool:",
           " "
         ] }),
-        toolName && /* @__PURE__ */ jsxs2(Text2, { color: "white", dimColor: true, children: [
+        toolName && /* @__PURE__ */ jsxs4(Text4, { color: "white", dimColor: true, children: [
           "[",
           toolName,
           "]"
         ] })
       ] }),
-      /* @__PURE__ */ jsx(Text2, { children: " " }),
-      summaries.map((s, i) => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+      /* @__PURE__ */ jsx4(Text4, { children: " " }),
+      summaries.map((s, i) => /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
           "  ",
           "\u2713",
           " ",
           s.line
         ] }),
-        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ jsx(DiffBlock, { file: s.diffFile, lines: s.diffLines })
+        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ jsx4(ToolDiffBlock, { file: s.diffFile, lines: s.diffLines })
       ] }, i))
     ] });
   }
   const lines = content.split("\n").filter((l) => l.trim());
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs2(Box2, { children: [
-      /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
         "Tool:",
         " "
       ] }),
-      toolName && /* @__PURE__ */ jsxs2(Text2, { color: "white", dimColor: true, children: [
+      toolName && /* @__PURE__ */ jsxs4(Text4, { color: "white", dimColor: true, children: [
         "[",
         toolName,
         "]"
       ] })
     ] }),
-    /* @__PURE__ */ jsx(Text2, { children: " " }),
-    lines.map((line, i) => /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
       "  ",
       "\u2713",
       " ",
@@ -2211,26 +2688,44 @@ var MessageItem = React.memo(function MessageItem2({
   message
 }) {
   if (isToolMessage(message)) {
-    return /* @__PURE__ */ jsx(ToolMessage, { message });
+    return /* @__PURE__ */ jsx4(ToolMessage, { message });
   }
   const content = message.content ?? "";
   const isInterrupted = message.state === "interrupted";
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsx(RoleLabel, { role: message.role }) }),
-    /* @__PURE__ */ jsx(Text2, { children: " " }),
-    /* @__PURE__ */ jsx(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text2, { wrap: "wrap", children: isAssistantMessage(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(RoleLabel, { role: message.role }) }),
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: isAssistantMessage(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
   ] });
 });
 function ToolSummaryEntry({ entry }) {
   const data = entry.data;
+  const tools = data?.tools;
   const lines = data?.summary?.split("\n") ?? [];
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+  if (tools && tools.length > 0) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] }) }),
+      /* @__PURE__ */ jsx4(Text4, { children: " " }),
+      tools.map((tool, i) => /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: getToolSummaryColor(tool), children: [
+          "  ",
+          getToolSummaryLabel(tool)
+        ] }),
+        /* @__PURE__ */ jsx4(ToolCommandOutput, { tool }),
+        tool.diffLines && tool.diffLines.length > 0 && /* @__PURE__ */ jsx4(ToolDiffBlock, { file: tool.diffFile, lines: tool.diffLines })
+      ] }, i))
+    ] });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: "white", bold: true, children: [
       "Tool:",
       " "
     ] }) }),
-    /* @__PURE__ */ jsx(Text2, { children: " " }),
-    lines.map((line, i) => /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
       "  ",
       line
     ] }, i))
@@ -2239,36 +2734,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__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: "yellow", bold: true, children: [
       "System:",
       " "
     ] }) }),
-    /* @__PURE__ */ jsx(Text2, { children: " " }),
-    /* @__PURE__ */ jsx(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text2, { wrap: "wrap", children: eventMessage }) })
+    /* @__PURE__ */ jsx4(Text4, { children: " " }),
+    /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: eventMessage }) })
   ] });
 }
 function EntryItem({ entry }) {
   if (entry.category === "chat") {
     const message = entry.data;
-    return /* @__PURE__ */ jsx(MessageItem, { message });
+    return /* @__PURE__ */ jsx4(MessageItem, { message });
   }
   if (entry.type === "tool-summary") {
-    return /* @__PURE__ */ jsx(ToolSummaryEntry, { entry });
+    return /* @__PURE__ */ jsx4(ToolSummaryEntry, { entry });
+  }
+  if (entry.type === "usage-summary") {
+    return /* @__PURE__ */ jsx4(UsageSummaryEntry, { entry });
   }
   if (entry.type === "tool-start" || entry.type === "tool-end") {
-    return /* @__PURE__ */ jsx(Fragment, {});
+    return /* @__PURE__ */ jsx4(Fragment2, {});
   }
-  return /* @__PURE__ */ jsx(EventEntry, { entry });
+  return /* @__PURE__ */ jsx4(EventEntry, { entry });
 }
 function MessageList({ history }) {
-  return /* @__PURE__ */ jsx(Box2, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ jsx(EntryItem, { entry }, entry.id)) });
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ jsx4(EntryItem, { entry }, entry.id)) });
+}
+
+// src/ui/SessionStatusBar.tsx
+import { useMemo as useMemo2 } from "react";
+import { getModelName as getModelName2 } from "@robota-sdk/agent-core";
+
+// src/utils/git-branch.ts
+import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname3, isAbsolute, join as join7, resolve } from "path";
+var DETACHED_HEAD_LENGTH = 7;
+function resolveGitBranch(cwd) {
+  try {
+    const gitDir = findGitDir(cwd);
+    if (!gitDir) return void 0;
+    const head = readFileSync4(join7(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 = resolve(start);
+  let parent = dirname3(current);
+  while (parent !== current) {
+    const candidate = join7(current, ".git");
+    const resolved = resolveGitMetadata(candidate, current);
+    if (resolved) return resolved;
+    current = parent;
+    parent = dirname3(current);
+  }
+  const rootCandidate = join7(current, ".git");
+  return resolveGitMetadata(rootCandidate, current);
+}
+function resolveGitMetadata(candidate, repoDir) {
+  if (!existsSync4(candidate)) return void 0;
+  const stat = lstatSync(candidate);
+  if (stat.isDirectory()) return candidate;
+  if (!stat.isFile()) return void 0;
+  const content = readFileSync4(candidate, "utf8").trim();
+  const prefix = "gitdir:";
+  if (!content.startsWith(prefix)) return void 0;
+  const rawPath = content.slice(prefix.length).trim();
+  return isAbsolute(rawPath) ? rawPath : resolve(repoDir, rawPath);
 }
 
 // src/ui/StatusBar.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { formatTokenCount } from "@robota-sdk/agent-core";
-import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Box as Box5, Text as Text5 } from "ink";
+import { formatTokenCount as formatTokenCount2 } from "@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
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var CONTEXT_YELLOW_THRESHOLD = 70;
 var CONTEXT_RED_THRESHOLD = 90;
 function getContextColor(percentage) {
@@ -2276,20 +2869,115 @@ function getContextColor(percentage) {
   if (percentage >= CONTEXT_YELLOW_THRESHOLD) return "yellow";
   return "green";
 }
+function StatusActivityText({
+  isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt
+}) {
+  const activity = formatStatusActivity({
+    isThinking,
+    activeToolCount,
+    activeBackgroundTaskCount,
+    hasPendingPrompt
+  });
+  return /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "cyan", bold: true, children: "Activity:" }),
+    " ",
+    /* @__PURE__ */ jsx5(Text5, { color: activity.color, bold: activity.kind !== "idle", children: activity.text })
+  ] });
+}
+function ContextText({
+  percentage,
+  usedTokens,
+  maxTokens
+}) {
+  return /* @__PURE__ */ jsxs5(Text5, { color: getContextColor(percentage), children: [
+    "Context: ",
+    Math.round(percentage),
+    "% (",
+    formatTokenCount2(usedTokens),
+    "/",
+    formatTokenCount2(maxTokens),
+    ")"
+  ] });
+}
+function ModeText({ permissionMode }) {
+  return /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "cyan", bold: true, children: "Mode:" }),
+    " ",
+    /* @__PURE__ */ jsx5(Text5, { children: permissionMode })
+  ] });
+}
+function StatusLeft({
+  permissionMode,
+  modelName,
+  isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt,
+  contextPercentage,
+  contextUsedTokens,
+  contextMaxTokens,
+  sessionName,
+  gitBranch,
+  showGitBranch
+}) {
+  const shouldShowGitBranch = showGitBranch && gitBranch !== void 0 && gitBranch.length > 0;
+  return /* @__PURE__ */ jsxs5(Text5, { children: [
+    /* @__PURE__ */ jsx5(
+      StatusActivityText,
+      {
+        isThinking,
+        activeToolCount,
+        activeBackgroundTaskCount,
+        hasPendingPrompt
+      }
+    ),
+    "  |  ",
+    /* @__PURE__ */ jsx5(ModeText, { permissionMode }),
+    sessionName && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      "  |  ",
+      /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: sessionName })
+    ] }),
+    shouldShowGitBranch && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      "  |  ",
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "git: ",
+        gitBranch
+      ] })
+    ] }),
+    "  |  ",
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: modelName }),
+    "  |  ",
+    /* @__PURE__ */ jsx5(
+      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
+  sessionName,
+  gitBranch,
+  showGitBranch = true
 }) {
-  const contextColor = getContextColor(contextPercentage);
-  return /* @__PURE__ */ jsxs3(
-    Box3,
+  return /* @__PURE__ */ jsxs5(
+    Box5,
     {
       borderStyle: "single",
       borderColor: "gray",
@@ -2297,46 +2985,78 @@ function StatusBar({
       paddingRight: 1,
       justifyContent: "space-between",
       children: [
-        /* @__PURE__ */ jsxs3(Text3, { children: [
-          /* @__PURE__ */ jsx2(Text3, { color: "cyan", bold: true, children: "Mode:" }),
-          " ",
-          /* @__PURE__ */ jsx2(Text3, { children: permissionMode }),
-          sessionName && /* @__PURE__ */ jsxs3(Fragment2, { children: [
-            "  |  ",
-            /* @__PURE__ */ jsx2(Text3, { color: "magenta", children: sessionName })
-          ] }),
-          "  |  ",
-          /* @__PURE__ */ jsx2(Text3, { dimColor: true, children: modelName }),
-          "  |  ",
-          /* @__PURE__ */ jsxs3(Text3, { color: contextColor, children: [
-            "Context: ",
-            Math.round(contextPercentage),
-            "% (",
-            formatTokenCount(contextUsedTokens),
-            "/",
-            formatTokenCount(contextMaxTokens),
-            ")"
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs3(Text3, { children: [
-          isThinking && /* @__PURE__ */ jsx2(Text3, { color: "yellow", children: "Thinking... " }),
-          /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
-            "msgs: ",
-            messageCount
-          ] })
-        ] })
+        /* @__PURE__ */ jsx5(
+          StatusLeft,
+          {
+            permissionMode,
+            modelName,
+            isThinking,
+            activeToolCount,
+            activeBackgroundTaskCount,
+            hasPendingPrompt,
+            contextPercentage,
+            contextUsedTokens,
+            contextMaxTokens,
+            sessionName,
+            gitBranch,
+            showGitBranch
+          }
+        ),
+        /* @__PURE__ */ jsx5(Text5, { children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+          "msgs: ",
+          messageCount
+        ] }) })
       ]
     }
   );
 }
 
+// src/ui/SessionStatusBar.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function SessionStatusBar({
+  cwd,
+  permissionMode,
+  modelId,
+  sessionId,
+  messageCount,
+  isThinking,
+  activeToolCount,
+  activeBackgroundTaskCount,
+  hasPendingPrompt,
+  contextState,
+  sessionName,
+  settings
+}) {
+  const gitBranch = useMemo2(() => resolveGitBranch(cwd), [cwd]);
+  if (!settings.enabled) return null;
+  return /* @__PURE__ */ jsx6(
+    StatusBar,
+    {
+      permissionMode,
+      modelName: modelId ? getModelName2(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
-import { useState as useState6, useCallback as useCallback4, useRef as useRef4 } from "react";
-import { Box as Box5, Text as Text7, useInput as useInput2, useStdout } from "ink";
+import { useState as useState7, useCallback as useCallback4, useRef as useRef4, useMemo as useMemo4 } from "react";
+import { Box as Box7, Text as Text9, useInput as useInput2, useWindowSize } from "ink";
 
 // src/ui/CjkTextInput.tsx
-import { useRef as useRef3, useState as useState3 } from "react";
-import { Text as Text4, useInput } from "ink";
+import { useRef as useRef3, useState as useState4 } from "react";
+import { Text as Text6, useInput, usePaste } from "ink";
 import chalk from "chalk";
 
 // src/ui/flows/cjk-text-input-flow.ts
@@ -2363,10 +3083,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);
@@ -2391,9 +3121,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");
@@ -2456,15 +3193,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) {
@@ -2514,7 +3244,7 @@ function insertPrintableInput(state, input) {
 }
 
 // src/ui/CjkTextInput.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 function CjkTextInput({
   value,
   onChange,
@@ -2524,41 +3254,79 @@ function CjkTextInput({
   focus = true,
   showCursor = true,
   availableWidth,
-  cursorHint = null
+  cursorHint = null,
+  enableVerticalNavigation = true
 }) {
   const stateRef = useRef3(createCjkTextInputFlowState(value));
-  const [, forceRender] = useState3(0);
+  const [, forceRender] = useState4(0);
   stateRef.current = syncCjkTextInputFlowState(stateRef.current, value, cursorHint);
-  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__ */ jsx3(Text4, { children: renderWithCursor(
+  useCjkTextInputHandlers({
+    stateRef,
+    onChange,
+    onSubmit,
+    onPaste,
+    availableWidth,
+    focus,
+    enableVerticalNavigation,
+    forceRender
+  });
+  return /* @__PURE__ */ jsx7(Text6, { children: renderWithCursor(
     stateRef.current.value,
     stateRef.current.cursor,
     placeholder,
     showCursor && focus
   ) });
 }
-function applyCjkTextInputEffect(effect, onChange, onSubmit, onPaste, forceRender) {
-  if (effect.type === "change") {
-    onChange(effect.value);
-  } else if (effect.type === "submit") {
-    onSubmit?.(effect.value);
-  } else if (effect.type === "paste") {
-    onPaste?.(effect.text, effect.cursor);
-  } else if (effect.type === "render") {
-    forceRender((n) => n + 1);
+function useCjkTextInputHandlers(options) {
+  usePaste(
+    (text) => {
+      applyCjkFlowSafely(
+        options,
+        () => applyCjkTextPaste(options.stateRef.current, text, createFlowOptions(options))
+      );
+    },
+    { isActive: options.focus }
+  );
+  useInput(
+    (input, key) => {
+      applyCjkFlowSafely(
+        options,
+        () => applyCjkTextInput(options.stateRef.current, input, key, createFlowOptions(options))
+      );
+    },
+    { isActive: options.focus }
+  );
+}
+function createFlowOptions(options) {
+  return {
+    availableWidth: options.availableWidth,
+    canPaste: options.onPaste !== void 0,
+    enableVerticalNavigation: options.enableVerticalNavigation
+  };
+}
+function applyCjkFlowSafely(options, run) {
+  try {
+    const result = run();
+    options.stateRef.current = result.state;
+    applyCjkTextInputEffect(
+      result.effect,
+      options.onChange,
+      options.onSubmit,
+      options.onPaste,
+      options.forceRender
+    );
+  } catch {
+  }
+}
+function applyCjkTextInputEffect(effect, onChange, onSubmit, onPaste, forceRender) {
+  if (effect.type === "change") {
+    onChange(effect.value);
+  } else if (effect.type === "submit") {
+    onSubmit?.(effect.value);
+  } else if (effect.type === "paste") {
+    onPaste?.(effect.text, effect.cursor);
+  } else if (effect.type === "render") {
+    forceRender((n) => n + 1);
   }
 }
 function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
@@ -2584,14 +3352,14 @@ function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
 }
 
 // src/ui/WaveText.tsx
-import { useState as useState4, useEffect as useEffect2 } from "react";
-import { Text as Text5 } from "ink";
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { useState as useState5, useEffect as useEffect2 } from "react";
+import { Text as Text7 } from "ink";
+import { jsx as jsx8 } from "react/jsx-runtime";
 var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
 var INTERVAL_MS = 400;
 var CHARS_PER_GROUP = 4;
 function WaveText({ text }) {
-  const [tick, setTick] = useState4(0);
+  const [tick, setTick] = useState5(0);
   useEffect2(() => {
     const timer = setInterval(() => {
       setTick((prev) => prev + 1);
@@ -2599,23 +3367,23 @@ function WaveText({ text }) {
     return () => clearInterval(timer);
   }, []);
   const chars = [...text];
-  return /* @__PURE__ */ jsx4(Text5, { children: chars.map((char, i) => {
+  return /* @__PURE__ */ jsx8(Text7, { children: chars.map((char, i) => {
     const group = Math.floor(i / CHARS_PER_GROUP);
     const colorIndex = (tick + group) % WAVE_COLORS.length;
-    return /* @__PURE__ */ jsx4(Text5, { color: WAVE_COLORS[colorIndex], children: char }, i);
+    return /* @__PURE__ */ jsx8(Text7, { color: WAVE_COLORS[colorIndex], children: char }, i);
   }) });
 }
 
 // src/ui/SlashAutocomplete.tsx
-import { Box as Box4, Text as Text6 } from "ink";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Box as Box6, Text as Text8 } from "ink";
+import { jsx as jsx9, jsxs as jsxs6 } from "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__ */ jsx5(Box4, { children: /* @__PURE__ */ jsxs4(Text6, { color: nameColor, dimColor: dimmed, children: [
+  return /* @__PURE__ */ jsx9(Box6, { children: /* @__PURE__ */ jsxs6(Text8, { color: nameColor, dimColor: dimmed, children: [
     indicator,
     showSlash ? `/${cmd.name}  ${cmd.description}` : cmd.description
   ] }) });
@@ -2629,7 +3397,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__ */ jsx5(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx9(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ jsx9(
     CommandRow,
     {
       cmd,
@@ -2653,7 +3421,7 @@ function expandPasteLabels(text, store) {
 }
 
 // src/ui/hooks/useAutocomplete.ts
-import React4, { useState as useState5, useMemo as useMemo2 } from "react";
+import React5, { useState as useState6, useMemo as useMemo3 } from "react";
 function parseSlashInput(value) {
   if (!value.startsWith("/")) return { isSlash: false, parentCommand: "", filter: "" };
   const afterSlash = value.slice(1);
@@ -2664,16 +3432,16 @@ function parseSlashInput(value) {
   return { isSlash: true, parentCommand: parent, filter: rest };
 }
 function useAutocomplete(value, registry) {
-  const [selectedIndex, setSelectedIndex] = useState5(0);
-  const [dismissed, setDismissed] = useState5(false);
-  const prevValueRef = React4.useRef(value);
+  const [selectedIndex, setSelectedIndex] = useState6(0);
+  const [dismissed, setDismissed] = useState6(false);
+  const prevValueRef = React5.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 = useMemo2(() => {
+  const filteredCommands = useMemo3(() => {
     if (!registry || !parsed.isSlash || dismissed) return [];
     if (isSubcommandMode) {
       const subs = registry.getSubcommands(parsed.parentCommand);
@@ -2721,6 +3489,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") {
@@ -2763,11 +3586,12 @@ function shouldSubmitInput(text) {
 }
 
 // src/ui/InputArea.tsx
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs7 } from "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,
@@ -2775,13 +3599,24 @@ function InputArea({
   isAborting,
   pendingPrompt,
   registry,
-  sessionName
+  sessionName,
+  history
 }) {
-  const [value, setValue] = useState6("");
-  const [cursorHint, setCursorHint] = useState6(null);
+  const [value, setValue] = useState7("");
+  const [cursorHint, setCursorHint] = useState7(null);
+  const [historyState, setHistoryState] = useState7(createPromptHistoryNavigationState);
+  const [localPromptHistory, setLocalPromptHistory] = useState7([]);
+  const restoredPromptHistory = useMemo4(() => extractPromptHistory(history ?? []), [history]);
+  const promptHistory = useMemo4(
+    () => localPromptHistory.reduce(
+      (prompts, prompt) => appendPromptHistory(prompts, prompt),
+      restoredPromptHistory
+    ),
+    [restoredPromptHistory, localPromptHistory]
+  );
   const pasteStore = useRef4(/* @__PURE__ */ new Map());
-  const { stdout } = useStdout();
-  const terminalColumns = stdout?.columns ?? 80;
+  const { columns } = useWindowSize();
+  const terminalColumns = columns > 0 ? columns : DEFAULT_TERMINAL_COLUMNS;
   const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
   const pasteIdRef = useRef4(0);
   const {
@@ -2802,6 +3637,20 @@ function InputArea({
       return change.value;
     });
   }, []);
+  const resetHistoryNavigation = useCallback4(() => {
+    setHistoryState(createPromptHistoryNavigationState());
+  }, []);
+  const recordPromptHistory = useCallback4((prompt) => {
+    setLocalPromptHistory((prev) => appendPromptHistory(prev, prompt));
+  }, []);
+  const submitPrompt = useCallback4(
+    (prompt) => {
+      recordPromptHistory(prompt);
+      resetHistoryNavigation();
+      onSubmit(prompt);
+    },
+    [onSubmit, recordPromptHistory, resetHistoryNavigation]
+  );
   const tabCompleteCommand = useCallback4(
     (cmd) => {
       const result = resolveTabCompletion(value, cmd);
@@ -2825,9 +3674,9 @@ function InputArea({
         return;
       }
       setValue("");
-      onSubmit(result.value);
+      submitPrompt(result.value);
     },
-    [value, onSubmit, setSelectedIndex]
+    [value, submitPrompt, setSelectedIndex]
   );
   const handleSubmit = useCallback4(
     (text) => {
@@ -2840,9 +3689,9 @@ function InputArea({
       setValue("");
       pasteStore.current.clear();
       pasteIdRef.current = 0;
-      onSubmit(expanded);
+      submitPrompt(expanded);
     },
-    [showPopup, filteredCommands, selectedIndex, onSubmit, enterSelectCommand]
+    [showPopup, filteredCommands, selectedIndex, enterSelectCommand, submitPrompt]
   );
   useInput2(
     (_input, key) => {
@@ -2861,6 +3710,17 @@ function InputArea({
     },
     { isActive: showPopup && !isDisabled }
   );
+  useInput2(
+    (_input, key) => {
+      const action = getPromptHistoryInputAction(key);
+      if (!action) return;
+      const result = navigatePromptHistory(value, promptHistory, historyState, action);
+      setValue(result.value);
+      setCursorHint(result.cursorHint);
+      setHistoryState(result.state);
+    },
+    { isActive: !showPopup && !isDisabled && !pendingPrompt }
+  );
   useInput2(
     (_input, key) => {
       if (getPendingPromptInputAction(key) === "cancelQueue" && pendingPrompt) {
@@ -2880,8 +3740,8 @@ function InputArea({
     }
     return { left: "\u250C" + "\u2500".repeat(innerWidth), label: "", right: "\u2510" };
   })();
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
-    showPopup && /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ jsx10(
       SlashAutocomplete,
       {
         commands: filteredCommands,
@@ -2890,32 +3750,34 @@ function InputArea({
         isSubcommandMode
       }
     ),
-    /* @__PURE__ */ jsxs5(Text7, { color: borderColor, children: [
+    /* @__PURE__ */ jsxs7(Text9, { color: borderColor, children: [
       topBorder.left,
-      topBorder.label ? /* @__PURE__ */ jsx6(Text7, { backgroundColor: borderColor, color: "black", bold: true, children: topBorder.label }) : null,
+      topBorder.label ? /* @__PURE__ */ jsx10(Text9, { backgroundColor: borderColor, color: "black", bold: true, children: topBorder.label }) : null,
       topBorder.right
     ] }),
-    /* @__PURE__ */ jsx6(Box5, { borderStyle: "single", borderTop: false, borderColor, paddingLeft: 1, children: isAborting ? /* @__PURE__ */ jsx6(Text7, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ jsxs5(Text7, { color: "cyan", children: [
+    /* @__PURE__ */ jsx10(Box7, { borderStyle: "single", borderTop: false, borderColor, paddingLeft: 1, children: isAborting ? /* @__PURE__ */ jsx10(Text9, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ jsxs7(Text9, { color: "cyan", children: [
       " ",
       "Queued: ",
       pendingPrompt.length > 50 ? pendingPrompt.slice(0, 47) + "..." : pendingPrompt,
       " ",
-      /* @__PURE__ */ jsx6(Text7, { dimColor: true, children: "(Backspace to cancel)" })
-    ] }) : isDisabled ? /* @__PURE__ */ jsx6(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx6(Text7, { color: "green", bold: true, children: "> " }),
-      /* @__PURE__ */ jsx6(
+      /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "(Backspace to cancel)" })
+    ] }) : isDisabled ? /* @__PURE__ */ jsx10(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx10(Text9, { color: "green", bold: true, children: "> " }),
+      /* @__PURE__ */ jsx10(
         CjkTextInput,
         {
           value,
           onChange: (v) => {
             setValue(v);
+            resetHistoryNavigation();
             setCursorHint(null);
           },
           onSubmit: handleSubmit,
           onPaste: handlePaste,
           placeholder: "Type a message or /help",
           availableWidth,
-          cursorHint
+          cursorHint,
+          enableVerticalNavigation: false
         }
       )
     ] }) })
@@ -2923,8 +3785,8 @@ function InputArea({
 }
 
 // src/ui/ConfirmPrompt.tsx
-import { useState as useState7, useRef as useRef5, useCallback as useCallback5 } from "react";
-import { Box as Box6, Text as Text8, useInput as useInput3 } from "ink";
+import { useState as useState8, useRef as useRef5, useCallback as useCallback5 } from "react";
+import { Box as Box8, Text as Text10, useInput as useInput3 } from "ink";
 
 // src/ui/flows/selection-flow.ts
 function createSelectionFlowState() {
@@ -3027,13 +3889,13 @@ function applyConfirmPromptInput(state, action, optionCount) {
 }
 
 // src/ui/ConfirmPrompt.tsx
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
 function ConfirmPrompt({
   message,
   options = ["Yes", "No"],
   onSelect
 }) {
-  const [state, setState] = useState7(() => createSelectionFlowState());
+  const [state, setState] = useState8(() => createSelectionFlowState());
   const stateRef = useRef5(state);
   const applyAction = useCallback5(
     (action) => {
@@ -3052,10 +3914,10 @@ function ConfirmPrompt({
       applyAction(action);
     }
   });
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx7(Text8, { color: "yellow", children: message }),
-    /* @__PURE__ */ jsx7(Box6, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ jsx7(Box6, { marginRight: 2, children: /* @__PURE__ */ jsxs6(
-      Text8,
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx11(Text10, { color: "yellow", children: message }),
+    /* @__PURE__ */ jsx11(Box8, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ jsx11(Box8, { marginRight: 2, children: /* @__PURE__ */ jsxs8(
+      Text10,
       {
         color: i === state.selectedIndex ? "cyan" : void 0,
         bold: i === state.selectedIndex,
@@ -3065,16 +3927,81 @@ function ConfirmPrompt({
         ]
       }
     ) }, opt)) }),
-    /* @__PURE__ */ jsx7(Text8, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
+    /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
   ] });
 }
 
-// src/ui/ProviderSetupPrompt.tsx
-import { useState as useState9 } from "react";
+// src/ui/InteractivePrompt.tsx
+import { Box as Box11, Text as Text13 } from "ink";
+
+// src/ui/ListPicker.tsx
+import { useState as useState9, useRef as useRef6, useCallback as useCallback6 } from "react";
+import { Box as Box9, Text as Text11, useInput as useInput4 } from "ink";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+var DEFAULT_MAX_VISIBLE = 3;
+function ListPicker({
+  items,
+  renderItem,
+  onSelect,
+  onCancel,
+  maxVisible = DEFAULT_MAX_VISIBLE
+}) {
+  const [state, setState] = useState9(() => createSelectionFlowState());
+  const stateRef = useRef6(state);
+  const applyAction = useCallback6(
+    (action) => {
+      const result = applySelectionInput(stateRef.current, action, {
+        itemCount: items.length,
+        maxVisible
+      });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onCancel();
+      } else if (result.effect.type === "select") {
+        const item = items[result.effect.index];
+        if (item !== void 0) {
+          onSelect(item);
+        }
+      }
+    },
+    [items, maxVisible, onCancel, onSelect]
+  );
+  useInput4((_input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx12(Box9, {});
+  }
+  const normalizedState = normalizeSelectionState(state, { itemCount: items.length, maxVisible });
+  if (normalizedState !== state) {
+    stateRef.current = normalizedState;
+  }
+  const { selectedIndex, scrollOffset } = normalizedState;
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxVisible);
+  const hasMore = scrollOffset + maxVisible < items.length;
+  const hasLess = scrollOffset > 0;
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    hasLess && /* @__PURE__ */ jsxs9(Text11, { dimColor: true, children: [
+      " \u2191 ",
+      scrollOffset,
+      " more above"
+    ] }),
+    visibleItems.map((item, index) => /* @__PURE__ */ jsx12(Box9, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
+    hasMore && /* @__PURE__ */ jsxs9(Text11, { dimColor: true, children: [
+      " \u2193 ",
+      items.length - scrollOffset - maxVisible,
+      " more below"
+    ] })
+  ] });
+}
 
 // src/ui/TextPrompt.tsx
-import { useState as useState8, useRef as useRef6, useCallback as useCallback6 } from "react";
-import { Box as Box7, Text as Text9, useInput as useInput4 } from "ink";
+import { useState as useState10, useRef as useRef7, useCallback as useCallback7 } from "react";
+import { Box as Box10, Text as Text12, useInput as useInput5 } from "ink";
 
 // src/ui/flows/text-prompt-flow.ts
 function createTextPromptFlowState() {
@@ -3133,7 +4060,7 @@ function submitTextPromptValue(state, options) {
 }
 
 // src/ui/TextPrompt.tsx
-import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
 function TextPrompt({
   title,
   placeholder,
@@ -3143,9 +4070,9 @@ function TextPrompt({
   allowEmpty = false,
   masked = false
 }) {
-  const [state, setState] = useState8(() => createTextPromptFlowState());
-  const stateRef = useRef6(state);
-  const applyAction = useCallback6(
+  const [state, setState] = useState10(() => createTextPromptFlowState());
+  const stateRef = useRef7(state);
+  const applyAction = useCallback7(
     (action) => {
       const result = applyTextPromptInput(stateRef.current, action, { allowEmpty, validate });
       stateRef.current = result.state;
@@ -3158,64 +4085,67 @@ function TextPrompt({
     },
     [allowEmpty, validate, onCancel, onSubmit]
   );
-  useInput4((input, key) => {
+  useInput5((input, key) => {
     const action = getTextPromptInputAction(input, key);
     if (action !== void 0) {
       applyAction(action);
     }
   });
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx8(Text9, { color: "yellow", bold: true, children: title }),
-    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx8(Text9, { color: "cyan", children: "> " }),
-      state.value ? /* @__PURE__ */ jsx8(Text9, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ jsx8(Text9, { dimColor: true, children: placeholder }) : null,
-      /* @__PURE__ */ jsx8(Text9, { color: "cyan", children: "\u2588" })
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx13(Text12, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx13(Text12, { color: "cyan", children: "> " }),
+      state.value ? /* @__PURE__ */ jsx13(Text12, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ jsx13(Text12, { dimColor: true, children: placeholder }) : null,
+      /* @__PURE__ */ jsx13(Text12, { color: "cyan", children: "\u2588" })
     ] }),
-    state.error && /* @__PURE__ */ jsx8(Text9, { color: "red", children: state.error }),
-    /* @__PURE__ */ jsx8(Text9, { dimColor: true, children: " Enter Submit Esc Cancel" })
+    state.error && /* @__PURE__ */ jsx13(Text12, { color: "red", children: state.error }),
+    /* @__PURE__ */ jsx13(Text12, { dimColor: true, children: " Enter Submit Esc Cancel" })
   ] });
 }
 
-// src/ui/ProviderSetupPrompt.tsx
-import { jsx as jsx9 } from "react/jsx-runtime";
-function ProviderSetupPrompt({
-  type,
-  providerDefinitions,
+// src/ui/InteractivePrompt.tsx
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+function InteractivePrompt({
+  prompt,
   onSubmit,
   onCancel
 }) {
-  const [state, setState] = useState9(
-    () => 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__ */ jsx9(
-    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__ */ jsx14(
+      TextPrompt,
+      {
+        title: prompt.title,
+        placeholder: prompt.placeholder,
+        allowEmpty: prompt.allowEmpty,
+        masked: prompt.masked,
+        validate: prompt.validate,
+        onSubmit,
+        onCancel
+      },
+      `text:${prompt.title}`
+    );
+  }
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx14(Text13, { bold: true, children: prompt.title }),
+    /* @__PURE__ */ jsx14(
+      ListPicker,
+      {
+        items: [...prompt.options],
+        maxVisible: prompt.maxVisible,
+        renderItem: (option, isSelected) => /* @__PURE__ */ jsxs11(Text13, { color: isSelected ? "cyan" : void 0, children: [
+          isSelected ? "> " : "  ",
+          option.label
+        ] }),
+        onSelect: (option) => onSubmit(option.value),
+        onCancel
+      }
+    )
+  ] });
 }
 
 // src/ui/PermissionPrompt.tsx
-import React9 from "react";
-import { Box as Box8, Text as Text10, useInput as useInput5 } from "ink";
+import React10 from "react";
+import { Box as Box12, Text as Text14, useInput as useInput6 } from "ink";
 
 // src/ui/flows/permission-prompt-flow.ts
 var PERMISSION_PROMPT_OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
@@ -3266,23 +4196,23 @@ function resolvePermissionIndex(state, index) {
 }
 
 // src/ui/PermissionPrompt.tsx
-import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
 function formatArgs(args) {
   const entries = Object.entries(args);
   if (entries.length === 0) return "(no arguments)";
   return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
 }
 function PermissionPrompt({ request }) {
-  const [state, setState] = React9.useState(() => createSelectionFlowState());
-  const stateRef = React9.useRef(state);
-  const prevRequestRef = React9.useRef(request);
+  const [state, setState] = React10.useState(() => createSelectionFlowState());
+  const stateRef = React10.useRef(state);
+  const prevRequestRef = React10.useRef(request);
   if (prevRequestRef.current !== request) {
     prevRequestRef.current = request;
     const nextState = createSelectionFlowState();
     stateRef.current = nextState;
     setState(nextState);
   }
-  const applyAction = React9.useCallback(
+  const applyAction = React10.useCallback(
     (action) => {
       const result = applyPermissionPromptInput(stateRef.current, action);
       stateRef.current = result.state;
@@ -3293,25 +4223,25 @@ function PermissionPrompt({ request }) {
     },
     [request]
   );
-  useInput5((input, key) => {
+  useInput6((input, key) => {
     const action = getPermissionPromptInputAction(input, key);
     if (action !== void 0) {
       applyAction(action);
     }
   });
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx10(Text10, { color: "yellow", bold: true, children: "[Permission Required]" }),
-    /* @__PURE__ */ jsxs8(Text10, { children: [
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx15(Text14, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ jsxs12(Text14, { children: [
       "Tool:",
       " ",
-      /* @__PURE__ */ jsx10(Text10, { color: "cyan", bold: true, children: request.toolName })
+      /* @__PURE__ */ jsx15(Text14, { color: "cyan", bold: true, children: request.toolName })
     ] }),
-    /* @__PURE__ */ jsxs8(Text10, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs12(Text14, { dimColor: true, children: [
       " ",
       formatArgs(request.toolArgs)
     ] }),
-    /* @__PURE__ */ jsx10(Box8, { marginTop: 1, children: PERMISSION_PROMPT_OPTIONS.map((opt, i) => /* @__PURE__ */ jsx10(Box8, { marginRight: 2, children: /* @__PURE__ */ jsxs8(
-      Text10,
+    /* @__PURE__ */ jsx15(Box12, { marginTop: 1, children: PERMISSION_PROMPT_OPTIONS.map((opt, i) => /* @__PURE__ */ jsx15(Box12, { marginRight: 2, children: /* @__PURE__ */ jsxs12(
+      Text14,
       {
         color: i === state.selectedIndex ? "cyan" : void 0,
         bold: i === state.selectedIndex,
@@ -3321,13 +4251,13 @@ function PermissionPrompt({ request }) {
         ]
       }
     ) }, opt)) }),
-    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: " left/right to select, Enter to confirm" })
+    /* @__PURE__ */ jsx15(Text14, { dimColor: true, children: " left/right to select, Enter to confirm" })
   ] });
 }
 
 // src/ui/StreamingIndicator.tsx
-import { Box as Box9, Text as Text11 } from "ink";
-import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Box as Box13, Text as Text15 } from "ink";
+import { Fragment as Fragment4, jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
 function getToolStyle(t) {
   if (t.isRunning) return { color: "yellow", icon: "\u27F3", strikethrough: false };
   if (t.result === "error") return { color: "red", icon: "\u2717", strikethrough: true };
@@ -3338,16 +4268,16 @@ function StreamingIndicator({ text, activeTools }) {
   const hasTools = activeTools.length > 0;
   const hasText = text.length > 0;
   if (!hasTools && !hasText) {
-    return /* @__PURE__ */ jsx11(Fragment3, {});
+    return /* @__PURE__ */ jsx16(Fragment4, {});
   }
-  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
-    hasTools && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx11(Text11, { color: "white", bold: true, children: "Tools:" }),
-      /* @__PURE__ */ jsx11(Text11, { children: " " }),
+  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+    hasTools && /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "Tools:" }),
+      /* @__PURE__ */ jsx16(Text15, { children: " " }),
       activeTools.map((t, i) => {
         const { color, icon, strikethrough } = getToolStyle(t);
-        return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxs9(Text11, { color, strikethrough, children: [
+        return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs13(Text15, { color, strikethrough, children: [
             "  ",
             icon,
             " ",
@@ -3356,25 +4286,25 @@ function StreamingIndicator({ text, activeTools }) {
             t.firstArg,
             ")"
           ] }),
-          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ jsx11(DiffBlock, { file: t.diffFile, lines: t.diffLines })
+          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ jsx16(ToolDiffBlock, { file: t.diffFile, lines: t.diffLines })
         ] }, `${t.toolName}-${i}`);
       })
     ] }),
-    hasText && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx11(Text11, { color: "cyan", bold: true, children: "Robota:" }),
-      /* @__PURE__ */ jsx11(Text11, { children: " " }),
-      /* @__PURE__ */ jsx11(Box9, { marginLeft: 2, children: /* @__PURE__ */ jsx11(Text11, { wrap: "wrap", children: renderMarkdown(text) }) })
+    hasText && /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text15, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ jsx16(Text15, { children: " " }),
+      /* @__PURE__ */ jsx16(Box13, { marginLeft: 2, children: /* @__PURE__ */ jsx16(Text15, { wrap: "wrap", children: renderMarkdown(text) }) })
     ] })
   ] });
 }
 
 // src/ui/PluginTUI.tsx
-import { useState as useState12, useCallback as useCallback8 } from "react";
+import { useState as useState13, useCallback as useCallback9 } from "react";
 
 // src/ui/MenuSelect.tsx
-import { useState as useState10, useCallback as useCallback7, useRef as useRef7 } from "react";
-import { Box as Box10, Text as Text12, useInput as useInput6 } from "ink";
-import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+import { useState as useState11, useCallback as useCallback8, useRef as useRef8 } from "react";
+import { Box as Box14, Text as Text16, useInput as useInput7 } from "ink";
+import { jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
 function MenuSelect({
   title,
   items,
@@ -3383,10 +4313,10 @@ function MenuSelect({
   loading,
   error
 }) {
-  const [state, setState] = useState10(() => createSelectionFlowState());
-  const stateRef = useRef7(state);
+  const [state, setState] = useState11(() => createSelectionFlowState());
+  const stateRef = useRef8(state);
   const isEnabled = !loading && !error;
-  const applyAction = useCallback7(
+  const applyAction = useCallback8(
     (action) => {
       const result = applySelectionInput(stateRef.current, action, {
         itemCount: items.length,
@@ -3405,7 +4335,7 @@ function MenuSelect({
     },
     [isEnabled, items, onBack, onSelect]
   );
-  useInput6((input, key) => {
+  useInput7((input, key) => {
     const action = getVerticalSelectionInputAction(key);
     if (action !== void 0) {
       applyAction(action);
@@ -3416,24 +4346,24 @@ function MenuSelect({
     stateRef.current = normalizedState;
   }
   const selected = normalizedState.selectedIndex;
-  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx12(Text12, { color: "yellow", bold: true, children: title }),
-    loading && /* @__PURE__ */ jsx12(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Loading..." }) }),
-    error && /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx12(Text12, { color: "red", children: error }),
-      /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Press Esc to go back" })
+  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx17(Text16, { color: "yellow", bold: true, children: title }),
+    loading && /* @__PURE__ */ jsx17(Box14, { marginTop: 1, children: /* @__PURE__ */ jsx17(Text16, { dimColor: true, children: "Loading..." }) }),
+    error && /* @__PURE__ */ jsxs14(Box14, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx17(Text16, { color: "red", children: error }),
+      /* @__PURE__ */ jsx17(Text16, { dimColor: true, children: "Press Esc to go back" })
     ] }),
-    !loading && !error && /* @__PURE__ */ jsx12(Box10, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ jsxs10(Box10, { children: [
-      /* @__PURE__ */ jsxs10(Text12, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+    !loading && !error && /* @__PURE__ */ jsx17(Box14, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ jsxs14(Box14, { children: [
+      /* @__PURE__ */ jsxs14(Text16, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
         i === selected ? "> " : "  ",
         item.label
       ] }),
-      item.hint && /* @__PURE__ */ jsxs10(Text12, { dimColor: true, children: [
+      item.hint && /* @__PURE__ */ jsxs14(Text16, { dimColor: true, children: [
         " ",
         item.hint
       ] })
     ] }, item.value)) }),
-    /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
+    /* @__PURE__ */ jsx17(Text16, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
   ] });
 }
 
@@ -3530,11 +4460,11 @@ function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
 }
 
 // src/ui/hooks/usePluginScreenData.ts
-import { useState as useState11, useEffect as useEffect3 } from "react";
+import { useState as useState12, useEffect as useEffect3 } from "react";
 function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, stackLength) {
-  const [items, setItems] = useState11([]);
-  const [loading, setLoading] = useState11(false);
-  const [error, setError] = useState11();
+  const [items, setItems] = useState12([]);
+  const [loading, setLoading] = useState12(false);
+  const [error, setError] = useState12();
   useEffect3(() => {
     setItems([]);
     setError(void 0);
@@ -3590,16 +4520,16 @@ function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, sta
 }
 
 // src/ui/PluginTUI.tsx
-import { jsx as jsx13 } from "react/jsx-runtime";
+import { jsx as jsx18 } from "react/jsx-runtime";
 function PluginTUI({ callbacks, onClose, addMessage }) {
-  const [stack, setStack] = useState12([{ screen: "main" }]);
-  const [confirm, setConfirm] = useState12();
-  const [refreshCounter, setRefreshCounter] = useState12(0);
+  const [stack, setStack] = useState13([{ screen: "main" }]);
+  const [confirm, setConfirm] = useState13();
+  const [refreshCounter, setRefreshCounter] = useState13(0);
   const current = stack[stack.length - 1] ?? { screen: "main" };
-  const push = useCallback8((state) => {
+  const push = useCallback9((state) => {
     setStack((prev) => [...prev, state]);
   }, []);
-  const pop = useCallback8(() => {
+  const pop = useCallback9(() => {
     setStack((prev) => {
       if (prev.length <= 1) {
         onClose();
@@ -3608,7 +4538,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       return prev.slice(0, -1);
     });
   }, [onClose]);
-  const popN = useCallback8(
+  const popN = useCallback9(
     (n) => {
       setStack((prev) => {
         const next = prev.slice(0, Math.max(1, prev.length - n));
@@ -3621,20 +4551,20 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [onClose]
   );
-  const notify = useCallback8(
+  const notify = useCallback9(
     (content) => {
       addMessage?.({ role: "system", content });
     },
     [addMessage]
   );
-  const refresh = useCallback8(() => {
+  const refresh = useCallback9(() => {
     setRefreshCounter((c) => c + 1);
   }, []);
-  const setConfirmNav = useCallback8(
+  const setConfirmNav = useCallback9(
     (state) => setConfirm(state),
     [setConfirm]
   );
-  const pushNav = useCallback8(
+  const pushNav = useCallback9(
     (state) => push({ screen: state.screen, context: state.context }),
     [push]
   );
@@ -3646,7 +4576,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     refreshCounter,
     stack.length
   );
-  const handleSelect = useCallback8(
+  const handleSelect = useCallback9(
     (value) => {
       const screen2 = current.screen;
       const ctx = current.context;
@@ -3664,7 +4594,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
   );
-  const handleTextSubmit = useCallback8(
+  const handleTextSubmit = useCallback9(
     (value) => {
       if (current.screen === "marketplace-add") {
         callbacks.marketplaceAdd(value).then((name) => {
@@ -3679,7 +4609,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     [current.screen, callbacks, notify, pop]
   );
   if (confirm) {
-    return /* @__PURE__ */ jsx13(
+    return /* @__PURE__ */ jsx18(
       ConfirmPrompt,
       {
         message: confirm.message,
@@ -3692,7 +4622,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
   }
   const screen = current.screen;
   if (screen === "marketplace-add") {
-    return /* @__PURE__ */ jsx13(
+    return /* @__PURE__ */ jsx18(
       TextPrompt,
       {
         title: "Add Marketplace Source",
@@ -3704,7 +4634,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "marketplace-action") {
-    return /* @__PURE__ */ jsx13(
+    return /* @__PURE__ */ jsx18(
       MenuSelect,
       {
         title: `Marketplace: ${current.context?.marketplace ?? ""}`,
@@ -3720,7 +4650,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "marketplace-install-scope") {
-    return /* @__PURE__ */ jsx13(
+    return /* @__PURE__ */ jsx18(
       MenuSelect,
       {
         title: `Install scope for "${current.context?.pluginId ?? ""}"`,
@@ -3735,7 +4665,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "installed-action") {
-    return /* @__PURE__ */ jsx13(
+    return /* @__PURE__ */ jsx18(
       MenuSelect,
       {
         title: `Plugin: ${current.context?.pluginId ?? ""}`,
@@ -3758,7 +4688,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       { label: "Installed Plugins", value: "installed" }
     ]
   };
-  return /* @__PURE__ */ jsx13(
+  return /* @__PURE__ */ jsx18(
     MenuSelect,
     {
       title: titleMap[screen] ?? "Plugin Management",
@@ -3773,75 +4703,8 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
 }
 
 // src/ui/SessionPicker.tsx
-import { Box as Box12, Text as Text14 } from "ink";
-
-// src/ui/ListPicker.tsx
-import { useState as useState13, useRef as useRef8, useCallback as useCallback9 } from "react";
-import { Box as Box11, Text as Text13, useInput as useInput7 } from "ink";
-import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
-var DEFAULT_MAX_VISIBLE = 3;
-function ListPicker({
-  items,
-  renderItem,
-  onSelect,
-  onCancel,
-  maxVisible = DEFAULT_MAX_VISIBLE
-}) {
-  const [state, setState] = useState13(() => createSelectionFlowState());
-  const stateRef = useRef8(state);
-  const applyAction = useCallback9(
-    (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]
-  );
-  useInput7((_input, key) => {
-    const action = getVerticalSelectionInputAction(key);
-    if (action !== void 0) {
-      applyAction(action);
-    }
-  });
-  if (items.length === 0) {
-    return /* @__PURE__ */ jsx14(Box11, {});
-  }
-  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__ */ jsxs11(Box11, { flexDirection: "column", children: [
-    hasLess && /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
-      " \u2191 ",
-      scrollOffset,
-      " more above"
-    ] }),
-    visibleItems.map((item, index) => /* @__PURE__ */ jsx14(Box11, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
-    hasMore && /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
-      " \u2193 ",
-      items.length - scrollOffset - maxVisible,
-      " more below"
-    ] })
-  ] });
-}
-
-// src/ui/SessionPicker.tsx
-import { Fragment as Fragment4, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+import { Box as Box15, Text as Text17 } from "ink";
+import { Fragment as Fragment5, jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
 var SESSION_ID_DISPLAY_LENGTH = 8;
 function SessionPicker({
   sessionStore,
@@ -3850,9 +4713,9 @@ function SessionPicker({
   onCancel
 }) {
   const sessions = (sessionStore?.list() ?? []).filter((s) => s.cwd === cwd);
-  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ jsx15(Text14, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
-    /* @__PURE__ */ jsx15(
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx19(Text17, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
+    /* @__PURE__ */ jsx19(
       ListPicker,
       {
         items: sessions,
@@ -3863,24 +4726,24 @@ function SessionPicker({
           });
           const rawPreview = lastMsg?.content?.replace(/[\n\r]+/g, " ").trim() ?? "";
           const preview = rawPreview ? rawPreview.slice(0, 60) + (rawPreview.length > 60 ? "..." : "") : "";
-          return /* @__PURE__ */ jsxs12(Text14, { children: [
+          return /* @__PURE__ */ jsxs15(Text17, { children: [
             isSelected ? "> " : "  ",
-            /* @__PURE__ */ jsx15(Text14, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
+            /* @__PURE__ */ jsx19(Text17, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
             "  ",
-            /* @__PURE__ */ jsx15(Text14, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
+            /* @__PURE__ */ jsx19(Text17, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
               month: "short",
               day: "numeric",
               hour: "2-digit",
               minute: "2-digit"
             }) }),
             "  ",
-            /* @__PURE__ */ jsxs12(Text14, { dimColor: true, children: [
+            /* @__PURE__ */ jsxs15(Text17, { dimColor: true, children: [
               "msgs: ",
               session.messages.length
             ] }),
-            preview ? /* @__PURE__ */ jsxs12(Fragment4, { children: [
+            preview ? /* @__PURE__ */ jsxs15(Fragment5, { children: [
               "\n    ",
-              /* @__PURE__ */ jsx15(Text14, { color: "gray", children: preview })
+              /* @__PURE__ */ jsx19(Text17, { color: "gray", children: preview })
             ] }) : null
           ] });
         },
@@ -3892,54 +4755,382 @@ function SessionPicker({
 }
 
 // src/ui/BackgroundTaskPanel.tsx
-import { Box as Box13, Text as Text15 } from "ink";
-import { jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
+import { Box as Box16, Text as Text18 } from "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
+import { jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
 function BackgroundTaskPanel({ tasks }) {
   if (tasks.length === 0) return null;
-  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx16(Text15, { color: "cyan", bold: true, children: "Background" }),
-    tasks.map((task) => /* @__PURE__ */ jsxs13(Text15, { children: [
-      "- ",
-      /* @__PURE__ */ jsx16(Text15, { color: getStatusColor(task.status), children: getStatusMarker(task.status) }),
-      ` ${task.kind}:${task.label} ${task.id}`,
-      task.status === "running" && formatAge(task.lastActivityAt) ? /* @__PURE__ */ jsx16(Text15, { dimColor: true, children: ` idle ${formatAge(task.lastActivityAt)}` }) : null,
-      task.timeoutReason ? /* @__PURE__ */ jsx16(Text15, { dimColor: true, children: ` (${task.timeoutReason})` }) : null,
-      getTaskPreview(task) ? /* @__PURE__ */ jsx16(Text15, { dimColor: true, children: ` - ${getTaskPreview(task)}` }) : null
-    ] }, task.id))
+  return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx20(Text18, { color: "cyan", bold: true, children: "Background work" }),
+    tasks.map((task, index) => {
+      const row = formatBackgroundTaskRow(task, { isLast: index === tasks.length - 1 });
+      return /* @__PURE__ */ jsxs16(Text18, { children: [
+        `${row.connector} `,
+        /* @__PURE__ */ jsx20(Text18, { color: row.color, children: row.marker }),
+        ` ${row.label}`,
+        row.segments.map((segment, segmentIndex) => /* @__PURE__ */ jsx20(Text18, { dimColor: true, children: ` \xB7 ${segment}` }, `${segment}-${segmentIndex}`)),
+        row.preview ? /* @__PURE__ */ jsx20(Text18, { dimColor: true, children: ` \xB7 ${row.preview}` }) : null
+      ] }, task.id);
+    })
   ] });
 }
 
+// src/ui/UpdateNotice.tsx
+import { Box as Box17, Text as Text19 } from "ink";
+import { jsx as jsx21 } from "react/jsx-runtime";
+function UpdateNotice({ message }) {
+  return /* @__PURE__ */ jsx21(Box17, { paddingX: 1, marginBottom: 1, children: /* @__PURE__ */ jsx21(Text19, { color: "yellow", children: message }) });
+}
+
+// src/utils/update-check.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, join as join8 } from "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 join8(home, ".robota", "update-check.json");
+}
+function readUpdateCheckCache(path) {
+  if (!existsSync5(path)) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    return parseUpdateCheckCache(parsed);
+  } catch {
+    return void 0;
+  }
+}
+function writeUpdateCheckCache(path, cache) {
+  mkdirSync3(dirname4(path), { recursive: true });
+  writeFileSync2(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
-import { jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
+import { jsx as jsx22, jsxs as jsxs17 } from "react/jsx-runtime";
 function App(props) {
   const [activeSessionId, setActiveSessionId] = useState14(props.resumeSessionId);
-  return /* @__PURE__ */ jsx17(
+  return /* @__PURE__ */ jsx22(
     AppInner,
     {
       ...props,
@@ -3951,7 +5142,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,
@@ -3987,31 +5178,49 @@ function AppInner(props) {
   const pluginCallbacks = usePluginCallbacks(cwd);
   const { exit } = useApp2();
   const [sessionName, setSessionName] = useState14(props.sessionName);
+  const [updateNotice, setUpdateNotice] = useState14();
+  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
   });
   useEffect4(() => {
     const name = interactiveSession?.getName?.();
     if (name && !sessionName) setSessionName(name);
   }, [interactiveSession, sessionName]);
+  useEffect4(() => {
+    let isMounted = true;
+    props.startupUpdateNoticePromise?.then((notice) => {
+      if (isMounted && notice !== void 0) {
+        setUpdateNotice(notice);
+      }
+    }).catch(() => {
+    });
+    return () => {
+      isMounted = false;
+    };
+  }, [props.startupUpdateNoticePromise]);
   useEffect4(() => {
     const title = sessionName ? `Robota \u2014 ${sessionName}` : "Robota";
     process.stdout.write(`\x1B]0;${title}\x07`);
@@ -4045,51 +5254,51 @@ function AppInner(props) {
     sessionId = session.getSessionId();
   } catch {
   }
-  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ jsx17(Text16, { color: "cyan", bold: true, children: `
+  return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx22(Text20, { color: "cyan", bold: true, children: `
   ____   ___  ____   ___ _____  _
  |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
  | |_) | | | |  _ \\| | | || | / _ \\
  |  _ <| |_| | |_) | |_| || |/ ___ \\
  |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
 ` }),
-      /* @__PURE__ */ jsxs14(Text16, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs17(Text20, { dimColor: true, children: [
         " v",
         props.version ?? "0.0.0"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ jsx17(MessageList, { history }),
-      isShuttingDown && /* @__PURE__ */ jsx17(Box14, { marginBottom: 1, children: /* @__PURE__ */ jsx17(Text16, { color: "yellow", children: "Shutting down..." }) }),
-      (isThinking || activeTools.length > 0) && /* @__PURE__ */ jsx17(Box14, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx17(StreamingIndicator, { text: streamingText, activeTools }) }),
-      /* @__PURE__ */ jsx17(BackgroundTaskPanel, { tasks: backgroundTasks })
+    updateNotice && /* @__PURE__ */ jsx22(UpdateNotice, { message: formatCliUpdateNotice(updateNotice) }),
+    /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsx22(MessageList, { history }),
+      isShuttingDown && /* @__PURE__ */ jsx22(Box18, { marginBottom: 1, children: /* @__PURE__ */ jsx22(Text20, { color: "yellow", children: "Shutting down..." }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ jsx22(Box18, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx22(StreamingIndicator, { text: streamingText, activeTools }) }),
+      /* @__PURE__ */ jsx22(BackgroundTaskPanel, { tasks: backgroundTasks })
     ] }),
-    permissionRequest && /* @__PURE__ */ jsx17(PermissionPrompt, { request: permissionRequest }),
-    pendingModelId && /* @__PURE__ */ jsx17(
+    permissionRequest && /* @__PURE__ */ jsx22(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ jsx22(
       ConfirmPrompt,
       {
-        message: `Change model to ${getModelName2(pendingModelId)}? This will restart the session.`,
+        message: `Change model to ${getModelName3(pendingModelId)}? This will restart the session.`,
         onSelect: handleModelConfirm
       }
     ),
-    pendingProviderProfile && /* @__PURE__ */ jsx17(
+    pendingProviderProfile && /* @__PURE__ */ jsx22(
       ConfirmPrompt,
       {
         message: `Change provider to ${pendingProviderProfile}? This will restart the session.`,
         onSelect: handleProviderConfirm
       }
     ),
-    pendingProviderSetupType && /* @__PURE__ */ jsx17(
-      ProviderSetupPrompt,
+    pendingInteractionPrompt && /* @__PURE__ */ jsx22(
+      InteractivePrompt,
       {
-        type: pendingProviderSetupType,
-        providerDefinitions,
-        onSubmit: handleProviderSetupSubmit,
-        onCancel: handleProviderSetupCancel
+        prompt: pendingInteractionPrompt,
+        onSubmit: handleInteractionSubmit,
+        onCancel: handleInteractionCancel
       }
     ),
-    showPluginTUI && /* @__PURE__ */ jsx17(
+    showPluginTUI && /* @__PURE__ */ jsx22(
       PluginTUI,
       {
         callbacks: pluginCallbacks,
@@ -4097,7 +5306,7 @@ function AppInner(props) {
         addMessage: (msg) => addEntry(messageToHistoryEntry4(createSystemMessage4(msg.content)))
       }
     ),
-    showSessionPicker && /* @__PURE__ */ jsx17(
+    showSessionPicker && /* @__PURE__ */ jsx22(
       SessionPicker,
       {
         sessionStore: props.sessionStore,
@@ -4112,38 +5321,42 @@ function AppInner(props) {
         }
       }
     ),
-    /* @__PURE__ */ jsx17(
-      StatusBar,
+    /* @__PURE__ */ jsx22(
+      SessionStatusBar,
       {
+        cwd,
         permissionMode,
-        modelName: props.modelId ? getModelName2(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__ */ jsx17(
+    /* @__PURE__ */ jsx22(
       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__ */ jsx17(Text16, { children: " " })
+    /* @__PURE__ */ jsx22(Text20, { children: " " })
   ] });
 }
 
 // src/ui/render.tsx
-import { jsx as jsx18 } from "react/jsx-runtime";
+import { jsx as jsx23 } from "react/jsx-runtime";
 function renderApp(options) {
   process.on("unhandledRejection", (reason) => {
     process.stderr.write(`
@@ -4154,16 +5367,10 @@ function renderApp(options) {
 `);
     }
   });
-  if (process.stdin.isTTY && process.stdout.isTTY) {
-    process.stdout.write("\x1B[?2004h");
-  }
-  const instance = render(/* @__PURE__ */ jsx18(App, { ...options }), {
+  const instance = render(/* @__PURE__ */ jsx23(App, { ...options }), {
     exitOnCtrlC: false
   });
   instance.waitUntilExit().then(() => {
-    if (process.stdout.isTTY) {
-      process.stdout.write("\x1B[?2004l");
-    }
     process.exit(0);
   }).catch((err) => {
     if (err) {
@@ -4175,15 +5382,102 @@ function renderApp(options) {
   });
 }
 
+// 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
 function readVersion() {
   try {
     const thisFile = fileURLToPath(import.meta.url);
-    const dir = dirname3(thisFile);
-    const candidates = [join7(dir, "..", "..", "package.json"), join7(dir, "..", "package.json")];
+    const dir = dirname5(thisFile);
+    const candidates = [join9(dir, "..", "..", "package.json"), join9(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = readFileSync4(pkgPath, "utf-8");
+        const raw = readFileSync6(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version !== void 0 && pkg.name !== void 0) {
           return pkg.version;
@@ -4197,7 +5491,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;
@@ -4212,7 +5506,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) {
@@ -4242,8 +5536,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;
   }
@@ -4253,6 +5560,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;
@@ -4332,7 +5644,7 @@ ${args.jsonSchema}`
       appendSystemPrompt,
       backgroundTaskRunners,
       subagentRunnerFactory,
-      commandModules: options.commandModules
+      commandModules
     });
     const transport = createHeadlessTransport({
       outputFormat: args.outputFormat ?? "text",
@@ -4350,15 +5662,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
   });
 }