@adhdev/daemon-standalone 1.0.28 → 1.0.29-rc.2

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "65cb2fc5efccc67d1480cbb5472cfab944160211" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "65cb2fc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-31T07:59:06.980Z" : void 0);
+      const commit = readInjected(true ? "970517bde86bb64ddf4944f4676a0b7aa3e0ecd6" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "970517bd" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.29-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-01T12:48:29.542Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -36235,6 +36235,7 @@ ${error48.message || ""}`;
       normalizeRepoIdentity: () => normalizeRepoIdentity,
       removeMagiKindPanel: () => removeMagiKindPanel,
       removeNode: () => removeNode,
+      resolveScopedMeshId: () => resolveScopedMeshId,
       setDifficultyBrains: () => setDifficultyBrains,
       setMagiKindPanel: () => setMagiKindPanel,
       tokenIdForManualPairing: () => tokenIdForManualPairing,
@@ -36265,15 +36266,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 +36323,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 }));
@@ -36640,6 +36662,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 +36719,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 +36737,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 +36754,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 +36806,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 +36882,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;
       }
@@ -40828,7 +40902,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;
@@ -54047,6 +54121,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;
@@ -54395,7 +54540,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, {
@@ -54696,6 +54841,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 +55036,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 +55046,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 +55056,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 +55085,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 +55229,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 +55266,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 +55408,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 +55497,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;
@@ -55441,7 +55620,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 +56064,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 +56097,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();
@@ -71152,6 +71338,7 @@ ${lastSnapshot}`;
       buildChatMessageSignature: () => buildChatMessageSignature,
       buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
       buildClaudeInteractiveToolResult: () => buildClaudeInteractiveToolResult,
+      buildCloudStatusReportPayload: () => buildCloudStatusReportPayload,
       buildCompactStaleDirectWorkSummary: () => buildCompactStaleDirectWorkSummary,
       buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
       buildIdleReminderMessage: () => buildIdleReminderMessage,
@@ -71451,6 +71638,7 @@ ${lastSnapshot}`;
       resolveNotBefore: () => resolveNotBefore,
       resolveProviderChannel: () => resolveProviderChannel,
       resolveProviderMaxParallel: () => resolveProviderMaxParallel,
+      resolveScopedMeshId: () => resolveScopedMeshId,
       resolveSessionHostAppName: () => resolveSessionHostAppName,
       resolveSessionHostAppNameResolution: () => resolveSessionHostAppNameResolution2,
       resolveSessionTurnPresentation: () => resolveSessionTurnPresentation,
@@ -73026,7 +73214,7 @@ ${lastSnapshot}`;
       const bootstrapLoaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
       let magiKindPanels = {};
       try {
-        magiKindPanels = listMagiKindPanelsReadOnly();
+        magiKindPanels = listMagiKindPanelsReadOnly(typeof mesh?.id === "string" ? mesh.id : void 0);
       } catch {
         magiKindPanels = {};
       }
@@ -87981,6 +88169,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 +88223,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;
           }
         }
@@ -101184,19 +101414,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 +101452,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 +101465,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 };
         }
@@ -102889,10 +103161,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 +103266,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}`);
@@ -103191,7 +103463,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}`);
@@ -109175,6 +109447,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 +109686,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