@adhdev/daemon-standalone 0.9.82-rc.172 → 0.9.82-rc.173

package/dist/index.js

@@ -35008,6 +35008,261 @@ var require_dist3 = __commonJS({
         };
       }
     });
+    async function getGitRepoStatus(workspace, options = {}) {
+      const lastCheckedAt = Date.now();
+      const includeSubmodules = options.includeSubmodules !== false;
+      try {
+        const repo = await resolveGitRepository(workspace, options);
+        let parsed = await readPorcelainStatus(repo, options);
+        let upstreamProbe = getInitialUpstreamProbe(parsed);
+        if (options.refreshUpstream) {
+          upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
+          if (upstreamProbe.upstreamStatus === "fresh") {
+            parsed = await readPorcelainStatus(repo, options);
+          }
+        }
+        const head = await readHead(repo, options);
+        const stashCount = await readStashCount(repo, options);
+        let submodules;
+        if (includeSubmodules) {
+          submodules = await getSubmoduleStatuses(repo, options);
+        }
+        return {
+          workspace: repo.workspace,
+          repoRoot: repo.repoRoot,
+          isGitRepo: true,
+          branch: parsed.branch,
+          headCommit: head.commit,
+          headMessage: head.message,
+          upstream: parsed.upstream,
+          upstreamStatus: parsed.upstream ? upstreamProbe.upstreamStatus : "no_upstream",
+          upstreamFetchedAt: upstreamProbe.upstreamFetchedAt,
+          upstreamFetchError: upstreamProbe.upstreamFetchError,
+          ahead: parsed.ahead,
+          behind: parsed.behind,
+          staged: parsed.staged,
+          modified: parsed.modified,
+          untracked: parsed.untracked,
+          deleted: parsed.deleted,
+          renamed: parsed.renamed,
+          hasConflicts: parsed.conflictFiles.length > 0,
+          conflictFiles: parsed.conflictFiles,
+          stashCount,
+          lastCheckedAt,
+          submodules
+        };
+      } catch (error48) {
+        if (error48 instanceof GitCommandError) {
+          return emptyStatus(workspace, lastCheckedAt, error48);
+        }
+        return emptyStatus(
+          workspace,
+          lastCheckedAt,
+          new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error48 })
+        );
+      }
+    }
+    async function readPorcelainStatus(repo, options) {
+      const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
+      return parsePorcelainV2Status(statusOutput.stdout);
+    }
+    function getInitialUpstreamProbe(parsed) {
+      return {
+        upstreamStatus: parsed.upstream ? "unchecked" : "no_upstream"
+      };
+    }
+    async function refreshTrackedUpstream(repo, parsed, options) {
+      if (!parsed.upstream || !parsed.branch) {
+        return { upstreamStatus: "no_upstream" };
+      }
+      const remoteName = await readBranchRemote(repo, parsed.branch, options) ?? inferRemoteName(parsed.upstream);
+      if (!remoteName) {
+        return {
+          upstreamStatus: "stale",
+          upstreamFetchError: `Unable to resolve remote for upstream '${parsed.upstream}'`
+        };
+      }
+      try {
+        await runGit(repo, ["fetch", "--quiet", "--prune", "--no-tags", remoteName], options);
+        return {
+          upstreamStatus: "fresh",
+          upstreamFetchedAt: Date.now()
+        };
+      } catch (error48) {
+        return {
+          upstreamStatus: "stale",
+          upstreamFetchError: formatGitError(error48)
+        };
+      }
+    }
+    async function readBranchRemote(repo, branch, options) {
+      try {
+        const result = await runGit(repo, ["config", "--get", `branch.${branch}.remote`], options);
+        return result.stdout.trim() || null;
+      } catch {
+        return null;
+      }
+    }
+    function inferRemoteName(upstream) {
+      const [remoteName] = upstream.split("/");
+      return remoteName?.trim() || null;
+    }
+    function formatGitError(error48) {
+      if (error48 instanceof GitCommandError) {
+        return error48.stderr || error48.message;
+      }
+      if (error48 instanceof Error) {
+        return error48.message;
+      }
+      return String(error48);
+    }
+    function parsePorcelainV2Status(output) {
+      const parsed = {
+        branch: null,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        modified: 0,
+        untracked: 0,
+        deleted: 0,
+        renamed: 0,
+        conflictFiles: []
+      };
+      for (const line of output.split("\n")) {
+        if (!line) continue;
+        if (line.startsWith("# branch.head ")) {
+          const branch = line.slice("# branch.head ".length).trim();
+          parsed.branch = branch && branch !== "(detached)" ? branch : null;
+          continue;
+        }
+        if (line.startsWith("# branch.upstream ")) {
+          parsed.upstream = line.slice("# branch.upstream ".length).trim() || null;
+          continue;
+        }
+        if (line.startsWith("# branch.ab ")) {
+          const match = line.match(/\+(-?\d+)\s+-(-?\d+)/);
+          if (match) {
+            parsed.ahead = Number.parseInt(match[1] ?? "0", 10) || 0;
+            parsed.behind = Number.parseInt(match[2] ?? "0", 10) || 0;
+          }
+          continue;
+        }
+        if (line.startsWith("? ")) {
+          parsed.untracked += 1;
+          continue;
+        }
+        if (line.startsWith("u ")) {
+          const fields = line.split(" ");
+          const filePath = fields.slice(10).join(" ");
+          if (filePath) parsed.conflictFiles.push(filePath);
+          continue;
+        }
+        if (line.startsWith("1 ") || line.startsWith("2 ")) {
+          const fields = line.split(" ");
+          const xy = fields[1] ?? "..";
+          const indexStatus = xy[0] ?? ".";
+          const worktreeStatus = xy[1] ?? ".";
+          if (isStagedStatus(indexStatus)) parsed.staged += 1;
+          if (worktreeStatus === "M" || worktreeStatus === "T") parsed.modified += 1;
+          if (indexStatus === "D" || worktreeStatus === "D") parsed.deleted += 1;
+          if (indexStatus === "R" || worktreeStatus === "R") parsed.renamed += 1;
+          if (xy.includes("U")) {
+            const filePath = fields.slice(line.startsWith("2 ") ? 9 : 8).join(" ").split("	")[0] ?? "";
+            if (filePath) parsed.conflictFiles.push(filePath);
+          }
+        }
+      }
+      parsed.conflictFiles = Array.from(new Set(parsed.conflictFiles));
+      return parsed;
+    }
+    async function readHead(repo, options) {
+      try {
+        const result = await runGit(repo, ["log", "-1", "--pretty=%h%x00%s"], options);
+        const text = result.stdout.trimEnd();
+        if (!text) return { commit: null, message: null };
+        const [commit, ...messageParts] = text.split("\0");
+        return {
+          commit: commit || null,
+          message: messageParts.join("\0") || null
+        };
+      } catch {
+        return { commit: null, message: null };
+      }
+    }
+    async function readStashCount(repo, options) {
+      try {
+        const result = await runGit(repo, ["stash", "list", "--format=%gd"], options);
+        return result.stdout.split("\n").filter((line) => line.trim().length > 0).length;
+      } catch {
+        return 0;
+      }
+    }
+    function isStagedStatus(status) {
+      return status !== "." && status !== "?" && status !== "U";
+    }
+    function emptyStatus(workspace, lastCheckedAt, error48) {
+      return {
+        workspace,
+        repoRoot: null,
+        isGitRepo: false,
+        branch: null,
+        headCommit: null,
+        headMessage: null,
+        upstream: null,
+        upstreamStatus: "unavailable",
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        modified: 0,
+        untracked: 0,
+        deleted: 0,
+        renamed: 0,
+        hasConflicts: false,
+        conflictFiles: [],
+        stashCount: 0,
+        lastCheckedAt,
+        error: error48.stderr || error48.message,
+        reason: error48.reason
+      };
+    }
+    async function getSubmoduleStatuses(repo, options) {
+      if (!repo.repoRoot) return [];
+      try {
+        const result = await runGit(repo, ["submodule", "status", "--recursive"], options);
+        return parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
+      } catch {
+        return [];
+      }
+    }
+    function parseSubmoduleStatusOutput(output, repoRoot, ignorePaths) {
+      const submodules = [];
+      const ignoreSet = new Set(ignorePaths || []);
+      for (const line of output.split("\n")) {
+        if (!line.trim()) continue;
+        const match = line.match(/^([\-+\s])([0-9a-f]{40})\s+(\S+)(?:\s+\(([^)]+)\))?/);
+        if (!match) continue;
+        const prefix = match[1];
+        const commit = match[2];
+        const path40 = match[3];
+        if (ignoreSet.has(path40)) continue;
+        submodules.push({
+          path: path40,
+          commit,
+          repoPath: repoRoot + "/" + path40,
+          dirty: prefix === "+",
+          outOfSync: prefix === "-",
+          lastCheckedAt: Date.now()
+        });
+      }
+      return submodules;
+    }
+    var init_git_status = __esm2({
+      "src/git/git-status.ts"() {
+        "use strict";
+        init_git_executor();
+      }
+    });
     var git_worktree_exports = {};
     __export2(git_worktree_exports, {
       createWorktree: () => createWorktree,
@@ -35540,6 +35795,16 @@ ${error48.message || ""}`;
         return { meshes: [] };
       }
     }
+    function normalizeCapabilityTags(value) {
+      if (!Array.isArray(value)) return void 0;
+      const seen = /* @__PURE__ */ new Set();
+      const tags = value.map((tag) => typeof tag === "string" ? tag.trim() : "").filter(Boolean).filter((tag) => {
+        if (seen.has(tag)) return false;
+        seen.add(tag);
+        return true;
+      });
+      return tags.length ? tags : void 0;
+    }
     function saveMeshConfig(config2) {
       const path40 = getMeshConfigPath();
       (0, import_fs2.writeFileSync)(path40, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
@@ -35825,6 +36090,7 @@ ${error48.message || ""}`;
         repoRoot: opts.repoRoot,
         daemonId: opts.daemonId,
         machineId: opts.machineId,
+        capabilities: normalizeCapabilityTags(opts.capabilities),
         userOverrides: opts.userOverrides || {},
         policy: opts.policy || {},
         isLocalWorktree: opts.isLocalWorktree,
@@ -37349,6 +37615,367 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         LEDGER_CACHE_TTL_MS = 100;
       }
     });
