@adhdev/daemon-core 0.9.76-rc.25 → 0.9.76-rc.26

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

@@ -67,6 +67,7 @@ export declare class ProviderInstanceManager {
     onEvent(listener: (event: ProviderEvent & {
         providerType: string;
     }) => void): void;
+    emitProviderEvent(providerType: string, instanceId: string, event: ProviderEvent): void;
     private emitPendingEvents;
     /**
     * Forward event to specific Instance

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

@@ -147,6 +147,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 {
     /** Provider type */

package/dist/shared-types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.76-rc.25",
+  "version": "0.9.76-rc.26",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -62,6 +62,54 @@ function resolveUpgradeChannel(args: any): ReleaseChannel {
         || normalizeReleaseChannel(loadConfig().updateChannel)
         || 'stable';
 }
+
+function readProviderPriorityFromPolicy(policy: unknown): string[] {
+    const record = policy && typeof policy === 'object' && !Array.isArray(policy)
+        ? policy as Record<string, unknown>
+        : {};
+    const raw = record.providerPriority;
+    if (!Array.isArray(raw)) return [];
+    const seen = new Set<string>();
+    return raw
+        .map(type => typeof type === 'string' ? type.trim() : '')
+        .filter(Boolean)
+        .filter(type => {
+            if (seen.has(type)) return false;
+            seen.add(type);
+            return true;
+        });
+}
+
+async function resolveProviderTypeFromPriority(args: {
+    nodeId: string;
+    providerPriority: string[];
+    providerLoader: ProviderLoader;
+    onStatusChange?: () => void;
+}): Promise<{ providerType?: string; error?: string }> {
+    if (!args.providerPriority.length) {
+        return { error: `Node '${args.nodeId}' has no providerPriority policy; pass cliType explicitly or configure node.policy.providerPriority` };
+    }
+
+    const failed: string[] = [];
+    for (const requestedType of args.providerPriority) {
+        const normalizedType = args.providerLoader.resolveAlias(requestedType);
+        if (!args.providerLoader.isMachineProviderEnabled(normalizedType)) {
+            failed.push(`${requestedType}: disabled`);
+            continue;
+        }
+        const detected = await detectCLI(normalizedType, args.providerLoader, { includeVersion: false });
+        args.providerLoader.setCliDetectionResults([{
+            id: normalizedType,
+            installed: !!detected,
+            path: detected?.path,
+        }], false);
+        args.onStatusChange?.();
+        if (detected) return { providerType: normalizedType };
+        failed.push(`${requestedType}: not detected`);
+    }
+
+    return { error: `No usable provider detected for node '${args.nodeId}' from providerPriority: ${failed.join('; ')}` };
+}
 import * as fs from 'fs';
 
 type MeshCoordinatorConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
@@ -1194,7 +1242,7 @@ export class DaemonCommandRouter {
             // ─── 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';
+                let cliType = typeof args?.cliType === 'string' ? args.cliType.trim() : '';
                 if (!meshId) return { success: false, error: 'meshId required' };
 
                 try {
@@ -1232,6 +1280,25 @@ export class DaemonCommandRouter {
                     }
                     const workspace = typeof coordinatorNode.workspace === 'string' ? coordinatorNode.workspace.trim() : '';
                     if (!workspace) return { success: false, error: 'Coordinator node workspace required', meshId, cliType };
+                    if (!cliType) {
+                        const resolved = await resolveProviderTypeFromPriority({
+                            nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || 'coordinator'),
+                            providerPriority: readProviderPriorityFromPolicy(coordinatorNode.policy),
+                            providerLoader: this.deps.providerLoader,
+                            onStatusChange: this.deps.onStatusChange,
+                        });
+                        if (!resolved.providerType) {
+                            return {
+                                success: false,
+                                code: 'mesh_coordinator_provider_priority_unusable',
+                                error: resolved.error || 'No usable provider found from node providerPriority',
+                                meshId,
+                                cliType,
+                                workspace,
+                            };
+                        }
+                        cliType = resolved.providerType;
+                    }
                     const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
                     const coordinatorSetup = resolveMeshCoordinatorSetup({
                         provider: providerMeta,

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

@@ -738,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[] {

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/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;

package/src/status/reporter.ts

@@ -151,6 +151,12 @@ export class DaemonStatusReporter {
         if (providerType) {
             payload.providerType = providerType;
         }
+        if (typeof event.providerSessionId === 'string' && event.providerSessionId.trim()) {
+            payload.providerSessionId = event.providerSessionId.trim();
+        }
+        if (typeof event.workspaceName === 'string' && event.workspaceName.trim()) {
+            payload.workspaceName = event.workspaceName.trim();
+        }
         if (typeof event.duration === 'number' && Number.isFinite(event.duration)) {
             payload.duration = event.duration;
         }