@adhdev/daemon-standalone 1.0.29-rc.1 → 1.0.29-rc.10

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "97193d744d40d248ccdc0eb70e8170f4cccdf8a6" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "97193d74" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.29-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-31T22:51:04.932Z" : void 0);
+      const commit = readInjected(true ? "8f47a188527a03de6f207dbc0c6d844f72dcfcc5" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "8f47a188" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.29-rc.10" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-02T07:59:04.126Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -36155,20 +36155,40 @@ ${error48.message || ""}`;
       let hostDaemonId = readString3(raw?.hostDaemonId);
       let hostNodeId = readString3(raw?.hostNodeId);
       const hostAddress = readString3(raw?.hostAddress);
+      let hostSynthesized = false;
+      const nodes = Array.isArray(meshRecord?.nodes) ? meshRecord.nodes : [];
+      const nodeDaemonIdOf = (node) => {
+        const record2 = readObject(node);
+        return readString3(record2?.daemonId) ?? readString3(record2?.daemon_id);
+      };
+      if (role === "host" && !hostDaemonId) {
+        const declaredHostNode = nodes.find((n) => normalizeMeshDaemonRole(readObject(n)?.role) === "host");
+        if (declaredHostNode) {
+          const declaredDaemonId = nodeDaemonIdOf(declaredHostNode);
+          if (declaredDaemonId) {
+            hostDaemonId = declaredDaemonId;
+            if (!hostNodeId) hostNodeId = readString3(readObject(declaredHostNode)?.id);
+          }
+        }
+      }
       const localDaemonId = readString3(opts?.localDaemonId);
-      if (role === "host" && !hostDaemonId && localDaemonId) {
+      const hasForeignDaemonNode = localDaemonId ? nodes.some((n) => {
+        const nodeDaemonId = nodeDaemonIdOf(n);
+        return nodeDaemonId ? !daemonIdsEquivalent(nodeDaemonId, localDaemonId) : false;
+      }) : false;
+      if (role === "host" && !hostDaemonId && !hostNodeId && localDaemonId && !hasForeignDaemonNode) {
         hostDaemonId = localDaemonId;
-        if (!hostNodeId && Array.isArray(meshRecord?.nodes)) {
-          const selfNode = meshRecord.nodes.find((n) => {
-            const nodeDaemonId = readString3(readObject(n)?.daemonId);
-            return nodeDaemonId ? daemonIdsEquivalent(nodeDaemonId, localDaemonId) : false;
-          });
-          const selfNodeId = readString3(readObject(selfNode)?.id);
-          if (selfNodeId) hostNodeId = selfNodeId;
-        }
+        hostSynthesized = true;
+        const selfNode = nodes.find((n) => {
+          const nodeDaemonId = nodeDaemonIdOf(n);
+          return nodeDaemonId ? daemonIdsEquivalent(nodeDaemonId, localDaemonId) : false;
+        });
+        const selfNodeId = readString3(readObject(selfNode)?.id);
+        if (selfNodeId) hostNodeId = selfNodeId;
       }
       if (hostDaemonId) normalized.hostDaemonId = hostDaemonId;
       if (hostNodeId) normalized.hostNodeId = hostNodeId;
+      if (hostSynthesized) normalized.hostSynthesized = true;
       if (hostAddress) normalized.hostAddress = hostAddress;
       if (pairing) {
         const status = pairing.status === "pairing" || pairing.status === "paired" || pairing.status === "rejected" || pairing.status === "revoked" ? pairing.status : "not_configured";
@@ -36235,8 +36255,10 @@ ${error48.message || ""}`;
       normalizeRepoIdentity: () => normalizeRepoIdentity,
       removeMagiKindPanel: () => removeMagiKindPanel,
       removeNode: () => removeNode,
+      resolveScopedMeshId: () => resolveScopedMeshId,
       setDifficultyBrains: () => setDifficultyBrains,
       setMagiKindPanel: () => setMagiKindPanel,
+      setMeshHostPin: () => setMeshHostPin,
       tokenIdForManualPairing: () => tokenIdForManualPairing,
       updateMesh: () => updateMesh,
       updateNode: () => updateNode
@@ -36265,15 +36287,41 @@ ${error48.message || ""}`;
     }
     function migrateLoadedMeshConfig(config2) {
       let changed = false;
+      if (foldLegacyTopLevelMeshSetting(config2, "magiKindPanels", "mesh_magi_kind_panel_set({ meshId, task_kind, slots })")) changed = true;
+      if (foldLegacyTopLevelMeshSetting(config2, "difficultyBrains", "difficulty_brains_set({ meshId, difficultyBrains })")) changed = true;
       for (const mesh of config2.meshes) {
         if (!mesh || !Array.isArray(mesh.nodes)) continue;
+        const brains = normalizeDifficultyBrainMap(mesh.difficultyBrains);
+        const ownerBrains = Object.keys(brains).length > 0 ? brains : { ...DEFAULT_DIFFICULTY_BRAINS };
         for (const node of mesh.nodes) {
-          if (migrateProviderRolesToSlots(node?.policy)) changed = true;
+          if (migrateProviderRolesToSlots(node?.policy, ownerBrains)) changed = true;
         }
       }
       return changed;
     }
-    function migrateProviderRolesToSlots(policy) {
+    function foldLegacyTopLevelMeshSetting(config2, key2, rebindHint) {
+      const root = config2;
+      const legacy = root[key2];
+      if (!legacy || typeof legacy !== "object" || Array.isArray(legacy)) {
+        if (key2 in root) {
+          delete root[key2];
+          return true;
+        }
+        return false;
+      }
+      delete root[key2];
+      const entryKeys = Object.keys(legacy);
+      if (config2.meshes.length === 1 && entryKeys.length > 0) {
+        const mesh = config2.meshes[0];
+        mesh[key2] = { ...legacy, ...mesh[key2] ?? {} };
+      } else if (entryKeys.length > 0) {
+        console.warn(
+          `[mesh-config] Dropped legacy top-level ${key2} (keys: ${entryKeys.join(", ")}) \u2014 ${config2.meshes.length} meshes are configured, so the owning mesh cannot be determined. Re-apply it per mesh with ${rebindHint}.`
+        );
+      }
+      return true;
+    }
+    function migrateProviderRolesToSlots(policy, ownerDifficultyBrains) {
       if (!policy || typeof policy !== "object" || Array.isArray(policy)) return false;
       const p = policy;
       const rawRoles = p.providerRoles;
@@ -36296,12 +36344,7 @@ ${error48.message || ""}`;
         }
         p.slots = explicitSlots;
       } else if (roleCap.size) {
-        let difficultyBrains;
-        try {
-          difficultyBrains = getDifficultyBrains();
-        } catch {
-          difficultyBrains = void 0;
-        }
+        const difficultyBrains = ownerDifficultyBrains;
         const priority = Array.isArray(p.providerPriority) ? p.providerPriority.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean) : [];
         const derived = deriveSlotsFromLegacy({ providerPriority: priority, difficultyBrains });
         const slots = derived.length ? derived : [...roleCap.values()].map((r) => ({ provider: r.provider }));
@@ -36382,7 +36425,11 @@ ${error48.message || ""}`;
         defaultBranch: opts.defaultBranch,
         policy: mergeMeshPolicy(void 0, opts.policy),
         coordinator: opts.coordinator || {},
-        meshHost: opts.meshHost || createDefaultMeshHostMetadata(),
+        meshHost: opts.meshHost || (() => {
+          const base = createDefaultMeshHostMetadata();
+          const creatingDaemonId = typeof opts.hostDaemonId === "string" ? opts.hostDaemonId.trim() : "";
+          return creatingDaemonId ? { ...base, hostDaemonId: creatingDaemonId } : base;
+        })(),
         nodes: [],
         createdAt: now,
         updatedAt: now
@@ -36568,6 +36615,86 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return { accepted: true, mesh, meshHost: mesh.meshHost, node, tokenId: validation.tokenId };
     }
+    function setMeshHostPin(meshId, opts) {
+      const config2 = loadMeshConfig();
+      const mesh = config2.meshes.find((m) => m.id === meshId);
+      if (!mesh) return void 0;
+      const hostDaemonId = typeof opts.hostDaemonId === "string" ? opts.hostDaemonId.trim() : "";
+      const hostNodeId = typeof opts.hostNodeId === "string" ? opts.hostNodeId.trim() : "";
+      const previous = mesh.meshHost || createDefaultMeshHostMetadata();
+      if (!hostDaemonId && !hostNodeId) {
+        return {
+          mesh,
+          meshHost: previous,
+          applied: false,
+          reason: "invalid_host_daemon_id",
+          ...previous.hostDaemonId ? { hostDaemonId: previous.hostDaemonId } : {},
+          ...previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {}
+        };
+      }
+      if (previous.role === "member") {
+        return {
+          mesh,
+          meshHost: previous,
+          applied: false,
+          reason: "not_host_role",
+          ...previous.hostDaemonId ? { hostDaemonId: previous.hostDaemonId } : {},
+          ...previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {}
+        };
+      }
+      const existingDaemonId = typeof previous.hostDaemonId === "string" ? previous.hostDaemonId.trim() : "";
+      if (existingDaemonId && !opts.force) {
+        const sameHost = hostDaemonId ? daemonIdsEquivalent(existingDaemonId, hostDaemonId) : true;
+        if (!sameHost) {
+          return {
+            mesh,
+            meshHost: previous,
+            applied: false,
+            reason: "host_already_pinned",
+            hostDaemonId: existingDaemonId,
+            ...previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {}
+          };
+        }
+        const existingNodeId = typeof previous.hostNodeId === "string" ? previous.hostNodeId.trim() : "";
+        if (!hostNodeId || hostNodeId === existingNodeId) {
+          return {
+            mesh,
+            meshHost: previous,
+            applied: false,
+            reason: "already_pinned_same",
+            hostDaemonId: existingDaemonId,
+            ...existingNodeId ? { hostNodeId: existingNodeId } : {}
+          };
+        }
+      }
+      const now = opts.now || (/* @__PURE__ */ new Date()).toISOString();
+      const effectiveDaemonId = hostDaemonId || existingDaemonId;
+      mesh.meshHost = {
+        ...previous,
+        role: "host",
+        ...effectiveDaemonId ? { hostDaemonId: effectiveDaemonId } : {},
+        ...hostNodeId ? { hostNodeId } : previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {},
+        ...opts.hostAddress?.trim() ? { hostAddress: opts.hostAddress.trim() } : {}
+      };
+      const hostNode = hostNodeId ? mesh.nodes.find((n) => n.id === hostNodeId) : effectiveDaemonId ? mesh.nodes.find((n) => n.daemonId && daemonIdsEquivalent(n.daemonId, effectiveDaemonId)) : void 0;
+      if (hostNode) {
+        for (const node of mesh.nodes) {
+          if (node.role === "host" && node !== hostNode) node.role = void 0;
+        }
+        hostNode.role = "host";
+        if (!mesh.meshHost.hostNodeId) mesh.meshHost.hostNodeId = hostNode.id;
+      }
+      mesh.updatedAt = now;
+      saveMeshConfig(config2);
+      return {
+        mesh,
+        meshHost: mesh.meshHost,
+        applied: true,
+        reason: "pinned",
+        ...mesh.meshHost.hostDaemonId ? { hostDaemonId: mesh.meshHost.hostDaemonId } : {},
+        ...mesh.meshHost.hostNodeId ? { hostNodeId: mesh.meshHost.hostNodeId } : {}
+      };
+    }
     function markMeshHostPairingJoined(meshId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
@@ -36628,6 +36755,12 @@ ${error48.message || ""}`;
         worktreeBootstrap: opts.worktreeBootstrap,
         role: opts.role
       };
+      const pinnedHostDaemonId = typeof mesh.meshHost?.hostDaemonId === "string" ? mesh.meshHost.hostDaemonId.trim() : "";
+      const anchorMissing = !(typeof mesh.meshHost?.hostNodeId === "string" && mesh.meshHost.hostNodeId.trim());
+      if (!node.role && anchorMissing && pinnedHostDaemonId && mesh.meshHost?.role !== "member" && node.daemonId && daemonIdsEquivalent(node.daemonId, pinnedHostDaemonId) && !mesh.nodes.some((n) => n.role === "host")) {
+        node.role = "host";
+        mesh.meshHost = { ...mesh.meshHost || createDefaultMeshHostMetadata(), hostNodeId: node.id };
+      }
       mesh.nodes.push(node);
       mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       saveMeshConfig(config2);
@@ -36640,6 +36773,7 @@ ${error48.message || ""}`;
       const idx = mesh.nodes.findIndex((n) => n.id === nodeId);
       if (idx === -1) return false;
       mesh.nodes.splice(idx, 1);
+      pruneMagiKindPanelsForRemovedNode(mesh, nodeId);
       mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       saveMeshConfig(config2);
       return true;
@@ -36696,7 +36830,8 @@ ${error48.message || ""}`;
       }
       return s2;
     }
-    function normalizeMagiSlots(slots) {
+    function normalizeMagiSlots(slots, knownNodeIds) {
+      const allowed = knownNodeIds ? new Set(knownNodeIds) : void 0;
       if (!Array.isArray(slots) || slots.length === 0) {
         throw new Error("invalid_magi_kind_panel: slots must be a non-empty array");
       }
@@ -36713,6 +36848,11 @@ ${error48.message || ""}`;
           throw new Error(`invalid_magi_kind_panel: slot[${idx}].provider is required`);
         }
         const nodeId = typeof s2.nodeId === "string" && s2.nodeId.trim() ? s2.nodeId.trim() : void 0;
+        if (nodeId && allowed && !allowed.has(nodeId)) {
+          throw new Error(
+            `invalid_magi_kind_panel: slot[${idx}].nodeId '${nodeId}' is not a node of this mesh (known: ${[...allowed].join(", ") || "(none)"}). Pin a node from this mesh, or omit nodeId to let the fan-out pick any node offering the provider.`
+          );
+        }
         const model = typeof s2.model === "string" && s2.model.trim() ? s2.model.trim() : void 0;
         const capabilityTags = normalizeCapabilityTags(s2.capabilityTags);
         const n = normalizeReplicaCount(s2.n);
@@ -36725,32 +36865,51 @@ ${error48.message || ""}`;
         };
       });
     }
-    function listMagiKindPanels() {
-      return loadMeshConfig().magiKindPanels ?? {};
+    function resolveScopedMeshId(config2) {
+      const meshes = (config2 ?? loadMeshConfig({ persistMigrations: false })).meshes;
+      return meshes.length === 1 ? meshes[0].id : void 0;
+    }
+    function resolveScopedMesh(config2, meshId) {
+      const id = meshId?.trim() || resolveScopedMeshId(config2);
+      if (!id) return void 0;
+      return config2.meshes.find((m) => m.id === id);
     }
-    function listMagiKindPanelsReadOnly() {
-      return loadMeshConfig({ persistMigrations: false }).magiKindPanels ?? {};
+    function listMagiKindPanels(meshId) {
+      const config2 = loadMeshConfig();
+      return resolveScopedMesh(config2, meshId)?.magiKindPanels ?? {};
+    }
+    function listMagiKindPanelsReadOnly(meshId) {
+      const config2 = loadMeshConfig({ persistMigrations: false });
+      return resolveScopedMesh(config2, meshId)?.magiKindPanels ?? {};
     }
-    function getMagiKindPanel(kind) {
+    function getMagiKindPanel(kind, meshId) {
       let key2;
       try {
         key2 = normalizeMagiTaskKindKey(kind);
       } catch {
         return void 0;
       }
-      return loadMeshConfig().magiKindPanels?.[key2];
+      const config2 = loadMeshConfig();
+      return resolveScopedMesh(config2, meshId)?.magiKindPanels?.[key2];
     }
-    function setMagiKindPanel(kind, slots) {
+    function setMagiKindPanel(kind, slots, meshId) {
       const key2 = normalizeMagiTaskKindKey(kind);
-      const normalized = normalizeMagiSlots(slots);
       const stored = loadMeshConfig();
-      const map3 = stored.magiKindPanels ?? {};
+      const mesh = resolveScopedMesh(stored, meshId);
+      if (!mesh) {
+        throw new Error(
+          meshId?.trim() ? `invalid_magi_kind_panel: mesh '${meshId.trim()}' not found` : `magi_kind_panel_mesh_ambiguous: this machine hosts ${stored.meshes.length} meshes, so a MAGI kind-panel write must name its mesh explicitly (meshId). Panels are per mesh.`
+        );
+      }
+      const normalized = normalizeMagiSlots(slots, mesh.nodes.map((n) => n.id));
+      const map3 = mesh.magiKindPanels ?? {};
       map3[key2] = normalized;
-      stored.magiKindPanels = map3;
+      mesh.magiKindPanels = map3;
+      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       saveMeshConfig(stored);
       return normalized;
     }
-    function removeMagiKindPanel(kind) {
+    function removeMagiKindPanel(kind, meshId) {
       let key2;
       try {
         key2 = normalizeMagiTaskKindKey(kind);
@@ -36758,21 +36917,47 @@ ${error48.message || ""}`;
         return false;
       }
       const stored = loadMeshConfig();
-      if (!stored.magiKindPanels || !stored.magiKindPanels[key2]) return false;
-      delete stored.magiKindPanels[key2];
+      const mesh = resolveScopedMesh(stored, meshId);
+      if (!mesh?.magiKindPanels?.[key2]) return false;
+      delete mesh.magiKindPanels[key2];
+      if (Object.keys(mesh.magiKindPanels).length === 0) delete mesh.magiKindPanels;
+      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       saveMeshConfig(stored);
       return true;
     }
-    function getDifficultyBrains() {
-      const stored = loadMeshConfig().difficultyBrains;
+    function pruneMagiKindPanelsForRemovedNode(mesh, nodeId) {
+      const panels = mesh.magiKindPanels;
+      if (!panels) return false;
+      let changed = false;
+      for (const [kind, slots] of Object.entries(panels)) {
+        if (!Array.isArray(slots)) continue;
+        const kept = slots.filter((slot) => slot.nodeId !== nodeId);
+        if (kept.length === slots.length) continue;
+        changed = true;
+        if (kept.length === 0) delete panels[kind];
+        else panels[kind] = kept;
+      }
+      if (changed && Object.keys(panels).length === 0) delete mesh.magiKindPanels;
+      return changed;
+    }
+    function getDifficultyBrains(meshId) {
+      const config2 = loadMeshConfig();
+      const stored = resolveScopedMesh(config2, meshId)?.difficultyBrains;
       const normalized = normalizeDifficultyBrainMap(stored);
       return Object.keys(normalized).length > 0 ? normalized : { ...DEFAULT_DIFFICULTY_BRAINS };
     }
-    function setDifficultyBrains(map3) {
+    function setDifficultyBrains(map3, meshId) {
       const normalized = normalizeDifficultyBrainMap(map3);
       const stored = loadMeshConfig();
-      if (Object.keys(normalized).length > 0) stored.difficultyBrains = normalized;
-      else delete stored.difficultyBrains;
+      const mesh = resolveScopedMesh(stored, meshId);
+      if (!mesh) {
+        throw new Error(
+          meshId?.trim() ? `invalid_difficulty_brains: mesh '${meshId.trim()}' not found` : `difficulty_brains_mesh_ambiguous: this machine hosts ${stored.meshes.length} meshes, so a difficulty-brain write must name its mesh explicitly (meshId). Presets are per mesh \u2014 they decide which model a task runs on, so writing to the wrong mesh changes what it costs.`
+        );
+      }
+      if (Object.keys(normalized).length > 0) mesh.difficultyBrains = normalized;
+      else delete mesh.difficultyBrains;
+      mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       saveMeshConfig(stored);
       return normalized;
     }
@@ -36808,12 +36993,12 @@ ${error48.message || ""}`;
         return true;
       });
     }
-    function resolveNodeCapabilitySlots(node) {
+    function resolveNodeCapabilitySlots(node, meshId) {
       const explicit = normalizeNodeCapabilitySlots(node?.policy?.slots);
       if (explicit.length) return explicit;
       let difficultyBrains;
       try {
-        difficultyBrains = getDifficultyBrains();
+        difficultyBrains = getDifficultyBrains(meshId);
       } catch {
         difficultyBrains = void 0;
       }
@@ -39298,9 +39483,20 @@ Next step: ${nextStep}`;
           }
           continue;
         }
+        if (validated.intendedFor && !validated.intendedFor.sessionId && daemonIdsEquivalent(validated.intendedFor.daemonId, drainer.daemonId)) {
+          const liveSessions = ctx.countLiveCoordinatorSessions?.(validated.intendedFor.daemonId) ?? 0;
+          if (liveSessions > 1) {
+            warnV2Once(
+              `${event.meshId}::${eventId}::ambiguous-unicast`,
+              `v2 unicast ${event.event} on mesh ${event.meshId} carries NO coordinator session but ${liveSessions} coordinator sessions are live on ${validated.intendedFor.daemonId} \u2014 delivery is first-come-first-served and may reach the wrong coordinator. Delivered to ${coordinatorIdentityKey(drainer)}. The EMITTING path must stamp targetCoordinatorSessionId.`
+            );
+            bump("v2AmbiguousUnicastDelivered");
+          }
+        }
         if (validated.intendedFor && identityDeliversTo(validated.intendedFor, drainer)) {
           ctx.batchSeen.add(eventId);
           bump("v2Delivered");
+          LOG2.debug("MeshEventsV2", `unicast ${event.event} (mesh ${event.meshId}, eventId ${eventId}) delivered to ${coordinatorIdentityKey(drainer)}; intendedFor=${coordinatorIdentityKey(validated.intendedFor)}`);
           kept.push(event);
           continue;
         }
@@ -39315,6 +39511,7 @@ Next step: ${nextStep}`;
           kept.push(event);
           continue;
         }
+        LOG2.debug("MeshEventsV2", `unicast ${event.event} (mesh ${event.meshId}, eventId ${eventId}) NOT delivered to ${coordinatorIdentityKey(drainer)}; intendedFor=${validated.intendedFor ? coordinatorIdentityKey(validated.intendedFor) : "none"} \u2014 left for its own drainer`);
         bump("v2RoutedAway");
       }
       return kept;
@@ -39767,7 +39964,12 @@ Next step: ${nextStep}`;
       try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
-          for (const row of store.drainPendingEvents(meshId, daemonIds.length > 0 ? daemonIds : void 0, onlyEvents ? { onlyEvents } : void 0)) {
+          const drainedBy = drainer ? JSON.stringify(drainer) : null;
+          for (const row of store.drainPendingEvents(
+            meshId,
+            daemonIds.length > 0 ? daemonIds : void 0,
+            { ...onlyEvents ? { onlyEvents } : {}, drainedBy }
+          )) {
             const event = row.payload;
             if (event) pushUnique(event);
           }
@@ -39806,7 +40008,8 @@ Next step: ${nextStep}`;
       const routed = routeV2EventsForDrainer(merged, drainer, {
         alreadyDrained: (eventId) => priorDrainedEventIds.has(eventId),
         batchSeen: /* @__PURE__ */ new Set(),
-        countMetrics: true
+        countMetrics: true,
+        ...opts?.countLiveCoordinatorSessions ? { countLiveCoordinatorSessions: opts.countLiveCoordinatorSessions } : {}
       });
       return reconcilePendingMeshCoordinatorEvents(meshId, routed);
     }
@@ -40026,6 +40229,11 @@ Next step: ${nextStep}`;
           /** unicast events re-attributed to the drainer via daemon-core match (a
            *  coordinatorRunId change orphaned them). */
           v2ReattributedToDrainer: 0,
+          /** REFINE-EVENT-SESSION-SCOPED-UNICAST: unicast events delivered while addressed only
+           *  at DAEMON granularity (no sessionId in intendedFor) even though >1 coordinator
+           *  session was live on that daemon — i.e. delivered by race, not by address. Non-zero
+           *  here names an emit path that still fails to stamp targetCoordinatorSessionId. */
+          v2AmbiguousUnicastDelivered: 0,
           /** v1 (unversioned) events passed through as broadcast (rollout baseline). */
           v1BroadcastAccepted: 0,
           /** T6 enforce: v2 events that FAILED validation and were QUARANTINED (held back
@@ -40828,7 +41036,7 @@ Next step: ${nextStep}`;
       const taskDifficulty = isMeshTaskDifficulty(opts?.difficulty) ? opts.difficulty : void 0;
       if (isMeshTaskDifficulty(opts?.difficulty)) {
         try {
-          const preset = getDifficultyBrains()[opts.difficulty];
+          const preset = getDifficultyBrains(meshId)[opts.difficulty];
           if (preset) {
             if (!effectiveModel && preset.model) effectiveModel = preset.model;
             if (!effectiveThinkingLevel && preset.thinkingLevel) effectiveThinkingLevel = preset.thinkingLevel;
@@ -41784,7 +41992,15 @@ Next step: ${nextStep}`;
                 event_id TEXT,
                 scope TEXT,
                 dispatched_by TEXT,
-                intended_for TEXT
+                intended_for TEXT,
+                -- REFINE-EVENT-SESSION-SCOPED-UNICAST: WHO consumed this row. The ledger
+                -- previously recorded only THAT an event was drained, never by which
+                -- coordinator identity \u2014 so a mis-delivered unicast (a sibling session
+                -- consuming another coordinator's event) left no evidence and had to be
+                -- inferred. Written at drain time as the JSON-serialized drainer
+                -- CoordinatorIdentity. NULL on rows drained before this column existed
+                -- and on any drain whose caller passed no identity (daemon-level drain).
+                drained_by TEXT
             );
 
             CREATE INDEX IF NOT EXISTS idx_mesh_pending_events_mesh_drained
@@ -42030,7 +42246,7 @@ Next step: ${nextStep}`;
                 this.db.exec(`ALTER TABLE mesh_missions ADD COLUMN close_candidate_emitted_at TEXT`);
               }
               const pendingCols = this.tableColumns("mesh_pending_events");
-              for (const col of ["protocol_version", "event_id", "scope", "dispatched_by", "intended_for"]) {
+              for (const col of ["protocol_version", "event_id", "scope", "dispatched_by", "intended_for", "drained_by"]) {
                 if (!pendingCols.has(col)) {
                   this.db.exec(`ALTER TABLE mesh_pending_events ADD COLUMN ${col} TEXT`);
                 }
@@ -43299,8 +43515,8 @@ Next step: ${nextStep}`;
               const ids = rows.map((r) => r.id);
               const now = Date.now();
               this.db.prepare(
-                `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE id IN (${ids.map(() => "?").join(",")})`
-              ).run(now, ...ids);
+                `UPDATE mesh_pending_events SET drained = 1, drained_at = ?, drained_by = ? WHERE id IN (${ids.map(() => "?").join(",")})`
+              ).run(now, opts?.drainedBy ?? null, ...ids);
               return rows.map((r) => ({
                 id: r.id,
                 event: r.event,
@@ -43334,6 +43550,30 @@ Next step: ${nextStep}`;
               })()
             }));
           }
+          /**
+           * REFINE-EVENT-SESSION-SCOPED-UNICAST — drain attribution audit. Returns the most
+           * recent pending-event rows for a mesh with WHO drained each one, so a suspected
+           * mis-delivery ("my refine result went to another coordinator session") is answered
+           * from the ledger instead of inferred from timing. `drainedBy` is the serialized
+           * drainer CoordinatorIdentity, or null when the row is still queued, was drained
+           * before this column existed, or was drained by a caller that passed no identity.
+           */
+          recentDrainedPendingEvents(meshId, limit = 100) {
+            const rows = this.db.prepare(
+              `SELECT id, event, scope, intended_for, drained_by, drained, queued_at, drained_at
+             FROM mesh_pending_events WHERE mesh_id = ? ORDER BY queued_at DESC LIMIT ?`
+            ).all(meshId, Math.max(1, limit));
+            return rows.map((r) => ({
+              id: r.id,
+              event: r.event,
+              scope: r.scope ?? null,
+              intendedFor: r.intended_for ?? null,
+              drainedBy: r.drained_by ?? null,
+              drained: r.drained === 1,
+              queuedAt: r.queued_at,
+              drainedAt: r.drained_at ?? null
+            }));
+          }
           hasPendingEventFingerprint(meshId, fingerprint) {
             const row = this.db.prepare(
               "SELECT 1 FROM mesh_pending_events WHERE mesh_id = ? AND fingerprint = ? AND drained = 0 LIMIT 1"
@@ -43508,7 +43748,7 @@ Next step: ${nextStep}`;
           requeueDrainedPendingEventByFingerprint(meshId, fingerprint) {
             if (!fingerprint) return false;
             const changes = this.db.prepare(
-              `UPDATE mesh_pending_events SET drained = 0, drained_at = NULL
+              `UPDATE mesh_pending_events SET drained = 0, drained_at = NULL, drained_by = NULL
              WHERE mesh_id = ? AND fingerprint = ? AND drained = 1`
             ).run(meshId, fingerprint).changes;
             if (changes > 0) this.maybeCheckpointWal();
@@ -54047,6 +54287,77 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         ]);
       }
     });
