@adhdev/daemon-core 0.9.82-rc.223 → 0.9.82-rc.225

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.223",
+  "version": "0.9.82-rc.225",
   "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

@@ -2545,9 +2545,15 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
         const historyLimit = normalizeReadChatTailLimit(args);
         try {
             const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h);
+            const targetSid = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+            const registrySessionWorkspace = targetSid
+                ? (h.ctx?.sessionRegistry?.get?.(targetSid) as any)?.workspace
+                : undefined;
             const workspace = typeof (h.currentSession as any)?.workspace === 'string'
                 ? (h.currentSession as any).workspace
-                : undefined;
+                : typeof registrySessionWorkspace === 'string'
+                    ? registrySessionWorkspace
+                    : undefined;
             const intendedWorkspace = typeof args?.workspace === 'string' ? args.workspace : undefined;
             const supportsNative = supportsCliNativeTranscript(agentStr, provider)
                 && isNativeSourceCanonicalHistory(provider?.nativeHistory);

package/src/commands/router.ts

@@ -39,7 +39,7 @@ import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../sessi
 import { createHermesManualMeshCoordinatorSetup, resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
 import { buildSessionEntries } from '../status/builders.js';
 import { registerMeshCoordinator, getCoordinatorForSession } from '../mesh/coordinator-registry.js';
-import { handleMeshForwardEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent } from '../mesh/mesh-events.js';
+import { handleMeshForwardEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, type PendingMeshCoordinatorEvent } from '../mesh/mesh-events.js';
 import { buildMeshHostRequiredFailure, normalizeMeshDaemonRole, resolveMeshHostStatus } from '../mesh/mesh-host-ownership.js';
 import { fastForwardMeshNode } from '../mesh/mesh-fast-forward.js';
 import { buildPreviewFreshness } from '../mesh/preview-freshness.js';
@@ -845,7 +845,12 @@ function applyInlineMeshBranchConvergence(mesh: any, node: any, status: Record<s
 
 function summarizeInlineMeshBranchConvergence(nodes: Array<Record<string, unknown>>): Record<string, unknown> {
     const followUps = nodes
-        .filter(node => readObjectRecord(node.branchConvergence).needsConvergence === true)
+        .filter(node => {
+            if (readObjectRecord(node.branchConvergence).needsConvergence !== true) return false;
+            const workspace = typeof node.workspace === 'string' ? node.workspace : '';
+            if (workspace && !fs.existsSync(workspace)) return false;
+            return true;
+        })
         .map(node => {
             const convergence = readObjectRecord(node.branchConvergence);
             return {
@@ -2857,7 +2862,59 @@ export class DaemonCommandRouter {
         } catch (e: any) {
             const message = String(e?.message || e || 'worktree cleanup failed');
             const dirty = message.includes('dirty worktree') || message.includes('local changes');
-            const submoduleForceBlocked = /working trees containing submodules cannot be moved or removed/i.test(message) && !forceFallbackConvergence.allow;
+            const isSubmoduleGuard = /working trees containing submodules cannot be moved or removed/i.test(message);
+            const submoduleForceBlocked = isSubmoduleGuard && !forceFallbackConvergence.allow;
+
+            // Fallback 1: submodule guard on --force path — deinit submodules first, then retry remove
+            if (isSubmoduleGuard && forceFallbackConvergence.allow) {
+                const { execFile } = await import('node:child_process');
+                const { promisify } = await import('node:util');
+                const execFileAsync = promisify(execFile);
+                const GIT_TIMEOUT_CLEANUP = 30_000;
+                const GIT_MAX_BUFFER_CLEANUP = 4 * 1024 * 1024;
+                try {
+                    await execFileAsync('git', ['-C', workspace, 'submodule', 'deinit', '--all', '-f'], {
+                        encoding: 'utf8', timeout: GIT_TIMEOUT_CLEANUP, maxBuffer: GIT_MAX_BUFFER_CLEANUP, windowsHide: true,
+                    });
+                    await execFileAsync('git', ['worktree', 'remove', '--force', workspace], {
+                        cwd: repoRoot, encoding: 'utf8', timeout: GIT_TIMEOUT_CLEANUP, maxBuffer: GIT_MAX_BUFFER_CLEANUP, windowsHide: true,
+                    });
+                    return {
+                        success: true,
+                        removedPath: workspace,
+                        repoRoot,
+                        fallback: 'git_worktree_remove_submodule_deinit' as const,
+                        forced: true,
+                        reason: 'working_trees_containing_submodules' as const,
+                        convergence: forceFallbackConvergence,
+                    };
+                } catch (deinitError: any) {
+                    // Fallback 2: deinit+remove still failed — rmSync + prune
+                    try {
+                        fs.rmSync(workspace, { recursive: true, force: true });
+                        await execFileAsync('git', ['worktree', 'prune'], {
+                            cwd: repoRoot, encoding: 'utf8', timeout: GIT_TIMEOUT_CLEANUP, maxBuffer: GIT_MAX_BUFFER_CLEANUP, windowsHide: true,
+                        });
+                        return {
+                            success: true,
+                            removedPath: workspace,
+                            repoRoot,
+                            fallback: 'fs_rm_worktree_prune' as const,
+                            forced: true,
+                            reason: 'working_trees_containing_submodules' as const,
+                            convergence: forceFallbackConvergence,
+                        };
+                    } catch (rmError: any) {
+                        return {
+                            success: false,
+                            code: 'mesh_worktree_cleanup_failed',
+                            error: `All removal fallbacks exhausted. deinit+remove: ${deinitError?.message || deinitError}; rmSync+prune: ${rmError?.message || rmError}`,
+                            recoveryHint: 'Manually remove the worktree directory and run git worktree prune from the source repo.',
+                        };
+                    }
+                }
+            }
+
             return {
                 success: false,
                 code: dirty
@@ -2886,10 +2943,20 @@ export class DaemonCommandRouter {
         const metadataStatus = typeof args.node?.branchConvergence?.status === 'string'
             ? args.node.branchConvergence.status
             : '';
-        if (metadataStatus === 'merged_to_main' || metadataStatus === 'cleanup_candidate') {
+        if (metadataStatus === 'merged_to_main' || metadataStatus === 'cleanup_candidate' || metadataStatus === 'merged_pushed') {
             return { allow: true, status: metadataStatus, source: 'node_branch_convergence' };
         }
 
+        // Also allow when the node's last recorded refine job reached final convergence merged_pushed
+        const refinedConvergence = typeof args.node?.refineState?.finalBranchConvergenceState?.status === 'string'
+            ? args.node.refineState.finalBranchConvergenceState.status
+            : typeof args.node?.lastRefineResult?.finalBranchConvergenceState?.status === 'string'
+                ? args.node.lastRefineResult.finalBranchConvergenceState.status
+                : '';
+        if (refinedConvergence === 'merged_pushed' || refinedConvergence === 'merged_to_main') {
+            return { allow: true, status: refinedConvergence, source: 'node_refine_state' };
+        }
+
         const { execFile } = await import('node:child_process');
         const { promisify } = await import('node:util');
         const execFileAsync = promisify(execFile);
@@ -3455,11 +3522,31 @@ export class DaemonCommandRouter {
 
             const { stdout: baseBranchStdout } = await execFileAsync('git', ['branch', '--show-current'], { cwd: repoRoot, encoding: 'utf8' });
             const baseBranch = baseBranchStdout.trim();
-            const { stdout: baseHeadStdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: repoRoot, encoding: 'utf8' });
+
+            // Fetch origin so baseHead reflects the latest pushed state, not a stale local HEAD.
+            // This prevents patch_equivalence failures when sequential Refines push to origin/main
+            // but the local main checkout hasn't been fast-forwarded yet.
+            let fetchWarning: string | undefined;
+            try {
+                await execFileAsync('git', ['fetch', 'origin', baseBranch], { cwd: repoRoot, encoding: 'utf8' });
+            } catch (e: any) {
+                fetchWarning = `git fetch origin ${baseBranch} failed (proceeding with local HEAD): ${e?.message}`;
+            }
+
+            // Prefer origin/<baseBranch> as the authoritative base; fall back to local HEAD if fetch failed.
+            let baseHeadRaw: string;
+            try {
+                const { stdout } = await execFileAsync('git', ['rev-parse', `origin/${baseBranch}`], { cwd: repoRoot, encoding: 'utf8' });
+                baseHeadRaw = stdout.trim();
+            } catch {
+                const { stdout: localHead } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: repoRoot, encoding: 'utf8' });
+                baseHeadRaw = localHead.trim();
+            }
+
             const { stdout: branchHeadStdout } = await execFileAsync('git', ['rev-parse', branch], { cwd: node.workspace, encoding: 'utf8' });
-            const baseHead = baseHeadStdout.trim();
+            const baseHead = baseHeadRaw;
             let branchHead = branchHeadStdout.trim();
-            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, { branch, baseBranch, baseHead, branchHead });
+            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, { branch, baseBranch, baseHead, branchHead, ...(fetchWarning ? { fetchWarning } : {}) });
 
             const validationStarted = Date.now();
             const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace, {
@@ -3480,15 +3567,35 @@ export class DaemonCommandRouter {
                 { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length },
             );
             if (validationSummary.status === 'failed') {
+                const firstFailedCmd = Array.isArray(validationSummary.commandsRun)
+                    ? (validationSummary.commandsRun as Array<Record<string, unknown>>).find(c => c.success === false)
+                    : undefined;
+                const buildValidationFailedError = (): string => {
+                    const base = validationSummary.failureCode === 'missing_dependencies'
+                        ? 'Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation.'
+                        : validationSummary.failureCode === 'dependency_bootstrap_failed'
+                            ? 'Refinery dependency/bootstrap command failed; merge/refine was not attempted.'
+                            : 'Refinery validation gate failed; merge/refine was not attempted.';
+                    if (!firstFailedCmd) return base;
+                    const cmdName = typeof firstFailedCmd.displayCommand === 'string' ? firstFailedCmd.displayCommand
+                        : typeof firstFailedCmd.command === 'string'
+                            ? [firstFailedCmd.command, ...(Array.isArray(firstFailedCmd.args) ? firstFailedCmd.args : [])].join(' ').trim()
+                            : typeof firstFailedCmd.cmd === 'string' ? firstFailedCmd.cmd : '';
+                    const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output]
+                        .filter(s => typeof s === 'string' && s.length > 0)
+                        .join('\n');
+                    const tail = rawOutput.length > 800 ? rawOutput.slice(-800) : rawOutput;
+                    return [
+                        base,
+                        cmdName ? `First failing command: ${cmdName}` : '',
+                        tail ? `Output (tail):\n${tail}` : '',
+                    ].filter(Boolean).join('\n');
+                };
                 return {
                     success: false,
                     code: validationSummary.failureCode || 'validation_failed',
                     convergenceStatus: 'blocked_review',
-                    error: validationSummary.failureCode === 'missing_dependencies'
-                        ? 'Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation.'
-                        : validationSummary.failureCode === 'dependency_bootstrap_failed'
-                            ? 'Refinery dependency/bootstrap command failed; merge/refine was not attempted.'
-                            : 'Refinery validation gate failed; merge/refine was not attempted.',
+                    error: buildValidationFailedError(),
                     branch,
                     into: baseBranch,
                     validationSummary,
@@ -4184,13 +4291,64 @@ export class DaemonCommandRouter {
                 return { success: true };
             }
 
-            case 'launch_cli':
+            case 'launch_cli': {
+                const launchResult = await this.deps.cliManager.handleCliCommand(cmd, args);
+                // Bug C fix (part 1): when launching a mesh node worker session, surface
+                // bootstrapPending:true if the node's worktree bootstrap is still running.
+                // This is informational — the launch is NOT blocked here (blocking is done
+                // upstream by getWorktreeBootstrapLaunchBlock in the MCP layer).
+                const meshNodeId = readStringValue((args?.settings as any)?.meshNodeId);
+                const meshId = readStringValue((args?.settings as any)?.meshNodeFor);
+                if (meshNodeId && meshId && launchResult?.success !== false) {
+                    try {
+                        const { getMesh } = await import('../config/mesh-config.js');
+                        const meshObj = getMesh(meshId) ?? this.getCachedInlineMesh(meshId);
+                        const nodeObj = Array.isArray(meshObj?.nodes)
+                            ? meshObj.nodes.find((n: any) => n.id === meshNodeId || n.nodeId === meshNodeId)
+                            : undefined;
+                        const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
+                        if (bootstrapStatus === 'running') {
+                            return { success: true, ...launchResult, bootstrapPending: true };
+                        }
+                    } catch { /* best-effort — do not fail launch for bootstrap probe errors */ }
+                }
+                return launchResult;
+            }
             case 'stop_cli':
             case 'set_cli_view_mode':
-            case 'record_provider_pty':
-            case 'agent_command': {
+            case 'record_provider_pty': {
                 return this.deps.cliManager.handleCliCommand(cmd, args);
             }
+            case 'agent_command': {
+                const agentResult = await this.deps.cliManager.handleCliCommand(cmd, args);
+                // Bug C fix (part 2): when dispatching a task to a mesh node session, override
+                // the dispatch acknowledgement risk reason to 'bootstrap_still_running' when
+                // the target node's worktree bootstrap is still running. Informational only —
+                // dispatch is NOT blocked.
+                const meshCtx = args?.meshContext as Record<string, unknown> | undefined;
+                const dispatchNodeId = readStringValue(meshCtx?.nodeId);
+                const dispatchMeshId = readStringValue(meshCtx?.meshId);
+                if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
+                    try {
+                        const { getMesh } = await import('../config/mesh-config.js');
+                        const meshObj = getMesh(dispatchMeshId) ?? this.getCachedInlineMesh(dispatchMeshId);
+                        const nodeObj = Array.isArray(meshObj?.nodes)
+                            ? meshObj.nodes.find((n: any) => n.id === dispatchNodeId || n.nodeId === dispatchNodeId)
+                            : undefined;
+                        const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
+                        if (bootstrapStatus === 'running') {
+                            return {
+                                success: true,
+                                ...agentResult,
+                                dispatchAcknowledgementRisk: true,
+                                dispatchAcknowledgementRiskReason: 'bootstrap_still_running',
+                                nextAction: 'Wait for worktree_bootstrap_complete event before dispatching work to this node.',
+                            };
+                        }
+                    } catch { /* best-effort */ }
+                }
+                return agentResult;
+            }
 
             // ─── Logs ───
             case 'get_logs': {
@@ -5766,9 +5924,16 @@ export class DaemonCommandRouter {
                         // keeps showing up in the dashboard graph until the cache
                         // ages out on its own.
                         if (removed) this.invalidateAggregateMeshStatus(meshId);
+                        // Node was already absent from the inline mesh (e.g. removed by a
+                        // prior refine cleanup). Treat as removed so caller gets removed:true.
+                        if (!removed && !node) removed = true;
                     } else {
                         const { removeNode } = await import('../config/mesh-config.js');
                         removed = removeNode(meshId, nodeId);
+                        // Node already absent from config (e.g. removed by a prior refine
+                        // cleanup after a successful Refinery merge). Treat as removed so
+                        // the response is accurate.
+                        if (!removed && !node) removed = true;
                         if (removed) this.invalidateAggregateMeshStatus(meshId);
                     }
 
@@ -5974,17 +6139,58 @@ export class DaemonCommandRouter {
                         new Promise<{ completed: false }>((resolve) => setTimeout(() => resolve({ completed: false }), setupWaitMs)),
                     ]);
 
-                    if (!setupResult.completed) {
-                        setupPromise.catch((error: any) => {
-                            const failedState: WorktreeBootstrapState = {
-                                ...runningBootstrapState,
-                                status: 'failed',
-                                completedAt: new Date().toISOString(),
-                                error: error?.message || String(error),
+                    const emitBootstrapEvent = (eventStatus: 'bootstrap_complete' | 'bootstrap_failed', bootstrapState: WorktreeBootstrapState, startedAtMs: number, extraPayload?: Record<string, unknown>): void => {
+                        try {
+                            const durationMs = Date.now() - startedAtMs;
+                            const event = `worktree_${eventStatus}` as const;
+                            const metadataEvent = {
+                                source: 'clone_mesh_node_bootstrap',
+                                nodeId: node.id,
+                                status: eventStatus,
+                                worktreePath: result.worktreePath,
+                                durationMs,
+                                bootstrapStatus: bootstrapState.status,
+                                ...(bootstrapState.error ? { error: bootstrapState.error } : {}),
+                                ...(bootstrapState.exitCode !== undefined ? { exitCode: bootstrapState.exitCode } : {}),
+                                ...(extraPayload || {}),
                             };
-                            void persistWorktreeSetupState(failedState);
-                            void appendCloneLedger(false, failedState);
-                        });
+                            if (typeof this.deps.instanceManager?.getByCategory === 'function') {
+                                const forwarded = handleMeshForwardEvent(
+                                    { instanceManager: this.deps.instanceManager } as any,
+                                    { event, meshId, nodeId: node.id, workspace: result.worktreePath, metadataEvent },
+                                );
+                                if (forwarded?.success === true) return;
+                            }
+                            queuePendingMeshCoordinatorEvent({
+                                event,
+                                meshId,
+                                nodeLabel: node.id,
+                                nodeId: node.id,
+                                workspace: result.worktreePath,
+                                metadataEvent,
+                                queuedAt: Date.now(),
+                            });
+                        } catch { /* event emission is best-effort */ }
+                    };
+
+                    const bootstrapStartedMs = Date.now();
+
+                    if (!setupResult.completed) {
+                        setupPromise
+                            .then(({ bootstrapState }) => {
+                                emitBootstrapEvent('bootstrap_complete', bootstrapState, bootstrapStartedMs);
+                            })
+                            .catch((error: any) => {
+                                const failedState: WorktreeBootstrapState = {
+                                    ...runningBootstrapState,
+                                    status: 'failed',
+                                    completedAt: new Date().toISOString(),
+                                    error: error?.message || String(error),
+                                };
+                                void persistWorktreeSetupState(failedState);
+                                void appendCloneLedger(false, failedState);
+                                emitBootstrapEvent('bootstrap_failed', failedState, bootstrapStartedMs, { error: error?.message || String(error) });
+                            });
                         return {
                             success: true,
                             async: true,
@@ -6002,6 +6208,7 @@ export class DaemonCommandRouter {
                     }
 
                     const { submodulesInitialized, bootstrapState } = setupResult.value;
+                    emitBootstrapEvent('bootstrap_complete', bootstrapState, bootstrapStartedMs);
                     return {
                         success: true,
                         node,
@@ -6077,7 +6284,40 @@ export class DaemonCommandRouter {
                 const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'queue trigger');
                 if (ownerFailure) return ownerFailure;
                 try {
-                    const { triggerMeshQueue } = await import('../mesh/mesh-events.js');
+                    const { triggerMeshQueue, tryAssignQueueTask } = await import('../mesh/mesh-events.js');
+
+                    // Bug A fix: when preferredNodeId is provided, attempt to claim a pending
+                    // task for the preferred node's idle session first, before the general
+                    // round-robin trigger picks a different node.
+                    const preferredNodeId = typeof args?.preferredNodeId === 'string' ? args.preferredNodeId.trim() : '';
+                    if (preferredNodeId) {
+                        const cliInstances = this.deps.instanceManager.getByCategory('cli');
+                        // Sort: preferred node's sessions first, others after
+                        const sorted = [...cliInstances].sort((a, b) => {
+                            const aSettings = a.getState().settings as Record<string, unknown> || {};
+                            const bSettings = b.getState().settings as Record<string, unknown> || {};
+                            const aNode = readStringValue(aSettings.meshNodeId, aSettings.nodeId);
+                            const bNode = readStringValue(bSettings.meshNodeId, bSettings.nodeId);
+                            return (aNode === preferredNodeId ? -1 : 0) - (bNode === preferredNodeId ? -1 : 0);
+                        });
+                        for (const inst of sorted) {
+                            const state = inst.getState();
+                            const settings = state.settings as Record<string, unknown> || {};
+                            const nodeId = readStringValue(settings.meshNodeId, settings.nodeId);
+                            if (!nodeId || nodeId !== preferredNodeId) continue;
+                            const meshNodeFor = readStringValue(settings.meshNodeFor);
+                            if (meshNodeFor !== meshId) continue;
+                            const status = (readStringValue(state.status) || '').toLowerCase();
+                            if (status !== 'idle') continue;
+                            const sessionId = typeof state.instanceId === 'string' ? state.instanceId : '';
+                            const providerType = readStringValue(state.type, settings.providerType) || '';
+                            if (sessionId && providerType) {
+                                tryAssignQueueTask(this.deps as any, meshId, nodeId, sessionId, providerType);
+                                break;
+                            }
+                        }
+                    }
+
                     const trigger = await triggerMeshQueue(this.deps as any, meshId);
                     return { success: true, trigger };
                 } catch (e: any) {

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

@@ -870,6 +870,8 @@ const MESH_COORDINATOR_EVENTS = new Set([
     'refine:accepted',
     'refine:completed',
     'refine:failed',
+    'worktree_bootstrap_complete',
+    'worktree_bootstrap_failed',
 ]);
 
 const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind> = {

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

@@ -1483,9 +1483,14 @@ export class CliProviderInstance implements ProviderInstance {
         const rawStatus = adapterStatus.status;
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
         const externalNativeFinal = this.getExternalNativeFinalReconciliation(undefined, adapterStatus);
+        // During the autoApproveBusy window (2s after firing approval key), the PTY
+        // can briefly report 'idle' before the next generating phase starts. Treat that
+        // transient idle as 'generating' to suppress a spurious agent:generating_completed
+        // push notification. externalNativeFinal still wins to allow hard-stop overrides.
+        const autoApproveHoldIdle = this.autoApproveBusy && rawStatus === 'idle';
         const newStatus = externalNativeFinal && isCliGeneratingLikeStatus(rawStatus)
             ? 'idle'
-            : (autoApproveActive ? 'generating' : rawStatus);
+            : (autoApproveActive || autoApproveHoldIdle ? 'generating' : rawStatus);
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();