@adhdev/daemon-core 0.8.35 → 0.8.36

package/dist/status/snapshot.d.ts

@@ -6,8 +6,9 @@
  * - daemon-standalone HTTP/WS status responses
  */
 import type { DaemonCdpManager } from '../cdp/manager.js';
+import { type SessionEntryProfile } from './builders.js';
 import type { ProviderState } from '../providers/provider-instance.js';
-import type { AvailableProviderInfo, StatusReportPayload } from '../shared-types.js';
+import type { MachineInfo, StatusReportPayload } from '../shared-types.js';
 export interface StatusSnapshotOptions {
     allStates: ProviderState[];
     cdpManagers: Map<string, DaemonCdpManager>;
@@ -36,14 +37,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;
+export declare function buildMachineInfo(profile?: 'full' | 'live' | 'metadata'): MachineInfo;
 export declare function getSessionCompletionMarker(session: {
     activeChat?: {
         messages?: Array<{

package/dist/types.d.ts

@@ -15,7 +15,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;
 }

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.35",
+  "version": "0.8.36",
   "description": "ADHDev local session host core — session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.8.35",
+  "version": "0.8.36",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/boot/daemon-lifecycle.ts

@@ -68,6 +68,11 @@ export interface DaemonInitConfig {
 
     /** CDP scan interval (ms), default 30000 */
     cdpScanIntervalMs?: number;
+
+    /** Canonical status identity used by on-demand snapshot commands */
+    statusInstanceId?: string;
+    statusVersion?: string;
+    statusDaemonMode?: boolean;
 }
 
 // ─── Result ───
@@ -276,6 +281,8 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         onStatusChange: config.onStatusChange,
         onPostChatCommand: config.onPostChatCommand,
         sessionHostControl: config.sessionHostControl,
+        statusInstanceId: config.statusInstanceId,
+        statusVersion: config.statusVersion,
         getCdpLogFn: config.getCdpLogFn || ((ideType: string) => LOG.forComponent(`CDP:${ideType}`).asLogFn()),
     });
 

package/src/commands/chat-commands.ts

@@ -5,15 +5,30 @@
 
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
-import type { ProviderModule, ProviderScripts } from '../providers/contracts.js';
+import { flattenContent, type ProviderModule, type ProviderScripts } from '../providers/contracts.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
-import type { SessionTransport } from '../shared-types.js';
+import type { ChatMessage } from '../types.js';
+import type { ReadChatCursor, ReadChatSyncMode, SessionTransport } from '../shared-types.js';
 
 const RECENT_SEND_WINDOW_MS = 1200;
 const recentSendByTarget = new Map<string, number>();
 
+function hashSignatureParts(parts: string[]): string {
+    let hash = 0x811c9dc5;
+    for (const part of parts) {
+        const text = String(part || '');
+        for (let i = 0; i < text.length; i += 1) {
+            hash ^= text.charCodeAt(i);
+            hash = Math.imul(hash, 0x01000193) >>> 0;
+        }
+        hash ^= 0xff;
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, '0');
+}
+
 interface ApprovalSelectableInstance extends ProviderInstance {
     recordApprovalSelection?(buttonText: string): void;
 }
@@ -113,6 +128,163 @@ function parseMaybeJson(value: any): any {
     }
 }
 
+function getChatMessageSignature(message: ChatMessage | null | undefined): string {
+    if (!message) return '';
+    let content = '';
+    try {
+        content = JSON.stringify(message.content ?? '');
+    } catch {
+        content = String(message.content ?? '');
+    }
+    return hashSignatureParts([
+        String(message.id || ''),
+        String(message.index ?? ''),
+        String(message.role || ''),
+        String(message.receivedAt ?? message.timestamp ?? ''),
+        content,
+    ]);
+}
+
+function normalizeReadChatCursor(args: any): Required<ReadChatCursor> {
+    const knownMessageCount = Math.max(0, Number(args?.knownMessageCount || 0));
+    const lastMessageSignature = typeof args?.lastMessageSignature === 'string'
+        ? args.lastMessageSignature
+        : '';
+    const tailLimit = Math.max(0, Number(args?.tailLimit || 0));
+    return { knownMessageCount, lastMessageSignature, tailLimit };
+}
+
+function normalizeReadChatMessages(payload: Record<string, any>): ChatMessage[] {
+    const messages = Array.isArray(payload.messages) ? payload.messages as ChatMessage[] : [];
+    return messages;
+}
+
+function deriveHistoryDedupKey(message: ChatMessage & { _unitKey?: string; _turnKey?: string }): string | undefined {
+    const unitKey = typeof message._unitKey === 'string' ? message._unitKey.trim() : '';
+    if (unitKey) return `read_chat:${unitKey}`;
+
+    const turnKey = typeof message._turnKey === 'string' ? message._turnKey.trim() : '';
+    if (!turnKey) return undefined;
+
+    let content = '';
+    try {
+        content = JSON.stringify(message.content ?? '');
+    } catch {
+        content = String(message.content ?? '');
+    }
+    return `read_chat:${turnKey}:${String(message.role || '').toLowerCase()}:${content}`;
+}
+
+function toHistoryPersistedMessages(messages: ChatMessage[]): Array<{
+    role: string;
+    content: string;
+    receivedAt?: number;
+    kind?: string;
+    senderName?: string;
+    historyDedupKey?: string;
+}> {
+    return messages.map((message) => ({
+        role: message.role,
+        content: flattenContent(message.content),
+        receivedAt: typeof message.receivedAt === 'number' ? message.receivedAt : undefined,
+        kind: typeof message.kind === 'string' ? message.kind : undefined,
+        senderName: typeof message.senderName === 'string' ? message.senderName : undefined,
+        historyDedupKey: deriveHistoryDedupKey(message as ChatMessage & { _unitKey?: string; _turnKey?: string }),
+    }));
+}
+
+function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatCursor>): {
+    syncMode: ReadChatSyncMode;
+    replaceFrom: number;
+    messages: ChatMessage[];
+    totalMessages: number;
+    lastMessageSignature: string;
+} {
+    const totalMessages = messages.length;
+    const lastMessageSignature = getChatMessageSignature(messages[totalMessages - 1]);
+    const { knownMessageCount, lastMessageSignature: knownSignature } = cursor;
+
+    if (!knownMessageCount || !knownSignature) {
+        return {
+            syncMode: 'full',
+            replaceFrom: 0,
+            messages,
+            totalMessages,
+            lastMessageSignature,
+        };
+    }
+
+    if (knownMessageCount > totalMessages) {
+        return {
+            syncMode: 'full',
+            replaceFrom: 0,
+            messages,
+            totalMessages,
+            lastMessageSignature,
+        };
+    }
+
+    if (knownMessageCount === totalMessages && knownSignature === lastMessageSignature) {
+        return {
+            syncMode: 'noop',
+            replaceFrom: totalMessages,
+            messages: [],
+            totalMessages,
+            lastMessageSignature,
+        };
+    }
+
+    if (knownMessageCount < totalMessages) {
+        const anchorSignature = getChatMessageSignature(messages[knownMessageCount - 1]);
+        if (anchorSignature === knownSignature) {
+            return {
+                syncMode: 'append',
+                replaceFrom: knownMessageCount,
+                messages: messages.slice(knownMessageCount),
+                totalMessages,
+                lastMessageSignature,
+            };
+        }
+    }
+
+    const replaceFrom = Math.max(0, Math.min(knownMessageCount - 1, totalMessages));
+    return {
+        syncMode: replaceFrom === 0 ? 'full' : 'replace_tail',
+        replaceFrom,
+        messages: replaceFrom === 0 ? messages : messages.slice(replaceFrom),
+        totalMessages,
+        lastMessageSignature,
+    };
+}
+
+function buildReadChatCommandResult(payload: Record<string, any>, args: any): CommandResult {
+    const messages = normalizeReadChatMessages(payload);
+    const cursor = normalizeReadChatCursor(args);
+    if (!cursor.knownMessageCount && !cursor.lastMessageSignature && cursor.tailLimit > 0 && messages.length > cursor.tailLimit) {
+        const tailMessages = messages.slice(-cursor.tailLimit);
+        const lastMessageSignature = getChatMessageSignature(tailMessages[tailMessages.length - 1]);
+        return {
+            success: true,
+            ...payload,
+            messages: tailMessages,
+            syncMode: 'full',
+            replaceFrom: 0,
+            totalMessages: messages.length,
+            lastMessageSignature,
+        };
+    }
+    const sync = computeReadChatSync(messages, cursor);
+    return {
+        success: true,
+        ...payload,
+        messages: sync.messages,
+        syncMode: sync.syncMode,
+        replaceFrom: sync.replaceFrom,
+        totalMessages: sync.totalMessages,
+        lastMessageSignature: sync.lastMessageSignature,
+    };
+}
+
 function didProviderConfirmSend(result: any): boolean {
     const parsed = parseMaybeJson(result);
     if (parsed === true) return true;
@@ -201,12 +373,11 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             _log(`${transport} adapter: ${adapter.cliType}`);
             const status = adapter.getStatus();
             if (status) {
-                return {
-                    success: true,
+                return buildReadChatCommandResult({
                     messages: status.messages || [],
                     status: status.status,
                     activeModal: status.activeModal,
-                };
+                }, args);
             }
         }
         return { success: false, error: `${transport} adapter not found` };
