@robota-sdk/agent-cli 3.0.0-beta.61 → 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");
@@ -60,6 +60,7 @@ 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_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
@@ -98,6 +99,9 @@ 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" },
@@ -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,6 +139,9 @@ 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"],
@@ -151,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");
@@ -658,67 +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;
@@ -750,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?.();
@@ -825,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) {
@@ -885,49 +877,24 @@ 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();
   }
 };
@@ -965,7 +932,6 @@ function reloadPluginCommandSource(registry) {
 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());
@@ -1050,6 +1016,16 @@ function applyCompactEventToManager(interactiveSession, manager) {
 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,
@@ -1120,9 +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);
@@ -1133,7 +1132,7 @@ function useInteractiveSession(props) {
     interactiveSession.on("context_update", manager.onContextUpdate);
     interactiveSession.on("compact", onCompact);
     interactiveSession.on("skill_activation", onSkillActivation);
-    interactiveSession.on("background_task_event", manager.onBackgroundTaskEvent);
+    interactiveSession.on("execution_workspace_event", onExecutionWorkspaceEvent);
     const initCheck = setInterval(() => {
       try {
         const ctx = interactiveSession.getContextState();
@@ -1146,6 +1145,7 @@ function useInteractiveSession(props) {
         if (restored.length > 0) {
           manager.syncHistory(restored);
         }
+        syncExecutionWorkspaceFromSession(interactiveSession, manager);
         clearInterval(initCheck);
       } catch {
       }
@@ -1162,11 +1162,12 @@ function useInteractiveSession(props) {
       interactiveSession.off("context_update", manager.onContextUpdate);
       interactiveSession.off("compact", onCompact);
       interactiveSession.off("skill_activation", onSkillActivation);
-      interactiveSession.off("background_task_event", manager.onBackgroundTaskEvent);
+      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());
     }
@@ -1189,6 +1190,14 @@ 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,
@@ -1201,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
   };
 }
 
@@ -1889,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;
@@ -1900,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),
@@ -1930,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) {
@@ -4182,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
@@ -4385,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 ?? "/") {
@@ -4557,13 +4735,13 @@ 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);
-  const [showInitialSessionPicker, setShowInitialSessionPicker] = (0, import_react19.useState)(
+  const [activeSessionId, setActiveSessionId] = (0, import_react20.useState)(props.resumeSessionId);
+  const [showInitialSessionPicker, setShowInitialSessionPicker] = (0, import_react20.useState)(
     props.showSessionPickerOnStart ?? false
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
     AppInner,
     {
       ...props,
@@ -4591,7 +4769,10 @@ function AppInner(props) {
     isAborting,
     isShuttingDown,
     pendingPrompt,
-    backgroundTasks,
+    executionWorkspaceSnapshot,
+    selectedExecutionEntryId,
+    selectExecutionWorkspaceEntry,
+    readExecutionWorkspaceDetail,
     permissionRequest,
     contextState,
     handleSubmit: baseHandleSubmit,
@@ -4610,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,
@@ -4643,11 +4838,11 @@ function AppInner(props) {
     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) {
@@ -4659,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());
@@ -4684,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 {
@@ -4692,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,
@@ -4718,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,
@@ -4736,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,
@@ -4744,7 +4986,7 @@ 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,
       {
         sessions: (0, import_agent_sdk9.listResumableSessionSummaries)(props.sessionStore, props.cwd),
@@ -4758,7 +5000,7 @@ function AppInner(props) {
         }
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       SessionStatusBar,
       {
         cwd,
@@ -4776,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,
@@ -4789,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(`
@@ -4805,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(() => {
@@ -5449,6 +5691,29 @@ function readTranscriptLog(jobId, transcriptPath, cursor) {
   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
 var import_meta = {};
 function readVersion() {
@@ -5472,11 +5737,19 @@ function readVersion() {
   }
 }
 function promptInput(label, masked = false) {
-  return new Promise((resolve3) => {
+  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");
@@ -5542,6 +5815,7 @@ function createDefaultCliCommandModules({
     (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)(),
@@ -5585,6 +5859,9 @@ async function startCli(options = {}) {
     return;
   }
   const cwd = process.cwd();
+  if (await runUserLocalDirectCommandIfRequested(args, cwd)) {
+    return;
+  }
   const commandHostAdapters = {
     settings: {
       read: () => readSettings(getUserSettingsPath()),
@@ -5671,6 +5948,9 @@ async function startCli(options = {}) {
 ${args.jsonSchema}`
       );
     const appendSystemPrompt = appendParts.length > 0 ? appendParts.join("\n\n") : void 0;
+    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,
@@ -5715,7 +5995,9 @@ ${args.jsonSchema}`
     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: