@adhdev/daemon-core 0.8.75 → 0.8.77

package/src/index.ts

@@ -205,6 +205,8 @@ export {
   prepareSessionChatTailUpdate,
   prepareSessionModalUpdate,
 } from './chat/subscription-updates.js';
+export { runAsyncBatch } from './chat/async-batch.js';
+export type { AsyncBatchOptions } from './chat/async-batch.js';
 export type {
   ChatTailSubscriptionCursor,
   PrepareSessionChatTailUpdateInput,

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

@@ -383,8 +383,12 @@ export class CliProviderInstance implements ProviderInstance {
                 runtimeKey: runtime.runtimeKey,
                 displayName: runtime.displayName,
                 workspaceLabel: runtime.workspaceLabel,
+                lifecycle: runtime.lifecycle ?? null,
+                surfaceKind: runtime.surfaceKind,
                 writeOwner: runtime.writeOwner || null,
                 attachedClients: runtime.attachedClients || [],
+                restoredFromStorage: runtime.restoredFromStorage === true,
+                recoveryState: runtime.recoveryState ?? null,
             } : undefined,
             resume: this.provider.resume,
             controlValues: surface.controlValues,

package/src/providers/provider-instance.ts

@@ -32,8 +32,12 @@ export interface ProviderRuntimeInfo {
     runtimeKey?: string;
     displayName?: string;
     workspaceLabel?: string;
+    lifecycle?: string | null;
+    surfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
     writeOwner?: ProviderRuntimeWriteOwner | null;
     attachedClients?: ProviderRuntimeClient[];
+    restoredFromStorage?: boolean;
+    recoveryState?: string | null;
 }
 
 export interface ActiveChatData {

package/src/shared-types.ts

@@ -309,10 +309,14 @@ export interface SessionEntry {
     runtimeKey?: string;
     runtimeDisplayName?: string;
     runtimeWorkspaceLabel?: string;
+    runtimeLifecycle?: string | null;
+    runtimeSurfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
     /** CLI only: active presentation mode */
     mode?: 'terminal' | 'chat';
     runtimeWriteOwner?: RuntimeWriteOwner | null;
     runtimeAttachedClients?: RuntimeAttachedClient[];
+    runtimeRestoredFromStorage?: boolean;
+    runtimeRecoveryState?: string | null;
     resume?: ProviderResumeCapability;
     activeChat: _ActiveChatData | null;
     capabilities?: SessionCapability[];

package/src/status/builders.ts

@@ -50,7 +50,7 @@ function shouldIncludeSessionMetadata(profile: SessionEntryProfile): boolean {
 }
 
 function shouldIncludeRuntimeMetadata(profile: SessionEntryProfile): boolean {
-    return profile !== 'live';
+    return true;
 }
 
 // ─── CDP Manager lookup helpers ──────────────────────
@@ -214,6 +214,33 @@ function buildExtensionAgentSession(
     };
 }
 
+function shouldIncludeExtensionSession(ext: ExtensionProviderState): boolean {
+    const status = String(ext.status || '').trim().toLowerCase();
+    const hasActiveChat = !!ext.activeChat;
+    const hasMessages = Array.isArray(ext.activeChat?.messages) && ext.activeChat!.messages.length > 0;
+    const hasModal = !!ext.activeChat?.activeModal;
+    const hasStreams = Array.isArray((ext as any).agentStreams) && (ext as any).agentStreams.length > 0;
+    const hasProviderSessionId = typeof ext.providerSessionId === 'string' && ext.providerSessionId.trim().length > 0;
+    const hasControlValues = !!(ext.controlValues && Object.keys(ext.controlValues).length > 0);
+    const hasProviderControls = Array.isArray(ext.providerControls) && ext.providerControls.length > 0;
+    const hasOpenPanelCapability = Array.isArray(ext.sessionCapabilities) && ext.sessionCapabilities.includes('open_panel');
+    const hasSummaryMetadata = !!ext.summaryMetadata;
+    const hasError = typeof ext.errorMessage === 'string' && ext.errorMessage.trim().length > 0;
+    const hasInterestingStatus = !!status && !['idle', 'panel_hidden', 'disconnected', 'not_monitored'].includes(status);
+
+    return hasActiveChat
+        || hasMessages
+        || hasModal
+        || hasStreams
+        || hasProviderSessionId
+        || hasControlValues
+        || hasProviderControls
+        || hasOpenPanelCapability
+        || hasSummaryMetadata
+        || hasError
+        || hasInterestingStatus;
+}
+
 function buildCliSession(state: CliProviderState, options: SessionEntryBuildOptions): SessionEntry {
     const profile = options.profile || 'full';
     const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
@@ -239,8 +266,12 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
             runtimeKey: state.runtime?.runtimeKey,
             runtimeDisplayName: state.runtime?.displayName,
             runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
+            runtimeLifecycle: state.runtime?.lifecycle ?? null,
+            runtimeSurfaceKind: state.runtime?.surfaceKind,
             runtimeWriteOwner: state.runtime?.writeOwner || null,
             runtimeAttachedClients: state.runtime?.attachedClients || [],
+            runtimeRestoredFromStorage: state.runtime?.restoredFromStorage === true,
+            runtimeRecoveryState: state.runtime?.recoveryState ?? null,
         }),
         mode: state.mode,
         resume: state.resume,
@@ -305,6 +336,7 @@ export function buildSessionEntries(
     for (const state of ideStates) {
         sessions.push(buildIdeWorkspaceSession(state, cdpManagers, options));
         for (const ext of state.extensions as ExtensionProviderState[]) {
+            if (!shouldIncludeExtensionSession(ext)) continue;
             sessions.push(buildExtensionAgentSession(state, ext, options));
         }
     }

package/src/status/chat-tail-hot-sessions.ts

@@ -1,3 +1,5 @@
+import { getSessionHostSurfaceKind } from '../session-host/runtime-surface.js';
+
 export const DEFAULT_ACTIVE_CHAT_POLL_STATUSES = new Set([
   'generating',
   'waiting_approval',
@@ -6,10 +8,16 @@ export const DEFAULT_ACTIVE_CHAT_POLL_STATUSES = new Set([
 
 export const DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS = 8_000;
 
+const LIVE_RUNTIME_LIFECYCLES = new Set(['starting', 'running', 'stopping', 'interrupted']);
+
 export interface HotChatSessionLike {
   id?: string | null;
   status?: unknown;
   lastMessageAt?: unknown;
+  runtimeLifecycle?: unknown;
+  runtimeSurfaceKind?: unknown;
+  runtimeRestoredFromStorage?: unknown;
+  runtimeRecoveryState?: unknown;
 }
 
 function parseMessageTimestamp(value: unknown): number {
@@ -21,6 +29,27 @@ function parseMessageTimestamp(value: unknown): number {
   return 0;
 }
 
+function isDefinitelyNonLiveRuntimeSession(session: HotChatSessionLike): boolean {
+  const surfaceKind = String(session?.runtimeSurfaceKind || '').trim();
+  if (surfaceKind === 'live_runtime') return false;
+  if (surfaceKind === 'recovery_snapshot') return true;
+  if (surfaceKind === 'inactive_record') return false;
+
+  const lifecycle = String(session?.runtimeLifecycle || '').trim();
+  if (lifecycle && LIVE_RUNTIME_LIFECYCLES.has(lifecycle)) return false;
+
+  const inferredSurfaceKind = getSessionHostSurfaceKind({
+    lifecycle: lifecycle || null,
+    meta: {
+      restoredFromStorage: session?.runtimeRestoredFromStorage === true,
+      ...(session?.runtimeRecoveryState ? { runtimeRecoveryState: session.runtimeRecoveryState } : {}),
+    },
+  });
+  if (inferredSurfaceKind === 'recovery_snapshot') return true;
+
+  return false;
+}
+
 export function classifyHotChatSessionsForSubscriptionFlush(
   sessions: HotChatSessionLike[],
   previousHotSessionIds: ReadonlySet<string>,
@@ -39,10 +68,15 @@ export function classifyHotChatSessionsForSubscriptionFlush(
   );
   const activeStatuses = options.activeStatuses ?? DEFAULT_ACTIVE_CHAT_POLL_STATUSES;
   const active = new Set<string>();
+  const excluded = new Set<string>();
 
   for (const session of sessions) {
     const sessionId = typeof session?.id === 'string' ? session.id : '';
     if (!sessionId) continue;
+    if (isDefinitelyNonLiveRuntimeSession(session)) {
+      excluded.add(sessionId);
+      continue;
+    }
 
     const status = String(session?.status || '').toLowerCase();
     const lastMessageAt = parseMessageTimestamp(session?.lastMessageAt);
@@ -54,7 +88,7 @@ export function classifyHotChatSessionsForSubscriptionFlush(
   }
 
   const finalizing = new Set(
-    Array.from(previousHotSessionIds).filter((sessionId) => !active.has(sessionId)),
+    Array.from(previousHotSessionIds).filter((sessionId) => !active.has(sessionId) && !excluded.has(sessionId)),
   );
 
   return { active, finalizing };