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

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 ? "2cf602f99ce68b3d3f1af02b429f6fb7a7c8e686" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "2cf602f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.263" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-14T13:48:10.699Z" : 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,35 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+async function detectDaemonBuildBehind(repo, submodules, options) {
+  const build = options.daemonBuildInfo ?? getDaemonBuildInfo();
+  if (!build.commit || build.commit === "unknown") return void 0;
+  const scopes = [
+    { scope: "root", repoPath: repo.repoRoot || repo.workspace }
+  ];
+  for (const sub of submodules || []) {
+    if (sub.repoPath && !sub.error) scopes.push({ scope: sub.path, repoPath: sub.repoPath });
+  }
+  for (const { scope, repoPath } of scopes) {
+    try {
+      await runGit(repoPath, ["cat-file", "-e", `${build.commit}^{commit}`], options);
+      const headResult = await runGit(repoPath, ["rev-parse", "HEAD"], options);
+      const head = headResult.stdout.trim();
+      if (!head || head === build.commit) continue;
+      await runGit(repoPath, ["merge-base", "--is-ancestor", build.commit, "HEAD"], options);
+      return {
+        buildCommit: build.commit,
+        buildCommitShort: build.commitShort,
+        head,
+        scope,
+        warning: `Live daemon was built from ${build.commitShort} which is behind ${scope === "root" ? "workspace" : scope} HEAD ${head.slice(0, 7)}. Merged code is NOT live until the daemon is rebuilt/redeployed and restarted \u2014 a local dist rebuild alone does not update a cloud daemon.`
+      };
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
 async function readPorcelainStatus(repo, options) {
   const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
   return parsePorcelainV2Status(statusOutput.stdout);
@@ -525,6 +579,7 @@ var init_git_status = __esm({
   "src/git/git-status.ts"() {
     "use strict";
     init_git_executor();
+    init_build_info();
   }
 });
 
@@ -2385,8 +2440,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 +2700,7 @@ __export(mesh_work_queue_exports, {
   cancelTask: () => cancelTask,
   claimNextTask: () => claimNextTask,
   cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
+  deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
   describeTaskDependencyState: () => describeTaskDependencyState,
   enqueueTask: () => enqueueTask,
   getActiveDirectDispatches: () => getActiveDirectDispatches,
@@ -3054,6 +3110,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 +3748,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 +5434,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 +5455,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 +5583,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 +5835,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 +5894,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 +5954,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 +6037,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 +6048,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 +6059,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 +7239,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 +12133,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 +12596,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 +17080,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 +20314,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 +20768,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 +37378,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 +39377,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 +40165,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 +40200,7 @@ function reconcileInlineMeshCache(cached, incoming) {
     }
   }
   return {
-    ...cached,
+    ...cached2,
     ...incoming,
     nodes
   };
@@ -40418,8 +40811,37 @@ async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead)
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
     });
     const mergeBase = git(["merge-base", baseHead, branchHead]).trim();
-    const mergeTreeStdout = git(["merge-tree", "--write-tree", baseHead, branchHead]);
-    const mergedTree = mergeTreeStdout.trim().split(/\s+/)[0] || "";
+    let mergedTree = "";
+    let mergeTreeStdout = "";
+    let gitlinkTrivialFastForward;
+    try {
+      mergeTreeStdout = git(["merge-tree", "--write-tree", baseHead, branchHead]);
+      mergedTree = mergeTreeStdout.trim().split(/\s+/)[0] || "";
+    } catch (mergeTreeErr) {
+      const output = `${mergeTreeErr?.message || ""}
+${mergeTreeErr?.stdout || ""}
+${mergeTreeErr?.stderr || ""}`;
+      const isSubmoduleConflict = /(submodule|160000)/i.test(output) || /Recursive merging with submodules/i.test(output);
+      if (!isSubmoduleConflict) throw mergeTreeErr;
+      const evaluation = evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead);
+      if (!evaluation.trivial) {
+        return {
+          status: "failed",
+          equivalent: false,
+          baseHead,
+          branchHead,
+          mergeBase: mergeBase || void 0,
+          durationMs: Date.now() - startedAt,
+          error: mergeTreeErr?.message || String(mergeTreeErr),
+          stdout: truncateValidationOutput(mergeTreeErr?.stdout),
+          stderr: truncateValidationOutput(mergeTreeErr?.stderr),
+          gitlinkTrivialFastForward: { resolved: false, gitlinks: evaluation.gitlinks, reason: evaluation.reason },
+          actionableHint: buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHead, output)
+        };
+      }
+      mergedTree = synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, evaluation.gitlinks) || "";
+      gitlinkTrivialFastForward = { resolved: true, gitlinks: evaluation.gitlinks };
+    }
     if (!mergeBase || !mergedTree) {
       return {
         status: "failed",
@@ -40430,7 +40852,8 @@ async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead)
         mergedTree: mergedTree || void 0,
         durationMs: Date.now() - startedAt,
         error: "patch equivalence preflight could not resolve merge-base or synthetic merge tree",
-        stdout: truncateValidationOutput(mergeTreeStdout)
+        stdout: truncateValidationOutput(mergeTreeStdout),
+        gitlinkTrivialFastForward
       };
     }
     const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead);
