@robota-sdk/agent-cli 3.0.0-beta.54 → 3.0.0-beta.55

package/dist/node/index.cjs

@@ -30,15 +30,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ChildProcessSubagentRunner: () => ChildProcessSubagentRunner,
+  GitWorktreeIsolationAdapter: () => GitWorktreeIsolationAdapter,
+  createChildProcessSubagentRunnerFactory: () => createChildProcessSubagentRunnerFactory,
+  createGitWorktreeIsolationAdapter: () => createGitWorktreeIsolationAdapter,
+  createManagedShellProcessRunner: () => createManagedShellProcessRunner,
   startCli: () => startCli
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/cli.ts
-var import_node_fs3 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path8 = require("path");
 var import_node_url = require("url");
-var import_agent_sdk4 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk8 = require("@robota-sdk/agent-sdk");
 var import_agent_sessions = require("@robota-sdk/agent-sessions");
 
 // src/utils/cli-args.ts
@@ -80,7 +85,20 @@ function parseCliArgs() {
       "system-prompt": { type: "string" },
       "append-system-prompt": { type: "string" },
       version: { type: "boolean", default: false },
-      reset: { type: "boolean", default: false }
+      reset: { type: "boolean", default: false },
+      bare: { type: "boolean", default: false },
+      "allowed-tools": { type: "string" },
+      "no-session-persistence": { type: "boolean", default: false },
+      "json-schema": { type: "string" },
+      configure: { type: "boolean", default: false },
+      "configure-provider": { type: "string" },
+      provider: { type: "string" },
+      type: { type: "string" },
+      "base-url": { type: "string" },
+      "api-key": { type: "string" },
+      "api-key-env": { type: "string" },
+      "set-current": { type: "boolean", default: false },
+      "settings-scope": { type: "string" }
     }
   });
   return {
@@ -98,7 +116,20 @@ function parseCliArgs() {
     systemPrompt: values["system-prompt"],
     appendSystemPrompt: values["append-system-prompt"],
     version: values["version"] ?? false,
-    reset: values["reset"] ?? false
+    reset: values["reset"] ?? false,
+    bare: values["bare"] ?? false,
+    allowedTools: values["allowed-tools"],
+    noSessionPersistence: values["no-session-persistence"] ?? false,
+    jsonSchema: values["json-schema"],
+    configure: values["configure"] ?? false,
+    configureProvider: values["configure-provider"],
+    provider: values["provider"],
+    providerType: values["type"],
+    baseURL: values["base-url"],
+    apiKey: values["api-key"],
+    apiKeyEnv: values["api-key-env"],
+    setCurrent: values["set-current"] ?? false,
+    settingsScope: values["settings-scope"]
   };
 }
 
@@ -126,11 +157,26 @@ function writeSettings(path, settings) {
 }
 function updateModelInSettings(settingsPath, modelId) {
   const settings = readSettings(settingsPath);
-  const provider = settings.provider ?? {};
-  provider.model = modelId;
-  settings.provider = provider;
+  const currentProvider = settings.currentProvider;
+  const providers = settings.providers;
+  if (typeof currentProvider === "string" && isSettingsData(providers)) {
+    const providerMap = providers;
+    providerMap[currentProvider] = {
+      ...isSettingsData(providerMap[currentProvider]) ? providerMap[currentProvider] : {},
+      model: modelId
+    };
+    settings.providers = providerMap;
+  } else {
+    settings.provider = {
+      ...isSettingsData(settings.provider) ? settings.provider : {},
+      model: modelId
+    };
+  }
   writeSettings(settingsPath, settings);
 }
