@adhdev/daemon-standalone 0.9.67 → 0.9.69

package/dist/index.js

@@ -27884,6 +27884,20 @@ var require_dist2 = __commonJS({
       mod
     ));
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var DEFAULT_MESH_POLICY;
+    var init_repo_mesh_types = __esm2({
+      "src/repo-mesh-types.ts"() {
+        "use strict";
+        DEFAULT_MESH_POLICY = {
+          requirePreTaskCheckpoint: false,
+          requirePostTaskCheckpoint: true,
+          requireApprovalForPush: true,
+          requireApprovalForDestructiveGit: true,
+          dirtyWorkspaceBehavior: "warn",
+          maxParallelTasks: 2
+        };
+      }
+    });
     var config_exports = {};
     __export2(config_exports, {
       generateMachineId: () => generateMachineId,
@@ -28125,6 +28139,276 @@ var require_dist2 = __commonJS({
         MACHINE_ID_PREFIX = "mach_";
       }
     });
+    var mesh_config_exports = {};
+    __export2(mesh_config_exports, {
+      addNode: () => addNode,
+      createMesh: () => createMesh,
+      deleteMesh: () => deleteMesh,
+      getMesh: () => getMesh,
+      getMeshByRepo: () => getMeshByRepo,
+      listMeshes: () => listMeshes,
+      normalizeRepoIdentity: () => normalizeRepoIdentity,
+      removeNode: () => removeNode,
+      updateMesh: () => updateMesh,
+      updateNode: () => updateNode
+    });
+    function getMeshConfigPath() {
+      return (0, import_path22.join)(getConfigDir(), "meshes.json");
+    }
+    function loadMeshConfig() {
+      const path26 = getMeshConfigPath();
+      if (!(0, import_fs2.existsSync)(path26)) return { meshes: [] };
+      try {
+        const raw = JSON.parse((0, import_fs2.readFileSync)(path26, "utf-8"));
+        if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
+        return raw;
+      } catch {
+        return { meshes: [] };
+      }
+    }
+    function saveMeshConfig(config2) {
+      const path26 = getMeshConfigPath();
+      (0, import_fs2.writeFileSync)(path26, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
+    }
+    function normalizeRepoIdentity(remoteUrl) {
+      let identity = remoteUrl.trim();
+      if (identity.startsWith("http://") || identity.startsWith("https://")) {
+        try {
+          const url2 = new URL(identity);
+          const path26 = url2.pathname.replace(/^\//, "").replace(/\.git$/, "");
+          return `${url2.hostname}/${path26}`;
+        } catch {
+        }
+      }
+      const sshMatch = identity.match(/^(?:ssh:\/\/)?[\w.-]+@([\w.-]+)[:/]([\w.\-/]+?)(?:\.git)?$/);
+      if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
+      return identity;
+    }
+    function listMeshes() {
+      return loadMeshConfig().meshes;
+    }
+    function getMesh(meshId) {
+      return loadMeshConfig().meshes.find((m) => m.id === meshId);
+    }
+    function getMeshByRepo(repoIdentity) {
+      return loadMeshConfig().meshes.find((m) => m.repoIdentity === repoIdentity);
+    }
+    function createMesh(opts) {
+      const config2 = loadMeshConfig();
+      if (config2.meshes.length >= 20) {
+        throw new Error("Maximum 20 meshes allowed");
+      }
+      const repoIdentity = opts.repoIdentity || (opts.repoRemoteUrl ? normalizeRepoIdentity(opts.repoRemoteUrl) : "");
+      if (!repoIdentity) throw new Error("Either repoRemoteUrl or repoIdentity is required");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const mesh = {
+        id: `mesh_${(0, import_crypto32.randomUUID)().replace(/-/g, "")}`,
+        name: opts.name.trim().slice(0, 100),
+        repoIdentity,
+        repoRemoteUrl: opts.repoRemoteUrl,
+        defaultBranch: opts.defaultBranch,
+        policy: { ...DEFAULT_MESH_POLICY, ...opts.policy },
+        coordinator: opts.coordinator || {},
+        nodes: [],
+        createdAt: now,
+        updatedAt: now
+      };
+      config2.meshes.push(mesh);
+      saveMeshConfig(config2);
+      return mesh;
+    }
+    function updateMesh(meshId, opts) {
+      const config2 = loadMeshConfig();
+      const mesh = config2.meshes.find((m) => m.id === meshId);
+      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.coordinator) mesh.coordinator = opts.coordinator;
+      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveMeshConfig(config2);
+      return mesh;
+    }
+    function deleteMesh(meshId) {
+      const config2 = loadMeshConfig();
+      const idx = config2.meshes.findIndex((m) => m.id === meshId);
+      if (idx === -1) return false;
+      config2.meshes.splice(idx, 1);
+      saveMeshConfig(config2);
+      return true;
+    }
+    function addNode(meshId, opts) {
+      const config2 = loadMeshConfig();
+      const mesh = config2.meshes.find((m) => m.id === meshId);
+      if (!mesh) return void 0;
+      if (mesh.nodes.length >= 10) {
+        throw new Error("Maximum 10 nodes per mesh");
+      }
+      if (mesh.nodes.some((n) => n.workspace === opts.workspace)) {
+        throw new Error("This workspace is already in the mesh");
+      }
+      const node = {
+        id: `node_${(0, import_crypto32.randomUUID)().replace(/-/g, "")}`,
+        workspace: opts.workspace.trim(),
+        repoRoot: opts.repoRoot,
+        userOverrides: opts.userOverrides || {},
+        policy: opts.policy || {},
+        isLocalWorktree: opts.isLocalWorktree
+      };
+      mesh.nodes.push(node);
+      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveMeshConfig(config2);
+      return node;
+    }
+    function removeNode(meshId, nodeId) {
+      const config2 = loadMeshConfig();
+      const mesh = config2.meshes.find((m) => m.id === meshId);
+      if (!mesh) return false;
+      const idx = mesh.nodes.findIndex((n) => n.id === nodeId);
+      if (idx === -1) return false;
+      mesh.nodes.splice(idx, 1);
+      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveMeshConfig(config2);
+      return true;
+    }
+    function updateNode(meshId, nodeId, opts) {
+      const config2 = loadMeshConfig();
+      const mesh = config2.meshes.find((m) => m.id === meshId);
+      if (!mesh) return void 0;
+      const node = mesh.nodes.find((n) => n.id === nodeId);
+      if (!node) return void 0;
+      if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
+      if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveMeshConfig(config2);
+      return node;
+    }
+    var import_fs2;
+    var import_path22;
+    var import_crypto32;
+    var init_mesh_config = __esm2({
+      "src/config/mesh-config.ts"() {
+        "use strict";
+        import_fs2 = require("fs");
+        import_path22 = require("path");
+        import_crypto32 = require("crypto");
+        init_config();
+        init_repo_mesh_types();
+      }
+    });
+    var coordinator_prompt_exports = {};
+    __export2(coordinator_prompt_exports, {
+      buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt
+    });
+    function buildCoordinatorSystemPrompt(ctx) {
+      const { mesh, status, userInstruction } = 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.
+
+Your mesh: **${mesh.name}**
+Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `
+Default branch: \`${mesh.defaultBranch}\`` : ""}`);
+      if (status?.nodes?.length) {
+        sections.push(buildNodeStatusSection(status.nodes));
+      } else if (mesh.nodes.length) {
+        sections.push(buildNodeConfigSection(mesh));
+      } 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(TOOLS_SECTION);
+      sections.push(WORKFLOW_SECTION);
+      sections.push(RULES_SECTION);
+      if (userInstruction) {
+        sections.push(`## Additional Context
+${userInstruction}`);
+      }
+      if (mesh.coordinator.systemPromptSuffix) {
+        sections.push(mesh.coordinator.systemPromptSuffix);
+      }
+      return sections.join("\n\n");
+    }
+    function buildNodeStatusSection(nodes) {
+      const lines = ["## Current Node Status", ""];
+      for (const n of nodes) {
+        const healthIcon = n.health === "online" ? "\u{1F7E2}" : n.health === "dirty" ? "\u{1F7E1}" : n.health === "offline" ? "\u26AB" : "\u{1F534}";
+        const sessions = n.activeSessions.length > 0 ? `sessions: ${n.activeSessions.join(", ")}` : "no active sessions";
+        const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : "";
+        lines.push(`- ${healthIcon} **${n.machineLabel}** (${n.nodeId})`);
+        lines.push(`  workspace: \`${n.workspace}\` | ${branch} | ${sessions}`);
+        if (n.error) lines.push(`  \u26A0\uFE0F ${n.error}`);
+      }
+      return lines.join("\n");
+    }
+    function buildNodeConfigSection(mesh) {
+      const lines = ["## Configured Nodes", ""];
+      for (const n of mesh.nodes) {
+        const labels = [];
+        if (n.isLocalWorktree) labels.push("worktree");
+        if (n.policy.readOnly) labels.push("read-only");
+        const suffix = labels.length ? ` [${labels.join(", ")}]` : "";
+        lines.push(`- **${n.workspace}** (${n.id})${suffix}`);
+      }
+      lines.push("", "_Use `mesh_status` to probe live health before delegating work._");
+      return lines.join("\n");
+    }
+    function buildPolicySection(policy) {
+      const rules = [];
+      if (policy.requirePreTaskCheckpoint) rules.push("- Create a git checkpoint **before** starting each task");
+      if (policy.requirePostTaskCheckpoint) rules.push("- Create a git checkpoint **after** each task completes");
+      if (policy.requireApprovalForPush) rules.push("- **Ask for user approval** before pushing to remote");
+      if (policy.requireApprovalForDestructiveGit) rules.push("- **Ask for user approval** before destructive git operations (force push, reset, etc.)");
+      const dirtyBehavior = {
+        block: "- **Do not** send tasks to nodes with dirty workspaces",
+        warn: "- Warn the user if a node has uncommitted changes before sending a task",
+        checkpoint_then_continue: "- Auto-checkpoint dirty nodes before sending tasks"
+      }[policy.dirtyWorkspaceBehavior] || "";
+      if (dirtyBehavior) rules.push(dirtyBehavior);
+      rules.push(`- Maximum **${policy.maxParallelTasks}** tasks running in parallel`);
+      return `## Policy
+${rules.join("\n")}`;
+    }
+    var TOOLS_SECTION;
+    var WORKFLOW_SECTION;
+    var RULES_SECTION;
+    var init_coordinator_prompt = __esm2({
+      "src/mesh/coordinator-prompt.ts"() {
+        "use strict";
+        TOOLS_SECTION = `## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`mesh_status\` | Check all nodes' health, git state, and active sessions |
+| \`mesh_list_nodes\` | List nodes with workspace paths |
+| \`mesh_launch_session\` | Start a new agent session on a node |
+| \`mesh_send_task\` | Send a task (natural language) to a running agent |
+| \`mesh_read_chat\` | Read an agent's recent messages to check progress |
+| \`mesh_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 |`;
+        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 clear, self-contained natural-language instruction.
+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
+
+- **Be conversational.** Delegate work the way a tech lead would \u2014 clear, specific instructions in natural language.
+- **Don't inspect code.** Trust the agent's output. Verify via git diff/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.
+- **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.`;
+      }
+    });
     function setLogLevel(level) {
       currentLevel = level;
       daemonLog("Logger", `Log level set to: ${level}`, "info");
@@ -31381,14 +31665,7 @@ var require_dist2 = __commonJS({
       upsertSavedProviderSession: () => upsertSavedProviderSession
     });
     module2.exports = __toCommonJS2(index_exports);
-    var DEFAULT_MESH_POLICY = {
-      requirePreTaskCheckpoint: false,
-      requirePostTaskCheckpoint: true,
-      requireApprovalForPush: true,
-      requireApprovalForDestructiveGit: true,
-      dirtyWorkspaceBehavior: "warn",
-      maxParallelTasks: 2
-    };
+    init_repo_mesh_types();
     var import_node_child_process = require("child_process");
     var import_node_fs3 = require("fs");
     var import_promises4 = require("fs/promises");
@@ -33063,337 +33340,104 @@ var require_dist2 = __commonJS({
         return ["task_complete", target, lastMessageHash, String(timestamp)].join("|");
       })();
       const dismissedNotificationId = typeof overlay.dismissedNotificationId === "string" ? overlay.dismissedNotificationId.trim() : "";
-      const unreadNotificationId = typeof overlay.unreadNotificationId === "string" ? overlay.unreadNotificationId.trim() : "";
-      if (unreadNotificationId && (currentNotificationId === unreadNotificationId || taskCompleteNotificationId === unreadNotificationId)) {
-        const forcedInboxBucket = session.inboxBucket === "needs_attention" || session.status === "waiting_approval" ? "needs_attention" : "task_complete";
-        return {
-          unread: true,
-          inboxBucket: forcedInboxBucket
-        };
-      }
-      if (!currentNotificationId || !dismissedNotificationId || currentNotificationId !== dismissedNotificationId) {
-        return {
-          unread: !!session.unread,
-          inboxBucket: session.inboxBucket || "idle"
-        };
-      }
-      return {
-        unread: false,
-        inboxBucket: "idle"
-      };
-    }
-    function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker, providerSessionId) {
-      const prev = state.sessionReads || {};
-      const prevMarkers = state.sessionReadMarkers || {};
-      const nextMarker = typeof completionMarker === "string" ? completionMarker : "";
-      const readKeys = Array.from(new Set([
-        sessionId,
-        buildSessionReadStateKey(sessionId, providerSessionId)
-      ].filter(Boolean)));
-      const nextSessionReads = { ...prev };
-      const nextSessionReadMarkers = { ...prevMarkers };
-      const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
-      const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-      for (const key of readKeys) {
-        nextSessionReads[key] = Math.max(prev[key] || 0, seenAt);
-        if (nextMarker) nextSessionReadMarkers[key] = nextMarker;
-        delete nextSessionNotificationDismissals[key];
-        delete nextSessionNotificationUnreadOverrides[key];
-      }
-      return {
-        ...state,
-        sessionReads: nextSessionReads,
-        sessionReadMarkers: nextMarker ? nextSessionReadMarkers : prevMarkers,
-        sessionNotificationDismissals: nextSessionNotificationDismissals,
-        sessionNotificationUnreadOverrides: nextSessionNotificationUnreadOverrides
-      };
-    }
-    var path6 = __toESM2(require("path"));
-    var MAX_SAVED_SESSIONS = 500;
-    function normalizeWorkspace2(workspace) {
-      if (!workspace) return "";
-      try {
-        return path6.resolve(expandPath(workspace));
-      } catch {
-        return path6.resolve(workspace);
-      }
-    }
-    function buildSavedProviderSessionKey(providerSessionId) {
-      return `saved:${providerSessionId.trim()}`;
-    }
-    function upsertSavedProviderSession(state, entry) {
-      const providerSessionId = typeof entry.providerSessionId === "string" ? entry.providerSessionId.trim() : "";
-      if (!providerSessionId) return state;
-      const id = buildSavedProviderSessionKey(providerSessionId);
-      const existing = (state.savedProviderSessions || []).find((item) => item.id === id);
-      const nextEntry = {
-        id,
-        kind: entry.kind,
-        providerType: entry.providerType,
-        providerName: entry.providerName,
-        providerSessionId,
-        workspace: entry.workspace ? normalizeWorkspace2(entry.workspace) : void 0,
-        summaryMetadata: normalizePersistedSummaryMetadata({
-          summaryMetadata: entry.summaryMetadata
-        }),
-        title: entry.title,
-        createdAt: existing?.createdAt || entry.createdAt || Date.now(),
-        lastUsedAt: entry.lastUsedAt || Date.now()
-      };
-      const filtered = (state.savedProviderSessions || []).filter((item) => item.id !== id);
-      return {
-        ...state,
-        savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS)
-      };
-    }
-    function getSavedProviderSessions(state, filters) {
-      return [...state.savedProviderSessions || []].filter((entry) => {
-        if (filters?.providerType && entry.providerType !== filters.providerType) return false;
-        if (filters?.kind && entry.kind !== filters.kind) return false;
-        return true;
-      }).map((entry) => ({
-        ...entry,
-        summaryMetadata: normalizePersistedSummaryMetadata({
-          summaryMetadata: entry.summaryMetadata
-        })
-      })).sort((a, b2) => b2.lastUsedAt - a.lastUsedAt);
-    }
-    var import_fs2 = require("fs");
-    var import_path22 = require("path");
-    var import_crypto32 = require("crypto");
-    init_config();
-    function getMeshConfigPath() {
-      return (0, import_path22.join)(getConfigDir(), "meshes.json");
-    }
-    function loadMeshConfig() {
-      const path26 = getMeshConfigPath();
-      if (!(0, import_fs2.existsSync)(path26)) return { meshes: [] };
-      try {
-        const raw = JSON.parse((0, import_fs2.readFileSync)(path26, "utf-8"));
-        if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
-        return raw;
-      } catch {
-        return { meshes: [] };
-      }
-    }
-    function saveMeshConfig(config2) {
-      const path26 = getMeshConfigPath();
-      (0, import_fs2.writeFileSync)(path26, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
-    }
-    function normalizeRepoIdentity(remoteUrl) {
-      let identity = remoteUrl.trim();
-      if (identity.startsWith("http://") || identity.startsWith("https://")) {
-        try {
-          const url2 = new URL(identity);
-          const path26 = url2.pathname.replace(/^\//, "").replace(/\.git$/, "");
-          return `${url2.hostname}/${path26}`;
-        } catch {
-        }
-      }
-      const sshMatch = identity.match(/^(?:ssh:\/\/)?[\w.-]+@([\w.-]+)[:/]([\w.\-/]+?)(?:\.git)?$/);
-      if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
-      return identity;
-    }
-    function listMeshes() {
-      return loadMeshConfig().meshes;
-    }
-    function getMesh(meshId) {
-      return loadMeshConfig().meshes.find((m) => m.id === meshId);
-    }
-    function getMeshByRepo(repoIdentity) {
-      return loadMeshConfig().meshes.find((m) => m.repoIdentity === repoIdentity);
-    }
-    function createMesh(opts) {
-      const config2 = loadMeshConfig();
-      if (config2.meshes.length >= 20) {
-        throw new Error("Maximum 20 meshes allowed");
-      }
-      const repoIdentity = opts.repoIdentity || (opts.repoRemoteUrl ? normalizeRepoIdentity(opts.repoRemoteUrl) : "");
-      if (!repoIdentity) throw new Error("Either repoRemoteUrl or repoIdentity is required");
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const mesh = {
-        id: `mesh_${(0, import_crypto32.randomUUID)().replace(/-/g, "")}`,
-        name: opts.name.trim().slice(0, 100),
-        repoIdentity,
-        repoRemoteUrl: opts.repoRemoteUrl,
-        defaultBranch: opts.defaultBranch,
-        policy: { ...DEFAULT_MESH_POLICY, ...opts.policy },
-        coordinator: opts.coordinator || {},
-        nodes: [],
-        createdAt: now,
-        updatedAt: now
-      };
-      config2.meshes.push(mesh);
-      saveMeshConfig(config2);
-      return mesh;
-    }
-    function updateMesh(meshId, opts) {
-      const config2 = loadMeshConfig();
-      const mesh = config2.meshes.find((m) => m.id === meshId);
-      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.coordinator) mesh.coordinator = opts.coordinator;
-      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      saveMeshConfig(config2);
-      return mesh;
-    }
-    function deleteMesh(meshId) {
-      const config2 = loadMeshConfig();
-      const idx = config2.meshes.findIndex((m) => m.id === meshId);
-      if (idx === -1) return false;
-      config2.meshes.splice(idx, 1);
-      saveMeshConfig(config2);
-      return true;
-    }
-    function addNode(meshId, opts) {
-      const config2 = loadMeshConfig();
-      const mesh = config2.meshes.find((m) => m.id === meshId);
-      if (!mesh) return void 0;
-      if (mesh.nodes.length >= 10) {
-        throw new Error("Maximum 10 nodes per mesh");
-      }
-      if (mesh.nodes.some((n) => n.workspace === opts.workspace)) {
-        throw new Error("This workspace is already in the mesh");
-      }
-      const node = {
-        id: `node_${(0, import_crypto32.randomUUID)().replace(/-/g, "")}`,
-        workspace: opts.workspace.trim(),
-        repoRoot: opts.repoRoot,
-        userOverrides: opts.userOverrides || {},
-        policy: opts.policy || {},
-        isLocalWorktree: opts.isLocalWorktree
-      };
-      mesh.nodes.push(node);
-      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      saveMeshConfig(config2);
-      return node;
-    }
-    function removeNode(meshId, nodeId) {
-      const config2 = loadMeshConfig();
-      const mesh = config2.meshes.find((m) => m.id === meshId);
-      if (!mesh) return false;
-      const idx = mesh.nodes.findIndex((n) => n.id === nodeId);
-      if (idx === -1) return false;
-      mesh.nodes.splice(idx, 1);
-      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      saveMeshConfig(config2);
-      return true;
-    }
-    function updateNode(meshId, nodeId, opts) {
-      const config2 = loadMeshConfig();
-      const mesh = config2.meshes.find((m) => m.id === meshId);
-      if (!mesh) return void 0;
-      const node = mesh.nodes.find((n) => n.id === nodeId);
-      if (!node) return void 0;
-      if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
-      if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
-      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      saveMeshConfig(config2);
-      return node;
-    }
-    function buildCoordinatorSystemPrompt(ctx) {
-      const { mesh, status, userInstruction } = 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.
-
-Your mesh: **${mesh.name}**
-Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `
-Default branch: \`${mesh.defaultBranch}\`` : ""}`);
-      if (status?.nodes?.length) {
-        sections.push(buildNodeStatusSection(status.nodes));
-      } else if (mesh.nodes.length) {
-        sections.push(buildNodeConfigSection(mesh));
-      } 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(TOOLS_SECTION);
-      sections.push(WORKFLOW_SECTION);
-      sections.push(RULES_SECTION);
-      if (userInstruction) {
-        sections.push(`## Additional Context
-${userInstruction}`);
+      const unreadNotificationId = typeof overlay.unreadNotificationId === "string" ? overlay.unreadNotificationId.trim() : "";
+      if (unreadNotificationId && (currentNotificationId === unreadNotificationId || taskCompleteNotificationId === unreadNotificationId)) {
+        const forcedInboxBucket = session.inboxBucket === "needs_attention" || session.status === "waiting_approval" ? "needs_attention" : "task_complete";
+        return {
+          unread: true,
+          inboxBucket: forcedInboxBucket
+        };
       }
-      if (mesh.coordinator.systemPromptSuffix) {
-        sections.push(mesh.coordinator.systemPromptSuffix);
+      if (!currentNotificationId || !dismissedNotificationId || currentNotificationId !== dismissedNotificationId) {
+        return {
+          unread: !!session.unread,
+          inboxBucket: session.inboxBucket || "idle"
+        };
       }
-      return sections.join("\n\n");
+      return {
+        unread: false,
+        inboxBucket: "idle"
+      };
     }
-    function buildNodeStatusSection(nodes) {
-      const lines = ["## Current Node Status", ""];
-      for (const n of nodes) {
-        const healthIcon = n.health === "online" ? "\u{1F7E2}" : n.health === "dirty" ? "\u{1F7E1}" : n.health === "offline" ? "\u26AB" : "\u{1F534}";
-        const sessions = n.activeSessions.length > 0 ? `sessions: ${n.activeSessions.join(", ")}` : "no active sessions";
-        const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : "";
-        lines.push(`- ${healthIcon} **${n.machineLabel}** (${n.nodeId})`);
-        lines.push(`  workspace: \`${n.workspace}\` | ${branch} | ${sessions}`);
-        if (n.error) lines.push(`  \u26A0\uFE0F ${n.error}`);
+    function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker, providerSessionId) {
+      const prev = state.sessionReads || {};
+      const prevMarkers = state.sessionReadMarkers || {};
+      const nextMarker = typeof completionMarker === "string" ? completionMarker : "";
+      const readKeys = Array.from(new Set([
+        sessionId,
+        buildSessionReadStateKey(sessionId, providerSessionId)
+      ].filter(Boolean)));
+      const nextSessionReads = { ...prev };
+      const nextSessionReadMarkers = { ...prevMarkers };
+      const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
+      const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
+      for (const key of readKeys) {
+        nextSessionReads[key] = Math.max(prev[key] || 0, seenAt);
+        if (nextMarker) nextSessionReadMarkers[key] = nextMarker;
+        delete nextSessionNotificationDismissals[key];
+        delete nextSessionNotificationUnreadOverrides[key];
       }
-      return lines.join("\n");
+      return {
+        ...state,
+        sessionReads: nextSessionReads,
+        sessionReadMarkers: nextMarker ? nextSessionReadMarkers : prevMarkers,
+        sessionNotificationDismissals: nextSessionNotificationDismissals,
+        sessionNotificationUnreadOverrides: nextSessionNotificationUnreadOverrides
+      };
     }
