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

package/dist/node/index.cjs

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   ChildProcessSubagentRunner: () => ChildProcessSubagentRunner,
   GitWorktreeIsolationAdapter: () => GitWorktreeIsolationAdapter,
   createChildProcessSubagentRunnerFactory: () => createChildProcessSubagentRunnerFactory,
@@ -37,7 +37,7 @@ __export(index_exports, {
   createManagedShellProcessRunner: () => createManagedShellProcessRunner,
   startCli: () => startCli
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/cli.ts
 var import_node_fs8 = require("fs");
@@ -52,7 +52,6 @@ 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");
@@ -60,8 +59,9 @@ 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");
+var import_agent_command_skills = require("@robota-sdk/agent-command-skills");
+var import_agent_command_user_local2 = require("@robota-sdk/agent-command-user-local");
+var import_agent_sdk15 = require("@robota-sdk/agent-sdk");
 
 // src/utils/cli-args.ts
 var import_node_util = require("util");
@@ -99,8 +99,12 @@ function parseCliArgs() {
       "fork-session": { type: "boolean", default: false },
       name: { type: "string", short: "n" },
       "output-format": { type: "string" },
+      format: { type: "string" },
+      summary: { type: "string" },
+      source: { type: "string" },
       "system-prompt": { type: "string" },
       "append-system-prompt": { type: "string" },
+      "task-file": { type: "string" },
       version: { type: "boolean", default: false },
       reset: { type: "boolean", default: false },
       bare: { type: "boolean", default: false },
@@ -117,7 +121,10 @@ function parseCliArgs() {
       "set-current": { type: "boolean", default: false },
       "settings-scope": { type: "string" },
       "check-update": { type: "boolean", default: false },
-      "disable-update-check": { type: "boolean", default: false }
+      "disable-update-check": { type: "boolean", default: false },
+      web: { type: "boolean", default: false },
+      "web-port": { type: "string" },
+      "no-open": { type: "boolean", default: false }
     }
   });
   return {
@@ -132,8 +139,12 @@ function parseCliArgs() {
     forkSession: values["fork-session"] ?? false,
     sessionName: values["name"],
     outputFormat: values["output-format"],
+    format: values["format"],
+    summary: values["summary"],
+    source: values["source"],
     systemPrompt: values["system-prompt"],
     appendSystemPrompt: values["append-system-prompt"],
+    taskFile: values["task-file"],
     version: values["version"] ?? false,
     reset: values["reset"] ?? false,
     bare: values["bare"] ?? false,
@@ -150,9 +161,23 @@ function parseCliArgs() {
     setCurrent: values["set-current"] ?? false,
     settingsScope: values["settings-scope"],
     checkUpdate: values["check-update"] ?? false,
-    disableUpdateCheck: values["disable-update-check"] ?? false
+    disableUpdateCheck: values["disable-update-check"] ?? false,
+    web: values["web"] ?? false,
+    webPort: parseWebPort(values["web-port"]),
+    noOpen: values["no-open"] ?? false
   };
 }
+var DEFAULT_WEB_PORT = 7070;
+function parseWebPort(raw) {
+  if (raw === void 0) return DEFAULT_WEB_PORT;
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n < 1 || n > 65535) {
+    process.stderr.write(`Invalid --web-port "${raw}". Must be 1\u201365535.
+`);
+    process.exit(1);
+  }
+  return n;
+}
 
 // src/utils/settings-io.ts
 var import_node_fs = require("fs");
@@ -190,6 +215,7 @@ var import_node_path2 = require("path");
 
 // src/utils/provider-default-definitions.ts
 var import_agent_provider_anthropic = require("@robota-sdk/agent-provider-anthropic");
+var import_agent_provider_deepseek = require("@robota-sdk/agent-provider-deepseek");
 var import_agent_provider_gemma = require("@robota-sdk/agent-provider-gemma");
 var import_agent_provider_gemini = require("@robota-sdk/agent-provider-gemini");
 var import_agent_provider_openai = require("@robota-sdk/agent-provider-openai");
@@ -199,7 +225,8 @@ var DEFAULT_PROVIDER_DEFINITIONS = [
   (0, import_agent_provider_openai.createOpenAIProviderDefinition)(),
   (0, import_agent_provider_gemini.createGeminiProviderDefinition)(),
   (0, import_agent_provider_gemma.createGemmaProviderDefinition)(),
-  (0, import_agent_provider_qwen.createQwenProviderDefinition)()
+  (0, import_agent_provider_qwen.createQwenProviderDefinition)(),
+  (0, import_agent_provider_deepseek.createDeepSeekProviderDefinition)()
 ];
 
 // src/utils/provider-definition.ts
@@ -335,8 +362,11 @@ function createProviderFromConfig(settings, providerDefinitions) {
       `Unknown provider: ${settings.name}. Currently supported: ${(0, import_agent_core.formatSupportedProviderTypes)(providerDefinitions)}`
     );
   }
-  if (definition.requiresApiKey === true && !settings.apiKey) {
-    throw new Error(`Provider ${settings.name} requires apiKey`);
+  const credentialRequirement = (0, import_agent_core.getProviderCredentialRequirement)(definition);
+  if (credentialRequirement !== void 0 && !hasRequiredProviderCredential(settings, credentialRequirement)) {
+    throw new Error(
+      `Provider ${settings.name} requires ${formatCredentialRequirement(credentialRequirement)}`
+    );
   }
   return definition.createProvider(settings);
 }
@@ -346,6 +376,16 @@ function createProviderFromSettings(cwd, modelOverride, options = {}) {
   const model = modelOverride ?? settings.model;
   return createProviderFromConfig({ ...settings, model }, providerDefinitions);
 }
+function hasRequiredProviderCredential(settings, requirement) {
+  return requirement.anyOf.some((field) => hasProviderCredentialValue(settings, field));
+}
+function hasProviderCredentialValue(settings, field) {
+  const value = settings[field];
+  return value !== void 0 && value.length > 0;
+}
+function formatCredentialRequirement(requirement) {
+  return requirement.anyOf.join(" or ");
+}
 function getProviderDefinitions(options) {
   return options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
 }
@@ -372,23 +412,40 @@ function isUsableProviderProfile(type, profile, providerDefinitions) {
   if (!profile) {
     return false;
   }
-  if ((0, import_agent_sdk.hasUsableSecretReference)(profile.apiKey)) {
-    return true;
-  }
   if (!type) {
-    return false;
+    return (0, import_agent_sdk.hasUsableSecretReference)(profile.apiKey);
   }
   const definition = (0, import_agent_core.findProviderDefinition)(providerDefinitions, type);
   if (definition === void 0) {
     return false;
   }
-  return definition.requiresApiKey !== true || (0, import_agent_sdk.hasUsableSecretReference)(definition.defaults?.apiKey);
+  const credentialRequirement = (0, import_agent_core.getProviderCredentialRequirement)(definition);
+  if (credentialRequirement === void 0) {
+    return true;
+  }
+  return hasUsableRequiredProviderCredential(profile, definition, credentialRequirement);
+}
+function hasUsableRequiredProviderCredential(profile, definition, requirement) {
+  return requirement.anyOf.some(
+    (field) => (0, import_agent_sdk.hasUsableSecretReference)(resolveProviderCredentialValue(field, profile, definition))
+  );
+}
+function resolveProviderCredentialValue(field, profile, definition) {
+  return profile[field] ?? definition.defaults?.[field];
 }
 
 // src/utils/provider-settings.ts
 var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
 
 // src/utils/provider-configuration.ts
+function resolveProviderSettingsWriteTargetPath(cwd, options = {}) {
+  const settingsPaths = options.settingsPaths ?? getProviderSettingsPaths(cwd);
+  const targetPath = findLastPathWithCurrentProvider(settingsPaths) ?? settingsPaths[0];
+  if (targetPath === void 0) {
+    throw new Error("No settings path available for provider update");
+  }
+  return targetPath;
+}
 function readProviderDocument(settingsPath) {
   return readSettings(settingsPath);
 }
@@ -471,6 +528,15 @@ function findLastPathWithLegacyProvider(settingsPaths) {
   }
   return void 0;
 }
+function findLastPathWithCurrentProvider(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.currentProvider !== void 0) return settingsPath;
+  }
+  return void 0;
+}
 
 // src/utils/provider-setup-flow.ts
 var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