+function isSettingsData(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
 function deleteSettings(path) {
   if ((0, import_node_fs.existsSync)(path)) {
     (0, import_node_fs.unlinkSync)(path);
@@ -143,62 +189,556 @@ function deleteSettings(path) {
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 var import_node_os = require("os");
+
+// src/utils/provider-default-definitions.ts
 var import_agent_provider_anthropic = require("@robota-sdk/agent-provider-anthropic");
-function readProviderSettings(cwd) {
+var import_agent_provider_gemma = require("@robota-sdk/agent-provider-gemma");
+var import_agent_provider_openai = require("@robota-sdk/agent-provider-openai");
+var DEFAULT_PROVIDER_DEFINITIONS = [
+  (0, import_agent_provider_anthropic.createAnthropicProviderDefinition)(),
+  (0, import_agent_provider_openai.createOpenAIProviderDefinition)(),
+  (0, import_agent_provider_gemma.createGemmaProviderDefinition)()
+];
+
+// src/utils/provider-definition.ts
+var import_agent_core = require("@robota-sdk/agent-core");
+
+// src/utils/provider-factory.ts
+function readProviderSettings(cwd, options = {}) {
+  const merged = readMergedProviderSettings(cwd);
+  const providerConfig = resolveActiveProvider(
+    merged,
+    options.providerOverride,
+    getProviderDefinitions(options)
+  );
+  if (providerConfig !== void 0) {
+    return providerConfig;
+  }
+  throw new Error("No provider configuration found. Run `robota` to set up.");
+}
+function readMergedProviderSettings(cwd) {
   const paths = [
-    (0, import_node_path2.join)(cwd, ".robota", "settings.local.json"),
+    (0, import_node_path2.join)((0, import_node_os.homedir)(), ".robota", "settings.json"),
+    (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "settings.json"),
     (0, import_node_path2.join)(cwd, ".robota", "settings.json"),
-    (0, import_node_path2.join)(cwd, ".claude", "settings.local.json"),
+    (0, import_node_path2.join)(cwd, ".robota", "settings.local.json"),
     (0, import_node_path2.join)(cwd, ".claude", "settings.json"),
-    (0, import_node_path2.join)((0, import_node_os.homedir)(), ".robota", "settings.json"),
-    (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "settings.json")
+    (0, import_node_path2.join)(cwd, ".claude", "settings.local.json")
   ];
-  for (const filePath of paths) {
-    if (!(0, import_node_fs2.existsSync)(filePath)) continue;
-    try {
-      const raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
-      const parsed = JSON.parse(raw);
-      const provider = parsed.provider;
-      if (provider?.apiKey && provider?.name) {
-        return {
-          name: provider.name,
-          model: provider.model ?? "claude-sonnet-4-6",
-          apiKey: provider.apiKey
-        };
-      }
-    } catch {
-      continue;
+  return paths.reduce((settings, filePath) => {
+    const parsed = readSettingsFile(filePath);
+    if (parsed === void 0) {
+      return settings;
     }
+    return mergeSettings(settings, parsed);
+  }, {});
+}
+function readSettingsFile(filePath) {
+  if (!(0, import_node_fs2.existsSync)(filePath)) {
+    return void 0;
   }
-  throw new Error("No provider configuration found. Run `robota` to set up.");
+  try {
+    const raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function mergeSettings(base, override) {
+  return {
+    ...base,
+    ...override,
+    provider: base.provider !== void 0 || override.provider !== void 0 ? { ...base.provider, ...override.provider } : void 0,
+    providers: base.providers !== void 0 || override.providers !== void 0 ? mergeProviders(base.providers, override.providers) : void 0
+  };
+}
+function mergeProviders(base, override) {
+  const result = { ...base ?? {} };
+  for (const [name, profile] of Object.entries(override ?? {})) {
+    result[name] = { ...result[name], ...profile };
+  }
+  return result;
+}
+function resolveActiveProvider(settings, providerOverride, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  const activeProvider = providerOverride ?? settings.currentProvider;
+  if (activeProvider !== void 0) {
+    const profile = settings.providers?.[activeProvider];
+    if (profile === void 0) {
+      throw new Error(`Provider profile "${activeProvider}" was not found in providers`);
+    }
+    if (!profile.type) {
+      throw new Error(`Provider profile "${activeProvider}" is missing type`);
+    }
+    return normalizeProviderConfig(
+      {
+        name: profile.type,
+        model: profile.model,
+        apiKey: profile.apiKey,
+        baseURL: profile.baseURL,
+        timeout: profile.timeout
+      },
+      providerDefinitions
+    );
+  }
+  const provider = settings.provider;
+  if (provider?.name) {
+    return normalizeProviderConfig(
+      {
+        name: provider.name,
+        model: provider.model,
+        apiKey: provider.apiKey,
+        baseURL: provider.baseURL,
+        timeout: provider.timeout
+      },
+      providerDefinitions
+    );
+  }
+  return void 0;
 }
-function createProviderFromSettings(cwd, modelOverride) {
-  const settings = readProviderSettings(cwd);
+function normalizeProviderConfig(settings, providerDefinitions) {
+  const defaults = (0, import_agent_core.findProviderDefinition)(providerDefinitions, settings.name)?.defaults ?? {};
+  const model = settings.model ?? defaults.model;
+  if (!model) {
+    throw new Error(`Provider ${settings.name} requires model`);
+  }
+  return {
+    name: settings.name,
+    model,
+    apiKey: settings.apiKey !== void 0 ? resolveEnvRef(settings.apiKey) : defaults.apiKey,
+    baseURL: settings.baseURL ?? defaults.baseURL,
+    timeout: settings.timeout
+  };
+}
+function resolveEnvRef(value) {
+  const envPrefix = "$ENV:";
+  if (!value.startsWith(envPrefix)) {
+    return value;
+  }
+  const envName = value.slice(envPrefix.length);
+  return process.env[envName] ?? value;
+}
+function createProviderFromConfig(settings, providerDefinitions) {
+  const definition = (0, import_agent_core.findProviderDefinition)(providerDefinitions, settings.name);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${settings.name}. Currently supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`
+    );
+  }
+  if (definition.requiresApiKey === true && !settings.apiKey) {
+    throw new Error(`Provider ${settings.name} requires apiKey`);
+  }
+  return definition.createProvider(settings);
+}
+function createProviderFromSettings(cwd, modelOverride, options = {}) {
+  const providerDefinitions = getProviderDefinitions(options);
+  const settings = readProviderSettings(cwd, { ...options, providerDefinitions });
   const model = modelOverride ?? settings.model;
-  switch (settings.name) {
-    case "anthropic":
-      return new import_agent_provider_anthropic.AnthropicProvider({ apiKey: settings.apiKey, defaultModel: model });
-    default:
-      throw new Error(`Unknown provider: ${settings.name}. Currently supported: anthropic`);
+  return createProviderFromConfig({ ...settings, model }, providerDefinitions);
+}
+function getProviderDefinitions(options) {
+  return options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+}
+
+// src/utils/provider-setup.ts
+var import_node_path3 = require("path");
+var import_node_os2 = require("os");
+
+// src/utils/settings-check.ts
+var import_node_fs3 = require("fs");
+function checkSettingsFile(filePath, providerDefinitions = []) {
+  if (!(0, import_node_fs3.existsSync)(filePath)) return "missing";
+  try {
+    const raw = (0, import_node_fs3.readFileSync)(filePath, "utf8").trim();
+    if (raw.length === 0) return "incomplete";
+    const parsed = JSON.parse(raw);
+    if (!hasUsableProviderConfig(parsed, providerDefinitions)) return "incomplete";
+    return "valid";
+  } catch {
+    return "corrupt";
+  }
+}
+function hasUsableProviderConfig(settings, providerDefinitions) {
+  if (settings.provider && isUsableProviderProfile(settings.provider.name, settings.provider, providerDefinitions)) {
+    return true;
+  }
+  if (typeof settings.currentProvider !== "string") {
+    return false;
+  }
+  const profile = settings.providers?.[settings.currentProvider];
+  return isUsableProviderProfile(profile?.type, profile, providerDefinitions);
+}
+function isUsableProviderProfile(type, profile, providerDefinitions) {
+  if (!profile) {
+    return false;
+  }
+  if (profile.apiKey) {
+    return true;
+  }
+  if (!type) {
+    return false;
+  }
+  const definition = (0, import_agent_core.findProviderDefinition)(providerDefinitions, type);
+  if (definition === void 0) {
+    return false;
+  }
+  return definition.requiresApiKey !== true || definition.defaults?.apiKey !== void 0;
+}
+
+// src/utils/provider-settings.ts
+function upsertProviderProfile(settings, profileName, profile) {
+  return {
+    ...settings,
+    providers: {
+      ...settings.providers ?? {},
+      [profileName]: profile
+    }
+  };
+}
+function setCurrentProvider(settings, profileName) {
+  if (!settings.providers?.[profileName]) {
+    throw new Error(`Provider profile "${profileName}" was not found`);
+  }
+  return {
+    ...settings,
+    currentProvider: profileName
+  };
+}
+function validateProviderProfile(profileName, profile, options = {}) {
+  if (!profile.type) {
+    throw new Error(`Provider profile "${profileName}" is missing type`);
+  }
+  if (!profile.model) {
+    throw new Error(`Provider profile "${profileName}" is missing model`);
+  }
+  const definition = (0, import_agent_core.findProviderDefinition)(options.providerDefinitions ?? [], profile.type);
+  if (definition?.requiresApiKey === true && !profile.apiKey && definition.defaults?.apiKey === void 0) {
+    throw new Error(`Provider profile "${profileName}" is missing apiKey`);
   }
 }
+function buildProviderSetupPatch(input, options = {}) {
+  const profile = buildProviderProfile(input, options);
+  validateProviderProfile(input.profile, profile, options);
+  return {
+    ...input.setCurrent && { currentProvider: input.profile },
+    providers: {
+      [input.profile]: profile
+    }
+  };
+}
+function buildProviderProfile(input, options = {}) {
+  const defaults = getProviderDefaults(input.type, options.providerDefinitions ?? []);
+  const apiKey = input.apiKeyEnv !== void 0 ? `$ENV:${input.apiKeyEnv}` : input.apiKey ?? defaults.apiKey;
+  const baseURL = input.baseURL ?? defaults.baseURL;
+  return {
+    type: input.type,
+    model: input.model ?? defaults.model,
+    ...apiKey !== void 0 && { apiKey },
+    ...baseURL !== void 0 && { baseURL },
+    ...input.timeout !== void 0 && { timeout: input.timeout }
+  };
+}
+function getProviderDefaults(type, providerDefinitions) {
+  return (0, import_agent_core.findProviderDefinition)(providerDefinitions, type)?.defaults ?? {};
+}
+function mergeProviderPatch(settings, patch) {
+  const [profileName, profile] = Object.entries(patch.providers)[0] ?? [];
+  if (!profileName || !profile) {
+    return settings;
+  }
+  const withProfile = upsertProviderProfile(settings, profileName, profile);
+  return patch.currentProvider ? setCurrentProvider(withProfile, patch.currentProvider) : withProfile;
+}
+
+// src/utils/provider-configuration.ts
+function readProviderDocument(settingsPath) {
+  return readSettings(settingsPath);
+}
+function applyProviderConfiguration(settingsPath, input, options = {}) {
+  const settings = readProviderDocument(settingsPath);
+  const patch = buildProviderSetupPatch(input, options);
+  const next = mergeProviderPatch(settings, patch);
+  writeSettings(settingsPath, next);
+  return next;
+}
+function applyProviderSwitch(settingsPath, profileName, options = {}) {
+  const settings = readProviderDocument(settingsPath);
+  const hasLocalProfile = settings.providers?.[profileName] !== void 0;
+  const hasKnownProfile = options.knownProviders?.[profileName] !== void 0;
+  const next = hasLocalProfile || hasKnownProfile ? { ...settings, currentProvider: profileName } : setCurrentProvider(settings, profileName);
+  writeSettings(settingsPath, next);
+  return next;
+}
+
+// src/utils/provider-setup-flow.ts
+function createProviderSetupFlow(type, providerDefinitions) {
+  return {
+    type,
+    steps: getProviderSetupSteps(type, providerDefinitions),
+    stepIndex: 0,
+    values: {}
+  };
+}
+function getProviderSetupStep(state) {
+  const step = state.steps[state.stepIndex];
+  if (step === void 0) {
+    throw new Error(`Provider setup step ${state.stepIndex} is out of range`);
+  }
+  return step;
+}
+function submitProviderSetupValue(state, rawValue) {
+  const step = getProviderSetupStep(state);
+  const value = rawValue.trim() || step.defaultValue || "";
+  const validationMessage = validateProviderSetupValue(step, value);
+  if (validationMessage !== void 0) {
+    return { status: "error", state, message: validationMessage };
+  }
+  const nextState = {
+    ...state,
+    stepIndex: state.stepIndex + 1,
+    values: { ...state.values, [step.key]: value }
+  };
+  if (nextState.stepIndex < state.steps.length) {
+    return { status: "next", state: nextState };
+  }
+  return { status: "complete", input: buildProviderSetupInput(nextState) };
+}
+async function runProviderSetupPromptFlow(type, promptInput2, providerDefinitions) {
+  let state = createProviderSetupFlow(type, providerDefinitions);
+  const stepCount = state.steps.length;
+  while (state.stepIndex < stepCount) {
+    const step = getProviderSetupStep(state);
+    const value = await promptInput2(formatProviderSetupPromptLabel(step), step.masked === true);
+    const result = submitProviderSetupValue(state, value);
+    if (result.status === "complete") {
+      return result.input;
+    }
+    if (result.status === "error") {
+      throw new Error(result.message);
+    }
+    state = result.state;
+  }
+  throw new Error("Provider setup flow ended without completion");
+}
+function formatProviderSetupPromptLabel(step) {
+  const suffix = step.defaultValue !== void 0 ? ` (default: ${step.defaultValue})` : "";
+  return `  ${step.title}${suffix}: `;
+}
+function validateProviderSetupValue(step, value) {
+  if (step.required === true && value.length === 0) {
+    return "Required";
+  }
+  return void 0;
+}
+function getProviderSetupSteps(type, providerDefinitions) {
+  const definition = (0, import_agent_core.findProviderDefinition)(providerDefinitions, type);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${type}. Currently supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`
+    );
+  }
+  if (definition.setupSteps !== void 0) {
+    return [...definition.setupSteps];
+  }
+  const steps = [
+    {
+      key: "model",
+      title: `${definition.type} model`,
+      defaultValue: definition.defaults?.model,
+      required: definition.defaults?.model === void 0
+    }
+  ];
+  if (definition.defaults?.baseURL !== void 0) {
+    steps.unshift({
+      key: "baseURL",
+      title: `${definition.type} base URL`,
+      defaultValue: definition.defaults.baseURL
+    });
+  }
+  if (definition.requiresApiKey === true) {
+    steps.push({
+      key: "apiKey",
+      title: `${definition.type} API key`,
+      defaultValue: definition.defaults?.apiKey,
+      required: definition.defaults?.apiKey === void 0,
+      masked: true
+    });
+  }
+  return steps;
+}
+function buildProviderSetupInput(state) {
+  return {
+    profile: state.type,
+    type: state.type,
+    model: state.values.model,
+    apiKey: state.values.apiKey,
+    ...state.values.baseURL !== void 0 && { baseURL: state.values.baseURL },
+    setCurrent: true
+  };
+}
+
+// src/utils/provider-setup.ts
+function getSettingsPathForScope(cwd, scope) {
+  if (scope === void 0 || scope === "user") {
+    return getUserSettingsPath();
+  }
+  if (scope === "project-local") {
+    return (0, import_node_path3.join)(cwd, ".robota", "settings.local.json");
+  }
+  throw new Error(`Invalid --settings-scope "${scope}". Valid: user | project-local`);
+}
+function handleProviderConfigurationArgs(cwd, args, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  const settingsPath = getSettingsPathForScope(cwd, args.settingsScope);
+  if (args.configureProvider) {
+    applyProviderConfiguration(settingsPath, buildSetupInputFromArgs(args), {
+      providerDefinitions
+    });
+    process.stdout.write(`Provider profile saved to ${settingsPath}
+`);
+    return !args.printMode && args.positional.length === 0;
+  }
+  if (args.provider && args.setCurrent) {
+    applyProviderSwitch(settingsPath, args.provider, {
+      knownProviders: readMergedProviderSettings(cwd).providers
+    });
+    process.stdout.write(`Current provider set to ${args.provider}
+`);
+    return !args.printMode && args.positional.length === 0;
+  }
+  return false;
+}
+async function ensureConfig(cwd, args, promptInput2, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  const checks = getSettingsCheckPaths(cwd).map((path) => ({
+    path,
+    status: checkSettingsFile(path, providerDefinitions)
+  }));
+  if (checks.some((check) => check.status === "valid")) {
+    return;
+  }
+  if (!isInteractiveTerminal()) {
+    throw new Error(formatMissingProviderConfigMessage());
+  }
+  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 settingsPath = getSettingsPathForScope(cwd, args.settingsScope);
+  const input = await runProviderSetupPromptFlow(type, promptInput2, providerDefinitions);
+  applyProviderConfiguration(settingsPath, input, {
+    providerDefinitions
+  });
+  const language = await promptInput2("  Response language (ko/en/ja/zh, default: en): ");
+  if (language) {
+    const settings = readSettings(settingsPath);
+    settings.language = language;
+    writeSettings(settingsPath, settings);
+  }
+  process.stdout.write(`
+  Config saved to ${settingsPath}
+
+`);
+}
+function parseProviderSetupType(value) {
+  return value.trim();
+}
+function buildSetupInputFromArgs(args) {
+  const type = args.providerType ?? args.configureProvider;
+  if (!args.configureProvider || !type) {
+    throw new Error("--configure-provider requires a provider profile and --type");
+  }
+  return {
+    profile: args.configureProvider,
+    type,
+    ...args.model !== void 0 && { model: args.model },
+    ...args.apiKey !== void 0 && { apiKey: args.apiKey },
+    ...args.apiKeyEnv !== void 0 && { apiKeyEnv: args.apiKeyEnv },
+    ...args.baseURL !== void 0 && { baseURL: args.baseURL },
+    setCurrent: args.setCurrent
+  };
+}
+function getSettingsCheckPaths(cwd) {
+  return [
+    getUserSettingsPath(),
+    (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".claude", "settings.json"),
+    (0, import_node_path3.join)(cwd, ".robota", "settings.json"),
+    (0, import_node_path3.join)(cwd, ".robota", "settings.local.json"),
+    (0, import_node_path3.join)(cwd, ".claude", "settings.json"),
+    (0, import_node_path3.join)(cwd, ".claude", "settings.local.json")
+  ];
+}
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function formatMissingProviderConfigMessage() {
+  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"
+  ].join("\n");
+}
 
 // src/cli.ts
 var import_agent_transport_headless = require("@robota-sdk/agent-transport-headless");
 
 // src/ui/render.tsx
-var import_ink17 = require("ink");
+var import_ink18 = require("ink");
 
 // src/ui/App.tsx
-var import_react17 = require("react");
-var import_ink16 = require("ink");
-var import_agent_core5 = require("@robota-sdk/agent-core");
+var import_react18 = require("react");
+var import_ink17 = require("ink");
+var import_agent_core7 = require("@robota-sdk/agent-core");
 
 // src/ui/hooks/useInteractiveSession.ts
 var import_react2 = require("react");
-var import_node_os2 = require("os");
-var import_node_path3 = require("path");
-var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+var import_agent_sdk = require("@robota-sdk/agent-sdk");
+var import_agent_core3 = require("@robota-sdk/agent-core");
+
+// src/ui/background-task-view-model.ts
+var BACKGROUND_PREVIEW_LENGTH = 120;
+var BACKGROUND_PREVIEW_WHITESPACE = /\s+/g;
+var BACKGROUND_PREVIEW_SEPARATOR = " ";
+var SUCCESS_EXIT_CODE = 0;
+function toBackgroundTaskViewModel(state, partialText) {
+  return {
+    id: state.id,
+    kind: state.kind,
+    label: state.label,
+    status: state.status,
+    statusLabel: getBackgroundTaskStatusLabel(state),
+    mode: state.mode,
+    currentAction: state.currentAction,
+    unread: state.unread,
+    preview: trimBackgroundPreview(state.promptPreview ?? state.commandPreview) ?? "",
+    resultPreview: trimBackgroundPreview(state.result?.output ?? partialText),
+    errorPreview: trimBackgroundPreview(state.error?.message),
+    startedAt: state.startedAt,
+    lastActivityAt: state.lastActivityAt,
+    timeoutReason: state.timeoutReason
+  };
+}
+function getBackgroundTaskStatusLabel(state) {
+  if (state.status === "failed" && state.timeoutReason) {
+    if (state.timeoutReason === "idle" || state.timeoutReason === "max_runtime") {
+      return "timed out";
+    }
+    return state.timeoutReason.replace(/_/g, " ");
+  }
+  return state.status;
+}
+function shouldHideAtNextUserTurn(state) {
+  return state.status === "completed" && !state.error && (state.result?.exitCode === void 0 || state.result.exitCode === SUCCESS_EXIT_CODE) && !state.result?.signalCode && !state.worktreePath && !state.branchName;
+}
+function trimBackgroundPreview(value) {
+  if (!value) return void 0;
+  const preview = value.trim().replace(BACKGROUND_PREVIEW_WHITESPACE, BACKGROUND_PREVIEW_SEPARATOR);
+  if (!preview) return void 0;
+  return preview.length > BACKGROUND_PREVIEW_LENGTH ? `${preview.slice(0, BACKGROUND_PREVIEW_LENGTH)}...` : preview;
+}
 
 // src/ui/tui-state-manager.ts
 var MAX_RENDERED_MESSAGES = 100;
@@ -231,10 +771,13 @@ var TuiStateManager = class {
   isAborting = false;
   pendingPrompt = null;
   contextState = { percentage: 0, usedTokens: 0, maxTokens: 0 };
+  backgroundTasks = [];
   /** Called after any state change. React hook sets this to trigger re-render. */
   onChange = null;
   // ── Internal ──────────────────────────────────────────────────
   streamBuf = "";
+  backgroundTextBuffers = /* @__PURE__ */ new Map();
+  backgroundTasksHiddenOnNextTurn = /* @__PURE__ */ new Set();
   debouncedStreamNotify = createDebouncedNotify(() => this.notify(), STREAMING_DEBOUNCE_MS);
   notify() {
     this.onChange?.();
@@ -296,6 +839,30 @@ var TuiStateManager = class {
     this.activeTools = [];
     this.notify();
   };
+  onBackgroundTaskEvent = (event) => {
+    if ("task" in event) {
+      this.upsertBackgroundTask(event.task);
+      return;
+    }
+    if (event.type === "background_task_closed") {
+      this.backgroundTextBuffers.delete(event.taskId);
+      this.backgroundTasksHiddenOnNextTurn.delete(event.taskId);
+      this.backgroundTasks = this.backgroundTasks.filter((task) => task.id !== event.taskId);
+      this.notify();
+      return;
+    }
+    if (event.type === "background_task_text_delta") {
+      this.appendBackgroundTaskText(event.taskId, event.delta);
+      return;
+    }
+    if (event.type === "background_task_tool_start") {
+      this.updateBackgroundTaskAction(event.taskId, event.firstArg ?? event.toolName);
+      return;
+    }
+    if (event.type === "background_task_tool_end") {
+      this.updateBackgroundTaskAction(event.taskId, event.success ? void 0 : event.error);
+    }
+  };
   // ── State updates from external sources ───────────────────────
   /** Sync history from InteractiveSession */
   syncHistory(entries) {
@@ -324,16 +891,176 @@ var TuiStateManager = class {
     this.contextState = state;
     this.notify();
   }
+  onUserTurnAccepted() {
+    if (this.backgroundTasksHiddenOnNextTurn.size === 0) return;
+    const visible = this.backgroundTasks.filter(
+      (task) => !this.backgroundTasksHiddenOnNextTurn.has(task.id)
+    );
+    this.backgroundTasksHiddenOnNextTurn.clear();
+    if (visible.length === this.backgroundTasks.length) return;
+    this.backgroundTasks = visible;
+    this.notify();
+  }
+  upsertBackgroundTask(state) {
+    const partialText = state.result ? void 0 : this.backgroundTextBuffers.get(state.id);
+    const viewModel = toBackgroundTaskViewModel(state, partialText);
+    const index = this.backgroundTasks.findIndex((task) => task.id === state.id);
+    if (index === -1) {
+      this.backgroundTasks = [...this.backgroundTasks, viewModel];
+    } else {
+      const updated = [...this.backgroundTasks];
+      updated[index] = viewModel;
+      this.backgroundTasks = updated;
+    }
+    if (state.status === "completed" || state.status === "failed" || state.status === "cancelled") {
+      this.backgroundTextBuffers.delete(state.id);
+    }
+    if (shouldHideAtNextUserTurn(state)) {
+      this.backgroundTasksHiddenOnNextTurn.add(state.id);
+    } else {
+      this.backgroundTasksHiddenOnNextTurn.delete(state.id);
+    }
+    this.notify();
+  }
+  appendBackgroundTaskText(taskId, delta) {
+    const nextText = `${this.backgroundTextBuffers.get(taskId) ?? ""}${delta}`;
+    this.backgroundTextBuffers.set(taskId, nextText);
+    this.backgroundTasks = this.backgroundTasks.map(
+      (task) => task.id === taskId ? { ...task, resultPreview: trimBackgroundPreview(nextText) } : task
+    );
+    this.notify();
+  }
+  updateBackgroundTaskAction(taskId, currentAction) {
+    this.backgroundTasks = this.backgroundTasks.map(
+      (task) => task.id === taskId ? { ...task, currentAction } : task
+    );
+    this.notify();
+  }
 };
 
 // src/ui/hooks/useSlashRouting.ts
 var import_react = require("react");
 var import_node_crypto = require("crypto");
-var import_agent_sdk = require("@robota-sdk/agent-sdk");
-var import_agent_core = require("@robota-sdk/agent-core");
-function useSlashRouting(interactiveSession, registry, manager) {
+var import_agent_core2 = require("@robota-sdk/agent-core");
+
+// src/utils/provider-command.ts
+async function handleProviderCommand(cwd, args, deps = {}) {
+  const settings = readMergedProviderSettings(cwd);
+  const providerDefinitions = deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  const [subcommand = "current", profileArg] = args.trim().split(/\s+/);
+  if (subcommand === "list") {
+    return {
+      message: formatProviderList(settings.currentProvider, settings.providers),
+      success: true
+    };
+  }
+  if (subcommand === "current" || subcommand === "") {
+    return {
+      message: formatCurrentProvider(settings.currentProvider, settings.providers),
+      success: true
+    };
+  }
+  if (subcommand === "use") {
+    return buildProviderSwitch(settings.providers, profileArg);
+  }
+  if (subcommand === "test") {
+    return await testProvider(settings.currentProvider, settings.providers, profileArg, deps);
+  }
+  if (subcommand === "add") {
+    return buildProviderSetup(profileArg, providerDefinitions);
+  }
+  return {
+    message: "Usage: provider [current|list|use <profile>|add <type>|test [profile]]",
+    success: false
+  };
+}
+function formatProviderList(currentProvider, providers) {
+  const entries = Object.entries(providers ?? {});
+  if (entries.length === 0) {
+    return "No provider profiles configured.";
+  }
+  return entries.map(([name, profile]) => {
+    const marker = name === currentProvider ? "*" : "-";
+    return `${marker} ${name}: ${profile.type ?? "unknown"} ${profile.model ?? "(no model)"}`;
+  }).join("\n");
+}
+function formatCurrentProvider(currentProvider, providers) {
+  if (!currentProvider) {
+    return "No current provider configured.";
+  }
+  const profile = providers?.[currentProvider];
+  if (!profile) {
+    return `Current provider "${currentProvider}" was not found in providers.`;
+  }
+  return [
+    `Current provider: ${currentProvider}`,
+    `Type: ${profile.type ?? "unknown"}`,
+    `Model: ${profile.model ?? "(no model)"}`,
+    ...profile.baseURL ? [`Base URL: ${profile.baseURL}`] : []
+  ].join("\n");
+}
+function buildProviderSwitch(providers, profileName) {
+  if (!profileName) {
+    return { message: "Usage: provider use <profile>", success: false };
+  }
+  if (!providers?.[profileName]) {
+    return { message: `Provider profile "${profileName}" was not found.`, success: false };
+  }
+  return {
+    message: `Provider change requested: ${profileName}`,
+    success: true,
+    data: { providerSwitch: { profile: profileName } }
+  };
+}
+function buildProviderSetup(type, providerDefinitions) {
+  if (!type || (0, import_agent_core.findProviderDefinition)(providerDefinitions, type) === void 0) {
+    return {
+      message: `Usage: provider add <type>. Supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`,
+      success: false
+    };
+  }
+  return {
+    message: `Provider setup requested: ${type}`,
+    success: true,
+    data: { providerSetup: { type } }
+  };
+}
+async function testProvider(currentProvider, providers, profileArg, deps) {
+  const profileName = profileArg ?? currentProvider;
+  if (!profileName) {
+    return { message: "No provider profile selected.", success: false };
+  }
+  const profile = providers?.[profileName];
+  if (!profile) {
+    return { message: `Provider profile "${profileName}" was not found.`, success: false };
+  }
+  try {
+    validateProviderProfile(profileName, profile, {
+      providerDefinitions: deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS
+    });
+  } catch (error) {
+    return { message: error instanceof Error ? error.message : String(error), success: false };
+  }
+  const providerDefinitions = deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  const definition = profile.type ? (0, import_agent_core.findProviderDefinition)(providerDefinitions, profile.type) : void 0;
+  const probe = deps.probe ?? definition?.probeProfile ?? probeProviderProfile;
+  const result = await probe(profile);
+  return {
+    message: result.ok ? `Provider "${profileName}" test passed: ${result.message}` : `Provider "${profileName}" test failed: ${result.message}; manual configuration can continue.`,
+    success: true,
+    data: { providerTest: { profile: profileName } }
+  };
+}
+async function probeProviderProfile(profile) {
+  void profile;
+  return { ok: true, message: "Profile fields are valid; no endpoint probe configured." };
+}
+
+// src/ui/hooks/useSlashRouting.ts
+function useSlashRouting(cwd, interactiveSession, registry, manager, providerDefinitions) {
   return (0, import_react.useCallback)(
     async (input) => {
+      manager.onUserTurnAccepted();
       if (!input.startsWith("/")) {
         await interactiveSession.submit(input);
         manager.setPendingPrompt(interactiveSession.getPendingPrompt());
@@ -342,81 +1069,114 @@ function useSlashRouting(interactiveSession, registry, manager) {
       const parts = input.slice(1).split(/\s+/);
       const cmd = parts[0]?.toLowerCase() ?? "";
       const args = parts.slice(1).join(" ");
+      if (cmd === "provider") {
+        await routeProviderCommand(cwd, args, interactiveSession, manager, providerDefinitions);
+        return;
+      }
       const result = await interactiveSession.executeCommand(cmd, args);
       if (result) {
-        manager.addEntry((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createSystemMessage)(result.message)));
-        const effects = interactiveSession;
-        if (result.data?.modelId) {
-          effects._pendingModelId = result.data.modelId;
-          return;
-        }
-        if (result.data?.language) {
-          effects._pendingLanguage = result.data.language;
-          return;
-        }
-        if (result.data?.resetRequested) {
-          effects._resetRequested = true;
-          return;
-        }
-        if (result.data?.triggerResumePicker) {
-          effects._triggerResumePicker = true;
-          return;
-        }
-        if (result.data?.name) {
-          effects._sessionName = result.data.name;
-          return;
-        }
-        const ctx = interactiveSession.getContextState();
-        manager.setContextState({
-          percentage: ctx.usedPercentage,
-          usedTokens: ctx.usedTokens,
-          maxTokens: ctx.maxTokens
-        });
+        applySystemCommandResult(result, interactiveSession, manager);
         return;
       }
-      const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
-      if (skillCmd) {
-        manager.addEntry({
-          id: (0, import_node_crypto.randomUUID)(),
-          timestamp: /* @__PURE__ */ new Date(),
-          category: "event",
-          type: "skill-invocation",
-          data: {
-            skillName: cmd,
-            source: skillCmd.source,
-            message: `Invoking ${skillCmd.source}: ${cmd}`
-          }
-        });
-        const prompt = await (0, import_agent_sdk.buildSkillPrompt)(input, registry);
-        if (prompt) {
-          const qualifiedName = registry.resolveQualifiedName(cmd);
-          const hookInput = qualifiedName ? `/${qualifiedName}${input.slice(1 + cmd.length)}` : input;
-          await interactiveSession.submit(prompt, input, hookInput);
-          manager.setPendingPrompt(interactiveSession.getPendingPrompt());
-          return;
-        }
-      }
-      if (cmd === "exit") {
-        interactiveSession._exitRequested = true;
+      if (await routeSkillCommand(input, cmd, registry, interactiveSession, manager)) {
         return;
       }
-      if (cmd === "plugin") {
-        interactiveSession._triggerPluginTUI = true;
+      if (routeTuiCommand(cmd, interactiveSession)) {
         return;
       }
       manager.addEntry(
-        (0, import_agent_core.messageToHistoryEntry)(
-          (0, import_agent_core.createSystemMessage)(`Unknown command "/${cmd}". Type /help for help.`)
+        (0, import_agent_core2.messageToHistoryEntry)(
+          (0, import_agent_core2.createSystemMessage)(`Unknown command "/${cmd}". Type /help for help.`)
         )
       );
     },
-    [interactiveSession, registry, manager]
+    [cwd, interactiveSession, registry, manager, providerDefinitions]
   );
 }
+async function routeProviderCommand(cwd, args, interactiveSession, manager, providerDefinitions) {
+  const result = await handleProviderCommand(cwd, args, { providerDefinitions });
+  manager.addEntry((0, import_agent_core2.messageToHistoryEntry)((0, import_agent_core2.createSystemMessage)(result.message)));
+  const providerSwitch = result.data?.providerSwitch;
+  if (providerSwitch?.profile) {
+    getEffects(interactiveSession)._pendingProviderProfile = providerSwitch.profile;
+  }
+  const providerSetup = result.data?.providerSetup;
+  if (providerSetup?.type) {
+    getEffects(interactiveSession)._pendingProviderSetupType = providerSetup.type;
+  }
+}
+function applySystemCommandResult(result, interactiveSession, manager) {
+  manager.addEntry((0, import_agent_core2.messageToHistoryEntry)((0, import_agent_core2.createSystemMessage)(result.message)));
+  const data = result.data;
+  const effects = getEffects(interactiveSession);
+  if (typeof data?.modelId === "string") {
+    effects._pendingModelId = data.modelId;
+    return;
+  }
+  if (typeof data?.language === "string") {
+    effects._pendingLanguage = data.language;
+    return;
+  }
+  if (data?.resetRequested === true) {
+    effects._resetRequested = true;
+    return;
+  }
+  if (data?.triggerResumePicker === true) {
+    effects._triggerResumePicker = true;
+    return;
+  }
+  if (typeof data?.name === "string") {
+    effects._sessionName = data.name;
+    return;
+  }
+  const ctx = interactiveSession.getContextState();
+  manager.setContextState({
+    percentage: ctx.usedPercentage,
+    usedTokens: ctx.usedTokens,
+    maxTokens: ctx.maxTokens
+  });
+}
+async function routeSkillCommand(input, cmd, registry, interactiveSession, manager) {
+  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+  if (!skillCmd) {
+    return false;
+  }
+  manager.addEntry({
+    id: (0, import_node_crypto.randomUUID)(),
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "skill-invocation",
+    data: {
+      skillName: cmd,
+      source: skillCmd.source,
+      message: `Invoking ${skillCmd.source}: ${cmd}`
+    }
+  });
+  const args = input.slice(1 + cmd.length).trimStart();
+  const qualifiedName = registry.resolveQualifiedName(cmd);
+  const hookInput = qualifiedName ? `/${qualifiedName}${input.slice(1 + cmd.length)}` : input;
+  await interactiveSession.executeSkillCommand(skillCmd, args, input, hookInput);
+  manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+  return true;
+}
+function routeTuiCommand(cmd, interactiveSession) {
+  if (cmd === "exit") {
+    getEffects(interactiveSession)._exitRequested = true;
+    return true;
+  }
+  if (cmd === "plugin") {
+    getEffects(interactiveSession)._triggerPluginTUI = true;
+    return true;
+  }
+  return false;
+}
+function getEffects(interactiveSession) {
+  return interactiveSession;
+}
 
 // src/ui/hooks/useInteractiveSession.ts
 function initializeSession(props, permissionHandler) {
-  const interactiveSession = new import_agent_sdk2.InteractiveSession({
+  const interactiveSession = new import_agent_sdk.InteractiveSession({
     cwd: props.cwd,
     provider: props.provider,
     permissionMode: props.permissionMode,
@@ -425,17 +1185,23 @@ function initializeSession(props, permissionHandler) {
     sessionStore: props.sessionStore,
     resumeSessionId: props.resumeSessionId,
     forkSession: props.forkSession,
-    sessionName: props.sessionName
+    sessionName: props.sessionName,
+    backgroundTaskRunners: props.backgroundTaskRunners,
+    subagentRunnerFactory: props.subagentRunnerFactory,
+    commandModules: props.commandModules
   });
-  const registry = new import_agent_sdk2.CommandRegistry();
-  registry.addSource(new import_agent_sdk2.BuiltinCommandSource());
-  registry.addSource(new import_agent_sdk2.SkillCommandSource(props.cwd));
-  const pluginsDir = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".robota", "plugins");
-  const loader = new import_agent_sdk2.BundlePluginLoader(pluginsDir);
+  const registry = new import_agent_sdk.CommandRegistry();
+  registry.addSource(new import_agent_sdk.BuiltinCommandSource());
+  for (const module2 of props.commandModules ?? []) {
+    registry.addModule(module2);
+  }
+  registry.addSource(new import_agent_sdk.SkillCommandSource(props.cwd));
+  const pluginsDir = (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".robota", "plugins");
+  const loader = new import_agent_sdk.BundlePluginLoader(pluginsDir);
   try {
     const plugins = loader.loadPluginsSync();
     if (plugins.length > 0) {
-      registry.addSource(new import_agent_sdk2.PluginCommandSource(plugins));
+      registry.addSource(new import_agent_sdk.PluginCommandSource(plugins));
     }
   } catch {
   }
@@ -445,6 +1211,7 @@ function initializeSession(props, permissionHandler) {
 function useInteractiveSession(props) {
   const [, forceRender] = (0, import_react2.useState)(0);
   const [permissionRequest, setPermissionRequest] = (0, import_react2.useState)(null);
+  const [isShuttingDown, setIsShuttingDown] = (0, import_react2.useState)(false);
   const permissionQueueRef = (0, import_react2.useRef)([]);
   const processingRef = (0, import_react2.useRef)(false);
   const processNextPermission = (0, import_react2.useCallback)(() => {
@@ -494,6 +1261,7 @@ function useInteractiveSession(props) {
     interactiveSession.on("complete", manager.onComplete);
     interactiveSession.on("interrupted", manager.onInterrupted);
     interactiveSession.on("error", manager.onError);
+    interactiveSession.on("background_task_event", manager.onBackgroundTaskEvent);
     const initCheck = setInterval(() => {
       try {
         const ctx = interactiveSession.getContextState();
@@ -519,6 +1287,7 @@ function useInteractiveSession(props) {
       interactiveSession.off("complete", manager.onComplete);
       interactiveSession.off("interrupted", manager.onInterrupted);
       interactiveSession.off("error", manager.onError);
+      interactiveSession.off("background_task_event", manager.onBackgroundTaskEvent);
     };
   }, [interactiveSession, manager]);
   (0, import_react2.useEffect)(() => {
@@ -527,7 +1296,13 @@ function useInteractiveSession(props) {
       manager.setPendingPrompt(interactiveSession.getPendingPrompt());
     }
   }, [manager.isThinking, interactiveSession, manager]);
-  const handleSubmit = useSlashRouting(interactiveSession, registry, manager);
+  const handleSubmit = useSlashRouting(
+    props.cwd,
+    interactiveSession,
+    registry,
+    manager,
+    props.providerDefinitions ?? []
+  );
   const handleAbort = (0, import_react2.useCallback)(() => {
     manager.setAborting(true);
     interactiveSession.abort();
@@ -536,6 +1311,15 @@ function useInteractiveSession(props) {
     interactiveSession.cancelQueue();
     manager.setPendingPrompt(null);
   }, [interactiveSession, manager]);
+  const handleShutdown = (0, import_react2.useCallback)(
+    async (reason = "prompt_input_exit") => {
+      if (isShuttingDown) return;
+      setIsShuttingDown(true);
+      manager.addEntry((0, import_agent_core3.messageToHistoryEntry)((0, import_agent_core3.createSystemMessage)("Shutting down...")));
+      await interactiveSession.shutdown({ reason, message: "CLI shutdown" });
+    },
+    [interactiveSession, manager, isShuttingDown]
+  );
   return {
     interactiveSession,
     registry,
@@ -545,33 +1329,36 @@ function useInteractiveSession(props) {
     activeTools: manager.activeTools,
     isThinking: manager.isThinking,
     isAborting: manager.isAborting,
+    isShuttingDown,
     pendingPrompt: manager.pendingPrompt,
+    backgroundTasks: manager.backgroundTasks,
     permissionRequest,
     contextState: manager.contextState,
     handleSubmit,
     handleAbort,
-    handleCancelQueue
+    handleCancelQueue,
+    handleShutdown
   };
 }
 
 // src/ui/hooks/usePluginCallbacks.ts
 var import_react3 = require("react");
-var import_node_os3 = require("os");
-var import_node_path4 = require("path");
-var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
+var import_node_os4 = require("os");
+var import_node_path5 = require("path");
+var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
 function usePluginCallbacks(cwd) {
   return (0, import_react3.useMemo)(() => {
-    const home = (0, import_node_os3.homedir)();
-    const pluginsDir = (0, import_node_path4.join)(home, ".robota", "plugins");
-    const userSettingsPath = (0, import_node_path4.join)(home, ".robota", "settings.json");
-    const settingsStore = new import_agent_sdk3.PluginSettingsStore(userSettingsPath);
-    const marketplace = new import_agent_sdk3.MarketplaceClient({ pluginsDir });
-    const installer = new import_agent_sdk3.BundlePluginInstaller({
+    const home = (0, import_node_os4.homedir)();
+    const pluginsDir = (0, import_node_path5.join)(home, ".robota", "plugins");
+    const userSettingsPath = (0, import_node_path5.join)(home, ".robota", "settings.json");
+    const settingsStore = new import_agent_sdk2.PluginSettingsStore(userSettingsPath);
+    const marketplace = new import_agent_sdk2.MarketplaceClient({ pluginsDir });
+    const installer = new import_agent_sdk2.BundlePluginInstaller({
       pluginsDir,
       settingsStore,
       marketplaceClient: marketplace
     });
-    const loader = new import_agent_sdk3.BundlePluginLoader(pluginsDir);
+    const loader = new import_agent_sdk2.BundlePluginLoader(pluginsDir);
     return {
       listInstalled: async () => {
         const plugins = await loader.loadAll();
@@ -609,8 +1396,8 @@ function usePluginCallbacks(cwd) {
           throw new Error("Plugin ID must be in format: name@marketplace");
         }
         if (scope === "project") {
-          const projectPluginsDir = (0, import_node_path4.join)(cwd, ".robota", "plugins");
-          const projectInstaller = new import_agent_sdk3.BundlePluginInstaller({
+          const projectPluginsDir = (0, import_node_path5.join)(cwd, ".robota", "plugins");
+          const projectInstaller = new import_agent_sdk2.BundlePluginInstaller({
             pluginsDir: projectPluginsDir,
             settingsStore,
             marketplaceClient: marketplace
@@ -661,19 +1448,33 @@ function usePluginCallbacks(cwd) {
 // src/ui/hooks/useSideEffects.ts
 var import_react4 = require("react");
 var import_ink = require("ink");
-var import_agent_core2 = require("@robota-sdk/agent-core");
+var import_agent_core4 = require("@robota-sdk/agent-core");
 var EXIT_DELAY_MS = 500;
 function useSideEffects({
+  cwd,
   interactiveSession,
   addEntry,
   baseHandleSubmit,
-  setSessionName
+  setSessionName,
+  providerDefinitions
 }) {
   const { exit } = (0, import_ink.useApp)();
   const [pendingModelId, setPendingModelId] = (0, import_react4.useState)(null);
   const pendingModelChangeRef = (0, import_react4.useRef)(null);
+  const [pendingProviderProfile, setPendingProviderProfile] = (0, import_react4.useState)(null);
+  const pendingProviderProfileRef = (0, import_react4.useRef)(null);
+  const [pendingProviderSetupType, setPendingProviderSetupType] = (0, import_react4.useState)(null);
   const [showPluginTUI, setShowPluginTUI] = (0, import_react4.useState)(false);
   const [showSessionPicker, setShowSessionPicker] = (0, import_react4.useState)(false);
+  const requestShutdown = (0, import_react4.useCallback)(
+    (reason, message) => {
+      addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Shutting down...")));
+      setTimeout(() => {
+        void interactiveSession.shutdown({ reason, message }).finally(() => exit());
+      }, EXIT_DELAY_MS);
+    },
+    [interactiveSession, addEntry, exit]
+  );
   const handleSubmit = (0, import_react4.useCallback)(
     async (input) => {
       await baseHandleSubmit(input);
@@ -693,9 +1494,22 @@ function useSideEffects({
         settings.language = lang;
         writeSettings(settingsPath, settings);
         addEntry(
-          (0, import_agent_core2.messageToHistoryEntry)((0, import_agent_core2.createSystemMessage)(`Language set to "${lang}". Restarting...`))
+          (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Language set to "${lang}". Restarting...`))
         );
-        setTimeout(() => exit(), EXIT_DELAY_MS);
+        requestShutdown("other", "Language change restart");
+        return;
+      }
+      if (sideEffects._pendingProviderProfile) {
+        const profile = sideEffects._pendingProviderProfile;
+        delete sideEffects._pendingProviderProfile;
+        pendingProviderProfileRef.current = profile;
+        setPendingProviderProfile(profile);
+        return;
+      }
+      if (sideEffects._pendingProviderSetupType) {
+        const type = sideEffects._pendingProviderSetupType;
+        delete sideEffects._pendingProviderSetupType;
+        setPendingProviderSetupType(type);
         return;
       }
       if (sideEffects._resetRequested) {
@@ -703,17 +1517,17 @@ function useSideEffects({
         const settingsPath = getUserSettingsPath();
         if (deleteSettings(settingsPath)) {
           addEntry(
-            (0, import_agent_core2.messageToHistoryEntry)((0, import_agent_core2.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`))
+            (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`))
           );
         } else {
-          addEntry((0, import_agent_core2.messageToHistoryEntry)((0, import_agent_core2.createSystemMessage)("No user settings found.")));
+          addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("No user settings found.")));
         }
-        setTimeout(() => exit(), EXIT_DELAY_MS);
+        requestShutdown("other", "Reset settings restart");
         return;
       }
       if (sideEffects._exitRequested) {
         delete sideEffects._exitRequested;
-        setTimeout(() => exit(), EXIT_DELAY_MS);
+        requestShutdown("prompt_input_exit", "User requested exit");
         return;
       }
       if (sideEffects._triggerPluginTUI) {
@@ -734,7 +1548,7 @@ function useSideEffects({
         return;
       }
     },
-    [interactiveSession, baseHandleSubmit, addEntry, exit, setSessionName]
+    [interactiveSession, baseHandleSubmit, addEntry, requestShutdown, setSessionName]
   );
   const handleModelConfirm = (0, import_react4.useCallback)(
     (index) => {
@@ -746,40 +1560,101 @@ function useSideEffects({
           const settingsPath = getUserSettingsPath();
           updateModelInSettings(settingsPath, modelId);
           addEntry(
-            (0, import_agent_core2.messageToHistoryEntry)(
-              (0, import_agent_core2.createSystemMessage)(`Model changed to ${(0, import_agent_core2.getModelName)(modelId)}. Restarting...`)
+            (0, import_agent_core4.messageToHistoryEntry)(
+              (0, import_agent_core4.createSystemMessage)(`Model changed to ${(0, import_agent_core4.getModelName)(modelId)}. Restarting...`)
+            )
+          );
+          requestShutdown("other", "Model change restart");
+        } catch (err) {
+          addEntry(
+            (0, import_agent_core4.messageToHistoryEntry)(
+              (0, import_agent_core4.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            )
+          );
+        }
+      } else {
+        addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Model change cancelled.")));
+      }
+    },
+    [addEntry, requestShutdown]
+  );
+  const handleProviderConfirm = (0, import_react4.useCallback)(
+    (index) => {
+      const profile = pendingProviderProfileRef.current;
+      setPendingProviderProfile(null);
+      pendingProviderProfileRef.current = null;
+      if (index === 0 && profile) {
+        try {
+          const settingsPath = getUserSettingsPath();
+          applyProviderSwitch(settingsPath, profile, {
+            knownProviders: readMergedProviderSettings(cwd).providers
+          });
+          addEntry(
+            (0, import_agent_core4.messageToHistoryEntry)(
+              (0, import_agent_core4.createSystemMessage)(`Provider changed to ${profile}. Restarting...`)
             )
           );
-          setTimeout(() => exit(), EXIT_DELAY_MS);
+          requestShutdown("other", "Provider change restart");
         } catch (err) {
           addEntry(
-            (0, import_agent_core2.messageToHistoryEntry)(
-              (0, import_agent_core2.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            (0, import_agent_core4.messageToHistoryEntry)(
+              (0, import_agent_core4.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
             )
           );
         }
       } else {
-        addEntry((0, import_agent_core2.messageToHistoryEntry)((0, import_agent_core2.createSystemMessage)("Model change cancelled.")));
+        addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Provider change cancelled.")));
+      }
+    },
+    [cwd, addEntry, requestShutdown]
+  );
+  const handleProviderSetupSubmit = (0, import_react4.useCallback)(
+    (input) => {
+      setPendingProviderSetupType(null);
+      try {
+        const settingsPath = getUserSettingsPath();
+        applyProviderConfiguration(settingsPath, input, { providerDefinitions });
+        addEntry(
+          (0, import_agent_core4.messageToHistoryEntry)(
+            (0, import_agent_core4.createSystemMessage)(`Provider ${input.profile} configured. Restarting...`)
+          )
+        );
+        requestShutdown("other", "Provider setup restart");
+      } catch (err) {
+        addEntry(
+          (0, import_agent_core4.messageToHistoryEntry)(
+            (0, import_agent_core4.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+          )
+        );
       }
     },
-    [addEntry, exit]
+    [addEntry, requestShutdown, providerDefinitions]
   );
+  const handleProviderSetupCancel = (0, import_react4.useCallback)(() => {
+    setPendingProviderSetupType(null);
+    addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Provider setup cancelled.")));
+  }, [addEntry]);
   return {
     handleSubmit,
     pendingModelId,
+    pendingProviderProfile,
+    pendingProviderSetupType,
     showPluginTUI,
     showSessionPicker,
     setPendingModelId,
     setShowPluginTUI,
     setShowSessionPicker,
-    handleModelConfirm
+    handleModelConfirm,
+    handleProviderConfirm,
+    handleProviderSetupSubmit,
+    handleProviderSetupCancel
   };
 }
 
 // src/ui/MessageList.tsx
 var import_react5 = __toESM(require("react"), 1);
 var import_ink3 = require("ink");
-var import_agent_core3 = require("@robota-sdk/agent-core");
+var import_agent_core5 = require("@robota-sdk/agent-core");
 
 // src/ui/render-markdown.ts
 var import_marked = require("marked");
@@ -865,7 +1740,7 @@ function RoleLabel({ role }) {
   }
 }
 function ToolMessage({ message }) {
-  if (!(0, import_agent_core3.isToolMessage)(message)) {
+  if (!(0, import_agent_core5.isToolMessage)(message)) {
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, {});
   }
   const toolName = message.name;
@@ -928,7 +1803,7 @@ function ToolMessage({ message }) {
 var MessageItem = import_react5.default.memo(function MessageItem2({
   message
 }) {
-  if ((0, import_agent_core3.isToolMessage)(message)) {
+  if ((0, import_agent_core5.isToolMessage)(message)) {
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ToolMessage, { message });
   }
   const content = message.content ?? "";
@@ -936,7 +1811,7 @@ var MessageItem = import_react5.default.memo(function MessageItem2({
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RoleLabel, { role: message.role }) }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: " " }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { wrap: "wrap", children: (0, import_agent_core3.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { wrap: "wrap", children: (0, import_agent_core5.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
   ] });
 });
 function ToolSummaryEntry({ entry }) {
@@ -985,7 +1860,7 @@ function MessageList({ history }) {
 
 // src/ui/StatusBar.tsx
 var import_ink4 = require("ink");
-var import_agent_core4 = require("@robota-sdk/agent-core");
+var import_agent_core6 = require("@robota-sdk/agent-core");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var CONTEXT_YELLOW_THRESHOLD = 70;
 var CONTEXT_RED_THRESHOLD = 90;
@@ -1030,9 +1905,9 @@ function StatusBar({
             "Context: ",
             Math.round(contextPercentage),
             "% (",
-            (0, import_agent_core4.formatTokenCount)(contextUsedTokens),
+            (0, import_agent_core6.formatTokenCount)(contextUsedTokens),
             "/",
-            (0, import_agent_core4.formatTokenCount)(contextMaxTokens),
+            (0, import_agent_core6.formatTokenCount)(contextMaxTokens),
             ")"
           ] })
         ] }),
@@ -1056,39 +1931,183 @@ var import_ink8 = require("ink");
 var import_react6 = require("react");
 var import_ink5 = require("ink");
 var import_chalk = __toESM(require("chalk"), 1);
+
+// src/ui/flows/cjk-text-input-flow.ts
 var import_string_width = __toESM(require("string-width"), 1);
-var import_jsx_runtime4 = require("react/jsx-runtime");
 var PASTE_START = "[200~";
 var PASTE_END = "[201~";
+var LAST_ASCII_CONTROL_CODE = 31;
+var DELETE_CONTROL_CODE = 127;
+function createCjkTextInputFlowState(value) {
+  return { value, cursor: value.length, isPasting: false, pasteBuffer: "" };
+}
+function syncCjkTextInputFlowState(state, value, cursorHint) {
+  if (value === state.value) {
+    return state;
+  }
+  return {
+    ...state,
+    value,
+    cursor: cursorHint != null ? Math.min(cursorHint, value.length) : value.length
+  };
+}
+function applyCjkTextInput(state, input, key, options) {
+  const pasteResult = applyPasteBoundaryInput(state, input, options);
+  if (pasteResult !== void 0) return pasteResult;
+  const controlResult = applyControlInput(state, input, key, options);
+  if (controlResult !== void 0) return controlResult;
+  const cursorResult = applyCursorInput(state, key, options.availableWidth);
+  if (cursorResult !== void 0) return cursorResult;
+  return insertPrintableInput(state, input);
+}
+function applyPasteBoundaryInput(state, input, options) {
+  if (input === PASTE_START || input.startsWith(PASTE_START)) {
+    return startBracketedPaste(state, input);
+  }
+  if (state.isPasting) {
+    return continueBracketedPaste(state, input, options);
+  }
+  return void 0;
+}
+function applyControlInput(state, input, key, options) {
+  if (key.ctrl === true && input === "c" || key.tab === true) {
+    return { state, effect: { type: "none" } };
+  }
+  if (key.return === true) {
+    return { state, effect: { type: "submit", value: state.value } };
+  }
+  if (input.length > 1 && (input.includes("\n") || input.includes("\r")) && options.canPaste) {
+    return {
+      state,
+      effect: { type: "paste", text: input.replace(/\r\n?/g, "\n"), cursor: state.cursor }
+    };
+  }
+  return void 0;
+}
+function applyCursorInput(state, key, availableWidth) {
+  if (key.upArrow === true || key.downArrow === true) {
+    return moveCursorVertically(state, key.upArrow === true ? "up" : "down", availableWidth);
+  }
+  if (key.leftArrow === true) {
+    return moveCursorHorizontally(state, "left");
+  }
+  if (key.rightArrow === true) {
+    return moveCursorHorizontally(state, "right");
+  }
+  if (key.backspace === true || key.delete === true) {
+    return deleteBeforeCursor(state);
+  }
+  return void 0;
+}
 function filterPrintable(input) {
   if (!input || input.length === 0) return "";
-  return input.replace(/[\x00-\x1f\x7f]/g, "");
+  let output = "";
+  for (const char of input) {
+    const code = char.charCodeAt(0);
+    if (code > LAST_ASCII_CONTROL_CODE && code !== DELETE_CONTROL_CODE) {
+      output += char;
+    }
+  }
+  return output;
 }
 function insertAtCursor(value, cursor, input) {
   const next = value.slice(0, cursor) + input + value.slice(cursor);
   return { value: next, cursor: cursor + input.length };
 }
-function displayOffset(chars, charIndex, width) {
-  let offset = 0;
-  for (let i = 0; i < charIndex && i < chars.length; i++) {
-    const w = (0, import_string_width.default)(chars[i]);
-    const col = offset % width;
-    if (col + w > width) offset += width - col;
-    offset += w;
+function displayOffset(chars, charIndex, width) {
+  let offset = 0;
+  for (let i = 0; i < charIndex && i < chars.length; i++) {
+    const w = (0, import_string_width.default)(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return offset;
+}
+function charIndexAtDisplayOffset(chars, target, width) {
+  let offset = 0;
+  for (let i = 0; i < chars.length; i++) {
+    if (offset >= target) return i;
+    const w = (0, import_string_width.default)(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return chars.length;
+}
+function startBracketedPaste(state, input) {
+  return {
+    state: { ...state, isPasting: true, pasteBuffer: input.slice(PASTE_START.length) },
+    effect: { type: "none" }
+  };
+}
+function continueBracketedPaste(state, input, options) {
+  if (input !== PASTE_END && !input.includes(PASTE_END)) {
+    return {
+      state: { ...state, pasteBuffer: state.pasteBuffer + input },
+      effect: { type: "none" }
+    };
+  }
+  const beforeMarker = input.split(PASTE_END)[0] ?? "";
+  const 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);
+}
+function moveCursorVertically(state, direction, availableWidth) {
+  if (!availableWidth || availableWidth <= 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const chars = [...state.value];
+  const offset = displayOffset(chars, state.cursor, availableWidth);
+  const target = direction === "up" ? offset - availableWidth : offset + availableWidth;
+  if (target < 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const cursor = charIndexAtDisplayOffset(chars, target, availableWidth);
+  if (cursor === state.cursor) {
+    return { state, effect: { type: "none" } };
+  }
+  return { state: { ...state, cursor }, effect: { type: "render" } };
+}
+function moveCursorHorizontally(state, direction) {
+  if (direction === "left" && state.cursor > 0) {
+    return { state: { ...state, cursor: state.cursor - 1 }, effect: { type: "render" } };
+  }
+  if (direction === "right" && state.cursor < state.value.length) {
+    return { state: { ...state, cursor: state.cursor + 1 }, effect: { type: "render" } };
+  }
+  return { state, effect: { type: "none" } };
+}
+function deleteBeforeCursor(state) {
+  if (state.cursor === 0) {
+    return { state, effect: { type: "none" } };
   }
-  return offset;
+  const value = state.value.slice(0, state.cursor - 1) + state.value.slice(state.cursor);
+  return {
+    state: { ...state, value, cursor: state.cursor - 1 },
+    effect: { type: "change", value }
+  };
 }
-function charIndexAtDisplayOffset(chars, target, width) {
-  let offset = 0;
-  for (let i = 0; i < chars.length; i++) {
-    if (offset >= target) return i;
-    const w = (0, import_string_width.default)(chars[i]);
-    const col = offset % width;
-    if (col + w > width) offset += width - col;
-    offset += w;
+function insertPrintableInput(state, input) {
+  const printable = filterPrintable(input);
+  if (printable.length === 0) {
+    return { state, effect: { type: "none" } };
   }
-  return chars.length;
+  const result = insertAtCursor(state.value, state.cursor, printable);
+  return {
+    state: { ...state, value: result.value, cursor: result.cursor },
+    effect: { type: "change", value: result.value }
+  };
 }
+
+// src/ui/CjkTextInput.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
 function CjkTextInput({
   value,
   onChange,
@@ -1100,113 +2119,40 @@ function CjkTextInput({
   availableWidth,
   cursorHint = null
 }) {
-  const valueRef = (0, import_react6.useRef)(value);
-  const cursorRef = (0, import_react6.useRef)(value.length);
+  const stateRef = (0, import_react6.useRef)(createCjkTextInputFlowState(value));
   const [, forceRender] = (0, import_react6.useState)(0);
-  const isPastingRef = (0, import_react6.useRef)(false);
-  const pasteBufferRef = (0, import_react6.useRef)("");
-  if (value !== valueRef.current) {
-    valueRef.current = value;
-    cursorRef.current = cursorHint != null ? Math.min(cursorHint, value.length) : value.length;
-  }
+  stateRef.current = syncCjkTextInputFlowState(stateRef.current, value, cursorHint);
   (0, import_ink5.useInput)(
     (input, key) => {
       try {
-        if (input === PASTE_START || input.startsWith(PASTE_START)) {
-          isPastingRef.current = true;
-          const afterMarker = input.slice(PASTE_START.length);
-          if (afterMarker.length > 0) {
-            pasteBufferRef.current += afterMarker;
-          }
-          return;
-        }
-        if (isPastingRef.current) {
-          if (input === PASTE_END || input.includes(PASTE_END)) {
-            const beforeMarker = input.split(PASTE_END)[0] ?? "";
-            pasteBufferRef.current += beforeMarker;
-            const text = pasteBufferRef.current.replace(/\r\n?/g, "\n");
-            pasteBufferRef.current = "";
-            isPastingRef.current = false;
-            if (text.length > 0) {
-              if (text.includes("\n") && onPaste) {
-                onPaste(text, cursorRef.current);
-              } else {
-                const printable2 = filterPrintable(text);
-                if (printable2.length > 0) {
-                  const result2 = insertAtCursor(valueRef.current, cursorRef.current, printable2);
-                  cursorRef.current = result2.cursor;
-                  valueRef.current = result2.value;
-                  onChange(result2.value);
-                }
-              }
-            }
-          } else {
-            pasteBufferRef.current += input;
-          }
-          return;
-        }
-        if (key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
-          return;
-        }
-        if (key.upArrow || key.downArrow) {
-          if (availableWidth && availableWidth > 0) {
-            const chars = [...valueRef.current];
-            const offset = displayOffset(chars, cursorRef.current, availableWidth);
-            const target = key.upArrow ? offset - availableWidth : offset + availableWidth;
-            if (target >= 0) {
-              const newCursor = charIndexAtDisplayOffset(chars, target, availableWidth);
-              if (newCursor !== cursorRef.current) {
-                cursorRef.current = newCursor;
-                forceRender((n) => n + 1);
-              }
-            }
-          }
-          return;
-        }
-        if (key.return) {
-          onSubmit?.(valueRef.current);
-          return;
-        }
-        if (input.length > 1 && (input.includes("\n") || input.includes("\r")) && onPaste) {
-          onPaste(input.replace(/\r\n?/g, "\n"), cursorRef.current);
-          return;
-        }
-        if (key.leftArrow) {
-          if (cursorRef.current > 0) {
-            cursorRef.current -= 1;
-            forceRender((n) => n + 1);
-          }
-          return;
-        }
-        if (key.rightArrow) {
-          if (cursorRef.current < valueRef.current.length) {
-            cursorRef.current += 1;
-            forceRender((n) => n + 1);
-          }
-          return;
-        }
-        if (key.backspace || key.delete) {
-          if (cursorRef.current > 0) {
-            const v = valueRef.current;
-            const next = v.slice(0, cursorRef.current - 1) + v.slice(cursorRef.current);
-            cursorRef.current -= 1;
-            valueRef.current = next;
-            onChange(next);
-          }
-          return;
-        }
-        const printable = filterPrintable(input);
-        if (printable.length === 0) return;
-        const result = insertAtCursor(valueRef.current, cursorRef.current, printable);
-        cursorRef.current = result.cursor;
-        valueRef.current = result.value;
-        onChange(result.value);
+        const result = applyCjkTextInput(stateRef.current, input, key, {
+          availableWidth,
+          canPaste: onPaste !== void 0
+        });
+        stateRef.current = result.state;
+        applyCjkTextInputEffect(result.effect, onChange, onSubmit, onPaste, forceRender);
       } catch {
       }
     },
     { isActive: focus }
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: renderWithCursor(valueRef.current, cursorRef.current, placeholder, showCursor && focus) });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { 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 renderWithCursor(value, cursorOffset, placeholder, showCursor) {
   if (!showCursor) {
@@ -1354,6 +2300,61 @@ function useAutocomplete(value, registry) {
   };
 }
 
+// src/ui/flows/input-area-flow.ts
+function getAutocompletePopupAction(key) {
+  if (key.upArrow === true) return "previous";
+  if (key.downArrow === true) return "next";
+  if (key.escape === true) return "close";
+  if (key.tab === true) return "complete";
+  return void 0;
+}
+function getPendingPromptInputAction(key) {
+  if (key.backspace === true || key.delete === true) {
+    return "cancelQueue";
+  }
+  return void 0;
+}
+function moveAutocompleteSelection(selectedIndex, commandCount, direction) {
+  if (commandCount === 0) return 0;
+  if (direction === "previous") {
+    return selectedIndex > 0 ? selectedIndex - 1 : commandCount - 1;
+  }
+  return selectedIndex < commandCount - 1 ? selectedIndex + 1 : 0;
+}
+function resolveTabCompletion(value, command) {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: "insert", value: `/${parsed.parentCommand} ${command.name} ` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: "insert", value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: "insert", value: `/${command.name} ` };
+}
+function resolveEnterCommandSelection(value, command) {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: "submit", value: `/${parsed.parentCommand} ${command.name}` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: "insert", value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: "submit", value: `/${command.name}` };
+}
+function createPasteLabelChange(value, cursorPosition, pasteId, text) {
+  const lineCount = text.split("\n").length;
+  const label = `[Pasted text #${pasteId} +${lineCount} lines]`;
+  return {
+    value: value.slice(0, cursorPosition) + label + value.slice(cursorPosition),
+    cursorHint: cursorPosition + label.length,
+    label,
+    lineCount
+  };
+}
+function shouldSubmitInput(text) {
+  return text.trim().length > 0;
+}
+
 // src/ui/InputArea.tsx
 var import_jsx_runtime7 = require("react/jsx-runtime");
 var BORDER_HORIZONTAL = 2;
@@ -1388,56 +2389,47 @@ function InputArea({
     pasteIdRef.current += 1;
     const id = pasteIdRef.current;
     pasteStore.current.set(id, text);
-    const lineCount = text.split("\n").length;
-    const label = `[Pasted text #${id} +${lineCount} lines]`;
-    const newCursorPos = cursorPosition + label.length;
-    setCursorHint(newCursorPos);
-    setValue((prev) => prev.slice(0, cursorPosition) + label + prev.slice(cursorPosition));
+    setValue((prev) => {
+      const change = createPasteLabelChange(prev, cursorPosition, id, text);
+      setCursorHint(change.cursorHint);
+      return change.value;
+    });
   }, []);
   const tabCompleteCommand = (0, import_react9.useCallback)(
     (cmd) => {
-      const parsed = parseSlashInput(value);
-      if (parsed.parentCommand) {
-        setValue(`/${parsed.parentCommand} ${cmd.name} `);
-        return;
-      }
-      if (cmd.subcommands && cmd.subcommands.length > 0) {
-        setValue(`/${cmd.name} `);
-        setSelectedIndex(0);
-        return;
+      const result = resolveTabCompletion(value, cmd);
+      if (result.type === "insert") {
+        setValue(result.value);
+        if (result.selectedIndex !== void 0) {
+          setSelectedIndex(result.selectedIndex);
+        }
       }
-      setValue(`/${cmd.name} `);
     },
     [value, setSelectedIndex]
   );
   const enterSelectCommand = (0, import_react9.useCallback)(
     (cmd) => {
-      const parsed = parseSlashInput(value);
-      if (parsed.parentCommand) {
-        const fullCommand = `/${parsed.parentCommand} ${cmd.name}`;
-        setValue("");
-        onSubmit(fullCommand);
-        return;
-      }
-      if (cmd.subcommands && cmd.subcommands.length > 0) {
-        setValue(`/${cmd.name} `);
-        setSelectedIndex(0);
+      const result = resolveEnterCommandSelection(value, cmd);
+      if (result.type === "insert") {
+        setValue(result.value);
+        if (result.selectedIndex !== void 0) {
+          setSelectedIndex(result.selectedIndex);
+        }
         return;
       }
       setValue("");
-      onSubmit(`/${cmd.name}`);
+      onSubmit(result.value);
     },
     [value, onSubmit, setSelectedIndex]
   );
   const handleSubmit = (0, import_react9.useCallback)(
     (text) => {
-      const trimmed = text.trim();
-      if (trimmed.length === 0) return;
+      if (!shouldSubmitInput(text)) return;
       if (showPopup && filteredCommands[selectedIndex]) {
         enterSelectCommand(filteredCommands[selectedIndex]);
         return;
       }
-      const expanded = expandPasteLabels(trimmed, pasteStore.current);
+      const expanded = expandPasteLabels(text.trim(), pasteStore.current);
       setValue("");
       pasteStore.current.clear();
       pasteIdRef.current = 0;
@@ -1448,13 +2440,14 @@ function InputArea({
   (0, import_ink8.useInput)(
     (_input, key) => {
       if (!showPopup) return;
-      if (key.upArrow) {
-        setSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredCommands.length - 1);
-      } else if (key.downArrow) {
-        setSelectedIndex((prev) => prev < filteredCommands.length - 1 ? prev + 1 : 0);
-      } else if (key.escape) {
+      const action = getAutocompletePopupAction(key);
+      if (action === "previous" || action === "next") {
+        setSelectedIndex(
+          (prev) => moveAutocompleteSelection(prev, filteredCommands.length, action)
+        );
+      } else if (action === "close") {
         setShowPopup(false);
-      } else if (key.tab) {
+      } else if (action === "complete") {
         const cmd = filteredCommands[selectedIndex];
         if (cmd) tabCompleteCommand(cmd);
       }
@@ -1463,7 +2456,7 @@ function InputArea({
   );
   (0, import_ink8.useInput)(
     (_input, key) => {
-      if ((key.backspace || key.delete) && pendingPrompt) {
+      if (getPendingPromptInputAction(key) === "cancelQueue" && pendingPrompt) {
         onCancelQueue?.();
       }
     },
@@ -1525,113 +2518,409 @@ function InputArea({
 // src/ui/ConfirmPrompt.tsx
 var import_react10 = require("react");
 var import_ink9 = require("ink");
+
+// src/ui/flows/selection-flow.ts
+function createSelectionFlowState() {
+  return { selectedIndex: 0, scrollOffset: 0, resolved: false };
+}
+function getVerticalSelectionInputAction(key) {
+  if (key.escape === true) return "cancel";
+  if (key.upArrow === true) return "previous";
+  if (key.downArrow === true) return "next";
+  if (key.return === true) return "select";
+  return void 0;
+}
+function getDirectionalSelectionInputAction(key) {
+  if (key.escape === true) return "cancel";
+  if (key.leftArrow === true || key.upArrow === true) return "previous";
+  if (key.rightArrow === true || key.downArrow === true) return "next";
+  if (key.return === true) return "select";
+  return void 0;
+}
+function applySelectionInput(state, action, options) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action === "cancel") {
+    return { state: { ...state, resolved: true }, effect: { type: "cancel" } };
+  }
+  if (options.enabled === false || options.itemCount === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action === "select") {
+    const index = clampIndex(state.selectedIndex, options.itemCount);
+    return {
+      state: { ...state, selectedIndex: index, resolved: true },
+      effect: { type: "select", index }
+    };
+  }
+  const selectedIndex = moveSelection(state.selectedIndex, action, options);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  return { state: { ...state, selectedIndex, scrollOffset }, effect: { type: "none" } };
+}
+function normalizeSelectionState(state, options) {
+  if (options.itemCount === 0) {
+    return { ...state, selectedIndex: 0, scrollOffset: 0 };
+  }
+  const selectedIndex = clampIndex(state.selectedIndex, options.itemCount);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  if (selectedIndex === state.selectedIndex && scrollOffset === state.scrollOffset) {
+    return state;
+  }
+  return {
+    ...state,
+    selectedIndex,
+    scrollOffset
+  };
+}
+function moveSelection(selectedIndex, action, options) {
+  if (action === "previous") {
+    if (options.wrap === true && selectedIndex === 0) return options.itemCount - 1;
+    return Math.max(0, selectedIndex - 1);
+  }
+  if (options.wrap === true && selectedIndex === options.itemCount - 1) return 0;
+  return Math.min(options.itemCount - 1, selectedIndex + 1);
+}
+function resolveScrollOffset(selectedIndex, scrollOffset, options) {
+  const maxVisible = options.maxVisible ?? options.itemCount;
+  if (maxVisible <= 0) return 0;
+  if (selectedIndex < scrollOffset) return selectedIndex;
+  if (selectedIndex >= scrollOffset + maxVisible) return selectedIndex - maxVisible + 1;
+  return Math.max(0, scrollOffset);
+}
+function clampIndex(index, itemCount) {
+  return Math.min(Math.max(index, 0), itemCount - 1);
+}
+
+// src/ui/flows/confirm-prompt-flow.ts
+function getConfirmPromptInputAction(input, key, optionCount) {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== void 0) {
+    return action;
+  }
+  if (optionCount === 2 && input === "y") {
+    return { type: "shortcut", index: 0 };
+  }
+  if (optionCount === 2 && input === "n") {
+    return { type: "shortcut", index: 1 };
+  }
+  return void 0;
+}
+function applyConfirmPromptInput(state, action, optionCount) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (typeof action !== "string") {
+    return {
+      state: { ...state, selectedIndex: action.index, resolved: true },
+      effect: { type: "select", index: action.index }
+    };
+  }
+  return applySelectionInput(state, action, { itemCount: optionCount });
+}
+
+// src/ui/ConfirmPrompt.tsx
 var import_jsx_runtime8 = require("react/jsx-runtime");
 function ConfirmPrompt({
   message,
   options = ["Yes", "No"],
   onSelect
 }) {
-  const [selected, setSelected] = (0, import_react10.useState)(0);
-  const resolvedRef = (0, import_react10.useRef)(false);
-  const doSelect = (0, import_react10.useCallback)(
-    (index) => {
-      if (resolvedRef.current) return;
-      resolvedRef.current = true;
-      onSelect(index);
+  const [state, setState] = (0, import_react10.useState)(() => createSelectionFlowState());
+  const stateRef = (0, import_react10.useRef)(state);
+  const applyAction = (0, import_react10.useCallback)(
+    (action) => {
+      const result = applyConfirmPromptInput(stateRef.current, action, options.length);
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "select") {
+        onSelect(result.effect.index);
+      }
     },
-    [onSelect]
+    [onSelect, options.length]
   );
   (0, import_ink9.useInput)((input, key) => {
-    if (resolvedRef.current) return;
-    if (key.leftArrow || key.upArrow) {
-      setSelected((prev) => prev > 0 ? prev - 1 : prev);
-    } else if (key.rightArrow || key.downArrow) {
-      setSelected((prev) => prev < options.length - 1 ? prev + 1 : prev);
-    } else if (key.return) {
-      doSelect(selected);
-    } else if (input === "y" && options.length === 2) {
-      doSelect(0);
-    } else if (input === "n" && options.length === 2) {
-      doSelect(1);
+    const action = getConfirmPromptInputAction(input, key, options.length);
+    if (action !== void 0) {
+      applyAction(action);
     }
   });
   return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink9.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Text, { color: "yellow", children: message }),
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Box, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink9.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
-      i === selected ? "> " : "  ",
-      opt
-    ] }) }, opt)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Box, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+      import_ink9.Text,
+      {
+        color: i === state.selectedIndex ? "cyan" : void 0,
+        bold: i === state.selectedIndex,
+        children: [
+          i === state.selectedIndex ? "> " : "  ",
+          opt
+        ]
+      }
+    ) }, opt)) }),
     /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink9.Text, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
   ] });
 }
 
-// src/ui/PermissionPrompt.tsx
-var import_react11 = __toESM(require("react"), 1);
+// src/ui/ProviderSetupPrompt.tsx
+var import_react12 = require("react");
+
+// src/ui/TextPrompt.tsx
+var import_react11 = require("react");
 var import_ink10 = require("ink");
+
+// src/ui/flows/text-prompt-flow.ts
+function createTextPromptFlowState() {
+  return { value: "", resolved: false };
+}
+function getTextPromptInputAction(input, key) {
+  if (key.escape === true) {
+    return { type: "cancel" };
+  }
+  if (key.return === true) {
+    return { type: "submit" };
+  }
+  if (key.backspace === true || key.delete === true) {
+    return { type: "delete" };
+  }
+  if (input && key.ctrl !== true && key.meta !== true) {
+    return { type: "insert", value: input };
+  }
+  return void 0;
+}
+function applyTextPromptInput(state, action, options) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action.type === "cancel") {
+    return { state: { ...state, resolved: true }, effect: { type: "cancel" } };
+  }
+  if (action.type === "delete") {
+    return {
+      state: { ...state, value: state.value.slice(0, -1), error: void 0 },
+      effect: { type: "none" }
+    };
+  }
+  if (action.type === "insert") {
+    return {
+      state: { ...state, value: state.value + action.value, error: void 0 },
+      effect: { type: "none" }
+    };
+  }
+  return submitTextPromptValue(state, options);
+}
+function submitTextPromptValue(state, options) {
+  const trimmed = state.value.trim();
+  if (!trimmed && !options.allowEmpty) {
+    const emptyError = options.validate?.(trimmed);
+    return {
+      state: emptyError ? { ...state, error: emptyError } : state,
+      effect: { type: "none" }
+    };
+  }
+  const error = options.validate?.(trimmed);
+  if (error !== void 0) {
+    return { state: { ...state, error }, effect: { type: "none" } };
+  }
+  return { state: { ...state, resolved: true }, effect: { type: "submit", value: trimmed } };
+}
+
+// src/ui/TextPrompt.tsx
 var import_jsx_runtime9 = require("react/jsx-runtime");
-var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
+function TextPrompt({
+  title,
+  placeholder,
+  onSubmit,
+  onCancel,
+  validate,
+  allowEmpty = false,
+  masked = false
+}) {
+  const [state, setState] = (0, import_react11.useState)(() => createTextPromptFlowState());
+  const stateRef = (0, import_react11.useRef)(state);
+  const applyAction = (0, import_react11.useCallback)(
+    (action) => {
+      const result = applyTextPromptInput(stateRef.current, action, { allowEmpty, validate });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onCancel();
+      } else if (result.effect.type === "submit") {
+        onSubmit(result.effect.value);
+      }
+    },
+    [allowEmpty, validate, onCancel, onSubmit]
+  );
+  (0, import_ink10.useInput)((input, key) => {
+    const action = getTextPromptInputAction(input, key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Box, { marginTop: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "cyan", children: "> " }),
+      state.value ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { dimColor: true, children: placeholder }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "cyan", children: "\u2588" })
+    ] }),
+    state.error && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "red", children: state.error }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { dimColor: true, children: " Enter Submit Esc Cancel" })
+  ] });
+}
+
+// src/ui/ProviderSetupPrompt.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+function ProviderSetupPrompt({
+  type,
+  providerDefinitions,
+  onSubmit,
+  onCancel
+}) {
+  const [state, setState] = (0, import_react12.useState)(
+    () => createProviderSetupFlow(type, providerDefinitions)
+  );
+  const step = getProviderSetupStep(state);
+  const handleStepSubmit = (rawValue) => {
+    const result = submitProviderSetupValue(state, rawValue);
+    if (result.status === "next") {
+      setState(result.state);
+      return;
+    }
+    if (result.status === "complete") {
+      onSubmit(result.input);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+    TextPrompt,
+    {
+      title: step.title,
+      placeholder: step.defaultValue,
+      allowEmpty: step.defaultValue !== void 0,
+      masked: step.masked,
+      validate: (value) => validateProviderSetupValue(step, value),
+      onSubmit: handleStepSubmit,
+      onCancel
+    },
+    `${type}-${step.key}`
+  );
+}
+
+// src/ui/PermissionPrompt.tsx
+var import_react13 = __toESM(require("react"), 1);
+var import_ink11 = require("ink");
+
+// src/ui/flows/permission-prompt-flow.ts
+var PERMISSION_PROMPT_OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
+function getPermissionPromptInputAction(input, key) {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== void 0) {
+    return action;
+  }
+  if (input === "y" || input === "1") {
+    return { type: "shortcut", index: 0 };
+  }
+  if (input === "a" || input === "2") {
+    return { type: "shortcut", index: 1 };
+  }
+  if (input === "n" || input === "d" || input === "3") {
+    return { type: "shortcut", index: 2 };
+  }
+  return void 0;
+}
+function applyPermissionPromptInput(state, action) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (typeof action !== "string") {
+    return resolvePermissionIndex(state, action.index);
+  }
+  const result = applySelectionInput(state, action, {
+    itemCount: PERMISSION_PROMPT_OPTIONS.length
+  });
+  if (result.effect.type !== "select") {
+    return { state: result.state, effect: { type: "none" } };
+  }
+  return {
+    state: result.state,
+    effect: { type: "resolve", decision: getPermissionDecision(result.effect.index) }
+  };
+}
+function getPermissionDecision(index) {
+  if (index === 0) return true;
+  if (index === 1) return "allow-session";
+  return false;
+}
+function resolvePermissionIndex(state, index) {
+  return {
+    state: { ...state, selectedIndex: index, resolved: true },
+    effect: { type: "resolve", decision: getPermissionDecision(index) }
+  };
+}
+
+// src/ui/PermissionPrompt.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
 function formatArgs(args) {
   const entries = Object.entries(args);
   if (entries.length === 0) return "(no arguments)";
   return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
 }
 function PermissionPrompt({ request }) {
-  const [selected, setSelected] = import_react11.default.useState(0);
-  const resolvedRef = import_react11.default.useRef(false);
-  const prevRequestRef = import_react11.default.useRef(request);
+  const [state, setState] = import_react13.default.useState(() => createSelectionFlowState());
+  const stateRef = import_react13.default.useRef(state);
+  const prevRequestRef = import_react13.default.useRef(request);
   if (prevRequestRef.current !== request) {
     prevRequestRef.current = request;
-    resolvedRef.current = false;
-    setSelected(0);
+    const nextState = createSelectionFlowState();
+    stateRef.current = nextState;
+    setState(nextState);
   }
-  const doResolve = import_react11.default.useCallback(
-    (index) => {
-      if (resolvedRef.current) return;
-      resolvedRef.current = true;
-      if (index === 0) request.resolve(true);
-      else if (index === 1) request.resolve("allow-session");
-      else request.resolve(false);
+  const applyAction = import_react13.default.useCallback(
+    (action) => {
+      const result = applyPermissionPromptInput(stateRef.current, action);
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "resolve") {
+        request.resolve(result.effect.decision);
+      }
     },
     [request]
   );
-  (0, import_ink10.useInput)((input, key) => {
-    if (resolvedRef.current) return;
-    if (key.upArrow || key.leftArrow) {
-      setSelected((prev) => prev > 0 ? prev - 1 : prev);
-    } else if (key.downArrow || key.rightArrow) {
-      setSelected((prev) => prev < OPTIONS.length - 1 ? prev + 1 : prev);
-    } else if (key.return) {
-      doResolve(selected);
-    } else if (input === "y" || input === "1") {
-      doResolve(0);
-    } else if (input === "a" || input === "2") {
-      doResolve(1);
-    } else if (input === "n" || input === "d" || input === "3") {
-      doResolve(2);
+  (0, import_ink11.useInput)((input, key) => {
+    const action = getPermissionPromptInputAction(input, key);
+    if (action !== void 0) {
+      applyAction(action);
     }
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "yellow", bold: true, children: "[Permission Required]" }),
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Text, { children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { children: [
       "Tool:",
       " ",
-      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { color: "cyan", bold: true, children: request.toolName })
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { color: "cyan", bold: true, children: request.toolName })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Text, { dimColor: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { dimColor: true, children: [
       " ",
       formatArgs(request.toolArgs)
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Box, { marginTop: 1, children: OPTIONS.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink10.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
-      i === selected ? "> " : "  ",
-      opt
-    ] }) }, opt)) }),
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink10.Text, { dimColor: true, children: " left/right to select, Enter to confirm" })
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginTop: 1, children: PERMISSION_PROMPT_OPTIONS.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(
+      import_ink11.Text,
+      {
+        color: i === state.selectedIndex ? "cyan" : void 0,
+        bold: i === state.selectedIndex,
+        children: [
+          i === state.selectedIndex ? "> " : "  ",
+          opt
+        ]
+      }
+    ) }, opt)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { dimColor: true, children: " left/right to select, Enter to confirm" })
   ] });
 }
 
 // src/ui/StreamingIndicator.tsx
-var import_ink11 = require("ink");
-var import_jsx_runtime10 = require("react/jsx-runtime");
+var import_ink12 = require("ink");
+var import_jsx_runtime12 = require("react/jsx-runtime");
 function getToolStyle(t) {
   if (t.isRunning) return { color: "yellow", icon: "\u27F3", strikethrough: false };
   if (t.result === "error") return { color: "red", icon: "\u2717", strikethrough: true };
@@ -1642,16 +2931,16 @@ function StreamingIndicator({ text, activeTools }) {
   const hasTools = activeTools.length > 0;
   const hasText = text.length > 0;
   if (!hasTools && !hasText) {
-    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_jsx_runtime10.Fragment, {});
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_jsx_runtime12.Fragment, {});
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink11.Box, { flexDirection: "column", children: [
-    hasTools && /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink11.Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink11.Text, { color: "white", bold: true, children: "Tools:" }),
-      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink11.Text, { children: " " }),
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", children: [
+    hasTools && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "white", bold: true, children: "Tools:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { children: " " }),
       activeTools.map((t, i) => {
         const { color, icon, strikethrough } = getToolStyle(t);
-        return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink11.Box, { flexDirection: "column", children: [
-          /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink11.Text, { color, strikethrough, children: [
+        return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Text, { color, strikethrough, children: [
             "  ",
             icon,
             " ",
@@ -1660,25 +2949,25 @@ function StreamingIndicator({ text, activeTools }) {
             t.firstArg,
             ")"
           ] }),
-          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(DiffBlock, { file: t.diffFile, lines: t.diffLines })
+          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(DiffBlock, { file: t.diffFile, lines: t.diffLines })
         ] }, `${t.toolName}-${i}`);
       })
     ] }),
-    hasText && /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink11.Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink11.Text, { color: "cyan", bold: true, children: "Robota:" }),
-      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink11.Text, { children: " " }),
-      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink11.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink11.Text, { wrap: "wrap", children: renderMarkdown(text) }) })
+    hasText && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { children: " " }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { wrap: "wrap", children: renderMarkdown(text) }) })
     ] })
   ] });
 }
 
 // src/ui/PluginTUI.tsx
-var import_react15 = require("react");
+var import_react16 = require("react");
 
 // src/ui/MenuSelect.tsx
-var import_react12 = require("react");
-var import_ink12 = require("ink");
-var import_jsx_runtime11 = require("react/jsx-runtime");
+var import_react14 = require("react");
+var import_ink13 = require("ink");
+var import_jsx_runtime13 = require("react/jsx-runtime");
 function MenuSelect({
   title,
   items,
@@ -1687,119 +2976,57 @@ function MenuSelect({
   loading,
   error
 }) {
-  const [selected, setSelected] = (0, import_react12.useState)(0);
-  const selectedRef = (0, import_react12.useRef)(0);
-  const resolvedRef = (0, import_react12.useRef)(false);
-  const doSelect = (0, import_react12.useCallback)(
-    (index) => {
-      if (resolvedRef.current || items.length === 0) return;
-      resolvedRef.current = true;
-      onSelect(items[index].value);
-    },
-    [items, onSelect]
-  );
-  (0, import_ink12.useInput)((input, key) => {
-    if (resolvedRef.current) return;
-    if (key.escape) {
-      resolvedRef.current = true;
-      onBack();
-      return;
-    }
-    if (loading || error || items.length === 0) return;
-    if (key.upArrow) {
-      const next = selectedRef.current > 0 ? selectedRef.current - 1 : selectedRef.current;
-      selectedRef.current = next;
-      setSelected(next);
-    } else if (key.downArrow) {
-      const next = selectedRef.current < items.length - 1 ? selectedRef.current + 1 : selectedRef.current;
-      selectedRef.current = next;
-      setSelected(next);
-    } else if (key.return) {
-      doSelect(selectedRef.current);
-    }
-  });
-  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink12.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink12.Text, { color: "yellow", bold: true, children: title }),
-    loading && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink12.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink12.Text, { dimColor: true, children: "Loading..." }) }),
-    error && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink12.Box, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink12.Text, { color: "red", children: error }),
-      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink12.Text, { dimColor: true, children: "Press Esc to go back" })
-    ] }),
-    !loading && !error && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink12.Box, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink12.Box, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink12.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
-        i === selected ? "> " : "  ",
-        item.label
-      ] }),
-      item.hint && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink12.Text, { dimColor: true, children: [
-        " ",
-        item.hint
-      ] })
-    ] }, item.value)) }),
-    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink12.Text, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
-  ] });
-}
-
-// src/ui/TextPrompt.tsx
-var import_react13 = require("react");
-var import_ink13 = require("ink");
-var import_jsx_runtime12 = require("react/jsx-runtime");
-function TextPrompt({
-  title,
-  placeholder,
-  onSubmit,
-  onCancel,
-  validate
-}) {
-  const [value, setValue] = (0, import_react13.useState)("");
-  const [error, setError] = (0, import_react13.useState)();
-  const resolvedRef = (0, import_react13.useRef)(false);
-  const valueRef = (0, import_react13.useRef)("");
-  const handleSubmit = (0, import_react13.useCallback)(() => {
-    if (resolvedRef.current) return;
-    const trimmed = valueRef.current.trim();
-    if (!trimmed) return;
-    if (validate) {
-      const err = validate(trimmed);
-      if (err) {
-        setError(err);
-        return;
+  const [state, setState] = (0, import_react14.useState)(() => createSelectionFlowState());
+  const stateRef = (0, import_react14.useRef)(state);
+  const isEnabled = !loading && !error;
+  const applyAction = (0, import_react14.useCallback)(
+    (action) => {
+      const result = applySelectionInput(stateRef.current, action, {
+        itemCount: items.length,
+        enabled: isEnabled
+      });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onBack();
+      } else if (result.effect.type === "select") {
+        const item = items[result.effect.index];
+        if (item !== void 0) {
+          onSelect(item.value);
+        }
       }
-    }
-    resolvedRef.current = true;
-    onSubmit(trimmed);
-  }, [validate, onSubmit]);
-  (0, import_ink13.useInput)((input, key) => {
-    if (resolvedRef.current) return;
-    if (key.escape) {
-      resolvedRef.current = true;
-      onCancel();
-      return;
-    }
-    if (key.return) {
-      handleSubmit();
-      return;
-    }
-    if (key.backspace || key.delete) {
-      valueRef.current = valueRef.current.slice(0, -1);
-      setValue(valueRef.current);
-      setError(void 0);
-      return;
-    }
-    if (input && !key.ctrl && !key.meta) {
-      valueRef.current = valueRef.current + input;
-      setValue(valueRef.current);
-      setError(void 0);
+    },
+    [isEnabled, items, onBack, onSelect]
+  );
+  (0, import_ink13.useInput)((input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
     }
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink13.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { color: "yellow", bold: true, children: title }),
-    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink13.Box, { marginTop: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { color: "cyan", children: "> " }),
-      value ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { children: value }) : placeholder ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { dimColor: true, children: placeholder }) : null,
-      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { color: "cyan", children: "\u2588" })
+  const normalizedState = normalizeSelectionState(state, { itemCount: items.length });
+  if (normalizedState !== state) {
+    stateRef.current = normalizedState;
+  }
+  const selected = normalizedState.selectedIndex;
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "yellow", bold: true, children: title }),
+    loading && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: "Loading..." }) }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "red", children: error }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: "Press Esc to go back" })
     ] }),