+    async function fastForwardMeshNode(args) {
+      const workspace = typeof args.workspace === "string" ? args.workspace.trim() : "";
+      const nodeId = normalizeOptionalString(args.nodeId);
+      const meshId = normalizeOptionalString(args.meshId);
+      const requestedBranch = normalizeOptionalString(args.branch);
+      const trigger = normalizeOptionalString(args.trigger) || "manual";
+      const updateSubmodules = args.updateSubmodules === true;
+      const dryRun = args.dryRun === true || args.execute !== true;
+      const plannedSteps = buildPlannedSteps(updateSubmodules);
+      const base = {
+        ...nodeId ? { nodeId } : {},
+        ...meshId ? { meshId } : {},
+        workspace,
+        dryRun,
+        updateSubmodules,
+        plannedSteps,
+        trigger
+      };
+      if (!workspace) {
+        return block(base, "invalid_workspace", ["workspace_required"]);
+      }
+      const current = await getGitRepoStatus(workspace, {
+        ...STATUS_OPTIONS,
+        submoduleIgnorePaths: args.submoduleIgnorePaths,
+        timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
+      });
+      const earlyBlockers = collectPreflightBlockers(current, requestedBranch);
+      if (earlyBlockers.length > 0) {
+        const result2 = {
+          ...block(base, chooseBlockCode(current, earlyBlockers), earlyBlockers),
+          current,
+          finalBranchConvergenceState: buildConvergenceState(current, codeToConvergenceStatus(chooseBlockCode(current, earlyBlockers)))
+        };
+        await appendFastForwardLedger(result2, "blocked");
+        return result2;
+      }
+      if (current.behind === 0) {
+        const result2 = {
+          ...base,
+          success: true,
+          code: "already_up_to_date",
+          allowed: true,
+          willRun: false,
+          executed: false,
+          blockingReasons: [],
+          current,
+          preStatus: current,
+          postStatus: current,
+          finalBranchConvergenceState: buildConvergenceState(current, "up_to_date")
+        };
+        await appendFastForwardLedger(result2, "noop");
+        return result2;
+      }
+      const ancestorCheck = await verifyHeadIsAncestorOfUpstream(workspace, current.upstream || "", args.timeoutMs);
+      if (!ancestorCheck.ok) {
+        const result2 = {
+          ...block(base, "non_fast_forward", ["head_is_not_ancestor_of_upstream"]),
+          current,
+          preStatus: current,
+          operationError: ancestorCheck.error,
+          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
+        };
+        await appendFastForwardLedger(result2, "blocked");
+        return result2;
+      }
+      if (dryRun) {
+        const result2 = {
+          ...base,
+          success: true,
+          code: "fast_forward_available",
+          allowed: true,
+          willRun: false,
+          executed: false,
+          blockingReasons: [],
+          current,
+          preStatus: current,
+          finalBranchConvergenceState: buildConvergenceState(current, "fast_forward_available")
+        };
+        await appendFastForwardLedger(result2, "dry_run");
+        return result2;
+      }
+      try {
+        await runGit(workspace, ["merge", "--ff-only", current.upstream || ""], { timeoutMs: args.timeoutMs ?? 3e4 });
+      } catch (error48) {
+        const result2 = {
+          ...block(base, "merge_ff_only_failed", ["merge_ff_only_failed"]),
+          current,
+          preStatus: current,
+          operationError: formatGitError2(error48),
+          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
+        };
+        await appendFastForwardLedger(result2, "failed");
+        return result2;
+      }
+      let postStatus = await getGitRepoStatus(workspace, {
+        ...STATUS_OPTIONS,
+        submoduleIgnorePaths: args.submoduleIgnorePaths,
+        timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
+      });
+      const submoduleIssues = collectSubmoduleBlockers(postStatus, "post");
+      let submoduleFollowUpRequired = false;
+      let operationError;
+      if (submoduleIssues.length > 0) {
+        if (updateSubmodules) {
+          try {
+            await runGit(workspace, ["submodule", "update", "--init", "--recursive"], { timeoutMs: args.timeoutMs ?? 6e4 });
+            postStatus = await getGitRepoStatus(workspace, {
+              ...STATUS_OPTIONS,
+              submoduleIgnorePaths: args.submoduleIgnorePaths,
+              timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
+            });
+          } catch (error48) {
+            operationError = formatGitError2(error48);
+          }
+        } else {
+          submoduleFollowUpRequired = true;
+        }
+      }
+      const postBlockers = collectPostExecutionBlockers(postStatus);
+      if (operationError) postBlockers.push("submodule_update_failed");
+      if (submoduleFollowUpRequired) postBlockers.push("submodule_update_required");
+      const success2 = postBlockers.length === 0 || submoduleFollowUpRequired;
+      const code = postBlockers.length === 0 ? "fast_forward_applied" : submoduleFollowUpRequired ? "fast_forward_applied_submodule_update_required" : "post_verify_failed";
+      const result = {
+        ...base,
+        success: success2,
+        code,
+        allowed: true,
+        willRun: true,
+        executed: true,
+        blockingReasons: postBlockers,
+        current,
+        preStatus: current,
+        postStatus,
+        ...operationError ? { operationError } : {},
+        finalBranchConvergenceState: buildConvergenceState(
+          postStatus,
+          postBlockers.length === 0 ? "fast_forwarded" : submoduleFollowUpRequired ? "follow_up_required" : "post_verify_failed"
+        )
+      };
+      await appendFastForwardLedger(result, success2 ? "executed" : "failed");
+      return result;
+    }
+    function buildPlannedSteps(updateSubmodules) {
+      const steps = [
+        {
+          operation: "refresh_upstream",
+          description: "Refresh the tracked upstream remote ref before trusting ahead/behind state.",
+          safe: true,
+          willMutateWorktree: false
+        },
+        {
+          operation: "verify_clean_worktree",
+          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.",
+          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.",
+          safe: true,
+          willMutateWorktree: true
+        }
+      ];
+      if (updateSubmodules) {
+        steps.push({
+          operation: "submodule_update",
+          description: "If the fast-forward changes gitlinks, run git submodule update --init --recursive and re-verify submodules.",
+          safe: true,
+          willMutateWorktree: true
+        });
+      }
+      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;
+    }
+    function collectPreflightBlockers(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");
+      blockers.push(...collectSubmoduleBlockers(status, "pre"));
+      if (status.ahead > 0 && status.behind > 0) {
+        blockers.push("branch_diverged_from_upstream");
+        blockers.push("branch_has_local_commits");
+      } else if (status.ahead > 0) blockers.push("branch_has_local_commits");
+      return blockers;
+    }
+    function collectPostExecutionBlockers(status) {
+      const blockers = [];
+      if (!status.isGitRepo) blockers.push("post_not_git_repo");
+      if (status.hasConflicts) blockers.push("post_conflicts_present");
+      if (status.ahead !== 0) blockers.push("post_branch_ahead");
+      if (status.behind !== 0) blockers.push("post_branch_still_behind");
+      if (status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0) {
+        blockers.push("post_working_tree_not_clean");
+      }
+      if (status.stashCount > 0) blockers.push("post_stash_entries_present");
+      blockers.push(...collectSubmoduleBlockers(status, "post"));
+      return blockers;
+    }
+    function collectSubmoduleBlockers(status, phase) {
+      const submodules = Array.isArray(status.submodules) ? status.submodules : [];
+      const blockers = [];
+      for (const submodule of submodules) {
+        if (submodule.error) blockers.push(`${phase}_submodule_status_error:${submodule.path}`);
+        if (submodule.dirty) blockers.push(`${phase}_submodule_dirty:${submodule.path}`);
+        if (submodule.outOfSync) blockers.push(`${phase}_submodule_out_of_sync:${submodule.path}`);
+      }
+      return blockers;
+    }
+    function chooseBlockCode(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.some((reason) => reason.includes("submodule"))) return "submodule_not_clean";
+      if (blockers.includes("branch_diverged_from_upstream")) return "branch_diverged";
+      if (blockers.includes("branch_has_local_commits") || status.ahead > 0) return "branch_ahead";
+      if (blockers.some((reason) => reason.includes("changes") || reason.includes("conflicts") || reason.includes("stash"))) return "dirty_worktree";
+      return "preflight_blocked";
+    }
+    function codeToConvergenceStatus(code) {
+      if (code === "branch_diverged" || code === "branch_ahead" || code === "non_fast_forward") return "not_mergeable";
+      if (code === "dirty_worktree" || code === "submodule_not_clean") return "blocked_review";
+      return "blocked";
+    }
+    async function verifyHeadIsAncestorOfUpstream(workspace, upstream, timeoutMs) {
+      if (!upstream) return { ok: false, error: "missing upstream" };
+      try {
+        await runGit(workspace, ["merge-base", "--is-ancestor", "HEAD", upstream], { timeoutMs: timeoutMs ?? 15e3 });
+        return { ok: true };
+      } catch (error48) {
+        return { ok: false, error: formatGitError2(error48) };
+      }
+    }
+    function block(base, code, blockingReasons) {
+      const normalizedReasons = normalizeBlockingReasons(blockingReasons);
+      return {
+        ...base,
+        success: false,
+        code,
+        allowed: false,
+        willRun: false,
+        executed: false,
+        blockingReasons: normalizedReasons
+      };
+    }
+    function normalizeBlockingReasons(reasons) {
+      const normalized = /* @__PURE__ */ new Set();
+      for (const reason of reasons) {
+        normalized.add(reason);
+      }
+      if ([
+        "conflicts_present",
+        "staged_changes_present",
+        "modified_changes_present",
+        "untracked_changes_present",
+        "deleted_changes_present",
+        "renamed_changes_present"
+      ].some((reason) => normalized.has(reason))) {
+        normalized.add("working_tree_not_clean");
+      }
+      return Array.from(normalized);
+    }
+    function buildConvergenceState(status, convergenceStatus) {
+      return {
+        status: convergenceStatus,
+        branch: status.branch,
+        headCommit: status.headCommit,
+        upstream: status.upstream,
+        ahead: status.ahead,
+        behind: status.behind,
+        dirty: status.staged + status.modified + status.untracked + status.deleted + status.renamed > 0 || status.hasConflicts,
+        stashCount: status.stashCount,
+        submodules: summarizeSubmodules(status.submodules)
+      };
+    }
+    function summarizeSubmodules(submodules) {
+      return (submodules || []).map((submodule) => ({
+        path: submodule.path,
+        commit: submodule.commit,
+        dirty: submodule.dirty,
+        outOfSync: submodule.outOfSync,
+        ...submodule.error ? { error: submodule.error } : {}
+      }));
+    }
+    function normalizeOptionalString(value) {
+      return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    }
+    function formatGitError2(error48) {
+      if (error48 instanceof GitCommandError) {
+        return error48.stderr || error48.stdout || error48.message;
+      }
+      if (error48 instanceof Error) return error48.message;
+      return String(error48);
+    }
+    async function appendFastForwardLedger(result, outcome) {
+      if (!result.meshId) return;
+      try {
+        const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+        appendLedgerEntry2(result.meshId, {
+          kind: "direct_fast_forward",
+          ...result.nodeId ? { nodeId: result.nodeId } : {},
+          payload: {
+            operation: "mesh_fast_forward_node",
+            trigger: result.trigger || "manual",
+            outcome,
+            code: result.code,
+            workspace: result.workspace,
+            allowed: result.allowed,
+            dryRun: result.dryRun,
+            willRun: result.willRun,
+            executed: result.executed,
+            branch: result.postStatus?.branch ?? result.current?.branch,
+            upstream: result.postStatus?.upstream ?? result.current?.upstream,
+            before: result.current ? {
+              headCommit: result.current.headCommit,
+              ahead: result.current.ahead,
+              behind: result.current.behind
+            } : void 0,
+            after: result.postStatus ? {
+              headCommit: result.postStatus.headCommit,
+              ahead: result.postStatus.ahead,
+              behind: result.postStatus.behind
+            } : void 0,
+            blockingReasons: result.blockingReasons
+          }
+        });
+      } catch (error48) {
+        result.ledgerError = error48 instanceof Error ? error48.message : String(error48);
+      }
+    }
+    var STATUS_OPTIONS;
+    var init_mesh_fast_forward = __esm2({
+      "src/mesh/mesh-fast-forward.ts"() {
+        "use strict";
+        init_git_status();
+        init_git_executor();
+        STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3 };
+      }
+    });
     function loadDatabaseCtor() {
       if (DatabaseCtor) return DatabaseCtor;
       const runtimeRequire = typeof require === "function" ? require : (0, import_module.createRequire)(import_meta.url);
@@ -37374,6 +38001,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         import_path7 = require("path");
         import_module = require("module");
         init_mesh_ledger();
+        init_mesh_work_queue();
         import_meta = {};
         BeadsDB = class _BeadsDB {
           static instance;
@@ -37595,25 +38223,29 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             return row !== void 0;
           }
           // O(1) claim: transaction ensures only one session claims a pending task
-          claimNextQueueTask(meshId, nodeId, sessionId) {
+          claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags = []) {
             return this.transaction(() => {
               this.ensureLegacyQueueMigrated(meshId);
               if (this.hasActiveAssignment(meshId, sessionId, nodeId)) return null;
-              const row = this.db.prepare(`
+              const rows = [
+                ...this.db.prepare(`
                     SELECT payload FROM mesh_queue
                     WHERE mesh_id = ? AND status = 'pending' AND target_session_id = ?
-                    ORDER BY created_at ASC LIMIT 1
-                `).get(meshId, sessionId) || this.db.prepare(`
+                    ORDER BY created_at ASC
+                `).all(meshId, sessionId),
+                ...this.db.prepare(`
                     SELECT payload FROM mesh_queue
                     WHERE mesh_id = ? AND status = 'pending' AND target_node_id = ? AND target_session_id IS NULL
-                    ORDER BY created_at ASC LIMIT 1
-                `).get(meshId, nodeId) || this.db.prepare(`
+                    ORDER BY created_at ASC
+                `).all(meshId, nodeId),
+                ...this.db.prepare(`
                     SELECT payload FROM mesh_queue
                     WHERE mesh_id = ? AND status = 'pending' AND target_node_id IS NULL AND target_session_id IS NULL
-                    ORDER BY created_at ASC LIMIT 1
-                `).get(meshId);
-              if (!row) return null;
-              const entry = JSON.parse(row.payload);
+                    ORDER BY created_at ASC
+                `).all(meshId)
+              ];
+              const entry = rows.map((row) => JSON.parse(row.payload)).find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags));
+              if (!entry) return null;
               const now = (/* @__PURE__ */ new Date()).toISOString();
               entry.status = "assigned";
               entry.assignedNodeId = nodeId;
@@ -37759,6 +38391,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       __clearMeshQueueForTests: () => __clearMeshQueueForTests,
       __replaceMeshQueueForTests: () => __replaceMeshQueueForTests,
       __resetBeadsDBForTests: () => __resetBeadsDBForTests,
+      buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
       cancelTask: () => cancelTask,
       claimNextTask: () => claimNextTask,
       cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
@@ -37769,6 +38402,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       getQueue: () => getQueue,
       insertDirectDispatch: () => insertDirectDispatch,
       markStaleDirectDispatches: () => markStaleDirectDispatches,
+      nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
+      normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
       normalizeMeshTaskMode: () => normalizeMeshTaskMode,
       recordTaskAutoLaunch: () => recordTaskAutoLaunch,
       requeueTask: () => requeueTask,
@@ -37803,6 +38438,35 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         ]
       };
     }
