adhdev 0.9.66 → 0.9.68

package/dist/cli/index.js

@@ -554,6 +554,22 @@ var init_source = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/repo-mesh-types.ts
+var DEFAULT_MESH_POLICY;
+var init_repo_mesh_types = __esm({
+  "../../oss/packages/daemon-core/src/repo-mesh-types.ts"() {
+    "use strict";
+    DEFAULT_MESH_POLICY = {
+      requirePreTaskCheckpoint: false,
+      requirePostTaskCheckpoint: true,
+      requireApprovalForPush: true,
+      requireApprovalForDestructiveGit: true,
+      dirtyWorkspaceBehavior: "warn",
+      maxParallelTasks: 2
+    };
+  }
+});
+
 // ../../oss/packages/daemon-core/src/git/git-executor.ts
 async function resolveGitRepository(workspace, options = {}) {
   const normalizedWorkspace = await validateWorkspace(workspace);
@@ -2682,12 +2698,343 @@ var init_saved_sessions = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/config/mesh-config.ts
+var mesh_config_exports = {};
+__export(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_path2.join)(getConfigDir(), "meshes.json");
+}
+function loadMeshConfig() {
+  const path40 = getMeshConfigPath();
+  if (!(0, import_fs2.existsSync)(path40)) return { meshes: [] };
+  try {
+    const raw = JSON.parse((0, import_fs2.readFileSync)(path40, "utf-8"));
+    if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
+    return raw;
+  } catch {
+    return { meshes: [] };
+  }
+}
+function saveMeshConfig(config2) {
+  const path40 = getMeshConfigPath();
+  (0, import_fs2.writeFileSync)(path40, 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 path40 = url2.pathname.replace(/^\//, "").replace(/\.git$/, "");
+      return `${url2.hostname}/${path40}`;
+    } 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_crypto3.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_crypto3.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, import_path2, import_crypto3;
+var init_mesh_config = __esm({
+  "../../oss/packages/daemon-core/src/config/mesh-config.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+    import_crypto3 = require("crypto");
+    init_config();
+    init_repo_mesh_types();
+  }
+});
+
+// ../../oss/packages/daemon-core/src/mesh/coordinator-prompt.ts
+var coordinator_prompt_exports = {};
+__export(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, WORKFLOW_SECTION, RULES_SECTION;
+var init_coordinator_prompt = __esm({
+  "../../oss/packages/daemon-core/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.`;
+  }
+});
+
+// ../../oss/packages/daemon-core/src/mesh/mesh-sync.ts
+async function syncMeshes(transport) {
+  const result = { pushed: 0, pulled: 0, deleted: 0, errors: [] };
+  let remoteMeshes;
+  try {
+    const res = await transport.listRemoteMeshes();
+    remoteMeshes = res.meshes;
+  } catch (e) {
+    result.errors.push(`Failed to list remote meshes: ${e.message}`);
+    return result;
+  }
+  const localMeshes = listMeshes();
+  const remoteByIdentity = new Map(remoteMeshes.map((m) => [m.repo_identity, m]));
+  const localByIdentity = new Map(localMeshes.map((m) => [m.repoIdentity, m]));
+  for (const local of localMeshes) {
+    if (!remoteByIdentity.has(local.repoIdentity)) {
+      try {
+        await transport.createRemoteMesh({
+          name: local.name,
+          repo_identity: local.repoIdentity,
+          repo_remote_url: local.repoRemoteUrl,
+          default_branch: local.defaultBranch,
+          policy: JSON.stringify(local.policy)
+        });
+        result.pushed++;
+      } catch (e) {
+        result.errors.push(`Push failed for "${local.name}": ${e.message}`);
+      }
+    }
+  }
+  for (const remote of remoteMeshes) {
+    if (!localByIdentity.has(remote.repo_identity)) {
+      try {
+        let policy;
+        try {
+          policy = JSON.parse(remote.policy);
+        } catch {
+          policy = void 0;
+        }
+        createMesh({
+          name: remote.name,
+          repoIdentity: remote.repo_identity,
+          repoRemoteUrl: remote.repo_remote_url || void 0,
+          defaultBranch: remote.default_branch || void 0,
+          policy
+        });
+        result.pulled++;
+      } catch (e) {
+        result.errors.push(`Pull failed for "${remote.name}": ${e.message}`);
+      }
+    }
+  }
+  return result;
+}
+var init_mesh_sync = __esm({
+  "../../oss/packages/daemon-core/src/mesh/mesh-sync.ts"() {
+    "use strict";
+    init_mesh_config();
+  }
+});
+
 // ../../oss/packages/daemon-core/src/config/state-store.ts
 function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return (0, import_path2.join)(getConfigDir(), "state.json");
+  return (0, import_path3.join)(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -2723,11 +3070,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs2.existsSync)(statePath)) {
+  if (!(0, import_fs3.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs2.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs3.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -2736,17 +3083,17 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs2.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs3.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
 }
-var import_fs2, import_path2, DEFAULT_STATE;
+var import_fs3, import_path3, DEFAULT_STATE;
 var init_state_store = __esm({
   "../../oss/packages/daemon-core/src/config/state-store.ts"() {
     "use strict";
-    import_fs2 = require("fs");
-    import_path2 = require("path");
+    import_fs3 = require("fs");
+    import_path3 = require("path");
     init_config();
     DEFAULT_STATE = {
       recentActivity: [],
@@ -2779,7 +3126,7 @@ function findCliCommand(command) {
   if (path7.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path7.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
     const resolved = path7.isAbsolute(candidate) ? candidate : path7.resolve(candidate);
-    return (0, import_fs3.existsSync)(resolved) ? resolved : null;
+    return (0, import_fs4.existsSync)(resolved) ? resolved : null;
   }
   try {
     const result = (0, import_child_process.execSync)(
@@ -2810,9 +3157,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if ((0, import_fs3.existsSync)(resolved)) return resolved;
+      if ((0, import_fs4.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs3.existsSync)(normalized)) return normalized;
+      if ((0, import_fs4.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -2826,7 +3173,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os31 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs3.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs4.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os31 === "win32") {
       const { dirname: dirname11 } = await import("path");
@@ -2839,7 +3186,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs3.existsSync)(c)) {
+        if ((0, import_fs4.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -2860,12 +3207,12 @@ async function detectIDEs(providerLoader) {
   }
   return results;
 }
-var import_child_process, import_fs3, import_os2, path7, BUILTIN_IDE_DEFINITIONS, registeredIDEs;
+var import_child_process, import_fs4, import_os2, path7, BUILTIN_IDE_DEFINITIONS, registeredIDEs;
 var init_ide_detector = __esm({
   "../../oss/packages/daemon-core/src/detection/ide-detector.ts"() {
     "use strict";
     import_child_process = require("child_process");
-    import_fs3 = require("fs");
+    import_fs4 = require("fs");
     import_os2 = require("os");
     path7 = __toESM(require("path"));
     BUILTIN_IDE_DEFINITIONS = [];
@@ -2897,7 +3244,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
-    return (0, import_fs4.existsSync)(candidate) ? candidate : null;
+    return (0, import_fs5.existsSync)(candidate) ? candidate : null;
   }
   return null;
 }
@@ -2997,14 +3344,14 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
-var import_child_process2, os3, path8, import_fs4;
+var import_child_process2, os3, path8, import_fs5;
 var init_cli_detector = __esm({
   "../../oss/packages/daemon-core/src/detection/cli-detector.ts"() {
     "use strict";
     import_child_process2 = require("child_process");
     os3 = __toESM(require("os"));
     path8 = __toESM(require("path"));
-    import_fs4 = require("fs");
+    import_fs5 = require("fs");
   }
 });
 
@@ -13173,16 +13520,16 @@ function ensureNodePtySpawnHelperPermissions(logFn) {
   } catch {
   }
 }
-var import_crypto3, path13, os10, path22, net, import_crypto4, os22, path32, __require, DEFAULT_SESSION_RING_BUFFER_MAX_BYTES, SessionRingBuffer, DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS, LIVE_LIFECYCLES2, SessionHostRegistry, SessionHostClient;
+var import_crypto4, path13, os10, path22, net, import_crypto5, os22, path32, __require, DEFAULT_SESSION_RING_BUFFER_MAX_BYTES, SessionRingBuffer, DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS, LIVE_LIFECYCLES2, SessionHostRegistry, SessionHostClient;
 var init_dist = __esm({
   "../../oss/packages/session-host-core/dist/index.mjs"() {
     "use strict";
-    import_crypto3 = require("crypto");
+    import_crypto4 = require("crypto");
     path13 = __toESM(require("path"), 1);
     os10 = __toESM(require("os"), 1);
     path22 = __toESM(require("path"), 1);
     net = __toESM(require("net"), 1);
-    import_crypto4 = require("crypto");
+    import_crypto5 = require("crypto");
     os22 = __toESM(require("os"), 1);
     path32 = __toESM(require("path"), 1);
     __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -13258,7 +13605,7 @@ var init_dist = __esm({
     SessionHostRegistry = class {
       sessions = /* @__PURE__ */ new Map();
       createSession(payload) {
-        const sessionId = payload.sessionId || (0, import_crypto3.randomUUID)();
+        const sessionId = payload.sessionId || (0, import_crypto4.randomUUID)();
         if (this.sessions.has(sessionId)) {
           throw new Error(`Session already exists: ${sessionId}`);
         }
@@ -13529,7 +13876,7 @@ var init_dist = __esm({
       async request(request) {
         await this.connect();
         if (!this.socket) throw new Error("Session host socket unavailable");
-        const requestId = (0, import_crypto4.randomUUID)();
+        const requestId = (0, import_crypto5.randomUUID)();
         const envelope = {
           kind: "request",
           requestId,
@@ -34565,7 +34912,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return (0, import_fs5.existsSync)(expandExecutable(trimmed));
+    return (0, import_fs6.existsSync)(expandExecutable(trimmed));
   }
   try {
     (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -34696,14 +35043,14 @@ function resolveCliSessionBinding(provider, normalizedType, cliArgs, requestedRe
     launchMode: "new"
   };
 }
-var os16, path17, crypto4, import_fs5, import_child_process6, chalkModule, chalkApi, DaemonCliManager;
+var os16, path17, crypto4, import_fs6, import_child_process6, chalkModule, chalkApi, DaemonCliManager;
 var init_cli_manager = __esm({
   "../../oss/packages/daemon-core/src/commands/cli-manager.ts"() {
     "use strict";
     os16 = __toESM(require("os"));
     path17 = __toESM(require("path"));
     crypto4 = __toESM(require("crypto"));
-    import_fs5 = require("fs");
+    import_fs6 = require("fs");
     import_child_process6 = require("child_process");
     init_source2();
     init_provider_cli_adapter();
@@ -38271,7 +38618,7 @@ var init_provider_loader = __esm({
           return { updated: false };
         }
         const https = require("https");
-        const { execSync: execSync8 } = require("child_process");
+        const { execSync: execSync9 } = require("child_process");
         const metaPath = path18.join(this.upstreamDir, _ProviderLoader.META_FILE);
         let prevEtag = "";
         let prevTimestamp = 0;
@@ -38336,7 +38683,7 @@ var init_provider_loader = __esm({
           const tmpExtract = path18.join(os17.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
           await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
           fs7.mkdirSync(tmpExtract, { recursive: true });
-          execSync8(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
+          execSync9(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
           const extracted = fs7.readdirSync(tmpExtract);
           const rootDir = extracted.find(
             (d) => fs7.statSync(path18.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
@@ -40921,6 +41268,142 @@ var init_router = __esm({
             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 { existsSync: existsSync28, readFileSync: readFileSync21, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4 } = await import("fs");
+              const { join: join35 } = await import("path");
+              const mcpConfigPath = join35(workspace, ".mcp.json");
+              const hadExistingMcpConfig = existsSync28(mcpConfigPath);
+              let existingMcpConfig = {};
+              if (hadExistingMcpConfig) {
+                try {
+                  existingMcpConfig = JSON.parse(readFileSync21(mcpConfigPath, "utf-8"));
+                  copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
+                } catch {
+                }
+              }
+              const mcpConfig = {
+                ...existingMcpConfig,
+                mcpServers: {
+                  ...existingMcpConfig.mcpServers || {},
+                  "adhdev-mesh": {
+                    command: "adhdev-mcp",
+                    args: ["--repo-mesh", meshId]
+                  }
+                }
+              };
+              writeFileSync15(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+              LOG.info("MeshCoordinator", `Wrote .mcp.json to ${workspace} with adhdev-mesh 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" };
+              }
+              LOG.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) {
+              LOG.error("MeshCoordinator", `Failed: ${e.message}`);
+              return { success: false, error: e.message };
+            }
+          }
           default:
             break;
         }
@@ -49059,6 +49542,7 @@ __export(src_exports, {
   DEFAULT_DAEMON_PORT: () => DEFAULT_DAEMON_PORT,
   DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS: () => DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
   DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
+  DEFAULT_MESH_POLICY: () => DEFAULT_MESH_POLICY,
   DEFAULT_SESSION_HOST_APP_NAME: () => DEFAULT_SESSION_HOST_APP_NAME,
   DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_SESSION_HOST_READY_TIMEOUT_MS: () => DEFAULT_SESSION_HOST_READY_TIMEOUT_MS,
@@ -49092,11 +49576,13 @@ __export(src_exports, {
   SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
   TurnSnapshotTracker: () => TurnSnapshotTracker,
   VersionArchive: () => VersionArchive,
+  addNode: () => addNode,
   appendRecentActivity: () => appendRecentActivity,
   buildAssistantChatMessage: () => buildAssistantChatMessage,
   buildChatMessage: () => buildChatMessage,
   buildChatMessageSignature: () => buildChatMessageSignature,
   buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
+  buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
   buildMachineInfo: () => buildMachineInfo,
   buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
@@ -49119,6 +49605,8 @@ __export(src_exports, {
   createGitSnapshotStore: () => createGitSnapshotStore,
   createGitWorkspaceMonitor: () => createGitWorkspaceMonitor,
   createInteractionId: () => createInteractionId,
+  createMesh: () => createMesh,
+  deleteMesh: () => deleteMesh,
   detectAllVersions: () => detectAllVersions,
   detectCLIs: () => detectCLIs,
   detectIDEs: () => detectIDEs,
@@ -49137,6 +49625,8 @@ __export(src_exports, {
   getGitRepoStatus: () => getGitRepoStatus,
   getHostMemorySnapshot: () => getHostMemorySnapshot,
   getLogLevel: () => getLogLevel,
+  getMesh: () => getMesh,
+  getMeshByRepo: () => getMeshByRepo,
   getNpmExecOptions: () => getNpmExecOptions,
   getRecentActivity: () => getRecentActivity,
   getRecentCommands: () => getRecentCommands,
@@ -49167,6 +49657,7 @@ __export(src_exports, {
   launchIDE: () => launchIDE,
   launchWithCdp: () => launchWithCdp,
   listHostedCliRuntimes: () => listHostedCliRuntimes,
+  listMeshes: () => listMeshes,
   loadConfig: () => loadConfig,
   loadState: () => loadState,
   logCommand: () => logCommand,
@@ -49182,6 +49673,7 @@ __export(src_exports, {
   normalizeInputEnvelope: () => normalizeInputEnvelope,
   normalizeManagedStatus: () => normalizeManagedStatus,
   normalizeMessageParts: () => normalizeMessageParts,
+  normalizeRepoIdentity: () => normalizeRepoIdentity,
   normalizeSessionModalFields: () => normalizeSessionModalFields,
   parsePorcelainV2Status: () => parsePorcelainV2Status,
   parseProviderSourceConfigUpdate: () => parseProviderSourceConfigUpdate,
@@ -49193,6 +49685,7 @@ __export(src_exports, {
   readChatHistory: () => readChatHistory,
   recordDebugTrace: () => recordDebugTrace,
   registerExtensionProviders: () => registerExtensionProviders,
+  removeNode: () => removeNode,
   resetConfig: () => resetConfig,
   resetDebugRuntimeConfig: () => resetDebugRuntimeConfig,
   resetState: () => resetState,
@@ -49215,17 +49708,24 @@ __export(src_exports, {
   spawnDetachedDaemonUpgradeHelper: () => spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport: () => startDaemonDevSupport,
   summarizeGitStatus: () => summarizeGitStatus,
+  syncMeshes: () => syncMeshes,
   updateConfig: () => updateConfig,
+  updateMesh: () => updateMesh,
+  updateNode: () => updateNode,
   upsertSavedProviderSession: () => upsertSavedProviderSession
 });
 var init_src = __esm({
   "../../oss/packages/daemon-core/src/index.ts"() {
     "use strict";
+    init_repo_mesh_types();
     init_git();
     init_config();
     init_workspaces();
     init_recent_activity();
     init_saved_sessions();
+    init_mesh_config();
+    init_coordinator_prompt();
+    init_mesh_sync();
     init_state_store();
     init_ide_detector();
     init_cli_detector();
@@ -64071,7 +64571,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join34(s) {
+        value: function join35(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -78130,13 +78630,13 @@ function splitStringBySpace(str) {
   }
   return pieces;
 }
-var import_chardet, import_child_process12, import_fs6, import_node_path2, import_node_os4, import_node_crypto2, import_iconv_lite, ExternalEditor;
+var import_chardet, import_child_process12, import_fs7, import_node_path2, import_node_os4, import_node_crypto2, import_iconv_lite, ExternalEditor;
 var init_esm2 = __esm({
   "../../node_modules/@inquirer/external-editor/dist/esm/index.js"() {
     "use strict";
     import_chardet = __toESM(require_lib(), 1);
     import_child_process12 = require("child_process");
-    import_fs6 = require("fs");
+    import_fs7 = require("fs");
     import_node_path2 = __toESM(require("path"), 1);
     import_node_os4 = __toESM(require("os"), 1);
     import_node_crypto2 = require("crypto");
@@ -78212,14 +78712,14 @@ var init_esm2 = __esm({
           if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
             opt.mode = this.fileOptions.mode;
           }
-          (0, import_fs6.writeFileSync)(this.tempFile, this.text, opt);
+          (0, import_fs7.writeFileSync)(this.tempFile, this.text, opt);
         } catch (createFileError) {
           throw new CreateFileError(createFileError);
         }
       }
       readTemporaryFile() {
         try {
-          const tempFileBuffer = (0, import_fs6.readFileSync)(this.tempFile);
+          const tempFileBuffer = (0, import_fs7.readFileSync)(this.tempFile);
           if (tempFileBuffer.length === 0) {
             this.text = "";
           } else {
@@ -78235,7 +78735,7 @@ var init_esm2 = __esm({
       }
       removeTemporaryFile() {
         try {
-          (0, import_fs6.unlinkSync)(this.tempFile);
+          (0, import_fs7.unlinkSync)(this.tempFile);
         } catch (removeFileError) {
           throw new RemoveFileError(removeFileError);
         }
@@ -79937,25 +80437,25 @@ function resolvePackageVersion(options) {
   const injectedVersion = options?.injectedVersion || "unknown";
   const dir = options?.dirname || __dirname;
   const possiblePaths = [
-    (0, import_path3.join)(dir, "..", "..", "package.json"),
-    (0, import_path3.join)(dir, "..", "package.json"),
-    (0, import_path3.join)(dir, "package.json")
+    (0, import_path4.join)(dir, "..", "..", "package.json"),
+    (0, import_path4.join)(dir, "..", "package.json"),
+    (0, import_path4.join)(dir, "package.json")
   ];
   for (const p of possiblePaths) {
     try {
-      const data = JSON.parse((0, import_fs7.readFileSync)(p, "utf-8"));
+      const data = JSON.parse((0, import_fs8.readFileSync)(p, "utf-8"));
       if (data.version) return data.version;
     } catch {
     }
   }
   return injectedVersion;
 }
-var import_fs7, import_path3;
+var import_fs8, import_path4;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    import_fs7 = require("fs");
-    import_path3 = require("path");
+    import_fs8 = require("fs");
+    import_path4 = require("path");
   }
 });
 
@@ -81873,7 +82373,7 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync20 = (path40) => {
+    var readFileSync21 = (path40) => {
       const fd = fs24.openSync(path40, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs24.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -81898,7 +82398,7 @@ var require_filesystem = __commonJS({
     module2.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync20,
+      readFileSync: readFileSync21,
       readFile: readFile2
     };
   }
@@ -81947,7 +82447,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = require("child_process");
     var { isLinux: isLinux2, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync20 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync21 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -82039,7 +82539,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync20(LDD_PATH);
+        const lddContent = readFileSync21(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -82064,7 +82564,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync20(SELF_PATH);
+        const selfContent = readFileSync21(SELF_PATH);
         const path40 = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path40);
       } catch (e) {
@@ -82128,7 +82628,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync20(LDD_PATH);
+        const lddContent = readFileSync21(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -89392,7 +89892,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.66" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.68" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -90884,20 +91384,20 @@ async function startDaemonFlow() {
   try {
     const { AdhdevDaemon: AdhdevDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const daemon = new AdhdevDaemon2();
-    const { execSync: execSync8 } = await import("child_process");
+    const { execSync: execSync9 } = await import("child_process");
     const { getCurrentDaemonLogPath: getCurrentDaemonLogPath2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const logPath = getCurrentDaemonLogPath2();
     const os31 = await import("os");
     const platform12 = os31.platform();
     try {
       if (platform12 === "win32") {
-        execSync8("start /B adhdev daemon >NUL 2>&1", {
+        execSync9("start /B adhdev daemon >NUL 2>&1", {
           timeout: 3e3,
           stdio: "ignore",
           shell: "cmd.exe"
         });
       } else {
-        execSync8("nohup adhdev daemon >/dev/null 2>&1 &", {
+        execSync9("nohup adhdev daemon >/dev/null 2>&1 &", {
           timeout: 3e3,
           stdio: "ignore"
         });
@@ -93336,7 +93836,7 @@ async function handleTraceCommand(options) {
 async function runDaemonUpgrade(options, pkgVersion3) {
   const { isDaemonRunning: isDaemonRunning2, stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
   const { stopManagedSessionHostProcess: stopManagedSessionHostProcess2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
-  const { execSync: execSync8, spawn: spawn7 } = await import("child_process");
+  const { execSync: execSync9, spawn: spawn7 } = await import("child_process");
   const fsMod = await import("fs");
   const pathMod = await import("path");
   console.log(source_default.bold("\n  \u{1F504} ADHDev Upgrade\n"));
@@ -93356,10 +93856,10 @@ async function runDaemonUpgrade(options, pkgVersion3) {
       while (!fsMod.existsSync(pathMod.join(gitRoot, ".git")) && gitRoot !== "/") {
         gitRoot = pathMod.dirname(gitRoot);
       }
-      execSync8("git pull --rebase", { cwd: gitRoot, stdio: "inherit" });
+      execSync9("git pull --rebase", { cwd: gitRoot, stdio: "inherit" });
       console.log(source_default.cyan("\n  Building..."));
-      execSync8("npm run build", { cwd: launcherDir, stdio: "inherit" });
-      execSync8("npm link", { cwd: launcherDir, stdio: "inherit" });
+      execSync9("npm run build", { cwd: launcherDir, stdio: "inherit" });
+      execSync9("npm link", { cwd: launcherDir, stdio: "inherit" });
       console.log(source_default.green("\n  \u2713 Build complete"));
     } catch (e) {
       console.log(source_default.red(`
@@ -93467,7 +93967,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     }
   });
   program2.command("standalone").description("\u{1F5A5}\uFE0F  Start ADHDev Standalone Server (Local Dashboard & Embedded Daemon)").option("-p, --port <port>", "Local HTTP/WS server port", "3847").option("--host <host>", "Bind to specific host (use 0.0.0.0 for LAN access)").option("--no-open", "Prevent opening browser automatically").option("--token <token>", "Require token authentication").option("--dev", "Enable Dev Mode").action(async (options) => {
-    const { spawn: spawn7, execSync: execSync8 } = await import("child_process");
+    const { spawn: spawn7, execSync: execSync9 } = await import("child_process");
     const { DEFAULT_STANDALONE_SESSION_HOST_APP_NAME: DEFAULT_STANDALONE_SESSION_HOST_APP_NAME2, resolveSessionHostAppNameResolution: resolveSessionHostAppNameResolution2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     console.log(source_default.cyan("\n  Starting ADHDev Standalone Server..."));
     const args = [];
@@ -93485,7 +93985,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     let bin = "npx";
     const npxArgs = ["-y", "@adhdev/daemon-standalone@latest", ...args];
     try {
-      execSync8("adhdev-standalone --help", { stdio: "ignore" });
+      execSync9("adhdev-standalone --help", { stdio: "ignore" });
       bin = "adhdev-standalone";
     } catch {
       console.log(source_default.gray("  Standalone server package not found locally."));
@@ -95993,7 +96493,7 @@ var import_node_module3 = require("module");
 var path39 = __toESM(require("path"));
 init_source();
 function registerMcpCommands(program2) {
-  program2.command("mcp").description("Start an MCP server to expose IDE agents as tools (for Claude Desktop, etc.)").option("--api-key <key>", "ADHDev cloud API key (switches to cloud mode)").option("--port <n>", "Standalone daemon port (default: 3847)", "3847").option("--password <pass>", "Standalone daemon password (if set)").option("--base-url <url>", "Override cloud API base URL").addHelpText("after", `
+  program2.command("mcp").description("Start an MCP server to expose IDE agents as tools (for Claude Desktop, etc.)").option("--api-key <key>", "ADHDev cloud API key (switches to cloud mode)").option("--port <n>", "Standalone daemon port (default: 3847)", "3847").option("--password <pass>", "Standalone daemon password (if set)").option("--base-url <url>", "Override cloud API base URL").option("--repo-mesh <mesh_id>", "Start in mesh mode (coordinator-scoped tools)").addHelpText("after", `
 Examples:
   adhdev mcp                          Local mode (requires: adhdev standalone)
   adhdev mcp --api-key adk_xxx        Cloud mode (no local daemon needed)
@@ -96021,6 +96521,7 @@ Tools available (cloud):  list_daemons, list_sessions, launch_session, stop_sess
     if (opts.port && opts.port !== "3847") args.push("--port", opts.port);
     if (opts.password) args.push("--password", opts.password);
     if (opts.baseUrl) args.push("--base-url", opts.baseUrl);
+    if (opts.repoMesh) args.push("--repo-mesh", opts.repoMesh);
     const env3 = { ...process.env };
     if (opts.apiKey) env3.ADHDEV_API_KEY = opts.apiKey;
     if (opts.password) env3.ADHDEV_PASSWORD = opts.password;
@@ -96055,6 +96556,283 @@ function resolveMcpBin() {
   }
 }
 
+// src/cli/mesh-commands.ts
+init_source();
+var import_node_child_process4 = require("child_process");
+init_src();
+function registerMeshCommands(program2) {
+  const mesh = program2.command("mesh").description("Manage Repo Meshes \u2014 repo-scoped execution environments");
+  mesh.command("list").description("List all configured meshes").action(() => {
+    const meshes = listMeshes();
+    if (meshes.length === 0) {
+      console.log(source_default.gray("No meshes configured. Create one with: adhdev mesh create <name>"));
+      return;
+    }
+    console.log(source_default.bold(`
+  Repo Meshes (${meshes.length})
+`));
+    for (const m of meshes) {
+      const nodeCount = m.nodes.length;
+      const statusIcon = nodeCount > 0 ? source_default.green("\u25CF") : source_default.yellow("\u25CB");
+      console.log(`  ${statusIcon} ${source_default.bold(m.name)}  ${source_default.gray(m.id)}`);
+      console.log(`    ${source_default.gray("repo:")} ${m.repoIdentity}`);
+      console.log(`    ${source_default.gray("nodes:")} ${nodeCount}  ${source_default.gray("created:")} ${m.createdAt.split("T")[0]}`);
+      console.log();
+    }
+  });
+  mesh.command("create <name>").description("Create a new mesh for the current Git repository").option("--remote-url <url>", "Git remote URL (auto-detected from current directory)").option("--identity <identity>", "Repo identity override (e.g. github.com/user/repo)").option("--branch <branch>", "Default branch (e.g. main)").option("--add-current", "Also add current workspace as the first node", false).action(async (name, opts) => {
+    let repoRemoteUrl = opts.remoteUrl;
+    let repoIdentity = opts.identity;
+    let defaultBranch = opts.branch;
+    if (!repoRemoteUrl && !repoIdentity) {
+      try {
+        repoRemoteUrl = (0, import_node_child_process4.execSync)("git remote get-url origin", {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        console.log(source_default.gray(`  Detected remote: ${repoRemoteUrl}`));
+      } catch {
+        console.error(source_default.red("\u2717 Could not detect Git remote. Use --remote-url or --identity."));
+        process.exit(1);
+      }
+    }
+    if (!defaultBranch) {
+      try {
+        defaultBranch = (0, import_node_child_process4.execSync)("git symbolic-ref refs/remotes/origin/HEAD", {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim().replace("refs/remotes/origin/", "");
+      } catch {
+        try {
+          defaultBranch = (0, import_node_child_process4.execSync)("git branch --show-current", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+        } catch {
+          defaultBranch = "main";
+        }
+      }
+    }
+    try {
+      const mesh2 = createMesh({
+        name,
+        repoRemoteUrl,
+        repoIdentity,
+        defaultBranch
+      });
+      console.log(source_default.green(`
+  \u2713 Mesh created: ${source_default.bold(mesh2.name)}`));
+      console.log(source_default.gray(`    ID: ${mesh2.id}`));
+      console.log(source_default.gray(`    Repo: ${mesh2.repoIdentity}`));
+      console.log(source_default.gray(`    Branch: ${mesh2.defaultBranch || "auto"}`));
+      if (opts.addCurrent) {
+        const cwd = process.cwd();
+        try {
+          const node = addNode(mesh2.id, { workspace: cwd });
+          if (node) {
+            console.log(source_default.green(`  \u2713 Added current workspace as node: ${source_default.gray(cwd)}`));
+            console.log(source_default.gray(`    Node ID: ${node.id}`));
+          }
+        } catch (e) {
+          console.error(source_default.yellow(`  \u26A0 Could not add current workspace: ${e.message}`));
+        }
+      }
+      console.log();
+      console.log(source_default.gray("  Next steps:"));
+      console.log(source_default.gray(`    adhdev mesh add-node ${mesh2.id}       \u2014 Add a workspace to this mesh`));
+      console.log(source_default.gray(`    adhdev mcp --repo-mesh ${mesh2.id}  \u2014 Start MCP server in mesh mode`));
+      console.log();
+    } catch (e) {
+      console.error(source_default.red(`\u2717 ${e.message}`));
+      process.exit(1);
+    }
+  });
+  mesh.command("show <mesh_id>").description("Show mesh details and nodes").action((meshId) => {
+    const m = getMesh(meshId);
+    if (!m) {
+      console.error(source_default.red(`\u2717 Mesh not found: ${meshId}`));
+      process.exit(1);
+    }
+    console.log(source_default.bold(`
+  ${m.name}  ${source_default.gray(m.id)}`));
+    console.log(`  ${source_default.gray("repo:")} ${m.repoIdentity}`);
+    if (m.repoRemoteUrl) console.log(`  ${source_default.gray("remote:")} ${m.repoRemoteUrl}`);
+    if (m.defaultBranch) console.log(`  ${source_default.gray("branch:")} ${m.defaultBranch}`);
+    console.log(`  ${source_default.gray("created:")} ${m.createdAt}`);
+    console.log(`  ${source_default.gray("updated:")} ${m.updatedAt}`);
+    console.log(source_default.bold("\n  Policy"));
+    console.log(`    ${source_default.gray("checkpoint after task:")} ${m.policy.requirePostTaskCheckpoint ? "yes" : "no"}`);
+    console.log(`    ${source_default.gray("push requires approval:")} ${m.policy.requireApprovalForPush ? "yes" : "no"}`);
+    console.log(`    ${source_default.gray("dirty workspace:")} ${m.policy.dirtyWorkspaceBehavior}`);
+    console.log(`    ${source_default.gray("max parallel tasks:")} ${m.policy.maxParallelTasks}`);
+    console.log(source_default.bold(`
+  Nodes (${m.nodes.length})`));
+    if (m.nodes.length === 0) {
+      console.log(source_default.gray("    No nodes. Add one with: adhdev mesh add-node " + meshId));
+    } else {
+      for (const n of m.nodes) {
+        const label = n.isLocalWorktree ? source_default.cyan("[worktree]") : "";
+        console.log(`    ${source_default.gray("\u25CF")} ${n.workspace} ${label}  ${source_default.gray(n.id)}`);
+        if (n.policy.readOnly) console.log(`      ${source_default.yellow("read-only")}`);
+        if (Object.keys(n.userOverrides).length > 0) {
+          console.log(`      ${source_default.gray("overrides:")} ${JSON.stringify(n.userOverrides)}`);
+        }
+      }
+    }
+    console.log();
+  });
+  mesh.command("delete <mesh_id>").description("Delete a mesh").action((meshId) => {
+    const m = getMesh(meshId);
+    if (!m) {
+      console.error(source_default.red(`\u2717 Mesh not found: ${meshId}`));
+      process.exit(1);
+    }
+    const ok = deleteMesh(meshId);
+    if (ok) {
+      console.log(source_default.green(`  \u2713 Deleted mesh: ${m.name} (${meshId})`));
+    } else {
+      console.error(source_default.red(`\u2717 Failed to delete mesh: ${meshId}`));
+      process.exit(1);
+    }
+  });
+  mesh.command("add-node <mesh_id>").description("Add a workspace as a node to the mesh").option("--workspace <path>", "Workspace path (default: current directory)").option("--worktree", "Mark as a local Git worktree", false).option("--read-only", "Mark this node as read-only", false).action((meshId, opts) => {
+    const m = getMesh(meshId);
+    if (!m) {
+      console.error(source_default.red(`\u2717 Mesh not found: ${meshId}`));
+      process.exit(1);
+    }
+    const workspace = opts.workspace || process.cwd();
+    try {
+      const node = addNode(meshId, {
+        workspace,
+        isLocalWorktree: opts.worktree,
+        policy: opts.readOnly ? { readOnly: true } : {}
+      });
+      if (node) {
+        console.log(source_default.green(`  \u2713 Node added to ${m.name}`));
+        console.log(source_default.gray(`    ID: ${node.id}`));
+        console.log(source_default.gray(`    Workspace: ${workspace}`));
+        if (opts.worktree) console.log(source_default.gray(`    Type: local worktree`));
+        if (opts.readOnly) console.log(source_default.gray(`    Policy: read-only`));
+      } else {
+        console.error(source_default.red(`\u2717 Mesh not found`));
+        process.exit(1);
+      }
+    } catch (e) {
+      console.error(source_default.red(`\u2717 ${e.message}`));
+      process.exit(1);
+    }
+  });
+  mesh.command("remove-node <mesh_id> <node_id>").description("Remove a node from the mesh").action((meshId, nodeId) => {
+    const ok = removeNode(meshId, nodeId);
+    if (ok) {
+      console.log(source_default.green(`  \u2713 Node removed: ${nodeId}`));
+    } else {
+      console.error(source_default.red(`\u2717 Node or mesh not found`));
+      process.exit(1);
+    }
+  });
+  mesh.command("status <mesh_id>").description("Probe all mesh nodes and show health").action(async (meshId) => {
+    const m = getMesh(meshId);
+    if (!m) {
+      console.error(source_default.red(`\u2717 Mesh not found: ${meshId}`));
+      process.exit(1);
+    }
+    console.log(source_default.bold(`
+  ${m.name}  \u2014  Node Status
+`));
+    if (m.nodes.length === 0) {
+      console.log(source_default.gray("  No nodes configured."));
+      return;
+    }
+    for (const node of m.nodes) {
+      let gitInfo = "";
+      let healthIcon = source_default.gray("?");
+      let health = "unknown";
+      try {
+        const branch = (0, import_node_child_process4.execSync)(`git -C "${node.workspace}" branch --show-current`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        const status = (0, import_node_child_process4.execSync)(`git -C "${node.workspace}" status --porcelain`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        const isDirty = status.length > 0;
+        const changedFiles = isDirty ? status.split("\n").length : 0;
+        if (isDirty) {
+          health = "dirty";
+          healthIcon = source_default.yellow("\u25CF");
+          gitInfo = `${source_default.cyan(branch)} ${source_default.yellow(`(${changedFiles} changed)`)}`;
+        } else {
+          health = "clean";
+          healthIcon = source_default.green("\u25CF");
+          gitInfo = `${source_default.cyan(branch)} ${source_default.green("clean")}`;
+        }
+      } catch {
+        health = "error";
+        healthIcon = source_default.red("\u2717");
+        gitInfo = source_default.red("git probe failed");
+      }
+      const label = node.isLocalWorktree ? source_default.gray(" [worktree]") : "";
+      console.log(`  ${healthIcon} ${node.workspace}${label}  ${source_default.gray(node.id.slice(0, 12))}`);
+      console.log(`    ${gitInfo}`);
+      if (node.policy.readOnly) console.log(`    ${source_default.yellow("read-only")}`);
+      console.log();
+    }
+  });
+  mesh.command("sync").description("Sync local mesh config with cloud (push/pull)").action(async () => {
+    try {
+      const { syncMeshes: syncMeshes2, loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      const config2 = loadConfig2();
+      const apiKey = process.env.ADHDEV_API_KEY;
+      if (!apiKey) {
+        console.error(source_default.red("\u2717 No API key set. Export ADHDEV_API_KEY or use: adhdev setup"));
+        process.exit(1);
+      }
+      const baseUrl = config2.serverUrl || "https://api.adhf.dev";
+      const transport = {
+        async listRemoteMeshes() {
+          const res = await fetch(`${baseUrl}/api/v1/repo-meshes`, {
+            headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json" }
+          });
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+          return res.json();
+        },
+        async createRemoteMesh(data) {
+          const res = await fetch(`${baseUrl}/api/v1/repo-meshes`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json" },
+            body: JSON.stringify(data)
+          });
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+          return res.json();
+        },
+        async deleteRemoteMesh(meshId) {
+          const res = await fetch(`${baseUrl}/api/v1/repo-meshes/${meshId}`, {
+            method: "DELETE",
+            headers: { "Authorization": `Bearer ${apiKey}` }
+          });
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        }
+      };
+      console.log(source_default.gray("  Syncing with cloud..."));
+      const result = await syncMeshes2(transport);
+      if (result.pushed > 0) console.log(source_default.green(`  \u2713 Pushed ${result.pushed} mesh${result.pushed > 1 ? "es" : ""} to cloud`));
+      if (result.pulled > 0) console.log(source_default.green(`  \u2713 Pulled ${result.pulled} mesh${result.pulled > 1 ? "es" : ""} from cloud`));
+      if (result.pushed === 0 && result.pulled === 0 && result.errors.length === 0) {
+        console.log(source_default.gray("  Already in sync."));
+      }
+      for (const err of result.errors) {
+        console.error(source_default.yellow(`  \u26A0 ${err}`));
+      }
+    } catch (e) {
+      console.error(source_default.red(`\u2717 Sync failed: ${e.message}`));
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli/index.ts
 init_version();
 var pkgVersion2 = resolvePackageVersion();
@@ -96075,6 +96853,7 @@ registerProviderCommands(program);
 registerCdpCommands(program);
 registerServiceCommands(program);
 registerMcpCommands(program);
+registerMeshCommands(program);
 void (async () => {
   const helperMode = await maybeRunDaemonUpgradeHelperFromEnv();
   if (helperMode) {
@@ -96102,6 +96881,8 @@ void (async () => {
     console.log(source_default.gray("    adhdev trace --category session_host \u2014 Inspect structured daemon trace"));
     console.log(source_default.gray("    adhdev service           \u2014 Manage OS background auto-start service"));
     console.log(source_default.gray("    adhdev mcp               \u2014 Start MCP server (expose agents to Claude Desktop, etc.)"));
+    console.log(source_default.gray("    adhdev mesh list          \u2014 List configured Repo Meshes"));
+    console.log(source_default.gray("    adhdev mesh create myapp  \u2014 Create a mesh for the current Git repo"));
     console.log(source_default.gray("    adhdev provider ...      \u2014 Provider development commands"));
     console.log(source_default.gray("    adhdev cdp ...           \u2014 CDP debugging tools"));
     console.log();