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

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

@@ -3,11 +3,13 @@ import {
   createProviderFromSettings,
   findProviderDefinition,
   formatSupportedProviderTypes,
+  getProviderSettingsPaths,
   hasUsableSecretReference,
   isSubagentWorkerChildMessage,
   readMergedProviderSettings,
+  readMergedProviderSettingsFromPaths,
   readProviderSettings
-} from "./chunk-4ZX5RLIX.js";
+} from "./chunk-6XQKLNRF.js";
 
 // src/background/managed-shell-process-runner.ts
 import { spawn } from "child_process";
@@ -191,28 +193,55 @@ 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 = randomUUID().slice(0, SHORT_ID_LENGTH);
-    const branchName = `${this.branchPrefix}/${request.jobId}-${shortId}`;
+    if (this.maxCreateAttempts < 1) {
+      throw new BackgroundTaskError2("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 = join(repoRoot, this.worktreeDir);
-    const worktreePath = join(worktreeRoot, `${request.jobId}-${shortId}`);
     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 = 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 BackgroundTaskError2(
+      "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]);
@@ -224,13 +253,51 @@ function runGit(cwd, args) {
     return 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 BackgroundTaskError2("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 BackgroundTaskError2(
+      "runner",
+      `Worktree isolation requires a Git repository. Run from a Git worktree or request isolation "none". Details: ${message}`
+    );
+  }
+}
+function createShortId() {
+  return 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
 import { fork } from "child_process";
@@ -594,6 +661,23 @@ function readTranscriptLog(jobId, transcriptPath, cursor) {
 import { readFileSync as readFileSync6 } from "fs";
 import { join as join9, dirname as dirname5 } from "path";
 import { fileURLToPath } from "url";
+import { createAgentCommandModule } from "@robota-sdk/agent-command-agent";
+import { createBackgroundCommandModule } from "@robota-sdk/agent-command-background";
+import { createProviderCommandModule } from "@robota-sdk/agent-command-provider";
+import { createCompactCommandModule } from "@robota-sdk/agent-command-compact";
+import { createContextCommandModule } from "@robota-sdk/agent-command-context";
+import { createExitCommandModule } from "@robota-sdk/agent-command-exit";
+import { createHelpCommandModule } from "@robota-sdk/agent-command-help";
+import { createLanguageCommandModule } from "@robota-sdk/agent-command-language";
+import { createMemoryCommandModule } from "@robota-sdk/agent-command-memory";
+import { createModeCommandModule } from "@robota-sdk/agent-command-mode";
+import { createModelCommandModule } from "@robota-sdk/agent-command-model";
+import { createPermissionsCommandModule } from "@robota-sdk/agent-command-permissions";
+import { createPluginCommandModule } from "@robota-sdk/agent-command-plugin";
+import { createResetCommandModule } from "@robota-sdk/agent-command-reset";
+import { createRewindCommandModule } from "@robota-sdk/agent-command-rewind";
+import { createStatusLineCommandModule } from "@robota-sdk/agent-command-statusline";
+import { createSessionCommandModule } from "@robota-sdk/agent-command-session";
 import { InteractiveSession as InteractiveSession2, projectPaths } from "@robota-sdk/agent-sdk";
 import { SessionStore } from "@robota-sdk/agent-sessions";
 
@@ -710,28 +794,6 @@ function writeSettings(path, settings) {
   mkdirSync2(dirname2(path), { recursive: true });
   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 (existsSync2(path)) {
     unlinkSync(path);
@@ -742,31 +804,21 @@ function deleteSettings(path) {
 
 // src/utils/provider-setup.ts
 import { join as join4 } from "path";
-import { homedir } from "os";
 
 // src/utils/settings-check.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-function checkSettingsFile(filePath, providerDefinitions = []) {
-  if (!existsSync3(filePath)) return "missing";
-  try {
-    const raw = readFileSync3(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) {
@@ -786,69 +838,14 @@ function isUsableProviderProfile(type, profile, providerDefinitions) {
 }
 
 // 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 = 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 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;
-}
+import {
+  buildProviderProfile,
+  buildProviderSetupPatch,
+  mergeProviderPatch,
+  setCurrentProvider,
+  upsertProviderProfile,
+  validateProviderProfile
+} from "@robota-sdk/agent-sdk";
 
 // src/utils/provider-configuration.ts
 function readProviderDocument(settingsPath) {
@@ -869,158 +866,84 @@ function applyProviderSwitch(settingsPath, profileName, options = {}) {
   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: ${formatSupportedProviderTypes(providerDefinitions)}`
-    );
-  }
-  const definition = findProviderDefinition(providerDefinitions, selectedValue);
-  if (definition === void 0) {
-    throw new Error(
-      `Unknown provider: ${selectedValue}. Currently supported: ${formatSupportedProviderTypes(providerDefinitions)}`
-    );
+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 definition.type;
+  return updateLegacyProviderModel(settingsPaths, modelId);
 }
-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 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");
   }
-  return step;
-}
-function submitProviderSetupValue(state, rawValue) {
-  const step = getProviderSetupStep(state);
-  const value = rawValue.trim() || step.defaultValue || "";
-  const validationMessage = validateProviderSetupValue(step, value);
-  if (validationMessage !== void 0) {
-    return { status: "error", state, message: validationMessage };
-  }
-  const nextState = {
-    ...state,
-    stepIndex: state.stepIndex + 1,
-    values: { ...state.values, [step.key]: value }
-  };
-  if (nextState.stepIndex < state.steps.length) {
-    return { status: "next", state: nextState };
-  }
-  return { status: "complete", input: buildProviderSetupInput(nextState) };
-}
-async function runProviderSetupPromptFlow(type, promptInput2, providerDefinitions) {
-  let state = createProviderSetupFlow(type, providerDefinitions);
-  const stepCount = state.steps.length;
-  while (state.stepIndex < stepCount) {
-    const step = getProviderSetupStep(state);
-    const value = await promptInput2(formatProviderSetupPromptLabel(step), step.masked === true);
-    const result = submitProviderSetupValue(state, value);
-    if (result.status === "complete") {
-      return result.input;
-    }
-    if (result.status === "error") {
-      throw new Error(result.message);
+  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 = findProviderDefinition(providerDefinitions, type);
-  if (definition === void 0) {
-    throw new Error(
-      `Unknown provider: ${type}. Currently supported: ${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
-    });
+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;
   }
-  if (definition.requiresApiKey === true) {
-    steps.push({
-      key: "apiKey",
-      title: `${definition.type} API key`,
-      defaultValue: definition.defaults?.apiKey,
-      required: definition.defaults?.apiKey === void 0,
-      masked: true
-    });
-  }
-  return steps;
-}
-function buildProviderSetupInput(state) {
-  return {
-    profile: state.type,
-    type: state.type,
-    model: state.values.model,
-    apiKey: state.values.apiKey,
-    ...state.values.baseURL !== void 0 && { baseURL: state.values.baseURL },
-    setCurrent: true
-  };
+  return void 0;
 }
 
+// src/utils/provider-setup-flow.ts
+import {
+  createProviderSetupFlow,
+  formatProviderSetupChoiceLabel,
+  formatProviderSetupPromptLabel,
+  formatProviderSetupSelectionPrompt,
+  getProviderSetupStep,
+  resolveProviderSetupSelection,
+  runProviderSetupPromptFlow,
+  submitProviderSetupValue,
+  validateProviderSetupValue
+} from "@robota-sdk/agent-sdk";
+
 // src/utils/provider-setup.ts
 function getSettingsPathForScope(cwd, scope) {
   if (scope === void 0 || scope === "user") {
@@ -1052,17 +975,25 @@ 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));
@@ -1098,15 +1029,31 @@ function buildSetupInputFromArgs(args) {
     setCurrent: args.setCurrent
   };
 }
-function getSettingsCheckPaths(cwd) {
-  return [
-    getUserSettingsPath(),
-    join4(homedir(), ".claude", "settings.json"),
-    join4(cwd, ".robota", "settings.json"),
-    join4(cwd, ".robota", "settings.local.json"),
-    join4(cwd, ".claude", "settings.json"),
-    join4(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 = join4(cwd, ".robota", "settings.json");
+  const projectLocalSettingsPath = join4(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;
@@ -1140,19 +1087,15 @@ import { render } from "ink";
 // src/ui/App.tsx
 import { useState as useState14, useEffect as useEffect4 } from "react";
 import { Box as Box18, Text as Text20, useApp as useApp2, useInput as useInput8 } from "ink";
-import { getModelName as getModelName3, createSystemMessage as createSystemMessage4, messageToHistoryEntry as messageToHistoryEntry4 } from "@robota-sdk/agent-core";
+import { createSystemMessage as createSystemMessage6, messageToHistoryEntry as messageToHistoryEntry6 } from "@robota-sdk/agent-core";
 
 // src/ui/hooks/useInteractiveSession.ts
 import { useState, useRef, useCallback as useCallback2, useEffect } from "react";
-import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
 import {
   InteractiveSession,
-  CommandRegistry,
-  BuiltinCommandSource,
-  SkillCommandSource,
-  PluginCommandSource,
-  BundlePluginLoader
+  CommandRegistry as CommandRegistry2,
+  createBuiltinCommandModule,
+  SkillCommandSource
 } from "@robota-sdk/agent-sdk";
 import { createSystemMessage as createSystemMessage2, messageToHistoryEntry as messageToHistoryEntry2 } from "@robota-sdk/agent-core";
 
@@ -1178,7 +1121,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) {
@@ -1343,6 +1290,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;
@@ -1408,133 +1363,35 @@ var TuiStateManager = class {
 // src/ui/hooks/useSlashRouting.ts
 import { useCallback } from "react";
 import { randomUUID as randomUUID2 } from "crypto";
-import {
-  createSystemMessage,
-  messageToHistoryEntry
-} from "@robota-sdk/agent-core";
+import { createSystemMessage, messageToHistoryEntry } from "@robota-sdk/agent-core";
 
-// src/utils/provider-command.ts
-async function handleProviderCommand(cwd, args, deps = {}) {
-  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 (findProviderDefinition(providerDefinitions, type) === void 0) {
-    return {
-      message: `Usage: provider add <type>. Supported: ${formatSupportedProviderTypes(providerDefinitions)}`,
-      success: false
-    };
-  }
-  return {
-    message: `Provider setup requested: ${type}`,
-    success: true,
-    data: { providerSetup: { type } }
-  };
+// src/plugins/plugin-command-source-loader.ts
+import { homedir } from "os";
+import { join as join5 } from "path";
+import { BundlePluginLoader, PluginCommandSource } from "@robota-sdk/agent-sdk";
+var PLUGIN_SOURCE_NAME = "plugin";
+function getHomeDir() {
+  return process.env.HOME ?? 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 = join5(getHomeDir(), ".robota", "plugins");
+  const loader = new 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 PluginCommandSource(plugins));
+    return plugins.length;
+  } catch {
+    registry.replaceSource(PLUGIN_SOURCE_NAME);
+    return 0;
   }
-  const providerDefinitions = deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
-  const definition = profile.type ? 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 useCallback(
     async (input) => {
       manager.onUserTurnAccepted();
@@ -1546,70 +1403,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(
         messageToHistoryEntry(
           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(messageToHistoryEntry(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(messageToHistoryEntry(createSystemMessage(result.message)));
-  const data = result.data;
   const effects = getEffects(interactiveSession);
-  if (typeof data?.modelId === "string") {
-    effects._pendingModelId = data.modelId;
-    return;
-  }
-  if (typeof data?.language === "string") {
-    effects._pendingLanguage = data.language;
-    return;
+  if (result.interaction !== void 0) {
+    effects._pendingCommandInteraction = result.interaction;
   }
-  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({
@@ -1618,6 +1437,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) {
@@ -1641,29 +1476,14 @@ 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 InteractiveSession({
     cwd: props.cwd,
@@ -1677,23 +1497,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 CommandRegistry();
-  registry.addSource(new BuiltinCommandSource());
+  const registry = new CommandRegistry2();
+  registry.addModule(createBuiltinCommandModule());
   for (const module of props.commandModules ?? []) {
     registry.addModule(module);
   }
   registry.addSource(new SkillCommandSource(props.cwd));
-  const pluginsDir = join5(homedir2(), ".robota", "plugins");
-  const loader = new BundlePluginLoader(pluginsDir);
-  try {
-    const plugins = loader.loadPluginsSync();
-    if (plugins.length > 0) {
-      registry.addSource(new PluginCommandSource(plugins));
-    }
-  } catch {
-  }
+  reloadPluginCommandSource(registry);
   const manager = new TuiStateManager();
   return { interactiveSession, registry, manager };
 }
@@ -1743,6 +1556,7 @@ function useInteractiveSession(props) {
     }
   }
   useEffect(() => {
+    const onCompact = () => applyCompactEventToManager(interactiveSession, manager);
     interactiveSession.on("text_delta", manager.onTextDelta);
     interactiveSession.on("tool_start", manager.onToolStart);
     interactiveSession.on("tool_end", manager.onToolEnd);
@@ -1751,6 +1565,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 {
@@ -1778,6 +1593,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]);
@@ -1787,13 +1603,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 = useCallback2(() => {
     manager.setAborting(true);
     interactiveSession.abort();
@@ -1834,184 +1644,134 @@ function useInteractiveSession(props) {
 
 // src/ui/hooks/usePluginCallbacks.ts
 import { useMemo } from "react";
-import { homedir as homedir3 } from "os";
+
+// src/plugins/plugin-command-adapter.ts
+import { homedir as homedir2 } from "os";
 import { join as join6 } from "path";
 import {
-  PluginSettingsStore,
-  BundlePluginLoader as BundlePluginLoader2,
   BundlePluginInstaller,
-  MarketplaceClient
+  BundlePluginLoader as BundlePluginLoader2,
+  MarketplaceClient,
+  PluginSettingsStore
 } from "@robota-sdk/agent-sdk";
-function usePluginCallbacks(cwd) {
-  return useMemo(() => {
-    const home = homedir3();
-    const pluginsDir = join6(home, ".robota", "plugins");
-    const userSettingsPath = join6(home, ".robota", "settings.json");
-    const settingsStore = new PluginSettingsStore(userSettingsPath);
-    const marketplace = new MarketplaceClient({ pluginsDir });
-    const installer = new BundlePluginInstaller({
-      pluginsDir,
-      settingsStore,
-      marketplaceClient: marketplace
-    });
-    const loader = new BundlePluginLoader2(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 = join6(cwd, ".robota", "plugins");
-          const projectInstaller = new 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]);
-}
-
-// src/ui/hooks/useSideEffects.ts
-import { useState as useState2, useRef as useRef2, useCallback as useCallback3 } from "react";
-import { useApp } from "ink";
-import { createSystemMessage as createSystemMessage3, messageToHistoryEntry as messageToHistoryEntry3, getModelName } from "@robota-sdk/agent-core";
-
-// src/utils/provider-setup-interaction.ts
-function startProviderSetupInteraction(providerDefinitions, type) {
-  if (type === void 0) {
-    const state2 = {
-      mode: "select-provider",
-      providerDefinitions
-    };
-    return { status: "prompt", state: state2, prompt: toProviderSelectionPrompt(providerDefinitions) };
-  }
-  const state = {
-    mode: "setup-fields",
-    providerDefinitions,
-    flow: createProviderSetupFlow(type, providerDefinitions)
+function createCliPluginServices(cwd) {
+  const home = homedir2();
+  const pluginsDir = join6(home, ".robota", "plugins");
+  const userSettingsPath = join6(home, ".robota", "settings.json");
+  const settingsStore = new PluginSettingsStore(userSettingsPath);
+  const marketplace = new MarketplaceClient({ pluginsDir });
+  const installer = new BundlePluginInstaller({
+    pluginsDir,
+    settingsStore,
+    marketplaceClient: marketplace
+  });
+  const loader = new BundlePluginLoader2(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 = join6(services.cwd, ".robota", "plugins");
+    const projectInstaller = new 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 useMemo(() => createCliPluginCommandAdapter(cwd), [cwd]);
+}
+
+// src/ui/hooks/useSideEffects.ts
+import { useState as useState2, useRef as useRef2, useCallback as useCallback3 } from "react";
+import { useApp } from "ink";
+import { createSystemMessage as createSystemMessage5, messageToHistoryEntry as messageToHistoryEntry5 } from "@robota-sdk/agent-core";
+
 // src/utils/statusline-settings.ts
+import { DEFAULT_STATUS_LINE_COMMAND_SETTINGS } from "@robota-sdk/agent-sdk";
 var DEFAULT_STATUS_LINE_SETTINGS = {
-  enabled: true,
-  gitBranch: true
+  ...DEFAULT_STATUS_LINE_COMMAND_SETTINGS
 };
 function readStatusLineSettings(settings) {
   const raw = settings.statusline;
@@ -2046,39 +1806,196 @@ function applyPendingStatusLinePatch(sideEffects, setStatusLineSettings) {
   return true;
 }
 
+// src/ui/hooks/command-effect-handler.ts
+import { isStatusLineCommandSettingsPatch } from "@robota-sdk/agent-sdk";
+import { createSystemMessage as createSystemMessage3, messageToHistoryEntry as messageToHistoryEntry3 } from "@robota-sdk/agent-core";
+function applyCommandEffects(effects, 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 (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(
+    messageToHistoryEntry3(createSystemMessage3(`Language set to "${language}". Restarting...`))
+  );
+  deps.requestShutdown("other", "Language change restart");
+}
+function applySettingsResetEffect(deps) {
+  const settingsPath = getUserSettingsPath();
+  if (deleteSettings(settingsPath)) {
+    deps.addEntry(
+      messageToHistoryEntry3(createSystemMessage3(`Deleted ${settingsPath}. Exiting...`))
+    );
+  } else {
+    deps.addEntry(messageToHistoryEntry3(createSystemMessage3("No user settings found.")));
+  }
+  deps.requestShutdown("other", "Reset settings restart");
+}
+
+// src/ui/hooks/model-change-side-effect.ts
+import {
+  createSystemMessage as createSystemMessage4,
+  getModelName,
+  messageToHistoryEntry as messageToHistoryEntry4
+} from "@robota-sdk/agent-core";
+function formatModelChangeConfirmationMessage(modelId) {
+  return `Change model to ${getModelName(modelId)}? This will exit the current session so the next session uses it.`;
+}
+function formatModelChangeExitMessage(modelId) {
+  return `Model changed to ${getModelName(modelId)}. Exiting so the next session uses it.`;
+}
+function applyConfirmedModelChange(deps) {
+  const applyModelChange = deps.applyModelChange ?? applyActiveModelChange;
+  const options = deps.providerOverride !== void 0 ? { providerOverride: deps.providerOverride } : void 0;
+  try {
+    applyModelChange(deps.cwd, deps.modelId, options);
+    deps.addEntry(
+      messageToHistoryEntry4(createSystemMessage4(formatModelChangeExitMessage(deps.modelId)))
+    );
+    deps.requestShutdown("other", "Model change applied");
+  } catch (error) {
+    deps.addEntry(
+      messageToHistoryEntry4(
+        createSystemMessage4(`Failed: ${error instanceof Error ? error.message : String(error)}`)
+      )
+    );
+  }
+}
+function addModelChangeCancelledMessage(addEntry) {
+  addEntry(messageToHistoryEntry4(createSystemMessage4("Model change cancelled.")));
+}
+
 // src/ui/hooks/useSideEffects.ts
 var EXIT_DELAY_MS = 500;
 function useSideEffects({
   cwd,
+  providerOverride,
   interactiveSession,
   addEntry,
   baseHandleSubmit,
   setSessionName,
-  setStatusLineSettings,
-  providerDefinitions
+  setStatusLineSettings
 }) {
   const { exit } = useApp();
   const [pendingModelId, setPendingModelId] = useState2(null);
   const pendingModelChangeRef = useRef2(null);
-  const [pendingProviderProfile, setPendingProviderProfile] = useState2(null);
-  const pendingProviderProfileRef = useRef2(null);
   const [pendingInteractionPrompt, setPendingInteractionPrompt] = useState2(null);
-  const providerSetupInteractionRef = useRef2(null);
+  const commandInteractionRef = useRef2(null);
   const [showPluginTUI, setShowPluginTUI] = useState2(false);
   const [showSessionPicker, setShowSessionPicker] = useState2(false);
   const requestShutdown = useCallback3(
     (reason, message) => {
-      addEntry(messageToHistoryEntry3(createSystemMessage3("Shutting down...")));
+      addEntry(messageToHistoryEntry5(createSystemMessage5("Shutting down...")));
       setTimeout(() => {
         void interactiveSession.shutdown({ reason, message }).finally(() => exit());
       }, EXIT_DELAY_MS);
     },
     [interactiveSession, addEntry, exit]
   );
+  const applyEffects = useCallback3(
+    (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 = useCallback3(
+    (result) => {
+      if (result.message.length > 0) {
+        addEntry(messageToHistoryEntry5(createSystemMessage5(result.message)));
+      }
+      if (result.interaction !== void 0) {
+        commandInteractionRef.current = result.interaction;
+        setPendingInteractionPrompt(result.interaction.prompt);
+        return;
+      }
+      commandInteractionRef.current = null;
+      setPendingInteractionPrompt(null);
+      if (result.effects !== void 0 && result.effects.length > 0) {
+        applyEffects(result.effects, interactiveSession);
+      }
+    },
+    [addEntry, applyEffects, interactiveSession]
+  );
+  const applyQueuedCommandState = useCallback3(
+    (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 = useCallback3(
     async (input) => {
       await baseHandleSubmit(input);
       const sideEffects = interactiveSession;
+      if (applyQueuedCommandState(sideEffects)) return;
       if (sideEffects._pendingModelId) {
         const modelId = sideEffects._pendingModelId;
         delete sideEffects._pendingModelId;
@@ -2086,69 +2003,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(
-          messageToHistoryEntry3(createSystemMessage3(`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(
-            messageToHistoryEntry3(createSystemMessage3(`Deleted ${settingsPath}. Exiting...`))
-          );
-        } else {
-          addEntry(messageToHistoryEntry3(createSystemMessage3("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;
@@ -2156,11 +2029,9 @@ function useSideEffects({
     [
       interactiveSession,
       baseHandleSubmit,
-      addEntry,
-      requestShutdown,
-      setSessionName,
-      setStatusLineSettings,
-      providerDefinitions
+      applyQueuedCommandState,
+      applyEffects,
+      setStatusLineSettings
     ]
   );
   const handleModelConfirm = useCallback3(
@@ -2169,117 +2040,60 @@ function useSideEffects({
       setPendingModelId(null);
       pendingModelChangeRef.current = null;
       if (index === 0 && modelId) {
-        try {
-          const settingsPath = getUserSettingsPath();
-          updateModelInSettings(settingsPath, modelId);
-          addEntry(
-            messageToHistoryEntry3(
-              createSystemMessage3(`Model changed to ${getModelName(modelId)}. Restarting...`)
-            )
-          );
-          requestShutdown("other", "Model change restart");
-        } catch (err) {
-          addEntry(
-            messageToHistoryEntry3(
-              createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
-            )
-          );
-        }
-      } else {
-        addEntry(messageToHistoryEntry3(createSystemMessage3("Model change cancelled.")));
-      }
-    },
-    [addEntry, requestShutdown]
-  );
-  const handleProviderConfirm = useCallback3(
-    (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(
-            messageToHistoryEntry3(
-              createSystemMessage3(`Provider changed to ${profile}. Restarting...`)
-            )
-          );
-          requestShutdown("other", "Provider change restart");
-        } catch (err) {
-          addEntry(
-            messageToHistoryEntry3(
-              createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
-            )
-          );
-        }
+        applyConfirmedModelChange({
+          cwd,
+          modelId,
+          providerOverride,
+          addEntry,
+          requestShutdown
+        });
       } else {
-        addEntry(messageToHistoryEntry3(createSystemMessage3("Provider change cancelled.")));
+        addModelChangeCancelledMessage(addEntry);
       }
     },
-    [cwd, addEntry, requestShutdown]
-  );
-  const completeProviderSetup = useCallback3(
-    (input) => {
-      providerSetupInteractionRef.current = null;
-      setPendingInteractionPrompt(null);
-      try {
-        const settingsPath = getUserSettingsPath();
-        applyProviderConfiguration(settingsPath, input, { providerDefinitions });
-        addEntry(
-          messageToHistoryEntry3(
-            createSystemMessage3(`Provider ${input.profile} configured. Restarting...`)
-          )
-        );
-        requestShutdown("other", "Provider setup restart");
-      } catch (err) {
-        addEntry(
-          messageToHistoryEntry3(
-            createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
-          )
-        );
-      }
-    },
-    [addEntry, requestShutdown, providerDefinitions]
+    [cwd, providerOverride, addEntry, requestShutdown]
   );
   const handleInteractionSubmit = useCallback3(
-    (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(
-          messageToHistoryEntry3(
-            createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+          messageToHistoryEntry5(
+            createSystemMessage5(`Failed: ${err instanceof Error ? err.message : String(err)}`)
           )
         );
       }
     },
-    [addEntry, completeProviderSetup]
+    [addEntry, applyCommandResult]
   );
   const handleInteractionCancel = useCallback3(() => {
-    providerSetupInteractionRef.current = null;
+    const interaction = commandInteractionRef.current;
+    commandInteractionRef.current = null;
     setPendingInteractionPrompt(null);
-    addEntry(messageToHistoryEntry3(createSystemMessage3("Provider setup cancelled.")));
-  }, [addEntry]);
+    if (interaction?.cancel === void 0) {
+      addEntry(messageToHistoryEntry5(createSystemMessage5("Command interaction cancelled.")));
+      return;
+    }
+    Promise.resolve(interaction.cancel()).then((result) => applyCommandResult(result)).catch((err) => {
+      addEntry(
+        messageToHistoryEntry5(
+          createSystemMessage5(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+        )
+      );
+    });
+  }, [addEntry, applyCommandResult]);
   return {
     handleSubmit,
     pendingModelId,
-    pendingProviderProfile,
     pendingInteractionPrompt,
     showPluginTUI,
     showSessionPicker,
@@ -2287,7 +2101,6 @@ function useSideEffects({
     setShowPluginTUI,
     setShowSessionPicker,
     handleModelConfirm,
-    handleProviderConfirm,
     handleInteractionSubmit,
     handleInteractionCancel
   };
@@ -2960,6 +2773,21 @@ function StatusLeft({
     )
   ] });
 }
+function StatusRight({
+  isThinking,
+  messageCount
+}) {
+  return /* @__PURE__ */ jsxs5(Text5, { children: [
+    isThinking && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "thinking..." }),
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "msgs: ",
+      messageCount
+    ] })
+  ] });
+}
 function StatusBar({
   permissionMode,
   modelName,
@@ -3002,10 +2830,7 @@ function StatusBar({
             showGitBranch
           }
         ),
-        /* @__PURE__ */ jsx5(Text5, { children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-          "msgs: ",
-          messageCount
-        ] }) })
+        /* @__PURE__ */ jsx5(StatusRight, { isThinking, messageCount })
       ]
     }
   );
@@ -4264,32 +4089,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__ */ jsx16(Fragment4, {});
+  return /* @__PURE__ */ jsx16(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text15, { color: "yellow", children: "Thinking..." }) });
+}
+function renderTools(activeTools) {
+  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "Tools:" }),
+    /* @__PURE__ */ jsx16(Text15, { children: " " }),
+    activeTools.map((t, i) => {
+      const { color, icon, strikethrough } = getToolStyle(t);
+      return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs13(Text15, { color, strikethrough, children: [
+          "  ",
+          icon,
+          " ",
+          t.toolName,
+          "(",
+          t.firstArg,
+          ")"
+        ] }),
+        t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ jsx16(ToolDiffBlock, { file: t.diffFile, lines: t.diffLines })
+      ] }, `${t.toolName}-${i}`);
+    })
+  ] });
+}
+function StreamingIndicator({
+  text,
+  activeTools,
+  isThinking = false
+}) {
   const hasTools = activeTools.length > 0;
   const hasText = text.length > 0;
   if (!hasTools && !hasText) {
-    return /* @__PURE__ */ jsx16(Fragment4, {});
+    return renderThinkingFallback(isThinking);
   }
   return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
-    hasTools && /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "Tools:" }),
-      /* @__PURE__ */ jsx16(Text15, { children: " " }),
-      activeTools.map((t, i) => {
-        const { color, icon, strikethrough } = getToolStyle(t);
-        return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxs13(Text15, { color, strikethrough, children: [
-            "  ",
-            icon,
-            " ",
-            t.toolName,
-            "(",
-            t.firstArg,
-            ")"
-          ] }),
-          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ jsx16(ToolDiffBlock, { file: t.diffFile, lines: t.diffLines })
-        ] }, `${t.toolName}-${i}`);
-      })
-    ] }),
+    hasTools && renderTools(activeTools),
     hasText && /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
       /* @__PURE__ */ jsx16(Text15, { color: "cyan", bold: true, children: "Robota:" }),
       /* @__PURE__ */ jsx16(Text15, { children: " " }),
@@ -4812,9 +4648,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;
 }
@@ -5142,7 +4983,6 @@ function App(props) {
 }
 function AppInner(props) {
   const cwd = props.cwd;
-  const providerDefinitions = props.providerDefinitions ?? [];
   const {
     interactiveSession,
     registry,
@@ -5173,9 +5013,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 } = useApp2();
   const [sessionName, setSessionName] = useState14(props.sessionName);
   const [updateNotice, setUpdateNotice] = useState14();
@@ -5186,24 +5027,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
   });
   useEffect4(() => {
     const name = interactiveSession?.getName?.();
@@ -5272,24 +5111,24 @@ function AppInner(props) {
     /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
       /* @__PURE__ */ jsx22(MessageList, { history }),
       isShuttingDown && /* @__PURE__ */ jsx22(Box18, { marginBottom: 1, children: /* @__PURE__ */ jsx22(Text20, { color: "yellow", children: "Shutting down..." }) }),
-      (isThinking || activeTools.length > 0) && /* @__PURE__ */ jsx22(Box18, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx22(StreamingIndicator, { text: streamingText, activeTools }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ jsx22(Box18, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx22(
+        StreamingIndicator,
+        {
+          text: streamingText,
+          activeTools,
+          isThinking
+        }
+      ) }),
       /* @__PURE__ */ jsx22(BackgroundTaskPanel, { tasks: backgroundTasks })
     ] }),
     permissionRequest && /* @__PURE__ */ jsx22(PermissionPrompt, { request: permissionRequest }),
     pendingModelId && /* @__PURE__ */ jsx22(
       ConfirmPrompt,
       {
-        message: `Change model to ${getModelName3(pendingModelId)}? This will restart the session.`,
+        message: formatModelChangeConfirmationMessage(pendingModelId),
         onSelect: handleModelConfirm
       }
     ),
-    pendingProviderProfile && /* @__PURE__ */ jsx22(
-      ConfirmPrompt,
-      {
-        message: `Change provider to ${pendingProviderProfile}? This will restart the session.`,
-        onSelect: handleProviderConfirm
-      }
-    ),
     pendingInteractionPrompt && /* @__PURE__ */ jsx22(
       InteractivePrompt,
       {
@@ -5303,7 +5142,7 @@ function AppInner(props) {
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addEntry(messageToHistoryEntry4(createSystemMessage4(msg.content)))
+        addMessage: (msg) => addEntry(messageToHistoryEntry6(createSystemMessage6(msg.content)))
       }
     ),
     showSessionPicker && /* @__PURE__ */ jsx22(
@@ -5317,7 +5156,7 @@ function AppInner(props) {
         },
         onCancel: () => {
           setShowSessionPicker(false);
-          addEntry(messageToHistoryEntry4(createSystemMessage4("Session resume cancelled.")));
+          addEntry(messageToHistoryEntry6(createSystemMessage6("Session resume cancelled.")));
         }
       }
     ),
@@ -5382,93 +5221,6 @@ function renderApp(options) {
   });
 }
 
-// src/commands/statusline-command-module.ts
-var USAGE = [
-  "Usage: /statusline on | off | reset | git on | git off",
-  "Fields: model, context, permission mode, message count, session name, thinking state, git branch."
-].join("\n");
-function createStatusLineEntry() {
-  return {
-    name: "statusline",
-    description: "Configure TUI status-line visibility and fields such as model, context, tokens, session, and git branch.",
-    source: "cli",
-    modelInvocable: false,
-    argumentHint: "on | off | reset | git on | git off",
-    subcommands: [
-      { name: "on", description: "Show the status line", source: "cli" },
-      { name: "off", description: "Hide the status line", source: "cli" },
-      { name: "reset", description: "Restore default status-line fields", source: "cli" },
-      { name: "git", description: "Show or hide git branch field", source: "cli" }
-    ]
-  };
-}
-function parseStatusLineArgs(args) {
-  const parts = args.trim().toLowerCase().split(/\s+/).filter((part) => part.length > 0);
-  const [first, second] = parts;
-  if (first === "on" && second === void 0) {
-    return { success: true, message: "Status line enabled.", patch: { enabled: true } };
-  }
-  if (first === "off" && second === void 0) {
-    return { success: true, message: "Status line disabled.", patch: { enabled: false } };
-  }
-  if (first === "reset" && second === void 0) {
-    return {
-      success: true,
-      message: "Status line settings reset.",
-      patch: { enabled: true, gitBranch: true }
-    };
-  }
-  if (first === "git" && second === "on" && parts.length === 2) {
-    return {
-      success: true,
-      message: "Status line git branch shown.",
-      patch: { gitBranch: true }
-    };
-  }
-  if (first === "git" && second === "off" && parts.length === 2) {
-    return {
-      success: true,
-      message: "Status line git branch hidden.",
-      patch: { gitBranch: false }
-    };
-  }
-  return { success: false, message: USAGE };
-}
-function createStatusLineSystemCommand() {
-  const entry = createStatusLineEntry();
-  return {
-    name: entry.name,
-    description: entry.description,
-    modelInvocable: false,
-    userInvocable: true,
-    argumentHint: entry.argumentHint,
-    execute: (_session, args) => {
-      const action = parseStatusLineArgs(args);
-      if (!action.success) {
-        return { success: false, message: action.message };
-      }
-      return {
-        success: true,
-        message: action.message,
-        data: { statuslinePatch: action.patch }
-      };
-    }
-  };
-}
-var StatusLineCommandSource = class {
-  name = "cli-statusline";
-  getCommands() {
-    return [createStatusLineEntry()];
-  }
-};
-function createStatusLineCommandModule() {
-  return {
-    name: "cli-statusline",
-    commandSources: [new StatusLineCommandSource()],
-    systemCommands: [createStatusLineSystemCommand()]
-  };
-}
-
 // src/cli.ts
 function readVersion() {
   try {
@@ -5559,9 +5311,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 = [
+    createHelpCommandModule(),
+    createAgentCommandModule(),
+    createModelCommandModule(),
+    createModeCommandModule(),
+    createPermissionsCommandModule(),
+    createLanguageCommandModule(),
+    createBackgroundCommandModule(),
+    createMemoryCommandModule(),
+    createCompactCommandModule(),
+    createContextCommandModule(),
+    createExitCommandModule(),
+    createSessionCommandModule(),
+    createResetCommandModule(),
+    createRewindCommandModule(),
     createStatusLineCommandModule(),
+    createPluginCommandModule(),
+    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;
@@ -5644,7 +5426,8 @@ ${args.jsonSchema}`
       appendSystemPrompt,
       backgroundTaskRunners,
       subagentRunnerFactory,
-      commandModules
+      commandModules,
+      commandHostAdapters
     });
     const transport = createHeadlessTransport({
       outputFormat: args.outputFormat ?? "text",
@@ -5658,6 +5441,7 @@ ${args.jsonSchema}`
   renderApp({
     cwd,
     provider,
+    providerOverride: args.provider,
     modelId,
     language: args.language,
     permissionMode: args.permissionMode,
@@ -5670,7 +5454,7 @@ ${args.jsonSchema}`
     backgroundTaskRunners,
     subagentRunnerFactory,
     commandModules,
-    providerDefinitions,
+    commandHostAdapters,
     startupUpdateNoticePromise
   });
 }