@adhdev/daemon-core 0.9.77-rc.1 → 0.9.77-rc.11

package/dist/index.mjs

@@ -38,7 +38,8 @@ var init_repo_mesh_types = __esm({
       dirtyWorkspaceBehavior: "warn",
       maxParallelTasks: 2,
       spawnedSessionVisibility: "visible",
-      sessionCleanupOnNodeRemove: "preserve"
+      sessionCleanupOnNodeRemove: "preserve",
+      maxTaskRetries: 1
     };
   }
 });
@@ -668,12 +669,13 @@ function buildRulesSection(coordinatorCliType) {
   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.
@@ -694,6 +696,7 @@ var init_coordinator_prompt = __esm({
 | \`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 |
@@ -704,25 +707,372 @@ var init_coordinator_prompt = __esm({
 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.`;
+  }
+});
+
+// src/mesh/mesh-ledger.ts
+var mesh_ledger_exports = {};
+__export(mesh_ledger_exports, {
+  appendLedgerEntry: () => appendLedgerEntry,
+  appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
+  getLedgerDir: () => getLedgerDir,
+  getLedgerSummary: () => getLedgerSummary,
+  getSessionRecoveryContext: () => getSessionRecoveryContext,
+  meshLedgerEvents: () => meshLedgerEvents,
+  readLedgerEntries: () => readLedgerEntries
+});
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, appendFileSync, statSync as statSync2, renameSync } from "fs";
+import { join as join5 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { EventEmitter } from "events";
+function getLedgerDir() {
+  const dir = join5(getConfigDir(), LEDGER_DIR_NAME);
+  if (!existsSync5(dir)) {
+    mkdirSync3(dir, { recursive: true, mode: 448 });
+  }
+  return dir;
+}
+function getLedgerPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join5(getLedgerDir(), `${safe}.jsonl`);
+}
+function getRotatedPath(meshId, index) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join5(getLedgerDir(), `${safe}.${index}.jsonl`);
+}
+function appendLedgerEntry(meshId, partial) {
+  const entry = {
+    id: randomUUID4(),
+    meshId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...partial
+  };
+  const filePath = getLedgerPath(meshId);
+  if (existsSync5(filePath)) {
+    try {
+      const stat2 = statSync2(filePath);
+      if (stat2.size >= MAX_FILE_SIZE_BYTES) {
+        rotateLedgerFile(meshId, filePath);
+      }
+    } catch {
+    }
+  }
+  try {
+    const line = JSON.stringify(entry) + "\n";
+    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";
+    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 (!existsSync5(filePath)) return [];
+  let content;
+  try {
+    content = readFileSync3(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 (existsSync5(getRotatedPath(meshId, index))) {
+    index++;
+    if (index > 10) break;
+  }
+  if (index > 10) index = 10;
+  try {
+    renameSync(currentPath, getRotatedPath(meshId, index));
+  } catch {
+  }
+}
+var LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, meshLedgerEvents;
+var init_mesh_ledger = __esm({
+  "src/mesh/mesh-ledger.ts"() {
+    "use strict";
+    init_config();
+    LEDGER_DIR_NAME = "mesh-ledger";
+    MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+    RECENT_FAILURE_WINDOW_MS = 30 * 60 * 1e3;
+    meshLedgerEvents = new EventEmitter();
+  }
+});
+
+// src/mesh/mesh-work-queue.ts
+import { existsSync as existsSync6, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+function getQueuePath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join6(getLedgerDir(), `${safe}.queue.json`);
+}
+function readQueue(meshId) {
+  const path28 = getQueuePath(meshId);
+  if (!existsSync6(path28)) return [];
+  try {
+    const content = readFileSync4(path28, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function writeQueue(meshId, queue) {
+  const path28 = getQueuePath(meshId);
+  writeFileSync3(path28, JSON.stringify(queue, null, 2), "utf-8");
+}
+function enqueueTask(meshId, message, opts) {
+  const queue = readQueue(meshId);
+  const entry = {
+    id: randomUUID5(),
+    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((q) => statuses.has(q.status));
+  }
+  return queue;
+}
+function claimNextTask(meshId, nodeId, sessionId) {
+  const queue = readQueue(meshId);
+  let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId);
+  if (targetIdx === -1) {
+    targetIdx = queue.findIndex((q) => q.status === "pending" && !q.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((q) => q.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((q) => q.status === "pending").length,
+    assigned: queue.filter((q) => q.status === "assigned").length,
+    completed: queue.filter((q) => q.status === "completed").length,
+    failed: queue.filter((q) => q.status === "failed").length
+  };
+}
+var init_mesh_work_queue = __esm({
+  "src/mesh/mesh-work-queue.ts"() {
+    "use strict";
+    init_mesh_ledger();
   }
 });
 
 // src/logging/logger.ts
 import * as fs2 from "fs";
-import * as path10 from "path";
-import * as os4 from "os";
+import * as path8 from "path";
+import * as os2 from "os";
 function setLogLevel(level) {
   currentLevel = level;
   daemonLog("Logger", `Log level set to: ${level}`, "info");
@@ -737,13 +1087,13 @@ function getDaemonLogDir() {
   return LOG_DIR;
 }
 function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
-  return path10.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
+  return path8.join(LOG_DIR, `daemon-${date.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();
   }
 }
@@ -757,7 +1107,7 @@ function cleanOldLogs() {
       const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path10.join(LOG_DIR, file));
+          fs2.unlinkSync(path8.join(LOG_DIR, file));
         } catch {
         }
       }
@@ -880,7 +1230,7 @@ var init_logger = __esm({
     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(os4.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path10.join(os4.homedir(), "Library", "Logs", "adhdev") : path10.join(os4.homedir(), ".local", "share", "adhdev", "logs");
+    LOG_DIR = process.platform === "win32" ? path8.join(process.env.LOCALAPPDATA || process.env.APPDATA || path8.join(os2.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path8.join(os2.homedir(), "Library", "Logs", "adhdev") : path8.join(os2.homedir(), ".local", "share", "adhdev", "logs");
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
@@ -888,16 +1238,16 @@ var init_logger = __esm({
     } 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 (fs2.existsSync(oldLog)) {
         const stat2 = fs2.statSync(oldLog);
         const oldDate = stat2.mtime.toISOString().slice(0, 10);
-        fs2.renameSync(oldLog, path10.join(LOG_DIR, `daemon-${oldDate}.log`));
+        fs2.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 (fs2.existsSync(oldLogBackup)) {
         fs2.unlinkSync(oldLogBackup);
       }
@@ -928,8 +1278,314 @@ var init_logger = __esm({
         };
       }
     };
-    interceptorInstalled = false;
-    LOG_PATH = path10.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    interceptorInstalled = false;
+    LOG_PATH = path8.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+  }
+});
+
+// src/mesh/mesh-events.ts
+var mesh_events_exports = {};
+__export(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;
+  LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+  components.cliManager.handleCliCommand("agent_command", {
+    targetSessionId: sessionId,
+    cliType: providerType,
+    action: "send_chat",
+    message: task.message
+  }).catch((e) => {
+    LOG.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) {
+      LOG.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
+            });
+            LOG.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) => LOG.error("MeshRecovery", `Failed to auto-relaunch session for ${node.id}: ${e?.message}`));
+            }
+          } catch (e) {
+            LOG.warn("MeshRecovery", `Failed to execute auto-recovery: ${e?.message}`);
+          }
+        }
+      }
+      LOG.info("MeshRecovery", `Recovery context for ${args.nodeLabel}: ${recoveryContext.advice}`);
+    } catch (e) {
+      LOG.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()
+      });
+      LOG.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();
+    LOG.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, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND;
+var init_mesh_events = __esm({
+  "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"
+    };
   }
 });
 
@@ -2039,6 +2695,8 @@ var init_provider_cli_adapter = __esm({
       statusHistory = [];
       // ─── CLI Scripts (script-based parsing) ───
       cliScripts;
+      /** Per-session opaque state object created by cliScripts.createState(), reset on stop. */
+      scriptState = null;
       runtimeSettings = {};
       /** Full accumulated rendered PTY transcript for parser/readback use */
       accumulatedBuffer = "";
@@ -2220,6 +2878,7 @@ ${lastSnapshot}`;
         this.cliScripts = scripts;
         this.parsedStatusCache = null;
         this.parseErrorMessage = null;
+        this.scriptState = typeof scripts.createState === "function" ? scripts.createState() : null;
         const scriptNames = listCliScriptNames(scripts);
         LOG.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
       }
@@ -2337,6 +2996,7 @@ ${lastSnapshot}`;
           this.ready = false;
           this.startupParseGate = false;
           this.spawnAt = 0;
+          this.scriptState = null;
           this.onStatusChange?.();
         });
         this.spawnAt = Date.now();
@@ -3110,7 +3770,7 @@ ${lastSnapshot}`;
             scope: this.currentTurnScope,
             runtimeSettings: this.runtimeSettings
           });
-          const session = this.cliScripts.parseSession({ ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+          const session = this.cliScripts.parseSession(this.scriptState, { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
           this.parseErrorMessage = null;
           return session && typeof session === "object" ? session : null;
         } catch (e) {
@@ -3124,7 +3784,7 @@ ${lastSnapshot}`;
         if (!this.cliScripts?.detectStatus) return null;
         try {
           const screenText = this.terminalScreen.getText();
-          const status = this.cliScripts.detectStatus({
+          const status = this.cliScripts.detectStatus(this.scriptState, {
             tail: text.slice(-500),
             screenText,
             rawBuffer: this.accumulatedRawBuffer,
@@ -3143,7 +3803,7 @@ ${lastSnapshot}`;
         try {
           const screenText = this.terminalScreen.getText();
           const buffer = screenText || this.accumulatedBuffer;
-          return this.cliScripts.parseApproval({
+          return this.cliScripts.parseApproval(this.scriptState, {
             buffer,
             screenText,
             rawBuffer: this.accumulatedRawBuffer,
@@ -3251,7 +3911,7 @@ ${lastSnapshot}`;
           scope: this.currentTurnScope,
           runtimeSettings: this.runtimeSettings
         });
-        return await Promise.resolve(fn({
+        return await Promise.resolve(fn(this.scriptState, {
           ...input,
           args: args && typeof args === "object" ? { ...args } : {}
         }));
@@ -5851,13 +6511,36 @@ async function syncMeshes(transport) {
       }
     }
   }
+  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;
 }
+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);
+  }
+}
+
+// src/index.ts
+init_mesh_ledger();
+init_mesh_work_queue();
+init_mesh_events();
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -5870,7 +6553,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join5(getConfigDir(), "state.json");
+  return join8(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -5906,11 +6589,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync5(statePath)) {
+  if (!existsSync8(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = readFileSync3(statePath, "utf-8");
+    const raw = readFileSync5(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -5919,7 +6602,7 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  writeFileSync3(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  writeFileSync4(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
@@ -5927,9 +6610,9 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { platform, homedir as homedir3 } from "os";
-import * as path8 from "path";
+import { existsSync as existsSync9 } from "fs";
+import { platform, homedir as homedir4 } from "os";
+import * as path9 from "path";
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -5948,10 +6631,10 @@ function getMergedDefinitions() {
 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(homedir3(), trimmed.slice(1)) : trimmed;
-    const resolved = path8.isAbsolute(candidate) ? candidate : path8.resolve(candidate);
-    return existsSync6(resolved) ? resolved : null;
+  if (path9.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+    const candidate = trimmed.startsWith("~") ? path9.join(homedir4(), trimmed.slice(1)) : trimmed;
+    const resolved = path9.isAbsolute(candidate) ? candidate : path9.resolve(candidate);
+    return existsSync9(resolved) ? resolved : null;
   }
   try {
     const result = execSync(
@@ -5976,15 +6659,15 @@ function getIdeVersion(cliCommand) {
   }
 }
 function checkPathExists(paths) {
-  const home = homedir3();
+  const home = homedir4();
   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 (existsSync6(resolved)) return resolved;
+      if (existsSync9(resolved)) return resolved;
     } else {
-      if (existsSync6(normalized)) return normalized;
+      if (existsSync9(normalized)) return normalized;
     }
   }
   return null;
@@ -5998,7 +6681,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync6(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync9(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -6011,7 +6694,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync6(c)) {
+        if (existsSync9(c)) {
           resolvedCli = c;
           break;
         }
@@ -6035,9 +6718,9 @@ async function detectIDEs(providerLoader) {
 
 // src/detection/cli-detector.ts
 import { exec } from "child_process";
-import * as os2 from "os";
-import * as path9 from "path";
-import { existsSync as existsSync7 } from "fs";
+import * as os3 from "os";
+import * as path10 from "path";
+import { existsSync as existsSync10 } from "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);
@@ -6049,19 +6732,19 @@ function shellQuote(value) {
 function expandHome(value) {
   const trimmed = value.trim();
   if (!trimmed.startsWith("~")) return trimmed;
-  return path9.join(os2.homedir(), trimmed.slice(1));
+  return path10.join(os3.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 existsSync7(candidate) ? candidate : null;
+    const candidate = path10.isAbsolute(expanded) ? expanded : path10.resolve(expanded);
+    return existsSync10(candidate) ? candidate : null;
   }
   return null;
 }
@@ -6082,7 +6765,7 @@ function execAsync(cmd, timeoutMs = 5e3) {
   });
 }
 async function detectCLIs(providerLoader, options) {
-  const platform10 = os2.platform();
+  const platform10 = os3.platform();
   const whichCmd = platform10 === "win32" ? "where" : "which";
   const includeVersion = options?.includeVersion !== false;
   const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
@@ -6126,7 +6809,7 @@ async function detectCLI(cliId, providerLoader, options) {
     const cliList = providerLoader.getCliDetectionList();
     const target = cliList.find((c) => c.id === resolvedId);
     if (target) {
-      const platform10 = os2.platform();
+      const platform10 = os3.platform();
       const whichCmd = platform10 === "win32" ? "where" : "which";
       try {
         const explicitPath = resolveCommandPath(target.command);
@@ -6163,10 +6846,10 @@ async function detectCLI(cliId, providerLoader, options) {
 }
 
 // src/system/host-memory.ts
-import * as os3 from "os";
+import * as os4 from "os";
 import { execSync as execSync2 } from "child_process";
 function parseDarwinAvailableBytes(totalMem) {
-  if (os3.platform() !== "darwin") return null;
+  if (os4.platform() !== "darwin") return null;
   try {
     const out = execSync2("vm_stat", {
       encoding: "utf-8",
@@ -6197,8 +6880,8 @@ function parseDarwinAvailableBytes(totalMem) {
   }
 }
 function getHostMemorySnapshot() {
-  const totalMem = os3.totalmem();
-  const freeMem = os3.freemem();
+  const totalMem = os4.totalmem();
+  const freeMem = os4.freemem();
   const darwinAvail = parseDarwinAvailableBytes(totalMem);
   const availableMem = darwinAvail != null ? darwinAvail : freeMem;
   return { totalMem, freeMem, availableMem };
@@ -11568,6 +12251,9 @@ function normalizeActiveChatData(activeChat, options = FULL_STATUS_ACTIVE_CHAT_O
   return normalized;
 }
 
+// src/status/builders.ts
+init_mesh_work_queue();
+
 // src/providers/provider-input-support.ts
 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"]);
@@ -11793,6 +12479,8 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
   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,
@@ -11815,7 +12503,8 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
     errorMessage: state.errorMessage,
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
-    settings: state.settings
+    settings: state.settings,
+    ...meshQueueStats && { meshQueueStats }
   };
 }
 function buildExtensionAgentSession(parent, ext, options) {
@@ -11827,6 +12516,8 @@ function buildExtensionAgentSession(parent, ext, options) {
   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,
@@ -11849,7 +12540,8 @@ function buildExtensionAgentSession(parent, ext, options) {
     errorMessage: ext.errorMessage,
     errorReason: ext.errorReason,
     lastUpdated: ext.lastUpdated,
-    settings: ext.settings
+    settings: ext.settings,
+    ...meshQueueStats && { meshQueueStats }
   };
 }
 function shouldIncludeExtensionSession(ext) {
@@ -11877,6 +12569,8 @@ function buildCliSession(state, options) {
   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,
@@ -11915,7 +12609,8 @@ function buildCliSession(state, options) {
     errorMessage: state.errorMessage,
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
-    settings: state.settings
+    settings: state.settings,
+    ...meshQueueStats && { meshQueueStats }
   };
 }
 function buildAcpSession(state, options) {
@@ -11927,6 +12622,8 @@ function buildAcpSession(state, options) {
   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,
@@ -11948,7 +12645,8 @@ function buildAcpSession(state, options) {
     errorMessage: state.errorMessage,
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
-    settings: state.settings
+    settings: state.settings,
+    ...meshQueueStats && { meshQueueStats }
   };
 }
 function buildSessionEntries(allStates, cdpManagers, options = {}) {
@@ -12058,7 +12756,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 import * as fs4 from "fs";
 import * as os6 from "os";
 import * as path12 from "path";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 init_logger();
 
 // src/logging/debug-trace.ts
@@ -12583,7 +13281,7 @@ function safeBundleIdSegment(value, fallback) {
 function createChatDebugBundleId(targetSessionId) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "").replace("T", "T").replace("Z", "Z");
   const sessionSegment = safeBundleIdSegment(targetSessionId, "unknown-session");
-  return `chat-debug-${timestamp}-${sessionSegment}-${randomUUID5().slice(0, 8)}`;
+  return `chat-debug-${timestamp}-${sessionSegment}-${randomUUID7().slice(0, 8)}`;
 }
 function buildChatDebugBundleSummary(bundle) {
   const target = bundle.target && typeof bundle.target === "object" ? bundle.target : {};
@@ -14289,11 +14987,13 @@ async function handleOpenPanel(h, args) {
 async function handlePtyInput(h, args) {
   const { cliType, data, targetSessionId } = args || {};
   if (!data) return { success: false, error: "data required" };
+  const cleanData = typeof data === "string" ? data.replace(/\x1b\[\?[0-9;]*c/g, "") : data;
+  if (!cleanData) return { success: true };
   const adapter = h.getCliAdapter(targetSessionId || cliType);
   if (!adapter || typeof adapter.writeRaw !== "function") {
     return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
   }
-  await adapter.writeRaw(data);
+  await adapter.writeRaw(cleanData);
   return { success: true };
 }
 function handlePtyResize(_h, args) {
@@ -15250,7 +15950,7 @@ init_provider_cli_adapter();
 import * as os13 from "os";
 import * as path18 from "path";
 import * as crypto4 from "crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
 init_config();
@@ -17632,7 +18332,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return existsSync12(expandExecutable(trimmed));
+    return existsSync14(expandExecutable(trimmed));
   }
   try {
     execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -17661,10 +18361,10 @@ function hasCliArg(args, flag) {
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
   const baseDir = path18.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-  mkdirSync8(baseDir, { recursive: true });
+  mkdirSync9(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`);
-  writeFileSync8(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  writeFileSync9(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
 function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -20903,10 +21603,10 @@ import * as yaml from "js-yaml";
 // src/commands/mesh-coordinator.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync15, readdirSync as readdirSync7, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync7, realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import * as os17 from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute11, join as join18, resolve as resolve13 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute11, join as join20, resolve as resolve13 } from "path";
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
 var HERMES_CLI_TYPE = "hermes-cli";
@@ -20927,7 +21627,7 @@ function resolveHermesMeshCoordinatorSetup(options) {
       reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
     };
   }
-  const configPath = join18(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join20(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -21008,6 +21708,22 @@ function resolveMeshCoordinatorSetup(options) {
     if (!instructions || !template?.trim()) {
       return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
     }
+    const renderedTemplate = renderMeshCoordinatorTemplate(template, {
+      meshId,
+      workspace,
+      serverName,
+      adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
+    });
+    const isCliCommand = !renderedTemplate.trim().includes("\n") && !renderedTemplate.trim().startsWith("{");
+    if (isCliCommand) {
+      return {
+        kind: "cli_command",
+        serverName,
+        command: renderedTemplate.trim(),
+        requiresRestart: mcpConfig.requiresRestart === true,
+        instructions
+      };
+    }
     return {
       kind: "manual",
       serverName,
@@ -21015,12 +21731,7 @@ function resolveMeshCoordinatorSetup(options) {
       configPathCommand: mcpConfig.configPathCommand,
       requiresRestart: mcpConfig.requiresRestart === true,
       instructions,
-      template: renderMeshCoordinatorTemplate(template, {
-        meshId,
-        workspace,
-        serverName,
-        adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
-      })
+      template: renderedTemplate
     };
   }
   return {
@@ -21035,14 +21746,14 @@ function resolveHermesCoordinatorHome(meshId, workspace) {
   const key = `${meshId || "mesh"}
 ${resolve13(workspace || os17.tmpdir())}`;
   const hash = createHash2("sha256").update(key).digest("hex").slice(0, 16);
-  return join18(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  return join20(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os17.homedir();
-  if (trimmed.startsWith("~/")) return join18(os17.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join20(os17.homedir(), trimmed.slice(2));
   if (isAbsolute11(trimmed)) return trimmed;
-  return join18(workspace, trimmed);
+  return join20(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
@@ -21082,15 +21793,15 @@ function addNodeCandidatesFromPath(pathValue, addCandidate) {
   for (const entry of (pathValue || "").split(":")) {
     const dir = entry.trim();
     if (!dir) continue;
-    addCandidate(join18(dir, "node"));
+    addCandidate(join20(dir, "node"));
   }
 }
 function addNodeCandidatesFromNvm(homeDir, addCandidate) {
-  const versionsDir = join18(homeDir, ".nvm", "versions", "node");
+  const versionsDir = join20(homeDir, ".nvm", "versions", "node");
   try {
     const versionDirs = readdirSync7(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareNodeVersionNamesDescending);
     for (const versionDir of versionDirs) {
-      addCandidate(join18(versionsDir, versionDir, "bin", "node"));
+      addCandidate(join20(versionsDir, versionDir, "bin", "node"));
     }
   } catch {
   }
@@ -21141,7 +21852,7 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
     if (normalized) return normalized;
   }
   try {
-    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join18(process.cwd(), "adhdev-daemon.js");
+    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join20(process.cwd(), "adhdev-daemon.js");
     const req = createRequire2(requireBase);
     const resolvedModule = req.resolve("@adhdev/mcp-server");
     return normalizeExistingPath(resolvedModule) || resolvedModule;
@@ -21151,141 +21862,15 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
 }
 function normalizeExistingPath(filePath) {
   try {
-    if (!existsSync15(filePath)) return null;
+    if (!existsSync17(filePath)) return null;
     return realpathSync2.native(filePath);
   } catch {
     return null;
   }
 }
 
-// src/mesh/mesh-events.ts
-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()
-      });
-      LOG.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();
-    LOG.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
-    });
-  });
-}
+// src/commands/router.ts
+init_mesh_events();
 
 // src/status/snapshot.ts
 init_config();
@@ -22985,6 +23570,21 @@ var DaemonCommandRouter = class {
           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() : "";
@@ -23053,6 +23653,54 @@ var DaemonCommandRouter = class {
           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() : "";
@@ -23088,6 +23736,17 @@ var DaemonCommandRouter = class {
             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 };
@@ -23117,9 +23776,9 @@ var DaemonCommandRouter = class {
           });
           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,
@@ -23144,6 +23803,15 @@ var DaemonCommandRouter = class {
             });
             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,
@@ -23154,6 +23822,19 @@ var DaemonCommandRouter = class {
           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() : "";
@@ -23232,6 +23913,93 @@ var DaemonCommandRouter = class {
               meshCoordinatorSetup: coordinatorSetup
             };
           }
+          if (coordinatorSetup.kind === "cli_command") {
+            let cliCmdSystemPrompt = "";
+            try {
+              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType });
+            } catch (error) {
+              const message = error?.message || String(error);
+              LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
+              return {
+                success: false,
+                code: "mesh_coordinator_prompt_failed",
+                error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
+                meshId,
+                cliType,
+                workspace
+              };
+            }
+            try {
+              const { execFileSync: execCmdSync } = await import("child_process");
+              const cmdParts = coordinatorSetup.command.trim().split(/\s+/);
+              const [regCmd, ...regArgs] = cmdParts;
+              LOG.info("MeshCoordinator", `Running MCP registration: ${coordinatorSetup.command}`);
+              execCmdSync(regCmd, regArgs, { stdio: "pipe", timeout: 15e3 });
+            } catch (error) {
+              LOG.warn("MeshCoordinator", `MCP registration command failed (may be pre-registered): ${error?.message || error}`);
+            }
+            const cliCmdArgs = [];
+            const cliCmdEnv = {};
+            if (cliCmdSystemPrompt) {
+              if (cliType === "codex-cli") {
+                cliCmdArgs.push("-c", `developer_instructions=${JSON.stringify(cliCmdSystemPrompt)}`);
+              } else if (cliType === "gemini-cli") {
+                try {
+                  const { writeFileSync: wfs, existsSync: efs, readFileSync: rfs } = await import("fs");
+                  const geminiMdPath = `${workspace}/GEMINI.md`;
+                  const marker = "<!-- adhdev-mesh-coordinator-prompt -->";
+                  const markerEnd = "<!-- /adhdev-mesh-coordinator-prompt -->";
+                  const block = `${marker}
+${cliCmdSystemPrompt}
+${markerEnd}`;
+                  if (efs(geminiMdPath)) {
+                    const existing = rfs(geminiMdPath, "utf-8");
+                    const replaced = existing.replace(
+                      new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, "g"),
+                      block
+                    );
+                    wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}
+
+${block}`);
+                  } else {
+                    wfs(geminiMdPath, block);
+                  }
+                  LOG.info("MeshCoordinator", `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
+                } catch (e) {
+                  LOG.warn("MeshCoordinator", `Could not write GEMINI.md: ${e?.message || e}`);
+                }
+              }
+            }
+            const cliCmdLaunch = await this.deps.cliManager.handleCliCommand("launch_cli", {
+              cliType,
+              dir: workspace,
+              cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : void 0,
+              env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : void 0,
+              settings: { meshCoordinatorFor: meshId }
+            });
+            if (!cliCmdLaunch?.success) {
+              return { success: false, error: cliCmdLaunch?.error || "Failed to launch CLI session" };
+            }
+            LOG.info("MeshCoordinator", `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
+            try {
+              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "coordinator_started",
+                sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                providerType: cliType,
+                payload: { workspace }
+              });
+            } catch {
+            }
+            return {
+              success: true,
+              meshId,
+              cliType,
+              workspace,
+              sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+              mcpRegistered: true
+            };
+          }
           const configFormat = coordinatorSetup.configFormat;
           if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
             return {
@@ -23258,7 +24026,7 @@ var DaemonCommandRouter = class {
               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;
@@ -23292,21 +24060,21 @@ var DaemonCommandRouter = class {
             };
           }
           try {
-            mkdirSync16(dirname9(mcpConfigPath), { recursive: true });
+            mkdirSync17(dirname9(mcpConfigPath), { recursive: true });
           } catch (error) {
             const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
             LOG.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 (error) {
@@ -23328,7 +24096,7 @@ var DaemonCommandRouter = class {
             }
           };
           try {
-            writeFileSync14(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+            writeFileSync15(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
           } catch (error) {
             const message = `Could not write MCP config for automatic setup: ${error?.message || error}`;
             LOG.error("MeshCoordinator", message);
@@ -23365,6 +24133,16 @@ var DaemonCommandRouter = class {
             return { success: false, error: launchResult?.error || "Failed to launch CLI session" };
           }
           LOG.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,
@@ -31155,6 +31933,7 @@ var SessionRegistry = class {
 // src/boot/daemon-lifecycle.ts
 init_logger();
 init_config();
+init_mesh_events();
 async function initDaemonComponents(config) {
   installGlobalInterceptor();
   const appConfig = loadConfig();
@@ -31437,6 +32216,7 @@ export {
   TurnSnapshotTracker,
   VersionArchive,
   addNode,
+  appendLedgerEntry,
   appendRecentActivity,
   buildAssistantChatMessage,
   buildChatMessage,
@@ -31454,6 +32234,7 @@ export {
   buildThoughtChatMessage,
   buildToolChatMessage,
   buildUserChatMessage,
+  claimNextTask,
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,
   clearDebugTrace,
@@ -31472,6 +32253,7 @@ export {
   detectAllVersions,
   detectCLIs,
   detectIDEs,
+  enqueueTask,
   ensureSessionHostReady,
   execNpmCommandSync,
   filterActivityChatMessages,
@@ -31490,10 +32272,13 @@ export {
   getGitFileDiff,
   getGitRepoStatus,
   getHostMemorySnapshot,
+  getLedgerDir,
+  getLedgerSummary,
   getLogLevel,
   getMesh,
   getMeshByRepo,
   getNpmExecOptions,
+  getQueue,
   getRecentActivity,
   getRecentCommands,
   getRecentDebugTrace,
@@ -31501,6 +32286,7 @@ export {
   getSavedProviderSessions,
   getSessionHostRecoveryLabel,
   getSessionHostSurfaceKind,
+  getSessionRecoveryContext,
   getWorkspaceState,
   handleGitCommand,
   hasCdpManager,
@@ -31554,6 +32340,7 @@ export {
   prepareSessionModalUpdate,
   probeCdpPort,
   readChatHistory,
+  readLedgerEntries,
   recordDebugTrace,
   registerExtensionProviders,
   removeNode,
@@ -31582,9 +32369,12 @@ export {
   startDaemonDevSupport,
   summarizeGitStatus,
   syncMeshes,
+  triggerMeshQueue,
   updateConfig,
   updateMesh,
   updateNode,
+  updateSessionTaskStatus,
+  updateTaskStatus,
   upsertSavedProviderSession
 };
 //# sourceMappingURL=index.mjs.map