@adhdev/daemon-standalone 0.9.82-rc.262 → 0.9.82-rc.264

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 ? "751232919b0935654ee3d75d7cee4607594d6836" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "7512329" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.264" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-14T15:25:15.217Z" : 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,68 @@ var require_dist3 = __commonJS({
         );
       }
     }
+    async function classifyDaemonBuildChange(repoPath, buildCommit, options) {
+      try {
+        const diff = await runGit(repoPath, ["diff", "--name-only", `${buildCommit}..HEAD`], options);
+        const files = diff.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+        if (files.length === 0) {
+          return { isDaemonAffecting: true, affectedPackages: [] };
+        }
+        const pkgs = /* @__PURE__ */ new Set();
+        let sawNonPackageOrUnknown = false;
+        for (const file2 of files) {
+          const match = file2.match(/(?:^|\/)packages\/([^/]+)\//);
+          if (!match) {
+            sawNonPackageOrUnknown = true;
+            continue;
+          }
+          pkgs.add(match[1]);
+        }
+        const affectedPackages = [...pkgs].sort();
+        const allWebOnly = !sawNonPackageOrUnknown && affectedPackages.length > 0 && affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
+        return { isDaemonAffecting: !allWebOnly, affectedPackages };
+      } catch {
+        return { isDaemonAffecting: true, affectedPackages: [] };
+      }
+    }
+    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);
+          const { isDaemonAffecting, affectedPackages } = await classifyDaemonBuildChange(
+            repoPath,
+            build.commit,
+            options
+          );
+          const scopeLabel = scope === "root" ? "workspace" : scope;
+          const warning = isDaemonAffecting ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} 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.` : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, but only web packages changed (${(affectedPackages || []).join(", ") || "web"}). Daemon restart NOT required \u2014 redeploy the web app to reflect the change.`;
+          return {
+            buildCommit: build.commit,
+            buildCommitShort: build.commitShort,
+            head,
+            scope,
+            isDaemonAffecting,
+            ...affectedPackages && affectedPackages.length > 0 ? { affectedPackages } : {},
+            warning
+          };
+        } catch {
+          continue;
+        }
+      }
+      return void 0;
+    }
     async function readPorcelainStatus(repo, options) {
       const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
       return parsePorcelainV2Status(statusOutput.stdout);
@@ -30234,10 +30319,30 @@ var require_dist3 = __commonJS({
       }
       return submodules;
     }
+    var DAEMON_RUNTIME_PACKAGES;
+    var WEB_ONLY_PACKAGES;
     var init_git_status = __esm2({
       "src/git/git-status.ts"() {
         "use strict";
         init_git_executor();
+        init_build_info();
+        DAEMON_RUNTIME_PACKAGES = /* @__PURE__ */ new Set([
+          "daemon-core",
+          "daemon-standalone",
+          "session-host-core",
+          "session-host-daemon",
+          "terminal-mux-core",
+          "terminal-mux-control",
+          "terminal-mux-cli",
+          "ghostty-vt-node",
+          "mcp-server"
+        ]);
+        WEB_ONLY_PACKAGES = /* @__PURE__ */ new Set([
+          "web-core",
+          "web-standalone",
+          "web-devconsole",
+          "terminal-render-web"
+        ]);
       }
     });
     var git_diff_exports = {};
@@ -32106,8 +32211,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 +32489,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       cancelTask: () => cancelTask,
       claimNextTask: () => claimNextTask,
       cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
+      deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       describeTaskDependencyState: () => describeTaskDependencyState,
       enqueueTask: () => enqueueTask,
       getActiveDirectDispatches: () => getActiveDirectDispatches,
@@ -32792,6 +32898,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 +33548,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 +35252,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 +35273,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 +35401,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 +35653,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 +35712,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 +35772,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 +35855,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 +35866,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 +35877,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 +37057,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 +41957,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 +42420,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 +44294,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 +44348,7 @@ ${lastSnapshot}`;
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       classifyP2pRelayFailure: () => classifyP2pRelayFailure,
+      classifyStaleDirectForPrune: () => classifyStaleDirectForPrune,
       cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
       clearDebugTrace: () => clearDebugTrace,
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
@@ -43937,6 +44368,7 @@ ${lastSnapshot}`;
       createNativeHistoryDispatcher: () => createNativeHistoryDispatcher,
       createSessionDelivery: () => createSessionDelivery,
       createWorktree: () => createWorktree,
+      deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       deleteMesh: () => deleteMesh,
       deriveMeshReviewInboxItems: () => deriveMeshReviewInboxItems,
       describeTaskDependencyState: () => describeTaskDependencyState,
@@ -43965,6 +44397,7 @@ ${lastSnapshot}`;
       getAvailableIdeIds: () => getAvailableIdeIds,
       getCoordinatorForSession: () => getCoordinatorForSession,
       getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
+      getDaemonBuildInfo: () => getDaemonBuildInfo,
       getDaemonDataDir: () => getDaemonDataDir,
       getDaemonLogDir: () => getDaemonLogDir,
       getDebugRuntimeConfig: () => getDebugRuntimeConfig,
@@ -46761,6 +47194,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 +50394,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 +50848,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 +67333,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 +69313,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 +70096,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 +70131,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
       return {
-        ...cached2,
+        ...cached22,
         ...incoming,
         nodes
       };
@@ -71370,13 +71815,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,
@@ -71387,7 +71832,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()
           }
         };
@@ -71431,9 +71876,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;
         }
@@ -71443,14 +71888,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);
@@ -71463,8 +71908,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;
       }
@@ -71771,6 +72216,8 @@ ${e?.stderr || ""}`
         const skippedSessionIds = [];
         const skippedLiveSessionIds = [];
         const skippedCoordinatorSessionIds = [];
+        const skippedLiveSessionReasons = [];
+        const actedLiveDelegateSessionIds = [];
         const deleteUnsupportedSessionIds = [];
         const recordsRemainSessionIds = [];
         const errors = [];
@@ -71804,16 +72251,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) {
@@ -71875,6 +72337,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",
@@ -72641,10 +73105,31 @@ ${hintLines.join("\n")}` : "",
             };
           }
           const cleanupStarted = Date.now();
+          const refineSessionCleanupMode = this.normalizeMeshSessionCleanupMode(
+            mesh?.policy?.sessionCleanupOnNodeRemove
+          );
+          let refineSessionIds;
+          if (refineSessionCleanupMode !== "preserve" && this.deps.sessionHostControl) {
+            try {
+              const liveSessions = await this.deps.sessionHostControl.listSessions();
+              const workspace = typeof node.workspace === "string" ? node.workspace : "";
+              refineSessionIds = liveSessions.filter((record2) => {
+                const sid = typeof record2?.sessionId === "string" ? record2.sessionId : "";
+                if (!sid) return false;
+                if (readStringValue(record2?.meta?.meshCoordinatorFor) === meshId) return false;
+                const boundToNode = readStringValue(record2?.meta?.meshNodeId) === nodeId;
+                const matchedByWorkspace = !!workspace && record2?.workspace === workspace;
+                return boundToNode || matchedByWorkspace;
+              }).map((record2) => String(record2.sessionId));
+            } catch {
+              refineSessionIds = void 0;
+            }
+          }
           const removeResult = await this.execute("remove_mesh_node", {
             meshId,
             nodeId,
-            sessionCleanupMode: "preserve",
+            sessionCleanupMode: refineSessionCleanupMode,
+            ...refineSessionIds && refineSessionIds.length > 0 ? { sessionIds: refineSessionIds } : {},
             inlineMesh: args?.inlineMesh
           });
           recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
@@ -72802,8 +73287,8 @@ ${hintLines.join("\n")}` : "",
         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" });
@@ -73701,7 +74186,7 @@ ${hintLines.join("\n")}` : "",
               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 {
@@ -74671,6 +75156,7 @@ ${hintLines.join("\n")}` : "",
             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;
@@ -74681,6 +75167,7 @@ ${hintLines.join("\n")}` : "",
               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;
@@ -74701,7 +75188,10 @@ ${hintLines.join("\n")}` : "",
               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;
           }
