@adhdev/daemon-standalone 0.9.76 → 0.9.77-rc.2

package/dist/index.js

@@ -31227,7 +31227,8 @@ var require_dist2 = __commonJS({
           dirtyWorkspaceBehavior: "warn",
           maxParallelTasks: 2,
           spawnedSessionVisibility: "visible",
-          sessionCleanupOnNodeRemove: "preserve"
+          sessionCleanupOnNodeRemove: "preserve",
+          maxTaskRetries: 1
         };
       }
     });
@@ -31866,12 +31867,13 @@ ${rules.join("\n")}`;
       return `## Rules
 
 - **Minimize coordinator context.** The coordinator's job is routing, not implementing. Do not read source files, run commands, or analyze code directly \u2014 delegate all of that to node agents. Your context should stay lean.
-- **Delegate analysis too.** If you need to understand a bug or explore the codebase, send that investigation as a task to a node. Do not do it yourself.
+- **Delegate analysis too.** If you need to understand a bug or explore the codebase, send that investigation as a task to the queue or a node. Do not do it yourself.
 - **Respect explicit provider requests.** If the user names an agent/provider, pass the matching provider type to \`mesh_launch_session\`: Hermes \u2192 \`hermes-cli\`, Claude Code/Claude \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`. Never substitute \`claude-cli\` just because the coordinator itself is Claude Code.
-- **Front-load the task message.** When calling \`mesh_send_task\`, include everything the agent needs: what files to touch, what the problem is, what the fix should look like. The agent won't ask follow-up questions.
+- **Front-load the task message.** When calling \`mesh_enqueue_task\` or \`mesh_send_task\`, include everything the agent needs: what files to touch, what the problem is, what the fix should look like. The agent won't ask follow-up questions.
 - **Don't inspect code.** Treat delegated agent summaries as self-reports, not verification. Verify side effects via \`mesh_git_status\` (including related repo freshness when configured), not by reading source files.
 - **Don't over-parallelize.** Start with 1-2 concurrent tasks. Scale up if they succeed. Never launch a duplicate session or second worker solely because \`mesh_read_chat\` has no final assistant message while the delegated session is still showing tool/terminal activity.
-- **Handle failures gracefully.** If a task fails, read the chat to understand why, then retry or reassign.
+- **Handle failures with context.** If a task fails, check \`mesh_task_history\` first to see if this task was attempted before and how it failed. Read the chat to understand why, then decide: retry on the same node, reassign to a different node, or escalate to the user.
+- **Check history before starting.** At the beginning of a coordination session, call \`mesh_task_history\` to understand what was previously delegated and its outcomes. This prevents duplicate work and informs recovery decisions.
 - **Keep the user informed.** Report progress after each delegation round \u2014 one or two sentences, not a narration.
 - **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.
@@ -31894,6 +31896,7 @@ ${rules.join("\n")}`;
 | \`mesh_launch_session\` | Start a new agent session on a node |
 | \`mesh_send_task\` | Send a task (natural language) to a running agent |
 | \`mesh_read_chat\` | Read an agent's recent messages to check progress |
+| \`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_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
@@ -31904,18 +31907,371 @@ ${rules.join("\n")}`;
 Before doing any coordinator work, confirm that the actual callable tool list includes \`mesh_status\` and the other \`mesh_*\` tools from the table above. If this Repo Mesh coordinator prompt is present but the callable \`mesh_*\` tools are missing, the MCP server/tool manifest is stale or not injected yet. Do not substitute terminal/file/git tools, do not inspect or edit the repository directly, and do not continue as a non-mesh local coding agent. Stop immediately and tell the user to run \`/reload-mcp\` or start a fresh coordinator session so ADHDev can reconnect \`adhdev-mesh\`.`;
         WORKFLOW_SECTION = `## Orchestration Workflow
 
-1. **Assess** \u2014 Call \`mesh_status\` to see which nodes are healthy and available.
-2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist.
-3. **Delegate** \u2014 For each task:
-   a. Pick the best node (consider: health, dirty state, current workload).
-   b. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
-   c. If no session exists, call \`mesh_launch_session\` to start one.
-   d. Call \`mesh_send_task\` with a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
-4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly just because the delegated session has not produced a final assistant message yet; tool/terminal activity means work may still be in progress. Do not call \`mesh_read_chat\` again within a few seconds for the same generating session; wait for the completion callback/status event instead unless you are debugging a real stall. Use at most one compact \`mesh_read_chat\` check after a completion/approval signal, an explicit user status request, or a real timeout/stall. Handle approvals via \`mesh_approve\`.
+1. **Assess** \u2014 Call \`mesh_status\` to see which nodes are healthy and available. Check \`mesh_task_history\` to understand what has already been done in this mesh \u2014 previous delegations, completions, and failures.
+2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign.
+3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:
+   a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
+   b. **Node Preparation**: Call \`mesh_launch_session\` to ensure enough agent sessions are active to handle the queue. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
+   c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
+   d. Always provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
+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. **Clean up** \u2014 Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
-8. **Report** \u2014 Summarize what was done, what changed, and any issues.`;
+8. **Report** \u2014 Summarize what was done, what changed, and any issues.
+
+## Failure Recovery
+
+When a node agent stops unexpectedly, the daemon automatically enriches the system message with **Recovery Context** that includes:
+- The number of consecutive failures on that node
+- The original task message (if recorded in the ledger)
+- A recommendation: **retry**, **reassign**, or **escalate**
+
+Follow these recovery rules:
+1. **If "Retry recommended"**: Re-launch the session on the same node (\`mesh_launch_session\`), then resend the original task (\`mesh_send_task\`). The system message includes the original task text.
+2. **If "Max retries exceeded"**: Do NOT retry on the same node. Either reassign the task to a different node, or inform the user that the task requires manual intervention.
+3. **If no recovery context**: The stop may be intentional (normal completion). Use \`mesh_read_chat\` once to verify, then move on.
+4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.`;
+      }
+    });
+    var mesh_ledger_exports = {};
+    __export2(mesh_ledger_exports, {
+      appendLedgerEntry: () => appendLedgerEntry,
+      appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
+      getLedgerDir: () => getLedgerDir,
+      getLedgerSummary: () => getLedgerSummary,
+      getSessionRecoveryContext: () => getSessionRecoveryContext,
+      meshLedgerEvents: () => meshLedgerEvents,
+      readLedgerEntries: () => readLedgerEntries
+    });
+    function getLedgerDir() {
+      const dir = (0, import_path3.join)(getConfigDir(), LEDGER_DIR_NAME);
+      if (!(0, import_fs3.existsSync)(dir)) {
+        (0, import_fs3.mkdirSync)(dir, { recursive: true, mode: 448 });
+      }
+      return dir;
+    }
+    function getLedgerPath(meshId) {
+      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+      return (0, import_path3.join)(getLedgerDir(), `${safe}.jsonl`);
+    }
+    function getRotatedPath(meshId, index) {
+      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+      return (0, import_path3.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
+    }
+    function appendLedgerEntry(meshId, partial2) {
+      const entry = {
+        id: (0, import_crypto4.randomUUID)(),
+        meshId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...partial2
+      };
+      const filePath = getLedgerPath(meshId);
+      if ((0, import_fs3.existsSync)(filePath)) {
+        try {
+          const stat2 = (0, import_fs3.statSync)(filePath);
+          if (stat2.size >= MAX_FILE_SIZE_BYTES) {
+            rotateLedgerFile(meshId, filePath);
+          }
+        } catch {
+        }
+      }
+      try {
+        const line = JSON.stringify(entry) + "\n";
+        (0, import_fs3.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
+        meshLedgerEvents.emit("append", meshId, entry);
+        return entry;
+      } catch (e) {
+        throw new Error(`Failed to append to ledger for mesh ${meshId}: ${e.message}`);
+      }
+    }
+    function appendRemoteLedgerEntries(meshId, entries) {
+      if (entries.length === 0) return;
+      const ledgerPath = getLedgerPath(meshId);
+      const existing = new Set(readLedgerEntries(meshId).map((e) => e.id));
+      const newEntries = entries.filter((e) => !existing.has(e.id));
+      if (newEntries.length === 0) return;
+      try {
+        const lines = newEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+        (0, import_fs3.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+      } catch (e) {
+        throw new Error(`Failed to append remote ledger entries for mesh ${meshId}: ${e.message}`);
+      }
+    }
+    function readLedgerEntries(meshId, opts) {
+      const filePath = getLedgerPath(meshId);
+      if (!(0, import_fs3.existsSync)(filePath)) return [];
+      let content;
+      try {
+        content = (0, import_fs3.readFileSync)(filePath, "utf-8");
+      } catch {
+        return [];
+      }
+      const lines = content.split("\n").filter((line) => line.trim());
+      let entries = [];
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (!entry.id || !entry.kind) continue;
+          entries.push(entry);
+        } catch {
+        }
+      }
+      if (opts?.since) {
+        const sinceDate = new Date(opts.since).getTime();
+        if (!isNaN(sinceDate)) {
+          entries = entries.filter((e) => new Date(e.timestamp).getTime() >= sinceDate);
+        }
+      }
+      if (opts?.kind?.length) {
+        const kindSet = new Set(opts.kind);
+        entries = entries.filter((e) => kindSet.has(e.kind));
+      }
+      if (opts?.tail && opts.tail > 0 && entries.length > opts.tail) {
+        entries = entries.slice(-opts.tail);
+      }
+      return entries;
+    }
+    function getLedgerSummary(meshId) {
+      const entries = readLedgerEntries(meshId);
+      const now = Date.now();
+      const recentFailureCutoff = now - RECENT_FAILURE_WINDOW_MS;
+      const summary = {
+        meshId,
+        totalEntries: entries.length,
+        taskDispatched: 0,
+        taskCompleted: 0,
+        taskFailed: 0,
+        taskStalled: 0,
+        sessionLaunched: 0,
+        checkpointCreated: 0,
+        lastActivityAt: null,
+        recentFailures: 0
+      };
+      for (const entry of entries) {
+        switch (entry.kind) {
+          case "task_dispatched":
+            summary.taskDispatched++;
+            break;
+          case "task_completed":
+            summary.taskCompleted++;
+            break;
+          case "task_failed": {
+            summary.taskFailed++;
+            if (new Date(entry.timestamp).getTime() >= recentFailureCutoff) {
+              summary.recentFailures++;
+            }
+            break;
+          }
+          case "task_stalled":
+            summary.taskStalled++;
+            break;
+          case "session_launched":
+            summary.sessionLaunched++;
+            break;
+          case "checkpoint_created":
+            summary.checkpointCreated++;
+            break;
+        }
+      }
+      if (entries.length > 0) {
+        summary.lastActivityAt = entries[entries.length - 1].timestamp;
+      }
+      return summary;
+    }
+    function getSessionRecoveryContext(meshId, opts) {
+      const maxRetries = opts.maxRetries ?? 1;
+      const entries = readLedgerEntries(meshId);
+      let lastDispatch = null;
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const e = entries[i];
+        if (e.kind !== "task_dispatched") continue;
+        if (opts.sessionId && e.sessionId === opts.sessionId) {
+          lastDispatch = e;
+          break;
+        }
+        if (opts.nodeId && e.nodeId === opts.nodeId) {
+          lastDispatch = e;
+          break;
+        }
+      }
+      const lastTaskMessage = typeof lastDispatch?.payload?.message === "string" ? lastDispatch.payload.message : null;
+      const now = Date.now();
+      const recentWindow = now - RECENT_FAILURE_WINDOW_MS;
+      let consecutiveNodeFailures = 0;
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const e = entries[i];
+        if (new Date(e.timestamp).getTime() < recentWindow) break;
+        if (opts.nodeId && e.nodeId !== opts.nodeId) continue;
+        if (e.kind === "task_failed") {
+          consecutiveNodeFailures++;
+        } else if (e.kind === "task_completed" || e.kind === "task_dispatched") {
+          break;
+        }
+      }
+      let taskAttemptCount = 0;
+      if (lastTaskMessage) {
+        const prefix = lastTaskMessage.slice(0, 200);
+        for (const e of entries) {
+          if (e.kind === "task_dispatched" && typeof e.payload?.message === "string") {
+            if (e.payload.message.startsWith(prefix)) {
+              taskAttemptCount++;
+            }
+          }
+        }
+      }
+      const retryRecommended = consecutiveNodeFailures <= maxRetries;
+      let advice;
+      if (consecutiveNodeFailures === 0) {
+        advice = "No recent failures detected. This may be a normal stop.";
+      } else if (retryRecommended) {
+        const remaining = maxRetries - consecutiveNodeFailures + 1;
+        advice = `Retry recommended (${consecutiveNodeFailures}/${maxRetries + 1} attempts used, ${remaining} remaining). ` + (lastTaskMessage ? `Re-launch the session and resend the original task.` : `Re-launch the session. Original task message not found in ledger.`);
+      } else {
+        advice = `Max retries exceeded (${consecutiveNodeFailures} consecutive failures). Consider: (1) reassigning to a different node, (2) simplifying the task, or (3) escalating to the user.`;
+      }
+      return {
+        lastTaskMessage,
+        failedNodeId: opts.nodeId || null,
+        failedSessionId: opts.sessionId || null,
+        failedProviderType: null,
+        // filled by caller if available
+        consecutiveNodeFailures,
+        taskAttemptCount,
+        retryRecommended,
+        advice
+      };
+    }
+    function rotateLedgerFile(meshId, currentPath) {
+      let index = 1;
+      while ((0, import_fs3.existsSync)(getRotatedPath(meshId, index))) {
+        index++;
+        if (index > 10) break;
+      }
+      if (index > 10) index = 10;
+      try {
+        (0, import_fs3.renameSync)(currentPath, getRotatedPath(meshId, index));
+      } catch {
+      }
+    }
+    var import_fs3;
+    var import_path3;
+    var import_crypto4;
+    var import_events;
+    var LEDGER_DIR_NAME;
+    var MAX_FILE_SIZE_BYTES;
+    var RECENT_FAILURE_WINDOW_MS;
+    var meshLedgerEvents;
+    var init_mesh_ledger = __esm2({
+      "src/mesh/mesh-ledger.ts"() {
+        "use strict";
+        import_fs3 = require("fs");
+        import_path3 = require("path");
+        import_crypto4 = require("crypto");
+        init_config();
+        import_events = require("events");
+        LEDGER_DIR_NAME = "mesh-ledger";
+        MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+        RECENT_FAILURE_WINDOW_MS = 30 * 60 * 1e3;
+        meshLedgerEvents = new import_events.EventEmitter();
+      }
+    });
+    function getQueuePath(meshId) {
+      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+      return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.json`);
+    }
+    function readQueue(meshId) {
+      const path28 = getQueuePath(meshId);
+      if (!(0, import_fs4.existsSync)(path28)) return [];
+      try {
+        const content = (0, import_fs4.readFileSync)(path28, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return [];
+      }
+    }
+    function writeQueue(meshId, queue) {
+      const path28 = getQueuePath(meshId);
+      (0, import_fs4.writeFileSync)(path28, JSON.stringify(queue, null, 2), "utf-8");
+    }
+    function enqueueTask(meshId, message, opts) {
+      const queue = readQueue(meshId);
+      const entry = {
+        id: (0, import_crypto5.randomUUID)(),
+        meshId,
+        message,
+        status: "pending",
+        targetNodeId: opts?.targetNodeId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      queue.push(entry);
+      writeQueue(meshId, queue);
+      return entry;
+    }
+    function getQueue(meshId, opts) {
+      let queue = readQueue(meshId);
+      if (opts?.status?.length) {
+        const statuses = new Set(opts.status);
+        queue = queue.filter((q2) => statuses.has(q2.status));
+      }
+      return queue;
+    }
+    function claimNextTask(meshId, nodeId, sessionId) {
+      const queue = readQueue(meshId);
+      let targetIdx = queue.findIndex((q2) => q2.status === "pending" && q2.targetNodeId === nodeId);
+      if (targetIdx === -1) {
+        targetIdx = queue.findIndex((q2) => q2.status === "pending" && !q2.targetNodeId);
+      }
+      if (targetIdx === -1) return null;
+      const entry = queue[targetIdx];
+      entry.status = "assigned";
+      entry.assignedNodeId = nodeId;
+      entry.assignedSessionId = sessionId;
+      entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      writeQueue(meshId, queue);
+      return entry;
+    }
+    function updateTaskStatus(meshId, taskId, status) {
+      const queue = readQueue(meshId);
+      const idx = queue.findIndex((q2) => q2.id === taskId);
+      if (idx === -1) return null;
+      queue[idx].status = status;
+      queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      writeQueue(meshId, queue);
+      return queue[idx];
+    }
+    function updateSessionTaskStatus(meshId, sessionId, status) {
+      const queue = readQueue(meshId);
+      for (let i = queue.length - 1; i >= 0; i--) {
+        if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
+          queue[i].status = status;
+          queue[i].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          writeQueue(meshId, queue);
+          return queue[i];
+        }
+      }
+      return null;
+    }
+    function getMeshQueueStats(meshId) {
+      const queue = readQueue(meshId);
+      return {
+        pending: queue.filter((q2) => q2.status === "pending").length,
+        assigned: queue.filter((q2) => q2.status === "assigned").length,
+        completed: queue.filter((q2) => q2.status === "completed").length,
+        failed: queue.filter((q2) => q2.status === "failed").length
+      };
+    }
+    var import_fs4;
+    var import_path4;
+    var import_crypto5;
+    var init_mesh_work_queue = __esm2({
+      "src/mesh/mesh-work-queue.ts"() {
+        "use strict";
+        import_fs4 = require("fs");
+        import_path4 = require("path");
+        import_crypto5 = require("crypto");
+        init_mesh_ledger();
       }
     });
     function setLogLevel(level) {
@@ -31932,13 +32288,13 @@ Before doing any coordinator work, confirm that the actual callable tool list in
       return LOG_DIR;
     }
     function getCurrentDaemonLogPath(date5 = /* @__PURE__ */ new Date()) {
-      return path10.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
+      return path8.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
     }
     function checkDateRotation() {
       const today = getDateStr();
       if (today !== currentDate) {
         currentDate = today;
-        currentLogFile = path10.join(LOG_DIR, `daemon-${currentDate}.log`);
+        currentLogFile = path8.join(LOG_DIR, `daemon-${currentDate}.log`);
         cleanOldLogs();
       }
     }
@@ -31952,7 +32308,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
           const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs22.unlinkSync(path10.join(LOG_DIR, file2));
+              fs22.unlinkSync(path8.join(LOG_DIR, file2));
             } catch {
             }
           }
@@ -32069,8 +32425,8 @@ Before doing any coordinator work, confirm that the actual callable tool list in
       writeToFile(`Log level: ${currentLevel}`);
     }
     var fs22;
-    var path10;
-    var os42;
+    var path8;
+    var os22;
     var LEVEL_NUM;
     var LEVEL_LABEL;
     var currentLevel;
@@ -32092,12 +32448,12 @@ Before doing any coordinator work, confirm that the actual callable tool list in
       "src/logging/logger.ts"() {
         "use strict";
         fs22 = __toESM2(require("fs"));
-        path10 = __toESM2(require("path"));
-        os42 = __toESM2(require("os"));
+        path8 = __toESM2(require("path"));
+        os22 = __toESM2(require("os"));
         LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
         LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
         currentLevel = "info";
-        LOG_DIR = process.platform === "win32" ? path10.join(process.env.LOCALAPPDATA || process.env.APPDATA || path10.join(os42.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path10.join(os42.homedir(), "Library", "Logs", "adhdev") : path10.join(os42.homedir(), ".local", "share", "adhdev", "logs");
+        LOG_DIR = process.platform === "win32" ? path8.join(process.env.LOCALAPPDATA || process.env.APPDATA || path8.join(os22.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path8.join(os22.homedir(), "Library", "Logs", "adhdev") : path8.join(os22.homedir(), ".local", "share", "adhdev", "logs");
         MAX_LOG_SIZE = 5 * 1024 * 1024;
         MAX_LOG_DAYS = 7;
         try {
@@ -32105,16 +32461,16 @@ Before doing any coordinator work, confirm that the actual callable tool list in
         } catch {
         }
         currentDate = getDateStr();
-        currentLogFile = path10.join(LOG_DIR, `daemon-${currentDate}.log`);
+        currentLogFile = path8.join(LOG_DIR, `daemon-${currentDate}.log`);
         cleanOldLogs();
         try {
-          const oldLog = path10.join(LOG_DIR, "daemon.log");
+          const oldLog = path8.join(LOG_DIR, "daemon.log");
           if (fs22.existsSync(oldLog)) {
             const stat2 = fs22.statSync(oldLog);
             const oldDate = stat2.mtime.toISOString().slice(0, 10);
-            fs22.renameSync(oldLog, path10.join(LOG_DIR, `daemon-${oldDate}.log`));
+            fs22.renameSync(oldLog, path8.join(LOG_DIR, `daemon-${oldDate}.log`));
           }
-          const oldLogBackup = path10.join(LOG_DIR, "daemon.log.old");
+          const oldLogBackup = path8.join(LOG_DIR, "daemon.log.old");
           if (fs22.existsSync(oldLogBackup)) {
             fs22.unlinkSync(oldLogBackup);
           }
@@ -32146,7 +32502,314 @@ Before doing any coordinator work, confirm that the actual callable tool list in
           }
         };
         interceptorInstalled = false;
-        LOG_PATH = path10.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+        LOG_PATH = path8.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+      }
+    });
+    var mesh_events_exports = {};
+    __export2(mesh_events_exports, {
+      drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
+      handleMeshForwardEvent: () => handleMeshForwardEvent,
+      setupMeshEventForwarding: () => setupMeshEventForwarding,
+      triggerMeshQueue: () => triggerMeshQueue,
+      tryAssignQueueTask: () => tryAssignQueueTask
+    });
+    function drainPendingMeshCoordinatorEvents() {
+      return pendingMeshCoordinatorEvents.splice(0);
+    }
+    function readNonEmptyString(value) {
+      return typeof value === "string" && value.trim() ? value.trim() : "";
+    }
+    function isMeshCoordinatorEvent(eventName) {
+      return typeof eventName === "string" && MESH_COORDINATOR_EVENTS.has(eventName);
+    }
+    function formatCompletionMetadata(event) {
+      const parts = [
+        readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : "",
+        readNonEmptyString(event.providerType) ? `provider=${readNonEmptyString(event.providerType)}` : "",
+        readNonEmptyString(event.providerSessionId) ? `provider_session_id=${readNonEmptyString(event.providerSessionId)}` : ""
+      ].filter(Boolean);
+      return parts.length > 0 ? ` (${parts.join("; ")})` : "";
+    }
+    function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
+      const task = claimNextTask(meshId, nodeId, sessionId);
+      if (!task) return false;
+      LOG2.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+      components.cliManager.handleCliCommand("agent_command", {
+        targetSessionId: sessionId,
+        cliType: providerType,
+        action: "send_chat",
+        input: task.message
+      }).catch((e) => {
+        LOG2.error("MeshQueue", `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
+      });
+      return true;
+    }
+    function triggerMeshQueue(components, meshId) {
+      const mesh = getMesh(meshId);
+      if (!mesh) return;
+      const cliInstances = components.instanceManager.getByCategory("cli");
+      for (const inst of cliInstances) {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        const instMeshId = readNonEmptyString(settings.meshNodeFor);
+        if (instMeshId !== meshId && !settings.launchedByCoordinator) continue;
+        const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!nodeId) continue;
+        if (state.status !== "idle" && state.status !== "stopped" && state.activeChat?.status !== "waiting_input") continue;
+        const sessionId = state.instanceId;
+        const providerType = state.type || readNonEmptyString(settings.providerType);
+        if (providerType) {
+          tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
+        }
+      }
+    }
+    function buildMeshSystemMessage(args) {
+      const metadata = formatCompletionMetadata(args.metadataEvent);
+      if (args.event === "agent:generating_completed") {
+        return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path; use mesh_read_chat once to review its final progress, but do not poll repeatedly.`;
+      }
+      if (args.event === "agent:waiting_approval") {
+        return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
+      }
+      if (args.event === "agent:stopped") {
+        const rc = args.recoveryContext;
+        if (rc && rc.consecutiveNodeFailures > 0) {
+          const parts = [
+            `[System] ${args.nodeLabel} has stopped unexpectedly${metadata}.`,
+            `
+
+**Recovery Context:**`,
+            `- Consecutive failures on this node: ${rc.consecutiveNodeFailures}`,
+            rc.taskAttemptCount > 0 ? `- This task has been attempted ${rc.taskAttemptCount} time(s)` : "",
+            `- Recommendation: ${rc.advice}`
+          ];
+          if (rc.retryRecommended && rc.lastTaskMessage) {
+            parts.push(
+              `
+
+**Original task to retry:**`,
+              `> ${rc.lastTaskMessage.length > 300 ? rc.lastTaskMessage.slice(0, 300) + "..." : rc.lastTaskMessage}`,
+              `
+To retry: call \`mesh_launch_session\` for this node, then \`mesh_send_task\` with the original task.`
+            );
+          } else if (!rc.retryRecommended) {
+            parts.push(
+              `
+Do NOT retry on this node. Consider reassigning to a different node or asking the user for guidance.`
+            );
+          }
+          return parts.filter(Boolean).join("\n");
+        }
+        return `[System] ${args.nodeLabel} has stopped${metadata}. Use mesh_read_chat once if you need to inspect its last output.`;
+      }
+      if (args.event === "monitor:long_generating") {
+        return `[System] ${args.nodeLabel} has been generating for a long time${metadata}. Use mesh_read_chat once for a status check, but do not poll repeatedly.`;
+      }
+      return "";
+    }
+    function injectMeshSystemMessage(components, args) {
+      if (args.event === "agent:generating_completed") {
+        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const nodeId = readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const providerType = readNonEmptyString(args.metadataEvent.providerType);
+        if (sessionId) {
+          updateSessionTaskStatus(args.meshId, sessionId, "completed");
+          if (nodeId && providerType) {
+            setTimeout(() => {
+              tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
+            }, 500);
+          }
+        }
+      } else if (args.event === "agent:stopped") {
+        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        if (sessionId) {
+          updateSessionTaskStatus(args.meshId, sessionId, "failed");
+        }
+      }
+      const ledgerKind = EVENT_TO_LEDGER_KIND[args.event];
+      if (ledgerKind) {
+        try {
+          appendLedgerEntry(args.meshId, {
+            kind: ledgerKind,
+            nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
+            sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || void 0,
+            providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
+            payload: {
+              event: args.event,
+              nodeLabel: args.nodeLabel,
+              providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0
+            }
+          });
+        } catch (e) {
+          LOG2.warn("MeshLedger", `Failed to record ${ledgerKind}: ${e?.message || e}`);
+        }
+      }
+      let recoveryContext = null;
+      if (args.event === "agent:stopped") {
+        try {
+          const mesh = getMesh(args.meshId);
+          const maxRetries = mesh?.policy?.maxTaskRetries ?? 1;
+          recoveryContext = getSessionRecoveryContext(args.meshId, {
+            sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || void 0,
+            nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
+            maxRetries
+          });
+          recoveryContext.failedProviderType = readNonEmptyString(args.metadataEvent.providerType) || null;
+          if (recoveryContext.retryRecommended && recoveryContext.consecutiveNodeFailures > 0) {
+            appendLedgerEntry(args.meshId, {
+              kind: "recovery_attempted",
+              nodeId: recoveryContext.failedNodeId || void 0,
+              sessionId: recoveryContext.failedSessionId || void 0,
+              providerType: recoveryContext.failedProviderType || void 0,
+              payload: {
+                consecutiveFailures: recoveryContext.consecutiveNodeFailures,
+                taskAttemptCount: recoveryContext.taskAttemptCount,
+                retryRecommended: recoveryContext.retryRecommended,
+                advice: recoveryContext.advice
+              }
+            });
+            if (recoveryContext.lastTaskMessage && recoveryContext.failedNodeId && recoveryContext.failedProviderType) {
+              const autoNodeId = recoveryContext.failedNodeId;
+              try {
+                const task = enqueueTask(args.meshId, recoveryContext.lastTaskMessage, {
+                  targetNodeId: autoNodeId
+                });
+                LOG2.info("MeshRecovery", `Auto-requeued failed task: ${task.id} for node ${autoNodeId}`);
+                const node = mesh?.nodes.find((n) => n.id === autoNodeId);
+                if (node) {
+                  components.cliManager.handleCliCommand("launch_cli", {
+                    cliType: recoveryContext.failedProviderType,
+                    dir: node.workspace,
+                    settings: {
+                      meshNodeFor: args.meshId,
+                      meshNodeId: node.id,
+                      spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
+                      launchedByCoordinator: true
+                    }
+                  }).catch((e) => LOG2.error("MeshRecovery", `Failed to auto-relaunch session for ${node.id}: ${e?.message}`));
+                }
+              } catch (e) {
+                LOG2.warn("MeshRecovery", `Failed to execute auto-recovery: ${e?.message}`);
+              }
+            }
+          }
+          LOG2.info("MeshRecovery", `Recovery context for ${args.nodeLabel}: ${recoveryContext.advice}`);
+        } catch (e) {
+          LOG2.warn("MeshRecovery", `Failed to build recovery context: ${e?.message || e}`);
+        }
+      }
+      const coordinatorInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
+        const instState = inst.getState();
+        if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
+        if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
+        return true;
+      });
+      if (coordinatorInstances.length === 0) {
+        if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
+          pendingMeshCoordinatorEvents.push({
+            event: args.event,
+            meshId: args.meshId,
+            nodeLabel: args.nodeLabel,
+            metadataEvent: {
+              ...args.metadataEvent,
+              ...recoveryContext ? { recoveryContext } : {}
+            },
+            queuedAt: Date.now()
+          });
+          LOG2.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
+        }
+        return { success: true, forwarded: 0 };
+      }
+      const messageText = buildMeshSystemMessage({
+        event: args.event,
+        nodeLabel: args.nodeLabel,
+        metadataEvent: args.metadataEvent,
+        recoveryContext
+      });
+      if (!messageText) return { success: false, error: "unsupported mesh event" };
+      for (const coord of coordinatorInstances) {
+        const coordState = coord.getState();
+        LOG2.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}`);
+        coord.onEvent("send_message", { input: { text: messageText, textFallback: messageText } });
+      }
+      return { success: true, forwarded: coordinatorInstances.length };
+    }
+    function handleMeshForwardEvent(components, payload) {
+      const eventName = readNonEmptyString(payload.event);
+      if (!isMeshCoordinatorEvent(eventName)) {
+        return { success: false, error: "unsupported mesh event" };
+      }
+      const meshId = readNonEmptyString(payload.meshId);
+      if (!meshId) return { success: false, error: "meshId required" };
+      const nodeId = readNonEmptyString(payload.nodeId);
+      const workspace = readNonEmptyString(payload.workspace);
+      const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : "Remote agent";
+      return injectMeshSystemMessage(components, {
+        meshId,
+        nodeLabel,
+        event: eventName,
+        metadataEvent: {
+          targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId),
+          providerType: readNonEmptyString(payload.providerType),
+          providerSessionId: readNonEmptyString(payload.providerSessionId)
+        }
+      });
+    }
+    function setupMeshEventForwarding(components) {
+      components.instanceManager.onEvent((event) => {
+        if (!isMeshCoordinatorEvent(event.event)) return;
+        const instanceId = readNonEmptyString(event.instanceId);
+        if (!instanceId) return;
+        const sourceInstance = components.instanceManager.getInstance(instanceId);
+        if (!sourceInstance || sourceInstance.category !== "cli") return;
+        const state = sourceInstance.getState();
+        const workspace = readNonEmptyString(state.workspace);
+        if (!workspace) return;
+        const settings = state.settings && typeof state.settings === "object" ? state.settings : {};
+        if (readNonEmptyString(settings.meshCoordinatorFor)) return;
+        const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
+        const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
+        if (!isMeshDelegate) return;
+        const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
+        const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
+        if (!meshId) return;
+        const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
+        const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
+        const nodeLabel = targetNode ? `Node '${targetNode.id}'` : runtimeNodeId ? `Node '${runtimeNodeId}'` : `Agent at ${workspace}`;
+        injectMeshSystemMessage(components, {
+          meshId,
+          sourceInstanceId: instanceId,
+          nodeLabel,
+          event: event.event,
+          metadataEvent: event
+        });
+      });
+    }
+    var MAX_PENDING_EVENTS;
+    var pendingMeshCoordinatorEvents;
+    var MESH_COORDINATOR_EVENTS;
+    var EVENT_TO_LEDGER_KIND;
+    var init_mesh_events = __esm2({
+      "src/mesh/mesh-events.ts"() {
+        "use strict";
+        init_mesh_config();
+        init_logger();
+        init_mesh_ledger();
+        init_mesh_work_queue();
+        MAX_PENDING_EVENTS = 50;
+        pendingMeshCoordinatorEvents = [];
+        MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
+          "agent:generating_completed",
+          "agent:waiting_approval",
+          "agent:stopped",
+          "monitor:long_generating"
+        ]);
+        EVENT_TO_LEDGER_KIND = {
+          "agent:generating_completed": "task_completed",
+          "agent:waiting_approval": "task_approval_needed",
+          "agent:stopped": "task_failed",
+          "monitor:long_generating": "task_stalled"
+        };
       }
     });
     function normalizeCategories(categories) {
@@ -35254,6 +35917,7 @@ ${lastSnapshot}`;
       TurnSnapshotTracker: () => TurnSnapshotTracker,
       VersionArchive: () => VersionArchive,
       addNode: () => addNode,
