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

package/dist/index.js

@@ -46541,12 +46541,89 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     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 = (0, import_path7.join)(workspace, "package.json");
@@ -48191,26 +48268,41 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             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,
@@ -48220,6 +48312,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -48239,6 +48332,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -48249,37 +48343,121 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   }
                 };
               }
+              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,
@@ -48288,18 +48466,14 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 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": {
@@ -48811,6 +48985,43 @@ ${block}`);
               const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
               const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
               const localMachineId = loadConfig2().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,
@@ -48906,7 +49117,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,
@@ -48997,7 +49208,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,