@@ -40445,7 +40868,8 @@ async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead)
       mergedTree,
       expectedPatchId,
       actualPatchId,
-      durationMs: Date.now() - startedAt
+      durationMs: Date.now() - startedAt,
+      gitlinkTrivialFastForward
     };
   } catch (e) {
     return {
@@ -40468,6 +40892,65 @@ ${e?.stderr || ""}`
     };
   }
 }
+async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
+  const startedAt = Date.now();
+  try {
+    const { execFileSync: execFileSync6 } = await import("child_process");
+    const git = (args, opts) => execFileSync6("git", args, {
+      cwd: opts?.cwd || repoRoot,
+      encoding: "utf8",
+      maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+    });
+    const rawDiff = git(["diff", "--raw", baseHead, branchHead]).trim();
+    if (rawDiff) {
+      const changedPaths = rawDiff.split("\n").map((line) => line.split("	").slice(1).join("	").trim()).filter(Boolean).slice(0, 50);
+      return {
+        status: "passed",
+        hasEffectiveDiff: true,
+        baseHead,
+        branchHead,
+        changedPaths,
+        durationMs: Date.now() - startedAt
+      };
+    }
+    const submoduleHints = [];
+    try {
+      const status = git(["submodule", "status"]);
+      for (const line of status.split("\n")) {
+        const trimmed = line.trimEnd();
+        if (!trimmed) continue;
+        if (trimmed.startsWith("+")) {
+          const parts = trimmed.slice(1).trim().split(/\s+/);
+          const path39 = parts[1] || parts[0] || "(unknown)";
+          submoduleHints.push({
+            path: path39,
+            reason: "submodule checked-out commit differs from the committed gitlink (pointer bump not committed on the root branch)"
+          });
+        }
+      }
+    } catch {
+    }
+    return {
+      status: "failed",
+      hasEffectiveDiff: false,
+      baseHead,
+      branchHead,
+      ...submoduleHints.length ? { submoduleHints } : {},
+      durationMs: Date.now() - startedAt
+    };
+  } catch (e) {
+    return {
+      status: "skipped",
+      hasEffectiveDiff: true,
+      baseHead,
+      branchHead,
+      durationMs: Date.now() - startedAt,
+      error: e?.message || String(e),
+      stdout: truncateValidationOutput(e?.stdout),
+      stderr: truncateValidationOutput(e?.stderr)
+    };
+  }
+}
 function buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHead, output) {
   if (!/(submodule|160000)/i.test(output) || !/(conflict|failed to merge)/i.test(output)) return void 0;
   const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path39) => ({
@@ -40524,6 +41007,135 @@ function readTreeObject(repoRoot, ref, path39) {
     return void 0;
   }
 }
+function resolveGitDir(repoRoot) {
+  const out = execFileSync5("git", ["rev-parse", "--absolute-git-dir"], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024
+  }).trim();
+  return out;
+}
+function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
+  if (!baseCommit || !branchCommit) return false;
+  if (baseCommit === branchCommit) return true;
+  try {
+    if (!fs23.existsSync(submoduleRepoPath)) return false;
+    execFileSync5("git", ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+    execFileSync5("git", ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+    execFileSync5("git", ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readChangedPathKinds(repoRoot, fromRef, toRef) {
+  try {
+    const output = execFileSync5("git", ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+    });
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of output.split("\n")) {
+      if (!line.trim()) continue;
+      const metaAndPath = line.split("	");
+      const meta = metaAndPath[0] || "";
+      const path39 = metaAndPath[metaAndPath.length - 1]?.trim();
+      if (!path39 || seen.has(path39)) continue;
+      seen.add(path39);
+      const parts = meta.split(/\s+/);
+      const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
+      result.push({ path: path39, isGitlink });
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
+  const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path39) => {
+    const baseCommit = readTreeObject(repoRoot, baseHead, path39);
+    const branchCommit = readTreeObject(repoRoot, branchHead, path39);
+    const submoduleRepoPath = pathResolve2(repoRoot, path39);
+    const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
+    return { path: path39, baseCommit, branchCommit, fastForward };
+  });
+  if (changedGitlinks.length === 0) {
+    return { trivial: false, reason: "no_changed_gitlinks", gitlinks: changedGitlinks };
+  }
+  const nonFastForward = changedGitlinks.filter((entry) => !entry.fastForward);
+  if (nonFastForward.length > 0) {
+    return {
+      trivial: false,
+      reason: `diverged_gitlinks:${nonFastForward.map((entry) => entry.path).join(",")}`,
+      gitlinks: changedGitlinks
+    };
+  }
+  let mergeBase = "";
+  try {
+    mergeBase = execFileSync5("git", ["merge-base", baseHead, branchHead], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024
+    }).trim();
+  } catch {
+    return { trivial: false, reason: "merge_base_unresolved", gitlinks: changedGitlinks };
+  }
+  if (!mergeBase) {
+    return { trivial: false, reason: "merge_base_unresolved", gitlinks: changedGitlinks };
+  }
+  const baseSideChanges = readChangedPathKinds(repoRoot, mergeBase, baseHead);
+  const branchSideChanges = readChangedPathKinds(repoRoot, mergeBase, branchHead);
+  const baseChangedPaths = new Map(baseSideChanges.map((entry) => [entry.path, entry]));
+  const overlapping = branchSideChanges.filter((entry) => baseChangedPaths.has(entry.path));
+  const nonGitlinkOverlap = overlapping.filter((entry) => {
+    const baseEntry = baseChangedPaths.get(entry.path);
+    return !(entry.isGitlink && baseEntry?.isGitlink);
+  });
+  if (nonGitlinkOverlap.length > 0) {
+    return {
+      trivial: false,
+      reason: `non_gitlink_overlap:${nonGitlinkOverlap.map((entry) => entry.path).join(",")}`,
+      gitlinks: changedGitlinks
+    };
+  }
+  return { trivial: true, gitlinks: changedGitlinks };
+}
+function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, gitlinks) {
+  try {
+    const baseTree = execFileSync5("git", ["rev-parse", `${baseHead}^{tree}`], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024
+    }).trim();
+    if (!baseTree) return void 0;
+    const updates = gitlinks.filter((entry) => entry.branchCommit).map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
+    if (!updates) return baseTree;
+    const tmpIndex = pathJoin(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+    const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+    try {
+      execFileSync5("git", ["read-tree", baseTree], { cwd: repoRoot, env, stdio: "ignore" });
+      execFileSync5("git", ["update-index", "--index-info"], {
+        cwd: repoRoot,
+        env,
+        input: `${updates}
+`,
+        encoding: "utf8",
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+      const newTree = execFileSync5("git", ["write-tree"], { cwd: repoRoot, env, encoding: "utf8" }).trim();
+      return newTree || void 0;
+    } finally {
+      try {
+        fs23.rmSync(tmpIndex, { force: true });
+      } catch {
+      }
+    }
+  } catch {
+    return void 0;
+  }
+}
 async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, currentHead, options = {}) {
   const startedAt = Date.now();
   const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path39) => !(options.submoduleIgnorePaths || []).includes(path39));
@@ -41191,6 +41803,10 @@ var DaemonCommandRouter = class {
   runningRefineJobs = /* @__PURE__ */ new Map();
   /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
   terminalRefineJobs = /* @__PURE__ */ new Map();
+  /** In-memory async batch Refinery jobs keyed by meshId (one batch convergence per mesh at a time). */
+  runningRefineBatchJobs = /* @__PURE__ */ new Map();
+  /** Terminal async batch Refinery jobs preserve the last batch outcome for late readers. */
+  terminalRefineBatchJobs = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -41268,13 +41884,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,
@@ -41285,7 +41901,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()
       }
     };
@@ -41329,9 +41945,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;
     }
@@ -41341,14 +41957,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);
@@ -41361,8 +41977,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;
   }
@@ -41669,6 +42285,8 @@ var DaemonCommandRouter = class {
     const skippedSessionIds = [];
     const skippedLiveSessionIds = [];
     const skippedCoordinatorSessionIds = [];
+    const skippedLiveSessionReasons = [];
+    const actedLiveDelegateSessionIds = [];
     const deleteUnsupportedSessionIds = [];
     const recordsRemainSessionIds = [];
     const errors = [];
@@ -41702,16 +42320,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) {
@@ -41773,6 +42406,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",
@@ -42420,6 +43055,48 @@ ${tail}` : ""
           }
         };
       }
