@adhdev/daemon-core 0.8.87 → 0.8.89

package/dist/runtime-defaults.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_CDP_SCAN_INTERVAL_MS = 30000;
+export declare const DEFAULT_CDP_DISCOVERY_INTERVAL_MS = 30000;
+export declare const DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS = 2000;
+export declare const DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS = 30000;
+export declare const DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS = 5000;
+export declare const MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS = 5000;
+export declare const DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS = 15000;
+export declare const MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 5000;
+export declare const DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 10000;
+export declare const DEFAULT_SESSION_HOST_READY_TIMEOUT_MS = 15000;
+export declare const STANDALONE_CDP_SCAN_INTERVAL_MS = 15000;

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

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

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -27,7 +27,11 @@ import { DevServer } from '../daemon/dev-server.js';
 import { detectIDEs, type IDEInfo } from '../detection/ide-detector.js';
 import { detectCLI, detectCLIs } from '../detection/cli-detector.js';
 import { SessionRegistry } from '../sessions/registry.js';
-import { installGlobalInterceptor, LOG } from '../logging/logger.js';
+import { LOG, installGlobalInterceptor } from '../logging/logger.js';
+import {
+    DEFAULT_CDP_DISCOVERY_INTERVAL_MS,
+    DEFAULT_CDP_SCAN_INTERVAL_MS,
+} from '../runtime-defaults.js';
 import { loadConfig } from '../config/config.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { IdeProviderInstance } from '../providers/ide-provider-instance.js';
@@ -240,8 +244,8 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         },
     });
     await cdpInitializer.connectAll(detectedIdesRef.value);
