@adhdev/daemon-core 0.9.32 → 0.9.34

package/dist/providers/cli-provider-instance.d.ts

@@ -5,7 +5,7 @@
  * collectCliData() + status transition logic from daemon-status.ts moved here.
  */
 import { type ProviderModule } from './contracts.js';
-import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, InstanceContext, HotChatSessionState } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 type PersistableCliHistoryMessage = {
@@ -89,6 +89,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     getState(): ProviderState;
     setPresentationMode(mode: 'terminal' | 'chat'): void;
     getPresentationMode(): 'terminal' | 'chat';
+    getHotChatSessionState(): HotChatSessionState;
     updateSettings(newSettings: Record<string, any>): void;
     onEvent(event: string, data?: any): void;
     dispose(): void;

package/dist/providers/provider-instance-manager.d.ts

@@ -7,7 +7,7 @@
  * 3. Collect overall state
  * 4. Event collection and propagation
  */
-import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, HotChatSessionState } from './provider-instance.js';
 export declare class ProviderInstanceManager {
     private instances;
     private tickTimer;
@@ -45,6 +45,7 @@ export declare class ProviderInstanceManager {
     * + Propagate pending events to event listeners
     */
     collectAllStates(): ProviderState[];
+    collectHotChatSessionStates(): HotChatSessionState[];
     /**
     * Per-category status collect
     */

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

@@ -112,6 +112,17 @@ export interface ProviderEvent {
     timestamp: number;
     [key: string]: any;
 }
+export interface HotChatSessionState {
+    id: string;
+    status?: unknown;
+    unread?: unknown;
+    inboxBucket?: unknown;
+    lastMessageAt?: unknown;
+    runtimeLifecycle?: unknown;
+    runtimeSurfaceKind?: unknown;
+    runtimeRestoredFromStorage?: unknown;
+    runtimeRecoveryState?: unknown;
+}
 export interface InstanceContext {
     /** CDP connection (IDE/Extension) */
     cdp?: {
@@ -142,6 +153,12 @@ export interface ProviderInstance {
     onTick(): Promise<void>;
     /** Return current status */
     getState(): ProviderState;
+    /**
+     * Return the cheap session metadata needed to decide whether chat-tail
+     * subscriptions should be flushed. Implementations must avoid rich transcript
+     * parsing here; callers use this on P2P hot flush paths.
+     */
+    getHotChatSessionState?(): HotChatSessionState | HotChatSessionState[] | null;
     /** Receive event (external → Instance) */
     onEvent(event: string, data?: any): void;
     /** Update settings at runtime (called when user changes settings from dashboard) */

package/dist/providers/provider-loader.d.ts

@@ -221,6 +221,7 @@ export declare class ProviderLoader {
     getMachineProviderConfig(type: string): MachineProviderConfig;
     setMachineProviderConfig(type: string, patch: Partial<MachineProviderConfig>): boolean;
     setMachineProviderEnabled(type: string, enabled: boolean): boolean;
+    private getEffectiveProviderAvailability;
     getMachineProviderStatus(type: string): ProviderMachineStatus;
     getSpawnArgs(type: string, fallback?: string[]): string[];
     private parseArgsSetting;

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.32",
+  "version": "0.9.34",
   "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.9.32",
+  "version": "0.9.34",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -1067,7 +1067,7 @@ export class ProviderCliAdapter implements CliAdapter {
         }
 
         if (this.currentTurnScope && !lastParsedAssistant) {
-            LOG.info(
+            LOG.debug(
                 'CLI',
                 `[${this.cliType}] Settled without assistant: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 220)).slice(0, 260)} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || '-'} scriptDir=${this.providerResolutionMeta.scriptDir || '-'}`
             );
@@ -2013,9 +2013,52 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private armResponseTimeout(): void {
         if (this.responseTimeout) clearTimeout(this.responseTimeout);
+        const timeoutMs = this.timeouts.maxResponse;
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            this.responseTimeout = null;
+            return;
+        }
         this.responseTimeout = setTimeout(() => {
-            if (this.isWaitingForResponse) this.finishResponse();
-        }, this.timeouts.maxResponse);
+            this.responseTimeout = null;
+            if (!this.isWaitingForResponse) return;
+
+            const detectedStatusBeforeEval = this.runDetectStatus(this.recentOutputBuffer);
+            this.recordTrace('response_timeout_check', {
+                timeoutMs,
+                detectedStatus: detectedStatusBeforeEval,
+                currentStatus: this.currentStatus,
+                isWaitingForResponse: this.isWaitingForResponse,
+                hasActionableApproval: this.hasActionableApproval(),
+                ...buildCliTraceParseSnapshot({
+                    accumulatedBuffer: this.accumulatedBuffer,
+                    accumulatedRawBuffer: this.accumulatedRawBuffer,
+                    responseBuffer: this.responseBuffer,
+                    partialResponse: this.responseBuffer,
+                    scope: this.currentTurnScope,
+                }),
+            });
+
+            // maxResponse is a watchdog/checkpoint, not a completion signal. The old
+            // behavior called finishResponse() unconditionally at the default 300s,
+            // which fabricated idle transitions and downstream generating_completed
+            // notifications while long-running CLIs were still generating. Re-run the
+            // normal settled parser instead and keep the turn open unless the provider
+            // actually reports an idle, commit-ready state.
+            this.settledBuffer = this.recentOutputBuffer;
+            this.evaluateSettled();
+
+            if (this.isWaitingForResponse && !this.hasActionableApproval()) {
+                const detectedStatusAfterEval = this.runDetectStatus(this.recentOutputBuffer);
+                this.recordTrace('response_timeout_kept_open', {
+                    timeoutMs,
+                    detectedStatusBeforeEval,
+                    detectedStatusAfterEval,
+                    currentStatus: this.currentStatus,
+                    isWaitingForResponse: this.isWaitingForResponse,
+                });
+                this.armResponseTimeout();
+            }
+        }, timeoutMs);
     }
 
     private writeSubmitKeyForRetry(mode: string): void {

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

@@ -31,6 +31,7 @@ export function hydrateCliParsedMessages(
 ): any[] {
     const { committedMessages, scope, lastOutputAt } = options;
     const referenceMessages = [...committedMessages];
+    const referenceComparables = referenceMessages.map((message) => normalizeComparableMessageContent(message?.content || ''));
     const usedReferenceIndexes = new Set<number>();
     const now = options.now ?? Date.now();
 
@@ -43,7 +44,7 @@ export function hydrateCliParsedMessages(
             sameIndex
             && !usedReferenceIndexes.has(parsedIndex)
             && sameIndex.role === role
-            && normalizeComparableMessageContent(sameIndex.content) === normalizedContent
+            && referenceComparables[parsedIndex] === normalizedContent
             && typeof sameIndex.timestamp === 'number'
             && Number.isFinite(sameIndex.timestamp)
         ) {
@@ -55,7 +56,7 @@ export function hydrateCliParsedMessages(
             if (usedReferenceIndexes.has(i)) continue;
             const candidate = referenceMessages[i];
             if (!candidate || candidate.role !== role) continue;
-            const candidateContent = normalizeComparableMessageContent(candidate.content);
+            const candidateContent = referenceComparables[i];
             if (!candidateContent) continue;
             const exactMatch = candidateContent === normalizedContent;
             const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);

package/src/commands/chat-commands.ts

@@ -297,6 +297,36 @@ function toHistoryPersistedMessages(messages: ChatMessage[]): Array<{
     }));
 }
 
+function findLastMessageIndexBySignature(messages: ChatMessage[], signature: string): number {
+    if (!signature) return -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (getChatMessageSignature(messages[index]) === signature) {
+            return index;
+        }
+    }
+    return -1;
+}
+
+function buildBoundedTailSync(messages: ChatMessage[], cursor: Required<ReadChatCursor>): {
+    syncMode: ReadChatSyncMode;
+    replaceFrom: number;
+    messages: ChatMessage[];
+    totalMessages: number;
+    lastMessageSignature: string;
+} {
+    const totalMessages = messages.length;
+    const tailMessages = cursor.tailLimit > 0 && totalMessages > cursor.tailLimit
+        ? messages.slice(-cursor.tailLimit)
+        : messages;
+    return {
+        syncMode: 'full',
+        replaceFrom: 0,
+        messages: tailMessages,
+        totalMessages,
+        lastMessageSignature: getChatMessageSignature(messages[totalMessages - 1]),
+    };
+}
+
 function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatCursor>): {
     syncMode: ReadChatSyncMode;
     replaceFrom: number;
@@ -338,6 +368,16 @@ function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatC
         };
     }
 
+    if (cursor.tailLimit > 0 && knownSignature === lastMessageSignature) {
+        return {
+            syncMode: 'noop',
+            replaceFrom: totalMessages,
+            messages: [],
+            totalMessages,
+            lastMessageSignature,
+        };
+    }
+
     if (knownMessageCount < totalMessages) {
         const anchorSignature = getChatMessageSignature(messages[knownMessageCount - 1]);
         if (anchorSignature === knownSignature) {
@@ -349,6 +389,20 @@ function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatC
                 lastMessageSignature,
             };
         }
+
+        if (cursor.tailLimit > 0) {
+            const signatureIndex = findLastMessageIndexBySignature(messages, knownSignature);
+            if (signatureIndex >= 0) {
+                return {
+                    syncMode: 'append',
+                    replaceFrom: knownMessageCount,
+                    messages: messages.slice(signatureIndex + 1),
+                    totalMessages,
+                    lastMessageSignature,
+                };
+            }
+            return buildBoundedTailSync(messages, cursor);
+        }
     }
 
     const replaceFrom = Math.max(0, Math.min(knownMessageCount - 1, totalMessages));

package/src/commands/upgrade-helper.ts

@@ -161,6 +161,52 @@ function killPid(pid: number): boolean {
   }
 }
 
