@adhdev/daemon-core 0.9.76-rc.9 → 0.9.76

package/src/providers/io-contracts.ts

@@ -5,6 +5,7 @@ export type InputPart =
   | ImageInputPart
   | AudioInputPart
   | VideoInputPart
+  | ResourceLinkInputPart
   | ResourceInputPart
 
 export interface TextInputPart {
@@ -33,6 +34,7 @@ export interface VideoInputPart {
   mimeType: string
   uri?: string
   data?: string
+  transcript?: string
   posterUri?: string
 }
 
@@ -45,6 +47,17 @@ export interface ResourceInputPart {
   data?: string
 }
 
+export interface ResourceLinkInputPart {
+  type: 'resource_link'
+  uri: string
+  name: string
+  title?: string
+  description?: string
+  mimeType?: string
+  size?: number
+  annotations?: ContentAnnotations
+}
+
 export interface InputEnvelope {
   parts: InputPart[]
   textFallback: string
@@ -73,6 +86,7 @@ export interface ImageMessagePart {
   mimeType: string
   uri?: string
   data?: string
+  alt?: string
   annotations?: ContentAnnotations
 }
 
@@ -90,6 +104,7 @@ export interface VideoMessagePart {
   mimeType: string
   uri?: string
   data?: string
+  transcript?: string
   posterUri?: string
   annotations?: ContentAnnotations
 }
@@ -98,8 +113,11 @@ export interface ResourceLinkMessagePart {
   type: 'resource_link'
   uri: string
   name: string
+  title?: string
+  description?: string
   mimeType?: string
   size?: number
+  annotations?: ContentAnnotations
 }
 
 export interface ResourceMessagePart {
@@ -149,6 +167,10 @@ export function flattenMessageParts(parts: MessagePart[]): string {
     .map((part) => {
       if (part.type === 'text') return part.text
       if (part.type === 'resource') return part.resource.text || ''
+      if (part.type === 'image') return part.alt || (part.data ? `[image: ${part.mimeType}]` : '')
+      if (part.type === 'audio') return part.transcript || (part.data ? `[audio: ${part.mimeType}]` : '')
+      if (part.type === 'video') return part.transcript || (part.data ? `[video: ${part.mimeType}]` : '')
+      if (part.type === 'resource_link') return [part.name, part.description].filter(Boolean).join('\n')
       return ''
     })
     .filter((value) => value.length > 0)
@@ -247,6 +269,7 @@ function normalizeInputPartObject(raw: Record<string, unknown>): InputPart | nul
       mimeType: raw.mimeType,
       ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
       ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.transcript === 'string' ? { transcript: raw.transcript } : {}),
       ...(typeof raw.posterUri === 'string' ? { posterUri: raw.posterUri } : {}),
     }
   }
@@ -262,10 +285,14 @@ function normalizeInputPartObject(raw: Record<string, unknown>): InputPart | nul
   }
   if (type === 'resource_link' && typeof raw.uri === 'string') {
     return {
-      type: 'resource',
+      type,
       uri: raw.uri,
+      name: typeof raw.name === 'string' ? raw.name : getUriDisplayName(raw.uri, 'resource'),
+      ...(typeof raw.title === 'string' ? { title: raw.title } : {}),
+      ...(typeof raw.description === 'string' ? { description: raw.description } : {}),
       ...(typeof raw.mimeType === 'string' ? { mimeType: raw.mimeType } : {}),
-      ...(typeof raw.name === 'string' ? { name: raw.name } : {}),
+      ...(typeof raw.size === 'number' && Number.isFinite(raw.size) ? { size: raw.size } : {}),
+      ...normalizeAnnotationsProperty(raw.annotations),
     }
   }
   return null
@@ -282,6 +309,7 @@ function normalizeMessagePartObject(raw: Record<string, unknown>): MessagePart |
       mimeType: raw.mimeType,
       ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
       ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.alt === 'string' ? { alt: raw.alt } : {}),
     }
   }
   if (type === 'audio' && typeof raw.mimeType === 'string') {
@@ -299,6 +327,7 @@ function normalizeMessagePartObject(raw: Record<string, unknown>): MessagePart |
       mimeType: raw.mimeType,
       ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
       ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.transcript === 'string' ? { transcript: raw.transcript } : {}),
       ...(typeof raw.posterUri === 'string' ? { posterUri: raw.posterUri } : {}),
     }
   }
