@adhdev/daemon-standalone 1.0.58-rc.3 → 1.0.58-rc.4

package/dist/index.js

@@ -36831,10 +36831,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "789e0aa08f214c5b059b3d12eff74e412488db3b" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "789e0aa0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.3" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-23T01:04:20.549Z" : void 0);
+      const commit = readInjected(true ? "388d6e74b391ae9afd94d860aed141063297dca9" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "388d6e74" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.4" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-23T04:11:22.908Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -58268,6 +58268,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           "task_approval_needed",
           "task_question_pending",
           "p2p_dispatch_failed",
+          "dispatch_failed",
           "dispatch_duplicate_rebound",
           "queue_hold_hard_deadline"
         ]);
@@ -69057,6 +69058,146 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         CLASSIFIED_DIFFICULTIES = ["easy", "medium", "difficult"];
       }
     });
+    function normalizeProviderPriority2(policy) {
+      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
+      if (!Array.isArray(raw)) return [];
+      const seen = /* @__PURE__ */ new Set();
+      return raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
+        if (seen.has(type2)) return false;
+        seen.add(type2);
+        return true;
+      });
+    }
+    function isTerminalSessionStatus(status) {
+      return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
+    }
+    function isIdleSessionState3(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      if (isTerminalSessionStatus(status)) return false;
+      return status === "idle" || state?.activeChat?.status === "waiting_input";
+    }
+    function sessionStateLooksActive(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
+      const active = /* @__PURE__ */ new Set(["generating", "streaming", "no_progress", "long_generating", "working", "starting", "waiting_approval"]);
+      return active.has(status) || active.has(chatStatus);
+    }
+    function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
+      if (nodeHasActiveAssignment(meshId, nodeId)) return true;
+      return components.instanceManager.getByCategory("cli").some((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState3(state)) return false;
+        return sessionStateLooksActive(state);
+      });
+    }
+    function isLaunchableNode(node) {
+      if (!node || node.status === "disabled" || node.status === "removed") return false;
+      if (shouldDeferDispatchForBootstrap(node)) {
+        return false;
+      }
+      return isMeshNodeHealthLaunchable(node);
+    }
+    function isLocalAutoLaunchNode(node) {
+      const daemonId = readNonEmptyString(node?.daemonId);
+      const machineId = readNonEmptyString(node?.machineId);
+      const appConfig = loadConfig2();
+      const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
+      const daemonMatchesLocal = !daemonId || daemonIdsEquivalent(daemonId, localMachineId);
+      const machineMatchesLocal = !machineId || daemonIdsEquivalent(machineId, localMachineId);
+      if (node?.isLocalWorktree === true) {
+        return daemonMatchesLocal && machineMatchesLocal;
+      }
+      if (daemonId || machineId) {
+        return daemonMatchesLocal && machineMatchesLocal;
+      }
+      return true;
+    }
+    function isSessionActivelyGenerating(components, sessionId) {
+      if (!sessionId) return false;
+      const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+      if (!state) return false;
+      return sessionStateLooksActive(state);
+    }
+    function resolveSessionBusyVerdict(components, sessionId) {
+      if (!sessionId) return "UNKNOWN";
+      try {
+        const instances = components.instanceManager?.getByCategory?.("cli") || [];
+        const inst = instances.find((i) => {
+          const sid = readNonEmptyString(i?.getState?.().instanceId);
+          return sid && sessionIdsEquivalent(sid, sessionId);
+        });
+        if (!inst) return "UNKNOWN";
+        const state = inst.getState?.();
+        if (!state) return "UNKNOWN";
+        return sessionStateLooksActive(state) ? "GENERATING" : "IDLE_CONFIRMED";
+      } catch {
+        return "UNKNOWN";
+      }
+    }
+    function liveSessionCountForNode(components, meshId, nodeId) {
+      const localInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        return !isTerminalSessionStatus(status);
+      });
+      let count = localInstances.length;
+      const localSessionIds = localInstances.map((inst) => readNonEmptyString(inst.getState().instanceId)).filter(Boolean);
+      for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
+        if (!localSessionIds.some((local) => sessionIdsEquivalent(local, sid))) count += 1;
+      }
+      return count;
+    }
+    function nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node) {
+      if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
+      const busySessionIds = new Set(
+        getQueue(meshId, { status: ["assigned"] }).filter((task2) => daemonIdsEquivalent(task2.assignedNodeId, nodeId)).map((task2) => readNonEmptyString(task2.assignedSessionId)).filter(Boolean)
+      );
+      return components.instanceManager.getByCategory("cli").some((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        if (readNonEmptyString(settings.meshCoordinatorFor) === meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        if (isTerminalSessionStatus(status)) return false;
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (sessionId && busySessionIds.has(sessionId)) return false;
+        const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
+        if (task.requiredTags?.length) {
+          if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
+            return false;
+          }
+        }
+        const allowance = allowedClassifiedDifficultiesForSession(node, resolveNodeCapabilitySlots(node, meshId), sessionProviderType, readSessionModel(state));
+        if (!taskMeetsSessionDifficultyFloor(task, allowance)) return false;
+        return true;
+      });
+    }
+    var init_mesh_candidacy_predicates = __esm2({
+      "src/mesh/mesh-candidacy-predicates.ts"() {
+        "use strict";
+        init_config();
+        init_mesh_work_queue();
+        init_dist();
+        init_mesh_events_utils();
+        init_mesh_node_identity();
+        init_worktree_bootstrap_config();
+        init_mesh_autolaunch_integrity();
+        init_mesh_scheduling_fitness();
+        init_mesh_node_slots();
+        init_mesh_difficulty_floor();
+      }
+    });
     function localCoordinatorDaemonId2() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