-    function buildNodeConfigSection(mesh) {
-      const lines = ["## Configured Nodes", ""];
-      for (const n of mesh.nodes) {
-        const labels = [];
-        if (n.isLocalWorktree) labels.push("worktree");
-        if (n.policy.readOnly) labels.push("read-only");
-        const suffix = labels.length ? ` [${labels.join(", ")}]` : "";
-        lines.push(`- **${n.workspace}** (${n.id})${suffix}`);
+    var path6 = __toESM2(require("path"));
+    var MAX_SAVED_SESSIONS = 500;
+    function normalizeWorkspace2(workspace) {
+      if (!workspace) return "";
+      try {
+        return path6.resolve(expandPath(workspace));
+      } catch {
+        return path6.resolve(workspace);
       }
-      lines.push("", "_Use `mesh_status` to probe live health before delegating work._");
-      return lines.join("\n");
     }
-    function buildPolicySection(policy) {
-      const rules = [];
-      if (policy.requirePreTaskCheckpoint) rules.push("- Create a git checkpoint **before** starting each task");
-      if (policy.requirePostTaskCheckpoint) rules.push("- Create a git checkpoint **after** each task completes");
-      if (policy.requireApprovalForPush) rules.push("- **Ask for user approval** before pushing to remote");
-      if (policy.requireApprovalForDestructiveGit) rules.push("- **Ask for user approval** before destructive git operations (force push, reset, etc.)");
-      const dirtyBehavior = {
-        block: "- **Do not** send tasks to nodes with dirty workspaces",
-        warn: "- Warn the user if a node has uncommitted changes before sending a task",
-        checkpoint_then_continue: "- Auto-checkpoint dirty nodes before sending tasks"
-      }[policy.dirtyWorkspaceBehavior] || "";
-      if (dirtyBehavior) rules.push(dirtyBehavior);
-      rules.push(`- Maximum **${policy.maxParallelTasks}** tasks running in parallel`);
-      return `## Policy
-${rules.join("\n")}`;
+    function buildSavedProviderSessionKey(providerSessionId) {
+      return `saved:${providerSessionId.trim()}`;
     }
-    var TOOLS_SECTION = `## Available Tools
-
-| Tool | Purpose |
-|------|---------|
-| \`mesh_status\` | Check all nodes' health, git state, and active sessions |
-| \`mesh_list_nodes\` | List nodes with workspace paths |
-| \`mesh_launch_session\` | Start a new agent session on a node |
-| \`mesh_send_task\` | Send a task (natural language) to a running agent |
-| \`mesh_read_chat\` | Read an agent's recent messages to check progress |
-| \`mesh_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 |`;
-    var 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 clear, self-contained natural-language instruction.
-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.`;
-    var RULES_SECTION = `## Rules
-
-- **Be conversational.** Delegate work the way a tech lead would \u2014 clear, specific instructions in natural language.
-- **Don't inspect code.** Trust the agent's output. Verify via git diff/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.
-- **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.`;
+    function upsertSavedProviderSession(state, entry) {
+      const providerSessionId = typeof entry.providerSessionId === "string" ? entry.providerSessionId.trim() : "";
+      if (!providerSessionId) return state;
+      const id = buildSavedProviderSessionKey(providerSessionId);
+      const existing = (state.savedProviderSessions || []).find((item) => item.id === id);
+      const nextEntry = {
+        id,
+        kind: entry.kind,
+        providerType: entry.providerType,
+        providerName: entry.providerName,
+        providerSessionId,
+        workspace: entry.workspace ? normalizeWorkspace2(entry.workspace) : void 0,
+        summaryMetadata: normalizePersistedSummaryMetadata({
+          summaryMetadata: entry.summaryMetadata
+        }),
+        title: entry.title,
+        createdAt: existing?.createdAt || entry.createdAt || Date.now(),
+        lastUsedAt: entry.lastUsedAt || Date.now()
+      };
+      const filtered = (state.savedProviderSessions || []).filter((item) => item.id !== id);
+      return {
+        ...state,
+        savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS)
+      };
+    }
+    function getSavedProviderSessions(state, filters) {
+      return [...state.savedProviderSessions || []].filter((entry) => {
+        if (filters?.providerType && entry.providerType !== filters.providerType) return false;
+        if (filters?.kind && entry.kind !== filters.kind) return false;
+        return true;
+      }).map((entry) => ({
+        ...entry,
+        summaryMetadata: normalizePersistedSummaryMetadata({
+          summaryMetadata: entry.summaryMetadata
+        })
+      })).sort((a, b2) => b2.lastUsedAt - a.lastUsedAt);
+    }
+    init_mesh_config();
+    init_coordinator_prompt();
+    init_mesh_config();
     async function syncMeshes(transport) {
       const result = { pushed: 0, pulled: 0, deleted: 0, errors: [] };
       let remoteMeshes;
@@ -45210,6 +45254,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "type",
       "name",
       "category",
+      "transcriptAuthority",
+      "transcriptContext",
       "aliases",
       "cdpPorts",
       "targetFilter",
@@ -45254,6 +45300,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "staticConfigOptions",
       "spawnArgBuilder",
       "auth",
+      "meshCoordinator",
       "contractVersion",
       "capabilities",
       "providerVersion",
@@ -45311,6 +45358,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       validateCapabilities(provider, controls, errors);
       validateCanonicalHistory(provider.canonicalHistory, errors);
+      validateMeshCoordinator(provider.meshCoordinator, errors);
       for (const control of controls) {
         validateControl(control, errors);
       }
@@ -45401,6 +45449,60 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       }
     }
+    function validateMeshCoordinator(raw, errors) {
+      if (raw === void 0) return;
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        errors.push("meshCoordinator must be an object");
+        return;
+      }
+      const meshCoordinator = raw;
+      if (typeof meshCoordinator.supported !== "boolean") {
+        errors.push("meshCoordinator.supported must be boolean");
+      }
+      if (meshCoordinator.reason !== void 0 && (typeof meshCoordinator.reason !== "string" || !meshCoordinator.reason.trim())) {
+        errors.push("meshCoordinator.reason must be a non-empty string when provided");
+      }
+      const mcpConfig = meshCoordinator.mcpConfig;
+      if (mcpConfig === void 0) return;
+      if (!mcpConfig || typeof mcpConfig !== "object" || Array.isArray(mcpConfig)) {
+        errors.push("meshCoordinator.mcpConfig must be an object");
+        return;
+      }
+      const config2 = mcpConfig;
+      const mode = config2.mode;
+      if (!["auto_import", "manual", "none"].includes(String(mode))) {
+        errors.push("meshCoordinator.mcpConfig.mode must be one of: auto_import, manual, none");
+      }
+      const format = config2.format;
+      if (format !== void 0 && !["claude_mcp_json", "hermes_config_yaml"].includes(String(format))) {
+        errors.push("meshCoordinator.mcpConfig.format must be one of: claude_mcp_json, hermes_config_yaml");
+      }
+      for (const key of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
+        const value = config2[key];
+        if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
+          errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`);
+        }
+      }
+      if (config2.requiresRestart !== void 0 && typeof config2.requiresRestart !== "boolean") {
+        errors.push("meshCoordinator.mcpConfig.requiresRestart must be boolean when provided");
+      }
+      if (mode === "auto_import") {
+        if (format === void 0) {
+          errors.push("meshCoordinator.mcpConfig.format is required for auto_import MCP setup");
+        }
+        if (typeof config2.path !== "string" || !config2.path.trim()) {
+          errors.push("meshCoordinator.mcpConfig.path is required for auto_import MCP setup");
+        }
+      }
+      if (mode === "manual") {
+        if (typeof config2.instructions !== "string" || !config2.instructions.trim()) {
+          errors.push("meshCoordinator.mcpConfig.instructions is required for manual MCP setup");
+        }
+        if (typeof config2.template !== "string" || !config2.template.trim()) {
+          errors.push("meshCoordinator.mcpConfig.template is required for manual MCP setup");
+        }
+      }
+    }
     function validateControl(control, errors) {
       if (!control || typeof control !== "object") {
         errors.push("controls: each control must be an object");
@@ -47543,6 +47645,67 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     cleanOldFiles();
     init_logger();
+    var import_path4 = require("path");
+    var DEFAULT_SERVER_NAME = "adhdev-mesh";
+    var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
+    function resolveMeshCoordinatorSetup(options) {
+      const { provider, meshId, workspace } = options;
+      const config2 = provider?.meshCoordinator;
+      if (!config2?.supported) {
+        return {
+          kind: "unsupported",
+          reason: config2?.reason || "Provider does not declare Repo Mesh coordinator support"
+        };
+      }
+      const mcpConfig = config2.mcpConfig;
+      if (!mcpConfig || mcpConfig.mode === "none") {
+        return {
+          kind: "unsupported",
+          reason: config2.reason || "Provider does not declare a usable Repo Mesh MCP configuration mode"
+        };
+      }
+      const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
+      if (mcpConfig.mode === "auto_import") {
+        const path26 = mcpConfig.path?.trim();
+        if (!path26) {
+          return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
+        }
+        return {
+          kind: "auto_import",
+          serverName,
+          configPath: (0, import_path4.join)(workspace, path26),
+          configFormat: mcpConfig.format
+        };
+      }
+      if (mcpConfig.mode === "manual") {
+        const instructions = mcpConfig.instructions?.trim();
+        const template = mcpConfig.template;
+        if (!instructions || !template?.trim()) {
+          return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
+        }
+        return {
+          kind: "manual",
+          serverName,
+          configFormat: mcpConfig.format,
+          configPathCommand: mcpConfig.configPathCommand,
+          requiresRestart: mcpConfig.requiresRestart === true,
+          instructions,
+          template: renderMeshCoordinatorTemplate(template, {
+            meshId,
+            workspace,
+            serverName,
+            adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
+          })
+        };
+      }
+      return {
+        kind: "unsupported",
+        reason: `Unsupported Repo Mesh MCP configuration mode: ${String(mcpConfig.mode)}`
+      };
+    }
+    function renderMeshCoordinatorTemplate(template, values) {
+      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key) => values[key] || "");
+    }
     var os17 = __toESM2(require("os"));
     init_config();
     init_terminal_screen();