+    function normalizeLiteral(model) {
+      return model.toLowerCase().replace(/[_/\\().,]+/g, " ").replace(/-+/g, " ").replace(/\s+/g, " ").trim();
+    }
+    function canonicalizeModelName(model) {
+      if (typeof model !== "string") return void 0;
+      const literal2 = normalizeLiteral(model);
+      if (!literal2) return void 0;
+      const tokens = literal2.split(" ").filter((t) => t && !MODIFIER_WORDS.has(t));
+      const family = CLAUDE_FAMILIES.find((f) => tokens.includes(f));
+      let version2;
+      if (family) {
+        const after = tokens.slice(tokens.indexOf(family) + 1).filter((t) => /^\d+$/.test(t));
+        if (after.length) version2 = after.join(".");
+        else {
+          const dotted = tokens.find((t) => /^\d+(\.\d+)+$/.test(t));
+          if (dotted) version2 = dotted;
+        }
+      }
+      return { family, version: version2, literal: literal2 };
+    }
+    function modelNamesEquivalent(a, b) {
+      const ca = canonicalizeModelName(a);
+      const cb = canonicalizeModelName(b);
+      if (!ca || !cb) return false;
+      if (ca.family && cb.family) {
+        if (ca.family !== cb.family) return false;
+        if (ca.version && cb.version) return ca.version === cb.version;
+        return true;
+      }
+      if (ca.family || cb.family) return false;
+      return ca.literal === cb.literal;
+    }
+    function isModelAllowedBySlot(model, slot) {
+      if (!slot) return true;
+      const declared = typeof slot.model === "string" ? slot.model.trim() : "";
+      const requested = typeof model === "string" ? model.trim() : "";
+      if (!declared) return !requested;
+      if (!requested) return true;
+      return modelNamesEquivalent(requested, declared);
+    }
+    function decideSlotForModel(input) {
+      const { requestedModel, slots } = input;
+      const declaring = slots.filter((s2) => isModelAllowedBySlot(requestedModel, s2.slot));
+      if (!declaring.length) {
+        const declaredModels = slots.map((s2) => typeof s2.slot.model === "string" && s2.slot.model.trim() ? s2.slot.model.trim() : "(provider default)").filter((v, i, a) => a.indexOf(v) === i);
+        return { outcome: "notify", reason: SLOT_MODEL_ABSENT_SKIP_REASON, declaredModels };
+      }
+      const free = declaring.find((s2) => s2.available);
+      if (free) {
+        const declared = typeof free.slot.model === "string" && free.slot.model.trim() ? free.slot.model.trim() : void 0;
+        return { outcome: "run", slot: free.slot, model: declared };
+      }
+      return {
+        outcome: "wait",
+        reason: SLOT_MODEL_BUSY_SKIP_REASON,
+        busySlots: declaring.map((s2) => s2.slot)
+      };
+    }
+    var CLAUDE_FAMILIES;
+    var MODIFIER_WORDS;
+    var SLOT_MODEL_BUSY_SKIP_REASON;
+    var SLOT_MODEL_ABSENT_SKIP_REASON;
+    var init_slot_model_enforcement = __esm2({
+      "src/mesh/slot-model-enforcement.ts"() {
+        "use strict";
+        CLAUDE_FAMILIES = ["opus", "sonnet", "haiku"];
+        MODIFIER_WORDS = /* @__PURE__ */ new Set(["thinking", "latest", "preview", "claude", "anthropic"]);
+        SLOT_MODEL_BUSY_SKIP_REASON = "slot_for_model_busy";
+        SLOT_MODEL_ABSENT_SKIP_REASON = "no_slot_declares_requested_model";
+      }
+    });
     function encodeDuplicateMeshDispatchCode(holderSessionId) {
       const holder = typeof holderSessionId === "string" ? holderSessionId.trim() : "";
       return holder ? `${DUPLICATE_MESH_DISPATCH_CODE}:${holder}` : DUPLICATE_MESH_DISPATCH_CODE;
@@ -54111,11 +54422,34 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!workspace) return null;
       try {
         const result = loadRepoMeshJsonConfig(workspace);
-        return result.sourceType === "repo_file" && result.config ? result.config : null;
+        if (result.sourceType !== "repo_file" || !result.config) return null;
+        if (!isConfigPathInsideWorkspace(result.path, workspace)) return null;
+        return result.config;
       } catch {
         return null;
       }
     }
