@adhdev/daemon-core 0.5.19 → 0.5.21

package/providers/_builtin/ide/antigravity/scripts/1.107/read_chat.js

@@ -266,8 +266,14 @@
         // 5. 모달/승인 감지 — Run⌥⏎/Reject 인라인 + Deny/Allow 브라우저 승인
         let activeModal = null;
         try {
+            // Strip Mac symbols and Windows shortcut labels (e.g. "RunAlt+⏎" → "Run")
+            const stripShortcut = (s) => s
+                .replace(/[⌥⏎⇧⌫⌘⌃↵]/g, '')
+                .replace(/\s*(Alt|Ctrl|Shift|Cmd|Enter|Return|Esc|Tab|Backspace)(\+\s*\w+)*/gi, '')
+                .trim();
             const isApprovalLike = (el) => {
-                const t = (el.textContent || '').trim().toLowerCase();
+                const raw = (el.textContent || '').trim();
+                const t = stripShortcut(raw).toLowerCase();
                 // 드롭다운 옵션 제외
                 if (t === 'ask every time') return false;
                 return /^(run|reject|skip|approve|allow|deny|cancel|accept|yes|no)\b/i.test(t)
@@ -293,11 +299,9 @@
                 const approvalBtns = panelBtns.filter(isApprovalLike);
                 if (approvalBtns.length > 0) {
                     const hasActionBtn = approvalBtns.some(b => {
-                        const t = (b.textContent || '').trim().toLowerCase();
-                        return t.indexOf('run') === 0 || t === 'reject' || t.indexOf('reject') === 0
-                            || t === 'skip' || t.indexOf('skip') === 0
-                            || t === 'deny' || t === 'allow' || t === 'always allow' || t === 'always deny'
-                            || t === 'accept' || t === 'approve';
+                        const t = stripShortcut((b.textContent || '').trim()).toLowerCase();
+                        return /^(run|reject|skip|deny|allow|accept|approve|yes|no)\b/.test(t)
+                            || t === 'always allow' || t === 'always deny';
                     });
                     if (hasActionBtn) {
                         const btnTexts = [...new Set(

package/providers/_builtin/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.03.21",
+  "version": "2026.03.22",
   "providers": {
     "agentpool-acp": {
       "providerVersion": "0.0.0",
@@ -196,6 +196,11 @@
       "category": "extension",
       "name": "Cline"
     },
+    "codex": {
+      "providerVersion": "0.0.0",
+      "category": "extension",
+      "name": "Codex"
+    },
     "roo-code": {
       "providerVersion": "0.0.0",
       "category": "extension",

package/src/commands/handler.ts

@@ -1,16 +1,19 @@
 /**
- * Daemon Commands — unified command handler
- * 
- * Routes all functionality from legacy Extension commands.ts to Daemon.
- * 
- * 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
+ * DaemonCommandHandler — unified command routing for CDP & CLI
+ *
+ * Routes incoming commands (from server WS, P2P, or local WS) to
+ * the correct CDP manager or CLI adapter.
+ *
+ * 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
  */
 
-import { DaemonCdpManager } from '../cdp/manager.js';
+import type { DaemonCdpManager } from '../cdp/manager.js';
 import { CdpDomHandlers } from '../cdp/devtools.js';
+import { findCdpManager } from '../status/builders.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import type { ProviderModule } from '../providers/contracts.js';
@@ -85,12 +88,16 @@ export class DaemonCommandHandler implements CommandHelpers {
     get currentIdeType(): string | undefined { return this._currentIdeType; }
     get currentProviderType(): string | undefined { 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?: string): DaemonCdpManager | null {
         const key = ideType || this._currentIdeType;
         if (!key) return null;
-        const m = this._ctx.cdpManagers.get(key.toLowerCase());
+        // 1. Try instanceIdMap (UUID → managerKey)
+        const resolved = this._ctx.instanceIdMap?.get(key) || key;
+        // 2. Use findCdpManager (exact + prefix match)
+        const m = findCdpManager(this._ctx.cdpManagers, resolved.toLowerCase());
         if (m?.isConnected) return m;
         return null;
     }
@@ -177,11 +184,22 @@ export class DaemonCommandHandler implements CommandHelpers {
         return managed?.sessionId || null;
     }
 
-    /** Extract ideType from _targetInstance */
+    /** Extract ideType from _targetInstance or explicit ideType */
     private extractIdeType(args: any): string | undefined {
-        // Also accept explicit ideType from args (agentType for extensions)
-        if (args?.ideType && this._ctx.cdpManagers.has(args.ideType)) {
-            return args.ideType;
+        // Also accept explicit ideType from args (P2P input, agentType for extensions)
+        if (args?.ideType) {
+            // Exact match first
+            if (this._ctx.cdpManagers.has(args.ideType)) {
+                return args.ideType;
+            }
+            // Prefix match for multi-window (e.g. "cursor" matches "cursor_remote_vs")
+            const found = findCdpManager(this._ctx.cdpManagers, args.ideType);
+            if (found) {
+                // Return the actual key so getCdp() finds it
+                for (const [k, m] of this._ctx.cdpManagers.entries()) {
+                    if (m === found) return k;
+                }
+            }
         }
 
         if (args?._targetInstance) {
@@ -197,19 +215,24 @@ export class DaemonCommandHandler implements CommandHelpers {
                 return this._ctx.instanceIdMap.get(raw)!;
             }
 
-            // Direct CDP manager key match (e.g. "cursor", "antigravity")
+            // Direct CDP manager key match (e.g. "cursor", "cursor_remote_vs")
             if (this._ctx.cdpManagers.has(raw)) {
                 return raw;
             }
 
-            // Fallback: if no structured format matched and raw looks like a machine ID
-            // (e.g. "standalone_hostname"), find first available connected CDP
-            if (!ideMatch && !cliMatch && !acpMatch) {
-                for (const [key, mgr] of this._ctx.cdpManagers.entries()) {
-                    if (mgr.isConnected) return key;
+            // Prefix match for multi-window keys
+            const found = findCdpManager(this._ctx.cdpManagers, raw);
+            if (found) {
+                for (const [k, m] of this._ctx.cdpManagers.entries()) {
+                    if (m === found) return k;
                 }
             }
 
+            // Fallback removed: returning first-connected CDP was the root cause of
+            // input routing to wrong IDE (e.g. screenshot shows Cursor but input goes
+            // to Antigravity). If no match is found, return undefined so the caller
+            // gets an explicit error rather than silently routing to the wrong IDE.
+
             // Legacy: strip trailing _N suffix (e.g. "cursor_1" → "cursor")
             const lastUnderscore = raw.lastIndexOf('_');
             if (lastUnderscore > 0) {

package/src/commands/router.ts

@@ -48,6 +48,8 @@ export 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;
 }
 
 export interface CommandRouterResult {
@@ -257,12 +259,17 @@ export class DaemonCommandRouter {
                 try {
                     const { execSync } = await import('child_process');
 
+                    // Detect package: standalone uses @adhdev/daemon-standalone, cloud uses adhdev
+                    const isStandalone = this.deps.packageName === '@adhdev/daemon-standalone'
+                        || process.argv[1]?.includes('daemon-standalone');
+                    const pkgName = isStandalone ? '@adhdev/daemon-standalone' : 'adhdev';
+
                     // Check latest version
-                    const latest = execSync('npm view adhdev version', { encoding: 'utf-8', timeout: 10000 }).trim();
-                    LOG.info('Upgrade', `Latest available: v${latest}`);
+                    const latest = execSync(`npm view ${pkgName} version`, { encoding: 'utf-8', timeout: 10000 }).trim();
+                    LOG.info('Upgrade', `Latest ${pkgName}: v${latest}`);
 
                     // Install latest
-                    execSync('npm install -g adhdev@latest', {
+                    execSync(`npm install -g ${pkgName}@latest`, {
                         encoding: 'utf-8',
                         timeout: 60000,
                         stdio: ['pipe', 'pipe', 'pipe'],
@@ -272,8 +279,15 @@ export class DaemonCommandRouter {
                     // Schedule restart after response is sent
                     setTimeout(() => {
                         LOG.info('Upgrade', 'Restarting daemon with new version...');
+                        // Remove PID file so the new process doesn't see 'already running'
+                        try {
+                            const path = require('path');
+                            const fs = require('fs');
+                            const pidFile = path.join(process.env.HOME || process.env.USERPROFILE || '', '.adhdev', 'daemon.pid');
+                            if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile);
+                        } catch { /* ignore */ }
                         const { spawn } = require('child_process');
-                        const child = spawn(process.execPath, [process.argv[1], 'daemon', '-p', '19222'], {
+                        const child = spawn(process.execPath, process.argv.slice(1), {
                             detached: true,
                             stdio: 'ignore',
                             env: { ...process.env },

package/src/daemon/dev-server.ts

@@ -367,7 +367,10 @@ export class DevServer {
       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 — picked first connected manager');
+    }
     if (!cdp?.isConnected) {
       this.json(res, 503, { error: 'No CDP connection available' });
       return;
@@ -626,7 +629,7 @@ export 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;
@@ -2361,22 +2364,27 @@ export class DevServer {
     }
   }
 
-  /** 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(ideType?: string): DaemonCdpManager | null {
     if (ideType) {
       const cdp = this.cdpManagers.get(ideType);
       if (cdp?.isConnected) return cdp;
+      // Prefix match for multi-window keys
+      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;
     }
+    // No ideType — return first connected (dev convenience)
     for (const cdp of this.cdpManagers.values()) {
       if (cdp.isConnected) return cdp;
     }
     return null;
   }
 
-  private getAnyCdp(): DaemonCdpManager | null {
-    return this.getCdp();
-  }
-
   private json(res: http.ServerResponse, status: number, data: any): void {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data, null, 2));

package/src/index.ts

@@ -75,6 +75,7 @@ export type { CommandRouterDeps, CommandRouterResult } from './commands/router.j
 
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';
+export { buildManagedIdes, buildManagedClis, buildManagedAcps, buildAllManagedEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
 
 // ── Logger ──
 export { LOG, installGlobalInterceptor, setLogLevel, getLogLevel, getRecentLogs } from './logging/logger.js';

package/src/status/builders.ts

@@ -0,0 +1,210 @@
+/**
+ * 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.
+ */
+
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ManagedIdeEntry, ManagedCliEntry, ManagedAcpEntry } from '../shared-types.js';
+import type {
+    IdeProviderState,
+    CliProviderState,
+    AcpProviderState,
+    ProviderState,
+} from '../providers/provider-instance.js';
+
+// ─── CDP Manager lookup helpers ──────────────────────
+
+/**
+ * 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.
+ */
+export function findCdpManager(
+    cdpManagers: Map<string, DaemonCdpManager>,
+    key: string,
+): DaemonCdpManager | null {
+    // 1. Exact match (single-window: "cursor", or full managerKey: "cursor_remote_vs")
+    const exact = cdpManagers.get(key);
+    if (exact) return exact;
+
+    // 2. Prefix match (key = ideType like "cursor", managerKey = "cursor_remote_vs")
+    const prefix = key + '_';
+    for (const [k, m] of cdpManagers.entries()) {
+        if (k.startsWith(prefix) && m.isConnected) return m;
+    }
+
+    return null;
+}
+
+/**
+ * Check if any CDP manager matches the given key (exact or prefix).
+ */
+export function hasCdpManager(
+    cdpManagers: Map<string, DaemonCdpManager>,
+    key: string,
+): boolean {
+    if (cdpManagers.has(key)) return true;
+    const prefix = key + '_';
+    for (const k of cdpManagers.keys()) {
+        if (k.startsWith(prefix)) return true;
+    }
+    return false;
+}
+
+/**
+ * Check if any CDP manager matching the key is connected.
+ */
+export function isCdpConnected(
+    cdpManagers: Map<string, DaemonCdpManager>,
+    key: string,
+): boolean {
+    const m = findCdpManager(cdpManagers, key);
+    return m?.isConnected ?? false;
+}
+
+// ─── ProviderState → ManagedEntry builders ───────────
+
+/**
+ * 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
+ */
+export function buildManagedIdes(
+    ideStates: IdeProviderState[],
+    cdpManagers: Map<string, DaemonCdpManager>,
+    opts?: { detectedIdes?: { id: string; installed: boolean }[] },
+): ManagedIdeEntry[] {
+    const result: ManagedIdeEntry[] = [];
+
+    for (const state of ideStates) {
+        // Use cdpConnected from IdeProviderState if available (it checks internally),
+        // otherwise fall back to CDP manager lookup
+        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,
+        });
+    }
+
+    // Include CDPs with no ProviderInstance yet (newly detected IDEs)
+    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: undefined,
+                currentPlan: undefined,
+            });
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Convert CliProviderState[] → ManagedCliEntry[]
+ */
+export function buildManagedClis(
+    cliStates: CliProviderState[],
+): ManagedCliEntry[] {
+    return cliStates.map((s) => ({
+        id: s.instanceId,
+        instanceId: s.instanceId,
+        cliType: s.type,
+        cliName: s.name,
+        status: s.status,
+        mode: s.mode as 'terminal' | 'chat',
+        workspace: s.workspace || '',
+        activeChat: s.activeChat,
+    }));
+}
+
+/**
+ * Convert AcpProviderState[] → ManagedAcpEntry[]
+ */
+export function buildManagedAcps(
+    acpStates: AcpProviderState[],
+): ManagedAcpEntry[] {
+    return acpStates.map((s) => ({
+        id: s.instanceId,
+        acpType: s.type,
+        acpName: s.name,
+        status: s.status,
+        mode: 'chat' as const,
+        workspace: s.workspace || '',
+        activeChat: s.activeChat,
+        currentModel: s.currentModel,
+        currentPlan: s.currentPlan,
+        acpConfigOptions: s.acpConfigOptions,
+        acpModes: s.acpModes,
+        errorMessage: s.errorMessage,
+        errorReason: s.errorReason,
+    }));
+}
+
+/**
+ * Convenience: collect & build all managed entries from instanceManager
+ */
+export function buildAllManagedEntries(
+    allStates: ProviderState[],
+    cdpManagers: Map<string, DaemonCdpManager>,
+    opts?: { detectedIdes?: { id: string; installed: boolean }[] },
+): {
+    managedIdes: ManagedIdeEntry[];
+    managedClis: ManagedCliEntry[];
+    managedAcps: ManagedAcpEntry[];
+} {
+    const ideStates = allStates.filter((s): s is IdeProviderState => s.category === 'ide');
+    const cliStates = allStates.filter((s): s is CliProviderState => s.category === 'cli');
+    const acpStates = allStates.filter((s): s is AcpProviderState => s.category === 'acp');
+
+    return {
+        managedIdes: buildManagedIdes(ideStates, cdpManagers, opts),
+        managedClis: buildManagedClis(cliStates),
+        managedAcps: buildManagedAcps(acpStates),
+    };
+}

package/src/status/reporter.ts

@@ -12,13 +12,12 @@ import { getWorkspaceState } from '../config/workspaces.js';
 import { getHostMemorySnapshot } from '../system/host-memory.js';
 import { getWorkspaceActivity } from '../config/workspace-activity.js';
 import { LOG } from '../logging/logger.js';
-import type { ManagedIdeEntry, ManagedCliEntry, ManagedAcpEntry } from '../shared-types.js';
+import { buildAllManagedEntries } from './builders.js';
 import type {
     ProviderState,
     IdeProviderState,
     CliProviderState,
     AcpProviderState,
-    ExtensionProviderState,
 } from '../providers/provider-instance.js';
 
 // ─── Daemon dependency interface ──────────────────────
@@ -156,62 +155,13 @@ export class DaemonStatusReporter {
             }
         }
 
- // IDE states → managedIdes
-        const managedIdes: ManagedIdeEntry[] = 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,
-        }));
-
- // Merge/add Extension data
-
-
- // CLI states → managedClis
-        const managedClis: ManagedCliEntry[] = 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,
-        }));
-
- // ACP states → managedAcps
-        const managedAcps: ManagedAcpEntry[] = 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,
-        }));
+ // IDE/CLI/ACP states → managed entries (shared builder)
+        const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+            allStates,
+            this.deps.cdpManagers as Map<string, any>,
+        );
+
+
 
 
 
@@ -265,33 +215,30 @@ export class DaemonStatusReporter {
 
  // ═══ Server transmit (minimal routing meta only — sanitizeForRelay removes everything else) ═══
         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,
+        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,
-                })),
+            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,
-                })),
+            managedClis: managedClis.map(c => ({
+                id: c.id, cliType: c.cliType, cliName: c.cliName,
+            })),
  // managedAcps: server only saves id, type, name
-                managedAcps: managedAcps?.map((a: any) => ({
-                    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)`);
-        }
+            managedAcps: managedAcps?.map((a: any) => ({
+                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 ─────────────────────────────────────────