@adhdev/daemon-core 0.9.82-rc.253 → 0.9.82-rc.255

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

@@ -56,7 +56,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private runtimeMessages;
     private lastPersistedHistoryMessages;
     private lastAcknowledgedUserInputAt;
-    private externalBusyIdleFingerprint;
     private lastNativeSourceCanonicalCheckAt;
     private lastNativeSourceCanonicalCacheKey;
     private cachedSqliteDb;
@@ -133,8 +132,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private readExternalCompletionMessages;
     private completionFinalAssistantEvidence;
     private completionFinalSummary;
-    private externalNativeFinalFingerprint;
-    private getExternalNativeFinalReconciliation;
     private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;

package/dist/providers/spec/fsm-driver.d.ts

@@ -10,6 +10,7 @@ export type DashboardEvent = {
         id: string;
         label: string;
         title: string | null;
+        status: 'idle' | 'generating' | 'approval';
     };
     modal: {
         title: string | null;

package/package.json

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

package/src/commands/router.ts

@@ -627,10 +627,12 @@ function reconcileInlineMeshCache(cached: any, incoming: any): any {
         if (nodeId) cachedById.set(nodeId, node);
     }
 
+    const mergedIncomingIds = new Set<string>();
     const nodes = incomingNodes.map((incomingNode: any) => {
         const nodeId = readInlineMeshNodeId(incomingNode);
         const cachedNode = nodeId ? cachedById.get(nodeId) : undefined;
         if (!cachedNode && preserveCachedMembership) return null;
+        if (nodeId) mergedIncomingIds.add(nodeId);
         if (!cachedNode) return incomingNode;
         if (hasInlineMeshTransientNodeState(incomingNode)) {
             return { ...cachedNode, ...incomingNode };
@@ -638,6 +640,21 @@ function reconcileInlineMeshCache(cached: any, incoming: any): any {
         return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
     }).filter(Boolean);
 
+    // When the cached membership is authoritative (newer than the incoming
+    // snapshot), nodes that exist only in the cache must survive reconciliation.
+    // A freshly cloned worktree node lives only in the coordinator's cache until
+    // the next snapshot catches up; iterating incomingNodes alone would silently
+    // drop it, making the node invisible to get_mesh / membership reads even
+    // though worktree_bootstrap_complete already fired.
+    if (preserveCachedMembership) {
+        for (const cachedNode of cachedNodes) {
+            const nodeId = readInlineMeshNodeId(cachedNode);
+            if (nodeId && !mergedIncomingIds.has(nodeId)) {
+                nodes.push(cachedNode);
+            }
+        }
+    }
+
     return {
         ...cached,
         ...incoming,
@@ -4292,6 +4309,27 @@ export class DaemonCommandRouter {
             }
 
             case 'launch_cli': {
+                // Worker launch envelope hardening: a mesh worker session must carry
+                // meshCoordinatorDaemonId so completion events route back to the
+                // coordinator (the cloud relay and the daemon-core forwarder both key on
+                // it). mesh_launch_session resolves coordinatorNode.daemonId || ctx.localDaemonId
+                // upstream, but for a freshly-cloned local worktree both can be empty. When the
+                // launch is a coordinator-driven worker on this machine and the id is missing,
+                // stamp this daemon's own id — worker and coordinator are co-located here.
+                {
+                    const launchSettings = (args?.settings && typeof args.settings === 'object')
+                        ? args.settings as Record<string, unknown>
+                        : undefined;
+                    const isMeshWorkerLaunch = !!launchSettings
+                        && (readStringValue(launchSettings.meshNodeFor) || launchSettings.launchedByCoordinator === true);
+                    const hasCoordinatorDaemonId = !!launchSettings && !!readStringValue(launchSettings.meshCoordinatorDaemonId);
+                    if (launchSettings && isMeshWorkerLaunch && !hasCoordinatorDaemonId) {
+                        try {
+                            const localDaemonId = readStringValue(loadConfig().machineId);
+                            if (localDaemonId) launchSettings.meshCoordinatorDaemonId = localDaemonId;
+                        } catch { /* best-effort — launch proceeds without the stamp */ }
+                    }
+                }
                 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.
@@ -6005,7 +6043,16 @@ export class DaemonCommandRouter {
                 if (ownerFailure) return ownerFailure;
 
                 try {
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+                    // Resolve with preferInline so the clone writes the new node into the
+                    // same representation that get_mesh reads back. The MCP coordinator
+                    // passes inlineMesh on every mesh command, so when it owns an inline
+                    // mesh the membership read path (get_mesh, preferInline: true) returns
+                    // the inline cache. Without preferInline here, clone could resolve to a
+                    // local-config mesh and write the node only to config — leaving the
+                    // inline cache (and therefore get_mesh / refreshMeshFromDaemon) without
+                    // the node, so the new worktree node is never visible in live mesh
+                    // membership even though worktree_bootstrap_complete fires.
+                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
                     if (!mesh) return { success: false, error: 'Mesh not found' };
 
@@ -6064,6 +6111,13 @@ export class DaemonCommandRouter {
                             policy: { ...(sourceNode.policy || {}) },
                         });
                         if (!node) return { success: false, error: 'Failed to register worktree node' };
+                        // Also reconcile the freshly-registered node into any warmed inline
+                        // cache for this mesh. get_mesh (preferInline: true) reads the inline
+                        // cache first when one exists; if we only wrote to local config the
+                        // node would be invisible to membership reads. updateInlineMeshNode is
+                        // a no-op when no inline cache is present.
+                        const inlineForReconcile = this.getCachedInlineMesh(meshId);
+                        if (inlineForReconcile) this.updateInlineMeshNode(meshId, inlineForReconcile, node);
                         this.invalidateAggregateMeshStatus(meshId);
                     }
 

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

@@ -438,7 +438,21 @@ function nodeHasActiveAssignment(meshId: string, nodeId: string): boolean {
 }
 
 function sessionHasActiveAssignment(meshId: string, sessionId: string): boolean {
-    return getQueue(meshId, { status: ['assigned'] as any }).some(task => task.assignedSessionId === sessionId);
+    if (getQueue(meshId, { status: ['assigned'] as any }).some(task => task.assignedSessionId === sessionId)) {
+        return true;
+    }
+    // Direct dispatches (mesh_send_task) are tracked in mesh_direct_dispatches, not the
+    // work queue. A session completing a still-active direct dispatch IS an active
+    // assignment — without this, findRecentTerminalLedgerEvidence dedup wrongly suppresses
+    // the canonical agent:generating_completed for direct-dispatch tasks (validation/general),
+    // so the coordinator polling get_pending_mesh_events never observes task_completed and the
+    // session goes silently idle. This check runs before markSessionTerminal marks the
+    // dispatch terminal, so the in-flight dispatch is still observable here.
+    try {
+        if (getActiveDirectDispatches(meshId).some(d => d.sessionId === sessionId)) return true;
+        if (hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId)) return true;
+    } catch { /* best-effort — fall through to false */ }
+    return false;
 }
 
 function liveSessionCountForNode(components: DaemonComponents, meshId: string, nodeId: string): number {
@@ -927,6 +941,27 @@ export function isMeshCoordinatorEvent(eventName: unknown): eventName is string
     return typeof eventName === 'string' && MESH_COORDINATOR_EVENTS.has(eventName);
 }
 
+// Terminal events that the coordinator is actively blocked waiting on. When the
+// coordinator CLI session dispatches a task (e.g. mesh_send_task) it stays in
+// `generating` until the result arrives — but a generating coordinator queues
+// incoming send_message calls into its adapter's pendingOutboundQueue, which is
+// only flushed on the coordinator's OWN idle transition. That transition can't
+// happen until it receives this very event → deadlock. We force-inject these so
+// they bypass the busy send-guard and land in the PTY while generating.
+const MESH_FORCE_INJECT_EVENTS = new Set([
+    'agent:generating_completed',
+    'agent:stopped',
+    'agent:waiting_approval',
+    'refine:completed',
+    'refine:failed',
+    'worktree_bootstrap_complete',
+    'worktree_bootstrap_failed',
+]);
+
+function shouldForceInjectMeshEvent(eventName: unknown): boolean {
+    return typeof eventName === 'string' && MESH_FORCE_INJECT_EVENTS.has(eventName);
+}
+
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
@@ -1362,10 +1397,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
 
+    const forceInject = shouldForceInjectMeshEvent(args.event);
     for (const coord of coordinatorInstances) {
         const coordState = coord.getState();
-        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}`);
-        coord.onEvent('send_message', { input: { text: messageText, textFallback: messageText } });
+        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}${forceInject ? ' (force)' : ''}`);
+        coord.onEvent('send_message', {
+            input: { text: messageText, textFallback: messageText },
+            ...(forceInject ? { force: true } : {}),
+        });
     }
     return { success: true, forwarded: coordinatorInstances.length };
 }
@@ -1424,6 +1463,58 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
 
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
+        // --- Coordinator idle auto-flush ---
+        // When a coordinator session becomes idle, flush any pending coordinator events
+        // that accumulated while it was generating. This runs before the delegate routing
+        // below so that coordinator-own idle transitions are handled first.
+        // Exception: a coordinator that is itself a direct-dispatch target still needs
+        // to go through delegate routing so that the dispatching coordinator receives a
+        // pendingCoordinatorEvents entry for the completion.
+        if (event.event === 'agent:ready' || event.event === 'agent:generating_completed') {
+            const flushInstanceId = readNonEmptyString(event.instanceId);
+            if (flushInstanceId) {
+                const flushSource = components.instanceManager.getInstance(flushInstanceId);
+                if (flushSource && flushSource.category === 'cli') {
+                    const flushState = flushSource.getState();
+                    const flushSettings = flushState.settings && typeof flushState.settings === 'object' ? flushState.settings as Record<string, unknown> : {};
+                    const coordinatorMeshId = readNonEmptyString(flushSettings.meshCoordinatorFor);
+                    if (coordinatorMeshId) {
+                        const status = readNonEmptyString(flushState.status).toLowerCase();
+                        if (status === 'idle') {
+                            try {
+                                const localDaemonId = readNonEmptyString(loadConfig().machineId) || undefined;
+                                const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
+                                if (pendingEvents.length > 0) {
+                                    LOG.info('MeshEvents', `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId} on coordinator idle`);
+                                    for (const pending of pendingEvents) {
+                                        if (!pending.coordinatorMessage) continue;
+                                        const forcePending = shouldForceInjectMeshEvent(pending.event);
+                                        flushSource.onEvent('send_message', {
+                                            input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage },
+                                            ...(forcePending ? { force: true } : {}),
+                                        });
+                                    }
+                                }
+                            } catch (e: any) {
+                                LOG.warn('MeshEvents', `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
+                            }
+                        }
+                        // Skip delegate routing unless this coordinator session is itself
+                        // a direct-dispatch target — in that case fall through so the
+                        // dispatching coordinator gets a pendingCoordinatorEvents entry.
+                        let hasDirectDispatch = false;
+                        try {
+                            hasDirectDispatch =
+                                getActiveDirectDispatches(coordinatorMeshId).some(d => d.sessionId === flushInstanceId)
+                                || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, flushInstanceId);
+                        } catch { /* best-effort */ }
+                        if (!hasDirectDispatch) return;
+                    }
+                }
+            }
+        }
+
+        // --- Delegate event routing ---
         if (!isMeshCoordinatorEvent(event.event)) return;
 
         const instanceId = readNonEmptyString(event.instanceId);
@@ -1475,36 +1566,4 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
             metadataEvent: event,
         });
     });
-
-    // Auto-flush pending coordinator events when a coordinator session becomes idle.
-    components.instanceManager.onEvent((event) => {
-        if (event.event !== 'agent:ready' && event.event !== 'agent:generating_completed') return;
-
-        const instanceId = readNonEmptyString(event.instanceId);
-        if (!instanceId) return;
-
-        const sourceInstance = components.instanceManager.getInstance(instanceId);
-        if (!sourceInstance || sourceInstance.category !== 'cli') return;
-        const state = sourceInstance.getState();
-        const settings = state.settings && typeof state.settings === 'object' ? state.settings as Record<string, unknown> : {};
-
-        const coordinatorMeshId = readNonEmptyString(settings.meshCoordinatorFor);
-        if (!coordinatorMeshId) return;
-
-        const status = readNonEmptyString(state.status).toLowerCase();
-        if (status !== 'idle') return;
-
-        try {
-            const localDaemonId = readNonEmptyString(loadConfig().machineId) || undefined;
-            const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
-            if (pendingEvents.length === 0) return;
-            LOG.info('MeshEvents', `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId} on coordinator idle`);
-            for (const pending of pendingEvents) {
-                if (!pending.coordinatorMessage) continue;
-                sourceInstance.onEvent('send_message', { input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage } });
-            }
-        } catch (e: any) {
-            LOG.warn('MeshEvents', `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
-        }
-    });
 }

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

@@ -185,12 +185,20 @@ function refineTerminalEventFromLedger(meshId: string, pending: readonly Pending
 
 function reconcilePendingMeshCoordinatorEvents(meshId: string, events: PendingMeshCoordinatorEvent[]): PendingMeshCoordinatorEvent[] {
     const backfilled = refineTerminalEventFromLedger(meshId, events);
-    if (backfilled.length === 0) return events;
-    const terminalJobIds = new Set(backfilled.map(event => readRefineJobId(event)).filter(Boolean));
-    return [
-        ...events.filter(event => !(event.event === 'refine:accepted' && terminalJobIds.has(readRefineJobId(event)))),
-        ...backfilled,
-    ];
+    // A refine:accepted event is a provisional "job accepted, result to follow" signal.
+    // Once its terminal (completed/failed) counterpart for the same jobId exists — whether
+    // already direct-queued into the pending store OR backfilled from the ledger here — the
+    // accepted is superseded and is dropped so the coordinator isn't shown stale duplicate
+    // noise alongside the terminal outcome.
+    const terminalJobIds = new Set(
+        [...events.filter(event => REFINE_TERMINAL_EVENTS.has(event.event)), ...backfilled]
+            .map(event => readRefineJobId(event))
+            .filter(Boolean),
+    );
+    const reconciled = terminalJobIds.size === 0
+        ? events
+        : events.filter(event => !(event.event === 'refine:accepted' && terminalJobIds.has(readRefineJobId(event))));
+    return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
 }
 
 const MAX_PENDING_EVENTS_BYTES = 100 * 1024; // 100 KB — keep the pending file small

package/src/mesh/mesh-work-queue.ts

@@ -22,7 +22,6 @@ export interface MeshTaskModeValidationResult {
 
 const LIVE_DEBUG_READONLY_FORBIDDEN: Array<{ label: string; pattern: RegExp }> = [
     { label: 'source_edit', pattern: /\b(edit|modify|patch|apply\s+patch|write\s+(?:to\s+)?(?:file|source)|overwrite|delete\s+file|remove\s+file|create\s+file|touch\s+file)\b/i },
-    { label: 'git_mutation', pattern: /\b(?:git\s+(?:add|commit|push|reset|rebase|clean|checkout|switch|merge|tag|restore|rm|mv|stash|worktree\s+(?:add|remove|move))|push\b)/i },
     { label: 'checkpoint', pattern: /\b(checkpoint|mesh_checkpoint)\b/i },
     { label: 'deploy_or_version_bump', pattern: /\b(deploy|wrangler\s+deploy|version[-\s]?bump|npm\s+version|release|npm\s+publish|yarn\s+publish|pnpm\s+publish)\b/i },
     { label: 'destructive_shell', pattern: /\b(rm\s+-rf|mv\s+\S+\s+\S+|truncate\s|tee\s+\S+|sed\s+-i|shred\b)\b/i },
@@ -30,6 +29,61 @@ const LIVE_DEBUG_READONLY_FORBIDDEN: Array<{ label: string; pattern: RegExp }> =
     { label: 'container_mutation', pattern: /\b(docker\s+(?:build|run|exec|push|tag|rmi|rm|create|start|stop|kill)|kubectl\s+(?:apply|delete|patch|replace|create|scale))\b/i },
 ];
 
+/**
+ * Git subcommands that mutate the working tree, index, refs, or remote.
+ * `stash` and `checkout` are intentionally absent here: they have read-only
+ * variants (`git stash list`/`show`, `git checkout-index`) and are classified
+ * token-by-token in {@link detectGitMutation} rather than by bare keyword.
+ */
+const GIT_MUTATION_SUBCOMMANDS = new Set([
+    'add', 'commit', 'push', 'reset', 'rebase', 'clean', 'switch', 'merge',
+    'tag', 'restore', 'rm', 'mv', 'cherry-pick', 'revert', 'pull', 'fetch',
+    'am', 'apply', 'gc', 'prune',
+]);
+
+/**
+ * Read-only `git stash` variants. Any other `git stash <x>` (pop/apply/drop/
+ * push/save/clear, or bare `git stash` which defaults to push) is a mutation.
+ */
+const GIT_STASH_READONLY_SUBCOMMANDS = new Set(['list', 'show']);
+
+/**
+ * Detects a true git mutation in free-text task message, token-aware so that
+ * read-only diagnostics (`git stash list`, `git stash show --stat`,
+ * `git checkout-index`, `git status`, `git diff`, `git log`, ...) are allowed.
+ * Returns true only when a genuine mutating git invocation is present.
+ */
+function detectGitMutation(message: string): boolean {
+    const re = /\bgit\s+([a-z][a-z0-9-]*)/gi;
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(message)) !== null) {
+        const sub = match[1].toLowerCase();
+        if (GIT_MUTATION_SUBCOMMANDS.has(sub)) return true;
+        if (sub === 'stash') {
+            // Token following `git stash`; read-only only for list/show.
+            const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+            const next = after ? after[1].toLowerCase() : '';
+            if (!GIT_STASH_READONLY_SUBCOMMANDS.has(next)) return true; // bare stash = push, or pop/apply/drop/...
+        } else if (sub === 'checkout') {
+            // `git checkout <ref/path>` mutates; `git checkout-index` is matched
+            // as its own token by the regex (sub === 'checkout-index') and is read-only.
+            return true;
+        } else if (sub === 'submodule') {
+            // `git submodule update` mutates; `git submodule status` is read-only.
+            const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+            const next = after ? after[1].toLowerCase() : '';
+            if (next === 'update' || next === 'add' || next === 'sync' || next === 'deinit') return true;
+        } else if (sub === 'worktree') {
+            const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+            const next = after ? after[1].toLowerCase() : '';
+            if (next === 'add' || next === 'remove' || next === 'move' || next === 'prune') return true;
+        }
+        // checkout-index, stash-with-no-next-already-handled, status/diff/log/show/
+        // rev-parse/branch/submodule status fall through as read-only.
+    }
+    return false;
+}
+
 export function normalizeMeshTaskMode(value: unknown): MeshTaskMode | undefined {
     if (typeof value !== 'string') return undefined;
     const normalized = value.trim() as MeshTaskMode;
@@ -44,9 +98,13 @@ export function validateMeshTaskModeRequest(mode: unknown, message: string): Mes
     if (taskMode !== 'live_debug_readonly') {
         return { valid: true, taskMode, violations: [] };
     }
+    const text = message || '';
     const violations = LIVE_DEBUG_READONLY_FORBIDDEN
-        .filter(rule => rule.pattern.test(message || ''))
+        .filter(rule => rule.pattern.test(text))
         .map(rule => rule.label);
+    if (detectGitMutation(text)) {
+        violations.push('git_mutation');
+    }
     return {
         valid: violations.length === 0,
         taskMode,