+      const effectiveDiffStarted = Date.now();
+      const effectiveDiff = await runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead);
+      recordMeshRefineStage(refineStages, "effective_diff", effectiveDiff.status, effectiveDiffStarted, {
+        hasEffectiveDiff: effectiveDiff.hasEffectiveDiff,
+        changedPaths: effectiveDiff.changedPaths,
+        submoduleHints: effectiveDiff.submoduleHints,
+        ...effectiveDiff.error ? { error: effectiveDiff.error } : {}
+      });
+      if (effectiveDiff.status === "failed" && !effectiveDiff.hasEffectiveDiff) {
+        const hintLines = (effectiveDiff.submoduleHints || []).map((h) => `  - ${h.path}: ${h.reason}`);
+        const message = [
+          `Refinery no-op guard: branch '${branch}' has no effective root-tree diff against '${baseBranch}' (${baseHead.slice(0, 12)}); nothing would merge.`,
+          "This usually means a submodule (e.g. oss) has commits but the root branch never committed the gitlink (pointer) bump, so the merge would be a silent no-op while the real change never reaches main.",
+          hintLines.length ? `Submodules with uncommitted pointer bumps:
+${hintLines.join("\n")}` : "",
+          `Fix: commit the submodule pointer bump on '${branch}' (git add <submodule-path> && git commit), then re-run refine.`
+        ].filter(Boolean).join("\n");
+        return {
+          success: false,
+          code: "no_effective_diff",
+          convergenceStatus: "blocked_review",
+          error: message,
+          branch,
+          into: baseBranch,
+          validationSummary,
+          patchEquivalence,
+          effectiveDiff,
+          refineStages,
+          finalBranchConvergenceState: {
+            branch,
+            baseBranch,
+            merged: false,
+            removed: false,
+            validation: "passed",
+            patchEquivalence: "passed",
+            effectiveDiff: "no_effective_diff",
+            status: "blocked_review",
+            reason: "no_effective_diff",
+            ...effectiveDiff.submoduleHints?.length ? { submoduleHints: effectiveDiff.submoduleHints } : {}
+          }
+        };
+      }
       let mergeResult;
       const mergeStarted = Date.now();
       try {
@@ -42658,8 +43335,8 @@ ${tail}` : ""
     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" });
@@ -42761,6 +43438,17 @@ ${tail}` : ""
         note: "Dry-run: no validation, rebase, or merge was executed. Re-run with execute=true to converge nodes in this order."
       };
     }
