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

package/dist/index.js

@@ -3068,27 +3068,46 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     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 = readNonEmptyString2(validationSummary?.status);
+    const patchStatus = readNonEmptyString2(patchEquivalence?.status) || (patchEquivalence?.equivalent === true ? "passed" : "");
     const into = readNonEmptyString2(result?.into);
     const branch = readNonEmptyString2(result?.branch);
+    const mergeStatus = result?.merged === true ? "merged" : readNonEmptyString2(finalConvergence?.status);
+    const convergenceStatus = readNonEmptyString2(finalConvergence?.status);
+    const nextStep = readNonEmptyString2(result?.nextStep) || readNonEmptyString2(finalConvergence?.nextStep) || "Continue from the updated mesh state.";
     const details = [
       jobId ? `job_id=${jobId}` : "",
       branch && into ? `${branch}\u2192${into}` : "",
-      validationStatus ? `validation=${validationStatus}` : ""
+      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})` : ""}.
+Next 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 = readNonEmptyString2(result?.code);
     const error = readNonEmptyString2(result?.error);
-    const convergenceStatus = readNonEmptyString2(result?.convergenceStatus);
+    const validationStatus = readNonEmptyString2(validationSummary?.status);
+    const patchStatus = readNonEmptyString2(patchEquivalence?.status) || (patchEquivalence?.equivalent === true ? "passed" : "");
+    const mergeStatus = result?.merged === true ? "merged" : finalConvergence?.merged === false ? "not_merged" : "";
+    const convergenceStatus = readNonEmptyString2(result?.convergenceStatus) || readNonEmptyString2(finalConvergence?.status);
     const blockedReason = readNonEmptyString2(result?.blockedReason);
-    const nextStep = readNonEmptyString2(result?.nextStep) || readNonEmptyString2(readRecord(result?.finalBranchConvergenceState)?.nextStep);
+    const nextStep = readNonEmptyString2(result?.nextStep) || readNonEmptyString2(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("; ");
@@ -3314,6 +3333,13 @@ function injectMeshSystemMessage(components, args) {
       LOG.warn("MeshRecovery", `Failed to build recovery context: ${e?.message || e}`);
     }
   }
+  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;
@@ -3331,19 +3357,13 @@ function injectMeshSystemMessage(components, args) {
         ...args.metadataEvent,
         ...recoveryContext ? { recoveryContext } : {}
       },
+      coordinatorMessage: messageText,
       queuedAt: Date.now()
     })) {
       LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
     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}`);
@@ -26719,16 +26739,9 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
       });
       return String(stdout || "");
     };
-    const verifyRemoteMainContainsCommit = async (remoteUrl, commit, branch = "main") => {
-      const probeDir = fs11.mkdtempSync((0, import_path8.join)((0, import_os3.tmpdir)(), "adhdev-submodule-reachability-"));
-      try {
-        await runGit2(probeDir, ["init", "-q"]);
-        await runGit2(probeDir, ["-c", "protocol.file.allow=always", "fetch", "--depth=1", remoteUrl, `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
-        await runGit2(probeDir, ["cat-file", "-e", `${commit}^{commit}`]);
-        await runGit2(probeDir, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
-      } finally {
-        fs11.rmSync(probeDir, { recursive: true, force: true });
-      }
+    const verifyRemoteMainContainsCommit = async (submodulePath, commit, branch = "main") => {
+      await runGit2(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+      await runGit2(submodulePath, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
     };
     const treeOutput = await runGit2(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
     const gitlinks = treeOutput.split("\0").filter(Boolean).map((record) => {
@@ -26770,7 +26783,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
             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;
@@ -27755,28 +27768,51 @@ var DaemonCommandRouter = class {
     };
   }
   queueRefineJobEvent(event, handle, result) {
-    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 },
+        {
+          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);
   }
   async appendRefineJobLedger(kind, handle, result) {
     try {