@adhdev/daemon-core 0.5.18 → 0.5.20

package/dist/index.d.ts

@@ -1611,14 +1611,16 @@ declare function readChatHistory(agentType: string, offset?: number, limit?: num
 };
 
 /**
- * Daemon Commands — unified command handler
+ * DaemonCommandHandler — unified command routing for CDP & CLI
  *
- * Routes all functionality from legacy Extension commands.ts to Daemon.
+ * Routes incoming commands (from server WS, P2P, or local WS) to
+ * the correct CDP manager or CLI adapter.
  *
- * Command implementations are split into sub-modules:
- * - chat-commands.ts    — Chat I/O, session management, mode/model control
- * - cdp-commands.ts     — CDP eval, screenshot, batch, remote actions, file ops
- * - stream-commands.ts  — Agent stream, PTY I/O, provider settings, extension scripts
+ * Key concepts:
+ *   - extractIdeType(): determines target IDE from _targetInstance
+ *   - getCdp(): returns the DaemonCdpManager for current command
+ *   - getProvider(): returns the ProviderModule for current command
+ *   - handle(): main entry point, sets context then dispatches
  */
 
 interface CommandResult$1 {
@@ -1669,7 +1671,8 @@ declare class DaemonCommandHandler implements CommandHelpers {
     get historyWriter(): ChatHistoryWriter;
     get currentIdeType(): string | undefined;
     get currentProviderType(): string | undefined;
-    /** Get CDP manager for a specific ideType.
+    /** Get CDP manager for a specific ideType or managerKey.
+     * Supports exact match, multi-window prefix match, and instanceIdMap UUID lookup.
      * Returns null if no match — never falls back to another IDE. */
     getCdp(ideType?: string): DaemonCdpManager | null;
     /**
@@ -1690,7 +1693,7 @@ declare class DaemonCommandHandler implements CommandHelpers {
     /** CLI adapter search */
     getCliAdapter(type?: string): any | null;
     private getExtensionSessionId;
-    /** Extract ideType from _targetInstance */
+    /** Extract ideType from _targetInstance or explicit ideType */
     private extractIdeType;
     setAgentStreamManager(manager: DaemonAgentStreamManager): void;
     handle(cmd: string, args: any): Promise<CommandResult$1>;
@@ -2116,6 +2119,8 @@ interface CommandRouterDeps {
     onPostChatCommand?: () => void;
     /** Get a connected CDP manager (for agent stream reset check) */
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
+    /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
+    packageName?: string;
 }
 interface CommandRouterResult {
     success: boolean;
@@ -2219,6 +2224,72 @@ declare class DaemonStatusReporter {
     private simpleHash;
 }
 
+/**
+ * Status Builders — shared conversion functions for ProviderState → ManagedEntry
+ *
+ * Used by:
+ *   - daemon-cloud (DaemonStatusReporter)
+ *   - daemon-standalone (StandaloneServer.getStatus)
+ *
+ * Consolidates duplicated ProviderState→ManagedEntry mapping that was
+ * previously copy-pasted between cloud and standalone codebases.
+ */
+
+/**
+ * Find a CDP manager by key, with prefix matching for multi-window support.
+ *
+ * Lookup order:
+ *   1. Exact match: cdpManagers.get(key)
+ *   2. Prefix match: key starts with `${ideType}_` (multi-window: "cursor_remote_vs")
+ *   3. null
+ *
+ * This replaces raw `cdpManagers.get(ideType)` calls that broke when
+ * multi-window keys like "cursor_remote_vs" were used.
+ */
+declare function findCdpManager(cdpManagers: Map<string, DaemonCdpManager>, key: string): DaemonCdpManager | null;
+/**
+ * Check if any CDP manager matches the given key (exact or prefix).
+ */
+declare function hasCdpManager(cdpManagers: Map<string, DaemonCdpManager>, key: string): boolean;
+/**
+ * Check if any CDP manager matching the key is connected.
+ */
+declare function isCdpConnected(cdpManagers: Map<string, DaemonCdpManager>, key: string): boolean;
+/**
+ * Convert IdeProviderState[] → ManagedIdeEntry[]
+ *
+ * @param ideStates - from instanceManager.collectAllStates() filtered to ide
+ * @param cdpManagers - for cdpConnected lookup
+ * @param opts.detectedIdes - include CDPs that have no instance yet
+ */
+declare function buildManagedIdes(ideStates: IdeProviderState[], cdpManagers: Map<string, DaemonCdpManager>, opts?: {
+    detectedIdes?: {
+        id: string;
+        installed: boolean;
+    }[];
+}): ManagedIdeEntry[];
+/**
+ * Convert CliProviderState[] → ManagedCliEntry[]
+ */
+declare function buildManagedClis(cliStates: CliProviderState[]): ManagedCliEntry[];
+/**
+ * Convert AcpProviderState[] → ManagedAcpEntry[]
+ */
+declare function buildManagedAcps(acpStates: AcpProviderState[]): ManagedAcpEntry[];
+/**
+ * Convenience: collect & build all managed entries from instanceManager
+ */
+declare function buildAllManagedEntries(allStates: ProviderState[], cdpManagers: Map<string, DaemonCdpManager>, opts?: {
+    detectedIdes?: {
+        id: string;
+        installed: boolean;
+    }[];
+}): {
+    managedIdes: ManagedIdeEntry[];
+    managedClis: ManagedCliEntry[];
+    managedAcps: ManagedAcpEntry[];
+};
+
 /**
  * ADHDev Daemon — unified logger (v2)
  *
@@ -2729,9 +2800,10 @@ declare class DevServer {
     private handleAutoImplSSE;
     private handleAutoImplCancel;
     private sendAutoImplSSE;
-    /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise */
+    /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise.
+     *  DevServer is a debugging tool so first-connected fallback is acceptable,
+     *  but callers should pass ideType when possible. */
     private getCdp;
-    private getAnyCdp;
     private json;
     private readBody;
     /** GET /api/cli/status — list all running CLI/ACP instances with state */
@@ -2875,4 +2947,4 @@ declare function initDaemonComponents(config: DaemonInitConfig): Promise<DaemonC
  */
 declare function shutdownDaemonComponents(components: DaemonComponents): Promise<void>;
 
-export { type AcpConfigOption, type AcpMode, AcpProviderInstance, type AcpProviderState, type ActiveChatData, type AgentEntry, AgentStreamPoller, type AgentStreamPollerDeps, type AvailableProviderInfo, CdpDomHandlers, type CdpInitializerConfig, type CdpScannerOptions, type CdpSetupContext, type CdpTargetFilter, type ChatMessage, type CliAdapter, CliProviderInstance, type CliProviderState, type CommandContext, type CommandResult$1 as CommandResult, type CommandRouterDeps, type CommandRouterResult, type CommandResult$2 as CoreCommandResult, DAEMON_WS_PATH, DEFAULT_DAEMON_PORT, DaemonAgentStreamManager, DaemonCdpInitializer, DaemonCdpManager, DaemonCdpScanner, DaemonCliManager, DaemonCommandHandler, DaemonCommandRouter, type DaemonComponents, type DaemonCoreOptions, type DaemonEvent, type DaemonInitConfig, DaemonStatusReporter, type DetectedIde, type DetectedIdeInfo, DevServer, type ExtensionInfo$1 as ExtensionInfo, type ExtensionProviderState, type HostMemorySnapshot, type IDEInfo, type IDaemonCore, IdeProviderInstance, type IdeProviderState, type ExtensionInfo as InstallerExtensionInfo, LOG, type LogEntry, type LogLevel, type MachineInfo, type ManagedAcpEntry, type ManagedAgentStream, type ManagedCliEntry, type ManagedIdeEntry, ProviderCliAdapter, type ProviderConfig, type ProviderErrorReason, type ProviderInfo, ProviderInstanceManager, ProviderLoader, type ProviderModule, type ProviderStatus, type ProviderVersionInfo, type ScopedLogger, type SetupIdeInstanceOptions, type StatusReportPayload, type StatusResponse, type SystemInfo, VersionArchive, type VersionHistory, type WorkspaceActivity, type WorkspaceEntry, addCliHistory, connectCdpManager, detectAllVersions, detectCLIs, detectIDEs, getAIExtensions, getAvailableIdeIds, getHostMemorySnapshot, getLogLevel, getRecentCommands, getRecentLogs, getWorkspaceActivity, getWorkspaceState, initDaemonComponents, installExtensions, installGlobalInterceptor, isExtensionInstalled, isIdeRunning, isSetupComplete, killIdeProcess, launchIDE, launchWithCdp, loadConfig, logCommand, markSetupComplete, probeCdpPort, readChatHistory, registerExtensionProviders, resetConfig, saveConfig, setLogLevel, setupIdeInstance, shutdownDaemonComponents, updateConfig };
+export { type AcpConfigOption, type AcpMode, AcpProviderInstance, type AcpProviderState, type ActiveChatData, type AgentEntry, AgentStreamPoller, type AgentStreamPollerDeps, type AvailableProviderInfo, CdpDomHandlers, type CdpInitializerConfig, type CdpScannerOptions, type CdpSetupContext, type CdpTargetFilter, type ChatMessage, type CliAdapter, CliProviderInstance, type CliProviderState, type CommandContext, type CommandResult$1 as CommandResult, type CommandRouterDeps, type CommandRouterResult, type CommandResult$2 as CoreCommandResult, DAEMON_WS_PATH, DEFAULT_DAEMON_PORT, DaemonAgentStreamManager, DaemonCdpInitializer, DaemonCdpManager, DaemonCdpScanner, DaemonCliManager, DaemonCommandHandler, DaemonCommandRouter, type DaemonComponents, type DaemonCoreOptions, type DaemonEvent, type DaemonInitConfig, DaemonStatusReporter, type DetectedIde, type DetectedIdeInfo, DevServer, type ExtensionInfo$1 as ExtensionInfo, type ExtensionProviderState, type HostMemorySnapshot, type IDEInfo, type IDaemonCore, IdeProviderInstance, type IdeProviderState, type ExtensionInfo as InstallerExtensionInfo, LOG, type LogEntry, type LogLevel, type MachineInfo, type ManagedAcpEntry, type ManagedAgentStream, type ManagedCliEntry, type ManagedIdeEntry, ProviderCliAdapter, type ProviderConfig, type ProviderErrorReason, type ProviderInfo, ProviderInstanceManager, ProviderLoader, type ProviderModule, type ProviderStatus, type ProviderVersionInfo, type ScopedLogger, type SetupIdeInstanceOptions, type StatusReportPayload, type StatusResponse, type SystemInfo, VersionArchive, type VersionHistory, type WorkspaceActivity, type WorkspaceEntry, addCliHistory, buildAllManagedEntries, buildManagedAcps, buildManagedClis, buildManagedIdes, connectCdpManager, detectAllVersions, detectCLIs, detectIDEs, findCdpManager, getAIExtensions, getAvailableIdeIds, getHostMemorySnapshot, getLogLevel, getRecentCommands, getRecentLogs, getWorkspaceActivity, getWorkspaceState, hasCdpManager, initDaemonComponents, installExtensions, installGlobalInterceptor, isCdpConnected, isExtensionInstalled, isIdeRunning, isSetupComplete, killIdeProcess, launchIDE, launchWithCdp, loadConfig, logCommand, markSetupComplete, probeCdpPort, readChatHistory, registerExtensionProviders, resetConfig, saveConfig, setLogLevel, setupIdeInstance, shutdownDaemonComponents, updateConfig };

package/dist/index.js

@@ -380,10 +380,15 @@ __export(index_exports, {
   ProviderLoader: () => ProviderLoader,
   VersionArchive: () => VersionArchive,
   addCliHistory: () => addCliHistory,
+  buildAllManagedEntries: () => buildAllManagedEntries,
+  buildManagedAcps: () => buildManagedAcps,
+  buildManagedClis: () => buildManagedClis,
+  buildManagedIdes: () => buildManagedIdes,
   connectCdpManager: () => connectCdpManager,
   detectAllVersions: () => detectAllVersions,
   detectCLIs: () => detectCLIs,
   detectIDEs: () => detectIDEs,
+  findCdpManager: () => findCdpManager,
   getAIExtensions: () => getAIExtensions,
   getAvailableIdeIds: () => getAvailableIdeIds,
   getHostMemorySnapshot: () => getHostMemorySnapshot,
@@ -392,9 +397,11 @@ __export(index_exports, {
   getRecentLogs: () => getRecentLogs,
   getWorkspaceActivity: () => getWorkspaceActivity,
   getWorkspaceState: () => getWorkspaceState,
+  hasCdpManager: () => hasCdpManager,
   initDaemonComponents: () => initDaemonComponents,
   installExtensions: () => installExtensions,
   installGlobalInterceptor: () => installGlobalInterceptor,
+  isCdpConnected: () => isCdpConnected,
   isExtensionInstalled: () => isExtensionInstalled,
   isIdeRunning: () => isIdeRunning,
   isSetupComplete: () => isSetupComplete,
@@ -2968,6 +2975,119 @@ var DaemonCdpInitializer = class {
   }
 };
 
+// src/status/builders.ts
+function findCdpManager(cdpManagers, key) {
+  const exact = cdpManagers.get(key);
+  if (exact) return exact;
+  const prefix = key + "_";
+  for (const [k, m] of cdpManagers.entries()) {
+    if (k.startsWith(prefix) && m.isConnected) return m;
+  }
+  return null;
+}
+function hasCdpManager(cdpManagers, key) {
+  if (cdpManagers.has(key)) return true;
+  const prefix = key + "_";
+  for (const k of cdpManagers.keys()) {
+    if (k.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function isCdpConnected(cdpManagers, key) {
+  const m = findCdpManager(cdpManagers, key);
+  return m?.isConnected ?? false;
+}
+function buildManagedIdes(ideStates, cdpManagers, opts) {
+  const result = [];
+  for (const state of ideStates) {
+    const cdpConnected = state.cdpConnected ?? isCdpConnected(cdpManagers, state.type);
+    result.push({
+      ideType: state.type,
+      ideVersion: "",
+      instanceId: state.instanceId || state.type,
+      workspace: state.workspace || null,
+      terminals: 0,
+      aiAgents: [],
+      activeChat: state.activeChat,
+      chats: [],
+      agentStreams: state.extensions.map((ext) => ({
+        agentType: ext.type,
+        agentName: ext.name,
+        extensionId: ext.type,
+        status: ext.status || "idle",
+        messages: ext.activeChat?.messages || [],
+        inputContent: ext.activeChat?.inputContent || "",
+        activeModal: ext.activeChat?.activeModal || null
+      })),
+      cdpConnected,
+      currentModel: state.currentModel,
+      currentPlan: state.currentPlan,
+      currentAutoApprove: state.currentAutoApprove
+    });
+  }
+  if (opts?.detectedIdes) {
+    const coveredTypes = new Set(ideStates.map((s) => s.type));
+    for (const ide of opts.detectedIdes) {
+      if (!ide.installed || coveredTypes.has(ide.id)) continue;
+      if (!isCdpConnected(cdpManagers, ide.id)) continue;
+      result.push({
+        ideType: ide.id,
+        ideVersion: "",
+        instanceId: ide.id,
+        workspace: null,
+        terminals: 0,
+        aiAgents: [],
+        activeChat: null,
+        chats: [],
+        agentStreams: [],
+        cdpConnected: true,
+        currentModel: void 0,
+        currentPlan: void 0
+      });
+    }
+  }
+  return result;
+}
+function buildManagedClis(cliStates) {
+  return cliStates.map((s) => ({
+    id: s.instanceId,
+    instanceId: s.instanceId,
+    cliType: s.type,
+    cliName: s.name,
+    status: s.status,
+    mode: s.mode,
+    workspace: s.workspace || "",
+    activeChat: s.activeChat
+  }));
+}
+function buildManagedAcps(acpStates) {
+  return acpStates.map((s) => ({
+    id: s.instanceId,
+    acpType: s.type,
+    acpName: s.name,
+    status: s.status,
+    mode: "chat",
+    workspace: s.workspace || "",
+    activeChat: s.activeChat,
+    currentModel: s.currentModel,
+    currentPlan: s.currentPlan,
+    acpConfigOptions: s.acpConfigOptions,
+    acpModes: s.acpModes,
+    errorMessage: s.errorMessage,
+    errorReason: s.errorReason
+  }));
+}
+function buildAllManagedEntries(allStates, cdpManagers, opts) {
+  const ideStates = allStates.filter((s) => s.category === "ide");
+  const cliStates = allStates.filter((s) => s.category === "cli");
+  const acpStates = allStates.filter((s) => s.category === "acp");
+  return {
+    managedIdes: buildManagedIdes(ideStates, cdpManagers, opts),
+    managedClis: buildManagedClis(cliStates),
+    managedAcps: buildManagedAcps(acpStates)
+  };
+}
+
 // src/commands/handler.ts
 init_config();
 
@@ -4284,12 +4404,14 @@ var DaemonCommandHandler = class {
   get currentProviderType() {
     return this._currentProviderType;
   }
-  /** Get CDP manager for a specific ideType.
+  /** Get CDP manager for a specific ideType or managerKey.
+   * Supports exact match, multi-window prefix match, and instanceIdMap UUID lookup.
    * Returns null if no match — never falls back to another IDE. */
   getCdp(ideType) {
     const key = ideType || this._currentIdeType;
     if (!key) return null;
-    const m = this._ctx.cdpManagers.get(key.toLowerCase());
+    const resolved = this._ctx.instanceIdMap?.get(key) || key;
+    const m = findCdpManager(this._ctx.cdpManagers, resolved.toLowerCase());
     if (m?.isConnected) return m;
     return null;
   }
@@ -4360,10 +4482,18 @@ var DaemonCommandHandler = class {
     const managed = this._agentStream.getManagedAgent(provider.type);
     return managed?.sessionId || null;
   }
-  /** Extract ideType from _targetInstance */
+  /** Extract ideType from _targetInstance or explicit ideType */
   extractIdeType(args) {
-    if (args?.ideType && this._ctx.cdpManagers.has(args.ideType)) {
-      return args.ideType;
+    if (args?.ideType) {
+      if (this._ctx.cdpManagers.has(args.ideType)) {
+        return args.ideType;
+      }
+      const found = findCdpManager(this._ctx.cdpManagers, args.ideType);
+      if (found) {
+        for (const [k, m] of this._ctx.cdpManagers.entries()) {
+          if (m === found) return k;
+        }
+      }
     }
     if (args?._targetInstance) {
       let raw = args._targetInstance;
@@ -4379,9 +4509,10 @@ var DaemonCommandHandler = class {
       if (this._ctx.cdpManagers.has(raw)) {
         return raw;
       }
-      if (!ideMatch && !cliMatch && !acpMatch) {
-        for (const [key, mgr] of this._ctx.cdpManagers.entries()) {
-          if (mgr.isConnected) return key;
+      const found = findCdpManager(this._ctx.cdpManagers, raw);
+      if (found) {
+        for (const [k, m] of this._ctx.cdpManagers.entries()) {
+          if (m === found) return k;
         }
       }
       const lastUnderscore = raw.lastIndexOf("_");
@@ -6113,9 +6244,11 @@ var DaemonCommandRouter = class {
         LOG.info("Upgrade", "Remote upgrade requested from dashboard");
         try {
           const { execSync: execSync7 } = await import("child_process");
-          const latest = execSync7("npm view adhdev version", { encoding: "utf-8", timeout: 1e4 }).trim();
-          LOG.info("Upgrade", `Latest available: v${latest}`);
-          execSync7("npm install -g adhdev@latest", {
+          const isStandalone = this.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
+          const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
+          const latest = execSync7(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
+          LOG.info("Upgrade", `Latest ${pkgName}: v${latest}`);
+          execSync7(`npm install -g ${pkgName}@latest`, {
             encoding: "utf-8",
             timeout: 6e4,
             stdio: ["pipe", "pipe", "pipe"]
@@ -6123,8 +6256,15 @@ var DaemonCommandRouter = class {
           LOG.info("Upgrade", `\u2705 Upgraded to v${latest}`);
           setTimeout(() => {
             LOG.info("Upgrade", "Restarting daemon with new version...");
+            try {
+              const path13 = require("path");
+              const fs10 = require("fs");
+              const pidFile = path13.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
+              if (fs10.existsSync(pidFile)) fs10.unlinkSync(pidFile);
+            } catch {
+            }
             const { spawn: spawn3 } = require("child_process");
-            const child = spawn3(process.execPath, [process.argv[1], "daemon", "-p", "19222"], {
+            const child = spawn3(process.execPath, process.argv.slice(1), {
               detached: true,
               stdio: "ignore",
               env: { ...process.env }
@@ -6332,54 +6472,10 @@ var DaemonStatusReporter = class {
         LOG.info("StatusReport", summary);
       }
     }
-    const managedIdes = ideStates.map((s) => ({
-      ideType: s.type,
-      ideVersion: "",
-      instanceId: s.instanceId,
-      workspace: s.workspace || null,
-      terminals: 0,
-      aiAgents: [],
-      activeChat: s.activeChat,
-      chats: [],
-      agentStreams: s.extensions.map((ext) => ({
-        agentType: ext.type,
-        agentName: ext.name,
-        extensionId: ext.type,
-        status: ext.status || "idle",
-        messages: ext.activeChat?.messages || [],
-        inputContent: ext.activeChat?.inputContent || "",
-        activeModal: ext.activeChat?.activeModal || null
-      })),
-      cdpConnected: s.cdpConnected,
-      currentModel: s.currentModel,
-      currentPlan: s.currentPlan,
-      currentAutoApprove: s.currentAutoApprove
-    }));
-    const managedClis = cliStates.map((s) => ({
-      id: s.instanceId,
-      instanceId: s.instanceId,
-      cliType: s.type,
-      cliName: s.name,
-      status: s.status,
-      mode: s.mode,
-      workspace: s.workspace || "",
-      activeChat: s.activeChat
-    }));
-    const managedAcps = acpStates.map((s) => ({
-      id: s.instanceId,
-      acpType: s.type,
-      acpName: s.name,
-      status: s.status,
-      mode: s.mode,
-      workspace: s.workspace || "",
-      activeChat: s.activeChat,
-      currentModel: s.currentModel,
-      currentPlan: s.currentPlan,
-      acpConfigOptions: s.acpConfigOptions,
-      acpModes: s.acpModes,
-      errorMessage: s.errorMessage,
-      errorReason: s.errorReason
-    }));
+    const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+      allStates,
+      this.deps.cdpManagers
+    );
     const cfg = loadConfig();
     const wsState = getWorkspaceState(cfg);
     const memSnap = getHostMemorySnapshot();
@@ -6426,37 +6522,34 @@ var DaemonStatusReporter = class {
       LOG.debug("P2P", `sent (${JSON.stringify(payload).length} bytes)`);
     }
     if (opts?.p2pOnly) return;
-    const plan = serverConn.getUserPlan();
-    if (plan !== "free") {
-      const wsPayload = {
-        daemonMode: true,
-        machineNickname: payload.machineNickname,
-        defaultWorkspaceId: wsState.defaultWorkspaceId,
-        workspaceCount: (wsState.workspaces || []).length,
-        // managedIdes: server only saves id, type, cdpConnected
-        managedIdes: managedIdes.map((ide) => ({
-          ideType: ide.ideType,
-          instanceId: ide.instanceId,
-          cdpConnected: ide.cdpConnected
-        })),
-        // managedClis: server only saves id, type, name
-        managedClis: managedClis.map((c) => ({
-          id: c.id,
-          cliType: c.cliType,
-          cliName: c.cliName
-        })),
-        // managedAcps: server only saves id, type, name
-        managedAcps: managedAcps?.map((a) => ({
-          id: a.id,
-          acpType: a.acpType,
-          acpName: a.acpName
-        })),
-        p2p: payload.p2p,
-        timestamp: now
-      };
-      serverConn.sendMessage("status_report", wsPayload);
-      LOG.debug("Server", `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
-    }
+    const wsPayload = {
+      daemonMode: true,
+      machineNickname: payload.machineNickname,
+      defaultWorkspaceId: wsState.defaultWorkspaceId,
+      workspaceCount: (wsState.workspaces || []).length,
+      // managedIdes: server only saves id, type, cdpConnected
+      managedIdes: managedIdes.map((ide) => ({
+        ideType: ide.ideType,
+        instanceId: ide.instanceId,
+        cdpConnected: ide.cdpConnected
+      })),
+      // managedClis: server only saves id, type, name
+      managedClis: managedClis.map((c) => ({
+        id: c.id,
+        cliType: c.cliType,
+        cliName: c.cliName
+      })),
+      // managedAcps: server only saves id, type, name
+      managedAcps: managedAcps?.map((a) => ({
+        id: a.id,
+        acpType: a.acpType,
+        acpName: a.acpName
+      })),
+      p2p: payload.p2p,
+      timestamp: now
+    };
+    serverConn.sendMessage("status_report", wsPayload);
+    LOG.debug("Server", `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
   }
   // ─── P2P ─────────────────────────────────────────
   sendP2PPayload(payload) {
@@ -9935,7 +10028,10 @@ var DevServer = class _DevServer {
       this.json(res, 400, { error: "expression required" });
       return;
     }
-    const cdp = ideType ? this.cdpManagers.get(ideType) : this.getAnyCdp();
+    const cdp = this.getCdp(ideType);
+    if (!cdp && !ideType) {
+      LOG.warn("DevServer", "CDP evaluate without ideType \u2014 picked first connected manager");
+    }
     if (!cdp?.isConnected) {
       this.json(res, 503, { error: "No CDP connection available" });
       return;
@@ -10175,7 +10271,7 @@ var DevServer = class _DevServer {
         this.sendSSE({ type: "watch_error", error: `Script '${this.watchScriptName}' not found` });
         return;
       }
-      const cdp = this.getAnyCdp();
+      const cdp = this.getCdp();
       if (!cdp) {
         this.sendSSE({ type: "watch_error", error: "No CDP connection" });
         return;
@@ -11928,20 +12024,24 @@ data: ${JSON.stringify(msg.data)}
       }
     }
   }
-  /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise */
+  /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise.
+   *  DevServer is a debugging tool so first-connected fallback is acceptable,
+   *  but callers should pass ideType when possible. */
   getCdp(ideType) {
     if (ideType) {
       const cdp = this.cdpManagers.get(ideType);
       if (cdp?.isConnected) return cdp;
+      for (const [k, m] of this.cdpManagers.entries()) {
+        if (k.startsWith(ideType + "_") && m.isConnected) return m;
+      }
+      LOG.warn("DevServer", `getCdp: no manager found for ideType '${ideType}', available: [${[...this.cdpManagers.keys()].join(", ")}]`);
+      return null;
     }
     for (const cdp of this.cdpManagers.values()) {
       if (cdp.isConnected) return cdp;
     }
     return null;
   }
-  getAnyCdp() {
-    return this.getCdp();
-  }
   json(res, status, data) {
     res.writeHead(status, { "Content-Type": "application/json" });
     res.end(JSON.stringify(data, null, 2));
@@ -12537,10 +12637,15 @@ async function shutdownDaemonComponents(components) {
   ProviderLoader,
   VersionArchive,
   addCliHistory,
+  buildAllManagedEntries,
+  buildManagedAcps,
+  buildManagedClis,
+  buildManagedIdes,
   connectCdpManager,
   detectAllVersions,
   detectCLIs,
   detectIDEs,
+  findCdpManager,
   getAIExtensions,
   getAvailableIdeIds,
   getHostMemorySnapshot,
@@ -12549,9 +12654,11 @@ async function shutdownDaemonComponents(components) {
   getRecentLogs,
   getWorkspaceActivity,
   getWorkspaceState,
+  hasCdpManager,
   initDaemonComponents,
   installExtensions,
   installGlobalInterceptor,
+  isCdpConnected,
   isExtensionInstalled,
   isIdeRunning,
   isSetupComplete,