@adhdev/daemon-core 0.8.35 → 0.8.36

package/src/status/builders.ts

@@ -17,7 +17,35 @@ import type {
     ExtensionProviderState,
     ProviderState,
 } from '../providers/provider-instance.js';
-import { normalizeActiveChatData, normalizeManagedStatus } from './normalize.js';
+import {
+    LIVE_STATUS_ACTIVE_CHAT_OPTIONS,
+    normalizeActiveChatData,
+    normalizeManagedStatus,
+    type NormalizeActiveChatOptions,
+} from './normalize.js';
+
+export type SessionEntryProfile = 'full' | 'live' | 'metadata';
+
+export interface SessionEntryBuildOptions {
+    profile?: SessionEntryProfile;
+}
+
+function getActiveChatOptions(profile: SessionEntryProfile): NormalizeActiveChatOptions {
+    if (profile === 'full') return {};
+    return LIVE_STATUS_ACTIVE_CHAT_OPTIONS;
+}
+
+function shouldIncludeSessionControls(profile: SessionEntryProfile): boolean {
+    return profile !== 'live';
+}
+
+function shouldIncludeSessionMetadata(profile: SessionEntryProfile): boolean {
+    return profile !== 'live';
+}
+
+function shouldIncludeRuntimeMetadata(profile: SessionEntryProfile): boolean {
+    return profile !== 'live';
+}
 
 // ─── CDP Manager lookup helpers ──────────────────────
 