@@ -223,12 +394,12 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     _log(`Extension OK: ${parsed.messages?.length || 0} msgs`);
                     h.historyWriter.appendNewMessages(
                         provider?.type || 'unknown_extension',
-                        parsed.messages || [],
+                        toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
                         parsed.title,
                         args?.targetSessionId,
                         historySessionId,
                     );
-                    return { success: true, ...parsed };
+                    return buildReadChatCommandResult(parsed, args);
                 }
             }
         } catch (e: any) {
@@ -241,21 +412,25 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             if (cdp && parentSessionId) {
                 const stream = await h.agentStream.collectActiveSession(cdp, parentSessionId);
                 if (stream?.agentType !== provider?.type) {
-                    return { success: true, messages: [], status: 'idle' };
+                    return buildReadChatCommandResult({ messages: [], status: 'idle' }, args);
                 }
                 if (stream) {
                     h.historyWriter.appendNewMessages(
                         stream.agentType,
-                        stream.messages || [],
+                        toHistoryPersistedMessages(stream.messages || []),
                         undefined,
                         args?.targetSessionId,
                         historySessionId,
                     );
-                    return { success: true, messages: stream.messages || [], status: stream.status, agentType: stream.agentType };
+                    return buildReadChatCommandResult({
+                        messages: stream.messages || [],
+                        status: stream.status,
+                        agentType: stream.agentType,
+                    }, args);
                 }
             }
         }