@@ -74709,6 +75199,23 @@ ${hintLines.join("\n")}` : "",
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
             if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+            const isDryRun = args?.dryRun !== false && args?.execute !== true;
+            if (isDryRun) {
+              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+              const mesh = meshRecord?.mesh;
+              const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+              if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+              return {
+                success: true,
+                dryRun: true,
+                nodeId,
+                workspace: node.workspace,
+                validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+                mergeWillRun: false,
+                cleanupWillRun: false,
+                hint: "Dry-run only \u2014 no merge/push/cleanup performed. Re-invoke with execute:true to converge this node."
+              };
+            }
             return this.startMeshRefineJob(meshId, nodeId, args);
           }
           case "batch_refine_mesh_nodes": {
@@ -74730,9 +75237,17 @@ ${hintLines.join("\n")}` : "",
               const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
                 args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
               );
+              const explicitSessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
               let sessionCleanup;
               if (node && sessionCleanupMode !== "preserve") {
-                sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode, source: "mesh_remove_node" });
+                sessionCleanup = await this.cleanupMeshSessions({
+                  meshId,
+                  nodeId,
+                  node,
+                  mode: sessionCleanupMode,
+                  ...explicitSessionIds && explicitSessionIds.length > 0 ? { sessionIds: explicitSessionIds } : {},
+                  source: "mesh_remove_node"
+                });
                 if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
               }
               let worktreeCleanup;
@@ -76397,6 +76912,7 @@ ${ptyResult.output.slice(-2e3)}`);
         return h.toString(36);
       }
     };
+    init_build_info();
     init_logger();
     init_debug_config();
     var DEFAULT_DAEMON_PORT2 = 19222;