@adhdev/daemon-core 0.7.41 → 0.7.43

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

@@ -7,7 +7,7 @@
 
 import * as path from 'path';
 import * as crypto from 'crypto';
-import type { ProviderModule, ProviderLaunchMode, ProviderLaunchOption } from './contracts.js';
+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';
@@ -33,8 +33,7 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     readonly instanceId: string;
 
-    private launchMode: ProviderLaunchMode | null;
-    private resolvedOutputFormat: 'terminal' | 'stream-json';
+    private presentationMode: 'terminal' | 'chat';
 
     constructor(
         private provider: ProviderModule,
@@ -42,37 +41,15 @@ export class CliProviderInstance implements ProviderInstance {
         private cliArgs: string[] = [],
         instanceId?: string,
         transportFactory?: PtyTransportFactory,
-        launchModeId?: string,
     ) {
         this.type = provider.type;
         this.instanceId = instanceId || crypto.randomUUID();
-        this.launchMode = (launchModeId && provider.launchModes?.find(m => m.id === launchModeId)) || null;
-        this.resolvedOutputFormat = this.resolveOutputFormat();
+        this.presentationMode = 'chat';
         this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
 
-    /**
-     * Determine output rendering format from:
-     * 1. launchMode.outputFormat (explicit override)
-     * 2. launchOptions[].outputFormatMap — check actual args for matching values
-     * 3. Default: 'terminal'
-     */
-    private resolveOutputFormat(): 'terminal' | 'stream-json' {
-        if (this.launchMode?.outputFormat) return this.launchMode.outputFormat;
-        if (this.provider.launchOptions?.length) {
-            for (const opt of this.provider.launchOptions) {
-                if (!opt.outputFormatMap) continue;
-                // Check if any cliArg matches a value with an outputFormatMap entry
-                for (const [val, fmt] of Object.entries(opt.outputFormatMap)) {
-                    if (this.cliArgs.includes(val)) return fmt;
-                }
-            }
-        }
-        return 'terminal';
-    }
-
  // ─── Lifecycle ─────────────────────────────────
 
     async init(context: InstanceContext): Promise<void> {
@@ -110,33 +87,23 @@ export class CliProviderInstance implements ProviderInstance {
 
     getState(): ProviderState {
         const adapterStatus = this.adapter.getStatus();
+        const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
         const runtime = this.adapter.getRuntimeMetadata();
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
-        if (adapterStatus.terminalHistory?.trim()) {
-            this.historyWriter.appendTerminalHistory(
-                this.type,
-                adapterStatus.terminalHistory,
-                `${this.provider.name} · ${dirName}`,
-                this.instanceId,
-            );
-        }
-
         return {
             type: this.type,
             name: this.provider.name,
             category: 'cli',
             status: adapterStatus.status,
-            mode: this.resolvedOutputFormat === 'stream-json' ? 'chat' : 'terminal',
-            launchMode: this.launchMode?.id,
+            mode: this.presentationMode,
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
-                title: `${this.provider.name} · ${dirName}`,
-                status: adapterStatus.status,
-                messages: [],
-                activeModal: adapterStatus.activeModal,
-                terminalHistory: adapterStatus.terminalHistory,
+                title: parsedStatus?.title || `${this.provider.name} · ${dirName}`,
+                status: parsedStatus?.status || adapterStatus.status,
+                messages: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [],
+                activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
                 inputContent: '',
             },
             workspace: this.workingDir,
@@ -158,6 +125,15 @@ export class CliProviderInstance implements ProviderInstance {
         };
     }
 
+    setPresentationMode(mode: 'terminal' | 'chat'): void {
+        if (this.presentationMode === mode) return;
+        this.presentationMode = mode;
+    }
+
+    getPresentationMode(): 'terminal' | 'chat' {
+        return this.presentationMode;
+    }
+
     onEvent(event: string, data?: any): void {
         if (event === 'send_message' && data?.text) {
             void this.adapter.sendMessage(data.text).catch((e: any) => {

package/src/providers/contracts.ts

@@ -317,20 +317,6 @@ export interface ProviderModule {
     shell?: boolean;
     env?: Record<string, string>;
   };
- /**
-  * Configurable options shown at session launch time (schema declaration).
-  * The frontend renders these as a launch config UI.
-  * Values are passed to launchArgBuilder to produce the final args.
-  */
-  launchOptions?: ProviderLaunchOption[];
- /**
-  * Builds extra spawn args from user-selected launch option values.
-  * Called with the merged defaults + mode preset + user overrides.
-  * When defined, takes precedence over launchMode.extraArgs.
-  */
-  launchArgBuilder?: (options: Record<string, string | boolean | number>) => string[];
- /** Named presets — shortcuts that set launchOption values in bulk */
-  launchModes?: ProviderLaunchMode[];
   patterns?: {
     prompt?: RegExp[];
     generating?: RegExp[];
@@ -407,72 +393,6 @@ export interface ProviderModule {
   auth?: AcpAuthMethod[];
 }
 
-// ─── CLI Launch Options (individual configurable flags) ────────────────
-
-export type ProviderLaunchOptionType = 'select' | 'boolean' | 'string' | 'number';
-
-/**
- * A single configurable option exposed at session launch time.
- * Providers declare these so the frontend can render a launch config UI.
- * The final args are built by launchArgBuilder(selectedValues).
- *
- * Example — Claude Code:
- *   { id: 'outputFormat', type: 'select', options: [
- *       { value: 'terminal', label: 'Terminal' },
- *       { value: 'stream-json', label: 'Chat' },
- *   ], default: 'terminal' }
- */
-export interface ProviderLaunchOption {
- /** Unique identifier — key used in launchArgBuilder options map */
-  id: string;
- /** Display label */
-  name: string;
-  description?: string;
-  type: ProviderLaunchOptionType;
- /** Options for 'select' type */
-  options?: { value: string; label: string; description?: string }[];
- /** Default value — applied when not explicitly set */
-  default?: string | boolean | number;
- /**
-  * Maps specific values of this option to a frontend rendering hint.
-  * e.g. { 'stream-json': 'stream-json' } tells the UI to switch to Chat mode.
-  */
-  outputFormatMap?: Record<string, 'terminal' | 'stream-json'>;
-}
-
-/**
- * A named launch preset — shorthand for a specific set of launchOption values.
- * When selected, its `options` are merged with user-configured values before
- * calling launchArgBuilder. Falls back to `extraArgs` if no launchArgBuilder defined.
- */
-export interface ProviderLaunchMode {
- /** Unique mode identifier (e.g. 'terminal', 'chat') */
-  id: string;
- /** Display name */
-  name: string;
-  description?: string;
- /**
-  * Preset option values — merged over defaults before calling launchArgBuilder.
-  * Keys correspond to ProviderLaunchOption.id.
-  */
-  options?: Record<string, string | boolean | number>;
- /**
-  * Fallback: raw args appended when no launchArgBuilder is defined.
-  * Use launchArgBuilder + options for anything more than trivial cases.
-  */
-  extraArgs?: string[];
- /** Env var overrides applied on top of spawn.env */
-  env?: Record<string, string>;
- /**
-  * Output rendering hint (shorthand when not using launchOptions/outputFormatMap).
-  * - 'terminal' — raw PTY stream (default)
-  * - 'stream-json' — structured JSON events → chat messages
-  */
-  outputFormat?: 'terminal' | 'stream-json';
- /** Whether this is the default mode when none is specified */
-  default?: boolean;
-}
-
 export interface ProviderResumeCapability {
   supported: boolean;
   stopStrategy?: 'command' | 'ctrl_c';
@@ -688,4 +608,3 @@ export interface ProviderControlDef {
  /** Hide this control when condition not met */
   hidden?: boolean;
 }
-

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

@@ -111,6 +111,8 @@ export class ExtensionProviderInstance implements ProviderInstance {
                 this.detectTransition(newStatus, data);
                 this.currentStatus = newStatus;
             }
+        } else if (event === 'stream_reset') {
+            this.resetStreamState();
         } else if (event === 'extension_connected') {
             this.ideType = data?.ideType || '';
  // Maintain instanceId UUID — do not overwrite
@@ -208,4 +210,29 @@ export class ExtensionProviderInstance implements ProviderInstance {
             : this.chatTitle;
         return title || this.agentName || this.provider.name;
     }
+
+    private resetStreamState(): void {
+        if (this.currentStatus !== 'idle') {
+            this.detectTransition('idle', {
+                title: this.chatTitle,
+                agentName: this.agentName,
+                extensionId: this.extensionId,
+                messages: this.messages,
+            });
+        }
+        this.agentStreams = [];
+        this.messages = [];
+        this.activeModal = null;
+        this.currentModel = '';
+        this.currentMode = '';
+        this.controlValues = {};
+        this.currentStatus = 'idle';
+        this.chatId = null;
+        this.chatTitle = null;
+        this.agentName = '';
+        this.extensionId = '';
+        this.lastAgentStatus = 'idle';
+        this.generatingStartedAt = 0;
+        this.monitor.reset();
+    }
 }

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

@@ -140,12 +140,24 @@ export class IdeProviderInstance implements ProviderInstance {
         } else if (event === 'cdp_disconnected') {
             this.cachedChat = null;
             this.currentStatus = 'idle';
+            for (const ext of this.extensions.values()) {
+                ext.onEvent('stream_reset');
+            }
         } else if (event === 'stream_update') {
  // Forward to Extension
             const extType = data?.extensionType;
             if (extType && this.extensions.has(extType)) {
                 this.extensions.get(extType)!.onEvent('stream_update', data);
             }
+        } else if (event === 'stream_reset') {
+            const extType = data?.extensionType;
+            if (extType && this.extensions.has(extType)) {
+                this.extensions.get(extType)!.onEvent('stream_reset');
+            }
+        } else if (event === 'stream_reset_all') {
+            for (const ext of this.extensions.values()) {
+                ext.onEvent('stream_reset');
+            }
         }
     }
 

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

@@ -37,7 +37,6 @@ export interface ActiveChatData {
         message: string;
         buttons: string[];
     } | null;
-    terminalHistory?: string;
     inputContent?: string;
 }
 /** Standardized error reasons across all provider categories */

package/src/providers/provider-instance.ts

@@ -42,7 +42,6 @@ export interface ActiveChatData {
     status: string;
     messages: ChatMessage[];
     activeModal: { message: string; buttons: string[] } | null;
-    terminalHistory?: string;
     inputContent?: string;
 }
 
@@ -103,8 +102,6 @@ export interface CliProviderState extends ProviderStateBase {
     category: 'cli';
  /** terminal = PTY stream, chat = parsed conversation */
     mode: 'terminal' | 'chat';
- /** Active launch mode id (e.g. 'chat') — undefined means default terminal */
-    launchMode?: string;
 }
 
 /** ACP provider state */

package/src/shared-types.ts

@@ -102,9 +102,7 @@ export interface SessionEntry {
     runtimeKey?: string;
     runtimeDisplayName?: string;
     runtimeWorkspaceLabel?: string;
-    /** CLI only: active launch mode id (e.g. 'terminal', 'chat') */
-    launchMode?: string;
-    /** CLI only: output rendering mode derived from launchMode.outputFormat */
+    /** CLI only: active presentation mode */
     mode?: 'terminal' | 'chat';
     runtimeWriteOwner?: RuntimeWriteOwner | null;
     runtimeAttachedClients?: RuntimeAttachedClient[];

package/src/status/builders.ts

@@ -167,6 +167,12 @@ const PTY_SESSION_CAPABILITIES: SessionCapability[] = [
     'resize_terminal',
 ];
 
+const CLI_CHAT_SESSION_CAPABILITIES: SessionCapability[] = [
+    'read_chat',
+    'send_message',
+    'resolve_action',
+];
+
 const ACP_SESSION_CAPABILITIES: SessionCapability[] = [
     'read_chat',
     'send_message',
@@ -265,11 +271,10 @@ function buildCliSession(state: CliProviderState): SessionEntry {
         runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
         runtimeWriteOwner: state.runtime?.writeOwner || null,
         runtimeAttachedClients: state.runtime?.attachedClients || [],
-        launchMode: state.launchMode,
         mode: state.mode,
         resume: state.resume,
         activeChat,
-        capabilities: PTY_SESSION_CAPABILITIES,
+        capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
         controlValues: state.controlValues,
         providerControls: buildFallbackControls(
             state.providerControls

package/src/status/normalize.ts

@@ -20,6 +20,77 @@ const WORKING_STATUSES = new Set([
     'active',
 ]);
 
+// Status snapshots are sent over P2P every 5s, so keep only a recent live window here.
+// Older history is fetched on demand via `chat_history`, and CLI terminals stream via runtime events.
+const STATUS_ACTIVE_CHAT_MESSAGE_LIMIT = 60;
+const STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT = 96 * 1024;
+const STATUS_ACTIVE_CHAT_STRING_LIMIT = 4 * 1024;
+const STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT = 1024;
+const STATUS_INPUT_CONTENT_LIMIT = 2 * 1024;
+const STATUS_MODAL_MESSAGE_LIMIT = 2 * 1024;
+const STATUS_MODAL_BUTTON_LIMIT = 120;
+
+function truncateString(value: string, maxChars: number): string {
+    if (value.length <= maxChars) return value;
+    if (maxChars <= 12) return value.slice(0, Math.max(0, maxChars));
+    return `${value.slice(0, maxChars - 12)}...[truncated]`;
+}
+
+function truncateStringTail(value: string, maxChars: number): string {
+    if (value.length <= maxChars) return value;
+    if (maxChars <= 12) return value.slice(value.length - Math.max(0, maxChars));
+    return `...[truncated]${value.slice(value.length - (maxChars - 12))}`;
+}
+
+function trimStructuredStrings(value: unknown, maxChars: number): unknown {
+    if (typeof value === 'string') return truncateString(value, maxChars);
+    if (Array.isArray(value)) return value.map((item) => trimStructuredStrings(item, maxChars));
+    if (!value || typeof value !== 'object') return value;
+    return Object.fromEntries(
+        Object.entries(value).map(([key, nested]) => [key, trimStructuredStrings(nested, maxChars)]),
+    );
+}
+
+function estimateBytes(value: unknown): number {
+    try {
+        return JSON.stringify(value).length;
+    } catch {
+        return String(value ?? '').length;
+    }
+}
+
+function trimMessageForStatus(message: unknown, stringLimit: number): unknown {
+    if (!message || typeof message !== 'object') return message;
+    return trimStructuredStrings(message, stringLimit);
+}
+
+function trimMessagesForStatus(messages: unknown[] | null | undefined): unknown[] {
+    if (!Array.isArray(messages) || messages.length === 0) return [];
+
+    const recent = messages.slice(-STATUS_ACTIVE_CHAT_MESSAGE_LIMIT);
+    const kept: unknown[] = [];
+    let totalBytes = 0;
+
+    for (let i = recent.length - 1; i >= 0; i -= 1) {
+        let normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT);
+        let size = estimateBytes(normalized);
+
+        if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+            normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT);
+            size = estimateBytes(normalized);
+        }
+
+        if (kept.length > 0 && (totalBytes + size) > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+            continue;
+        }
+
+        kept.push(normalized);
+        totalBytes += size;
+    }
+
+    return kept.reverse();
+}
+
 function hasApprovalButtons(activeModal?: { buttons?: unknown[] | null } | null): boolean {
     return (activeModal?.buttons?.length ?? 0) > 0;
 }
@@ -60,5 +131,15 @@ export function normalizeActiveChatData<T extends ActiveChatData | null | undefi
     return {
         ...activeChat,
         status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),
+        messages: trimMessagesForStatus(activeChat.messages) as T extends { messages: infer M } ? M : never,
+        activeModal: activeChat.activeModal ? {
+            message: truncateString(activeChat.activeModal.message || '', STATUS_MODAL_MESSAGE_LIMIT),
+            buttons: (activeChat.activeModal.buttons || []).map((button) =>
+                truncateString(String(button || ''), STATUS_MODAL_BUTTON_LIMIT)
+            ),
+        } : activeChat.activeModal,
+        inputContent: activeChat.inputContent
+            ? truncateString(activeChat.inputContent, STATUS_INPUT_CONTENT_LIMIT)
+            : activeChat.inputContent,
     } as T;
 }

package/src/status/reporter.ts

@@ -113,6 +113,26 @@ export class DaemonStatusReporter {
         return new Date().toISOString().slice(11, 23); // HH:mm:ss.SSS
     }
 
+    private summarizeLargePayloadSessions(payload: Record<string, any>): string {
+        const sessions = Array.isArray(payload.sessions) ? payload.sessions : [];
+        return sessions
+            .map((session: any) => ({
+                id: String(session?.id || ''),
+                providerType: String(session?.providerType || ''),
+                bytes: (() => {
+                    try {
+                        return JSON.stringify(session).length;
+                    } catch {
+                        return 0;
+                    }
+                })(),
+            }))
+            .sort((a, b) => b.bytes - a.bytes)
+            .slice(0, 3)
+            .map((session) => `${session.providerType || 'unknown'}:${session.id}=${session.bytes}b`)
+            .join(', ');
+    }
+
     async sendUnifiedStatusReport(opts?: { p2pOnly?: boolean }): Promise<void> {
         const { serverConn, p2p } = this.deps;
         if (!serverConn?.isConnected()) return;
@@ -179,10 +199,17 @@ export class DaemonStatusReporter {
             connectedExtensions: [],
         };
 
- // ═══ P2P transmit ═══
+// ═══ P2P transmit ═══
+        const payloadBytes = JSON.stringify(payload).length;
         const p2pSent = this.sendP2PPayload(payload);
         if (p2pSent) {
-            LOG.debug('P2P', `sent (${JSON.stringify(payload).length} bytes)`);
+            LOG.debug('P2P', `sent (${payloadBytes} bytes)`);
+            if (payloadBytes > 256 * 1024) {
+                LOG.warn(
+                    'P2P',
+                    `large status payload (${payloadBytes} bytes) top sessions: ${this.summarizeLargePayloadSessions(payload) || 'n/a'}`,
+                );
+            }
         }
 
  // ═══ Server transmit (minimal routing meta only) ═══
@@ -215,6 +242,8 @@ export class DaemonStatusReporter {
             })),
             p2p: payload.p2p,
             timestamp: now,
+            detectedIdes: payload.detectedIdes,
+            availableProviders: payload.availableProviders,
         };
         serverConn.sendMessage('status_report', wsPayload);
         LOG.debug('Server', `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);