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

package/dist/index.js

@@ -2662,6 +2662,7 @@ __export(mesh_work_queue_exports, {
   nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
   normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
   normalizeMeshTaskMode: () => normalizeMeshTaskMode,
+  recordDirectDispatchTask: () => recordDirectDispatchTask,
   recordMeshToolCall: () => recordMeshToolCall,
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
@@ -2826,6 +2827,37 @@ function enqueueTask(meshId, message, opts) {
     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);
 }
@@ -4407,9 +4439,48 @@ function buildMeshAsyncRefineJobs(args) {
     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, STALE_TERMINAL_REFINE_WINDOW_MS, RECENT_TERMINAL_REFINE_CAP;
 var init_mesh_refine_status = __esm({
   "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;
   }
 });
 
@@ -10407,6 +10478,26 @@ var init_cli_state_engine = __esm({
       // ── 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
@@ -10512,6 +10603,7 @@ var init_cli_state_engine = __esm({
             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();
@@ -10525,12 +10617,14 @@ var init_cli_state_engine = __esm({
         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);
@@ -10887,7 +10981,7 @@ var init_cli_state_engine = __esm({
           this.callbacks.onStatusChange();
           return;
         }
-        if (!inCooldown) {
+        if (!inCooldown || modal) {
           if (!modal) {
             LOG.warn("CLI", `[${this.provider.type}] detectStatus=waiting_approval but parseApproval returned null; ignoring`);
             if (this.currentStatus === "waiting_approval" && this.activeModal) {
@@ -10910,6 +11004,7 @@ var init_cli_state_engine = __esm({
           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);
@@ -12105,6 +12200,7 @@ ${lastSnapshot}`;
           messages: [],
           workingDir: this.workingDir,
           activeModal: effectiveModal,
+          approvalEntrySeq: this.engine.approvalEntrySeq,
           pendingOutboundCount: this.pendingOutboundQueue.length,
           pendingOutboundMessages: this.pendingOutboundQueue.map((message) => ({
             id: message.id,
@@ -13998,7 +14094,9 @@ __export(index_exports, {
   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_MS,
   SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
   TerminalAdapter: () => TerminalAdapter,
@@ -14206,6 +14304,7 @@ __export(index_exports, {
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict: () => recordCompletionConflict,
   recordDebugTrace: () => recordDebugTrace,
+  recordDirectDispatchTask: () => recordDirectDispatchTask,
   recordMeshToolCall: () => recordMeshToolCall,
   registerExtensionProviders: () => registerExtensionProviders,
   registerMeshCoordinator: () => registerMeshCoordinator,
@@ -14242,6 +14341,7 @@ __export(index_exports, {
   startLocalIpcServer: () => startLocalIpcServer,
   suggestMeshRefineConfig: () => suggestMeshRefineConfig,
   summarizeGitStatus: () => summarizeGitStatus,
+  summarizeMeshAsyncRefineJobs: () => summarizeMeshAsyncRefineJobs,
   summarizeMeshMission: () => summarizeMeshMission,
   summarizeMissionTasks: () => summarizeMissionTasks,
   triggerMeshQueue: () => triggerMeshQueue,
@@ -16506,7 +16606,7 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
   if (!validation.valid) {
     return { status: "failed", required, 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,
@@ -16532,7 +16632,7 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     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,
@@ -31646,7 +31746,9 @@ var CliProviderInstance = class {
     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
@@ -37318,8 +37420,8 @@ var ProviderLoader = class _ProviderLoader {
     }
     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;
@@ -38599,14 +38701,101 @@ init_mesh_routing();
 init_mesh_host_ownership();
 init_mesh_fast_forward();
 
-// src/mesh/preview-freshness.ts
+// src/mesh/mesh-refine-batch.ts
 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 file of files) {
+      const top = topLevel(file);
+      topSet.add(top);
+      if (submodulePaths.has(file) || submodulePaths.has(top)) {
+        submoduleSet.add(submodulePaths.has(file) ? file : 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 };
+}
+
+// src/mesh/preview-freshness.ts
+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"],
@@ -39374,7 +39563,7 @@ init_repo_mesh_types();
 var import_os3 = require("os");
 var import_path10 = require("path");
 var fs23 = __toESM(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",
@@ -40532,7 +40721,7 @@ function buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHe
 }
 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
@@ -40556,7 +40745,7 @@ function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
 }
 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
@@ -40590,10 +40779,10 @@ async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, cur
   }
   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,
@@ -40636,11 +40825,11 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
   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,
@@ -40655,7 +40844,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
     };
     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,
@@ -40840,9 +41029,9 @@ function buildMeshRefineValidationPlan(mesh, workspace) {
   };
 }
 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",
@@ -40936,7 +41125,7 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       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,
@@ -40978,7 +41167,7 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       return summary;
     }
     try {
-      const result = await execFileAsync3(candidate.command, candidate.args, {
+      const result = await execFileAsync4(candidate.command, candidate.args, {
         cwd,
         encoding: "utf8",
         timeout,
@@ -41546,19 +41735,19 @@ var DaemonCommandRouter = class {
       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,
@@ -41577,7 +41766,7 @@ var DaemonCommandRouter = class {
         } 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,
@@ -41621,11 +41810,11 @@ var DaemonCommandRouter = class {
     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,
@@ -42097,30 +42286,30 @@ var DaemonCommandRouter = class {
       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 } : {} });
@@ -42208,7 +42397,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"
           });
@@ -42218,11 +42407,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, {
@@ -42259,7 +42448,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, {
@@ -42466,7 +42655,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),
@@ -42600,7 +42789,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";
@@ -42641,6 +42830,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 cached = repoRootBaseRef.get(repoRoot);
+      if (cached) return cached;
+      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;
@@ -44184,6 +44590,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() : "";
@@ -54140,7 +54552,9 @@ var V1_CONTRACT_VERSION = "1.0.0";
   ProviderCliAdapter,
   ProviderInstanceManager,
   ProviderLoader,
+  RECENT_TERMINAL_REFINE_CAP,
   RawTerminalAttachment,
+  STALE_TERMINAL_REFINE_WINDOW_MS,
   STANDALONE_CDP_SCAN_INTERVAL_MS,
   SessionHostPtyTransportFactory,
   TerminalAdapter,
@@ -54348,6 +54762,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict,
   recordDebugTrace,
+  recordDirectDispatchTask,
   recordMeshToolCall,
   registerExtensionProviders,
   registerMeshCoordinator,
@@ -54384,6 +54799,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   startLocalIpcServer,
   suggestMeshRefineConfig,
   summarizeGitStatus,
+  summarizeMeshAsyncRefineJobs,
   summarizeMeshMission,
   summarizeMissionTasks,
   triggerMeshQueue,