@@ -496,7 +562,8 @@ function handleProviderConfigurationArgs(cwd, args, providerDefinitions = DEFAUL
     return !args.printMode && args.positional.length === 0;
   }
   if (args.provider && args.setCurrent) {
-    applyProviderSwitch(settingsPath, args.provider, {
+    const switchSettingsPath = args.settingsScope === void 0 ? resolveProviderSettingsWriteTargetPath(cwd) : settingsPath;
+    applyProviderSwitch(switchSettingsPath, args.provider, {
       knownProviders: readMergedProviderSettings(cwd).providers
     });
     process.stdout.write(`Current provider set to ${args.provider}
@@ -530,7 +597,9 @@ async function runInteractiveProviderSetup(cwd, args, promptInput2, providerDefi
   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 (0, import_agent_sdk3.runProviderSetupPromptFlow)(type, promptInput2, providerDefinitions);
+  const input = await (0, import_agent_sdk3.runProviderSetupPromptFlow)(type, promptInput2, providerDefinitions, {
+    existingProfileNames: Object.keys(readMergedProviderSettings(cwd).providers ?? {})
+  });
   applyProviderConfiguration(settingsPath, input, {
     providerDefinitions
   });
@@ -613,66 +682,60 @@ function formatConfigureProviderExample(definition) {
 var import_agent_transport_headless = require("@robota-sdk/agent-transport-headless");
 
 // src/ui/render.tsx
-var import_ink22 = require("ink");
+var import_ink24 = require("ink");
 
 // src/ui/App.tsx
-var import_react19 = require("react");
-var import_ink21 = require("ink");
+var import_react20 = require("react");
+var import_ink23 = require("ink");
+var import_agent_sdk9 = require("@robota-sdk/agent-sdk");
 var import_agent_core11 = require("@robota-sdk/agent-core");
 
 // src/ui/hooks/useInteractiveSession.ts
 var import_react2 = require("react");
+var import_open = __toESM(require("open"), 1);
 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
-var BACKGROUND_PREVIEW_LENGTH = 120;
-var BACKGROUND_PREVIEW_WHITESPACE = /\s+/g;
-var BACKGROUND_PREVIEW_SEPARATOR = " ";
-var SUCCESS_EXIT_CODE = 0;
-function toBackgroundTaskViewModel(state, partialText) {
-  return {
-    id: state.id,
-    kind: state.kind,
-    label: state.label,
-    status: state.status,
-    statusLabel: getBackgroundTaskStatusLabel(state),
-    mode: state.mode,
-    currentAction: state.currentAction,
-    unread: state.unread,
-    preview: trimBackgroundPreview(state.promptPreview ?? state.commandPreview) ?? "",
-    resultPreview: trimBackgroundPreview(state.result?.output ?? partialText),
-    errorPreview: trimBackgroundPreview(state.error?.message),
-    startedAt: state.startedAt,
-    lastActivityAt: state.lastActivityAt,
-    timeoutReason: state.timeoutReason,
-    exitCode: state.result?.exitCode,
-    signalCode: state.result?.signalCode,
-    worktreePath: state.worktreePath,
-    branchName: state.branchName,
-    worktreeStatus: state.worktreeStatus,
-    worktreeNextAction: state.worktreeNextAction
-  };
-}
-function getBackgroundTaskStatusLabel(state) {
-  if (state.status === "failed" && state.timeoutReason) {
-    if (state.timeoutReason === "idle" || state.timeoutReason === "max_runtime") {
-      return "timed out";
-    }
-    return state.timeoutReason.replace(/_/g, " ");
-  }
-  return state.status;
-}
-function shouldHideAtNextUserTurn(state) {
-  return state.status === "completed" && !state.error && (state.result?.exitCode === void 0 || state.result.exitCode === SUCCESS_EXIT_CODE) && !state.result?.signalCode && !state.worktreePath && !state.branchName;
-}
-function trimBackgroundPreview(value) {
-  if (!value) return void 0;
-  const preview = value.trim().replace(BACKGROUND_PREVIEW_WHITESPACE, BACKGROUND_PREVIEW_SEPARATOR);
-  if (!preview) return void 0;
-  return preview.length > BACKGROUND_PREVIEW_LENGTH ? `${preview.slice(0, BACKGROUND_PREVIEW_LENGTH)}...` : preview;
+// src/web-sidecar/web-sidecar-server.ts
+var import_node_http = require("http");
+var import_ws = require("ws");
+var import_agent_transport_ws = require("@robota-sdk/agent-transport-ws");
+function startWebSidecarServer(session, port) {
+  return new Promise((resolve3, reject) => {
+    const httpServer = (0, import_node_http.createServer)((_req, res) => {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("Robota web monitor sidecar");
+    });
+    const wss = new import_ws.WebSocketServer({ server: httpServer });
+    wss.on("connection", (ws) => {
+      const send = (message) => {
+        if (ws.readyState === import_ws.WebSocket.OPEN) {
+          ws.send(JSON.stringify(message));
+        }
+      };
+      const { onMessage, cleanup } = (0, import_agent_transport_ws.createWsHandler)({ session, send });
+      ws.on("message", (data) => onMessage(String(data)));
+      ws.on("close", cleanup);
+      ws.on("error", cleanup);
+      const messages = session.getMessages();
+      send({ type: "messages", messages });
+    });
+    httpServer.on("error", reject);
+    httpServer.listen(port, "127.0.0.1", () => {
+      resolve3({
+        port,
+        stop: () => new Promise((res) => {
+          wss.close(() => {
+            httpServer.close(() => res());
+          });
+        })
+      });
+    });
+  });
 }
 
+// src/ui/hooks/useInteractiveSession.ts
+var import_agent_core3 = require("@robota-sdk/agent-core");
+
 // src/ui/tui-state-manager.ts
 var MAX_RENDERED_MESSAGES = 100;
 var STREAMING_DEBOUNCE_MS = 300;
@@ -704,13 +767,12 @@ var TuiStateManager = class {
   isAborting = false;
   pendingPrompt = null;
   contextState = { percentage: 0, usedTokens: 0, maxTokens: 0 };
-  backgroundTasks = [];
+  executionWorkspaceSnapshot = null;
+  selectedExecutionEntryId;
   /** Called after any state change. React hook sets this to trigger re-render. */
   onChange = null;
   // ── Internal ──────────────────────────────────────────────────
   streamBuf = "";
-  backgroundTextBuffers = /* @__PURE__ */ new Map();
-  backgroundTasksHiddenOnNextTurn = /* @__PURE__ */ new Set();
   debouncedStreamNotify = createDebouncedNotify(() => this.notify(), STREAMING_DEBOUNCE_MS);
   notify() {
     this.onChange?.();
@@ -779,30 +841,6 @@ var TuiStateManager = class {
       maxTokens: state.maxTokens
     });
   };
-  onBackgroundTaskEvent = (event) => {
-    if ("task" in event) {
-      this.upsertBackgroundTask(event.task);
-      return;
-    }
-    if (event.type === "background_task_closed") {
-      this.backgroundTextBuffers.delete(event.taskId);
-      this.backgroundTasksHiddenOnNextTurn.delete(event.taskId);
-      this.backgroundTasks = this.backgroundTasks.filter((task) => task.id !== event.taskId);
-      this.notify();
-      return;
-    }
-    if (event.type === "background_task_text_delta") {
-      this.appendBackgroundTaskText(event.taskId, event.delta);
-      return;
-    }
-    if (event.type === "background_task_tool_start") {
-      this.updateBackgroundTaskAction(event.taskId, event.firstArg ?? event.toolName);
-      return;
-    }
-    if (event.type === "background_task_tool_end") {
-      this.updateBackgroundTaskAction(event.taskId, event.success ? void 0 : event.error);
-    }
-  };
   // ── State updates from external sources ───────────────────────
   /** Sync history from InteractiveSession */
   syncHistory(entries) {
@@ -839,56 +877,30 @@ var TuiStateManager = class {
     this.contextState = state;
     this.notify();
   }
-  onUserTurnAccepted() {
-    if (this.backgroundTasksHiddenOnNextTurn.size === 0) return;
-    const visible = this.backgroundTasks.filter(
-      (task) => !this.backgroundTasksHiddenOnNextTurn.has(task.id)
-    );
-    this.backgroundTasksHiddenOnNextTurn.clear();
-    if (visible.length === this.backgroundTasks.length) return;
-    this.backgroundTasks = visible;
-    this.notify();
-  }
-  upsertBackgroundTask(state) {
-    const partialText = state.result ? void 0 : this.backgroundTextBuffers.get(state.id);
-    const viewModel = toBackgroundTaskViewModel(state, partialText);
-    const index = this.backgroundTasks.findIndex((task) => task.id === state.id);
-    if (index === -1) {
-      this.backgroundTasks = [...this.backgroundTasks, viewModel];
-    } else {
-      const updated = [...this.backgroundTasks];
-      updated[index] = viewModel;
-      this.backgroundTasks = updated;
-    }
-    if (state.status === "completed" || state.status === "failed" || state.status === "cancelled") {
-      this.backgroundTextBuffers.delete(state.id);
-    }
-    if (shouldHideAtNextUserTurn(state)) {
-      this.backgroundTasksHiddenOnNextTurn.add(state.id);
-    } else {
-      this.backgroundTasksHiddenOnNextTurn.delete(state.id);
-    }
-    this.notify();
-  }
-  appendBackgroundTaskText(taskId, delta) {
-    const nextText = `${this.backgroundTextBuffers.get(taskId) ?? ""}${delta}`;
-    this.backgroundTextBuffers.set(taskId, nextText);
-    this.backgroundTasks = this.backgroundTasks.map(
-      (task) => task.id === taskId ? { ...task, resultPreview: trimBackgroundPreview(nextText) } : task
-    );
+  syncExecutionWorkspaceSnapshot(snapshot) {
+    const currentSelection = this.selectedExecutionEntryId;
+    const hasCurrentSelection = currentSelection !== void 0 && snapshot.entries.some((entry) => entry.id === currentSelection);
+    const selectedExecutionEntryId = hasCurrentSelection ? currentSelection : snapshot.selectedEntryId ?? snapshot.entries[0]?.id;
+    this.executionWorkspaceSnapshot = {
+      ...snapshot,
+      ...selectedExecutionEntryId ? { selectedEntryId: selectedExecutionEntryId } : {}
+    };
+    this.selectedExecutionEntryId = selectedExecutionEntryId;
     this.notify();
   }
-  updateBackgroundTaskAction(taskId, currentAction) {
-    this.backgroundTasks = this.backgroundTasks.map(
-      (task) => task.id === taskId ? { ...task, currentAction } : task
-    );
+  selectExecutionWorkspaceEntry(entryId) {
+    if (!this.executionWorkspaceSnapshot?.entries.some((entry) => entry.id === entryId)) return;
+    this.selectedExecutionEntryId = entryId;
+    this.executionWorkspaceSnapshot = {
+      ...this.executionWorkspaceSnapshot,
+      selectedEntryId: entryId
+    };
     this.notify();
   }
 };
 
 // src/ui/hooks/useSlashRouting.ts
 var import_react = require("react");
-var import_node_crypto = require("crypto");
 var import_agent_core2 = require("@robota-sdk/agent-core");
 
 // src/plugins/plugin-command-source-loader.ts
@@ -917,10 +929,9 @@ function reloadPluginCommandSource(registry) {
 }
 
 // src/ui/hooks/useSlashRouting.ts
-function useSlashRouting(interactiveSession, registry, manager) {
+function useSlashRouting(interactiveSession, registry, manager, commandEffectQueue) {
   return (0, import_react.useCallback)(
     async (input) => {
-      manager.onUserTurnAccepted();
       if (!input.startsWith("/")) {
         await interactiveSession.submit(input);
         manager.setPendingPrompt(interactiveSession.getPendingPrompt());
@@ -931,10 +942,11 @@ function useSlashRouting(interactiveSession, registry, manager) {
       const args = parts.slice(1).join(" ");
       const result = await interactiveSession.executeCommand(cmd, args);
       if (result) {
-        applySystemCommandResult(result, interactiveSession, registry, manager);
-        return;
-      }
-      if (await routeSkillCommand(input, cmd, registry, interactiveSession, manager)) {
+        if (result.effects?.some((effect) => effect.type === "session-execution-started")) {
+          manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+          return;
+        }
+        applySystemCommandResult(result, interactiveSession, registry, manager, commandEffectQueue);
         return;
       }
       manager.addEntry(
@@ -943,18 +955,17 @@ function useSlashRouting(interactiveSession, registry, manager) {
         )
       );
     },
-    [interactiveSession, registry, manager]
+    [interactiveSession, registry, manager, commandEffectQueue]
   );
 }
-function applySystemCommandResult(result, interactiveSession, registry, manager) {
+function applySystemCommandResult(result, interactiveSession, registry, manager, commandEffectQueue) {
   const pendingEffects = applyImmediateCommandEffects(result.effects, registry, manager);
   manager.addEntry((0, import_agent_core2.messageToHistoryEntry)((0, import_agent_core2.createSystemMessage)(result.message)));
-  const effects = getEffects(interactiveSession);
   if (result.interaction !== void 0) {
-    effects._pendingCommandInteraction = result.interaction;
+    commandEffectQueue.enqueueInteraction(result.interaction);
   }
   if (pendingEffects.length > 0) {
-    effects._pendingCommandEffects = pendingEffects;
+    commandEffectQueue.enqueueEffects(pendingEffects);
   }
   const ctx = interactiveSession.getContextState();
   manager.setContextState({
@@ -979,37 +990,42 @@ function applyImmediateCommandEffects(effects, registry, manager) {
   }
   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) {
-    return false;
+
+// src/ui/hooks/command-effect-queue.ts
+var CommandEffectQueue = class {
+  queue = [];
+  enqueueInteraction(interaction) {
+    this.queue.push({ type: "interaction", interaction });
   }
-  manager.addEntry({
-    id: (0, import_node_crypto.randomUUID)(),
-    timestamp: /* @__PURE__ */ new Date(),
-    category: "event",
-    type: "skill-invocation",
-    data: {
-      skillName: cmd,
-      source: skillCmd.source,
-      message: `Invoking ${skillCmd.source}: ${cmd}`
-    }
-  });
-  const args = input.slice(1 + cmd.length).trimStart();
-  const qualifiedName = registry.resolveQualifiedName(cmd);
-  const hookInput = qualifiedName ? `/${qualifiedName}${input.slice(1 + cmd.length)}` : input;
-  await interactiveSession.executeSkillCommand(skillCmd, args, input, hookInput);
-  manager.setPendingPrompt(interactiveSession.getPendingPrompt());
-  return true;
-}
-function getEffects(interactiveSession) {
-  return interactiveSession;
-}
+  enqueueEffects(effects) {
+    if (effects.length === 0) return;
+    this.queue.push({ type: "effects", effects: [...effects] });
+  }
+  drain() {
+    return this.queue.shift();
+  }
+  clear() {
+    this.queue.length = 0;
+  }
+};
 
 // src/ui/hooks/useInteractiveSession.ts
 function applyCompactEventToManager(interactiveSession, manager) {
   manager.syncHistory(interactiveSession.getFullHistory());
 }
+function applySkillActivationEventToManager(interactiveSession, manager) {
+  manager.syncHistory(interactiveSession.getFullHistory());
+}
+function syncExecutionWorkspaceFromSession(interactiveSession, manager) {
+  try {
+    manager.syncExecutionWorkspaceSnapshot(
+      interactiveSession.getExecutionWorkspaceSnapshot({
+        selectedEntryId: manager.selectedExecutionEntryId
+      })
+    );
+  } catch {
+  }
+}
 function initializeSession(props, permissionHandler) {
   const interactiveSession = new import_agent_sdk5.InteractiveSession({
     cwd: props.cwd,
@@ -1027,14 +1043,13 @@ function initializeSession(props, permissionHandler) {
     commandHostAdapters: props.commandHostAdapters
   });
   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_sdk5.SkillCommandSource(props.cwd));
   reloadPluginCommandSource(registry);
   const manager = new TuiStateManager();
-  return { interactiveSession, registry, manager };
+  const commandEffectQueue = new CommandEffectQueue();
+  return { interactiveSession, registry, manager, commandEffectQueue };
 }
 function useInteractiveSession(props) {
   const [, forceRender] = (0, import_react2.useState)(0);
@@ -1063,8 +1078,8 @@ function useInteractiveSession(props) {
     });
   }, []);
   const permissionHandler = (0, import_react2.useCallback)(
-    (toolName, toolArgs) => new Promise((resolve2) => {
-      permissionQueueRef.current.push({ toolName, toolArgs, resolve: resolve2 });
+    (toolName, toolArgs) => new Promise((resolve3) => {
+      permissionQueueRef.current.push({ toolName, toolArgs, resolve: resolve3 });
       processNextPermission();
     }),
     [processNextPermission]
@@ -1073,7 +1088,7 @@ function useInteractiveSession(props) {
   if (stateRef.current === null) {
     stateRef.current = initializeSession(props, permissionHandler);
   }
-  const { interactiveSession, registry, manager } = stateRef.current;
+  const { interactiveSession, registry, manager, commandEffectQueue } = stateRef.current;
   manager.onChange = () => forceRender((n) => n + 1);
   if (manager.history.length === 0) {
     const restored = interactiveSession.getFullHistory();
@@ -1081,8 +1096,32 @@ function useInteractiveSession(props) {
       manager.syncHistory(restored);
     }
   }
+  (0, import_react2.useEffect)(() => {
+    if (!props.webPort) return;
+    const port = props.webPort;
+    let stopped = false;
+    let stopFn = null;
+    startWebSidecarServer(interactiveSession, port).then((server) => {
+      stopFn = server.stop;
+      if (stopped) {
+        server.stop().catch(() => void 0);
+        return;
+      }
+      const shouldOpen = !props.noOpen && !process.env["ROBOTA_NO_OPEN"];
+      const monitorUrl = process.env["ROBOTA_MONITOR_URL"] ?? "http://localhost:7071/monitor";
+      if (shouldOpen) {
+        (0, import_open.default)(monitorUrl).catch(() => void 0);
+      }
+    }).catch(() => void 0);
+    return () => {
+      stopped = true;
+      if (stopFn) stopFn().catch(() => void 0);
+    };
+  }, [interactiveSession, props.webPort, props.noOpen]);
   (0, import_react2.useEffect)(() => {
     const onCompact = () => applyCompactEventToManager(interactiveSession, manager);
+    const onSkillActivation = () => applySkillActivationEventToManager(interactiveSession, manager);
+    const onExecutionWorkspaceEvent = (event) => manager.syncExecutionWorkspaceSnapshot(event.snapshot);
     interactiveSession.on("text_delta", manager.onTextDelta);
     interactiveSession.on("tool_start", manager.onToolStart);
     interactiveSession.on("tool_end", manager.onToolEnd);
@@ -1092,7 +1131,8 @@ function useInteractiveSession(props) {
     interactiveSession.on("error", manager.onError);
     interactiveSession.on("context_update", manager.onContextUpdate);
     interactiveSession.on("compact", onCompact);
-    interactiveSession.on("background_task_event", manager.onBackgroundTaskEvent);
+    interactiveSession.on("skill_activation", onSkillActivation);
+    interactiveSession.on("execution_workspace_event", onExecutionWorkspaceEvent);
     const initCheck = setInterval(() => {
       try {
         const ctx = interactiveSession.getContextState();
@@ -1105,6 +1145,7 @@ function useInteractiveSession(props) {
         if (restored.length > 0) {
           manager.syncHistory(restored);
         }
+        syncExecutionWorkspaceFromSession(interactiveSession, manager);
         clearInterval(initCheck);
       } catch {
       }
@@ -1120,16 +1161,18 @@ function useInteractiveSession(props) {
       interactiveSession.off("error", manager.onError);
       interactiveSession.off("context_update", manager.onContextUpdate);
       interactiveSession.off("compact", onCompact);
-      interactiveSession.off("background_task_event", manager.onBackgroundTaskEvent);
+      interactiveSession.off("skill_activation", onSkillActivation);
+      interactiveSession.off("execution_workspace_event", onExecutionWorkspaceEvent);
     };
   }, [interactiveSession, manager]);
   (0, import_react2.useEffect)(() => {
     manager.syncHistory(interactiveSession.getFullHistory());
+    syncExecutionWorkspaceFromSession(interactiveSession, manager);
     if (!manager.isThinking) {
       manager.setPendingPrompt(interactiveSession.getPendingPrompt());
     }
   }, [manager.isThinking, interactiveSession, manager]);
-  const handleSubmit = useSlashRouting(interactiveSession, registry, manager);
+  const handleSubmit = useSlashRouting(interactiveSession, registry, manager, commandEffectQueue);
   const handleAbort = (0, import_react2.useCallback)(() => {
     manager.setAborting(true);
     interactiveSession.abort();
@@ -1147,9 +1190,18 @@ function useInteractiveSession(props) {
     },
     [interactiveSession, manager, isShuttingDown]
   );
+  const selectExecutionWorkspaceEntry = (0, import_react2.useCallback)(
+    (entryId) => manager.selectExecutionWorkspaceEntry(entryId),
+    [manager]
+  );
+  const readExecutionWorkspaceDetail = (0, import_react2.useCallback)(
+    (entryId) => interactiveSession.readExecutionWorkspaceDetail(entryId),
+    [interactiveSession]
+  );
   return {
     interactiveSession,
     registry,
+    commandEffectQueue,
     history: manager.history,
     addEntry: (entry) => manager.addEntry(entry),
     streamingText: manager.streamingText,
@@ -1158,13 +1210,16 @@ function useInteractiveSession(props) {
     isAborting: manager.isAborting,
     isShuttingDown,
     pendingPrompt: manager.pendingPrompt,
-    backgroundTasks: manager.backgroundTasks,
+    executionWorkspaceSnapshot: manager.executionWorkspaceSnapshot,
+    selectedExecutionEntryId: manager.selectedExecutionEntryId,
     permissionRequest,
     contextState: manager.contextState,
     handleSubmit,
     handleAbort,
     handleCancelQueue,
-    handleShutdown
+    handleShutdown,
+    selectExecutionWorkspaceEntry,
+    readExecutionWorkspaceDetail
   };
 }
 
@@ -1433,10 +1488,12 @@ function useSideEffects({
   cwd,
   providerOverride,
   interactiveSession,
+  commandEffectQueue,
   addEntry,
   baseHandleSubmit,
   setSessionName,
-  setStatusLineSettings
+  setStatusLineSettings,
+  showSessionPickerOnStart
 }) {
   const { exit } = (0, import_ink.useApp)();
   const [pendingModelId, setPendingModelId] = (0, import_react4.useState)(null);
@@ -1444,7 +1501,7 @@ function useSideEffects({
   const [pendingInteractionPrompt, setPendingInteractionPrompt] = (0, import_react4.useState)(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 [showSessionPicker, setShowSessionPicker] = (0, import_react4.useState)(showSessionPickerOnStart ?? false);
   const requestShutdown = (0, import_react4.useCallback)(
     (reason, message) => {
       addEntry((0, import_agent_core6.messageToHistoryEntry)((0, import_agent_core6.createSystemMessage)("Shutting down...")));
@@ -1485,33 +1542,31 @@ function useSideEffects({
       commandInteractionRef.current = null;
       setPendingInteractionPrompt(null);
       if (result.effects !== void 0 && result.effects.length > 0) {
-        applyEffects(result.effects, interactiveSession);
+        applyEffects(result.effects, getHostSideEffects(interactiveSession));
       }
     },
     [addEntry, applyEffects, interactiveSession]
   );
   const applyQueuedCommandState = (0, import_react4.useCallback)(
     (sideEffects) => {
-      if (sideEffects._pendingCommandInteraction !== void 0) {
-        const interaction = sideEffects._pendingCommandInteraction;
-        delete sideEffects._pendingCommandInteraction;
+      const queued = commandEffectQueue.drain();
+      if (queued === void 0) {
+        return false;
+      }
+      if (queued.type === "interaction") {
+        const { interaction } = queued;
         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;
+      return applyEffects(queued.effects, sideEffects);
     },
-    [applyEffects]
+    [applyEffects, commandEffectQueue]
   );
   const handleSubmit = (0, import_react4.useCallback)(
     async (input) => {
       await baseHandleSubmit(input);
-      const sideEffects = interactiveSession;
+      const sideEffects = getHostSideEffects(interactiveSession);
       if (applyQueuedCommandState(sideEffects)) return;
       if (sideEffects._pendingModelId) {
         const modelId = sideEffects._pendingModelId;
@@ -1622,6 +1677,9 @@ function useSideEffects({
     handleInteractionCancel
   };
 }
+function getHostSideEffects(interactiveSession) {
+  return interactiveSession;
+}
 
 // src/ui/hooks/useStatusLineSettings.ts
 var import_react5 = require("react");
@@ -1639,10 +1697,12 @@ var import_agent_core8 = require("@robota-sdk/agent-core");
 // src/ui/render-markdown.ts
 var import_marked = require("marked");
 var import_marked_terminal = __toESM(require("marked-terminal"), 1);
-var ANSI_RED = "\x1B[31m";
-var ANSI_GREEN = "\x1B[32m";
+var ANSI_LIGHT_RED = "\x1B[38;5;210m";
+var ANSI_LIGHT_GREEN = "\x1B[38;5;120m";
 var ANSI_CYAN = "\x1B[36m";
 var ANSI_DIM = "\x1B[2m";
+var ANSI_DARK_RED_BACKGROUND = "\x1B[48;5;52m";
+var ANSI_DARK_GREEN_BACKGROUND = "\x1B[48;5;22m";
 var ANSI_RESET = "\x1B[0m";
 var CODE_BLOCK_INDENT = "    ";
 var ZERO_COLOR = "0";
@@ -1662,36 +1722,59 @@ function shouldUseColor(option) {
 function isDiffLanguage(language) {
   return language?.trim().toLowerCase() === "diff";
 }
-function colorizeDiffLine(line, color) {
+function styleAddedOrRemovedDiffRow(line, rowWidth, color) {
+  const row = `${CODE_BLOCK_INDENT}${line}`.padEnd(rowWidth);
   if (!color) {
-    return line;
+    return row.trimEnd();
   }
   if (line.startsWith("+")) {
-    return `${ANSI_GREEN}${line}${ANSI_RESET}`;
+    return `${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}${row}${ANSI_RESET}`;
   }
   if (line.startsWith("-")) {
-    return `${ANSI_RED}${line}${ANSI_RESET}`;
+    return `${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}${row}${ANSI_RESET}`;
+  }
+  return row.trimEnd();
+}
+function colorizeDiffLine(line, color, rowWidth) {
+  if (line.startsWith("+") || line.startsWith("-")) {
+    return styleAddedOrRemovedDiffRow(line, rowWidth, color);
+  }
+  const row = `${CODE_BLOCK_INDENT}${line}`;
+  if (!color) {
+    return row;
   }
   if (line.startsWith("@@")) {
-    return `${ANSI_CYAN}${line}${ANSI_RESET}`;
+    return `${ANSI_CYAN}${row}${ANSI_RESET}`;
   }
   if (line.startsWith("diff ") || line.startsWith("index ")) {
-    return `${ANSI_DIM}${line}${ANSI_RESET}`;
+    return `${ANSI_DIM}${row}${ANSI_RESET}`;
+  }
+  return row;
+}
+function resolveDiffRowWidth(lines, requestedWidth) {
+  const minimumWidth = lines.reduce(
+    (maxWidth, line) => Math.max(maxWidth, CODE_BLOCK_INDENT.length + line.length),
+    0
+  );
+  if (requestedWidth === void 0) {
+    return minimumWidth;
   }
-  return line;
+  return Math.max(minimumWidth, requestedWidth);
 }
-function renderDiffCodeBlock(code, color) {
-  const body = code.split("\n").map((line) => `${CODE_BLOCK_INDENT}${colorizeDiffLine(line, color)}`).join("\n");
+function renderDiffCodeBlock(code, color, codeBlockWidth) {
+  const lines = code.split("\n");
+  const rowWidth = resolveDiffRowWidth(lines, codeBlockWidth);
+  const body = lines.map((line) => colorizeDiffLine(line, color, rowWidth)).join("\n");
   return `${body}
 
 `;
 }
-function createTerminalRenderer(color) {
+function createTerminalRenderer(color, codeBlockWidth) {
   const renderer = new TerminalRendererConstructor(void 0, { ignoreIllegals: true });
   const renderCode = renderer.code.bind(renderer);
   renderer.code = (code, language, escaped) => {
     if (isDiffLanguage(language)) {
-      return renderDiffCodeBlock(code, color);
+      return renderDiffCodeBlock(code, color, codeBlockWidth);
     }
     return renderCode(code, language, escaped);
   };
@@ -1699,7 +1782,7 @@ function createTerminalRenderer(color) {
 }
 function renderMarkdown(md, options = {}) {
   const result = import_marked.marked.parse(md, {
-    renderer: createTerminalRenderer(shouldUseColor(options.color))
+    renderer: createTerminalRenderer(shouldUseColor(options.color), options.codeBlockWidth)
   });
   return typeof result === "string" ? result.trimEnd() : md;
 }
@@ -1818,7 +1901,7 @@ function formatUsageTokenCount(tokens) {
 
 // src/ui/command-output-summary.ts
 var MAX_PREVIEW_LINES = 4;
-var SUCCESS_EXIT_CODE2 = 0;
+var SUCCESS_EXIT_CODE = 0;
 var COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set(["Bash", "BackgroundProcess"]);
 function formatCommandOutputSummary(tool) {
   if (!COMMAND_TOOL_NAMES.has(tool.toolName) || !tool.toolResultData) return void 0;
@@ -1829,7 +1912,7 @@ function formatCommandOutputSummary(tool) {
   const lines = trimTrailingBlankLines(splitOutputLines(output));
   const previewLines = lines.slice(0, MAX_PREVIEW_LINES);
   const omittedLineCount = Math.max(0, lines.length - previewLines.length);
-  const isFailed = tool.result === "error" || successValue === false || exitCode !== void 0 && exitCode !== SUCCESS_EXIT_CODE2;
+  const isFailed = tool.result === "error" || successValue === false || exitCode !== void 0 && exitCode !== SUCCESS_EXIT_CODE;
   return {
     status: isFailed ? "error" : "success",
     statusLabel: formatStatusLabel(isFailed, exitCode),
@@ -1859,7 +1942,7 @@ function buildOutputText(raw, parsed) {
   return lines.join("\n");
 }
 function formatStatusLabel(isFailed, exitCode) {
-  if (exitCode !== void 0 && exitCode !== SUCCESS_EXIT_CODE2) return `exit ${exitCode}`;
+  if (exitCode !== void 0 && exitCode !== SUCCESS_EXIT_CODE) return `exit ${exitCode}`;
   return isFailed ? "error" : "ok";
 }
 function splitOutputLines(output) {
@@ -2211,11 +2294,7 @@ function StatusActivityText({
     activeBackgroundTaskCount,
     hasPendingPrompt
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: "cyan", bold: true, children: "Activity:" }),
-    " ",
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: activity.color, bold: activity.kind !== "idle", children: activity.text })
-  ] });
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: activity.color, bold: activity.kind !== "idle", children: activity.text });
 }
 function ContextText({
   percentage,
@@ -2239,77 +2318,79 @@ function ModeText({ permissionMode }) {
     /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { children: permissionMode })
   ] });
 }
-function StatusLeft({
-  permissionMode,
+function shouldShowPermissionMode(permissionMode) {
+  return permissionMode !== "default";
+}
+function ProviderText({
   modelName,
-  isThinking,
-  activeToolCount,
-  activeBackgroundTaskCount,
-  hasPendingPrompt,
-  contextPercentage,
-  contextUsedTokens,
-  contextMaxTokens,
-  sessionName,
-  gitBranch,
-  showGitBranch
+  providerProfileName,
+  providerType
 }) {
-  const shouldShowGitBranch = showGitBranch && gitBranch !== void 0 && gitBranch.length > 0;
+  if (providerProfileName !== void 0 && providerType !== void 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { dimColor: true, children: [
+      providerProfileName,
+      " (",
+      providerType,
+      ") ",
+      modelName
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { dimColor: true, children: modelName });
+}
+function StatusLeft(props) {
+  const shouldShowGitBranch = props.showGitBranch && props.gitBranch !== void 0 && props.gitBranch.length > 0;
+  const showPermissionMode = shouldShowPermissionMode(props.permissionMode);
   return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { children: [
     /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       StatusActivityText,
       {
-        isThinking,
-        activeToolCount,
-        activeBackgroundTaskCount,
-        hasPendingPrompt
+        isThinking: props.isThinking,
+        activeToolCount: props.activeToolCount,
+        activeBackgroundTaskCount: props.activeBackgroundTaskCount,
+        hasPendingPrompt: props.hasPendingPrompt
       }
     ),
-    "  |  ",
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ModeText, { permissionMode }),
-    sessionName && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+    showPermissionMode && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+      "  |  ",
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ModeText, { permissionMode: props.permissionMode })
+    ] }),
+    props.sessionName && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
       "  |  ",
-      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: "magenta", children: sessionName })
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { color: "magenta", children: props.sessionName })
     ] }),
     shouldShowGitBranch && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
       "  |  ",
       /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink6.Text, { dimColor: true, children: [
         "git: ",
-        gitBranch
+        props.gitBranch
       ] })
     ] }),
     "  |  ",
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { dimColor: true, children: modelName }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      ProviderText,
+      {
+        modelName: props.modelName,
+        providerProfileName: props.providerProfileName,
+        providerType: props.providerType
+      }
+    ),
     "  |  ",
     /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       ContextText,
       {
-        percentage: contextPercentage,
-        usedTokens: contextUsedTokens,
-        maxTokens: contextMaxTokens
+        percentage: props.contextPercentage,
+        usedTokens: props.contextUsedTokens,
+        maxTokens: props.contextMaxTokens
       }
     )
   ] });
 }
-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,
+  providerProfileName,
+  providerType,
   sessionId: _sessionId,
-  messageCount,
   isThinking,
   activeToolCount = 0,
   activeBackgroundTaskCount = 0,
@@ -2321,7 +2402,7 @@ function StatusBar({
   gitBranch,
   showGitBranch = true
 }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
     import_ink6.Box,
     {
       borderStyle: "single",
@@ -2329,26 +2410,25 @@ function StatusBar({
       paddingLeft: 1,
       paddingRight: 1,
       justifyContent: "space-between",
-      children: [
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-          StatusLeft,
-          {
-            permissionMode,
-            modelName,
-            isThinking,
-            activeToolCount,
-            activeBackgroundTaskCount,
-            hasPendingPrompt,
-            contextPercentage,
-            contextUsedTokens,
-            contextMaxTokens,
-            sessionName,
-            gitBranch,
-            showGitBranch
-          }
-        ),
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(StatusRight, { isThinking, messageCount })
-      ]
+      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        StatusLeft,
+        {
+          permissionMode,
+          modelName,
+          providerProfileName,
+          providerType,
+          isThinking,
+          activeToolCount,
+          activeBackgroundTaskCount,
+          hasPendingPrompt,
+          contextPercentage,
+          contextUsedTokens,
+          contextMaxTokens,
+          sessionName,
+          gitBranch,
+          showGitBranch
+        }
+      )
     }
   );
 }
@@ -2359,8 +2439,9 @@ function SessionStatusBar({
   cwd,
   permissionMode,
   modelId,
+  providerProfileName,
+  providerType,
   sessionId,
-  messageCount,
   isThinking,
   activeToolCount,
   activeBackgroundTaskCount,
@@ -2376,8 +2457,9 @@ function SessionStatusBar({
     {
       permissionMode,
       modelName: modelId ? (0, import_agent_core10.getModelName)(modelId) : "",
+      providerProfileName,
+      providerType,
       sessionId,
-      messageCount,
       isThinking,
       activeToolCount,
       activeBackgroundTaskCount,
@@ -3405,6 +3487,7 @@ function submitTextPromptValue(state, options) {
 var import_jsx_runtime13 = require("react/jsx-runtime");
 function TextPrompt({
   title,
+  description,
   placeholder,
   onSubmit,
   onCancel,
@@ -3429,12 +3512,11 @@ function TextPrompt({
   );
   (0, import_ink13.useInput)((input, key) => {
     const action = getTextPromptInputAction(input, key);
-    if (action !== void 0) {
-      applyAction(action);
-    }
+    if (action !== void 0) applyAction(action);
   });
   return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(PromptDescription, { description }),
     /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_ink13.Box, { marginTop: 1, children: [
       /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { color: "cyan", children: "> " }),
       state.value ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: placeholder }) : null,
@@ -3444,6 +3526,12 @@ function TextPrompt({
     /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: " Enter Submit Esc Cancel" })
   ] });
 }
+function PromptDescription({ description }) {
+  if (description === void 0 || description.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_ink13.Text, { dimColor: true, children: description });
+}
 
 // src/ui/InteractivePrompt.tsx
 var import_jsx_runtime14 = require("react/jsx-runtime");
@@ -3457,6 +3545,7 @@ function InteractivePrompt({
       TextPrompt,
       {
         title: prompt.title,
+        description: prompt.description,
         placeholder: prompt.placeholder,
         allowEmpty: prompt.allowEmpty,
         masked: prompt.masked,
@@ -3469,6 +3558,7 @@ function InteractivePrompt({
   }
   return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink14.Box, { flexDirection: "column", children: [
     /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink14.Text, { bold: true, children: prompt.title }),
+    prompt.description !== void 0 && prompt.description.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink14.Text, { dimColor: true, children: prompt.description }),
     /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       ListPicker,
       {
@@ -4059,26 +4149,20 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
 var import_ink18 = require("ink");
 var import_jsx_runtime19 = require("react/jsx-runtime");
 var SESSION_ID_DISPLAY_LENGTH = 8;
+var SESSION_PREVIEW_DISPLAY_LENGTH = 60;
 function SessionPicker({
-  sessionStore,
-  cwd,
+  sessions,
   onSelect,
   onCancel
 }) {
-  const sessions = (sessionStore?.list() ?? []).filter((s) => s.cwd === cwd);
   return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_ink18.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_ink18.Text, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
     /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
       ListPicker,
       {
-        items: sessions,
+        items: [...sessions],
         renderItem: (session, isSelected) => {
-          const lastMsg = session.messages.slice().reverse().find((m) => {
-            const msg = m;
-            return msg.role === "assistant" && msg.content;
-          });
-          const rawPreview = lastMsg?.content?.replace(/[\n\r]+/g, " ").trim() ?? "";
-          const preview = rawPreview ? rawPreview.slice(0, 60) + (rawPreview.length > 60 ? "..." : "") : "";
+          const preview = session.preview ? session.preview.slice(0, SESSION_PREVIEW_DISPLAY_LENGTH) + (session.preview.length > SESSION_PREVIEW_DISPLAY_LENGTH ? "..." : "") : "";
           return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_ink18.Text, { children: [
             isSelected ? "> " : "  ",
             /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_ink18.Text, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
@@ -4092,7 +4176,7 @@ function SessionPicker({
             "  ",
             /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_ink18.Text, { dimColor: true, children: [
               "msgs: ",
-              session.messages.length
+              session.messageCount
             ] }),
             preview ? /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_jsx_runtime19.Fragment, { children: [
               "\n    ",
@@ -4110,115 +4194,281 @@ function SessionPicker({
 // src/ui/BackgroundTaskPanel.tsx
 var import_ink19 = require("ink");
 
-// src/ui/background-task-row-format.ts
-var MS_PER_SECOND = 1e3;
-var SECONDS_PER_MINUTE = 60;
-var MINUTES_PER_HOUR = 60;
-var SUCCESS_EXIT_CODE3 = 0;
-function formatBackgroundTaskRow(task, options = {}) {
-  const row = {
-    connector: options.isLast === false ? "\u251C" : "\u2514",
-    marker: getStatusMarker(task),
-    color: getStatusColor(task),
-    label: getTaskLabel(task),
-    segments: getTaskSegments(task, options.now ?? Date.now()),
-    preview: getTaskPreview(task)
-  };
-  return {
-    ...row,
-    accessibleText: formatAccessibleText(row)
-  };
+// src/ui/execution-workspace-view-model.ts
+var ACTIVE_STATUSES = [
+  "active",
+  "queued",
+  "running",
+  "waiting_permission"
+];
+var DETAIL_RECORD_TEXT_LIMIT = 160;
+var PREVIEW_WHITESPACE = /\s+/g;
+var PREVIEW_SEPARATOR = " ";
+function getDefaultBackgroundWorkspaceEntries(snapshot) {
+  return (snapshot?.entries ?? []).filter(
+    (entry) => entry.kind === "background_task" && entry.visibility === "default"
+  );
 }
-function getStatusColor(task) {
-  if (isFailedTask(task)) return "red";
-  if (task.status === "completed") return "green";
-  if (task.status === "cancelled") return "yellow";
-  return "cyan";
+function countActiveBackgroundWorkspaceEntries(snapshot) {
+  return getDefaultBackgroundWorkspaceEntries(snapshot).filter(
+    (entry) => ACTIVE_STATUSES.includes(entry.status)
+  ).length;
 }
-function getStatusMarker(task) {
-  if (task.status === "queued" || task.status === "running") return "\u25A1";
-  return "\u25A0";
+function formatExecutionWorkspaceEntryRow(entry, options = {}) {
+  const isSelected = entry.id === options.selectedEntryId;
+  const row = {
+    id: entry.id,
+    radio: isSelected ? "\u25CF" : "\u25CB",
+    title: formatEntryTitle(entry),
+    subtitle: formatEntrySubtitle(entry),
+    statusLabel: formatStatusLabel2(entry.status),
+    preview: trimPreview(entry.preview ?? entry.currentAction),
+    color: getEntryColor(entry),
+    isSelected
+  };
+  return { ...row, accessibleText: formatAccessibleText(row) };
+}
+function formatExecutionDetailRecord(record) {
+  const text = record.text.trim().replace(PREVIEW_WHITESPACE, PREVIEW_SEPARATOR);
+  if (!text) return record.kind;
+  return text.length > DETAIL_RECORD_TEXT_LIMIT ? `${text.slice(0, DETAIL_RECORD_TEXT_LIMIT)}...` : text;
+}
+function formatEntryTitle(entry) {
+  if (entry.kind === "main_thread") return entry.title;
+  if (entry.kind === "background_group") return `${entry.title} group`;
+  if (entry.taskKind === "agent") return `${entry.title} agent`;
+  if (entry.taskKind === "process") return entry.title || "Process";
+  return entry.title;
+}
+function formatEntrySubtitle(entry) {
+  if (entry.kind === "main_thread") return entry.subtitle;
+  const parts = [
+    entry.taskKind,
+    entry.subtitle,
+    entry.attention === "none" ? void 0 : entry.attention
+  ];
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" \xB7 ") || void 0;
 }
-function getTaskLabel(task) {
-  if (task.kind === "agent") return `${task.label} agent`;
-  if (task.kind === "process") return task.label || "Process";
-  return task.label;
+function formatStatusLabel2(status) {
+  return status.replace(/_/g, " ");
 }
-function getTaskSegments(task, now) {
-  const segments = [];
-  if (task.status === "running") {
-    const idle = formatAge(task.lastActivityAt, now);
-    if (idle) segments.push(`idle ${idle}`);
-  }
-  if (task.status === "failed") {
-    segments.push(task.statusLabel === "timed out" ? "timed out" : "failed");
-  }
-  if (task.status === "cancelled") {
-    segments.push("cancelled");
-  }
-  if (task.timeoutReason) {
-    segments.push(task.timeoutReason);
-  }
-  if (task.status === "completed" && task.exitCode !== void 0 && task.exitCode !== SUCCESS_EXIT_CODE3) {
-    segments.push(`exit ${task.exitCode}`);
-  }
-  if (task.signalCode) {
-    segments.push(`signal ${task.signalCode}`);
-  }
-  if (task.worktreePath || task.branchName) {
-    segments.push("worktree");
-  }
-  return segments;
+function getEntryColor(entry) {
+  if (entry.attention === "failed" || entry.status === "failed") return "red";
+  if (entry.attention === "permission" || entry.status === "waiting_permission") return "yellow";
+  if (entry.status === "completed") return "green";
+  if (entry.status === "cancelled") return "yellow";
+  if (ACTIVE_STATUSES.includes(entry.status)) return "cyan";
+  return "white";
 }
-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;
+function trimPreview(value) {
+  const preview = value?.trim().replace(PREVIEW_WHITESPACE, PREVIEW_SEPARATOR);
   return preview || void 0;
 }
-function formatAge(iso, now) {
-  if (!iso) return void 0;
-  const timestamp = Date.parse(iso);
-  if (Number.isNaN(timestamp)) return void 0;
-  const seconds = Math.max(0, Math.floor((now - timestamp) / MS_PER_SECOND));
-  if (seconds < SECONDS_PER_MINUTE) return `${seconds}s`;
-  const minutes = Math.floor(seconds / SECONDS_PER_MINUTE);
-  if (minutes < MINUTES_PER_HOUR) return `${minutes}m`;
-  return `${Math.floor(minutes / MINUTES_PER_HOUR)}h`;
+function formatAccessibleText(row) {
+  const parts = [row.radio, row.title, row.statusLabel, row.subtitle, row.preview];
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" \xB7 ");
 }
-function isFailedTask(task) {
-  return task.status === "failed" || task.status === "completed" && (task.exitCode !== void 0 && task.exitCode !== SUCCESS_EXIT_CODE3 || !!task.signalCode);
+
+// src/ui/background-task-row-format.ts
+function formatBackgroundTaskRow(entry, options = {}) {
+  const row = formatExecutionWorkspaceEntryRow(entry);
+  const marker = isActiveEntry(entry) ? "\u25A1" : "\u25A0";
+  const segments = [row.statusLabel, row.subtitle].filter(
+    (segment) => typeof segment === "string" && segment.length > 0
+  );
+  return {
+    connector: options.isLast === false ? "\u251C" : "\u2514",
+    marker,
+    color: row.color,
+    label: row.title,
+    segments,
+    preview: row.preview,
+    accessibleText: [
+      `${options.isLast === false ? "\u251C" : "\u2514"} ${marker} ${row.title}`,
+      ...segments,
+      row.preview
+    ].filter((part) => typeof part === "string" && part.length > 0).join(" \xB7 ")
+  };
 }
-function formatAccessibleText(row) {
-  const parts = [`${row.connector} ${row.marker} ${row.label}`, ...row.segments];
-  if (row.preview) parts.push(row.preview);
-  return parts.join(" \xB7 ");
+function isActiveEntry(entry) {
+  return entry.status === "active" || entry.status === "queued" || entry.status === "running" || entry.status === "waiting_permission";
 }
 
 // src/ui/BackgroundTaskPanel.tsx
 var import_jsx_runtime20 = require("react/jsx-runtime");
-function BackgroundTaskPanel({ tasks }) {
-  if (tasks.length === 0) return null;
+function BackgroundTaskPanel({ entries }) {
+  if (entries.length === 0) return null;
   return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_ink19.Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { color: "cyan", bold: true, children: "Background work" }),
-    tasks.map((task, index) => {
-      const row = formatBackgroundTaskRow(task, { isLast: index === tasks.length - 1 });
+    entries.map((entry, index) => {
+      const row = formatBackgroundTaskRow(entry, { isLast: index === entries.length - 1 });
       return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_ink19.Text, { children: [
         `${row.connector} `,
         /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { color: row.color, children: row.marker }),
         ` ${row.label}`,
         row.segments.map((segment, segmentIndex) => /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { dimColor: true, children: ` \xB7 ${segment}` }, `${segment}-${segmentIndex}`)),
         row.preview ? /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { dimColor: true, children: ` \xB7 ${row.preview}` }) : null
-      ] }, task.id);
+      ] }, entry.id);
     })
   ] });
 }
 
-// src/ui/UpdateNotice.tsx
+// src/ui/ExecutionWorkspaceSwitcher.tsx
+var import_react19 = require("react");
 var import_ink20 = require("ink");
 var import_jsx_runtime21 = require("react/jsx-runtime");
+var MAX_VISIBLE_WORKSPACE_ENTRIES = 8;
+function ExecutionWorkspaceSwitcher({
+  snapshot,
+  selectedEntryId,
+  onSelect,
+  onClose
+}) {
+  const entries = [...snapshot?.entries ?? []];
+  const { normalized, visibleEntries, applyAction } = useWorkspaceSwitcherSelection({
+    entries,
+    selectedEntryId,
+    onSelect,
+    onClose
+  });
+  (0, import_ink20.useInput)((_input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) applyAction(action);
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_ink20.Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { color: "cyan", bold: true, children: "Execution workspace" }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Box, { flexDirection: "column", marginTop: 1, children: visibleEntries.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { dimColor: true, children: "No workspace entries" }) : visibleEntries.map((entry, index) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+      ExecutionWorkspaceSwitcherRow,
+      {
+        entry,
+        isFocused: normalized.scrollOffset + index === normalized.selectedIndex,
+        selectedEntryId
+      },
+      entry.id
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { dimColor: true, children: "Ctrl+B Close \u2191\u2193 Navigate Enter Switch Esc Close" })
+  ] });
+}
+function useWorkspaceSwitcherSelection({
+  entries,
+  selectedEntryId,
+  onSelect,
+  onClose
+}) {
+  const [state, setState] = (0, import_react19.useState)(() => createSelectionFlowState());
+  const stateRef = (0, import_react19.useRef)(state);
+  (0, import_react19.useEffect)(() => {
+    const selectedIndex = Math.max(
+      0,
+      entries.findIndex((entry) => entry.id === selectedEntryId)
+    );
+    const nextState = createNormalizedSelection({ selectedIndex, itemCount: entries.length });
+    stateRef.current = nextState;
+    setState(nextState);
+  }, [entries.length, selectedEntryId]);
+  const normalized = createNormalizedSelection({
+    selectedIndex: state.selectedIndex,
+    scrollOffset: state.scrollOffset,
+    itemCount: entries.length
+  });
+  if (normalized !== state) stateRef.current = normalized;
+  return {
+    normalized,
+    visibleEntries: entries.slice(
+      normalized.scrollOffset,
+      normalized.scrollOffset + MAX_VISIBLE_WORKSPACE_ENTRIES
+    ),
+    applyAction: createApplyAction({ entries, stateRef, setState, onSelect, onClose })
+  };
+}
+function createApplyAction({
+  entries,
+  stateRef,
+  setState,
+  onSelect,
+  onClose
+}) {
+  return (action) => {
+    const result = applySelectionInput(stateRef.current, action, {
+      itemCount: entries.length,
+      maxVisible: MAX_VISIBLE_WORKSPACE_ENTRIES
+    });
+    const nextState = result.effect.type === "select" || result.effect.type === "cancel" ? { ...result.state, resolved: false } : result.state;
+    stateRef.current = nextState;
+    setState(nextState);
+    if (result.effect.type === "cancel") {
+      onClose();
+    } else if (result.effect.type === "select") {
+      const entry = entries[result.effect.index];
+      if (entry) onSelect(entry.id);
+    }
+  };
+}
+function createNormalizedSelection(input) {
+  return normalizeSelectionState(
+    {
+      selectedIndex: input.selectedIndex,
+      scrollOffset: input.scrollOffset ?? 0,
+      resolved: false
+    },
+    { itemCount: input.itemCount, maxVisible: MAX_VISIBLE_WORKSPACE_ENTRIES }
+  );
+}
+function ExecutionWorkspaceSwitcherRow({
+  entry,
+  isFocused,
+  selectedEntryId
+}) {
+  const row = formatExecutionWorkspaceEntryRow(entry, { selectedEntryId });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_ink20.Text, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { color: isFocused ? "cyan" : void 0, bold: isFocused, children: isFocused ? "> " : "  " }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { color: row.color, children: row.radio }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { color: isFocused ? "cyan" : void 0, bold: isFocused, children: ` ${row.title}` }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { dimColor: true, children: ` \xB7 ${row.statusLabel}` }),
+    row.subtitle ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { dimColor: true, children: ` \xB7 ${row.subtitle}` }) : null,
+    row.preview ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { dimColor: true, children: ` \xB7 ${row.preview}` }) : null
+  ] });
+}
+
+// src/ui/ExecutionWorkspaceDetailPane.tsx
+var import_ink21 = require("ink");
+var import_jsx_runtime22 = require("react/jsx-runtime");
+var MAX_VISIBLE_DETAIL_RECORDS = 12;
+function ExecutionWorkspaceDetailPane({
+  entry,
+  page,
+  loading,
+  error
+}) {
+  const row = formatExecutionWorkspaceEntryRow(entry, { selectedEntryId: entry.id });
+  const records = page?.records.slice(-MAX_VISIBLE_DETAIL_RECORDS) ?? [];
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: "cyan", bold: true, children: `Viewing ${row.title}` }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Text, { dimColor: true, children: [
+      row.statusLabel,
+      row.subtitle ? ` \xB7 ${row.subtitle}` : "",
+      row.preview ? ` \xB7 ${row.preview}` : ""
+    ] }),
+    loading ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { dimColor: true, children: "Loading workspace detail..." }) : null,
+    error ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: "red", children: error }) : null,
+    !loading && !error && records.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { dimColor: true, children: "No detail yet" }) : null,
+    !loading && !error && records.map((record) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: getDetailRecordColor(record.kind), children: formatExecutionDetailRecord(record) }, record.id)),
+    page?.nextCursor ? /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { dimColor: true, children: "... more detail available" }) : null
+  ] });
+}
+function getDetailRecordColor(kind) {
+  if (kind === "error") return "red";
+  if (kind === "result") return "green";
+  if (kind === "process_output") return "white";
+  if (kind === "group_summary") return "cyan";
+  return void 0;
+}
+
+// src/ui/UpdateNotice.tsx
+var import_ink22 = require("ink");
+var import_jsx_runtime23 = require("react/jsx-runtime");
 function UpdateNotice({ message }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Box, { paddingX: 1, marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { color: "yellow", children: message }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_ink22.Box, { paddingX: 1, marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_ink22.Text, { color: "yellow", children: message }) });
 }
 
 // src/utils/update-check.ts
@@ -4313,10 +4563,10 @@ function comparePrereleaseIdentifier(left, right) {
 var CLI_UPDATE_PACKAGE_NAME = "@robota-sdk/agent-cli";
 var CLI_UPDATE_REGISTRY_URL = "https://registry.npmjs.org";
 var HOURS_PER_DAY = 24;
-var MINUTES_PER_HOUR2 = 60;
-var SECONDS_PER_MINUTE2 = 60;
-var MS_PER_SECOND2 = 1e3;
-var CLI_UPDATE_CACHE_TTL_MS = HOURS_PER_DAY * MINUTES_PER_HOUR2 * SECONDS_PER_MINUTE2 * MS_PER_SECOND2;
+var MINUTES_PER_HOUR = 60;
+var SECONDS_PER_MINUTE = 60;
+var MS_PER_SECOND = 1e3;
+var CLI_UPDATE_CACHE_TTL_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
 var CLI_UPDATE_TIMEOUT_MS = 1500;
 var DEFAULT_INSTALL_COMMAND = "npm install -g '@robota-sdk/agent-cli@latest'";
 function getUserUpdateCheckCachePath(home = process.env.HOME ?? process.env.USERPROFILE ?? "/") {
@@ -4485,15 +4735,22 @@ function isJsonObject(value) {
 }
 
 // src/ui/App.tsx
-var import_jsx_runtime22 = require("react/jsx-runtime");
+var import_jsx_runtime24 = require("react/jsx-runtime");
 function App(props) {
-  const [activeSessionId, setActiveSessionId] = (0, import_react19.useState)(props.resumeSessionId);
-  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+  const [activeSessionId, setActiveSessionId] = (0, import_react20.useState)(props.resumeSessionId);
+  const [showInitialSessionPicker, setShowInitialSessionPicker] = (0, import_react20.useState)(
+    props.showSessionPickerOnStart ?? false
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
     AppInner,
     {
       ...props,
+      showSessionPickerOnStart: showInitialSessionPicker,
       resumeSessionId: activeSessionId,
-      onSessionSwitch: (sessionId) => setActiveSessionId(sessionId)
+      onSessionSwitch: (sessionId) => {
+        setShowInitialSessionPicker(false);
+        setActiveSessionId(sessionId);
+      }
     },
     activeSessionId ?? "__new__"
   );
@@ -4503,6 +4760,7 @@ function AppInner(props) {
   const {
     interactiveSession,
     registry,
+    commandEffectQueue,
     history,
     addEntry,
     streamingText,
@@ -4511,7 +4769,10 @@ function AppInner(props) {
     isAborting,
     isShuttingDown,
     pendingPrompt,
-    backgroundTasks,
+    executionWorkspaceSnapshot,
+    selectedExecutionEntryId,
+    selectExecutionWorkspaceEntry,
+    readExecutionWorkspaceDetail,
     permissionRequest,
     contextState,
     handleSubmit: baseHandleSubmit,
@@ -4530,17 +4791,31 @@ function AppInner(props) {
     backgroundTaskRunners: props.backgroundTaskRunners,
     subagentRunnerFactory: props.subagentRunnerFactory,
     commandModules: props.commandModules,
-    commandHostAdapters: props.commandHostAdapters
+    commandHostAdapters: props.commandHostAdapters,
+    webPort: props.webPort,
+    noOpen: props.noOpen
   });
   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)();
+  const { exit } = (0, import_ink23.useApp)();
+  const [sessionName, setSessionName] = (0, import_react20.useState)(props.sessionName);
+  const [updateNotice, setUpdateNotice] = (0, import_react20.useState)();
+  const [showExecutionWorkspaceSwitcher, setShowExecutionWorkspaceSwitcher] = (0, import_react20.useState)(false);
+  const [executionDetailPage, setExecutionDetailPage] = (0, import_react20.useState)(null);
+  const [executionDetailError, setExecutionDetailError] = (0, import_react20.useState)();
+  const [isExecutionDetailLoading, setIsExecutionDetailLoading] = (0, import_react20.useState)(false);
   const [statusLineSettings, setStatusLineSettings] = useStatusLineSettings();
-  const activeBackgroundTaskCount = backgroundTasks.filter(
-    (task) => task.status === "queued" || task.status === "running"
-  ).length;
+  const backgroundWorkspaceEntries = (0, import_react20.useMemo)(
+    () => getDefaultBackgroundWorkspaceEntries(executionWorkspaceSnapshot),
+    [executionWorkspaceSnapshot]
+  );
+  const activeBackgroundTaskCount = countActiveBackgroundWorkspaceEntries(
+    executionWorkspaceSnapshot
+  );
+  const selectedExecutionEntry = (0, import_react20.useMemo)(
+    () => executionWorkspaceSnapshot?.entries.find((entry) => entry.id === selectedExecutionEntryId),
+    [executionWorkspaceSnapshot, selectedExecutionEntryId]
+  );
   const {
     handleSubmit,
     pendingModelId,
@@ -4556,16 +4831,18 @@ function AppInner(props) {
     cwd,
     providerOverride: props.providerOverride,
     interactiveSession,
+    commandEffectQueue,
     addEntry,
     baseHandleSubmit,
     setSessionName,
-    setStatusLineSettings
+    setStatusLineSettings,
+    showSessionPickerOnStart: props.showSessionPickerOnStart
   });
-  (0, import_react19.useEffect)(() => {
+  (0, import_react20.useEffect)(() => {
     const name = interactiveSession?.getName?.();
     if (name && !sessionName) setSessionName(name);
   }, [interactiveSession, sessionName]);
-  (0, import_react19.useEffect)(() => {
+  (0, import_react20.useEffect)(() => {
     let isMounted = true;
     props.startupUpdateNoticePromise?.then((notice) => {
       if (isMounted && notice !== void 0) {
@@ -4577,20 +4854,27 @@ function AppInner(props) {
       isMounted = false;
     };
   }, [props.startupUpdateNoticePromise]);
-  (0, import_react19.useEffect)(() => {
+  (0, import_react20.useEffect)(() => {
     const title = sessionName ? `Robota \u2014 ${sessionName}` : "Robota";
     process.stdout.write(`\x1B]0;${title}\x07`);
   }, [sessionName]);
-  (0, import_ink21.useInput)((_input, key) => {
+  (0, import_ink23.useInput)((_input, key) => {
     if (!key.escape || !isThinking) return;
-    if (permissionRequest || showPluginTUI || showSessionPicker) return;
+    if (permissionRequest || showPluginTUI || showSessionPicker || showExecutionWorkspaceSwitcher) {
+      return;
+    }
     handleAbort();
   });
-  (0, import_ink21.useInput)((input, key) => {
+  (0, import_ink23.useInput)((input, key) => {
+    if (!key.ctrl || input !== "b") return;
+    if (permissionRequest || showPluginTUI || showSessionPicker || isShuttingDown) return;
+    setShowExecutionWorkspaceSwitcher((shown) => !shown);
+  });
+  (0, import_ink23.useInput)((input, key) => {
     if (!key.ctrl || input !== "c" || isShuttingDown) return;
     void handleShutdown("prompt_input_exit").finally(() => exit());
   });
-  (0, import_react19.useEffect)(() => {
+  (0, import_react20.useEffect)(() => {
     const onSigterm = () => {
       if (isShuttingDown) return;
       void handleShutdown("other").finally(() => exit());
@@ -4602,6 +4886,29 @@ function AppInner(props) {
       process.off("SIGTERM", onSigterm);
     };
   }, [handleShutdown, exit, isShuttingDown]);
+  (0, import_react20.useEffect)(() => {
+    if (!selectedExecutionEntry || selectedExecutionEntry.kind === "main_thread") {
+      setExecutionDetailPage(null);
+      setExecutionDetailError(void 0);
+      setIsExecutionDetailLoading(false);
+      return;
+    }
+    let isCurrent = true;
+    setIsExecutionDetailLoading(true);
+    setExecutionDetailError(void 0);
+    readExecutionWorkspaceDetail(selectedExecutionEntry.id).then((page) => {
+      if (!isCurrent) return;
+      setExecutionDetailPage(page);
+      setIsExecutionDetailLoading(false);
+    }).catch((error) => {
+      if (!isCurrent) return;
+      setExecutionDetailError(error.message);
+      setIsExecutionDetailLoading(false);
+    });
+    return () => {
+      isCurrent = false;
+    };
+  }, [executionWorkspaceSnapshot, readExecutionWorkspaceDetail, selectedExecutionEntry]);
   let permissionMode = props.permissionMode ?? "default";
   let sessionId = "";
   try {
@@ -4610,25 +4917,33 @@ function AppInner(props) {
     sessionId = session.getSessionId();
   } catch {
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: "cyan", bold: true, children: `
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_ink23.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_ink23.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink23.Text, { color: "cyan", bold: true, children: `
   ____   ___  ____   ___ _____  _
  |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
  | |_) | | | |  _ \\| | | || | / _ \\
  |  _ <| |_| | |_) | |_| || |/ ___ \\
  |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
 ` }),
-      /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Text, { dimColor: true, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_ink23.Text, { dimColor: true, children: [
         " v",
         props.version ?? "0.0.0"
       ] })
     ] }),
