@adhdev/daemon-core 0.7.5 → 0.7.7

package/src/index.ts

@@ -110,7 +110,7 @@ export { ProviderInstanceManager } from './providers/provider-instance-manager.j
 export { IdeProviderInstance } from './providers/ide-provider-instance.js';
 export { CliProviderInstance } from './providers/cli-provider-instance.js';
 export { AcpProviderInstance } from './providers/acp-provider-instance.js';
-export type { ProviderModule, CdpTargetFilter } from './providers/contracts.js';
+export type { ProviderModule, CdpTargetFilter, ProviderResumeCapability } from './providers/contracts.js';
 export { VersionArchive, detectAllVersions } from './providers/version-archive.js';
 export type { ProviderVersionInfo, VersionHistory } from './providers/version-archive.js';
 
@@ -120,6 +120,10 @@ export { DevServer } from './daemon/dev-server.js';
 // ── CLI Adapters ──
 export { ProviderCliAdapter } from './cli-adapters/provider-cli-adapter.js';
 export type { CliAdapter } from './cli-adapter-types.js';
+export { NodePtyTransportFactory } from './cli-adapters/pty-transport.js';
+export type { PtyRuntimeTransport, PtyTransportFactory, PtySpawnOptions } from './cli-adapters/pty-transport.js';
+export { SessionHostPtyTransportFactory } from './cli-adapters/session-host-transport.js';
+export type { HostedCliRuntimeDescriptor, CliTransportFactoryParams } from './commands/cli-manager.js';
 
 // ── Installer ──
 export { getAIExtensions, installExtensions, launchIDE, isExtensionInstalled } from './installer.js';

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

@@ -11,6 +11,7 @@ import type { ProviderModule } from './contracts.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
@@ -37,10 +38,11 @@ export class CliProviderInstance implements ProviderInstance {
         private workingDir: string,
         private cliArgs: string[] = [],
         instanceId?: string,
+        transportFactory?: PtyTransportFactory,
     ) {
         this.type = provider.type;
         this.instanceId = instanceId || crypto.randomUUID();
-        this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs);
+        this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
@@ -82,6 +84,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getState(): ProviderState {
         const adapterStatus = this.adapter.getStatus();
+        const runtime = this.adapter.getRuntimeMetadata();
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
@@ -114,6 +117,15 @@ export class CliProviderInstance implements ProviderInstance {
             lastUpdated: Date.now(),
             settings: this.settings,
             pendingEvents: this.flushEvents(),
+            runtime: runtime ? {
+                runtimeId: runtime.runtimeId,
+                runtimeKey: runtime.runtimeKey,
+                displayName: runtime.displayName,
+                workspaceLabel: runtime.workspaceLabel,
+                writeOwner: runtime.writeOwner || null,
+                attachedClients: runtime.attachedClients || [],
+            } : undefined,
+            resume: this.provider.resume,
         };
     }
 

package/src/providers/contracts.d.ts