@@ -307,8 +336,11 @@ function normalizeMessagePartObject(raw: Record<string, unknown>): MessagePart |
       type,
       uri: raw.uri,
       name: raw.name,
+      ...(typeof raw.title === 'string' ? { title: raw.title } : {}),
+      ...(typeof raw.description === 'string' ? { description: raw.description } : {}),
       ...(typeof raw.mimeType === 'string' ? { mimeType: raw.mimeType } : {}),
-      ...(typeof raw.size === 'number' ? { size: raw.size } : {}),
+      ...(typeof raw.size === 'number' && Number.isFinite(raw.size) ? { size: raw.size } : {}),
+      ...normalizeAnnotationsProperty(raw.annotations),
     }
   }
   if (type === 'resource' && raw.resource && typeof raw.resource === 'object') {
@@ -331,10 +363,36 @@ function flattenInputParts(parts: InputPart[]): string {
   return parts
     .map((part) => {
       if (part.type === 'text') return part.text
-      if (part.type === 'audio') return part.transcript || ''
-      if (part.type === 'resource') return part.text || ''
+      if (part.type === 'image') return part.alt || (part.data ? `[image: ${part.mimeType}]` : '')
+      if (part.type === 'audio') return part.transcript || (part.data ? `[audio: ${part.mimeType}]` : '')
+      if (part.type === 'video') return part.transcript || (part.data ? `[video: ${part.mimeType}]` : '')
+      if (part.type === 'resource_link') return [part.title, part.name, part.description, part.uri].filter(Boolean).join('\n')
+      if (part.type === 'resource') return part.text || part.name || part.uri
       return ''
     })
     .filter((value) => value.length > 0)
     .join('\n')
 }
+
+function getUriDisplayName(uri: string, fallback: string): string {
+  try {
+    const pathname = uri.startsWith('file://') ? new URL(uri).pathname : uri
+    return pathname.split(/[\\/]/).filter(Boolean).pop() || fallback
+  } catch {
+    return uri.split(/[\\/]/).filter(Boolean).pop() || fallback
+  }
+}
+
+function normalizeAnnotationsProperty(value: unknown): { annotations?: ContentAnnotations } {
+  if (!value || typeof value !== 'object') return {}
+  const record = value as Record<string, unknown>
+  const annotations: ContentAnnotations = {}
+  if (Array.isArray(record.audience)) {
+    const audience = record.audience.filter((item): item is 'user' | 'assistant' => item === 'user' || item === 'assistant')
+    if (audience.length > 0) annotations.audience = audience
+  }
+  if (typeof record.priority === 'number' && Number.isFinite(record.priority)) {
+    annotations.priority = record.priority
+  }
+  return Object.keys(annotations).length > 0 ? { annotations } : {}
+}

package/src/providers/provider-input-support.ts

@@ -1,8 +1,38 @@
 import type { InputEnvelope, ProviderModule } from './contracts.js'
 
-type InputMediaType = 'text' | 'image' | 'audio' | 'video' | 'resource'
+export type InputMediaType = 'text' | 'image' | 'audio' | 'video' | 'resource'
+
+export type InputAttachmentStrategy =
+  | 'native'
+  | 'native_acp'
+  | 'resource_link'
+  | 'text_fallback'
+  | 'paste'
+  | 'upload'
+
+export interface InputMediaStrategyDescriptor {
+  mediaType: InputMediaType
+  strategies: InputAttachmentStrategy[]
+  native?: boolean
+  degradation?: InputAttachmentStrategy[]
+}
+
+export interface MessageInputSupport {
+  text: boolean
+  multipart: boolean
+  mediaTypes: InputMediaType[]
+  strategies: InputMediaStrategyDescriptor[]
+}
 
 const VALID_INPUT_MEDIA_TYPES = new Set<InputMediaType>(['text', 'image', 'audio', 'video', 'resource'])
+const VALID_INPUT_STRATEGIES = new Set<InputAttachmentStrategy>(['native', 'native_acp', 'resource_link', 'text_fallback', 'paste', 'upload'])
+
+export const TEXT_ONLY_MESSAGE_INPUT_SUPPORT: MessageInputSupport = Object.freeze<MessageInputSupport>({
+  text: true,
+  multipart: false,
+  mediaTypes: ['text'],
+  strategies: [],
+})
 
 function getProviderLabel(provider?: Pick<ProviderModule, 'name' | 'type'> | null): string {
   return provider?.name || provider?.type || 'This provider'
@@ -44,14 +74,108 @@ export function assertTextOnlyInput(provider: Pick<ProviderModule, 'name' | 'typ
 export function getDeclaredProviderInputSupport(provider?: Pick<ProviderModule, 'capabilities'> | null): {
   multipart: boolean
   mediaTypes: Set<InputMediaType>
+  strategies: InputMediaStrategyDescriptor[]
 } {
   const rawMediaTypes = Array.isArray(provider?.capabilities?.input?.mediaTypes)
     ? provider?.capabilities?.input?.mediaTypes.filter((type): type is InputMediaType => VALID_INPUT_MEDIA_TYPES.has(type as InputMediaType))
     : []
+  const strategies = normalizeInputStrategyDescriptors(provider?.capabilities?.input?.strategies)
 
   return {
     multipart: provider?.capabilities?.input?.multipart === true,
     mediaTypes: new Set<InputMediaType>(rawMediaTypes.length > 0 ? rawMediaTypes : ['text']),
+    strategies,
+  }
+}
+
+export function normalizeInputStrategyDescriptors(raw: unknown): InputMediaStrategyDescriptor[] {
+  if (!Array.isArray(raw)) return []
+  const result: InputMediaStrategyDescriptor[] = []
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue
+    const record = entry as Record<string, unknown>
+    const mediaType = record.mediaType
+    if (typeof mediaType !== 'string' || !VALID_INPUT_MEDIA_TYPES.has(mediaType as InputMediaType)) continue
+    const strategies = Array.isArray(record.strategies)
+      ? record.strategies.filter((value): value is InputAttachmentStrategy => typeof value === 'string' && VALID_INPUT_STRATEGIES.has(value as InputAttachmentStrategy))
+      : []
+    const degradation = Array.isArray(record.degradation)
+      ? record.degradation.filter((value): value is InputAttachmentStrategy => typeof value === 'string' && VALID_INPUT_STRATEGIES.has(value as InputAttachmentStrategy))
+      : []
+    if (strategies.length === 0 && degradation.length === 0) continue
+    result.push({
+      mediaType: mediaType as InputMediaType,
+      strategies,
+      ...(typeof record.native === 'boolean' ? { native: record.native } : {}),
+      ...(degradation.length > 0 ? { degradation } : {}),
+    })
+  }
+  return result
+}
+
+function promptCapabilityFlags(runtimeCapabilities?: Record<string, any> | null): { image: boolean; audio: boolean; embeddedContext: boolean } {
+  const prompt = runtimeCapabilities?.promptCapabilities || {}
+  return {
+    image: prompt.image === true,
+    audio: prompt.audio === true,
+    embeddedContext: prompt.embeddedContext === true,
+  }
+}
+
+function supportFromDeclared(provider?: Pick<ProviderModule, 'capabilities'> | null): MessageInputSupport {
+  const declared = getDeclaredProviderInputSupport(provider)
+  return {
+    text: true,
+    multipart: declared.multipart,
+    mediaTypes: Array.from(declared.mediaTypes),
+    strategies: declared.strategies,
+  }
+}
+
+export function getEffectiveMessageInputSupport(
+  provider?: Pick<ProviderModule, 'category' | 'capabilities'> | null,
+  runtimeCapabilities?: Record<string, any> | null,
+): MessageInputSupport {
+  if (provider?.category !== 'acp') {
+    const declared = supportFromDeclared(provider)
+    return {
+      ...declared,
+      mediaTypes: [...declared.mediaTypes],
+      strategies: declared.strategies.map((strategy) => ({
+        ...strategy,
+        strategies: [...strategy.strategies],
+        ...(strategy.degradation ? { degradation: [...strategy.degradation] } : {}),
+      })),
+    }
+  }
+
+  const declared = supportFromDeclared(provider)
+  const caps = promptCapabilityFlags(runtimeCapabilities)
+  const mediaTypes = new Set<InputMediaType>(['text'])
+  const strategies: InputMediaStrategyDescriptor[] = []
+
+  if (declared.mediaTypes.includes('resource')) {
+    mediaTypes.add('resource')
+    strategies.push({ mediaType: 'resource', strategies: caps.embeddedContext ? ['native_acp', 'resource_link', 'text_fallback'] : ['resource_link', 'text_fallback'], native: caps.embeddedContext, degradation: ['resource_link', 'text_fallback'] })
+  }
+  if (declared.mediaTypes.includes('video')) {
+    mediaTypes.add('video')
+    strategies.push({ mediaType: 'video', strategies: ['resource_link', 'text_fallback'], native: false, degradation: ['resource_link', 'text_fallback'] })
+  }
+  if (declared.mediaTypes.includes('image')) {
+    mediaTypes.add('image')
+    strategies.push({ mediaType: 'image', strategies: caps.image ? ['native_acp', 'resource_link', 'text_fallback'] : ['resource_link', 'text_fallback'], native: caps.image, degradation: ['resource_link', 'text_fallback'] })
+  }
+  if (declared.mediaTypes.includes('audio')) {
+    mediaTypes.add('audio')
+    strategies.push({ mediaType: 'audio', strategies: caps.audio ? ['native_acp', 'resource_link', 'text_fallback'] : ['resource_link', 'text_fallback'], native: caps.audio, degradation: ['resource_link', 'text_fallback'] })
+  }
+
+  return {
+    text: true,
+    multipart: declared.multipart && mediaTypes.size > 1,
+    mediaTypes: Array.from(mediaTypes),
+    strategies,
   }
 }
 

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

@@ -10,6 +10,7 @@
 
 import type { ProviderModule, ProviderSettingDef, ProviderResumeCapability } from './contracts.js';
 import type { AcpConfigOption, AcpMode, ProviderControlSchema, ProviderSummaryMetadata, SessionCapability } from '../shared-types.js';
+import type { MessageInputSupport } from './provider-input-support.js';
 import type { ChatMessage } from '../types.js';
 
 // ─── ProviderState — Discriminated union by category ─────────────
@@ -87,6 +88,7 @@ interface ProviderStateBase {
     runtime?: ProviderRuntimeInfo;
     resume?: ProviderResumeCapability;
     sessionCapabilities?: SessionCapability[];
+    messageInput?: MessageInputSupport;
  /** Dynamic control current values */
     controlValues?: Record<string, string | number | boolean>;
     /** Provider-declared controls schema (from provider.controls) */
@@ -174,6 +176,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/provider-schema.ts

@@ -2,6 +2,7 @@ import type { ProviderControlDef, ProviderControlType, ProviderModule } from './
 import { providerHasOpenPanelSupport } from './open-panel-support.js'
 
 const VALID_CAPABILITY_MEDIA_TYPES = new Set(['text', 'image', 'audio', 'video', 'resource'])
+const VALID_INPUT_STRATEGIES = new Set(['native', 'native_acp', 'resource_link', 'text_fallback', 'paste', 'upload'])
 
 const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'type',
@@ -158,16 +159,45 @@ function validateCapabilities(provider: ProviderModule, controls: ProviderContro
   }
 
   const input = capabilities.input
-  if (!input || typeof input !== 'object') {
-    errors.push('capabilities.input is required')
-  } else {
-    if (typeof input.multipart !== 'boolean') {
+  if (input !== undefined) {
+    if (!input || typeof input !== 'object') {
+      errors.push('capabilities.input must be an object when provided')
+    } else if (typeof input.multipart !== 'boolean') {
       errors.push('capabilities.input.multipart must be boolean')
     }
-    if (!Array.isArray(input.mediaTypes) || input.mediaTypes.length === 0) {
-      errors.push('capabilities.input.mediaTypes must be a non-empty array')
-    } else if (input.mediaTypes.some((type) => typeof type !== 'string' || !VALID_CAPABILITY_MEDIA_TYPES.has(type))) {
-      errors.push(`capabilities.input.mediaTypes must only include: ${Array.from(VALID_CAPABILITY_MEDIA_TYPES).join(', ')}`)
+    if (input && typeof input === 'object') {
+      const mediaTypes = Array.isArray(input.mediaTypes) ? input.mediaTypes : undefined
+      if (!mediaTypes || mediaTypes.length === 0) {
+        errors.push('capabilities.input.mediaTypes must be a non-empty array')
+      } else if (mediaTypes.some((type) => typeof type !== 'string' || !VALID_CAPABILITY_MEDIA_TYPES.has(type))) {
+        errors.push(`capabilities.input.mediaTypes must only include: ${Array.from(VALID_CAPABILITY_MEDIA_TYPES).join(', ')}`)
+      }
+    }
+    if (input && typeof input === 'object' && input.strategies !== undefined) {
+      if (!Array.isArray(input.strategies)) {
+        errors.push('capabilities.input.strategies must be an array when provided')
+      } else {
+        for (const strategy of input.strategies) {
+          if (!strategy || typeof strategy !== 'object' || Array.isArray(strategy)) {
+            errors.push('capabilities.input.strategies entries must be objects')
+            continue
+          }
+          const entry = strategy as Record<string, unknown>
+          if (typeof entry.mediaType !== 'string' || !VALID_CAPABILITY_MEDIA_TYPES.has(entry.mediaType)) {
+            errors.push(`capabilities.input.strategies.mediaType must only include: ${Array.from(VALID_CAPABILITY_MEDIA_TYPES).join(', ')}`)
+          }
+          for (const field of ['strategies', 'degradation'] as const) {
+            const values = entry[field]
+            if (values === undefined) continue
+            if (!Array.isArray(values) || values.some((value) => typeof value !== 'string' || !VALID_INPUT_STRATEGIES.has(value))) {
+              errors.push(`capabilities.input.strategies.${field} must only include: ${Array.from(VALID_INPUT_STRATEGIES).join(', ')}`)
+            }
+          }
+          if (entry.native !== undefined && typeof entry.native !== 'boolean') {
+            errors.push('capabilities.input.strategies.native must be boolean when provided')
+          }
+        }
+      }
     }
   }
 

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,9 @@ export type RepoMeshNodeHealth =
 
 // ─── Policy Types ───────────────────────────────
 
+export type RepoMeshSessionCleanupMode = 'preserve' | 'stop' | 'delete_stopped' | 'stop_and_delete';
+export type RepoMeshSpawnedSessionVisibility = 'visible' | 'hidden';
+
 export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
@@ -63,12 +66,39 @@ export interface RepoMeshPolicy {
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;
     allowedProviders?: string[];
+    /**
+     * Whether sessions spawned by mesh/coordinator policy should auto-open as visible
+     * dashboard tabs or start hidden. Defaults to 'visible' to preserve existing
+     * watch-the-agents behavior; hidden sessions remain discoverable and manually openable.
+     */
+    spawnedSessionVisibility?: RepoMeshSpawnedSessionVisibility;
+    /**
+     * 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 +108,8 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,
+    spawnedSessionVisibility: 'visible',
+    sessionCleanupOnNodeRemove: 'preserve',
 };
 
 // ─── Capabilities ───────────────────────────────
@@ -189,6 +221,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

@@ -336,7 +336,9 @@ export type SessionCapability =
     | 'mark_notification_unread';
 
 import type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
+import type { MessageInputSupport } from './providers/provider-input-support.js';
 export type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
+export type { MessageInputSupport, InputMediaStrategyDescriptor, InputAttachmentStrategy, InputMediaType } from './providers/provider-input-support.js';
 
 export interface SessionEntry {
     id: string;
@@ -364,6 +366,8 @@ export interface SessionEntry {
     resume?: ProviderResumeCapability;
     activeChat: SessionActiveChatData | null;
     capabilities?: SessionCapability[];
+    /** Effective message input/media support for this session. Defaults fail-closed to text-only. */
+    messageInput?: MessageInputSupport;
     cdpConnected?: boolean;
     /** Dynamic control current values (generic key-value) */
     controlValues?: Record<string, string | number | boolean>;
@@ -641,6 +645,8 @@ export interface DaemonStatusEventPayload {
     timestamp: number;
     targetSessionId?: string;
     providerType?: string;
+    providerSessionId?: string;
+    workspaceName?: string;
     duration?: number;
     elapsedSec?: number;
     modalMessage?: string;
@@ -662,6 +668,8 @@ export interface DashboardStatusEventPayload {
     daemonId?: string;
     providerType?: string;
     targetSessionId?: string;
+    providerSessionId?: string;
+    workspaceName?: string;
     duration?: number;
     elapsedSec?: number;
     modalMessage?: string;