adhdev 0.9.82-rc.36 → 0.9.82-rc.38

package/dist/cli/index.js

@@ -47128,6 +47128,82 @@ function truncateValidationOutput(value) {
   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: execFileSync7 } = await import("child_process");
+  const diff = execFileSync7("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  });
+  if (!diff.trim()) return "";
+  const patchId = execFileSync7("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: execFileSync7 } = await import("child_process");
+    const git = (args) => execFileSync7("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");
@@ -47471,7 +47547,7 @@ function summarizeSessionHostPruneResult(result) {
     keptCount: Array.isArray(value.keptSessionIds) ? value.keptSessionIds.length : void 0
   };
 }
-var import_os4, import_path7, fs10, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, REFINE_VALIDATION_CATEGORIES, REFINE_VALIDATION_TIMEOUT_MS, REFINE_VALIDATION_OUTPUT_LIMIT_BYTES, REFINE_VALIDATION_SUMMARY_CHARS, REFINE_VALIDATION_MAX_COMMANDS, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
+var import_os4, import_path7, fs10, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, REFINE_VALIDATION_CATEGORIES, REFINE_VALIDATION_TIMEOUT_MS, REFINE_VALIDATION_OUTPUT_LIMIT_BYTES, REFINE_VALIDATION_SUMMARY_CHARS, REFINE_VALIDATION_MAX_COMMANDS, REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
 var init_router = __esm({
   "../../oss/packages/daemon-core/src/commands/router.ts"() {
     "use strict";
@@ -47513,6 +47589,7 @@ var init_router = __esm({
     REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
     REFINE_VALIDATION_SUMMARY_CHARS = 2e3;
     REFINE_VALIDATION_MAX_COMMANDS = 4;
+    REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
     CHAT_COMMANDS = [
       "send_chat",
       "new_chat",
@@ -48814,26 +48891,41 @@ var init_router = __esm({
             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,
@@ -48843,6 +48935,7 @@ var init_router = __esm({
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -48862,6 +48955,7 @@ var init_router = __esm({
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -48872,37 +48966,121 @@ var init_router = __esm({
                   }
                 };
               }
+              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,
@@ -48911,18 +49089,14 @@ var init_router = __esm({
                 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": {
@@ -49434,6 +49608,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,
@@ -49529,7 +49740,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,
@@ -49620,7 +49831,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,
@@ -98778,7 +99001,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.36" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.38" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;