+function getWindowsProcessCommandLine(pid: number): string | null {
+  const pidFilter = `ProcessId=${pid}`;
+  try {
+    const psOut = execFileSync('powershell.exe', [
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy', 'Bypass',
+      '-Command',
+      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`,
+    ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (psOut) return psOut;
+  } catch {
+    // fall through to wmic fallback
+  }
+
+  try {
+    const wmicOut = execFileSync('wmic', [
+      'process', 'where', pidFilter, 'get', 'CommandLine',
+    ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (wmicOut) return wmicOut;
+  } catch {
+    // noop
+  }
+  return null;
+}
+
+function getProcessCommandLine(pid: number): string | null {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  if (process.platform === 'win32') return getWindowsProcessCommandLine(pid);
+  try {
+    const text = execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+      encoding: 'utf8',
+      timeout: 3000,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+
+function isManagedSessionHostPid(pid: number): boolean {
+  const commandLine = getProcessCommandLine(pid);
+  return !!commandLine && /session-host-daemon/i.test(commandLine);
+}
+
 async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -173,12 +219,12 @@ async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
   }
 }
 
-function stopSessionHostProcesses(appName: string): void {
+export function stopSessionHostProcesses(appName: string): void {
   const pidFile = path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
   try {
     if (fs.existsSync(pidFile)) {
       const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
-      if (Number.isFinite(pid)) {
+      if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
         killPid(pid);
       }
     }
@@ -191,20 +237,6 @@ function stopSessionHostProcesses(appName: string): void {
       // noop
     }
   }
-
-  if (process.platform !== 'win32') {
-    try {
-      const raw = execFileSync('pgrep', ['-f', 'session-host-daemon'], { encoding: 'utf8' }).trim();
-      for (const line of raw.split('\n')) {
-        const pid = Number.parseInt(line.trim(), 10);
-        if (Number.isFinite(pid)) {
-          killPid(pid);
-        }
-      }
-    } catch {
-      // noop
-    }
-  }
 }
 
 function removeDaemonPidFile(): void {

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

@@ -12,7 +12,7 @@ import * as fs from 'fs';
 import { createRequire } from 'node:module';
 import { normalizeInputEnvelope, type ProviderModule, flattenContent } from './contracts.js';
 import { assertTextOnlyInput } from './provider-input-support.js';
-import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, ProviderErrorReason } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, ProviderErrorReason, HotChatSessionState } 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 { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
@@ -487,6 +487,21 @@ export class CliProviderInstance implements ProviderInstance {
         return this.presentationMode;
     }
 
+    getHotChatSessionState(): HotChatSessionState {
+        const adapterStatus = this.adapter.getStatus();
+        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const visibleStatus = autoApproveActive ? 'generating' : adapterStatus.status;
+        const runtime = this.adapter.getRuntimeMetadata();
+        return {
+            id: this.instanceId,
+            status: visibleStatus,
+            runtimeLifecycle: runtime?.lifecycle ?? null,
+            runtimeSurfaceKind: runtime?.surfaceKind,
+            runtimeRestoredFromStorage: runtime?.restoredFromStorage === true,
+            runtimeRecoveryState: runtime?.recoveryState ?? null,
+        };
+    }
+
     updateSettings(newSettings: Record<string, any>): void {
         this.settings = { ...newSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
@@ -650,6 +665,15 @@ export class CliProviderInstance implements ProviderInstance {
                     this.completedDebouncePending = { chatTitle, duration, timestamp: now };
                     this.completedDebounceTimer = setTimeout(() => {
                         if (this.completedDebouncePending) {
+                            const latestStatus = this.adapter.getStatus();
+                            const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+                            const latestVisibleStatus = latestAutoApproveActive ? 'generating' : latestStatus.status;
+                            if (latestVisibleStatus !== 'idle') {
+                                LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
+                                this.completedDebouncePending = null;
+                                this.completedDebounceTimer = null;
+                                return;
+                            }
                             LOG.info('CLI', `[${this.type}] completed in ${this.completedDebouncePending.duration}s`);
                             this.pushEvent({ event: 'agent:generating_completed', ...this.completedDebouncePending });
                             this.completedDebouncePending = null;

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

@@ -8,9 +8,25 @@
  * 4. Event collection and propagation
  */
 
-import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, HotChatSessionState } from './provider-instance.js';
 import { LOG } from '../logging/logger.js';
 
+function projectHotChatSessionStatesFromProviderState(state: ProviderState): HotChatSessionState[] {
+    const project = (item: ProviderState): HotChatSessionState => ({
+        id: item.instanceId,
+        status: item.activeChat?.status || item.status,
+        runtimeLifecycle: item.runtime?.lifecycle ?? null,
+        runtimeSurfaceKind: item.runtime?.surfaceKind,
+        runtimeRestoredFromStorage: item.runtime?.restoredFromStorage === true,
+        runtimeRecoveryState: item.runtime?.recoveryState ?? null,
+    });
+
+    if (state.category === 'ide') {
+        return [project(state), ...state.extensions.map(project)];
+    }
+    return [project(state)];
+}
+
 export class ProviderInstanceManager {
     private instances = new Map<string, ProviderInstance>();
     private tickTimer: NodeJS.Timeout | null = null;
@@ -120,6 +136,32 @@ export class ProviderInstanceManager {
         return states;
     }
 
+    collectHotChatSessionStates(): HotChatSessionState[] {
+        const sessions: HotChatSessionState[] = [];
+        for (const [id, instance] of this.instances) {
+            try {
+                const projected = instance.getHotChatSessionState?.();
+                if (Array.isArray(projected)) {
+                    sessions.push(...projected.filter((session): session is HotChatSessionState => !!session?.id));
+                    continue;
+                }
+                if (projected?.id) {
+                    sessions.push(projected);
+                    continue;
+                }
+
+                // Fallback for provider types that have not implemented the cheap
+                // projection yet. CLI implements getHotChatSessionState() because
+                // its full getState() may run rich transcript parsing.
+                const state = instance.getState();
+                sessions.push(...projectHotChatSessionStatesFromProviderState(state));
+            } catch (e) {
+                LOG.warn('InstanceMgr', `[InstanceManager] Failed to collect hot chat metadata from ${id}: ${(e as Error).message}`);
+            }
+        }
+        return sessions;
+    }
+
  /**
  * Per-category status collect
  */

package/src/providers/provider-instance.ts

@@ -135,6 +135,18 @@ export interface ProviderEvent {
     [key: string]: any;
 }
 
+export interface HotChatSessionState {
+    id: string;
+    status?: unknown;
+    unread?: unknown;
+    inboxBucket?: unknown;
+    lastMessageAt?: unknown;
+    runtimeLifecycle?: unknown;
+    runtimeSurfaceKind?: unknown;
+    runtimeRestoredFromStorage?: unknown;
+    runtimeRecoveryState?: unknown;
+}
+
 // ─── ProviderInstance interface ─────────────────
 
 export interface InstanceContext {
@@ -172,6 +184,13 @@ export interface ProviderInstance {
  /** Return current status */
     getState(): ProviderState;
 
+    /**
+     * Return the cheap session metadata needed to decide whether chat-tail
+     * subscriptions should be flushed. Implementations must avoid rich transcript
+     * parsing here; callers use this on P2P hot flush paths.
+     */
+    getHotChatSessionState?(): HotChatSessionState | HotChatSessionState[] | null;
+
  /** Receive event (external → Instance) */
     onEvent(event: string, data?: any): void;
 

package/src/providers/provider-loader.ts

@@ -653,10 +653,26 @@ export class ProviderLoader {
     return this.setMachineProviderConfig(type, { enabled });
   }
 
+  private getEffectiveProviderAvailability(type: string): ProviderAvailabilityState | undefined {
+    const providerType = this.resolveAlias(type);
+    const availability = this.providerAvailability.get(providerType);
+    if (availability) return availability;
+
+    const machineConfig = this.getMachineProviderConfig(providerType);
+    const lastDetection = machineConfig.lastDetection;
+    if (!lastDetection) return undefined;
+    return {
+      installed: lastDetection.ok === true,
+      detectedPath: typeof lastDetection.path === 'string' && lastDetection.path.trim()
+        ? lastDetection.path.trim()
+        : null,
+    };
+  }
+
   getMachineProviderStatus(type: string): ProviderMachineStatus {
     const providerType = this.resolveAlias(type);
     if (!this.isMachineProviderEnabled(providerType)) return 'disabled';
-    const availability = this.providerAvailability.get(providerType);
+    const availability = this.getEffectiveProviderAvailability(providerType);
     if (!availability) return 'enabled_unchecked';
     return availability.installed ? 'detected' : 'not_detected';
   }
@@ -792,7 +808,7 @@ export class ProviderLoader {
 
   getAvailableProviderInfos(): Array<ProviderModule & { installed?: boolean; detectedPath?: string | null; enabled: boolean; machineStatus: ProviderMachineStatus; lastDetection?: MachineProviderCheckResult; lastVerification?: MachineProviderCheckResult }> {
     return this.getAll().map((provider) => {
-      const availability = this.providerAvailability.get(provider.type);
+      const availability = this.getEffectiveProviderAvailability(provider.type);
       const enabled = this.isMachineProviderEnabled(provider.type);
       const machineConfig = this.getMachineProviderConfig(provider.type);
       return {