@@ -0,0 +1,408 @@
+/**
+ * Provider Output Contracts — Output contracts all providers must conform to
+ *
+ * Design principles:
+ * - Only output format is standardized; implementation is free
+ * - Common across all categories (cli, ide, extension)
+ * - User custom providers use the same contracts
+ */
+export interface ReadChatResult {
+    messages: ChatMessage[];
+    status: AgentStatus;
+    activeModal?: ModalInfo | null;
+    /** IDE/Extension only: session info */
+    id?: string;
+    title?: string;
+    /** Extension only: additional metadata */
+    agentType?: string;
+    agentName?: string;
+    extensionId?: string;
+    /** Status metadata */
+    isVisible?: boolean;
+    isWelcomeScreen?: boolean;
+    inputContent?: string;
+    model?: string;
+    autoApprove?: string;
+}
+import type { ChatMessage } from '../types.js';
+export type { ChatMessage };
+export type AgentStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'panel_hidden' | 'streaming';
+export interface ModalInfo {
+    message: string;
+    buttons: string[];
+    width?: number;
+    height?: number;
+}
+/**
+ * ContentBlock — ACP ContentBlock union type
+ * Represents displayable content in messages, tool call results, etc.
+ */
+export type ContentBlock = TextBlock | ImageBlock | AudioBlock | ResourceLinkBlock | ResourceBlock;
+/** Text content — ACP TextContent */
+export interface TextBlock {
+    type: 'text';
+    text: string;
+    annotations?: ContentAnnotations;
+}
+/** Image content — ACP ImageContent */
+export interface ImageBlock {
+    type: 'image';
+    data: string;
+    mimeType: string;
+    uri?: string;
+    annotations?: ContentAnnotations;
+}
+/** Audio content — ACP AudioContent */
+export interface AudioBlock {
+    type: 'audio';
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+}
+/** Resource link (file reference) — ACP ResourceLink */
+export interface ResourceLinkBlock {
+    type: 'resource_link';
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: ContentAnnotations;
+}
+/** Embedded resource (inline file) — ACP EmbeddedResource */
+export interface ResourceBlock {
+    type: 'resource';
+    resource: TextResourceContents | BlobResourceContents;
+    annotations?: ContentAnnotations;
+}
+export interface TextResourceContents {
+    uri: string;
+    text: string;
+    mimeType?: string | null;
+}
+export interface BlobResourceContents {
+    uri: string;
+    blob: string;
+    mimeType?: string | null;
+}
+export interface ContentAnnotations {
+    audience?: ('user' | 'assistant')[];
+    priority?: number;
+}
+/** Tool call info — ACP ToolCall */
+export interface ToolCallInfo {
+    toolCallId: string;
+    title: string;
+    kind?: ToolKind;
+    status?: ToolCallStatus;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    content?: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+export type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+export type ToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+/** Content produced by a tool call — ACP ToolCallContent */
+export type ToolCallContent = {
+    type: 'content';
+    content: ContentBlock;
+} | {
+    type: 'diff';
+    path: string;
+    oldText?: string;
+    newText: string;
+} | {
+    type: 'terminal';
+    terminalId: string;
+};
+export interface ToolCallLocation {
+    path: string;
+    line?: number | null;
+}
+/** Normalize content: string → ContentBlock[] */
+export declare function normalizeContent(content: string | ContentBlock[]): ContentBlock[];
+/** Flatten ContentBlock[] → string (backward compat / plain-text extraction) */
+export declare function flattenContent(content: string | ContentBlock[]): string;
+/** SendMessage params — supports rich content (ACP PromptRequest compatible) */
+export interface SendMessageParams {
+    /** Shortcut: text-only message */
+    text?: string;
+    /** Rich content blocks (ACP ContentBlock[]) */
+    prompt?: ContentBlock[];
+}
+export interface SendMessageResult {
+    sent: boolean;
+    error?: string;
+    /** When CDP Input API is needed (Lexical editor etc) */
+    needsTypeAndSend?: boolean;
+    selector?: string;
+}
+export interface ListSessionsResult {
+    sessions: SessionInfo[];
+}
+export interface SessionInfo {
+    id: string;
+    title: string;
+    time?: string;
+}
+export interface SwitchSessionResult {
+    switched: boolean;
+    /** When CDP click coordinates are needed (Antigravity QuickInput etc) */
+    action?: 'click';
+    clickX?: number;
+    clickY?: number;
+    error?: string;
+}
+/**
+ * Method 1: Script-Click — script calls el.click() directly
+ * Cursor Suitable for IDEs using div.cursor-pointer elements.
+ */
+export interface ResolveActionScriptClick {
+    resolved: boolean;
+    clicked?: string;
+    available?: string[];
+    error?: string;
+}
+/**
+ * Method 2: Coordinate-Click — returns coordinates, daemon performs CDP mouse click
+ * Antigravity Suitable for IDEs where el.click() does not work.
+ */
+export interface ResolveActionCoordinateClick {
+    found: boolean;
+    text?: string;
+    x?: number;
+    y?: number;
+    w?: number;
+    h?: number;
+}
+export type ResolveActionResult = ResolveActionScriptClick | ResolveActionCoordinateClick;
+export type ProviderCategory = 'cli' | 'ide' | 'extension' | 'acp';
+/**
+ * Type of object exported by module.exports in provider.js.
+ *
+ * Each provider.js is fully independent and does not import other providers.
+ * Helpers (_helpers/) can be optionally used.
+ */
+/**
+ * Provider-configurable CDP target filter.
+ * Used by DaemonCdpManager to select the correct page/tab to connect to.
+ * Without this, the manager uses a hardcoded default filter.
+ */
+export interface CdpTargetFilter {
+    /** URL must include this string (e.g. 'workbench.html') */
+    urlIncludes?: string;
+    /** URL must NOT include any of these strings */
+    urlExcludes?: string[];
+    /** Page title regex pattern for titles to EXCLUDE (e.g. 'Debug Console|Output') */
+    titleExcludes?: string;
+}
+export interface ProviderModule {
+    /** Unique identifier (e.g. 'cline', 'cursor', 'gemini-cli') */
+    type: string;
+    /** Display name (e.g. 'Cline', 'Cursor') */
+    name: string;
+    /** Category: determines execution method */
+    category: ProviderCategory;
+    /** Alias list — allows users to invoke by alternate names (e.g. ['claude', 'claude-code']) */
+    aliases?: string[];
+    /** CDP ports [primary, secondary] (IDE category only) */
+    cdpPorts?: [number, number];
+    /** CDP target filter — controls which page/tab to connect to (IDE category only) */
+    targetFilter?: CdpTargetFilter;
+    /** CLI command (e.g. 'cursor', 'code') */
+    cli?: string;
+    /** Display icon */
+    icon?: string;
+    /** Display name (short name) */
+    displayName?: string;
+    /** Install instructions (shown when command is missing) */
+    install?: string;
+    /** Custom version detection command (e.g. 'cursor --version', 'claude -v') */
+    versionCommand?: string;
+    /** Versions tested by provider maintainer (informational) */
+    testedVersions?: string[];
+    /** Per-OS process names — used by launch.ts to detect/kill IDE processes */
+    processNames?: {
+        darwin?: string;
+        win32?: string[];
+        linux?: string[];
+        [key: string]: string | string[] | undefined;
+    };
+    /** Per-OS install paths — used by detector.ts to detect IDE installation */
+    paths?: {
+        darwin?: string[];
+        win32?: string[];
+        linux?: string[];
+        [key: string]: string[] | undefined;
+    };
+    extensionId?: string;
+    extensionIdPattern?: RegExp;
+    binary?: string;
+    spawn?: {
+        command: string;
+        args?: string[];
+        shell?: boolean;
+        env?: Record<string, string>;
+    };
+    patterns?: {
+        prompt?: RegExp[];
+        generating?: RegExp[];
+        approval?: RegExp[];
+        ready?: RegExp[];
+    };
+    cleanOutput?: (raw: string, lastUserInput?: string) => string;
+    resume?: ProviderResumeCapability;
+    scripts?: ProviderScripts;
+    vscodeCommands?: {
+        focusPanel?: string;
+        openPanel?: string;
+        [key: string]: string | undefined;
+    };
+    inputMethod?: 'cdp-type-and-send' | 'script';
+    inputSelector?: string;
+    /** webview iframe match text (must be contained in body) */
+    webviewMatchText?: string;
+    os?: {
+        [platform: string]: Partial<Pick<ProviderModule, 'scripts' | 'inputMethod' | 'inputSelector'>>;
+    };
+    /** Key: semver range string (e.g. '< 1.107.0', '>= 2.0.0') */
+    versions?: {
+        [versionRange: string]: Partial<Pick<ProviderModule, 'scripts'>> & {
+            /**
+             * Load scripts from a subdirectory instead of scripts.js root.
+             * Path is relative to the provider directory (e.g. 'scripts/legacy').
+             * The subdirectory should contain its own scripts.js or individual .js files.
+             */
+            __dir?: string;
+        };
+    };
+    overrides?: Array<{
+        when: {
+            os?: string;
+            version?: string;
+        };
+        scripts?: Partial<ProviderScripts>;
+        /** Load scripts from a subdirectory for this OS+version combination */
+        __dir?: string;
+    }>;
+    settings?: Record<string, ProviderSettingDef>;
+    /** Static options used when agent does not provide configOptions */
+    staticConfigOptions?: Array<{
+        category: 'model' | 'mode' | 'thought_level' | 'other';
+        configId: string;
+        defaultValue?: string;
+        options: Array<{
+            value: string;
+            name: string;
+            description?: string;
+            group?: string;
+        }>;
+    }>;
+    /** Function to convert selected config values to spawn args (applied via process restart when config/* not supported) */
+    spawnArgBuilder?: (config: Record<string, string>) => string[];
+    /** ACP agent auth methods (multiple supported — in priority order) */
+    auth?: AcpAuthMethod[];
+}
+export interface ProviderResumeCapability {
+    supported: boolean;
+    stopStrategy?: 'command' | 'ctrl_c';
+    stopCommand?: string;
+    shutdownGraceMs?: number;
+    resumeArgs?: string[];
+}
+/** ACP auth method — based on ACP official spec */
+export type AcpAuthMethod = AcpAuthEnvVar | AcpAuthAgent | AcpAuthTerminal;
+/** Environment variable-based auth (API keys etc) */
+export interface AcpAuthEnvVar {
+    type: 'env_var';
+    id: string;
+    name: string;
+    vars: Array<{
+        name: string;
+        label?: string;
+        secret?: boolean;
+        optional?: boolean;
+    }>;
+    link?: string;
+}
+/** Agent self-auth (OAuth, browser-based etc) */
+export interface AcpAuthAgent {
+    type: 'agent';
+    id: string;
+    name: string;
+    description?: string;
+}
+/** Terminal command-based auth (runs setup command) */
+export interface AcpAuthTerminal {
+    type: 'terminal';
+    id: string;
+    name: string;
+    description?: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/**
+ * CDP script functions.
+ * Each function takes a params object and returns a JS code string for CDP evaluate.
+ * The JS execution result must conform to the Output Contract.
+ *
+ * Custom scripts can be added via index signature in addition to built-in scripts.
+ * All scripts can receive params: Record<string, any>,
+ * backward compatible with legacy single-argument style (e.g. sendMessage(text)).
+ */
+export interface ProviderScripts {
+    readChat?: (params?: Record<string, any>) => string;
+    sendMessage?: (params?: Record<string, any>) => string;
+    listSessions?: (params?: Record<string, any>) => string;
+    switchSession?: (params?: Record<string, any>) => string;
+    newSession?: (params?: Record<string, any>) => string;
+    focusEditor?: (params?: Record<string, any>) => string;
+    openPanel?: (params?: Record<string, any>) => string;
+    /** List available models → { models: string[], current: string } */
+    listModels?: (params?: Record<string, any>) => string;
+    /** Change model → { success: boolean } */
+    setModel?: (params?: Record<string, any>) => string;
+    /** List available modes → { modes: string[], current: string } */
+    listModes?: (params?: Record<string, any>) => string;
+    /** Change mode → { success: boolean } */
+    setMode?: (params?: Record<string, any>) => string;
+    /** params: { action: 'approve'|'reject'|'custom', button?: string } */
+    resolveAction?: (params?: Record<string, any>) => string;
+    webviewResolveAction?: (params?: Record<string, any>) => string;
+    listNotifications?: (params?: Record<string, any>) => string;
+    dismissNotification?: (params?: Record<string, any>) => string;
+    [scriptName: string]: ((params?: Record<string, any>) => string) | undefined;
+}
+/**
+ * ProviderLoader.resolve() result: Final provider with OS/version overrides applied
+ */
+export interface ResolvedProvider extends ProviderModule {
+    /** OS applied during resolve */
+    _resolvedOs?: string;
+    /** Version applied during resolve */
+    _resolvedVersion?: string;
+    /** Warning when detected version is not in compatibility matrix */
+    _versionWarning?: string;
+}
+/** Setting variable definition declared by provider */
+export interface ProviderSettingDef {
+    type: 'boolean' | 'number' | 'string' | 'select';
+    default: any;
+    /** true = controllable from dashboard UI */
+    public: boolean;
+    /** UI label */
+    label?: string;
+    /** UI description */
+    description?: string;
+    /** Minimum value for number type */
+    min?: number;
+    /** Maximum value for number type */
+    max?: number;
+    /** Options for select type */
+    options?: string[];
+}
+/** Public settings schema (for dashboard transmission) */
+export interface ProviderSettingSchema extends ProviderSettingDef {
+    key: string;
+}

package/src/providers/contracts.ts

@@ -324,6 +324,7 @@ export interface ProviderModule {
     ready?: RegExp[];
   };
   cleanOutput?: (raw: string, lastUserInput?: string) => string;
+  resume?: ProviderResumeCapability;
 
  // ─── CDP scripts (ide/extension category) ───
   scripts?: ProviderScripts;
@@ -388,6 +389,14 @@ export interface ProviderModule {
   auth?: AcpAuthMethod[];
 }
 
+export interface ProviderResumeCapability {
+  supported: boolean;
+  stopStrategy?: 'command' | 'ctrl_c';
+  stopCommand?: string;
+  shutdownGraceMs?: number;
+  resumeArgs?: string[];
+}
+
 // ─── ACP Auth Types ─────────────────────────────────
 
 /** ACP auth method — based on ACP official spec */

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

@@ -32,6 +32,10 @@ export class ExtensionProviderInstance implements ProviderInstance {
  // meta
     private instanceId: string;
     private ideType: string = '';
+    private chatId: string | null = null;
+    private chatTitle: string | null = null;
+    private agentName: string = '';
+    private extensionId: string = '';
 
     constructor(provider: ProviderModule) {
         this.type = provider.type;
@@ -69,8 +73,8 @@ export class ExtensionProviderInstance implements ProviderInstance {
             category: 'extension',
             status: this.currentStatus as ProviderState['status'],
             activeChat: this.messages.length > 0 ? {
-                id: `${this.type}_session`,
-                title: this.provider.name,
+                id: this.chatId || this.instanceId,
+                title: this.chatTitle || this.agentName || this.provider.name,
                 status: this.currentStatus,
                 messages: this.messages,
                 activeModal: this.activeModal,
@@ -94,6 +98,10 @@ export class ExtensionProviderInstance implements ProviderInstance {
             if (data?.activeModal !== undefined) this.activeModal = data.activeModal;
             if (data?.model) this.currentModel = data.model;
             if (data?.mode) this.currentMode = data.mode;
+            if (typeof data?.sessionId === 'string' && data.sessionId.trim()) this.chatId = data.sessionId;
+            if (typeof data?.title === 'string' && data.title.trim()) this.chatTitle = data.title;
+            if (typeof data?.agentName === 'string' && data.agentName.trim()) this.agentName = data.agentName;
+            if (typeof data?.extensionId === 'string' && data.extensionId.trim()) this.extensionId = data.extensionId;
             if (data?.status) {
                 const newStatus = data.status;
                 this.detectTransition(newStatus, data);
@@ -117,12 +125,6 @@ export class ExtensionProviderInstance implements ProviderInstance {
     }
 
  // ─── status transition detect ──────────────────────────────
-    // NOTE: Extension transitions are TRACKED but NOT emitted as events.
-    // The parent IdeProviderInstance already emits identical events
-    // (generating_started, generating_completed, waiting_approval)
-    // via its own detectAgentTransitions(). Emitting here would cause
-    // duplicate toasts with slightly different content.
-
     private detectTransition(newStatus: string, data: any): void {
         const now = Date.now();
         const agentStatus = (newStatus === 'streaming' || newStatus === 'generating') ? 'generating'
@@ -136,13 +138,44 @@ export class ExtensionProviderInstance implements ProviderInstance {
             : undefined;
 
         if (agentStatus !== this.lastAgentStatus) {
-            // Track generating start time (for monitor elapsed calculation)
             if (this.lastAgentStatus === 'idle' && agentStatus === 'generating') {
                 this.generatingStartedAt = now;
+                this.pushEvent({
+                    event: 'agent:generating_started',
+                    chatTitle: this.resolveChatTitle(data),
+                    timestamp: now,
+                    ideType: this.ideType || this.type,
+                    agentType: this.type,
+                    agentName: this.agentName || this.provider.name,
+                    extensionId: this.extensionId || this.type,
+                });
+            } else if (agentStatus === 'waiting_approval') {
+                if (!this.generatingStartedAt) this.generatingStartedAt = now;
+                this.pushEvent({
+                    event: 'agent:waiting_approval',
+                    chatTitle: this.resolveChatTitle(data),
+                    timestamp: now,
+                    ideType: this.ideType || this.type,
+                    agentType: this.type,
+                    agentName: this.agentName || this.provider.name,
+                    extensionId: this.extensionId || this.type,
+                    modalMessage: data?.activeModal?.message,
+                    modalButtons: data?.activeModal?.buttons,
+                });
             } else if (agentStatus === 'idle' && (this.lastAgentStatus === 'generating' || this.lastAgentStatus === 'waiting_approval')) {
+                const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
+                this.pushEvent({
+                    event: 'agent:generating_completed',
+                    chatTitle: this.resolveChatTitle(data),
+                    duration,
+                    timestamp: now,
+                    ideType: this.ideType || this.type,
+                    agentType: this.type,
+                    agentName: this.agentName || this.provider.name,
+                    extensionId: this.extensionId || this.type,
+                });
                 this.generatingStartedAt = 0;
             }
-            // Do NOT pushEvent for transitions — parent IDE instance handles these
             this.lastAgentStatus = agentStatus;
         }
 
@@ -164,4 +197,11 @@ export class ExtensionProviderInstance implements ProviderInstance {
         this.events = [];
         return events;
     }
+
+    private resolveChatTitle(data: any): string {
+        const title = typeof data?.title === 'string' && data.title.trim()
+            ? data.title.trim()
+            : this.chatTitle;
+        return title || this.agentName || this.provider.name;
+    }
 }

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

@@ -42,6 +42,27 @@ export class ProviderInstanceManager {
         }
     }
 
+    removeByCategory(
+        category: 'cli' | 'ide' | 'extension' | 'acp',
+        options: { dispose?: boolean } = {},
+    ): number {
+        const dispose = options.dispose !== false;
+        let removed = 0;
+        for (const [id, instance] of this.instances) {
+            if (instance.category !== category) continue;
+            if (dispose) {
+                try {
+                    instance.dispose();
+                } catch {
+                    // noop
+                }
+            }
+            this.instances.delete(id);
+            removed += 1;
+        }
+        return removed;
+    }
+
  /**
  * Import by Instance ID
  */
@@ -75,16 +96,13 @@ export class ProviderInstanceManager {
             try {
                 const state = instance.getState();
                 states.push(state);
-
- // pending events propagation
-                for (const event of state.pendingEvents) {
-                    for (const listener of this.eventListeners) {
-                        listener({
-                            ...event,
-                            providerType: instance.type,
-                            instanceId: state.instanceId,
-                            targetSessionId: state.instanceId,
-                            providerCategory: state.category,
+                this.emitPendingEvents(instance.type, state);
+                if (state.category === 'ide') {
+                    for (const childState of state.extensions) {
+                        this.emitPendingEvents(childState.type, childState, {
+                            targetSessionId: childState.instanceId,
+                            workspaceName: state.workspace || undefined,
+                            parentSessionId: state.instanceId,
                         });
                     }
                 }
@@ -141,6 +159,26 @@ export class ProviderInstanceManager {
         this.eventListeners.push(listener);
     }
 
+    private emitPendingEvents(
+        providerType: string,
+        state: ProviderState,
+        extra: Record<string, unknown> = {},
+    ): void {
+        for (const event of state.pendingEvents) {
+            for (const listener of this.eventListeners) {
+                listener({
+                    ...event,
+                    providerType,
+                    instanceId: state.instanceId,
+                    targetSessionId: state.instanceId,
+                    providerCategory: state.category,
+                    workspaceName: state.workspace || undefined,
+                    ...extra,
+                });
+            }
+        }
+    }
+
  /**
  * Forward event to specific Instance
  */