@robota-sdk/agent-cli 3.0.0-beta.59 → 3.0.0-beta.60

package/dist/node/index.cjs

@@ -43,7 +43,24 @@ module.exports = __toCommonJS(index_exports);
 var import_node_fs8 = require("fs");
 var import_node_path10 = require("path");
 var import_node_url = require("url");
-var import_agent_sdk8 = require("@robota-sdk/agent-sdk");
+var import_agent_command_agent = require("@robota-sdk/agent-command-agent");
+var import_agent_command_background = require("@robota-sdk/agent-command-background");
+var import_agent_command_provider = require("@robota-sdk/agent-command-provider");
+var import_agent_command_compact = require("@robota-sdk/agent-command-compact");
+var import_agent_command_context = require("@robota-sdk/agent-command-context");
+var import_agent_command_exit = require("@robota-sdk/agent-command-exit");
+var import_agent_command_help = require("@robota-sdk/agent-command-help");
+var import_agent_command_language = require("@robota-sdk/agent-command-language");
+var import_agent_command_memory = require("@robota-sdk/agent-command-memory");
+var import_agent_command_mode = require("@robota-sdk/agent-command-mode");
+var import_agent_command_model = require("@robota-sdk/agent-command-model");
+var import_agent_command_permissions = require("@robota-sdk/agent-command-permissions");
+var import_agent_command_plugin = require("@robota-sdk/agent-command-plugin");
+var import_agent_command_reset = require("@robota-sdk/agent-command-reset");
+var import_agent_command_rewind = require("@robota-sdk/agent-command-rewind");
+var import_agent_command_statusline = require("@robota-sdk/agent-command-statusline");
+var import_agent_command_session = require("@robota-sdk/agent-command-session");
+var import_agent_sdk14 = require("@robota-sdk/agent-sdk");
 var import_agent_sessions = require("@robota-sdk/agent-sessions");
 
 // src/utils/cli-args.ts
