@adhdev/daemon-core 0.9.82-rc.65 → 0.9.82-rc.66

package/dist/index.mjs

@@ -25941,6 +25941,81 @@ async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead)
     };
   }
 }
+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((record) => {
+      const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record);
+      return match ? { commit: match[1], path: match[2] } : null;
+    }).filter((entry) => !!entry);
+    for (const gitlink of gitlinks) {
+      const submodulePath = pathResolve(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 {
@@ -27049,6 +27124,37 @@ var DaemonCommandRouter = class {
           }
         };
       }
+      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 {