@adhdev/daemon-standalone 0.9.82-rc.259 → 0.9.82-rc.260

package/dist/index.js

@@ -32396,6 +32396,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
       normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
       normalizeMeshTaskMode: () => normalizeMeshTaskMode,
+      recordDirectDispatchTask: () => recordDirectDispatchTask,
       recordMeshToolCall: () => recordMeshToolCall,
       recordTaskAutoLaunch: () => recordTaskAutoLaunch,
       requeueTask: () => requeueTask,
@@ -32560,6 +32561,37 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         return entry;
       });
     }
+    function recordDirectDispatchTask(meshId, message, opts) {
+      const missionId = typeof opts.missionId === "string" ? opts.missionId.trim() : "";
+      if (!missionId) return null;
+      const taskId = typeof opts.id === "string" ? opts.id.trim() : "";
+      if (!taskId) return null;
+      const modeValidation = validateMeshTaskModeRequest(opts.taskMode, message);
+      if (!modeValidation.valid) {
+        throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`);
+      }
+      const now = opts.dispatchedAt && opts.dispatchedAt.trim() ? opts.dispatchedAt : (/* @__PURE__ */ new Date()).toISOString();
+      return withQueueLock(meshId, () => {
+        if (MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId)) {
+          return null;
+        }
+        const entry = {
+          id: taskId,
+          meshId,
+          message,
+          status: "assigned",
+          ...modeValidation.taskMode ? { taskMode: modeValidation.taskMode } : {},
+          missionId,
+          ...opts.assignedNodeId ? { targetNodeId: opts.assignedNodeId, assignedNodeId: opts.assignedNodeId } : {},
+          ...opts.assignedSessionId ? { targetSessionId: opts.assignedSessionId, assignedSessionId: opts.assignedSessionId } : {},
+          dispatchTimestamp: now,
+          createdAt: now,
+          updatedAt: now
+        };
+        MeshRuntimeStore.getInstance().insertQueueEntry(entry);
+        return entry;
+      });
+    }
     function getQueue(meshId, opts) {
       return MeshRuntimeStore.getInstance().getQueueEntries(meshId, opts?.status?.length ? opts.status : void 0);
     }
@@ -34148,9 +34180,50 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         return (Number.isFinite(bTime) ? bTime : 0) - (Number.isFinite(aTime) ? aTime : 0);
       });
     }
+    function jobActivityTime(job) {
+      const raw = job.lastUpdatedAt || job.completedAt || job.startedAt || "";
+      const t = new Date(raw).getTime();
+      return Number.isFinite(t) ? t : 0;
+    }
+    function summarizeMeshAsyncRefineJobs(jobs) {
+      const activeJobs = [];
+      const terminalJobs = [];
+      for (const job of jobs) {
+        if (TERMINAL_REFINE_STATUSES.has(job.status)) terminalJobs.push(job);
+        else activeJobs.push(job);
+      }
+      let newest = 0;
+      for (const job of jobs) newest = Math.max(newest, jobActivityTime(job));
+      const cutoff = newest - STALE_TERMINAL_REFINE_WINDOW_MS;
+      const terminalByRecency = [...terminalJobs].sort(
+        (a, b) => jobActivityTime(b) - jobActivityTime(a)
+      );
+      const freshTerminal = terminalByRecency.filter((job) => jobActivityTime(job) >= cutoff).slice(0, RECENT_TERMINAL_REFINE_CAP);
+      const freshTerminalIds = new Set(freshTerminal.map((job) => job.jobId));
+      const byStatus = {};
+      for (const job of activeJobs) {
+        byStatus[job.status] = (byStatus[job.status] ?? 0) + 1;
+      }
+      for (const job of freshTerminal) {
+        byStatus[job.status] = (byStatus[job.status] ?? 0) + 1;
+      }
+      const staleTerminal = terminalJobs.length - freshTerminalIds.size;
+      return {
+        total: activeJobs.length + freshTerminal.length,
+        byStatus,
+        staleTerminal,
+        activeJobs
+      };
+    }
+    var TERMINAL_REFINE_STATUSES;
+    var STALE_TERMINAL_REFINE_WINDOW_MS;
+    var RECENT_TERMINAL_REFINE_CAP;
     var init_mesh_refine_status = __esm2({
       "src/mesh/mesh-refine-status.ts"() {
         "use strict";
+        TERMINAL_REFINE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed"]);
+        STALE_TERMINAL_REFINE_WINDOW_MS = 6 * 60 * 60 * 1e3;
+        RECENT_TERMINAL_REFINE_CAP = 8;
       }
     });
     var mesh_review_inbox_exports = {};
@@ -40176,6 +40249,26 @@ ${cont}` : cont;
           // ── Approval ─────────────────────────────────────
           lastApprovalResolvedAt = 0;
           lastResolvedModalMessage = "";
+          /**
+           * Monotonic counter bumped every time the FSM *enters* waiting_approval
+           * with a freshly captured modal (see `applyWaitingApproval`). It is the
+           * single discriminator between "the same approval re-observed across TUI
+           * paint flaps" and "a genuinely new, distinct approval".
+           *
+           * The message-equality cooldown below (`lastResolvedModalMessage`) cannot
+           * tell these apart on its own: claude-cli routinely presents consecutive
+           * approvals whose modal message text is identical (e.g. two back-to-back
+           * Bash-command prompts). When that second approval arrived inside
+           * `approvalCooldown`, the message-equality guard silently swallowed the
+           * key write and the approval stuck forever — fatal under auto-approval.
+           *
+           * `approvalEntrySeq` increments on every fresh entry; `lastResolvedEntrySeq`
+           * records which entry the cooldown belongs to. We only short-circuit the
+           * write when we are still resolving *that same* entry — a new entry (new
+           * seq) is always a real, distinct approval and must be written.
+           */
+          approvalEntrySeq = 0;
+          lastResolvedEntrySeq = -1;
           /**
            * When the engine previously held a modal but the latest parse failed
            * to extract one, we record the timestamp here and only drop the modal
@@ -40281,6 +40374,7 @@ ${cont}` : cont;
                 if (parsed?.status === "waiting_approval" && parsedModal) {
                   modal = parsedModal;
                   this.activeModal = parsedModal;
+                  this.approvalEntrySeq++;
                   if (this.currentStatus !== "waiting_approval") {
                     this.setStatus("waiting_approval", "resolve_modal_parse");
                     this.callbacks.onStatusChange();
@@ -40294,12 +40388,14 @@ ${cont}` : cont;
             if (!modal || !buttonsValid) return;
             const currentModalMessage = typeof modal?.message === "string" ? modal.message.trim() : "";
             const inCooldown = !!this.lastApprovalResolvedAt && Date.now() - this.lastApprovalResolvedAt < this.timeouts.approvalCooldown;
-            if (inCooldown && currentModalMessage === this.lastResolvedModalMessage) return;
+            const sameEntryReResolve = this.approvalEntrySeq === this.lastResolvedEntrySeq;
+            if (inCooldown && sameEntryReResolve && currentModalMessage === this.lastResolvedModalMessage) return;
             this.clearIdleFinishCandidate("resolve_modal");
-            this.recordTrace("resolve_modal", { buttonIndex, activeModal: modal });
+            this.recordTrace("resolve_modal", { buttonIndex, activeModal: modal, approvalEntrySeq: this.approvalEntrySeq });
             this.activeModal = null;
             this.lastApprovalResolvedAt = Date.now();
             this.lastResolvedModalMessage = currentModalMessage;
+            this.lastResolvedEntrySeq = this.approvalEntrySeq;
             this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
             if (this.approvalExitTimeout) {
               clearTimeout(this.approvalExitTimeout);
@@ -40656,7 +40752,7 @@ ${cont}` : cont;
               this.callbacks.onStatusChange();
               return;
             }
-            if (!inCooldown) {
+            if (!inCooldown || modal) {
               if (!modal) {
                 LOG2.warn("CLI", `[${this.provider.type}] detectStatus=waiting_approval but parseApproval returned null; ignoring`);
                 if (this.currentStatus === "waiting_approval" && this.activeModal) {
@@ -40679,6 +40775,7 @@ ${cont}` : cont;
               const nextBtnCount = Array.isArray(modal.buttons) ? modal.buttons.length : 0;
               if (!prev || prevBtnCount !== nextBtnCount) {
                 this.activeModal = modal;
+                this.approvalEntrySeq++;
                 this.callbacks.onStatusChange();
               }
               if (this.idleTimeout) clearTimeout(this.idleTimeout);
@@ -41872,6 +41969,7 @@ ${lastSnapshot}`;
               messages: [],
               workingDir: this.workingDir,
               activeModal: effectiveModal,
+              approvalEntrySeq: this.engine.approvalEntrySeq,
               pendingOutboundCount: this.pendingOutboundQueue.length,
               pendingOutboundMessages: this.pendingOutboundQueue.map((message) => ({
                 id: message.id,
@@ -43770,7 +43868,9 @@ ${lastSnapshot}`;
       ProviderCliAdapter: () => ProviderCliAdapter,
       ProviderInstanceManager: () => ProviderInstanceManager,
       ProviderLoader: () => ProviderLoader,
+      RECENT_TERMINAL_REFINE_CAP: () => RECENT_TERMINAL_REFINE_CAP,
       RawTerminalAttachment: () => RawTerminalAttachment,
+      STALE_TERMINAL_REFINE_WINDOW_MS: () => STALE_TERMINAL_REFINE_WINDOW_MS,
       STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS2,
       SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory2,
       TerminalAdapter: () => TerminalAdapter,
@@ -43978,6 +44078,7 @@ ${lastSnapshot}`;
       reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
       recordCompletionConflict: () => recordCompletionConflict,
       recordDebugTrace: () => recordDebugTrace,
+      recordDirectDispatchTask: () => recordDirectDispatchTask,
       recordMeshToolCall: () => recordMeshToolCall,
       registerExtensionProviders: () => registerExtensionProviders,
       registerMeshCoordinator: () => registerMeshCoordinator,
@@ -44014,6 +44115,7 @@ ${lastSnapshot}`;
       startLocalIpcServer: () => startLocalIpcServer2,
       suggestMeshRefineConfig: () => suggestMeshRefineConfig,
       summarizeGitStatus: () => summarizeGitStatus,
+      summarizeMeshAsyncRefineJobs: () => summarizeMeshAsyncRefineJobs,
       summarizeMeshMission: () => summarizeMeshMission,
       summarizeMissionTasks: () => summarizeMissionTasks,
       triggerMeshQueue: () => triggerMeshQueue,
@@ -46236,7 +46338,7 @@ ${lastSnapshot}`;
       if (!validation.valid) {
         return { status: "failed", required: required2, configSource: loaded.path || loaded.source, configSourceType: "invalid", error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")), commandsRun: [] };
       }
-      const execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+      const execFileAsync4 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
       const state = {
         status: "running",
         required: required2,
@@ -46262,7 +46364,7 @@ ${lastSnapshot}`;
         const startedAt = Date.now();
         state.lastCommand = command.displayCommand;
         try {
-          const result = await execFileAsync3(command.command, command.args, {
+          const result = await execFileAsync4(command.command, command.args, {
             cwd,
             encoding: "utf8",
             timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS2,
@@ -61244,7 +61346,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         if (buttonIndex < 0) {
           return autoApproveActive;
         }
+        const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : 0;
         const signature = [
+          approvalEntrySeq,
           typeof modal?.message === "string" ? modal.message.trim() : "",
           buttons.join("|"),
           buttonIndex
@@ -66886,8 +66990,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         const https = require("https");
         const { exec: exec7 } = require("child_process");
-        const { promisify: promisify7 } = require("util");
-        const execAsync5 = promisify7(exec7);
+        const { promisify: promisify8 } = require("util");
+        const execAsync5 = promisify8(exec7);
         const metaPath = path30.join(this.upstreamDir, _ProviderLoader.META_FILE);
         let prevEtag = "";
         let prevTimestamp = 0;
@@ -68157,12 +68261,97 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_mesh_host_ownership();
     init_mesh_fast_forward();
     var import_node_child_process4 = require("child_process");
+    var import_node_util4 = require("util");
+    var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
+    var MAX_CHANGED_FILES2 = 500;
+    function topLevel(path39) {
+      const slash = path39.indexOf("/");
+      return slash === -1 ? path39 : path39.slice(0, slash);
+    }
+    async function analyzeMeshRefineNodeChangeArea(args) {
+      const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
+      const base = {
+        nodeId,
+        workspace,
+        branch,
+        changedTopLevelPaths: [],
+        changedFiles: [],
+        touchedSubmodulePaths: [],
+        touchesSubmodule: false,
+        aheadCount: 0
+      };
+      try {
+        let mergeBase = baseRef;
+        try {
+          const { stdout } = await execFileAsync3("git", ["merge-base", baseRef, branchRef], { cwd: diffCwd, encoding: "utf8" });
+          const resolved = stdout.trim();
+          if (resolved) mergeBase = resolved;
+        } catch {
+        }
+        const { stdout: countStdout } = await execFileAsync3(
+          "git",
+          ["rev-list", "--count", `${mergeBase}..${branchRef}`],
+          { cwd: diffCwd, encoding: "utf8" }
+        );
+        base.aheadCount = Number.parseInt(countStdout.trim(), 10) || 0;
+        const { stdout: nameStdout } = await execFileAsync3(
+          "git",
+          ["diff", "--name-only", `${mergeBase}..${branchRef}`],
+          { cwd: diffCwd, encoding: "utf8" }
+        );
+        const files = nameStdout.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, MAX_CHANGED_FILES2);
+        base.changedFiles = files;
+        const topSet = /* @__PURE__ */ new Set();
+        const submoduleSet = /* @__PURE__ */ new Set();
+        for (const file2 of files) {
+          const top = topLevel(file2);
+          topSet.add(top);
+          if (submodulePaths.has(file2) || submodulePaths.has(top)) {
+            submoduleSet.add(submodulePaths.has(file2) ? file2 : top);
+          }
+        }
+        base.changedTopLevelPaths = [...topSet].sort();
+        base.touchedSubmodulePaths = [...submoduleSet].sort();
+        base.touchesSubmodule = submoduleSet.size > 0;
+        return base;
+      } catch (e) {
+        base.error = e?.message || String(e);
+        return base;
+      }
+    }
+    function orderMeshRefineBatchNodes(changeAreas) {
+      const areaById = {};
+      for (const area of changeAreas) areaById[area.nodeId] = area;
+      const ranked = [...changeAreas].sort((a, b) => {
+        const aSub = a.touchesSubmodule ? 1 : 0;
+        const bSub = b.touchesSubmodule ? 1 : 0;
+        if (aSub !== bSub) return aSub - bSub;
+        const aBreadth = a.changedTopLevelPaths.length;
+        const bBreadth = b.changedTopLevelPaths.length;
+        if (aBreadth !== bBreadth) return aBreadth - bBreadth;
+        return a.nodeId.localeCompare(b.nodeId);
+      });
+      const rationale = [];
+      const nonSub = ranked.filter((a) => !a.touchesSubmodule).map((a) => a.nodeId);
+      const sub = ranked.filter((a) => a.touchesSubmodule).map((a) => a.nodeId);
+      if (nonSub.length) {
+        rationale.push(`Non-submodule nodes first (no submodule-main advance, conflict-free ordering): ${nonSub.join(", ")}`);
+      }
+      if (sub.length) {
+        rationale.push(`Submodule-touching nodes last, serialized (each merge advances submodule main, forcing rebase of the next): ${sub.join(", ")}`);
+      }
+      for (const area of ranked) {
+        if (area.error) rationale.push(`Node ${area.nodeId}: change-area analysis degraded (${area.error}); placed with neutral priority.`);
+      }
+      return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
+    }
+    var import_node_child_process5 = require("child_process");
     var import_node_fs4 = require("fs");
     var import_node_path2 = require("path");
     var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
     function runGit2(repoRoot, args) {
       try {
-        return (0, import_node_child_process4.execFileSync)("git", args, {
+        return (0, import_node_child_process5.execFileSync)("git", args, {
           cwd: repoRoot,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "ignore"],
@@ -68922,7 +69111,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     var import_os3 = require("os");
     var import_path10 = require("path");
     var fs23 = __toESM2(require("fs"));
-    var import_node_child_process5 = require("child_process");
+    var import_node_child_process6 = require("child_process");
     var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     var CHANNEL_SERVER_URL = {
       stable: "https://api.adhf.dev",
@@ -70080,7 +70269,7 @@ ${e?.stderr || ""}`
     }
     function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
       try {
-        const output = (0, import_node_child_process5.execFileSync)("git", ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+        const output = (0, import_node_child_process6.execFileSync)("git", ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -70104,7 +70293,7 @@ ${e?.stderr || ""}`
     }
     function readTreeObject(repoRoot, ref, path39) {
       try {
-        const output = (0, import_node_child_process5.execFileSync)("git", ["ls-tree", ref, "--", path39], {
+        const output = (0, import_node_child_process6.execFileSync)("git", ["ls-tree", ref, "--", path39], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -70138,10 +70327,10 @@ ${e?.stderr || ""}`
       }
       const commandArgs = ["submodule", "update", "--init", "--recursive", "--", ...updatePaths];
       try {
-        const { execFile: execFile4 } = await import("child_process");
-        const { promisify: promisify7 } = await import("util");
-        const execFileAsync3 = promisify7(execFile4);
-        const result = await execFileAsync3("git", commandArgs, {
+        const { execFile: execFile5 } = await import("child_process");
+        const { promisify: promisify8 } = await import("util");
+        const execFileAsync4 = promisify8(execFile5);
+        const result = await execFileAsync4("git", commandArgs, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -70184,11 +70373,11 @@ ${e?.stderr || ""}`
       const startedAt = Date.now();
       const entries = [];
       try {
-        const { execFile: execFile4 } = await import("child_process");
-        const { promisify: promisify7 } = await import("util");
-        const execFileAsync3 = promisify7(execFile4);
+        const { execFile: execFile5 } = await import("child_process");
+        const { promisify: promisify8 } = await import("util");
+        const execFileAsync4 = promisify8(execFile5);
         const runGit3 = async (cwd, args) => {
-          const { stdout } = await execFileAsync3("git", args, {
+          const { stdout } = await execFileAsync4("git", args, {
             cwd,
             encoding: "utf8",
             timeout: 3e4,
@@ -70203,7 +70392,7 @@ ${e?.stderr || ""}`
         };
         const publishCommitToRemoteMain = async (submodulePath, commit, branch = "main") => {
           const refspec = `${commit}:refs/heads/${branch}`;
-          const { stdout, stderr } = await execFileAsync3("git", ["push", "origin", refspec], {
+          const { stdout, stderr } = await execFileAsync4("git", ["push", "origin", refspec], {
             cwd: submodulePath,
             encoding: "utf8",
             timeout: 3e4,
@@ -70388,9 +70577,9 @@ ${e?.stderr || ""}`
       };
     }
     async function runMeshRefineValidationGate(mesh, workspace, opts) {
-      const { execFile: execFile4 } = await import("child_process");
-      const { promisify: promisify7 } = await import("util");
-      const execFileAsync3 = promisify7(execFile4);
+      const { execFile: execFile5 } = await import("child_process");
+      const { promisify: promisify8 } = await import("util");
+      const execFileAsync4 = promisify8(execFile5);
       const selection = resolveMeshRefineValidationPlan(mesh, workspace);
       const summary = {
         status: "skipped",
@@ -70484,7 +70673,7 @@ ${e?.stderr || ""}`
           const cwd = candidate.cwd ? (0, import_path10.resolve)(workspace, candidate.cwd) : workspace;
           const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
           try {
-            const result = await execFileAsync3(candidate.command, candidate.args, {
+            const result = await execFileAsync4(candidate.command, candidate.args, {
               cwd,
               encoding: "utf8",
               timeout,
@@ -70526,7 +70715,7 @@ ${e?.stderr || ""}`
           return summary;
         }
         try {
-          const result = await execFileAsync3(candidate.command, candidate.args, {
+          const result = await execFileAsync4(candidate.command, candidate.args, {
             cwd,
             encoding: "utf8",
             timeout,
@@ -71094,19 +71283,19 @@ ${e?.stderr || ""}`
           const isSubmoduleGuard = /working trees containing submodules cannot be moved or removed/i.test(message);
           const submoduleForceBlocked = isSubmoduleGuard && !forceFallbackConvergence.allow;
           if (isSubmoduleGuard && forceFallbackConvergence.allow) {
-            const { execFile: execFile4 } = await import("child_process");
-            const { promisify: promisify7 } = await import("util");
-            const execFileAsync3 = promisify7(execFile4);
+            const { execFile: execFile5 } = await import("child_process");
+            const { promisify: promisify8 } = await import("util");
+            const execFileAsync4 = promisify8(execFile5);
             const GIT_TIMEOUT_CLEANUP = 3e4;
             const GIT_MAX_BUFFER_CLEANUP = 4 * 1024 * 1024;
             try {
-              await execFileAsync3("git", ["-C", workspace, "submodule", "deinit", "--all", "-f"], {
+              await execFileAsync4("git", ["-C", workspace, "submodule", "deinit", "--all", "-f"], {
                 encoding: "utf8",
                 timeout: GIT_TIMEOUT_CLEANUP,
                 maxBuffer: GIT_MAX_BUFFER_CLEANUP,
                 windowsHide: true
               });
-              await execFileAsync3("git", ["worktree", "remove", "--force", workspace], {
+              await execFileAsync4("git", ["worktree", "remove", "--force", workspace], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 timeout: GIT_TIMEOUT_CLEANUP,
@@ -71125,7 +71314,7 @@ ${e?.stderr || ""}`
             } catch (deinitError) {
               try {
                 fs23.rmSync(workspace, { recursive: true, force: true });
-                await execFileAsync3("git", ["worktree", "prune"], {
+                await execFileAsync4("git", ["worktree", "prune"], {
                   cwd: repoRoot,
                   encoding: "utf8",
                   timeout: GIT_TIMEOUT_CLEANUP,
@@ -71169,11 +71358,11 @@ ${e?.stderr || ""}`
         if (refinedConvergence === "merged_pushed" || refinedConvergence === "merged_to_main") {
           return { allow: true, status: refinedConvergence, source: "node_refine_state" };
         }
-        const { execFile: execFile4 } = await import("child_process");
-        const { promisify: promisify7 } = await import("util");
-        const execFileAsync3 = promisify7(execFile4);
+        const { execFile: execFile5 } = await import("child_process");
+        const { promisify: promisify8 } = await import("util");
+        const execFileAsync4 = promisify8(execFile5);
         const runGit3 = async (gitArgs, cwd) => {
-          const { stdout } = await execFileAsync3("git", gitArgs, {
+          const { stdout } = await execFileAsync4("git", gitArgs, {
             cwd,
             encoding: "utf8",
             timeout: 3e4,
@@ -71645,30 +71834,30 @@ ${e?.stderr || ""}`
           const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
           const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
           if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
-          const { execFile: execFile4 } = await import("child_process");
-          const { promisify: promisify7 } = await import("util");
-          const execFileAsync3 = promisify7(execFile4);
+          const { execFile: execFile5 } = await import("child_process");
+          const { promisify: promisify8 } = await import("util");
+          const execFileAsync4 = promisify8(execFile5);
           const resolveStarted = Date.now();
-          const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
+          const { stdout: branchStdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
           const branch = branchStdout.trim();
           if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
-          const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
+          const { stdout: baseBranchStdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
           const baseBranch = baseBranchStdout.trim();
           let fetchWarning;
           try {
-            await execFileAsync3("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+            await execFileAsync4("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
           } catch (e) {
             fetchWarning = `git fetch origin ${baseBranch} failed (proceeding with local HEAD): ${e?.message}`;
           }
           let baseHeadRaw;
           try {
-            const { stdout } = await execFileAsync3("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
+            const { stdout } = await execFileAsync4("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
             baseHeadRaw = stdout.trim();
           } catch {
-            const { stdout: localHead } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+            const { stdout: localHead } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
             baseHeadRaw = localHead.trim();
           }
-          const { stdout: branchHeadStdout } = await execFileAsync3("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
+          const { stdout: branchHeadStdout } = await execFileAsync4("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
           const baseHead = baseHeadRaw;
           let branchHead = branchHeadStdout.trim();
           recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead, ...fetchWarning ? { fetchWarning } : {} });
@@ -71756,7 +71945,7 @@ ${tail}` : ""
             let didAutoRebase = false;
             let isBehindBase = false;
             try {
-              (0, import_node_child_process5.execFileSync)("git", ["merge-base", "--is-ancestor", branchHead, baseHead], {
+              (0, import_node_child_process6.execFileSync)("git", ["merge-base", "--is-ancestor", branchHead, baseHead], {
                 cwd: node.workspace,
                 stdio: "ignore"
               });
@@ -71766,11 +71955,11 @@ ${tail}` : ""
             if (isBehindBase) {
               const autoRebaseStarted = Date.now();
               try {
-                (0, import_node_child_process5.execFileSync)("git", ["rebase", baseHead], {
+                (0, import_node_child_process6.execFileSync)("git", ["rebase", baseHead], {
                   cwd: node.workspace,
                   stdio: ["ignore", "pipe", "pipe"]
                 });
-                const { stdout: rebasedHeadStdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8" });
+                const { stdout: rebasedHeadStdout } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8" });
                 branchHead = rebasedHeadStdout.trim();
                 const rebasedPatchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
                 recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", rebasedPatchEquivalence.status, autoRebaseStarted, {
@@ -71807,7 +71996,7 @@ ${tail}` : ""
                 }
               } catch (rebaseErr) {
                 try {
-                  (0, import_node_child_process5.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+                  (0, import_node_child_process6.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
                 } catch {
                 }
                 recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", "failed", autoRebaseStarted, {
@@ -72014,7 +72203,7 @@ ${tail}` : ""
           let mergeResult;
           const mergeStarted = Date.now();
           try {
-            const result = await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+            const result = await execFileAsync4("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
             mergeResult = {
               stdout: truncateValidationOutput(result.stdout),
               stderr: truncateValidationOutput(result.stderr),
@@ -72148,7 +72337,7 @@ ${tail}` : ""
           if (!requireApprovalForPush) {
             const pushStarted = Date.now();
             try {
-              await execFileAsync3("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+              await execFileAsync4("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
               pushResult = { pushed: true, remote: "origin", branch: baseBranch, durationMs: Date.now() - pushStarted };
               recordMeshRefineStage(refineStages, "push", "passed", pushStarted, pushResult);
               finalBranchConvergenceState.status = "merged_pushed";
@@ -72189,6 +72378,223 @@ ${tail}` : ""
           return { success: false, error: e.message, refineStages };
         }
       }
+      /**
+       * Batch refinery: converge multiple sibling worktree nodes onto the base branch
+       * in one sequential pipeline, absorbing the rebase + patch-equivalence churn that
+       * arises when several siblings touch the same submodule.
+       *
+       * Reuses executeMeshRefineNodeSynchronously per node — every node goes through the
+       * exact same validation / patch-equivalence / submodule-reachability / merge / cleanup
+       * gates, including its built-in auto-rebase onto fresh origin/<base>. Because each
+       * node fetches origin/<base> at the start of its own refine, a node merged earlier in
+       * the batch advances the base, and the next node's refine auto-rebases onto it before
+       * re-running patch-equivalence. No force-push, no reset — conflicting nodes are
+       * isolated as blocked_review while the rest of the batch proceeds.
+       */
+      async batchRefineMeshNodes(meshId, requestedNodeIds, args) {
+        const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        const mesh = meshRecord?.mesh;
+        if (!mesh) return { success: false, error: `Mesh '${meshId}' not found` };
+        const allNodes = Array.isArray(mesh.nodes) ? mesh.nodes : [];
+        const isConvergeable = (n) => n?.isLocalWorktree && typeof n.workspace === "string" && n.workspace;
+        let targetNodes;
+        if (Array.isArray(requestedNodeIds) && requestedNodeIds.length > 0) {
+          targetNodes = [];
+          const missing = [];
+          const nonWorktree = [];
+          for (const nodeId of requestedNodeIds) {
+            const node = allNodes.find((n) => n.id === nodeId || n.nodeId === nodeId);
+            if (!node) {
+              missing.push(nodeId);
+              continue;
+            }
+            if (!isConvergeable(node)) {
+              nonWorktree.push(nodeId);
+              continue;
+            }
+            targetNodes.push(node);
+          }
+          if (missing.length || nonWorktree.length) {
+            return {
+              success: false,
+              error: "One or more requested nodes are not convergeable local worktree nodes.",
+              ...missing.length ? { missingNodeIds: missing } : {},
+              ...nonWorktree.length ? { nonWorktreeNodeIds: nonWorktree } : {}
+            };
+          }
+        } else {
+          targetNodes = allNodes.filter(isConvergeable);
+        }
+        if (targetNodes.length === 0) {
+          return { success: true, batch: true, dryRun: args?.dryRun !== false, nodeCount: 0, order: [], results: [], note: "No convergeable local worktree nodes found." };
+        }
+        const { execFile: execFile5 } = await import("child_process");
+        const { promisify: promisify8 } = await import("util");
+        const execFileAsync4 = promisify8(execFile5);
+        const resolveRepoRootFor = (node) => {
+          const sourceNode = node.clonedFromNodeId ? allNodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : allNodes.find((n) => !n.isLocalWorktree);
+          return sourceNode?.repoRoot || sourceNode?.workspace;
+        };
+        const repoRootBaseRef = /* @__PURE__ */ new Map();
+        const submodulePathsByRepoRoot = /* @__PURE__ */ new Map();
+        const resolveBaseRef = async (repoRoot) => {
+          const cached2 = repoRootBaseRef.get(repoRoot);
+          if (cached2) return cached2;
+          let baseBranch = "main";
+          try {
+            const { stdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
+            if (stdout.trim()) baseBranch = stdout.trim();
+          } catch {
+          }
+          let baseRef = "HEAD";
+          try {
+            await execFileAsync4("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+          } catch {
+          }
+          try {
+            const { stdout } = await execFileAsync4("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
+            baseRef = stdout.trim();
+          } catch {
+            try {
+              const { stdout } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+              baseRef = stdout.trim();
+            } catch {
+            }
+          }
+          repoRootBaseRef.set(repoRoot, baseRef);
+          return baseRef;
+        };
+        const changeAreas = [];
+        for (const node of targetNodes) {
+          const repoRoot = resolveRepoRootFor(node);
+          let branch = typeof node.worktreeBranch === "string" ? node.worktreeBranch : "";
+          try {
+            const { stdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
+            if (stdout.trim()) branch = stdout.trim();
+          } catch {
+          }
+          if (!repoRoot || !branch) {
+            changeAreas.push({
+              nodeId: node.id,
+              workspace: node.workspace,
+              branch: branch || "(unknown)",
+              changedTopLevelPaths: [],
+              changedFiles: [],
+              touchedSubmodulePaths: [],
+              touchesSubmodule: false,
+              aheadCount: 0,
+              error: !repoRoot ? "source repoRoot not found" : "branch not resolved"
+            });
+            continue;
+          }
+          if (!submodulePathsByRepoRoot.has(repoRoot)) {
+            let subPaths = /* @__PURE__ */ new Set();
+            try {
+              const { stdout } = await execFileAsync4("git", ["config", "--file", ".gitmodules", "--get-regexp", "path"], { cwd: repoRoot, encoding: "utf8" });
+              for (const line of stdout.split("\n")) {
+                const trimmed = line.trim();
+                const spaceIdx = trimmed.indexOf(" ");
+                if (spaceIdx === -1) continue;
+                const value = trimmed.slice(spaceIdx + 1).trim();
+                if (value) subPaths.add(value);
+              }
+            } catch {
+              subPaths = /* @__PURE__ */ new Set();
+            }
+            submodulePathsByRepoRoot.set(repoRoot, subPaths);
+          }
+          const baseRef = await resolveBaseRef(repoRoot);
+          let branchRef = branch;
+          try {
+            const { stdout } = await execFileAsync4("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
+            branchRef = stdout.trim() || branch;
+          } catch {
+          }
+          changeAreas.push(await analyzeMeshRefineNodeChangeArea({
+            nodeId: node.id,
+            workspace: node.workspace,
+            branch,
+            baseRef,
+            branchRef,
+            diffCwd: node.workspace,
+            submodulePaths: submodulePathsByRepoRoot.get(repoRoot)
+          }));
+        }
+        const ordering = orderMeshRefineBatchNodes(changeAreas);
+        const orderedNodes = ordering.order.map((nodeId) => targetNodes.find((n) => n.id === nodeId || n.nodeId === nodeId)).filter((n) => !!n);
+        const dryRun = args?.dryRun !== false && args?.execute !== true;
+        if (dryRun) {
+          return {
+            success: true,
+            batch: true,
+            dryRun: true,
+            nodeCount: orderedNodes.length,
+            order: ordering.order,
+            orderingRationale: ordering.rationale,
+            changeAreas: ordering.changeAreas,
+            plan: orderedNodes.map((node) => ({
+              nodeId: node.id,
+              workspace: node.workspace,
+              validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+              mergeWillRun: false
+            })),
+            note: "Dry-run: no validation, rebase, or merge was executed. Re-run with execute=true to converge nodes in this order."
+          };
+        }
+        const results = [];
+        for (const node of orderedNodes) {
+          let result;
+          try {
+            result = await this.executeMeshRefineNodeSynchronously(meshId, node.id, args);
+          } catch (e) {
+            result = { success: false, error: e?.message || String(e) };
+          }
+          const code = typeof result.code === "string" ? result.code : "";
+          let convergence;
+          if (code === "already_merged" && result.alreadyMergedViaOtherPath) {
+            convergence = "skipped_patch_equivalent";
+          } else if (result.success === true) {
+            convergence = "merged_to_main";
+          } else if (code === "merge_failed") {
+            convergence = "not_mergeable";
+          } else {
+            convergence = "blocked_review";
+          }
+          const fbcs = result.finalBranchConvergenceState && typeof result.finalBranchConvergenceState === "object" ? result.finalBranchConvergenceState : void 0;
+          const stage = Array.isArray(result.refineStages) ? result.refineStages.filter((s) => s.status === "failed").map((s) => s.stage).filter(Boolean).pop() : void 0;
+          results.push({
+            nodeId: node.id,
+            workspace: node.workspace,
+            convergence,
+            ...code ? { code } : {},
+            ...typeof result.blockedReason === "string" ? { reason: result.blockedReason } : {},
+            ...stage ? { stage } : {},
+            ...typeof result.error === "string" ? { error: result.error } : {},
+            ...fbcs ? { finalBranchConvergenceState: fbcs } : {}
+          });
+        }
+        const summary = {
+          merged: results.filter((r) => r.convergence === "merged_to_main").length,
+          skipped: results.filter((r) => r.convergence === "skipped_patch_equivalent").length,
+          blocked: results.filter((r) => r.convergence === "blocked_review").length,
+          notMergeable: results.filter((r) => r.convergence === "not_mergeable").length
+        };
+        const allConverged = summary.blocked === 0 && summary.notMergeable === 0;
+        return {
+          success: true,
+          batch: true,
+          dryRun: false,
+          nodeCount: orderedNodes.length,
+          order: ordering.order,
+          orderingRationale: ordering.rationale,
+          summary,
+          allConverged,
+          results,
+          ...allConverged ? {} : {
+            nextStep: "Resolve blocked_review / not_mergeable nodes manually (see per-node code/stage/error), then re-run mesh_refine_batch for the remaining nodes."
+          }
+        };
+      }
       async finishMeshRefineJob(handle, args) {
         const key = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
         let result;
@@ -73732,6 +74138,12 @@ ${tail}` : ""
             if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
             return this.startMeshRefineJob(meshId, nodeId, args);
           }
+          case "batch_refine_mesh_nodes": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            const requestedNodeIds = Array.isArray(args?.nodeIds) ? args.nodeIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
+            return this.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+          }
           case "remove_mesh_node": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";