+      appendLedgerEntry: () => appendLedgerEntry,
       appendRecentActivity: () => appendRecentActivity,
       buildAssistantChatMessage: () => buildAssistantChatMessage,
       buildChatMessage: () => buildChatMessage,
@@ -35271,6 +35935,7 @@ ${lastSnapshot}`;
       buildThoughtChatMessage: () => buildThoughtChatMessage,
       buildToolChatMessage: () => buildToolChatMessage,
       buildUserChatMessage: () => buildUserChatMessage,
+      claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       clearDebugTrace: () => clearDebugTrace,
@@ -35289,6 +35954,7 @@ ${lastSnapshot}`;
       detectAllVersions: () => detectAllVersions,
       detectCLIs: () => detectCLIs,
       detectIDEs: () => detectIDEs,
+      enqueueTask: () => enqueueTask,
       ensureSessionHostReady: () => ensureSessionHostReady2,
       execNpmCommandSync: () => execNpmCommandSync,
       filterActivityChatMessages: () => filterActivityChatMessages,
@@ -35307,10 +35973,13 @@ ${lastSnapshot}`;
       getGitFileDiff: () => getGitFileDiff,
       getGitRepoStatus: () => getGitRepoStatus,
       getHostMemorySnapshot: () => getHostMemorySnapshot,
+      getLedgerDir: () => getLedgerDir,
+      getLedgerSummary: () => getLedgerSummary,
       getLogLevel: () => getLogLevel,
       getMesh: () => getMesh,
       getMeshByRepo: () => getMeshByRepo,
       getNpmExecOptions: () => getNpmExecOptions,
+      getQueue: () => getQueue,
       getRecentActivity: () => getRecentActivity,
       getRecentCommands: () => getRecentCommands,
       getRecentDebugTrace: () => getRecentDebugTrace,
@@ -35318,6 +35987,7 @@ ${lastSnapshot}`;
       getSavedProviderSessions: () => getSavedProviderSessions,
       getSessionHostRecoveryLabel: () => getSessionHostRecoveryLabel,
       getSessionHostSurfaceKind: () => getSessionHostSurfaceKind,
