@adhdev/daemon-standalone 0.9.82-rc.52 → 0.9.82-rc.54

package/dist/index.js

@@ -22482,9 +22482,9 @@ ${error48.message || ""}`;
     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 ")) {
@@ -23311,7 +23311,8 @@ ${rules.join("\n")}`;
 - **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;
@@ -23337,6 +23338,7 @@ ${rules.join("\n")}`;
 | \`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 |
@@ -23359,7 +23361,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.
 
@@ -28363,6 +28365,7 @@ ${lastSnapshot}`;
       enqueueTask: () => enqueueTask,
       ensureSessionHostReady: () => ensureSessionHostReady2,
       execNpmCommandSync: () => execNpmCommandSync,
+      fastForwardMeshNode: () => fastForwardMeshNode,
       filterActivityChatMessages: () => filterActivityChatMessages,
       filterChatMessagesByVisibility: () => filterChatMessagesByVisibility,
       filterInternalChatMessages: () => filterInternalChatMessages,
@@ -30480,6 +30483,354 @@ ${lastSnapshot}`;
       return result;
     }
     init_mesh_ledger();
+    init_git_executor();
+    var STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3 };
+    async function fastForwardMeshNode(args) {
+      const workspace = typeof args.workspace === "string" ? args.workspace.trim() : "";
+      const nodeId = normalizeOptionalString(args.nodeId);
+      const meshId = normalizeOptionalString(args.meshId);
+      const requestedBranch = normalizeOptionalString(args.branch);
+      const updateSubmodules = args.updateSubmodules === true;
+      const dryRun = args.dryRun === true || args.execute !== true;
+      const plannedSteps = buildPlannedSteps(updateSubmodules);
+      const base = {
+        ...nodeId ? { nodeId } : {},
+        ...meshId ? { meshId } : {},
+        workspace,
+        dryRun,
+        updateSubmodules,
+        plannedSteps
+      };
+      if (!workspace) {
+        return block(base, "invalid_workspace", ["workspace_required"]);
+      }
+      const current = await getGitRepoStatus(workspace, {
+        ...STATUS_OPTIONS,
+        submoduleIgnorePaths: args.submoduleIgnorePaths,
+        timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
+      });
+      const earlyBlockers = collectPreflightBlockers(current, requestedBranch);
+      if (earlyBlockers.length > 0) {
+        return {
+          ...block(base, chooseBlockCode(current, earlyBlockers), earlyBlockers),
+          current,
+          finalBranchConvergenceState: buildConvergenceState(current, codeToConvergenceStatus(chooseBlockCode(current, earlyBlockers)))
+        };
+      }
+      if (current.behind === 0) {
+        const result2 = {
+          ...base,
+          success: true,
+          code: "already_up_to_date",
+          allowed: true,
+          willRun: false,
+          executed: false,
+          blockingReasons: [],
+          current,
+          preStatus: current,
+          postStatus: current,
+          finalBranchConvergenceState: buildConvergenceState(current, "up_to_date")
+        };
+        await appendFastForwardLedger(result2, "noop");
+        return result2;
+      }
+      const ancestorCheck = await verifyHeadIsAncestorOfUpstream(workspace, current.upstream || "", args.timeoutMs);
+      if (!ancestorCheck.ok) {
+        const result2 = {
+          ...block(base, "non_fast_forward", ["head_is_not_ancestor_of_upstream"]),
+          current,
+          preStatus: current,
+          operationError: ancestorCheck.error,
+          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
+        };
+        await appendFastForwardLedger(result2, "blocked");
+        return result2;
+      }
+      if (dryRun) {
+        const result2 = {
+          ...base,
+          success: true,
+          code: "fast_forward_available",
+          allowed: true,
+          willRun: false,
+          executed: false,
+          blockingReasons: [],
+          current,
+          preStatus: current,
+          finalBranchConvergenceState: buildConvergenceState(current, "fast_forward_available")
+        };
+        return result2;
+      }
+      try {
+        await runGit(workspace, ["merge", "--ff-only", current.upstream || ""], { timeoutMs: args.timeoutMs ?? 3e4 });
+      } catch (error48) {
+        const result2 = {
+          ...block(base, "merge_ff_only_failed", ["merge_ff_only_failed"]),
+          current,
+          preStatus: current,
+          operationError: formatGitError2(error48),
+          finalBranchConvergenceState: buildConvergenceState(current, "not_mergeable")
+        };
+        await appendFastForwardLedger(result2, "failed");
+        return result2;
+      }
+      let postStatus = await getGitRepoStatus(workspace, {
+        ...STATUS_OPTIONS,
+        submoduleIgnorePaths: args.submoduleIgnorePaths,
+        timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
+      });
+      const submoduleIssues = collectSubmoduleBlockers(postStatus, "post");
+      let submoduleFollowUpRequired = false;
+      let operationError;
+      if (submoduleIssues.length > 0) {
+        if (updateSubmodules) {
+          try {
+            await runGit(workspace, ["submodule", "update", "--init", "--recursive"], { timeoutMs: args.timeoutMs ?? 6e4 });
+            postStatus = await getGitRepoStatus(workspace, {
+              ...STATUS_OPTIONS,
+              submoduleIgnorePaths: args.submoduleIgnorePaths,
+              timeoutMs: args.timeoutMs ?? STATUS_OPTIONS.timeoutMs
+            });
+          } catch (error48) {
+            operationError = formatGitError2(error48);
+          }
+        } else {
+          submoduleFollowUpRequired = true;
+        }
+      }
+      const postBlockers = collectPostExecutionBlockers(postStatus);
+      if (operationError) postBlockers.push("submodule_update_failed");
+      if (submoduleFollowUpRequired) postBlockers.push("submodule_update_required");
+      const success2 = postBlockers.length === 0 || submoduleFollowUpRequired;
+      const code = postBlockers.length === 0 ? "fast_forward_applied" : submoduleFollowUpRequired ? "fast_forward_applied_submodule_update_required" : "post_verify_failed";
+      const result = {
+        ...base,
+        success: success2,
+        code,
+        allowed: true,
+        willRun: true,
+        executed: true,
+        blockingReasons: postBlockers,
+        current,
+        preStatus: current,
+        postStatus,
+        ...operationError ? { operationError } : {},
+        finalBranchConvergenceState: buildConvergenceState(
+          postStatus,
+          postBlockers.length === 0 ? "fast_forwarded" : submoduleFollowUpRequired ? "follow_up_required" : "post_verify_failed"
+        )
+      };
+      await appendFastForwardLedger(result, success2 ? "executed" : "failed");
+      return result;
+    }
+    function buildPlannedSteps(updateSubmodules) {
+      const steps = [
+        {
+          operation: "refresh_upstream",
+          description: "Refresh the tracked upstream remote ref before trusting ahead/behind state.",
+          safe: true,
+          willMutateWorktree: false
+        },
+        {
+          operation: "verify_clean_worktree",
+          description: "Require clean staged/modified/untracked/deleted/renamed/conflict/stash/submodule state.",
+          safe: true,
+          willMutateWorktree: false
+        },
+        {
+          operation: "verify_fast_forward",
+          description: "Require ahead=0, behind>0, and HEAD to be an ancestor of the upstream ref.",
+          safe: true,
+          willMutateWorktree: false
+        },
+        {
+          operation: "merge_ff_only",
+          description: "Apply git merge --ff-only against the tracked upstream; no force, reset, rebase, push, or deploy.",
+          safe: true,
+          willMutateWorktree: true
+        }
+      ];
+      if (updateSubmodules) {
+        steps.push({
+          operation: "submodule_update",
+          description: "If the fast-forward changes gitlinks, run git submodule update --init --recursive and re-verify submodules.",
+          safe: true,
+          willMutateWorktree: true
+        });
+      }
+      steps.push({
+        operation: "verify_post_status",
+        description: "Re-read daemon-owned git status and report final branch convergence state.",
+        safe: true,
+        willMutateWorktree: false
+      });
+      return steps;
+    }
+    function collectPreflightBlockers(status, requestedBranch) {
+      const blockers = [];
+      if (!status.isGitRepo) blockers.push("not_git_repo");
+      if (!status.branch) blockers.push("detached_head_or_unknown_branch");
+      if (requestedBranch && status.branch !== requestedBranch) blockers.push("branch_mismatch");
+      if (!status.upstream) blockers.push("upstream_missing");
+      if (status.upstreamStatus !== "fresh") blockers.push("upstream_not_fresh");
+      if (status.hasConflicts) blockers.push("conflicts_present");
+      if (status.staged > 0) blockers.push("staged_changes_present");
+      if (status.modified > 0) blockers.push("modified_changes_present");
+      if (status.untracked > 0) blockers.push("untracked_changes_present");
+      if (status.deleted > 0) blockers.push("deleted_changes_present");
+      if (status.renamed > 0) blockers.push("renamed_changes_present");
+      if (status.stashCount > 0) blockers.push("stash_entries_present");
+      blockers.push(...collectSubmoduleBlockers(status, "pre"));
+      if (status.ahead > 0 && status.behind > 0) {
+        blockers.push("branch_diverged_from_upstream");
+        blockers.push("branch_has_local_commits");
+      } else if (status.ahead > 0) blockers.push("branch_has_local_commits");
+      return blockers;
+    }
+    function collectPostExecutionBlockers(status) {
+      const blockers = [];
+      if (!status.isGitRepo) blockers.push("post_not_git_repo");
+      if (status.hasConflicts) blockers.push("post_conflicts_present");
+      if (status.ahead !== 0) blockers.push("post_branch_ahead");
+      if (status.behind !== 0) blockers.push("post_branch_still_behind");
+      if (status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0) {
+        blockers.push("post_working_tree_not_clean");
+      }
+      if (status.stashCount > 0) blockers.push("post_stash_entries_present");
+      blockers.push(...collectSubmoduleBlockers(status, "post"));
+      return blockers;
+    }
+    function collectSubmoduleBlockers(status, phase) {
+      const submodules = Array.isArray(status.submodules) ? status.submodules : [];
+      const blockers = [];
+      for (const submodule of submodules) {
+        if (submodule.error) blockers.push(`${phase}_submodule_status_error:${submodule.path}`);
+        if (submodule.dirty) blockers.push(`${phase}_submodule_dirty:${submodule.path}`);
+        if (submodule.outOfSync) blockers.push(`${phase}_submodule_out_of_sync:${submodule.path}`);
+      }
+      return blockers;
+    }
+    function chooseBlockCode(status, blockers) {
+      if (blockers.includes("not_git_repo")) return "not_git_repo";
+      if (blockers.includes("branch_mismatch")) return "branch_mismatch";
+      if (blockers.includes("upstream_missing")) return "upstream_missing";
+      if (blockers.includes("upstream_not_fresh")) return "upstream_not_fresh";
+      if (blockers.some((reason) => reason.includes("submodule"))) return "submodule_not_clean";
+      if (blockers.includes("branch_diverged_from_upstream")) return "branch_diverged";
+      if (blockers.includes("branch_has_local_commits") || status.ahead > 0) return "branch_ahead";
+      if (blockers.some((reason) => reason.includes("changes") || reason.includes("conflicts") || reason.includes("stash"))) return "dirty_worktree";
+      return "preflight_blocked";
+    }
+    function codeToConvergenceStatus(code) {
+      if (code === "branch_diverged" || code === "branch_ahead" || code === "non_fast_forward") return "not_mergeable";
+      if (code === "dirty_worktree" || code === "submodule_not_clean") return "blocked_review";
+      return "blocked";
+    }
+    async function verifyHeadIsAncestorOfUpstream(workspace, upstream, timeoutMs) {
+      if (!upstream) return { ok: false, error: "missing upstream" };
+      try {
+        await runGit(workspace, ["merge-base", "--is-ancestor", "HEAD", upstream], { timeoutMs: timeoutMs ?? 15e3 });
+        return { ok: true };
+      } catch (error48) {
+        return { ok: false, error: formatGitError2(error48) };
+      }
+    }
+    function block(base, code, blockingReasons) {
+      const normalizedReasons = normalizeBlockingReasons(blockingReasons);
+      return {
+        ...base,
+        success: false,
+        code,
+        allowed: false,
+        willRun: false,
+        executed: false,
+        blockingReasons: normalizedReasons
+      };
+    }
+    function normalizeBlockingReasons(reasons) {
+      const normalized = /* @__PURE__ */ new Set();
+      for (const reason of reasons) {
+        normalized.add(reason);
+      }
+      if ([
+        "conflicts_present",
+        "staged_changes_present",
+        "modified_changes_present",
+        "untracked_changes_present",
+        "deleted_changes_present",
+        "renamed_changes_present"
+      ].some((reason) => normalized.has(reason))) {
+        normalized.add("working_tree_not_clean");
+      }
+      return Array.from(normalized);
+    }
+    function buildConvergenceState(status, convergenceStatus) {
+      return {
+        status: convergenceStatus,
+        branch: status.branch,
+        headCommit: status.headCommit,
+        upstream: status.upstream,
+        ahead: status.ahead,
+        behind: status.behind,
+        dirty: status.staged + status.modified + status.untracked + status.deleted + status.renamed > 0 || status.hasConflicts,
+        stashCount: status.stashCount,
+        submodules: summarizeSubmodules(status.submodules)
+      };
+    }
+    function summarizeSubmodules(submodules) {
+      return (submodules || []).map((submodule) => ({
+        path: submodule.path,
+        commit: submodule.commit,
+        dirty: submodule.dirty,
+        outOfSync: submodule.outOfSync,
+        ...submodule.error ? { error: submodule.error } : {}
+      }));
+    }
+    function normalizeOptionalString(value) {
+      return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    }
+    function formatGitError2(error48) {
+      if (error48 instanceof GitCommandError) {
+        return error48.stderr || error48.stdout || error48.message;
+      }
+      if (error48 instanceof Error) return error48.message;
+      return String(error48);
+    }
+    async function appendFastForwardLedger(result, outcome) {
+      if (!result.meshId) return;
+      try {
+        const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+        appendLedgerEntry2(result.meshId, {
+          kind: "direct_fast_forward",
+          ...result.nodeId ? { nodeId: result.nodeId } : {},
+          payload: {
+            operation: "mesh_fast_forward_node",
+            outcome,
+            code: result.code,
+            workspace: result.workspace,
+            allowed: result.allowed,
+            dryRun: result.dryRun,
+            willRun: result.willRun,
+            executed: result.executed,
+            branch: result.postStatus?.branch ?? result.current?.branch,
+            upstream: result.postStatus?.upstream ?? result.current?.upstream,
+            before: result.current ? {
+              headCommit: result.current.headCommit,
+              ahead: result.current.ahead,
+              behind: result.current.behind
+            } : void 0,
+            after: result.postStatus ? {
+              headCommit: result.postStatus.headCommit,
+              ahead: result.postStatus.ahead,
+              behind: result.postStatus.behind
+            } : void 0,
+            blockingReasons: result.blockingReasons
+          }
+        });
+      } catch (error48) {
+        result.ledgerError = error48 instanceof Error ? error48.message : String(error48);
+      }
+    }
     function lastTimestamp(slice) {
       const entries = Array.isArray(slice?.entries) ? slice.entries : [];
       return entries.length ? entries[entries.length - 1].timestamp : null;
@@ -45959,10 +46310,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     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(" ");
@@ -49203,6 +49554,32 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               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() : "";
@@ -49713,20 +50090,20 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                       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);
                       }
                       LOG2.info("MeshCoordinator", `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
                     } catch (e) {