@adhdev/daemon-core 0.6.77 → 0.7.0

package/src/providers/acp-provider-instance.ts

@@ -259,6 +259,10 @@ export class AcpProviderInstance implements ProviderInstance {
         }
     }
 
+    getInstanceId(): string {
+        return this.instanceId;
+    }
+
  // ─── ACP Config Options & Modes ─────────────────────
 
     private parseConfigOptions(raw: any): void {

package/src/providers/provider-instance-manager.ts

@@ -83,6 +83,7 @@ export class ProviderInstanceManager {
                             ...event,
                             providerType: instance.type,
                             instanceId: state.instanceId,
+                            targetSessionId: state.instanceId,
                             providerCategory: state.category,
                         });
                     }

package/src/sessions/registry.ts

@@ -0,0 +1,76 @@
+import type { SessionTransport } from '../shared-types.js';
+
+export interface SessionRuntimeTarget {
+    sessionId: string;
+    parentSessionId: string | null;
+    providerType: string;
+    providerCategory: 'ide' | 'extension' | 'cli' | 'acp';
+    transport: SessionTransport;
+    cdpManagerKey?: string;
+    adapterKey?: string;
+    instanceKey?: string;
+}
+
+export class SessionRegistry {
+    private readonly bySessionId = new Map<string, SessionRuntimeTarget>();
+    private readonly byManagerKey = new Map<string, Set<string>>();
+    private readonly byInstanceKey = new Map<string, Set<string>>();
+    private readonly byParentSessionId = new Map<string, Set<string>>();
+
+    register(target: SessionRuntimeTarget): void {
+        this.unregister(target.sessionId);
+        this.bySessionId.set(target.sessionId, target);
+        if (target.cdpManagerKey) this.addIndex(this.byManagerKey, target.cdpManagerKey, target.sessionId);
+        if (target.instanceKey) this.addIndex(this.byInstanceKey, target.instanceKey, target.sessionId);
+        if (target.parentSessionId) this.addIndex(this.byParentSessionId, target.parentSessionId, target.sessionId);
+    }
+
+    get(sessionId: string | undefined | null): SessionRuntimeTarget | undefined {
+        if (!sessionId) return undefined;
+        return this.bySessionId.get(sessionId);
+    }
+
+    unregister(sessionId: string | undefined | null): void {
+        if (!sessionId) return;
+        const target = this.bySessionId.get(sessionId);
+        if (!target) return;
+        this.bySessionId.delete(sessionId);
+        if (target.cdpManagerKey) this.removeIndex(this.byManagerKey, target.cdpManagerKey, sessionId);
+        if (target.instanceKey) this.removeIndex(this.byInstanceKey, target.instanceKey, sessionId);
+        if (target.parentSessionId) this.removeIndex(this.byParentSessionId, target.parentSessionId, sessionId);
+    }
+
+    unregisterByManagerKey(managerKey: string): void {
+        for (const sessionId of [...(this.byManagerKey.get(managerKey) || [])]) {
+            this.unregister(sessionId);
+        }
+    }
+
+    unregisterByInstanceKey(instanceKey: string): void {
+        for (const sessionId of [...(this.byInstanceKey.get(instanceKey) || [])]) {
+            this.unregister(sessionId);
+        }
+    }
+
+    listChildren(parentSessionId: string): SessionRuntimeTarget[] {
+        const ids = this.byParentSessionId.get(parentSessionId);
+        if (!ids) return [];
+        return [...ids].map((id) => this.bySessionId.get(id)).filter(Boolean) as SessionRuntimeTarget[];
+    }
+
+    private addIndex(index: Map<string, Set<string>>, key: string, sessionId: string): void {
+        let set = index.get(key);
+        if (!set) {
+            set = new Set<string>();
+            index.set(key, set);
+        }
+        set.add(sessionId);
+    }
+
+    private removeIndex(index: Map<string, Set<string>>, key: string, sessionId: string): void {
+        const set = index.get(key);
+        if (!set) return;
+        set.delete(sessionId);
+        if (set.size === 0) index.delete(key);
+    }
+}

package/src/shared-types.ts

