@adhdev/daemon-core 0.8.86 → 0.8.88

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.86",
+  "version": "0.8.88",
   "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.86",
+  "version": "0.8.88",
   "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

@@ -1550,12 +1550,40 @@ 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 shouldAdoptParsedIdleReplay =
+                !this.currentTurnScope
+                && !this.activeModal
+                && this.currentStatus === 'idle'
+                && parsedHydratedMessages.length > committedHydratedMessages.length
+                && !!parsedLastAssistant;
+            if (shouldAdoptParsedIdleReplay) {
+                this.committedMessages = normalizeCliParsedMessages(parsed.messages, {
+                    committedMessages: this.committedMessages,
+                    scope: this.currentTurnScope,
+                    lastOutputAt: this.lastOutputAt,
+                });
+                this.syncMessageViews();
+            }
+            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',

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);
         }
     }