-    error && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { color: "red", children: error }),
-    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { dimColor: true, children: " Enter Submit Esc Cancel" })
+    !loading && !error && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Box, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+        i === selected ? "> " : "  ",
+        item.label
+      ] }),
+      item.hint && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Text, { dimColor: true, children: [
+        " ",
+        item.hint
+      ] })
+    ] }, item.value)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
   ] });
 }
 
@@ -1896,12 +3123,12 @@ function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
 }
 
 // src/ui/hooks/usePluginScreenData.ts
-var import_react14 = require("react");
+var import_react15 = require("react");
 function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, stackLength) {
-  const [items, setItems] = (0, import_react14.useState)([]);
-  const [loading, setLoading] = (0, import_react14.useState)(false);
-  const [error, setError] = (0, import_react14.useState)();
-  (0, import_react14.useEffect)(() => {
+  const [items, setItems] = (0, import_react15.useState)([]);
+  const [loading, setLoading] = (0, import_react15.useState)(false);
+  const [error, setError] = (0, import_react15.useState)();
+  (0, import_react15.useEffect)(() => {
     setItems([]);
     setError(void 0);
     if (screen === "marketplace-list") {
@@ -1956,16 +3183,16 @@ function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, sta
 }
 
 // src/ui/PluginTUI.tsx
-var import_jsx_runtime13 = require("react/jsx-runtime");
+var import_jsx_runtime14 = require("react/jsx-runtime");
 function PluginTUI({ callbacks, onClose, addMessage }) {
-  const [stack, setStack] = (0, import_react15.useState)([{ screen: "main" }]);
-  const [confirm, setConfirm] = (0, import_react15.useState)();
-  const [refreshCounter, setRefreshCounter] = (0, import_react15.useState)(0);
+  const [stack, setStack] = (0, import_react16.useState)([{ screen: "main" }]);
+  const [confirm, setConfirm] = (0, import_react16.useState)();
+  const [refreshCounter, setRefreshCounter] = (0, import_react16.useState)(0);
   const current = stack[stack.length - 1] ?? { screen: "main" };
-  const push = (0, import_react15.useCallback)((state) => {
+  const push = (0, import_react16.useCallback)((state) => {
     setStack((prev) => [...prev, state]);
   }, []);
-  const pop = (0, import_react15.useCallback)(() => {
+  const pop = (0, import_react16.useCallback)(() => {
     setStack((prev) => {
       if (prev.length <= 1) {
         onClose();
@@ -1974,7 +3201,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       return prev.slice(0, -1);
     });
   }, [onClose]);
-  const popN = (0, import_react15.useCallback)(
+  const popN = (0, import_react16.useCallback)(
     (n) => {
       setStack((prev) => {
         const next = prev.slice(0, Math.max(1, prev.length - n));
@@ -1987,20 +3214,20 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [onClose]
   );
-  const notify = (0, import_react15.useCallback)(
+  const notify = (0, import_react16.useCallback)(
     (content) => {
       addMessage?.({ role: "system", content });
     },
     [addMessage]
   );
-  const refresh = (0, import_react15.useCallback)(() => {
+  const refresh = (0, import_react16.useCallback)(() => {
     setRefreshCounter((c) => c + 1);
   }, []);
-  const setConfirmNav = (0, import_react15.useCallback)(
+  const setConfirmNav = (0, import_react16.useCallback)(
     (state) => setConfirm(state),
     [setConfirm]
   );
-  const pushNav = (0, import_react15.useCallback)(
+  const pushNav = (0, import_react16.useCallback)(
     (state) => push({ screen: state.screen, context: state.context }),
     [push]
   );
@@ -2012,7 +3239,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     refreshCounter,
     stack.length
   );
-  const handleSelect = (0, import_react15.useCallback)(
+  const handleSelect = (0, import_react16.useCallback)(
     (value) => {
       const screen2 = current.screen;
       const ctx = current.context;
@@ -2030,7 +3257,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
   );
-  const handleTextSubmit = (0, import_react15.useCallback)(
+  const handleTextSubmit = (0, import_react16.useCallback)(
     (value) => {
       if (current.screen === "marketplace-add") {
         callbacks.marketplaceAdd(value).then((name) => {
@@ -2045,7 +3272,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     [current.screen, callbacks, notify, pop]
   );
   if (confirm) {
-    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       ConfirmPrompt,
       {
         message: confirm.message,
@@ -2058,7 +3285,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
   }
   const screen = current.screen;
   if (screen === "marketplace-add") {
-    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       TextPrompt,
       {
         title: "Add Marketplace Source",
@@ -2070,7 +3297,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "marketplace-action") {
-    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       MenuSelect,
       {
         title: `Marketplace: ${current.context?.marketplace ?? ""}`,
@@ -2086,7 +3313,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "marketplace-install-scope") {
-    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       MenuSelect,
       {
         title: `Install scope for "${current.context?.pluginId ?? ""}"`,
@@ -2101,7 +3328,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     );
   }
   if (screen === "installed-action") {
-    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       MenuSelect,
       {
         title: `Plugin: ${current.context?.pluginId ?? ""}`,
@@ -2124,7 +3351,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       { label: "Installed Plugins", value: "installed" }
     ]
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
     MenuSelect,
     {
       title: titleMap[screen] ?? "Plugin Management",
@@ -2142,9 +3369,9 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
 var import_ink15 = require("ink");
 
 // src/ui/ListPicker.tsx
-var import_react16 = require("react");
+var import_react17 = require("react");
 var import_ink14 = require("ink");
-var import_jsx_runtime14 = require("react/jsx-runtime");
+var import_jsx_runtime15 = require("react/jsx-runtime");
 var DEFAULT_MAX_VISIBLE = 3;
 function ListPicker({
   items,
@@ -2153,54 +3380,52 @@ function ListPicker({
   onCancel,
   maxVisible = DEFAULT_MAX_VISIBLE
 }) {
-  const [selectedIndex, setSelectedIndex] = (0, import_react16.useState)(0);
-  const [scrollOffset, setScrollOffset] = (0, import_react16.useState)(0);
-  const selectedRef = (0, import_react16.useRef)(0);
-  const resolvedRef = (0, import_react16.useRef)(false);
-  (0, import_ink14.useInput)((_input, key) => {
-    if (resolvedRef.current) return;
-    if (key.escape) {
-      resolvedRef.current = true;
-      onCancel();
-      return;
-    }
-    if (items.length === 0) return;
-    if (key.upArrow) {
-      const next = selectedRef.current > 0 ? selectedRef.current - 1 : selectedRef.current;
-      selectedRef.current = next;
-      setSelectedIndex(next);
-      if (next < scrollOffset) {
-        setScrollOffset(next);
-      }
-    } else if (key.downArrow) {
-      const next = selectedRef.current < items.length - 1 ? selectedRef.current + 1 : selectedRef.current;
-      selectedRef.current = next;
-      setSelectedIndex(next);
-      if (next >= scrollOffset + maxVisible) {
-        setScrollOffset(next - maxVisible + 1);
-      }
-    } else if (key.return) {
-      const item = items[selectedRef.current];
-      if (item !== void 0) {
-        resolvedRef.current = true;
-        onSelect(item);
+  const [state, setState] = (0, import_react17.useState)(() => createSelectionFlowState());
+  const stateRef = (0, import_react17.useRef)(state);
+  const applyAction = (0, import_react17.useCallback)(
+    (action) => {
+      const result = applySelectionInput(stateRef.current, action, {
+        itemCount: items.length,
+        maxVisible
+      });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onCancel();
+      } else if (result.effect.type === "select") {
+        const item = items[result.effect.index];
+        if (item !== void 0) {
+          onSelect(item);
+        }
       }
+    },
+    [items, maxVisible, onCancel, onSelect]
+  );
+  (0, import_ink14.useInput)((_input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
     }
   });
   if (items.length === 0) {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink14.Box, {});
+    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, {});
+  }
+  const normalizedState = normalizeSelectionState(state, { itemCount: items.length, maxVisible });
+  if (normalizedState !== state) {
+    stateRef.current = normalizedState;
   }
+  const { selectedIndex, scrollOffset } = normalizedState;
   const visibleItems = items.slice(scrollOffset, scrollOffset + maxVisible);
   const hasMore = scrollOffset + maxVisible < items.length;
   const hasLess = scrollOffset > 0;
-  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink14.Box, { flexDirection: "column", children: [
-    hasLess && /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink14.Text, { dimColor: true, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Box, { flexDirection: "column", children: [
+    hasLess && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { dimColor: true, children: [
       " \u2191 ",
       scrollOffset,
       " more above"
     ] }),
-    visibleItems.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink14.Box, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
-    hasMore && /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink14.Text, { dimColor: true, children: [
+    visibleItems.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
+    hasMore && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { dimColor: true, children: [
       " \u2193 ",
       items.length - scrollOffset - maxVisible,
       " more below"
@@ -2209,7 +3434,7 @@ function ListPicker({
 }
 
 // src/ui/SessionPicker.tsx
-var import_jsx_runtime15 = require("react/jsx-runtime");
+var import_jsx_runtime16 = require("react/jsx-runtime");
 var SESSION_ID_DISPLAY_LENGTH = 8;
 function SessionPicker({
   sessionStore,
@@ -2218,9 +3443,9 @@ function SessionPicker({
   onCancel
 }) {
   const sessions = (sessionStore?.list() ?? []).filter((s) => s.cwd === cwd);
-  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink15.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Text, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
-    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink15.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
       ListPicker,
       {
         items: sessions,
@@ -2231,24 +3456,24 @@ function SessionPicker({
           });
           const rawPreview = lastMsg?.content?.replace(/[\n\r]+/g, " ").trim() ?? "";
           const preview = rawPreview ? rawPreview.slice(0, 60) + (rawPreview.length > 60 ? "..." : "") : "";
-          return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink15.Text, { children: [
+          return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink15.Text, { children: [
             isSelected ? "> " : "  ",
-            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Text, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
+            /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
             "  ",
-            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Text, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
+            /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
               month: "short",
               day: "numeric",
               hour: "2-digit",
               minute: "2-digit"
             }) }),
             "  ",
-            /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink15.Text, { dimColor: true, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink15.Text, { dimColor: true, children: [
               "msgs: ",
               session.messages.length
             ] }),
-            preview ? /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_jsx_runtime15.Fragment, { children: [
+            preview ? /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_jsx_runtime16.Fragment, { children: [
               "\n    ",
-              /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink15.Text, { color: "gray", children: preview })
+              /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { color: "gray", children: preview })
             ] }) : null
           ] });
         },
@@ -2259,11 +3484,55 @@ function SessionPicker({
   ] });
 }
 
+// src/ui/BackgroundTaskPanel.tsx
+var import_ink16 = require("ink");
+var import_jsx_runtime17 = require("react/jsx-runtime");
+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";
+  return "cyan";
+}
+function getStatusMarker(status) {
+  if (status === "queued" || status === "running") return "\u25A1";
+  return "\u25A0";
+}
+function getTaskPreview(task) {
+  return task.errorPreview ?? task.resultPreview ?? task.currentAction ?? task.preview;
+}
+function formatAge(iso) {
+  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));
+  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 BackgroundTaskPanel({ tasks }) {
+  if (tasks.length === 0) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { color: "cyan", bold: true, children: "Background" }),
+    tasks.map((task) => /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_ink16.Text, { children: [
+      "- ",
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { color: getStatusColor(task.status), children: getStatusMarker(task.status) }),
+      ` ${task.kind}:${task.label} ${task.id}`,
+      task.status === "running" && formatAge(task.lastActivityAt) ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { dimColor: true, children: ` idle ${formatAge(task.lastActivityAt)}` }) : null,
+      task.timeoutReason ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { dimColor: true, children: ` (${task.timeoutReason})` }) : null,
+      getTaskPreview(task) ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_ink16.Text, { dimColor: true, children: ` - ${getTaskPreview(task)}` }) : null
+    ] }, task.id))
+  ] });
+}
+
 // src/ui/App.tsx
-var import_jsx_runtime16 = require("react/jsx-runtime");
+var import_jsx_runtime18 = require("react/jsx-runtime");
 function App(props) {
-  const [activeSessionId, setActiveSessionId] = (0, import_react17.useState)(props.resumeSessionId);
-  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+  const [activeSessionId, setActiveSessionId] = (0, import_react18.useState)(props.resumeSessionId);
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
     AppInner,
     {
       ...props,
@@ -2275,6 +3544,7 @@ function App(props) {
 }
 function AppInner(props) {
   const cwd = props.cwd;
+  const providerDefinitions = props.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
   const {
     interactiveSession,
     registry,
@@ -2284,12 +3554,15 @@ function AppInner(props) {
     activeTools,
     isThinking,
     isAborting,
+    isShuttingDown,
     pendingPrompt,
+    backgroundTasks,
     permissionRequest,
     contextState,
     handleSubmit: baseHandleSubmit,
     handleAbort,
-    handleCancelQueue
+    handleCancelQueue,
+    handleShutdown
   } = useInteractiveSession({
     cwd,
     provider: props.provider,
@@ -2298,38 +3571,65 @@ function AppInner(props) {
     sessionStore: props.sessionStore,
     resumeSessionId: props.resumeSessionId,
     forkSession: props.forkSession,
-    sessionName: props.sessionName
+    sessionName: props.sessionName,
+    backgroundTaskRunners: props.backgroundTaskRunners,
+    subagentRunnerFactory: props.subagentRunnerFactory,
+    commandModules: props.commandModules,
+    providerDefinitions
   });
   const pluginCallbacks = usePluginCallbacks(cwd);
-  const [sessionName, setSessionName] = (0, import_react17.useState)(props.sessionName);
+  const { exit } = (0, import_ink17.useApp)();
+  const [sessionName, setSessionName] = (0, import_react18.useState)(props.sessionName);
   const {
     handleSubmit,
     pendingModelId,
+    pendingProviderProfile,
+    pendingProviderSetupType,
     showPluginTUI,
     showSessionPicker,
     setShowPluginTUI,
     setShowSessionPicker,
-    handleModelConfirm
+    handleModelConfirm,
+    handleProviderConfirm,
+    handleProviderSetupSubmit,
+    handleProviderSetupCancel
   } = useSideEffects({
+    cwd,
     interactiveSession,
     addEntry,
     baseHandleSubmit,
-    setSessionName
+    setSessionName,
+    providerDefinitions
   });
-  (0, import_react17.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     const name = interactiveSession?.getName?.();
     if (name && !sessionName) setSessionName(name);
   }, [interactiveSession, sessionName]);
-  (0, import_react17.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     const title = sessionName ? `Robota \u2014 ${sessionName}` : "Robota";
     process.stdout.write(`\x1B]0;${title}\x07`);
   }, [sessionName]);
-  (0, import_ink16.useInput)(
-    (_input, key) => {
-      if (key.escape && isThinking) handleAbort();
-    },
-    { isActive: !permissionRequest && !showPluginTUI && !showSessionPicker }
-  );
+  (0, import_ink17.useInput)((_input, key) => {
+    if (!key.escape || !isThinking) return;
+    if (permissionRequest || showPluginTUI || showSessionPicker) return;
+    handleAbort();
+  });
+  (0, import_ink17.useInput)((input, key) => {
+    if (!key.ctrl || input !== "c" || isShuttingDown) return;
+    void handleShutdown("prompt_input_exit").finally(() => exit());
+  });
+  (0, import_react18.useEffect)(() => {
+    const onSigterm = () => {
+      if (isShuttingDown) return;
+      void handleShutdown("other").finally(() => exit());
+    };
+    process.once("SIGINT", onSigterm);
+    process.once("SIGTERM", onSigterm);
+    return () => {
+      process.off("SIGINT", onSigterm);
+      process.off("SIGTERM", onSigterm);
+    };
+  }, [handleShutdown, exit, isShuttingDown]);
   let permissionMode = props.permissionMode ?? "default";
   let sessionId = "";
   try {
@@ -2338,41 +3638,59 @@ function AppInner(props) {
     sessionId = session.getSessionId();
   } catch {
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { color: "cyan", bold: true, children: `
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Text, { color: "cyan", bold: true, children: `
   ____   ___  ____   ___ _____  _
  |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
  | |_) | | | |  _ \\| | | || | / _ \\
  |  _ <| |_| | |_) | |_| || |/ ___ \\
  |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
 ` }),
-      /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Text, { dimColor: true, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Text, { dimColor: true, children: [
         " v",
         props.version ?? "0.0.0"
       ] })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(MessageList, { history }),
-      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(StreamingIndicator, { text: streamingText, activeTools }) })
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(import_ink17.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(MessageList, { history }),
+      isShuttingDown && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Text, { color: "yellow", children: "Shutting down..." }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(StreamingIndicator, { text: streamingText, activeTools }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(BackgroundTaskPanel, { tasks: backgroundTasks })
     ] }),
-    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(PermissionPrompt, { request: permissionRequest }),
-    pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       ConfirmPrompt,
       {
-        message: `Change model to ${(0, import_agent_core5.getModelName)(pendingModelId)}? This will restart the session.`,
+        message: `Change model to ${(0, import_agent_core7.getModelName)(pendingModelId)}? This will restart the session.`,
         onSelect: handleModelConfirm
       }
     ),
-    showPluginTUI && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    pendingProviderProfile && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+      ConfirmPrompt,
+      {
+        message: `Change provider to ${pendingProviderProfile}? This will restart the session.`,
+        onSelect: handleProviderConfirm
+      }
+    ),
+    pendingProviderSetupType && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+      ProviderSetupPrompt,
+      {
+        type: pendingProviderSetupType,
+        providerDefinitions,
+        onSubmit: handleProviderSetupSubmit,
+        onCancel: handleProviderSetupCancel
+      }
+    ),
+    showPluginTUI && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       PluginTUI,
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addEntry((0, import_agent_core5.messageToHistoryEntry)((0, import_agent_core5.createSystemMessage)(msg.content)))
+        addMessage: (msg) => addEntry((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(msg.content)))
       }
     ),
-    showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       SessionPicker,
       {
         sessionStore: props.sessionStore,
@@ -2383,15 +3701,15 @@ function AppInner(props) {
         },
         onCancel: () => {
           setShowSessionPicker(false);
-          addEntry((0, import_agent_core5.messageToHistoryEntry)((0, import_agent_core5.createSystemMessage)("Session resume cancelled.")));
+          addEntry((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)("Session resume cancelled.")));
         }
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       StatusBar,
       {
         permissionMode,
-        modelName: props.modelId ? (0, import_agent_core5.getModelName)(props.modelId) : "",
+        modelName: props.modelId ? (0, import_agent_core7.getModelName)(props.modelId) : "",
         sessionId,
         messageCount: history.length,
         isThinking,
@@ -2401,24 +3719,24 @@ function AppInner(props) {
         sessionName
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
       InputArea,
       {
         onSubmit: handleSubmit,
         onCancelQueue: handleCancelQueue,
-        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || isThinking && !!pendingPrompt,
+        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || isShuttingDown || !!pendingProviderSetupType || isThinking && !!pendingPrompt,
         isAborting,
         pendingPrompt,
         registry,
         sessionName
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { children: " " })
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Text, { children: " " })
   ] });
 }
 
 // src/ui/render.tsx
-var import_jsx_runtime17 = require("react/jsx-runtime");
+var import_jsx_runtime19 = require("react/jsx-runtime");
 function renderApp(options) {
   process.on("unhandledRejection", (reason) => {
     process.stderr.write(`
@@ -2432,8 +3750,8 @@ function renderApp(options) {
   if (process.stdin.isTTY && process.stdout.isTTY) {
     process.stdout.write("\x1B[?2004h");
   }
-  const instance = (0, import_ink17.render)(/* @__PURE__ */ (0, import_jsx_runtime17.jsx)(App, { ...options }), {
-    exitOnCtrlC: true
+  const instance = (0, import_ink18.render)(/* @__PURE__ */ (0, import_jsx_runtime19.jsx)(App, { ...options }), {
+    exitOnCtrlC: false
   });
   instance.waitUntilExit().then(() => {
     if (process.stdout.isTTY) {
@@ -2450,29 +3768,613 @@ function renderApp(options) {
   });
 }
 
-// src/cli.ts
-var import_meta = {};
-function checkSettingsFile(filePath) {
-  if (!(0, import_node_fs3.existsSync)(filePath)) return "missing";
+// src/background/managed-shell-process-runner.ts
+var import_node_child_process = require("child_process");
+var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
+var DEFAULT_OUTPUT_LIMIT_BYTES = 3e4;
+var DEFAULT_KILL_GRACE_MS = 2e3;
+var LOG_PAGE_SIZE = 200;
+function createCapture(limitBytes) {
+  const chunks = [];
+  let capturedBytes = 0;
+  let truncated = false;
+  return {
+    appendOutput(text) {
+      if (truncated) return;
+      const remaining = limitBytes - capturedBytes;
+      const buffer = Buffer.from(text, "utf8");
+      if (buffer.byteLength <= remaining) {
+        chunks.push(text);
+        capturedBytes += buffer.byteLength;
+        return;
+      }
+      chunks.push(buffer.subarray(0, Math.max(remaining, 0)).toString("utf8"));
+      chunks.push("\n[output truncated]\n");
+      truncated = true;
+    },
+    getOutput() {
+      return chunks.join("");
+    }
+  };
+}
+function appendLog(lines, source, text) {
+  for (const line of text.split(/\r?\n/)) {
+    if (line.length > 0) lines.push(`[${source}] ${line}`);
+  }
+}
+function resolveShell(request) {
+  return { command: request.shell ?? "sh", args: ["-c", request.command] };
+}
+function sendInput(child, input) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      child.stdin.off("error", onError);
+      reject(error);
+    };
+    child.stdin.once("error", onError);
+    child.stdin.end(input, () => {
+      child.stdin.off("error", onError);
+      resolve();
+    });
+  });
+}
+function createManagedShellProcessRunner(options = {}) {
+  const killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+  return {
+    kind: "process",
+    start(task) {
+      if (task.request.kind !== "process") {
+        throw new import_agent_sdk3.BackgroundTaskError("runner", `Invalid process task kind: ${task.request.kind}`);
+      }
+      return startProcessTask(task.taskId, task.request, killGraceMs);
+    }
+  };
+}
+function startProcessTask(taskId, request, killGraceMs) {
+  const shell = resolveShell(request);
+  const runtime = {
+    taskId,
+    request,
+    child: (0, import_node_child_process.spawn)(shell.command, shell.args, {
+      cwd: request.cwd,
+      env: { ...process.env, ...request.env ?? {} },
+      stdio: ["pipe", "pipe", "pipe"]
+    }),
+    logs: [],
+    capture: createCapture(request.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES),
+    killGraceMs
+  };
+  const result = createProcessResult(runtime);
+  return createProcessHandle(runtime, result);
+}
+function createProcessResult(runtime) {
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    const timeoutTimer = runtime.request.timeoutMs ? setTimeout(() => {
+      appendLog(runtime.logs, "system", `timed out after ${runtime.request.timeoutMs}ms`);
+      runtime.child.kill("SIGTERM");
+      rejectOnceLocal(new import_agent_sdk3.BackgroundTaskError("timeout", "Background process timed out"));
+    }, runtime.request.timeoutMs) : void 0;
+    function clearTimers() {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      if (runtime.killTimer) clearTimeout(runtime.killTimer);
+    }
+    function resolveOnce(exitCode, signalCode) {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      resolve({
+        taskId: runtime.taskId,
+        kind: "process",
+        output: runtime.capture.getOutput(),
+        exitCode,
+        signalCode
+      });
+    }
+    function rejectOnceLocal(error) {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      reject(error);
+    }
+    attachOutputListeners(runtime);
+    runtime.child.on("error", (error) => {
+      appendLog(runtime.logs, "system", error.message);
+      rejectOnceLocal(new import_agent_sdk3.BackgroundTaskError("process", error.message));
+    });
+    runtime.child.on("close", (code, signal) => {
+      resolveOnce(code ?? void 0, signal ?? void 0);
+    });
+    if (runtime.request.stdin) {
+      runtime.child.stdin.write(runtime.request.stdin);
+      runtime.child.stdin.end();
+    }
+  });
+}
+function createProcessHandle(runtime, result) {
+  return {
+    taskId: runtime.taskId,
+    ...runtime.child.pid !== void 0 ? { pid: runtime.child.pid } : {},
+    result,
+    cancel: async (reason) => {
+      cancelProcess(runtime, reason);
+    },
+    send: async (input) => {
+      if (!input.stdin) return;
+      await sendInput(runtime.child, input.stdin);
+    },
+    readLog: (cursor) => Promise.resolve(readProcessLog(runtime, cursor))
+  };
+}
+function attachOutputListeners(runtime) {
+  runtime.child.stdout.on("data", (chunk) => {
+    const text = chunk.toString("utf8");
+    runtime.capture.appendOutput(text);
+    appendLog(runtime.logs, "stdout", text);
+  });
+  runtime.child.stderr.on("data", (chunk) => {
+    const text = chunk.toString("utf8");
+    runtime.capture.appendOutput(text);
+    appendLog(runtime.logs, "stderr", text);
+  });
+}
+function cancelProcess(runtime, reason) {
+  appendLog(runtime.logs, "system", reason ? `cancel requested: ${reason}` : "cancel requested");
+  if (!runtime.child.killed) runtime.child.kill("SIGTERM");
+  runtime.killTimer = setTimeout(() => {
+    if (!runtime.child.killed) runtime.child.kill("SIGKILL");
+  }, runtime.killGraceMs);
+}
+function readProcessLog(runtime, cursor) {
+  const offset = cursor?.offset ?? 0;
+  const nextOffset = Math.min(offset + LOG_PAGE_SIZE, runtime.logs.length);
+  return {
+    taskId: runtime.taskId,
+    cursor,
+    nextCursor: nextOffset < runtime.logs.length ? { offset: nextOffset } : void 0,
+    lines: runtime.logs.slice(offset, nextOffset)
+  };
+}
+
+// src/subagents/child-process-subagent-runner.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs5 = require("fs");
+var import_node_path7 = require("path");
+var import_agent_sdk7 = require("@robota-sdk/agent-sdk");
+
+// src/subagents/child-process-subagent-runner-result.ts
+var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
+
+// src/subagents/child-process-subagent-ipc.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasString(value, key) {
+  return typeof value[key] === "string";
+}
+function isSubagentWorkerChildMessage(value) {
+  if (!isRecord(value) || !hasString(value, "type")) return false;
+  switch (value.type) {
+    case "ready":
+      return true;
+    case "text_delta":
+      return hasString(value, "delta");
+    case "tool_start":
+      return hasString(value, "toolName");
+    case "tool_end":
+      return hasString(value, "toolName") && typeof value.success === "boolean";
+    case "result":
+      return hasString(value, "output");
+    case "error":
+      return hasString(value, "message");
+    case "cancelled":
+      return value.reason === void 0 || typeof value.reason === "string";
+    default:
+      return false;
+  }
+}
+
+// src/subagents/child-process-subagent-transport.ts
+var import_agent_sdk4 = require("@robota-sdk/agent-sdk");
+function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit) {
+  switch (message.type) {
+    case "ready":
+      startWorker();
+      break;
+    case "result":
+      resolveOnce(message.output);
+      break;
+    case "error":
+      rejectOnce(new import_agent_sdk4.BackgroundTaskError("runner", message.message));
+      break;
+    case "cancelled":
+      rejectOnce(new import_agent_sdk4.BackgroundTaskError("runner", message.reason ?? "Subagent worker cancelled"));
+      break;
+    case "text_delta":
+      emit?.({ type: "background_task_text_delta", delta: message.delta });
+      break;
+    case "tool_start":
+      emit?.({
+        type: "background_task_tool_start",
+        toolName: message.toolName,
+        firstArg: extractFirstArg(message.toolArgs)
+      });
+      break;
+    case "tool_end":
+      emit?.({
+        type: "background_task_tool_end",
+        toolName: message.toolName,
+        success: message.success
+      });
+      break;
+    default:
+      rejectOnce(new import_agent_sdk4.BackgroundTaskError("runner", "Unhandled subagent worker message"));
+  }
+}
+function extractFirstArg(toolArgs) {
+  if (!toolArgs) return void 0;
+  const firstValue = Object.values(toolArgs)[0];
+  if (firstValue === void 0) return void 0;
+  return typeof firstValue === "object" ? JSON.stringify(firstValue) : String(firstValue);
+}
+function sendWorkerMessage(child, message) {
+  return new Promise((resolve, reject) => {
+    if (!child.connected) {
+      reject(new import_agent_sdk4.BackgroundTaskError("crash", "Subagent worker IPC channel is closed"));
+      return;
+    }
+    child.send(message, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function cancelChildProcess(runtime, reason) {
+  if (runtime.child.connected) {
+    await sendWorkerMessage(runtime.child, { type: "cancel", reason }).catch(() => void 0);
+  }
+  runtime.killTimer = setTimeout(() => {
+    if (!runtime.child.killed) {
+      runtime.child.kill("SIGTERM");
+    }
+  }, runtime.killGraceMs);
+}
+
+// src/subagents/child-process-subagent-runner-result.ts
+function createChildProcessSubagentResult(options) {
+  return new Promise((resolve, reject) => {
+    new ChildProcessSubagentResultController(options, resolve, reject).start();
+  });
+}
+var ChildProcessSubagentResultController = class {
+  constructor(options, resolve, reject) {
+    this.options = options;
+    this.resolve = resolve;
+    this.reject = reject;
+    this.timeoutTimer = createTimeoutTimer(this.options.runtime, (error) => this.rejectOnce(error));
+  }
+  settled = false;
+  started = false;
+  timeoutTimer;
+  start() {
+    const { child } = this.options.runtime;
+    child.on("message", this.onMessage);
+    child.on("error", this.onError);
+    child.on("exit", this.onExit);
+    child.once("spawn", () => {
+      setImmediate(this.startWorker);
+    });
+  }
+  startWorker = () => {
+    if (this.started) return;
+    this.started = true;
+    const { child } = this.options.runtime;
+    void sendWorkerMessage(child, { type: "start", payload: this.options.payload }).catch(
+      (error) => {
+        this.rejectOnce(error instanceof Error ? error : new Error(String(error)));
+      }
+    );
+  };
+  onMessage = (message) => {
+    if (!isSubagentWorkerChildMessage(message)) {
+      this.rejectOnce(
+        new import_agent_sdk5.BackgroundTaskError("runner", "Received malformed subagent worker message")
+      );
+      return;
+    }
+    const { job } = this.options.runtime;
+    handleWorkerMessage(message, this.startWorker, this.resolveOnce, this.rejectOnce, job.emit);
+  };
+  onError = (error) => {
+    this.rejectOnce(new import_agent_sdk5.BackgroundTaskError("crash", error.message));
+  };
+  onExit = (code, signal) => {
+    if (this.settled) return;
+    this.rejectOnce(new import_agent_sdk5.BackgroundTaskError("crash", formatEarlyExitMessage(code, signal)));
+  };
+  resolveOnce = (output) => {
+    if (this.settled) return;
+    this.settled = true;
+    this.clearTimers();
+    this.cleanup();
+    const { runtime, resolveTranscriptPath } = this.options;
+    this.resolve(toSubagentResult(runtime.job, output, resolveTranscriptPath));
+  };
+  rejectOnce = (error) => {
+    if (this.settled) return;
+    this.settled = true;
+    this.clearTimers();
+    this.cleanup();
+    this.reject(error);
+  };
+  clearTimers() {
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    if (this.options.runtime.killTimer) clearTimeout(this.options.runtime.killTimer);
+  }
+  cleanup() {
+    const { child } = this.options.runtime;
+    child.off("message", this.onMessage);
+    child.off("error", this.onError);
+    child.off("exit", this.onExit);
+  }
+};
+function createCancellationResult(jobId) {
+  let settled = false;
+  let rejectFn = () => {
+  };
+  const promise = new Promise((_resolve, reject) => {
+    rejectFn = reject;
+  });
+  return {
+    promise,
+    reject(reason) {
+      if (settled) return;
+      settled = true;
+      rejectFn(new import_agent_sdk5.BackgroundTaskError("runner", reason ?? `Subagent job cancelled: ${jobId}`));
+    }
+  };
+}
+function createTimeoutTimer(runtime, rejectOnce) {
+  if (!runtime.job.request.timeoutMs) return void 0;
+  return setTimeout(() => {
+    void cancelChildProcess(runtime, "Subagent worker timed out");
+    rejectOnce(new import_agent_sdk5.BackgroundTaskError("timeout", "Subagent worker timed out"));
+  }, runtime.job.request.timeoutMs);
+}
+function toSubagentResult(job, output, resolveTranscriptPath) {
+  const transcriptPath = resolveTranscriptPath(job);
+  return {
+    jobId: job.jobId,
+    output,
+    ...transcriptPath ? { metadata: { transcriptPath, logPath: transcriptPath } } : {}
+  };
+}
+function formatEarlyExitMessage(code, signal) {
+  const detail = signal !== null ? `signal ${signal}` : `exit code ${code === null ? "unknown" : code}`;
+  return `Subagent worker exited before result: ${detail}`;
+}
+
+// src/subagents/git-worktree-isolation-adapter.ts
+var import_node_child_process2 = require("child_process");
+var import_node_crypto2 = require("crypto");
+var import_node_fs4 = require("fs");
+var import_node_path6 = require("path");
+var import_agent_sdk6 = require("@robota-sdk/agent-sdk");
+var WORKTREE_DIR = ".robota/worktrees";
+var BRANCH_PREFIX = "robota";
+var GIT_ENCODING = "utf8";
+var SHORT_ID_LENGTH = 8;
+function createGitWorktreeIsolationAdapter(options) {
+  return new GitWorktreeIsolationAdapter(options);
+}
+var GitWorktreeIsolationAdapter = class {
+  worktreeDir;
+  branchPrefix;
+  constructor(options = {}) {
+    this.worktreeDir = options.worktreeDir ?? WORKTREE_DIR;
+    this.branchPrefix = options.branchPrefix ?? BRANCH_PREFIX;
+  }
+  prepare(request) {
+    const repoRoot = runGit(request.cwd, ["rev-parse", "--show-toplevel"]).trim();
+    const shortId = (0, import_node_crypto2.randomUUID)().slice(0, SHORT_ID_LENGTH);
+    const branchName = `${this.branchPrefix}/${request.jobId}-${shortId}`;
+    const worktreeRoot = (0, import_node_path6.join)(repoRoot, this.worktreeDir);
+    const worktreePath = (0, import_node_path6.join)(worktreeRoot, `${request.jobId}-${shortId}`);
+    (0, import_node_fs4.mkdirSync)(worktreeRoot, { recursive: true });
+    runGit(repoRoot, ["worktree", "add", "-b", branchName, worktreePath, "HEAD"]);
+    return { repoRoot, worktreePath, branchName };
+  }
+  isClean(worktree) {
+    return runGit(worktree.worktreePath, ["status", "--porcelain"]).trim().length === 0;
+  }
+  remove(worktree) {
+    runGit(worktree.repoRoot, ["worktree", "remove", "--force", worktree.worktreePath]);
+    runGit(worktree.repoRoot, ["branch", "-D", worktree.branchName]);
+  }
+};
+function runGit(cwd, args) {
   try {
-    const raw = (0, import_node_fs3.readFileSync)(filePath, "utf8").trim();
-    if (raw.length === 0) return "incomplete";
-    const parsed = JSON.parse(raw);
-    const provider = parsed.provider;
-    if (!provider?.apiKey) return "incomplete";
-    return "valid";
-  } catch {
-    return "corrupt";
+    return (0, import_node_child_process2.execFileSync)("git", args, {
+      cwd,
+      encoding: GIT_ENCODING,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new import_agent_sdk6.BackgroundTaskError("runner", `git ${args.join(" ")} failed: ${message}`);
+  }
+}
+
+// src/subagents/child-process-subagent-runner.ts
+var DEFAULT_KILL_GRACE_MS2 = 2e3;
+var LOG_PAGE_SIZE2 = 200;
+function createChildProcessSubagentRunnerFactory(options = {}) {
+  return (deps) => {
+    const runner = new ChildProcessSubagentRunner(deps, options);
+    if (options.worktreeIsolation === false) return runner;
+    return (0, import_agent_sdk7.createWorktreeSubagentRunner)({
+      runner,
+      worktreeAdapter: options.worktreeAdapter ?? createGitWorktreeIsolationAdapter(),
+      hooks: deps.config.hooks,
+      hookTypeExecutors: deps.hookTypeExecutors
+    });
+  };
+}
+var ChildProcessSubagentRunner = class {
+  constructor(deps, options = {}) {
+    this.deps = deps;
+    this.workerPath = options.workerPath ?? resolveDefaultWorkerPath();
+    this.execArgv = options.execArgv;
+    this.killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS2;
+    this.providerConfig = options.providerConfig;
+    this.env = options.env;
+    this.logsDir = options.logsDir;
+  }
+  workerPath;
+  execArgv;
+  killGraceMs;
+  providerConfig;
+  env;
+  logsDir;
+  start(job) {
+    const child = (0, import_node_child_process3.fork)(this.workerPath, [], {
+      cwd: job.request.cwd,
+      env: { ...process.env, ...this.env ?? {} },
+      execArgv: this.execArgv ?? resolveDefaultExecArgv(this.workerPath),
+      stdio: ["ignore", "ignore", "ignore", "ipc"]
+    });
+    const runtime = {
+      job,
+      child,
+      killGraceMs: this.killGraceMs
+    };
+    const payload = this.createStartPayload(job);
+    const workerResult = createChildProcessSubagentResult({
+      runtime,
+      payload,
+      resolveTranscriptPath: (request) => this.resolveTranscriptPath(request)
+    });
+    const cancellation = createCancellationResult(job.jobId);
+    void workerResult.catch(() => void 0);
+    const result = Promise.race([workerResult, cancellation.promise]);
+    const transcriptPath = this.resolveTranscriptPath(job);
+    return {
+      jobId: job.jobId,
+      ...child.pid !== void 0 && { pid: child.pid },
+      ...transcriptPath !== void 0 && { transcriptPath, logPath: transcriptPath },
+      result,
+      cancel: async (reason) => {
+        cancellation.reject(reason);
+        await cancelChildProcess(runtime, reason);
+      },
+      send: async (prompt) => {
+        await sendWorkerMessage(child, { type: "send", prompt });
+      },
+      ...transcriptPath !== void 0 && {
+        readLog: async (cursor) => readTranscriptLog(job.jobId, transcriptPath, cursor)
+      }
+    };
+  }
+  createStartPayload(job) {
+    const definition = resolveAgentDefinition(job.request.type, this.deps.customAgentRegistry);
+    return {
+      jobId: job.jobId,
+      request: job.request,
+      agentDefinition: applyRequestOverrides(definition, job),
+      parentConfig: this.deps.config,
+      parentContext: this.deps.context,
+      providerProfile: createProviderProfile(this.providerConfig, this.deps, job),
+      permissionMode: this.deps.permissionMode,
+      ...this.logsDir ? { logsDir: this.logsDir } : {}
+    };
+  }
+  resolveTranscriptPath(job) {
+    if (!this.logsDir) return void 0;
+    return (0, import_node_path7.join)(this.logsDir, job.request.parentSessionId, "subagents", `${job.jobId}.jsonl`);
+  }
+};
+function resolveAgentDefinition(agentType, customRegistry) {
+  const definition = customRegistry?.(agentType) ?? (0, import_agent_sdk7.getBuiltInAgent)(agentType);
+  if (!definition) {
+    throw new import_agent_sdk7.BackgroundTaskError("validation", `Unknown agent type: ${agentType}`);
+  }
+  return definition;
+}
+function applyRequestOverrides(definition, job) {
+  return {
+    ...definition,
+    ...job.request.model ? { model: job.request.model } : {},
+    ...job.request.allowedTools ? { tools: job.request.allowedTools } : {},
+    ...job.request.disallowedTools ? { disallowedTools: job.request.disallowedTools } : {}
+  };
+}
+function createProviderProfile(providerConfig, deps, job) {
+  const provider = providerConfig ?? deps.config.provider;
+  return {
+    profileName: deps.config.currentProvider,
+    type: provider.name,
+    model: job.request.model ?? provider.model,
+    apiKey: provider.apiKey,
+    baseURL: provider.baseURL,
+    timeout: provider.timeout
+  };
+}
+function resolveDefaultWorkerPath() {
+  const entryPoint = process.argv[1] ?? "";
+  const entryDir = entryPoint ? (0, import_node_path7.dirname)(entryPoint) : process.cwd();
+  const extension = entryPoint.endsWith(".ts") || entryPoint.endsWith(".tsx") ? ".ts" : ".js";
+  const candidates = [
+    (0, import_node_path7.join)(entryDir, "subagents", `child-process-subagent-worker${extension}`),
+    (0, import_node_path7.join)(entryDir, `child-process-subagent-worker${extension}`)
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_node_fs5.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+}
+function resolveDefaultExecArgv(workerPath) {
+  if (!workerPath.endsWith(".ts")) {
+    return process.execArgv;
+  }
+  if (process.execArgv.some((arg) => arg.includes("tsx"))) {
+    return process.execArgv;
+  }
+  return [...process.execArgv, "--import", "tsx"];
+}
+function readTranscriptLog(jobId, transcriptPath, cursor) {
+  const offset = cursor?.offset ?? 0;
+  if (!(0, import_node_fs5.existsSync)(transcriptPath)) {
+    return {
+      taskId: jobId,
+      cursor,
+      lines: []
+    };
   }
+  const lines = (0, import_node_fs5.readFileSync)(transcriptPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const nextOffset = Math.min(offset + LOG_PAGE_SIZE2, lines.length);
+  return {
+    taskId: jobId,
+    cursor,
+    nextCursor: nextOffset < lines.length ? { offset: nextOffset } : void 0,
+    lines: lines.slice(offset, nextOffset)
+  };
 }
+
+// src/cli.ts
+var import_meta = {};
 function readVersion() {
   try {
     const thisFile = (0, import_node_url.fileURLToPath)(import_meta.url);
-    const dir = (0, import_node_path5.dirname)(thisFile);
-    const candidates = [(0, import_node_path5.join)(dir, "..", "..", "package.json"), (0, import_node_path5.join)(dir, "..", "package.json")];
+    const dir = (0, import_node_path8.dirname)(thisFile);
+    const candidates = [(0, import_node_path8.join)(dir, "..", "..", "package.json"), (0, import_node_path8.join)(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = (0, import_node_fs3.readFileSync)(pkgPath, "utf-8");
+        const raw = (0, import_node_fs6.readFileSync)(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version !== void 0 && pkg.name !== void 0) {
           return pkg.version;
@@ -2520,63 +4422,6 @@ function promptInput(label, masked = false) {
     stdin.on("data", onData);
   });
 }
-async function ensureConfig(cwd) {
-  const userPath = getUserSettingsPath();
-  const projectPath = (0, import_node_path5.join)(cwd, ".robota", "settings.json");
-  const localPath = (0, import_node_path5.join)(cwd, ".robota", "settings.local.json");
-  const paths = [userPath, projectPath, localPath];
-  const checks = paths.map((p) => ({ path: p, status: checkSettingsFile(p) }));
-  if (checks.some((c) => c.status === "valid")) {
-    return;
-  }
-  const corrupt = checks.filter((c) => c.status === "corrupt");
-  const incomplete = checks.filter((c) => c.status === "incomplete");
-  process.stdout.write("\n");
-  if (corrupt.length > 0) {
-    for (const c of corrupt) {
-      process.stderr.write(`  ERROR: Settings file is corrupt (invalid JSON): ${c.path}
-`);
-    }
-    process.stdout.write("\n");
-  }
-  if (incomplete.length > 0) {
-    for (const c of incomplete) {
-      process.stderr.write(`  WARNING: Settings file is missing provider.apiKey: ${c.path}
-`);
-    }
-    process.stdout.write("\n");
-  }
-  if (corrupt.length === 0 && incomplete.length === 0) {
-    process.stdout.write("  Welcome to Robota CLI!\n");
-    process.stdout.write("  No configuration found. Let's set up.\n");
-  } else {
-    process.stdout.write("  Reconfiguring...\n");
-  }
-  process.stdout.write("\n");
-  const apiKey = await promptInput("  Anthropic API key: ", true);
-  if (!apiKey) {
-    process.stderr.write("\n  No API key provided. Exiting.\n");
-    process.exit(1);
-  }
-  const language = await promptInput("  Response language (ko/en/ja/zh, default: en): ");
-  const settingsDir = (0, import_node_path5.dirname)(userPath);
-  (0, import_node_fs3.mkdirSync)(settingsDir, { recursive: true });
-  const settings = {
-    provider: {
-      name: "anthropic",
-      model: "claude-sonnet-4-6",
-      apiKey
-    }
-  };
-  if (language) {
-    settings.language = language;
-  }
-  (0, import_node_fs3.writeFileSync)(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
-  process.stdout.write(`
-  Config saved to ${userPath}
-
-`);
-}
 function resetConfig() {
   const userPath = getUserSettingsPath();
   if (deleteSettings(userPath)) {
@@ -2586,7 +4431,7 @@ function resetConfig() {
     process.stdout.write("No user settings found.\n");
   }
 }
-async function startCli() {
+async function startCli(options = {}) {
   const args = parseCliArgs();
   if (args.version) {
     process.stdout.write(`robota ${readVersion()}
@@ -2598,11 +4443,32 @@ async function startCli() {
     return;
   }
   const cwd = process.cwd();
-  await ensureConfig(cwd);
-  const providerSettings = readProviderSettings(cwd);
+  const providerDefinitions = options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  if (args.configure) {
+    await runInteractiveProviderSetup(cwd, args, promptInput, providerDefinitions);
+    return;
+  }
+  if (handleProviderConfigurationArgs(cwd, args, providerDefinitions)) {
+    return;
+  }
+  try {
+    await ensureConfig(cwd, args, promptInput, providerDefinitions);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+  const providerOptions = args.provider ? { providerOverride: args.provider, providerDefinitions } : { providerDefinitions };
+  const providerSettings = readProviderSettings(cwd, providerOptions);
   const modelId = args.model ?? providerSettings.model;
-  const provider = createProviderFromSettings(cwd, args.model);
-  const sessionStore = new import_agent_sessions.SessionStore();
+  const provider = createProviderFromSettings(cwd, args.model, providerOptions);
+  const backgroundTaskRunners = [createManagedShellProcessRunner()];
+  const paths = (0, import_agent_sdk8.projectPaths)(cwd);
+  const subagentRunnerFactory = createChildProcessSubagentRunnerFactory({
+    providerConfig: { ...providerSettings, model: modelId },
+    logsDir: paths.logs
+  });
+  const sessionStore = new import_agent_sessions.SessionStore(paths.sessions);
   let resumeSessionId;
   if (args.continueMode) {
     const sessions = sessionStore.list().filter((s) => s.cwd === cwd);
@@ -2637,13 +4503,27 @@ async function startCli() {
       process.stderr.write("Print mode (-p) requires a prompt argument.\n");
       process.exit(1);
     }
-    const session = new import_agent_sdk4.InteractiveSession({
+    const appendParts = [];
+    if (args.appendSystemPrompt) appendParts.push(args.appendSystemPrompt);
+    if (args.jsonSchema)
+      appendParts.push(
+        `Respond with valid JSON only, matching this JSON schema:
+${args.jsonSchema}`
+      );
+    const appendSystemPrompt = appendParts.length > 0 ? appendParts.join("\n\n") : void 0;
+    const session = new import_agent_sdk8.InteractiveSession({
       cwd,
       provider,
       permissionMode: args.permissionMode ?? "bypassPermissions",
       maxTurns: args.maxTurns,
-      sessionStore,
-      sessionName: args.sessionName
+      sessionStore: args.noSessionPersistence ? void 0 : sessionStore,
+      sessionName: args.sessionName,
+      bare: args.bare || void 0,
+      allowedTools: args.allowedTools ? args.allowedTools.split(",").map((t) => t.trim()).filter((t) => t.length > 0) : void 0,
+      appendSystemPrompt,
+      backgroundTaskRunners,
+      subagentRunnerFactory,
+      commandModules: options.commandModules
     });
     const transport = (0, import_agent_transport_headless.createHeadlessTransport)({
       outputFormat: args.outputFormat ?? "text",
@@ -2651,6 +4531,7 @@ async function startCli() {
     });
     session.attachTransport(transport);
     await transport.start();
+    await session.shutdown({ reason: "prompt_input_exit", message: "Headless transport complete" });
     process.exit(transport.getExitCode());
   }
   renderApp({
@@ -2664,10 +4545,19 @@ async function startCli() {
     sessionStore,
     resumeSessionId,
     forkSession: args.forkSession,
-    sessionName: args.sessionName
+    sessionName: args.sessionName,
+    backgroundTaskRunners,
+    subagentRunnerFactory,
+    commandModules: options.commandModules,
+    providerDefinitions
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ChildProcessSubagentRunner,
+  GitWorktreeIsolationAdapter,
+  createChildProcessSubagentRunnerFactory,
+  createGitWorktreeIsolationAdapter,
+  createManagedShellProcessRunner,
   startCli
 });