-        return { success: true, messages: [], status: 'idle' };
+        return buildReadChatCommandResult({ messages: [], status: 'idle' }, args);
     }
 
     // IDE category (default): cdp.evaluate
@@ -278,18 +453,18 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     _log(`Webview OK: ${parsed.messages?.length || 0} msgs`);
                 h.historyWriter.appendNewMessages(
                     provider?.type || getCurrentProviderType(h, 'unknown_webview'),
-                    parsed.messages || [],
+                    toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
                     parsed.title,
                     args?.targetSessionId,
                     historySessionId,
                 );
-                    return { success: true, ...parsed };
+                    return buildReadChatCommandResult(parsed, args);
                 }
             }
         } catch (e: any) {
             _log(`Webview readChat error: ${e.message}`);
         }
-        return { success: true, messages: [], status: 'idle' };
+        return buildReadChatCommandResult({ messages: [], status: 'idle' }, args);
     }
 
     // Regular IDE (Cursor, Windsurf, Trae etc) → main DOM evaluate
@@ -303,19 +478,19 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 _log(`OK: ${parsed.messages?.length} msgs`);
                 h.historyWriter.appendNewMessages(
                     provider?.type || getCurrentProviderType(h, 'unknown_ide'),
-                    parsed.messages || [],
+                    toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
                     parsed.title,
                     args?.targetSessionId,
                     historySessionId,
                 );