+      getSessionRecoveryContext: () => getSessionRecoveryContext,
       getWorkspaceState: () => getWorkspaceState2,
       handleGitCommand: () => handleGitCommand,
       hasCdpManager: () => hasCdpManager,
@@ -35371,6 +36041,7 @@ ${lastSnapshot}`;
       prepareSessionModalUpdate: () => prepareSessionModalUpdate2,
       probeCdpPort: () => probeCdpPort,
       readChatHistory: () => readChatHistory,
+      readLedgerEntries: () => readLedgerEntries,
       recordDebugTrace: () => recordDebugTrace,
       registerExtensionProviders: () => registerExtensionProviders,
       removeNode: () => removeNode,
@@ -35399,9 +36070,12 @@ ${lastSnapshot}`;
       startDaemonDevSupport: () => startDaemonDevSupport2,
       summarizeGitStatus: () => summarizeGitStatus,
       syncMeshes: () => syncMeshes,
+      triggerMeshQueue: () => triggerMeshQueue,
       updateConfig: () => updateConfig,
       updateMesh: () => updateMesh,
       updateNode: () => updateNode,
+      updateSessionTaskStatus: () => updateSessionTaskStatus,
+      updateTaskStatus: () => updateTaskStatus,
       upsertSavedProviderSession: () => upsertSavedProviderSession
     });
     module2.exports = __toCommonJS2(index_exports);