+    return this.runMeshRefineBatchConvergence(meshId, orderedNodes, ordering, args);
+  }
+  /**
+   * Convergence core shared by the synchronous batch entry and the async batch job.
+   * Refines each node in order: the per-node refine pipeline fetches origin/<base>
+   * fresh, so each merged sibling advances the base before the next node's auto-rebase
+   * + patch-equivalence re-check. A blocked/failed node is isolated; the batch
+   * continues with the remaining nodes. Does NOT touch the per-node merge logic — it
+   * only sequences calls to executeMeshRefineNodeSynchronously and aggregates outcomes.
+   */
+  async runMeshRefineBatchConvergence(meshId, orderedNodes, ordering, args) {
     const results = [];
     for (const node of orderedNodes) {
       let result;
@@ -42815,6 +43503,204 @@ ${tail}` : ""
       }
     };
   }
+  buildRefineBatchJobKey(meshId) {
+    return `${meshId}::batch`;
+  }
+  buildRefineBatchJobHandle(args) {
+    return {
+      success: true,
+      async: true,
+      batch: true,
+      status: args.status || "accepted",
+      jobId: args.jobId || `refine_batch_${createInteractionId()}`,
+      interactionId: args.interactionId || createInteractionId(),
+      meshId: args.meshId,
+      batchLabel: `batch:${args.nodeIds.length} node${args.nodeIds.length === 1 ? "" : "s"}`,
+      nodeIds: args.nodeIds,
+      nodeCount: args.nodeIds.length,
+      order: args.order,
+      startedAt: args.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      ...args.completedAt ? { completedAt: args.completedAt } : {},
+      ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
+      eventDelivery: { pendingEvents: true, ledger: true },
+      evidence: {
+        pendingEventsCommand: "get_pending_mesh_events",
+        ledgerCommand: "get_mesh_ledger_slice",
+        taskHistoryKind: args.status === "completed" ? "task_completed" : args.status === "failed" ? "task_failed" : "task_dispatched"
+      }
+    };
+  }
+  /**
+   * Emit a batch Refinery terminal/accepted event through the SAME pending-event +
+   * forward mechanism single-node refine uses (queueRefineJobEvent), so the
+   * coordinator's existing refine:accepted/completed/failed handling and message
+   * renderer apply unchanged. The aggregate per-node results ride along in `result`.
+   */
+  queueRefineBatchJobEvent(event, handle, result) {
+    const metadataEvent = {
+      source: "refine_mesh_node_async_job",
+      batch: true,
+      jobId: handle.jobId,
+      interactionId: handle.interactionId,
+      meshId: handle.meshId,
+      nodeId: handle.batchLabel,
+      nodeIds: handle.nodeIds,
+      workspace: void 0,
+      status: handle.status,
+      startedAt: handle.startedAt,
+      completedAt: handle.completedAt,
+      order: handle.order,
+      ...result ? { result } : {}
+    };
+    const eventPayload = {
+      event,
+      meshId: handle.meshId,
+      nodeLabel: handle.batchLabel,
+      nodeId: handle.batchLabel,
+      metadataEvent,
+      queuedAt: Date.now(),
+      ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {}
+    };
+    if (typeof this.deps.instanceManager?.getByCategory === "function") {
+      const forwarded = handleMeshForwardEvent(
+        { instanceManager: this.deps.instanceManager },
+        {
+          event,
+          meshId: handle.meshId,
+          nodeId: handle.batchLabel,
+          jobId: handle.jobId,
+          interactionId: handle.interactionId,
+          status: handle.status,
+          startedAt: handle.startedAt,
+          completedAt: handle.completedAt,
+          ...result ? { result } : {}
+        }
+      );
+      if (forwarded?.success === true) return;
+      LOG.warn("Mesh", `[Refinery] Failed to forward async refine batch event ${event}: ${forwarded?.error || "unknown error"}`);
+    }
+    queuePendingMeshCoordinatorEvent(eventPayload);
+  }
+  async appendRefineBatchJobLedger(kind, handle, result) {
+    try {
+      const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+      appendLedgerEntry2(handle.meshId, {
+        kind,
+        nodeId: handle.batchLabel,
+        payload: {
+          source: "refine_mesh_node_async_job",
+          refineJob: {
+            batch: true,
+            jobId: handle.jobId,
+            interactionId: handle.interactionId,
+            status: handle.status,
+            meshId: handle.meshId,
+            nodeIds: handle.nodeIds,
+            order: handle.order,
+            targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId,
+            startedAt: handle.startedAt,
+            completedAt: handle.completedAt
+          },
+          async: true,
+          batch: true,
+          ...result ? {
+            success: result.success === true,
+            result
+          } : {}
+        }
+      });
+    } catch (e) {
+      LOG.warn("Mesh", `[Refinery] Failed to append async refine batch ledger entry: ${e?.message || e}`);
+    }
+  }
+  async finishMeshRefineBatchJob(handle, orderedNodes, ordering, args) {
+    const key = this.buildRefineBatchJobKey(handle.meshId);
+    let result;
+    try {
+      result = await this.runMeshRefineBatchConvergence(handle.meshId, orderedNodes, ordering, args);
+    } catch (e) {
+      result = { success: false, error: e?.message || String(e), batch: true };
+    }
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const summary = result.summary && typeof result.summary === "object" ? result.summary : void 0;
+    const allConverged = result.allConverged === true;
+    const isTerminalSuccess = result.success === true && allConverged;
+    const nextStep = typeof result.nextStep === "string" && result.nextStep ? result.nextStep : isTerminalSuccess ? "All batched nodes converged onto base. Continue from the updated mesh state." : "Resolve blocked_review / not_mergeable nodes (see per-node code/stage/error in result.results), then re-run mesh_refine_batch for the remaining nodes.";
+    const normalizedResult = {
+      ...result,
+      batch: true,
+      nextStep,
+      ...summary ? {
+        convergenceStatus: allConverged ? "all_converged" : "partial"
+      } : {}
+    };
+    const terminalHandle = this.buildRefineBatchJobHandle({
+      meshId: handle.meshId,
+      nodeIds: handle.nodeIds,
+      order: handle.order,
+      status: isTerminalSuccess ? "completed" : "failed",
+      startedAt: handle.startedAt,
+      completedAt,
+      jobId: handle.jobId,
+      interactionId: handle.interactionId,
+      coordinatorDaemonId: handle.targetCoordinatorDaemonId
+    });
+    const terminal = { ...terminalHandle, result: normalizedResult };
+    this.terminalRefineBatchJobs.set(key, terminal);
+    this.runningRefineBatchJobs.delete(key);
+    this.invalidateAggregateMeshStatus(handle.meshId);
+    await this.appendRefineBatchJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
+    this.queueRefineBatchJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
+  }
+  /**
+   * Async entry for the batch Refinery execute path. Mirrors startMeshRefineJob:
+   * resolves the plan synchronously (so target/ordering errors and the dry-run shape
+   * stay synchronous), then for execute=true registers an in-flight batch job, returns
+   * {async:true, status:'accepted', batch:true, ...plan} immediately, and runs the
+   * convergence loop in the background — emitting the same terminal refine event.
+   * Idempotent: a batch already in flight for this mesh returns the running handle
+   * with duplicate:true rather than spawning a second background job.
+   */
+  async startMeshRefineBatchJob(meshId, requestedNodeIds, args) {
+    const plan = await this.batchRefineMeshNodes(meshId, requestedNodeIds, { ...args, dryRun: true, execute: false });
+    const planRecord = plan;
+    if (planRecord.success !== true) return plan;
+    if (args?.dryRun === true && args?.execute !== true) return plan;
+    const order = Array.isArray(planRecord.order) ? planRecord.order.filter((v) => typeof v === "string") : [];
+    const nodeIds = order.slice();
+    if (nodeIds.length === 0) {
+      return { ...planRecord, success: true, batch: true, dryRun: false, async: false };
+    }
+    const key = this.buildRefineBatchJobKey(meshId);
+    const running = this.runningRefineBatchJobs.get(key);
+    if (running) return { ...running, duplicate: true };
+    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+    const mesh = meshRecord?.mesh;
+    const allNodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+    const orderedNodes = nodeIds.map((id) => allNodes.find((n) => n.id === id || n.nodeId === id)).filter((n) => !!n);
+    if (orderedNodes.length === 0) {
+      return { success: false, error: "Batch nodes no longer resolvable in mesh", batch: true };
+    }
+    const ordering = {
+      order,
+      rationale: planRecord.orderingRationale
+    };
+    const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
+    const handle = this.buildRefineBatchJobHandle({ meshId, nodeIds, order, coordinatorDaemonId });
+    this.runningRefineBatchJobs.set(key, handle);
+    await this.appendRefineBatchJobLedger("task_dispatched", handle);
+    this.queueRefineBatchJobEvent("refine:accepted", handle);
+    setImmediate(() => {
+      void this.finishMeshRefineBatchJob(handle, orderedNodes, ordering, args);
+    });
+    return {
+      ...handle,
+      order,
+      orderingRationale: planRecord.orderingRationale,
+      plan: planRecord.plan,
+      note: "Batch convergence accepted and running in the background. Completion/failure (with per-node results) will be delivered as a terminal refine event; do not poll repeatedly."
+    };
+  }
   async finishMeshRefineJob(handle, args) {
     const key = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
     let result;
@@ -43348,7 +44234,7 @@ ${tail}` : ""
           version: this.deps.statusVersion || "unknown",
           profile: "metadata"
         });
