@adhdev/daemon-core 0.7.40 → 0.7.42

package/dist/index.js

@@ -33,7 +33,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/config/config.ts
 var config_exports = {};
 __export(config_exports, {
-  generateConnectionToken: () => generateConnectionToken,
   generateMachineId: () => generateMachineId,
   getConfigDir: () => getConfigDir,
   isSetupComplete: () => isSetupComplete,
@@ -44,6 +43,57 @@ __export(config_exports, {
   saveConfig: () => saveConfig,
   updateConfig: () => updateConfig
 });
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function asNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function normalizeConfig(raw) {
+  const parsed = isPlainObject(raw) ? raw : {};
+  const legacySessionReads = isPlainObject(parsed.recentSessionReads) ? parsed.recentSessionReads : {};
+  const sessionReads = isPlainObject(parsed.sessionReads) ? parsed.sessionReads : {};
+  const mergedSessionReads = Object.fromEntries(
+    Object.entries({ ...legacySessionReads, ...sessionReads }).filter(([, value]) => typeof value === "number" && Number.isFinite(value))
+  );
+  const sessionReadMarkers = Object.fromEntries(
+    Object.entries(isPlainObject(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {}).filter(([, value]) => typeof value === "string")
+  );
+  return {
+    serverUrl: typeof parsed.serverUrl === "string" && parsed.serverUrl.trim() ? parsed.serverUrl : DEFAULT_CONFIG.serverUrl,
+    selectedIde: asNullableString(parsed.selectedIde),
+    configuredIdes: asStringArray(parsed.configuredIdes),
+    installedExtensions: asStringArray(parsed.installedExtensions),
+    userEmail: asNullableString(parsed.userEmail),
+    userName: asNullableString(parsed.userName),
+    setupCompleted: asBoolean(parsed.setupCompleted, DEFAULT_CONFIG.setupCompleted),
+    setupDate: asNullableString(parsed.setupDate),
+    enabledIdes: asStringArray(parsed.enabledIdes),
+    workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces : [],
+    defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
+    recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity : [],
+    sessionReads: mergedSessionReads,
+    sessionReadMarkers,
+    machineNickname: asNullableString(parsed.machineNickname),
+    machineId: asOptionalString(parsed.machineId),
+    machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
+    registeredMachineId: asOptionalString(parsed.registeredMachineId),
+    providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
+    ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
+    disableUpstream: asBoolean(parsed.disableUpstream, DEFAULT_CONFIG.disableUpstream ?? false),
+    providerDir: asOptionalString(parsed.providerDir)
+  };
+}
 function generateMachineId() {
   return `${MACHINE_ID_PREFIX}${(0, import_crypto.randomUUID)().replace(/-/g, "")}`;
 }
@@ -87,14 +137,10 @@ function loadConfig() {
   try {
     const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
     const parsed = JSON.parse(raw);
-    const merged = { ...DEFAULT_CONFIG, ...parsed };
-    if (merged.defaultWorkspaceId == null && merged.activeWorkspaceId != null) {
-      merged.defaultWorkspaceId = merged.activeWorkspaceId;
-    }
-    delete merged.activeWorkspaceId;
-    const ensured = ensureMachineId(merged);
+    const normalizedInput = normalizeConfig(parsed);
+    const ensured = ensureMachineId(normalizedInput);
     const normalized = ensured.config;
-    if (ensured.changed) {
+    if (ensured.changed || JSON.stringify(parsed) !== JSON.stringify(normalized)) {
       try {
         saveConfig(normalized);
       } catch {
@@ -109,10 +155,11 @@ function loadConfig() {
 function saveConfig(config) {
   const configPath = getConfigPath();
   const dir = getConfigDir();
+  const normalized = normalizeConfig(config);
   if (!(0, import_fs.existsSync)(dir)) {
     (0, import_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
   }
-  (0, import_fs.writeFileSync)(configPath, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs.writeFileSync)(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
   try {
     (0, import_fs.chmodSync)(configPath, 384);
   } catch {
@@ -141,14 +188,6 @@ function isSetupComplete() {
 function resetConfig() {
   saveConfig({ ...DEFAULT_CONFIG });
 }
-function generateConnectionToken() {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let token = "db_";
-  for (let i = 0; i < 32; i++) {
-    token += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return token;
-}
 var import_os, import_path, import_fs, import_crypto, DEFAULT_CONFIG, MACHINE_ID_PREFIX;
 var init_config = __esm({
   "src/config/config.ts"() {
@@ -159,18 +198,13 @@ var init_config = __esm({
     import_crypto = require("crypto");
     DEFAULT_CONFIG = {
       serverUrl: "https://api.adhf.dev",
-      apiToken: null,
-      connectionToken: null,
       selectedIde: null,
       configuredIdes: [],
       installedExtensions: [],
-      autoConnect: true,
-      notifications: true,
       userEmail: null,
       userName: null,
       setupCompleted: false,
       setupDate: null,
-      configuredCLIs: [],
       enabledIdes: [],
       workspaces: [],
       defaultWorkspaceId: null,
@@ -983,6 +1017,13 @@ var init_provider_cli_adapter = __esm({
         this.messages = [...this.committedMessages];
         this.structuredMessages = [...this.committedMessages];
       }
+      normalizeParsedMessages(parsedMessages) {
+        return parsedMessages.filter((message) => message && (message.role === "user" || message.role === "assistant")).map((message) => ({
+          role: message.role,
+          content: typeof message.content === "string" ? message.content : String(message.content || ""),
+          timestamp: typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : Date.now()
+        }));
+      }
       sliceFromOffset(text, start) {
         if (!text) return "";
         if (!Number.isFinite(start) || start <= 0) return text;
@@ -1379,6 +1420,15 @@ var init_provider_cli_adapter = __esm({
         this.onStatusChange?.();
       }
       commitCurrentTranscript() {
+        const parsed = this.parseCurrentTranscript(
+          this.committedMessages,
+          this.responseBuffer,
+          this.currentTurnScope
+        );
+        if (parsed && Array.isArray(parsed.messages)) {
+          this.committedMessages = this.normalizeParsedMessages(parsed.messages);
+          this.syncMessageViews();
+        }
       }
       // ─── Script Execution ──────────────────────────
       runDetectStatus(text) {
@@ -1423,6 +1473,21 @@ var init_provider_cli_adapter = __esm({
        * Called by command handler / dashboard for rich content rendering.
        */
       getScriptParsedStatus() {
+        const parsed = this.parseCurrentTranscript(
+          this.committedMessages,
+          this.responseBuffer,
+          this.currentTurnScope
+        );
+        if (parsed && Array.isArray(parsed.messages)) {
+          return {
+            id: parsed.id || "cli_session",
+            status: parsed.status || this.currentStatus,
+            title: parsed.title || this.cliName,
+            terminalHistory: this.terminalHistory,
+            messages: parsed.messages,
+            activeModal: parsed.activeModal ?? this.activeModal
+          };
+        }
         const messages = [...this.committedMessages];
         return {
           id: "cli_session",
@@ -3823,6 +3888,8 @@ var ExtensionProviderInstance = class {
         this.detectTransition(newStatus, data);
         this.currentStatus = newStatus;
       }
+    } else if (event === "stream_reset") {
+      this.resetStreamState();
     } else if (event === "extension_connected") {
       this.ideType = data?.ideType || "";
     }
@@ -3902,6 +3969,30 @@ var ExtensionProviderInstance = class {
     const title = typeof data?.title === "string" && data.title.trim() ? data.title.trim() : this.chatTitle;
     return title || this.agentName || this.provider.name;
   }
+  resetStreamState() {
+    if (this.currentStatus !== "idle") {
+      this.detectTransition("idle", {
+        title: this.chatTitle,
+        agentName: this.agentName,
+        extensionId: this.extensionId,
+        messages: this.messages
+      });
+    }
+    this.agentStreams = [];
+    this.messages = [];
+    this.activeModal = null;
+    this.currentModel = "";
+    this.currentMode = "";
+    this.controlValues = {};
+    this.currentStatus = "idle";
+    this.chatId = null;
+    this.chatTitle = null;
+    this.agentName = "";
+    this.extensionId = "";
+    this.lastAgentStatus = "idle";
+    this.generatingStartedAt = 0;
+    this.monitor.reset();
+  }
 };
 
 // src/config/chat-history.ts
@@ -4184,11 +4275,23 @@ var IdeProviderInstance = class {
     } else if (event === "cdp_disconnected") {
       this.cachedChat = null;
       this.currentStatus = "idle";
+      for (const ext of this.extensions.values()) {
+        ext.onEvent("stream_reset");
+      }
     } else if (event === "stream_update") {
       const extType = data?.extensionType;
       if (extType && this.extensions.has(extType)) {
         this.extensions.get(extType).onEvent("stream_update", data);
       }
+    } else if (event === "stream_reset") {
+      const extType = data?.extensionType;
+      if (extType && this.extensions.has(extType)) {
+        this.extensions.get(extType).onEvent("stream_reset");
+      }
+    } else if (event === "stream_reset_all") {
+      for (const ext of this.extensions.values()) {
+        ext.onEvent("stream_reset");
+      }
     }
   }
   dispose() {
@@ -4855,6 +4958,63 @@ var WORKING_STATUSES = /* @__PURE__ */ new Set([
   "thinking",
   "active"
 ]);
+var STATUS_ACTIVE_CHAT_MESSAGE_LIMIT = 60;
+var STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT = 96 * 1024;
+var STATUS_ACTIVE_CHAT_STRING_LIMIT = 4 * 1024;
+var STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT = 1024;
+var STATUS_TERMINAL_HISTORY_LIMIT = 8 * 1024;
+var STATUS_INPUT_CONTENT_LIMIT = 2 * 1024;
+var STATUS_MODAL_MESSAGE_LIMIT = 2 * 1024;
+var STATUS_MODAL_BUTTON_LIMIT = 120;
+function truncateString(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  if (maxChars <= 12) return value.slice(0, Math.max(0, maxChars));
+  return `${value.slice(0, maxChars - 12)}...[truncated]`;
+}
+function truncateStringTail(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  if (maxChars <= 12) return value.slice(value.length - Math.max(0, maxChars));
+  return `...[truncated]${value.slice(value.length - (maxChars - 12))}`;
+}
+function trimStructuredStrings(value, maxChars) {
+  if (typeof value === "string") return truncateString(value, maxChars);
+  if (Array.isArray(value)) return value.map((item) => trimStructuredStrings(item, maxChars));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [key, trimStructuredStrings(nested, maxChars)])
+  );
+}
+function estimateBytes(value) {
+  try {
+    return JSON.stringify(value).length;
+  } catch {
+    return String(value ?? "").length;
+  }
+}
+function trimMessageForStatus(message, stringLimit) {
+  if (!message || typeof message !== "object") return message;
+  return trimStructuredStrings(message, stringLimit);
+}
+function trimMessagesForStatus(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return [];
+  const recent = messages.slice(-STATUS_ACTIVE_CHAT_MESSAGE_LIMIT);
+  const kept = [];
+  let totalBytes = 0;
+  for (let i = recent.length - 1; i >= 0; i -= 1) {
+    let normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT);
+    let size = estimateBytes(normalized);
+    if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+      normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT);
+      size = estimateBytes(normalized);
+    }
+    if (kept.length > 0 && totalBytes + size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+      continue;
+    }
+    kept.push(normalized);
+    totalBytes += size;
+  }
+  return kept.reverse();
+}
 function hasApprovalButtons(activeModal) {
   return (activeModal?.buttons?.length ?? 0) > 0;
 }
@@ -4881,7 +5041,16 @@ function normalizeActiveChatData(activeChat) {
   if (!activeChat) return activeChat;
   return {
     ...activeChat,
-    status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal })
+    status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),
+    messages: trimMessagesForStatus(activeChat.messages),
+    activeModal: activeChat.activeModal ? {
+      message: truncateString(activeChat.activeModal.message || "", STATUS_MODAL_MESSAGE_LIMIT),
+      buttons: (activeChat.activeModal.buttons || []).map(
+        (button) => truncateString(String(button || ""), STATUS_MODAL_BUTTON_LIMIT)
+      )
+    } : activeChat.activeModal,
+    terminalHistory: activeChat.terminalHistory ? truncateStringTail(activeChat.terminalHistory, STATUS_TERMINAL_HISTORY_LIMIT) : activeChat.terminalHistory,
+    inputContent: activeChat.inputContent ? truncateString(activeChat.inputContent, STATUS_INPUT_CONTENT_LIMIT) : activeChat.inputContent
   };
 }
 
@@ -4979,6 +5148,11 @@ var PTY_SESSION_CAPABILITIES = [
   "terminal_io",
   "resize_terminal"
 ];
+var CLI_CHAT_SESSION_CAPABILITIES = [
+  "read_chat",
+  "send_message",
+  "resolve_action"
+];
 var ACP_SESSION_CAPABILITIES = [
   "read_chat",
   "send_message",
@@ -5068,9 +5242,10 @@ function buildCliSession(state) {
     runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
     runtimeWriteOwner: state.runtime?.writeOwner || null,
     runtimeAttachedClients: state.runtime?.attachedClients || [],
+    mode: state.mode,
     resume: state.resume,
     activeChat,
-    capabilities: PTY_SESSION_CAPABILITIES,
+    capabilities: state.mode === "terminal" ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
     controlValues: state.controlValues,
     providerControls: buildFallbackControls(
       state.providerControls
@@ -6244,6 +6419,13 @@ async function handleFileListBrowse(h, args) {
 
 // src/commands/stream-commands.ts
 init_logger();
+function getCliPresentationMode(h, targetSessionId) {
+  if (!targetSessionId) return null;
+  const instance = h.ctx.instanceManager?.getInstance(targetSessionId);
+  if (instance?.category !== "cli") return null;
+  const mode = instance.getPresentationMode?.();
+  return mode === "chat" || mode === "terminal" ? mode : null;
+}
 async function handleFocusSession(h, args) {
   if (!h.agentStream || !h.getCdp()) return { success: false, error: "AgentStream or CDP not available" };
   const sessionId = args?.targetSessionId || h.currentSession?.sessionId;
@@ -6254,6 +6436,9 @@ async function handleFocusSession(h, args) {
 function handlePtyInput(h, args) {
   const { cliType, data, targetSessionId } = args || {};
   if (!data) return { success: false, error: "data required" };
+  if (getCliPresentationMode(h, targetSessionId) === "chat") {
+    return { success: false, error: "CLI session is in chat mode", code: "CLI_VIEW_MODE_NOT_TERMINAL" };
+  }
   const adapter = h.getCliAdapter(targetSessionId || cliType);
   if (!adapter || typeof adapter.writeRaw !== "function") {
     return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
@@ -6264,6 +6449,9 @@ function handlePtyInput(h, args) {
 function handlePtyResize(h, args) {
   const { cliType, cols, rows, force, targetSessionId } = args || {};
   if (!cols || !rows) return { success: false, error: "cols and rows required" };
+  if (getCliPresentationMode(h, targetSessionId) === "chat") {
+    return { success: false, error: "CLI session is in chat mode", code: "CLI_VIEW_MODE_NOT_TERMINAL" };
+  }
   const adapter = h.getCliAdapter(targetSessionId || cliType);
   if (!adapter || typeof adapter.resize !== "function") {
     return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
@@ -8671,6 +8859,7 @@ var DaemonCommandRouter = class {
       // ─── CLI / ACP commands ───
       case "launch_cli":
       case "stop_cli":
+      case "set_cli_view_mode":
       case "agent_command": {
         return this.deps.cliManager.handleCliCommand(cmd, args);
       }
@@ -9015,6 +9204,20 @@ var DaemonStatusReporter = class {
   ts() {
     return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
   }
+  summarizeLargePayloadSessions(payload) {
+    const sessions = Array.isArray(payload.sessions) ? payload.sessions : [];
+    return sessions.map((session) => ({
+      id: String(session?.id || ""),
+      providerType: String(session?.providerType || ""),
+      bytes: (() => {
+        try {
+          return JSON.stringify(session).length;
+        } catch {
+          return 0;
+        }
+      })()
+    })).sort((a, b) => b.bytes - a.bytes).slice(0, 3).map((session) => `${session.providerType || "unknown"}:${session.id}=${session.bytes}b`).join(", ");
+  }
   async sendUnifiedStatusReport(opts) {
     const { serverConn, p2p } = this.deps;
     if (!serverConn?.isConnected()) return;
@@ -9067,9 +9270,16 @@ var DaemonStatusReporter = class {
       screenshotUsage: this.deps.getScreenshotUsage?.() || null,
       connectedExtensions: []
     };
+    const payloadBytes = JSON.stringify(payload).length;
     const p2pSent = this.sendP2PPayload(payload);
     if (p2pSent) {
-      LOG.debug("P2P", `sent (${JSON.stringify(payload).length} bytes)`);
+      LOG.debug("P2P", `sent (${payloadBytes} bytes)`);
+      if (payloadBytes > 256 * 1024) {
+        LOG.warn(
+          "P2P",
+          `large status payload (${payloadBytes} bytes) top sessions: ${this.summarizeLargePayloadSessions(payload) || "n/a"}`
+        );
+      }
     }
     if (opts?.p2pOnly) return;
     const wsPayload = {
@@ -9099,7 +9309,9 @@ var DaemonStatusReporter = class {
         acpModes: session.acpModes
       })),
       p2p: payload.p2p,
-      timestamp: now
+      timestamp: now,
+      detectedIdes: payload.detectedIdes,
+      availableProviders: payload.availableProviders
     };
     serverConn.sendMessage("status_report", wsPayload);
     LOG.debug("Server", `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
@@ -9151,6 +9363,7 @@ var CliProviderInstance = class {
     this.cliArgs = cliArgs;
     this.type = provider.type;
     this.instanceId = instanceId || crypto3.randomUUID();
+    this.presentationMode = "terminal";
     this.adapter = new ProviderCliAdapter(provider, workingDir, cliArgs, transportFactory);
     this.monitor = new StatusMonitor();
     this.historyWriter = new ChatHistoryWriter();
@@ -9169,6 +9382,7 @@ var CliProviderInstance = class {
   lastApprovalEventAt = 0;
   historyWriter;
   instanceId;
+  presentationMode;
   // ─── Lifecycle ─────────────────────────────────
   async init(context) {
     this.context = context;
@@ -9193,6 +9407,7 @@ var CliProviderInstance = class {
   }
   getState() {
     const adapterStatus = this.adapter.getStatus();
+    const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
     const runtime = this.adapter.getRuntimeMetadata();
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     if (adapterStatus.terminalHistory?.trim()) {
@@ -9208,13 +9423,13 @@ var CliProviderInstance = class {
       name: this.provider.name,
       category: "cli",
       status: adapterStatus.status,
-      mode: "terminal",
+      mode: this.presentationMode,
       activeChat: {
         id: `${this.type}_${this.workingDir}`,
-        title: `${this.provider.name} \xB7 ${dirName}`,
-        status: adapterStatus.status,
-        messages: [],
-        activeModal: adapterStatus.activeModal,
+        title: parsedStatus?.title || `${this.provider.name} \xB7 ${dirName}`,
+        status: parsedStatus?.status || adapterStatus.status,
+        messages: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [],
+        activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
         terminalHistory: adapterStatus.terminalHistory,
         inputContent: ""
       },
@@ -9237,6 +9452,13 @@ var CliProviderInstance = class {
       providerControls: this.provider.controls
     };
   }
+  setPresentationMode(mode) {
+    if (this.presentationMode === mode) return;
+    this.presentationMode = mode;
+  }
+  getPresentationMode() {
+    return this.presentationMode;
+  }
   onEvent(event, data) {
     if (event === "send_message" && data?.text) {
       void this.adapter.sendMessage(data.text).catch((e) => {
@@ -10295,6 +10517,15 @@ var DaemonCliManager = class {
     const hash = require("crypto").createHash("md5").update(require("path").resolve(dir)).digest("hex").slice(0, 8);
     return `${cliType}_${hash}`;
   }
+  getSessionPresentationMode(sessionId) {
+    if (!sessionId) return null;
+    const instance = this.deps.getInstanceManager()?.getInstance(sessionId);
+    const mode = instance?.category === "cli" ? instance.getPresentationMode?.() : null;
+    return mode === "chat" || mode === "terminal" ? mode : null;
+  }
+  isTerminalSession(sessionId) {
+    return this.getSessionPresentationMode(sessionId) === "terminal";
+  }
   persistRecentActivity(entry) {
     try {
       saveConfig(appendRecentActivity(loadConfig(), entry));
@@ -10473,6 +10704,7 @@ ${installInfo}`
     if (provider) {
       console.log(colorize("cyan", `  \u{1F4E6} Using provider: ${provider.name} (${provider.type})`));
     }
+    const resolvedCliArgs = cliArgs;
     const instanceManager = this.deps.getInstanceManager();
     if (provider && instanceManager) {
       const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
@@ -10481,14 +10713,14 @@ ${installInfo}`
         normalizedType,
         cliType,
         resolvedDir,
-        cliArgs,
+        resolvedCliArgs,
         resolvedProvider,
         {},
         false
       );
       console.log(colorize("green", `  \u2713 CLI started: ${cliInfo.displayName} v${cliInfo.version || "unknown"} in ${resolvedDir}`));
     } else {
-      const adapter = this.createAdapter(cliType, resolvedDir, cliArgs, key, false);
+      const adapter = this.createAdapter(cliType, resolvedDir, resolvedCliArgs, key, false);
       try {
         await adapter.spawn();
       } catch (spawnErr) {
@@ -10638,6 +10870,14 @@ ${installInfo}`
     }
     return null;
   }
+  findAdapterBySessionId(instanceKey) {
+    if (!instanceKey) return null;
+    let ik = instanceKey;
+    const colonIdx = ik.lastIndexOf(":");
+    if (colonIdx >= 0) ik = ik.substring(colonIdx + 1);
+    const adapter = this.adapters.get(ik);
+    return adapter ? { adapter, key: ik } : null;
+  }
   // ─── CLI command handling ────────────────────────────
   async handleCliCommand(cmd, args) {
     switch (cmd) {
@@ -10688,6 +10928,23 @@ ${installInfo}`
         }
         return { success: true, cliType, dir, stopped: true, mode };
       }
+      case "set_cli_view_mode": {
+        const mode = args?.mode === "chat" ? "chat" : "terminal";
+        const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId : "";
+        const cliType = args?.cliType || args?.agentType || "";
+        const dir = args?.dir || "";
+        const found = this.findAdapterBySessionId(targetSessionId) || (cliType ? this.findAdapter(cliType, { instanceKey: targetSessionId, dir }) : null);
+        if (!found) {
+          return { success: false, error: "CLI session not found", code: "CLI_SESSION_NOT_FOUND" };
+        }
+        const instance = this.deps.getInstanceManager()?.getInstance(found.key);
+        if (!(instance instanceof CliProviderInstance)) {
+          return { success: false, error: "CLI instance not found", code: "CLI_INSTANCE_NOT_FOUND" };
+        }
+        instance.setPresentationMode(mode);
+        this.deps.onStatusChange();
+        return { success: true, id: found.key, mode };
+      }
       case "restart_session": {
         const cliType = args?.cliType || args?.agentType || args?.ideType;
         const cfg = loadConfig();
@@ -11306,7 +11563,12 @@ var AgentStreamPoller = class {
         } catch {
         }
       }
-      if (!resolvedActiveSessionId || !parentSessionId) continue;
+      if (!resolvedActiveSessionId || !parentSessionId) {
+        if (parentSessionId) {
+          this.deps.onStreamsUpdated?.(ideType, []);
+        }
+        continue;
+      }
       try {
         await agentStreamManager.syncActiveSession(cdp, parentSessionId);
         const stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
@@ -11321,7 +11583,11 @@ var AgentStreamPoller = class {
 function forwardAgentStreamsToIdeInstance(instanceManager, ideType, streams) {
   const ideInstance = instanceManager.getInstance(`ide:${ideType}`);
   if (!ideInstance?.onEvent) return;
+  const seenExtensionTypes = /* @__PURE__ */ new Set();
   for (const stream of streams) {
+    if (typeof stream.agentType === "string" && stream.agentType) {
+      seenExtensionTypes.add(stream.agentType);
+    }
     ideInstance.onEvent("stream_update", {
       extensionType: stream.agentType,
       streams: [stream],
@@ -11338,6 +11604,16 @@ function forwardAgentStreamsToIdeInstance(instanceManager, ideType, streams) {
       inputContent: stream.inputContent || ""
     });
   }
+  const extensionTypes = ideInstance.getExtensionTypes?.() || [];
+  if (streams.length === 0) {
+    ideInstance.onEvent("stream_reset_all");
+    return;
+  }
+  for (const extensionType of extensionTypes) {
+    if (!seenExtensionTypes.has(extensionType)) {
+      ideInstance.onEvent("stream_reset", { extensionType });
+    }
+  }
 }
 
 // src/providers/provider-instance-manager.ts