@adhdev/daemon-core 0.9.76-rc.4 → 0.9.76-rc.41

package/dist/index.mjs

@@ -36,11 +36,140 @@ var init_repo_mesh_types = __esm({
       requireApprovalForPush: true,
       requireApprovalForDestructiveGit: true,
       dirtyWorkspaceBehavior: "warn",
-      maxParallelTasks: 2
+      maxParallelTasks: 2,
+      sessionCleanupOnNodeRemove: "preserve"
     };
   }
 });
 
+// src/git/git-worktree.ts
+var git_worktree_exports = {};
+__export(git_worktree_exports, {
+  createWorktree: () => createWorktree,
+  listWorktrees: () => listWorktrees,
+  parseWorktreeListOutput: () => parseWorktreeListOutput,
+  removeWorktree: () => removeWorktree,
+  resolveWorktreePath: () => resolveWorktreePath
+});
+import * as path4 from "path";
+import { mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+function resolveWorktreePath(repoRoot, meshName, branch) {
+  const safeBranch = branch.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
+  const safeMeshName = meshName.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
+  const parentDir = path4.dirname(repoRoot);
+  return path4.join(parentDir, WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+}
+async function createWorktree(opts) {
+  const { repoRoot, branch, baseBranch, meshName } = opts;
+  const targetDir = opts.targetDir || resolveWorktreePath(repoRoot, meshName, branch);
+  if (existsSync(targetDir)) {
+    throw new Error(`Worktree target directory already exists: ${targetDir}`);
+  }
+  await mkdir(path4.dirname(targetDir), { recursive: true });
+  const args = ["worktree", "add", targetDir, "-b", branch];
+  if (baseBranch) {
+    args.push(baseBranch);
+  }
+  try {
+    await execFileAsync2("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+      windowsHide: true
+    });
+  } catch (error) {
+    const stderr = typeof error.stderr === "string" ? error.stderr : "";
+    if (/already exists/i.test(stderr)) {
+      throw new Error(`Branch '${branch}' already exists or is checked out in another worktree`);
+    }
+    throw new Error(`git worktree add failed: ${stderr.trim() || error.message}`);
+  }
+  return {
+    success: true,
+    worktreePath: targetDir,
+    branch
+  };
+}
+async function removeWorktree(repoRoot, worktreePath) {
+  if (!existsSync(worktreePath)) {
+    await pruneWorktrees(repoRoot);
+    return { success: true, removedPath: worktreePath };
+  }
+  try {
+    await execFileAsync2("git", ["worktree", "remove", worktreePath, "--force"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+      windowsHide: true
+    });
+  } catch (error) {
+    const stderr = typeof error.stderr === "string" ? error.stderr : "";
+    throw new Error(`git worktree remove failed: ${stderr.trim() || error.message}`);
+  }
+  return { success: true, removedPath: worktreePath };
+}
+async function listWorktrees(repoRoot) {
+  const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_MAX_BUFFER,
+    windowsHide: true
+  });
+  return parseWorktreeListOutput(stdout);
+}
+function parseWorktreeListOutput(output) {
+  const entries = [];
+  const blocks = output.trim().split(/\n\n+/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    const lines = block.trim().split("\n");
+    const entry = { path: "", head: "", branch: null, bare: false };
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        entry.path = line.slice("worktree ".length).trim();
+      } else if (line.startsWith("HEAD ")) {
+        entry.head = line.slice("HEAD ".length).trim();
+      } else if (line.startsWith("branch ")) {
+        const ref = line.slice("branch ".length).trim();
+        entry.branch = ref.replace(/^refs\/heads\//, "");
+      } else if (line === "bare") {
+        entry.bare = true;
+      }
+    }
+    if (entry.path) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+async function pruneWorktrees(repoRoot) {
+  try {
+    await execFileAsync2("git", ["worktree", "prune"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      windowsHide: true
+    });
+  } catch {
+  }
+}
+var execFileAsync2, WORKTREE_DIR_NAME, GIT_TIMEOUT_MS, GIT_MAX_BUFFER;
+var init_git_worktree = __esm({
+  "src/git/git-worktree.ts"() {
+    "use strict";
+    execFileAsync2 = promisify2(execFile2);
+    WORKTREE_DIR_NAME = ".adhdev-worktrees";
+    GIT_TIMEOUT_MS = 3e4;
+    GIT_MAX_BUFFER = 4 * 1024 * 1024;
+  }
+});
+
 // src/config/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -56,8 +185,8 @@ __export(config_exports, {
   updateConfig: () => updateConfig
 });
 import { homedir } from "os";