-        return { success: true, status: snapshot };
+        return { success: true, status: snapshot, daemonBuild: getDaemonBuildInfo() };
       }
       case "get_machine_runtime_stats": {
         return {
@@ -44318,6 +45204,7 @@ ${tail}` : ""
         let workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
         let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths) ? args.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
         let nodeDaemonId;
+        let allowAutoPublishSubmoduleMainCommits = false;
         if (meshId && nodeId) {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
@@ -44328,6 +45215,7 @@ ${tail}` : ""
           if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
             submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string");
           }
+          allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
           nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
         }
         const selfDaemonId = this.deps.statusInstanceId;
@@ -44348,7 +45236,10 @@ ${tail}` : ""
           execute: args?.execute === true,
           dryRun: args?.dryRun === true,
           updateSubmodules: args?.updateSubmodules === true,
-          submoduleIgnorePaths
+          submoduleIgnorePaths,
+          mode: args?.mode === "push" ? "push" : "merge",
+          pushSubmodules: args?.pushSubmodules === true,
+          allowAutoPublishSubmoduleMainCommits
         });
         return result;
       }
@@ -44362,7 +45253,9 @@ ${tail}` : ""
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
         const requestedNodeIds = Array.isArray(args?.nodeIds) ? args.nodeIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
-        return this.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+        const isDryRun = args?.dryRun !== false && args?.execute !== true;
+        if (isDryRun) return this.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+        return this.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
       }
       case "remove_mesh_node": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
