@adhdev/daemon-core 0.9.76-rc.6 → 0.9.76-rc.61

package/src/providers/chat-message-normalization.ts

@@ -5,6 +5,43 @@ export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'termi
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});
 
+export const CHAT_MESSAGE_VISIBILITIES = ['user', 'debug', 'internal', 'hidden'] as const;
+export const CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ['visible', 'chat', 'user', 'debug', 'internal', 'hidden'] as const;
+export const CHAT_MESSAGE_AUDIENCES = ['chat', 'debug', 'trace', 'internal'] as const;
+export const CHAT_MESSAGE_SOURCES = [
+  'assistant_text',
+  'tool_call',
+  'terminal_command',
+  'runtime_activity',
+  'runtime_status',
+  'provider_chrome',
+  'control',
+] as const;
+export const CHAT_MESSAGE_ACTIVITY_SOURCES = ['tool_call', 'terminal_command', 'runtime_activity'] as const;
+export const CHAT_MESSAGE_INTERNAL_SOURCES = ['runtime_status', 'provider_chrome', 'control'] as const;
+
+export type ChatMessageVisibility = typeof CHAT_MESSAGE_VISIBILITIES[number] | (string & {});
+export type ChatMessageTranscriptVisibility = typeof CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES[number] | (string & {});
+export type ChatMessageAudience = typeof CHAT_MESSAGE_AUDIENCES[number] | (string & {});
+export type ChatMessageSource = typeof CHAT_MESSAGE_SOURCES[number] | (string & {});
+export type ChatMessageTranscriptSurface = 'chat' | 'activity' | 'internal';
+
+export interface ChatMessageVisibilityClassification {
+  surface: ChatMessageTranscriptSurface;
+  isUserFacing: boolean;
+  isActivityFacing: boolean;
+  isInternal: boolean;
+  explicitUserFacing: boolean;
+  explicitHidden: boolean;
+  role: string;
+  kind: ChatMessageKind;
+  visibility: string;
+  transcriptVisibility: string;
+  audience: string;
+  source: string;
+}
+
+
 const KNOWN_CHAT_MESSAGE_KINDS = new Set<string>(BUILTIN_CHAT_MESSAGE_KINDS);
 const CHAT_MESSAGE_KIND_ALIASES: Record<string, BuiltinChatMessageKind> = {
   text: 'standard',
@@ -171,3 +208,207 @@ export function normalizeChatMessage<T extends ChatMessage>(message: T): T {
 export function normalizeChatMessages<T extends ChatMessage>(messages: T[] | null | undefined): T[] {
   return (Array.isArray(messages) ? messages : []).map((message) => normalizeChatMessage(message));
 }
+
+function readMessageMeta(message: ChatMessage): Record<string, unknown> | null {
+  const meta = message?.meta;
+  return meta && typeof meta === 'object' && !Array.isArray(meta)
+    ? meta as Record<string, unknown>
+    : null;
+}
+
+function readStringField(value: unknown): string {
+  return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+function readRecordField(message: ChatMessage, meta: Record<string, unknown> | null, key: string): unknown {
+  const record = message as ChatMessage & Record<string, unknown>;
+  return record[key] ?? meta?.[key];
+}
+
+function readVisibilityField(message: ChatMessage, meta: Record<string, unknown> | null): string {
+  return readStringField(readRecordField(message, meta, 'visibility'));
+}
+
+function readTranscriptVisibilityField(message: ChatMessage, meta: Record<string, unknown> | null): string {
+  const record = message as ChatMessage & Record<string, unknown>;
+  return readStringField(record.transcriptVisibility ?? meta?.transcriptVisibility ?? record.visibility ?? meta?.visibility);
+}
+
+const EXPLICIT_HIDDEN_VISIBILITIES = new Set(['hidden', 'debug', 'internal']);
+const EXPLICIT_VISIBLE_VISIBILITIES = new Set(['visible', 'user', 'chat']);
+const HIDDEN_AUDIENCES = new Set(['debug', 'trace', 'internal']);
+const ACTIVITY_SOURCE_SET = new Set<string>(CHAT_MESSAGE_ACTIVITY_SOURCES);
+const INTERNAL_SOURCE_SET = new Set<string>(CHAT_MESSAGE_INTERNAL_SOURCES);
+
+function hasBooleanMarker(message: ChatMessage, meta: Record<string, unknown> | null, keys: string[]): boolean {
+  const record = message as ChatMessage & Record<string, unknown>;
+  return keys.some((key) => record[key] === true || meta?.[key] === true);
+}
+
+function isActivityKind(kind: ChatMessageKind): boolean {
+  return kind === 'thought' || kind === 'tool' || kind === 'terminal';
+}
+
+function isOrdinaryVisibleTurn(message: ChatMessage, role: string, kind: ChatMessageKind): boolean {
+  if (role === 'user' || role === 'human') return kind === 'standard' || kind === '';
+  if (role === 'assistant') return kind === 'standard' || kind === '';
+  return false;
+}
+
+/**
+ * Shared transcript visibility protocol for all ADHDev provider chat messages.
+ *
+ * Producers can stamp visibility/audience/source/userFacing/internal/debug either
+ * at the top level or under `meta`. Consumers should use this classifier instead
+ * of matching command text, icons, provider names, or terminal UI fragments.
+ */
+export function classifyChatMessageVisibility(message: ChatMessage | null | undefined): ChatMessageVisibilityClassification {
+  if (!message) {
+    return {
+      surface: 'internal',
+      isUserFacing: false,
+      isActivityFacing: false,
+      isInternal: true,
+      explicitUserFacing: false,
+      explicitHidden: true,
+      role: '',
+      kind: 'standard',
+      visibility: '',
+      transcriptVisibility: '',
+      audience: '',
+      source: '',
+    };
+  }
+
+  const meta = readMessageMeta(message);
+  const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
+  const kind = resolveChatMessageKind(message);
+  const visibility = readVisibilityField(message, meta);
+  const transcriptVisibility = readTranscriptVisibilityField(message, meta);
+  const audience = readStringField(readRecordField(message, meta, 'audience'));
+  const source = readStringField(readRecordField(message, meta, 'source'));
+  const explicitHidden = EXPLICIT_HIDDEN_VISIBILITIES.has(visibility)
+    || EXPLICIT_HIDDEN_VISIBILITIES.has(transcriptVisibility)
+    || HIDDEN_AUDIENCES.has(audience)
+    || hasBooleanMarker(message, meta, ['internal', 'isInternal', 'debug', 'statusOnly', 'controlOnly']);
+  const explicitUserFacing = EXPLICIT_VISIBLE_VISIBILITIES.has(visibility)
+    || EXPLICIT_VISIBLE_VISIBILITIES.has(transcriptVisibility)
+    || audience === 'chat'
+    || hasBooleanMarker(message, meta, ['userFacing']);
+
+  if (explicitHidden) {
+    const activityLike = isActivityKind(kind) || ACTIVITY_SOURCE_SET.has(source);
+    return {
+      surface: activityLike ? 'activity' : 'internal',
+      isUserFacing: false,
+      isActivityFacing: activityLike,
+      isInternal: !activityLike,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  if (explicitUserFacing) {
+    return {
+      surface: 'chat',
+      isUserFacing: true,
+      isActivityFacing: false,
+      isInternal: false,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  if (INTERNAL_SOURCE_SET.has(source) || role === 'system' || kind === 'system') {
+    return {
+      surface: 'internal',
+      isUserFacing: false,
+      isActivityFacing: false,
+      isInternal: true,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  if (ACTIVITY_SOURCE_SET.has(source) || isActivityKind(kind)) {
+    return {
+      surface: 'activity',
+      isUserFacing: false,
+      isActivityFacing: true,
+      isInternal: false,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  const isUserFacing = isOrdinaryVisibleTurn(message, role, kind);
+  return {
+    surface: isUserFacing ? 'chat' : 'internal',
+    isUserFacing,
+    isActivityFacing: false,
+    isInternal: !isUserFacing,
+    explicitUserFacing,
+    explicitHidden,
+    role,
+    kind,
+    visibility,
+    transcriptVisibility,
+    audience,
+    source,
+  };
+}
+
+export function isUserFacingChatMessage(message: ChatMessage | null | undefined): boolean {
+  return classifyChatMessageVisibility(message).isUserFacing;
+}
+
+export function isActivityChatMessage(message: ChatMessage | null | undefined): boolean {
+  return classifyChatMessageVisibility(message).isActivityFacing;
+}
+
+export function isInternalChatMessage(message: ChatMessage | null | undefined): boolean {
+  return classifyChatMessageVisibility(message).isInternal;
+}
+
+export function filterUserFacingChatMessages<T extends ChatMessage>(messages: T[] | null | undefined): T[] {
+  return (Array.isArray(messages) ? messages : []).filter((message) => isUserFacingChatMessage(message));
+}
+
+export function filterActivityChatMessages<T extends ChatMessage>(messages: T[] | null | undefined): T[] {
+  return (Array.isArray(messages) ? messages : []).filter((message) => isActivityChatMessage(message));
+}
+
+export function filterInternalChatMessages<T extends ChatMessage>(messages: T[] | null | undefined): T[] {
+  return (Array.isArray(messages) ? messages : []).filter((message) => isInternalChatMessage(message));
+}
+
+export function filterChatMessagesByVisibility<T extends ChatMessage>(
+  messages: T[] | null | undefined,
+  surface: ChatMessageTranscriptSurface,
+): T[] {
+  return (Array.isArray(messages) ? messages : []).filter((message) => classifyChatMessageVisibility(message).surface === surface);
+}

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

@@ -6,6 +6,7 @@
  */
 import type { ProviderModule } from './contracts.js';
 import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
+import type { ChatMessage } from '../types.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 export declare class CliProviderInstance implements ProviderInstance {
@@ -77,6 +78,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private formatMarkerTimestamp;
     private maybeAppendRuntimeRecoveryMessage;
     private appendRuntimeSystemMessage;
+    mergeRuntimeChatMessages(parsedMessages: ChatMessage[]): ChatMessage[];
     private mergeConversationMessages;
     private formatApprovalRequestMessage;
     private promoteProviderSessionId;

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

@@ -25,7 +25,7 @@ import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
-import { buildChatMessage, buildRuntimeSystemChatMessage, normalizeChatMessages } from './chat-message-normalization.js';
+import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind } from './chat-message-normalization.js';
 
 type PersistableCliHistoryMessage = {
     role: string;
@@ -214,6 +214,7 @@ export class CliProviderInstance implements ProviderInstance {
         options?: {
             providerSessionId?: string;
             launchMode?: 'new' | 'resume' | 'manual';
+            extraEnv?: Record<string, string>;
             onProviderSessionResolved?: (info: {
                 instanceId: string;
                 providerType: string;
@@ -230,7 +231,7 @@ export class CliProviderInstance implements ProviderInstance {
         this.providerSessionId = options?.providerSessionId;
         this.launchMode = options?.launchMode || 'new';
         this.onProviderSessionResolved = options?.onProviderSessionResolved;
-        this.adapter = new ProviderCliAdapter(provider as CliProviderModule, workingDir, cliArgs, transportFactory);
+        this.adapter = new ProviderCliAdapter(provider as CliProviderModule, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
@@ -737,7 +738,29 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private pushEvent(event: ProviderEvent): void {
-        this.events.push(event);
+        const enrichedEvent: ProviderEvent = {
+            ...event,
+            instanceId: typeof event.instanceId === 'string' && event.instanceId.trim()
+                ? event.instanceId
+                : this.instanceId,
+            targetSessionId: typeof event.targetSessionId === 'string' && event.targetSessionId.trim()
+                ? event.targetSessionId
+                : this.instanceId,
+            providerType: typeof event.providerType === 'string' && event.providerType.trim()
+                ? event.providerType
+                : this.type,
+            workspaceName: typeof event.workspaceName === 'string' && event.workspaceName.trim()
+                ? event.workspaceName
+                : this.workingDir,
+            providerSessionId: typeof event.providerSessionId === 'string' && event.providerSessionId.trim()
+                ? event.providerSessionId
+                : this.providerSessionId,
+        };
+        if (this.context?.emitProviderEvent) {
+            this.context.emitProviderEvent(enrichedEvent);
+            return;
+        }
+        this.events.push(enrichedEvent);
     }
 
     private flushEvents(): ProviderEvent[] {
@@ -977,15 +1000,77 @@ export class CliProviderInstance implements ProviderInstance {
         }
     }
 
+    mergeRuntimeChatMessages(parsedMessages: ChatMessage[]): ChatMessage[] {
+        return this.mergeConversationMessages(parsedMessages);
+    }
+
     private mergeConversationMessages(parsedMessages: any[]): ChatMessage[] {
         if (this.runtimeMessages.length === 0) return normalizeChatMessages(parsedMessages);
 
-        return normalizeChatMessages([...parsedMessages, ...this.runtimeMessages.map((entry) => entry.message)]
-            .map((message, index) => ({ message, index }))
+        type MergeEntry = { message: ChatMessage; index: number; source: 'parsed' | 'runtime'; runtimeKey?: string };
+        const parsedEntries: MergeEntry[] = parsedMessages.map((message, index) => ({
+            message,
+            index,
+            source: 'parsed',
+        }));
+        const runtimeEntries: MergeEntry[] = this.runtimeMessages.map((entry, index) => ({
+            message: entry.message,
+            index: parsedMessages.length + index,
+            source: 'runtime',
+            runtimeKey: entry.key,
+        }));
+        const getTime = (message: ChatMessage): number => {
+            const value = typeof message.receivedAt === 'number'
+                ? message.receivedAt
+                : typeof message.timestamp === 'number'
+                    ? message.timestamp
+                    : 0;
+            return Number.isFinite(value) && value > 0 ? value : 0;
+        };
+
+        const getRole = (message: ChatMessage): string => typeof message.role === 'string'
+            ? message.role.trim().toLowerCase()
+            : '';
+        const isRuntimeOverlay = (entry: MergeEntry): boolean => {
+            if (entry.source !== 'runtime') return false;
+            const key = typeof entry.runtimeKey === 'string' ? entry.runtimeKey.trim().toLowerCase() : '';
+            if (key.startsWith('auto_approval:')) return true;
+            return !isUserFacingChatMessage(entry.message);
+        };
+        const shouldKeepParsedBeforeUntimedRuntime = (message: ChatMessage): boolean => {
+            const role = getRole(message);
+            return role === 'user' || role === 'human';
+        };
+        const shouldKeepParsedAfterUntimedRuntime = (message: ChatMessage): boolean => {
+            const role = getRole(message);
+            if (role !== 'assistant') return false;
+            const kind = resolveChatMessageKind(message);
+            return kind === 'standard' || kind === 'terminal';
+        };
+
+        return normalizeChatMessages([...parsedEntries, ...runtimeEntries]
             .sort((a, b) => {
-                const aTime = a.message.receivedAt || a.message.timestamp || 0;
-                const bTime = b.message.receivedAt || b.message.timestamp || 0;
-                if (aTime !== bTime) return aTime - bTime;
+                const aTime = getTime(a.message);
+                const bTime = getTime(b.message);
+                if (aTime && bTime && aTime !== bTime) return aTime - bTime;
+                if (a.source !== b.source && aTime !== bTime) {
+                    const parsedEntry = a.source === 'parsed' ? a : b.source === 'parsed' ? b : null;
+                    const runtimeEntry = a.source === 'runtime' ? a : b.source === 'runtime' ? b : null;
+                    if (parsedEntry && runtimeEntry && isRuntimeOverlay(runtimeEntry) && getTime(parsedEntry.message) === 0 && getTime(runtimeEntry.message) > 0) {
+                        if (shouldKeepParsedBeforeUntimedRuntime(parsedEntry.message)) {
+                            return a.source === 'parsed' ? -1 : 1;
+                        }
+                        if (shouldKeepParsedAfterUntimedRuntime(parsedEntry.message)) {
+                            return a.source === 'parsed' ? 1 : -1;
+                        }
+                    }
+                }
+                // Many provider-owned CLI transcripts (including Hermes CLI in debug bundles)
+                // do not carry timestamps on parsed messages. In that case there is no safe
+                // clock basis for interleaving timestamped runtime/system messages into the
+                // provider transcript. Keep user prompts before runtime overlays, but do not
+                // let timed runtime/system/tool/internal overlays become the final chat turns
+                // after an untimed parsed assistant transcript.
                 return a.index - b.index;
             })
             .map((entry) => entry.message));

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

@@ -47,7 +47,10 @@ export class ProviderInstanceManager {
             this.instances.get(id)!.dispose();
         }
         this.instances.set(id, instance);
-        await instance.init(context);
+        await instance.init({
+            ...context,
+            emitProviderEvent: (event) => this.emitProviderEvent(instance.type, id, event),
+        });
     }
 
  /**
@@ -237,6 +240,22 @@ export class ProviderInstanceManager {
         this.eventListeners.push(listener);
     }
 
+    emitProviderEvent(providerType: string, instanceId: string, event: ProviderEvent): void {
+        const payload = {
+            ...event,
+            providerType,
+            instanceId: typeof event.instanceId === 'string' && event.instanceId.trim()
+                ? event.instanceId
+                : instanceId,
+            targetSessionId: typeof event.targetSessionId === 'string' && event.targetSessionId.trim()
+                ? event.targetSessionId
+                : instanceId,
+        } as ProviderEvent & { providerType: string };
+        for (const listener of this.eventListeners) {
+            listener(payload);
+        }
+    }
+
     private emitPendingEvents(
         providerType: string,
         state: ProviderState,

package/src/providers/provider-instance.ts

@@ -174,6 +174,8 @@ export interface InstanceContext {
     onPtyData?: (data: string) => void;
  /** Provider configvalue (resolved) */
     settings: Record<string, any>;
+ /** Immediate provider-originated status/event emission. Used to avoid waiting for status polling. */
+    emitProviderEvent?: (event: ProviderEvent) => void;
 }
 
 export interface ProviderInstance {

package/src/providers/read-chat-contract.ts

@@ -77,6 +77,14 @@ function validateMessage(message: unknown, source: string, index: number): ChatM
   if (typeof message.senderName === 'string') normalized.senderName = message.senderName
   if (typeof (message as any)._type === 'string') normalized._type = (message as any)._type
   if (typeof (message as any)._sub === 'string') normalized._sub = (message as any)._sub
+  if (typeof (message as any).visibility === 'string') normalized.visibility = (message as any).visibility
+  if (typeof (message as any).transcriptVisibility === 'string') normalized.transcriptVisibility = (message as any).transcriptVisibility
+  if (typeof (message as any).audience === 'string') normalized.audience = (message as any).audience
+  if (typeof (message as any).source === 'string') normalized.source = (message as any).source
+  if (typeof (message as any).userFacing === 'boolean') normalized.userFacing = (message as any).userFacing
+  if (typeof (message as any).internal === 'boolean') normalized.internal = (message as any).internal
+  if (typeof (message as any).isInternal === 'boolean') normalized.isInternal = (message as any).isInternal
+  if (typeof (message as any).debug === 'boolean') normalized.debug = (message as any).debug
 
   return normalized
 }

package/src/repo-mesh-types.ts

@@ -55,6 +55,8 @@ export type RepoMeshNodeHealth =
 
 // ─── Policy Types ───────────────────────────────
 
+export type RepoMeshSessionCleanupMode = 'preserve' | 'stop' | 'delete_stopped' | 'stop_and_delete';
+
 export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
@@ -63,12 +65,33 @@ export interface RepoMeshPolicy {
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;
     allowedProviders?: string[];
+    /**
+     * What to do with delegated session-host records for a node when it is removed.
+     * Defaults to 'preserve' so completed work can be reviewed later and live
+     * runtimes are never stopped/deleted unless the mesh owner opts in.
+     */
+    sessionCleanupOnNodeRemove?: RepoMeshSessionCleanupMode;
+}
+
+export interface RepoMeshRelatedRepo {
+    /** Stable display label for an explicitly configured associated checkout. */
+    label: string;
+    /** Absolute checkout/workspace path for git freshness probes. */
+    workspace: string;
 }
 
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
     maxConcurrentSessions?: number;
+    /** Ordered provider preference used when mesh_launch_session omits an explicit type. */
+    providerPriority?: string[];
+    /**
+     * Optional associated/external repos that must be checked alongside this node.
+     * These are explicit policy/config entries only; Repo Mesh does not auto-discover
+     * sibling paths so freshness checks stay fail-closed and non-surprising.
+     */
+    relatedRepos?: RepoMeshRelatedRepo[];
 }
 
 export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
@@ -78,6 +101,7 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,
+    sessionCleanupOnNodeRemove: 'preserve',
 };
 
 // ─── Capabilities ───────────────────────────────
@@ -189,6 +213,12 @@ export interface LocalMeshNodeEntry {
     policy: RepoMeshNodePolicy;
     /** For single-machine mesh: same daemon, different worktree */
     isLocalWorktree?: boolean;
+    /** Branch this worktree tracks (set when created via clone_mesh_node) */
+    worktreeBranch?: string;
+    /** Node ID this worktree was cloned from */
+    clonedFromNodeId?: string;
+    /** Optional associated/external repos configured as node metadata. */
+    relatedRepos?: RepoMeshRelatedRepo[];
 }
 
 // ─── Mesh Status (runtime, not persisted) ───────

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

@@ -1,8 +1,10 @@
 import {
     SessionHostClient,
     getDefaultSessionHostEndpoint,
+    type SessionHostDiagnostics,
     type SessionHostEndpoint,
     type SessionHostRecord,
+    type SessionHostRequestType,
 } from '@adhdev/session-host-core';
 import type { HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
 import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
@@ -10,21 +12,65 @@ import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
 const STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
 const STARTUP_POLL_MS = 200;
 
-async function canConnect(endpoint: SessionHostEndpoint): Promise<boolean> {
+class SessionHostCompatibilityError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'SessionHostCompatibilityError';
+    }
+}
+
+function getMissingRequestTypes(
+    diagnostics: SessionHostDiagnostics | undefined,
+    requiredRequestTypes: readonly SessionHostRequestType[],
+): SessionHostRequestType[] {
+    const supported = new Set(diagnostics?.supportedRequestTypes || []);
+    return requiredRequestTypes.filter((requestType) => !supported.has(requestType));
+}
+
+async function assertRequiredRequestTypes(
+    client: SessionHostClient,
+    requiredRequestTypes: readonly SessionHostRequestType[],
+): Promise<void> {
+    if (requiredRequestTypes.length === 0) return;
+
+    const response = await client.request<SessionHostDiagnostics>({
+        type: 'get_host_diagnostics',
+        payload: { includeSessions: false },
+    });
+    const missing = getMissingRequestTypes(response.success ? response.result : undefined, requiredRequestTypes);
+    if (missing.length > 0) {
+        const detail = response.success ? '' : ` (${response.error || 'capability probe failed'})`;
+        throw new SessionHostCompatibilityError(
+            `Session host does not support required request types: ${missing.join(', ')}${detail}`,
+        );
+    }
+}
+
+async function canConnect(
+    endpoint: SessionHostEndpoint,
+    requiredRequestTypes: readonly SessionHostRequestType[] = [],
+): Promise<boolean> {
     const client = new SessionHostClient({ endpoint });
     try {
         await client.connect();
-        await client.close();
+        await assertRequiredRequestTypes(client, requiredRequestTypes);
         return true;
-    } catch {
+    } catch (error) {
+        if (error instanceof SessionHostCompatibilityError) throw error;
         return false;
+    } finally {
+        await client.close().catch(() => {});
     }
 }
 
-async function waitForReady(endpoint: SessionHostEndpoint, timeoutMs = STARTUP_TIMEOUT_MS): Promise<void> {
+async function waitForReady(
+    endpoint: SessionHostEndpoint,
+    timeoutMs = STARTUP_TIMEOUT_MS,
+    requiredRequestTypes: readonly SessionHostRequestType[] = [],
+): Promise<void> {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        if (await canConnect(endpoint)) return;
+        if (await canConnect(endpoint, requiredRequestTypes)) return;
         await new Promise((resolve) => setTimeout(resolve, STARTUP_POLL_MS));
     }
     throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
@@ -34,11 +80,13 @@ export async function ensureSessionHostReady(options: {
     appName?: string;
     spawnHost: () => void;
     timeoutMs?: number;
+    requiredRequestTypes?: readonly SessionHostRequestType[];
 }): Promise<SessionHostEndpoint> {
     const endpoint = getDefaultSessionHostEndpoint(options.appName || 'adhdev');
-    if (await canConnect(endpoint)) return endpoint;
+    const requiredRequestTypes = options.requiredRequestTypes || [];
+    if (await canConnect(endpoint, requiredRequestTypes)) return endpoint;
     options.spawnHost();
-    await waitForReady(endpoint, options.timeoutMs);
+    await waitForReady(endpoint, options.timeoutMs, requiredRequestTypes);
     return endpoint;
 }
 

package/src/shared-types.ts

@@ -641,6 +641,8 @@ export interface DaemonStatusEventPayload {
     timestamp: number;
     targetSessionId?: string;
     providerType?: string;
+    providerSessionId?: string;
+    workspaceName?: string;
     duration?: number;
     elapsedSec?: number;
     modalMessage?: string;
@@ -662,6 +664,8 @@ export interface DashboardStatusEventPayload {
     daemonId?: string;
     providerType?: string;
     targetSessionId?: string;
+    providerSessionId?: string;
+    workspaceName?: string;
     duration?: number;
     elapsedSec?: number;
     modalMessage?: string;