+    function isConfigPathInsideWorkspace(configPath, workspace) {
+      if (typeof configPath !== "string" || !configPath) return false;
+      const toPosix = (value) => value.replace(/\\/g, "/").replace(/\/+$/, "");
+      const ws = toPosix(workspace);
+      const target = toPosix(configPath);
+      return !!ws && (target === ws || target.startsWith(`${ws}/`));
+    }
+    function warnUnreadableRepoConfigForNode(node, providerType) {
+      const workspace = typeof node?.workspace === "string" && node.workspace.trim() ? node.workspace.trim() : "";
+      if (!workspace) return;
+      const nodeId = readNonEmptyString(node?.id) || readNonEmptyString(node?.nodeId) || "unknown-node";
+      LOG2.warn(
+        "MeshQueue",
+        `repo mesh.json unreadable from this daemon for node=${nodeId} workspace=${workspace} provider=${providerType || "unknown"} \u2014 delegated auto-approve MODE falls back to the provider default here; the worker daemon re-resolves it from its own checkout at launch`
+      );
+    }
+    function delegatedWorkerAutoApproveSettingsForNode(mesh, node, provider, providerType) {
+      const repoConfig = loadRepoConfigForNode(node);
+      if (!repoConfig) warnUnreadableRepoConfigForNode(node, providerType);
+      return delegatedWorkerAutoApproveSettings(mesh?.policy, node?.policy, provider, repoConfig, providerType);
+    }
     function getMeshWithCache(components, meshId) {
       const localMesh = getMesh(meshId);
       const cachedMesh = components.router?.getCachedInlineMesh(meshId);
@@ -54395,7 +54729,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         return false;
       }
       const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