@@ -46046,6 +46939,7 @@ var DaemonStatusReporter = class {
 };
 
 // src/index.ts
+init_build_info();
 init_logger();
 init_debug_config();
 
@@ -54323,6 +55217,7 @@ export {
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   NodePtyTransportFactory,
   P2pRelayFailureError,
+  PRUNABLE_ORPHAN_STALE_REASONS,
   ProviderCliAdapter,
   ProviderInstanceManager,
   ProviderLoader,
@@ -54376,6 +55271,7 @@ export {
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,
   classifyP2pRelayFailure,
+  classifyStaleDirectForPrune,
   cleanupTerminalDirectDispatches,
   clearDebugTrace,
   clearPendingMeshCoordinatorEvents,
@@ -54395,6 +55291,7 @@ export {
   createNativeHistoryDispatcher,
   createSessionDelivery,
   createWorktree,
+  deleteDirectDispatchesByTaskId,
   deleteMesh,
   deriveMeshReviewInboxItems,
   describeTaskDependencyState,
@@ -54423,6 +55320,7 @@ export {
   getAvailableIdeIds,
   getCoordinatorForSession,
   getCurrentDaemonLogPath,
+  getDaemonBuildInfo,
   getDaemonDataDir,
   getDaemonLogDir,
   getDebugRuntimeConfig,