-                return { success: true, ...parsed };
+                return buildReadChatCommandResult(parsed, args);
             }
         } catch (e: any) {
             LOG.info('Command', `[read_chat] Script error: ${e.message}`);
         }
     }
 
-    return { success: true, messages: [], status: 'idle' };
+    return buildReadChatCommandResult({ messages: [], status: 'idle' }, args);
 }
 
 export async function handleSendChat(h: CommandHelpers, args: any): Promise<CommandResult> {

package/src/commands/router.ts

@@ -31,6 +31,7 @@ import { logCommand } from '../logging/command-log.js';
 import type { CommandLogEntry } from '../logging/command-log.js';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
 import { buildSessionEntries } from '../status/builders.js';
+import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import * as fs from 'fs';
@@ -71,6 +72,9 @@ export interface CommandRouterDeps {
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
     /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
     packageName?: string;
+    /** Canonical daemon status identity used by snapshot commands */
+    statusInstanceId?: string;
+    statusVersion?: string;
     /** Session host control plane */
     sessionHostControl?: SessionHostControlPlane | null;
 }
@@ -491,6 +495,27 @@ export class DaemonCommandRouter {
                 return { success: true, userName: name };
             }
 
+            case 'get_status_metadata': {
+                const snapshot = buildStatusSnapshot({
+                    allStates: this.deps.instanceManager.collectAllStates(),
+                    cdpManagers: this.deps.cdpManagers,
+                    providerLoader: this.deps.providerLoader,
+                    detectedIdes: this.deps.detectedIdes.value,
+                    instanceId: this.deps.statusInstanceId || loadConfig().machineId || 'daemon',
+                    version: this.deps.statusVersion || 'unknown',
+                    profile: 'metadata',
+                });
+                return { success: true, status: snapshot };
+            }
+
+            case 'get_machine_runtime_stats': {
+                return {
+                    success: true,
+                    machine: buildMachineInfo('full'),
+                    timestamp: Date.now(),
+                };
+            }
+
             case 'mark_session_seen': {
                 const sessionId = args?.sessionId;
                 if (!sessionId || typeof sessionId !== 'string') {

package/src/commands/stream-commands.ts

@@ -164,13 +164,17 @@ function applyProviderPatch(h: CommandHelpers, args: any, payload: any): void {
 }
 
 async function executeProviderScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult> {
-    const { agentType, ideType } = args || {};
-    if (!agentType) return { success: false, error: 'agentType is required' };
+    const resolvedProviderType =
+        h.currentSession?.providerType
+        || h.currentProviderType
+        || args?.agentType
+        || args?.providerType;
+    if (!resolvedProviderType) return { success: false, error: 'targetSessionId or providerType is required' };
 
     const loader = h.ctx.providerLoader;
     if (!loader) return { success: false, error: 'ProviderLoader not initialized' };
-    const provider = loader.resolve(agentType);
-    if (!provider) return { success: false, error: `Provider not found: ${agentType}` };
+    const provider = loader.resolve(resolvedProviderType);
+    if (!provider) return { success: false, error: `Provider not found: ${resolvedProviderType}` };
 
     const webviewScriptName = `webview${scriptName.charAt(0).toUpperCase() + scriptName.slice(1)}`;
     const hasWebviewScript = provider.category === 'ide' &&
@@ -179,13 +183,13 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
     const actualScriptName = hasWebviewScript ? webviewScriptName : scriptName;
 
     if (!provider.scripts?.[actualScriptName as keyof typeof provider.scripts]) {
-        return { success: false, error: `Script '${actualScriptName}' not available for ${agentType}` };
+        return { success: false, error: `Script '${actualScriptName}' not available for ${resolvedProviderType}` };
     }
 
     const normalizedArgs = normalizeProviderScriptArgs(args);
 
     if (provider.category === 'cli') {
-        const adapter = h.getCliAdapter(args?.targetSessionId || agentType);
+        const adapter = h.getCliAdapter(args?.targetSessionId || resolvedProviderType);
         if (!adapter?.invokeScript) {
             return { success: false, error: `CLI adapter does not support script '${actualScriptName}'` };
         }
@@ -213,8 +217,8 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
     if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
 
     const cdpKey = provider.category === 'ide'
-        ? (h.currentSession?.cdpManagerKey || h.currentManagerKey || agentType)
-        : (h.currentSession?.cdpManagerKey || h.currentManagerKey || ideType);
+        ? (h.currentSession?.cdpManagerKey || h.currentManagerKey || resolvedProviderType)
+        : (h.currentSession?.cdpManagerKey || h.currentManagerKey);
     LOG.info('Command', `[ExtScript] provider=${provider.type} category=${provider.category} cdpKey=${cdpKey}`);
     const cdp = h.getCdp(cdpKey);
     if (!cdp?.isConnected) return { success: false, error: `No CDP connection for ${cdpKey || 'any'}` };
@@ -224,7 +228,7 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
 
         if (provider.category === 'extension') {
             const runtimeSessionId = h.currentSession?.sessionId || args?.targetSessionId;
-            if (!runtimeSessionId) return { success: false, error: `No target session found for ${agentType}` };
+            if (!runtimeSessionId) return { success: false, error: `No target session found for ${resolvedProviderType}` };
             const parentSessionId = h.currentSession?.parentSessionId;
             if (parentSessionId) {
                 await h.agentStream?.setActiveSession(cdp, parentSessionId, runtimeSessionId);
@@ -257,7 +261,7 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
                 }
             } else {
                 if (!targetSessionId) {
-                    return { success: false, error: `No active session found for ${agentType}` };
+                    return { success: false, error: `No active session found for ${resolvedProviderType}` };
                 }
                 result = await cdp.evaluateInSessionFrame(targetSessionId, scriptCode);
             }

package/src/config/config.ts

@@ -18,6 +18,12 @@ export interface ADHDevConfig {
  // Server connection
     serverUrl: string;
 
+    /**
+     * Allow server-relayed REST/API commands to reach the daemon.
+     * Disabled by default so cloud dashboard traffic stays P2P-only.
+     */
+    allowServerApiProxy?: boolean;
+
  // Selected IDE (primary)
     selectedIde: string | null;
 
@@ -90,6 +96,7 @@ export interface ADHDevConfig {
 
 const DEFAULT_CONFIG: ADHDevConfig = {
     serverUrl: 'https://api.adhf.dev',
+    allowServerApiProxy: false,
     selectedIde: null,
     configuredIdes: [],
     installedExtensions: [],
@@ -140,6 +147,7 @@ function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: str
         serverUrl: typeof parsed.serverUrl === 'string' && parsed.serverUrl.trim()
             ? parsed.serverUrl
             : DEFAULT_CONFIG.serverUrl,
+        allowServerApiProxy: asBoolean(parsed.allowServerApiProxy, DEFAULT_CONFIG.allowServerApiProxy ?? false),
         selectedIde: asNullableString(parsed.selectedIde),
         configuredIdes: asStringArray(parsed.configuredIdes),
         installedExtensions: asStringArray(parsed.installedExtensions),

package/src/index.d.ts

@@ -4,7 +4,7 @@
  * Core logic for daemon: CDP, Provider, IDE detection, CLI/ACP adapters and more.
  */
 export type { ChatMessage, ExtensionInfo, CommandResult as CoreCommandResult, ProviderConfig, DaemonEvent, StatusResponse, SystemInfo, DetectedIde, ProviderInfo, AgentEntry, } from './types.js';
-export type { SessionEntry, CompactSessionEntry, CompactDaemonEntry, SessionTransport, SessionKind, SessionCapability, AgentSessionStream, AvailableProviderInfo, AcpConfigOption, AcpMode, ProviderControlSchema, StatusReportPayload, MachineInfo, DetectedIdeInfo, WorkspaceEntry, ProviderStatus, ProviderErrorReason, ActiveChatData, IdeProviderState, CliProviderState, AcpProviderState, ExtensionProviderState, } from './shared-types.js';
+export type { SessionEntry, CompactSessionEntry, CompactDaemonEntry, SessionTransport, SessionKind, SessionCapability, AgentSessionStream, ReadChatCursor, ReadChatSyncMode, ReadChatSyncResult, TransportTopic, SessionChatTailSubscriptionParams, MachineRuntimeSubscriptionParams, SessionHostDiagnosticsSubscriptionParams, SessionModalSubscriptionParams, DaemonMetadataSubscriptionParams, SessionChatTailUpdate, MachineRuntimeUpdate, SessionHostDiagnosticsUpdate, SessionModalUpdate, DaemonMetadataUpdate, TopicUpdateEnvelope, SubscribeRequest, UnsubscribeRequest, StandaloneWsStatusPayload, AvailableProviderInfo, AcpConfigOption, AcpMode, ProviderControlSchema, StatusReportPayload, MachineInfo, SessionHostDiagnosticsSnapshot, SessionHostRecord, SessionHostWriteOwner, SessionHostAttachedClient, SessionHostLogEntry, SessionHostRequestTrace, SessionHostRuntimeTransition, DetectedIdeInfo, WorkspaceEntry, ProviderState, ProviderStatus, ProviderErrorReason, ActiveChatData, IdeProviderState, CliProviderState, AcpProviderState, ExtensionProviderState, } from './shared-types.js';
 import type { RuntimeWriteOwner as _RuntimeWriteOwner } from './shared-types-extra.js';
 import type { RuntimeAttachedClient as _RuntimeAttachedClient } from './shared-types-extra.js';
 import type { RecentLaunchEntry as _RecentLaunchEntry } from './shared-types.js';
@@ -45,7 +45,7 @@ export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper }
 export type { DaemonUpgradeHelperPayload } from './commands/upgrade-helper.js';
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
-export { buildStatusSnapshot } from './status/snapshot.js';
+export { buildStatusSnapshot, buildMachineInfo } from './status/snapshot.js';
 export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';
 export type { ManagedStatus } from './status/normalize.js';
 export type { StatusSnapshotOptions, StatusSnapshot } from './status/snapshot.js';

package/src/index.ts

@@ -23,18 +23,49 @@ export type {
   SessionEntry,
   CompactSessionEntry,
   CompactDaemonEntry,
+  CloudDaemonSummaryEntry,
+  DashboardBootstrapDaemonEntry,
+  CloudStatusReportPayload,
+  DaemonStatusEventPayload,
+  DashboardStatusEventPayload,
   SessionTransport,
   SessionKind,
   SessionCapability,
   AgentSessionStream,
+  ReadChatCursor,
+  ReadChatSyncMode,
+  ReadChatSyncResult,
+  TransportTopic,
+  SessionChatTailSubscriptionParams,
+  MachineRuntimeSubscriptionParams,
+  SessionHostDiagnosticsSubscriptionParams,
+  SessionModalSubscriptionParams,
+  DaemonMetadataSubscriptionParams,
+  SessionChatTailUpdate,
+  MachineRuntimeUpdate,
+  SessionHostDiagnosticsUpdate,
+  SessionModalUpdate,
+  DaemonMetadataUpdate,
+  TopicUpdateEnvelope,
+  SubscribeRequest,
+  UnsubscribeRequest,
+  StandaloneWsStatusPayload,
   AvailableProviderInfo,
   AcpConfigOption,
   AcpMode,
   ProviderControlSchema,
   StatusReportPayload,
   MachineInfo,
+  SessionHostDiagnosticsSnapshot,
+  SessionHostRecord,
+  SessionHostWriteOwner,
+  SessionHostAttachedClient,
+  SessionHostLogEntry,
+  SessionHostRequestTrace,
+  SessionHostRuntimeTransition,
   DetectedIdeInfo,
   WorkspaceEntry,
+  ProviderState,
   ProviderStatus,
   ProviderErrorReason,
   ActiveChatData,
@@ -103,7 +134,7 @@ export type { DaemonUpgradeHelperPayload } from './commands/upgrade-helper.js';
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
-export { buildStatusSnapshot } from './status/snapshot.js';
+export { buildStatusSnapshot, buildMachineInfo } from './status/snapshot.js';
 export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';
 export type { ManagedStatus } from './status/normalize.js';
 export type { StatusSnapshotOptions, StatusSnapshot } from './status/snapshot.js';