-      const providerMaxParallel = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node), providerType);
+      const providerMaxParallel = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node, meshId), providerType);
       const nodeIsWorktree = node?.isLocalWorktree === true;
       const assignedTranscriptProfile = resolveClaimingSessionTranscriptProfile(components, sessionId);
       const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
@@ -54532,11 +54866,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             meshNodeFor: meshId,
             meshNodeId: nodeId,
             launchedByCoordinator: true,
-            ...delegatedWorkerAutoApproveSettings(
-              mesh?.policy,
-              node?.policy,
+            ...delegatedWorkerAutoApproveSettingsForNode(
+              mesh,
+              node,
               components.providerLoader?.getMeta(providerType),
-              loadRepoConfigForNode(node),
               providerType
             ),
             ...localDaemonId ? { meshCoordinatorDaemonId: localDaemonId } : {},
@@ -54696,6 +55029,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         summary: "the node's workspace is dirty, so auto-launch is blocked to avoid clobbering uncommitted changes",
         nextAction: "Clean or commit the node's working tree (or fast-forward it); the task will then auto-assign."
       };
+      if (reason === SLOT_MODEL_ABSENT_SKIP_REASON) return {
+        summary: "no capability slot on the node declares the model this task resolved to (its difficulty\u2192brain preset picked a model the node was never configured to run)",
+        nextAction: "Re-enqueue with a difficulty/model the node's slots declare, target a node that declares this model, or add a slot for it. The task is NOT run on a substitute model \u2014 an undeclared model is never launched."
+      };
       return {
         summary: `it cannot be dispatched (${reason})`,
         nextAction: "Inspect the node/mesh state with mesh_status and resolve the blocker, or re-enqueue the task."
@@ -54887,8 +55224,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return score;
     }