@@ -37234,10 +37908,31 @@ ${lastSnapshot}`;
           }
         }
       }
+      if (transport.syncMeshLedger) {
+        for (const local of localMeshes) {
+          try {
+            await syncMeshLedger(local.id, transport);
+          } catch (e) {
+            result.errors.push(`Ledger sync failed for "${local.name}": ${e.message}`);
+          }
+        }
+      }
       return result;
     }
-    var import_fs3 = require("fs");
-    var import_path3 = require("path");
+    async function syncMeshLedger(meshId, transport) {
+      if (!transport.syncMeshLedger) return;
+      const { readLedgerEntries: readLedgerEntries2, appendRemoteLedgerEntries: appendRemoteLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+      const localEntries = readLedgerEntries2(meshId);
+      const res = await transport.syncMeshLedger(meshId, { newEntries: localEntries });
+      if (res.missingEntries && res.missingEntries.length > 0) {
+        appendRemoteLedgerEntries2(meshId, res.missingEntries);
+      }
+    }
+    init_mesh_ledger();
+    init_mesh_work_queue();
+    init_mesh_events();
+    var import_fs5 = require("fs");
+    var import_path5 = require("path");
     init_config();
     var DEFAULT_STATE = {
       recentActivity: [],
@@ -37251,7 +37946,7 @@ ${lastSnapshot}`;
       return !!value && typeof value === "object" && !Array.isArray(value);
     }
     function getStatePath() {
-      return (0, import_path3.join)(getConfigDir(), "state.json");
+      return (0, import_path5.join)(getConfigDir(), "state.json");
     }
     function normalizeState(raw) {
       const parsed = isPlainObject22(raw) ? raw : {};
@@ -37287,11 +37982,11 @@ ${lastSnapshot}`;
     }
     function loadState() {
       const statePath = getStatePath();
-      if (!(0, import_fs3.existsSync)(statePath)) {
+      if (!(0, import_fs5.existsSync)(statePath)) {
         return { ...DEFAULT_STATE };
       }
       try {
-        const raw = (0, import_fs3.readFileSync)(statePath, "utf-8");
+        const raw = (0, import_fs5.readFileSync)(statePath, "utf-8");
         return normalizeState(JSON.parse(raw));
       } catch {
         return { ...DEFAULT_STATE };
@@ -37300,15 +37995,15 @@ ${lastSnapshot}`;
     function saveState(state) {
       const statePath = getStatePath();
       const normalized = normalizeState(state);
-      (0, import_fs3.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs5.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
     }
     function resetState() {
       saveState({ ...DEFAULT_STATE });
     }
     var import_child_process = require("child_process");
-    var import_fs4 = require("fs");
+    var import_fs6 = require("fs");
     var import_os22 = require("os");
-    var path8 = __toESM2(require("path"));
+    var path9 = __toESM2(require("path"));
     var BUILTIN_IDE_DEFINITIONS = [];
     var registeredIDEs = /* @__PURE__ */ new Map();
     function registerIDEDefinition(def) {
@@ -37327,10 +38022,10 @@ ${lastSnapshot}`;
     function findCliCommand(command) {
       const trimmed = String(command || "").trim();
       if (!trimmed) return null;
-      if (path8.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
-        const candidate = trimmed.startsWith("~") ? path8.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
-        const resolved = path8.isAbsolute(candidate) ? candidate : path8.resolve(candidate);
-        return (0, import_fs4.existsSync)(resolved) ? resolved : null;
+      if (path9.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+        const candidate = trimmed.startsWith("~") ? path9.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
+        const resolved = path9.isAbsolute(candidate) ? candidate : path9.resolve(candidate);
+        return (0, import_fs6.existsSync)(resolved) ? resolved : null;
       }
       try {
         const result = (0, import_child_process.execSync)(
@@ -37357,13 +38052,13 @@ ${lastSnapshot}`;
     function checkPathExists(paths) {
       const home = (0, import_os22.homedir)();
       for (const p of paths) {
-        const normalized = p.startsWith("~") ? path8.join(home, p.slice(1)) : p;
+        const normalized = p.startsWith("~") ? path9.join(home, p.slice(1)) : p;
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
-          if ((0, import_fs4.existsSync)(resolved)) return resolved;
+          if ((0, import_fs6.existsSync)(resolved)) return resolved;
         } else {
-          if ((0, import_fs4.existsSync)(normalized)) return normalized;
+          if ((0, import_fs6.existsSync)(normalized)) return normalized;
         }
       }
       return null;
@@ -37377,7 +38072,7 @@ ${lastSnapshot}`;
         let resolvedCli = cliPath;
         if (!resolvedCli && appPath && os222 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-          if ((0, import_fs4.existsSync)(bundledCli)) resolvedCli = bundledCli;
+          if ((0, import_fs6.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os222 === "win32") {
           const { dirname: dirname9 } = await import("path");
@@ -37390,7 +38085,7 @@ ${lastSnapshot}`;
             `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
           ];
           for (const c of candidates) {
-            if ((0, import_fs4.existsSync)(c)) {
+            if ((0, import_fs6.existsSync)(c)) {
               resolvedCli = c;
               break;
             }
@@ -37412,9 +38107,9 @@ ${lastSnapshot}`;
       return results;
     }
     var import_child_process2 = require("child_process");
-    var os22 = __toESM2(require("os"));
-    var path9 = __toESM2(require("path"));
-    var import_fs5 = require("fs");
+    var os32 = __toESM2(require("os"));
+    var path10 = __toESM2(require("path"));
+    var import_fs7 = require("fs");
     function parseVersion(raw) {
       const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
       return match ? match[1] : raw.split("\n")[0].slice(0, 100);
@@ -37426,19 +38121,19 @@ ${lastSnapshot}`;
     function expandHome(value) {
       const trimmed = value.trim();
       if (!trimmed.startsWith("~")) return trimmed;
-      return path9.join(os22.homedir(), trimmed.slice(1));
+      return path10.join(os32.homedir(), trimmed.slice(1));
     }
     function isExplicitCommandPath(command) {
       const trimmed = command.trim();
-      return path9.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+      return path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
     }
     function resolveCommandPath(command) {
       const trimmed = command.trim();
       if (!trimmed) return null;
       if (isExplicitCommandPath(trimmed)) {
         const expanded = expandHome(trimmed);
-        const candidate = path9.isAbsolute(expanded) ? expanded : path9.resolve(expanded);
-        return (0, import_fs5.existsSync)(candidate) ? candidate : null;
+        const candidate = path10.isAbsolute(expanded) ? expanded : path10.resolve(expanded);
+        return (0, import_fs7.existsSync)(candidate) ? candidate : null;
       }
       return null;
     }
@@ -37459,7 +38154,7 @@ ${lastSnapshot}`;
       });
     }
     async function detectCLIs(providerLoader, options) {
-      const platform10 = os22.platform();
+      const platform10 = os32.platform();
       const whichCmd = platform10 === "win32" ? "where" : "which";
       const includeVersion = options?.includeVersion !== false;
       const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
@@ -37503,7 +38198,7 @@ ${lastSnapshot}`;
         const cliList = providerLoader.getCliDetectionList();
         const target = cliList.find((c) => c.id === resolvedId);
         if (target) {
-          const platform10 = os22.platform();
+          const platform10 = os32.platform();
           const whichCmd = platform10 === "win32" ? "where" : "which";
           try {
             const explicitPath = resolveCommandPath(target.command);
@@ -37538,10 +38233,10 @@ ${lastSnapshot}`;
       const all = await detectCLIs(providerLoader, options);
       return all.find((c) => c.id === resolvedId && c.installed) || null;
     }