@@ -47593,7 +47756,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         ...provider.enabled !== void 0 ? { enabled: provider.enabled } : {},
         ...provider.machineStatus !== void 0 ? { machineStatus: provider.machineStatus } : {},
         ...provider.lastDetection !== void 0 ? { lastDetection: provider.lastDetection } : {},
-        ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {}
+        ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {},
+        ...provider.meshCoordinator !== void 0 ? { meshCoordinator: provider.meshCoordinator } : {}
       }));
     }
     function buildMachineInfo2(profile = "full") {
@@ -48914,6 +49078,178 @@ Run 'adhdev doctor' for detailed diagnostics.`
             updateConfig({ machineNickname: nickname || null });
             return { success: true };
           }
+          // ─── Mesh CRUD (local meshes.json) ───
+          case "list_meshes": {
+            try {
+              const { listMeshes: listMeshes2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              return { success: true, meshes: listMeshes2() };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "get_mesh": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const mesh = getMesh3(meshId);
+              if (!mesh) return { success: false, error: "Mesh not found" };
+              return { success: true, mesh };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "create_mesh": {
+            const name = typeof args?.name === "string" ? args.name.trim() : "";
+            const repoIdentity = typeof args?.repoIdentity === "string" ? args.repoIdentity.trim() : "";
+            const repoRemoteUrl = typeof args?.repoRemoteUrl === "string" ? args.repoRemoteUrl.trim() : void 0;
+            const defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
+            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 });
+              return { success: true, mesh };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "delete_mesh": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { deleteMesh: deleteMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const deleted = deleteMesh3(meshId);
+              return { success: true, deleted };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "add_mesh_node": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            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 });
+              if (!node) return { success: false, error: "Mesh not found" };
+              return { success: true, node };
+            } 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 };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          // ─── 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";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
+              const mesh = getMesh3(meshId);
+              if (!mesh) return { success: false, error: "Mesh not found" };
+              if (mesh.nodes.length === 0) return { success: false, error: "No nodes in mesh" };
+              const workspace = mesh.nodes[0].workspace;
+              const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
+              const coordinatorSetup = resolveMeshCoordinatorSetup({
+                provider: providerMeta,
+                meshId,
+                workspace
+              });
+              if (coordinatorSetup.kind === "unsupported") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_unsupported",
+                  error: coordinatorSetup.reason,
+                  meshId,
+                  cliType,
+                  workspace
+                };
+              }
+              if (coordinatorSetup.kind === "manual") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_manual_mcp_setup_required",
+                  error: coordinatorSetup.instructions,
+                  meshId,
+                  cliType,
+                  workspace,
+                  meshCoordinatorSetup: coordinatorSetup
+                };
+              }
+              if (coordinatorSetup.configFormat !== "claude_mcp_json") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_unsupported",
+                  error: `Unsupported auto-import MCP config format: ${String(coordinatorSetup.configFormat)}`,
+                  meshId,
+                  cliType,
+                  workspace
+                };
+              }
+              const { existsSync: existsSync21, readFileSync: readFileSync15, writeFileSync: writeFileSync12, copyFileSync: copyFileSync3 } = await import("fs");
+              const mcpConfigPath = coordinatorSetup.configPath;
+              const hadExistingMcpConfig = existsSync21(mcpConfigPath);
+              let existingMcpConfig = {};
+              if (hadExistingMcpConfig) {
+                try {
+                  existingMcpConfig = JSON.parse(readFileSync15(mcpConfigPath, "utf-8"));
+                  copyFileSync3(mcpConfigPath, mcpConfigPath + ".backup");
+                } catch {
+                }
+              }
+              const mcpConfig = {
+                ...existingMcpConfig,
+                mcpServers: {
+                  ...existingMcpConfig.mcpServers || {},
+                  [coordinatorSetup.serverName]: {
+                    command: "adhdev-mcp",
+                    args: ["--repo-mesh", meshId]
+                  }
+                }
+              };
+              writeFileSync12(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+              LOG2.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).`;
+              }
+              const launchResult = await this.deps.cliManager.handleCliCommand("launch_cli", {
+                cliType,
+                dir: workspace,
+                initialPrompt: systemPrompt
+              });
+              if (!launchResult?.success) {
+                return { success: false, error: launchResult?.error || "Failed to launch CLI session" };
+              }
+              LOG2.info("MeshCoordinator", `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+              return {
+                success: true,
+                meshId,
+                cliType,
+                workspace,
+                sessionId: launchResult.sessionId || launchResult.id,
+                mcpConfigWritten: true
+              };
+            } catch (e) {
+              LOG2.error("MeshCoordinator", `Failed: ${e.message}`);
+              return { success: false, error: e.message };
+            }
+          }
           default:
             break;
         }