@@ -69323,6 +69464,12 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
         try {
           appendLedgerEntry(ctx.meshId, {
+            // 'dispatch_failed' is a real MeshLedgerKind and a member of
+            // TASK_LIFECYCLE_LEDGER_KINDS, so appendLedgerEntry derives the top-level
+            // taskId from payload.taskId below. It spent its whole life as
+            // `as any` — off the union, hence off the lifecycle set, hence written to
+            // the indexed SQLite task_id column as NULL and unreachable by the
+            // kind+taskId join every reader uses. Do not reintroduce the cast.
             kind: "dispatch_failed",
             nodeId: ctx.nodeId,
             sessionId: ctx.sessionId,
@@ -69668,65 +69815,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (now >= until) autoLaunchCooldownUntil.delete(key2);
       }
     }
-    function normalizeProviderPriority2(policy) {
-      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
-      if (!Array.isArray(raw)) return [];
-      const seen = /* @__PURE__ */ new Set();
-      return raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
-        if (seen.has(type2)) return false;
-        seen.add(type2);
-        return true;
-      });
-    }
-    function isTerminalSessionStatus(status) {
-      return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
-    }
-    function isIdleSessionState3(state) {
-      const status = readNonEmptyString(state?.status).toLowerCase();
-      if (isTerminalSessionStatus(status)) return false;
-      return status === "idle" || state?.activeChat?.status === "waiting_input";
-    }
-    function sessionStateLooksActive(state) {
-      const status = readNonEmptyString(state?.status).toLowerCase();
-      const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
-      const active = /* @__PURE__ */ new Set(["generating", "streaming", "no_progress", "long_generating", "working", "starting", "waiting_approval"]);
-      return active.has(status) || active.has(chatStatus);
-    }
-    function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
-      if (nodeHasActiveAssignment(meshId, nodeId)) return true;
-      return components.instanceManager.getByCategory("cli").some((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const sessionId = readNonEmptyString(state.instanceId);
-        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState3(state)) return false;
-        return sessionStateLooksActive(state);
-      });
-    }
-    function isLaunchableNode(node) {
-      if (!node || node.status === "disabled" || node.status === "removed") return false;
-      if (shouldDeferDispatchForBootstrap(node)) {
-        return false;
-      }
-      return isMeshNodeHealthLaunchable(node);
-    }
-    function isLocalAutoLaunchNode(node) {
-      const daemonId = readNonEmptyString(node?.daemonId);
-      const machineId = readNonEmptyString(node?.machineId);
-      const appConfig = loadConfig2();
-      const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
-      const daemonMatchesLocal = !daemonId || daemonIdsEquivalent(daemonId, localMachineId);
-      const machineMatchesLocal = !machineId || daemonIdsEquivalent(machineId, localMachineId);
-      if (node?.isLocalWorktree === true) {
-        return daemonMatchesLocal && machineMatchesLocal;
-      }
-      if (daemonId || machineId) {
-        return daemonMatchesLocal && machineMatchesLocal;
-      }
-      return true;
-    }
     function resolveAutoLaunchTarget(components, node) {
       if (isLocalAutoLaunchNode(node)) return { mode: "local" };
       const daemonId = readMeshNodeDaemonId(node ?? {});
@@ -69736,72 +69824,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
       return { mode: "remote", daemonId, coordinatorDaemonId };
     }