+    function normalizeMeshCapabilityTags(value) {
+      if (!Array.isArray(value)) return [];
+      const seen = /* @__PURE__ */ new Set();
+      return value.map((tag) => typeof tag === "string" ? tag.trim() : "").filter(Boolean).filter((tag) => {
+        if (seen.has(tag)) return false;
+        seen.add(tag);
+        return true;
+      });
+    }
+    function firstProviderPriority(policy) {
+      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
+      if (!Array.isArray(raw)) return void 0;
+      return raw.find((type) => typeof type === "string" && type.trim())?.trim();
+    }
+    function buildMeshNodeCapabilityTags(node, providerType) {
+      const provider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : firstProviderPriority(node?.policy);
+      return normalizeMeshCapabilityTags([
+        ...Array.isArray(node?.capabilities) ? node.capabilities : [],
+        `os=${process.platform}`,
+        `arch=${process.arch}`,
+        ...provider ? [`provider=${provider}`] : []
+      ]);
+    }
+    function nodeSatisfiesRequiredTags(requiredTags, capabilityTags) {
+      const required2 = normalizeMeshCapabilityTags(requiredTags);
+      if (required2.length === 0) return true;
+      const available = new Set(normalizeMeshCapabilityTags(capabilityTags));
+      return required2.every((tag) => available.has(tag));
+    }
     function withQueueLock(_meshId, fn) {
       return BeadsDB.getInstance().transaction(fn);
     }