@@ -159,28 +176,6 @@ function writeSettings(path, settings) {
   (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
   (0, import_node_fs.writeFileSync)(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
 }
-function updateModelInSettings(settingsPath, modelId) {
-  const settings = readSettings(settingsPath);
-  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);
@@ -192,7 +187,6 @@ function deleteSettings(path) {
 // src/utils/provider-factory.ts
 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");
@@ -212,31 +206,7 @@ var DEFAULT_PROVIDER_DEFINITIONS = [
 var import_agent_core = require("@robota-sdk/agent-core");
 
 // src/utils/env-ref.ts
-var ENV_REFERENCE_PREFIX = "$ENV:";
-function isEnvReference(value) {
-  return value.startsWith(ENV_REFERENCE_PREFIX);
-}
-function getEnvReferenceName(value) {
-  if (!isEnvReference(value)) {
-    return void 0;
-  }
-  const envName = value.slice(ENV_REFERENCE_PREFIX.length).trim();
-  return envName.length > 0 ? envName : void 0;
-}
-function resolveEnvReference(value) {
-  const envName = getEnvReferenceName(value);
-  if (envName === void 0) {
-    return value;
-  }
-  const resolved = process.env[envName];
-  return resolved !== void 0 && resolved.length > 0 ? resolved : void 0;
-}
-function hasUsableSecretReference(value) {
-  if (value === void 0 || value.length === 0) {
-    return false;
-  }
-  return resolveEnvReference(value) !== void 0;
-}
+var import_agent_sdk = require("@robota-sdk/agent-sdk");
 
 // src/utils/provider-factory.ts
 function readProviderSettings(cwd, options = {}) {
@@ -252,14 +222,23 @@ function readProviderSettings(cwd, options = {}) {
   throw new Error("No provider configuration found. Run `robota` to set up.");
 }
 function readMergedProviderSettings(cwd) {
-  const paths = [
-    (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"),
+  return readMergedProviderSettingsFromPaths(getProviderSettingsPaths(cwd));
+}
+function getProviderSettingsPaths(cwd) {
+  const userHome = getUserHome();
+  return [
+    (0, import_node_path2.join)(userHome, ".robota", "settings.json"),
+    (0, import_node_path2.join)(userHome, ".claude", "settings.json"),
     (0, import_node_path2.join)(cwd, ".robota", "settings.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)(cwd, ".claude", "settings.local.json")
   ];
+}
+function getUserHome() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "/";
+}
+function readMergedProviderSettingsFromPaths(paths) {
   return paths.reduce((settings, filePath) => {
     const parsed = readSettingsFile(filePath);
     if (parsed === void 0) {
@@ -343,7 +322,7 @@ function normalizeProviderConfig(settings, providerDefinitions) {
   return {
     name: settings.name,
     model,
-    apiKey: apiKeyReference !== void 0 ? resolveEnvReference(apiKeyReference) : void 0,
+    apiKey: apiKeyReference !== void 0 ? (0, import_agent_sdk.resolveEnvReference)(apiKeyReference) : void 0,
     baseURL: settings.baseURL ?? defaults.baseURL,
     timeout: settings.timeout,
     ...options !== void 0 && { options }
@@ -373,37 +352,27 @@ function getProviderDefinitions(options) {
 
 // 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 checkSettingsDocument(settings, providerDefinitions = []) {
+  return hasUsableProviderConfig(settings, providerDefinitions) ? "valid" : "incomplete";
 }
 function hasUsableProviderConfig(settings, providerDefinitions) {
+  if (typeof settings.currentProvider === "string") {
+    const profile = settings.providers?.[settings.currentProvider];
+    return isUsableProviderProfile(profile?.type, profile, 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);
+  return false;
 }
 function isUsableProviderProfile(type, profile, providerDefinitions) {
   if (!profile) {
     return false;
   }
-  if (hasUsableSecretReference(profile.apiKey)) {
+  if ((0, import_agent_sdk.hasUsableSecretReference)(profile.apiKey)) {
     return true;
   }
   if (!type) {
@@ -413,73 +382,11 @@ function isUsableProviderProfile(type, profile, providerDefinitions) {
   if (definition === void 0) {
     return false;
   }
-  return definition.requiresApiKey !== true || hasUsableSecretReference(definition.defaults?.apiKey);
+  return definition.requiresApiKey !== true || (0, import_agent_sdk.hasUsableSecretReference)(definition.defaults?.apiKey);
 }
 
 // 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 && !hasUsableSecretReference(profile.apiKey ?? definition.defaults?.apiKey)) {
-    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;
-}
+var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
 
 // src/utils/provider-configuration.ts
 function readProviderDocument(settingsPath) {
@@ -487,8 +394,8 @@ function readProviderDocument(settingsPath) {
 }
 function applyProviderConfiguration(settingsPath, input, options = {}) {
   const settings = readProviderDocument(settingsPath);
-  const patch = buildProviderSetupPatch(input, options);
-  const next = mergeProviderPatch(settings, patch);
+  const patch = (0, import_agent_sdk2.buildProviderSetupPatch)(input, options);
+  const next = (0, import_agent_sdk2.mergeProviderPatch)(settings, patch);
   writeSettings(settingsPath, next);
   return next;
 }
@@ -496,162 +403,78 @@ 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);
+  const next = hasLocalProfile || hasKnownProfile ? { ...settings, currentProvider: profileName } : (0, import_agent_sdk2.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 formatProviderSetupSelectionPrompt(providerDefinitions) {
-  if (providerDefinitions.length === 0) {
-    return "  No providers are available.";
-  }
-  const lines = [
-    "  Select provider:",
-    ...providerDefinitions.map(
-      (definition, index) => `    ${index + 1}. ${formatProviderSetupChoiceLabel(definition)}`
-    ),
-    `  Provider [1-${providerDefinitions.length}] (default: 1): `
-  ];
-  return lines.join("\n");
-}
-function resolveProviderSetupSelection(rawValue, providerDefinitions) {
-  const value = rawValue.trim();
-  const selectedValue = value.length > 0 ? value : "1";
-  const index = parseProviderSelectionIndex(selectedValue);
-  if (index !== void 0) {
-    const definition2 = providerDefinitions[index];
-    if (definition2 !== void 0) {
-      return definition2.type;
-    }
-    throw new Error(
-      `Provider selection ${selectedValue} is out of range. Currently supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`
-    );
-  }
-  const definition = (0, import_agent_core.findProviderDefinition)(providerDefinitions, selectedValue);
-  if (definition === void 0) {
-    throw new Error(
-      `Unknown provider: ${selectedValue}. Currently supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`
-    );
-  }
-  return definition.type;
-}
-function getProviderSetupStep(state) {
-  const step = state.steps[state.stepIndex];
-  if (step === void 0) {
-    throw new Error(`Provider setup step ${state.stepIndex} is out of range`);
+function applyActiveModelChange(cwd, modelId, options = {}) {
+  const settingsPaths = options.settingsPaths ?? getProviderSettingsPaths(cwd);
+  const merged = readMergedProviderSettingsFromPaths(settingsPaths);
+  const activeProfileName = options.providerOverride ?? merged.currentProvider;
+  if (typeof activeProfileName === "string") {
+    return updateActiveProviderProfileModel(settingsPaths, activeProfileName, modelId);
   }
-  return step;
+  return updateLegacyProviderModel(settingsPaths, modelId);
 }
-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 };
+function updateActiveProviderProfileModel(settingsPaths, profileName, modelId) {
+  const settingsPath = findLastPathWithProviderProfile(settingsPaths, profileName) ?? settingsPaths[0];
+  if (settingsPath === void 0) {
+    throw new Error("No settings path available for model update");
   }
-  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);
+  const settings = readProviderDocument(settingsPath);
+  const providers = settings.providers ?? {};
+  const existing = providers[profileName] ?? {};
+  const next = {
+    ...settings,
+    providers: {
+      ...providers,
+      [profileName]: {
+        ...existing,
+        model: modelId
+      }
     }
-    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 formatProviderSetupChoiceLabel(definition) {
-  const label = definition.displayName !== void 0 ? `${definition.displayName} (${definition.type})` : definition.type;
-  return definition.description !== void 0 ? `${label} - ${definition.description}` : label;
+  };
+  writeSettings(settingsPath, next);
+  return { settingsPath, settings: next, profileName };
 }
-function parseProviderSelectionIndex(value) {
-  if (!/^\d+$/.test(value)) {
-    return void 0;
+function updateLegacyProviderModel(settingsPaths, modelId) {
+  const settingsPath = findLastPathWithLegacyProvider(settingsPaths) ?? settingsPaths[0];
+  if (settingsPath === void 0) {
+    throw new Error("No settings path available for model update");
   }
-  return Number(value) - 1;
+  const settings = readProviderDocument(settingsPath);
+  const next = {
+    ...settings,
+    provider: {
+      ...settings.provider ?? {},
+      model: modelId
+    }
+  };
+  writeSettings(settingsPath, next);
+  return { settingsPath, settings: next, legacyProvider: true };
 }
-function validateProviderSetupValue(step, value) {
-  if (step.required === true && value.length === 0) {
-    return "Required";
+function findLastPathWithProviderProfile(settingsPaths, profileName) {
+  for (let index = settingsPaths.length - 1; index >= 0; index -= 1) {
+    const settingsPath = settingsPaths[index];
+    if (settingsPath === void 0) continue;
+    const settings = readProviderDocument(settingsPath);
+    if (settings.providers?.[profileName] !== void 0) return settingsPath;
   }
   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
-    });
+function findLastPathWithLegacyProvider(settingsPaths) {
+  for (let index = settingsPaths.length - 1; index >= 0; index -= 1) {
+    const settingsPath = settingsPaths[index];
+    if (settingsPath === void 0) continue;
+    const settings = readProviderDocument(settingsPath);
+    if (settings.provider !== void 0) return settingsPath;
   }
-  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
-  };
+  return void 0;
 }
 
+// src/utils/provider-setup-flow.ts
+var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
+
 // src/utils/provider-setup.ts
 function getSettingsPathForScope(cwd, scope) {
   if (scope === void 0 || scope === "user") {
@@ -683,23 +506,31 @@ function handleProviderConfigurationArgs(cwd, args, providerDefinitions = DEFAUL
   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")) {
+  const merged = readMergedProviderSettings(cwd);
+  const selectedSettings = args.provider !== void 0 ? { ...merged, currentProvider: args.provider } : merged;
+  if (checkSettingsDocument(selectedSettings, providerDefinitions) === "valid") {
     return;
   }
   if (!isInteractiveTerminal()) {
     throw new Error(formatMissingProviderConfigMessage(providerDefinitions));
   }
-  await runInteractiveProviderSetup(cwd, args, promptInput2, providerDefinitions);
+  await runInteractiveProviderSetup(
+    cwd,
+    selectStartupSetupArgs(cwd, args),
+    promptInput2,
+    providerDefinitions
+  );
+  const updated = readMergedProviderSettings(cwd);
+  const updatedSettings = args.provider !== void 0 ? { ...updated, currentProvider: args.provider } : updated;
+  if (checkSettingsDocument(updatedSettings, providerDefinitions) !== "valid") {
+    throw new Error(formatMissingProviderConfigMessage(providerDefinitions));
+  }
 }
 async function runInteractiveProviderSetup(cwd, args, promptInput2, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
-  const providerChoice = await promptInput2(formatProviderSetupSelectionPrompt(providerDefinitions));
-  const type = resolveProviderSetupSelection(providerChoice, providerDefinitions);
+  const providerChoice = await promptInput2((0, import_agent_sdk3.formatProviderSetupSelectionPrompt)(providerDefinitions));
+  const type = (0, import_agent_sdk3.resolveProviderSetupSelection)(providerChoice, providerDefinitions);
   const settingsPath = getSettingsPathForScope(cwd, args.settingsScope);
-  const input = await runProviderSetupPromptFlow(type, promptInput2, providerDefinitions);
+  const input = await (0, import_agent_sdk3.runProviderSetupPromptFlow)(type, promptInput2, providerDefinitions);
   applyProviderConfiguration(settingsPath, input, {
     providerDefinitions
   });
@@ -729,15 +560,31 @@ function buildSetupInputFromArgs(args) {
     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 selectStartupSetupArgs(cwd, args) {
+  if (args.settingsScope !== void 0 || args.provider !== void 0) {
+    return args;
+  }
+  const currentProviderPath = findHighestPriorityCurrentProviderPath(getProviderSettingsPaths(cwd));
+  if (currentProviderPath === void 0) {
+    return args;
+  }
+  const projectSettingsPath = (0, import_node_path3.join)(cwd, ".robota", "settings.json");
+  const projectLocalSettingsPath = (0, import_node_path3.join)(cwd, ".robota", "settings.local.json");
+  if (currentProviderPath === projectSettingsPath || currentProviderPath === projectLocalSettingsPath) {
+    return { ...args, settingsScope: "project-local" };
+  }
+  return args;
+}
+function findHighestPriorityCurrentProviderPath(settingsPaths) {
+  for (let index = settingsPaths.length - 1; index >= 0; index -= 1) {
+    const settingsPath = settingsPaths[index];
+    if (settingsPath === void 0) continue;
+    const settings = readSettings(settingsPath);
+    if (typeof settings.currentProvider === "string") {
+      return settingsPath;
+    }
+  }
+  return void 0;
 }
 function isInteractiveTerminal() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -771,13 +618,11 @@ var import_ink22 = require("ink");
 // src/ui/App.tsx
 var import_react19 = require("react");
 var import_ink21 = require("ink");
-var import_agent_core9 = require("@robota-sdk/agent-core");
+var import_agent_core11 = require("@robota-sdk/agent-core");
 
 // src/ui/hooks/useInteractiveSession.ts
 var import_react2 = require("react");
-var import_node_os3 = require("os");
-var import_node_path4 = require("path");
-var import_agent_sdk = require("@robota-sdk/agent-sdk");
+var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
 var import_agent_core3 = require("@robota-sdk/agent-core");
 
 // src/ui/background-task-view-model.ts
@@ -802,7 +647,11 @@ function toBackgroundTaskViewModel(state, partialText) {
     lastActivityAt: state.lastActivityAt,
     timeoutReason: state.timeoutReason,
     exitCode: state.result?.exitCode,
-    signalCode: state.result?.signalCode
+    signalCode: state.result?.signalCode,
+    worktreePath: state.worktreePath,
+    branchName: state.branchName,
+    worktreeStatus: state.worktreeStatus,
+    worktreeNextAction: state.worktreeNextAction
   };
 }
 function getBackgroundTaskStatusLabel(state) {
@@ -967,6 +816,14 @@ var TuiStateManager = class {
     this.history = updated.length > MAX_RENDERED_MESSAGES ? updated.slice(-MAX_RENDERED_MESSAGES) : updated;
     this.notify();
   }
+  clearHistory() {
+    this.history = [];
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  }
   /** Update pending prompt state */
   setPendingPrompt(prompt) {
     this.pendingPrompt = prompt;
@@ -1034,128 +891,33 @@ var import_react = require("react");
 var import_node_crypto = require("crypto");
 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) {
-    return {
-      message: "Provider setup requested. Select a provider to continue.",
-      success: true,
-      data: { providerSetup: {} }
-    };
-  }
-  if ((0, import_agent_core.findProviderDefinition)(providerDefinitions, type) === void 0) {
-    return {
-      message: `Usage: provider add <type>. Supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`,
-      success: false
-    };
-  }
-  return {
-    message: `Provider setup requested: ${type}`,
-    success: true,
-    data: { providerSetup: { type } }
-  };
+// src/plugins/plugin-command-source-loader.ts
+var import_node_os = require("os");
+var import_node_path4 = require("path");
+var import_agent_sdk4 = require("@robota-sdk/agent-sdk");
+var PLUGIN_SOURCE_NAME = "plugin";
+function getHomeDir() {
+  return process.env.HOME ?? (0, import_node_os.homedir)();
 }
-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 };
-  }
+function reloadPluginCommandSource(registry) {
+  const pluginsDir = (0, import_node_path4.join)(getHomeDir(), ".robota", "plugins");
+  const loader = new import_agent_sdk4.BundlePluginLoader(pluginsDir);
   try {
-    validateProviderProfile(profileName, profile, {
-      providerDefinitions: deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS
-    });
-  } catch (error) {
-    return { message: error instanceof Error ? error.message : String(error), success: false };
+    const plugins = loader.loadPluginsSync();
+    if (plugins.length === 0) {
+      registry.replaceSource(PLUGIN_SOURCE_NAME);
+      return 0;
+    }
+    registry.replaceSource(PLUGIN_SOURCE_NAME, new import_agent_sdk4.PluginCommandSource(plugins));
+    return plugins.length;
+  } catch {
+    registry.replaceSource(PLUGIN_SOURCE_NAME);
+    return 0;
   }
-  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) {
+function useSlashRouting(interactiveSession, registry, manager) {
   return (0, import_react.useCallback)(
     async (input) => {
       manager.onUserTurnAccepted();
@@ -1167,70 +929,32 @@ function useSlashRouting(cwd, interactiveSession, registry, manager, providerDef
       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) {
-        applySystemCommandResult(result, interactiveSession, manager);
+        applySystemCommandResult(result, interactiveSession, registry, manager);
         return;
       }
       if (await routeSkillCommand(input, cmd, registry, interactiveSession, manager)) {
         return;
       }
-      if (routeTuiCommand(cmd, interactiveSession)) {
-        return;
-      }
       manager.addEntry(
         (0, import_agent_core2.messageToHistoryEntry)(
           (0, import_agent_core2.createSystemMessage)(`Unknown command "/${cmd}". Type /help for help.`)
         )
       );
     },
-    [cwd, interactiveSession, registry, manager, providerDefinitions]
+    [interactiveSession, registry, manager]
   );
 }
-async function routeProviderCommand(cwd, args, interactiveSession, manager, providerDefinitions) {
-  const result = await handleProviderCommand(cwd, args, { providerDefinitions });
+function applySystemCommandResult(result, interactiveSession, registry, manager) {
+  const pendingEffects = applyImmediateCommandEffects(result.effects, registry, manager);
   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 !== void 0) {
-    getEffects(interactiveSession)._pendingProviderSetup = providerSetup;
-  }
-}
-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 (result.interaction !== void 0) {
+    effects._pendingCommandInteraction = result.interaction;
   }
-  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 statusLinePatch = data?.statuslinePatch;
-  if (isStatusLineSettingsPatch(statusLinePatch)) {
-    effects._statusLinePatch = statusLinePatch;
-    return;
+  if (pendingEffects.length > 0) {
+    effects._pendingCommandEffects = pendingEffects;
   }
   const ctx = interactiveSession.getContextState();
   manager.setContextState({
@@ -1239,6 +963,22 @@ function applySystemCommandResult(result, interactiveSession, manager) {
     maxTokens: ctx.maxTokens
   });
 }
+function applyImmediateCommandEffects(effects, registry, manager) {
+  if (effects === void 0 || effects.length === 0) return [];
+  const pendingEffects = [];
+  for (const effect of effects) {
+    if (effect.type === "conversation-history-cleared") {
+      manager.clearHistory();
+      continue;
+    }
+    if (effect.type === "plugin-registry-reload-requested") {
+      reloadPluginCommandSource(registry);
+      continue;
+    }
+    pendingEffects.push(effect);
+  }
+  return pendingEffects;
+}
 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) {
@@ -1262,31 +1002,16 @@ async function routeSkillCommand(input, cmd, registry, interactiveSession, manag
   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;
 }
-function isStatusLineSettingsPatch(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Date) {
-    return false;
-  }
-  const candidate = value;
-  return (candidate.enabled === void 0 || typeof candidate.enabled === "boolean") && (candidate.gitBranch === void 0 || typeof candidate.gitBranch === "boolean");
-}
 
 // src/ui/hooks/useInteractiveSession.ts
+function applyCompactEventToManager(interactiveSession, manager) {
+  manager.syncHistory(interactiveSession.getFullHistory());
+}
 function initializeSession(props, permissionHandler) {
-  const interactiveSession = new import_agent_sdk.InteractiveSession({
+  const interactiveSession = new import_agent_sdk5.InteractiveSession({
     cwd: props.cwd,
     provider: props.provider,
     permissionMode: props.permissionMode,
@@ -1298,23 +1023,16 @@ function initializeSession(props, permissionHandler) {
     sessionName: props.sessionName,
     backgroundTaskRunners: props.backgroundTaskRunners,
     subagentRunnerFactory: props.subagentRunnerFactory,
-    commandModules: props.commandModules
+    commandModules: props.commandModules,
+    commandHostAdapters: props.commandHostAdapters
   });
-  const registry = new import_agent_sdk.CommandRegistry();
-  registry.addSource(new import_agent_sdk.BuiltinCommandSource());
+  const registry = new import_agent_sdk5.CommandRegistry();
+  registry.addModule((0, import_agent_sdk5.createBuiltinCommandModule)());
   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_sdk.PluginCommandSource(plugins));
-    }
-  } catch {
-  }
+  registry.addSource(new import_agent_sdk5.SkillCommandSource(props.cwd));
+  reloadPluginCommandSource(registry);
   const manager = new TuiStateManager();
   return { interactiveSession, registry, manager };
 }
@@ -1364,6 +1082,7 @@ function useInteractiveSession(props) {
     }
   }
   (0, import_react2.useEffect)(() => {
+    const onCompact = () => applyCompactEventToManager(interactiveSession, manager);
     interactiveSession.on("text_delta", manager.onTextDelta);
     interactiveSession.on("tool_start", manager.onToolStart);
     interactiveSession.on("tool_end", manager.onToolEnd);
@@ -1372,6 +1091,7 @@ function useInteractiveSession(props) {
     interactiveSession.on("interrupted", manager.onInterrupted);
     interactiveSession.on("error", manager.onError);
     interactiveSession.on("context_update", manager.onContextUpdate);
+    interactiveSession.on("compact", onCompact);
     interactiveSession.on("background_task_event", manager.onBackgroundTaskEvent);
     const initCheck = setInterval(() => {
       try {
@@ -1399,6 +1119,7 @@ function useInteractiveSession(props) {
       interactiveSession.off("interrupted", manager.onInterrupted);
       interactiveSession.off("error", manager.onError);
       interactiveSession.off("context_update", manager.onContextUpdate);
+      interactiveSession.off("compact", onCompact);
       interactiveSession.off("background_task_event", manager.onBackgroundTaskEvent);
     };
   }, [interactiveSession, manager]);
@@ -1408,13 +1129,7 @@ function useInteractiveSession(props) {
       manager.setPendingPrompt(interactiveSession.getPendingPrompt());
     }
   }, [manager.isThinking, interactiveSession, manager]);
-  const handleSubmit = useSlashRouting(
-    props.cwd,
-    interactiveSession,
-    registry,
-    manager,
-    props.providerDefinitions ?? []
-  );
+  const handleSubmit = useSlashRouting(interactiveSession, registry, manager);
   const handleAbort = (0, import_react2.useCallback)(() => {
     manager.setAborting(true);
     interactiveSession.abort();
@@ -1442,192 +1157,142 @@ function useInteractiveSession(props) {
     isThinking: manager.isThinking,
     isAborting: manager.isAborting,
     isShuttingDown,
-    pendingPrompt: manager.pendingPrompt,
-    backgroundTasks: manager.backgroundTasks,
-    permissionRequest,
-    contextState: manager.contextState,
-    handleSubmit,
-    handleAbort,
-    handleCancelQueue,
-    handleShutdown
-  };
-}
-
-// src/ui/hooks/usePluginCallbacks.ts
-var import_react3 = require("react");
-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_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_sdk2.BundlePluginLoader(pluginsDir);
-    return {
-      listInstalled: async () => {
-        const plugins = await loader.loadAll();
-        const enabledMap = settingsStore.getEnabledPlugins();
-        return plugins.map((p) => {
-          const parts = p.pluginDir.split("/");
-          const cacheIdx = parts.indexOf("cache");
-          const marketplaceName = cacheIdx >= 0 ? parts[cacheIdx + 1] : "";
-          const fullId = marketplaceName ? `${p.manifest.name}@${marketplaceName}` : p.manifest.name;
-          return {
-            name: fullId,
-            description: p.manifest.description,
-            enabled: enabledMap[fullId] !== false && enabledMap[p.manifest.name] !== false
-          };
-        });
-      },
-      listAvailablePlugins: async (marketplaceName) => {
-        let manifest;
-        try {
-          manifest = marketplace.fetchManifest(marketplaceName);
-        } catch {
-          return [];
-        }
-        const installed = installer.getInstalledPlugins();
-        const installedNames = new Set(Object.values(installed).map((r) => r.pluginName));
-        return manifest.plugins.map((p) => ({
-          name: p.name,
-          description: p.description,
-          installed: installedNames.has(p.name)
-        }));
-      },
-      install: async (pluginId, scope) => {
-        const [name, marketplaceName] = pluginId.split("@");
-        if (!name || !marketplaceName) {
-          throw new Error("Plugin ID must be in format: name@marketplace");
-        }
-        if (scope === "project") {
-          const projectPluginsDir = (0, import_node_path5.join)(cwd, ".robota", "plugins");
-          const projectInstaller = new import_agent_sdk2.BundlePluginInstaller({
-            pluginsDir: projectPluginsDir,
-            settingsStore,
-            marketplaceClient: marketplace
-          });
-          await projectInstaller.install(name, marketplaceName);
-        } else {
-          await installer.install(name, marketplaceName);
-        }
-      },
-      uninstall: async (pluginId) => {
-        await installer.uninstall(pluginId);
-      },
-      enable: async (pluginId) => {
-        await installer.enable(pluginId);
-      },
-      disable: async (pluginId) => {
-        await installer.disable(pluginId);
-      },
-      marketplaceAdd: async (source) => {
-        if (source.includes("/") && !source.includes(":")) {
-          return marketplace.addMarketplace({ type: "github", repo: source });
-        } else {
-          return marketplace.addMarketplace({ type: "git", url: source });
-        }
-      },
-      marketplaceRemove: async (name) => {
-        const installedFromMarketplace = installer.getPluginsByMarketplace(name);
-        for (const record of installedFromMarketplace) {
-          await installer.uninstall(`${record.pluginName}@${record.marketplace}`);
-        }
-        marketplace.removeMarketplace(name);
-      },
-      marketplaceUpdate: async (name) => {
-        marketplace.updateMarketplace(name);
-      },
-      marketplaceList: async () => {
-        return marketplace.listMarketplaces().map((m) => ({
-          name: m.name,
-          type: m.source.type
-        }));
-      },
-      reloadPlugins: async () => {
-      }
-    };
-  }, [cwd]);
+    pendingPrompt: manager.pendingPrompt,
+    backgroundTasks: manager.backgroundTasks,
+    permissionRequest,
+    contextState: manager.contextState,
+    handleSubmit,
+    handleAbort,
+    handleCancelQueue,
+    handleShutdown
+  };
 }
 
-// src/ui/hooks/useSideEffects.ts
-var import_react4 = require("react");
-var import_ink = require("ink");
-var import_agent_core4 = require("@robota-sdk/agent-core");
+// src/ui/hooks/usePluginCallbacks.ts
+var import_react3 = require("react");
 
-// src/utils/provider-setup-interaction.ts
-function startProviderSetupInteraction(providerDefinitions, type) {
-  if (type === void 0) {
-    const state2 = {
-      mode: "select-provider",
-      providerDefinitions
-    };
-    return { status: "prompt", state: state2, prompt: toProviderSelectionPrompt(providerDefinitions) };
-  }
-  const state = {
-    mode: "setup-fields",
-    providerDefinitions,
-    flow: createProviderSetupFlow(type, providerDefinitions)
+// src/plugins/plugin-command-adapter.ts
+var import_node_os2 = require("os");
+var import_node_path5 = require("path");
+var import_agent_sdk6 = require("@robota-sdk/agent-sdk");
+function createCliPluginServices(cwd) {
+  const home = (0, import_node_os2.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_sdk6.PluginSettingsStore(userSettingsPath);
+  const marketplace = new import_agent_sdk6.MarketplaceClient({ pluginsDir });
+  const installer = new import_agent_sdk6.BundlePluginInstaller({
+    pluginsDir,
+    settingsStore,
+    marketplaceClient: marketplace
+  });
+  const loader = new import_agent_sdk6.BundlePluginLoader(pluginsDir);
+  return {
+    cwd,
+    marketplace,
+    installer,
+    loader,
+    settingsStore
   };
-  return { status: "prompt", state, prompt: toProviderSetupStepPrompt(state.flow) };
-}
-function submitProviderSetupInteractionValue(state, value) {
-  if (state.mode === "select-provider") {
-    const nextState2 = {
-      mode: "setup-fields",
-      providerDefinitions: state.providerDefinitions,
-      flow: createProviderSetupFlow(value, state.providerDefinitions)
-    };
+}
+async function listInstalledPlugins(services) {
+  const plugins = await services.loader.loadAll();
+  const enabledMap = services.settingsStore.getEnabledPlugins();
+  return plugins.map((plugin) => {
+    const parts = plugin.pluginDir.split("/");
+    const cacheIdx = parts.indexOf("cache");
+    const marketplaceName = cacheIdx >= 0 ? parts[cacheIdx + 1] ?? "" : "";
+    const fullId = marketplaceName ? `${plugin.manifest.name}@${marketplaceName}` : plugin.manifest.name;
     return {
-      status: "prompt",
-      state: nextState2,
-      prompt: toProviderSetupStepPrompt(nextState2.flow)
+      name: fullId,
+      description: plugin.manifest.description,
+      enabled: enabledMap[fullId] !== false && enabledMap[plugin.manifest.name] !== false
     };
+  });
+}
+async function listAvailablePlugins(services, marketplaceName) {
+  let manifest;
+  try {
+    manifest = services.marketplace.fetchManifest(marketplaceName);
+  } catch {
+    return [];
+  }
+  const installed = services.installer.getInstalledPlugins();
+  const installedNames = new Set(Object.values(installed).map((record) => record.pluginName));
+  return manifest.plugins.map((plugin) => ({
+    name: plugin.name,
+    description: plugin.description,
+    installed: installedNames.has(plugin.name)
+  }));
+}
+async function installPlugin(services, pluginId, scope) {
+  const [name, marketplaceName] = pluginId.split("@");
+  if (!name || !marketplaceName) {
+    throw new Error("Plugin ID must be in format: name@marketplace");
+  }
+  if (scope === "project") {
+    const projectPluginsDir = (0, import_node_path5.join)(services.cwd, ".robota", "plugins");
+    const projectInstaller = new import_agent_sdk6.BundlePluginInstaller({
+      pluginsDir: projectPluginsDir,
+      settingsStore: services.settingsStore,
+      marketplaceClient: services.marketplace
+    });
+    await projectInstaller.install(name, marketplaceName);
+    return;
   }
-  const result = submitProviderSetupValue(state.flow, value);
-  if (result.status === "complete") {
-    return { status: "complete", input: result.input };
+  await services.installer.install(name, marketplaceName);
+}
+async function removeMarketplace(services, name) {
+  const installedFromMarketplace = services.installer.getPluginsByMarketplace(name);
+  for (const record of installedFromMarketplace) {
+    await services.installer.uninstall(`${record.pluginName}@${record.marketplace}`);
   }
-  const nextState = {
-    ...state,
-    flow: result.state
-  };
-  return { status: "prompt", state: nextState, prompt: toProviderSetupStepPrompt(result.state) };
+  services.marketplace.removeMarketplace(name);
 }
-function toProviderSelectionPrompt(providerDefinitions) {
-  return {
-    kind: "choice",
-    title: "Select provider",
-    options: providerDefinitions.map((definition) => ({
-      value: definition.type,
-      label: formatProviderSetupChoiceLabel(definition)
-    })),
-    maxVisible: 6
-  };
+function listMarketplaces(services) {
+  return services.marketplace.listMarketplaces().map((marketplaceEntry) => ({
+    name: marketplaceEntry.name,
+    type: marketplaceEntry.source.type
+  }));
 }
-function toProviderSetupStepPrompt(flow) {
-  const step = getProviderSetupStep(flow);
+function createCliPluginCommandAdapter(cwd) {
+  const services = createCliPluginServices(cwd);
   return {
-    kind: "text",
-    title: step.title,
-    ...step.defaultValue !== void 0 ? { placeholder: step.defaultValue } : {},
-    ...step.defaultValue !== void 0 ? { allowEmpty: true } : {},
-    ...step.masked !== void 0 ? { masked: step.masked } : {},
-    validate: (value) => validateProviderSetupValue(step, value)
+    listInstalled: () => listInstalledPlugins(services),
+    listAvailablePlugins: (marketplaceName) => listAvailablePlugins(services, marketplaceName),
+    install: (pluginId, scope) => installPlugin(services, pluginId, scope),
+    uninstall: async (pluginId) => services.installer.uninstall(pluginId),
+    enable: async (pluginId) => services.installer.enable(pluginId),
+    disable: async (pluginId) => services.installer.disable(pluginId),
+    marketplaceAdd: async (source) => {
+      if (source.includes("/") && !source.includes(":")) {
+        return services.marketplace.addMarketplace({ type: "github", repo: source });
+      }
+      return services.marketplace.addMarketplace({ type: "git", url: source });
+    },
+    marketplaceRemove: (name) => removeMarketplace(services, name),
+    marketplaceUpdate: async (name) => services.marketplace.updateMarketplace(name),
+    marketplaceList: async () => listMarketplaces(services),
+    reloadPlugins: async () => ({
+      loadedPluginCount: (await services.loader.loadAll()).length
+    })
   };
 }
 
+// src/ui/hooks/usePluginCallbacks.ts
+function usePluginCallbacks(cwd) {
+  return (0, import_react3.useMemo)(() => createCliPluginCommandAdapter(cwd), [cwd]);
+}
+
+// src/ui/hooks/useSideEffects.ts
+var import_react4 = require("react");
+var import_ink = require("ink");
+var import_agent_core6 = require("@robota-sdk/agent-core");
+
 // src/utils/statusline-settings.ts
+var import_agent_sdk7 = require("@robota-sdk/agent-sdk");
 var DEFAULT_STATUS_LINE_SETTINGS = {
-  enabled: true,
-  gitBranch: true
+  ...import_agent_sdk7.DEFAULT_STATUS_LINE_COMMAND_SETTINGS
 };
 function readStatusLineSettings(settings) {
   const raw = settings.statusline;
@@ -1662,39 +1327,192 @@ function applyPendingStatusLinePatch(sideEffects, setStatusLineSettings) {
   return true;
 }
 
+// src/ui/hooks/command-effect-handler.ts
+var import_agent_sdk8 = require("@robota-sdk/agent-sdk");
+var import_agent_core4 = require("@robota-sdk/agent-core");
+function applyCommandEffects(effects, sideEffects, deps) {
+  for (const effect of effects) {
+    if (effect.type === "model-change-requested") {
+      deps.requestModelChange(effect.modelId);
+      return true;
+    }
+    if (effect.type === "language-change-requested") {
+      applyLanguageEffect(effect.language, deps);
+      return true;
+    }
+    if (effect.type === "settings-reset-requested") {
+      applySettingsResetEffect(deps);
+      return true;
+    }
+    if (effect.type === "session-exit-requested") {
+      deps.requestShutdown(
+        effect.reason ?? "prompt_input_exit",
+        effect.message ?? "User requested exit"
+      );
+      return true;
+    }
+    if (effect.type === "session-restart-requested") {
+      deps.requestShutdown(effect.reason, effect.message);
+      return true;
+    }
+    if (effect.type === "plugin-tui-requested") {
+      deps.openPluginTUI();
+      return true;
+    }
+    if (effect.type === "session-picker-requested") {
+      deps.openSessionPicker();
+      return true;
+    }
+    if (effect.type === "session-renamed") {
+      deps.renameSession(effect.name);
+      return true;
+    }
+    if (effect.type === "statusline-settings-patch") {
+      if ((0, import_agent_sdk8.isStatusLineCommandSettingsPatch)(effect.patch)) {
+        sideEffects._statusLinePatch = effect.patch;
+        if (deps.applyStatusLinePatch(effect.patch)) return true;
+      }
+    }
+  }
+  return false;
+}
+function applyLanguageEffect(language, deps) {
+  const settingsPath = getUserSettingsPath();
+  const settings = readSettings(settingsPath);
+  settings.language = language;
+  writeSettings(settingsPath, settings);
+  deps.addEntry(
+    (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Language set to "${language}". Restarting...`))
+  );
+  deps.requestShutdown("other", "Language change restart");
+}
+function applySettingsResetEffect(deps) {
+  const settingsPath = getUserSettingsPath();
+  if (deleteSettings(settingsPath)) {
+    deps.addEntry(
+      (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`))
+    );
+  } else {
+    deps.addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("No user settings found.")));
+  }
+  deps.requestShutdown("other", "Reset settings restart");
+}
+
+// src/ui/hooks/model-change-side-effect.ts
+var import_agent_core5 = require("@robota-sdk/agent-core");
+function formatModelChangeConfirmationMessage(modelId) {
+  return `Change model to ${(0, import_agent_core5.getModelName)(modelId)}? This will exit the current session so the next session uses it.`;
+}
+function formatModelChangeExitMessage(modelId) {
+  return `Model changed to ${(0, import_agent_core5.getModelName)(modelId)}. Exiting so the next session uses it.`;
+}
+function applyConfirmedModelChange(deps) {
+  const applyModelChange = deps.applyModelChange ?? applyActiveModelChange;
+  const options = deps.providerOverride !== void 0 ? { providerOverride: deps.providerOverride } : void 0;
+  try {
+    applyModelChange(deps.cwd, deps.modelId, options);
+    deps.addEntry(
+      (0, import_agent_core5.messageToHistoryEntry)((0, import_agent_core5.createSystemMessage)(formatModelChangeExitMessage(deps.modelId)))
+    );
+    deps.requestShutdown("other", "Model change applied");
+  } catch (error) {
+    deps.addEntry(
+      (0, import_agent_core5.messageToHistoryEntry)(
+        (0, import_agent_core5.createSystemMessage)(`Failed: ${error instanceof Error ? error.message : String(error)}`)
+      )
+    );
+  }
+}
+function addModelChangeCancelledMessage(addEntry) {
+  addEntry((0, import_agent_core5.messageToHistoryEntry)((0, import_agent_core5.createSystemMessage)("Model change cancelled.")));
+}
+
 // src/ui/hooks/useSideEffects.ts
 var EXIT_DELAY_MS = 500;
 function useSideEffects({
   cwd,
+  providerOverride,
   interactiveSession,
   addEntry,
   baseHandleSubmit,
   setSessionName,
-  setStatusLineSettings,
-  providerDefinitions
+  setStatusLineSettings
 }) {
   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 [pendingInteractionPrompt, setPendingInteractionPrompt] = (0, import_react4.useState)(null);
-  const providerSetupInteractionRef = (0, import_react4.useRef)(null);
+  const commandInteractionRef = (0, import_react4.useRef)(null);
   const [showPluginTUI, setShowPluginTUI] = (0, import_react4.useState)(false);
   const [showSessionPicker, setShowSessionPicker] = (0, import_react4.useState)(false);
   const requestShutdown = (0, import_react4.useCallback)(
     (reason, message) => {
-      addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Shutting down...")));
+      addEntry((0, import_agent_core6.messageToHistoryEntry)((0, import_agent_core6.createSystemMessage)("Shutting down...")));
       setTimeout(() => {
         void interactiveSession.shutdown({ reason, message }).finally(() => exit());
       }, EXIT_DELAY_MS);
     },
     [interactiveSession, addEntry, exit]
   );
+  const applyEffects = (0, import_react4.useCallback)(
+    (effects, sideEffects) => applyCommandEffects(effects, sideEffects, {
+      addEntry,
+      requestShutdown,
+      requestModelChange: (modelId) => {
+        pendingModelChangeRef.current = modelId;
+        setPendingModelId(modelId);
+      },
+      openPluginTUI: () => setShowPluginTUI(true),
+      openSessionPicker: () => setShowSessionPicker(true),
+      renameSession: (name) => {
+        interactiveSession.setName(name);
+        setSessionName(name);
+      },
+      applyStatusLinePatch: () => applyPendingStatusLinePatch(sideEffects, setStatusLineSettings)
+    }),
+    [addEntry, interactiveSession, requestShutdown, setSessionName, setStatusLineSettings]
+  );
+  const applyCommandResult = (0, import_react4.useCallback)(
+    (result) => {
+      if (result.message.length > 0) {
+        addEntry((0, import_agent_core6.messageToHistoryEntry)((0, import_agent_core6.createSystemMessage)(result.message)));
+      }
+      if (result.interaction !== void 0) {
+        commandInteractionRef.current = result.interaction;
+        setPendingInteractionPrompt(result.interaction.prompt);
+        return;
+      }
+      commandInteractionRef.current = null;
+      setPendingInteractionPrompt(null);
+      if (result.effects !== void 0 && result.effects.length > 0) {
+        applyEffects(result.effects, interactiveSession);
+      }
+    },
+    [addEntry, applyEffects, interactiveSession]
+  );
+  const applyQueuedCommandState = (0, import_react4.useCallback)(
+    (sideEffects) => {
+      if (sideEffects._pendingCommandInteraction !== void 0) {
+        const interaction = sideEffects._pendingCommandInteraction;
+        delete sideEffects._pendingCommandInteraction;
+        commandInteractionRef.current = interaction;
+        setPendingInteractionPrompt(interaction.prompt);
+        return true;
+      }
+      if (sideEffects._pendingCommandEffects !== void 0) {
+        const effects = sideEffects._pendingCommandEffects;
+        delete sideEffects._pendingCommandEffects;
+        return applyEffects(effects, sideEffects);
+      }
+      return false;
+    },
+    [applyEffects]
+  );
   const handleSubmit = (0, import_react4.useCallback)(
     async (input) => {
       await baseHandleSubmit(input);
       const sideEffects = interactiveSession;
+      if (applyQueuedCommandState(sideEffects)) return;
       if (sideEffects._pendingModelId) {
         const modelId = sideEffects._pendingModelId;
         delete sideEffects._pendingModelId;
@@ -1702,69 +1520,25 @@ function useSideEffects({
         setPendingModelId(modelId);
         return;
       }
-      if (sideEffects._pendingLanguage) {
-        const lang = sideEffects._pendingLanguage;
-        delete sideEffects._pendingLanguage;
-        const settingsPath = getUserSettingsPath();
-        const settings = readSettings(settingsPath);
-        settings.language = lang;
-        writeSettings(settingsPath, settings);
-        addEntry(
-          (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Language set to "${lang}". Restarting...`))
-        );
-        requestShutdown("other", "Language change restart");
-        return;
-      }
-      if (sideEffects._pendingProviderProfile) {
-        const profile = sideEffects._pendingProviderProfile;
-        delete sideEffects._pendingProviderProfile;
-        pendingProviderProfileRef.current = profile;
-        setPendingProviderProfile(profile);
-        return;
-      }
-      if (sideEffects._pendingProviderSetup !== void 0) {
-        const setup = sideEffects._pendingProviderSetup;
-        delete sideEffects._pendingProviderSetup;
-        const result = startProviderSetupInteraction(providerDefinitions, setup.type);
-        if (result.status === "prompt") {
-          providerSetupInteractionRef.current = result.state;
-          setPendingInteractionPrompt(result.prompt);
-        }
-        return;
-      }
       if (sideEffects._resetRequested) {
         delete sideEffects._resetRequested;
-        const settingsPath = getUserSettingsPath();
-        if (deleteSettings(settingsPath)) {
-          addEntry(
-            (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`))
-          );
-        } else {
-          addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("No user settings found.")));
-        }
-        requestShutdown("other", "Reset settings restart");
+        applyEffects([{ type: "settings-reset-requested" }], sideEffects);
         return;
       }
       if (sideEffects._exitRequested) {
         delete sideEffects._exitRequested;
-        requestShutdown("prompt_input_exit", "User requested exit");
-        return;
-      }
-      if (sideEffects._triggerPluginTUI) {
-        delete sideEffects._triggerPluginTUI;
-        setShowPluginTUI(true);
+        applyEffects([{ type: "session-exit-requested" }], sideEffects);
         return;
       }
       if (sideEffects._triggerResumePicker) {
         delete sideEffects._triggerResumePicker;
-        setShowSessionPicker(true);
+        applyEffects([{ type: "session-picker-requested" }], sideEffects);
         return;
       }
       if (sideEffects._sessionName) {
         const name = sideEffects._sessionName;
         delete sideEffects._sessionName;
-        interactiveSession.setName(name);
-        setSessionName(name);
+        applyEffects([{ type: "session-renamed", name }], sideEffects);
         return;
       }
       if (applyPendingStatusLinePatch(sideEffects, setStatusLineSettings)) return;
@@ -1772,11 +1546,9 @@ function useSideEffects({
     [
       interactiveSession,
       baseHandleSubmit,
-      addEntry,
-      requestShutdown,
-      setSessionName,
-      setStatusLineSettings,
-      providerDefinitions
+      applyQueuedCommandState,
+      applyEffects,
+      setStatusLineSettings
     ]
   );
   const handleModelConfirm = (0, import_react4.useCallback)(
@@ -1785,117 +1557,60 @@ function useSideEffects({
       setPendingModelId(null);
       pendingModelChangeRef.current = null;
       if (index === 0 && modelId) {
-        try {
-          const settingsPath = getUserSettingsPath();
-          updateModelInSettings(settingsPath, modelId);
-          addEntry(
-            (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...`)
-            )
-          );
-          requestShutdown("other", "Provider change restart");
-        } catch (err) {
-          addEntry(
-            (0, import_agent_core4.messageToHistoryEntry)(
-              (0, import_agent_core4.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
-            )
-          );
-        }
+        applyConfirmedModelChange({
+          cwd,
+          modelId,
+          providerOverride,
+          addEntry,
+          requestShutdown
+        });
       } else {
-        addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Provider change cancelled.")));
-      }
-    },
-    [cwd, addEntry, requestShutdown]
-  );
-  const completeProviderSetup = (0, import_react4.useCallback)(
-    (input) => {
-      providerSetupInteractionRef.current = null;
-      setPendingInteractionPrompt(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)}`)
-          )
-        );
+        addModelChangeCancelledMessage(addEntry);
       }
     },
-    [addEntry, requestShutdown, providerDefinitions]
+    [cwd, providerOverride, addEntry, requestShutdown]
   );
   const handleInteractionSubmit = (0, import_react4.useCallback)(
-    (value) => {
-      const state = providerSetupInteractionRef.current;
-      if (state === null) {
+    async (value) => {
+      const interaction = commandInteractionRef.current;
+      if (interaction === null) {
         setPendingInteractionPrompt(null);
         return;
       }
       try {
-        const result = submitProviderSetupInteractionValue(state, value);
-        if (result.status === "complete") {
-          completeProviderSetup(result.input);
-          return;
-        }
-        providerSetupInteractionRef.current = result.state;
-        setPendingInteractionPrompt(result.prompt);
+        const result = await interaction.submit(value);
+        applyCommandResult(result);
       } catch (err) {
-        providerSetupInteractionRef.current = null;
+        commandInteractionRef.current = null;
         setPendingInteractionPrompt(null);
         addEntry(
-          (0, import_agent_core4.messageToHistoryEntry)(
-            (0, import_agent_core4.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+          (0, import_agent_core6.messageToHistoryEntry)(
+            (0, import_agent_core6.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
           )
         );
       }
     },
-    [addEntry, completeProviderSetup]
+    [addEntry, applyCommandResult]
   );
   const handleInteractionCancel = (0, import_react4.useCallback)(() => {
-    providerSetupInteractionRef.current = null;
+    const interaction = commandInteractionRef.current;
+    commandInteractionRef.current = null;
     setPendingInteractionPrompt(null);
-    addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Provider setup cancelled.")));
-  }, [addEntry]);
+    if (interaction?.cancel === void 0) {
+      addEntry((0, import_agent_core6.messageToHistoryEntry)((0, import_agent_core6.createSystemMessage)("Command interaction cancelled.")));
+      return;
+    }
+    Promise.resolve(interaction.cancel()).then((result) => applyCommandResult(result)).catch((err) => {
+      addEntry(
+        (0, import_agent_core6.messageToHistoryEntry)(
+          (0, import_agent_core6.createSystemMessage)(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+        )
+      );
+    });
+  }, [addEntry, applyCommandResult]);
   return {
     handleSubmit,
     pendingModelId,
-    pendingProviderProfile,
     pendingInteractionPrompt,
     showPluginTUI,
     showSessionPicker,
@@ -1903,7 +1618,6 @@ function useSideEffects({
     setShowPluginTUI,
     setShowSessionPicker,
     handleModelConfirm,
-    handleProviderConfirm,
     handleInteractionSubmit,
     handleInteractionCancel
   };
@@ -1920,7 +1634,7 @@ function useStatusLineSettings() {
 // src/ui/MessageList.tsx
 var import_react6 = __toESM(require("react"), 1);
 var import_ink5 = require("ink");
-var import_agent_core6 = require("@robota-sdk/agent-core");
+var import_agent_core8 = require("@robota-sdk/agent-core");
 
 // src/ui/render-markdown.ts
 var import_marked = require("marked");
@@ -2064,7 +1778,7 @@ function ToolDiffBlock({ file, lines }) {
 
 // src/ui/UsageSummaryEntry.tsx
 var import_ink3 = require("ink");
-var import_agent_core5 = require("@robota-sdk/agent-core");
+var import_agent_core7 = require("@robota-sdk/agent-core");
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var TOKEN_COMPACT_THRESHOLD = 1e3;
 function UsageSummaryEntry({ entry }) {
@@ -2073,9 +1787,9 @@ function UsageSummaryEntry({ entry }) {
   const prompt = usage.promptTokens !== void 0 ? formatUsageTokenCount(usage.promptTokens) : "?";
   const completion = usage.completionTokens !== void 0 ? formatUsageTokenCount(usage.completionTokens) : "?";
   const total = formatUsageTokenCount(usage.totalTokens);
-  const context = `${Math.round(usage.contextUsedPercentage)}% (${(0, import_agent_core5.formatTokenCount)(
+  const context = `${Math.round(usage.contextUsedPercentage)}% (${(0, import_agent_core7.formatTokenCount)(
     usage.contextUsedTokens
-  )}/${(0, import_agent_core5.formatTokenCount)(usage.contextMaxTokens)})`;
+  )}/${(0, import_agent_core7.formatTokenCount)(usage.contextMaxTokens)})`;
   const costLabel = usage.costStatus === "unknown" ? "cost unknown" : `cost ${usage.costStatus}`;
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { children: [
     /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { color: "white", bold: true, children: [
@@ -2099,7 +1813,7 @@ function UsageSummaryEntry({ entry }) {
   ] }) });
 }
 function formatUsageTokenCount(tokens) {
-  return tokens < TOKEN_COMPACT_THRESHOLD ? tokens.toLocaleString() : (0, import_agent_core5.formatTokenCount)(tokens);
+  return tokens < TOKEN_COMPACT_THRESHOLD ? tokens.toLocaleString() : (0, import_agent_core7.formatTokenCount)(tokens);
 }
 
 // src/ui/command-output-summary.ts
@@ -2240,7 +1954,7 @@ function RoleLabel({ role }) {
   }
 }
 function ToolMessage({ message }) {
-  if (!(0, import_agent_core6.isToolMessage)(message)) {
+  if (!(0, import_agent_core8.isToolMessage)(message)) {
     return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, {});
   }
   const toolName = message.name;
@@ -2303,7 +2017,7 @@ function ToolMessage({ message }) {
 var MessageItem = import_react6.default.memo(function MessageItem2({
   message
 }) {
-  if ((0, import_agent_core6.isToolMessage)(message)) {
+  if ((0, import_agent_core8.isToolMessage)(message)) {
     return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ToolMessage, { message });
   }
   const content = message.content ?? "";
@@ -2311,7 +2025,7 @@ var MessageItem = import_react6.default.memo(function MessageItem2({
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RoleLabel, { role: message.role }) }),
     /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: " " }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { wrap: "wrap", children: (0, import_agent_core6.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { wrap: "wrap", children: (0, import_agent_core8.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
   ] });
 });
 function ToolSummaryEntry({ entry }) {
@@ -2381,7 +2095,7 @@ function MessageList({ history }) {
 
 // src/ui/SessionStatusBar.tsx
 var import_react7 = require("react");
-var import_agent_core8 = require("@robota-sdk/agent-core");
+var import_agent_core10 = require("@robota-sdk/agent-core");
 
 // src/utils/git-branch.ts
 var import_node_fs4 = require("fs");
@@ -2430,7 +2144,7 @@ function resolveGitMetadata(candidate, repoDir) {
 
 // src/ui/StatusBar.tsx
 var import_ink6 = require("ink");
-var import_agent_core7 = require("@robota-sdk/agent-core");
+var import_agent_core9 = require("@robota-sdk/agent-core");
 
 // src/ui/status-activity.ts
 var NO_ACTIVE_ITEMS = 0;
@@ -2512,9 +2226,9 @@ function ContextText({
     "Context: ",
     Math.round(percentage),
     "% (",
-    (0, import_agent_core7.formatTokenCount)(usedTokens),
+    (0, import_agent_core9.formatTokenCount)(usedTokens),
     "/",
-    (0, import_agent_core7.formatTokenCount)(maxTokens),
+    (0, import_agent_core9.formatTokenCount)(maxTokens),
     ")"
   ] });
 }
@@ -2576,6 +2290,21 @@ function StatusLeft({
     )
   ] });
 }
+function StatusRight({
+  isThinking,
+  messageCount
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { children: [
+    isThinking && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: "yellow", children: "thinking..." }),
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { dimColor: true, children: [
+      "msgs: ",
+      messageCount
+    ] })
+  ] });
+}
 function StatusBar({
   permissionMode,
   modelName,
@@ -2618,10 +2347,7 @@ function StatusBar({
             showGitBranch
           }
         ),
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { dimColor: true, children: [
-          "msgs: ",
-          messageCount
-        ] }) })
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(StatusRight, { isThinking, messageCount })
       ]
     }
   );
@@ -2649,7 +2375,7 @@ function SessionStatusBar({
     StatusBar,
     {
       permissionMode,
-      modelName: modelId ? (0, import_agent_core8.getModelName)(modelId) : "",
+      modelName: modelId ? (0, import_agent_core10.getModelName)(modelId) : "",
       sessionId,
       messageCount,
       isThinking,
@@ -3880,32 +3606,43 @@ function getToolStyle(t) {
   if (t.result === "denied") return { color: "yellowBright", icon: "\u2298", strikethrough: true };
   return { color: "green", icon: "\u2713", strikethrough: false };
 }
-function StreamingIndicator({ text, activeTools }) {
+function renderThinkingFallback(isThinking) {
+  if (!isThinking) return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_jsx_runtime16.Fragment, {});
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { color: "yellow", children: "Thinking..." }) });
+}
+function renderTools(activeTools) {
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { color: "white", bold: true, children: "Tools:" }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { children: " " }),
+    activeTools.map((t, i) => {
+      const { color, icon, strikethrough } = getToolStyle(t);
+      return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Text, { color, strikethrough, children: [
+          "  ",
+          icon,
+          " ",
+          t.toolName,
+          "(",
+          t.firstArg,
+          ")"
+        ] }),
+        t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ToolDiffBlock, { file: t.diffFile, lines: t.diffLines })
+      ] }, `${t.toolName}-${i}`);
+    })
+  ] });
+}
+function StreamingIndicator({
+  text,
+  activeTools,
+  isThinking = false
+}) {
   const hasTools = activeTools.length > 0;
   const hasText = text.length > 0;
   if (!hasTools && !hasText) {
-    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_jsx_runtime16.Fragment, {});
+    return renderThinkingFallback(isThinking);
   }
   return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", children: [
-    hasTools && /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { color: "white", bold: true, children: "Tools:" }),
-      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { children: " " }),
-      activeTools.map((t, i) => {
-        const { color, icon, strikethrough } = getToolStyle(t);
-        return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", children: [
-          /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Text, { color, strikethrough, children: [
-            "  ",
-            icon,
-            " ",
-            t.toolName,
-            "(",
-            t.firstArg,
-            ")"
-          ] }),
-          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ToolDiffBlock, { file: t.diffFile, lines: t.diffLines })
-        ] }, `${t.toolName}-${i}`);
-      })
-    ] }),
+    hasTools && renderTools(activeTools),
     hasText && /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_ink16.Box, { flexDirection: "column", marginBottom: 1, children: [
       /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { color: "cyan", bold: true, children: "Robota:" }),
       /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink16.Text, { children: " " }),
@@ -4428,9 +4165,14 @@ function getTaskSegments(task, now) {
   if (task.signalCode) {
     segments.push(`signal ${task.signalCode}`);
   }
+  if (task.worktreePath || task.branchName) {
+    segments.push("worktree");
+  }
   return segments;
 }
 function getTaskPreview(task) {
+  if (task.worktreeNextAction) return task.worktreeNextAction;
+  if (task.worktreePath) return task.worktreePath;
   const preview = task.errorPreview ?? task.resultPreview ?? task.currentAction ?? task.preview;
   return preview || void 0;
 }
@@ -4758,7 +4500,6 @@ function App(props) {
 }
 function AppInner(props) {
   const cwd = props.cwd;
-  const providerDefinitions = props.providerDefinitions ?? [];
   const {
     interactiveSession,
     registry,
@@ -4789,9 +4530,10 @@ function AppInner(props) {
     backgroundTaskRunners: props.backgroundTaskRunners,
     subagentRunnerFactory: props.subagentRunnerFactory,
     commandModules: props.commandModules,
-    providerDefinitions
+    commandHostAdapters: props.commandHostAdapters
   });
-  const pluginCallbacks = usePluginCallbacks(cwd);
+  const fallbackPluginCallbacks = usePluginCallbacks(cwd);
+  const pluginCallbacks = props.commandHostAdapters?.plugin ?? fallbackPluginCallbacks;
   const { exit } = (0, import_ink21.useApp)();
   const [sessionName, setSessionName] = (0, import_react19.useState)(props.sessionName);
   const [updateNotice, setUpdateNotice] = (0, import_react19.useState)();
@@ -4802,24 +4544,22 @@ function AppInner(props) {
   const {
     handleSubmit,
     pendingModelId,
-    pendingProviderProfile,
     pendingInteractionPrompt,
     showPluginTUI,
     showSessionPicker,
     setShowPluginTUI,
     setShowSessionPicker,
     handleModelConfirm,
-    handleProviderConfirm,
     handleInteractionSubmit,
     handleInteractionCancel
   } = useSideEffects({
     cwd,
+    providerOverride: props.providerOverride,
     interactiveSession,
     addEntry,
     baseHandleSubmit,
     setSessionName,
-    setStatusLineSettings,
-    providerDefinitions
+    setStatusLineSettings
   });
   (0, import_react19.useEffect)(() => {
     const name = interactiveSession?.getName?.();
@@ -4888,24 +4628,24 @@ function AppInner(props) {
     /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
       /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(MessageList, { history }),
       isShuttingDown && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: "yellow", children: "Shutting down..." }) }),
-      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(StreamingIndicator, { text: streamingText, activeTools }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+        StreamingIndicator,
+        {
+          text: streamingText,
+          activeTools,
+          isThinking
+        }
+      ) }),
       /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(BackgroundTaskPanel, { tasks: backgroundTasks })
     ] }),
     permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(PermissionPrompt, { request: permissionRequest }),
     pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
       ConfirmPrompt,
       {
-        message: `Change model to ${(0, import_agent_core9.getModelName)(pendingModelId)}? This will restart the session.`,
+        message: formatModelChangeConfirmationMessage(pendingModelId),
         onSelect: handleModelConfirm
       }
     ),
-    pendingProviderProfile && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
-      ConfirmPrompt,
-      {
-        message: `Change provider to ${pendingProviderProfile}? This will restart the session.`,
-        onSelect: handleProviderConfirm
-      }
-    ),
     pendingInteractionPrompt && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
       InteractivePrompt,
       {
@@ -4919,7 +4659,7 @@ function AppInner(props) {
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addEntry((0, import_agent_core9.messageToHistoryEntry)((0, import_agent_core9.createSystemMessage)(msg.content)))
+        addMessage: (msg) => addEntry((0, import_agent_core11.messageToHistoryEntry)((0, import_agent_core11.createSystemMessage)(msg.content)))
       }
     ),
     showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
@@ -4933,7 +4673,7 @@ function AppInner(props) {
         },
         onCancel: () => {
           setShowSessionPicker(false);
-          addEntry((0, import_agent_core9.messageToHistoryEntry)((0, import_agent_core9.createSystemMessage)("Session resume cancelled.")));
+          addEntry((0, import_agent_core11.messageToHistoryEntry)((0, import_agent_core11.createSystemMessage)("Session resume cancelled.")));
         }
       }
     ),
@@ -5000,7 +4740,7 @@ function renderApp(options) {
 
 // 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 import_agent_sdk9 = require("@robota-sdk/agent-sdk");
 var DEFAULT_OUTPUT_LIMIT_BYTES = 3e4;
 var DEFAULT_KILL_GRACE_MS = 2e3;
 var LOG_PAGE_SIZE = 200;
@@ -5054,7 +4794,7 @@ function createManagedShellProcessRunner(options = {}) {
     kind: "process",
     start(task) {
       if (task.request.kind !== "process") {
-        throw new import_agent_sdk3.BackgroundTaskError("runner", `Invalid process task kind: ${task.request.kind}`);
+        throw new import_agent_sdk9.BackgroundTaskError("runner", `Invalid process task kind: ${task.request.kind}`);
       }
       return startProcessTask(task.taskId, task.request, killGraceMs);
     }
@@ -5083,7 +4823,7 @@ function createProcessResult(runtime) {
     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"));
+      rejectOnceLocal(new import_agent_sdk9.BackgroundTaskError("timeout", "Background process timed out"));
     }, runtime.request.timeoutMs) : void 0;
     function clearTimers() {
       if (timeoutTimer) clearTimeout(timeoutTimer);
@@ -5110,7 +4850,7 @@ function createProcessResult(runtime) {
     attachOutputListeners(runtime);
     runtime.child.on("error", (error) => {
       appendLog(runtime.logs, "system", error.message);
-      rejectOnceLocal(new import_agent_sdk3.BackgroundTaskError("process", error.message));
+      rejectOnceLocal(new import_agent_sdk9.BackgroundTaskError("process", error.message));
     });
     runtime.child.on("close", (code, signal) => {
       resolveOnce(code ?? void 0, signal ?? void 0);
@@ -5170,10 +4910,10 @@ function readProcessLog(runtime, cursor) {
 var import_node_child_process3 = require("child_process");
 var import_node_fs7 = require("fs");
 var import_node_path9 = require("path");
-var import_agent_sdk7 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk13 = require("@robota-sdk/agent-sdk");
 
 // src/subagents/child-process-subagent-runner-result.ts
-var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk11 = require("@robota-sdk/agent-sdk");
 
 // src/subagents/child-process-subagent-ipc.ts
 function isRecord2(value) {
@@ -5205,7 +4945,7 @@ function isSubagentWorkerChildMessage(value) {
 }
 
 // src/subagents/child-process-subagent-transport.ts
-var import_agent_sdk4 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk10 = require("@robota-sdk/agent-sdk");
 function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit) {
   switch (message.type) {
     case "ready":
@@ -5215,10 +4955,10 @@ function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit
       resolveOnce(message.output);
       break;
     case "error":
-      rejectOnce(new import_agent_sdk4.BackgroundTaskError("runner", message.message));
+      rejectOnce(new import_agent_sdk10.BackgroundTaskError("runner", message.message));
       break;
     case "cancelled":
-      rejectOnce(new import_agent_sdk4.BackgroundTaskError("runner", message.reason ?? "Subagent worker cancelled"));
+      rejectOnce(new import_agent_sdk10.BackgroundTaskError("runner", message.reason ?? "Subagent worker cancelled"));
       break;
     case "text_delta":
       emit?.({ type: "background_task_text_delta", delta: message.delta });
@@ -5238,7 +4978,7 @@ function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit
       });
       break;
     default:
-      rejectOnce(new import_agent_sdk4.BackgroundTaskError("runner", "Unhandled subagent worker message"));
+      rejectOnce(new import_agent_sdk10.BackgroundTaskError("runner", "Unhandled subagent worker message"));
   }
 }
 function extractFirstArg(toolArgs) {
@@ -5250,7 +4990,7 @@ function extractFirstArg(toolArgs) {
 function sendWorkerMessage(child, message) {
   return new Promise((resolve2, reject) => {
     if (!child.connected) {
-      reject(new import_agent_sdk4.BackgroundTaskError("crash", "Subagent worker IPC channel is closed"));
+      reject(new import_agent_sdk10.BackgroundTaskError("crash", "Subagent worker IPC channel is closed"));
       return;
     }
     child.send(message, (error) => {
@@ -5311,7 +5051,7 @@ var ChildProcessSubagentResultController = class {
   onMessage = (message) => {
     if (!isSubagentWorkerChildMessage(message)) {
       this.rejectOnce(
-        new import_agent_sdk5.BackgroundTaskError("runner", "Received malformed subagent worker message")
+        new import_agent_sdk11.BackgroundTaskError("runner", "Received malformed subagent worker message")
       );
       return;
     }
@@ -5319,11 +5059,11 @@ var ChildProcessSubagentResultController = class {
     handleWorkerMessage(message, this.startWorker, this.resolveOnce, this.rejectOnce, job.emit);
   };
   onError = (error) => {
-    this.rejectOnce(new import_agent_sdk5.BackgroundTaskError("crash", error.message));
+    this.rejectOnce(new import_agent_sdk11.BackgroundTaskError("crash", error.message));
   };
   onExit = (code, signal) => {
     if (this.settled) return;
-    this.rejectOnce(new import_agent_sdk5.BackgroundTaskError("crash", formatEarlyExitMessage(code, signal)));
+    this.rejectOnce(new import_agent_sdk11.BackgroundTaskError("crash", formatEarlyExitMessage(code, signal)));
   };
   resolveOnce = (output) => {
     if (this.settled) return;
@@ -5363,7 +5103,7 @@ function createCancellationResult(jobId) {
     reject(reason) {
       if (settled) return;
       settled = true;
-      rejectFn(new import_agent_sdk5.BackgroundTaskError("runner", reason ?? `Subagent job cancelled: ${jobId}`));
+      rejectFn(new import_agent_sdk11.BackgroundTaskError("runner", reason ?? `Subagent job cancelled: ${jobId}`));
     }
   };
 }
@@ -5371,7 +5111,7 @@ 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"));
+    rejectOnce(new import_agent_sdk11.BackgroundTaskError("timeout", "Subagent worker timed out"));
   }, runtime.job.request.timeoutMs);
 }
 function toSubagentResult(job, output, resolveTranscriptPath) {
@@ -5392,33 +5132,60 @@ var import_node_child_process2 = require("child_process");
 var import_node_crypto2 = require("crypto");
 var import_node_fs6 = require("fs");
 var import_node_path8 = require("path");
-var import_agent_sdk6 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk12 = require("@robota-sdk/agent-sdk");
 var WORKTREE_DIR = ".robota/worktrees";
 var BRANCH_PREFIX = "robota";
 var GIT_ENCODING = "utf8";
 var SHORT_ID_LENGTH = 8;
+var DEFAULT_MAX_CREATE_ATTEMPTS = 5;
+var COLLISION_ERROR_PATTERN = /already exists|is already checked out|missing but already registered/i;
 function createGitWorktreeIsolationAdapter(options) {
   return new GitWorktreeIsolationAdapter(options);
 }
 var GitWorktreeIsolationAdapter = class {
   worktreeDir;
   branchPrefix;
+  idFactory;
+  maxCreateAttempts;
   constructor(options = {}) {
     this.worktreeDir = options.worktreeDir ?? WORKTREE_DIR;
     this.branchPrefix = options.branchPrefix ?? BRANCH_PREFIX;
+    this.idFactory = options.idFactory ?? createShortId;
+    this.maxCreateAttempts = options.maxCreateAttempts ?? DEFAULT_MAX_CREATE_ATTEMPTS;
   }
   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}`;
+    if (this.maxCreateAttempts < 1) {
+      throw new import_agent_sdk12.BackgroundTaskError("runner", "Git worktree creation attempts must be at least 1");
+    }
+    const repoRoot = resolveRepoRoot(request.cwd);
+    const baseRevision = runGit(repoRoot, ["rev-parse", "HEAD"]).trim();
+    const parentStatus = runGit(repoRoot, ["status", "--porcelain"]).trimEnd();
     const worktreeRoot = (0, import_node_path8.join)(repoRoot, this.worktreeDir);
-    const worktreePath = (0, import_node_path8.join)(worktreeRoot, `${request.jobId}-${shortId}`);
     (0, import_node_fs6.mkdirSync)(worktreeRoot, { recursive: true });
-    runGit(repoRoot, ["worktree", "add", "-b", branchName, worktreePath, "HEAD"]);
-    return { repoRoot, worktreePath, branchName };
+    let lastError;
+    for (let attempt = 0; attempt < this.maxCreateAttempts; attempt += 1) {
+      const shortId = normalizeShortId(this.idFactory());
+      const jobId = sanitizePathSegment(request.jobId);
+      const branchName = `${this.branchPrefix}/${jobId}-${shortId}`;
+      const worktreePath = (0, import_node_path8.join)(worktreeRoot, `${jobId}-${shortId}`);
+      try {
+        runGit(repoRoot, ["worktree", "add", "-b", branchName, worktreePath, "HEAD"]);
+        return { repoRoot, worktreePath, branchName, baseRevision, parentStatus };
+      } catch (error) {
+        lastError = toError(error);
+        if (!isCollisionError(lastError)) throw lastError;
+      }
+    }
+    throw new import_agent_sdk12.BackgroundTaskError(
+      "runner",
+      `Unable to create Git worktree after ${this.maxCreateAttempts} attempts due to branch or path collisions. Last error: ${lastError?.message ?? "unknown error"}`
+    );
   }
   isClean(worktree) {
-    return runGit(worktree.worktreePath, ["status", "--porcelain"]).trim().length === 0;
+    return this.getStatus(worktree).trim().length === 0;
+  }
+  getStatus(worktree) {
+    return runGit(worktree.worktreePath, ["status", "--porcelain"]);
   }
   remove(worktree) {
     runGit(worktree.repoRoot, ["worktree", "remove", "--force", worktree.worktreePath]);
@@ -5430,13 +5197,51 @@ function runGit(cwd, args) {
     return (0, import_node_child_process2.execFileSync)("git", args, {
       cwd,
       encoding: GIT_ENCODING,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      env: createGitEnvironment()
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new import_agent_sdk6.BackgroundTaskError("runner", `git ${args.join(" ")} failed: ${message}`);
+    throw new import_agent_sdk12.BackgroundTaskError("runner", `git ${args.join(" ")} failed: ${message}`);
+  }
+}
+function createGitEnvironment() {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (key.startsWith("GIT_")) {
+      delete env[key];
+    }
+  }
+  return env;
+}
+function resolveRepoRoot(cwd) {
+  try {
+    return runGit(cwd, ["rev-parse", "--show-toplevel"]).trim();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new import_agent_sdk12.BackgroundTaskError(
+      "runner",
+      `Worktree isolation requires a Git repository. Run from a Git worktree or request isolation "none". Details: ${message}`
+    );
   }
 }
+function createShortId() {
+  return (0, import_node_crypto2.randomUUID)().slice(0, SHORT_ID_LENGTH);
+}
+function normalizeShortId(value) {
+  const sanitized = sanitizePathSegment(value).slice(0, SHORT_ID_LENGTH);
+  return sanitized.length > 0 ? sanitized : createShortId();
+}
+function sanitizePathSegment(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized.length > 0 ? sanitized : "agent";
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function isCollisionError(error) {
+  return COLLISION_ERROR_PATTERN.test(error.message);
+}
 
 // src/subagents/child-process-subagent-runner.ts
 var DEFAULT_KILL_GRACE_MS2 = 2e3;
@@ -5445,7 +5250,7 @@ function createChildProcessSubagentRunnerFactory(options = {}) {
   return (deps) => {
     const runner = new ChildProcessSubagentRunner(deps, options);
     if (options.worktreeIsolation === false) return runner;
-    return (0, import_agent_sdk7.createWorktreeSubagentRunner)({
+    return (0, import_agent_sdk13.createWorktreeSubagentRunner)({
       runner,
       worktreeAdapter: options.worktreeAdapter ?? createGitWorktreeIsolationAdapter(),
       hooks: deps.config.hooks,
@@ -5527,9 +5332,9 @@ var ChildProcessSubagentRunner = class {
   }
 };
 function resolveAgentDefinition(agentType, customRegistry) {
-  const definition = customRegistry?.(agentType) ?? (0, import_agent_sdk7.getBuiltInAgent)(agentType);
+  const definition = customRegistry?.(agentType) ?? (0, import_agent_sdk13.getBuiltInAgent)(agentType);
   if (!definition) {
-    throw new import_agent_sdk7.BackgroundTaskError("validation", `Unknown agent type: ${agentType}`);
+    throw new import_agent_sdk13.BackgroundTaskError("validation", `Unknown agent type: ${agentType}`);
   }
   return definition;
 }
@@ -5596,93 +5401,6 @@ function readTranscriptLog(jobId, transcriptPath, cursor) {
   };
 }
 
-// src/commands/statusline-command-module.ts
-var USAGE = [
-  "Usage: /statusline on | off | reset | git on | git off",
-  "Fields: model, context, permission mode, message count, session name, thinking state, git branch."
-].join("\n");
-function createStatusLineEntry() {
-  return {
-    name: "statusline",
-    description: "Configure TUI status-line visibility and fields such as model, context, tokens, session, and git branch.",
-    source: "cli",
-    modelInvocable: false,
-    argumentHint: "on | off | reset | git on | git off",
-    subcommands: [
-      { name: "on", description: "Show the status line", source: "cli" },
-      { name: "off", description: "Hide the status line", source: "cli" },
-      { name: "reset", description: "Restore default status-line fields", source: "cli" },
-      { name: "git", description: "Show or hide git branch field", source: "cli" }
-    ]
-  };
-}
-function parseStatusLineArgs(args) {
-  const parts = args.trim().toLowerCase().split(/\s+/).filter((part) => part.length > 0);
-  const [first, second] = parts;
-  if (first === "on" && second === void 0) {
-    return { success: true, message: "Status line enabled.", patch: { enabled: true } };
-  }
-  if (first === "off" && second === void 0) {
-    return { success: true, message: "Status line disabled.", patch: { enabled: false } };
-  }
-  if (first === "reset" && second === void 0) {
-    return {
-      success: true,
-      message: "Status line settings reset.",
-      patch: { enabled: true, gitBranch: true }
-    };
-  }
-  if (first === "git" && second === "on" && parts.length === 2) {
-    return {
-      success: true,
-      message: "Status line git branch shown.",
-      patch: { gitBranch: true }
-    };
-  }
-  if (first === "git" && second === "off" && parts.length === 2) {
-    return {
-      success: true,
-      message: "Status line git branch hidden.",
-      patch: { gitBranch: false }
-    };
-  }
-  return { success: false, message: USAGE };
-}
-function createStatusLineSystemCommand() {
-  const entry = createStatusLineEntry();
-  return {
-    name: entry.name,
-    description: entry.description,
-    modelInvocable: false,
-    userInvocable: true,
-    argumentHint: entry.argumentHint,
-    execute: (_session, args) => {
-      const action = parseStatusLineArgs(args);
-      if (!action.success) {
-        return { success: false, message: action.message };
-      }
-      return {
-        success: true,
-        message: action.message,
-        data: { statuslinePatch: action.patch }
-      };
-    }
-  };
-}
-var StatusLineCommandSource = class {
-  name = "cli-statusline";
-  getCommands() {
-    return [createStatusLineEntry()];
-  }
-};
-function createStatusLineCommandModule() {
-  return {
-    name: "cli-statusline",
-    commandSources: [new StatusLineCommandSource()],
-    systemCommands: [createStatusLineSystemCommand()]
-  };
-}
-
 // src/cli.ts
 var import_meta = {};
 function readVersion() {
@@ -5774,9 +5492,39 @@ async function startCli(options = {}) {
     return;
   }
   const cwd = process.cwd();
+  const commandHostAdapters = {
+    settings: {
+      read: () => readSettings(getUserSettingsPath()),
+      write: (settings) => writeSettings(getUserSettingsPath(), settings)
+    },
+    plugin: createCliPluginCommandAdapter(cwd)
+  };
   const providerDefinitions = options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
   const commandModules = [
-    createStatusLineCommandModule(),
+    (0, import_agent_command_help.createHelpCommandModule)(),
+    (0, import_agent_command_agent.createAgentCommandModule)(),
+    (0, import_agent_command_model.createModelCommandModule)(),
+    (0, import_agent_command_mode.createModeCommandModule)(),
+    (0, import_agent_command_permissions.createPermissionsCommandModule)(),
+    (0, import_agent_command_language.createLanguageCommandModule)(),
+    (0, import_agent_command_background.createBackgroundCommandModule)(),
+    (0, import_agent_command_memory.createMemoryCommandModule)(),
+    (0, import_agent_command_compact.createCompactCommandModule)(),
+    (0, import_agent_command_context.createContextCommandModule)(),
+    (0, import_agent_command_exit.createExitCommandModule)(),
+    (0, import_agent_command_session.createSessionCommandModule)(),
+    (0, import_agent_command_reset.createResetCommandModule)(),
+    (0, import_agent_command_rewind.createRewindCommandModule)(),
+    (0, import_agent_command_statusline.createStatusLineCommandModule)(),
+    (0, import_agent_command_plugin.createPluginCommandModule)(),
+    (0, import_agent_command_provider.createProviderCommandModule)({
+      providerDefinitions,
+      settings: {
+        readMergedSettings: () => readMergedProviderSettings(cwd),
+        readTargetSettings: () => readSettings(getUserSettingsPath()),
+        writeTargetSettings: (settings) => writeSettings(getUserSettingsPath(), settings)
+      }
+    }),
     ...options.commandModules ?? []
   ];
   const startupUpdateNoticePromise = shouldRunStartupCliUpdateCheck(args) ? getStartupCliUpdateNotice({ currentVersion: version }) : void 0;
@@ -5799,7 +5547,7 @@ async function startCli(options = {}) {
   const modelId = args.model ?? providerSettings.model;
   const provider = createProviderFromSettings(cwd, args.model, providerOptions);
   const backgroundTaskRunners = [createManagedShellProcessRunner()];
-  const paths = (0, import_agent_sdk8.projectPaths)(cwd);
+  const paths = (0, import_agent_sdk14.projectPaths)(cwd);
   const subagentRunnerFactory = createChildProcessSubagentRunnerFactory({
     providerConfig: { ...providerSettings, model: modelId },
     logsDir: paths.logs
@@ -5847,7 +5595,7 @@ async function startCli(options = {}) {
 ${args.jsonSchema}`
       );
     const appendSystemPrompt = appendParts.length > 0 ? appendParts.join("\n\n") : void 0;
-    const session = new import_agent_sdk8.InteractiveSession({
+    const session = new import_agent_sdk14.InteractiveSession({
       cwd,
       provider,
       permissionMode: args.permissionMode ?? "bypassPermissions",
@@ -5859,7 +5607,8 @@ ${args.jsonSchema}`
       appendSystemPrompt,
       backgroundTaskRunners,
       subagentRunnerFactory,
-      commandModules
+      commandModules,
+      commandHostAdapters
     });
     const transport = (0, import_agent_transport_headless.createHeadlessTransport)({
       outputFormat: args.outputFormat ?? "text",
@@ -5873,6 +5622,7 @@ ${args.jsonSchema}`
   renderApp({
     cwd,
     provider,
+    providerOverride: args.provider,
     modelId,
     language: args.language,
     permissionMode: args.permissionMode,
@@ -5885,7 +5635,7 @@ ${args.jsonSchema}`
     backgroundTaskRunners,
     subagentRunnerFactory,
     commandModules,
-    providerDefinitions,
+    commandHostAdapters,
     startupUpdateNoticePromise
   });
 }