@adhdev/daemon-standalone 0.9.82-rc.261 → 0.9.82-rc.263

package/dist/index.js

@@ -29965,6 +29965,27 @@ var require_dist3 = __commonJS({
         };
       }
     });
+    function readInjected(value) {
+      if (typeof value !== "string") return void 0;
+      const trimmed = value.trim();
+      if (!trimmed || trimmed === "unknown") return void 0;
+      return trimmed;
+    }
+    function getDaemonBuildInfo() {
+      if (cached2) return cached2;
+      const commit = readInjected(true ? "2cf602f99ce68b3d3f1af02b429f6fb7a7c8e686" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "2cf602f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.263" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-14T13:49:22.236Z" : void 0);
+      cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
+      return cached2;
+    }
+    var cached2;
+    var init_build_info = __esm2({
+      "src/build-info.ts"() {
+        "use strict";
+      }
+    });
     async function getGitRepoStatus(workspace, options = {}) {
       const lastCheckedAt = Date.now();
       const includeSubmodules = options.includeSubmodules !== false;
@@ -29986,6 +30007,7 @@ var require_dist3 = __commonJS({
         }
         const submoduleDirty = (submodules || []).some((submodule) => submodule.dirty || submodule.outOfSync || !!submodule.error);
         const dirty = parsed.staged + parsed.modified + parsed.untracked + parsed.deleted + parsed.renamed > 0 || parsed.conflictFiles.length > 0 || stashCount > 0 || submoduleDirty;
+        const daemonBuildBehind = await detectDaemonBuildBehind(repo, submodules, options);
         return {
           workspace: repo.workspace,
           repoRoot: repo.repoRoot,
@@ -30009,7 +30031,8 @@ var require_dist3 = __commonJS({
           conflictFiles: parsed.conflictFiles,
           stashCount,
           lastCheckedAt,
-          submodules
+          submodules,
+          ...daemonBuildBehind ? { daemonBuildBehind } : {}
         };
       } catch (error48) {
         if (error48 instanceof GitCommandError) {
@@ -30022,6 +30045,35 @@ var require_dist3 = __commonJS({
         );
       }
     }
+    async function detectDaemonBuildBehind(repo, submodules, options) {
+      const build = options.daemonBuildInfo ?? getDaemonBuildInfo();
+      if (!build.commit || build.commit === "unknown") return void 0;
+      const scopes = [
+        { scope: "root", repoPath: repo.repoRoot || repo.workspace }
+      ];
+      for (const sub of submodules || []) {
+        if (sub.repoPath && !sub.error) scopes.push({ scope: sub.path, repoPath: sub.repoPath });
+      }
+      for (const { scope, repoPath } of scopes) {
+        try {
+          await runGit(repoPath, ["cat-file", "-e", `${build.commit}^{commit}`], options);
+          const headResult = await runGit(repoPath, ["rev-parse", "HEAD"], options);
+          const head = headResult.stdout.trim();
+          if (!head || head === build.commit) continue;
+          await runGit(repoPath, ["merge-base", "--is-ancestor", build.commit, "HEAD"], options);
+          return {
+            buildCommit: build.commit,
+            buildCommitShort: build.commitShort,
+            head,
+            scope,
+            warning: `Live daemon was built from ${build.commitShort} which is behind ${scope === "root" ? "workspace" : scope} HEAD ${head.slice(0, 7)}. Merged code is NOT live until the daemon is rebuilt/redeployed and restarted \u2014 a local dist rebuild alone does not update a cloud daemon.`
+          };
+        } catch {
+          continue;
+        }
+      }
+      return void 0;
+    }
     async function readPorcelainStatus(repo, options) {
       const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
       return parsePorcelainV2Status(statusOutput.stdout);
@@ -30238,6 +30290,7 @@ var require_dist3 = __commonJS({
       "src/git/git-status.ts"() {
         "use strict";
         init_git_executor();
+        init_build_info();
       }
     });
     var git_diff_exports = {};
@@ -32106,8 +32159,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function getCachedRawEntries(meshId) {
       const now = Date.now();
-      const cached2 = ledgerReadCache.get(meshId);
-      if (cached2 && now - cached2.cachedAt < LEDGER_CACHE_TTL_MS) return cached2.entries;
+      const cached22 = ledgerReadCache.get(meshId);
+      if (cached22 && now - cached22.cachedAt < LEDGER_CACHE_TTL_MS) return cached22.entries;
       let entries;
       try {
         entries = readLedgerFromStore(meshId);
@@ -32384,6 +32437,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       cancelTask: () => cancelTask,
       claimNextTask: () => claimNextTask,
       cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
+      deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       describeTaskDependencyState: () => describeTaskDependencyState,
       enqueueTask: () => enqueueTask,
       getActiveDirectDispatches: () => getActiveDirectDispatches,
@@ -32792,6 +32846,13 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       } catch {
       }
     }
+    function deleteDirectDispatchesByTaskId(meshId, taskIds) {
+      try {
+        return MeshRuntimeStore.getInstance().deleteDirectDispatchesByTaskId(meshId, taskIds);
+      } catch {
+        return 0;
+      }
+    }
     function recordMeshToolCall(opts) {
       try {
         return MeshRuntimeStore.getInstance().recordMeshToolCall(opts);
@@ -33435,6 +33496,24 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           deleteDirectDispatches(meshId) {
             this.db.prepare(`DELETE FROM mesh_direct_dispatches WHERE mesh_id = ?`).run(meshId);
           }
+          /**
+           * Delete specific direct dispatch rows by taskId for a mesh. Used by the staleDirect prune
+           * path to remove orphaned/terminal dispatch records whose node/session is no longer in the
+           * live mesh. Returns the number of rows actually deleted. No-op for an empty taskId list.
+           */
+          deleteDirectDispatchesByTaskId(meshId, taskIds) {
+            const ids = (taskIds || []).map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean);
+            if (!ids.length) return 0;
+            const stmt = this.db.prepare(`DELETE FROM mesh_direct_dispatches WHERE mesh_id = ? AND task_id = ?`);
+            let deleted = 0;
+            const run = this.db.transaction((rows) => {
+              for (const taskId of rows) {
+                deleted += stmt.run(meshId, taskId).changes;
+              }
+            });
+            run(ids);
+            return deleted;
+          }
           markStaleDirectDispatches(meshId, olderThanMs) {
             const cutoff = new Date(Date.now() - olderThanMs).toISOString();
             const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -35121,11 +35200,14 @@ ${rendered}`, "utf-8");
       const trigger = normalizeOptionalString(args.trigger) || "manual";
       const updateSubmodules = args.updateSubmodules === true;
       const dryRun = args.dryRun === true || args.execute !== true;
-      const plannedSteps = buildPlannedSteps(updateSubmodules);
+      const mode = args.mode === "push" ? "push" : "merge";
+      const pushSubmodules = mode === "push" && args.pushSubmodules === true;
+      const plannedSteps = buildPlannedSteps(mode, updateSubmodules, pushSubmodules);
       const base = {
         ...nodeId ? { nodeId } : {},
         ...meshId ? { meshId } : {},
         workspace,
+        mode,
         dryRun,
         updateSubmodules,
         plannedSteps,
@@ -35139,13 +35221,24 @@ ${rendered}`, "utf-8");
         submoduleIgnorePaths: args.submoduleIgnorePaths,
         timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
       });
+      if (mode === "push") {
+        return pushMeshNode(base, args, current, {
+          pushSubmodules,
+          allowAutoPublishSubmoduleMainCommits: args.allowAutoPublishSubmoduleMainCommits === true
+        });
+      }
       const earlyBlockers = collectPreflightBlockers(current, requestedBranch);
       if (earlyBlockers.length > 0) {
+        const blockCode = chooseBlockCode(current, earlyBlockers);
         const result2 = {
-          ...block(base, chooseBlockCode(current, earlyBlockers), earlyBlockers),
+          ...block(base, blockCode, earlyBlockers),
           current,
-          finalBranchConvergenceState: buildConvergenceState(current, codeToConvergenceStatus(chooseBlockCode(current, earlyBlockers)))
+          finalBranchConvergenceState: buildConvergenceState(current, codeToConvergenceStatus(blockCode))
         };
+        if (blockCode === "branch_ahead" && current.ahead > 0 && current.behind === 0 && otherBlockersAreOnlyAhead(earlyBlockers)) {
+          result2.code = "ahead_needs_push";
+          result2.nextStep = 'Local branch is ahead of origin with nothing to merge. Re-run mesh_fast_forward_node with mode="push" (execute=true) to ff-only push the local commits to origin.';
+        }
         await appendFastForwardLedger(result2, "blocked");
         return result2;
       }
@@ -35256,7 +35349,246 @@ ${rendered}`, "utf-8");
       await appendFastForwardLedger(result, success2 ? "executed" : "failed");
       return result;
     }
-    function buildPlannedSteps(updateSubmodules) {
+    async function pushMeshNode(base, args, current, options) {
+      const workspace = base.workspace;
+      const requestedBranch = normalizeOptionalString(args.branch);
+      const dryRun = base.dryRun;
+      const blockers = collectPushPreflightBlockers(current, requestedBranch);
+      if (blockers.length > 0) {
+        const code2 = choosePushBlockCode(current, blockers);
+        const result2 = {
+          ...block(base, code2, blockers),
+          current,
+          preStatus: current,
+          finalBranchConvergenceState: buildConvergenceState(current, codeToConvergenceStatus(code2))
+        };
+        await appendFastForwardLedger(result2, "blocked");
+        return result2;
+      }
+      const target = parseUpstreamTarget(current.upstream || "");
+      if (!target) {
+        const result2 = {
+          ...block(base, "upstream_unparseable", ["upstream_unparseable"]),
+          current,
+          preStatus: current,
+          finalBranchConvergenceState: buildConvergenceState(current, "blocked")
+        };
+        await appendFastForwardLedger(result2, "blocked");
+        return result2;
+      }
+      const refspec = `HEAD:refs/heads/${target.remoteBranch}`;
+      const pushTarget = { remote: target.remote, remoteBranch: target.remoteBranch, refspec };
+      if (current.ahead <= 0) {
+        const result2 = {
+          ...base,
+          success: true,
+          code: "nothing_to_push",
+          allowed: true,
+          willRun: false,
+          executed: false,
+          blockingReasons: [],
+          current,
+          preStatus: current,
+          postStatus: current,
+          pushTarget,
+          finalBranchConvergenceState: buildConvergenceState(current, "up_to_date")
+        };
+        await appendFastForwardLedger(result2, "noop");
+        return result2;
+      }
+      const descendant = await verifyUpstreamIsAncestorOfHead(workspace, current.upstream || "", args.timeoutMs);
+      if (!descendant.ok) {
+        const result2 = {
+          ...block(base, "non_fast_forward_push", ["head_is_not_descendant_of_upstream"]),
+          current,
+          preStatus: current,
+          pushTarget,
+          operationError: descendant.error,
+          nextStep: "origin/<branch> has commits not in local HEAD; a ff-only push would lose them. Converge by rebasing onto origin first, then re-run. This operation never force-pushes.",
+          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
+        };
+        await appendFastForwardLedger(result2, "blocked");
+        return result2;
+      }
+      if (dryRun) {
+        const result2 = {
+          ...base,
+          success: true,
+          code: "push_available",
+          allowed: true,
+          willRun: false,
+          executed: false,
+          blockingReasons: [],
+          current,
+          preStatus: current,
+          pushTarget,
+          ...options.pushSubmodules ? { submodulePushes: await planSubmodulePushes(current, options, args.timeoutMs) } : {},
+          finalBranchConvergenceState: buildConvergenceState(current, "push_available")
+        };
+        await appendFastForwardLedger(result2, "dry_run");
+        return result2;
+      }
+      try {
+        await runGit(workspace, ["push", target.remote, refspec], { timeoutMs: args.timeoutMs ?? 3e4 });
+      } catch (error48) {
+        const result2 = {
+          ...block(base, "push_ff_only_failed", ["push_ff_only_failed"]),
+          current,
+          preStatus: current,
+          pushTarget,
+          operationError: formatGitError2(error48),
+          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
+        };
+        await appendFastForwardLedger(result2, "failed");
+        return result2;
+      }
+      let submodulePushes;
+      if (options.pushSubmodules) {
+        submodulePushes = await executeSubmodulePushes(current, options, args.timeoutMs);
+      }
+      const postStatus = await getGitRepoStatus(workspace, {
+        ...STATUS_OPTIONS,
+        submoduleIgnorePaths: args.submoduleIgnorePaths,
+        timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
+      });
+      const submodulePushFailed = (submodulePushes || []).some((entry) => !entry.pushed && !entry.skipped);
+      const blockingReasons = [];
+      if (postStatus.ahead !== 0) blockingReasons.push("post_branch_ahead");
+      if (submodulePushFailed) blockingReasons.push("submodule_push_failed");
+      const success2 = blockingReasons.length === 0;
+      const code = success2 ? "push_applied" : submodulePushFailed && postStatus.ahead === 0 ? "push_applied_submodule_push_failed" : "post_push_verify_failed";
+      const result = {
+        ...base,
+        success: success2,
+        code,
+        allowed: true,
+        willRun: true,
+        executed: true,
+        blockingReasons,
+        current,
+        preStatus: current,
+        postStatus,
+        pushTarget,
+        ...submodulePushes ? { submodulePushes } : {},
+        finalBranchConvergenceState: buildConvergenceState(postStatus, success2 ? "pushed" : "post_verify_failed")
+      };
+      await appendFastForwardLedger(result, success2 ? "executed" : "failed");
+      return result;
+    }
+    function collectPushPreflightBlockers(status, requestedBranch) {
+      const blockers = [];
+      if (!status.isGitRepo) blockers.push("not_git_repo");
+      if (!status.branch) blockers.push("detached_head_or_unknown_branch");
+      if (requestedBranch && status.branch !== requestedBranch) blockers.push("branch_mismatch");
+      if (!status.upstream) blockers.push("upstream_missing");
+      if (status.upstreamStatus !== "fresh") blockers.push("upstream_not_fresh");
+      if (status.hasConflicts) blockers.push("conflicts_present");
+      if (status.staged > 0) blockers.push("staged_changes_present");
+      if (status.modified > 0) blockers.push("modified_changes_present");
+      if (status.untracked > 0) blockers.push("untracked_changes_present");
+      if (status.deleted > 0) blockers.push("deleted_changes_present");
+      if (status.renamed > 0) blockers.push("renamed_changes_present");
+      if (status.stashCount > 0) blockers.push("stash_entries_present");
+      if (status.ahead > 0 && status.behind > 0) blockers.push("branch_diverged_from_upstream");
+      else if (status.behind > 0) blockers.push("branch_behind_upstream");
+      return blockers;
+    }
+    function choosePushBlockCode(status, blockers) {
+      if (blockers.includes("not_git_repo")) return "not_git_repo";
+      if (blockers.includes("branch_mismatch")) return "branch_mismatch";
+      if (blockers.includes("upstream_missing")) return "upstream_missing";
+      if (blockers.includes("upstream_not_fresh")) return "upstream_not_fresh";
+      if (blockers.includes("branch_diverged_from_upstream")) return "branch_diverged";
+      if (blockers.includes("branch_behind_upstream")) return "non_fast_forward_push";
+      if (blockers.some((reason) => reason.includes("changes") || reason.includes("conflicts") || reason.includes("stash"))) return "dirty_worktree";
+      return "preflight_blocked";
+    }
+    function parseUpstreamTarget(upstream) {
+      const trimmed = upstream.trim();
+      const slash = trimmed.indexOf("/");
+      if (slash <= 0 || slash >= trimmed.length - 1) return null;
+      return { remote: trimmed.slice(0, slash), remoteBranch: trimmed.slice(slash + 1) };
+    }
+    async function verifyUpstreamIsAncestorOfHead(workspace, upstream, timeoutMs) {
+      if (!upstream) return { ok: false, error: "missing upstream" };
+      try {
+        await runGit(workspace, ["merge-base", "--is-ancestor", upstream, "HEAD"], { timeoutMs: timeoutMs ?? 15e3 });
+        return { ok: true };
+      } catch (error48) {
+        return { ok: false, error: formatGitError2(error48) };
+      }
+    }
+    async function planSubmodulePushes(status, options, timeoutMs) {
+      return resolveSubmodulePushes(status, options, false, timeoutMs);
+    }
+    async function executeSubmodulePushes(status, options, timeoutMs) {
+      return resolveSubmodulePushes(status, options, true, timeoutMs);
+    }
+    async function resolveSubmodulePushes(status, options, execute, timeoutMs) {
+      const submodules = Array.isArray(status.submodules) ? status.submodules : [];
+      const results = [];
+      for (const submodule of submodules) {
+        const base = {
+          path: submodule.path,
+          commit: submodule.commit,
+          remote: "origin",
+          remoteBranch: "main",
+          pushed: false,
+          skipped: true,
+          code: "submodule_push_skipped"
+        };
+        if (!options.allowAutoPublishSubmoduleMainCommits) {
+          results.push({ ...base, code: "submodule_push_policy_disabled", error: "allowAutoPublishSubmoduleMainCommits is not enabled" });
+          continue;
+        }
+        if (submodule.error || submodule.dirty) {
+          results.push({ ...base, code: "submodule_not_clean", error: submodule.error || "submodule worktree is dirty" });
+          continue;
+        }
+        const repoPath = submodule.repoPath;
+        if (!repoPath || !submodule.commit) {
+          results.push({ ...base, code: "submodule_status_incomplete" });
+          continue;
+        }
+        try {
+          await runGit(repoPath, ["-c", "protocol.file.allow=always", "fetch", "origin", "refs/heads/main:refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 3e4 });
+        } catch (error48) {
+          results.push({ ...base, code: "submodule_fetch_failed", error: formatGitError2(error48) });
+          continue;
+        }
+        let alreadyReachable = false;
+        try {
+          await runGit(repoPath, ["merge-base", "--is-ancestor", submodule.commit, "refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 15e3 });
+          alreadyReachable = true;
+        } catch {
+        }
+        if (alreadyReachable) {
+          results.push({ ...base, pushed: false, skipped: true, code: "submodule_already_reachable" });
+          continue;
+        }
+        try {
+          await runGit(repoPath, ["merge-base", "--is-ancestor", "refs/remotes/origin/main", submodule.commit], { timeoutMs: timeoutMs ?? 15e3 });
+        } catch (error48) {
+          results.push({ ...base, pushed: false, skipped: false, code: "submodule_non_fast_forward", error: formatGitError2(error48) });
+          continue;
+        }
+        const refspec = `${submodule.commit}:refs/heads/main`;
+        if (!execute) {
+          results.push({ ...base, pushed: false, skipped: false, code: "submodule_push_available", refspec });
+          continue;
+        }
+        try {
+          await runGit(repoPath, ["push", "origin", refspec], { timeoutMs: timeoutMs ?? 3e4 });
+          await runGit(repoPath, ["-c", "protocol.file.allow=always", "fetch", "origin", "refs/heads/main:refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 3e4 });
+          await runGit(repoPath, ["merge-base", "--is-ancestor", submodule.commit, "refs/remotes/origin/main"], { timeoutMs: timeoutMs ?? 15e3 });
+          results.push({ ...base, pushed: true, skipped: false, code: "submodule_pushed", refspec });
+        } catch (error48) {
+          results.push({ ...base, pushed: false, skipped: false, code: "submodule_push_failed", refspec, error: formatGitError2(error48) });
+        }
+      }
+      return results;
+    }
+    function buildPlannedSteps(mode, updateSubmodules, pushSubmodules) {
       const steps = [
         {
           operation: "refresh_upstream",
@@ -35269,20 +35601,49 @@ ${rendered}`, "utf-8");
           description: "Require clean staged/modified/untracked/deleted/renamed/conflict/stash/submodule state.",
           safe: true,
           willMutateWorktree: false
-        },
-        {
-          operation: "verify_fast_forward",
-          description: "Require ahead=0, behind>0, and HEAD to be an ancestor of the upstream ref.",
+        }
+      ];
+      if (mode === "push") {
+        steps.push({
+          operation: "verify_push_descendant",
+          description: "Require HEAD to be a descendant of origin/<branch> (origin/<branch> is an ancestor of HEAD); refuse any non-fast-forward push.",
           safe: true,
           willMutateWorktree: false
-        },
-        {
-          operation: "merge_ff_only",
-          description: "Apply git merge --ff-only against the tracked upstream; no force, reset, rebase, push, or deploy.",
+        });
+        steps.push({
+          operation: "push_ff_only",
+          description: "Run git push origin HEAD:<branch> as a strict ff-only push; never --force, --force-with-lease, reset, or rebase. Does not mutate the worktree.",
           safe: true,
-          willMutateWorktree: true
+          willMutateWorktree: false
+        });
+        if (pushSubmodules) {
+          steps.push({
+            operation: "push_submodules_ff_only",
+            description: "For each submodule, if allowAutoPublishSubmoduleMainCommits is enabled and the submodule HEAD is a descendant of its origin main, ff-only push it to submodule origin main; otherwise skip.",
+            safe: true,
+            willMutateWorktree: false
+          });
         }
-      ];
+        steps.push({
+          operation: "verify_post_status",
+          description: "Re-read daemon-owned git status and report final branch convergence state.",
+          safe: true,
+          willMutateWorktree: false
+        });
+        return steps;
+      }
+      steps.push({
+        operation: "verify_fast_forward",
+        description: "Require ahead=0, behind>0, and HEAD to be an ancestor of the upstream ref.",
+        safe: true,
+        willMutateWorktree: false
+      });
+      steps.push({
+        operation: "merge_ff_only",
+        description: "Apply git merge --ff-only against the tracked upstream; no force, reset, rebase, push, or deploy.",
+        safe: true,
+        willMutateWorktree: true
+      });
       if (updateSubmodules) {
         steps.push({
           operation: "submodule_update",
@@ -35299,6 +35660,10 @@ ${rendered}`, "utf-8");
       });
       return steps;
     }
+    function otherBlockersAreOnlyAhead(blockers) {
+      const aheadOnly = /* @__PURE__ */ new Set(["branch_has_local_commits"]);
+      return blockers.every((reason) => aheadOnly.has(reason));
+    }
     function collectPreflightBlockers(status, requestedBranch) {
       const blockers = [];
       if (!status.isGitRepo) blockers.push("not_git_repo");
@@ -35355,7 +35720,7 @@ ${rendered}`, "utf-8");
       return "preflight_blocked";
     }
     function codeToConvergenceStatus(code) {
-      if (code === "branch_diverged" || code === "branch_ahead" || code === "non_fast_forward") return "not_mergeable";
+      if (code === "branch_diverged" || code === "branch_ahead" || code === "non_fast_forward" || code === "non_fast_forward_push" || code === "upstream_unparseable") return "not_mergeable";
       if (code === "dirty_worktree" || code === "submodule_not_clean") return "blocked_review";
       return "blocked";
     }
@@ -35438,6 +35803,7 @@ ${rendered}`, "utf-8");
           ...result.nodeId ? { nodeId: result.nodeId } : {},
           payload: {
             operation: "mesh_fast_forward_node",
+            mode: result.mode,
             trigger: result.trigger || "manual",
             outcome,
             code: result.code,
@@ -35448,6 +35814,7 @@ ${rendered}`, "utf-8");
             executed: result.executed,
             branch: result.postStatus?.branch ?? result.current?.branch,
             upstream: result.postStatus?.upstream ?? result.current?.upstream,
+            ...result.pushTarget ? { pushTarget: result.pushTarget } : {},
             before: result.current ? {
               headCommit: result.current.headCommit,
               ahead: result.current.ahead,
@@ -35458,6 +35825,16 @@ ${rendered}`, "utf-8");
               ahead: result.postStatus.ahead,
               behind: result.postStatus.behind
             } : void 0,
+            ...result.submodulePushes ? {
+              submodulePushes: result.submodulePushes.map((entry) => ({
+                path: entry.path,
+                commit: entry.commit,
+                pushed: entry.pushed,
+                skipped: entry.skipped,
+                code: entry.code,
+                ...entry.refspec ? { refspec: entry.refspec } : {}
+              }))
+            } : {},
             blockingReasons: result.blockingReasons
           }
         });
@@ -36628,8 +37005,8 @@ Next step: ${nextStep}`;
     });
     function getCachedMeshByWorkspace(workspace) {
       const now = Date.now();
-      const cached2 = meshByWorkspaceCache.get(workspace);
-      if (cached2 && now - cached2.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached2.mesh;
+      const cached22 = meshByWorkspaceCache.get(workspace);
+      if (cached22 && now - cached22.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached22.mesh;
       const mesh = getMeshByRepo(workspace);
       meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
       return mesh;
@@ -41528,10 +41905,10 @@ ${lastSnapshot}`;
             return this.accumulatedRawBuffer.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
           }
           getFreshParsedStatusCache() {
-            const cached2 = this.parsedStatusCache;
+            const cached22 = this.parsedStatusCache;
             const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.engine.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBufferKey === accumulatedRawBufferKey && cached2.screenText === this.lastScreenText && cached2.currentStatus === this.engine.currentStatus && cached2.activeModal === this.engine.activeModal && cached2.cliName === this.cliName) {
-              return cached2.result;
+            if (cached22 && cached22.responseBuffer === this.responseBuffer && cached22.currentTurnScope === this.engine.currentTurnScope && cached22.recentOutputBuffer === this.recentOutputBuffer && cached22.accumulatedBuffer === this.accumulatedBuffer && cached22.accumulatedRawBufferKey === accumulatedRawBufferKey && cached22.screenText === this.lastScreenText && cached22.currentStatus === this.engine.currentStatus && cached22.activeModal === this.engine.activeModal && cached22.cliName === this.cliName) {
+              return cached22.result;
             }
             return null;
           }
@@ -41991,10 +42368,10 @@ ${lastSnapshot}`;
           getScriptParsedStatus() {
             const screenText = this.readTerminalScreenText();
             const parseScreenText = this.getParseScreenText(screenText);
-            const cached2 = this.parsedStatusCache;
+            const cached22 = this.parsedStatusCache;
             const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-            if (!this.providerOwnsTranscript() && cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.engine.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBufferKey === accumulatedRawBufferKey && cached2.screenText === parseScreenText && cached2.currentStatus === this.engine.currentStatus && cached2.activeModal === this.engine.activeModal && cached2.cliName === this.cliName) {
-              return cached2.result;
+            if (!this.providerOwnsTranscript() && cached22 && cached22.responseBuffer === this.responseBuffer && cached22.currentTurnScope === this.engine.currentTurnScope && cached22.recentOutputBuffer === this.recentOutputBuffer && cached22.accumulatedBuffer === this.accumulatedBuffer && cached22.accumulatedRawBufferKey === accumulatedRawBufferKey && cached22.screenText === parseScreenText && cached22.currentStatus === this.engine.currentStatus && cached22.activeModal === this.engine.activeModal && cached22.cliName === this.cliName) {
+              return cached22.result;
             }
             const parsed = this.runParseSession();
             if (!parsed || !Array.isArray(parsed.messages)) {
@@ -43865,6 +44242,7 @@ ${lastSnapshot}`;
       MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS2,
       NodePtyTransportFactory: () => NodePtyTransportFactory,
       P2pRelayFailureError: () => P2pRelayFailureError,
+      PRUNABLE_ORPHAN_STALE_REASONS: () => PRUNABLE_ORPHAN_STALE_REASONS,
       ProviderCliAdapter: () => ProviderCliAdapter,
       ProviderInstanceManager: () => ProviderInstanceManager,
       ProviderLoader: () => ProviderLoader,
@@ -43918,6 +44296,7 @@ ${lastSnapshot}`;
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       classifyP2pRelayFailure: () => classifyP2pRelayFailure,
+      classifyStaleDirectForPrune: () => classifyStaleDirectForPrune,
       cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
       clearDebugTrace: () => clearDebugTrace,
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
@@ -43937,6 +44316,7 @@ ${lastSnapshot}`;
       createNativeHistoryDispatcher: () => createNativeHistoryDispatcher,
       createSessionDelivery: () => createSessionDelivery,
       createWorktree: () => createWorktree,
+      deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       deleteMesh: () => deleteMesh,
       deriveMeshReviewInboxItems: () => deriveMeshReviewInboxItems,
       describeTaskDependencyState: () => describeTaskDependencyState,
@@ -43965,6 +44345,7 @@ ${lastSnapshot}`;
       getAvailableIdeIds: () => getAvailableIdeIds,
       getCoordinatorForSession: () => getCoordinatorForSession,
       getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
+      getDaemonBuildInfo: () => getDaemonBuildInfo,
       getDaemonDataDir: () => getDaemonDataDir,
       getDaemonLogDir: () => getDaemonLogDir,
       getDebugRuntimeConfig: () => getDebugRuntimeConfig,
@@ -46761,6 +47142,17 @@ ${lastSnapshot}`;
       }
       return { activeWork: records, staleDirectWork, staleDirectWorkNote, terminalDirectWork, summary };
     }
+    var PRUNABLE_ORPHAN_STALE_REASONS = /* @__PURE__ */ new Set([
+      "direct task node is no longer in the live mesh",
+      "direct task session is not present in live session records",
+      "direct task has no node id"
+    ]);
+    function classifyStaleDirectForPrune(record2, opts = {}) {
+      if (record2.staleDispatchUnacknowledged === true) return "preserve_unacknowledged";
+      if (record2.terminal === true) return opts.includeTerminal ? "prunable_terminal" : "preserve_active";
+      if (record2.staleReason && PRUNABLE_ORPHAN_STALE_REASONS.has(record2.staleReason)) return "prunable_orphan";
+      return "preserve_active";
+    }
     function buildCompactStaleDirectWorkSummary(staleDirectWork, opts = {}) {
       const sampleLimit = Math.max(0, Math.min(10, Math.floor(opts.sampleLimit ?? 3)));
       const reasonCounts = {};
@@ -49950,9 +50342,9 @@ ${cleanBody}`;
       for (const file2 of files.slice().sort()) {
         const filePath = path12.join(dir, file2);
         const signature = fileSignatures.get(file2) || `${file2}:missing`;
-        const cached2 = savedHistoryFileSummaryCache.get(filePath);
+        const cached22 = savedHistoryFileSummaryCache.get(filePath);
         const persisted = persistedEntries.get(file2);
-        const reusableEntry = cached2?.signature === signature ? cached2 : persisted?.signature === signature ? persisted : null;
+        const reusableEntry = cached22?.signature === signature ? cached22 : persisted?.signature === signature ? persisted : null;
         const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(dir, file2);
         const nextEntry = reusableEntry || {
           signature,
@@ -50404,23 +50796,23 @@ ${cleanBody}`;
           savedHistorySessionCache.delete(sanitized);
           return { sessions: [], hasMore: false };
         }
-        const cached2 = savedHistorySessionCache.get(sanitized);
+        const cached22 = savedHistorySessionCache.get(sanitized);
         const offset = Math.max(0, options.offset || 0);
         const limit = Math.max(1, options.limit || 30);
         const indexSignature = buildSavedHistoryIndexFileSignature(dir);
         let cacheWasInvalidated = false;
-        if (cached2) {
-          const cacheLooksPersisted = cached2.signature.startsWith("index:");
-          const cacheStillValid = cacheLooksPersisted ? cached2.signature === indexSignature : (() => {
+        if (cached22) {
+          const cacheLooksPersisted = cached22.signature.startsWith("index:");
+          const cacheStillValid = cacheLooksPersisted ? cached22.signature === indexSignature : (() => {
             const files2 = listHistoryFiles(dir);
             const fileSignatures2 = buildSavedHistoryFileSignatureMap(dir, files2);
-            return cached2.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+            return cached22.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
           })();
           if (cacheStillValid) {
-            const sliced2 = cached2.summaries.slice(offset, offset + limit);
+            const sliced2 = cached22.summaries.slice(offset, offset + limit);
             return {
               sessions: sliced2,
-              hasMore: cached2.summaries.length > offset + limit
+              hasMore: cached22.summaries.length > offset + limit
             };
           }
           cacheWasInvalidated = true;
@@ -66889,8 +67281,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return null;
         }
         registerProviderScriptRootSafely(path30.dirname(path30.dirname(providerDir)));
-        const cached2 = this.scriptsCache.get(dir);
-        if (cached2) return cached2;
+        const cached22 = this.scriptsCache.get(dir);
+        if (cached22) return cached22;
         const scriptsJs = path30.join(dir, "scripts.js");
         if (fs20.existsSync(scriptsJs)) {
           try {
@@ -68869,6 +69261,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       };
     }
+    init_build_info();
     var import_child_process7 = require("child_process");
     var import_child_process8 = require("child_process");
     var fs222 = __toESM2(require("fs"));
@@ -69651,13 +70044,13 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         nodes
       };
     }
-    function reconcileInlineMeshCache(cached2, incoming) {
-      if (!cached2 || typeof cached2 !== "object" || Array.isArray(cached2)) return incoming;
-      if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached2;
-      const cachedNodes = Array.isArray(cached2.nodes) ? cached2.nodes : [];
+    function reconcileInlineMeshCache(cached22, incoming) {
+      if (!cached22 || typeof cached22 !== "object" || Array.isArray(cached22)) return incoming;
+      if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached22;
+      const cachedNodes = Array.isArray(cached22.nodes) ? cached22.nodes : [];
       const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
-      if (!cachedNodes.length || !incomingNodes.length) return { ...cached2, ...incoming };
-      const cachedUpdatedAt = Date.parse(readStringValue(cached2.updatedAt, cached2.updated_at) || "");
+      if (!cachedNodes.length || !incomingNodes.length) return { ...cached22, ...incoming };
+      const cachedUpdatedAt = Date.parse(readStringValue(cached22.updatedAt, cached22.updated_at) || "");
       const incomingUpdatedAt = Date.parse(readStringValue(incoming.updatedAt, incoming.updated_at) || "");
       const preserveCachedMembership = Number.isFinite(cachedUpdatedAt) && (!Number.isFinite(incomingUpdatedAt) || cachedUpdatedAt > incomingUpdatedAt);
       const cachedById = /* @__PURE__ */ new Map();
@@ -69686,7 +70079,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
       return {
-        ...cached2,
+        ...cached22,
         ...incoming,
         nodes
       };
@@ -70297,8 +70690,37 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           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] || "";
+        let mergedTree = "";
+        let mergeTreeStdout = "";
+        let gitlinkTrivialFastForward;
+        try {
+          mergeTreeStdout = git(["merge-tree", "--write-tree", baseHead, branchHead]);
+          mergedTree = mergeTreeStdout.trim().split(/\s+/)[0] || "";
+        } catch (mergeTreeErr) {
+          const output = `${mergeTreeErr?.message || ""}
+${mergeTreeErr?.stdout || ""}
+${mergeTreeErr?.stderr || ""}`;
+          const isSubmoduleConflict = /(submodule|160000)/i.test(output) || /Recursive merging with submodules/i.test(output);
+          if (!isSubmoduleConflict) throw mergeTreeErr;
+          const evaluation = evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead);
+          if (!evaluation.trivial) {
+            return {
+              status: "failed",
+              equivalent: false,
+              baseHead,
+              branchHead,
+              mergeBase: mergeBase || void 0,
+              durationMs: Date.now() - startedAt,
+              error: mergeTreeErr?.message || String(mergeTreeErr),
+              stdout: truncateValidationOutput(mergeTreeErr?.stdout),
+              stderr: truncateValidationOutput(mergeTreeErr?.stderr),
+              gitlinkTrivialFastForward: { resolved: false, gitlinks: evaluation.gitlinks, reason: evaluation.reason },
+              actionableHint: buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHead, output)
+            };
+          }
+          mergedTree = synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, evaluation.gitlinks) || "";
+          gitlinkTrivialFastForward = { resolved: true, gitlinks: evaluation.gitlinks };
+        }
         if (!mergeBase || !mergedTree) {
           return {
             status: "failed",
@@ -70309,7 +70731,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             mergedTree: mergedTree || void 0,
             durationMs: Date.now() - startedAt,
             error: "patch equivalence preflight could not resolve merge-base or synthetic merge tree",
-            stdout: truncateValidationOutput(mergeTreeStdout)
+            stdout: truncateValidationOutput(mergeTreeStdout),
+            gitlinkTrivialFastForward
           };
         }
         const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead);
@@ -70324,7 +70747,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           mergedTree,
           expectedPatchId,
           actualPatchId,
-          durationMs: Date.now() - startedAt
+          durationMs: Date.now() - startedAt,
+          gitlinkTrivialFastForward
         };
       } catch (e) {
         return {
@@ -70347,6 +70771,65 @@ ${e?.stderr || ""}`
         };
       }
     }
+    async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
+      const startedAt = Date.now();
+      try {
+        const { execFileSync: execFileSync6 } = await import("child_process");
+        const git = (args, opts) => execFileSync6("git", args, {
+          cwd: opts?.cwd || repoRoot,
+          encoding: "utf8",
+          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+        });
+        const rawDiff = git(["diff", "--raw", baseHead, branchHead]).trim();
+        if (rawDiff) {
+          const changedPaths = rawDiff.split("\n").map((line) => line.split("	").slice(1).join("	").trim()).filter(Boolean).slice(0, 50);
+          return {
+            status: "passed",
+            hasEffectiveDiff: true,
+            baseHead,
+            branchHead,
+            changedPaths,
+            durationMs: Date.now() - startedAt
+          };
+        }
+        const submoduleHints = [];
+        try {
+          const status = git(["submodule", "status"]);
+          for (const line of status.split("\n")) {
+            const trimmed = line.trimEnd();
+            if (!trimmed) continue;
+            if (trimmed.startsWith("+")) {
+              const parts = trimmed.slice(1).trim().split(/\s+/);
+              const path39 = parts[1] || parts[0] || "(unknown)";
+              submoduleHints.push({
+                path: path39,
+                reason: "submodule checked-out commit differs from the committed gitlink (pointer bump not committed on the root branch)"
+              });
+            }
+          }
+        } catch {
+        }
+        return {
+          status: "failed",
+          hasEffectiveDiff: false,
+          baseHead,
+          branchHead,
+          ...submoduleHints.length ? { submoduleHints } : {},
+          durationMs: Date.now() - startedAt
+        };
+      } catch (e) {
+        return {
+          status: "skipped",
+          hasEffectiveDiff: true,
+          baseHead,
+          branchHead,
+          durationMs: Date.now() - startedAt,
+          error: e?.message || String(e),
+          stdout: truncateValidationOutput(e?.stdout),
+          stderr: truncateValidationOutput(e?.stderr)
+        };
+      }
+    }
     function buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHead, output) {
       if (!/(submodule|160000)/i.test(output) || !/(conflict|failed to merge)/i.test(output)) return void 0;
       const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path39) => ({
@@ -70403,6 +70886,135 @@ ${e?.stderr || ""}`
         return void 0;
       }
     }
+    function resolveGitDir(repoRoot) {
+      const out = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", "--absolute-git-dir"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024
+      }).trim();
+      return out;
+    }
+    function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
+      if (!baseCommit || !branchCommit) return false;
+      if (baseCommit === branchCommit) return true;
+      try {
+        if (!fs23.existsSync(submoduleRepoPath)) return false;
+        (0, import_node_child_process6.execFileSync)("git", ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process6.execFileSync)("git", ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process6.execFileSync)("git", ["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_process6.execFileSync)("git", ["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 path39 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path39 || seen.has(path39)) continue;
+          seen.add(path39);
+          const parts = meta3.split(/\s+/);
+          const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
+          result.push({ path: path39, isGitlink });
+        }
+        return result;
+      } catch {
+        return [];
+      }
+    }
+    function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
+      const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path39) => {
+        const baseCommit = readTreeObject(repoRoot, baseHead, path39);
+        const branchCommit = readTreeObject(repoRoot, branchHead, path39);
+        const submoduleRepoPath = (0, import_path10.resolve)(repoRoot, path39);
+        const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
+        return { path: path39, baseCommit, branchCommit, fastForward };
+      });
+      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
+        };
+      }
+      let mergeBase = "";
+      try {
+        mergeBase = (0, import_node_child_process6.execFileSync)("git", ["merge-base", baseHead, branchHead], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024
+        }).trim();
+      } catch {
+        return { trivial: false, reason: "merge_base_unresolved", gitlinks: changedGitlinks };
+      }
+      if (!mergeBase) {
+        return { trivial: false, reason: "merge_base_unresolved", gitlinks: changedGitlinks };
+      }
+      const baseSideChanges = readChangedPathKinds(repoRoot, mergeBase, baseHead);
+      const branchSideChanges = readChangedPathKinds(repoRoot, mergeBase, branchHead);
+      const baseChangedPaths = new Map(baseSideChanges.map((entry) => [entry.path, entry]));
+      const overlapping = branchSideChanges.filter((entry) => baseChangedPaths.has(entry.path));
+      const nonGitlinkOverlap = overlapping.filter((entry) => {
+        const baseEntry = baseChangedPaths.get(entry.path);
+        return !(entry.isGitlink && baseEntry?.isGitlink);
+      });
+      if (nonGitlinkOverlap.length > 0) {
+        return {
+          trivial: false,
+          reason: `non_gitlink_overlap:${nonGitlinkOverlap.map((entry) => entry.path).join(",")}`,
+          gitlinks: changedGitlinks
+        };
+      }
+      return { trivial: true, gitlinks: changedGitlinks };
+    }
+    function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, gitlinks) {
+      try {
+        const baseTree = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", `${baseHead}^{tree}`], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024
+        }).trim();
+        if (!baseTree) return void 0;
+        const updates = gitlinks.filter((entry) => entry.branchCommit).map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
+        if (!updates) return baseTree;
+        const tmpIndex = (0, import_path10.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+        const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+        try {
+          (0, import_node_child_process6.execFileSync)("git", ["read-tree", baseTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process6.execFileSync)("git", ["update-index", "--index-info"], {
+            cwd: repoRoot,
+            env: env2,
+            input: `${updates}
+`,
+            encoding: "utf8",
+            stdio: ["pipe", "ignore", "ignore"]
+          });
+          const newTree = (0, import_node_child_process6.execFileSync)("git", ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          return newTree || void 0;
+        } finally {
+          try {
+            fs23.rmSync(tmpIndex, { force: true });
+          } catch {
+          }
+        }
+      } catch {
+        return void 0;
+      }
+    }
     async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, currentHead, options = {}) {
       const startedAt = Date.now();
       const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path39) => !(options.submoduleIgnorePaths || []).includes(path39));
@@ -71070,6 +71682,10 @@ ${e?.stderr || ""}`
       runningRefineJobs = /* @__PURE__ */ new Map();
       /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
       terminalRefineJobs = /* @__PURE__ */ new Map();
+      /** In-memory async batch Refinery jobs keyed by meshId (one batch convergence per mesh at a time). */
+      runningRefineBatchJobs = /* @__PURE__ */ new Map();
+      /** Terminal async batch Refinery jobs preserve the last batch outcome for late readers. */
+      terminalRefineBatchJobs = /* @__PURE__ */ new Map();
       constructor(deps) {
         this.deps = deps;
       }
@@ -71147,13 +71763,13 @@ ${e?.stderr || ""}`
         };
       }
       getCachedAggregateMeshStatus(meshId, mesh, options) {
-        const cached2 = this.aggregateMeshStatusCache.get(meshId);
-        if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
-        if (cached2.queueRevision !== getMeshQueueRevision(meshId)) return null;
-        let snapshot = this.cloneJsonValue(cached2.snapshot);
+        const cached22 = this.aggregateMeshStatusCache.get(meshId);
+        if (!cached22?.snapshot || cached22.snapshot.success !== true || !Array.isArray(cached22.snapshot.nodes)) return null;
+        if (cached22.queueRevision !== getMeshQueueRevision(meshId)) return null;
+        let snapshot = this.cloneJsonValue(cached22.snapshot);
         snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
         if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
-        const ageMs = Math.max(0, Date.now() - cached2.builtAt);
+        const ageMs = Math.max(0, Date.now() - cached22.builtAt);
         const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
         snapshot.sourceOfTruth = {
           ...sourceOfTruth,
@@ -71164,7 +71780,7 @@ ${e?.stderr || ""}`
             source: "memory",
             refreshReason: "memory_cache_hit",
             ageMs,
-            cachedAt: new Date(cached2.builtAt).toISOString(),
+            cachedAt: new Date(cached22.builtAt).toISOString(),
             returnedAt: (/* @__PURE__ */ new Date()).toISOString()
           }
         };
@@ -71208,9 +71824,9 @@ ${e?.stderr || ""}`
       warmInlineMeshCache(meshId, inlineMesh) {
         if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
         const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
-        const cached2 = this.inlineMeshCache.get(meshId);
-        if (cached2) {
-          const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
+        const cached22 = this.inlineMeshCache.get(meshId);
+        if (cached22) {
+          const merged = reconcileInlineMeshCache(cached22, sanitizedInlineMesh);
           this.inlineMeshCache.set(meshId, merged);
           return merged;
         }
@@ -71220,14 +71836,14 @@ ${e?.stderr || ""}`
       async getMeshForCommand(meshId, inlineMesh, options) {
         const preferInline = options?.preferInline === true;
         if (preferInline) {
-          const cached22 = this.getCachedInlineMesh(meshId);
-          if (cached22) {
+          const cached3 = this.getCachedInlineMesh(meshId);
+          if (cached3) {
             if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
-              const merged = reconcileInlineMeshCache(cached22, inlineMesh);
+              const merged = reconcileInlineMeshCache(cached3, inlineMesh);
               this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
               return { mesh: merged, inline: true, source: "inline_cache" };
             }
-            return { mesh: cached22, inline: true, source: "inline_cache" };
+            return { mesh: cached3, inline: true, source: "inline_cache" };
           }
           if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
             this.warmInlineMeshCache(meshId, inlineMesh);
@@ -71240,8 +71856,8 @@ ${e?.stderr || ""}`
           if (mesh) return { mesh, inline: false, source: "local_config" };
         } catch {
         }
-        const cached2 = this.getCachedInlineMesh(meshId);
-        if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
+        const cached22 = this.getCachedInlineMesh(meshId);
+        if (cached22) return { mesh: cached22, inline: true, source: "inline_cache" };
         const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
         return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
       }
@@ -71548,6 +72164,8 @@ ${e?.stderr || ""}`
         const skippedSessionIds = [];
         const skippedLiveSessionIds = [];
         const skippedCoordinatorSessionIds = [];
+        const skippedLiveSessionReasons = [];
+        const actedLiveDelegateSessionIds = [];
         const deleteUnsupportedSessionIds = [];
         const recordsRemainSessionIds = [];
         const errors = [];
@@ -71581,16 +72199,31 @@ ${e?.stderr || ""}`
           const surfaceKind = getSessionHostSurfaceKind(record2);
           const liveRuntime = surfaceKind === "live_runtime";
           const coordinatorSession = readStringValue(record2?.meta?.meshCoordinatorFor) === args.meshId;
+          const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
+          const recordMeshNodeFor = readStringValue(record2?.meta?.meshNodeFor);
+          const delegateBoundToThisNode = !!recordNodeId && recordNodeId === args.nodeId && (!recordMeshNodeFor || recordMeshNodeFor === args.meshId);
           if (!hasExplicitSessionIds && coordinatorSession) {
             skippedSessionIds.push(sessionId);
             skippedCoordinatorSessionIds.push(sessionId);
             continue;
           }
-          if (!hasExplicitSessionIds && liveRuntime) {
+          if (!hasExplicitSessionIds && liveRuntime && !delegateBoundToThisNode) {
             skippedSessionIds.push(sessionId);
             skippedLiveSessionIds.push(sessionId);
+            const matchedByWorkspaceOnly = !recordNodeId;
+            const reason = recordNodeId && recordNodeId !== args.nodeId ? `live_delegate_bound_to_other_node:${recordNodeId}` : matchedByWorkspaceOnly ? "live_session_matched_by_workspace_only_no_node_binding" : "live_session_not_bound_to_this_node";
+            skippedLiveSessionReasons.push({ sessionId, reason });
             continue;
           }
+          if (!hasExplicitSessionIds && liveRuntime && delegateBoundToThisNode && args.mode === "delete_stopped") {
+            skippedSessionIds.push(sessionId);
+            skippedLiveSessionIds.push(sessionId);
+            skippedLiveSessionReasons.push({ sessionId, reason: "live_delegate_preserved_by_delete_stopped_mode_use_stop_or_stop_and_delete" });
+            continue;
+          }
+          if (!hasExplicitSessionIds && liveRuntime && delegateBoundToThisNode) {
+            actedLiveDelegateSessionIds.push(sessionId);
+          }
           try {
             if (args.mode === "stop") {
               if (!completed) {
@@ -71652,6 +72285,8 @@ ${e?.stderr || ""}`
           skippedSessionIds,
           skippedLiveSessionIds,
           skippedCoordinatorSessionIds,
+          ...actedLiveDelegateSessionIds.length ? { actedLiveDelegateSessionIds } : {},
+          ...skippedLiveSessionReasons.length ? { skippedLiveSessionReasons } : {},
           ...deleteUnsupported ? {
             deleteUnsupported: true,
             effectiveCleanup: args.mode === "stop_and_delete" ? "stopped_only_records_remain" : "delete_unsupported_records_remain",
@@ -72299,6 +72934,48 @@ ${tail}` : ""
               }
             };
           }
+          const effectiveDiffStarted = Date.now();
+          const effectiveDiff = await runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead);
+          recordMeshRefineStage(refineStages, "effective_diff", effectiveDiff.status, effectiveDiffStarted, {
+            hasEffectiveDiff: effectiveDiff.hasEffectiveDiff,
+            changedPaths: effectiveDiff.changedPaths,
+            submoduleHints: effectiveDiff.submoduleHints,
+            ...effectiveDiff.error ? { error: effectiveDiff.error } : {}
+          });
+          if (effectiveDiff.status === "failed" && !effectiveDiff.hasEffectiveDiff) {
+            const hintLines = (effectiveDiff.submoduleHints || []).map((h) => `  - ${h.path}: ${h.reason}`);
+            const message = [
+              `Refinery no-op guard: branch '${branch}' has no effective root-tree diff against '${baseBranch}' (${baseHead.slice(0, 12)}); nothing would merge.`,
+              "This usually means a submodule (e.g. oss) has commits but the root branch never committed the gitlink (pointer) bump, so the merge would be a silent no-op while the real change never reaches main.",
+              hintLines.length ? `Submodules with uncommitted pointer bumps:
+${hintLines.join("\n")}` : "",
+              `Fix: commit the submodule pointer bump on '${branch}' (git add <submodule-path> && git commit), then re-run refine.`
+            ].filter(Boolean).join("\n");
+            return {
+              success: false,
+              code: "no_effective_diff",
+              convergenceStatus: "blocked_review",
+              error: message,
+              branch,
+              into: baseBranch,
+              validationSummary,
+              patchEquivalence,
+              effectiveDiff,
+              refineStages,
+              finalBranchConvergenceState: {
+                branch,
+                baseBranch,
+                merged: false,
+                removed: false,
+                validation: "passed",
+                patchEquivalence: "passed",
+                effectiveDiff: "no_effective_diff",
+                status: "blocked_review",
+                reason: "no_effective_diff",
+                ...effectiveDiff.submoduleHints?.length ? { submoduleHints: effectiveDiff.submoduleHints } : {}
+              }
+            };
+          }
           let mergeResult;
           const mergeStarted = Date.now();
           try {
@@ -72537,8 +73214,8 @@ ${tail}` : ""
         const repoRootBaseRef = /* @__PURE__ */ new Map();
         const submodulePathsByRepoRoot = /* @__PURE__ */ new Map();
         const resolveBaseRef = async (repoRoot) => {
-          const cached2 = repoRootBaseRef.get(repoRoot);
-          if (cached2) return cached2;
+          const cached22 = repoRootBaseRef.get(repoRoot);
+          if (cached22) return cached22;
           let baseBranch = "main";
           try {
             const { stdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
@@ -72640,6 +73317,17 @@ ${tail}` : ""
             note: "Dry-run: no validation, rebase, or merge was executed. Re-run with execute=true to converge nodes in this order."
           };
         }
+        return this.runMeshRefineBatchConvergence(meshId, orderedNodes, ordering, args);
+      }
+      /**
+       * Convergence core shared by the synchronous batch entry and the async batch job.
+       * Refines each node in order: the per-node refine pipeline fetches origin/<base>
+       * fresh, so each merged sibling advances the base before the next node's auto-rebase
+       * + patch-equivalence re-check. A blocked/failed node is isolated; the batch
+       * continues with the remaining nodes. Does NOT touch the per-node merge logic — it
+       * only sequences calls to executeMeshRefineNodeSynchronously and aggregates outcomes.
+       */
+      async runMeshRefineBatchConvergence(meshId, orderedNodes, ordering, args) {
         const results = [];
         for (const node of orderedNodes) {
           let result;
@@ -72694,6 +73382,204 @@ ${tail}` : ""
           }
         };
       }
+      buildRefineBatchJobKey(meshId) {
+        return `${meshId}::batch`;
+      }
+      buildRefineBatchJobHandle(args) {
+        return {
+          success: true,
+          async: true,
+          batch: true,
+          status: args.status || "accepted",
+          jobId: args.jobId || `refine_batch_${createInteractionId()}`,
+          interactionId: args.interactionId || createInteractionId(),
+          meshId: args.meshId,
+          batchLabel: `batch:${args.nodeIds.length} node${args.nodeIds.length === 1 ? "" : "s"}`,
+          nodeIds: args.nodeIds,
+          nodeCount: args.nodeIds.length,
+          order: args.order,
+          startedAt: args.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+          ...args.completedAt ? { completedAt: args.completedAt } : {},
+          ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
+          eventDelivery: { pendingEvents: true, ledger: true },
+          evidence: {
+            pendingEventsCommand: "get_pending_mesh_events",
+            ledgerCommand: "get_mesh_ledger_slice",
+            taskHistoryKind: args.status === "completed" ? "task_completed" : args.status === "failed" ? "task_failed" : "task_dispatched"
+          }
+        };
+      }
+      /**
+       * Emit a batch Refinery terminal/accepted event through the SAME pending-event +
+       * forward mechanism single-node refine uses (queueRefineJobEvent), so the
+       * coordinator's existing refine:accepted/completed/failed handling and message
+       * renderer apply unchanged. The aggregate per-node results ride along in `result`.
+       */
+      queueRefineBatchJobEvent(event, handle, result) {
+        const metadataEvent = {
+          source: "refine_mesh_node_async_job",
+          batch: true,
+          jobId: handle.jobId,
+          interactionId: handle.interactionId,
+          meshId: handle.meshId,
+          nodeId: handle.batchLabel,
+          nodeIds: handle.nodeIds,
+          workspace: void 0,
+          status: handle.status,
+          startedAt: handle.startedAt,
+          completedAt: handle.completedAt,
+          order: handle.order,
+          ...result ? { result } : {}
+        };
+        const eventPayload = {
+          event,
+          meshId: handle.meshId,
+          nodeLabel: handle.batchLabel,
+          nodeId: handle.batchLabel,
+          metadataEvent,
+          queuedAt: Date.now(),
+          ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {}
+        };
+        if (typeof this.deps.instanceManager?.getByCategory === "function") {
+          const forwarded = handleMeshForwardEvent(
+            { instanceManager: this.deps.instanceManager },
+            {
+              event,
+              meshId: handle.meshId,
+              nodeId: handle.batchLabel,
+              jobId: handle.jobId,
+              interactionId: handle.interactionId,
+              status: handle.status,
+              startedAt: handle.startedAt,
+              completedAt: handle.completedAt,
+              ...result ? { result } : {}
+            }
+          );
+          if (forwarded?.success === true) return;
+          LOG2.warn("Mesh", `[Refinery] Failed to forward async refine batch event ${event}: ${forwarded?.error || "unknown error"}`);
+        }
+        queuePendingMeshCoordinatorEvent(eventPayload);
+      }
+      async appendRefineBatchJobLedger(kind, handle, result) {
+        try {
+          const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          appendLedgerEntry2(handle.meshId, {
+            kind,
+            nodeId: handle.batchLabel,
+            payload: {
+              source: "refine_mesh_node_async_job",
+              refineJob: {
+                batch: true,
+                jobId: handle.jobId,
+                interactionId: handle.interactionId,
+                status: handle.status,
+                meshId: handle.meshId,
+                nodeIds: handle.nodeIds,
+                order: handle.order,
+                targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId,
+                startedAt: handle.startedAt,
+                completedAt: handle.completedAt
+              },
+              async: true,
+              batch: true,
+              ...result ? {
+                success: result.success === true,
+                result
+              } : {}
+            }
+          });
+        } catch (e) {
+          LOG2.warn("Mesh", `[Refinery] Failed to append async refine batch ledger entry: ${e?.message || e}`);
+        }
+      }
+      async finishMeshRefineBatchJob(handle, orderedNodes, ordering, args) {
+        const key = this.buildRefineBatchJobKey(handle.meshId);
+        let result;
+        try {
+          result = await this.runMeshRefineBatchConvergence(handle.meshId, orderedNodes, ordering, args);
+        } catch (e) {
+          result = { success: false, error: e?.message || String(e), batch: true };
+        }
+        const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const summary = result.summary && typeof result.summary === "object" ? result.summary : void 0;
+        const allConverged = result.allConverged === true;
+        const isTerminalSuccess = result.success === true && allConverged;
+        const nextStep = typeof result.nextStep === "string" && result.nextStep ? result.nextStep : isTerminalSuccess ? "All batched nodes converged onto base. Continue from the updated mesh state." : "Resolve blocked_review / not_mergeable nodes (see per-node code/stage/error in result.results), then re-run mesh_refine_batch for the remaining nodes.";
+        const normalizedResult = {
+          ...result,
+          batch: true,
+          nextStep,
+          ...summary ? {
+            convergenceStatus: allConverged ? "all_converged" : "partial"
+          } : {}
+        };
+        const terminalHandle = this.buildRefineBatchJobHandle({
+          meshId: handle.meshId,
+          nodeIds: handle.nodeIds,
+          order: handle.order,
+          status: isTerminalSuccess ? "completed" : "failed",
+          startedAt: handle.startedAt,
+          completedAt,
+          jobId: handle.jobId,
+          interactionId: handle.interactionId,
+          coordinatorDaemonId: handle.targetCoordinatorDaemonId
+        });
+        const terminal = { ...terminalHandle, result: normalizedResult };
+        this.terminalRefineBatchJobs.set(key, terminal);
+        this.runningRefineBatchJobs.delete(key);
+        this.invalidateAggregateMeshStatus(handle.meshId);
+        await this.appendRefineBatchJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
+        this.queueRefineBatchJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
+      }
+      /**
+       * Async entry for the batch Refinery execute path. Mirrors startMeshRefineJob:
+       * resolves the plan synchronously (so target/ordering errors and the dry-run shape
+       * stay synchronous), then for execute=true registers an in-flight batch job, returns
+       * {async:true, status:'accepted', batch:true, ...plan} immediately, and runs the
+       * convergence loop in the background — emitting the same terminal refine event.
+       * Idempotent: a batch already in flight for this mesh returns the running handle
+       * with duplicate:true rather than spawning a second background job.
+       */
+      async startMeshRefineBatchJob(meshId, requestedNodeIds, args) {
+        const plan = await this.batchRefineMeshNodes(meshId, requestedNodeIds, { ...args, dryRun: true, execute: false });
+        const planRecord = plan;
+        if (planRecord.success !== true) return plan;
+        if (args?.dryRun === true && args?.execute !== true) return plan;
+        const order = Array.isArray(planRecord.order) ? planRecord.order.filter((v) => typeof v === "string") : [];
+        const nodeIds = order.slice();
+        if (nodeIds.length === 0) {
+          return { ...planRecord, success: true, batch: true, dryRun: false, async: false };
+        }
+        const key = this.buildRefineBatchJobKey(meshId);
+        const running = this.runningRefineBatchJobs.get(key);
+        if (running) return { ...running, duplicate: true };
+        const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        const mesh = meshRecord?.mesh;
+        const allNodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+        const orderedNodes = nodeIds.map((id) => allNodes.find((n) => n.id === id || n.nodeId === id)).filter((n) => !!n);
+        if (orderedNodes.length === 0) {
+          return { success: false, error: "Batch nodes no longer resolvable in mesh", batch: true };
+        }
+        const ordering = {
+          order,
+          rationale: planRecord.orderingRationale
+        };
+        const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
+        const handle = this.buildRefineBatchJobHandle({ meshId, nodeIds, order, coordinatorDaemonId });
+        this.runningRefineBatchJobs.set(key, handle);
+        await this.appendRefineBatchJobLedger("task_dispatched", handle);
+        this.queueRefineBatchJobEvent("refine:accepted", handle);
+        setImmediate(() => {
+          void this.finishMeshRefineBatchJob(handle, orderedNodes, ordering, args);
+        });
+        return {
+          ...handle,
+          order,
+          orderingRationale: planRecord.orderingRationale,
+          plan: planRecord.plan,
+          note: "Batch convergence accepted and running in the background. Completion/failure (with per-node results) will be delivered as a terminal refine event; do not poll repeatedly."
+        };
+      }
       async finishMeshRefineJob(handle, args) {
         const key = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
         let result;
@@ -73227,7 +74113,7 @@ ${tail}` : ""
               version: this.deps.statusVersion || "unknown",
               profile: "metadata"
             });
-            return { success: true, status: snapshot };
+            return { success: true, status: snapshot, daemonBuild: getDaemonBuildInfo() };
           }
           case "get_machine_runtime_stats": {
             return {
@@ -74197,6 +75083,7 @@ ${tail}` : ""
             let workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
             let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths) ? args.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
             let nodeDaemonId;
+            let allowAutoPublishSubmoduleMainCommits = false;
             if (meshId && nodeId) {
               const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
               const mesh = meshRecord?.mesh;
@@ -74207,6 +75094,7 @@ ${tail}` : ""
               if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
                 submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string");
               }
+              allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
               nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
             }
             const selfDaemonId = this.deps.statusInstanceId;
@@ -74227,7 +75115,10 @@ ${tail}` : ""
               execute: args?.execute === true,
               dryRun: args?.dryRun === true,
               updateSubmodules: args?.updateSubmodules === true,
-              submoduleIgnorePaths
+              submoduleIgnorePaths,
+              mode: args?.mode === "push" ? "push" : "merge",
+              pushSubmodules: args?.pushSubmodules === true,
+              allowAutoPublishSubmoduleMainCommits
             });
             return result;
           }
@@ -74241,7 +75132,9 @@ ${tail}` : ""
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             if (!meshId) return { success: false, error: "meshId required" };
             const requestedNodeIds = Array.isArray(args?.nodeIds) ? args.nodeIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
-            return this.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+            const isDryRun = args?.dryRun !== false && args?.execute !== true;
+            if (isDryRun) return this.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+            return this.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
           }
           case "remove_mesh_node": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
@@ -75921,6 +76814,7 @@ ${ptyResult.output.slice(-2e3)}`);
         return h.toString(36);
       }
     };
+    init_build_info();
     init_logger();
     init_debug_config();
     var DEFAULT_DAEMON_PORT2 = 19222;