@@ -186,33 +214,39 @@ const ACP_SESSION_CAPABILITIES: SessionCapability[] = [
 function buildIdeWorkspaceSession(
     state: IdeProviderState,
     cdpManagers: Map<string, DaemonCdpManager>,
+    options: SessionEntryBuildOptions,
 ): SessionEntry {
-    const activeChat = normalizeActiveChatData(state.activeChat);
+    const profile = options.profile || 'full';
+    const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
+    const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+    const includeSessionControls = shouldIncludeSessionControls(profile);
     const title = activeChat?.title || state.name;
     return {
         id: state.instanceId || state.type,
         parentId: null,
         providerType: state.type,
-        providerName: state.name,
+        ...(includeSessionMetadata && { providerName: state.name }),
         kind: 'workspace',
         transport: 'cdp-page',
         status: normalizeManagedStatus(activeChat?.status || state.status, {
             activeModal: activeChat?.activeModal || null,
         }),
         title,
-        workspace: state.workspace || null,
+        ...(includeSessionMetadata && { workspace: state.workspace || null }),
         activeChat,
-        capabilities: IDE_SESSION_CAPABILITIES,
+        ...(includeSessionMetadata && { capabilities: IDE_SESSION_CAPABILITIES }),
         cdpConnected: state.cdpConnected ?? isCdpConnected(cdpManagers, state.type),
         currentModel: state.currentModel,
         currentPlan: state.currentPlan,
         currentAutoApprove: state.currentAutoApprove,
-        controlValues: state.controlValues,
-        providerControls: buildFallbackControls(
-            state.providerControls,
-            state.currentModel,
-            state.currentPlan
-        ),
+        ...(includeSessionControls && {
+            controlValues: state.controlValues,
+            providerControls: buildFallbackControls(
+                state.providerControls,
+                state.currentModel,
+                state.currentPlan
+            ),
+        }),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
@@ -222,43 +256,53 @@ function buildIdeWorkspaceSession(
 function buildExtensionAgentSession(
     parent: IdeProviderState,
     ext: ExtensionProviderState,
+    options: SessionEntryBuildOptions,
 ): SessionEntry {
-    const activeChat = normalizeActiveChatData(ext.activeChat);
+    const profile = options.profile || 'full';
+    const activeChat = normalizeActiveChatData(ext.activeChat, getActiveChatOptions(profile));
+    const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+    const includeSessionControls = shouldIncludeSessionControls(profile);
     return {
         id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
         parentId: parent.instanceId || parent.type,
         providerType: ext.type,
-        providerName: ext.name,
+        ...(includeSessionMetadata && { providerName: ext.name }),
         kind: 'agent',
         transport: 'cdp-webview',
         status: normalizeManagedStatus(activeChat?.status || ext.status, {
             activeModal: activeChat?.activeModal || null,
         }),
         title: activeChat?.title || ext.name,
-        workspace: parent.workspace || null,
+        ...(includeSessionMetadata && { workspace: parent.workspace || null }),
         activeChat,
-        capabilities: EXTENSION_SESSION_CAPABILITIES,
+        ...(includeSessionMetadata && { capabilities: EXTENSION_SESSION_CAPABILITIES }),
         currentModel: ext.currentModel,
         currentPlan: ext.currentPlan,
-        controlValues: ext.controlValues,
-        providerControls: buildFallbackControls(
-            ext.providerControls,
-            ext.currentModel,
-            ext.currentPlan
-        ),
+        ...(includeSessionControls && {
+            controlValues: ext.controlValues,
+            providerControls: buildFallbackControls(
+                ext.providerControls,
+                ext.currentModel,
+                ext.currentPlan
+            ),
+        }),
         errorMessage: ext.errorMessage,
         errorReason: ext.errorReason,
         lastUpdated: ext.lastUpdated,
     };
 }
 
-function buildCliSession(state: CliProviderState): SessionEntry {
-    const activeChat = normalizeActiveChatData(state.activeChat);
+function buildCliSession(state: CliProviderState, options: SessionEntryBuildOptions): SessionEntry {
+    const profile = options.profile || 'full';
+    const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
+    const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+    const includeRuntimeMetadata = shouldIncludeRuntimeMetadata(profile);
+    const includeSessionControls = shouldIncludeSessionControls(profile);
     return {
         id: state.instanceId,
         parentId: null,
         providerType: state.type,
-        providerName: state.name,
+        ...(includeSessionMetadata && { providerName: state.name }),
         providerSessionId: state.providerSessionId,
         kind: 'agent',
         transport: 'pty',
@@ -266,54 +310,65 @@ function buildCliSession(state: CliProviderState): SessionEntry {
             activeModal: activeChat?.activeModal || null,
         }),
         title: activeChat?.title || state.name,
-        workspace: state.workspace || null,
-        runtimeKey: state.runtime?.runtimeKey,
-        runtimeDisplayName: state.runtime?.displayName,
-        runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
-        runtimeWriteOwner: state.runtime?.writeOwner || null,
-        runtimeAttachedClients: state.runtime?.attachedClients || [],
+        ...(includeSessionMetadata && { workspace: state.workspace || null }),
+        ...(includeRuntimeMetadata && {
+            runtimeKey: state.runtime?.runtimeKey,
+            runtimeDisplayName: state.runtime?.displayName,
+            runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
+            runtimeWriteOwner: state.runtime?.writeOwner || null,
+            runtimeAttachedClients: state.runtime?.attachedClients || [],
+        }),
         mode: state.mode,
         resume: state.resume,
         activeChat,
-        capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
-        controlValues: state.controlValues,
-        providerControls: buildFallbackControls(
-            state.providerControls
-        ),
+        ...(includeSessionMetadata && {
+            capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
+        }),
+        ...(includeSessionControls && {
+            controlValues: state.controlValues,
+            providerControls: buildFallbackControls(
+                state.providerControls
+            ),
+        }),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
     };
 }
 
-function buildAcpSession(state: AcpProviderState): SessionEntry {
-    const activeChat = normalizeActiveChatData(state.activeChat);
+function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOptions): SessionEntry {
+    const profile = options.profile || 'full';
+    const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
+    const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+    const includeSessionControls = shouldIncludeSessionControls(profile);
     return {
         id: state.instanceId,
         parentId: null,
         providerType: state.type,
-        providerName: state.name,
+        ...(includeSessionMetadata && { providerName: state.name }),
         kind: 'agent',
         transport: 'acp',
         status: normalizeManagedStatus(activeChat?.status || state.status, {
             activeModal: activeChat?.activeModal || null,
         }),
         title: activeChat?.title || state.name,
-        workspace: state.workspace || null,
+        ...(includeSessionMetadata && { workspace: state.workspace || null }),
         activeChat,
-        capabilities: ACP_SESSION_CAPABILITIES,
+        ...(includeSessionMetadata && { capabilities: ACP_SESSION_CAPABILITIES }),
         currentModel: state.currentModel,
         currentPlan: state.currentPlan,
-        acpConfigOptions: state.acpConfigOptions,
-        acpModes: state.acpModes,
-        controlValues: state.controlValues,
-        providerControls: buildFallbackControls(
-            state.providerControls,
-            state.currentModel,
-            state.currentPlan,
-            state.acpConfigOptions,
-            state.acpModes
-        ),
+        ...(includeSessionControls && {
+            acpConfigOptions: state.acpConfigOptions,
+            acpModes: state.acpModes,
+            controlValues: state.controlValues,
+            providerControls: buildFallbackControls(
+                state.providerControls,
+                state.currentModel,
+                state.currentPlan,
+                state.acpConfigOptions,
+                state.acpModes
+            ),
+        }),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
@@ -323,6 +378,7 @@ function buildAcpSession(state: AcpProviderState): SessionEntry {
 export function buildSessionEntries(
     allStates: ProviderState[],
     cdpManagers: Map<string, DaemonCdpManager>,
+    options: SessionEntryBuildOptions = {},
 ): SessionEntry[] {
     const sessions: SessionEntry[] = [];
 
@@ -331,18 +387,18 @@ export function buildSessionEntries(
     const acpStates = allStates.filter((s): s is AcpProviderState => s.category === 'acp');
 
     for (const state of ideStates) {
-        sessions.push(buildIdeWorkspaceSession(state, cdpManagers));
+        sessions.push(buildIdeWorkspaceSession(state, cdpManagers, options));
         for (const ext of state.extensions as ExtensionProviderState[]) {
-            sessions.push(buildExtensionAgentSession(state, ext));
+            sessions.push(buildExtensionAgentSession(state, ext, options));
         }
     }
 
     for (const state of cliStates) {
-        sessions.push(buildCliSession(state));
+        sessions.push(buildCliSession(state, options));
     }
 
     for (const state of acpStates) {
-        sessions.push(buildAcpSession(state));
+        sessions.push(buildAcpSession(state, options));
     }
 
     // Hide native IDE parent rows from inbox/recent surfaces when extension tabs exist.

package/src/status/normalize.ts

@@ -20,13 +20,39 @@ const WORKING_STATUSES = new Set([
     'active',
 ]);
 
-// Status snapshots are sent over P2P every 5s, so keep only a recent live window here.
-// Older history is fetched on demand via `chat_history`, and CLI terminals stream via runtime events.
-const STATUS_ACTIVE_CHAT_MESSAGE_LIMIT = 60;
-const STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT = 96 * 1024;
-const STATUS_ACTIVE_CHAT_STRING_LIMIT = 4 * 1024;
-const STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT = 1024;
-const STATUS_INPUT_CONTENT_LIMIT = 2 * 1024;
+export interface NormalizeActiveChatOptions {
+    includeMessages?: boolean;
+    includeInputContent?: boolean;
+    includeActiveModal?: boolean;
+    messageLimit?: number;
+    totalBytesLimit?: number;
+    stringLimit?: number;
+    fallbackStringLimit?: number;
+}
+
+// Full snapshots are still capped, but can carry recent chat context for API/inspection use.
+const FULL_STATUS_ACTIVE_CHAT_OPTIONS: Required<NormalizeActiveChatOptions> = {
+    includeMessages: true,
+    includeInputContent: true,
+    includeActiveModal: true,
+    messageLimit: 60,
+    totalBytesLimit: 96 * 1024,
+    stringLimit: 4 * 1024,
+    fallbackStringLimit: 1024,
+};
+
+// Live/metadata snapshots only need routing + UI summary. Current chat text is loaded
+// on demand via `read_chat`, and older history via `chat_history`.
+export const LIVE_STATUS_ACTIVE_CHAT_OPTIONS: Required<NormalizeActiveChatOptions> = {
+    includeMessages: false,
+    includeInputContent: false,
+    includeActiveModal: false,
+    messageLimit: 0,
+    totalBytesLimit: 0,
+    stringLimit: 512,
+    fallbackStringLimit: 256,
+};
+
 const STATUS_MODAL_MESSAGE_LIMIT = 2 * 1024;
 const STATUS_MODAL_BUTTON_LIMIT = 120;
 
@@ -81,23 +107,27 @@ function normalizeMessageTime(message: unknown): unknown {
     return msg;
 }
 
-function trimMessagesForStatus(messages: unknown[] | null | undefined): unknown[] {
+function trimMessagesForStatus(
+    messages: unknown[] | null | undefined,
+    options: Required<NormalizeActiveChatOptions>,
+): unknown[] {
+    if (!options.includeMessages || options.messageLimit <= 0 || options.totalBytesLimit <= 0) return [];
     if (!Array.isArray(messages) || messages.length === 0) return [];
 
-    const recent = messages.slice(-STATUS_ACTIVE_CHAT_MESSAGE_LIMIT);
+    const recent = messages.slice(-options.messageLimit);
     const kept: unknown[] = [];
     let totalBytes = 0;
 
     for (let i = recent.length - 1; i >= 0; i -= 1) {
-        let normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT));
+        let normalized = normalizeMessageTime(trimMessageForStatus(recent[i], options.stringLimit));
         let size = estimateBytes(normalized);
 
-        if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
-            normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT));
+        if (size > options.totalBytesLimit) {
+            normalized = normalizeMessageTime(trimMessageForStatus(recent[i], options.fallbackStringLimit));
             size = estimateBytes(normalized);
         }
 
-        if (kept.length > 0 && (totalBytes + size) > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+        if (kept.length > 0 && (totalBytes + size) > options.totalBytesLimit) {
             continue;
         }
 
@@ -143,20 +173,25 @@ export function isManagedStatusWaiting(
 
 export function normalizeActiveChatData<T extends ActiveChatData | null | undefined>(
     activeChat: T,
+    options: NormalizeActiveChatOptions = FULL_STATUS_ACTIVE_CHAT_OPTIONS,
 ): T {
     if (!activeChat) return activeChat;
+    const resolvedOptions: Required<NormalizeActiveChatOptions> = {
+        ...FULL_STATUS_ACTIVE_CHAT_OPTIONS,
+        ...options,
+    };
     return {
         ...activeChat,
         status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),
-        messages: trimMessagesForStatus(activeChat.messages) as T extends { messages: infer M } ? M : never,
-        activeModal: activeChat.activeModal ? {
+        messages: trimMessagesForStatus(activeChat.messages, resolvedOptions) as T extends { messages: infer M } ? M : never,
+        activeModal: resolvedOptions.includeActiveModal && 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,
-        inputContent: activeChat.inputContent
-            ? truncateString(activeChat.inputContent, STATUS_INPUT_CONTENT_LIMIT)
-            : activeChat.inputContent,
+        } : null,
+        inputContent: resolvedOptions.includeInputContent && activeChat.inputContent
+            ? truncateString(activeChat.inputContent, 2 * 1024)
+            : undefined,
     } as T;
 }

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;
@@ -94,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 */ }
@@ -189,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,
@@ -197,9 +268,9 @@ export class DaemonStatusReporter {
                     peers: p2p?.connectedPeerCount || 0,
                     screenshotActive: p2p?.screenshotActive || false,
                 },
+                profile: 'live',
             }),
             screenshotUsage: this.deps.getScreenshotUsage?.() || null,
-            connectedExtensions: [],
         };
 
 // ═══ P2P transmit ═══
@@ -219,17 +290,16 @@ export class DaemonStatusReporter {
         if (opts?.p2pOnly) return;
         // Server relay only needs compact session metadata for routing, compact status,
         // initial_state fallback, and lightweight API/session inspection.
-        const wsPayload = {
-            daemonMode: true,
+        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,
@@ -238,8 +308,6 @@ export class DaemonStatusReporter {
             })),
             p2p: payload.p2p,
             timestamp: now,
-            detectedIdes: payload.detectedIdes,
-            availableProviders: payload.availableProviders,
         };
         const wsHash = this.simpleHash(JSON.stringify({
             ...wsPayload,
@@ -258,12 +326,19 @@ export class DaemonStatusReporter {
 
     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;