-import { join } from "path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, chmodSync } from "fs";
 import { randomUUID } from "crypto";
 function resolveProviderSourceMode(providerSourceMode, legacyDisableUpstream) {
   if (providerSourceMode === "normal" || providerSourceMode === "no-upstream") {
@@ -151,18 +280,18 @@ function ensureMachineId(config) {
   };
 }
 function getConfigDir() {
-  const dir = join(homedir(), ".adhdev");
-  if (!existsSync(dir)) {
+  const dir = join2(homedir(), ".adhdev");
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getConfigPath() {
-  return join(getConfigDir(), "config.json");
+  return join2(getConfigDir(), "config.json");
 }
 function migrateStateToStateFile(raw) {
-  const statePath = join(getConfigDir(), "state.json");
-  if (existsSync(statePath)) return;
+  const statePath = join2(getConfigDir(), "state.json");
+  if (existsSync2(statePath)) return;
   const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
   const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
   const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
@@ -186,7 +315,7 @@ function migrateStateToStateFile(raw) {
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
     try {
       saveConfig(initialized.config);
@@ -217,7 +346,7 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   const dir = getConfigDir();
   const normalized = normalizeConfig(config);
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
   writeFileSync(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
@@ -295,17 +424,17 @@ __export(mesh_config_exports, {
   updateMesh: () => updateMesh,
   updateNode: () => updateNode
 });
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function getMeshConfigPath() {
-  return join3(getConfigDir(), "meshes.json");
+  return join4(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
-  const path26 = getMeshConfigPath();
-  if (!existsSync3(path26)) return { meshes: [] };
+  const path27 = getMeshConfigPath();
+  if (!existsSync4(path27)) return { meshes: [] };
   try {
-    const raw = JSON.parse(readFileSync2(path26, "utf-8"));
+    const raw = JSON.parse(readFileSync2(path27, "utf-8"));
     if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
     return raw;
   } catch {
@@ -313,16 +442,16 @@ function loadMeshConfig() {
   }
 }
 function saveMeshConfig(config) {
-  const path26 = getMeshConfigPath();
-  writeFileSync2(path26, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  const path27 = getMeshConfigPath();
+  writeFileSync2(path27, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function normalizeRepoIdentity(remoteUrl) {
   let identity = remoteUrl.trim();
   if (identity.startsWith("http://") || identity.startsWith("https://")) {
     try {
       const url = new URL(identity);
-      const path26 = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
-      return `${url.hostname}/${path26}`;
+      const path27 = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
+      return `${url.hostname}/${path27}`;
     } catch {
     }
   }
@@ -330,6 +459,18 @@ function normalizeRepoIdentity(remoteUrl) {
   if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
   return identity;
 }
+function mergeMeshPolicy(base, patch) {
+  const policy = { ...DEFAULT_MESH_POLICY, ...base || {}, ...patch || {} };
+  if (!["block", "warn", "checkpoint_then_continue"].includes(policy.dirtyWorkspaceBehavior)) {
+    policy.dirtyWorkspaceBehavior = "warn";
+  }
+  const maxParallelTasks = Number(policy.maxParallelTasks);
+  policy.maxParallelTasks = Number.isFinite(maxParallelTasks) ? Math.max(1, Math.min(8, Math.floor(maxParallelTasks))) : 2;
+  if (!SESSION_CLEANUP_MODES.has(String(policy.sessionCleanupOnNodeRemove))) {
+    policy.sessionCleanupOnNodeRemove = "preserve";
+  }
+  return policy;
+}
 function listMeshes() {
   return loadMeshConfig().meshes;
 }
@@ -353,7 +494,7 @@ function createMesh(opts) {
     repoIdentity,
     repoRemoteUrl: opts.repoRemoteUrl,
     defaultBranch: opts.defaultBranch,
-    policy: { ...DEFAULT_MESH_POLICY, ...opts.policy },
+    policy: mergeMeshPolicy(void 0, opts.policy),
     coordinator: opts.coordinator || {},
     nodes: [],
     createdAt: now,
@@ -369,7 +510,7 @@ function updateMesh(meshId, opts) {
   if (!mesh) return void 0;
   if (opts.name !== void 0) mesh.name = opts.name.trim().slice(0, 100);
   if (opts.defaultBranch !== void 0) mesh.defaultBranch = opts.defaultBranch;
-  if (opts.policy) mesh.policy = { ...mesh.policy, ...opts.policy };
+  if (opts.policy) mesh.policy = mergeMeshPolicy(mesh.policy, opts.policy);
   if (opts.coordinator) mesh.coordinator = opts.coordinator;
   mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   saveMeshConfig(config);
@@ -397,9 +538,12 @@ function addNode(meshId, opts) {
     id: `node_${randomUUID3().replace(/-/g, "")}`,
     workspace: opts.workspace.trim(),
     repoRoot: opts.repoRoot,
+    daemonId: opts.daemonId,
     userOverrides: opts.userOverrides || {},
     policy: opts.policy || {},
-    isLocalWorktree: opts.isLocalWorktree
+    isLocalWorktree: opts.isLocalWorktree,
+    worktreeBranch: opts.worktreeBranch,
+    clonedFromNodeId: opts.clonedFromNodeId
   };
   mesh.nodes.push(node);
   mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -429,11 +573,13 @@ function updateNode(meshId, nodeId, opts) {
   saveMeshConfig(config);
   return node;
 }
+var SESSION_CLEANUP_MODES;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
     "use strict";
     init_config();
     init_repo_mesh_types();
+    SESSION_CLEANUP_MODES = /* @__PURE__ */ new Set(["preserve", "stop", "delete_stopped", "stop_and_delete"]);
   }
 });
 
@@ -443,7 +589,7 @@ __export(coordinator_prompt_exports, {
   buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt
 });
 function buildCoordinatorSystemPrompt(ctx) {
-  const { mesh, status, userInstruction } = ctx;
+  const { mesh, status, userInstruction, coordinatorCliType } = ctx;
   const sections = [];
   sections.push(`You are a **Repo Mesh Coordinator** \u2014 a technical team lead who orchestrates work across multiple agent sessions on a shared Git repository.
 
@@ -457,15 +603,15 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
   } else {
     sections.push("## Nodes\nNo nodes configured yet. Ask the user to add nodes with `adhdev mesh add-node`.");
   }
-  sections.push(buildPolicySection(mesh.policy));
+  sections.push(buildPolicySection({ ...DEFAULT_MESH_POLICY, ...mesh.policy || {} }));
   sections.push(TOOLS_SECTION);
   sections.push(WORKFLOW_SECTION);
-  sections.push(RULES_SECTION);
+  sections.push(buildRulesSection(coordinatorCliType));
   if (userInstruction) {
     sections.push(`## Additional Context
 ${userInstruction}`);
   }
-  if (mesh.coordinator.systemPromptSuffix) {
+  if (mesh.coordinator?.systemPromptSuffix) {
     sections.push(mesh.coordinator.systemPromptSuffix);
   }
   return sections.join("\n\n");
@@ -510,10 +656,29 @@ function buildPolicySection(policy) {
   return `## Policy
 ${rules.join("\n")}`;
 }
-var TOOLS_SECTION, WORKFLOW_SECTION, RULES_SECTION;
+function buildRulesSection(coordinatorCliType) {
+  const coordinatorNote = coordinatorCliType ? `
+- **Coordinator runtime is not a delegation default.** This coordinator is running as \`${coordinatorCliType}\`, but delegated node sessions must follow the user's requested provider, not the coordinator's own runtime.` : "";
+  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.
+- **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.
+- **Don't inspect code.** Trust the agent's output. Verify via \`mesh_git_status\`, not by reading source files.
+- **Don't over-parallelize.** Start with 1-2 concurrent tasks. Scale up if they succeed.
+- **Handle failures gracefully.** If a task fails, read the chat to understand why, then retry or reassign.
+- **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.
+- **Clean up worktree nodes.** After a worktree task completes and its changes are merged or checkpointed, call \`mesh_remove_node\` to free resources.
+- **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
+}
+var TOOLS_SECTION, WORKFLOW_SECTION;
 var init_coordinator_prompt = __esm({
   "src/mesh/coordinator-prompt.ts"() {
     "use strict";
+    init_repo_mesh_types();
     TOOLS_SECTION = `## Available Tools
 
 | Tool | Purpose |
@@ -525,36 +690,29 @@ var init_coordinator_prompt = __esm({
 | \`mesh_read_chat\` | Read an agent's recent messages to check progress |
 | \`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 |`;
+| \`mesh_approve\` | Approve/reject a pending agent action |
+| \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
+| \`mesh_remove_node\` | Remove a node (cleans up worktree if applicable) |`;
     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 no session exists, call \`mesh_launch_session\` to start one.
-   c. 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.
+   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 Periodically call \`mesh_read_chat\` to check progress. Handle approvals via \`mesh_approve\`.
 5. **Verify** \u2014 When a task reports completion, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
-7. **Report** \u2014 Summarize what was done, what changed, and any issues.`;
-    RULES_SECTION = `## 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.
-- **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.
-- **Don't inspect code.** Trust the agent's output. Verify via \`mesh_git_status\`, not by reading source files.
-- **Don't over-parallelize.** Start with 1-2 concurrent tasks. Scale up if they succeed.
-- **Handle failures gracefully.** If a task fails, read the chat to understand why, then retry or reassign.
-- **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.`;
+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.`;
   }
 });
 
 // src/logging/logger.ts
 import * as fs2 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import * as os4 from "os";
 function setLogLevel(level) {
   currentLevel = level;
@@ -570,13 +728,13 @@ function getDaemonLogDir() {
   return LOG_DIR;
 }
 function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
-  return path9.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
+  return path10.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
 }
 function checkDateRotation() {
   const today = getDateStr();
   if (today !== currentDate) {
     currentDate = today;
-    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
+    currentLogFile = path10.join(LOG_DIR, `daemon-${currentDate}.log`);
     cleanOldLogs();
   }
 }
@@ -590,7 +748,7 @@ function cleanOldLogs() {
       const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path9.join(LOG_DIR, file));
+          fs2.unlinkSync(path10.join(LOG_DIR, file));
         } catch {
         }
       }
@@ -713,7 +871,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" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os4.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os4.homedir(), "Library", "Logs", "adhdev") : path9.join(os4.homedir(), ".local", "share", "adhdev", "logs");
+    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");
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
@@ -721,16 +879,16 @@ var init_logger = __esm({
     } catch {
     }
     currentDate = getDateStr();
-    currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
+    currentLogFile = path10.join(LOG_DIR, `daemon-${currentDate}.log`);
     cleanOldLogs();
     try {
-      const oldLog = path9.join(LOG_DIR, "daemon.log");
+      const oldLog = path10.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, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
+        fs2.renameSync(oldLog, path10.join(LOG_DIR, `daemon-${oldDate}.log`));
       }
-      const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
+      const oldLogBackup = path10.join(LOG_DIR, "daemon.log.old");
       if (fs2.existsSync(oldLogBackup)) {
         fs2.unlinkSync(oldLogBackup);
       }
@@ -762,7 +920,7 @@ var init_logger = __esm({
       }
     };
     interceptorInstalled = false;
-    LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    LOG_PATH = path10.join(LOG_DIR, `daemon-${getDateStr()}.log`);
   }
 });
 
@@ -1171,7 +1329,7 @@ var init_pty_transport = __esm({
 
 // src/cli-adapters/provider-cli-shared.ts
 import * as os9 from "os";
-import * as path13 from "path";
+import * as path14 from "path";
 import { execSync as execSync3 } from "child_process";
 function stripAnsi(str) {
   return str.replace(/\x1B\][^\x07]*\x07/g, "").replace(/\x1B\][\s\S]*?\x1B\\/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B\[\d*[A-HJKSTfG]/g, " ").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/  +/g, " ");
@@ -1236,9 +1394,9 @@ function buildCliScreenSnapshot(text) {
 function findBinary(name) {
   const trimmed = String(name || "").trim();
   if (!trimmed) return trimmed;
-  const expanded = trimmed.startsWith("~") ? path13.join(os9.homedir(), trimmed.slice(1)) : trimmed;
-  if (path13.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
-    return path13.isAbsolute(expanded) ? expanded : path13.resolve(expanded);
+  const expanded = trimmed.startsWith("~") ? path14.join(os9.homedir(), trimmed.slice(1)) : trimmed;
+  if (path14.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
+    return path14.isAbsolute(expanded) ? expanded : path14.resolve(expanded);
   }
   const isWin = os9.platform() === "win32";
   try {
@@ -1254,7 +1412,7 @@ function findBinary(name) {
   }
 }
 function isScriptBinary(binaryPath) {
-  if (!path13.isAbsolute(binaryPath)) return false;
+  if (!path14.isAbsolute(binaryPath)) return false;
   try {
     const fs16 = __require("fs");
     const resolved = fs16.realpathSync(binaryPath);
@@ -1270,7 +1428,7 @@ function isScriptBinary(binaryPath) {
   }
 }
 function looksLikeMachOOrElf(filePath) {
-  if (!path13.isAbsolute(filePath)) return false;
+  if (!path14.isAbsolute(filePath)) return false;
   try {
     const fs16 = __require("fs");
     const resolved = fs16.realpathSync(filePath);
@@ -1484,10 +1642,10 @@ var init_provider_cli_config = __esm({
 
 // src/cli-adapters/provider-cli-runtime.ts
 import * as os10 from "os";
-import * as path14 from "path";
+import * as path15 from "path";
 import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from "@adhdev/session-host-core";
 function resolveCliSpawnPlan(options) {
-  const { provider, runtimeSettings, workingDir, extraArgs } = options;
+  const { provider, runtimeSettings, workingDir, extraArgs, extraEnv } = options;
   const { spawn: spawnConfig } = provider;
   const configuredCommand = typeof runtimeSettings.executablePath === "string" && runtimeSettings.executablePath.trim() ? runtimeSettings.executablePath.trim() : spawnConfig.command;
   const binaryPath = findBinary(configuredCommand);
@@ -1495,9 +1653,9 @@ function resolveCliSpawnPlan(options) {
   const allArgs = [...spawnConfig.args, ...extraArgs];
   let shellCmd;
   let shellArgs;
-  const useShellUnix = !isWin && (!!spawnConfig.shell || !path14.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
+  const useShellUnix = !isWin && (!!spawnConfig.shell || !path15.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
   const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
-  const useShellWin = !!spawnConfig.shell || isCmdShim || !path14.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
+  const useShellWin = !!spawnConfig.shell || isCmdShim || !path15.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
   const useShell = isWin ? useShellWin : useShellUnix;
   if (useShell) {
     shellCmd = isWin ? "cmd.exe" : process.env.SHELL || "/bin/zsh";
@@ -1511,7 +1669,7 @@ function resolveCliSpawnPlan(options) {
     shellCmd = binaryPath;
     shellArgs = allArgs;
   }
-  const env = buildCliSpawnEnv(process.env, spawnConfig.env);
+  const env = buildCliSpawnEnv(process.env, { ...spawnConfig.env || {}, ...extraEnv || {} });
   env.TERMINAL_CWD = workingDir;
   return {
     binaryPath,
@@ -1610,8 +1768,9 @@ var init_provider_cli_adapter = __esm({
     init_provider_cli_runtime();
     init_provider_cli_shared();
     ProviderCliAdapter = class _ProviderCliAdapter {
-      constructor(provider, workingDir, extraArgs = [], transportFactory = new NodePtyTransportFactory()) {
+      constructor(provider, workingDir, extraArgs = [], extraEnv = {}, transportFactory = new NodePtyTransportFactory()) {
         this.extraArgs = extraArgs;
+        this.extraEnv = extraEnv;
         this.provider = provider;
         this.transportFactory = transportFactory;
         this.cliType = provider.type;
@@ -1762,8 +1921,9 @@ var init_provider_cli_adapter = __esm({
         const currentSnapshot = normalizeScreenSnapshot(screenText);
         const lastSnapshot = this.lastScreenSnapshot;
         if (!lastSnapshot || lastSnapshot === currentSnapshot) return screenText;
-        const staleSnapshotLooksActive = /\besc to (?:interrupt|stop)\b|Enter to interrupt, Ctrl\+C to cancel/i.test(lastSnapshot);
-        const currentScreenLooksIdle = /(?:^|\n|\r)\s*[❯›>]\s*(?:\n|\r|$)/.test(screenText) && !/\besc to (?:interrupt|stop)\b|Enter to interrupt, Ctrl\+C to cancel/i.test(screenText);
+        const activeScreenPattern = /\besc to (?:interrupt|stop)\b|Enter to interrupt, Ctrl\+C to cancel|Enter to confirm\s*[·•-]\s*Esc to cancel|\b(?:MCP servers?|tool calls?)\b[^\n\r]{0,160}\brequire approval\b/i;
+        const staleSnapshotLooksActive = activeScreenPattern.test(lastSnapshot);
+        const currentScreenLooksIdle = /(?:^|\n|\r)\s*[❯›>]\s*(?:Try\s+["“][^\n\r"”]+["”])?\s*(?:\n|\r|$)/.test(screenText) && !activeScreenPattern.test(screenText);
         if (staleSnapshotLooksActive && currentScreenLooksIdle) return screenText;
         if (currentSnapshot.length >= lastSnapshot.length) return screenText;
         return `${screenText}
@@ -1926,7 +2086,8 @@ ${lastSnapshot}`;
           provider: this.provider,
           runtimeSettings: this.runtimeSettings,
           workingDir: this.workingDir,
-          extraArgs: this.extraArgs
+          extraArgs: this.extraArgs,
+          extraEnv: this.extraEnv
         });
         LOG.info("CLI", `[${this.cliType}] Spawning in ${this.workingDir}`);
         this.resetTraceSession();
@@ -3124,9 +3285,8 @@ ${lastSnapshot}`;
           };
           this.recordTrace("submit_echo_missing", diagnostic);
           if (this.requirePromptEchoBeforeSubmit) {
-            const message = `${this.cliName} prompt echo was not observed on the PTY screen before submit`;
-            LOG.warn("CLI", `[${this.cliType}] ${message} elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs} screen=${JSON.stringify(diagnostic.screenText).slice(0, 240)}`);
-            completion.rejectOnce(new Error(message));
+            LOG.warn("CLI", `[${this.cliType}] prompt echo was not observed before submit; sending guarded submit key anyway elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs} screen=${JSON.stringify(diagnostic.screenText).slice(0, 240)}`);
+            this.submitSendKey(state, completion);
             return;
           }
           LOG.warn("CLI", `[${this.cliType}] prompt echo was not observed before submit; sending submit key anyway elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs}`);
@@ -4547,6 +4707,7 @@ var FAILURE_REASONS = /* @__PURE__ */ new Set([
   "dirty_index_required",
   "conflict",
   "invalid_args",
+  "nothing_to_commit",
   "git_command_failed"
 ]);
 function failure(reason, error) {
@@ -4791,7 +4952,10 @@ async function gitCheckpoint(workspace, message, includeUntracked) {
   } catch (err) {
     const output = (err?.stdout || "") + (err?.stderr || "");
     if (/nothing to commit/i.test(output)) {
-      throw new GitCommandError("git_command_failed", "Nothing to commit");
+      throw new GitCommandError("nothing_to_commit", "Nothing to commit \u2014 working tree is clean.", {
+        stdout: err?.stdout,
+        stderr: err?.stderr
+      });
     }
     throw err;
   }
@@ -4983,20 +5147,23 @@ var TurnSnapshotTracker = class {
   }
 };
 
+// src/git/index.ts
+init_git_worktree();
+
 // src/index.ts
 init_config();
 
 // src/config/workspaces.ts
 import * as fs from "fs";
 import * as os from "os";
-import * as path4 from "path";
+import * as path5 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var MAX_WORKSPACES = 50;
 function expandPath(p) {
   const t = (p || "").trim();
   if (!t) return "";
-  if (t.startsWith("~")) return path4.join(os.homedir(), t.slice(1).replace(/^\//, ""));
-  return path4.resolve(t);
+  if (t.startsWith("~")) return path5.join(os.homedir(), t.slice(1).replace(/^\//, ""));
+  return path5.resolve(t);
 }
 function validateWorkspacePath(absPath) {
   try {
@@ -5010,7 +5177,7 @@ function validateWorkspacePath(absPath) {
   }
 }
 function defaultWorkspaceLabel(absPath) {
-  const base = path4.basename(absPath) || absPath;
+  const base = path5.basename(absPath) || absPath;
   return base;
 }
 function getDefaultWorkspacePath(config) {
@@ -5101,9 +5268,9 @@ function resolveIdeLaunchWorkspace(args, config) {
   return getDefaultWorkspacePath(config) || void 0;
 }
 function findWorkspaceByPath(config, rawPath) {
-  const abs = path4.resolve(expandPath(rawPath));
+  const abs = path5.resolve(expandPath(rawPath));
   if (!abs) return void 0;
-  return (config.workspaces || []).find((w) => path4.resolve(expandPath(w.path)) === abs);
+  return (config.workspaces || []).find((w) => path5.resolve(expandPath(w.path)) === abs);
 }
 function addWorkspaceEntry(config, rawPath, label, options) {
   const abs = expandPath(rawPath);
@@ -5119,7 +5286,7 @@ function addWorkspaceEntry(config, rawPath, label, options) {
   const v = validateWorkspacePath(abs);
   if (!v.ok) return { error: v.error };
   const list = [...config.workspaces || []];
-  if (list.some((w) => path4.resolve(w.path) === abs)) {
+  if (list.some((w) => path5.resolve(w.path) === abs)) {
     return { error: "Workspace already in list" };
   }
   if (list.length >= MAX_WORKSPACES) {
@@ -5153,7 +5320,7 @@ function setDefaultWorkspaceId(config, id) {
 }
 
 // src/config/recent-activity.ts
-import * as path5 from "path";
+import * as path6 from "path";
 
 // src/providers/summary-metadata.ts
 function normalizeSummaryItem(item) {
@@ -5222,9 +5389,9 @@ var MAX_ACTIVITY = 30;
 function normalizeWorkspace(workspace) {
   if (!workspace) return "";
   try {
-    return path5.resolve(expandPath(workspace));
+    return path6.resolve(expandPath(workspace));
   } catch {
-    return path5.resolve(workspace);
+    return path6.resolve(workspace);
   }
 }
 function buildRecentActivityKey(entry) {
@@ -5392,14 +5559,14 @@ function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker
 }
 
 // src/config/saved-sessions.ts
-import * as path6 from "path";
+import * as path7 from "path";
 var MAX_SAVED_SESSIONS = 500;
 function normalizeWorkspace2(workspace) {
   if (!workspace) return "";
   try {
-    return path6.resolve(expandPath(workspace));
+    return path7.resolve(expandPath(workspace));
   } catch {
-    return path6.resolve(workspace);
+    return path7.resolve(workspace);
   }
 }
 function buildSavedProviderSessionKey(providerSessionId) {
@@ -5505,8 +5672,8 @@ async function syncMeshes(transport) {
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -5519,7 +5686,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join4(getConfigDir(), "state.json");
+  return join5(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -5555,7 +5722,7 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync4(statePath)) {
+  if (!existsSync5(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
@@ -5576,9 +5743,9 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { platform, homedir as homedir3 } from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -5597,10 +5764,10 @@ function getMergedDefinitions() {
 function findCliCommand(command) {
   const trimmed = String(command || "").trim();
   if (!trimmed) return null;
-  if (path7.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
-    const candidate = trimmed.startsWith("~") ? path7.join(homedir3(), trimmed.slice(1)) : trimmed;
-    const resolved = path7.isAbsolute(candidate) ? candidate : path7.resolve(candidate);
-    return existsSync5(resolved) ? resolved : 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;
   }
   try {
     const result = execSync(
@@ -5627,31 +5794,31 @@ function getIdeVersion(cliCommand) {
 function checkPathExists(paths) {
   const home = homedir3();
   for (const p of paths) {
-    const normalized = p.startsWith("~") ? path7.join(home, p.slice(1)) : p;
+    const normalized = p.startsWith("~") ? path8.join(home, p.slice(1)) : p;
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if (existsSync5(resolved)) return resolved;
+      if (existsSync6(resolved)) return resolved;
     } else {
-      if (existsSync5(normalized)) return normalized;
+      if (existsSync6(normalized)) return normalized;
     }
   }
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os21 = platform();
+  const os22 = platform();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
-    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os21] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os22] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os21 === "darwin") {
+    if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync5(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync6(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os21 === "win32") {
-      const { dirname: dirname8 } = await import("path");
-      const appDir = dirname8(appPath);
+    if (!resolvedCli && appPath && os22 === "win32") {
+      const { dirname: dirname9 } = await import("path");
+      const appDir = dirname9(appPath);
       const candidates = [
         `${appDir}\\\\bin\\\\${def.cli}.cmd`,
         `${appDir}\\\\bin\\\\${def.cli}`,
@@ -5660,13 +5827,13 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync5(c)) {
+        if (existsSync6(c)) {
           resolvedCli = c;
           break;
         }
       }
     }
-    const installed = os21 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os22 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
@@ -5685,8 +5852,8 @@ async function detectIDEs(providerLoader) {
 // src/detection/cli-detector.ts
 import { exec } from "child_process";
 import * as os2 from "os";
-import * as path8 from "path";
-import { existsSync as existsSync6 } from "fs";
+import * as path9 from "path";
+import { existsSync as existsSync7 } 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);
@@ -5698,19 +5865,19 @@ function shellQuote(value) {
 function expandHome(value) {
   const trimmed = value.trim();
   if (!trimmed.startsWith("~")) return trimmed;
-  return path8.join(os2.homedir(), trimmed.slice(1));
+  return path9.join(os2.homedir(), trimmed.slice(1));
 }
 function isExplicitCommandPath(command) {
   const trimmed = command.trim();
-  return path8.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+  return path9.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 = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
-    return existsSync6(candidate) ? candidate : null;
+    const candidate = path9.isAbsolute(expanded) ? expanded : path9.resolve(expanded);
+    return existsSync7(candidate) ? candidate : null;
   }
   return null;
 }
@@ -7978,9 +8145,9 @@ ${cleanBody}`;
 
 // src/config/chat-history.ts
 import * as fs3 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 import * as os5 from "os";
-var HISTORY_DIR = path10.join(os5.homedir(), ".adhdev", "history");
+var HISTORY_DIR = path11.join(os5.homedir(), ".adhdev", "history");
 var RETAIN_DAYS = 30;
 var SAVED_HISTORY_INDEX_VERSION = 1;
 var SAVED_HISTORY_INDEX_FILE = ".saved-history-index.json";
@@ -8143,7 +8310,7 @@ function extractSavedHistorySessionIdFromFile(file) {
 function buildSavedHistoryFileSignatureMap(dir, files) {
   return new Map(files.map((file) => {
     try {
-      const stat2 = fs3.statSync(path10.join(dir, file));
+      const stat2 = fs3.statSync(path11.join(dir, file));
       return [file, `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`];
     } catch {
       return [file, `${file}:missing`];
@@ -8154,7 +8321,7 @@ function buildSavedHistoryCacheSignature(files, fileSignatures) {
   return files.map((file) => fileSignatures.get(file) || `${file}:missing`).join("|");
 }
 function getSavedHistoryIndexFilePath(dir) {
-  return path10.join(dir, SAVED_HISTORY_INDEX_FILE);
+  return path11.join(dir, SAVED_HISTORY_INDEX_FILE);
 }
 function getSavedHistoryIndexLockPath(dir) {
   return `${getSavedHistoryIndexFilePath(dir)}${SAVED_HISTORY_INDEX_LOCK_SUFFIX}`;
@@ -8256,7 +8423,7 @@ function savePersistedSavedHistoryIndex(dir, entries) {
     }
     for (const file of Array.from(currentEntries.keys())) {
       if (incomingFiles.has(file)) continue;
-      if (!fs3.existsSync(path10.join(dir, file))) {
+      if (!fs3.existsSync(path11.join(dir, file))) {
         currentEntries.delete(file);
       }
     }
@@ -8282,7 +8449,7 @@ function historyDirectoryHasFilesNewerThanIndex(dir) {
     const indexStat = fs3.statSync(getSavedHistoryIndexFilePath(dir));
     const files = listHistoryFiles(dir);
     for (const file of files) {
-      const stat2 = fs3.statSync(path10.join(dir, file));
+      const stat2 = fs3.statSync(path11.join(dir, file));
       if (stat2.mtimeMs > indexStat.mtimeMs) return true;
     }
     return false;
@@ -8292,14 +8459,14 @@ function historyDirectoryHasFilesNewerThanIndex(dir) {
 }
 function buildSavedHistoryFileSignature(dir, file) {
   try {
-    const stat2 = fs3.statSync(path10.join(dir, file));
+    const stat2 = fs3.statSync(path11.join(dir, file));
     return `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
   } catch {
     return `${file}:missing`;
   }
 }
 function persistSavedHistoryFileSummaryEntry(agentType, dir, file, updater) {
-  const filePath = path10.join(dir, file);
+  const filePath = path11.join(dir, file);
   const result = withLockedPersistedSavedHistoryIndex(dir, (entries) => {
     const currentEntry = entries.get(file) || null;
     const nextSummary = updater(currentEntry?.summary || null);
@@ -8372,7 +8539,7 @@ function updateSavedHistoryIndexForAppendedMessages(agentType, dir, file, histor
 function computeSavedHistoryFileSummary(dir, file) {
   const historySessionId = extractSavedHistorySessionIdFromFile(file);
   if (!historySessionId) return null;
-  const filePath = path10.join(dir, file);
+  const filePath = path11.join(dir, file);
   const content = fs3.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter(Boolean);
   let messageCount = 0;
@@ -8459,7 +8626,7 @@ function computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatur
   const summaryBySessionId = /* @__PURE__ */ new Map();
   const nextPersistedEntries = /* @__PURE__ */ new Map();
   for (const file of files.slice().sort()) {
-    const filePath = path10.join(dir, file);
+    const filePath = path11.join(dir, file);
     const signature = fileSignatures.get(file) || `${file}:missing`;
     const cached = savedHistoryFileSummaryCache.get(filePath);
     const persisted = persistedEntries.get(file);
@@ -8579,12 +8746,12 @@ var ChatHistoryWriter = class {
         });
       }
       if (newMessages.length === 0) return;
-      const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
       fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
       const fileName = `${filePrefix}${date}.jsonl`;
-      const filePath = path10.join(dir, fileName);
+      const filePath = path11.join(dir, fileName);
       const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
       fs3.appendFileSync(filePath, lines, "utf-8");
       updateSavedHistoryIndexForAppendedMessages(agentType, dir, fileName, effectiveHistoryKey, newMessages);
@@ -8675,11 +8842,11 @@ var ChatHistoryWriter = class {
     const ws = String(workspace || "").trim();
     if (!id || !ws) return;
     try {
-      const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
       fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const fileName = `${this.sanitize(id)}_${date}.jsonl`;
-      const filePath = path10.join(dir, fileName);
+      const filePath = path11.join(dir, fileName);
       const record = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         receivedAt: Date.now(),
@@ -8725,14 +8892,14 @@ var ChatHistoryWriter = class {
         this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
         this.lastSeenCounts.delete(fromDedupKey);
       }
-      const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
       if (!fs3.existsSync(dir)) return;
       const fromPrefix = `${this.sanitize(fromId)}_`;
       const toPrefix = `${this.sanitize(toId)}_`;
       const files = fs3.readdirSync(dir).filter((file) => file.startsWith(fromPrefix) && file.endsWith(".jsonl"));
       for (const file of files) {
-        const sourcePath = path10.join(dir, file);
-        const targetPath = path10.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
+        const sourcePath = path11.join(dir, file);
+        const targetPath = path11.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
         const sourceLines = fs3.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
         const rewritten = sourceLines.map((line) => {
           try {
@@ -8766,13 +8933,13 @@ var ChatHistoryWriter = class {
     const sessionId = String(historySessionId || "").trim();
     if (!sessionId) return;
     try {
-      const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
       if (!fs3.existsSync(dir)) return;
       const prefix = `${this.sanitize(sessionId)}_`;
       const files = fs3.readdirSync(dir).filter((file) => file.startsWith(prefix) && file.endsWith(".jsonl")).sort();
       const seen = /* @__PURE__ */ new Set();
       for (const file of files) {
-        const filePath = path10.join(dir, file);
+        const filePath = path11.join(dir, file);
         const lines = fs3.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
         const next = [];
         for (const line of lines) {
@@ -8826,11 +8993,11 @@ var ChatHistoryWriter = class {
       const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
       const agentDirs = fs3.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
       for (const dir of agentDirs) {
-        const dirPath = path10.join(HISTORY_DIR, dir.name);
+        const dirPath = path11.join(HISTORY_DIR, dir.name);
         const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
         let removedAny = false;
         for (const file of files) {
-          const filePath = path10.join(dirPath, file);
+          const filePath = path11.join(dirPath, file);
           const stat2 = fs3.statSync(filePath);
           if (stat2.mtimeMs < cutoff) {
             fs3.unlinkSync(filePath);
@@ -8880,13 +9047,13 @@ function pageHistoryRecords(agentType, records, offset = 0, limit = 30, excludeR
 function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, excludeRecentCount = 0, historyBehavior) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const dir = path10.join(HISTORY_DIR, sanitized);
+    const dir = path11.join(HISTORY_DIR, sanitized);
     if (!fs3.existsSync(dir)) return { messages: [], hasMore: false };
     const files = listHistoryFiles(dir, historySessionId);
     const allMessages = [];
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
-      const filePath = path10.join(dir, file);
+      const filePath = path11.join(dir, file);
       const content = fs3.readFileSync(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
       for (let i = 0; i < lines.length; i++) {
@@ -8910,7 +9077,7 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
 function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const dir = path10.join(HISTORY_DIR, sanitized);
+    const dir = path11.join(HISTORY_DIR, sanitized);
     if (!fs3.existsSync(dir)) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
@@ -8971,11 +9138,11 @@ function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
 }
 function readExistingSessionStartRecord(agentType, historySessionId) {
   try {
-    const dir = path10.join(HISTORY_DIR, agentType);
+    const dir = path11.join(HISTORY_DIR, agentType);
     if (!fs3.existsSync(dir)) return null;
     const files = listHistoryFiles(dir, historySessionId).sort();
     for (const file of files) {
-      const lines = fs3.readFileSync(path10.join(dir, file), "utf-8").split("\n").filter(Boolean);
+      const lines = fs3.readFileSync(path11.join(dir, file), "utf-8").split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
@@ -8995,16 +9162,16 @@ function readExistingSessionStartRecord(agentType, historySessionId) {
 function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
   if (records.length === 0) return false;
   try {
-    const dir = path10.join(HISTORY_DIR, agentType);
+    const dir = path11.join(HISTORY_DIR, agentType);
     fs3.mkdirSync(dir, { recursive: true });
     const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
     for (const file of fs3.readdirSync(dir)) {
       if (file.startsWith(prefix) && file.endsWith(".jsonl")) {
-        fs3.unlinkSync(path10.join(dir, file));
+        fs3.unlinkSync(path11.join(dir, file));
       }
     }
     const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
-    const filePath = path10.join(dir, `${prefix}${targetDate}.jsonl`);
+    const filePath = path11.join(dir, `${prefix}${targetDate}.jsonl`);
     fs3.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
 `, "utf-8");
     invalidatePersistedSavedHistoryIndex(agentType, dir);
@@ -10999,6 +11166,14 @@ function getActiveChatOptions(profile) {
   if (profile === "full") return {};
   return LIVE_STATUS_ACTIVE_CHAT_OPTIONS;
 }
+function resolveSessionStatus(activeChat, providerStatus) {
+  const chatStatus = normalizeManagedStatus(activeChat?.status, { activeModal: activeChat?.activeModal || null });
+  const topLevelStatus = normalizeManagedStatus(providerStatus, { activeModal: activeChat?.activeModal || null });
+  if (chatStatus === "waiting_approval" || topLevelStatus === "waiting_approval") return "waiting_approval";
+  if (chatStatus === "generating" || topLevelStatus === "generating") return "generating";
+  if (topLevelStatus !== "idle") return topLevelStatus;
+  return chatStatus;
+}
 function shouldIncludeSessionControls(profile) {
   return profile !== "live";
 }
@@ -11077,9 +11252,7 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
     providerName: state.name,
     kind: "workspace",
     transport: "cdp-page",
-    status: normalizeManagedStatus(activeChat?.status || state.status, {
-      activeModal: activeChat?.activeModal || null
-    }),
+    status: resolveSessionStatus(activeChat, state.status),
     title,
     workspace,
     ...git && { git },
@@ -11114,9 +11287,7 @@ function buildExtensionAgentSession(parent, ext, options) {
     providerSessionId: ext.providerSessionId,
     kind: "agent",
     transport: "cdp-webview",
-    status: normalizeManagedStatus(activeChat?.status || ext.status, {
-      activeModal: activeChat?.activeModal || null
-    }),
+    status: resolveSessionStatus(activeChat, ext.status),
     title: activeChat?.title || ext.name,
     workspace,
     ...git && { git },
@@ -11166,9 +11337,7 @@ function buildCliSession(state, options) {
     providerSessionId: state.providerSessionId,
     kind: "agent",
     transport: "pty",
-    status: normalizeManagedStatus(activeChat?.status || state.status, {
-      activeModal: activeChat?.activeModal || null
-    }),
+    status: resolveSessionStatus(activeChat, state.status),
     title: activeChat?.title || state.name,
     workspace,
     ...git && { git },
@@ -11216,9 +11385,7 @@ function buildAcpSession(state, options) {
     providerName: state.name,
     kind: "agent",
     transport: "acp",
-    status: normalizeManagedStatus(activeChat?.status || state.status, {
-      activeModal: activeChat?.activeModal || null
-    }),
+    status: resolveSessionStatus(activeChat, state.status),
     title: activeChat?.title || state.name,
     workspace,
     ...git && { git },
@@ -11341,7 +11508,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 // src/commands/chat-commands.ts
 import * as fs4 from "fs";
 import * as os6 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/providers/provider-input-support.ts
@@ -11704,6 +11871,34 @@ function normalizeReadChatCommandStatus(status, activeModal) {
       return raw;
   }
 }
+function isGeneratingLikeStatus(status) {
+  return status === "generating" || status === "streaming" || status === "long_generating" || status === "starting";
+}
+function shouldTrustCliAdapterTerminalStatus(parsedStatus, activeModal, adapter, adapterStatus) {
+  if (!isGeneratingLikeStatus(parsedStatus)) return false;
+  if (hasNonEmptyModalButtons(activeModal)) return false;
+  const adapterRawStatus = typeof adapterStatus?.status === "string" ? adapterStatus.status.trim() : "";
+  if (adapterRawStatus !== "idle") return false;
+  if (typeof adapter.isProcessing === "function" && adapter.isProcessing()) return false;
+  return true;
+}
+function normalizeCliReadChatStatus(parsedStatus, activeModal, adapter, adapterStatus) {
+  if (shouldTrustCliAdapterTerminalStatus(parsedStatus, activeModal, adapter, adapterStatus)) return "idle";
+  return typeof parsedStatus === "string" && parsedStatus.trim() ? parsedStatus : "idle";
+}
+function finalizeStreamingMessagesWhenIdle(messages, status) {
+  if (status !== "idle") return messages;
+  return messages.map((message) => {
+    const meta = message.meta && typeof message.meta === "object" ? message.meta : void 0;
+    const hasStreamingMeta = meta?.streaming === true;
+    if (message.bubbleState !== "streaming" && !hasStreamingMeta) return message;
+    return {
+      ...message,
+      ...message.bubbleState === "streaming" ? { bubbleState: "final" } : {},
+      ...hasStreamingMeta ? { meta: { ...meta, streaming: false } } : {}
+    };
+  });
+}
 function buildReadChatCommandResult(payload, args) {
   let validatedPayload;
   const debugReadChat = payload?.debugReadChat && typeof payload.debugReadChat === "object" ? payload.debugReadChat : void 0;
@@ -11852,7 +12047,7 @@ function buildDebugBundleText(bundle) {
 }
 function getChatDebugBundleDir() {
   const override = typeof process.env.ADHDEV_DEBUG_BUNDLE_DIR === "string" ? process.env.ADHDEV_DEBUG_BUNDLE_DIR.trim() : "";
-  return override || path11.join(os6.homedir(), ".adhdev", "debug-bundles", "chat");
+  return override || path12.join(os6.homedir(), ".adhdev", "debug-bundles", "chat");
 }
 function safeBundleIdSegment(value, fallback) {
   const normalized = String(value || fallback).trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
@@ -11868,6 +12063,14 @@ function buildChatDebugBundleSummary(bundle) {
   const readChat = bundle.readChat && typeof bundle.readChat === "object" ? bundle.readChat : {};
   const cli = bundle.cli && typeof bundle.cli === "object" ? bundle.cli : null;
   const frontend = bundle.frontend && typeof bundle.frontend === "object" ? bundle.frontend : null;
+  const debugReadChat = readChat.debugReadChat && typeof readChat.debugReadChat === "object" ? readChat.debugReadChat : {};
+  const parsedStatus = cli?.parsedStatus && typeof cli.parsedStatus === "object" ? cli.parsedStatus : null;
+  const cliParsedMessageCount = Array.isArray(parsedStatus?.messages) ? parsedStatus.messages.length : void 0;
+  const readChatReturnedMessages = Array.isArray(readChat.messagesTail) ? readChat.messagesTail.length : void 0;
+  const cliPartialResponse = typeof cli?.partialResponse === "string" ? cli.partialResponse : "";
+  const readChatStatus = typeof readChat.status === "string" ? readChat.status : "";
+  const cliStatus = typeof cli?.status === "string" ? cli.status : "";
+  const cliParsedStatus = typeof parsedStatus?.status === "string" ? parsedStatus.status : "";
   return {
     createdAt: bundle.createdAt,
     targetSessionId: target.targetSessionId,
@@ -11876,8 +12079,22 @@ function buildChatDebugBundleSummary(bundle) {
     readChatSuccess: readChat.success,
     readChatStatus: readChat.status,
     readChatTotalMessages: readChat.totalMessages,
+    readChatReturnedMessages,
     cliStatus: cli?.status,
+    cliParsedStatus: cliParsedStatus || void 0,
     cliMessageCount: cli?.messageCount,
+    cliParsedMessageCount,
+    cliPartialResponseChars: cliPartialResponse.length,
+    parserAdapterStatusMismatch: Boolean(cliStatus && cliParsedStatus && cliStatus !== cliParsedStatus),
+    parserReadChatStatusMismatch: Boolean(readChatStatus && cliParsedStatus && readChatStatus !== cliParsedStatus),
+    readChatDebug: Object.keys(debugReadChat).length ? {
+      adapterStatus: debugReadChat.adapterStatus,
+      parsedStatus: debugReadChat.parsedStatus,
+      returnedStatus: debugReadChat.returnedStatus,
+      parsedMsgCount: debugReadChat.parsedMsgCount,
+      returnedMsgCount: debugReadChat.returnedMsgCount,
+      shouldPreferAdapterMessages: debugReadChat.shouldPreferAdapterMessages
+    } : void 0,
     hasFrontendSnapshot: !!frontend
   };
 }
@@ -11885,7 +12102,7 @@ function storeChatDebugBundleOnDaemon(bundle, targetSessionId) {
   const bundleId = createChatDebugBundleId(targetSessionId);
   const dir = getChatDebugBundleDir();
   fs4.mkdirSync(dir, { recursive: true });
-  const savedPath = path11.join(dir, `${bundleId}.json`);
+  const savedPath = path12.join(dir, `${bundleId}.json`);
   const json = `${JSON.stringify(bundle, null, 2)}
 `;
   fs4.writeFileSync(savedPath, json, { encoding: "utf8", mode: 384 });
@@ -12115,7 +12332,7 @@ async function handleChatHistory(h, args) {
   }
 }
 async function handleReadChat(h, args) {
-  const provider = h.getProvider(args?.agentType);
+  const provider = h.getProvider(args?.agentType || args?.providerType);
   const transport = getTargetTransport(h, provider);
   const historySessionId = getHistorySessionId(h, args);
   const _log = (msg) => LOG.debug("Command", `[read_chat] ${msg}`);
@@ -12142,10 +12359,13 @@ async function handleReadChat(h, args) {
       const transcriptAuthority = parsedRecord.transcriptAuthority === "provider" || parsedRecord.transcriptAuthority === "daemon" ? parsedRecord.transcriptAuthority : void 0;
       const coverage = parsedRecord.coverage === "full" || parsedRecord.coverage === "tail" || parsedRecord.coverage === "current-turn" ? parsedRecord.coverage : void 0;
       const activeModal = parsedRecord.activeModal ?? parsedRecord.modal ?? null;
-      const returnedStatus = parsedRecord.status || "idle";
-      LOG.debug("Command", `[read_chat] cli-like parsed provider=${adapter.cliType} target=${String(args?.targetSessionId || "")} adapterStatus=${String(adapterStatus.status || "")} parsedStatus=${String(parsedRecord.status || "")} parsedMsgCount=${parsedRecord.messages.length}`);
+      const returnedStatus = normalizeCliReadChatStatus(parsedRecord.status, activeModal, adapter, adapterStatus);
+      const runtimeMessageMerger = getTargetInstance(h, args);
+      const parsedMessages = finalizeStreamingMessagesWhenIdle(parsedRecord.messages, returnedStatus);
+      const returnedMessages = runtimeMessageMerger?.category === "cli" && runtimeMessageMerger.type === adapter.cliType && typeof runtimeMessageMerger.mergeRuntimeChatMessages === "function" ? runtimeMessageMerger.mergeRuntimeChatMessages(parsedMessages) : parsedMessages;
+      LOG.debug("Command", `[read_chat] cli-like parsed provider=${adapter.cliType} target=${String(args?.targetSessionId || "")} adapterStatus=${String(adapterStatus.status || "")} parsedStatus=${String(parsedRecord.status || "")} parsedMsgCount=${parsedRecord.messages.length} returnedMsgCount=${returnedMessages.length}`);
       return buildReadChatCommandResult({
-        messages: parsedRecord.messages,
+        messages: returnedMessages,
         status: returnedStatus,
         activeModal,
         debugReadChat: {
@@ -12156,7 +12376,7 @@ async function handleReadChat(h, args) {
           returnedStatus: String(returnedStatus || ""),
           shouldPreferAdapterMessages: false,
           parsedMsgCount: parsedRecord.messages.length,
-          returnedMsgCount: parsedRecord.messages.length
+          returnedMsgCount: returnedMessages.length
         },
         ...title ? { title } : {},
         ...providerSessionId ? { providerSessionId } : {},
@@ -13029,7 +13249,7 @@ async function handleResolveAction(h, args) {
 
 // src/commands/cdp-commands.ts
 import * as fs5 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 import * as os7 from "os";
 var KEY_TO_VK = {
   Backspace: 8,
@@ -13286,25 +13506,25 @@ function resolveSafePath(requestedPath) {
   const inputPath = rawPath || ".";
   const home = os7.homedir();
   if (inputPath.startsWith("~")) {
-    return path12.resolve(path12.join(home, inputPath.slice(1)));
+    return path13.resolve(path13.join(home, inputPath.slice(1)));
   }
   if (process.platform === "win32") {
     const normalized = normalizeWindowsRequestedPath(inputPath);
-    if (path12.win32.isAbsolute(normalized)) {
-      return path12.win32.normalize(normalized);
+    if (path13.win32.isAbsolute(normalized)) {
+      return path13.win32.normalize(normalized);
     }
-    return path12.win32.resolve(normalized);
+    return path13.win32.resolve(normalized);
   }
-  if (path12.isAbsolute(inputPath)) {
-    return path12.normalize(inputPath);
+  if (path13.isAbsolute(inputPath)) {
+    return path13.normalize(inputPath);
   }
-  return path12.resolve(inputPath);
+  return path13.resolve(inputPath);
 }
 function listDirectoryEntriesSafe(dirPath) {
   const entries = fs5.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path12.join(dirPath, entry.name);
+    const entryPath = path13.join(dirPath, entry.name);
     try {
       if (entry.isDirectory()) {
         files.push({ name: entry.name, type: "directory" });
@@ -13358,7 +13578,7 @@ async function handleFileRead(h, args) {
 async function handleFileWrite(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    fs5.mkdirSync(path12.dirname(filePath), { recursive: true });
+    fs5.mkdirSync(path13.dirname(filePath), { recursive: true });
     fs5.writeFileSync(filePath, args?.content || "", "utf-8");
     return { success: true, path: filePath };
   } catch (e) {
@@ -14142,9 +14362,11 @@ var DaemonCommandHandler = class {
     }
     const sessionLookupFailed = !!targetSessionId && !session;
     const managerKey = this.extractIdeType(args, sessionLookupFailed);
-    let providerType;
+    let providerType = args?.agentType || args?.providerType;
     if (!sessionLookupFailed) {
-      providerType = session?.providerType || args?.agentType || args?.providerType || this.inferProviderType(managerKey);
+      providerType = session?.providerType || providerType || this.inferProviderType(managerKey);
+    } else if (!providerType) {
+      providerType = this.inferProviderType(managerKey);
     }
     return { session, managerKey, providerType, sessionLookupFailed };
   }
@@ -14224,7 +14446,8 @@ var DaemonCommandHandler = class {
       "pty_resize",
       "invoke_provider_script"
     ]);
-    if (this._currentRoute.sessionLookupFailed && sessionScopedCommands.has(cmd)) {
+    const allowsInactiveReadChatFallback = cmd === "read_chat" && !!this._currentRoute.providerType && (typeof args?.providerSessionId === "string" && args.providerSessionId.trim().length > 0 || typeof args?.historySessionId === "string" && args.historySessionId.trim().length > 0);
+    if (this._currentRoute.sessionLookupFailed && sessionScopedCommands.has(cmd) && !allowsInactiveReadChatFallback) {
       const result2 = {
         success: false,
         error: `Live session not found for targetSessionId: ${String(args?.targetSessionId || "").trim() || "unknown"}`
@@ -14478,16 +14701,16 @@ var DaemonCommandHandler = class {
 // src/commands/cli-manager.ts
 init_provider_cli_adapter();
 import * as os13 from "os";
-import * as path16 from "path";
+import * as path17 from "path";
 import * as crypto4 from "crypto";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
 init_config();
 
 // src/providers/cli-provider-instance.ts
 import * as os12 from "os";
-import * as path15 from "path";
+import * as path16 from "path";
 import * as crypto3 from "crypto";
 import * as fs6 from "fs";
 import { createRequire } from "module";
@@ -14546,7 +14769,7 @@ function buildIncrementalHistoryAppendMessages(previousMessages, currentMessages
 var CachedDatabaseSync = null;
 function getDatabaseSync() {
   if (CachedDatabaseSync) return CachedDatabaseSync;
-  const requireFn = typeof __require === "function" ? __require : createRequire(path15.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
+  const requireFn = typeof __require === "function" ? __require : createRequire(path16.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
   const sqliteModule = requireFn(`node:${"sqlite"}`);
   CachedDatabaseSync = sqliteModule.DatabaseSync;
   if (!CachedDatabaseSync) {
@@ -14599,7 +14822,7 @@ var CliProviderInstance = class {
     this.providerSessionId = options?.providerSessionId;
     this.launchMode = options?.launchMode || "new";
     this.onProviderSessionResolved = options?.onProviderSessionResolved;
-    this.adapter = new ProviderCliAdapter(provider, workingDir, cliArgs, transportFactory);
+    this.adapter = new ProviderCliAdapter(provider, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
     this.monitor = new StatusMonitor();
     this.historyWriter = new ChatHistoryWriter();
   }
@@ -15076,7 +15299,19 @@ var CliProviderInstance = class {
     }
   }
   pushEvent(event) {
-    this.events.push(event);
+    const enrichedEvent = {
+      ...event,
+      instanceId: typeof event.instanceId === "string" && event.instanceId.trim() ? event.instanceId : this.instanceId,
+      targetSessionId: typeof event.targetSessionId === "string" && event.targetSessionId.trim() ? event.targetSessionId : this.instanceId,
+      providerType: typeof event.providerType === "string" && event.providerType.trim() ? event.providerType : this.type,
+      workspaceName: typeof event.workspaceName === "string" && event.workspaceName.trim() ? event.workspaceName : this.workingDir,
+      providerSessionId: typeof event.providerSessionId === "string" && event.providerSessionId.trim() ? event.providerSessionId : this.providerSessionId
+    };
+    if (this.context?.emitProviderEvent) {
+      this.context.emitProviderEvent(enrichedEvent);
+      return;
+    }
+    this.events.push(enrichedEvent);
   }
   flushEvents() {
     const events = [...this.events];
@@ -15283,12 +15518,31 @@ ${effect.notification.body || ""}`.trim();
       );
     }
   }
+  mergeRuntimeChatMessages(parsedMessages) {
+    return this.mergeConversationMessages(parsedMessages);
+  }
   mergeConversationMessages(parsedMessages) {
     if (this.runtimeMessages.length === 0) return normalizeChatMessages(parsedMessages);
-    return normalizeChatMessages([...parsedMessages, ...this.runtimeMessages.map((entry) => entry.message)].map((message, index) => ({ message, index })).sort((a, b) => {
-      const aTime = a.message.receivedAt || a.message.timestamp || 0;
-      const bTime = b.message.receivedAt || b.message.timestamp || 0;
-      if (aTime !== bTime) return aTime - bTime;
+    const parsedEntries = parsedMessages.map((message, index) => ({
+      message,
+      index,
+      source: "parsed"
+    }));
+    const runtimeEntries = this.runtimeMessages.map((entry, index) => ({
+      message: entry.message,
+      index: parsedMessages.length + index,
+      source: "runtime"
+    }));
+    const getTime = (message) => {
+      const value = typeof message.receivedAt === "number" ? message.receivedAt : typeof message.timestamp === "number" ? message.timestamp : 0;
+      return Number.isFinite(value) && value > 0 ? value : 0;
+    };
+    return normalizeChatMessages([...parsedEntries, ...runtimeEntries].sort((a, b) => {
+      const aTime = getTime(a.message);
+      const bTime = getTime(b.message);
+      if (aTime && bTime && aTime !== bTime) return aTime - bTime;
+      if (aTime && !bTime && a.source === "runtime" && b.source === "parsed") return -1;
+      if (!aTime && bTime && a.source === "parsed" && b.source === "runtime") return 1;
       return a.index - b.index;
     }).map((entry) => entry.message));
   }
@@ -16617,17 +16871,17 @@ function shouldRestoreHostedRuntime(record, managerTag) {
 // src/commands/cli-manager.ts
 function isExplicitCommand(command) {
   const trimmed = command.trim();
-  return path16.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+  return path17.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
 }
 function expandExecutable(command) {
   const trimmed = command.trim();
-  return trimmed.startsWith("~") ? path16.join(os13.homedir(), trimmed.slice(1)) : trimmed;
+  return trimmed.startsWith("~") ? path17.join(os13.homedir(), trimmed.slice(1)) : trimmed;
 }
 function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return existsSync11(expandExecutable(trimmed));
+    return existsSync12(expandExecutable(trimmed));
   }
   try {
     execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -16645,6 +16899,35 @@ function colorize(color, text) {
   const fn = chalkApi?.[color];
   return typeof fn === "function" ? fn(text) : text;
 }
+var COORDINATOR_DELEGATED_ENV_UNSETS = {
+  ADHDEV_INLINE_MESH: "",
+  ADHDEV_MCP_TRANSPORT: "",
+  ADHDEV_MESH_ID: "",
+  HERMES_EPHEMERAL_SYSTEM_PROMPT: ""
+};
+function hasCliArg(args, flag) {
+  return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+function ensureEmptyDelegatedMcpConfig(workspace) {
+  const baseDir = path17.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
+  mkdirSync7(baseDir, { recursive: true });
+  const workspaceHash = crypto4.createHash("sha256").update(path17.resolve(workspace || os13.tmpdir())).digest("hex").slice(0, 16);
+  const filePath = path17.join(baseDir, `${workspaceHash}.json`);
+  writeFileSync7(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  return filePath;
+}
+function buildCoordinatorDelegatedCliLaunchOptions(input) {
+  const cliType = String(input.cliType || "").trim();
+  const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
+  const env = { ...input.env || {}, ...COORDINATOR_DELEGATED_ENV_UNSETS };
+  if (cliType === "hermes-cli" && !hasCliArg(cliArgs, "--ignore-user-config")) {
+    cliArgs.unshift("--ignore-user-config");
+  }
+  if (cliType === "claude-cli" && !hasCliArg(cliArgs, "--mcp-config")) {
+    cliArgs.unshift("--mcp-config", ensureEmptyDelegatedMcpConfig(input.workspace));
+  }
+  return { cliArgs, env };
+}
 function isUuid(value) {
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
@@ -16815,7 +17098,7 @@ var DaemonCliManager = class {
       attachExisting
     }) || void 0;
   }
-  createAdapter(cliType, workingDir, cliArgs, runtimeId, providerSessionId, attachExisting = false) {
+  createAdapter(cliType, workingDir, cliArgs, runtimeId, providerSessionId, attachExisting = false, extraEnv) {
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getMeta(normalizedType);
     if (provider && provider.category === "cli" && provider.patterns && provider.spawn) {
@@ -16829,7 +17112,7 @@ var DaemonCliManager = class {
         providerSessionId,
         attachExisting
       );
-      return new ProviderCliAdapter(resolvedProvider, workingDir, cliArgs, transportFactory);
+      return new ProviderCliAdapter(resolvedProvider, workingDir, cliArgs, extraEnv || {}, transportFactory);
     }
     throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
   }
@@ -16902,7 +17185,7 @@ var DaemonCliManager = class {
   async startSession(cliType, workingDir, cliArgs, initialModel, options) {
     const trimmed = (workingDir || "").trim();
     if (!trimmed) throw new Error("working directory required");
-    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os13.homedir()) : path16.resolve(trimmed);
+    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os13.homedir()) : path17.resolve(trimmed);
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const rawProvider = this.providerLoader.getByAlias(cliType);
     const provider = rawProvider ? this.providerLoader.resolve(normalizedType) || rawProvider : void 0;
@@ -17032,6 +17315,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         {
           providerSessionId: sessionBinding.providerSessionId,
           launchMode: sessionBinding.launchMode,
+          extraEnv: options?.extraEnv,
           onProviderSessionResolved: ({ providerSessionId, providerName, providerType, workspace }) => {
             this.persistRecentActivity({
               kind: "cli",
@@ -17052,7 +17336,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         resolvedCliArgs,
         key,
         sessionBinding.providerSessionId,
-        false
+        false,
+        options?.extraEnv
       );
       try {
         await adapter.spawn();
@@ -17276,12 +17561,23 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const dir = resolved.path;
         const launchSource = resolved.source;
         if (!cliType) throw new Error("cliType required");
+        const settingsOverride = args?.settings && typeof args.settings === "object" ? args.settings : void 0;
+        const delegatedLaunch = settingsOverride?.launchedByCoordinator === true ? buildCoordinatorDelegatedCliLaunchOptions({
+          cliType,
+          workspace: dir,
+          cliArgs: args?.cliArgs,
+          env: args?.env
+        }) : null;
         const started = await this.startSession(
           cliType,
           dir,
-          args?.cliArgs,
+          delegatedLaunch ? delegatedLaunch.cliArgs : args?.cliArgs,
           args?.initialModel,
-          { resumeSessionId: args?.resumeSessionId, settingsOverride: args?.settings }
+          {
+            resumeSessionId: args?.resumeSessionId,
+            settingsOverride,
+            extraEnv: delegatedLaunch ? delegatedLaunch.env : args?.env
+          }
         );
         return {
           success: true,
@@ -17403,11 +17699,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
 import { execSync as execSync4, spawn as spawn2 } from "child_process";
 import * as net from "net";
 import * as os15 from "os";
-import * as path18 from "path";
+import * as path19 from "path";
 
 // src/providers/provider-loader.ts
 import * as fs7 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 import * as os14 from "os";
 import * as chokidar from "chokidar";
 init_logger();
@@ -17731,7 +18027,7 @@ var ProviderLoader = class _ProviderLoader {
     try {
       if (!fs7.existsSync(candidate) || !fs7.statSync(candidate).isDirectory()) return false;
       return ["ide", "extension", "cli", "acp"].some(
-        (category) => fs7.existsSync(path17.join(candidate, category))
+        (category) => fs7.existsSync(path18.join(candidate, category))
       );
     } catch {
       return false;
@@ -17739,20 +18035,20 @@ var ProviderLoader = class _ProviderLoader {
   }
   static hasProviderRootMarker(candidate) {
     try {
-      return fs7.existsSync(path17.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
+      return fs7.existsSync(path18.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
     } catch {
       return false;
     }
   }
   detectDefaultUserDir() {
-    const fallback = path17.join(os14.homedir(), ".adhdev", "providers");
+    const fallback = path18.join(os14.homedir(), ".adhdev", "providers");
     const envOptIn = process.env[_ProviderLoader.SIBLING_ENV_VAR] === "1";
     const visited = /* @__PURE__ */ new Set();
     for (const start of this.probeStarts) {
-      let current = path17.resolve(start);
+      let current = path18.resolve(start);
       while (!visited.has(current)) {
         visited.add(current);
-        const siblingCandidate = path17.join(path17.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
+        const siblingCandidate = path18.join(path18.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
         if (_ProviderLoader.looksLikeProviderRoot(siblingCandidate)) {
           const hasMarker = _ProviderLoader.hasProviderRootMarker(siblingCandidate);
           if (envOptIn || hasMarker) {
@@ -17774,7 +18070,7 @@ var ProviderLoader = class _ProviderLoader {
             return { path: siblingCandidate, source };
           }
         }
-        const parent = path17.dirname(current);
+        const parent = path18.dirname(current);
         if (parent === current) break;
         current = parent;
       }
@@ -17784,11 +18080,11 @@ var ProviderLoader = class _ProviderLoader {
   constructor(options) {
     this.logFn = options?.logFn || LOG.forComponent("Provider").asLogFn();
     this.probeStarts = options?.probeStarts ?? [process.cwd(), __dirname];
-    this.defaultProvidersDir = path17.join(os14.homedir(), ".adhdev", "providers");
+    this.defaultProvidersDir = path18.join(os14.homedir(), ".adhdev", "providers");
     const detected = this.detectDefaultUserDir();
     this.userDir = detected.path;
     this.userDirSource = detected.source;
-    this.upstreamDir = path17.join(this.defaultProvidersDir, ".upstream");
+    this.upstreamDir = path18.join(this.defaultProvidersDir, ".upstream");
     this.disableUpstream = false;
     this.applySourceConfig({
       userDir: options?.userDir,
@@ -17847,7 +18143,7 @@ var ProviderLoader = class _ProviderLoader {
       this.userDir = detected.path;
       this.userDirSource = detected.source;
     }
-    this.upstreamDir = path17.join(this.defaultProvidersDir, ".upstream");
+    this.upstreamDir = path18.join(this.defaultProvidersDir, ".upstream");
     this.disableUpstream = this.sourceMode === "no-upstream";
     if (this.explicitProviderDir) {
       this.log(`Config 'providerDir' applied: ${this.userDir}`);
@@ -17861,7 +18157,7 @@ var ProviderLoader = class _ProviderLoader {
   * Canonical provider directory shape for a given root.
   */
   getProviderDir(root, category, type) {
-    return path17.join(root, category, type);
+    return path18.join(root, category, type);
   }
   /**
   * Canonical user override directory for a provider.
@@ -17888,7 +18184,7 @@ var ProviderLoader = class _ProviderLoader {
   resolveProviderFile(type, ...segments) {
     const dir = this.findProviderDirInternal(type);
     if (!dir) return null;
-    return path17.join(dir, ...segments);
+    return path18.join(dir, ...segments);
   }
   /**
   * Load all providers (3-tier priority)
@@ -17927,7 +18223,7 @@ var ProviderLoader = class _ProviderLoader {
     if (!fs7.existsSync(this.upstreamDir)) return false;
     try {
       return fs7.readdirSync(this.upstreamDir).some(
-        (d) => fs7.statSync(path17.join(this.upstreamDir, d)).isDirectory()
+        (d) => fs7.statSync(path18.join(this.upstreamDir, d)).isDirectory()
       );
     } catch {
       return false;
@@ -18424,8 +18720,8 @@ var ProviderLoader = class _ProviderLoader {
               resolved._resolvedScriptDir = entry.scriptDir;
               resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
               if (providerDir) {
-                const fullDir = path17.join(providerDir, entry.scriptDir);
-                resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
+                const fullDir = path18.join(providerDir, entry.scriptDir);
+                resolved._resolvedScriptsPath = fs7.existsSync(path18.join(fullDir, "scripts.js")) ? path18.join(fullDir, "scripts.js") : fullDir;
               }
               matched = true;
             }
@@ -18440,8 +18736,8 @@ var ProviderLoader = class _ProviderLoader {
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
             if (providerDir) {
-              const fullDir = path17.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
+              const fullDir = path18.join(providerDir, base.defaultScriptDir);
+              resolved._resolvedScriptsPath = fs7.existsSync(path18.join(fullDir, "scripts.js")) ? path18.join(fullDir, "scripts.js") : fullDir;
             }
           }
           resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -18458,8 +18754,8 @@ var ProviderLoader = class _ProviderLoader {
               resolved._resolvedScriptDir = dirOverride;
               resolved._resolvedScriptsSource = `versions:${range}`;
               if (providerDir) {
-                const fullDir = path17.join(providerDir, dirOverride);
-                resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
+                const fullDir = path18.join(providerDir, dirOverride);
+                resolved._resolvedScriptsPath = fs7.existsSync(path18.join(fullDir, "scripts.js")) ? path18.join(fullDir, "scripts.js") : fullDir;
               }
             }
           } else if (override.scripts) {
@@ -18475,8 +18771,8 @@ var ProviderLoader = class _ProviderLoader {
         resolved._resolvedScriptDir = base.defaultScriptDir;
         resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
         if (providerDir) {
-          const fullDir = path17.join(providerDir, base.defaultScriptDir);
-          resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
+          const fullDir = path18.join(providerDir, base.defaultScriptDir);
+          resolved._resolvedScriptsPath = fs7.existsSync(path18.join(fullDir, "scripts.js")) ? path18.join(fullDir, "scripts.js") : fullDir;
         }
       }
     }
@@ -18508,14 +18804,14 @@ var ProviderLoader = class _ProviderLoader {
       this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
       return null;
     }
-    const dir = path17.join(providerDir, scriptDir);
+    const dir = path18.join(providerDir, scriptDir);
     if (!fs7.existsSync(dir)) {
       this.log(`  [loadScriptsFromDir] ${type}: dir not found: ${dir}`);
       return null;
     }
     const cached = this.scriptsCache.get(dir);
     if (cached) return cached;
-    const scriptsJs = path17.join(dir, "scripts.js");
+    const scriptsJs = path18.join(dir, "scripts.js");
     if (fs7.existsSync(scriptsJs)) {
       try {
         delete __require.cache[__require.resolve(scriptsJs)];
@@ -18557,7 +18853,7 @@ var ProviderLoader = class _ProviderLoader {
             return;
           }
           if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
-            this.log(`File changed: ${path17.basename(filePath)}, reloading...`);
+            this.log(`File changed: ${path18.basename(filePath)}, reloading...`);
             this.reload();
           }
         };
@@ -18612,7 +18908,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     const https = __require("https");
     const { execSync: execSync7 } = __require("child_process");
-    const metaPath = path17.join(this.upstreamDir, _ProviderLoader.META_FILE);
+    const metaPath = path18.join(this.upstreamDir, _ProviderLoader.META_FILE);
     let prevEtag = "";
     let prevTimestamp = 0;
     try {
@@ -18672,17 +18968,17 @@ var ProviderLoader = class _ProviderLoader {
         return { updated: false };
       }
       this.log("Downloading latest providers from GitHub...");
-      const tmpTar = path17.join(os14.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
-      const tmpExtract = path17.join(os14.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
+      const tmpTar = path18.join(os14.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
+      const tmpExtract = path18.join(os14.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
       await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
       fs7.mkdirSync(tmpExtract, { recursive: true });
       execSync7(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
       const extracted = fs7.readdirSync(tmpExtract);
       const rootDir = extracted.find(
-        (d) => fs7.statSync(path17.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+        (d) => fs7.statSync(path18.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
       );
       if (!rootDir) throw new Error("Unexpected tarball structure");
-      const sourceDir = path17.join(tmpExtract, rootDir);
+      const sourceDir = path18.join(tmpExtract, rootDir);
       const backupDir = this.upstreamDir + ".bak";
       if (fs7.existsSync(this.upstreamDir)) {
         if (fs7.existsSync(backupDir)) fs7.rmSync(backupDir, { recursive: true, force: true });
@@ -18757,8 +19053,8 @@ var ProviderLoader = class _ProviderLoader {
   copyDirRecursive(src, dest) {
     fs7.mkdirSync(dest, { recursive: true });
     for (const entry of fs7.readdirSync(src, { withFileTypes: true })) {
-      const srcPath = path17.join(src, entry.name);
-      const destPath = path17.join(dest, entry.name);
+      const srcPath = path18.join(src, entry.name);
+      const destPath = path18.join(dest, entry.name);
       if (entry.isDirectory()) {
         this.copyDirRecursive(srcPath, destPath);
       } else {
@@ -18769,7 +19065,7 @@ var ProviderLoader = class _ProviderLoader {
   /** .meta.json save */
   writeMeta(metaPath, etag, timestamp) {
     try {
-      fs7.mkdirSync(path17.dirname(metaPath), { recursive: true });
+      fs7.mkdirSync(path18.dirname(metaPath), { recursive: true });
       fs7.writeFileSync(metaPath, JSON.stringify({
         etag,
         timestamp,
@@ -18786,7 +19082,7 @@ var ProviderLoader = class _ProviderLoader {
     const scan = (d) => {
       try {
         for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-          if (entry.isDirectory()) scan(path17.join(d, entry.name));
+          if (entry.isDirectory()) scan(path18.join(d, entry.name));
           else if (entry.name === "provider.json") count++;
         }
       } catch {
@@ -19014,17 +19310,17 @@ var ProviderLoader = class _ProviderLoader {
     for (const root of searchRoots) {
       if (!fs7.existsSync(root)) continue;
       const candidate = this.getProviderDir(root, cat, type);
-      if (fs7.existsSync(path17.join(candidate, "provider.json"))) return candidate;
-      const catDir = path17.join(root, cat);
+      if (fs7.existsSync(path18.join(candidate, "provider.json"))) return candidate;
+      const catDir = path18.join(root, cat);
       if (fs7.existsSync(catDir)) {
         try {
           for (const entry of fs7.readdirSync(catDir, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const jsonPath = path17.join(catDir, entry.name, "provider.json");
+            const jsonPath = path18.join(catDir, entry.name, "provider.json");
             if (fs7.existsSync(jsonPath)) {
               try {
                 const data = JSON.parse(fs7.readFileSync(jsonPath, "utf-8"));
-                if (data.type === type) return path17.join(catDir, entry.name);
+                if (data.type === type) return path18.join(catDir, entry.name);
               } catch {
               }
             }
@@ -19041,7 +19337,7 @@ var ProviderLoader = class _ProviderLoader {
    * (template substitution is NOT applied here — scripts.js handles that)
    */
   buildScriptWrappersFromDir(dir) {
-    const scriptsJs = path17.join(dir, "scripts.js");
+    const scriptsJs = path18.join(dir, "scripts.js");
     if (fs7.existsSync(scriptsJs)) {
       try {
         delete __require.cache[__require.resolve(scriptsJs)];
@@ -19055,7 +19351,7 @@ var ProviderLoader = class _ProviderLoader {
       for (const file of fs7.readdirSync(dir)) {
         if (!file.endsWith(".js")) continue;
         const scriptName = toCamel(file.replace(".js", ""));
-        const filePath = path17.join(dir, file);
+        const filePath = path18.join(dir, file);
         result[scriptName] = (...args) => {
           try {
             let content = fs7.readFileSync(filePath, "utf-8");
@@ -19115,7 +19411,7 @@ var ProviderLoader = class _ProviderLoader {
       }
       const hasJson = entries.some((e) => e.name === "provider.json");
       if (hasJson) {
-        const jsonPath = path17.join(d, "provider.json");
+        const jsonPath = path18.join(d, "provider.json");
         try {
           const raw = fs7.readFileSync(jsonPath, "utf-8");
           const mod = JSON.parse(raw);
@@ -19136,7 +19432,7 @@ var ProviderLoader = class _ProviderLoader {
             this.log(`\u26A0 Invalid provider at ${jsonPath}: ${validation.errors.join("; ")}`);
           } else {
             const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
-            const scriptsPath = path17.join(d, "scripts.js");
+            const scriptsPath = path18.join(d, "scripts.js");
             if (!hasCompatibility && fs7.existsSync(scriptsPath)) {
               try {
                 delete __require.cache[__require.resolve(scriptsPath)];
@@ -19162,7 +19458,7 @@ var ProviderLoader = class _ProviderLoader {
           if (!entry.isDirectory()) continue;
           if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
           if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-          scan(path17.join(d, entry.name));
+          scan(path18.join(d, entry.name));
         }
       }
     };
@@ -19487,8 +19783,8 @@ function detectCurrentWorkspace(ideId) {
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
-        const storagePath = path18.join(
-          process.env.APPDATA || path18.join(os15.homedir(), "AppData", "Roaming"),
+        const storagePath = path19.join(
+          process.env.APPDATA || path19.join(os15.homedir(), "AppData", "Roaming"),
           appName,
           "storage.json"
         );
@@ -19677,9 +19973,9 @@ init_logger();
 
 // src/logging/command-log.ts
 import * as fs8 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 import * as os16 from "os";
-var LOG_DIR2 = process.platform === "win32" ? path19.join(process.env.LOCALAPPDATA || process.env.APPDATA || path19.join(os16.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path19.join(os16.homedir(), "Library", "Logs", "adhdev") : path19.join(os16.homedir(), ".local", "share", "adhdev", "logs");
+var LOG_DIR2 = process.platform === "win32" ? path20.join(process.env.LOCALAPPDATA || process.env.APPDATA || path20.join(os16.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path20.join(os16.homedir(), "Library", "Logs", "adhdev") : path20.join(os16.homedir(), ".local", "share", "adhdev", "logs");
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_DAYS = 7;
 try {
@@ -19717,13 +20013,13 @@ function getDateStr2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 var currentDate2 = getDateStr2();
-var currentFile = path19.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+var currentFile = path20.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
 var writeCount2 = 0;
 function checkRotation() {
   const today = getDateStr2();
   if (today !== currentDate2) {
     currentDate2 = today;
-    currentFile = path19.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    currentFile = path20.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     cleanOldFiles();
   }
 }
@@ -19737,7 +20033,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs8.unlinkSync(path19.join(LOG_DIR2, file));
+          fs8.unlinkSync(path20.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -19821,13 +20117,65 @@ cleanOldFiles();
 
 // src/commands/router.ts
 init_logger();
+import * as yaml from "js-yaml";
 
 // src/commands/mesh-coordinator.ts
-import { existsSync as existsSync14, realpathSync as realpathSync2 } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync15, readdirSync as readdirSync6, realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname3, join as join17, resolve as resolve13 } from "path";
+import * as os17 from "os";
+import { dirname as dirname4, isAbsolute as isAbsolute10, join as join18, resolve as resolve13 } from "path";
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
+var HERMES_CLI_TYPE = "hermes-cli";
+var HERMES_MCP_CONFIG_PATH = "~/.hermes/config.yaml";
+function isHermesProvider(provider, cliType) {
+  const type = cliType?.trim() || provider?.type?.trim() || "";
+  return type === HERMES_CLI_TYPE;
+}
+function resolveHermesMeshCoordinatorSetup(options) {
+  const mcpServer = resolveAdhdevMcpServerLaunch({
+    meshId: options.meshId,
+    nodeExecutable: options.nodeExecutable,
+    adhdevMcpEntryPath: options.adhdevMcpEntryPath
+  });
+  if (!mcpServer) {
+    return {
+      kind: "unsupported",
+      reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
+    };
+  }
+  const configPath = resolveMcpConfigPath(HERMES_MCP_CONFIG_PATH, options.workspace);
+  if (!configPath.trim()) {
+    return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
+  }
+  return {
+    kind: "auto_import",
+    serverName: DEFAULT_SERVER_NAME,
+    configPath,
+    configFormat: "hermes_config_yaml",
+    mcpServer
+  };
+}
+function createHermesManualMeshCoordinatorSetup(meshId, workspace) {
+  return {
+    kind: "manual",
+    serverName: DEFAULT_SERVER_NAME,
+    configFormat: "hermes_config_yaml",
+    configPathCommand: HERMES_MCP_CONFIG_PATH,
+    requiresRestart: true,
+    instructions: "Hermes CLI does not auto-import repo-local .mcp.json. Add this MCP server to Hermes config under mcp_servers, then start a fresh Hermes session.",
+    template: renderMeshCoordinatorTemplate(
+      "mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n",
+      {
+        meshId,
+        workspace,
+        serverName: DEFAULT_SERVER_NAME,
+        adhdevMcpCommand: DEFAULT_ADHDEV_MCP_COMMAND
+      }
+    )
+  };
+}
 function resolveMeshCoordinatorSetup(options) {
   const { provider, meshId, workspace } = options;
   const config = provider?.meshCoordinator;
@@ -19837,6 +20185,9 @@ function resolveMeshCoordinatorSetup(options) {
       reason: config?.reason || "Provider does not declare Repo Mesh coordinator support"
     };
   }
+  if (isHermesProvider(provider, options.cliType)) {
+    return resolveHermesMeshCoordinatorSetup(options);
+  }
   const mcpConfig = config.mcpConfig;
   if (!mcpConfig || mcpConfig.mode === "none") {
     return {
@@ -19846,8 +20197,8 @@ function resolveMeshCoordinatorSetup(options) {
   }
   const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
   if (mcpConfig.mode === "auto_import") {
-    const path26 = mcpConfig.path?.trim();
-    if (!path26) {
+    const path27 = mcpConfig.path?.trim();
+    if (!path27) {
       return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
     }
     const mcpServer = resolveAdhdevMcpServerLaunch({
@@ -19858,13 +20209,13 @@ function resolveMeshCoordinatorSetup(options) {
     if (!mcpServer) {
       return {
         kind: "unsupported",
-        reason: "Could not resolve the ADHDev MCP server entrypoint without relying on a PATH bin shim"
+        reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
       };
     }
     return {
       kind: "auto_import",
       serverName,
-      configPath: join17(workspace, path26),
+      configPath: resolveMcpConfigPath(path27, workspace),
       configFormat: mcpConfig.format,
       mcpServer
     };
@@ -19898,14 +20249,85 @@ function resolveMeshCoordinatorSetup(options) {
 function renderMeshCoordinatorTemplate(template, values) {
   return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key) => values[key] || "");
 }
+function resolveMcpConfigPath(configPath, workspace) {
+  const trimmed = configPath.trim();
+  if (trimmed === "~") return os17.homedir();
+  if (trimmed.startsWith("~/")) return join18(os17.homedir(), trimmed.slice(2));
+  if (isAbsolute10(trimmed)) return trimmed;
+  return join18(workspace, trimmed);
+}
 function resolveAdhdevMcpServerLaunch(options) {
   const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
   if (!entryPath) return null;
+  const nodeExecutable = resolveMcpNodeExecutable(options.nodeExecutable);
+  if (!nodeExecutable) return null;
   return {
-    command: options.nodeExecutable?.trim() || process.execPath,
-    args: [entryPath, "--repo-mesh", options.meshId]
+    command: nodeExecutable,
+    args: [entryPath, "--mode", "ipc", "--repo-mesh", options.meshId]
   };
 }
+function resolveMcpNodeExecutable(explicitExecutable) {
+  const explicit = explicitExecutable?.trim();
+  if (explicit) return explicit;
+  const candidates = [];
+  const addCandidate = (candidate) => {
+    const trimmed = candidate?.trim();
+    if (!trimmed) return;
+    const normalized = normalizeExistingPath(trimmed) || trimmed;
+    if (!candidates.includes(normalized)) candidates.push(normalized);
+  };
+  addCandidate(process.env.ADHDEV_MCP_NODE_EXECUTABLE);
+  addCandidate(process.env.ADHDEV_NODE_EXECUTABLE);
+  addCandidate(process.env.npm_node_execpath);
+  addNodeCandidatesFromPath(process.env.PATH, addCandidate);
+  addNodeCandidatesFromNvm(os17.homedir(), addCandidate);
+  addCandidate("/opt/homebrew/bin/node");
+  addCandidate("/usr/local/bin/node");
+  addCandidate("/usr/bin/node");
+  addCandidate(process.execPath);
+  for (const candidate of candidates) {
+    if (nodeRuntimeSupportsWebSocket(candidate)) return candidate;
+  }
+  return null;
+}
+function addNodeCandidatesFromPath(pathValue, addCandidate) {
+  for (const entry of (pathValue || "").split(":")) {
+    const dir = entry.trim();
+    if (!dir) continue;
+    addCandidate(join18(dir, "node"));
+  }
+}
+function addNodeCandidatesFromNvm(homeDir, addCandidate) {
+  const versionsDir = join18(homeDir, ".nvm", "versions", "node");
+  try {
+    const versionDirs = readdirSync6(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareNodeVersionNamesDescending);
+    for (const versionDir of versionDirs) {
+      addCandidate(join18(versionsDir, versionDir, "bin", "node"));
+    }
+  } catch {
+  }
+}
+function compareNodeVersionNamesDescending(a, b) {
+  const parse = (value) => value.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = parse(a);
+  const right = parse(b);
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const diff = (right[i] || 0) - (left[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return b.localeCompare(a);
+}
+function nodeRuntimeSupportsWebSocket(nodeExecutable) {
+  try {
+    execFileSync2(nodeExecutable, ["-e", "process.exit(typeof WebSocket === 'function' ? 0 : 42)"], {
+      stdio: "ignore",
+      timeout: 3e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function resolveAdhdevMcpEntryPath(explicitPath) {
   const explicit = explicitPath?.trim();
   if (explicit) return normalizeExistingPath(explicit) || explicit;
@@ -19918,7 +20340,7 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
   const addPackagedCandidates = (baseFile) => {
     if (!baseFile) return;
     const realBase = normalizeExistingPath(baseFile) || baseFile;
-    const dir = dirname3(realBase);
+    const dir = dirname4(realBase);
     addCandidate(resolve13(dir, "../vendor/mcp-server/index.js"));
     addCandidate(resolve13(dir, "../../vendor/mcp-server/index.js"));
     addCandidate(resolve13(dir, "../../../vendor/mcp-server/index.js"));
@@ -19931,7 +20353,7 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
     if (normalized) return normalized;
   }
   try {
-    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join17(process.cwd(), "adhdev-daemon.js");
+    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join18(process.cwd(), "adhdev-daemon.js");
     const req = createRequire2(requireBase);
     const resolvedModule = req.resolve("@adhdev/mcp-server");
     return normalizeExistingPath(resolvedModule) || resolvedModule;
@@ -19941,16 +20363,110 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
 }
 function normalizeExistingPath(filePath) {
   try {
-    if (!existsSync14(filePath)) return null;
+    if (!existsSync15(filePath)) return null;
     return realpathSync2.native(filePath);
   } catch {
     return null;
   }
 }
 
+// src/mesh/mesh-events.ts
+init_mesh_config();
+init_logger();
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+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}. You may use mesh_read_chat to review its progress.`;
+  }
+  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.`;
+  }
+  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) 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 (eventName !== "agent:generating_completed" && eventName !== "agent:waiting_approval") {
+    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 (event.event !== "agent:generating_completed" && event.event !== "agent:waiting_approval") 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 : {};
+    const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
+    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/status/snapshot.ts
 init_config();
-import * as os17 from "os";
+import * as os18 from "os";
 init_terminal_screen();
 init_logger();
 var READ_DEBUG_ENABLED = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
@@ -20005,8 +20521,8 @@ function buildAvailableProviders(providerLoader) {
 }
 function buildMachineInfo(profile = "full") {
   const base = {
-    hostname: os17.hostname(),
-    platform: os17.platform()
+    hostname: os18.hostname(),
+    platform: os18.platform()
   };
   if (profile === "live") {
     return base;
@@ -20015,23 +20531,23 @@ function buildMachineInfo(profile = "full") {
     const memSnap2 = getHostMemorySnapshot();
     return {
       ...base,
-      arch: os17.arch(),
-      cpus: os17.cpus().length,
+      arch: os18.arch(),
+      cpus: os18.cpus().length,
       totalMem: memSnap2.totalMem,
-      release: os17.release()
+      release: os18.release()
     };
   }
   const memSnap = getHostMemorySnapshot();
   return {
     ...base,
-    arch: os17.arch(),
-    cpus: os17.cpus().length,
+    arch: os18.arch(),
+    cpus: os18.cpus().length,
     totalMem: memSnap.totalMem,
     freeMem: memSnap.freeMem,
     availableMem: memSnap.availableMem,
-    loadavg: os17.loadavg(),
-    uptime: os17.uptime(),
-    release: os17.release()
+    loadavg: os18.loadavg(),
+    uptime: os18.uptime(),
+    release: os18.release()
   };
 }
 function parseMessageTime(value) {
@@ -20262,17 +20778,17 @@ function buildStatusSnapshot(options) {
 }
 
 // src/commands/upgrade-helper.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import { spawn as spawn3 } from "child_process";
 import * as fs9 from "fs";
-import * as os18 from "os";
-import * as path20 from "path";
+import * as os19 from "os";
+import * as path21 from "path";
 var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
 function getUpgradeLogPath() {
-  const home = os18.homedir();
-  const dir = path20.join(home, ".adhdev");
+  const home = os19.homedir();
+  const dir = path21.join(home, ".adhdev");
   fs9.mkdirSync(dir, { recursive: true });
-  return path20.join(dir, "daemon-upgrade.log");
+  return path21.join(dir, "daemon-upgrade.log");
 }
 function appendUpgradeLog(message) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
@@ -20283,14 +20799,14 @@ function appendUpgradeLog(message) {
   }
 }
 function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platform) {
-  const binDir = path20.dirname(nodeExecutable);
+  const binDir = path21.dirname(nodeExecutable);
   if (platform10 === "win32") {
-    const npmCliPath = path20.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
+    const npmCliPath = path21.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
     if (fs9.existsSync(npmCliPath)) {
       return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
     }
     for (const candidate of ["npm.exe", "npm"]) {
-      const candidatePath = path20.join(binDir, candidate);
+      const candidatePath = path21.join(binDir, candidate);
       if (fs9.existsSync(candidatePath)) {
         return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
       }
@@ -20298,7 +20814,7 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
     return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
   }
   for (const candidate of ["npm"]) {
-    const candidatePath = path20.join(binDir, candidate);
+    const candidatePath = path21.join(binDir, candidate);
     if (fs9.existsSync(candidatePath)) {
       return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
     }
@@ -20315,13 +20831,13 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   let currentDir = resolvedPath;
   try {
     if (fs9.statSync(resolvedPath).isFile()) {
-      currentDir = path20.dirname(resolvedPath);
+      currentDir = path21.dirname(resolvedPath);
     }
   } catch {
-    currentDir = path20.dirname(resolvedPath);
+    currentDir = path21.dirname(resolvedPath);
   }
   while (true) {
-    const packageJsonPath = path20.join(currentDir, "package.json");
+    const packageJsonPath = path21.join(currentDir, "package.json");
     try {
       if (fs9.existsSync(packageJsonPath)) {
         const parsed = JSON.parse(fs9.readFileSync(packageJsonPath, "utf8"));
@@ -20332,7 +20848,7 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
       }
     } catch {
     }
-    const parentDir = path20.dirname(currentDir);
+    const parentDir = path21.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -20340,13 +20856,13 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   }
 }
 function resolveInstallPrefixFromPackageRoot(packageRoot, packageName) {
-  const nodeModulesDir = packageName.startsWith("@") ? path20.dirname(path20.dirname(packageRoot)) : path20.dirname(packageRoot);
-  if (path20.basename(nodeModulesDir) !== "node_modules") {
+  const nodeModulesDir = packageName.startsWith("@") ? path21.dirname(path21.dirname(packageRoot)) : path21.dirname(packageRoot);
+  if (path21.basename(nodeModulesDir) !== "node_modules") {
     return null;
   }
-  const maybeLibDir = path20.dirname(nodeModulesDir);
-  if (path20.basename(maybeLibDir) === "lib") {
-    return path20.dirname(maybeLibDir);
+  const maybeLibDir = path21.dirname(nodeModulesDir);
+  if (path21.basename(maybeLibDir) === "lib") {
+    return path21.dirname(maybeLibDir);
   }
   return maybeLibDir;
 }
@@ -20382,7 +20898,7 @@ function getNpmExecOptions(platform10 = process.platform) {
 }
 function execNpmCommandSync(args, options = {}, surface) {
   const execOptions = surface?.execOptions || getNpmExecOptions();
-  return execFileSync2(
+  return execFileSync3(
     surface?.npmExecutable || "npm",
     [...surface?.npmArgsPrefix || [], ...args],
     {
@@ -20395,7 +20911,7 @@ function execNpmCommandSync(args, options = {}, surface) {
 function killPid(pid) {
   try {
     if (process.platform === "win32") {
-      execFileSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      execFileSync3("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -20407,7 +20923,7 @@ function killPid(pid) {
 function getWindowsProcessCommandLine(pid) {
   const pidFilter = `ProcessId=${pid}`;
   try {
-    const psOut = execFileSync2("powershell.exe", [
+    const psOut = execFileSync3("powershell.exe", [
       "-NoProfile",
       "-NonInteractive",
       "-ExecutionPolicy",
@@ -20419,7 +20935,7 @@ function getWindowsProcessCommandLine(pid) {
   } catch {
   }
   try {
-    const wmicOut = execFileSync2("wmic", [
+    const wmicOut = execFileSync3("wmic", [
       "process",
       "where",
       pidFilter,
@@ -20435,7 +20951,7 @@ function getProcessCommandLine(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return null;
   if (process.platform === "win32") return getWindowsProcessCommandLine(pid);
   try {
-    const text = execFileSync2("ps", ["-o", "command=", "-p", String(pid)], {
+    const text = execFileSync3("ps", ["-o", "command=", "-p", String(pid)], {
       encoding: "utf8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -20461,7 +20977,7 @@ async function waitForPidExit(pid, timeoutMs) {
   }
 }
 function stopSessionHostProcesses(appName) {
-  const pidFile = path20.join(os18.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  const pidFile = path21.join(os19.homedir(), ".adhdev", `${appName}-session-host.pid`);
   try {
     if (fs9.existsSync(pidFile)) {
       const pid = Number.parseInt(fs9.readFileSync(pidFile, "utf8").trim(), 10);
@@ -20478,7 +20994,7 @@ function stopSessionHostProcesses(appName) {
   }
 }
 function removeDaemonPidFile() {
-  const pidFile = path20.join(os18.homedir(), ".adhdev", "daemon.pid");
+  const pidFile = path21.join(os19.homedir(), ".adhdev", "daemon.pid");
   try {
     fs9.unlinkSync(pidFile);
   } catch {
@@ -20489,7 +21005,7 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   const npmRoot = String(execNpmCommandSync(["root", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
   if (!npmRoot) return;
   const npmPrefix = surface.installPrefix || String(execNpmCommandSync(["prefix", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
-  const binDir = process.platform === "win32" ? npmPrefix : path20.join(npmPrefix, "bin");
+  const binDir = process.platform === "win32" ? npmPrefix : path21.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
   if (pkgName === "@adhdev/daemon-standalone") {
@@ -20497,25 +21013,25 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   }
   if (pkgName.startsWith("@")) {
     const [scope, name] = pkgName.split("/");
-    const scopeDir = path20.join(npmRoot, scope);
+    const scopeDir = path21.join(npmRoot, scope);
     if (!fs9.existsSync(scopeDir)) return;
     for (const entry of fs9.readdirSync(scopeDir)) {
       if (!entry.startsWith(`.${name}-`)) continue;
-      fs9.rmSync(path20.join(scopeDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale scoped staging dir: ${path20.join(scopeDir, entry)}`);
+      fs9.rmSync(path21.join(scopeDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale scoped staging dir: ${path21.join(scopeDir, entry)}`);
     }
   } else {
     for (const entry of fs9.readdirSync(npmRoot)) {
       if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs9.rmSync(path20.join(npmRoot, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale staging dir: ${path20.join(npmRoot, entry)}`);
+      fs9.rmSync(path21.join(npmRoot, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale staging dir: ${path21.join(npmRoot, entry)}`);
     }
   }
   if (fs9.existsSync(binDir)) {
     for (const entry of fs9.readdirSync(binDir)) {
       if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs9.rmSync(path20.join(binDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale bin staging entry: ${path20.join(binDir, entry)}`);
+      fs9.rmSync(path21.join(binDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale bin staging entry: ${path21.join(binDir, entry)}`);
     }
   }
 }
@@ -20551,7 +21067,7 @@ async function runDaemonUpgradeHelper(payload) {
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
-  const installOutput = execFileSync2(
+  const installOutput = execFileSync3(
     installCommand.command,
     installCommand.args,
     {
@@ -20616,6 +21132,56 @@ function normalizeReleaseChannel(value) {
 function resolveUpgradeChannel(args) {
   return normalizeReleaseChannel(args?.channel) || normalizeReleaseChannel(args?.updatePolicy?.channel) || normalizeReleaseChannel(args?.npmTag) || normalizeReleaseChannel(loadConfig().updateChannel) || "stable";
 }
+function readProviderPriorityFromPolicy(policy) {
+  const record = policy && typeof policy === "object" && !Array.isArray(policy) ? policy : {};
+  const raw = record.providerPriority;
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return raw.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean).filter((type) => {
+    if (seen.has(type)) return false;
+    seen.add(type);
+    return true;
+  });
+}
+async function resolveProviderTypeFromPriority(args) {
+  if (!args.providerPriority.length) {
+    return { error: `Node '${args.nodeId}' has no providerPriority policy; pass cliType explicitly or configure node.policy.providerPriority` };
+  }
+  const failed = [];
+  for (const requestedType of args.providerPriority) {
+    const normalizedType = args.providerLoader.resolveAlias(requestedType);
+    if (!args.providerLoader.isMachineProviderEnabled(normalizedType)) {
+      failed.push(`${requestedType}: disabled`);
+      continue;
+    }
+    const detected = await detectCLI(normalizedType, args.providerLoader, { includeVersion: false });
+    args.providerLoader.setCliDetectionResults([{
+      id: normalizedType,
+      installed: !!detected,
+      path: detected?.path
+    }], false);
+    args.onStatusChange?.();
+    if (detected) return { providerType: normalizedType };
+    failed.push(`${requestedType}: not detected`);
+  }
+  return { error: `No usable provider detected for node '${args.nodeId}' from providerPriority: ${failed.join("; ")}` };
+}
+function loadYamlModule() {
+  return yaml;
+}
+function getMcpServersKey(format) {
+  return format === "hermes_config_yaml" ? "mcp_servers" : "mcpServers";
+}
+function parseMeshCoordinatorMcpConfig(text, format) {
+  if (!text.trim()) return {};
+  if (format === "claude_mcp_json") return JSON.parse(text);
+  const parsed = loadYamlModule().load(text);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function serializeMeshCoordinatorMcpConfig(config, format) {
+  if (format === "claude_mcp_json") return JSON.stringify(config, null, 2);
+  return loadYamlModule().dump(config, { noRefs: true, lineWidth: 120 });
+}
 var CHAT_COMMANDS = [
   "send_chat",
   "new_chat",
@@ -20714,6 +21280,109 @@ var DaemonCommandRouter = class {
   constructor(deps) {
     this.deps = deps;
   }
+  getCachedInlineMesh(meshId, inlineMesh) {
+    if (inlineMesh && typeof inlineMesh === "object") {
+      this.inlineMeshCache.set(meshId, inlineMesh);
+      return inlineMesh;
+    }
+    return this.inlineMeshCache.get(meshId);
+  }
+  async getMeshForCommand(meshId, inlineMesh) {
+    try {
+      const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+      const mesh = getMesh3(meshId);
+      if (mesh) return { mesh, inline: false };
+    } catch {
+    }
+    const cached = this.getCachedInlineMesh(meshId, inlineMesh);
+    return cached ? { mesh: cached, inline: true } : null;
+  }
+  updateInlineMeshNode(meshId, mesh, node) {
+    if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
+    const idx = mesh.nodes.findIndex((entry) => entry?.id === node.id || entry?.nodeId === node.id);
+    if (idx >= 0) mesh.nodes[idx] = node;
+    else mesh.nodes.push(node);
+    mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.inlineMeshCache.set(meshId, mesh);
+  }
+  removeInlineMeshNode(meshId, mesh, nodeId) {
+    if (!mesh || !Array.isArray(mesh.nodes)) return false;
+    const idx = mesh.nodes.findIndex((entry) => entry?.id === nodeId || entry?.nodeId === nodeId);
+    if (idx === -1) return false;
+    mesh.nodes.splice(idx, 1);
+    mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.inlineMeshCache.set(meshId, mesh);
+    return true;
+  }
+  normalizeMeshSessionCleanupMode(value) {
+    return value === "stop" || value === "delete_stopped" || value === "stop_and_delete" || value === "preserve" ? value : "preserve";
+  }
+  sessionMatchesMeshNode(record, node, nodeId, sessionIds) {
+    const sessionId = typeof record?.sessionId === "string" ? record.sessionId : "";
+    if (!sessionId) return false;
+    if (sessionIds?.size) return sessionIds.has(sessionId);
+    const workspace = typeof node?.workspace === "string" ? node.workspace : "";
+    if (workspace && record?.workspace === workspace) return true;
+    if (record?.meta?.meshNodeId === nodeId) return true;
+    return false;
+  }
+  isCompletedHostedSession(record) {
+    return record?.lifecycle === "stopped" || record?.lifecycle === "failed" || record?.lifecycle === "interrupted";
+  }
+  async cleanupMeshSessions(args) {
+    if (args.mode === "preserve") {
+      return { success: true, mode: "preserve", matchedCount: 0, stoppedSessionIds: [], deletedSessionIds: [], skippedSessionIds: [] };
+    }
+    if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+    const requestedSessionIds = Array.isArray(args.sessionIds) ? new Set(args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean)) : void 0;
+    const sessions = await this.deps.sessionHostControl.listSessions();
+    const matched = sessions.filter((record) => this.sessionMatchesMeshNode(record, args.node, args.nodeId, requestedSessionIds));
+    const stoppedSessionIds = [];
+    const deletedSessionIds = [];
+    const skippedSessionIds = [];
+    const errors = [];
+    for (const record of matched) {
+      const sessionId = String(record.sessionId);
+      const completed = this.isCompletedHostedSession(record);
+      try {
+        if (args.mode === "stop") {
+          if (!completed) {
+            if (!args.dryRun) await this.deps.sessionHostControl.stopSession(sessionId);
+            stoppedSessionIds.push(sessionId);
+          } else {
+            skippedSessionIds.push(sessionId);
+          }
+          continue;
+        }
+        if (args.mode === "delete_stopped") {
+          if (completed) {
+            if (!args.dryRun) await this.deps.sessionHostControl.deleteSession(sessionId, { force: false });
+            deletedSessionIds.push(sessionId);
+          } else {
+            skippedSessionIds.push(sessionId);
+          }
+          continue;
+        }
+        if (args.mode === "stop_and_delete") {
+          if (!args.dryRun) await this.deps.sessionHostControl.deleteSession(sessionId, { force: true });
+          deletedSessionIds.push(sessionId);
+          continue;
+        }
+      } catch (e) {
+        errors.push({ sessionId, error: e?.message || String(e) });
+      }
+    }
+    return {
+      success: errors.length === 0,
+      mode: args.mode,
+      dryRun: args.dryRun === true,
+      matchedCount: matched.length,
+      stoppedSessionIds,
+      deletedSessionIds,
+      skippedSessionIds,
+      ...errors.length ? { errors } : {}
+    };
+  }
   async traceSessionHostAction(action, args, run, summarizeResult) {
     const interactionId = typeof args?._interactionId === "string" ? args._interactionId : void 0;
     const sessionId = typeof args?.sessionId === "string" ? args.sessionId : void 0;
@@ -20833,6 +21502,9 @@ var DaemonCommandRouter = class {
   async executeDaemonCommand(cmd, args) {
     switch (cmd) {
       // ─── CLI / ACP commands ───
+      case "mesh_forward_event": {
+        return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager }, args);
+      }
       case "launch_cli":
       case "stop_cli":
       case "set_cli_view_mode":
@@ -21377,7 +22049,26 @@ var DaemonCommandRouter = class {
         if (!name) return { success: false, error: "name required" };
         try {
           const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch });
+          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy });
+          return { success: true, mesh };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      case "update_mesh": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { updateMesh: updateMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const patch = {};
+          if (typeof args?.name === "string") patch.name = args.name;
+          if (typeof args?.defaultBranch === "string") patch.defaultBranch = args.defaultBranch;
+          if (args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy)) patch.policy = args.policy;
+          if (args?.coordinator && typeof args.coordinator === "object" && !Array.isArray(args.coordinator)) patch.coordinator = args.coordinator;
+          if (!Object.keys(patch).length) return { success: false, error: "No updates provided" };
+          const mesh = updateMesh2(meshId, patch);
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          this.inlineMeshCache.set(meshId, mesh);
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
@@ -21401,21 +22092,164 @@ var DaemonCommandRouter = class {
         if (!workspace) return { success: false, error: "workspace required" };
         try {
           const { addNode: addNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const node = addNode3(meshId, { workspace });
+          const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
+          const readOnly = args?.readOnly === true;
+          const policy = {
+            ...readOnly ? { readOnly: true } : {},
+            ...providerPriority.length ? { providerPriority } : {}
+          };
+          const node = addNode3(meshId, { workspace, ...policy ? { policy } : {} });
           if (!node) return { success: false, error: "Mesh not found" };
           return { success: true, node };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
+      case "update_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 { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
+          if (Array.isArray(args?.providerPriority)) {
+            const providerPriority = args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean);
+            delete policy.provider_priority;
+            if (providerPriority.length) {
+              policy.providerPriority = providerPriority;
+            } else {
+              delete policy.providerPriority;
+            }
+          }
+          const node = updateNode2(meshId, nodeId, { policy });
+          if (!node) return { success: false, error: "Mesh node not found" };
+          return { success: true, node };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      case "cleanup_mesh_sessions": {
+        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;
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          const mode = this.normalizeMeshSessionCleanupMode(args?.mode ?? mesh?.policy?.sessionCleanupOnNodeRemove);
+          const sessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean) : void 0;
+          const result = await this.cleanupMeshSessions({
+            meshId,
+            nodeId,
+            node,
+            mode,
+            sessionIds,
+            dryRun: args?.dryRun === true
+          });
+          return result;
+        } 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() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
         try {
-          const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const removed = removeNode3(meshId, nodeId);
-          return { success: true, removed };
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+          const mesh = meshRecord?.mesh;
+          const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+          const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
+            args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
+          );
+          let sessionCleanup;
+          if (node && sessionCleanupMode !== "preserve") {
+            sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode });
+            if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
+          }
+          if (node?.isLocalWorktree && node.workspace) {
+            try {
+              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) {
+                const { removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
+                await removeWorktree2(repoRoot, node.workspace);
+              }
+            } catch (e) {
+              LOG.warn("MeshNode", `Worktree cleanup failed for ${nodeId}: ${e.message}`);
+            }
+          }
+          let removed = false;
+          if (meshRecord?.inline) {
+            removed = this.removeInlineMeshNode(meshId, mesh, nodeId);
+          } else {
+            const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            removed = removeNode3(meshId, nodeId);
+          }
+          return { success: true, removed, ...sessionCleanup ? { sessionCleanup } : {} };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      case "clone_mesh_node": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const sourceNodeId = typeof args?.sourceNodeId === "string" ? args.sourceNodeId.trim() : "";
+        const branch = typeof args?.branch === "string" ? args.branch.trim() : "";
+        const baseBranch = typeof args?.baseBranch === "string" ? args.baseBranch.trim() : void 0;
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!sourceNodeId) return { success: false, error: "sourceNodeId required" };
+        if (!branch) return { success: false, error: "branch required" };
+        try {
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+          const mesh = meshRecord?.mesh;
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          const sourceNode = mesh.nodes?.find((n) => n.id === sourceNodeId || n.nodeId === sourceNodeId);
+          if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
+          const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
+          const { createWorktree: createWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
+          const result = await createWorktree2({
+            repoRoot,
+            branch,
+            baseBranch,
+            meshName: mesh.name
+          });
+          let node;
+          if (meshRecord.inline) {
+            const { randomUUID: randomUUID8 } = await import("crypto");
+            node = {
+              id: `node_${randomUUID8().replace(/-/g, "")}`,
+              workspace: result.worktreePath,
+              repoRoot: result.worktreePath,
+              daemonId: sourceNode.daemonId,
+              userOverrides: { ...sourceNode.userOverrides || {} },
+              policy: { ...sourceNode.policy || {} },
+              isLocalWorktree: true,
+              worktreeBranch: result.branch,
+              clonedFromNodeId: sourceNodeId
+            };
+            this.updateInlineMeshNode(meshId, mesh, node);
+          } else {
+            const { addNode: addNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            node = addNode3(meshId, {
+              workspace: result.worktreePath,
+              repoRoot: result.worktreePath,
+              daemonId: sourceNode.daemonId,
+              userOverrides: { ...sourceNode.userOverrides || {} },
+              isLocalWorktree: true,
+              worktreeBranch: result.branch,
+              clonedFromNodeId: sourceNodeId,
+              policy: { ...sourceNode.policy || {} }
+            });
+            if (!node) return { success: false, error: "Failed to register worktree node" };
+          }
+          return {
+            success: true,
+            node,
+            worktreePath: result.worktreePath,
+            branch: result.branch
+          };
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -21423,7 +22257,7 @@ var DaemonCommandRouter = class {
       // ─── Mesh Coordinator Launch ───
       case "launch_mesh_coordinator": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-        const cliType = typeof args?.cliType === "string" ? args.cliType.trim() : "claude-cli";
+        let cliType = typeof args?.cliType === "string" ? args.cliType.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
         try {
           const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
@@ -21451,9 +22285,29 @@ var DaemonCommandRouter = class {
           }
           const workspace = typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "";
           if (!workspace) return { success: false, error: "Coordinator node workspace required", meshId, cliType };
+          if (!cliType) {
+            const resolved = await resolveProviderTypeFromPriority({
+              nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || "coordinator"),
+              providerPriority: readProviderPriorityFromPolicy(coordinatorNode.policy),
+              providerLoader: this.deps.providerLoader,
+              onStatusChange: this.deps.onStatusChange
+            });
+            if (!resolved.providerType) {
+              return {
+                success: false,
+                code: "mesh_coordinator_provider_priority_unusable",
+                error: resolved.error || "No usable provider found from node providerPriority",
+                meshId,
+                cliType,
+                workspace
+              };
+            }
+            cliType = resolved.providerType;
+          }
           const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
           const coordinatorSetup = resolveMeshCoordinatorSetup({
             provider: providerMeta,
+            cliType,
             meshId,
             workspace
           });
@@ -21478,7 +22332,8 @@ var DaemonCommandRouter = class {
               meshCoordinatorSetup: coordinatorSetup
             };
           }
-          if (coordinatorSetup.configFormat !== "claude_mcp_json") {
+          const configFormat = coordinatorSetup.configFormat;
+          if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
             return {
               success: false,
               code: "mesh_coordinator_unsupported",
@@ -21488,44 +22343,93 @@ var DaemonCommandRouter = class {
               workspace
             };
           }
-          const { existsSync: existsSync22, readFileSync: readFileSync15, writeFileSync: writeFileSync12, copyFileSync: copyFileSync3 } = await import("fs");
-          const mcpConfigPath = coordinatorSetup.configPath;
-          const hadExistingMcpConfig = existsSync22(mcpConfigPath);
-          let existingMcpConfig = {};
-          if (hadExistingMcpConfig) {
-            try {
-              existingMcpConfig = JSON.parse(readFileSync15(mcpConfigPath, "utf-8"));
-              copyFileSync3(mcpConfigPath, mcpConfigPath + ".backup");
-            } catch {
-            }
+          let systemPrompt = "";
+          try {
+            systemPrompt = 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
+            };
           }
+          const { existsSync: existsSync23, readFileSync: readFileSync15, writeFileSync: writeFileSync13, copyFileSync: copyFileSync3, mkdirSync: mkdirSync15 } = 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;
+          const returnManualFallback = (message) => ({
+            success: false,
+            code: "mesh_coordinator_manual_mcp_setup_required",
+            error: message,
+            meshId,
+            cliType,
+            workspace,
+            meshCoordinatorSetup: hermesManualFallback
+          });
           const mcpServerEntry = {
             command: coordinatorSetup.mcpServer.command,
             args: coordinatorSetup.mcpServer.args
           };
           if (args?.inlineMesh) {
             mcpServerEntry.env = {
-              ADHDEV_INLINE_MESH: JSON.stringify(mesh)
+              ADHDEV_INLINE_MESH: JSON.stringify(mesh),
+              ADHDEV_MCP_TRANSPORT: "ipc"
             };
           }
+          try {
+            mkdirSync15(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);
+          let existingMcpConfig = {};
+          if (hadExistingMcpConfig) {
+            try {
+              existingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync15(mcpConfigPath, "utf-8"), configFormat);
+              copyFileSync3(mcpConfigPath, mcpConfigPath + ".backup");
+            } catch (error) {
+              LOG.error("MeshCoordinator", `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);
+              return {
+                success: false,
+                code: "mesh_coordinator_config_parse_failed",
+                error: `Failed to parse existing MCP config at ${mcpConfigPath}`
+              };
+            }
+          }
+          const mcpServersKey = getMcpServersKey(configFormat);
+          const existingServers = existingMcpConfig[mcpServersKey];
           const mcpConfig = {
             ...existingMcpConfig,
-            mcpServers: {
-              ...existingMcpConfig.mcpServers || {},
+            [mcpServersKey]: {
+              ...existingServers && typeof existingServers === "object" && !Array.isArray(existingServers) ? existingServers : {},
               [coordinatorSetup.serverName]: mcpServerEntry
             }
           };
-          writeFileSync12(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-          LOG.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
-          let systemPrompt = "";
           try {
-            systemPrompt = buildCoordinatorSystemPrompt2({ mesh });
-          } catch {
-            systemPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}". Use the adhdev-mesh MCP tools (mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, etc.) to orchestrate work across ${mesh.nodes.length} node(s).`;
+            writeFileSync13(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);
+            if (hermesManualFallback) return returnManualFallback(message);
+            return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
+          LOG.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
           const cliArgs = [];
+          const launchEnv = {};
           if (systemPrompt) {
-            cliArgs.push("--append-system-prompt", systemPrompt);
+            if (configFormat === "hermes_config_yaml") {
+              launchEnv.HERMES_EPHEMERAL_SYSTEM_PROMPT = systemPrompt;
+            } else {
+              cliArgs.push("--append-system-prompt", systemPrompt);
+            }
           }
           if (cliType === "claude-cli") {
             cliArgs.push("--mcp-config", coordinatorSetup.configPath);
@@ -21534,6 +22438,7 @@ var DaemonCommandRouter = class {
             cliType,
             dir: workspace,
             cliArgs: cliArgs.length > 0 ? cliArgs : void 0,
+            env: Object.keys(launchEnv).length > 0 ? launchEnv : void 0,
             settings: {
               meshCoordinatorFor: meshId
             }
@@ -21713,6 +22618,12 @@ var DaemonStatusReporter = class {
     if (providerType) {
       payload.providerType = providerType;
     }
+    if (typeof event.providerSessionId === "string" && event.providerSessionId.trim()) {
+      payload.providerSessionId = event.providerSessionId.trim();
+    }
+    if (typeof event.workspaceName === "string" && event.workspaceName.trim()) {
+      payload.workspaceName = event.workspaceName.trim();
+    }
     if (typeof event.duration === "number" && Number.isFinite(event.duration)) {
       payload.duration = event.duration;
     }
@@ -22960,7 +23871,10 @@ var ProviderInstanceManager = class {
       this.instances.get(id).dispose();
     }
     this.instances.set(id, instance);
-    await instance.init(context);
+    await instance.init({
+      ...context,
+      emitProviderEvent: (event) => this.emitProviderEvent(instance.type, id, event)
+    });
   }
   /**
   * Instance remove
@@ -23122,6 +24036,17 @@ var ProviderInstanceManager = class {
   onEvent(listener) {
     this.eventListeners.push(listener);
   }
+  emitProviderEvent(providerType, instanceId, event) {
+    const payload = {
+      ...event,
+      providerType,
+      instanceId: typeof event.instanceId === "string" && event.instanceId.trim() ? event.instanceId : instanceId,
+      targetSessionId: typeof event.targetSessionId === "string" && event.targetSessionId.trim() ? event.targetSessionId : instanceId
+    };
+    for (const listener of this.eventListeners) {
+      listener(payload);
+    }
+  }
   emitPendingEvents(providerType, state, extra = {}) {
     for (const event of state.pendingEvents) {
       for (const listener of this.eventListeners) {
@@ -23194,11 +24119,11 @@ var ProviderInstanceManager = class {
 
 // src/providers/version-archive.ts
 import * as fs11 from "fs";
-import * as path21 from "path";
-import * as os19 from "os";
+import * as path22 from "path";
+import * as os20 from "os";
 import { execSync as execSync5 } from "child_process";
 import { platform as platform8 } from "os";
-var ARCHIVE_PATH = path21.join(os19.homedir(), ".adhdev", "version-history.json");
+var ARCHIVE_PATH = path22.join(os20.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
   history = {};
@@ -23245,7 +24170,7 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs11.mkdirSync(path21.dirname(ARCHIVE_PATH), { recursive: true });
+      fs11.mkdirSync(path22.dirname(ARCHIVE_PATH), { recursive: true });
       fs11.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
@@ -23301,8 +24226,8 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os19.homedir();
-      const resolved = p.replace(/\*/g, home.split(path21.sep).pop() || "");
+      const home = os20.homedir();
+      const resolved = p.replace(/\*/g, home.split(path22.sep).pop() || "");
       if (fs11.existsSync(resolved)) return resolved;
     } else {
       if (fs11.existsSync(p)) return p;
@@ -23312,7 +24237,7 @@ function checkPathExists2(paths) {
 }
 function getMacAppVersion(appPath) {
   if (platform8() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path21.join(appPath, "Contents", "Info.plist");
+  const plistPath = path22.join(appPath, "Contents", "Info.plist");
   if (!fs11.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
@@ -23338,7 +24263,7 @@ async function detectAllVersions(loader, archive) {
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path21.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        const bundled = path22.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
         if (provider.cli && fs11.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
@@ -23379,7 +24304,7 @@ async function detectAllVersions(loader, archive) {
 // src/daemon/dev-server.ts
 import * as http2 from "http";
 import * as fs15 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 init_config();
 
 // src/daemon/scaffold-template.ts
@@ -23731,7 +24656,7 @@ init_logger();
 // src/daemon/dev-cdp-handlers.ts
 init_logger();
 import * as fs12 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 async function handleCdpEvaluate(ctx, req, res) {
   const body = await ctx.readBody(req);
   const { expression, timeout, ideType } = body;
@@ -23909,17 +24834,17 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path22.join(dir, "scripts.js");
+  const directScripts = path23.join(dir, "scripts.js");
   if (fs12.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path22.join(dir, "scripts");
+    const scriptsDir = path23.join(dir, "scripts");
     if (fs12.existsSync(scriptsDir)) {
       const versions = fs12.readdirSync(scriptsDir).filter((d) => {
-        return fs12.statSync(path22.join(scriptsDir, d)).isDirectory();
+        return fs12.statSync(path23.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path22.join(scriptsDir, ver, "scripts.js");
+        const p = path23.join(scriptsDir, ver, "scripts.js");
         if (fs12.existsSync(p)) {
           scriptsPath = p;
           break;
@@ -24748,7 +25673,7 @@ async function handleDomContext(ctx, type, req, res) {
 
 // src/daemon/dev-cli-debug.ts
 import * as fs13 from "fs";
-import * as path23 from "path";
+import * as path24 from "path";
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || `fixture-${Date.now()}`;
@@ -24758,11 +25683,11 @@ function getCliFixtureDir(ctx, type) {
   if (!providerDir) {
     throw new Error(`Provider directory not found for '${type}'`);
   }
-  return path23.join(providerDir, "fixtures");
+  return path24.join(providerDir, "fixtures");
 }
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
-  const filePath = path23.join(fixtureDir, `${name}.json`);
+  const filePath = path24.join(fixtureDir, `${name}.json`);
   if (!fs13.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
@@ -25529,7 +26454,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       },
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
-    const filePath = path23.join(fixtureDir, `${name}.json`);
+    const filePath = path24.join(fixtureDir, `${name}.json`);
     fs13.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
@@ -25553,7 +26478,7 @@ async function handleCliFixtureList(ctx, type, _req, res) {
       return;
     }
     const fixtures = fs13.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
-      const fullPath = path23.join(fixtureDir, file);
+      const fullPath = path24.join(fixtureDir, file);
       try {
         const raw = JSON.parse(fs13.readFileSync(fullPath, "utf-8"));
         return {
@@ -25689,8 +26614,8 @@ async function handleCliRaw(ctx, req, res) {
 
 // src/daemon/dev-auto-implement.ts
 import * as fs14 from "fs";
-import * as path24 from "path";
-import * as os20 from "os";
+import * as path25 from "path";
+import * as os21 from "os";
 function getAutoImplPid(ctx) {
   const pid = ctx.autoImplProcess?.pid;
   return typeof pid === "number" && pid > 0 ? pid : null;
@@ -25739,22 +26664,22 @@ function getLatestScriptVersionDir(scriptsDir) {
   if (!fs14.existsSync(scriptsDir)) return null;
   const versions = fs14.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs14.statSync(path24.join(scriptsDir, d)).isDirectory();
+      return fs14.statSync(path25.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
   }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
   if (versions.length === 0) return null;
-  return path24.join(scriptsDir, versions[0]);
+  return path25.join(scriptsDir, versions[0]);
 }
 function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-  const canonicalUserDir = path24.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-  const desiredDir = requestedDir ? path24.resolve(requestedDir) : canonicalUserDir;
-  const upstreamRoot = path24.resolve(ctx.providerLoader.getUpstreamDir());
-  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path24.sep}`)) {
+  const canonicalUserDir = path25.resolve(ctx.providerLoader.getUserProviderDir(category, type));
+  const desiredDir = requestedDir ? path25.resolve(requestedDir) : canonicalUserDir;
+  const upstreamRoot = path25.resolve(ctx.providerLoader.getUpstreamDir());
+  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path25.sep}`)) {
     return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
   }
-  if (path24.basename(desiredDir) !== type) {
+  if (path25.basename(desiredDir) !== type) {
     return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
   }
   const sourceDir = ctx.findProviderDir(type);
@@ -25762,11 +26687,11 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
   if (!fs14.existsSync(desiredDir)) {
-    fs14.mkdirSync(path24.dirname(desiredDir), { recursive: true });
+    fs14.mkdirSync(path25.dirname(desiredDir), { recursive: true });
     fs14.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path24.join(desiredDir, "provider.json");
+  const providerJson = path25.join(desiredDir, "provider.json");
   if (!fs14.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
@@ -25777,13 +26702,13 @@ function loadAutoImplReferenceScripts(ctx, referenceType) {
   const refDir = ctx.findProviderDir(referenceType);
   if (!refDir || !fs14.existsSync(refDir)) return {};
   const referenceScripts = {};
-  const scriptsDir = path24.join(refDir, "scripts");
+  const scriptsDir = path25.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
   for (const file of fs14.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs14.readFileSync(path24.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs14.readFileSync(path25.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -25891,9 +26816,9 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-    const tmpDir = path24.join(os20.tmpdir(), "adhdev-autoimpl");
+    const tmpDir = path25.join(os21.tmpdir(), "adhdev-autoimpl");
     if (!fs14.existsSync(tmpDir)) fs14.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path24.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+    const promptFile = path25.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
     fs14.writeFileSync(promptFile, prompt, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
@@ -26046,7 +26971,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
     const baseArgs = [...spawn4.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os20.platform() === "win32";
+    const isWin = os21.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     const promptMode = autoImpl?.promptMode ?? "stdin";
     const extraArgs = autoImpl?.extraArgs ?? [];
@@ -26085,7 +27010,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty = __require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os20.platform() === "win32";
+      const isWin2 = os21.platform() === "win32";
       child = pty.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: 120,
@@ -26325,7 +27250,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     setMode: "set_mode.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path24.join(providerDir, "scripts");
+  const scriptsDir = path25.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -26336,7 +27261,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     for (const file of fs14.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -26353,7 +27278,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -26394,10 +27319,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
     }
   }
-  const docsDir = path24.join(providerDir, "../../docs");
+  const docsDir = path25.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path24.join(docsDir, name);
+      const p = path25.join(docsDir, name);
       if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
     } catch {
     }
@@ -26634,7 +27559,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     parseApproval: "parse_approval.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path24.join(providerDir, "scripts");
+  const scriptsDir = path25.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -26646,7 +27571,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
+        const content = fs14.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -26662,7 +27587,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -26695,10 +27620,10 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
     }
   }
-  const docsDir = path24.join(providerDir, "../../docs");
+  const docsDir = path25.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path24.join(docsDir, name);
+      const p = path25.join(docsDir, name);
       if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
     } catch {
     }
@@ -27145,8 +28070,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path26 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path26}`;
+      const path27 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+      return `${r.method.padEnd(5)} ${path27}`;
     });
   }
   async start(port = DEV_SERVER_PORT) {
@@ -27434,12 +28359,12 @@ var DevServer = class _DevServer {
   // ─── DevConsole SPA ───
   getConsoleDistDir() {
     const candidates = [
-      path25.resolve(__dirname, "../../web-devconsole/dist"),
-      path25.resolve(__dirname, "../../../web-devconsole/dist"),
-      path25.join(process.cwd(), "packages/web-devconsole/dist")
+      path26.resolve(__dirname, "../../web-devconsole/dist"),
+      path26.resolve(__dirname, "../../../web-devconsole/dist"),
+      path26.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs15.existsSync(path25.join(dir, "index.html"))) return dir;
+      if (fs15.existsSync(path26.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -27449,7 +28374,7 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
       return;
     }
-    const htmlPath = path25.join(distDir, "index.html");
+    const htmlPath = path26.join(distDir, "index.html");
     try {
       const html = fs15.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
@@ -27474,15 +28399,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: "Not found" });
       return;
     }
-    const safePath = path25.normalize(pathname).replace(/^\.\.\//, "");
-    const filePath = path25.join(distDir, safePath);
+    const safePath = path26.normalize(pathname).replace(/^\.\.\//, "");
+    const filePath = path26.join(distDir, safePath);
     if (!filePath.startsWith(distDir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
       const content = fs15.readFileSync(filePath);
-      const ext = path25.extname(filePath);
+      const ext = path26.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
       res.end(content);
@@ -27595,9 +28520,9 @@ var DevServer = class _DevServer {
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
-            scan(path25.join(d, entry.name), rel);
+            scan(path26.join(d, entry.name), rel);
           } else {
-            const stat2 = fs15.statSync(path25.join(d, entry.name));
+            const stat2 = fs15.statSync(path26.join(d, entry.name));
             files.push({ path: rel, size: stat2.size, type: "file" });
           }
         }
@@ -27620,7 +28545,7 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path25.resolve(dir, path25.normalize(filePath));
+    const fullPath = path26.resolve(dir, path26.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
@@ -27645,14 +28570,14 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path25.resolve(dir, path25.normalize(filePath));
+    const fullPath = path26.resolve(dir, path26.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
       if (fs15.existsSync(fullPath)) fs15.copyFileSync(fullPath, fullPath + ".bak");
-      fs15.mkdirSync(path25.dirname(fullPath), { recursive: true });
+      fs15.mkdirSync(path26.dirname(fullPath), { recursive: true });
       fs15.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
@@ -27669,7 +28594,7 @@ var DevServer = class _DevServer {
       return;
     }
     for (const name of ["scripts.js", "provider.json"]) {
-      const p = path25.join(dir, name);
+      const p = path26.join(dir, name);
       if (fs15.existsSync(p)) {
         const source = fs15.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
@@ -27690,8 +28615,8 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs15.existsSync(path25.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-    const targetPath = path25.join(dir, target);
+    const target = fs15.existsSync(path26.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const targetPath = path26.join(dir, target);
     try {
       if (fs15.existsSync(targetPath)) fs15.copyFileSync(targetPath, targetPath + ".bak");
       fs15.writeFileSync(targetPath, source, "utf-8");
@@ -27838,7 +28763,7 @@ var DevServer = class _DevServer {
     }
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
-    const jsonPath = path25.join(targetDir, "provider.json");
+    const jsonPath = path26.join(targetDir, "provider.json");
     if (fs15.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
@@ -27850,8 +28775,8 @@ var DevServer = class _DevServer {
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
-          const fullPath = path25.join(targetDir, relPath);
-          fs15.mkdirSync(path25.dirname(fullPath), { recursive: true });
+          const fullPath = path26.join(targetDir, relPath);
+          fs15.mkdirSync(path26.dirname(fullPath), { recursive: true });
           fs15.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
@@ -27904,22 +28829,22 @@ var DevServer = class _DevServer {
     if (!fs15.existsSync(scriptsDir)) return null;
     const versions = fs15.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs15.statSync(path25.join(scriptsDir, d)).isDirectory();
+        return fs15.statSync(path26.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
     }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
     if (versions.length === 0) return null;
-    return path25.join(scriptsDir, versions[0]);
+    return path26.join(scriptsDir, versions[0]);
   }
   resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-    const canonicalUserDir = path25.resolve(this.providerLoader.getUserProviderDir(category, type));
-    const desiredDir = requestedDir ? path25.resolve(requestedDir) : canonicalUserDir;
-    const upstreamRoot = path25.resolve(this.providerLoader.getUpstreamDir());
-    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path25.sep}`)) {
+    const canonicalUserDir = path26.resolve(this.providerLoader.getUserProviderDir(category, type));
+    const desiredDir = requestedDir ? path26.resolve(requestedDir) : canonicalUserDir;
+    const upstreamRoot = path26.resolve(this.providerLoader.getUpstreamDir());
+    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path26.sep}`)) {
       return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
     }
-    if (path25.basename(desiredDir) !== type) {
+    if (path26.basename(desiredDir) !== type) {
       return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
     }
     const sourceDir = this.findProviderDir(type);
@@ -27927,11 +28852,11 @@ var DevServer = class _DevServer {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
     if (!fs15.existsSync(desiredDir)) {
-      fs15.mkdirSync(path25.dirname(desiredDir), { recursive: true });
+      fs15.mkdirSync(path26.dirname(desiredDir), { recursive: true });
       fs15.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
-    const providerJson = path25.join(desiredDir, "provider.json");
+    const providerJson = path26.join(desiredDir, "provider.json");
     if (!fs15.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
@@ -27967,7 +28892,7 @@ var DevServer = class _DevServer {
       setMode: "set_mode.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path25.join(providerDir, "scripts");
+    const scriptsDir = path26.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -27978,7 +28903,7 @@ var DevServer = class _DevServer {
       for (const file of fs15.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
+            const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -27995,7 +28920,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
+            const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -28036,10 +28961,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path25.join(providerDir, "../../docs");
+    const docsDir = path26.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path25.join(docsDir, name);
+        const p = path26.join(docsDir, name);
         if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
       } catch {
       }
@@ -28213,7 +29138,7 @@ var DevServer = class _DevServer {
       parseApproval: "parse_approval.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path25.join(providerDir, "scripts");
+    const scriptsDir = path26.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -28225,7 +29150,7 @@ var DevServer = class _DevServer {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
+          const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -28241,7 +29166,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
+            const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -28274,10 +29199,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path25.join(providerDir, "../../docs");
+    const docsDir = path26.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path25.join(docsDir, name);
+        const p = path26.join(docsDir, name);
         if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
       } catch {
       }
@@ -29282,48 +30207,6 @@ var SessionRegistry = class {
 // src/boot/daemon-lifecycle.ts
 init_logger();
 init_config();
-
-// src/mesh/mesh-events.ts
-init_mesh_config();
-init_logger();
-function setupMeshEventForwarding(components) {
-  components.instanceManager.onEvent((event) => {
-    if (event.event !== "agent:generating_completed" && event.event !== "agent:waiting_approval") return;
-    const instanceId = event.instanceId;
-    if (!instanceId) return;
-    const sourceInstance = components.instanceManager.getInstance(instanceId);
-    if (!sourceInstance || sourceInstance.category !== "cli") return;
-    const state = sourceInstance.getState();
-    const workspace = state.workspace;
-    if (!workspace) return;
-    const mesh = getMeshByRepo(workspace);
-    if (!mesh) return;
-    const allInstances = components.instanceManager.getByCategory("cli");
-    const coordinatorInstances = allInstances.filter((inst) => {
-      const instState = inst.getState();
-      if (instState.settings?.meshCoordinatorFor !== mesh.id) return false;
-      if (instState.instanceId === instanceId) return false;
-      return true;
-    });
-    if (coordinatorInstances.length === 0) return;
-    const targetNode = mesh.nodes.find((n) => n.workspace === workspace);
-    const nodeLabel = targetNode ? `Node '${targetNode.id}'` : `Agent at ${workspace}`;
-    let messageText = "";
-    if (event.event === "agent:generating_completed") {
-      messageText = `[System] ${nodeLabel} has completed its task and is now idle. You may use mesh_read_chat to review its progress.`;
-    } else if (event.event === "agent:waiting_approval") {
-      messageText = `[System] ${nodeLabel} is waiting for approval to proceed. You may use mesh_read_chat and mesh_approve to handle it.`;
-    }
-    if (!messageText) return;
-    for (const coord of coordinatorInstances) {
-      const coordState = coord.getState();
-      LOG.info("MeshEvents", `Forwarding event from ${workspace} to coordinator ${coordState.instanceId}`);
-      coord.onEvent("send_message", { input: { text: messageText, textFallback: messageText } });
-    }
-  });
-}
-
-// src/boot/daemon-lifecycle.ts
 async function initDaemonComponents(config) {
   installGlobalInterceptor();
   const appConfig = loadConfig();
@@ -29629,6 +30512,7 @@ export {
   createGitWorkspaceMonitor,
   createInteractionId,
   createMesh,
+  createWorktree,
   deleteMesh,
   detectAllVersions,
   detectCLIs,
@@ -29681,6 +30565,7 @@ export {
   launchWithCdp,
   listHostedCliRuntimes,
   listMeshes,
+  listWorktrees,
   loadConfig,
   loadState,
   logCommand,
@@ -29700,6 +30585,7 @@ export {
   normalizeSessionModalFields,
   parsePorcelainV2Status,
   parseProviderSourceConfigUpdate,
+  parseWorktreeListOutput,
   partitionSessionHostDiagnosticsSessions,
   partitionSessionHostRecords,
   prepareSessionChatTailUpdate,
@@ -29709,6 +30595,7 @@ export {
   recordDebugTrace,
   registerExtensionProviders,
   removeNode,
+  removeWorktree,
   resetConfig,
   resetDebugRuntimeConfig,
   resetState,
@@ -29718,6 +30605,7 @@ export {
   resolveGitRepository,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,
+  resolveWorktreePath,
   runAsyncBatch,
   runGit,
   saveConfig,