@adhdev/daemon-core 0.9.82-rc.172 → 0.9.82-rc.174

package/dist/index.js

@@ -255,6 +255,263 @@ var init_git_executor = __esm({
   }
 });
 
+// src/git/git-status.ts
+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 (error) {
+    if (error instanceof GitCommandError) {
+      return emptyStatus(workspace, lastCheckedAt, error);
+    }
+    return emptyStatus(
+      workspace,
+      lastCheckedAt,
+      new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error })
+    );
+  }
+}
+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 (error) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: formatGitError(error)
+    };
+  }
+}
+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(error) {
+  if (error instanceof GitCommandError) {
+    return error.stderr || error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+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, error) {
+  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: error.stderr || error.message,
+    reason: error.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 = __esm({
+  "src/git/git-status.ts"() {
+    "use strict";
+    init_git_executor();
+  }
+});
+
 // src/git/git-worktree.ts
 var git_worktree_exports = {};
 __export(git_worktree_exports, {
@@ -780,6 +1037,16 @@ function loadMeshConfig() {
     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(config) {
   const path40 = getMeshConfigPath();
   (0, import_fs2.writeFileSync)(path40, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
@@ -1065,6 +1332,7 @@ function addNode(meshId, opts) {
     repoRoot: opts.repoRoot,
     daemonId: opts.daemonId,
     machineId: opts.machineId,
+    capabilities: normalizeCapabilityTags(opts.capabilities),
     userOverrides: opts.userOverrides || {},
     policy: opts.policy || {},
     isLocalWorktree: opts.isLocalWorktree,
@@ -2550,6 +2818,369 @@ var init_mesh_ledger = __esm({
   }
 });
 
+// src/mesh/mesh-fast-forward.ts
+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 (error) {
+    const result2 = {
+      ...block(base, "merge_ff_only_failed", ["merge_ff_only_failed"]),
+      current,
+      preStatus: current,
+      operationError: formatGitError2(error),
+      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 (error) {
+        operationError = formatGitError2(error);
+      }
+    } else {
+      submoduleFollowUpRequired = true;
+    }
+  }
+  const postBlockers = collectPostExecutionBlockers(postStatus);
+  if (operationError) postBlockers.push("submodule_update_failed");
+  if (submoduleFollowUpRequired) postBlockers.push("submodule_update_required");
+  const success = 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,
+    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, success ? "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 (error) {
+    return { ok: false, error: formatGitError2(error) };
+  }
+}
+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(error) {
+  if (error instanceof GitCommandError) {
+    return error.stderr || error.stdout || error.message;
+  }
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+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 (error) {
+    result.ledgerError = error instanceof Error ? error.message : String(error);
+  }
+}
+var STATUS_OPTIONS;
+var init_mesh_fast_forward = __esm({
+  "src/mesh/mesh-fast-forward.ts"() {
+    "use strict";
+    init_git_status();
+    init_git_executor();
+    STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3 };
+  }
+});
+
 // src/mesh/beads-db.ts
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
@@ -2571,6 +3202,7 @@ var init_beads_db = __esm({
     import_path7 = require("path");
     import_module = require("module");
     init_mesh_ledger();
+    init_mesh_work_queue();
     import_meta = {};
     BeadsDB = class _BeadsDB {
       static instance;
@@ -2792,25 +3424,29 @@ var init_beads_db = __esm({
         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;
@@ -2958,6 +3594,7 @@ __export(mesh_work_queue_exports, {
   __clearMeshQueueForTests: () => __clearMeshQueueForTests,
   __replaceMeshQueueForTests: () => __replaceMeshQueueForTests,
   __resetBeadsDBForTests: () => __resetBeadsDBForTests,
+  buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
   cancelTask: () => cancelTask,
   claimNextTask: () => claimNextTask,
   cleanupTerminalDirectDispatches: () => cleanupTerminalDirectDispatches,
@@ -2968,6 +3605,8 @@ __export(mesh_work_queue_exports, {
   getQueue: () => getQueue,
   insertDirectDispatch: () => insertDirectDispatch,
   markStaleDirectDispatches: () => markStaleDirectDispatches,
+  nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
+  normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
   normalizeMeshTaskMode: () => normalizeMeshTaskMode,
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
@@ -3002,6 +3641,35 @@ function validateMeshTaskModeRequest(mode, message) {
     ]
   };
 }
+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 required = normalizeMeshCapabilityTags(requiredTags);
+  if (required.length === 0) return true;
+  const available = new Set(normalizeMeshCapabilityTags(capabilityTags));
+  return required.every((tag) => available.has(tag));
+}
 function withQueueLock(_meshId, fn) {
   return BeadsDB.getInstance().transaction(fn);
 }
@@ -3019,6 +3687,7 @@ function enqueueTask(meshId, message, opts) {
     taskMode: modeValidation.taskMode,
     targetNodeId: opts?.targetNodeId,
     targetSessionId: opts?.targetSessionId,
+    requiredTags: normalizeMeshCapabilityTags(opts?.requiredTags),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -3031,8 +3700,8 @@ function getQueue(meshId, opts) {
 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);
@@ -3325,6 +3994,7 @@ var init_cli_detector = __esm({
 // src/mesh/mesh-events.ts
 var mesh_events_exports = {};
 __export(mesh_events_exports, {
+  __resetIdleAutoFastForwardForTests: () => __resetIdleAutoFastForwardForTests,
   clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
@@ -3345,6 +4015,9 @@ function getCachedMeshByWorkspace(workspace) {
 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) {
@@ -3770,13 +4443,14 @@ function buildLongGeneratingCompletionReconciliation(args) {
   };
 }
 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;
   }
   LOG.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) {
@@ -4082,6 +4756,55 @@ async function triggerMeshQueue(components, meshId) {
   }
   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) {
+    LOG.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) {
+        LOG.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") {
@@ -4303,9 +5026,7 @@ function injectMeshSystemMessage(components, args) {
       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") {
@@ -4359,8 +5080,14 @@ function injectMeshSystemMessage(components, args) {
         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) {
+            LOG.warn("MeshQueue", `Failed to assign idle queue task after maintenance for ${nodeId}: ${e?.message || e}`);
+          }
+        });
       });
     }
   } else if (args.event === "agent:generating_started") {
@@ -4636,7 +5363,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var import_fs9, import_path8, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var import_fs9, import_path8, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
@@ -4649,10 +5376,13 @@ var init_mesh_events = __esm({
     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;
@@ -10655,13 +11385,15 @@ function executeJsonl(src, input) {
     try {
       stat2 = fs13.statSync(resolved);
     } catch {
-      return null;
     }
-    if (stat2.isFile()) {
+    if (stat2 && stat2.isFile()) {
       sourcePath = resolved;
-    } else if (stat2.isDirectory()) {
+    } else if (stat2 && stat2.isDirectory()) {
       sourcePath = newestRecentFile(resolved, filePat, windowMs, sessionFloor);
     }
+    if (!sourcePath && hasDateTemplateSegment(src.path)) {
+      sourcePath = newestRecentFileAcrossDateWindow(src.path, input, filePat, windowMs, sessionFloor);
+    }
   }
   if (!sourcePath) return null;
   const mtime = safeMtimeMs(sourcePath);
@@ -10884,6 +11616,69 @@ function newestRecentFileAcrossGlob(template, pattern, windowMs, sessionFloorMs
   }
   return best ? best.p : null;
 }
+function hasDateTemplateSegment(template) {
+  return /\{yyyy\}|\{mm\}|\{dd\}/.test(template);
+}
+function newestRecentFileAcrossDateWindow(template, input, pattern, windowMs, sessionFloorMs) {
+  const cutoff = Math.max(Date.now() - windowMs, sessionFloorMs);
+  let best = null;
+  for (let dayOffset = 0; dayOffset < 3; dayOffset += 1) {
+    const dayMs = Date.now() - dayOffset * 24 * 60 * 60 * 1e3;
+    const dayInput = { ...input, sessionStartedAtMs: sessionFloorMs };
+    const resolved = expandPathForDate(template, dayInput, new Date(dayMs));
+    if (!resolved) continue;
+    let entries;
+    try {
+      entries = fs13.readdirSync(resolved, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isFile() || !pattern.test(e.name)) continue;
+      const p = path25.join(resolved, e.name);
+      const mtime = safeMtimeMs(p);
+      if (mtime < cutoff) continue;
+      if (!best || mtime > best.mtime) best = { p, mtime };
+    }
+  }
+  return best ? best.p : null;
+}
+function expandPathForDate(template, input, day) {
+  if (!template) return null;
+  let out = template;
+  if (out.startsWith("~/") || out === "~") {
+    out = path25.join(os18.homedir(), out.slice(2));
+  }
+  out = out.replace(/\$\{([A-Z_][A-Z0-9_]*)(?::-(.*?))?\}/g, (_m, name, fallback) => {
+    const v = input.envOverrides?.[name] ?? process.env[name];
+    return v != null && v !== "" ? v : fallback ?? "";
+  });
+  if (out.startsWith("~/")) out = path25.join(os18.homedir(), out.slice(2));
+  const workspaceRaw = input.workspace ?? "";
+  let workspaceResolved = workspaceRaw;
+  if (workspaceRaw) {
+    try {
+      workspaceResolved = fs13.realpathSync(workspaceRaw);
+    } catch {
+    }
+  }
+  const vars = {
+    cwd: workspaceResolved,
+    cwd_dashed: workspaceResolved.replace(/\//g, "-"),
+    session_id: input.providerSessionId || input.sessionId || input.historySessionId || "",
+    yyyy: String(day.getUTCFullYear()),
+    mm: String(day.getUTCMonth() + 1).padStart(2, "0"),
+    dd: String(day.getUTCDate()).padStart(2, "0")
+  };
+  let missing = false;
+  out = out.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_m, name) => {
+    const v = vars[name] ?? "";
+    if (!v) missing = true;
+    return v;
+  });
+  if (missing) return null;
+  return out;
+}
 function newestRecentFile(dir, pattern, windowMs, sessionFloorMs = 0) {
   let entries;
   try {
@@ -12143,6 +12938,7 @@ __export(index_exports, {
   buildMeshHostRequiredFailure: () => buildMeshHostRequiredFailure,
   buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
+  buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
   buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
@@ -12270,6 +13066,7 @@ __export(index_exports, {
   maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv,
   namedKeyToAnsi: () => namedKeyToAnsi,
   namedKeysToAnsi: () => namedKeysToAnsi,
+  nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
   normalizeActiveChatData: () => normalizeActiveChatData,
   normalizeChatMessage: () => normalizeChatMessage,
   normalizeChatMessageKind: () => normalizeChatMessageKind,
@@ -12281,6 +13078,7 @@ __export(index_exports, {
   normalizeInteractivePrompt: () => normalizeInteractivePrompt,
   normalizeInteractivePromptResponse: () => normalizeInteractivePromptResponse,
   normalizeManagedStatus: () => normalizeManagedStatus,
+  normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
   normalizeMeshDaemonRole: () => normalizeMeshDaemonRole,
   normalizeMeshTaskMode: () => normalizeMeshTaskMode,
   normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
@@ -12339,7 +13137,6 @@ __export(index_exports, {
   startLocalIpcServer: () => startLocalIpcServer,
   suggestMeshRefineConfig: () => suggestMeshRefineConfig,
   summarizeGitStatus: () => summarizeGitStatus,
-  syncMeshes: () => syncMeshes,
   triggerMeshQueue: () => triggerMeshQueue,
   unregisterMeshCoordinator: () => unregisterMeshCoordinator,
   updateConfig: () => updateConfig,
@@ -12582,258 +13379,7 @@ init_repo_mesh_types();
 
 // src/git/index.ts
 init_git_executor();
-
-// src/git/git-status.ts
-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 (error) {
-    if (error instanceof GitCommandError) {
-      return emptyStatus(workspace, lastCheckedAt, error);
-    }
-    return emptyStatus(
-      workspace,
-      lastCheckedAt,
-      new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error })
-    );
-  }
-}
-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 (error) {
-    return {
-      upstreamStatus: "stale",
-      upstreamFetchError: formatGitError(error)
-    };
-  }
-}
-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(error) {
-  if (error instanceof GitCommandError) {
-    return error.stderr || error.message;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-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, error) {
-  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: error.stderr || error.message,
-    reason: error.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();
 
 // src/git/git-diff.ts
 var import_promises2 = require("fs/promises");
@@ -13249,6 +13795,7 @@ function createGitSnapshotStore(options = {}) {
 }
 
 // src/git/git-monitor.ts
+init_git_status();
 var DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS = 5e3;
 var MIN_GIT_WORKSPACE_POLL_INTERVAL_MS = 1e3;
 function defaultStatusProvider(workspace) {
@@ -13371,6 +13918,7 @@ function createGitWorkspaceMonitor(options = {}) {
 // src/git/git-commands.ts
 var path3 = __toESM(require("path"));
 init_git_executor();
+init_git_status();
 var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "git_status",
   "git_diff_summary",
@@ -14851,414 +15399,9 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
   return state;
 }
 
-// src/mesh/mesh-sync.ts
-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;
-}
-
 // src/index.ts
 init_mesh_ledger();
-
-// src/mesh/mesh-fast-forward.ts
-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 (error) {
-    const result2 = {
-      ...block(base, "merge_ff_only_failed", ["merge_ff_only_failed"]),
-      current,
-      preStatus: current,
-      operationError: formatGitError2(error),
-      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 (error) {
-        operationError = formatGitError2(error);
-      }
-    } else {
-      submoduleFollowUpRequired = true;
-    }
-  }
-  const postBlockers = collectPostExecutionBlockers(postStatus);
-  if (operationError) postBlockers.push("submodule_update_failed");
-  if (submoduleFollowUpRequired) postBlockers.push("submodule_update_required");
-  const success = 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,
-    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, success ? "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 (error) {
-    return { ok: false, error: formatGitError2(error) };
-  }
-}
-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(error) {
-  if (error instanceof GitCommandError) {
-    return error.stderr || error.stdout || error.message;
-  }
-  if (error instanceof Error) return error.message;
-  return String(error);
-}
-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 (error) {
-    result.ledgerError = error instanceof Error ? error.message : String(error);
-  }
-}
+init_mesh_fast_forward();
 
 // src/mesh/mesh-ledger-reconciliation.ts
 function lastTimestamp(slice) {
@@ -34719,6 +34862,7 @@ function getAvailableIdeIds() {
 // src/commands/router.ts
 init_config();
 init_cli_detector();
+init_git_status();
 init_logger();
 
 // src/logging/command-log.ts
@@ -34871,6 +35015,7 @@ init_logger();
 init_mesh_coordinator();
 init_mesh_events();
 init_mesh_host_ownership();
+init_mesh_fast_forward();
 
 // src/mesh/preview-freshness.ts
 var import_node_child_process4 = require("child_process");
@@ -37525,8 +37670,8 @@ var DaemonCommandRouter = class {
       }
     }
     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 {
     }
@@ -39451,8 +39596,8 @@ var DaemonCommandRouter = class {
         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 };
@@ -39570,7 +39715,7 @@ var DaemonCommandRouter = class {
         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 = {
@@ -39581,7 +39726,7 @@ var DaemonCommandRouter = class {
           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 } : {},
@@ -39772,8 +39917,8 @@ var DaemonCommandRouter = class {
           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) {
@@ -39842,8 +39987,8 @@ var DaemonCommandRouter = class {
             };
             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,
@@ -39998,8 +40143,8 @@ var DaemonCommandRouter = class {
             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);
@@ -49371,6 +49516,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   buildMeshHostRequiredFailure,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
+  buildMeshNodeCapabilityTags,
   buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage,
@@ -49498,6 +49644,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   maybeRunDaemonUpgradeHelperFromEnv,
   namedKeyToAnsi,
   namedKeysToAnsi,
+  nodeSatisfiesRequiredTags,
   normalizeActiveChatData,
   normalizeChatMessage,
   normalizeChatMessageKind,
@@ -49509,6 +49656,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   normalizeInteractivePrompt,
   normalizeInteractivePromptResponse,
   normalizeManagedStatus,
+  normalizeMeshCapabilityTags,
   normalizeMeshDaemonRole,
   normalizeMeshTaskMode,
   normalizeMeshWorkerResult,
@@ -49567,7 +49715,6 @@ var V1_CONTRACT_VERSION = "1.0.0";
   startLocalIpcServer,
   suggestMeshRefineConfig,
   summarizeGitStatus,
-  syncMeshes,
   triggerMeshQueue,
   unregisterMeshCoordinator,
   updateConfig,