@@ -41,7 +41,7 @@ export type {
 export type { ProviderErrorReason } from './providers/provider-instance.js';
 
 // Local import for use in Managed*Entry types below
-import type { ActiveChatData as _ActiveChatData } from './providers/provider-instance.js';
+import type { ActiveChatData as _ActiveChatData, ProviderErrorReason as _ProviderErrorReason } from './providers/provider-instance.js';
 import type { WorkspaceEntry } from './config/workspaces.js';
 
 // Re-export WorkspaceEntry for downstream consumers
@@ -51,63 +51,58 @@ export type { WorkspaceEntry } from './config/workspaces.js';
 // These define the shape of data sent by DaemonStatusReporter
 // and consumed by web-core and downstream consumers.
 
-/** IDE entry as reported by daemon to dashboard */
-export interface ManagedIdeEntry {
-    ideType: string;
-    ideVersion: string;
-    instanceId: string;
-    workspace: string | null;
-    terminals: number;
-    aiAgents: unknown[];
-    activeChat: _ActiveChatData | null;
-    chats: unknown[];
-    agentStreams: ManagedAgentStream[];
-    cdpConnected: boolean;
-    currentModel?: string;
-    currentPlan?: string;
-    currentAutoApprove?: string;
-}
-
-/** CLI entry as reported by daemon to dashboard */
-export interface ManagedCliEntry {
-    id: string;
-    instanceId: string;
-    cliType: string;
-    cliName: string;
+/** Agent stream snapshot carried by flattened UI entries. */
+export interface AgentSessionStream {
+    sessionId?: string;
+    parentSessionId?: string | null;
+    agentType: string;
+    agentName: string;
+    extensionId: string;
+    transport?: SessionTransport;
     status: string;
-    mode: 'terminal';
-    workspace: string;
-    activeChat: _ActiveChatData | null;
+    messages: ChatMessage[];
+    inputContent: string;
+    model?: string;
+    activeModal: { message: string; buttons: string[] } | null;
 }
 
-/** ACP entry as reported by daemon to dashboard */
-export interface ManagedAcpEntry {
+export type SessionTransport = 'cdp-page' | 'cdp-webview' | 'pty' | 'acp';
+
+export type SessionKind = 'workspace' | 'agent';
+
+export type SessionCapability =
+    | 'read_chat'
+    | 'send_message'
+    | 'new_session'
+    | 'list_sessions'
+    | 'switch_session'
+    | 'resolve_action'
+    | 'terminal_io'
+    | 'resize_terminal'
+    | 'change_model'
+    | 'set_mode'
+    | 'set_thought_level';
+
+export interface SessionEntry {
     id: string;
-    acpType: string;
-    acpName: string;
-    status: string;
-    mode: 'chat';
-    workspace: string;
+    parentId: string | null;
+    providerType: string;
+    providerName: string;
+    kind: SessionKind;
+    transport: SessionTransport;
+    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+    title: string;
+    workspace: string | null;
     activeChat: _ActiveChatData | null;
+    capabilities: SessionCapability[];
+    cdpConnected?: boolean;
     currentModel?: string;
     currentPlan?: string;
+    currentAutoApprove?: string;
     acpConfigOptions?: AcpConfigOption[];
     acpModes?: AcpMode[];
-    /** Error details */
     errorMessage?: string;
-    errorReason?: 'not_installed' | 'auth_failed' | 'spawn_error' | 'init_failed' | 'crash' | 'timeout' | 'cdp_error' | 'disconnected';
-}
-
-/** Agent stream within an IDE (extension status) */
-export interface ManagedAgentStream {
-    agentType: string;
-    agentName: string;
-    extensionId: string;
-    status: string;
-    messages: ChatMessage[];
-    inputContent: string;
-    model?: string;
-    activeModal: { message: string; buttons: string[] } | null;
+    errorReason?: _ProviderErrorReason;
 }
 
 /** Available provider information */
@@ -188,12 +183,8 @@ export interface StatusReportPayload {
     detectedIdes: DetectedIdeInfo[];
     /** P2P state */
     p2p?: { available: boolean; state: string; peers: number; screenshotActive?: boolean };
-    /** Managed IDE instances */
-    managedIdes: ManagedIdeEntry[];
-    /** Managed CLI instances */
-    managedClis: ManagedCliEntry[];
-    /** Managed ACP instances */
-    managedAcps: ManagedAcpEntry[];
+    /** Canonical daemon runtime sessions */
+    sessions: SessionEntry[];
     /** Saved workspaces */
     workspaces?: WorkspaceEntry[];
     defaultWorkspaceId?: string | null;

package/src/status/builders.ts

@@ -9,13 +9,15 @@
  */
 
 import type { DaemonCdpManager } from '../cdp/manager.js';
-import type { ManagedIdeEntry, ManagedCliEntry, ManagedAcpEntry } from '../shared-types.js';
+import type { SessionEntry, SessionCapability } from '../shared-types.js';
 import type {
     IdeProviderState,
     CliProviderState,
     AcpProviderState,
+    ExtensionProviderState,
     ProviderState,
 } from '../providers/provider-instance.js';
+import { normalizeActiveChatData, normalizeManagedStatus } from './normalize.js';
 
 // ─── CDP Manager lookup helpers ──────────────────────
 
@@ -73,137 +75,172 @@ export function isCdpConnected(
     return m?.isConnected ?? false;
 }
 
-// ─── ProviderState → ManagedEntry builders ───────────
-
-/**
- * Convert IdeProviderState[] → ManagedIdeEntry[]
- *
- * @param ideStates - from instanceManager.collectAllStates() filtered to ide
- * @param cdpManagers - for cdpConnected lookup
- * @param opts.detectedIdes - include CDPs that have no instance yet
- */
-export function buildManagedIdes(
-    ideStates: IdeProviderState[],
+const IDE_SESSION_CAPABILITIES: SessionCapability[] = [
+    'read_chat',
+    'send_message',
+    'new_session',
+    'list_sessions',
+    'switch_session',
+    'resolve_action',
+    'change_model',
+    'set_mode',
+    'set_thought_level',
+];
+
+const EXTENSION_SESSION_CAPABILITIES: SessionCapability[] = [
+    'read_chat',
+    'send_message',
+    'new_session',
+    'list_sessions',
+    'switch_session',
+    'resolve_action',
+    'change_model',
+    'set_mode',
+];
+
+const PTY_SESSION_CAPABILITIES: SessionCapability[] = [
+    'read_chat',
+    'send_message',
+    'resolve_action',
+    'terminal_io',
+    'resize_terminal',
+];
+
+const ACP_SESSION_CAPABILITIES: SessionCapability[] = [
+    'read_chat',
+    'send_message',
+    'new_session',
+    'resolve_action',
+    'change_model',
+    'set_mode',
+    'set_thought_level',
+];
+
+function buildIdeWorkspaceSession(
+    state: IdeProviderState,
     cdpManagers: Map<string, DaemonCdpManager>,
-    opts?: { detectedIdes?: { id: string; installed: boolean }[] },
-): ManagedIdeEntry[] {
-    const result: ManagedIdeEntry[] = [];
-
-    for (const state of ideStates) {
-        // Use cdpConnected from IdeProviderState if available (it checks internally),
-        // otherwise fall back to CDP manager lookup
-        const cdpConnected = state.cdpConnected ?? isCdpConnected(cdpManagers, state.type);
-        result.push({
-            ideType: state.type,
-            ideVersion: '',
-            instanceId: state.instanceId || state.type,
-            workspace: state.workspace || null,
-            terminals: 0,
-            aiAgents: [],
-            activeChat: state.activeChat,
-            chats: [],
-            agentStreams: state.extensions.map((ext) => ({
-                agentType: ext.type,
-                agentName: ext.name,
-                extensionId: ext.type,
-                status: ext.status || 'idle',
-                messages: ext.activeChat?.messages || [],
-                inputContent: ext.activeChat?.inputContent || '',
-                activeModal: ext.activeChat?.activeModal || null,
-            })),
-            cdpConnected,
-            currentModel: state.currentModel,
-            currentPlan: state.currentPlan,
-            currentAutoApprove: state.currentAutoApprove,
-        });
-    }
-
-    // Include CDPs with no ProviderInstance yet (newly detected IDEs)
-    if (opts?.detectedIdes) {
-        const coveredTypes = new Set(ideStates.map((s) => s.type));
-        for (const ide of opts.detectedIdes) {
-            if (!ide.installed || coveredTypes.has(ide.id)) continue;
-            if (!isCdpConnected(cdpManagers, ide.id)) continue;
-            result.push({
-                ideType: ide.id,
-                ideVersion: '',
-                instanceId: ide.id,
-                workspace: null,
-                terminals: 0,
-                aiAgents: [],
-                activeChat: null,
-                chats: [],
-                agentStreams: [],
-                cdpConnected: true,
-                currentModel: undefined,
-                currentPlan: undefined,
-            });
-        }
-    }
+): SessionEntry {
+    const activeChat = normalizeActiveChatData(state.activeChat);
+    const title = activeChat?.title || state.name;
+    return {
+        id: state.instanceId || state.type,
+        parentId: null,
+        providerType: state.type,
+        providerName: state.name,
+        kind: 'workspace',
+        transport: 'cdp-page',
+        status: normalizeManagedStatus(activeChat?.status || state.status, {
+            activeModal: activeChat?.activeModal || null,
+        }),
+        title,
+        workspace: state.workspace || null,
+        activeChat,
+        capabilities: IDE_SESSION_CAPABILITIES,
+        cdpConnected: state.cdpConnected ?? isCdpConnected(cdpManagers, state.type),
+        currentModel: state.currentModel,
+        currentPlan: state.currentPlan,
+        currentAutoApprove: state.currentAutoApprove,
+        errorMessage: state.errorMessage,
+        errorReason: state.errorReason,
+    };
+}
 
-    return result;
+function buildExtensionAgentSession(
+    parent: IdeProviderState,
+    ext: ExtensionProviderState,
+): SessionEntry {
+    const activeChat = normalizeActiveChatData(ext.activeChat);
+    return {
+        id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
+        parentId: parent.instanceId || parent.type,
+        providerType: ext.type,
+        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,
+        activeChat,
+        capabilities: EXTENSION_SESSION_CAPABILITIES,
+        currentModel: ext.currentModel,
+        currentPlan: ext.currentPlan,
+        errorMessage: ext.errorMessage,
+        errorReason: ext.errorReason,
+    };
 }
 
-/**
- * Convert CliProviderState[] → ManagedCliEntry[]
- */
-export function buildManagedClis(
-    cliStates: CliProviderState[],
-): ManagedCliEntry[] {
-    return cliStates.map((s) => ({
-        id: s.instanceId,
-        instanceId: s.instanceId,
-        cliType: s.type,
-        cliName: s.name,
-        status: s.status,
-        mode: 'terminal' as const,
-        workspace: s.workspace || '',
-        activeChat: s.activeChat,
-    }));
+function buildCliSession(state: CliProviderState): SessionEntry {
+    const activeChat = normalizeActiveChatData(state.activeChat);
+    return {
+        id: state.instanceId,
+        parentId: null,
+        providerType: state.type,
+        providerName: state.name,
+        kind: 'agent',
+        transport: 'pty',
+        status: normalizeManagedStatus(activeChat?.status || state.status, {
+            activeModal: activeChat?.activeModal || null,
+        }),
+        title: activeChat?.title || state.name,
+        workspace: state.workspace || null,
+        activeChat,
+        capabilities: PTY_SESSION_CAPABILITIES,
+        errorMessage: state.errorMessage,
+        errorReason: state.errorReason,
+    };
 }
 
-/**
- * Convert AcpProviderState[] → ManagedAcpEntry[]
- */
-export function buildManagedAcps(
-    acpStates: AcpProviderState[],
-): ManagedAcpEntry[] {
-    return acpStates.map((s) => ({
-        id: s.instanceId,
-        acpType: s.type,
-        acpName: s.name,
-        status: s.status,
-        mode: 'chat' as const,
-        workspace: s.workspace || '',
-        activeChat: s.activeChat,
-        currentModel: s.currentModel,
-        currentPlan: s.currentPlan,
-        acpConfigOptions: s.acpConfigOptions,
-        acpModes: s.acpModes,
-        errorMessage: s.errorMessage,
-        errorReason: s.errorReason,
-    }));
+function buildAcpSession(state: AcpProviderState): SessionEntry {
+    const activeChat = normalizeActiveChatData(state.activeChat);
+    return {
+        id: state.instanceId,
+        parentId: null,
+        providerType: state.type,
+        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,
+        activeChat,
+        capabilities: ACP_SESSION_CAPABILITIES,
+        currentModel: state.currentModel,
+        currentPlan: state.currentPlan,
+        acpConfigOptions: state.acpConfigOptions,
+        acpModes: state.acpModes,
+        errorMessage: state.errorMessage,
+        errorReason: state.errorReason,
+    };
 }
 
-/**
- * Convenience: collect & build all managed entries from instanceManager
- */
-export function buildAllManagedEntries(
+export function buildSessionEntries(
     allStates: ProviderState[],
     cdpManagers: Map<string, DaemonCdpManager>,
-    opts?: { detectedIdes?: { id: string; installed: boolean }[] },
-): {
-    managedIdes: ManagedIdeEntry[];
-    managedClis: ManagedCliEntry[];
-    managedAcps: ManagedAcpEntry[];
-} {
+): SessionEntry[] {
+    const sessions: SessionEntry[] = [];
+
     const ideStates = allStates.filter((s): s is IdeProviderState => s.category === 'ide');
     const cliStates = allStates.filter((s): s is CliProviderState => s.category === 'cli');
     const acpStates = allStates.filter((s): s is AcpProviderState => s.category === 'acp');
 
-    return {
-        managedIdes: buildManagedIdes(ideStates, cdpManagers, opts),
-        managedClis: buildManagedClis(cliStates),
-        managedAcps: buildManagedAcps(acpStates),
-    };
+    for (const state of ideStates) {
+        sessions.push(buildIdeWorkspaceSession(state, cdpManagers));
+        for (const ext of state.extensions as ExtensionProviderState[]) {
+            sessions.push(buildExtensionAgentSession(state, ext));
+        }
+    }
+
+    for (const state of cliStates) {
+        sessions.push(buildCliSession(state));
+    }
+
+    for (const state of acpStates) {
+        sessions.push(buildAcpSession(state));
+    }
+
+    return sessions;
 }

package/src/status/normalize.ts

@@ -0,0 +1,64 @@
+import type { ActiveChatData } from '../providers/provider-instance.js';
+
+export type ManagedStatus =
+    | 'idle'
+    | 'generating'
+    | 'waiting_approval'
+    | 'error'
+    | 'stopped'
+    | 'starting'
+    | 'panel_hidden'
+    | 'not_monitored'
+    | 'disconnected';
+
+const WORKING_STATUSES = new Set([
+    'generating',
+    'streaming',
+    'loading',
+    'loading_reference',
+    'thinking',
+    'active',
+]);
+
+function hasApprovalButtons(activeModal?: { buttons?: unknown[] | null } | null): boolean {
+    return (activeModal?.buttons?.length ?? 0) > 0;
+}
+
+export function normalizeManagedStatus(
+    status?: string | null,
+    opts?: { activeModal?: { buttons?: unknown[] | null } | null },
+): ManagedStatus {
+    if (hasApprovalButtons(opts?.activeModal)) return 'waiting_approval';
+
+    const normalized = String(status || 'idle').trim().toLowerCase();
+    if (normalized === 'waiting_approval') return 'waiting_approval';
+    if (WORKING_STATUSES.has(normalized)) return 'generating';
+    if (normalized === 'error') return 'error';
+    if (normalized === 'stopped') return 'stopped';
+    if (normalized === 'starting') return 'starting';
+    if (normalized === 'panel_hidden') return 'panel_hidden';
+    if (normalized === 'not_monitored') return 'not_monitored';
+    if (normalized === 'disconnected') return 'disconnected';
+    return 'idle';
+}
+
+export function isManagedStatusWorking(status?: string | null): boolean {
+    return normalizeManagedStatus(status) === 'generating';
+}
+
+export function isManagedStatusWaiting(
+    status?: string | null,
+    opts?: { activeModal?: { buttons?: unknown[] | null } | null },
+): boolean {
+    return normalizeManagedStatus(status, opts) === 'waiting_approval';
+}
+
+export function normalizeActiveChatData<T extends ActiveChatData | null | undefined>(
+    activeChat: T,
+): T {
+    if (!activeChat) return activeChat;
+    return {
+        ...activeChat,
+        status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),
+    } as T;
+}

package/src/status/reporter.ts

@@ -6,7 +6,7 @@
  */
 
 import { LOG } from '../logging/logger.js';
-import { buildAllManagedEntries } from './builders.js';
+import { buildSessionEntries } from './builders.js';
 import { buildStatusSnapshot } from './snapshot.js';
 import type {
     ProviderState,
@@ -152,7 +152,7 @@ export class DaemonStatusReporter {
         }
 
  // IDE/CLI/ACP states → managed entries (shared builder)
-        const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+        const sessions = buildSessionEntries(
             allStates,
             this.deps.cdpManagers as Map<string, any>,
         );
@@ -189,19 +189,20 @@ export class DaemonStatusReporter {
         if (opts?.p2pOnly) return;
         const wsPayload = {
             daemonMode: true,
- // managedIdes: server only saves id, type, cdpConnected
-            managedIdes: managedIdes.map(ide => ({
-                ideType: ide.ideType,
-                instanceId: ide.instanceId,
-                cdpConnected: ide.cdpConnected,
-            })),
- // managedClis: server only saves id, type, name
-            managedClis: managedClis.map(c => ({
-                id: c.id, cliType: c.cliType, cliName: c.cliName,
-            })),
- // managedAcps: server only saves id, type, name
-            managedAcps: managedAcps?.map((a: any) => ({
-                id: a.id, acpType: a.acpType, acpName: a.acpName,
+            sessions: sessions.map((session) => ({
+                id: session.id,
+                parentId: session.parentId,
+                providerType: session.providerType,
+                providerName: session.providerName,
+                kind: session.kind,
+                transport: session.transport,
+                status: session.status,
+                workspace: session.workspace,
+                title: session.title,
+                cdpConnected: session.cdpConnected,
+                currentModel: session.currentModel,
+                currentPlan: session.currentPlan,
+                currentAutoApprove: session.currentAutoApprove,
             })),
             p2p: payload.p2p,
             timestamp: now,