-    updateNotice && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(UpdateNotice, { message: formatCliUpdateNotice(updateNotice) }),
-    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_ink21.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(MessageList, { history }),
-      isShuttingDown && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { color: "yellow", children: "Shutting down..." }) }),
-      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    updateNotice && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(UpdateNotice, { message: formatCliUpdateNotice(updateNotice) }),
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_ink23.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      selectedExecutionEntry && selectedExecutionEntry.kind !== "main_thread" ? /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+        ExecutionWorkspaceDetailPane,
+        {
+          entry: selectedExecutionEntry,
+          page: executionDetailPage,
+          loading: isExecutionDetailLoading,
+          error: executionDetailError
+        }
+      ) : /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MessageList, { history }),
+      isShuttingDown && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink23.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink23.Text, { color: "yellow", children: "Shutting down..." }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink23.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
         StreamingIndicator,
         {
           text: streamingText,
@@ -4636,17 +4951,26 @@ function AppInner(props) {
           isThinking
         }
       ) }),
-      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(BackgroundTaskPanel, { tasks: backgroundTasks })
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(BackgroundTaskPanel, { entries: backgroundWorkspaceEntries })
     ] }),
-    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(PermissionPrompt, { request: permissionRequest }),
-    pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    showExecutionWorkspaceSwitcher && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+      ExecutionWorkspaceSwitcher,
+      {
+        snapshot: executionWorkspaceSnapshot,
+        selectedEntryId: selectedExecutionEntryId,
+        onSelect: selectExecutionWorkspaceEntry,
+        onClose: () => setShowExecutionWorkspaceSwitcher(false)
+      }
+    ),
+    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       ConfirmPrompt,
       {
         message: formatModelChangeConfirmationMessage(pendingModelId),
         onSelect: handleModelConfirm
       }
     ),