-    function bestSlotForTask(node, task) {
-      const slots = resolveNodeCapabilitySlots(node);
+    function bestSlotForTask(node, task, meshId) {
+      const slots = resolveNodeCapabilitySlots(node, meshId);
       if (!slots.length) return null;
       let best = null;
       for (const slot of slots) {
@@ -54897,8 +55234,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return best;
     }
-    function nodeFitnessForTask(node, task) {
-      return bestSlotForTask(node, task)?.score ?? 0;
+    function nodeFitnessForTask(node, task, meshId) {
+      return bestSlotForTask(node, task, meshId)?.score ?? 0;
     }
     function orderEligibleNodes(meshId, strategy, nodes, opts) {
       if (strategy === "first_eligible" || nodes.length <= 1) {
@@ -54907,7 +55244,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (strategy === "fitness" && opts?.task) {
         const task = opts.task;
         return [...nodes].sort((a, b) => {
-          const fitDelta = nodeFitnessForTask(b.node, task) - nodeFitnessForTask(a.node, task);
+          const fitDelta = nodeFitnessForTask(b.node, task, meshId) - nodeFitnessForTask(a.node, task, meshId);
           if (fitDelta !== 0) return fitDelta;
           const prioDelta = resolveNodeSchedulingPriority(b.node?.policy) - resolveNodeSchedulingPriority(a.node?.policy);
           if (prioDelta !== 0) return prioDelta;
@@ -54936,6 +55273,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     function activeProviderAssignedCount(meshId, nodeId, providerType) {
       return getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId) && task.assignedProviderType === providerType).length;
     }
+    function slotHasCapacity(meshId, nodeId, node, slot) {
+      const providerType = typeof slot.provider === "string" ? slot.provider.trim() : "";
+      if (!providerType) return false;
+      const cap = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node, meshId), providerType);
+      if (cap === void 0) return true;
+      return activeProviderAssignedCount(meshId, nodeId, providerType) < cap;
+    }
     function sessionHasActiveAssignment(meshId, sessionId) {
       if (getQueue(meshId, { status: ["assigned"] }).some((task) => sessionIdsEquivalent(task.assignedSessionId, sessionId))) {
         return true;
@@ -55073,10 +55417,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         retractActionableSkipIfPreviouslyNotified(meshId, taskId);
       }
     }
-    async function resolveUsableProvider(components, nodeId, node, requiredTags, task) {
+    async function resolveUsableProvider(components, nodeId, node, meshId, requiredTags, task) {
       const providerLoader = components.providerLoader;
       if (!providerLoader) return { reason: "provider_loader_unavailable" };
-      const slots = resolveNodeCapabilitySlots(node);
+      const slots = resolveNodeCapabilitySlots(node, meshId);
       if (!slots.length) return { reason: "missing_provider_priority" };
       const orderedSlots = task ? [...slots].sort((a, b) => scoreSlotForTask(b, task) - scoreSlotForTask(a, task)) : slots;
       const failed = [];
@@ -55110,7 +55454,12 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           return {
             providerType: normalizedType,
             ...slot.model ? { model: slot.model } : {},
-            ...slot.thinkingLevel ? { thinkingLevel: slot.thinkingLevel } : {}
+            ...slot.thinkingLevel ? { thinkingLevel: slot.thinkingLevel } : {},
+            // The slot that won selection. Returned so the caller can enforce
+            // "the launch model must be one this slot declares" — a preset
+            // model must not widen what the operator configured. See
+            // slot-model-enforcement.ts.
+            slot
           };
         }
         failed.push(`${requestedType}: not detected`);
@@ -55247,7 +55596,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
           if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
           if (task.requiredTags?.length) {
-            const slotProviders = resolveNodeCapabilitySlots(node).map((s2) => s2.provider).filter(Boolean);
+            const slotProviders = resolveNodeCapabilitySlots(node, meshId).map((s2) => s2.provider).filter(Boolean);
             const priorities = slotProviders.length ? slotProviders : normalizeProviderPriority2(node?.policy);
             const providerCandidates = priorities.length ? priorities : [void 0];
             return providerCandidates.some(
@@ -55336,18 +55685,36 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           }
           autoLaunchInProgress.add(launchKey);
           try {
-            const resolved = await resolveUsableProvider(components, nodeId, node, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags });
+            const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags });
             if (!resolved.providerType) {
               markSkip(nodeId, resolved.reason || "provider_unusable");
               continue;
             }
-            const rawEffectiveModel = typeof task.model === "string" && task.model.trim() ? task.model.trim() : resolved.model;
+            const requestedModel = typeof task.model === "string" && task.model.trim() ? task.model.trim() : resolved.model;
             const effectiveThinkingLevel = typeof task.thinkingLevel === "string" && task.thinkingLevel.trim() ? task.thinkingLevel.trim() : resolved.thinkingLevel;
+            const slotDecision = decideSlotForModel({
+              requestedModel,
+              slots: resolveNodeCapabilitySlots(node, meshId).map((slot) => ({
+                slot,
+                available: slotHasCapacity(meshId, nodeId, node, slot)
+              }))
+            });
+            if (slotDecision.outcome === "wait") {
+              LOG2.info("MeshQueue", `SLOT MODEL GUARD: model '${requestedModel}' is declared on node ${nodeId} but every matching slot is at its maxParallel cap (task ${task.id}); leaving the task queued until a slot goes idle`);
+              markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+              continue;
+            }
+            if (slotDecision.outcome === "notify") {
+              LOG2.warn("MeshQueue", `SLOT MODEL GUARD: no slot on node ${nodeId} declares model '${requestedModel}' (declared: ${slotDecision.declaredModels.join(", ") || "none"}) for task ${task.id}; not launching \u2014 surfacing to the coordinator to re-drive`);
+              markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+              continue;
+            }
+            const rawEffectiveModel = slotDecision.model;
             const effectiveModel = isModelCompatibleWithProvider(rawEffectiveModel, resolved.providerType) ? rawEffectiveModel : void 0;
             if (rawEffectiveModel && effectiveModel === void 0) {
               LOG2.info("MeshQueue", `CODEX-400 GUARD: dropped incompatible launch model '${rawEffectiveModel}' for non-Anthropic provider '${resolved.providerType}' on node ${nodeId} (task ${task.id}); provider will use its own default model`);
             }
-            const providerCap = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node), resolved.providerType);
+            const providerCap = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node, meshId), resolved.providerType);
             if (providerCap !== void 0 && activeProviderAssignedCount(meshId, nodeId, resolved.providerType) >= providerCap) {
               markSkip(nodeId, "max_provider_parallel_reached", { providerType: resolved.providerType });
               continue;
@@ -55361,11 +55728,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
               // Coordinator-dispatched worker: auto-approve unless mesh/node policy
               // opts out (default true). Lands in settingsOverride and beats the
               // global per-provider-type boolean/mode through explicit opposite-key clearing.
-              ...delegatedWorkerAutoApproveSettings(
-                mesh?.policy,
-                node?.policy,
+              ...delegatedWorkerAutoApproveSettingsForNode(
+                mesh,
+                node,
                 components.providerLoader?.getMeta(resolved.providerType),
-                loadRepoConfigForNode(node),
                 resolved.providerType
               ),
               launchedByCoordinator: true,
@@ -55441,7 +55807,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
             const routingDecision = {
               source: "autoLaunch",
-              fitnessScore: nodeFitnessForTask(node, { difficulty: task.difficulty, requiredTags: task.requiredTags }),
+              fitnessScore: nodeFitnessForTask(node, { difficulty: task.difficulty, requiredTags: task.requiredTags }, meshId),
               ...skippedCandidates.length ? { skippedCandidates } : {},
               requiredTagsResult: {
                 required: requiredTags,
@@ -55885,6 +56251,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_clone_grace();
         init_mesh_task_inflight();
         init_model_provider_compat();
+        init_slot_model_enforcement();
         init_mesh_turn_ledger();
         init_mesh_duplicate_dispatch();
         IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
@@ -55917,7 +56284,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           "provider_loader_unavailable",
           "provider_priority_unusable",
           "provider_unusable",
-          "dirty_workspace"
+          "dirty_workspace",
+          // SLOT MODEL GUARD (absent): no slot on the node declares the task's model.
+          // Permanent — no amount of waiting produces a slot, so the coordinator must
+          // re-drive (adjust difficulty, target another node, ask the owner). Its
+          // busy counterpart SLOT_MODEL_BUSY_SKIP_REASON is deliberately NOT listed:
+          // that one clears on its own when the slot goes idle.
+          SLOT_MODEL_ABSENT_SKIP_REASON
         ];
         TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON = "target_node_bootstrap_pending";
         lastActionableSkipNotified = /* @__PURE__ */ new Map();
@@ -61308,7 +61681,15 @@ ${cleanBody}`;
       try {
         pendingEvents = drainPendingMeshCoordinatorEvents(
           meshId,
-          drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId
+          drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
+          {
+            // AMBIGUOUS-UNICAST guard (REFINE-EVENT-SESSION-SCOPED-UNICAST): observability
+            // only — it warns when a session-less unicast event is delivered while several
+            // coordinator sessions are live and racing for it. Never changes delivery, so
+            // an event can't be stranded by it. targetCoordinators is this daemon's live
+            // coordinator set for the mesh, which is exactly the racing population.
+            countLiveCoordinatorSessions: () => new Set(targetCoordinators.map((c) => c.sessionId).filter(Boolean)).size
+          }
         );
       } catch (e) {
         LOG2.warn("MeshReconcile", `Drain failed for mesh ${meshId}: ${e?.message || e}`);
@@ -71152,6 +71533,7 @@ ${lastSnapshot}`;
       buildChatMessageSignature: () => buildChatMessageSignature,
       buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
       buildClaudeInteractiveToolResult: () => buildClaudeInteractiveToolResult,
+      buildCloudStatusReportPayload: () => buildCloudStatusReportPayload,
       buildCompactStaleDirectWorkSummary: () => buildCompactStaleDirectWorkSummary,
       buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
       buildIdleReminderMessage: () => buildIdleReminderMessage,
@@ -71451,6 +71833,7 @@ ${lastSnapshot}`;
       resolveNotBefore: () => resolveNotBefore,
       resolveProviderChannel: () => resolveProviderChannel,
       resolveProviderMaxParallel: () => resolveProviderMaxParallel,
+      resolveScopedMeshId: () => resolveScopedMeshId,
       resolveSessionHostAppName: () => resolveSessionHostAppName,
       resolveSessionHostAppNameResolution: () => resolveSessionHostAppNameResolution2,
       resolveSessionTurnPresentation: () => resolveSessionTurnPresentation,
@@ -73026,7 +73409,7 @@ ${lastSnapshot}`;
       const bootstrapLoaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
       let magiKindPanels = {};
       try {
-        magiKindPanels = listMagiKindPanelsReadOnly();
+        magiKindPanels = listMagiKindPanelsReadOnly(typeof mesh?.id === "string" ? mesh.id : void 0);
       } catch {
         magiKindPanels = {};
       }
@@ -85484,6 +85867,84 @@ ${body}
     init_hash();
     init_coordinator_registry();
     init_mesh_duplicate_dispatch();
+    init_mesh_json_config();
+    init_logger();
+    init_repo_mesh_types();
+    function resolveDelegatedWorkerAutoApproveModeForLaunch(input) {
+      const settings = input.settings;
+      const envelopeMode = typeof settings?.autoApproveMode === "string" && settings.autoApproveMode.trim() ? settings.autoApproveMode.trim() : void 0;
+      if (settings?.launchedByCoordinator !== true) {
+        return { autoApproveMode: envelopeMode, changed: false, source: "not_delegated" };
+      }
+      if (settings.autoApprove === false) {
+        return { autoApproveMode: void 0, changed: false, source: "enable_gate_off" };
+      }
+      const providerType = typeof input.providerType === "string" ? input.providerType.trim() : "";
+      if (!providerType || !input.provider?.autoApproveModes) {
+        return { autoApproveMode: envelopeMode, changed: false, source: "no_provider_modes" };
+      }
+      const workspace = typeof input.workspace === "string" ? input.workspace.trim() : "";
+      if (!workspace) {
+        return { autoApproveMode: envelopeMode, changed: false, source: "no_repo_config" };
+      }
+      let repoConfig = null;
+      try {
+        const result = loadRepoMeshJsonConfig(workspace);
+        const fromThisWorkspace = result.sourceType === "repo_file" && typeof result.path === "string" && isPathInsideWorkspace(result.path, workspace);
+        repoConfig = fromThisWorkspace && result.config ? result.config : null;
+      } catch {
+        repoConfig = null;
+      }
+      const requestedMode = repoConfig?.providerDefaults?.autoApproveModes?.[providerType];
+      const requestedModeId = typeof requestedMode === "string" && requestedMode.trim() ? requestedMode.trim() : "";
+      if (!requestedModeId) {
+        return { autoApproveMode: envelopeMode, changed: false, source: "no_repo_config" };
+      }
+      const dangerousAllowed = settings.delegatedWorkerDangerousModeAllow === true;
+      const resolved = resolveDelegatedWorkerAutoApprove(
+        { delegatedWorkerAutoApprove: true, delegatedWorkerDangerousModeAllow: dangerousAllowed },
+        void 0,
+        input.provider,
+        repoConfig,
+        providerType
+      );
+      if (typeof resolved !== "string") {
+        return { autoApproveMode: envelopeMode, changed: false, source: "no_repo_config" };
+      }
+      return {
+        autoApproveMode: resolved,
+        changed: resolved !== envelopeMode,
+        source: "worker_repo_file"
+      };
+    }
+    function isPathInsideWorkspace(configPath, workspace) {
+      const normalize4 = (value) => value.replace(/[\\/]+$/, "");
+      const ws = normalize4(workspace);
+      if (!ws) return false;
+      const separatorAgnostic = (value) => value.replace(/\\/g, "/");
+      const normalizedPath = separatorAgnostic(configPath);
+      const normalizedWs = separatorAgnostic(ws);
+      return normalizedPath === normalizedWs || normalizedPath.startsWith(`${normalizedWs}/`);
+    }
+    function logDelegatedWorkerModeDelivery(resolution, context) {
+      if (resolution.source !== "worker_repo_file" && resolution.source !== "no_repo_config") return;
+      const node = context.meshNodeId || "unknown-node";
+      const workspace = context.workspace || "unknown-workspace";
+      const provider = context.providerType || "unknown-provider";
+      if (resolution.source === "worker_repo_file" && resolution.changed) {
+        LOG2.info(
+          "MeshWorker",
+          `auto-approve mode re-resolved from worker repo config: node=${node} workspace=${workspace} provider=${provider} coordinatorMode=${context.envelopeMode ?? "(none)"} workerMode=${resolution.autoApproveMode}`
+        );
+        return;
+      }
+      if (resolution.source === "no_repo_config" && context.envelopeMode) {
+        LOG2.warn(
+          "MeshWorker",
+          `auto-approve mode NOT confirmed by worker repo config (keeping coordinator value): node=${node} workspace=${workspace} provider=${provider} mode=${context.envelopeMode} \u2014 no readable .adhdev/mesh.json in this workspace`
+        );
+      }
+    }
     init_summary_metadata();
     var os19 = __toESM2(require("os"));
     var crypto5 = __toESM2(require("crypto"));
@@ -87981,6 +88442,48 @@ ${body}
         }
         return screenText;
       }
+      /**
+       * Is `reread` a re-render of the SAME picker page as `landed`?
+       *
+       * Guards the return-pass screenText swap in captureClaudeTuiPrompt, which
+       * replaces a page's entire raw screen and therefore must never be handed a
+       * frame belonging to a different question.
+       *
+       * WHAT WE COMPARE — the question line, via the same parser the capture
+       * itself uses (readFocusedClaudeTuiQuestion). Rationale:
+       *  - The question text is the one field that is per-page, always rendered
+       *    (it is the parse anchor — a page without it yields no question at all),
+       *    and stable across the redraw we are waiting on. The redraw races the
+       *    option-row GLYPH COLUMN, not the question line.
+       *  - The header is NOT usable on its own: on the headered variant every page
+       *    renders the identical nav line, and `page.header` is assigned by index
+       *    from that shared line rather than read from the page body — so it is
+       *    equal across pages by construction and would accept any frame.
+       *  - The option-label set is rejected as the primary key: it is drawn in the
+       *    very region that is mid-redraw, and rows can be clipped or scrolled out
+       *    of the captured frame (the same truncation that forced the headerless
+       *    parser to stop requiring the freeform escape hatch). Comparing it would
+       *    reject legitimate repairs — exactly the frames this pass exists to fix.
+       *
+       * STRICTNESS — deliberately asymmetric, because the two error directions are
+       * not equally costly. Wrongly ALLOWING a swap corrupts a question into a
+       * duplicate of another (the reported user-visible defect). Wrongly BLOCKING
+       * one merely leaves the forward-pass capture in place — at worst a
+       * multi-select page stays flagged single-select, which the live status-tick
+       * upgrade (maybeUpgradeClaudeTuiMultiSelect) then repairs anyway. So this
+       * blocks only on POSITIVE EVIDENCE of a different page: if either side fails
+       * to parse we return true and defer to the pre-existing glyph gate, keeping
+       * behaviour identical to before for every frame whose identity we cannot
+       * read. Comparison is whitespace-normalised so a reflow or trailing-pad
+       * difference does not read as a different question.
+       */
+      claudeTuiPagesLookLikeSameQuestion(landed, reread) {
+        const landedQuestion = readFocusedClaudeTuiQuestion(landed.screenText);
+        const rereadQuestion = readFocusedClaudeTuiQuestion(reread);
+        if (!landedQuestion || !rereadQuestion) return true;
+        const normalize4 = (text) => text.replace(/\s+/g, " ").trim();
+        return normalize4(landedQuestion.question) === normalize4(rereadQuestion.question);
+      }
       async captureClaudeTuiPrompt(firstScreen, headers) {
         const pages = [{ screenText: firstScreen, header: headers[0] }];
         for (let index = 1; index < headers.length; index += 1) {
@@ -87993,7 +88496,7 @@ ${body}
           await new Promise((resolve29) => setTimeout(resolve29, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
           const reread = await this.snapshotSettledClaudeTuiPage();
           const landed = pages[index - 1];
-          if (landed && !detectClaudeTuiMultiSelect(landed.screenText) && detectClaudeTuiMultiSelect(reread)) {
+          if (landed && !detectClaudeTuiMultiSelect(landed.screenText) && detectClaudeTuiMultiSelect(reread) && this.claudeTuiPagesLookLikeSameQuestion(landed, reread)) {
             landed.screenText = reread;
           }
         }
@@ -94794,7 +95297,29 @@ Run 'adhdev doctor' for detailed diagnostics.`
             if (!cliType) throw new Error("cliType required");
             const providerType = this.providerLoader.resolveAlias(cliType);
             const provLookup = this.providerLoader.getMeta(providerType);
-            const settingsOverride = args?.settings && typeof args.settings === "object" ? args.settings : void 0;
+            let settingsOverride = args?.settings && typeof args.settings === "object" ? args.settings : void 0;
+            if (settingsOverride?.launchedByCoordinator === true) {
+              const envelopeMode = typeof settingsOverride.autoApproveMode === "string" ? settingsOverride.autoApproveMode : void 0;
+              const modeResolution = resolveDelegatedWorkerAutoApproveModeForLaunch({
+                workspace: dir,
+                providerType,
+                provider: provLookup,
+                settings: settingsOverride
+              });
+              logDelegatedWorkerModeDelivery(modeResolution, {
+                workspace: dir,
+                providerType,
+                meshNodeId: typeof settingsOverride.meshNodeId === "string" ? settingsOverride.meshNodeId : void 0,
+                envelopeMode
+              });
+              if (modeResolution.changed && modeResolution.autoApproveMode) {
+                settingsOverride = {
+                  ...settingsOverride,
+                  autoApproveMode: modeResolution.autoApproveMode,
+                  autoApprove: void 0
+                };
+              }
+            }
             const delegatedLaunch = settingsOverride?.launchedByCoordinator === true ? buildCoordinatorDelegatedCliLaunchOptions({
               cliType,
               workspace: dir,
@@ -100893,7 +101418,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
         return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
       },
-      create_mesh: async (_ctx, args) => {
+      create_mesh: async (ctx, args) => {
         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;
@@ -100902,12 +101427,71 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         try {
           const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
-          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
+          const requestedHostDaemonId = typeof args?.hostDaemonId === "string" && args.hostDaemonId.trim() ? args.hostDaemonId.trim() : ctx.deps.statusInstanceId || "";
+          const mesh = createMesh2({
+            name,
+            repoIdentity,
+            repoRemoteUrl,
+            defaultBranch,
+            policy: args?.policy,
+            meshHost,
+            ...requestedHostDaemonId ? { hostDaemonId: requestedHostDaemonId } : {}
+          });
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
         }
       },
+      // HOST-PIN-WRITER — establish this mesh's host daemon as a DELIBERATE operator act.
+      //
+      // The dashboard's first-setup flow lets the operator pick which connected daemon
+      // becomes the host; this is the command that actually persists that choice. It is a
+      // separate surface from coordinator launch on purpose: the pin is effectively
+      // permanent ("Fixed when the mesh is created — it cannot be reassigned here"), so it
+      // must not be an incidental side effect of a button whose stated job is launching a
+      // session. A mis-click must not permanently re-home a mesh.
+      //
+      // Reassignment to a DIFFERENT daemon is refused unless the caller passes
+      // force:true — the mutator returns code 'host_already_pinned' and changes nothing.
+      // Re-pinning the same daemon is a no-op, so retries/races are safe.
+      set_mesh_host: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const hostDaemonId = typeof args?.hostDaemonId === "string" ? args.hostDaemonId.trim() : "";
+        const hostNodeId = typeof args?.hostNodeId === "string" ? args.hostNodeId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!hostDaemonId && !hostNodeId) return { success: false, error: "hostDaemonId or hostNodeId required" };
+        try {
+          const { setMeshHostPin: setMeshHostPin2, getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const result = setMeshHostPin2(meshId, {
+            ...hostDaemonId ? { hostDaemonId } : {},
+            ...hostNodeId ? { hostNodeId } : {},
+            force: args?.force === true
+          });
+          if (!result) return { success: false, error: "Mesh not found" };
+          if (!result.applied && result.reason !== "already_pinned_same") {
+            return {
+              success: false,
+              code: result.reason,
+              error: result.reason === "host_already_pinned" ? `Mesh host is already pinned to ${result.hostDaemonId}. Pass force:true to reassign it.` : result.reason === "not_host_role" ? "This daemon joined the mesh as a member; its host lives on the daemon it paired with." : "hostDaemonId or hostNodeId required",
+              meshId,
+              meshHost: resolveMeshHostStatus(result.mesh)
+            };
+          }
+          const fresh = getMesh2(meshId) || result.mesh;
+          if (ctx.getCachedInlineMesh(meshId)) ctx.inlineMeshCache.set(meshId, fresh);
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return {
+            success: true,
+            code: result.reason,
+            meshId,
+            applied: result.applied,
+            meshHost: resolveMeshHostStatus(fresh),
+            mesh: fresh
+          };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
       update_mesh: async (ctx, args) => {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
@@ -101184,19 +101768,37 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       },
       // ─── MAGI kind → panel bindings (MAGI-KIND-PANEL, machine-local config) ───
-      // Per-task_kind slot lists in ~/.adhdev/meshes.json `magiKindPanels` — the SOLE
-      // MAGI panel-resolution surface (the former named-panel magi_panel_* handlers were
-      // removed). Owner-only gating: intentionally NOT listed in
+      // Per-task_kind slot lists stored PER MESH in ~/.adhdev/meshes.json
+      // (`meshes[].magiKindPanels`) — the SOLE MAGI panel-resolution surface (the former
+      // named-panel magi_panel_* handlers were removed). `meshId` is optional on all three
+      // so existing callers keep working: it resolves to the sole mesh on a single-mesh
+      // machine, and is REQUIRED (loud error, never a silent pick) when several meshes
+      // exist. Owner-only gating: intentionally NOT listed in
       // canPeerUsePrivilegedShareCommand (daemon-cloud data-channel-router), so a peer
       // holding ANY share permission hits its `default → false` branch — identical
       // owner-only gating to create_mesh / update_mesh / list_meshes. A trusted peer (no
       // permission = the owner) passes the top `!permission → true` guard. set/remove are
       // WRITE commands; list is read-only. normalizeMagiSlots (inside setMagiKindPanel)
-      // surfaces invalid_magi_kind_panel: … messages verbatim for the editor.
-      magi_kind_panel_list: async (_ctx, _args) => {
+      // surfaces invalid_magi_kind_panel: … messages verbatim for the editor, including
+      // a nodeId that is not a member of the target mesh.
+      magi_kind_panel_list: async (_ctx, args) => {
+        const requestedMeshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         try {
-          const { listMagiKindPanels: listMagiKindPanels2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          return { success: true, kindPanels: listMagiKindPanels2() };
+          const { listMagiKindPanels: listMagiKindPanels2, resolveScopedMeshId: resolveScopedMeshId2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const meshId = requestedMeshId || resolveScopedMeshId2();
+          return {
+            success: true,
+            kindPanels: listMagiKindPanels2(requestedMeshId || void 0),
+            scope: {
+              kind: "mesh",
+              storage: "machine_local",
+              meshId: meshId ?? null,
+              resolvedFrom: requestedMeshId ? "explicit" : meshId ? "sole_mesh" : "ambiguous",
+              ...requestedMeshId || meshId ? {} : {
+                note: "Several meshes are configured and no meshId was given, so no panels could be read. Pass meshId."
+              }
+            }
+          };
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -101204,10 +101806,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       magi_kind_panel_set: async (_ctx, args) => {
         const kind = typeof args?.kind === "string" ? args.kind.trim() : "";
         if (!kind) return { success: false, error: "invalid_magi_kind_panel: task_kind is required" };
+        const requestedMeshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         try {
-          const { setMagiKindPanel: setMagiKindPanel2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const slots = setMagiKindPanel2(kind, args?.slots);
-          return { success: true, kind, slots };
+          const { setMagiKindPanel: setMagiKindPanel2, resolveScopedMeshId: resolveScopedMeshId2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const slots = setMagiKindPanel2(kind, args?.slots, requestedMeshId || void 0);
+          const meshId = requestedMeshId || resolveScopedMeshId2();
+          return { success: true, kind, slots, meshId: meshId ?? null };
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -101215,30 +101819,52 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       magi_kind_panel_remove: async (_ctx, args) => {
         const kind = typeof args?.kind === "string" ? args.kind.trim() : "";
         if (!kind) return { success: false, error: "invalid_magi_kind_panel: task_kind is required" };
+        const requestedMeshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         try {
-          const { removeMagiKindPanel: removeMagiKindPanel2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const removed = removeMagiKindPanel2(kind);
-          return { success: true, removed };
+          const { removeMagiKindPanel: removeMagiKindPanel2, resolveScopedMeshId: resolveScopedMeshId2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const removed = removeMagiKindPanel2(kind, requestedMeshId || void 0);
+          const meshId = requestedMeshId || resolveScopedMeshId2();
+          return { success: true, removed, meshId: meshId ?? null };
         } catch (e) {
           return { success: false, error: e.message };
         }
       },
-      // ─── Brain routing: per-difficulty brain presets (machine-local) ───
-      // getDifficultyBrains returns the seeded defaults when nothing is configured,
-      // so the editor always shows a usable mapping. set replaces the whole map.
-      difficulty_brains_get: async (_ctx, _args) => {
+      // ─── Brain routing: per-difficulty brain presets (PER MESH, machine-local) ───
+      // getDifficultyBrains returns the seeded defaults when the mesh has nothing
+      // configured, so the editor always shows a usable mapping. set replaces the whole
+      // map for ONE mesh. `meshId` is optional and resolves to the sole mesh, so
+      // existing callers keep working; with several meshes a write must name its mesh
+      // (these presets choose the model a task runs on — writing to the wrong mesh
+      // changes what that mesh costs).
+      difficulty_brains_get: async (_ctx, args) => {
+        const requestedMeshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         try {
-          const { getDifficultyBrains: getDifficultyBrains2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          return { success: true, difficultyBrains: getDifficultyBrains2() };
+          const { getDifficultyBrains: getDifficultyBrains2, resolveScopedMeshId: resolveScopedMeshId2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const meshId = requestedMeshId || resolveScopedMeshId2();
+          return {
+            success: true,
+            difficultyBrains: getDifficultyBrains2(requestedMeshId || void 0),
+            scope: {
+              kind: "mesh",
+              storage: "machine_local",
+              meshId: meshId ?? null,
+              resolvedFrom: requestedMeshId ? "explicit" : meshId ? "sole_mesh" : "ambiguous",
+              ...requestedMeshId || meshId ? {} : {
+                note: "Several meshes are configured and no meshId was given, so these are the shipped defaults, not any mesh's saved presets. Pass meshId."
+              }
+            }
+          };
         } catch (e) {
           return { success: false, error: e.message };
         }
       },
       difficulty_brains_set: async (_ctx, args) => {
+        const requestedMeshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         try {
-          const { setDifficultyBrains: setDifficultyBrains2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const difficultyBrains = setDifficultyBrains2(args?.difficultyBrains);
-          return { success: true, difficultyBrains };
+          const { setDifficultyBrains: setDifficultyBrains2, resolveScopedMeshId: resolveScopedMeshId2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const difficultyBrains = setDifficultyBrains2(args?.difficultyBrains, requestedMeshId || void 0);
+          const meshId = requestedMeshId || resolveScopedMeshId2();
+          return { success: true, difficultyBrains, meshId: meshId ?? null };
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -102810,6 +103436,26 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_mesh_coordinator();
     init_dist();
     init_repo_mesh_types();
+    async function backfillMeshHostPinAfterLaunch(opts) {
+      try {
+        const existingPin = typeof opts.mesh?.meshHost?.hostDaemonId === "string" ? opts.mesh.meshHost.hostDaemonId.trim() : "";
+        if (existingPin) return;
+        const { getMesh: getMesh2, setMeshHostPin: setMeshHostPin2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+        if (!getMesh2(opts.meshId)) return;
+        const nodeDaemonId = typeof opts.coordinatorNode?.daemonId === "string" && opts.coordinatorNode.daemonId.trim() ? opts.coordinatorNode.daemonId.trim() : typeof opts.coordinatorNode?.daemon_id === "string" && opts.coordinatorNode.daemon_id.trim() ? opts.coordinatorNode.daemon_id.trim() : opts.localDaemonId || "";
+        const nodeId = String(normalizeMeshNodeId(opts.coordinatorNode) || "");
+        if (!nodeDaemonId && !nodeId) return;
+        const result = setMeshHostPin2(opts.meshId, {
+          ...nodeDaemonId ? { hostDaemonId: nodeDaemonId } : {},
+          ...nodeId ? { hostNodeId: nodeId } : {}
+        });
+        if (result?.applied) {
+          LOG2.info("MeshCoordinator", `Pinned mesh ${opts.meshId} host to ${result.hostDaemonId || nodeDaemonId} (node ${result.hostNodeId || nodeId}) after coordinator launch`);
+        }
+      } catch (error48) {
+        LOG2.warn("MeshCoordinator", `Host pin backfill skipped for mesh ${opts.meshId}: ${error48?.message || String(error48)}`);
+      }
+    }
     var meshCoordinatorLaunchHandlers = {
       launch_mesh_coordinator: async (ctx, args) => {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
@@ -102889,10 +103535,10 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               return void 0;
             }
           };
-          const loadMagiKindPanelsBestEffort = async () => {
+          const loadMagiKindPanelsBestEffort = async (forMeshId) => {
             try {
               const { listMagiKindPanels: listMagiKindPanels2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              return listMagiKindPanels2();
+              return listMagiKindPanels2(forMeshId);
             } catch {
               return void 0;
             }
@@ -102994,7 +103640,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           if (coordinatorSetup.kind === "cli_command") {
             let cliCmdSystemPrompt = "";
             try {
-              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort() });
+              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort(meshId) });
             } catch (error48) {
               const message = error48?.message || String(error48);
               LOG2.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
@@ -103169,6 +103815,12 @@ ${ptyResult.output.slice(-2e3)}`);
               });
             } catch {
             }
+            await backfillMeshHostPinAfterLaunch({
+              meshId,
+              mesh,
+              coordinatorNode,
+              localDaemonId: ctx.deps.statusInstanceId
+            });
             return {
               success: true,
               meshId,
@@ -103191,7 +103843,7 @@ ${ptyResult.output.slice(-2e3)}`);
           }
           let systemPrompt = "";
           try {
-            systemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort() });
+            systemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort(meshId) });
           } catch (error48) {
             const message = error48?.message || String(error48);
             LOG2.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
@@ -103367,6 +104019,12 @@ ${ptyResult.output.slice(-2e3)}`);
             });
           } catch {
           }
