@adhdev/daemon-core 0.9.67 → 0.9.69

package/dist/providers/contracts.d.ts

@@ -260,6 +260,31 @@ export interface CdpTargetFilter {
     titleExcludes?: string;
 }
 export type ProviderVersionCommand = string | Partial<Record<string, string>>;
+export type MeshCoordinatorMcpConfigMode = 'auto_import' | 'manual' | 'none';
+export type MeshCoordinatorMcpConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
+export interface ProviderMeshCoordinatorConfig {
+    /** Whether ADHDev may select this provider for Repo Mesh coordinator sessions. */
+    supported: boolean;
+    /** Human-readable reason shown when unsupported or blocked. */
+    reason?: string;
+    /** How ADHDev mesh MCP tools become visible to the launched CLI. */
+    mcpConfig?: {
+        mode: MeshCoordinatorMcpConfigMode;
+        format?: MeshCoordinatorMcpConfigFormat;
+        /** Provider-relative/project-relative config path for auto-import modes, e.g. '.mcp.json'. */
+        path?: string;
+        /** MCP server name to materialize or display. Defaults to 'adhdev-mesh'. */
+        serverName?: string;
+        /** Manual setup target path/help command, e.g. 'hermes config path'. */
+        configPathCommand?: string;
+        /** Whether users need a fresh CLI session after config changes. */
+        requiresRestart?: boolean;
+        /** User-facing setup explanation for manual modes. */
+        instructions?: string;
+        /** Copyable setup template. Supports {{meshId}}, {{adhdevMcpCommand}}, {{workspace}}, {{serverName}}. */
+        template?: string;
+    };
+}
 export interface ProviderCompatibilityEntry {
     ideVersion: string;
     scriptDir: string;
@@ -271,6 +296,10 @@ export interface ProviderModule {
     name: string;
     /** Category: determines execution method */
     category: ProviderCategory;
+    /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */
+    transcriptAuthority?: 'provider' | 'daemon';
+    /** Full context lets provider-owned parsers canonicalize retained history instead of daemon prefix stitching. */
+    transcriptContext?: 'full' | 'tail';
     /** Alias list — allows users to invoke by alternate names (e.g. ['claude', 'claude-code']) */
     aliases?: string[];
     /** CDP ports [primary, secondary] (IDE category only) */
@@ -448,6 +477,11 @@ export interface ProviderModule {
     spawnArgBuilder?: (config: Record<string, string>) => string[];
     /** ACP agent auth methods (multiple supported — in priority order) */
     auth?: AcpAuthMethod[];
+    /**
+     * Repo Mesh coordinator capability and MCP ingestion behavior.
+     * Providers must declare this rather than relying on daemon hardcoded CLI quirks.
+     */
+    meshCoordinator?: ProviderMeshCoordinatorConfig;
     contractVersion?: number;
     capabilities?: {
         input?: {

package/dist/shared-types.d.ts

@@ -12,7 +12,7 @@ export type { ProviderState, ProviderStatus, ActiveChatData, IdeProviderState, C
 export type { ProviderErrorReason } from './providers/provider-instance.js';
 import type { ActiveChatData as _ActiveChatData, ProviderErrorReason as _ProviderErrorReason } from './providers/provider-instance.js';
 import type { WorkspaceEntry } from './config/workspaces.js';
-import type { ProviderResumeCapability } from './providers/contracts.js';
+import type { ProviderMeshCoordinatorConfig, ProviderResumeCapability } from './providers/contracts.js';
 import type { GitCompactSummary, GitWorkspaceUpdate, WorkspaceGitSubscriptionParams } from './git/git-types.js';
 export type { GitCommandName, GitCompactSummary, GitDiffSummary, GitFailureReason, GitFileChange, GitFileChangeStatus, GitRepoIdentity, GitRepoStatus, GitSnapshot, GitSnapshotCompareSummary, GitSnapshotReason, GitWorkspaceUpdate, WorkspaceGitSubscriptionParams, } from './git/git-types.js';
 export interface SessionActiveChatData extends Omit<_ActiveChatData, 'messages'> {
@@ -343,6 +343,8 @@ export interface AvailableProviderInfo {
     lastDetection?: MachineProviderCheckResult;
     /** Last end-to-end ADHDev verification result, when available. */
     lastVerification?: MachineProviderCheckResult;
+    /** Provider-declared Repo Mesh coordinator/MCP behavior. */
+    meshCoordinator?: ProviderMeshCoordinatorConfig;
 }
 export interface MachineProviderCheckResult {
     ok: boolean;

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

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

package/src/commands/mesh-coordinator.ts

@@ -0,0 +1,97 @@
+import { join } from 'path'
+import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js'
+
+export type MeshCoordinatorSetup =
+  | {
+      kind: 'auto_import'
+      serverName: string
+      configPath: string
+      configFormat?: MeshCoordinatorMcpConfigFormat
+    }
+  | {
+      kind: 'manual'
+      serverName: string
+      configFormat?: MeshCoordinatorMcpConfigFormat
+      configPathCommand?: string
+      requiresRestart: boolean
+      instructions: string
+      template: string
+    }
+  | {
+      kind: 'unsupported'
+      reason: string
+    }
+
+export interface ResolveMeshCoordinatorSetupOptions {
+  provider?: ProviderModule | null
+  meshId: string
+  workspace: string
+  adhdevMcpCommand?: string
+}
+
+const DEFAULT_SERVER_NAME = 'adhdev-mesh'
+const DEFAULT_ADHDEV_MCP_COMMAND = 'adhdev-mcp'
+
+export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup {
+  const { provider, meshId, workspace } = options
+  const config = provider?.meshCoordinator
+  if (!config?.supported) {
+    return {
+      kind: 'unsupported',
+      reason: config?.reason || 'Provider does not declare Repo Mesh coordinator support',
+    }
+  }
+
+  const mcpConfig = config.mcpConfig
+  if (!mcpConfig || mcpConfig.mode === 'none') {
+    return {
+      kind: 'unsupported',
+      reason: config.reason || 'Provider does not declare a usable Repo Mesh MCP configuration mode',
+    }
+  }
+
+  const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME
+  if (mcpConfig.mode === 'auto_import') {
+    const path = mcpConfig.path?.trim()
+    if (!path) {
+      return { kind: 'unsupported', reason: 'Provider auto-import MCP config is missing a config path' }
+    }
+    return {
+      kind: 'auto_import',
+      serverName,
+      configPath: join(workspace, path),
+      configFormat: mcpConfig.format,
+    }
+  }
+
+  if (mcpConfig.mode === 'manual') {
+    const instructions = mcpConfig.instructions?.trim()
+    const template = mcpConfig.template
+    if (!instructions || !template?.trim()) {
+      return { kind: 'unsupported', reason: 'Provider manual MCP setup is missing instructions or template' }
+    }
+    return {
+      kind: 'manual',
+      serverName,
+      configFormat: mcpConfig.format,
+      configPathCommand: mcpConfig.configPathCommand,
+      requiresRestart: mcpConfig.requiresRestart === true,
+      instructions,
+      template: renderMeshCoordinatorTemplate(template, {
+        meshId,
+        workspace,
+        serverName,
+        adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND,
+      }),
+    }
+  }
+
+  return {
+    kind: 'unsupported',
+    reason: `Unsupported Repo Mesh MCP configuration mode: ${String(mcpConfig.mode)}`,
+  }
+}
+
+function renderMeshCoordinatorTemplate(template: string, values: Record<string, string>): string {
+  return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key: string) => values[key] || '')
+}

package/src/commands/router.ts

@@ -33,6 +33,7 @@ import type { CommandLogEntry } from '../logging/command-log.js';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
 import { createInteractionId, getRecentDebugTrace, recordDebugTrace } from '../logging/debug-trace.js';
 import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../session-host/runtime-surface.js';
+import { resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
 import { buildSessionEntries } from '../status/builders.js';
 import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
@@ -920,6 +921,201 @@ export class DaemonCommandRouter {
                 return { success: true };
             }
 
+            // ─── Mesh CRUD (local meshes.json) ───
+            case 'list_meshes': {
+                try {
+                    const { listMeshes } = await import('../config/mesh-config.js');
+                    return { success: true, meshes: listMeshes() };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'get_mesh': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { getMesh } = await import('../config/mesh-config.js');
+                    const mesh = getMesh(meshId);
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+                    return { success: true, mesh };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'create_mesh': {
+                const name = typeof args?.name === 'string' ? args.name.trim() : '';
+                const repoIdentity = typeof args?.repoIdentity === 'string' ? args.repoIdentity.trim() : '';
+                const repoRemoteUrl = typeof args?.repoRemoteUrl === 'string' ? args.repoRemoteUrl.trim() : undefined;
+                const defaultBranch = typeof args?.defaultBranch === 'string' ? args.defaultBranch.trim() : undefined;
+                if (!name) return { success: false, error: 'name required' };
+                try {
+                    const { createMesh } = await import('../config/mesh-config.js');
+                    const mesh = createMesh({ name, repoIdentity, repoRemoteUrl, defaultBranch });
+                    return { success: true, mesh };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'delete_mesh': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { deleteMesh } = await import('../config/mesh-config.js');
+                    const deleted = deleteMesh(meshId);
+                    return { success: true, deleted };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'add_mesh_node': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                if (!workspace) return { success: false, error: 'workspace required' };
+                try {
+                    const { addNode } = await import('../config/mesh-config.js');
+                    const node = addNode(meshId, { workspace });
+                    if (!node) return { success: false, error: 'Mesh not found' };
+                    return { success: true, node };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'remove_mesh_node': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
+                if (!meshId || !nodeId) return { success: false, error: 'meshId and nodeId required' };
+                try {
+                    const { removeNode } = await import('../config/mesh-config.js');
+                    const removed = removeNode(meshId, nodeId);
+                    return { success: true, removed };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            // ─── Mesh Coordinator Launch ───
+            case 'launch_mesh_coordinator': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const cliType = typeof args?.cliType === 'string' ? args.cliType.trim() : 'claude-cli';
+                if (!meshId) return { success: false, error: 'meshId required' };
+
+                try {
+                    const { getMesh } = await import('../config/mesh-config.js');
+                    const { buildCoordinatorSystemPrompt } = await import('../mesh/coordinator-prompt.js');
+                    const mesh = getMesh(meshId);
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+                    if (mesh.nodes.length === 0) return { success: false, error: 'No nodes in mesh' };
+
+                    const workspace = mesh.nodes[0].workspace;
+                    const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
+                    const coordinatorSetup = resolveMeshCoordinatorSetup({
+                        provider: providerMeta,
+                        meshId,
+                        workspace,
+                    });
+
+                    if (coordinatorSetup.kind === 'unsupported') {
+                        return {
+                            success: false,
+                            code: 'mesh_coordinator_unsupported',
+                            error: coordinatorSetup.reason,
+                            meshId,
+                            cliType,
+                            workspace,
+                        };
+                    }
+
+                    if (coordinatorSetup.kind === 'manual') {
+                        return {
+                            success: false,
+                            code: 'mesh_coordinator_manual_mcp_setup_required',
+                            error: coordinatorSetup.instructions,
+                            meshId,
+                            cliType,
+                            workspace,
+                            meshCoordinatorSetup: coordinatorSetup,
+                        };
+                    }
+
+                    if (coordinatorSetup.configFormat !== 'claude_mcp_json') {
+                        return {
+                            success: false,
+                            code: 'mesh_coordinator_unsupported',
+                            error: `Unsupported auto-import MCP config format: ${String(coordinatorSetup.configFormat)}`,
+                            meshId,
+                            cliType,
+                            workspace,
+                        };
+                    }
+
+                    // 1. Write provider-declared MCP config to workspace for CLIs that auto-import it.
+                    const { existsSync, readFileSync, writeFileSync, copyFileSync } = await import('fs');
+                    const mcpConfigPath = coordinatorSetup.configPath;
+
+                    // Backup existing MCP config if present.
+                    const hadExistingMcpConfig = existsSync(mcpConfigPath);
+                    let existingMcpConfig: any = {};
+                    if (hadExistingMcpConfig) {
+                        try {
+                            existingMcpConfig = JSON.parse(readFileSync(mcpConfigPath, 'utf-8'));
+                            copyFileSync(mcpConfigPath, mcpConfigPath + '.backup');
+                        } catch { /* empty */ }
+                    }
+
+                    // Merge ADHDev mesh server into existing config.
+                    const mcpConfig = {
+                        ...existingMcpConfig,
+                        mcpServers: {
+                            ...(existingMcpConfig.mcpServers || {}),
+                            [coordinatorSetup.serverName]: {
+                                command: 'adhdev-mcp',
+                                args: ['--repo-mesh', meshId],
+                            },
+                        },
+                    };
+                    writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
+                    LOG.info('MeshCoordinator', `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
+
+                    // 2. Build coordinator system prompt
+                    let systemPrompt = '';
+                    try {
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh });
+                    } catch {
+                        systemPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}". Use the adhdev-mesh MCP tools (mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, etc.) to orchestrate work across ${mesh.nodes.length} node(s).`;
+                    }
+
+                    // 3. Launch CLI session via existing cliManager
+                    const launchResult: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
+                        cliType,
+                        dir: workspace,
+                        initialPrompt: systemPrompt,
+                    });
+
+                    if (!launchResult?.success) {
+                        return { success: false, error: launchResult?.error || 'Failed to launch CLI session' };
+                    }
+
+                    LOG.info('MeshCoordinator', `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+                    return {
+                        success: true,
+                        meshId,
+                        cliType,
+                        workspace,
+                        sessionId: launchResult.sessionId || launchResult.id,
+                        mcpConfigWritten: true,
+                    };
+                } catch (e: any) {
+                    LOG.error('MeshCoordinator', `Failed: ${e.message}`);
+                    return { success: false, error: e.message };
+                }
+            }
+
             default:
                 break;
         }

package/src/providers/contracts.ts

@@ -345,6 +345,33 @@ export interface CdpTargetFilter {
 
 export type ProviderVersionCommand = string | Partial<Record<string, string>>;
 
+export type MeshCoordinatorMcpConfigMode = 'auto_import' | 'manual' | 'none';
+export type MeshCoordinatorMcpConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
+
+export interface ProviderMeshCoordinatorConfig {
+  /** Whether ADHDev may select this provider for Repo Mesh coordinator sessions. */
+  supported: boolean;
+  /** Human-readable reason shown when unsupported or blocked. */
+  reason?: string;
+  /** How ADHDev mesh MCP tools become visible to the launched CLI. */
+  mcpConfig?: {
+    mode: MeshCoordinatorMcpConfigMode;
+    format?: MeshCoordinatorMcpConfigFormat;
+    /** Provider-relative/project-relative config path for auto-import modes, e.g. '.mcp.json'. */
+    path?: string;
+    /** MCP server name to materialize or display. Defaults to 'adhdev-mesh'. */
+    serverName?: string;
+    /** Manual setup target path/help command, e.g. 'hermes config path'. */
+    configPathCommand?: string;
+    /** Whether users need a fresh CLI session after config changes. */
+    requiresRestart?: boolean;
+    /** User-facing setup explanation for manual modes. */
+    instructions?: string;
+    /** Copyable setup template. Supports {{meshId}}, {{adhdevMcpCommand}}, {{workspace}}, {{serverName}}. */
+    template?: string;
+  };
+}
+
 export interface ProviderCompatibilityEntry {
   ideVersion: string;
   scriptDir: string;
@@ -357,6 +384,10 @@ export interface ProviderModule {
   name: string;
  /** Category: determines execution method */
   category: ProviderCategory;
+ /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */
+  transcriptAuthority?: 'provider' | 'daemon';
+ /** Full context lets provider-owned parsers canonicalize retained history instead of daemon prefix stitching. */
+  transcriptContext?: 'full' | 'tail';
  /** Alias list — allows users to invoke by alternate names (e.g. ['claude', 'claude-code']) */
   aliases?: string[];
 
@@ -555,6 +586,12 @@ export interface ProviderModule {
  /** ACP agent auth methods (multiple supported — in priority order) */
   auth?: AcpAuthMethod[];
 
+  /**
+   * Repo Mesh coordinator capability and MCP ingestion behavior.
+   * Providers must declare this rather than relying on daemon hardcoded CLI quirks.
+   */
+  meshCoordinator?: ProviderMeshCoordinatorConfig;
+
  // ─── Contract version / capability declaration ───
   contractVersion?: number;
   capabilities?: {

package/src/providers/provider-schema.ts

@@ -7,6 +7,8 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'type',
   'name',
   'category',
+  'transcriptAuthority',
+  'transcriptContext',
   'aliases',
   'cdpPorts',
   'targetFilter',
@@ -51,6 +53,7 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'staticConfigOptions',
   'spawnArgBuilder',
   'auth',
+  'meshCoordinator',
   'contractVersion',
   'capabilities',
   'providerVersion',
@@ -125,6 +128,7 @@ export function validateProviderDefinition(raw: unknown): ProviderValidationResu
 
   validateCapabilities(provider as unknown as ProviderModule, controls, errors)
   validateCanonicalHistory(provider.canonicalHistory, errors)
+  validateMeshCoordinator(provider.meshCoordinator, errors)
 
   for (const control of controls) {
     validateControl(control as ProviderControlDef, errors)
@@ -233,6 +237,69 @@ function validateCanonicalHistory(raw: unknown, errors: string[]): void {
   }
 }
 
+function validateMeshCoordinator(raw: unknown, errors: string[]): void {
+  if (raw === undefined) return
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    errors.push('meshCoordinator must be an object')
+    return
+  }
+
+  const meshCoordinator = raw as Record<string, unknown>
+  if (typeof meshCoordinator.supported !== 'boolean') {
+    errors.push('meshCoordinator.supported must be boolean')
+  }
+  if (meshCoordinator.reason !== undefined && (typeof meshCoordinator.reason !== 'string' || !meshCoordinator.reason.trim())) {
+    errors.push('meshCoordinator.reason must be a non-empty string when provided')
+  }
+
+  const mcpConfig = meshCoordinator.mcpConfig
+  if (mcpConfig === undefined) return
+  if (!mcpConfig || typeof mcpConfig !== 'object' || Array.isArray(mcpConfig)) {
+    errors.push('meshCoordinator.mcpConfig must be an object')
+    return
+  }
+
+  const config = mcpConfig as Record<string, unknown>
+  const mode = config.mode
+  if (!['auto_import', 'manual', 'none'].includes(String(mode))) {
+    errors.push('meshCoordinator.mcpConfig.mode must be one of: auto_import, manual, none')
+  }
+
+  const format = config.format
+  if (format !== undefined && !['claude_mcp_json', 'hermes_config_yaml'].includes(String(format))) {
+    errors.push('meshCoordinator.mcpConfig.format must be one of: claude_mcp_json, hermes_config_yaml')
+  }
+
+  for (const key of ['path', 'serverName', 'configPathCommand', 'instructions', 'template']) {
+    const value = config[key]
+    if (value !== undefined && (typeof value !== 'string' || !value.trim())) {
+      errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`)
+    }
+  }
+
+  if (config.requiresRestart !== undefined && typeof config.requiresRestart !== 'boolean') {
+    errors.push('meshCoordinator.mcpConfig.requiresRestart must be boolean when provided')
+  }
+
+  if (mode === 'auto_import') {
+    if (format === undefined) {
+      errors.push('meshCoordinator.mcpConfig.format is required for auto_import MCP setup')
+    }
+    if (typeof config.path !== 'string' || !config.path.trim()) {
+      errors.push('meshCoordinator.mcpConfig.path is required for auto_import MCP setup')
+    }
+  }
+
+  if (mode === 'manual') {
+    if (typeof config.instructions !== 'string' || !config.instructions.trim()) {
+      errors.push('meshCoordinator.mcpConfig.instructions is required for manual MCP setup')
+    }
+    if (typeof config.template !== 'string' || !config.template.trim()) {
+      errors.push('meshCoordinator.mcpConfig.template is required for manual MCP setup')
+    }
+  }
+}
+
 function validateControl(control: ProviderControlDef, errors: string[]): void {
   if (!control || typeof control !== 'object') {
     errors.push('controls: each control must be an object')

package/src/shared-types.ts

@@ -43,7 +43,7 @@ export type { ProviderErrorReason } from './providers/provider-instance.js';
 // Local import for use in Managed*Entry types below
 import type { ActiveChatData as _ActiveChatData, ProviderErrorReason as _ProviderErrorReason } from './providers/provider-instance.js';
 import type { WorkspaceEntry } from './config/workspaces.js';
-import type { ProviderResumeCapability } from './providers/contracts.js';
+import type { ProviderMeshCoordinatorConfig, ProviderResumeCapability } from './providers/contracts.js';
 import type {
     GitCompactSummary,
     GitDiffSummary,
@@ -447,6 +447,8 @@ export interface AvailableProviderInfo {
     lastDetection?: MachineProviderCheckResult;
     /** Last end-to-end ADHDev verification result, when available. */
     lastVerification?: MachineProviderCheckResult;
+    /** Provider-declared Repo Mesh coordinator/MCP behavior. */
+    meshCoordinator?: ProviderMeshCoordinatorConfig;
 }
 
 export interface MachineProviderCheckResult {

package/src/status/snapshot.ts

@@ -144,6 +144,7 @@ function buildAvailableProviders(
         machineStatus?: 'disabled' | 'enabled_unchecked' | 'not_detected' | 'detected';
         lastDetection?: AvailableProviderInfo['lastDetection'];
         lastVerification?: AvailableProviderInfo['lastVerification'];
+        meshCoordinator?: AvailableProviderInfo['meshCoordinator'];
     }> = providerLoader.getAvailableProviderInfos?.() || providerLoader.getAll();
     return providers.map((provider) => ({
         type: provider.type,
@@ -157,6 +158,7 @@ function buildAvailableProviders(
         ...(provider.machineStatus !== undefined ? { machineStatus: provider.machineStatus } : {}),
         ...(provider.lastDetection !== undefined ? { lastDetection: provider.lastDetection } : {}),
         ...(provider.lastVerification !== undefined ? { lastVerification: provider.lastVerification } : {}),
+        ...(provider.meshCoordinator !== undefined ? { meshCoordinator: provider.meshCoordinator } : {}),
     }));
 }