@adhdev/daemon-core 0.8.34 → 0.8.36

package/src/status/reporter.ts

@@ -8,6 +8,7 @@
 import { LOG } from '../logging/logger.js';
 import type { DaemonCdpManager } from '../cdp/manager.js';
 import type { MachineInfo } from '../shared-types.js';
+import type { CloudStatusReportPayload, DaemonStatusEventPayload } from '../shared-types.js';
 import { buildSessionEntries } from './builders.js';
 import { buildStatusSnapshot } from './snapshot.js';
 import type {
@@ -22,7 +23,15 @@ import type {
 export interface StatusReporterDeps {
     serverConn: { isConnected(): boolean; sendMessage(type: string, data: any): void; getUserPlan(): string } | null;
     cdpManagers: Map<string, DaemonCdpManager>;
-    p2p: { isConnected: boolean; isAvailable: boolean; connectionState: string; connectedPeerCount: number; screenshotActive: boolean; sendStatus(data: any): void } | null;
+    p2p: {
+        isConnected: boolean;
+        isAvailable: boolean;
+        connectionState: string;
+        connectedPeerCount: number;
+        screenshotActive: boolean;
+        sendStatus(data: any): void;
+        sendStatusEvent(event: DaemonStatusEventPayload): void;
+    } | null;
     providerLoader: { resolve(type: string): any; getAll(): any[] };
     detectedIdes: any[];
     instanceId: string;
@@ -38,6 +47,7 @@ export class DaemonStatusReporter {
     private lastStatusSentAt = 0;
     private statusPendingThrottle = false;
     private lastP2PStatusHash = '';
+    private lastServerStatusHash = '';
     private lastStatusSummary = '';
 
     private statusTimer: NodeJS.Timeout | null = null;
@@ -52,12 +62,12 @@ export class DaemonStatusReporter {
 
     startReporting(): void {
         setTimeout(() => {
-            this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Initial report failed: ${e?.message}`));
+            this.sendUnifiedStatusReport({ forceServer: true, reason: 'initial' }).catch(e => LOG.warn('Status', `Initial report failed: ${e?.message}`));
         }, 2000);
 
         const scheduleServerReport = () => {
             this.statusTimer = setTimeout(() => {
-                this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Periodic report failed: ${e?.message}`));
+                this.sendUnifiedStatusReport({ forceServer: true, reason: 'periodic' }).catch(e => LOG.warn('Status', `Periodic report failed: ${e?.message}`));
                 scheduleServerReport();
             }, 30_000);
         };
@@ -93,10 +103,73 @@ export class DaemonStatusReporter {
         }
     }
 
+    private toDaemonStatusEventName(value: unknown): DaemonStatusEventPayload['event'] | null {
+        switch (value) {
+            case 'agent:generating_started':
+            case 'agent:waiting_approval':
+            case 'agent:generating_completed':
+            case 'agent:stopped':
+            case 'monitor:long_generating':
+                return value;
+            default:
+                return null;
+        }
+    }
+
+    private buildServerStatusEvent(event: Record<string, unknown>): DaemonStatusEventPayload | null {
+        const eventName = this.toDaemonStatusEventName(event.event);
+        if (!eventName) return null;
+
+        // Provider UI effects can carry arbitrary text content and are not required
+        // for server-side routing, push, or dashboard session targeting.
+        if (eventName.startsWith('provider:')) {
+            return null;
+        }
+
+        const payload: DaemonStatusEventPayload = {
+            event: eventName,
+            timestamp: typeof event.timestamp === 'number' && Number.isFinite(event.timestamp)
+                ? event.timestamp
+                : Date.now(),
+        };
+
+        if (typeof event.targetSessionId === 'string' && event.targetSessionId.trim()) {
+            payload.targetSessionId = event.targetSessionId.trim();
+        }
+        const providerType = typeof event.providerType === 'string' && event.providerType.trim()
+            ? event.providerType.trim()
+            : (typeof event.ideType === 'string' && event.ideType.trim() ? event.ideType.trim() : '');
+        if (providerType) {
+            payload.providerType = providerType;
+        }
+        if (typeof event.duration === 'number' && Number.isFinite(event.duration)) {
+            payload.duration = event.duration;
+        }
+        if (typeof event.elapsedSec === 'number' && Number.isFinite(event.elapsedSec)) {
+            payload.elapsedSec = event.elapsedSec;
+        }
+        if (typeof event.modalMessage === 'string' && event.modalMessage.trim()) {
+            payload.modalMessage = event.modalMessage;
+        }
+        if (Array.isArray(event.modalButtons)) {
+            const modalButtons = event.modalButtons
+                .filter((button): button is string => typeof button === 'string' && button.trim().length > 0);
+            if (modalButtons.length > 0) {
+                payload.modalButtons = modalButtons;
+            }
+        }
+
+        return payload;
+    }
+
     emitStatusEvent(event: Record<string, unknown>): void {
         LOG.info('StatusEvent', `${event.event} (${event.providerType || event.ideType || ''})`);
-        // Send via WS (server relay → dashboard + push notifications)
-        this.deps.serverConn?.sendMessage('status_event', event);
+        const serverEvent = this.buildServerStatusEvent(event);
+        if (!serverEvent) return;
+        // Dashboard delivery is P2P-only, but the server still receives the event
+        // for push notifications, webhook dispatch, and audit-side effects.
+        this.deps.p2p?.sendStatusEvent(serverEvent);
+        this.deps.serverConn?.sendMessage('status_event', serverEvent);
     }
 
     removeAgentTracking(_key: string): void { /* Managed by Instance itself */ }
@@ -135,7 +208,7 @@ export class DaemonStatusReporter {
             .join(', ');
     }
 
-    async sendUnifiedStatusReport(opts?: { p2pOnly?: boolean }): Promise<void> {
+    async sendUnifiedStatusReport(opts?: { p2pOnly?: boolean; forceServer?: boolean; reason?: string }): Promise<void> {
         const { serverConn, p2p } = this.deps;
         if (!serverConn?.isConnected()) return;
         this.lastStatusSentAt = Date.now();
@@ -188,7 +261,6 @@ export class DaemonStatusReporter {
                 detectedIdes: this.deps.detectedIdes || [],
                 instanceId: this.deps.instanceId,
                 version: this.deps.daemonVersion || 'unknown',
-                daemonMode: true,
                 timestamp: now,
                 p2p: {
                     available: p2p?.isAvailable || false,
@@ -196,9 +268,9 @@ export class DaemonStatusReporter {
                     peers: p2p?.connectedPeerCount || 0,
                     screenshotActive: p2p?.screenshotActive || false,
                 },
+                profile: 'live',
             }),
             screenshotUsage: this.deps.getScreenshotUsage?.() || null,
-            connectedExtensions: [],
         };
 
 // ═══ P2P transmit ═══
@@ -216,51 +288,57 @@ export class DaemonStatusReporter {
 
  // ═══ Server transmit (minimal routing meta only) ═══
         if (opts?.p2pOnly) return;
-        const wsPayload = {
-            daemonMode: true,
+        // Server relay only needs compact session metadata for routing, compact status,
+        // initial_state fallback, and lightweight API/session inspection.
+        const wsPayload: CloudStatusReportPayload = {
             sessions: sessions.map((session) => ({
                 id: session.id,
                 parentId: session.parentId,
                 providerType: session.providerType,
-                providerName: session.providerName,
+                providerName: session.providerName || session.providerType,
                 kind: session.kind,
                 transport: session.transport,
                 status: session.status,
-                workspace: session.workspace,
+                workspace: session.workspace ?? null,
                 title: session.title,
                 cdpConnected: session.cdpConnected,
                 currentModel: session.currentModel,
                 currentPlan: session.currentPlan,
                 currentAutoApprove: session.currentAutoApprove,
-                lastUpdated: session.lastUpdated,
-                unread: session.unread,
-                lastSeenAt: session.lastSeenAt,
-                inboxBucket: session.inboxBucket,
-                surfaceHidden: session.surfaceHidden,
-                controlValues: session.controlValues,
-                providerControls: session.providerControls,
-                acpConfigOptions: session.acpConfigOptions,
-                acpModes: session.acpModes,
             })),
             p2p: payload.p2p,
             timestamp: now,
-            detectedIdes: payload.detectedIdes,
-            availableProviders: payload.availableProviders,
         };
+        const wsHash = this.simpleHash(JSON.stringify({
+            ...wsPayload,
+            timestamp: undefined,
+        }));
+        if (!opts?.forceServer && wsHash === this.lastServerStatusHash) {
+            LOG.debug('Server', `skip duplicate status_report${opts?.reason ? ` (${opts.reason})` : ''}`);
+            return;
+        }
+        this.lastServerStatusHash = wsHash;
         serverConn.sendMessage('status_report', wsPayload);
-        LOG.debug('Server', `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
+        LOG.debug('Server', `sent status_report (${JSON.stringify(wsPayload).length} bytes)${opts?.reason ? ` [${opts.reason}]` : ''}`);
     }
 
  // ─── P2P ─────────────────────────────────────────
 
     private sendP2PPayload(payload: { timestamp?: number; system?: unknown; machine?: MachineInfo; [key: string]: unknown }): boolean {
         const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
+        const sessions = Array.isArray(hashTarget.sessions)
+            ? hashTarget.sessions.map((session) => {
+                if (!session || typeof session !== 'object') return session;
+                const { lastUpdated: _lu, ...stableSession } = session as Record<string, unknown>;
+                return stableSession;
+            })
+            : hashTarget.sessions;
         const hashPayload = hashTarget.machine
             ? (() => {
                 const { freeMem: _f, availableMem: _a, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine;
-                return { ...hashTarget, machine: stableMachine };
+                return { ...hashTarget, sessions, machine: stableMachine };
             })()
-            : hashTarget;
+            : { ...hashTarget, sessions };
         const h = this.simpleHash(JSON.stringify(hashPayload));
         if (h !== this.lastP2PStatusHash) {
             this.lastP2PStatusHash = h;

package/src/status/snapshot.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared status snapshot builders.
+ *
+ * Used by:
+ * - DaemonStatusReporter (cloud)
+ * - daemon-standalone HTTP/WS status responses
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderState } from '../providers/provider-instance.js';
+import type { AvailableProviderInfo, StatusReportPayload } from '../shared-types.js';
+export interface StatusSnapshotOptions {
+    allStates: ProviderState[];
+    cdpManagers: Map<string, DaemonCdpManager>;
+    providerLoader: {
+        getAll(): Array<{
+            type: string;
+            icon?: string;
+            displayName?: string;
+            category: 'ide' | 'extension' | 'cli' | 'acp';
+        }>;
+        getAvailableProviderInfos?: () => Array<{
+            type: string;
+            icon?: string;
+            displayName?: string;
+            category: 'ide' | 'extension' | 'cli' | 'acp';
+            installed?: boolean;
+            detectedPath?: string | null;
+        }>;
+    };
+    detectedIdes: Array<{
+        id: string;
+        name?: string;
+        displayName?: string;
+        installed?: boolean;
+        path?: string;
+    }>;
+    instanceId: string;
+    version: string;
+    daemonMode: boolean;
+    timestamp?: number;
+    p2p?: StatusReportPayload['p2p'];
+    machineNickname?: string | null;
+}
+export interface StatusSnapshot extends StatusReportPayload {
+    availableProviders: AvailableProviderInfo[];
+}
+export declare function getSessionCompletionMarker(session: {
+    activeChat?: {
+        messages?: Array<{
+            role?: string;
+            id?: string;
+            index?: number;
+            receivedAt?: number | string;
+            _turnKey?: string;
+        }> | null;
+    } | null;
+}): string;
+export declare function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnapshot;

package/src/status/snapshot.ts

@@ -15,11 +15,12 @@ import { getHostMemorySnapshot } from '../system/host-memory.js';
 import { getTerminalBackendRuntimeStatus } from '../cli-adapters/terminal-screen.js';
 import { LOG } from '../logging/logger.js';
 import type { DaemonCdpManager } from '../cdp/manager.js';
-import { buildSessionEntries, isCdpConnected } from './builders.js';
+import { buildSessionEntries, isCdpConnected, type SessionEntryProfile } from './builders.js';
 import type { ProviderState } from '../providers/provider-instance.js';
 import type {
     AvailableProviderInfo,
     DetectedIdeInfo,
+    MachineInfo,
     RecentLaunchEntry,
     RecentSessionBucket,
     SessionEntry,
@@ -54,15 +55,13 @@ export interface StatusSnapshotOptions {
     }>;
     instanceId: string;
     version: string;
-    daemonMode: boolean;
     timestamp?: number;
     p2p?: StatusReportPayload['p2p'];
     machineNickname?: string | null;
+    profile?: SessionEntryProfile;
 }
 
-export interface StatusSnapshot extends StatusReportPayload {
-    availableProviders: AvailableProviderInfo[];
-}
+export type StatusSnapshot = StatusReportPayload;
 
 const READ_DEBUG_ENABLED = process.argv.includes('--dev') || process.env.ADHDEV_READ_DEBUG === '1';
 
@@ -103,6 +102,41 @@ function buildAvailableProviders(
     }));
 }
 
+export function buildMachineInfo(profile: 'full' | 'live' | 'metadata' = 'full'): MachineInfo {
+    const base: MachineInfo = {
+        hostname: os.hostname(),
+        platform: os.platform(),
+    };
+
+    if (profile === 'live') {
+        return base;
+    }
+
+    if (profile === 'metadata') {
+        const memSnap = getHostMemorySnapshot();
+        return {
+            ...base,
+            arch: os.arch(),
+            cpus: os.cpus().length,
+            totalMem: memSnap.totalMem,
+            release: os.release(),
+        };
+    }
+
+    const memSnap = getHostMemorySnapshot();
+    return {
+        ...base,
+        arch: os.arch(),
+        cpus: os.cpus().length,
+        totalMem: memSnap.totalMem,
+        freeMem: memSnap.freeMem,
+        availableMem: memSnap.availableMem,
+        loadavg: os.loadavg(),
+        uptime: os.uptime(),
+        release: os.release(),
+    };
+}
+
 function parseMessageTime(value: unknown): number {
     if (typeof value === 'number' && Number.isFinite(value)) return value;
     if (typeof value === 'string') {
@@ -207,28 +241,39 @@ function buildRecentLaunches(
 }
 
 export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnapshot {
+    const profile = options.profile || 'full';
     const cfg = loadConfig();
     const state = loadState();
     const wsState = getWorkspaceState(cfg);
-    const memSnap = getHostMemorySnapshot();
     const recentActivity = getRecentActivity(state, 20);
-    const sessions = buildSessionEntries(
+    const unreadSourceSessions = buildSessionEntries(
         options.allStates,
         options.cdpManagers,
+        { profile: 'full' },
     );
-    for (const session of sessions) {
-        const lastSeenAt = getSessionSeenAt(state, session.id);
-        const seenCompletionMarker = getSessionSeenMarker(state, session.id);
-        const lastUsedAt = getSessionLastUsedAt(session);
-        const completionMarker = getSessionCompletionMarker(session);
-        const { unread, inboxBucket } = session.surfaceHidden
+    const sessions = profile === 'full'
+        ? unreadSourceSessions
+        : buildSessionEntries(
+            options.allStates,
+            options.cdpManagers,
+            { profile },
+        );
+    const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+    for (const sourceSession of unreadSourceSessions) {
+        const session = sessionsById.get(sourceSession.id);
+        if (!session) continue;
+        const lastSeenAt = getSessionSeenAt(state, sourceSession.id);
+        const seenCompletionMarker = getSessionSeenMarker(state, sourceSession.id);
+        const lastUsedAt = getSessionLastUsedAt(sourceSession);
+        const completionMarker = getSessionCompletionMarker(sourceSession);
+        const { unread, inboxBucket } = sourceSession.surfaceHidden
             ? { unread: false, inboxBucket: 'idle' as RecentSessionBucket }
             : getUnreadState(
-                getSessionMessageUpdatedAt(session) > 0,
-                session.status,
+                getSessionMessageUpdatedAt(sourceSession) > 0,
+                sourceSession.status,
                 lastUsedAt,
                 lastSeenAt,
-                getLastMessageRole(session),
+                getLastMessageRole(sourceSession),
                 completionMarker,
                 seenCompletionMarker,
             );
@@ -238,39 +283,32 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
         if (READ_DEBUG_ENABLED && (session.unread || session.inboxBucket !== 'idle' || session.providerType.includes('codex'))) {
             LOG.info(
                 'RecentRead',
-                `snapshot session id=${session.id} provider=${session.providerType} status=${String(session.status || '')} bucket=${inboxBucket} unread=${String(unread)} lastSeenAt=${lastSeenAt} completionMarker=${completionMarker || '-'} seenMarker=${seenCompletionMarker || '-'} lastUpdated=${String(session.lastUpdated || 0)} lastUsedAt=${lastUsedAt} lastRole=${getLastMessageRole(session)} msgUpdatedAt=${getSessionMessageUpdatedAt(session)}`,
+                `snapshot session id=${session.id} provider=${session.providerType} status=${String(session.status || '')} bucket=${inboxBucket} unread=${String(unread)} lastSeenAt=${lastSeenAt} completionMarker=${completionMarker || '-'} seenMarker=${seenCompletionMarker || '-'} lastUpdated=${String(session.lastUpdated || 0)} lastUsedAt=${lastUsedAt} lastRole=${getLastMessageRole(sourceSession)} msgUpdatedAt=${getSessionMessageUpdatedAt(sourceSession)}`,
             );
         }
     }
-    const terminalBackend = getTerminalBackendRuntimeStatus();
+    const includeMachineMetadata = profile !== 'live';
+    const terminalBackend = includeMachineMetadata
+        ? getTerminalBackendRuntimeStatus()
+        : undefined;
 
     return {
         instanceId: options.instanceId,
-        version: options.version,
-        daemonMode: options.daemonMode,
-        machine: {
-            hostname: os.hostname(),
-            platform: os.platform(),
-            arch: os.arch(),
-            cpus: os.cpus().length,
-            totalMem: memSnap.totalMem,
-            freeMem: memSnap.freeMem,
-            availableMem: memSnap.availableMem,
-            loadavg: os.loadavg(),
-            uptime: os.uptime(),
-            release: os.release(),
-        },
-        machineNickname: options.machineNickname ?? cfg.machineNickname ?? null,
+        ...(includeMachineMetadata ? { version: options.version } : {}),
+        machine: buildMachineInfo(profile),
+        ...(includeMachineMetadata ? { machineNickname: options.machineNickname ?? cfg.machineNickname ?? null } : {}),
         timestamp: options.timestamp ?? Date.now(),
-        detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
         ...(options.p2p ? { p2p: options.p2p } : {}),
         sessions,
-        workspaces: wsState.workspaces,
-        defaultWorkspaceId: wsState.defaultWorkspaceId,
-        defaultWorkspacePath: wsState.defaultWorkspacePath,
-        terminalSizingMode: cfg.terminalSizingMode || 'measured',
-        recentLaunches: buildRecentLaunches(recentActivity),
-        terminalBackend,
-        availableProviders: buildAvailableProviders(options.providerLoader),
+        ...(terminalBackend ? { terminalBackend } : {}),
+        ...(includeMachineMetadata && {
+            detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
+            workspaces: wsState.workspaces,
+            defaultWorkspaceId: wsState.defaultWorkspaceId,
+            defaultWorkspacePath: wsState.defaultWorkspacePath,
+            terminalSizingMode: cfg.terminalSizingMode || 'measured',
+            recentLaunches: buildRecentLaunches(recentActivity),
+            availableProviders: buildAvailableProviders(options.providerLoader),
+        }),
     };
 }

package/src/system/host-memory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Host memory metrics — macOS-aware "available" memory.
+ *
+ * Node's os.freemem() on darwin reports only the tiny truly-free pool; most RAM
+ * sits in inactive/file-backed cache that the OS can reclaim. Dashboard "used %"
+ * based on (total - freemem) looks ~99% almost always — misleading.
+ *
+ * On macOS we parse `vm_stat` and approximate available bytes as:
+ *   (free + inactive + speculative + purgeable [+ file_backed]) × page size
+ * (aligned with common Activity Monitor–style interpretations.)
+ */
+export interface HostMemorySnapshot {
+    totalMem: number;
+    /** Raw kernel "free" — small on macOS; kept for debugging / API compat */
+    freeMem: number;
+    /** Use this for UI "used %" — on darwin from vm_stat; else equals freeMem */
+    availableMem: number;
+}
+export declare function getHostMemorySnapshot(): HostMemorySnapshot;

package/src/types.d.ts

@@ -4,7 +4,7 @@
  * Shared types referenced by daemon-core, daemon-standalone, and web-core.
  * When modifying this file, also update interface contracts in AGENT_PROTOCOL.md.
  */
-import type { StatusReportPayload } from './shared-types.js';
+import type { StatusReportPayload, AvailableProviderInfo } from './shared-types.js';
 /** Full status response from /api/v1/status and WS events */
 export interface StatusResponse extends StatusReportPayload {
     /** For standalone API compat */
@@ -15,7 +15,7 @@ export interface StatusResponse extends StatusReportPayload {
     /** User display name from config */
     userName?: string;
     /** Available providers */
-    availableProviders: ProviderInfo[];
+    availableProviders: AvailableProviderInfo[];
     /** System info (legacy compat) */
     system?: SystemInfo;
 }
@@ -111,11 +111,7 @@ export interface DetectedIde {
     installed: boolean;
     running: boolean;
 }
-export interface ProviderInfo {
-    type: string;
-    icon: string;
-    displayName: string;
-    category: string;
+export interface ProviderInfo extends AvailableProviderInfo {
 }
 /** Flattened agent entry from /api/v1/agents */
 export interface AgentEntry {

package/src/types.ts

@@ -18,7 +18,7 @@ export interface StatusResponse extends StatusReportPayload {
   /** User display name from config */
   userName?: string;
   /** Available providers */
-  availableProviders: AvailableProviderInfo[];
+  availableProviders?: AvailableProviderInfo[];
   /** System info (legacy compat) */
   system?: SystemInfo;
 }