@adhdev/daemon-core 0.8.34 → 0.8.36

package/src/cli-adapters/terminal-screen.d.ts

@@ -0,0 +1,33 @@
+/**
+ * PTY screen snapshot abstraction.
+ *
+ * Terminal viewport backend selection.
+ *
+ * Runtime preference is backend-agnostic:
+ * - prefer ghostty-vt when available (or when explicitly requested)
+ * - fall back to xterm when ghostty-vt is unavailable
+ */
+import type { TerminalViewportBackendKind, TerminalViewportBackendPreference } from './terminal-backends/types.js';
+export declare function getTerminalBackendRuntimeStatus(): {
+    backend: TerminalViewportBackendKind;
+    preference: TerminalViewportBackendPreference;
+    ghosttyAvailable: boolean;
+};
+export declare class TerminalScreen {
+    readonly backendKind: TerminalViewportBackendKind;
+    private rows;
+    private cols;
+    private readonly preference;
+    private terminal;
+    constructor(rows?: number, cols?: number);
+    reset(rows?: number, cols?: number): void;
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    getCursorPosition(): {
+        col: number;
+        row: number;
+    };
+    dispose(): void;
+    private createBackend;
+}

package/src/commands/cdp-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CDP Commands — cdpEval, screenshot, cdpCommand, cdpBatch, cdpRemoteAction,
+ *                discoverAgents, file operations
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleCdpEval(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleScreenshot(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpCommand(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpBatch(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpRemoteAction(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleDiscoverAgents(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileRead(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileWrite(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileList(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileListBrowse(h: CommandHelpers, args: any): Promise<CommandResult>;

package/src/commands/chat-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chat Commands — readChat, sendChat, listChats, newChat, switchChat,
+ *                 setMode, changeModel, setThoughtLevel, resolveAction, chatHistory
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSendChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleListChats(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleNewChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSwitchChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetMode(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleChangeModel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetThoughtLevel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleResolveAction(h: CommandHelpers, args: any): Promise<CommandResult>;

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/cli-manager.d.ts

@@ -0,0 +1,94 @@
+/**
+ * DaemonCliManager — CLI session creation, management, and command handling
+ *
+ * Separated from adhdev-daemon.ts.
+ * CLI cases of createAdapter, startCliSession, stopCliSession, executeDaemonCommand extracted to independent module extract.
+ */
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderResumeCapability } from '../providers/contracts.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+import type { SessionRegistry } from '../sessions/registry.js';
+export interface CliManagerDeps {
+    /** Server connection — injected into adapter */
+    getServerConn(): any | null;
+    /** P2P — PTY output transmit */
+    getP2p(): {
+        broadcastSessionOutput(key: string, data: string): void;
+    } | null;
+    /** StatusReporter callback */
+    onStatusChange(): void;
+    removeAgentTracking(key: string): void;
+    /** InstanceManager — register in CLI unified status */
+    getInstanceManager(): ProviderInstanceManager | null;
+    getSessionRegistry?(): SessionRegistry | null;
+    createPtyTransportFactory?: (params: CliTransportFactoryParams) => PtyTransportFactory | null;
+    listHostedCliRuntimes?: () => Promise<HostedCliRuntimeDescriptor[]>;
+}
+type CommandResult = {
+    success: boolean;
+    [key: string]: unknown;
+};
+export interface CliTransportFactoryParams {
+    runtimeId: string;
+    providerType: string;
+    workspace: string;
+    cliArgs?: string[];
+    providerSessionId?: string;
+    attachExisting?: boolean;
+}
+export interface HostedCliRuntimeDescriptor {
+    runtimeId: string;
+    runtimeKey?: string;
+    displayName?: string;
+    workspaceLabel?: string;
+    lifecycle?: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
+    recoveryState?: string | null;
+    cliType: string;
+    workspace: string;
+    cliArgs?: string[];
+    providerSessionId?: string;
+}
+export declare function supportsExplicitSessionResume(resume?: ProviderResumeCapability): boolean;
+export declare class DaemonCliManager {
+    readonly adapters: Map<string, CliAdapter>;
+    private deps;
+    private providerLoader;
+    constructor(deps: CliManagerDeps, providerLoader: ProviderLoader);
+    getCliKey(cliType: string, dir: string): string;
+    getSessionPresentationMode(sessionId: string): 'terminal' | 'chat' | null;
+    isTerminalSession(sessionId: string): boolean;
+    private persistRecentActivity;
+    private getTransportFactory;
+    private createAdapter;
+    private startCliExitMonitor;
+    private registerCliInstance;
+    startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string, options?: {
+        resumeSessionId?: string;
+    }): Promise<{
+        runtimeSessionId: string;
+        providerSessionId?: string;
+    }>;
+    stopSession(key: string): Promise<void>;
+    stopSessionWithMode(key: string, mode: 'hard' | 'save'): Promise<void>;
+    shutdownAll(): void;
+    detachAll(): void;
+    restoreHostedSessions(records?: HostedCliRuntimeDescriptor[]): Promise<number>;
+    /**
+    * Search for CLI adapter. Priority order:
+    * 0. sessionId (UUID direct match)
+    * 1. agentType + dir (iteration match)
+    * 2. agentType fuzzy match (⚠ returns first match when multiple sessions exist)
+    */
+    findAdapter(agentType: string, opts?: {
+        dir?: string;
+        instanceKey?: string;
+    }): {
+        adapter: CliAdapter;
+        key: string;
+    } | null;
+    private findAdapterBySessionId;
+    handleCliCommand(cmd: string, args: any): Promise<CommandResult | null>;
+}
+export {};

package/src/commands/handler.d.ts

@@ -0,0 +1,103 @@
+/**
+ * DaemonCommandHandler — unified command routing for CDP & CLI
+ *
+ * Routes incoming commands (from server WS, P2P, or local WS) to
+ * the correct CDP manager or CLI adapter.
+ *
+ * Key concepts:
+ *   - extractIdeType(): determines target IDE from targetSessionId or ideType
+ *   - getCdp(): returns the DaemonCdpManager for current command
+ *   - getProvider(): returns the ProviderModule for current command
+ *   - handle(): main entry point, sets context then dispatches
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { ProviderModule } from '../providers/contracts.js';
+import type { DaemonAgentStreamManager } from '../agent-stream/index.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import { ChatHistoryWriter } from '../config/chat-history.js';
+import type { SessionRegistry, SessionRuntimeTarget } from '../sessions/registry.js';
+export interface CommandResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+export interface CommandContext {
+    cdpManagers: Map<string, DaemonCdpManager>;
+    ideType: string;
+    adapters: Map<string, CliAdapter>;
+    providerLoader?: ProviderLoader;
+    /** ProviderInstanceManager — for runtime settings propagation */
+    instanceManager?: ProviderInstanceManager;
+    sessionRegistry?: SessionRegistry;
+    onProviderSettingChanged?: (providerType: string, key: string, value: any) => Promise<void> | void;
+}
+/**
+ * Shared helpers interface — passed to sub-module command functions
+ * for accessing CDP, providers, agent streams, and other handler-owned state.
+ */
+export interface CommandHelpers {
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    getProvider(overrideType?: string): ProviderModule | undefined;
+    getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
+    evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{
+        result: any;
+        category: string;
+    } | null>;
+    getCliAdapter(type?: string): CliAdapter | null;
+    readonly currentManagerKey: string | undefined;
+    readonly currentIdeType: string | undefined;
+    readonly currentProviderType: string | undefined;
+    readonly currentSession: SessionRuntimeTarget | undefined;
+    readonly agentStream: DaemonAgentStreamManager | null;
+    readonly ctx: CommandContext;
+    readonly historyWriter: ChatHistoryWriter;
+}
+export declare class DaemonCommandHandler implements CommandHelpers {
+    private _ctx;
+    private _agentStream;
+    private domHandlers;
+    private _historyWriter;
+    /** Current request route context */
+    private _currentRoute;
+    constructor(ctx: CommandContext);
+    get ctx(): CommandContext;
+    get agentStream(): DaemonAgentStreamManager | null;
+    get historyWriter(): ChatHistoryWriter;
+    get currentManagerKey(): string | undefined;
+    get currentIdeType(): string | undefined;
+    get currentProviderType(): string | undefined;
+    get currentSession(): SessionRuntimeTarget | undefined;
+    /** Get CDP manager for a specific session or manager key. */
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    /**
+     * Get provider module — _currentProviderType (agentType priority) use.
+     */
+    getProvider(overrideType?: string): ProviderModule | undefined;
+    /** Get a provider script by name from ProviderLoader. */
+    getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
+    /**
+     * per-category CDP script execute:
+     * IDE → cdp.evaluate(script) (main window)
+     * Extension → cdp.evaluateInSession(sessionId, script) (webview)
+     */
+    evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{
+        result: any;
+        category: string;
+    } | null>;
+    /** CLI adapter search */
+    getCliAdapter(type?: string): CliAdapter | null;
+    private inferProviderType;
+    private resolveRoute;
+    /** Extract CDP scope key from target session or explicit ideType */
+    private extractIdeType;
+    private logCommandStart;
+    private logCommandEnd;
+    setAgentStreamManager(manager: DaemonAgentStreamManager): void;
+    handle(cmd: string, args: any): Promise<CommandResult>;
+    private dispatch;
+    private handleRefreshScripts;
+    private proxyDevServerPost;
+    private proxyDevServerGet;
+    private proxyDevServerScaffold;
+}

package/src/commands/router.d.ts

@@ -0,0 +1,98 @@
+/**
+ * DaemonCommandRouter — Unified command routing for daemon-level commands
+ *
+ * Unified command routing for daemon-level commands.
+ *
+ * Routing flow:
+ *   1. Daemon-level commands (launch_ide, stop_ide, restart_ide, etc.) → handled here
+ *   2. CLI/ACP commands → delegated to cliManager
+ *   3. Everything else → delegated to commandHandler.handle()
+ */
+import { DaemonCdpManager } from '../cdp/manager.js';
+import { DaemonCommandHandler } from './handler.js';
+import { DaemonCliManager } from './cli-manager.js';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { SessionRegistry } from '../sessions/registry.js';
+export interface SessionHostControlPlane {
+    getDiagnostics(payload?: {
+        includeSessions?: boolean;
+        limit?: number;
+    }): Promise<any>;
+    listSessions(): Promise<any[]>;
+    stopSession(sessionId: string): Promise<any>;
+    resumeSession(sessionId: string): Promise<any>;
+    restartSession(sessionId: string): Promise<any>;
+    sendSignal(sessionId: string, signal: string): Promise<any>;
+    forceDetachClient(sessionId: string, clientId: string): Promise<any>;
+    pruneDuplicateSessions(payload?: {
+        providerType?: string;
+        workspace?: string;
+        dryRun?: boolean;
+    }): Promise<any>;
+    acquireWrite(payload: {
+        sessionId: string;
+        clientId: string;
+        ownerType: 'agent' | 'user';
+        force?: boolean;
+    }): Promise<any>;
+    releaseWrite(payload: {
+        sessionId: string;
+        clientId: string;
+    }): Promise<any>;
+}
+export interface CommandRouterDeps {
+    commandHandler: DaemonCommandHandler;
+    cliManager: DaemonCliManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    /** Reference to detected IDEs array (mutable — router updates it) */
+    detectedIdes: {
+        value: any[];
+    };
+    sessionRegistry: SessionRegistry;
+    /** Callback for CDP manager creation after launch_ide */
+    onCdpManagerCreated?: (ideType: string, manager: DaemonCdpManager) => void;
+    /** Callback after IDE connected (e.g., startAgentStreamPolling) */
+    onIdeConnected?: () => void;
+    /** Callback after status change (stop_ide, restart) */
+    onStatusChange?: () => void;
+    /** Callback after chat-related commands */
+    onPostChatCommand?: () => void;
+    /** Get a connected CDP manager (for agent stream reset check) */
+    getCdpLogFn?: (ideType: string) => (msg: string) => void;
+    /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
+    packageName?: string;
+    /** Session host control plane */
+    sessionHostControl?: SessionHostControlPlane | null;
+}
+export interface CommandRouterResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+export declare class DaemonCommandRouter {
+    private deps;
+    constructor(deps: CommandRouterDeps);
+    /**
+     * Unified command routing.
+     * Returns result for all commands:
+     *   1. Daemon-level commands (launch_ide, stop_ide, etc.)
+     *   2. CLI commands (launch_cli, stop_cli, agent_command)
+     *   3. DaemonCommandHandler delegation (CDP/agent-stream/file commands)
+     *
+     * @param cmd Command name
+     * @param args Command arguments
+     * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
+     */
+    execute(cmd: string, args: any, source?: string): Promise<CommandRouterResult>;
+    /**
+     * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
+     * Returns null if not handled at this level → caller delegates to CommandHandler.
+     */
+    private executeDaemonCommand;
+    /**
+     * IDE stop: CDP disconnect + InstanceManager cleanup + optionally kill OS process
+     */
+    private stopIde;
+}