-    pendingInteractionPrompt && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    pendingInteractionPrompt && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       InteractivePrompt,
       {
         prompt: pendingInteractionPrompt,
@@ -4654,7 +4978,7 @@ function AppInner(props) {
         onCancel: handleInteractionCancel
       }
     ),
-    showPluginTUI && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    showPluginTUI && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       PluginTUI,
       {
         callbacks: pluginCallbacks,
@@ -4662,11 +4986,10 @@ function AppInner(props) {
         addMessage: (msg) => addEntry((0, import_agent_core11.messageToHistoryEntry)((0, import_agent_core11.createSystemMessage)(msg.content)))
       }
     ),
-    showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       SessionPicker,
       {
-        sessionStore: props.sessionStore,
-        cwd: props.cwd,
+        sessions: (0, import_agent_sdk9.listResumableSessionSummaries)(props.sessionStore, props.cwd),
         onSelect: (id) => {
           setShowSessionPicker(false);
           props.onSessionSwitch(id);
@@ -4677,14 +5000,15 @@ function AppInner(props) {
         }
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       SessionStatusBar,
       {
         cwd,
         permissionMode,
         modelId: props.modelId,
+        providerProfileName: props.providerProfileName,
+        providerType: props.providerType,
         sessionId,
-        messageCount: history.length,
         isThinking,
         activeToolCount: activeTools.length,
         activeBackgroundTaskCount,
@@ -4694,12 +5018,12 @@ function AppInner(props) {
         settings: statusLineSettings
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       InputArea,
       {
         onSubmit: handleSubmit,
         onCancelQueue: handleCancelQueue,
-        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || isShuttingDown || pendingInteractionPrompt !== null || isThinking && !!pendingPrompt,
+        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || showExecutionWorkspaceSwitcher || isShuttingDown || pendingInteractionPrompt !== null || isThinking && !!pendingPrompt,
         isAborting,
         pendingPrompt,
         registry,
@@ -4707,12 +5031,12 @@ function AppInner(props) {
         history
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_ink21.Text, { children: " " })
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink23.Text, { children: " " })
   ] });
 }
 
 // src/ui/render.tsx
