adhdev 0.9.82-rc.35 → 0.9.82-rc.37

package/dist/index.js

@@ -46140,6 +46140,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: execFileSync6 } = await import("child_process");
+  const diff = execFileSync6("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  });
+  if (!diff.trim()) return "";
+  const patchId = execFileSync6("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: execFileSync6 } = await import("child_process");
+    const git = (args) => execFileSync6("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");
@@ -46483,7 +46559,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";
@@ -46525,6 +46601,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",
@@ -47826,26 +47903,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,
@@ -47855,6 +47947,7 @@ var init_router = __esm({
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -47874,6 +47967,7 @@ var init_router = __esm({
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -47884,37 +47978,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,
@@ -47923,18 +48101,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": {
@@ -57244,7 +57418,9 @@ var init_server_connection = __esm({
           const requestId = `mesh_${crypto.randomUUID()}`;
           const timer = setTimeout(() => {
             this.off("daemon_mesh_result", handler);
-            reject(new Error(`Mesh command timed out after ${timeoutMs}ms`));
+            reject(new Error(
+              `Mesh command '${command}' to ${targetDaemonId.slice(0, 12)} timed out after ${timeoutMs}ms (requestId=${requestId})`
+            ));
           }, timeoutMs);
           const handler = (msg) => {
             const body = msg.payload && typeof msg.payload === "object" ? { ...msg, ...msg.payload } : msg;
@@ -67142,7 +67318,18 @@ var init_daemon_mesh_manager = __esm({
               peer.pendingCandidates = [];
             }
           } catch (err) {
-            LOG.warn("Mesh", `[Mesh] Failed to set remote desc: ${err.message}`);
+            const errorMessage = err?.message || "Failed to set remote description";
+            const isDuplicateStableAnswer = type2 === "mesh_p2p_answer" && /Unexpected remote answer description in signaling state stable/i.test(errorMessage);
+            this.logMeshCommandEvent(isDuplicateStableAnswer ? "remote_desc_duplicate_ignored" : "remote_desc_failed", {
+              targetDaemonId,
+              signalType: type2,
+              receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              peerState: peer.state,
+              error: errorMessage
+            });
+            if (isDuplicateStableAnswer) return;
+            LOG.warn("Mesh", `[Mesh] Failed to set remote desc for ${type2} from ${targetDaemonId.slice(0, 12)}: ${errorMessage}`);
+            this.invalidatePeer(targetDaemonId, `P2P remote description failed: ${errorMessage}`, { rejectPending: true, closeResources: true });
           }
         } else if (type2 === "mesh_p2p_ice") {
           try {
@@ -67592,7 +67779,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.35" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.37" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;