@adhdev/daemon-core 0.9.82-rc.227 → 0.9.82-rc.229

package/package.json

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

package/src/commands/chat-commands.ts

@@ -2549,12 +2549,18 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             const registrySessionWorkspace = targetSid
                 ? (h.ctx?.sessionRegistry?.get?.(targetSid) as any)?.workspace
                 : undefined;
-            const workspace = typeof (h.currentSession as any)?.workspace === 'string'
+            const currentSessionWorkspace = typeof (h.currentSession as any)?.workspace === 'string'
                 ? (h.currentSession as any).workspace
-                : typeof registrySessionWorkspace === 'string'
-                    ? registrySessionWorkspace
-                    : undefined;
-            const intendedWorkspace = typeof args?.workspace === 'string' ? args.workspace : undefined;
+                : undefined;
+            const argsWorkspace = typeof args?.workspace === 'string' ? args.workspace : undefined;
+            // When reading a different session (targetSid), prefer that session's registered
+            // workspace (or the caller-supplied args.workspace) over the current (coordinator)
+            // session's workspace — otherwise the coordinator's cwd shadows the worker's cwd
+            // and history lookups find the wrong files.
+            const workspace = targetSid
+                ? (typeof registrySessionWorkspace === 'string' ? registrySessionWorkspace : argsWorkspace ?? currentSessionWorkspace)
+                : (typeof currentSessionWorkspace === 'string' ? currentSessionWorkspace : undefined);
+            const intendedWorkspace = argsWorkspace;
             const supportsNative = supportsCliNativeTranscript(agentStr, provider)
                 && isNativeSourceCanonicalHistory(provider?.nativeHistory);
             const history = supportsNative

package/src/commands/router.ts