+          await backfillMeshHostPinAfterLaunch({
+            meshId,
+            mesh,
+            coordinatorNode,
+            localDaemonId: ctx.deps.statusInstanceId
+          });
           return {
             success: true,
             meshId,
@@ -105769,6 +106427,7 @@ ${mergeTreeErr?.stderr || ""}`;
         ...args.completedAt ? { completedAt: args.completedAt } : {},
         ...args.retryOfJobId ? { retryOfJobId: args.retryOfJobId } : {},
         ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
+        ...args.coordinatorSessionId ? { targetCoordinatorSessionId: args.coordinatorSessionId } : {},
         eventDelivery: { pendingEvents: true, ledger: true },
         evidence: {
           pendingEventsCommand: "get_pending_mesh_events",
@@ -105867,9 +106526,23 @@ ${mergeTreeErr?.stderr || ""}`;
         nodeLabel: handle.targetNodeId,
         nodeId: handle.targetNodeId,
         workspace: handle.workspace,
-        metadataEvent,
+        metadataEvent: {
+          ...metadataEvent,
+          // REFINE-EVENT-SESSION-SCOPED-UNICAST: mirror the session INSIDE
+          // metadataEvent too. handleMeshForwardEvent reads the coordinator session
+          // anchor from `metadataEvent.meshCoordinatorSessionId` (a top-level field
+          // alone is dropped when the event crosses a machine boundary), so this is
+          // what survives the P2P relay for a remote-executing refine.
+          ...handle.targetCoordinatorSessionId ? { meshCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
+        },
         queuedAt: Date.now(),
-        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {}
+        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+        // THE FIX: address the terminal event to the requesting coordinator SESSION,
+        // not just its daemon. stampPendingEventV2 folds this into the v2 unicast
+        // `intendedFor`, so identityDeliversTo's both-sides-session branch excludes a
+        // sibling coordinator session on the same daemon. Absent (legacy requester) →
+        // session-less intendedFor → daemon-level delivery exactly as before.
+        ...handle.targetCoordinatorSessionId ? { targetCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
       };
       if (typeof self.deps.instanceManager?.getByCategory === "function") {
         const forwarded = handleMeshForwardEvent(
@@ -105893,6 +106566,14 @@ ${mergeTreeErr?.stderr || ""}`;
             // re-queued event self-fallbacks to THIS (the executing/worker)
             // daemon and the real coordinator's drain excludes it.
             ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+            // REFINE-EVENT-SESSION-SCOPED-UNICAST: carry the SESSION half of the
+            // return address across the relay as well. buildRelayMetadataEvent
+            // reads meshCoordinatorSessionId (falling back to
+            // targetCoordinatorSessionId), so both spellings are supplied.
+            ...handle.targetCoordinatorSessionId ? {
+              targetCoordinatorSessionId: handle.targetCoordinatorSessionId,
+              meshCoordinatorSessionId: handle.targetCoordinatorSessionId
+            } : {},
             ...slimResult ? { result: slimResult } : {}
           }
         );
@@ -107317,6 +107998,7 @@ ${e?.stderr || ""}`;
         startedAt: args.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
         ...args.completedAt ? { completedAt: args.completedAt } : {},
         ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
+        ...args.coordinatorSessionId ? { targetCoordinatorSessionId: args.coordinatorSessionId } : {},
         eventDelivery: { pendingEvents: true, ledger: true },
         evidence: {
           pendingEventsCommand: "get_pending_mesh_events",
@@ -107346,9 +108028,16 @@ ${e?.stderr || ""}`;
         meshId: handle.meshId,
         nodeLabel: handle.batchLabel,
         nodeId: handle.batchLabel,
-        metadataEvent,
+        metadataEvent: {
+          ...metadataEvent,
+          // REFINE-EVENT-SESSION-SCOPED-UNICAST — see queueRefineJobEvent.
+          ...handle.targetCoordinatorSessionId ? { meshCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
+        },
         queuedAt: Date.now(),
-        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {}
+        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+        // THE FIX (batch half) — address the batch terminal event to the requesting
+        // coordinator SESSION so a sibling session cannot consume it.
+        ...handle.targetCoordinatorSessionId ? { targetCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
       };
       if (typeof self.deps.instanceManager?.getByCategory === "function") {
         const forwarded = handleMeshForwardEvent(
@@ -107366,6 +108055,12 @@ ${e?.stderr || ""}`;
             // the sessionless batch job's terminal event must stay targeted
             // at the originating coordinator, not self-fallback to this daemon.
             ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+            // REFINE-EVENT-SESSION-SCOPED-UNICAST — session half of the return
+            // address, both spellings (see queueRefineJobEvent).
+            ...handle.targetCoordinatorSessionId ? {
+              targetCoordinatorSessionId: handle.targetCoordinatorSessionId,
+              meshCoordinatorSessionId: handle.targetCoordinatorSessionId
+            } : {},
             ...result ? { result } : {}
           }
         );
@@ -107438,7 +108133,10 @@ ${e?.stderr || ""}`;
         completedAt,
         jobId: handle.jobId,
         interactionId: handle.interactionId,
-        coordinatorDaemonId: handle.targetCoordinatorDaemonId
+        coordinatorDaemonId: handle.targetCoordinatorDaemonId,
+        // REFINE-EVENT-SESSION-SCOPED-UNICAST — carry the requester's session onto the
+        // terminal batch handle (see the single-node path).
+        coordinatorSessionId: handle.targetCoordinatorSessionId
       });
       const terminal = { ...terminalHandle, result: normalizedResult };
       self.terminalRefineBatchJobs.set(key2, terminal);
@@ -107472,7 +108170,8 @@ ${e?.stderr || ""}`;
         rationale: planRecord.orderingRationale
       };
       const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : self.deps.statusInstanceId || void 0;
-      const handle = buildRefineBatchJobHandle(self, { meshId, nodeIds, order, coordinatorDaemonId });
+      const coordinatorSessionId = typeof args?.coordinatorSessionId === "string" && args.coordinatorSessionId.trim() ? args.coordinatorSessionId.trim() : void 0;
+      const handle = buildRefineBatchJobHandle(self, { meshId, nodeIds, order, coordinatorDaemonId, coordinatorSessionId });
       self.runningRefineBatchJobs.set(key2, handle);
       await appendRefineBatchJobLedger(self, "task_dispatched", handle);
       queueRefineBatchJobEvent(self, "refine:accepted", handle);
@@ -107563,7 +108262,12 @@ ${e?.stderr || ""}`;
         interactionId: handle.interactionId,
         retryOfJobId: handle.retryOfJobId,
         node: { daemonId: handle.targetDaemonId, workspace: handle.workspace },
-        coordinatorDaemonId: handle.targetCoordinatorDaemonId
+        coordinatorDaemonId: handle.targetCoordinatorDaemonId,
+        // REFINE-EVENT-SESSION-SCOPED-UNICAST: carry the requester's session from the
+        // accepted handle onto the TERMINAL handle. Dropping it here would leave the
+        // completed/failed event — the one the coordinator actually waits on — back at
+        // daemon-level addressing, i.e. the original defect.
+        coordinatorSessionId: handle.targetCoordinatorSessionId
       });
       const terminal = { ...terminalHandle, result: normalizedResult };
       self.terminalRefineJobs.set(key2, terminal);
@@ -107583,7 +108287,8 @@ ${e?.stderr || ""}`;
       if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
       if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
       const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : self.deps.statusInstanceId || void 0;
-      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId });
+      const coordinatorSessionId = typeof args?.coordinatorSessionId === "string" && args.coordinatorSessionId.trim() ? args.coordinatorSessionId.trim() : void 0;
+      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId, coordinatorSessionId });
       self.runningRefineJobs.set(key2, handle);
       await appendRefineJobLedger(self, "task_dispatched", handle);
       queueRefineJobEvent(self, "refine:accepted", handle);
