@adhdev/daemon-core 0.9.82-rc.78 → 0.9.82-rc.79

package/dist/mesh/mesh-events.d.ts

@@ -6,6 +6,7 @@ export interface PendingMeshCoordinatorEvent {
     nodeId?: string;
     workspace?: string;
     metadataEvent: Record<string, unknown>;
+    coordinatorMessage?: string;
     queuedAt: number;
 }
 export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean;

package/package.json

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

package/src/commands/router.ts

@@ -55,7 +55,7 @@ import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import { getMeshQueueRevision } from '../mesh/mesh-work-queue.js';
 import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
-import { homedir, tmpdir } from 'os';
+import { homedir } from 'os';
 import { basename as pathBasename, join as pathJoin, resolve as pathResolve } from 'path';
 import * as fs from 'fs';
 
@@ -1281,16 +1281,9 @@ async function runMeshRefineSubmoduleReachabilityGate(
             });
             return String(stdout || '');
         };
-        const verifyRemoteMainContainsCommit = async (remoteUrl: string, commit: string, branch = 'main'): Promise<void> => {
-            const probeDir = fs.mkdtempSync(pathJoin(tmpdir(), 'adhdev-submodule-reachability-'));
-            try {
-                await runGit(probeDir, ['init', '-q']);
-                await runGit(probeDir, ['-c', 'protocol.file.allow=always', 'fetch', '--depth=1', remoteUrl, `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
-                await runGit(probeDir, ['cat-file', '-e', `${commit}^{commit}`]);
-                await runGit(probeDir, ['merge-base', '--is-ancestor', commit, `refs/remotes/origin/${branch}`]);
-            } finally {
-                fs.rmSync(probeDir, { recursive: true, force: true });
-            }
+        const verifyRemoteMainContainsCommit = async (submodulePath: string, commit: string, branch = 'main'): Promise<void> => {
+            await runGit(submodulePath, ['-c', 'protocol.file.allow=always', 'fetch', 'origin', `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+            await runGit(submodulePath, ['merge-base', '--is-ancestor', commit, `refs/remotes/origin/${branch}`]);
         };
 
         const treeOutput = await runGit(repoRoot, ['ls-tree', '-r', '-z', mergedTree]);
@@ -1341,7 +1334,7 @@ async function runMeshRefineSubmoduleReachabilityGate(
                         continue;
                     }
                     entry.remoteMainBranch = 'main';
-                    await verifyRemoteMainContainsCommit(remoteUrl, gitlink.commit, 'main');
+                    await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, 'main');
                     entry.fetchedFromOrigin = true;
                     entry.remoteReachable = true;
                     entry.remoteMainReachable = true;
@@ -2558,28 +2551,51 @@ export class DaemonCommandRouter {
     }
 
     private queueRefineJobEvent(event: 'refine:accepted' | 'refine:completed' | 'refine:failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): void {
-        queuePendingMeshCoordinatorEvent({
+        const metadataEvent = {
+            source: 'refine_mesh_node_async_job',
+            jobId: handle.jobId,
+            interactionId: handle.interactionId,
+            meshId: handle.meshId,
+            nodeId: handle.targetNodeId,
+            targetDaemonId: handle.targetDaemonId,
+            workspace: handle.workspace,
+            status: handle.status,
+            startedAt: handle.startedAt,
+            completedAt: handle.completedAt,
+            retryOfJobId: handle.retryOfJobId,
+            ...(result ? { result } : {}),
+        };
+        const eventPayload = {
             event,
             meshId: handle.meshId,
             nodeLabel: handle.targetNodeId,
             nodeId: handle.targetNodeId,
             workspace: handle.workspace,
-            metadataEvent: {
-                source: 'refine_mesh_node_async_job',
-                jobId: handle.jobId,
-                interactionId: handle.interactionId,
-                meshId: handle.meshId,
-                nodeId: handle.targetNodeId,
-                targetDaemonId: handle.targetDaemonId,
-                workspace: handle.workspace,
-                status: handle.status,
-                startedAt: handle.startedAt,
-                completedAt: handle.completedAt,
-                retryOfJobId: handle.retryOfJobId,
-                ...(result ? { result } : {}),
-            },
+            metadataEvent,
             queuedAt: Date.now(),
-        });
+        };
+        if (typeof this.deps.instanceManager?.getByCategory === 'function') {
+            const forwarded = handleMeshForwardEvent(
+                { instanceManager: this.deps.instanceManager } as any,
+                {
+                    event,
+                    meshId: handle.meshId,
+                    nodeId: handle.targetNodeId,
+                    workspace: handle.workspace,
+                    jobId: handle.jobId,
+                    interactionId: handle.interactionId,
+                    status: handle.status,
+                    targetDaemonId: handle.targetDaemonId,
+                    startedAt: handle.startedAt,
+                    completedAt: handle.completedAt,
+                    retryOfJobId: handle.retryOfJobId,
+                    ...(result ? { result } : {}),
+                },
+            );
+            if (forwarded?.success === true) return;
+            LOG.warn('Mesh', `[Refinery] Failed to forward async refine event ${event}: ${forwarded?.error || 'unknown error'}`);
+        }
+        queuePendingMeshCoordinatorEvent(eventPayload);
     }
 
     private async appendRefineJobLedger(kind: 'task_dispatched' | 'task_completed' | 'task_failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): Promise<void> {

package/src/mesh/mesh-events.ts

@@ -55,6 +55,7 @@ export interface PendingMeshCoordinatorEvent {
     nodeId?: string;
     workspace?: string;
     metadataEvent: Record<string, unknown>;
+    coordinatorMessage?: string;
     queuedAt: number;
 }
 
@@ -750,27 +751,54 @@ function buildMeshSystemMessage(args: {
         const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
         const result = readRecord(args.metadataEvent.result);
         const validationSummary = readRecord(result?.validationSummary);
+        const patchEquivalence = readRecord(result?.patchEquivalence);
+        const finalConvergence = readRecord(result?.finalBranchConvergenceState);
         const validationStatus = readNonEmptyString(validationSummary?.status);
+        const patchStatus = readNonEmptyString(patchEquivalence?.status)
+            || (patchEquivalence?.equivalent === true ? 'passed' : '');
         const into = readNonEmptyString(result?.into);
         const branch = readNonEmptyString(result?.branch);
+        const mergeStatus = result?.merged === true ? 'merged' : readNonEmptyString(finalConvergence?.status);
+        const convergenceStatus = readNonEmptyString(finalConvergence?.status);
+        const nextStep = readNonEmptyString(result?.nextStep)
+            || readNonEmptyString(finalConvergence?.nextStep)
+            || 'Continue from the updated mesh state.';
         const details = [
             jobId ? `job_id=${jobId}` : '',
             branch && into ? `${branch}→${into}` : '',
             validationStatus ? `validation=${validationStatus}` : '',
+            patchStatus ? `patch_equivalence=${patchStatus}` : '',
+            mergeStatus ? `merge=${mergeStatus}` : '',
+            convergenceStatus ? `final_convergence=${convergenceStatus}` : '',
         ].filter(Boolean).join('; ');
-        return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ''}. The worktree was merged and cleanup completed; continue from the updated mesh state.`;
+        return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ''}.\nNext step: ${nextStep}`;
     }
     if (args.event === 'refine:failed') {
         const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
         const result = readRecord(args.metadataEvent.result);
+        const validationSummary = readRecord(result?.validationSummary);
+        const patchEquivalence = readRecord(result?.patchEquivalence);
+        const finalConvergence = readRecord(result?.finalBranchConvergenceState);
         const code = readNonEmptyString(result?.code);
         const error = readNonEmptyString(result?.error);
-        const convergenceStatus = readNonEmptyString(result?.convergenceStatus);
+        const validationStatus = readNonEmptyString(validationSummary?.status);
+        const patchStatus = readNonEmptyString(patchEquivalence?.status)
+            || (patchEquivalence?.equivalent === true ? 'passed' : '');
+        const mergeStatus = result?.merged === true
+            ? 'merged'
+            : finalConvergence?.merged === false
+                ? 'not_merged'
+                : '';
+        const convergenceStatus = readNonEmptyString(result?.convergenceStatus)
+            || readNonEmptyString(finalConvergence?.status);
         const blockedReason = readNonEmptyString(result?.blockedReason);
-        const nextStep = readNonEmptyString(result?.nextStep) || readNonEmptyString(readRecord(result?.finalBranchConvergenceState)?.nextStep);
+        const nextStep = readNonEmptyString(result?.nextStep) || readNonEmptyString(finalConvergence?.nextStep);
         const details = [
             jobId ? `job_id=${jobId}` : '',
             code ? `code=${code}` : '',
+            validationStatus ? `validation=${validationStatus}` : '',
+            patchStatus ? `patch_equivalence=${patchStatus}` : '',
+            mergeStatus ? `merge=${mergeStatus}` : '',
             convergenceStatus ? `convergence=${convergenceStatus}` : '',
             blockedReason ? `reason=${blockedReason}` : '',
         ].filter(Boolean).join('; ');
@@ -1028,6 +1056,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
     }
 
+    const messageText = buildMeshSystemMessage({
+        event: args.event,
+        nodeLabel: args.nodeLabel,
+        metadataEvent: args.metadataEvent,
+        recoveryContext,
+    });
+    if (!messageText) return { success: false, error: 'unsupported mesh event' };
+
     const coordinatorInstances = components.instanceManager.getByCategory('cli').filter((inst) => {
         const instState = inst.getState();
         if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
@@ -1047,6 +1083,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                     ...args.metadataEvent,
                     ...(recoveryContext ? { recoveryContext } : {}),
                 },
+                coordinatorMessage: messageText,
                 queuedAt: Date.now(),
             })) {
             LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
@@ -1054,14 +1091,6 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         return { success: true, forwarded: 0 };
     }
 
-    const messageText = buildMeshSystemMessage({
-        event: args.event,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: args.metadataEvent,
-        recoveryContext,
-    });
-    if (!messageText) return { success: false, error: 'unsupported mesh event' };
-
     for (const coord of coordinatorInstances) {
         const coordState = coord.getState();
         LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}`);