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

package/dist/index.mjs

@@ -251,6 +251,29 @@ var init_git_executor = __esm({
   }
 });
 
+// src/build-info.ts
+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 (cached) return cached;
+  const commit = readInjected(true ? "751232919b0935654ee3d75d7cee4607594d6836" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "7512329" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = 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:24:06.476Z" : void 0);
+  cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
+  return cached;
+}
+var cached;
+var init_build_info = __esm({
+  "src/build-info.ts"() {
+    "use strict";
+  }
+});
+
 // src/git/git-status.ts
 async function getGitRepoStatus(workspace, options = {}) {
   const lastCheckedAt = Date.now();
@@ -273,6 +296,7 @@ async function getGitRepoStatus(workspace, options = {}) {
     }
     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,
@@ -296,7 +320,8 @@ async function getGitRepoStatus(workspace, options = {}) {
       conflictFiles: parsed.conflictFiles,
       stashCount,
       lastCheckedAt,
-      submodules
+      submodules,
+      ...daemonBuildBehind ? { daemonBuildBehind } : {}
     };
   } catch (error) {
     if (error instanceof GitCommandError) {
@@ -309,6 +334,68 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+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 file of files) {
+      const match = file.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);
@@ -521,10 +608,29 @@ function parseSubmoduleStatusOutput(output, repoRoot, ignorePaths) {
   }
   return submodules;
 }
+var DAEMON_RUNTIME_PACKAGES, WEB_ONLY_PACKAGES;
 var init_git_status = __esm({
   "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"
+    ]);
   }
 });
 