@@ -109175,6 +109880,32 @@ ${e?.stderr || ""}`;
     init_logger();
     init_runtime_defaults();
     init_snapshot();
+    function buildCloudStatusReportPayload(sessions, p2p, timestamp2) {
+      const list = Array.isArray(sessions) ? sessions : [];
+      return {
+        sessions: list.map((raw) => {
+          const session = raw || {};
+          return {
+            id: session.id,
+            parentId: session.parentId ?? null,
+            providerType: session.providerType,
+            providerName: session.providerName || session.providerType,
+            kind: session.kind,
+            transport: session.transport,
+            status: session.status,
+            workspace: session.workspace ?? null,
+            cdpConnected: session.cdpConnected,
+            // Forward surfaceHidden/muted so the server can gate push notifications
+            // for coordinator-hidden and user-muted sessions (the WS path is the
+            // only one the server sees). Both are plain booleans, not content.
+            surfaceHidden: session.surfaceHidden,
+            muted: session.muted
+          };
+        }),
+        p2p,
+        timestamp: timestamp2
+      };
+    }
     var DaemonStatusReporter = class {
       deps;
       log;
@@ -109388,28 +110119,7 @@ ${e?.stderr || ""}`;
         }
         if (opts?.p2pOnly) return;
         if (!serverConnected || !serverConn) return;
-        const payloadSessions = Array.isArray(payload.sessions) ? payload.sessions : [];
-        const wsPayload = {
-          sessions: payloadSessions.map((session) => ({
-            id: session.id,
-            parentId: session.parentId,
-            providerType: session.providerType,
-            providerName: session.providerName || session.providerType,
-            kind: session.kind,
-            transport: session.transport,
-            status: session.status,
-            workspace: session.workspace ?? null,
-            title: session.title,
-            cdpConnected: session.cdpConnected,
-            summaryMetadata: session.summaryMetadata,
-            settings: session.settings,
-            // Forward surfaceHidden so the server can gate push notifications for
-            // coordinator-hidden sessions (the WS path is the only one the server sees).
-            surfaceHidden: session.surfaceHidden
-          })),
-          p2p: payload.p2p,
-          timestamp: now
-        };
+        const wsPayload = buildCloudStatusReportPayload(payload.sessions, payload.p2p, now);
         const wsHash = this.simpleHash(JSON.stringify({
           ...wsPayload,
           timestamp: void 0