-    var os32 = __toESM2(require("os"));
+    var os42 = __toESM2(require("os"));
     var import_child_process3 = require("child_process");
     function parseDarwinAvailableBytes(totalMem) {
-      if (os32.platform() !== "darwin") return null;
+      if (os42.platform() !== "darwin") return null;
       try {
         const out = (0, import_child_process3.execSync)("vm_stat", {
           encoding: "utf-8",
@@ -37572,8 +38267,8 @@ ${lastSnapshot}`;
       }
     }
     function getHostMemorySnapshot() {
-      const totalMem = os32.totalmem();
-      const freeMem = os32.freemem();
+      const totalMem = os42.totalmem();
+      const freeMem = os42.freemem();
       const darwinAvail = parseDarwinAvailableBytes(totalMem);
       const availableMem = darwinAvail != null ? darwinAvail : freeMem;
       return { totalMem, freeMem, availableMem };
@@ -42894,6 +43589,7 @@ ${effect.notification.body || ""}`.trim();
       }
       return normalized;
     }
+    init_mesh_work_queue();
     var VALID_INPUT_MEDIA_TYPES = /* @__PURE__ */ new Set(["text", "image", "audio", "video", "resource"]);
     var VALID_INPUT_STRATEGIES = /* @__PURE__ */ new Set(["native", "native_acp", "resource_link", "text_fallback", "paste", "upload"]);
     var TEXT_ONLY_MESSAGE_INPUT_SUPPORT = Object.freeze({
@@ -43116,6 +43812,8 @@ ${effect.notification.body || ""}`.trim();
       const workspace = state.workspace || null;
       const git = getGitSummaryForWorkspace(workspace, options);
       const title = activeChat?.title || state.name;
+      const meshCoordinatorFor = state.settings?.meshCoordinatorFor;
+      const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
       return {
         id: state.instanceId || state.type,
         parentId: null,
@@ -43138,7 +43836,8 @@ ${effect.notification.body || ""}`.trim();
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
-        settings: state.settings
+        settings: state.settings,
+        ...meshQueueStats && { meshQueueStats }
       };
     }
     function buildExtensionAgentSession(parent, ext, options) {
@@ -43150,6 +43849,8 @@ ${effect.notification.body || ""}`.trim();
       const includeSessionControls = shouldIncludeSessionControls(profile);
       const workspace = parent.workspace || null;
       const git = getGitSummaryForWorkspace(workspace, options);
+      const meshCoordinatorFor = ext.settings?.meshCoordinatorFor;
+      const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
       return {
         id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
         parentId: parent.instanceId || parent.type,
@@ -43172,7 +43873,8 @@ ${effect.notification.body || ""}`.trim();
         errorMessage: ext.errorMessage,
         errorReason: ext.errorReason,
         lastUpdated: ext.lastUpdated,
-        settings: ext.settings
+        settings: ext.settings,
+        ...meshQueueStats && { meshQueueStats }
       };
     }
     function shouldIncludeExtensionSession(ext) {
@@ -43200,6 +43902,8 @@ ${effect.notification.body || ""}`.trim();
       const includeSessionControls = shouldIncludeSessionControls(profile);
       const workspace = state.workspace || null;
       const git = getGitSummaryForWorkspace(workspace, options);
+      const meshCoordinatorFor = state.settings?.meshCoordinatorFor;
+      const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
       return {
         id: state.instanceId,
         parentId: null,
@@ -43238,7 +43942,8 @@ ${effect.notification.body || ""}`.trim();
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
-        settings: state.settings
+        settings: state.settings,
+        ...meshQueueStats && { meshQueueStats }
       };
     }
     function buildAcpSession(state, options) {
@@ -43250,6 +43955,8 @@ ${effect.notification.body || ""}`.trim();
       const includeSessionControls = shouldIncludeSessionControls(profile);
       const workspace = state.workspace || null;
       const git = getGitSummaryForWorkspace(workspace, options);
+      const meshCoordinatorFor = state.settings?.meshCoordinatorFor;
+      const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
       return {
         id: state.instanceId,
         parentId: null,
@@ -43271,7 +43978,8 @@ ${effect.notification.body || ""}`.trim();
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
-        settings: state.settings
+        settings: state.settings,
+        ...meshQueueStats && { meshQueueStats }
       };
     }
     function buildSessionEntries(allStates, cdpManagers, options = {}) {
@@ -46542,7 +47250,7 @@ ${effect.notification.body || ""}`.trim();
     var os13 = __toESM2(require("os"));
     var path18 = __toESM2(require("path"));
     var crypto4 = __toESM2(require("crypto"));
-    var import_fs6 = require("fs");
+    var import_fs8 = require("fs");
     var import_child_process6 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_provider_cli_adapter();
@@ -48906,7 +49614,7 @@ ${rawInput}` : rawInput;
       const trimmed = command.trim();
       if (!trimmed) return false;
       if (isExplicitCommand(trimmed)) {
-        return (0, import_fs6.existsSync)(expandExecutable(trimmed));
+        return (0, import_fs8.existsSync)(expandExecutable(trimmed));
       }
       try {
         (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -48935,10 +49643,10 @@ ${rawInput}` : rawInput;
     }
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path18.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-      (0, import_fs6.mkdirSync)(baseDir, { recursive: true });
+      (0, import_fs8.mkdirSync)(baseDir, { recursive: true });
       const workspaceHash = crypto4.createHash("sha256").update(path18.resolve(workspace || os13.tmpdir())).digest("hex").slice(0, 16);
       const filePath = path18.join(baseDir, `${workspaceHash}.json`);
-      (0, import_fs6.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+      (0, import_fs8.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
     }
     function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -52411,133 +53119,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         return null;
       }
     }
-    init_mesh_config();
-    init_logger();
-    var MAX_PENDING_EVENTS = 50;
-    var pendingMeshCoordinatorEvents = [];
-    function drainPendingMeshCoordinatorEvents() {
-      return pendingMeshCoordinatorEvents.splice(0);
-    }
-    function readNonEmptyString(value) {
-      return typeof value === "string" && value.trim() ? value.trim() : "";
-    }
-    var MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
-      "agent:generating_completed",
-      "agent:waiting_approval",
-      "agent:stopped",
-      "monitor:long_generating"
-    ]);
-    function isMeshCoordinatorEvent(eventName) {
-      return typeof eventName === "string" && MESH_COORDINATOR_EVENTS.has(eventName);
-    }
-    function formatCompletionMetadata(event) {
-      const parts = [
-        readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : "",
-        readNonEmptyString(event.providerType) ? `provider=${readNonEmptyString(event.providerType)}` : "",
-        readNonEmptyString(event.providerSessionId) ? `provider_session_id=${readNonEmptyString(event.providerSessionId)}` : ""
-      ].filter(Boolean);
-      return parts.length > 0 ? ` (${parts.join("; ")})` : "";
-    }
-    function buildMeshSystemMessage(args) {
-      const metadata = formatCompletionMetadata(args.metadataEvent);
-      if (args.event === "agent:generating_completed") {
-        return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path; use mesh_read_chat once to review its final progress, but do not poll repeatedly.`;
-      }
-      if (args.event === "agent:waiting_approval") {
-        return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
-      }
-      if (args.event === "agent:stopped") {
-        return `[System] ${args.nodeLabel} has stopped${metadata}. Use mesh_read_chat once if you need to inspect its last output.`;
-      }
-      if (args.event === "monitor:long_generating") {
-        return `[System] ${args.nodeLabel} has been generating for a long time${metadata}. Use mesh_read_chat once for a status check, but do not poll repeatedly.`;
-      }
-      return "";
-    }
-    function injectMeshSystemMessage(components, args) {
-      const coordinatorInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
-        const instState = inst.getState();
-        if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
-        if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
-        return true;
-      });
-      if (coordinatorInstances.length === 0) {
-        if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
-          pendingMeshCoordinatorEvents.push({
-            event: args.event,
-            meshId: args.meshId,
-            nodeLabel: args.nodeLabel,
-            metadataEvent: args.metadataEvent,
-            queuedAt: Date.now()
-          });
-          LOG2.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
-        }
-        return { success: true, forwarded: 0 };
-      }
-      const messageText = buildMeshSystemMessage({
-        event: args.event,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: args.metadataEvent
-      });
-      if (!messageText) return { success: false, error: "unsupported mesh event" };
-      for (const coord of coordinatorInstances) {
-        const coordState = coord.getState();
-        LOG2.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}`);
-        coord.onEvent("send_message", { input: { text: messageText, textFallback: messageText } });
-      }
-      return { success: true, forwarded: coordinatorInstances.length };
-    }
-    function handleMeshForwardEvent(components, payload) {
-      const eventName = readNonEmptyString(payload.event);
-      if (!isMeshCoordinatorEvent(eventName)) {
-        return { success: false, error: "unsupported mesh event" };
-      }
-      const meshId = readNonEmptyString(payload.meshId);
-      if (!meshId) return { success: false, error: "meshId required" };
-      const nodeId = readNonEmptyString(payload.nodeId);
-      const workspace = readNonEmptyString(payload.workspace);
-      const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : "Remote agent";
-      return injectMeshSystemMessage(components, {
-        meshId,
-        nodeLabel,
-        event: eventName,
-        metadataEvent: {
-          targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId),
-          providerType: readNonEmptyString(payload.providerType),
-          providerSessionId: readNonEmptyString(payload.providerSessionId)
-        }
-      });
-    }
-    function setupMeshEventForwarding(components) {
-      components.instanceManager.onEvent((event) => {
-        if (!isMeshCoordinatorEvent(event.event)) return;
-        const instanceId = readNonEmptyString(event.instanceId);
-        if (!instanceId) return;
-        const sourceInstance = components.instanceManager.getInstance(instanceId);
-        if (!sourceInstance || sourceInstance.category !== "cli") return;
-        const state = sourceInstance.getState();
-        const workspace = readNonEmptyString(state.workspace);
-        if (!workspace) return;
-        const settings = state.settings && typeof state.settings === "object" ? state.settings : {};
-        if (readNonEmptyString(settings.meshCoordinatorFor)) return;
-        const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
-        const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
-        if (!isMeshDelegate) return;
-        const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
-        const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
-        if (!meshId) return;
-        const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
-        const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
-        const nodeLabel = targetNode ? `Node '${targetNode.id}'` : runtimeNodeId ? `Node '${runtimeNodeId}'` : `Agent at ${workspace}`;
-        injectMeshSystemMessage(components, {
-          meshId,
-          sourceInstanceId: instanceId,
-          nodeLabel,
-          event: event.event,
-          metadataEvent: event
-        });
-      });
-    }
+    init_mesh_events();
     var os18 = __toESM2(require("os"));
     init_config();
     init_terminal_screen();
@@ -53186,7 +53768,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
     }
     var import_os3 = require("os");
-    var import_path4 = require("path");
+    var import_path6 = require("path");
     var fs10 = __toESM2(require("fs"));
     var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     var CHANNEL_SERVER_URL = {
@@ -53255,22 +53837,22 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path4.join)((0, import_os3.homedir)(), ".hermes");
+      return explicitHome || (0, import_path6.join)((0, import_os3.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path4.join)(sourceHome, "config.yaml");
+      const sourceConfigPath = (0, import_path6.join)(sourceHome, "config.yaml");
       if (!fs10.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path4.resolve)(sourceConfigPath) === (0, import_path4.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path6.resolve)(sourceConfigPath) === (0, import_path6.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       const parsed = parseMeshCoordinatorMcpConfig(fs10.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path4.resolve)(sourceHome) === (0, import_path4.resolve)(targetHome)) return;
+      if ((0, import_path6.resolve)(sourceHome) === (0, import_path6.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path4.join)(sourceHome, fileName);
-        const targetPath = (0, import_path4.join)(targetHome, fileName);
+        const sourcePath = (0, import_path6.join)(sourceHome, fileName);
+        const targetPath = (0, import_path6.join)(targetHome, fileName);
         if (!fs10.existsSync(sourcePath)) continue;
         try {
           fs10.copyFileSync(sourcePath, targetPath);
@@ -54231,6 +54813,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               return { success: false, error: e.message };
             }
           }
+          case "get_mesh_ledger": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              const tail = typeof args?.tail === "number" ? args.tail : 20;
+              const since = typeof args?.since === "string" ? args.since : void 0;
+              const kind = Array.isArray(args?.kind) ? args.kind.filter((k) => typeof k === "string") : void 0;
+              const entries = readLedgerEntries2(meshId, { tail, since, kind });
+              const summary = getLedgerSummary2(meshId);
+              return { success: true, entries, summary };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
           case "add_mesh_node": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
@@ -54299,6 +54896,54 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               return { success: false, error: e.message };
             }
           }
+          case "refine_mesh_node": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+            if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+            try {
+              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+              const mesh = meshRecord?.mesh;
+              const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+              if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+              if (!node.isLocalWorktree || !node.workspace) {
+                return { success: false, error: `Refinery requires a local worktree node` };
+              }
+              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" };
+              const { execFile: execFile3 } = await import("child_process");
+              const { promisify: promisify3 } = await import("util");
+              const execFileAsync3 = promisify3(execFile3);
+              const { stdout: branchStdout } = await execFileAsync3("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" };
+              const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
+              const baseBranch = baseBranchStdout.trim();
+              try {
+                await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+              } catch (e) {
+                return { success: false, error: `Merge failed (conflicts?): ${e.message}` };
+              }
+              const removeResult = await this.execute("remove_mesh_node", {
+                meshId,
+                nodeId,
+                sessionCleanupMode: "kill",
+                inlineMesh: args?.inlineMesh
+              });
+              try {
+                const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+                appendLedgerEntry2(meshId, {
+                  kind: "node_removed",
+                  nodeId,
+                  payload: { refined: true, mergedBranch: branch, into: baseBranch }
+                });
+              } catch {
+              }
+              return { success: true, merged: true, branch, into: baseBranch, removeResult };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
           case "remove_mesh_node": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
@@ -54334,6 +54979,17 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
                 removed = removeNode3(meshId, nodeId);
               }
+              if (removed) {
+                try {
+                  const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+                  appendLedgerEntry2(meshId, {
+                    kind: "node_removed",
+                    nodeId,
+                    payload: { worktree: !!node?.isLocalWorktree, sessionCleanupMode }
+                  });
+                } catch {
+                }
+              }
               return { success: true, removed, ...sessionCleanup ? { sessionCleanup } : {} };
             } catch (e) {
               return { success: false, error: e.message };
@@ -54363,9 +55019,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               });
               let node;
               if (meshRecord.inline) {
-                const { randomUUID: randomUUID8 } = await import("crypto");
+                const { randomUUID: randomUUID10 } = await import("crypto");
                 node = {
-                  id: `node_${randomUUID8().replace(/-/g, "")}`,
+                  id: `node_${randomUUID10().replace(/-/g, "")}`,
                   workspace: result.worktreePath,
                   repoRoot: result.worktreePath,
                   daemonId: sourceNode.daemonId,
@@ -54390,6 +55046,15 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 });
                 if (!node) return { success: false, error: "Failed to register worktree node" };
               }
+              try {
+                const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+                appendLedgerEntry2(meshId, {
+                  kind: "node_cloned",
+                  nodeId: node.id,
+                  payload: { sourceNodeId, branch: result.branch, worktreePath: result.worktreePath }
+                });
+              } catch {
+              }
               return {
                 success: true,
                 node,
@@ -54400,6 +55065,19 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               return { success: false, error: e.message };
             }
           }
+          case "trigger_mesh_queue": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { triggerMeshQueue: triggerMeshQueue2 } = await Promise.resolve().then(() => (init_mesh_events(), mesh_events_exports));
+              if (meshId) {
+                triggerMeshQueue2(this.deps, meshId);
+              }
+              return { success: true };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
           // ─── Mesh Coordinator Launch ───
           case "launch_mesh_coordinator": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
@@ -54504,7 +55182,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   workspace
                 };
               }
-              const { existsSync: existsSync23, readFileSync: readFileSync15, writeFileSync: writeFileSync14, copyFileSync: copyFileSync4, mkdirSync: mkdirSync16 } = await import("fs");
+              const { existsSync: existsSync25, readFileSync: readFileSync17, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4, mkdirSync: mkdirSync17 } = await import("fs");
               const { dirname: dirname9 } = await import("path");
               const mcpConfigPath = coordinatorSetup.configPath;
               const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -54538,21 +55216,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 };
               }
               try {
-                mkdirSync16(dirname9(mcpConfigPath), { recursive: true });
+                mkdirSync17(dirname9(mcpConfigPath), { recursive: true });
               } catch (error48) {
                 const message = `Could not prepare MCP config path for automatic setup: ${error48?.message || error48}`;
                 LOG2.error("MeshCoordinator", message);
                 if (hermesManualFallback) return returnManualFallback(message);
                 return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
               }
-              const hadExistingMcpConfig = existsSync23(mcpConfigPath);
+              const hadExistingMcpConfig = existsSync25(mcpConfigPath);
               let existingMcpConfig = hermesBaseConfig?.config || {};
               if (hermesBaseConfig) {
                 copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname9(mcpConfigPath));
               }
               if (hadExistingMcpConfig) {
                 try {
-                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync15(mcpConfigPath, "utf-8"), configFormat);
+                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync17(mcpConfigPath, "utf-8"), configFormat);
                   existingMcpConfig = { ...existingMcpConfig, ...parsedExistingMcpConfig };
                   copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
                 } catch (error48) {
@@ -54574,7 +55252,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 }
               };
               try {
-                writeFileSync14(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+                writeFileSync15(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
               } catch (error48) {
                 const message = `Could not write MCP config for automatic setup: ${error48?.message || error48}`;
                 LOG2.error("MeshCoordinator", message);
@@ -54611,6 +55289,16 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 return { success: false, error: launchResult?.error || "Failed to launch CLI session" };
               }
               LOG2.info("MeshCoordinator", `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+              try {
+                const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+                appendLedgerEntry2(meshId, {
+                  kind: "coordinator_started",
+                  sessionId: launchResult.sessionId || launchResult.id,
+                  providerType: cliType,
+                  payload: { workspace }
+                });
+              } catch {
+              }
               return {
                 success: true,
                 meshId,
@@ -62344,6 +63032,7 @@ data: ${JSON.stringify(msg.data)}
     };
     init_logger();
     init_config();
+    init_mesh_events();
     async function initDaemonComponents2(config2) {
       installGlobalInterceptor();
       const appConfig = loadConfig2();