@adhdev/daemon-standalone 0.9.82-rc.64 → 0.9.82-rc.66

package/dist/index.js

@@ -47374,6 +47374,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         meshId: readStringValue(status?.meshId, status?.mesh_id) ?? null,
         refreshedAt: readStringValue(status?.refreshedAt, status?.refreshed_at) ?? null,
         sourceOfTruth: status?.sourceOfTruth ?? null,
+        branchConvergenceSummary: status?.branchConvergenceSummary ?? status?.branch_convergence_summary ?? null,
         nodeCount: nodes.length,
         nodes: nodes.map((node) => ({
           nodeId: readStringValue(node?.nodeId, node?.id) ?? null,
@@ -47389,7 +47390,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           } : null,
           gitProbePending: node?.gitProbePending === true,
           launchReady: node?.launchReady === true,
-          git: summarizeRepoMeshDebugGit(node?.git)
+          git: summarizeRepoMeshDebugGit(node?.git),
+          branchConvergence: node?.branchConvergence ?? node?.branch_convergence ?? null
         }))
       };
     }
@@ -47891,7 +47893,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     async function probeRemoteMeshGitStatus(args) {
       if (!args.dispatchMeshCommand) return null;
       const remoteResult = await Promise.race([
-        args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace }),
+        args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace, refreshUpstream: true }),
         new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), args.timeoutMs))
       ]);
       const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
@@ -48164,6 +48166,81 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         };
       }
     }
+    async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
+      const startedAt = Date.now();
+      const entries = [];
+      try {
+        const { execFile: execFile3 } = await import("child_process");
+        const { promisify: promisify3 } = await import("util");
+        const execFileAsync3 = promisify3(execFile3);
+        const runGit2 = async (cwd, args) => {
+          const { stdout } = await execFileAsync3("git", args, {
+            cwd,
+            encoding: "utf8",
+            timeout: 3e4,
+            maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+            windowsHide: true
+          });
+          return String(stdout || "");
+        };
+        const treeOutput = await runGit2(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
+        const gitlinks = treeOutput.split("\0").filter(Boolean).map((record2) => {
+          const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record2);
+          return match ? { commit: match[1], path: match[2] } : null;
+        }).filter((entry) => !!entry);
+        for (const gitlink of gitlinks) {
+          const submodulePath = (0, import_path8.resolve)(repoRoot, gitlink.path);
+          const entry = {
+            path: gitlink.path,
+            commit: gitlink.commit,
+            reachable: false
+          };
+          try {
+            if (!fs10.existsSync(submodulePath)) {
+              entry.error = `Submodule checkout missing at ${gitlink.path}`;
+              entries.push(entry);
+              continue;
+            }
+            entry.checkedLocal = true;
+            try {
+              await runGit2(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
+              entry.reachable = true;
+              entries.push(entry);
+              continue;
+            } catch {
+            }
+            try {
+              await runGit2(submodulePath, ["fetch", "origin", gitlink.commit]);
+              entry.fetchedFromOrigin = true;
+              await runGit2(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
+              entry.reachable = true;
+            } catch (e) {
+              entry.error = truncateValidationOutput(e?.stderr || e?.message || String(e));
+            }
+          } catch (e) {
+            entry.error = truncateValidationOutput(e?.message || String(e));
+          }
+          entries.push(entry);
+        }
+        const unreachable = entries.filter((entry) => !entry.reachable);
+        return {
+          status: unreachable.length ? "failed" : "passed",
+          checked: entries.length,
+          unreachable,
+          entries,
+          durationMs: Date.now() - startedAt
+        };
+      } catch (e) {
+        return {
+          status: "failed",
+          checked: entries.length,
+          unreachable: entries.filter((entry) => !entry.reachable),
+          entries,
+          durationMs: Date.now() - startedAt,
+          error: truncateValidationOutput(e?.message || String(e))
+        };
+      }
+    }
     function buildMeshRefineValidationPlan(mesh, workspace) {
       const plan = resolveMeshRefineValidationPlan(mesh, workspace);
       return {
@@ -49272,6 +49349,37 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               }
             };
           }
+          const submoduleReachabilityStarted = Date.now();
+          const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead);
+          recordMeshRefineStage(refineStages, "submodule_reachability", submoduleReachability.status, submoduleReachabilityStarted, {
+            checked: submoduleReachability.checked,
+            unreachable: submoduleReachability.unreachable.map((entry) => ({ path: entry.path, commit: entry.commit, error: entry.error })),
+            error: submoduleReachability.error
+          });
+          if (submoduleReachability.status === "failed") {
+            return {
+              success: false,
+              code: "submodule_reachability_failed",
+              convergenceStatus: "blocked_review",
+              error: "Refinery submodule reachability preflight failed; merge/refine cleanup was not attempted.",
+              branch,
+              into: baseBranch,
+              validationSummary,
+              patchEquivalence,
+              submoduleReachability,
+              refineStages,
+              finalBranchConvergenceState: {
+                branch,
+                baseBranch,
+                merged: false,
+                removed: false,
+                validation: "passed",
+                patchEquivalence: "passed",
+                submoduleReachability: "failed",
+                status: "blocked_review"
+              }
+            };
+          }
           let mergeResult;
           const mergeStarted = Date.now();
           try {