-    cdpInitializer.startPeriodicScan(config.cdpScanIntervalMs ?? 30_000);
-    cdpInitializer.startDiscovery(30_000);
+    cdpInitializer.startPeriodicScan(config.cdpScanIntervalMs ?? DEFAULT_CDP_SCAN_INTERVAL_MS);
+    cdpInitializer.startDiscovery(DEFAULT_CDP_DISCOVERY_INTERVAL_MS);
 
     // 7. CommandHandler
     const commandHandler = new DaemonCommandHandler({

package/src/cdp/initializer.ts

@@ -14,6 +14,7 @@ import { registerExtensionProviders } from './setup.js';
 import { probeCdpPort } from './setup.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import { LOG } from '../logging/logger.js';
+import { DEFAULT_CDP_DISCOVERY_INTERVAL_MS, DEFAULT_CDP_SCAN_INTERVAL_MS } from '../runtime-defaults.js';
 
 // ─── Config ───
 
@@ -206,7 +207,7 @@ export class DaemonCdpInitializer {
      * Start periodic scanning for newly opened IDEs.
      * Idempotent — ignored if already started.
      */
-    startPeriodicScan(intervalMs = 30_000): void {
+    startPeriodicScan(intervalMs = DEFAULT_CDP_SCAN_INTERVAL_MS): void {
         if (this.scanTimer) return;
 
         this.scanTimer = setInterval(async () => {
@@ -224,7 +225,7 @@ export class DaemonCdpInitializer {
     /**
      * Start periodic agent webview discovery.
      */
-    startDiscovery(intervalMs = 30_000): void {
+    startDiscovery(intervalMs = DEFAULT_CDP_DISCOVERY_INTERVAL_MS): void {
         if (this.discoveryTimer) return;
 
         this.discoveryTimer = setInterval(async () => {

package/src/cdp/scanner.ts

@@ -12,6 +12,7 @@ import { DaemonCdpManager } from './manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import { connectCdpManager, probeCdpPort, registerExtensionProviders, setupIdeInstance, type CdpSetupContext } from './setup.js';
 import { LOG } from '../logging/logger.js';
+import { DEFAULT_CDP_DISCOVERY_INTERVAL_MS, DEFAULT_CDP_SCAN_INTERVAL_MS } from '../runtime-defaults.js';
 
 export interface CdpScannerOptions {
   /** Context for setup operations */
@@ -68,7 +69,7 @@ export class DaemonCdpScanner {
    */
   startPeriodicScan(): void {
     if (this.scanTimer) return;
-    const interval = this.opts.scanIntervalMs || 30_000;
+    const interval = this.opts.scanIntervalMs || DEFAULT_CDP_SCAN_INTERVAL_MS;
 
     this.scanTimer = setInterval(async () => {
       const portMap = this.ctx.providerLoader.getCdpPortMap();
@@ -92,7 +93,7 @@ export class DaemonCdpScanner {
   /**
    * Start periodic agent webview discovery on all connected CDPs.
    */
-  startWebviewDiscovery(intervalMs = 30_000): void {
+  startWebviewDiscovery(intervalMs = DEFAULT_CDP_DISCOVERY_INTERVAL_MS): void {
     if (this.discoveryTimer) return;
     this.discoveryTimer = setInterval(async () => {
       for (const m of this.ctx.cdpManagers.values()) {

package/src/cli-adapters/provider-cli-adapter.ts

@@ -804,9 +804,7 @@ export class ProviderCliAdapter implements CliAdapter {
         const buttons = Array.isArray(modal.buttons) ? modal.buttons : [];
         if (buttons.length !== 1) return false;
         const buttonLabel = String(buttons[0] || '').trim();
-        const modalText = `${modal.message || ''} ${buttonLabel}`.trim();
-        return looksLikeConfirmOnlyLabel(buttonLabel)
-            || /Quick safety check|project trust|trust (?:this project|the contents of this directory|the files in this folder)|Enter to confirm/i.test(modalText);
+        return looksLikeConfirmOnlyLabel(buttonLabel);
     }
 
     private async waitForInteractivePrompt(maxWaitMs = 5000): Promise<void> {
@@ -1466,11 +1464,16 @@ export class ProviderCliAdapter implements CliAdapter {
  // ─── Public API (CliAdapter) ───────────────────
 
     getStatus(): CliSessionStatus {
+        const screenText = this.terminalScreen.getText() || '';
+        const startupModal = this.startupParseGate ? this.getStartupConfirmationModal(screenText) : null;
+        const effectiveStatus = this.parseErrorMessage
+            ? 'error'
+            : (startupModal ? 'waiting_approval' : this.currentStatus);
         return {
-            status: this.parseErrorMessage ? 'error' : this.currentStatus,
+            status: effectiveStatus,
             messages: [...this.committedMessages],
             workingDir: this.workingDir,
-            activeModal: this.activeModal,
+            activeModal: startupModal || this.activeModal,
             errorMessage: this.parseErrorMessage || undefined,
             errorReason: this.parseErrorMessage ? 'parse_error' : undefined,
         };
@@ -1550,12 +1553,61 @@ export class ProviderCliAdapter implements CliAdapter {
                     ? message.receivedAt
                     : message.timestamp,
             }));
+            const parsedLastAssistant = [...parsedHydratedMessages].reverse().find((message) => message.role === 'assistant' && typeof message.content === 'string' && message.content.trim());
+            const visibleIdlePrompt = this.looksLikeVisibleIdlePrompt(screenText);
+            const shouldAdoptParsedIdleReplay =
+                !this.currentTurnScope
+                && !this.activeModal
+                && !!parsedLastAssistant
+                && parsedHydratedMessages.length > committedHydratedMessages.length
+                && (
+                    this.currentStatus === 'idle'
+                    || (
+                        this.currentStatus === 'generating'
+                        && this.isWaitingForResponse
+                        && parsed.status === 'idle'
+                        && visibleIdlePrompt
+                    )
+                );
+            if (shouldAdoptParsedIdleReplay) {
+                this.committedMessages = normalizeCliParsedMessages(parsed.messages, {
+                    committedMessages: this.committedMessages,
+                    scope: this.currentTurnScope,
+                    lastOutputAt: this.lastOutputAt,
+                });
+                this.syncMessageViews();
+                if (this.currentStatus !== 'idle' || this.isWaitingForResponse) {
+                    this.responseBuffer = '';
+                    this.isWaitingForResponse = false;
+                    this.responseSettleIgnoreUntil = 0;
+                    this.submitRetryUsed = false;
+                    this.submitRetryPromptSnippet = '';
+                    this.finishRetryCount = 0;
+                    this.currentTurnScope = null;
+                    this.activeModal = null;
+                    this.setStatus('idle', 'parsed_idle_replay_commit');
+                    this.onStatusChange?.();
+                }
+            }
+            const effectiveCommittedHydratedMessages = shouldAdoptParsedIdleReplay
+                ? this.committedMessages.map((message, index) => buildChatMessage({
+                    ...message,
+                    id: message.id || `msg_${index}`,
+                    index: typeof message.index === 'number' ? message.index : index,
+                    receivedAt: typeof message.receivedAt === 'number'
+                        ? message.receivedAt
+                        : message.timestamp,
+                }))
+                : committedHydratedMessages;
             const shouldPreferCommittedHistoryReplay =
                 !this.currentTurnScope
                 && !this.activeModal
-                && committedHydratedMessages.length > parsedHydratedMessages.length;
-            const hydratedMessages = (shouldPreferCommittedMessages || shouldPreferCommittedHistoryReplay)
-                ? committedHydratedMessages
+                && effectiveCommittedHydratedMessages.length > parsedHydratedMessages.length;
+            const shouldPreferCommittedIdleReplay =
+                shouldPreferCommittedMessages
+                && !shouldAdoptParsedIdleReplay;
+            const hydratedMessages = (shouldPreferCommittedIdleReplay || shouldPreferCommittedHistoryReplay)
+                ? effectiveCommittedHydratedMessages
                 : parsedHydratedMessages;
             result = {
                 id: parsed.id || 'cli_session',
@@ -2132,8 +2184,9 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     resolveModal(buttonIndex: number): void {
-        if (!this.ptyProcess || (this.currentStatus !== 'waiting_approval' && !this.activeModal)) return;
-        const modal = this.activeModal;
+        const screenText = this.terminalScreen.getText() || '';
+        const modal = this.activeModal || this.getStartupConfirmationModal(screenText);
+        if (!this.ptyProcess || ((this.currentStatus !== 'waiting_approval') && !modal)) return;
         this.clearIdleFinishCandidate('resolve_modal');
         this.recordTrace('resolve_modal', {
             buttonIndex,
@@ -2148,7 +2201,10 @@ export class ProviderCliAdapter implements CliAdapter {
         }
         this.setStatus('generating', 'approval_resolved');
         this.onStatusChange?.();
-        if (this.shouldResolveModalWithEnter(modal, buttonIndex)) {
+        const startupTrustModal = /Quick safety check|project trust|trust (?:this project|the contents of this directory|the files in this folder)/i.test(String(modal?.message || ''));
+        if (startupTrustModal && buttonIndex in this.approvalKeys) {
+            this.ptyProcess.write(`${this.approvalKeys[buttonIndex]}\r`);
+        } else if (this.shouldResolveModalWithEnter(modal, buttonIndex)) {
             this.ptyProcess.write('\r');
         } else if (buttonIndex in this.approvalKeys) {
             this.ptyProcess.write(this.approvalKeys[buttonIndex]);
@@ -2170,20 +2226,24 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     getDebugState(): Record<string, any> {
+        const screenText = sanitizeTerminalText(this.terminalScreen.getText());
+        const startupModal = this.startupParseGate ? this.getStartupConfirmationModal(screenText) : null;
+        const effectiveStatus = startupModal ? 'waiting_approval' : this.currentStatus;
+        const effectiveReady = this.ready || !!startupModal;
         return {
             type: this.cliType,
             name: this.cliName,
             providerResolution: this.providerResolutionMeta,
-            status: this.currentStatus,
-            ready: this.ready,
+            status: effectiveStatus,
+            ready: effectiveReady,
             startupParseGate: this.startupParseGate,
             spawnAt: this.spawnAt,
             workingDir: this.workingDir,
-            messages: this.messages.slice(-20),
-            committedMessages: this.committedMessages.slice(-20),
-            structuredMessages: this.structuredMessages.slice(-20),
+            messages: this.messages,
+            committedMessages: this.committedMessages,
+            structuredMessages: this.structuredMessages,
             messageCount: this.committedMessages.length,
-            screenText: sanitizeTerminalText(this.terminalScreen.getText()).slice(-4000),
+            screenText: screenText.slice(-4000),
             currentTurnScope: this.currentTurnScope,
             startupBuffer: this.startupBuffer.slice(-4000),
             recentOutputBuffer: this.recentOutputBuffer.slice(-500),
@@ -2198,7 +2258,7 @@ export class ProviderCliAdapter implements CliAdapter {
             lastScreenChangeAt: this.lastScreenChangeAt,
             lastScreenSnapshot: this.lastScreenSnapshot.slice(-500),
             isWaitingForResponse: this.isWaitingForResponse,
-            activeModal: this.activeModal,
+            activeModal: startupModal || this.activeModal,
             lastApprovalResolvedAt: this.lastApprovalResolvedAt,
             sendDelayMs: this.sendDelayMs,
             sendKey: this.sendKey,

package/src/index.ts

@@ -185,6 +185,19 @@ export { launchWithCdp, getAvailableIdeIds, killIdeProcess, isIdeRunning } from
 
 // ── IPC ──
 export { DEFAULT_DAEMON_PORT, DAEMON_WS_PATH } from './ipc-protocol.js';
+export {
+  DEFAULT_CDP_SCAN_INTERVAL_MS,
+  DEFAULT_CDP_DISCOVERY_INTERVAL_MS,
+  DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS,
+  DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS,
+  DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS,
+  MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
+  DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
+  MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
+  DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
+  DEFAULT_SESSION_HOST_READY_TIMEOUT_MS,
+  STANDALONE_CDP_SCAN_INTERVAL_MS,
+} from './runtime-defaults.js';
 
 // ── Chat History ──
 export { readChatHistory } from './config/chat-history.js';
@@ -253,7 +266,7 @@ export { VersionArchive, detectAllVersions } from './providers/version-archive.j
 export type { ProviderVersionInfo, VersionHistory } from './providers/version-archive.js';
 
 // ── Dev Server ──
-export { DevServer } from './daemon/dev-server.js';
+export { DevServer, DEV_SERVER_PORT } from './daemon/dev-server.js';
 
 // ── CLI Adapters ──
 export { ProviderCliAdapter } from './cli-adapters/provider-cli-adapter.js';

package/src/runtime-defaults.ts

@@ -0,0 +1,16 @@
+export const DEFAULT_CDP_SCAN_INTERVAL_MS = 30_000;
+export const DEFAULT_CDP_DISCOVERY_INTERVAL_MS = 30_000;
+
+export const DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS = 2_000;
+export const DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS = 30_000;
+export const DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS = 5_000;
+
+export const MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS = 5_000;
+export const DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS = 15_000;
+
+export const MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 5_000;
+export const DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 10_000;
+
+export const DEFAULT_SESSION_HOST_READY_TIMEOUT_MS = 15_000;
+
+export const STANDALONE_CDP_SCAN_INTERVAL_MS = 15_000;

package/src/session-host/runtime-support.ts

@@ -5,8 +5,9 @@ import {
     type SessionHostRecord,
 } from '@adhdev/session-host-core';
 import type { HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
+import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
 
-const STARTUP_TIMEOUT_MS = 8000;
+const STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
 const STARTUP_POLL_MS = 200;
 
 async function canConnect(endpoint: SessionHostEndpoint): Promise<boolean> {

package/src/status/reporter.ts

@@ -6,6 +6,11 @@
  */
 
 import { LOG } from '../logging/logger.js';
+import {
+    DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS,
+    DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS,
+    DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS,
+} from '../runtime-defaults.js';
 import type { DaemonCdpManager } from '../cdp/manager.js';
 import type { MachineInfo } from '../shared-types.js';
 import type { CloudStatusReportPayload, DaemonStatusEventPayload } from '../shared-types.js';
@@ -63,13 +68,13 @@ export class DaemonStatusReporter {
     startReporting(): void {
         setTimeout(() => {
             this.sendUnifiedStatusReport({ forceServer: true, reason: 'initial' }).catch(e => LOG.warn('Status', `Initial report failed: ${e?.message}`));
-        }, 2000);
+        }, DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS);
 
         const scheduleServerReport = () => {
             this.statusTimer = setTimeout(() => {
                 this.sendUnifiedStatusReport({ forceServer: true, reason: 'periodic' }).catch(e => LOG.warn('Status', `Periodic report failed: ${e?.message}`));
                 scheduleServerReport();
-            }, 30_000);
+            }, DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS);
         };
         scheduleServerReport();
 
@@ -77,7 +82,7 @@ export class DaemonStatusReporter {
             if (this.deps.p2p?.isConnected) {
                 this.sendUnifiedStatusReport({ p2pOnly: true }).catch(e => LOG.warn('Status', `P2P status send failed: ${e?.message}`));
             }
-        }, 5_000);
+        }, DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS);
     }
 
     stopReporting(): void {
@@ -92,14 +97,14 @@ export class DaemonStatusReporter {
     throttledReport(): void {
         const now = Date.now();
         const elapsed = now - this.lastStatusSentAt;
-        if (elapsed >= 5_000) {
+        if (elapsed >= DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS) {
             this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Throttled report failed: ${e?.message}`));
         } else if (!this.statusPendingThrottle) {
             this.statusPendingThrottle = true;
             setTimeout(() => {
                 this.statusPendingThrottle = false;
                 this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Deferred report failed: ${e?.message}`));
-            }, 5_000 - elapsed);
+            }, DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS - elapsed);
         }
     }