@@ -37820,6 +38484,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         taskMode: modeValidation.taskMode,
         targetNodeId: opts?.targetNodeId,
         targetSessionId: opts?.targetSessionId,
+        requiredTags: normalizeMeshCapabilityTags(opts?.requiredTags),
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -37832,8 +38497,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function getMeshQueueRevision(meshId) {
       return BeadsDB.getInstance().getQueueRevision(meshId);
     }
-    function claimNextTask(meshId, nodeId, sessionId) {
-      return BeadsDB.getInstance().claimNextQueueTask(meshId, nodeId, sessionId);
+    function claimNextTask(meshId, nodeId, sessionId, capabilityTags) {
+      return BeadsDB.getInstance().claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags);
     }
     function updateTaskStatus(meshId, taskId, status, opts) {
       requireMeshHostQueueOwner(opts);
@@ -38129,6 +38794,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     });
     var mesh_events_exports = {};
     __export2(mesh_events_exports, {
+      __resetIdleAutoFastForwardForTests: () => __resetIdleAutoFastForwardForTests,
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
       drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
@@ -38149,6 +38815,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function readWorkerResultMetadata(event) {
       return readRecord2(event.workerResult) || readRecord2(event.meshWorkerResult) || readRecord2(event.structuredResult);
     }
+    function __resetIdleAutoFastForwardForTests() {
+      idleAutoFastForwardLastAttempt.clear();
+    }
     function sweepExpiredRemoteIdleSessions() {
       const now = Date.now();
       for (const [key, session] of remoteIdleSessions) {
@@ -38574,13 +39243,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       };
     }
     function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
-      const task = claimNextTask(meshId, nodeId, sessionId);
+      const mesh = getMeshWithCache(components, meshId);
+      const node = mesh?.nodes.find((n) => n.id === nodeId);
+      const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
+      const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags);
       if (!task) {
         return false;
       }
       LOG2.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
-      const mesh = getMeshWithCache(components, meshId);
-      const node = mesh?.nodes.find((n) => n.id === nodeId);
       if (node?.daemonId && components.dispatchMeshCommand) {
         const isLocalNode = components.cliManager.adapters.has(sessionId);
         if (!isLocalNode) {
@@ -38886,6 +39556,55 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
     }
+    async function maybeAutoFastForwardIdleNode(components, args) {
+      const mesh = getMeshWithCache(components, args.meshId);
+      const node = mesh?.nodes?.find((candidate) => candidate?.id === args.nodeId || candidate?.nodeId === args.nodeId);
+      const workspace = readNonEmptyString2(node?.workspace);
+      if (!workspace) return;
+      if (!(0, import_fs9.existsSync)(workspace)) return;
+      const throttleKey = `${args.meshId}:${args.nodeId}`;
+      const now = Date.now();
+      const lastAttempt = idleAutoFastForwardLastAttempt.get(throttleKey) || 0;
+      if (now - lastAttempt < IDLE_AUTO_FAST_FORWARD_THROTTLE_MS) return;
+      idleAutoFastForwardLastAttempt.set(throttleKey, now);
+      const submoduleIgnorePaths = Array.isArray(node?.policy?.submoduleIgnorePaths) ? node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
+      try {
+        const dryRun = await fastForwardMeshNode({
+          meshId: args.meshId,
+          nodeId: args.nodeId,
+          workspace,
+          execute: false,
+          dryRun: true,
+          updateSubmodules: false,
+          submoduleIgnorePaths,
+          trigger: "idle_auto"
+        });
+        if (!dryRun || dryRun.code !== "fast_forward_available" || dryRun.allowed !== true) return;
+        await fastForwardMeshNode({
+          meshId: args.meshId,
+          nodeId: args.nodeId,
+          workspace,
+          execute: true,
+          dryRun: false,
+          updateSubmodules: false,
+          submoduleIgnorePaths,
+          trigger: "idle_auto"
+        });
+      } catch (e) {
+        LOG2.warn("MeshFastForward", `Idle auto fast-forward check failed for ${args.nodeId}: ${e?.message || e}`);
+      }
+    }
+    function runIdleMaintenanceThenAssignQueue(components, args) {
+      setImmediate(() => {
+        maybeAutoFastForwardIdleNode(components, args).finally(() => {
+          try {
+            tryAssignQueueTask(components, args.meshId, args.nodeId, args.sessionId, args.providerType);
+          } catch (e) {
+            LOG2.warn("MeshQueue", `Failed to assign idle queue task after maintenance for ${args.nodeId}: ${e?.message || e}`);
+          }
+        });
+      });
+    }
     function buildMeshSystemMessage(args) {
       const metadata = formatCompletionMetadata(args.metadataEvent);
       if (args.event === "agent:generating_completed") {
@@ -39107,9 +39826,7 @@ Next step: ${nextStep}`;
           updateDirectDispatchStatus(args.meshId, sessionId, "completed");
           setImmediate(() => cleanupTerminalDirectDispatches());
           if (nodeId && providerType) {
-            setImmediate(() => {
-              tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-            });
+            runIdleMaintenanceThenAssignQueue(components, { meshId: args.meshId, nodeId, sessionId, providerType });
           }
         }
       } else if (args.event === "agent:ready") {
@@ -39163,8 +39880,14 @@ Next step: ${nextStep}`;
             expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS
           });
           setImmediate(() => {
-            const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-            if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+            maybeAutoFastForwardIdleNode(components, { meshId: args.meshId, nodeId, sessionId, providerType }).finally(() => {
+              try {
+                const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
+                if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+              } catch (e) {
+                LOG2.warn("MeshQueue", `Failed to assign idle queue task after maintenance for ${nodeId}: ${e?.message || e}`);
+              }
+            });
           });
         }
       } else if (args.event === "agent:generating_started") {
@@ -39446,6 +40169,8 @@ Next step: ${nextStep}`;
     var remoteIdleSessions;
     var meshByWorkspaceCache;
     var MESH_WORKSPACE_CACHE_TTL_MS;
+    var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS;
+    var idleAutoFastForwardLastAttempt;
     var REFINE_TERMINAL_EVENTS;
     var MAX_PENDING_EVENTS_BYTES;
     var MAX_PENDING_EVENTS_KEEP;
@@ -39468,10 +40193,13 @@ Next step: ${nextStep}`;
         init_mesh_ledger();
         init_mesh_work_queue();
         init_beads_db();
+        init_mesh_fast_forward();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         remoteIdleSessions = /* @__PURE__ */ new Map();
         meshByWorkspaceCache = /* @__PURE__ */ new Map();
         MESH_WORKSPACE_CACHE_TTL_MS = 5e3;
+        IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
+        idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
         REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
         MAX_PENDING_EVENTS_BYTES = 100 * 1024;
         MAX_PENDING_EVENTS_KEEP = 50;
@@ -46972,6 +47700,7 @@ ${lastSnapshot}`;
       buildMeshHostRequiredFailure: () => buildMeshHostRequiredFailure,
       buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
       buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
+      buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
       buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
@@ -47099,6 +47828,7 @@ ${lastSnapshot}`;
       maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv2,
       namedKeyToAnsi: () => namedKeyToAnsi,
       namedKeysToAnsi: () => namedKeysToAnsi,
+      nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
       normalizeActiveChatData: () => normalizeActiveChatData,
       normalizeChatMessage: () => normalizeChatMessage,
       normalizeChatMessageKind: () => normalizeChatMessageKind,
@@ -47110,6 +47840,7 @@ ${lastSnapshot}`;
       normalizeInteractivePrompt: () => normalizeInteractivePrompt,
       normalizeInteractivePromptResponse: () => normalizeInteractivePromptResponse2,
       normalizeManagedStatus: () => normalizeManagedStatus,
+      normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
       normalizeMeshDaemonRole: () => normalizeMeshDaemonRole,
       normalizeMeshTaskMode: () => normalizeMeshTaskMode,
       normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
@@ -47168,7 +47899,6 @@ ${lastSnapshot}`;
       startLocalIpcServer: () => startLocalIpcServer2,
       suggestMeshRefineConfig: () => suggestMeshRefineConfig,
       summarizeGitStatus: () => summarizeGitStatus,
-      syncMeshes: () => syncMeshes,
       triggerMeshQueue: () => triggerMeshQueue,
       unregisterMeshCoordinator: () => unregisterMeshCoordinator,
       updateConfig: () => updateConfig,
@@ -47405,256 +48135,7 @@ ${lastSnapshot}`;
     }
     init_repo_mesh_types();
     init_git_executor();
-    init_git_executor();
-    async function getGitRepoStatus(workspace, options = {}) {
-      const lastCheckedAt = Date.now();
-      const includeSubmodules = options.includeSubmodules !== false;
-      try {
-        const repo = await resolveGitRepository(workspace, options);
-        let parsed = await readPorcelainStatus(repo, options);
-        let upstreamProbe = getInitialUpstreamProbe(parsed);
-        if (options.refreshUpstream) {
-          upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
-          if (upstreamProbe.upstreamStatus === "fresh") {
-            parsed = await readPorcelainStatus(repo, options);
-          }
-        }
-        const head = await readHead(repo, options);
-        const stashCount = await readStashCount(repo, options);
-        let submodules;
-        if (includeSubmodules) {
-          submodules = await getSubmoduleStatuses(repo, options);
-        }
-        return {
-          workspace: repo.workspace,
-          repoRoot: repo.repoRoot,
-          isGitRepo: true,
-          branch: parsed.branch,
-          headCommit: head.commit,
-          headMessage: head.message,
-          upstream: parsed.upstream,
-          upstreamStatus: parsed.upstream ? upstreamProbe.upstreamStatus : "no_upstream",
-          upstreamFetchedAt: upstreamProbe.upstreamFetchedAt,
-          upstreamFetchError: upstreamProbe.upstreamFetchError,
-          ahead: parsed.ahead,
-          behind: parsed.behind,
-          staged: parsed.staged,
-          modified: parsed.modified,
-          untracked: parsed.untracked,
-          deleted: parsed.deleted,
-          renamed: parsed.renamed,
-          hasConflicts: parsed.conflictFiles.length > 0,
-          conflictFiles: parsed.conflictFiles,
-          stashCount,
-          lastCheckedAt,
-          submodules
-        };
-      } catch (error48) {
-        if (error48 instanceof GitCommandError) {
-          return emptyStatus(workspace, lastCheckedAt, error48);
-        }
-        return emptyStatus(
-          workspace,
-          lastCheckedAt,
-          new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error48 })
-        );
-      }
-    }
-    async function readPorcelainStatus(repo, options) {
-      const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
-      return parsePorcelainV2Status(statusOutput.stdout);
-    }
-    function getInitialUpstreamProbe(parsed) {
-      return {
-        upstreamStatus: parsed.upstream ? "unchecked" : "no_upstream"
-      };
-    }
-    async function refreshTrackedUpstream(repo, parsed, options) {
-      if (!parsed.upstream || !parsed.branch) {
-        return { upstreamStatus: "no_upstream" };
-      }
-      const remoteName = await readBranchRemote(repo, parsed.branch, options) ?? inferRemoteName(parsed.upstream);
-      if (!remoteName) {
-        return {
-          upstreamStatus: "stale",
-          upstreamFetchError: `Unable to resolve remote for upstream '${parsed.upstream}'`
-        };
-      }
-      try {
-        await runGit(repo, ["fetch", "--quiet", "--prune", "--no-tags", remoteName], options);
-        return {
-          upstreamStatus: "fresh",
-          upstreamFetchedAt: Date.now()
-        };
-      } catch (error48) {
-        return {
-          upstreamStatus: "stale",
-          upstreamFetchError: formatGitError(error48)
-        };
-      }
-    }
-    async function readBranchRemote(repo, branch, options) {
-      try {
-        const result = await runGit(repo, ["config", "--get", `branch.${branch}.remote`], options);
-        return result.stdout.trim() || null;
-      } catch {
-        return null;
-      }
-    }
-    function inferRemoteName(upstream) {
-      const [remoteName] = upstream.split("/");
-      return remoteName?.trim() || null;
-    }
-    function formatGitError(error48) {
-      if (error48 instanceof GitCommandError) {
-        return error48.stderr || error48.message;
-      }
-      if (error48 instanceof Error) {
-        return error48.message;
-      }
-      return String(error48);
-    }
-    function parsePorcelainV2Status(output) {
-      const parsed = {
-        branch: null,
-        upstream: null,
-        ahead: 0,
-        behind: 0,
-        staged: 0,
-        modified: 0,
-        untracked: 0,
-        deleted: 0,
-        renamed: 0,
-        conflictFiles: []
-      };
-      for (const line of output.split("\n")) {
-        if (!line) continue;
-        if (line.startsWith("# branch.head ")) {
-          const branch = line.slice("# branch.head ".length).trim();
-          parsed.branch = branch && branch !== "(detached)" ? branch : null;
-          continue;
-        }
-        if (line.startsWith("# branch.upstream ")) {
-          parsed.upstream = line.slice("# branch.upstream ".length).trim() || null;
-          continue;
-        }
-        if (line.startsWith("# branch.ab ")) {
-          const match = line.match(/\+(-?\d+)\s+-(-?\d+)/);
-          if (match) {
-            parsed.ahead = Number.parseInt(match[1] ?? "0", 10) || 0;
-            parsed.behind = Number.parseInt(match[2] ?? "0", 10) || 0;
-          }
-          continue;
-        }
-        if (line.startsWith("? ")) {
-          parsed.untracked += 1;
-          continue;
-        }
-        if (line.startsWith("u ")) {
-          const fields = line.split(" ");
-          const filePath = fields.slice(10).join(" ");
-          if (filePath) parsed.conflictFiles.push(filePath);
-          continue;
-        }
-        if (line.startsWith("1 ") || line.startsWith("2 ")) {
-          const fields = line.split(" ");
-          const xy = fields[1] ?? "..";
-          const indexStatus = xy[0] ?? ".";
-          const worktreeStatus = xy[1] ?? ".";
-          if (isStagedStatus(indexStatus)) parsed.staged += 1;
-          if (worktreeStatus === "M" || worktreeStatus === "T") parsed.modified += 1;
-          if (indexStatus === "D" || worktreeStatus === "D") parsed.deleted += 1;
-          if (indexStatus === "R" || worktreeStatus === "R") parsed.renamed += 1;
-          if (xy.includes("U")) {
-            const filePath = fields.slice(line.startsWith("2 ") ? 9 : 8).join(" ").split("	")[0] ?? "";
-            if (filePath) parsed.conflictFiles.push(filePath);
-          }
-        }
-      }
-      parsed.conflictFiles = Array.from(new Set(parsed.conflictFiles));
-      return parsed;
-    }
-    async function readHead(repo, options) {
-      try {
-        const result = await runGit(repo, ["log", "-1", "--pretty=%h%x00%s"], options);
-        const text = result.stdout.trimEnd();
-        if (!text) return { commit: null, message: null };
-        const [commit, ...messageParts] = text.split("\0");
-        return {
-          commit: commit || null,
-          message: messageParts.join("\0") || null
-        };
-      } catch {
-        return { commit: null, message: null };
-      }
-    }
-    async function readStashCount(repo, options) {
-      try {
-        const result = await runGit(repo, ["stash", "list", "--format=%gd"], options);
-        return result.stdout.split("\n").filter((line) => line.trim().length > 0).length;
-      } catch {
-        return 0;
-      }
-    }
-    function isStagedStatus(status) {
-      return status !== "." && status !== "?" && status !== "U";
-    }
-    function emptyStatus(workspace, lastCheckedAt, error48) {
-      return {
-        workspace,
-        repoRoot: null,
-        isGitRepo: false,
-        branch: null,
-        headCommit: null,
-        headMessage: null,
-        upstream: null,
-        upstreamStatus: "unavailable",
-        ahead: 0,
-        behind: 0,
-        staged: 0,
-        modified: 0,
-        untracked: 0,
-        deleted: 0,
-        renamed: 0,
-        hasConflicts: false,
-        conflictFiles: [],
-        stashCount: 0,
-        lastCheckedAt,
-        error: error48.stderr || error48.message,
-        reason: error48.reason
-      };
-    }
-    async function getSubmoduleStatuses(repo, options) {
-      if (!repo.repoRoot) return [];
-      try {
-        const result = await runGit(repo, ["submodule", "status", "--recursive"], options);
-        return parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
-      } catch {
-        return [];
-      }
-    }
-    function parseSubmoduleStatusOutput(output, repoRoot, ignorePaths) {
-      const submodules = [];
-      const ignoreSet = new Set(ignorePaths || []);
-      for (const line of output.split("\n")) {
-        if (!line.trim()) continue;
-        const match = line.match(/^([\-+\s])([0-9a-f]{40})\s+(\S+)(?:\s+\(([^)]+)\))?/);
-        if (!match) continue;
-        const prefix = match[1];
-        const commit = match[2];
-        const path40 = match[3];
-        if (ignoreSet.has(path40)) continue;
-        submodules.push({
-          path: path40,
-          commit,
-          repoPath: repoRoot + "/" + path40,
-          dirty: prefix === "+",
-          outOfSync: prefix === "-",
-          lastCheckedAt: Date.now()
-        });
-      }
-      return submodules;
-    }
+    init_git_status();
     var import_promises2 = require("fs/promises");
     var path23 = __toESM2(require("path"));
     init_git_executor();
@@ -48062,6 +48543,7 @@ ${lastSnapshot}`;
     function createGitSnapshotStore(options = {}) {
       return new InMemoryGitSnapshotStore(options);
     }
+    init_git_status();
     var DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS = 5e3;
     var MIN_GIT_WORKSPACE_POLL_INTERVAL_MS = 1e3;
     function defaultStatusProvider(workspace) {
@@ -48182,6 +48664,7 @@ ${lastSnapshot}`;
     }
     var path32 = __toESM2(require("path"));
     init_git_executor();
+    init_git_status();
     var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
       "git_status",
       "git_diff_summary",
@@ -49637,409 +50120,8 @@ ${lastSnapshot}`;
       state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
       return state;
     }
-    init_mesh_config();
-    async function syncMeshes(transport) {
-      const result = { pushed: 0, pulled: 0, deleted: 0, errors: [] };
-      let remoteMeshes;
-      try {
-        const res = await transport.listRemoteMeshes();
-        remoteMeshes = res.meshes;
-      } catch (e) {
-        result.errors.push(`Failed to list remote meshes: ${e.message}`);
-        return result;
-      }
-      const localMeshes = listMeshes();
-      const remoteByIdentity = new Map(remoteMeshes.map((m) => [m.repo_identity, m]));
-      const localByIdentity = new Map(localMeshes.map((m) => [m.repoIdentity, m]));
-      for (const local of localMeshes) {
-        if (!remoteByIdentity.has(local.repoIdentity)) {
-          try {
-            await transport.createRemoteMesh({
-              name: local.name,
-              repo_identity: local.repoIdentity,
-              repo_remote_url: local.repoRemoteUrl,
-              default_branch: local.defaultBranch,
-              policy: JSON.stringify(local.policy)
-            });
-            result.pushed++;
-          } catch (e) {
-            result.errors.push(`Push failed for "${local.name}": ${e.message}`);
-          }
-        }
-      }
-      for (const remote of remoteMeshes) {
-        if (!localByIdentity.has(remote.repo_identity)) {
-          try {
-            let policy;
-            try {
-              policy = JSON.parse(remote.policy);
-            } catch {
-              policy = void 0;
-            }
-            createMesh({
-              name: remote.name,
-              repoIdentity: remote.repo_identity,
-              repoRemoteUrl: remote.repo_remote_url || void 0,
-              defaultBranch: remote.default_branch || void 0,
-              policy
-            });
-            result.pulled++;
-          } catch (e) {
-            result.errors.push(`Pull failed for "${remote.name}": ${e.message}`);
-          }
-        }
-      }
-      return result;
-    }
     init_mesh_ledger();
-    init_git_executor();
-    var STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3 };
-    async function fastForwardMeshNode(args) {
-      const workspace = typeof args.workspace === "string" ? args.workspace.trim() : "";
-      const nodeId = normalizeOptionalString(args.nodeId);
-      const meshId = normalizeOptionalString(args.meshId);
-      const requestedBranch = normalizeOptionalString(args.branch);
-      const updateSubmodules = args.updateSubmodules === true;
-      const dryRun = args.dryRun === true || args.execute !== true;
-      const plannedSteps = buildPlannedSteps(updateSubmodules);
-      const base = {
-        ...nodeId ? { nodeId } : {},
-        ...meshId ? { meshId } : {},
-        workspace,
-        dryRun,
-        updateSubmodules,
-        plannedSteps
-      };
-      if (!workspace) {
-        return block(base, "invalid_workspace", ["workspace_required"]);
-      }
-      const current = await getGitRepoStatus(workspace, {
-        ...STATUS_OPTIONS,
-        submoduleIgnorePaths: args.submoduleIgnorePaths,
-        timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
-      });
-      const earlyBlockers = collectPreflightBlockers(current, requestedBranch);
-      if (earlyBlockers.length > 0) {
-        return {
-          ...block(base, chooseBlockCode(current, earlyBlockers), earlyBlockers),
-          current,
-          finalBranchConvergenceState: buildConvergenceState(current, codeToConvergenceStatus(chooseBlockCode(current, earlyBlockers)))
-        };
-      }
-      if (current.behind === 0) {
-        const result2 = {
-          ...base,
-          success: true,
-          code: "already_up_to_date",
-          allowed: true,
-          willRun: false,
-          executed: false,
-          blockingReasons: [],
-          current,
-          preStatus: current,
-          postStatus: current,
-          finalBranchConvergenceState: buildConvergenceState(current, "up_to_date")
-        };
-        await appendFastForwardLedger(result2, "noop");
-        return result2;
-      }
-      const ancestorCheck = await verifyHeadIsAncestorOfUpstream(workspace, current.upstream || "", args.timeoutMs);
-      if (!ancestorCheck.ok) {
-        const result2 = {
-          ...block(base, "non_fast_forward", ["head_is_not_ancestor_of_upstream"]),
-          current,
-          preStatus: current,
-          operationError: ancestorCheck.error,
-          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
-        };
-        await appendFastForwardLedger(result2, "blocked");
-        return result2;
-      }
-      if (dryRun) {
-        const result2 = {
-          ...base,
-          success: true,
-          code: "fast_forward_available",
-          allowed: true,
-          willRun: false,
-          executed: false,
-          blockingReasons: [],
-          current,
-          preStatus: current,
-          finalBranchConvergenceState: buildConvergenceState(current, "fast_forward_available")
-        };
-        return result2;
-      }
-      try {
-        await runGit(workspace, ["merge", "--ff-only", current.upstream || ""], { timeoutMs: args.timeoutMs ?? 3e4 });
-      } catch (error48) {
-        const result2 = {
-          ...block(base, "merge_ff_only_failed", ["merge_ff_only_failed"]),
-          current,
-          preStatus: current,
-          operationError: formatGitError2(error48),
-          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
-        };
-        await appendFastForwardLedger(result2, "failed");
-        return result2;
-      }
-      let postStatus = await getGitRepoStatus(workspace, {
-        ...STATUS_OPTIONS,
-        submoduleIgnorePaths: args.submoduleIgnorePaths,
-        timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
-      });
-      const submoduleIssues = collectSubmoduleBlockers(postStatus, "post");
-      let submoduleFollowUpRequired = false;
-      let operationError;
-      if (submoduleIssues.length > 0) {
-        if (updateSubmodules) {
-          try {
-            await runGit(workspace, ["submodule", "update", "--init", "--recursive"], { timeoutMs: args.timeoutMs ?? 6e4 });
-            postStatus = await getGitRepoStatus(workspace, {
-              ...STATUS_OPTIONS,
-              submoduleIgnorePaths: args.submoduleIgnorePaths,
-              timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
-            });
-          } catch (error48) {
-            operationError = formatGitError2(error48);
-          }
-        } else {
-          submoduleFollowUpRequired = true;
-        }
-      }
-      const postBlockers = collectPostExecutionBlockers(postStatus);
-      if (operationError) postBlockers.push("submodule_update_failed");
-      if (submoduleFollowUpRequired) postBlockers.push("submodule_update_required");
-      const success2 = postBlockers.length === 0 || submoduleFollowUpRequired;
-      const code = postBlockers.length === 0 ? "fast_forward_applied" : submoduleFollowUpRequired ? "fast_forward_applied_submodule_update_required" : "post_verify_failed";
-      const result = {
-        ...base,
-        success: success2,
-        code,
-        allowed: true,
-        willRun: true,
-        executed: true,
-        blockingReasons: postBlockers,
-        current,
-        preStatus: current,
-        postStatus,
-        ...operationError ? { operationError } : {},
-        finalBranchConvergenceState: buildConvergenceState(
-          postStatus,
-          postBlockers.length === 0 ? "fast_forwarded" : submoduleFollowUpRequired ? "follow_up_required" : "post_verify_failed"
-        )
-      };
-      await appendFastForwardLedger(result, success2 ? "executed" : "failed");
-      return result;
-    }
-    function buildPlannedSteps(updateSubmodules) {
-      const steps = [
-        {
-          operation: "refresh_upstream",
-          description: "Refresh the tracked upstream remote ref before trusting ahead/behind state.",
-          safe: true,
-          willMutateWorktree: false
-        },
-        {
-          operation: "verify_clean_worktree",
-          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.",
-          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.",
-          safe: true,
-          willMutateWorktree: true
-        }
-      ];
-      if (updateSubmodules) {
-        steps.push({
-          operation: "submodule_update",
-          description: "If the fast-forward changes gitlinks, run git submodule update --init --recursive and re-verify submodules.",
-          safe: true,
-          willMutateWorktree: true
-        });
-      }
-      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;
-    }
-    function collectPreflightBlockers(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");
-      blockers.push(...collectSubmoduleBlockers(status, "pre"));
-      if (status.ahead > 0 && status.behind > 0) {
-        blockers.push("branch_diverged_from_upstream");
-        blockers.push("branch_has_local_commits");
-      } else if (status.ahead > 0) blockers.push("branch_has_local_commits");
-      return blockers;
-    }
-    function collectPostExecutionBlockers(status) {
-      const blockers = [];
-      if (!status.isGitRepo) blockers.push("post_not_git_repo");
-      if (status.hasConflicts) blockers.push("post_conflicts_present");
-      if (status.ahead !== 0) blockers.push("post_branch_ahead");
-      if (status.behind !== 0) blockers.push("post_branch_still_behind");
-      if (status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0) {
-        blockers.push("post_working_tree_not_clean");
-      }
-      if (status.stashCount > 0) blockers.push("post_stash_entries_present");
-      blockers.push(...collectSubmoduleBlockers(status, "post"));
-      return blockers;
-    }
-    function collectSubmoduleBlockers(status, phase) {
-      const submodules = Array.isArray(status.submodules) ? status.submodules : [];
-      const blockers = [];
-      for (const submodule of submodules) {
-        if (submodule.error) blockers.push(`${phase}_submodule_status_error:${submodule.path}`);
-        if (submodule.dirty) blockers.push(`${phase}_submodule_dirty:${submodule.path}`);
-        if (submodule.outOfSync) blockers.push(`${phase}_submodule_out_of_sync:${submodule.path}`);
-      }
-      return blockers;
-    }
-    function chooseBlockCode(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.some((reason) => reason.includes("submodule"))) return "submodule_not_clean";
-      if (blockers.includes("branch_diverged_from_upstream")) return "branch_diverged";
-      if (blockers.includes("branch_has_local_commits") || status.ahead > 0) return "branch_ahead";
-      if (blockers.some((reason) => reason.includes("changes") || reason.includes("conflicts") || reason.includes("stash"))) return "dirty_worktree";
-      return "preflight_blocked";
-    }
-    function codeToConvergenceStatus(code) {
-      if (code === "branch_diverged" || code === "branch_ahead" || code === "non_fast_forward") return "not_mergeable";
-      if (code === "dirty_worktree" || code === "submodule_not_clean") return "blocked_review";
-      return "blocked";
-    }
-    async function verifyHeadIsAncestorOfUpstream(workspace, upstream, timeoutMs) {
-      if (!upstream) return { ok: false, error: "missing upstream" };
-      try {
-        await runGit(workspace, ["merge-base", "--is-ancestor", "HEAD", upstream], { timeoutMs: timeoutMs ?? 15e3 });
-        return { ok: true };
-      } catch (error48) {
-        return { ok: false, error: formatGitError2(error48) };
-      }
-    }
-    function block(base, code, blockingReasons) {
-      const normalizedReasons = normalizeBlockingReasons(blockingReasons);
-      return {
-        ...base,
-        success: false,
-        code,
-        allowed: false,
-        willRun: false,
-        executed: false,
-        blockingReasons: normalizedReasons
-      };
-    }
-    function normalizeBlockingReasons(reasons) {
-      const normalized = /* @__PURE__ */ new Set();
-      for (const reason of reasons) {
-        normalized.add(reason);
-      }
-      if ([
-        "conflicts_present",
-        "staged_changes_present",
-        "modified_changes_present",
-        "untracked_changes_present",
-        "deleted_changes_present",
-        "renamed_changes_present"
-      ].some((reason) => normalized.has(reason))) {
-        normalized.add("working_tree_not_clean");
-      }
-      return Array.from(normalized);
-    }
-    function buildConvergenceState(status, convergenceStatus) {
-      return {
-        status: convergenceStatus,
-        branch: status.branch,
-        headCommit: status.headCommit,
-        upstream: status.upstream,
-        ahead: status.ahead,
-        behind: status.behind,
-        dirty: status.staged + status.modified + status.untracked + status.deleted + status.renamed > 0 || status.hasConflicts,
-        stashCount: status.stashCount,
-        submodules: summarizeSubmodules(status.submodules)
-      };
-    }
-    function summarizeSubmodules(submodules) {
-      return (submodules || []).map((submodule) => ({
-        path: submodule.path,
-        commit: submodule.commit,
-        dirty: submodule.dirty,
-        outOfSync: submodule.outOfSync,
-        ...submodule.error ? { error: submodule.error } : {}
-      }));
-    }
-    function normalizeOptionalString(value) {
-      return typeof value === "string" && value.trim() ? value.trim() : void 0;
-    }
-    function formatGitError2(error48) {
-      if (error48 instanceof GitCommandError) {
-        return error48.stderr || error48.stdout || error48.message;
-      }
-      if (error48 instanceof Error) return error48.message;
-      return String(error48);
-    }
-    async function appendFastForwardLedger(result, outcome) {
-      if (!result.meshId) return;
-      try {
-        const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-        appendLedgerEntry2(result.meshId, {
-          kind: "direct_fast_forward",
-          ...result.nodeId ? { nodeId: result.nodeId } : {},
-          payload: {
-            operation: "mesh_fast_forward_node",
-            outcome,
-            code: result.code,
-            workspace: result.workspace,
-            allowed: result.allowed,
-            dryRun: result.dryRun,
-            willRun: result.willRun,
-            executed: result.executed,
-            branch: result.postStatus?.branch ?? result.current?.branch,
-            upstream: result.postStatus?.upstream ?? result.current?.upstream,
-            before: result.current ? {
-              headCommit: result.current.headCommit,
-              ahead: result.current.ahead,
-              behind: result.current.behind
-            } : void 0,
-            after: result.postStatus ? {
-              headCommit: result.postStatus.headCommit,
-              ahead: result.postStatus.ahead,
-              behind: result.postStatus.behind
-            } : void 0,
-            blockingReasons: result.blockingReasons
-          }
-        });
-      } catch (error48) {
-        result.ledgerError = error48 instanceof Error ? error48.message : String(error48);
-      }
-    }
+    init_mesh_fast_forward();
     function lastTimestamp(slice) {
       const entries = Array.isArray(slice?.entries) ? slice.entries : [];
       return entries.length ? entries[entries.length - 1].timestamp : null;
@@ -69346,6 +69428,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     init_config();
     init_cli_detector();
+    init_git_status();
     init_logger();
     var fs20 = __toESM2(require("fs"));
     var path33 = __toESM2(require("path"));
@@ -69494,6 +69577,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_mesh_coordinator();
     init_mesh_events();
     init_mesh_host_ownership();
+    init_mesh_fast_forward();
     var import_node_child_process4 = require("child_process");
     var import_node_fs4 = require("fs");
     var import_node_path2 = require("path");
@@ -72140,8 +72224,8 @@ ${e?.stderr || ""}`
           }
         }
         try {
-          const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const mesh = getMesh3(meshId);
+          const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const mesh = getMesh2(meshId);
           if (mesh) return { mesh, inline: false, source: "local_config" };
         } catch {
         }
@@ -74066,8 +74150,8 @@ ${e?.stderr || ""}`
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             if (!meshId) return { success: false, error: "meshId required" };
             try {
-              const { deleteMesh: deleteMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const deleted = deleteMesh3(meshId);
+              const { deleteMesh: deleteMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const deleted = deleteMesh2(meshId);
               return { success: true, deleted };
             } catch (e) {
               return { success: false, error: e.message };
@@ -74185,7 +74269,7 @@ ${e?.stderr || ""}`
             const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node addition");
             if (ownerFailure) return ownerFailure;
             try {
-              const { addNode: addNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
               const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
               const readOnly = args?.readOnly === true;
               const policy = {
@@ -74196,7 +74280,7 @@ ${e?.stderr || ""}`
               const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
               const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
               const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
-              const node = addNode3(meshId, {
+              const node = addNode2(meshId, {
                 workspace,
                 ...repoRoot ? { repoRoot } : {},
                 ...daemonId ? { daemonId } : {},
@@ -74387,8 +74471,8 @@ ${e?.stderr || ""}`
               if (meshRecord?.inline) {
                 removed = this.removeInlineMeshNode(meshId, mesh, nodeId);
               } else {
-                const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                removed = removeNode3(meshId, nodeId);
+                const { removeNode: removeNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+                removed = removeNode2(meshId, nodeId);
                 if (removed) this.invalidateAggregateMeshStatus(meshId);
               }
               if (removed) {
@@ -74457,8 +74541,8 @@ ${e?.stderr || ""}`
                 };
                 this.updateInlineMeshNode(meshId, mesh, node);
               } else {
-                const { addNode: addNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                node = addNode3(meshId, {
+                const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+                node = addNode2(meshId, {
                   workspace: result.worktreePath,
                   repoRoot: result.worktreePath,
                   daemonId: sourceNode.daemonId,
@@ -74613,8 +74697,8 @@ ${e?.stderr || ""}`
                 mesh = args.inlineMesh;
                 this.inlineMeshCache.set(meshId, mesh);
               } else {
-                const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                mesh = getMesh3(meshId);
+                const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+                mesh = getMesh2(meshId);
               }
               if (!mesh) return { success: false, error: "Mesh not found" };
               const meshHost = resolveMeshHostStatus(mesh);