@@ -5852,14 +5852,28 @@ export class DaemonCommandRouter {
                 let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
                     ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
                     : undefined;
-                if (!workspace && meshId && nodeId) {
+                let nodeDaemonId: string | undefined;
+                if (meshId && nodeId) {
                     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
                     const mesh = meshRecord?.mesh;
                     const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
-                    workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
+                    if (!workspace) {
+                        workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
+                    }
                     if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
                         submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
                     }
+                    nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
+                }
+                // If the target node belongs to a remote daemon, forward the command there.
+                const selfDaemonId = this.deps.statusInstanceId;
+                const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+                if (isRemote && this.deps.dispatchMeshCommand) {
+                    const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
+                        ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                        workspace,
+                    });
+                    return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
                 }
                 const result = await (fastForwardMeshNode({
                     meshId: meshId || undefined,
@@ -5901,6 +5915,15 @@ export class DaemonCommandRouter {
 
                     let worktreeCleanup: Record<string, unknown> | undefined;
                     if (node?.isLocalWorktree) {
+                        const nodeDaemonId = typeof node.daemonId === 'string' ? node.daemonId.trim() : undefined;
+                        const isRemoteWorktree = nodeDaemonId && nodeDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand;
+                        if (isRemoteWorktree) {
+                            // Worktree lives on a different machine — ask that daemon to clean it up.
+                            const forwarded = await this.deps.dispatchMeshCommand!(nodeDaemonId!, 'remove_mesh_node', {
+                                ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                            });
+                            return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
+                        }
                         const cleanupResult = await this.cleanupLocalWorktreeNode({ mesh, node, nodeId, force: args?.force === true });
                         if (cleanupResult.success === false) {
                             return {
@@ -5983,6 +6006,15 @@ export class DaemonCommandRouter {
                     const sourceNode = mesh.nodes?.find((n: any) => n.id === sourceNodeId || n.nodeId === sourceNodeId);
                     if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
 
+                    // Forward to the source node's daemon if it's on a different machine.
+                    const sourceDaemonId = typeof sourceNode.daemonId === 'string' ? sourceNode.daemonId.trim() : undefined;
+                    if (sourceDaemonId && sourceDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand) {
+                        const forwarded = await this.deps.dispatchMeshCommand(sourceDaemonId, 'clone_mesh_node', {
+                            ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                        });
+                        return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
+                    }
+
                     const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
                     const { createWorktree } = await import('../git/git-worktree.js');
                     const result = await createWorktree({
@@ -6238,6 +6270,15 @@ export class DaemonCommandRouter {
                     if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
                     if (!node.isLocalWorktree) return { success: false, error: 'Node is not a local worktree node' };
 
+                    // Bootstrap runs scripts in the worktree path — forward to the node's daemon if remote.
+                    const nodeDaemonId = typeof node.daemonId === 'string' ? node.daemonId.trim() : undefined;
+                    if (nodeDaemonId && nodeDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand) {
+                        const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, 'retry_mesh_node_bootstrap', {
+                            ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                        });
+                        return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
+                    }
+
                     const currentBootstrap = node.worktreeBootstrap as WorktreeBootstrapState | undefined;
                     if (currentBootstrap?.status === 'running') {
                         return { success: false, error: 'Bootstrap is already running for this node' };

package/src/mesh/mesh-events-coordinator.ts

@@ -6,7 +6,7 @@ import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry, buildTaskCompletionEvidence, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
-import { buildMeshNodeCapabilityTags, claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents } from './mesh-work-queue.js';
+import { buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents } from './mesh-work-queue.js';
 import { fastForwardMeshNode } from './mesh-fast-forward.js';
 import { createSessionDelivery, markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
@@ -499,7 +499,12 @@ function markAutoLaunch(meshId: string, taskId: string, args: {
     });
 }
 
-async function resolveUsableProvider(components: DaemonComponents, nodeId: string, node: any): Promise<{ providerType?: string; reason?: string }> {
+async function resolveUsableProvider(
+    components: DaemonComponents,
+    nodeId: string,
+    node: any,
+    requiredTags?: string[],
+): Promise<{ providerType?: string; reason?: string }> {
     const providerPriority = normalizeProviderPriority(node?.policy);
     if (!providerPriority.length) return { reason: 'missing_provider_priority' };
     const providerLoader = components.providerLoader;
@@ -510,6 +515,12 @@ async function resolveUsableProvider(components: DaemonComponents, nodeId: strin
         const normalizedType = typeof providerLoader.resolveAlias === 'function'
             ? providerLoader.resolveAlias(requestedType)
             : requestedType;
+        // Skip providers that can't satisfy the task's requiredTags (e.g. provider=hermes-cli
+        // means only hermes-cli qualifies, not any other type in providerPriority).
+        if (requiredTags?.length && !nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, normalizedType))) {
+            failed.push(`${requestedType}: required_tags_mismatch`);
+            continue;
+        }
         if (typeof providerLoader.isMachineProviderEnabled === 'function' && !providerLoader.isMachineProviderEnabled(normalizedType)) {
             failed.push(`${requestedType}: disabled`);
             continue;
@@ -552,10 +563,23 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
         }
 
         const candidateNodes = Array.isArray(mesh?.nodes)
-            ? mesh.nodes.filter((node: any) => task.targetNodeId ? node?.id === task.targetNodeId : true)
+            ? mesh.nodes.filter((node: any) => {
+                if (task.targetNodeId && node?.id !== task.targetNodeId) return false;
+                // Skip nodes that can never satisfy requiredTags regardless of which provider
+                // from providerPriority is selected. A node satisfies tags if at least one
+                // provider in its priority list would produce matching capability tags.
+                if (task.requiredTags?.length) {
+                    const priorities = normalizeProviderPriority(node?.policy);
+                    const providerCandidates = priorities.length ? priorities : [undefined as unknown as string];
+                    return providerCandidates.some(p =>
+                        nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, p))
+                    );
+                }
+                return true;
+            })
             : [];
         if (!candidateNodes.length) {
-            markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'no_matching_node', nodeId: task.targetNodeId });
+            markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'no_node_satisfies_required_tags', nodeId: task.targetNodeId });
             continue;
         }
 
@@ -599,7 +623,7 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
 
             autoLaunchInProgress.add(launchKey);
             try {
-                const resolved = await resolveUsableProvider(components, nodeId, node);
+                const resolved = await resolveUsableProvider(components, nodeId, node, task.requiredTags);
                 if (!resolved.providerType) {
                     markAutoLaunch(meshId, task.id, { status: 'skipped', reason: resolved.reason || 'provider_unusable', nodeId });
                     continue;

package/src/status/builders.ts

@@ -326,7 +326,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         mode: state.mode,
         resume: state.resume,
         activeChat,
-        ...(state.activeInteractivePrompt ? { activeInteractivePrompt: state.activeInteractivePrompt } : {}),
+        activeInteractivePrompt: state.activeInteractivePrompt ?? null,
         ...(summaryMetadata && { summaryMetadata }),
         ...(includeSessionMetadata && {
             capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
@@ -342,6 +342,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         settings: state.settings,
         ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
+        ...(state.settings?.spawnedSessionVisibility === 'hidden' && { surfaceHidden: true }),
     };
 }
 
@@ -383,6 +384,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         settings: state.settings,
         ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
+        ...(state.settings?.spawnedSessionVisibility === 'hidden' && { surfaceHidden: true }),
     };
 }