@adhdev/daemon-standalone 1.0.45-rc.8 → 1.0.45-rc.9

package/dist/index.js

@@ -37027,10 +37027,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "d95b1439eb1b062960654db2dd2d523a0831d1eb" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "d95b1439" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.45-rc.8" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-12T15:27:41.488Z" : void 0);
+      const commit = readInjected(true ? "6a45bfebc577345264d61b02a71a657bbc313033" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "6a45bfeb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.45-rc.9" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-13T03:05:02.343Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -40041,6 +40041,13 @@ child.on('exit', () => process.exit(0));
         metadata: { source: "oauth" }
       };
     }
+    async function readErrorBody(response) {
+      try {
+        return await response.text?.() ?? "";
+      } catch {
+        return "";
+      }
+    }
     function retryAfterMs(header, nowMs) {
       if (!header) {
         return void 0;
@@ -40084,11 +40091,28 @@ child.on('exit', () => process.exit(0));
           },
           signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
         });
-        if (response.status === 401 || response.status === 403) {
+        if (response.status === 401) {
+          return quotaFailure(
+            "kimi",
+            "error",
+            "Kimi usage request was rejected (HTTP 401)",
+            { source: "oauth", failureKind: "unauthorized" }
+          );
+        }
+        if (response.status === 403) {
+          const body = await readErrorBody(response);
+          if (USAGE_LIMIT_BODY_PATTERN.test(body)) {
+            return quotaFailure(
+              "kimi",
+              "error",
+              "Kimi usage limit reached (HTTP 403) \u2014 quota refreshes at the next reset/billing cycle",
+              { source: "oauth", failureKind: "quota-exhausted" }
+            );
+          }
           return quotaFailure(
             "kimi",
             "error",
-            `Kimi usage request was rejected (HTTP ${response.status})`,
+            "Kimi usage request was rejected (HTTP 403)",
             { source: "oauth", failureKind: "unauthorized" }
           );
         }
@@ -40122,6 +40146,7 @@ child.on('exit', () => process.exit(0));
     var DEFAULT_BASE_URL;
     var REQUEST_TIMEOUT_MS2;
     var EXPIRY_SKEW_SECONDS;
+    var USAGE_LIMIT_BODY_PATTERN;
     var init_kimi = __esm2({
       "src/quota/fetchers/kimi.ts"() {
         "use strict";
@@ -40133,6 +40158,7 @@ child.on('exit', () => process.exit(0));
         DEFAULT_BASE_URL = "https://api.kimi.com/coding/v1";
         REQUEST_TIMEOUT_MS2 = 1e4;
         EXPIRY_SKEW_SECONDS = 5;
+        USAGE_LIMIT_BODY_PATTERN = /usage limit|quota\s*(exhausted|refresh)|billing cycle/i;
       }
     });
     function opencodeCommand(env2) {
@@ -60592,7 +60618,17 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const entry = quotaEntryFor(node, providerType);
       if (!entry) return null;
       const { facts, quota } = entry;
-      if (quota.status !== "ok") return null;
+      if (quota.status !== "ok") {
+        if (quota.status === "error" && quota.metadata?.failureKind === "quota-exhausted" && isQuotaSnapshotFresh(facts, quota, policy, now)) {
+          return {
+            reason: PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON,
+            window: "unknown",
+            remainingPercent: 0,
+            thresholdPercent: 0
+          };
+        }
+        return null;
+      }
       if (!isQuotaSnapshotFresh(facts, quota, policy, now)) return null;
       const resolved = resolveQuotaRoutingPolicy(policy);
       const session = remainingPercent(quota.session);
@@ -60637,12 +60673,14 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     }
     var PROVIDER_QUOTA_SESSION_LOW_SKIP_REASON;
     var PROVIDER_QUOTA_WEEKLY_LOW_SKIP_REASON;
+    var PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON;
     var init_mesh_quota_routing = __esm2({
       "src/mesh/mesh-quota-routing.ts"() {
         "use strict";
         init_repo_mesh_types();
         PROVIDER_QUOTA_SESSION_LOW_SKIP_REASON = "provider_quota_session_low";
         PROVIDER_QUOTA_WEEKLY_LOW_SKIP_REASON = "provider_quota_weekly_low";
+        PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON = "provider_quota_exhausted";
       }
     });
     function isAnthropicProvider(providerType) {
@@ -61212,10 +61250,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           // busy counterpart SLOT_MODEL_BUSY_SKIP_REASON is deliberately NOT listed:
           // that one clears on its own when the slot goes idle.
           SLOT_MODEL_ABSENT_SKIP_REASON
-          // QUOTA GATE: 'provider_quota_session_low' / 'provider_quota_weekly_low' are
-          // deliberately NOT listed either — an exhausted quota window RESETS, so the
-          // block self-resolves exactly like the slot-busy case; the task waits in the
-          // queue and the coordinator is not paged (mesh-quota-routing.ts).
+          // QUOTA GATE: 'provider_quota_session_low' / 'provider_quota_weekly_low' /
+          // 'provider_quota_exhausted' are deliberately NOT listed either — an
+          // exhausted quota window RESETS, so the block self-resolves exactly like
+          // the slot-busy case; the task waits in the queue and the coordinator is
+          // not paged (mesh-quota-routing.ts).
         ];
         TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON = "target_node_bootstrap_pending";
         lastActionableSkipNotified = /* @__PURE__ */ new Map();
@@ -61720,7 +61759,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null);
       if (quotaClaimBlock) {
-        LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${nodeId} (${sessionId}): provider '${providerType}' has ${quotaClaimBlock.remainingPercent.toFixed(1)}% ${quotaClaimBlock.window} quota remaining (< ${quotaClaimBlock.thresholdPercent}% threshold) \u2014 task left pending until the window resets`);
+        if (quotaClaimBlock.reason === PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON) {
+          LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${nodeId} (${sessionId}): provider '${providerType}' reported its quota EXHAUSTED \u2014 task left pending until the quota resets`);
+        } else {
+          LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${nodeId} (${sessionId}): provider '${providerType}' has ${quotaClaimBlock.remainingPercent.toFixed(1)}% ${quotaClaimBlock.window} quota remaining (< ${quotaClaimBlock.thresholdPercent}% threshold) \u2014 task left pending until the window resets`);
+        }
         return false;
       }
       const inlineBootstrapNode = (() => {
@@ -62465,7 +62508,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             }
             const quotaBlock = evaluateProviderQuotaGate(node, resolved.providerType, mesh?.policy?.quotaRouting ?? null);
             if (quotaBlock) {
-              LOG2.info("MeshQueue", `QUOTA GATE: provider '${resolved.providerType}' on node ${nodeId} has ${quotaBlock.remainingPercent.toFixed(1)}% ${quotaBlock.window} quota remaining (< ${quotaBlock.thresholdPercent}% threshold, task ${task.id}); leaving the task queued until the window resets`);
+              if (quotaBlock.reason === PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON) {
+                LOG2.info("MeshQueue", `QUOTA GATE: provider '${resolved.providerType}' on node ${nodeId} reported its quota EXHAUSTED (task ${task.id}); leaving the task queued until the quota resets`);
+              } else {
+                LOG2.info("MeshQueue", `QUOTA GATE: provider '${resolved.providerType}' on node ${nodeId} has ${quotaBlock.remainingPercent.toFixed(1)}% ${quotaBlock.window} quota remaining (< ${quotaBlock.thresholdPercent}% threshold, task ${task.id}); leaving the task queued until the window resets`);
+              }
               markSkip(nodeId, quotaBlock.reason, { providerType: resolved.providerType });
               continue;
             }
@@ -75563,6 +75610,9 @@ ${cont}` : cont;
     var import_session_host_core8;
     var missingBackgroundSourceWarned;
     var FORCE_SUBMIT_SETTLE_MS;
+    var WIN32_INJECT_ENTER_MAX_RETRIES;
+    var WIN32_INJECT_ENTER_RETRY_DELAY_MS;
+    var WIN32_INJECT_COMPOSER_TAIL_LINES;
     var ProviderCliAdapter;
     var init_provider_cli_adapter = __esm2({
       "src/cli-adapters/provider-cli-adapter.ts"() {
@@ -75589,6 +75639,9 @@ ${cont}` : cont;
         init_provider_cli_shared();
         missingBackgroundSourceWarned = /* @__PURE__ */ new Set();
         FORCE_SUBMIT_SETTLE_MS = 150;
+        WIN32_INJECT_ENTER_MAX_RETRIES = 2;
+        WIN32_INJECT_ENTER_RETRY_DELAY_MS = 300;
+        WIN32_INJECT_COMPOSER_TAIL_LINES = 8;
         ProviderCliAdapter = class _ProviderCliAdapter {
           constructor(provider, workingDir, extraArgs = [], extraEnv = {}, transportFactory = new NodePtyTransportFactory(), owningSessionId) {
             this.extraArgs = extraArgs;
@@ -75736,6 +75789,9 @@ ${cont}` : cont;
           pendingOutboundStaleTimer = null;
           // Submit retry timer — PTY-level, not state machine
           submitRetryTimer = null;
+          // WIN32-INJECT-ENTER-RETRY: pending bare-ENTER resend for a mesh_send_keys
+          // injection whose submit may have been swallowed by win32 ConPTY.
+          injectEnterRetryTimer = null;
           // PTY-WRITE-SERIALIZE: a single per-session tail promise that serializes every
           // PTY write. Each writeToPty() call chains its actual write after the previous
           // one and returns a promise that resolves only after ITS write completes, so
@@ -76295,6 +76351,10 @@ ${lastSnapshot}`;
               clearTimeout(this.submitRetryTimer);
               this.submitRetryTimer = null;
             }
+            if (this.injectEnterRetryTimer) {
+              clearTimeout(this.injectEnterRetryTimer);
+              this.injectEnterRetryTimer = null;
+            }
             if (this.pendingOutputParseTimer) {
               clearTimeout(this.pendingOutputParseTimer);
               this.pendingOutputParseTimer = null;
@@ -77109,6 +77169,10 @@ ${lastSnapshot}`;
               clearTimeout(this.submitRetryTimer);
               this.submitRetryTimer = null;
             }
+            if (this.injectEnterRetryTimer) {
+              clearTimeout(this.injectEnterRetryTimer);
+              this.injectEnterRetryTimer = null;
+            }
             this.engine.onTurnStarted(turnScope);
             this.engine.submitRetryPromptSnippet = extractPromptRetrySnippet(text);
             const normalizedPromptSnippet = normalizePromptText(this.engine.submitRetryPromptSnippet);
@@ -77672,7 +77736,17 @@ ${lastSnapshot}`;
               LOG2.warn("CLI", `[${this.cliType}] send_keys refused (actionable_modal): keys=${encoded.keys.join(",")} \u2014 use mesh_approve`);
               return { ok: false, refused: "actionable_modal", keys: encoded.keys, hasDestructive: encoded.hasDestructive };
             }
+            if (this.injectEnterRetryTimer) {
+              clearTimeout(this.injectEnterRetryTimer);
+              this.injectEnterRetryTimer = null;
+            }
             await this.writeToPty(encoded.sequence);
+            if (process.platform === "win32" && encoded.submits) {
+              const snippet2 = extractPromptRetrySnippet(
+                items.map((it) => "text" in it ? it.text : "").join("\n")
+              );
+              if (snippet2) this.scheduleWin32InjectEnterRetry(snippet2, 1);
+            }
             LOG2.info("CLI", `[${this.cliType}] send_keys injected keys=${encoded.keys.join(",") || "(text-only)"} bytes=${Buffer.byteLength(encoded.sequence, "utf8")} destructive=${encoded.hasDestructive}`);
             return {
               ok: true,
@@ -77689,6 +77763,30 @@ ${lastSnapshot}`;
             const str2 = Buffer.isBuffer(data) ? data.toString("utf8") : data;
             await this.writeToPty(str2);
           }
+          /**
+           * WIN32-INJECT-ENTER-RETRY: resend the bare submit key while the injected
+           * text still stands in the composer (bottom viewport lines). Stops the
+           * instant the text leaves that region — proof the submit was consumed —
+           * so a delayed (not lost) original ENTER is never doubled. Bounded by
+           * WIN32_INJECT_ENTER_MAX_RETRIES; see the constants' comment for the
+           * rationale. Never logs the snippet (it is user text).
+           */
+          scheduleWin32InjectEnterRetry(snippet2, attempt) {
+            this.injectEnterRetryTimer = setTimeout(() => {
+              this.injectEnterRetryTimer = null;
+              if (!this.ptyProcess) return;
+              const screenLines = this.terminalScreen.getText().split("\n");
+              const composerRegion = screenLines.slice(-WIN32_INJECT_COMPOSER_TAIL_LINES).join("\n");
+              if (!promptLikelyVisible(composerRegion, snippet2)) return;
+              LOG2.info("CLI", `[${this.cliType}] send_keys ENTER retry (attempt ${attempt}/${WIN32_INJECT_ENTER_MAX_RETRIES}): injected text still in composer`);
+              void this.writeToPty(MESH_SEND_KEY_ENCODING.ENTER).catch((error48) => {
+                LOG2.warn("CLI", `[${this.cliType}] send_keys ENTER retry write failed: ${error48?.message || error48}`);
+              });
+              if (attempt < WIN32_INJECT_ENTER_MAX_RETRIES) {
+                this.scheduleWin32InjectEnterRetry(snippet2, attempt + 1);
+              }
+            }, WIN32_INJECT_ENTER_RETRY_DELAY_MS);
+          }
           resolveModal(buttonIndex) {
             this.engine.resolveModal(buttonIndex);
           }
@@ -113434,8 +113532,19 @@ ${asText(streams.stderr)}
       });
     }
     function buildSubmodulePublishRequiredNextStep(entries) {
-      const refs = entries.map((entry) => `${entry.path}@${entry.commit}`).join(", ");
-      return `Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to the configured submodule remote main branch, then rerun mesh_refine_node. Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.`;
+      const convergeable = entries.filter((entry) => entry.equivalentPublishedCommit);
+      const publishable = entries.filter((entry) => !entry.equivalentPublishedCommit);
+      const parts = [];
+      if (convergeable.length > 0) {
+        const refs = convergeable.map((entry) => `${entry.path}: ${entry.commit} \u2192 ${entry.equivalentPublishedCommit}`).join(", ");
+        parts.push(`Converge the submodule gitlink(s) to the already-published equivalent commit(s) (${refs}): a commit with an identical tree already exists on the submodule remote main branch, so publishing the local same-content twin is wrong. Retarget the gitlink to the published commit, commit the root pointer update, then rerun mesh_refine_node.`);
+      }
+      if (publishable.length > 0) {
+        const refs = publishable.map((entry) => `${entry.path}@${entry.commit}`).join(", ");
+        parts.push(`Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to the configured submodule remote main branch, then rerun mesh_refine_node.`);
+      }
+      parts.push("Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.");
+      return parts.join(" ");
     }
     function resolveRefineryAutoPublishSubmoduleMainCommits(mesh, workspace) {
       if (mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true) {
@@ -113989,6 +114098,47 @@ ${mergeTreeErr?.stderr || ""}`;
         return false;
       }
     }
+    function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
+      try {
+        const sym = (0, import_node_child_process9.execFileSync)(GIT3, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        if (sym) return sym;
+      } catch {
+      }
+      for (const branch of ["main", "master"]) {
+        try {
+          (0, import_node_child_process9.execFileSync)(GIT3, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          return `refs/remotes/origin/${branch}`;
+        } catch {
+        }
+      }
+      return void 0;
+    }
+    function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
+      try {
+        const mergeTreeOut = (0, import_node_child_process9.execFileSync)(GIT3, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const mergedTree = mergeTreeOut.trim().split(/\s+/)[0] || "";
+        if (!mergedTree) return void 0;
+        const candidates = (0, import_node_child_process9.execFileSync)(GIT3, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8"
+        }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        for (const candidate of candidates) {
+          try {
+            (0, import_node_child_process9.execFileSync)(GIT3, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+            continue;
+          }
+          const tree = (0, import_node_child_process9.execFileSync)(GIT3, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+          if (tree === mergedTree) return candidate;
+        }
+      } catch {
+      }
+      return void 0;
+    }
     function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
       if (!commit) return;
       try {
@@ -114025,6 +114175,21 @@ ${mergeTreeErr?.stderr || ""}`;
           continue;
         }
         sawDiverged = true;
+        try {
+          (0, import_node_child_process9.execFileSync)(GIT3, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+        } catch {
+        }
+        const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
+        const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
+        if (publishedEquivalent) {
+          try {
+            (0, import_node_child_process9.execFileSync)(GIT3, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          } catch {
+          }
+          gitlinks.push({ path: path54, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
+          resolutions.push({ path: path54, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
+          continue;
+        }
         let rebasedCommit;
         try {
           (0, import_node_child_process9.execFileSync)(GIT3, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
@@ -114422,6 +114587,19 @@ ${mergeTreeErr?.stderr || ""}`;
           await runGit3(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           return true;
         };
+        const findEquivalentPublishedCommit = async (submodulePath, commit, remoteRef) => {
+          try {
+            const targetTree = (await runGit3(submodulePath, ["rev-parse", `${commit}^{tree}`])).trim();
+            if (!targetTree) return void 0;
+            const candidates = (await runGit3(submodulePath, ["rev-list", "--max-count=100", remoteRef])).split("\n").map((s2) => s2.trim()).filter(Boolean);
+            for (const candidate of candidates) {
+              const tree = (await runGit3(submodulePath, ["rev-parse", `${candidate}^{tree}`])).trim();
+              if (tree === targetTree) return candidate;
+            }
+          } catch {
+          }
+          return void 0;
+        };
         const treeOutput = await runGit3(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);
@@ -114455,11 +114633,7 @@ ${mergeTreeErr?.stderr || ""}`;
               entry.localReachable = false;
               if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
                 try {
-                  const imported = await importCommitFromWorktreeSubmodule(
-                    submodulePath,
-                    (0, import_path17.resolve)(options.worktreeRoot, gitlink.path),
-                    gitlink.commit
-                  );
+                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path17.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
                   if (imported) {
                     entry.localReachable = true;
                     entry.importedFromWorktree = true;
@@ -114502,36 +114676,48 @@ ${mergeTreeErr?.stderr || ""}`;
               } catch (e) {
                 entry.remoteReachable = false;
                 entry.remoteMainReachable = false;
-                entry.publishRequired = true;
-                const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-                entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
-                if (options.allowAutoPublishSubmoduleMainCommits === true && entry.localReachable === true) {
-                  entry.autoPublishAllowed = true;
-                  entry.autoPublishAttempted = true;
-                  try {
-                    const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, submoduleDefaultBranch);
-                    entry.autoPublishRefspec = publish.refspec;
-                    entry.publishStdout = truncateValidationOutput(publish.stdout);
-                    entry.publishStderr = truncateValidationOutput(publish.stderr);
-                    entry.autoPublishSucceeded = true;
-                    await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
-                    entry.fetchedFromOrigin = true;
-                    entry.remoteReachable = true;
-                    entry.remoteMainReachable = true;
-                    entry.autoPublishVerified = true;
-                    entry.publishRequired = false;
-                    entry.reachable = true;
-                    entry.error = void 0;
-                  } catch (publishError) {
-                    entry.autoPublishSucceeded = false;
-                    entry.autoPublishVerified = false;
-                    const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
-                    entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} failed or could not be verified: ${publishDetails}`;
+                const equivalentPublished = await findEquivalentPublishedCommit(submodulePath, gitlink.commit, `refs/remotes/origin/${submoduleDefaultBranch}`);
+                if (equivalentPublished) {
+                  entry.equivalentPublishedCommit = equivalentPublished;
+                  entry.publishRequired = false;
+                  entry.error = `Submodule commit ${gitlink.commit} is not reachable from origin/${submoduleDefaultBranch}, but an equivalent commit ${equivalentPublished} (identical tree) is already published there; converge the gitlink to the published commit instead of publishing a same-content twin.`;
+                  if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                    entry.autoPublishAllowed = true;
+                    entry.autoPublishAttempted = false;
+                    entry.autoPublishSkippedReason = `an equivalent commit (${equivalentPublished}) is already published on origin/${submoduleDefaultBranch}; publishing a same-content twin is wrong \u2014 converge the gitlink to the published commit instead`;
+                  }
+                } else {
+                  entry.publishRequired = true;
+                  const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
+                  entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
+                  if (options.allowAutoPublishSubmoduleMainCommits === true && entry.localReachable === true) {
+                    entry.autoPublishAllowed = true;
+                    entry.autoPublishAttempted = true;
+                    try {
+                      const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, submoduleDefaultBranch);
+                      entry.autoPublishRefspec = publish.refspec;
+                      entry.publishStdout = truncateValidationOutput(publish.stdout);
+                      entry.publishStderr = truncateValidationOutput(publish.stderr);
+                      entry.autoPublishSucceeded = true;
+                      await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
+                      entry.fetchedFromOrigin = true;
+                      entry.remoteReachable = true;
+                      entry.remoteMainReachable = true;
+                      entry.autoPublishVerified = true;
+                      entry.publishRequired = false;
+                      entry.reachable = true;
+                      entry.error = void 0;
+                    } catch (publishError) {
+                      entry.autoPublishSucceeded = false;
+                      entry.autoPublishVerified = false;
+                      const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
+                      entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} failed or could not be verified: ${publishDetails}`;
+                    }
+                  } else if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                    entry.autoPublishAllowed = true;
+                    entry.autoPublishAttempted = false;
+                    entry.autoPublishSkippedReason = entry.autoPublishSkippedReason || `candidate commit is not reachable in the source checkout or worktree submodule, so Refinery cannot push it to origin/${submoduleDefaultBranch}`;
                   }
-                } else if (options.allowAutoPublishSubmoduleMainCommits === true) {
-                  entry.autoPublishAllowed = true;
-                  entry.autoPublishAttempted = false;
-                  entry.autoPublishSkippedReason = entry.autoPublishSkippedReason || `candidate commit is not reachable in the source checkout or worktree submodule, so Refinery cannot push it to origin/${submoduleDefaultBranch}`;
                 }
               }
             } catch (e) {
@@ -115100,18 +115286,49 @@ ${mergeTreeErr?.stderr || ""}`;
         const resolved = await refineResolveRefsStage(self, meshId, nodeId, args, refineStages);
         if (resolved.kind === "terminal") return resolved.result;
         const ctx = resolved.ctx;
-        const syncBase = await refineSyncBaseStage(self, ctx);
-        if (syncBase.kind === "terminal") return syncBase.result;
-        const validation = await refineValidationStage(self, ctx);
-        if (validation.kind === "terminal") return validation.result;
-        const patchEquivalence = await refinePatchEquivalenceStage(self, ctx);
-        if (patchEquivalence.kind === "terminal") return patchEquivalence.result;
-        const submoduleReachability = await refineSubmoduleReachabilityStage(self, ctx);
-        if (submoduleReachability.kind === "terminal") return submoduleReachability.result;
-        const effectiveDiff = await refineEffectiveDiffStage(self, ctx);
-        if (effectiveDiff.kind === "terminal") return effectiveDiff.result;
-        const merge3 = await refineMergeAndFinalizeStage(self, ctx);
-        return merge3.result;
+        const leaseKey = `${ctx.repoRoot}::${ctx.baseBranch}`;
+        const leaseHolder = buildRefineJobKey(self, meshId, nodeId);
+        if (self.refineBaseLeases.has(leaseKey) && self.refineBaseLeases.get(leaseKey) !== leaseHolder) {
+          recordMeshRefineStage(refineStages, "base_lease", "skipped", Date.now(), {
+            leaseKey,
+            heldBy: self.refineBaseLeases.get(leaseKey),
+            retryable: true
+          });
+          return {
+            success: false,
+            code: "base_locked",
+            convergenceStatus: "blocked_review",
+            retryable: true,
+            error: `Another refine holds the base lease for ${ctx.baseBranch} in this repo; retry after it completes.`,
+            branch: ctx.branch,
+            into: ctx.baseBranch,
+            refineStages,
+            finalBranchConvergenceState: {
+              branch: ctx.branch,
+              baseBranch: ctx.baseBranch,
+              merged: false,
+              removed: false,
+              status: "blocked_review"
+            }
+          };
+        }
+        self.refineBaseLeases.set(leaseKey, leaseHolder);
+        try {
+          const syncBase = await refineSyncBaseStage(self, ctx);
+          if (syncBase.kind === "terminal") return syncBase.result;
+          const validation = await refineValidationStage(self, ctx);
+          if (validation.kind === "terminal") return validation.result;
+          const patchEquivalence = await refinePatchEquivalenceStage(self, ctx);
+          if (patchEquivalence.kind === "terminal") return patchEquivalence.result;
+          const submoduleReachability = await refineSubmoduleReachabilityStage(self, ctx);
+          if (submoduleReachability.kind === "terminal") return submoduleReachability.result;
+          const effectiveDiff = await refineEffectiveDiffStage(self, ctx);
+          if (effectiveDiff.kind === "terminal") return effectiveDiff.result;
+          const merge3 = await refineMergeAndFinalizeStage(self, ctx);
+          return merge3.result;
+        } finally {
+          if (self.refineBaseLeases.get(leaseKey) === leaseHolder) self.refineBaseLeases.delete(leaseKey);
+        }
       } catch (e) {
         return { success: false, error: e.message, refineStages };
       }
@@ -115631,6 +115848,7 @@ ${tail}` : ""
         unreachable: submoduleReachability.unreachable.map((entry) => ({
           path: entry.path,
           commit: entry.commit,
+          equivalentPublishedCommit: entry.equivalentPublishedCommit,
           publishRequired: entry.publishRequired === true,
           autoPublishAllowed: entry.autoPublishAllowed,
           autoPublishAttempted: entry.autoPublishAttempted,
@@ -115649,15 +115867,23 @@ ${tail}` : ""
       });
       if (submoduleReachability.status === "failed") {
         const nextStep = buildSubmodulePublishRequiredNextStep(submoduleReachability.unreachable);
+        const convergeToPublished = submoduleReachability.unreachable.length > 0 && submoduleReachability.unreachable.every((entry) => !!entry.equivalentPublishedCommit);
+        const blockedReason = convergeToPublished ? "submodule_converge_to_published" : "submodule_publish_required";
         return { kind: "terminal", result: {
           success: false,
           code: "submodule_reachability_failed",
           convergenceStatus: "blocked_review",
-          publishRequired: true,
-          blockedReason: "submodule_publish_required",
-          error: "Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote main branch; merge/refine cleanup was not attempted.",
+          publishRequired: !convergeToPublished,
+          ...convergeToPublished ? { convergeToPublished: true } : {},
+          blockedReason,
+          error: convergeToPublished ? "Refinery submodule reachability preflight found submodule gitlink commit(s) that are not reachable from their configured remote main branch, but each has an equivalent commit (identical tree) already published there; converge the gitlink(s) to the published commit(s) instead of publishing same-content twins. Merge/refine cleanup was not attempted." : "Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote main branch; merge/refine cleanup was not attempted.",
           nextStep,
-          nextSteps: [
+          nextSteps: convergeToPublished ? [
+            "Do NOT publish the local submodule commit(s): an equivalent commit (identical tree) is already published on the submodule remote main branch for every unreachable gitlink.",
+            "Retarget each submodule gitlink to the already-published equivalent commit shown in the evidence (equivalentPublishedCommit), commit the root pointer update, and push the submodule checkout to that commit.",
+            "Rerun mesh_refine_node after the gitlink points at the published commit.",
+            "Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main."
+          ] : [
             "Ask the user for explicit approval before pushing or publishing any submodule commit.",
             "Push/publish each unreachable submodule commit to the configured submodule remote main branch shown in the evidence.",
             "Rerun mesh_refine_node after remote reachability is confirmed.",
@@ -115666,6 +115892,7 @@ ${tail}` : ""
           unreachableSubmoduleCommits: submoduleReachability.unreachable.map((entry) => ({
             path: entry.path,
             commit: entry.commit,
+            equivalentPublishedCommit: entry.equivalentPublishedCommit,
             remote: entry.remote,
             remoteUrl: entry.remoteUrl,
             remoteReachable: entry.remoteReachable,
@@ -115694,7 +115921,7 @@ ${tail}` : ""
             patchEquivalence: "passed",
             submoduleReachability: "failed",
             status: "blocked_review",
-            reason: "submodule_publish_required",
+            reason: blockedReason,
             nextStep
           }
         } };
@@ -115811,7 +116038,8 @@ ${hintLines.join("\n")}` : "",
       const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync6 } = ctx;
       const leaseKey = `${repoRoot}::${baseBranch}`;
       const leaseHolder = buildRefineJobKey(self, meshId, nodeId);
-      if (self.refineBaseLeases.has(leaseKey) && self.refineBaseLeases.get(leaseKey) !== leaseHolder) {
+      const alreadyHeld = self.refineBaseLeases.get(leaseKey) === leaseHolder;
+      if (!alreadyHeld && self.refineBaseLeases.has(leaseKey)) {
         recordMeshRefineStage(refineStages, "base_lease", "skipped", Date.now(), {
           leaseKey,
           heldBy: self.refineBaseLeases.get(leaseKey),
@@ -115838,11 +116066,11 @@ ${hintLines.join("\n")}` : "",
           }
         } };
       }
-      self.refineBaseLeases.set(leaseKey, leaseHolder);
+      if (!alreadyHeld) self.refineBaseLeases.set(leaseKey, leaseHolder);
       try {
         return await runRefineMergeAndFinalizeLocked(self, ctx);
       } finally {
-        if (self.refineBaseLeases.get(leaseKey) === leaseHolder) self.refineBaseLeases.delete(leaseKey);
+        if (!alreadyHeld && self.refineBaseLeases.get(leaseKey) === leaseHolder) self.refineBaseLeases.delete(leaseKey);
       }
     }
     async function runRefineMergeAndFinalizeLocked(self, ctx) {