adhdev 0.9.82-rc.53 → 0.9.82-rc.55

package/dist/cli/index.js

@@ -2199,9 +2199,9 @@ async function listWorktrees(repoRoot) {
 function parseWorktreeListOutput(output) {
   const entries = [];
   const blocks = output.trim().split(/\n\n+/);
-  for (const block of blocks) {
-    if (!block.trim()) continue;
-    const lines = block.trim().split("\n");
+  for (const block2 of blocks) {
+    if (!block2.trim()) continue;
+    const lines = block2.trim().split("\n");
     const entry = { path: "", head: "", branch: null, bare: false };
     for (const line of lines) {
       if (line.startsWith("worktree ")) {
@@ -3516,7 +3516,8 @@ function buildRulesSection(coordinatorCliType) {
 - **Respect node capabilities.** Don't send build tasks to read-only nodes. Don't push from nodes that aren't allowed to.
 - **Never fabricate tool results.** Always call the actual tool; never pretend you did.
 - **Clean up worktree nodes.** After a worktree task completes and its changes are merged or checkpointed, call \`mesh_remove_node\` to free resources.
-- **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
+- **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, fast-forward obvious clean behind-only branches with \`mesh_fast_forward_node\`, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
+- **Keep Refinery validation project-configurable.** \`mesh_refine_node\` must execute validation from repo mesh/refine config (for example \`.adhdev/refine.{json,yaml,yml}\`, \`.adhdev/repo-mesh-refine.*\`, or \`repo-mesh.refine.*\`). Heuristics are suggestions/scaffolding only, not the execution path.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }
 var TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION;
@@ -3540,6 +3541,7 @@ var init_coordinator_prompt = __esm({
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger \u2014 dispatches, completions, failures. Use to understand what has been done before deciding next steps |
 | \`mesh_git_status\` | Check git status on a specific node |
+| \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
@@ -3562,7 +3564,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Use \`mesh_view_queue\` to see the status of all pending, assigned, completed, and failed tasks. Do not call \`mesh_read_chat\` again within a few seconds for the same generating session. Use at most one compact \`mesh_read_chat\` check after a completion/approval signal. Handle approvals via \`mesh_approve\`.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
-7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary and \`mesh_refine_node\` for clean worktree branches when safe. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
+7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
 8. **Clean up** \u2014 Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
 9. **Report** \u2014 Summarize what was done, what changed, any issues, and the branch convergence state.
 
@@ -5654,17 +5656,17 @@ function detectType(state, object2, explicit) {
   }
   return false;
 }
-function writeNode(state, level, object2, block, compact, iskey, isblockseq) {
+function writeNode(state, level, object2, block2, compact, iskey, isblockseq) {
   state.tag = null;
   state.dump = object2;
   if (!detectType(state, object2, false)) {
     detectType(state, object2, true);
   }
   var type2 = _toString.call(state.dump);
-  var inblock = block;
+  var inblock = block2;
   var tagStr;
-  if (block) {
-    block = state.flowLevel < 0 || state.flowLevel > level;
+  if (block2) {
+    block2 = state.flowLevel < 0 || state.flowLevel > level;
   }
   var objectOrArray = type2 === "[object Object]" || type2 === "[object Array]", duplicateIndex, duplicate;
   if (objectOrArray) {
@@ -5681,7 +5683,7 @@ function writeNode(state, level, object2, block, compact, iskey, isblockseq) {
       state.usedDuplicates[duplicateIndex] = true;
     }
     if (type2 === "[object Object]") {
-      if (block && Object.keys(state.dump).length !== 0) {
+      if (block2 && Object.keys(state.dump).length !== 0) {
         writeBlockMapping(state, level, state.dump, compact);
         if (duplicate) {
           state.dump = "&ref_" + duplicateIndex + state.dump;
@@ -5693,7 +5695,7 @@ function writeNode(state, level, object2, block, compact, iskey, isblockseq) {
         }
       }
     } else if (type2 === "[object Array]") {
-      if (block && state.dump.length !== 0) {
+      if (block2 && state.dump.length !== 0) {
         if (state.noArrayIndent && !isblockseq && level > 0) {
           writeBlockSequence(state, level - 1, state.dump, compact);
         } else {
@@ -6871,6 +6873,363 @@ var init_mesh_ledger = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/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 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);
+  }
+}
+var STATUS_OPTIONS;
+var init_mesh_fast_forward = __esm({
+  "../../oss/packages/daemon-core/src/mesh/mesh-fast-forward.ts"() {
+    "use strict";
+    init_git_status();
+    init_git_executor();
+    STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3 };
+  }
+});
+
 // ../../oss/packages/daemon-core/src/mesh/mesh-ledger-reconciliation.ts
 function lastTimestamp(slice) {
   const entries = Array.isArray(slice?.entries) ? slice.entries : [];
@@ -46520,10 +46879,10 @@ function getMessageEventTime(message) {
 function stringifyPreviewContent(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
-    return content.map((block) => {
-      if (typeof block === "string") return block;
-      if (block && typeof block === "object" && "text" in block) {
-        return String(block.text || "");
+    return content.map((block2) => {
+      if (typeof block2 === "string") return block2;
+      if (block2 && typeof block2 === "object" && "text" in block2) {
+        return String(block2.text || "");
       }
       return "";
     }).join(" ");
@@ -48108,6 +48467,7 @@ var init_router = __esm({
     init_builders();
     init_mesh_events();
     init_mesh_host_ownership();
+    init_mesh_fast_forward();
     init_refine_config();
     init_snapshot();
     init_snapshot();
@@ -49824,6 +50184,32 @@ var init_router = __esm({
               cleanupWillRun: false
             };
           }
+          case "fast_forward_mesh_node": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+            let workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+            let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths) ? args.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
+            if (!workspace && meshId && nodeId) {
+              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+              const mesh = meshRecord?.mesh;
+              const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+              workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
+              if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
+                submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string");
+              }
+            }
+            const result = await fastForwardMeshNode({
+              meshId: meshId || void 0,
+              nodeId: nodeId || void 0,
+              workspace,
+              branch: typeof args?.branch === "string" ? args.branch : void 0,
+              execute: args?.execute === true,
+              dryRun: args?.dryRun === true,
+              updateSubmodules: args?.updateSubmodules === true,
+              submoduleIgnorePaths
+            });
+            return result;
+          }
           case "refine_mesh_node": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
@@ -50334,20 +50720,20 @@ var init_router = __esm({
                       const geminiMdPath = `${workspace}/GEMINI.md`;
                       const marker = "<!-- adhdev-mesh-coordinator-prompt -->";
                       const markerEnd = "<!-- /adhdev-mesh-coordinator-prompt -->";
-                      const block = `${marker}
+                      const block2 = `${marker}
 ${cliCmdSystemPrompt}
 ${markerEnd}`;
                       if (efs(geminiMdPath)) {
                         const existing = rfs(geminiMdPath, "utf-8");
                         const replaced = existing.replace(
                           new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, "g"),
-                          block
+                          block2
                         );
                         wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}
 
-${block}`);
+${block2}`);
                       } else {
-                        wfs(geminiMdPath, block);
+                        wfs(geminiMdPath, block2);
                       }
                       LOG.info("MeshCoordinator", `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
                     } catch (e) {
@@ -59161,6 +59547,7 @@ __export(src_exports, {
   enqueueTask: () => enqueueTask,
   ensureSessionHostReady: () => ensureSessionHostReady,
   execNpmCommandSync: () => execNpmCommandSync,
+  fastForwardMeshNode: () => fastForwardMeshNode,
   filterActivityChatMessages: () => filterActivityChatMessages,
   filterChatMessagesByVisibility: () => filterChatMessagesByVisibility,
   filterInternalChatMessages: () => filterInternalChatMessages,
@@ -59310,6 +59697,7 @@ var init_src = __esm({
     init_refine_config();
     init_mesh_sync();
     init_mesh_ledger();
+    init_mesh_fast_forward();
     init_mesh_ledger_reconciliation();
     init_mesh_work_queue();
     init_mesh_host_ownership();
@@ -98395,7 +98783,7 @@ var require_utility = __commonJS({
     function simd(simd2) {
       return sharp.simd(is.bool(simd2) ? simd2 : null);
     }
-    function block(options) {
+    function block2(options) {
       if (is.object(options)) {
         if (Array.isArray(options.operation) && options.operation.every(is.string)) {
           sharp.block(options.operation, true);
@@ -98426,7 +98814,7 @@ var require_utility = __commonJS({
       Sharp.interpolators = interpolators;
       Sharp.versions = versions;
       Sharp.queue = queue;
-      Sharp.block = block;
+      Sharp.block = block2;
       Sharp.unblock = unblock;
     };
   }
@@ -99220,6 +99608,17 @@ function summarizeMeshCommandArgs(command, args) {
       includeSubmodules: args.includeSubmodules === true
     };
   }
+  if (command === "fast_forward_mesh_node") {
+    return {
+      meshId: typeof args.meshId === "string" ? args.meshId : null,
+      nodeId: typeof args.nodeId === "string" ? args.nodeId : null,
+      workspace: typeof args.workspace === "string" ? args.workspace : null,
+      branch: typeof args.branch === "string" ? args.branch : null,
+      execute: args.execute === true,
+      dryRun: args.dryRun === true,
+      updateSubmodules: args.updateSubmodules === true
+    };
+  }
   if (command === "mesh_status" || command === "get_mesh") {
     const inlineMesh = asRecord(args.inlineMesh);
     const inlineNodes = Array.isArray(inlineMesh.nodes) ? inlineMesh.nodes : [];
@@ -100115,7 +100514,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.53" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.55" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;