-var import_jsx_runtime23 = require("react/jsx-runtime");
+var import_jsx_runtime25 = require("react/jsx-runtime");
 function renderApp(options) {
   process.on("unhandledRejection", (reason) => {
     process.stderr.write(`
@@ -4723,7 +5047,7 @@ function renderApp(options) {
 `);
     }
   });
-  const instance = (0, import_ink22.render)(/* @__PURE__ */ (0, import_jsx_runtime23.jsx)(App, { ...options }), {
+  const instance = (0, import_ink24.render)(/* @__PURE__ */ (0, import_jsx_runtime25.jsx)(App, { ...options }), {
     exitOnCtrlC: false
   });
   instance.waitUntilExit().then(() => {
@@ -4740,43 +5064,14 @@ function renderApp(options) {
 
 // src/background/managed-shell-process-runner.ts
 var import_node_child_process = require("child_process");
-var import_agent_sdk9 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk10 = require("@robota-sdk/agent-sdk");
 var DEFAULT_OUTPUT_LIMIT_BYTES = 3e4;
 var DEFAULT_KILL_GRACE_MS = 2e3;
-var LOG_PAGE_SIZE = 200;
-function createCapture(limitBytes) {
-  const chunks = [];
-  let capturedBytes = 0;
-  let truncated = false;
-  return {
-    appendOutput(text) {
-      if (truncated) return;
-      const remaining = limitBytes - capturedBytes;
-      const buffer = Buffer.from(text, "utf8");
-      if (buffer.byteLength <= remaining) {
-        chunks.push(text);
-        capturedBytes += buffer.byteLength;
-        return;
-      }
-      chunks.push(buffer.subarray(0, Math.max(remaining, 0)).toString("utf8"));
-      chunks.push("\n[output truncated]\n");
-      truncated = true;
-    },
-    getOutput() {
-      return chunks.join("");
-    }
-  };
-}
-function appendLog(lines, source, text) {
-  for (const line of text.split(/\r?\n/)) {
-    if (line.length > 0) lines.push(`[${source}] ${line}`);
-  }
-}
 function resolveShell(request) {
   return { command: request.shell ?? "sh", args: ["-c", request.command] };
 }
 function sendInput(child, input) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const onError = (error) => {
       child.stdin.off("error", onError);
       reject(error);
@@ -4784,7 +5079,7 @@ function sendInput(child, input) {
     child.stdin.once("error", onError);
     child.stdin.end(input, () => {
       child.stdin.off("error", onError);
-      resolve2();
+      resolve3();
     });
   });
 }
@@ -4794,7 +5089,7 @@ function createManagedShellProcessRunner(options = {}) {
     kind: "process",
     start(task) {
       if (task.request.kind !== "process") {
-        throw new import_agent_sdk9.BackgroundTaskError("runner", `Invalid process task kind: ${task.request.kind}`);
+        throw new import_agent_sdk10.BackgroundTaskError("runner", `Invalid process task kind: ${task.request.kind}`);
       }
       return startProcessTask(task.taskId, task.request, killGraceMs);
     }
@@ -4811,7 +5106,9 @@ function startProcessTask(taskId, request, killGraceMs) {
       stdio: ["pipe", "pipe", "pipe"]
     }),
     logs: [],
-    capture: createCapture(request.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES),
+    capture: (0, import_agent_sdk10.createLimitedOutputCapture)({
+      limitBytes: request.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES
+    }),
     killGraceMs
   };
   const result = createProcessResult(runtime);
@@ -4819,11 +5116,15 @@ function startProcessTask(taskId, request, killGraceMs) {
 }
 function createProcessResult(runtime) {
   let settled = false;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const timeoutTimer = runtime.request.timeoutMs ? setTimeout(() => {
-      appendLog(runtime.logs, "system", `timed out after ${runtime.request.timeoutMs}ms`);
+      (0, import_agent_sdk10.appendPrefixedLogLines)(
+        runtime.logs,
+        "system",
+        `timed out after ${runtime.request.timeoutMs}ms`
+      );
       runtime.child.kill("SIGTERM");
-      rejectOnceLocal(new import_agent_sdk9.BackgroundTaskError("timeout", "Background process timed out"));
+      rejectOnceLocal(new import_agent_sdk10.BackgroundTaskError("timeout", "Background process timed out"));
     }, runtime.request.timeoutMs) : void 0;
     function clearTimers() {
       if (timeoutTimer) clearTimeout(timeoutTimer);
@@ -4833,7 +5134,7 @@ function createProcessResult(runtime) {
       if (settled) return;
       settled = true;
       clearTimers();
-      resolve2({
+      resolve3({
         taskId: runtime.taskId,
         kind: "process",
         output: runtime.capture.getOutput(),
@@ -4849,8 +5150,8 @@ function createProcessResult(runtime) {
     }
     attachOutputListeners(runtime);
     runtime.child.on("error", (error) => {
-      appendLog(runtime.logs, "system", error.message);
-      rejectOnceLocal(new import_agent_sdk9.BackgroundTaskError("process", error.message));
+      (0, import_agent_sdk10.appendPrefixedLogLines)(runtime.logs, "system", error.message);
+      rejectOnceLocal(new import_agent_sdk10.BackgroundTaskError("process", error.message));
     });
     runtime.child.on("close", (code, signal) => {
       resolveOnce(code ?? void 0, signal ?? void 0);
@@ -4880,40 +5181,37 @@ function attachOutputListeners(runtime) {
   runtime.child.stdout.on("data", (chunk) => {
     const text = chunk.toString("utf8");
     runtime.capture.appendOutput(text);
-    appendLog(runtime.logs, "stdout", text);
+    (0, import_agent_sdk10.appendPrefixedLogLines)(runtime.logs, "stdout", text);
   });
   runtime.child.stderr.on("data", (chunk) => {
     const text = chunk.toString("utf8");
     runtime.capture.appendOutput(text);
-    appendLog(runtime.logs, "stderr", text);
+    (0, import_agent_sdk10.appendPrefixedLogLines)(runtime.logs, "stderr", text);
   });
 }
 function cancelProcess(runtime, reason) {
-  appendLog(runtime.logs, "system", reason ? `cancel requested: ${reason}` : "cancel requested");
+  (0, import_agent_sdk10.appendPrefixedLogLines)(
+    runtime.logs,
+    "system",
+    reason ? `cancel requested: ${reason}` : "cancel requested"
+  );
   if (!runtime.child.killed) runtime.child.kill("SIGTERM");
   runtime.killTimer = setTimeout(() => {
     if (!runtime.child.killed) runtime.child.kill("SIGKILL");
   }, runtime.killGraceMs);
 }
 function readProcessLog(runtime, cursor) {
-  const offset = cursor?.offset ?? 0;
-  const nextOffset = Math.min(offset + LOG_PAGE_SIZE, runtime.logs.length);
-  return {
-    taskId: runtime.taskId,
-    cursor,
-    nextCursor: nextOffset < runtime.logs.length ? { offset: nextOffset } : void 0,
-    lines: runtime.logs.slice(offset, nextOffset)
-  };
+  return (0, import_agent_sdk10.createBackgroundTaskLogPage)(runtime.taskId, runtime.logs, cursor);
 }
 
 // src/subagents/child-process-subagent-runner.ts
 var import_node_child_process3 = require("child_process");
 var import_node_fs7 = require("fs");
 var import_node_path9 = require("path");
-var import_agent_sdk13 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk14 = require("@robota-sdk/agent-sdk");
 
 // src/subagents/child-process-subagent-runner-result.ts
-var import_agent_sdk11 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk12 = require("@robota-sdk/agent-sdk");
 
 // src/subagents/child-process-subagent-ipc.ts
 function isRecord2(value) {
@@ -4945,7 +5243,7 @@ function isSubagentWorkerChildMessage(value) {
 }
 
 // src/subagents/child-process-subagent-transport.ts
-var import_agent_sdk10 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk11 = require("@robota-sdk/agent-sdk");
 function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit) {
   switch (message.type) {
     case "ready":
@@ -4955,10 +5253,10 @@ function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit
       resolveOnce(message.output);
       break;
     case "error":
-      rejectOnce(new import_agent_sdk10.BackgroundTaskError("runner", message.message));
+      rejectOnce(new import_agent_sdk11.BackgroundTaskError("runner", message.message));
       break;
     case "cancelled":
-      rejectOnce(new import_agent_sdk10.BackgroundTaskError("runner", message.reason ?? "Subagent worker cancelled"));
+      rejectOnce(new import_agent_sdk11.BackgroundTaskError("runner", message.reason ?? "Subagent worker cancelled"));
       break;
     case "text_delta":
       emit?.({ type: "background_task_text_delta", delta: message.delta });
@@ -4978,7 +5276,7 @@ function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit
       });
       break;
     default:
-      rejectOnce(new import_agent_sdk10.BackgroundTaskError("runner", "Unhandled subagent worker message"));
+      rejectOnce(new import_agent_sdk11.BackgroundTaskError("runner", "Unhandled subagent worker message"));
   }
 }
 function extractFirstArg(toolArgs) {
@@ -4988,9 +5286,9 @@ function extractFirstArg(toolArgs) {
   return typeof firstValue === "object" ? JSON.stringify(firstValue) : String(firstValue);
 }
 function sendWorkerMessage(child, message) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     if (!child.connected) {
-      reject(new import_agent_sdk10.BackgroundTaskError("crash", "Subagent worker IPC channel is closed"));
+      reject(new import_agent_sdk11.BackgroundTaskError("crash", "Subagent worker IPC channel is closed"));
       return;
     }
     child.send(message, (error) => {
@@ -4998,7 +5296,7 @@ function sendWorkerMessage(child, message) {
         reject(error);
         return;
       }
-      resolve2();
+      resolve3();
     });
   });
 }
@@ -5015,14 +5313,14 @@ async function cancelChildProcess(runtime, reason) {
 
 // src/subagents/child-process-subagent-runner-result.ts
 function createChildProcessSubagentResult(options) {
-  return new Promise((resolve2, reject) => {
-    new ChildProcessSubagentResultController(options, resolve2, reject).start();
+  return new Promise((resolve3, reject) => {
+    new ChildProcessSubagentResultController(options, resolve3, reject).start();
   });
 }
 var ChildProcessSubagentResultController = class {
-  constructor(options, resolve2, reject) {
+  constructor(options, resolve3, reject) {
     this.options = options;
-    this.resolve = resolve2;
+    this.resolve = resolve3;
     this.reject = reject;
     this.timeoutTimer = createTimeoutTimer(this.options.runtime, (error) => this.rejectOnce(error));
   }
@@ -5051,7 +5349,7 @@ var ChildProcessSubagentResultController = class {
   onMessage = (message) => {
     if (!isSubagentWorkerChildMessage(message)) {
       this.rejectOnce(
-        new import_agent_sdk11.BackgroundTaskError("runner", "Received malformed subagent worker message")
+        new import_agent_sdk12.BackgroundTaskError("runner", "Received malformed subagent worker message")
       );
       return;
     }
@@ -5059,11 +5357,11 @@ var ChildProcessSubagentResultController = class {
     handleWorkerMessage(message, this.startWorker, this.resolveOnce, this.rejectOnce, job.emit);
   };
   onError = (error) => {
-    this.rejectOnce(new import_agent_sdk11.BackgroundTaskError("crash", error.message));
+    this.rejectOnce(new import_agent_sdk12.BackgroundTaskError("crash", error.message));
   };
   onExit = (code, signal) => {
     if (this.settled) return;
-    this.rejectOnce(new import_agent_sdk11.BackgroundTaskError("crash", formatEarlyExitMessage(code, signal)));
+    this.rejectOnce(new import_agent_sdk12.BackgroundTaskError("crash", formatEarlyExitMessage(code, signal)));
   };
   resolveOnce = (output) => {
     if (this.settled) return;
@@ -5103,7 +5401,7 @@ function createCancellationResult(jobId) {
     reject(reason) {
       if (settled) return;
       settled = true;
-      rejectFn(new import_agent_sdk11.BackgroundTaskError("runner", reason ?? `Subagent job cancelled: ${jobId}`));
+      rejectFn(new import_agent_sdk12.BackgroundTaskError("runner", reason ?? `Subagent job cancelled: ${jobId}`));
     }
   };
 }
@@ -5111,7 +5409,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_sdk11.BackgroundTaskError("timeout", "Subagent worker timed out"));
+    rejectOnce(new import_agent_sdk12.BackgroundTaskError("timeout", "Subagent worker timed out"));
   }, runtime.job.request.timeoutMs);
 }
 function toSubagentResult(job, output, resolveTranscriptPath) {
@@ -5129,10 +5427,10 @@ function formatEarlyExitMessage(code, signal) {
 
 // src/subagents/git-worktree-isolation-adapter.ts
 var import_node_child_process2 = require("child_process");
-var import_node_crypto2 = require("crypto");
+var import_node_crypto = require("crypto");
 var import_node_fs6 = require("fs");
 var import_node_path8 = require("path");
-var import_agent_sdk12 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk13 = require("@robota-sdk/agent-sdk");
 var WORKTREE_DIR = ".robota/worktrees";
 var BRANCH_PREFIX = "robota";
 var GIT_ENCODING = "utf8";
@@ -5155,7 +5453,7 @@ var GitWorktreeIsolationAdapter = class {
   }
   prepare(request) {
     if (this.maxCreateAttempts < 1) {
-      throw new import_agent_sdk12.BackgroundTaskError("runner", "Git worktree creation attempts must be at least 1");
+      throw new import_agent_sdk13.BackgroundTaskError("runner", "Git worktree creation attempts must be at least 1");
     }
     const repoRoot = resolveRepoRoot(request.cwd);
     const baseRevision = runGit(repoRoot, ["rev-parse", "HEAD"]).trim();
@@ -5176,7 +5474,7 @@ var GitWorktreeIsolationAdapter = class {
         if (!isCollisionError(lastError)) throw lastError;
       }
     }
-    throw new import_agent_sdk12.BackgroundTaskError(
+    throw new import_agent_sdk13.BackgroundTaskError(
       "runner",
       `Unable to create Git worktree after ${this.maxCreateAttempts} attempts due to branch or path collisions. Last error: ${lastError?.message ?? "unknown error"}`
     );
@@ -5202,7 +5500,7 @@ function runGit(cwd, args) {
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new import_agent_sdk12.BackgroundTaskError("runner", `git ${args.join(" ")} failed: ${message}`);
+    throw new import_agent_sdk13.BackgroundTaskError("runner", `git ${args.join(" ")} failed: ${message}`);
   }
 }
 function createGitEnvironment() {
@@ -5219,14 +5517,14 @@ function resolveRepoRoot(cwd) {
     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(
+    throw new import_agent_sdk13.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);
+  return (0, import_node_crypto.randomUUID)().slice(0, SHORT_ID_LENGTH);
 }
 function normalizeShortId(value) {
   const sanitized = sanitizePathSegment(value).slice(0, SHORT_ID_LENGTH);
@@ -5245,12 +5543,11 @@ function isCollisionError(error) {
 
 // src/subagents/child-process-subagent-runner.ts
 var DEFAULT_KILL_GRACE_MS2 = 2e3;
-var LOG_PAGE_SIZE2 = 200;
 function createChildProcessSubagentRunnerFactory(options = {}) {
   return (deps) => {
     const runner = new ChildProcessSubagentRunner(deps, options);
     if (options.worktreeIsolation === false) return runner;
-    return (0, import_agent_sdk13.createWorktreeSubagentRunner)({
+    return (0, import_agent_sdk14.createWorktreeSubagentRunner)({
       runner,
       worktreeAdapter: options.worktreeAdapter ?? createGitWorktreeIsolationAdapter(),
       hooks: deps.config.hooks,
@@ -5332,9 +5629,9 @@ var ChildProcessSubagentRunner = class {
   }
 };
 function resolveAgentDefinition(agentType, customRegistry) {
-  const definition = customRegistry?.(agentType) ?? (0, import_agent_sdk13.getBuiltInAgent)(agentType);
+  const definition = customRegistry?.(agentType) ?? (0, import_agent_sdk14.getBuiltInAgent)(agentType);
   if (!definition) {
-    throw new import_agent_sdk13.BackgroundTaskError("validation", `Unknown agent type: ${agentType}`);
+    throw new import_agent_sdk14.BackgroundTaskError("validation", `Unknown agent type: ${agentType}`);
   }
   return definition;
 }
@@ -5383,7 +5680,6 @@ function resolveDefaultExecArgv(workerPath) {
   return [...process.execArgv, "--import", "tsx"];
 }
 function readTranscriptLog(jobId, transcriptPath, cursor) {
-  const offset = cursor?.offset ?? 0;
   if (!(0, import_node_fs7.existsSync)(transcriptPath)) {
     return {
       taskId: jobId,
@@ -5392,13 +5688,30 @@ function readTranscriptLog(jobId, transcriptPath, cursor) {
     };
   }
   const lines = (0, import_node_fs7.readFileSync)(transcriptPath, "utf8").split(/\r?\n/).filter(Boolean);
-  const nextOffset = Math.min(offset + LOG_PAGE_SIZE2, lines.length);
-  return {
-    taskId: jobId,
-    cursor,
-    nextCursor: nextOffset < lines.length ? { offset: nextOffset } : void 0,
-    lines: lines.slice(offset, nextOffset)
-  };
+  return (0, import_agent_sdk14.createBackgroundTaskLogPage)(jobId, lines, cursor);
+}
+
+// src/user-local-direct-command.ts
+var import_agent_command_user_local = require("@robota-sdk/agent-command-user-local");
+async function runUserLocalDirectCommandIfRequested(args, cwd) {
+  if (args.positional[0] !== "user-local") {
+    return false;
+  }
+  const result = await (0, import_agent_command_user_local.executeUserLocalDirectCommand)({
+    cwd,
+    argv: args.positional.slice(1),
+    format: args.format,
+    summary: args.summary,
+    source: args.source
+  });
+  const output = result.message.endsWith("\n") ? result.message : `${result.message}
+`;
+  if (!result.success) {
+    process.stderr.write(output);
+    process.exit(1);
+  }
+  process.stdout.write(output);
+  return true;
 }
 
 // src/cli.ts
@@ -5424,11 +5737,19 @@ function readVersion() {
   }
 }
 function promptInput(label, masked = false) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3, reject) => {
     process.stdout.write(label);
     let input = "";
     const stdin = process.stdin;
     const wasRaw = stdin.isRaw;
+    if (!stdin.isTTY) {
+      reject(
+        new Error(
+          "Cannot prompt for input: stdin is not a TTY.\nSet your API key via environment variable instead:\n  ANTHROPIC_API_KEY=<key> robota\n  OPENAI_API_KEY=<key> robota"
+        )
+      );
+      return;
+    }
     stdin.setRawMode(true);
     stdin.resume();
     stdin.setEncoding("utf8");
@@ -5439,7 +5760,7 @@ function promptInput(label, masked = false) {
           stdin.setRawMode(wasRaw ?? false);
           stdin.pause();
           process.stdout.write("\n");
-          resolve2(input.trim());
+          resolve3(input.trim());
           return;
         } else if (ch === "\x7F" || ch === "\b") {
           if (input.length > 0) {
@@ -5458,6 +5779,15 @@ function promptInput(label, masked = false) {
     stdin.on("data", onData);
   });
 }
+function readTaskFilePrompt(cwd, taskFile) {
+  const taskPath = (0, import_node_path10.resolve)(cwd, taskFile);
+  const content = (0, import_node_fs8.readFileSync)(taskPath, "utf8").trim();
+  if (content.length === 0) {
+    throw new Error(`Task file is empty: ${taskFile}`);
+  }
+  return `Task file (${taskFile}):
+${content}`;
+}
 function resetConfig() {
   const userPath = getUserSettingsPath();
   if (deleteSettings(userPath)) {
@@ -5467,6 +5797,43 @@ function resetConfig() {
     process.stdout.write("No user settings found.\n");
   }
 }
+function createDefaultCliCommandModules({
+  cwd,
+  providerDefinitions
+}) {
+  return [
+    (0, import_agent_command_skills.createSkillsCommandModule)({ cwd }),
+    (0, import_agent_command_help.createHelpCommandModule)(),
+    (0, import_agent_command_agent.createAgentCommandModule)(),
+    (0, import_agent_command_model.createModelCommandModule)({
+      providerDefinitions,
+      settings: {
+        readMergedSettings: () => readMergedProviderSettings(cwd)
+      }
+    }),
+    (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_user_local2.createUserLocalCommandModule)(),
+    (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(resolveProviderSettingsWriteTargetPath(cwd)),
+        writeTargetSettings: (settings) => writeSettings(resolveProviderSettingsWriteTargetPath(cwd), settings)
+      }
+    })
+  ];
+}
 async function startCli(options = {}) {
   const args = parseCliArgs();
   const version = readVersion();
@@ -5492,6 +5859,9 @@ async function startCli(options = {}) {
     return;
   }
   const cwd = process.cwd();
+  if (await runUserLocalDirectCommandIfRequested(args, cwd)) {
+    return;
+  }
   const commandHostAdapters = {
     settings: {
       read: () => readSettings(getUserSettingsPath()),
@@ -5501,30 +5871,7 @@ async function startCli(options = {}) {
   };
   const providerDefinitions = options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
   const commandModules = [
-    (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)
-      }
-    }),
+    ...createDefaultCliCommandModules({ cwd, providerDefinitions }),
     ...options.commandModules ?? []
   ];
   const startupUpdateNoticePromise = shouldRunStartupCliUpdateCheck(args) ? getStartupCliUpdateNotice({ currentVersion: version }) : void 0;
@@ -5543,31 +5890,28 @@ async function startCli(options = {}) {
     process.exit(1);
   }
   const providerOptions = args.provider ? { providerOverride: args.provider, providerDefinitions } : { providerDefinitions };
+  const activeProviderSettings = readMergedProviderSettings(cwd);
+  const providerProfileName = args.provider ?? activeProviderSettings.currentProvider;
   const providerSettings = readProviderSettings(cwd, providerOptions);
   const modelId = args.model ?? providerSettings.model;
   const provider = createProviderFromSettings(cwd, args.model, providerOptions);
   const backgroundTaskRunners = [createManagedShellProcessRunner()];
-  const paths = (0, import_agent_sdk14.projectPaths)(cwd);
+  const paths = (0, import_agent_sdk15.projectPaths)(cwd);
   const subagentRunnerFactory = createChildProcessSubagentRunnerFactory({
     providerConfig: { ...providerSettings, model: modelId },
     logsDir: paths.logs
   });
-  const sessionStore = new import_agent_sessions.SessionStore(paths.sessions);
+  const sessionStore = (0, import_agent_sdk15.createProjectSessionStore)(cwd);
   let resumeSessionId;
+  let showSessionPickerOnStart = false;
   if (args.continueMode) {
-    const sessions = sessionStore.list().filter((s) => s.cwd === cwd);
-    if (sessions.length > 0) {
-      resumeSessionId = sessions[0].id;
-    }
+    resumeSessionId = (0, import_agent_sdk15.resolveLatestSessionId)(sessionStore, cwd);
   } else if (args.resumeId !== void 0) {
     if (args.resumeId === "") {
-      resumeSessionId = "__picker__";
+      showSessionPickerOnStart = true;
     } else {
-      const sessions = sessionStore.list();
-      const match = sessions.find((s) => s.id === args.resumeId || s.name === args.resumeId);
-      if (match) {
-        resumeSessionId = match.id;
-      } else {
+      resumeSessionId = (0, import_agent_sdk15.resolveSessionIdByIdOrName)(sessionStore, args.resumeId);
+      if (resumeSessionId === void 0) {
         process.stderr.write(`Session not found: ${args.resumeId}
 `);
         process.exit(1);
@@ -5589,13 +5933,25 @@ async function startCli(options = {}) {
     }
     const appendParts = [];
     if (args.appendSystemPrompt) appendParts.push(args.appendSystemPrompt);
+    if (args.taskFile) {
+      try {
+        appendParts.push(readTaskFilePrompt(cwd, args.taskFile));
+      } catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+        process.exit(1);
+      }
+    }
     if (args.jsonSchema)
       appendParts.push(
         `Respond with valid JSON only, matching this JSON schema:
 ${args.jsonSchema}`
       );
     const appendSystemPrompt = appendParts.length > 0 ? appendParts.join("\n\n") : void 0;
-    const session = new import_agent_sdk14.InteractiveSession({
+    if (args.systemPrompt) {
+      process.stderr.write("Warning: --system-prompt is not yet functional and will be ignored.\n");
+    }
+    const session = new import_agent_sdk15.InteractiveSession({
       cwd,
       provider,
       permissionMode: args.permissionMode ?? "bypassPermissions",
@@ -5623,6 +5979,8 @@ ${args.jsonSchema}`
     cwd,
     provider,
     providerOverride: args.provider,
+    providerProfileName,
+    providerType: providerSettings.name,
     modelId,
     language: args.language,
     permissionMode: args.permissionMode,
@@ -5630,13 +5988,16 @@ ${args.jsonSchema}`
     version,
     sessionStore,
     resumeSessionId,
+    showSessionPickerOnStart,
     forkSession: args.forkSession,
     sessionName: args.sessionName,
     backgroundTaskRunners,
     subagentRunnerFactory,
     commandModules,
     commandHostAdapters,
-    startupUpdateNoticePromise
+    startupUpdateNoticePromise,
+    webPort: args.web ? args.webPort : void 0,
+    noOpen: args.noOpen
   });
 }
 // Annotate the CommonJS export names for ESM import in node: