@adhdev/daemon-core 0.9.82-rc.36 → 0.9.82-rc.38

package/dist/index.mjs

@@ -24328,12 +24328,89 @@ var REFINE_VALIDATION_TIMEOUT_MS = 12e4;
 var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
 var REFINE_VALIDATION_SUMMARY_CHARS = 2e3;
 var REFINE_VALIDATION_MAX_COMMANDS = 4;
+var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
 function truncateValidationOutput(value) {
   const text = typeof value === "string" ? value : value == null ? "" : String(value);
   if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
   return `${text.slice(0, REFINE_VALIDATION_SUMMARY_CHARS)}
 [truncated ${text.length - REFINE_VALIDATION_SUMMARY_CHARS} chars]`;
 }
+function recordMeshRefineStage(stages, stage, status, startedAt, details) {
+  stages.push({
+    stage,
+    status,
+    durationMs: Date.now() - startedAt,
+    ...details || {}
+  });
+}
+async function computeGitPatchId(cwd, fromRef, toRef) {
+  const { execFileSync: execFileSync4 } = await import("child_process");
+  const diff = execFileSync4("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  });
+  if (!diff.trim()) return "";
+  const patchId = execFileSync4("git", ["patch-id", "--stable"], {
+    cwd,
+    input: diff,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  }).trim();
+  return patchId.split(/\s+/)[0] || "";
+}
+async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
+  const startedAt = Date.now();
+  try {
+    const { execFileSync: execFileSync4 } = await import("child_process");
+    const git = (args) => execFileSync4("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+    });
+    const mergeBase = git(["merge-base", baseHead, branchHead]).trim();
+    const mergeTreeStdout = git(["merge-tree", "--write-tree", baseHead, branchHead]);
+    const mergedTree = mergeTreeStdout.trim().split(/\s+/)[0] || "";
+    if (!mergeBase || !mergedTree) {
+      return {
+        status: "failed",
+        equivalent: false,
+        baseHead,
+        branchHead,
+        mergeBase: mergeBase || void 0,
+        mergedTree: mergedTree || void 0,
+        durationMs: Date.now() - startedAt,
+        error: "patch equivalence preflight could not resolve merge-base or synthetic merge tree",
+        stdout: truncateValidationOutput(mergeTreeStdout)
+      };
+    }
+    const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead);
+    const actualPatchId = await computeGitPatchId(repoRoot, baseHead, mergedTree);
+    const equivalent = expectedPatchId === actualPatchId;
+    return {
+      status: equivalent ? "passed" : "failed",
+      equivalent,
+      baseHead,
+      branchHead,
+      mergeBase,
+      mergedTree,
+      expectedPatchId,
+      actualPatchId,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (e) {
+    return {
+      status: "failed",
+      equivalent: false,
+      baseHead,
+      branchHead,
+      durationMs: Date.now() - startedAt,
+      error: e?.message || String(e),
+      stdout: truncateValidationOutput(e?.stdout),
+      stderr: truncateValidationOutput(e?.stderr)
+    };
+  }
+}
 function readPackageScripts(workspace) {
   try {
     const packageJsonPath = pathJoin(workspace, "package.json");
@@ -25978,26 +26055,41 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const refineStages = [];
         try {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
           const mesh = meshRecord?.mesh;
           const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
-          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
           if (!node.isLocalWorktree || !node.workspace) {
-            return { success: false, error: `Refinery requires a local worktree node` };
+            return { success: false, error: `Refinery requires a local worktree node`, refineStages };
           }
           const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
           const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
-          if (!repoRoot) return { success: false, error: "Source node repoRoot not found" };
+          if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
           const { execFile: execFile3 } = await import("child_process");
           const { promisify: promisify3 } = await import("util");
           const execFileAsync3 = promisify3(execFile3);
+          const resolveStarted = Date.now();
           const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
           const branch = branchStdout.trim();
-          if (!branch) return { success: false, error: "Could not determine branch of the worktree node" };
+          if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
           const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
           const baseBranch = baseBranchStdout.trim();
+          const { stdout: baseHeadStdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+          const { stdout: branchHeadStdout } = await execFileAsync3("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
+          const baseHead = baseHeadStdout.trim();
+          const branchHead = branchHeadStdout.trim();
+          recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead });
+          const validationStarted = Date.now();
           const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace);
+          recordMeshRefineStage(
+            refineStages,
+            "validation",
+            validationSummary.status === "passed" ? "passed" : validationSummary.status === "failed" ? "failed" : "skipped",
+            validationStarted,
+            { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
+          );
           if (validationSummary.status === "failed") {
             return {
               success: false,
@@ -26007,6 +26099,7 @@ var DaemonCommandRouter = class {
               branch,
               into: baseBranch,
               validationSummary,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
@@ -26026,6 +26119,7 @@ var DaemonCommandRouter = class {
               branch,
               into: baseBranch,
               validationSummary,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
@@ -26036,37 +26130,121 @@ var DaemonCommandRouter = class {
               }
             };
           }
+          const patchEquivalenceStarted = Date.now();
+          const patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+          recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
+            equivalent: patchEquivalence.equivalent,
+            expectedPatchId: patchEquivalence.expectedPatchId,
+            actualPatchId: patchEquivalence.actualPatchId,
+            error: patchEquivalence.error
+          });
+          if (!patchEquivalence.equivalent) {
+            return {
+              success: false,
+              code: "patch_equivalence_failed",
+              convergenceStatus: "blocked_review",
+              error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
+              branch,
+              into: baseBranch,
+              validationSummary,
+              patchEquivalence,
+              refineStages,
+              finalBranchConvergenceState: {
+                branch,
+                baseBranch,
+                merged: false,
+                removed: false,
+                validation: "passed",
+                patchEquivalence: "failed",
+                status: "blocked_review"
+              }
+            };
+          }
+          let mergeResult;
+          const mergeStarted = Date.now();
           try {
-            await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+            const result = await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+            mergeResult = {
+              stdout: truncateValidationOutput(result.stdout),
+              stderr: truncateValidationOutput(result.stderr),
+              durationMs: Date.now() - mergeStarted
+            };
+            recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
           } catch (e) {
+            recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
+              error: e?.message || String(e),
+              stdout: truncateValidationOutput(e?.stdout),
+              stderr: truncateValidationOutput(e?.stderr)
+            });
             return {
               success: false,
               error: `Merge failed (conflicts?): ${e.message}`,
               validationSummary,
+              patchEquivalence,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
                 merged: false,
                 removed: false,
                 validation: "passed",
+                patchEquivalence: "passed",
                 status: "not_mergeable"
               }
             };
           }
+          const cleanupStarted = Date.now();
           const removeResult = await this.execute("remove_mesh_node", {
             meshId,
             nodeId,
-            sessionCleanupMode: "kill",
+            sessionCleanupMode: "preserve",
             inlineMesh: args?.inlineMesh
           });
+          recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
+            removed: removeResult?.removed,
+            code: removeResult?.code,
+            error: removeResult?.error
+          });
+          let ledgerError;
+          const ledgerStarted = Date.now();
           try {
             const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
             appendLedgerEntry2(meshId, {
               kind: "node_removed",
               nodeId,
-              payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary }
+              payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence }
             });
-          } catch {
+            recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
+          } catch (e) {
+            ledgerError = e?.message || String(e);
+            recordMeshRefineStage(refineStages, "ledger", "failed", ledgerStarted, { error: ledgerError });
+          }
+          const finalBranchConvergenceState = {
+            branch: baseBranch,
+            mergedBranch: branch,
+            baseBranch,
+            merged: true,
+            removed: removeResult?.success !== false,
+            validation: "passed",
+            patchEquivalence: "passed",
+            status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
+          };
+          if (removeResult?.success === false) {
+            return {
+              success: false,
+              code: "cleanup_failed",
+              error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
+              merged: true,
+              branch,
+              into: baseBranch,
+              removeResult,
+              validationSummary,
+              patchEquivalence,
+              mergeResult,
+              refineStages,
+              ...ledgerError ? { ledgerError } : {},
+              finalBranchConvergenceState
+            };
           }
           return {
             success: true,
@@ -26075,18 +26253,14 @@ var DaemonCommandRouter = class {
             into: baseBranch,
             removeResult,
             validationSummary,
-            finalBranchConvergenceState: {
-              branch: baseBranch,
-              mergedBranch: branch,
-              baseBranch,
-              merged: true,
-              removed: removeResult?.success !== false,
-              validation: "passed",
-              status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
-            }
+            patchEquivalence,
+            mergeResult,
+            refineStages,
+            ...ledgerError ? { ledgerError } : {},
+            finalBranchConvergenceState
           };
         } catch (e) {
-          return { success: false, error: e.message };
+          return { success: false, error: e.message, refineStages };
         }
       }
       case "remove_mesh_node": {
@@ -26598,6 +26772,43 @@ ${block}`);
           const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
           const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
           const localMachineId = loadConfig().machineId || "";
+          const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+          const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
+            mesh,
+            meshSource: meshRecord.source,
+            dispatchMeshCommand: this.deps.dispatchMeshCommand,
+            statusInstanceId: this.deps.statusInstanceId,
+            localMachineId
+          }) : {
+            directEvidenceCount: 0,
+            localConfirmedCount: 0,
+            peerAttemptedCount: 0,
+            peerConfirmedCount: 0,
+            unavailableNodeIds: []
+          };
+          const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+          if (requireDirectPeerTruth && !directTruthSatisfied) {
+            return {
+              success: false,
+              code: "mesh_direct_peer_truth_unavailable",
+              error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct mesh_status probes succeed.",
+              sourceOfTruth: {
+                membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+                coordinatorOwnsLiveTruth: false,
+                currentStatus: "direct_peer_truth_unavailable",
+                directPeerTruth: {
+                  required: true,
+                  satisfied: false,
+                  directEvidenceCount: directTruth.directEvidenceCount,
+                  localConfirmedCount: directTruth.localConfirmedCount,
+                  peerAttemptedCount: directTruth.peerAttemptedCount,
+                  peerConfirmedCount: directTruth.peerConfirmedCount,
+                  unavailableNodeIds: directTruth.unavailableNodeIds
+                }
+              }
+            };
+          }
+          const directTruthUnavailableNodeIds = new Set(directTruth.unavailableNodeIds);
           const selectedCoordinatorNodeId = readStringValue(
             mesh.coordinator?.preferredNodeId,
             mesh.nodes?.[0]?.id,
@@ -26693,7 +26904,7 @@ ${block}`);
                   status.git = inlineTransitGit;
                   status.health = inlineTransitGit.isGitRepo ? deriveMeshNodeHealthFromGit(inlineTransitGit) : "degraded";
                   remoteProbeApplied = true;
-                } else if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand) {
+                } else if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
                   try {
                     const remoteGit = await probeRemoteMeshGitStatus({
                       dispatchMeshCommand: this.deps.dispatchMeshCommand,
@@ -26784,7 +26995,19 @@ ${block}`);
             refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
             sourceOfTruth: {
               membership: meshRecord?.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord?.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
-              coordinatorOwnsLiveTruth: meshRecord?.source !== "inline_bootstrap",
+              coordinatorOwnsLiveTruth: directTruthSatisfied,
+              ...requireDirectPeerTruth ? {
+                currentStatus: directTruthSatisfied ? "live_git_and_session_probes" : "direct_peer_truth_unavailable",
+                directPeerTruth: {
+                  required: true,
+                  satisfied: directTruthSatisfied,
+                  directEvidenceCount: directTruth.directEvidenceCount,
+                  localConfirmedCount: directTruth.localConfirmedCount,
+                  peerAttemptedCount: directTruth.peerAttemptedCount,
+                  peerConfirmedCount: directTruth.peerConfirmedCount,
+                  unavailableNodeIds: directTruth.unavailableNodeIds
+                }
+              } : {},
               historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary"]
             },
             nodes: nodeStatuses,