-    function isSessionActivelyGenerating(components, sessionId) {
-      if (!sessionId) return false;
-      const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
-      if (!state) return false;
-      return sessionStateLooksActive(state);
-    }
-    function resolveSessionBusyVerdict(components, sessionId) {
-      if (!sessionId) return "UNKNOWN";
-      try {
-        const instances = components.instanceManager?.getByCategory?.("cli") || [];
-        const inst = instances.find((i) => {
-          const sid = readNonEmptyString(i?.getState?.().instanceId);
-          return sid && sessionIdsEquivalent(sid, sessionId);
-        });
-        if (!inst) return "UNKNOWN";
-        const state = inst.getState?.();
-        if (!state) return "UNKNOWN";
-        return sessionStateLooksActive(state) ? "GENERATING" : "IDLE_CONFIRMED";
-      } catch {
-        return "UNKNOWN";
-      }
-    }
-    function liveSessionCountForNode(components, meshId, nodeId) {
-      const localInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const status = readNonEmptyString(state.status).toLowerCase();
-        return !isTerminalSessionStatus(status);
-      });
-      let count = localInstances.length;
-      const localSessionIds = localInstances.map((inst) => readNonEmptyString(inst.getState().instanceId)).filter(Boolean);
-      for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
-        if (!localSessionIds.some((local) => sessionIdsEquivalent(local, sid))) count += 1;
-      }
-      return count;
-    }
-    function nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node) {
-      if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
-      const busySessionIds = new Set(
-        getQueue(meshId, { status: ["assigned"] }).filter((task2) => daemonIdsEquivalent(task2.assignedNodeId, nodeId)).map((task2) => readNonEmptyString(task2.assignedSessionId)).filter(Boolean)
-      );
-      return components.instanceManager.getByCategory("cli").some((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        if (readNonEmptyString(settings.meshCoordinatorFor) === meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const status = readNonEmptyString(state.status).toLowerCase();
-        if (isTerminalSessionStatus(status)) return false;
-        const sessionId = readNonEmptyString(state.instanceId);
-        if (sessionId && busySessionIds.has(sessionId)) return false;
-        const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
-        if (task.requiredTags?.length) {
-          if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
-            return false;
-          }
-        }
-        const allowance = allowedClassifiedDifficultiesForSession(node, resolveNodeCapabilitySlots(node, meshId), sessionProviderType, readSessionModel(state));
-        if (!taskMeetsSessionDifficultyFloor(task, allowance)) return false;
-        return true;
-      });
-    }
     function markAutoLaunch(meshId, taskId, args) {
       const reason = args.reason || args.error;
       const difficultyFloorSkip = args.status === "skipped" && isDifficultyFloorWaitReason(reason);
@@ -70541,6 +70563,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_routing_decision();
         init_mesh_autolaunch_integrity();
         init_mesh_difficulty_floor();
+        init_mesh_candidacy_predicates();
         init_mesh_difficulty_floor();
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
@@ -81644,6 +81667,49 @@ ${cleanBody}`;
       }
       return false;
     }
+    function probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
+      if (!baseCommit || !branchCommit) return "undeterminable";
+      if (baseCommit === branchCommit) return true;
+      return probeGitAncestry(submoduleRepoPath, baseCommit, branchCommit);
+    }
+    function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
+      return probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) === true;
+    }
+    function buildGitlinkFastForwardUndeterminableWarning(label, gitlinks) {
+      const entries = gitlinks.filter((entry) => entry.fastForwardUndeterminable);
+      if (entries.length === 0) return void 0;
+      const detail = entries.map((entry) => `${entry.path} (base=${(entry.baseCommit || "?").slice(0, 12)} branch=${(entry.branchCommit || "?").slice(0, 12)})`).join(", ");
+      return `[Refinery] Could NOT determine submodule gitlink fast-forward for ${label} \u2014 ancestry probe had NO ANSWER (a gitlink commit is missing from the local submodule object store, or the submodule checkout is absent). "undeterminable", NOT "diverged": ${detail}`;
+    }
+    function warnGitlinkFastForwardUndeterminable(label, gitlinks) {
+      const message = buildGitlinkFastForwardUndeterminableWarning(label, gitlinks);
+      if (message) LOG2.warn("Mesh", message);
+    }
+    function readChangedPathKinds(repoRoot, fromRef, toRef) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+        });
+        const result = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const metaAndPath = line.split("	");
+          const meta3 = metaAndPath[0] || "";
+          const path60 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path60 || seen.has(path60)) continue;
+          seen.add(path60);
+          const parts = meta3.split(/\s+/);
+          const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
+          result.push({ path: path60, isGitlink });
+        }
+        return result;
+      } catch {
+        return [];
+      }
+    }
     var fs51;
     var import_node_child_process11;
     var import_path17;
@@ -81729,7 +81795,16 @@ ${cleanBody}`;
       }
       return void 0;
     }
