@adhdev/daemon-core 0.8.34 → 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.d.ts

@@ -0,0 +1,69 @@
+/**
+ * DaemonStatusReporter — status collect & transmit (StatusReport / P2P / StatusEvent)
+ *
+ * Collect status from ProviderInstanceManager → assemble payload → transmit
+ * Each Instance manages its own status/transition. This module only assembles + transmits.
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderState } from '../providers/provider-instance.js';
+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;
+    providerLoader: {
+        resolve(type: string): any;
+        getAll(): any[];
+    };
+    detectedIdes: any[];
+    instanceId: string;
+    daemonVersion?: string;
+    instanceManager: {
+        collectAllStates(): ProviderState[];
+        collectStatesByCategory(cat: string): ProviderState[];
+    };
+    getScreenshotUsage?: () => {
+        dailyUsedMinutes: number;
+        dailyBudgetMinutes: number;
+        budgetExhausted: boolean;
+    } | null;
+}
+export declare class DaemonStatusReporter {
+    private deps;
+    private log;
+    private lastStatusSentAt;
+    private statusPendingThrottle;
+    private lastP2PStatusHash;
+    private lastStatusSummary;
+    private statusTimer;
+    private p2pTimer;
+    constructor(deps: StatusReporterDeps, opts?: {
+        logFn?: (msg: string) => void;
+    });
+    startReporting(): void;
+    stopReporting(): void;
+    onStatusChange(): void;
+    throttledReport(): void;
+    emitStatusEvent(event: Record<string, unknown>): void;
+    removeAgentTracking(_key: string): void;
+    updateAgentStreams(_ideType: string, _streams: any[]): void;
+    /** Reset P2P dedup hash — forces next send to transmit even if content unchanged */
+    resetP2PHash(): void;
+    private ts;
+    private summarizeLargePayloadSessions;
+    sendUnifiedStatusReport(opts?: {
+        p2pOnly?: boolean;
+    }): Promise<void>;
+    private sendP2PPayload;
+    private simpleHash;
+}