@@ -2385,8 +2491,8 @@ function readLedgerFromStore(meshId) {
 }
 function getCachedRawEntries(meshId) {
   const now = Date.now();
-  const cached = ledgerReadCache.get(meshId);
-  if (cached && now - cached.cachedAt < LEDGER_CACHE_TTL_MS) return cached.entries;
+  const cached2 = ledgerReadCache.get(meshId);
+  if (cached2 && now - cached2.cachedAt < LEDGER_CACHE_TTL_MS) return cached2.entries;
   let entries;
   try {
     entries = readLedgerFromStore(meshId);
@@ -2645,6 +2751,7 @@ __export(mesh_work_queue_exports, {
   cancelTask: () => cancelTask,
   claimNextTask: () => claimNextTask,
   cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
+  deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
   describeTaskDependencyState: () => describeTaskDependencyState,
   enqueueTask: () => enqueueTask,
   getActiveDirectDispatches: () => getActiveDirectDispatches,
@@ -3054,6 +3161,13 @@ function markStaleDirectDispatches(meshId, olderThanMs = 60 * 6e4) {
   } catch {
   }
 }
+function deleteDirectDispatchesByTaskId(meshId, taskIds) {
+  try {
+    return MeshRuntimeStore.getInstance().deleteDirectDispatchesByTaskId(meshId, taskIds);
+  } catch {
+    return 0;
+  }
+}
 function recordMeshToolCall(opts) {
   try {
     return MeshRuntimeStore.getInstance().recordMeshToolCall(opts);
@@ -3685,6 +3799,24 @@ var init_mesh_runtime_store = __esm({
       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();
@@ -5353,11 +5485,14 @@ async function fastForwardMeshNode(args) {
   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,
@@ -5371,13 +5506,24 @@ async function fastForwardMeshNode(args) {
     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;
   }
@@ -5488,7 +5634,246 @@ async function fastForwardMeshNode(args) {
   await appendFastForwardLedger(result, success ? "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 (error) {
+    const result2 = {
+      ...block(base, "push_ff_only_failed", ["push_ff_only_failed"]),
+      current,
+      preStatus: current,
+      pushTarget,
+      operationError: formatGitError2(error),
+      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 success = blockingReasons.length === 0;
+  const code = success ? "push_applied" : submodulePushFailed && postStatus.ahead === 0 ? "push_applied_submodule_push_failed" : "post_push_verify_failed";
+  const result = {
+    ...base,
+    success,
+    code,
+    allowed: true,
+    willRun: true,
+    executed: true,
+    blockingReasons,
+    current,
+    preStatus: current,
+    postStatus,
+    pushTarget,
+    ...submodulePushes ? { submodulePushes } : {},
+    finalBranchConvergenceState: buildConvergenceState(postStatus, success ? "pushed" : "post_verify_failed")
+  };
+  await appendFastForwardLedger(result, success ? "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 (error) {
+    return { ok: false, error: formatGitError2(error) };
+  }
+}
+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 (error) {
+      results.push({ ...base, code: "submodule_fetch_failed", error: formatGitError2(error) });
+      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 (error) {
+      results.push({ ...base, pushed: false, skipped: false, code: "submodule_non_fast_forward", error: formatGitError2(error) });
+      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 (error) {
+      results.push({ ...base, pushed: false, skipped: false, code: "submodule_push_failed", refspec, error: formatGitError2(error) });
+    }
+  }
+  return results;
+}
+function buildPlannedSteps(mode, updateSubmodules, pushSubmodules) {
   const steps = [
     {
       operation: "refresh_upstream",
@@ -5501,20 +5886,49 @@ function buildPlannedSteps(updateSubmodules) {
       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",
@@ -5531,6 +5945,10 @@ function buildPlannedSteps(updateSubmodules) {
   });
   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");
@@ -5587,7 +6005,7 @@ function chooseBlockCode(status, blockers) {
   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";
 }
@@ -5670,6 +6088,7 @@ async function appendFastForwardLedger(result, outcome) {
       ...result.nodeId ? { nodeId: result.nodeId } : {},
       payload: {
         operation: "mesh_fast_forward_node",
+        mode: result.mode,
         trigger: result.trigger || "manual",
         outcome,
         code: result.code,
@@ -5680,6 +6099,7 @@ async function appendFastForwardLedger(result, outcome) {
         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,
@@ -5690,6 +6110,16 @@ async function appendFastForwardLedger(result, outcome) {
           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
       }
     });
@@ -6860,8 +7290,8 @@ var init_mesh_routing = __esm({
 import { existsSync as existsSync14 } from "fs";
 function getCachedMeshByWorkspace(workspace) {
   const now = Date.now();
-  const cached = meshByWorkspaceCache.get(workspace);
-  if (cached && now - cached.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached.mesh;
+  const cached2 = meshByWorkspaceCache.get(workspace);
+  if (cached2 && now - cached2.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached2.mesh;
   const mesh = getMeshByRepo(workspace);
   meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
   return mesh;
@@ -11754,10 +12184,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 cached = this.parsedStatusCache;
+        const cached2 = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-        if (cached && cached.responseBuffer === this.responseBuffer && cached.currentTurnScope === this.engine.currentTurnScope && cached.recentOutputBuffer === this.recentOutputBuffer && cached.accumulatedBuffer === this.accumulatedBuffer && cached.accumulatedRawBufferKey === accumulatedRawBufferKey && cached.screenText === this.lastScreenText && cached.currentStatus === this.engine.currentStatus && cached.activeModal === this.engine.activeModal && cached.cliName === this.cliName) {
-          return cached.result;
+        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;
         }
         return null;
       }
@@ -12217,10 +12647,10 @@ ${lastSnapshot}`;
       getScriptParsedStatus() {
         const screenText = this.readTerminalScreenText();
         const parseScreenText = this.getParseScreenText(screenText);
-        const cached = this.parsedStatusCache;
+        const cached2 = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-        if (!this.providerOwnsTranscript() && cached && cached.responseBuffer === this.responseBuffer && cached.currentTurnScope === this.engine.currentTurnScope && cached.recentOutputBuffer === this.recentOutputBuffer && cached.accumulatedBuffer === this.accumulatedBuffer && cached.accumulatedRawBufferKey === accumulatedRawBufferKey && cached.screenText === parseScreenText && cached.currentStatus === this.engine.currentStatus && cached.activeModal === this.engine.activeModal && cached.cliName === this.cliName) {
-          return cached.result;
+        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;
         }
         const parsed = this.runParseSession();
         if (!parsed || !Array.isArray(parsed.messages)) {
@@ -16701,6 +17131,17 @@ function buildMeshActiveWork(opts) {
   }
   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(record, opts = {}) {
+  if (record.staleDispatchUnacknowledged === true) return "preserve_unacknowledged";
+  if (record.terminal === true) return opts.includeTerminal ? "prunable_terminal" : "preserve_active";
+  if (record.staleReason && PRUNABLE_ORPHAN_STALE_REASONS.has(record.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 = {};
@@ -19924,9 +20365,9 @@ function computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatur
   for (const file of files.slice().sort()) {
     const filePath = path12.join(dir, file);
     const signature = fileSignatures.get(file) || `${file}:missing`;
-    const cached = savedHistoryFileSummaryCache.get(filePath);
+    const cached2 = savedHistoryFileSummaryCache.get(filePath);
     const persisted = persistedEntries.get(file);
-    const reusableEntry = cached?.signature === signature ? cached : persisted?.signature === signature ? persisted : null;
+    const reusableEntry = cached2?.signature === signature ? cached2 : persisted?.signature === signature ? persisted : null;
     const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(dir, file);
     const nextEntry = reusableEntry || {
       signature,
@@ -20378,23 +20819,23 @@ function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
     }
-    const cached = savedHistorySessionCache.get(sanitized);
+    const cached2 = 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 (cached) {
-      const cacheLooksPersisted = cached.signature.startsWith("index:");
-      const cacheStillValid = cacheLooksPersisted ? cached.signature === indexSignature : (() => {
+    if (cached2) {
+      const cacheLooksPersisted = cached2.signature.startsWith("index:");
+      const cacheStillValid = cacheLooksPersisted ? cached2.signature === indexSignature : (() => {
         const files2 = listHistoryFiles(dir);
         const fileSignatures2 = buildSavedHistoryFileSignatureMap(dir, files2);
-        return cached.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+        return cached2.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
       })();
       if (cacheStillValid) {
-        const sliced2 = cached.summaries.slice(offset, offset + limit);
+        const sliced2 = cached2.summaries.slice(offset, offset + limit);
         return {
           sessions: sliced2,
-          hasMore: cached.summaries.length > offset + limit
+          hasMore: cached2.summaries.length > offset + limit
         };
       }
       cacheWasInvalidated = true;
@@ -36988,8 +37429,8 @@ var ProviderLoader = class _ProviderLoader {
       return null;
     }
     registerProviderScriptRootSafely(path30.dirname(path30.dirname(providerDir)));
-    const cached = this.scriptsCache.get(dir);
-    if (cached) return cached;
+    const cached2 = this.scriptsCache.get(dir);
+    if (cached2) return cached2;
     const scriptsJs = path30.join(dir, "scripts.js");
     if (fs20.existsSync(scriptsJs)) {
       try {
@@ -38987,6 +39428,9 @@ function buildStatusSnapshot(options) {
   };
 }
 
+// src/commands/router.ts
+init_build_info();
+
 // src/commands/upgrade-helper.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { spawn as spawn3 } from "child_process";
@@ -39772,13 +40216,13 @@ function sanitizeInlineMesh(inlineMesh) {
     nodes
   };
 }
-function reconcileInlineMeshCache(cached, incoming) {
-  if (!cached || typeof cached !== "object" || Array.isArray(cached)) return incoming;
-  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached;
-  const cachedNodes = Array.isArray(cached.nodes) ? cached.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 : [];
   const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
-  if (!cachedNodes.length || !incomingNodes.length) return { ...cached, ...incoming };
-  const cachedUpdatedAt = Date.parse(readStringValue(cached.updatedAt, cached.updated_at) || "");
+  if (!cachedNodes.length || !incomingNodes.length) return { ...cached2, ...incoming };
+  const cachedUpdatedAt = Date.parse(readStringValue(cached2.updatedAt, cached2.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();
@@ -39807,7 +40251,7 @@ function reconcileInlineMeshCache(cached, incoming) {
     }
   }
   return {
-    ...cached,
+    ...cached2,
     ...incoming,
     nodes
   };
@@ -41491,13 +41935,13 @@ var DaemonCommandRouter = class {
     };
   }
   getCachedAggregateMeshStatus(meshId, mesh, options) {
-    const cached = this.aggregateMeshStatusCache.get(meshId);
-    if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
-    if (cached.queueRevision !== getMeshQueueRevision(meshId)) return null;
-    let snapshot = this.cloneJsonValue(cached.snapshot);
+    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);
     snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
     if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
-    const ageMs = Math.max(0, Date.now() - cached.builtAt);
+    const ageMs = Math.max(0, Date.now() - cached2.builtAt);
     const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
     snapshot.sourceOfTruth = {
       ...sourceOfTruth,
@@ -41508,7 +41952,7 @@ var DaemonCommandRouter = class {
         source: "memory",
         refreshReason: "memory_cache_hit",
         ageMs,
-        cachedAt: new Date(cached.builtAt).toISOString(),
+        cachedAt: new Date(cached2.builtAt).toISOString(),
         returnedAt: (/* @__PURE__ */ new Date()).toISOString()
       }
     };
@@ -41552,9 +41996,9 @@ var DaemonCommandRouter = class {
   warmInlineMeshCache(meshId, inlineMesh) {
     if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
     const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
-    const cached = this.inlineMeshCache.get(meshId);
-    if (cached) {
-      const merged = reconcileInlineMeshCache(cached, sanitizedInlineMesh);
+    const cached2 = this.inlineMeshCache.get(meshId);
+    if (cached2) {
+      const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
       this.inlineMeshCache.set(meshId, merged);
       return merged;
     }
@@ -41564,14 +42008,14 @@ var DaemonCommandRouter = class {
   async getMeshForCommand(meshId, inlineMesh, options) {
     const preferInline = options?.preferInline === true;
     if (preferInline) {
-      const cached2 = this.getCachedInlineMesh(meshId);
-      if (cached2) {
+      const cached3 = this.getCachedInlineMesh(meshId);
+      if (cached3) {
         if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
-          const merged = reconcileInlineMeshCache(cached2, inlineMesh);
+          const merged = reconcileInlineMeshCache(cached3, inlineMesh);
           this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
           return { mesh: merged, inline: true, source: "inline_cache" };
         }
-        return { mesh: cached2, inline: true, source: "inline_cache" };
+        return { mesh: cached3, inline: true, source: "inline_cache" };
       }
       if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
         this.warmInlineMeshCache(meshId, inlineMesh);
@@ -41584,8 +42028,8 @@ var DaemonCommandRouter = class {
       if (mesh) return { mesh, inline: false, source: "local_config" };
     } catch {
     }
-    const cached = this.getCachedInlineMesh(meshId);
-    if (cached) return { mesh: cached, inline: true, source: "inline_cache" };
+    const cached2 = this.getCachedInlineMesh(meshId);
+    if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
     const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
     return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
   }
@@ -41892,6 +42336,8 @@ var DaemonCommandRouter = class {
     const skippedSessionIds = [];
     const skippedLiveSessionIds = [];
     const skippedCoordinatorSessionIds = [];
+    const skippedLiveSessionReasons = [];
+    const actedLiveDelegateSessionIds = [];
     const deleteUnsupportedSessionIds = [];
     const recordsRemainSessionIds = [];
     const errors = [];
@@ -41925,16 +42371,31 @@ var DaemonCommandRouter = class {
       const surfaceKind = getSessionHostSurfaceKind(record);
       const liveRuntime = surfaceKind === "live_runtime";
       const coordinatorSession = readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId;
+      const recordNodeId = readStringValue(record?.meta?.meshNodeId);
+      const recordMeshNodeFor = readStringValue(record?.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) {
@@ -41996,6 +42457,8 @@ var DaemonCommandRouter = class {
       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",
@@ -42762,10 +43225,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((record) => {
+            const sid = typeof record?.sessionId === "string" ? record.sessionId : "";
+            if (!sid) return false;
+            if (readStringValue(record?.meta?.meshCoordinatorFor) === meshId) return false;
+            const boundToNode = readStringValue(record?.meta?.meshNodeId) === nodeId;
+            const matchedByWorkspace = !!workspace && record?.workspace === workspace;
+            return boundToNode || matchedByWorkspace;
+          }).map((record) => String(record.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, {
@@ -42923,8 +43407,8 @@ ${hintLines.join("\n")}` : "",
     const repoRootBaseRef = /* @__PURE__ */ new Map();
     const submodulePathsByRepoRoot = /* @__PURE__ */ new Map();
     const resolveBaseRef = async (repoRoot) => {
-      const cached = repoRootBaseRef.get(repoRoot);
-      if (cached) return cached;
+      const cached2 = repoRootBaseRef.get(repoRoot);
+      if (cached2) return cached2;
       let baseBranch = "main";
       try {
         const { stdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
@@ -43822,7 +44306,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 {
@@ -44792,6 +45276,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;
@@ -44802,6 +45287,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;
@@ -44822,7 +45308,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;
       }
@@ -44830,6 +45319,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": {
@@ -44851,9 +45357,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;
@@ -46522,6 +47036,7 @@ var DaemonStatusReporter = class {
 };
 
 // src/index.ts
+init_build_info();
 init_logger();
 init_debug_config();
 
@@ -54799,6 +55314,7 @@ export {
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   NodePtyTransportFactory,
   P2pRelayFailureError,
+  PRUNABLE_ORPHAN_STALE_REASONS,
   ProviderCliAdapter,
   ProviderInstanceManager,
   ProviderLoader,
@@ -54852,6 +55368,7 @@ export {
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,
   classifyP2pRelayFailure,
+  classifyStaleDirectForPrune,
   cleanupTerminalDirectDispatches,
   clearDebugTrace,
   clearPendingMeshCoordinatorEvents,
@@ -54871,6 +55388,7 @@ export {
   createNativeHistoryDispatcher,
   createSessionDelivery,
   createWorktree,
+  deleteDirectDispatchesByTaskId,
   deleteMesh,
   deriveMeshReviewInboxItems,
   describeTaskDependencyState,
@@ -54899,6 +55417,7 @@ export {
   getAvailableIdeIds,
   getCoordinatorForSession,
   getCurrentDaemonLogPath,
+  getDaemonBuildInfo,
   getDaemonDataDir,
   getDaemonLogDir,
   getDebugRuntimeConfig,