-    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
+    function isCommitReachableFromRemoteMain(submoduleRepoPath, commit, remoteMainRef) {
+      if (!remoteMainRef) return false;
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", commit, remoteMainRef], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead, options = {}) {
       const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
       if (changed.length === 0) {
         return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
@@ -81781,6 +81856,30 @@ ${cleanBody}`;
           resolutions.push({ path: path60, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
           continue;
         }
+        const branchAlreadyPublished = isCommitReachableFromRemoteMain(submoduleRepoPath, branchCommit, remoteMainRef);
+        const willMintUnpublishedCommit = !branchAlreadyPublished;
+        const wouldConflict = (() => {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+              cwd: submoduleRepoPath,
+              encoding: "utf8",
+              stdio: ["ignore", "pipe", "pipe"]
+            });
+            return false;
+          } catch {
+            return true;
+          }
+        })();
+        if (willMintUnpublishedCommit && !wouldConflict && options.allowAutoPublishSubmoduleMainCommits !== true) {
+          gitlinks.push({
+            path: path60,
+            baseCommit,
+            branchCommit,
+            action: "publish_required_before_rebase",
+            remoteMainRef
+          });
+          return { converged: false, reason: "submodule_publish_required", resolutions: [], gitlinks };
+        }
         let rebasedCommit;
         try {
           (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
@@ -81820,7 +81919,14 @@ ${cleanBody}`;
           gitlinks.push({ path: path60, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
           return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
         }
-        gitlinks.push({ path: path60, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
+        gitlinks.push({
+          path: path60,
+          baseCommit,
+          branchCommit,
+          rebasedCommit,
+          action: "rebased",
+          ...willMintUnpublishedCommit ? { mintedUnpublishedCommit: true, remoteMainRef } : {}
+        });
         resolutions.push({ path: path60, baseCommit, branchCommit, rebasedCommit });
       }
       if (!sawDiverged) {
@@ -81829,6 +81935,31 @@ ${cleanBody}`;
       }
       return { converged: resolutions.length > 0, resolutions, gitlinks };
     }
+    function describeSubmodulePublishRequired(nodeId, gitlinks) {
+      const pending = gitlinks.filter((g) => g.action === "publish_required_before_rebase");
+      return `[Refinery] Refusing to auto-converge diverged submodule gitlink(s) for node ${nodeId} \u2014 the rebase would create a NEW submodule commit that is not reachable from the submodule remote, and allowAutoPublishSubmoduleMainCommits is disabled, so the reachability gate would reject it. The branch was left untouched. NEXT STEP: publish the branch-side submodule commit(s) to submodule origin main, then rerun mesh_refine_node \u2014 do NOT rebase: ` + pending.map((g) => `${g.path} (branch=${(g.branchCommit || "?").slice(0, 12)} base=${(g.baseCommit || "?").slice(0, 12)} remote=${g.remoteMainRef || "unresolved"})`).join(", ");
+    }
+    function describeSubmoduleConvergeDecline(nodeId, reason, gitlinks) {
+      if (reason === "submodule_publish_required") {
+        return describeSubmodulePublishRequired(nodeId, gitlinks);
+      }
+      if (reason === "submodule_commit_unavailable") {
+        return `[Refinery] Could NOT determine submodule gitlink divergence for node ${nodeId} \u2014 a gitlink commit is missing from the local submodule object store (auto-converge could not run): ` + gitlinks.filter((g) => g.action === "skipped_commit_unavailable").map((g) => `${g.path} (missing: ${(g.unavailable || []).join("+") || "unknown"}; base=${(g.baseCommit || "?").slice(0, 12)} branch=${(g.branchCommit || "?").slice(0, 12)})`).join(", ");
+      }
+      return void 0;
+    }
+    function buildSubmoduleConvergeDeclineDetails(reason, autoPublishEnabled) {
+      if (reason !== "submodule_publish_required") return {};
+      return {
+        recommendedAction: SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION,
+        autoPublishAllowed: autoPublishEnabled
+      };
+    }
+    function describeMintedUnpublishedCommits(nodeId, gitlinks, autoPublishEnabled) {
+      const minted = gitlinks.filter((g) => g.mintedUnpublishedCommit);
+      if (minted.length === 0) return void 0;
+      return `[Refinery] Node ${nodeId}: the convergence MINTED ${minted.length} new submodule commit(s) not reachable from the submodule remote (allowed because allowAutoPublishSubmoduleMainCommits=${autoPublishEnabled}); a publish is still required before merge: ` + minted.map((g) => `${g.path}\u2192${(g.rebasedCommit || "?").slice(0, 12)} (remote=${g.remoteMainRef || "unresolved"})`).join(", ");
+    }
     function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
       const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
       const runRebase = (args) => {
@@ -81910,6 +82041,7 @@ ${cleanBody}`;
     var fs52;
     var import_path18;
     var import_node_child_process12;
+    var SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION;
     var init_mesh_refine_submodule_converge = __esm2({
       "src/mesh/mesh-refine-submodule-converge.ts"() {
         "use strict";
@@ -81917,6 +82049,7 @@ ${cleanBody}`;
         import_path18 = require("path");
         import_node_child_process12 = require("child_process");
         init_mesh_refine_gitlink_utils();
+        SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION = "Publish the branch-side submodule commit(s) to submodule origin main, then rerun mesh_refine_node. Do NOT retry the rebase: the branch was intentionally left unrewritten because a rebase here would mint a submodule commit the reachability gate must reject.";
       }
     });
     function truncateValidationOutput(value) {
@@ -82059,6 +82192,7 @@ ${mergeTreeErr?.stderr || ""}`;
           if (!isSubmoduleConflict) throw mergeTreeErr;
           const evaluation = evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead);
           if (!evaluation.trivial) {
+            warnGitlinkFastForwardUndeterminable("patch-equivalence gate", evaluation.gitlinks);
             return {
               status: "failed",
               equivalent: false,
@@ -82152,14 +82286,6 @@ ${e?.stderr || ""}`
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
           windowsHide: true
         });
-        const gitOk = (args) => {
-          try {
-            git3(args);
-            return true;
-          } catch {
-            return false;
-          }
-        };
         let ahead = 0;
         let behind = 0;
         try {
@@ -82171,8 +82297,13 @@ ${e?.stderr || ""}`
         }
         evidence.ahead = ahead;
         evidence.behind = behind;
-        const baseIsAncestor = gitOk(["merge-base", "--is-ancestor", targetBaseRef, branchHead]);
-        evidence.baseDiverged = !baseIsAncestor;
+        const baseAncestry = probeGitAncestry(repoRoot, targetBaseRef, branchHead);
+        const baseIsAncestor = baseAncestry === true;
+        if (baseAncestry === "undeterminable") {
+          evidence.baseAncestryUndeterminable = true;
+        } else {
+          evidence.baseDiverged = !baseAncestry;
+        }
         let diffStat = "";
         try {
           if (summary.mergedTree) {
@@ -82253,6 +82384,14 @@ ${e?.stderr || ""}`
             evidence
           };
         }
+        if (baseAncestry === "undeterminable") {
+          return {
+            detailedReason: "base_ancestry_undeterminable",
+            detailedReasonDescription: `Could NOT determine whether HEAD descends ${targetBaseRef} \u2014 the ancestry probe had no answer (${targetBaseRef} and/or ${branchHead.slice(0, 12)} does not resolve in ${repoRoot}). This is "undeterminable", NOT "diverged": the ahead/behind counts above are unmeasured, not zero.`,
+            recommendedAction: `Make the probe answerable before judging: fetch/verify that ${targetBaseRef} and the branch head both resolve in ${repoRoot} (e.g. git fetch origin, git rev-parse --verify), then retry mesh_refine_node. Do NOT rebase on the strength of this result \u2014 no divergence has been measured.`,
+            evidence
+          };
+        }
         if (!baseIsAncestor) {
           return {
             detailedReason: "base_divergence",
@@ -82298,6 +82437,7 @@ ${mergeTreeErr?.stderr || ""}`;
           if (!isSubmoduleConflict) throw mergeTreeErr;
           const evaluation = evaluateGitlinkTrivialFastForward(repoRoot, ref, worktreeHead);
           if (!evaluation.trivial) {
+            warnGitlinkFastForwardUndeterminable(`containment check for ${ref}`, evaluation.gitlinks);
             return {
               contained: false,
               ref,
@@ -82427,44 +82567,6 @@ ${mergeTreeErr?.stderr || ""}`;
       }).trim();
       return out;
     }
-    function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
-      if (!baseCommit || !branchCommit) return false;
-      if (baseCommit === branchCommit) return true;
-      try {
-        if (!fs53.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    function readChangedPathKinds(repoRoot, fromRef, toRef) {
-      try {
-        const output = (0, import_node_child_process13.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
-        });
-        const result = [];
-        const seen = /* @__PURE__ */ new Set();
-        for (const line of output.split("\n")) {
-          if (!line.trim()) continue;
-          const metaAndPath = line.split("	");
-          const meta3 = metaAndPath[0] || "";
-          const path60 = metaAndPath[metaAndPath.length - 1]?.trim();
-          if (!path60 || seen.has(path60)) continue;
-          seen.add(path60);
-          const parts = meta3.split(/\s+/);
-          const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
-          result.push({ path: path60, isGitlink });
-        }
-        return result;
-      } catch {
-        return [];
-      }
-    }
     function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
       return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path60) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path60);
@@ -82497,19 +82599,27 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path60);
         const branchCommit = readTreeObject(repoRoot, branchHead, path60);
         const submoduleRepoPath = (0, import_path19.resolve)(repoRoot, path60);
-        const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
-        return { path: path60, baseCommit, branchCommit, fastForward };
+        const probe = !!baseCommit && !!branchCommit ? probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) : "undeterminable";
+        return {
+          path: path60,
+          baseCommit,
+          branchCommit,
+          fastForward: probe === true,
+          ...probe === "undeterminable" ? { fastForwardUndeterminable: true } : {}
+        };
       });
       if (changedGitlinks.length === 0) {
         return { trivial: false, reason: "no_changed_gitlinks", gitlinks: changedGitlinks };
       }
-      const nonFastForward = changedGitlinks.filter((entry) => !entry.fastForward);
-      if (nonFastForward.length > 0) {
-        return {
-          trivial: false,
-          reason: `diverged_gitlinks:${nonFastForward.map((entry) => entry.path).join(",")}`,
-          gitlinks: changedGitlinks
-        };
+      const undeterminable = changedGitlinks.filter((entry) => entry.fastForwardUndeterminable);
+      const diverged = changedGitlinks.filter((entry) => !entry.fastForward && !entry.fastForwardUndeterminable);
+      if (undeterminable.length > 0 || diverged.length > 0) {
+        const parts = [];
+        if (diverged.length > 0) parts.push(`diverged_gitlinks:${diverged.map((entry) => entry.path).join(",")}`);
+        if (undeterminable.length > 0) {
+          parts.push(`undeterminable_gitlinks:${undeterminable.map((entry) => entry.path).join(",")}`);
+        }
+        return { trivial: false, reason: parts.join(" "), gitlinks: changedGitlinks };
       }
       let mergeBase = "";
       try {
@@ -83235,6 +83345,7 @@ ${mergeTreeErr?.stderr || ""}`;
         init_mesh_refine_worker_cap();
         init_mesh_refine_gitlink_utils();
         init_mesh_refine_submodule_converge();
+        init_mesh_refine_gitlink_utils();
         REFINE_VALIDATION_TIMEOUT_MS = 12e4;
         REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
         REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
@@ -84224,7 +84335,14 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
           return { kind: "continue", ctx };
         }
         if (submoduleConflict) {
-          const converge = convergeDivergedSubmoduleGitlinks(node.workspace, repoRoot, baseHead, branchHead);
+          const convergeAutoPublish = resolveRefineryAutoPublishSubmoduleMainCommits(ctx.mesh, node.workspace);
+          const converge = convergeDivergedSubmoduleGitlinks(
+            node.workspace,
+            repoRoot,
+            baseHead,
+            branchHead,
+            { allowAutoPublishSubmoduleMainCommits: convergeAutoPublish.enabled }
+          );
           if (converge.converged) {
             gitlinkResolutions = converge.resolutions;
             recordMeshRefineStage(refineStages, "submodule_gitlink_converge", "passed", syncStarted, {
@@ -84232,15 +84350,19 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
               gitlinks: converge.gitlinks
             });
             LOG2.info("Mesh", `[Refinery] Auto-converged diverged submodule gitlink(s) onto base for node ${node.id}: ` + converge.resolutions.map((r) => `${r.path}\u2192${r.rebasedCommit.slice(0, 12)}`).join(", "));
+            const minted = describeMintedUnpublishedCommits(node.id, converge.gitlinks, convergeAutoPublish.enabled);
+            if (minted) LOG2.warn("Mesh", minted);
           } else {
             recordMeshRefineStage(refineStages, "submodule_gitlink_converge", "skipped", syncStarted, {
               reason: "submodule_conflict_defer_to_patch_equivalence",
               convergeReason: converge.reason,
-              gitlinks: converge.gitlinks
+              gitlinks: converge.gitlinks,
+              // ★Structural next step, so the coordinator is told to PUBLISH
+              // rather than retry the rebase (retrying re-mints the orphan).
+              ...buildSubmoduleConvergeDeclineDetails(converge.reason, convergeAutoPublish.enabled)
             });
-            if (converge.reason === "submodule_commit_unavailable") {
-              LOG2.warn("Mesh", `[Refinery] Could NOT determine submodule gitlink divergence for node ${node.id} \u2014 a gitlink commit is missing from the local submodule object store (auto-converge could not run): ` + converge.gitlinks.filter((g) => g.action === "skipped_commit_unavailable").map((g) => `${g.path} (missing: ${(g.unavailable || []).join("+") || "unknown"}; base=${(g.baseCommit || "?").slice(0, 12)} branch=${(g.branchCommit || "?").slice(0, 12)})`).join(", "));
-            }
+            const declined = describeSubmoduleConvergeDecline(node.id, converge.reason, converge.gitlinks);
+            if (declined) LOG2.warn("Mesh", declined);
             recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
               ahead: divergence.ahead,
               behind: divergence.behind,
@@ -122246,14 +122368,14 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         let daemonId;
         if (nodeId) {
           try {
-            const [{ getMesh: getMesh2 }, { meshNodeIdMatches: meshNodeIdMatches2 }, { readMeshNodeDaemonId: readMeshNodeDaemonId2 }] = await Promise.all([
+            const [{ getMesh: getMesh2 }, { meshNodeIdMatches: meshNodeIdMatches2 }, { readMeshNodeDaemonId: readMeshNodeDaemonId3 }] = await Promise.all([
               Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)),
               Promise.resolve().then(() => (init_dist(), dist_exports)),
               Promise.resolve().then(() => (init_mesh_node_identity(), mesh_node_identity_exports))
             ]);
             const mesh = getMesh2(meshId);
             const node = mesh?.nodes?.find((n) => meshNodeIdMatches2(n, nodeId));
-            daemonId = node ? readMeshNodeDaemonId2(node) || void 0 : void 0;
+            daemonId = node ? readMeshNodeDaemonId3(node) || void 0 : void 0;
           } catch {
           }
         }