@adhdev/daemon-standalone 1.0.41-rc.4 → 1.0.41-rc.6

package/dist/index.js

@@ -35953,6 +35953,23 @@ var require_dist3 = __commonJS({
       }
       return total;
     }
+    function resolveSlotMaxParallel(slots, providerType, model, modelMatchesSlot) {
+      const wanted = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
+      if (!wanted) return void 0;
+      if (!Array.isArray(slots)) return void 0;
+      const wantedModel = typeof model === "string" && model.trim() ? model.trim() : void 0;
+      let total;
+      for (const slot of slots) {
+        if (!slot || typeof slot !== "object") continue;
+        const type2 = typeof slot.provider === "string" ? slot.provider.trim().toLowerCase() : "";
+        if (!type2 || type2 !== wanted) continue;
+        if (!modelMatchesSlot(wantedModel, slot)) continue;
+        const raw = Number(slot.maxParallel);
+        if (!Number.isFinite(raw) || raw < 0) continue;
+        total = (total ?? 0) + Math.floor(raw);
+      }
+      return total;
+    }
     var MESH_SCHEDULING_STRATEGIES;
     var DEFAULT_MESH_SCHEDULING_STRATEGY;
     var MESH_CONVERGE_REFINE_TAG;
@@ -36539,10 +36556,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "da2ff48eebaf23f8f0ebc61f9e17fd9fd317d0d0" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "da2ff48e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.41-rc.4" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-09T07:23:13.303Z" : void 0);
+      const commit = readInjected(true ? "1fe844996962df9a0388208dec2db3160c2b9635" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "1fe84499" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.41-rc.6" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-09T11:53:30.826Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -42104,11 +42121,7 @@ ${error48.message || ""}`;
         DAEMON_ID_PREFIXES = ["daemon_", "standalone_"];
         MAGI_RAW_ANSWER_CAP = 4e3;
         MESH_TASK_DIFFICULTIES = ["easy", "medium", "difficult", "freeform"];
-        DEFAULT_DIFFICULTY_BRAINS = {
-          easy: { model: "haiku", thinkingLevel: "low" },
-          medium: { model: "sonnet", thinkingLevel: "medium" },
-          difficult: { model: "opus", thinkingLevel: "high" }
-        };
+        DEFAULT_DIFFICULTY_BRAINS = {};
         CLI_SLOT_RECIPES = Object.freeze({
           "claude-cli": [
             {
@@ -47229,6 +47242,7 @@ Next step: ${nextStep}`;
         delete entry.assignedNodeId;
         delete entry.assignedSessionId;
         delete entry.assignedProviderType;
+        delete entry.assignedModel;
         delete entry.dispatchTimestamp;
         entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
         delete entry.attemptId;
@@ -47328,6 +47342,7 @@ Next step: ${nextStep}`;
         delete entry.assignedNodeId;
         delete entry.assignedSessionId;
         delete entry.assignedProviderType;
+        delete entry.assignedModel;
         delete entry.dispatchTimestamp;
         entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
         entry.strandedReclaimCount = reclaims;
@@ -47596,6 +47611,77 @@ Next step: ${nextStep}`;
         REDRIVE_SUPERSEDE_WINDOW_MS = 5 * 6e4;
       }
     });
+    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 loadDatabaseCtor() {
       if (DatabaseCtor) return DatabaseCtor;
       DatabaseCtor = loadBetterSqlite3();
@@ -47729,6 +47815,7 @@ Next step: ${nextStep}`;
         init_mesh_ledger();
         init_mesh_retention_config();
         init_mesh_work_queue();
+        init_slot_model_enforcement();
         init_dist();
         loggedMigrationFailure = false;
         loggedStrayCleanup = false;
@@ -48526,6 +48613,43 @@ Next step: ${nextStep}`;
            * rows (no provider stamp) and other providers on the same node do not consume
            * this provider's budget, so the cap is fully backward compatible.
            */
+          /**
+           * Active assignments charged to ONE SLOT — the (provider, model) pair whose
+           * `maxParallel` is being enforced — on this node.
+           *
+           * A row with NO `assignedModel` (claimed by an older daemon, or via an idle/event
+           * drain that cannot know the launched model) counts against EVERY slot of its
+           * provider. That is deliberately conservative: skipping such a row would let a
+           * pre-upgrade opus task go uncounted and admit a second one past a cap of 1, which
+           * is the over-subscription this cap exists to prevent. The cost is that a mixed
+           * fleet can refuse slightly early, which is the safe direction.
+           *
+           * Model comparison goes through modelNamesEquivalent so `opus`,
+           * `claude-opus-4-6` and `Claude Opus 4.6 (Thinking)` are one slot rather than
+           * three separate budgets (the canon-identity defect class).
+           */
+          activeSlotAssignmentCount(meshId, nodeId, providerType, assignedModel) {
+            const rows = this.db.prepare(`
+            SELECT payload FROM mesh_queue
+            WHERE mesh_id = ? AND status = 'assigned' AND assigned_node_id = ?
+        `).all(meshId, nodeId);
+            let count = 0;
+            for (const row of rows) {
+              try {
+                const entry = JSON.parse(row.payload);
+                if (entry.assignedProviderType !== providerType) continue;
+                const rowModel = typeof entry.assignedModel === "string" ? entry.assignedModel.trim() : "";
+                if (!rowModel) {
+                  count += 1;
+                  continue;
+                }
+                if (!assignedModel) continue;
+                if (modelNamesEquivalent(rowModel, assignedModel)) count += 1;
+              } catch {
+              }
+            }
+            return count;
+          }
           activeProviderAssignmentCount(meshId, nodeId, providerType) {
             const rows = this.db.prepare(`
             SELECT payload FROM mesh_queue
@@ -48552,6 +48676,11 @@ Next step: ${nextStep}`;
               if (providerType && typeof providerMaxParallel === "number" && Number.isFinite(providerMaxParallel) && providerMaxParallel >= 0 && this.activeProviderAssignmentCount(meshId, nodeId, providerType) >= providerMaxParallel) {
                 return null;
               }
+              const assignedModel = typeof opts?.assignedModel === "string" ? opts.assignedModel.trim() : "";
+              const slotMaxParallel = opts?.slotMaxParallel;
+              if (providerType && typeof slotMaxParallel === "number" && Number.isFinite(slotMaxParallel) && slotMaxParallel >= 0 && this.activeSlotAssignmentCount(meshId, nodeId, providerType, assignedModel) >= slotMaxParallel) {
+                return null;
+              }
               const nodeIdForms = expandDaemonIdForms(nodeId);
               const nodePinnedPlaceholders = nodeIdForms.map(() => "?").join(", ");
               const parseTier = (query, ...params) => {
@@ -48607,6 +48736,7 @@ Next step: ${nextStep}`;
               entry.assignedNodeId = nodeId;
               entry.assignedSessionId = sessionId;
               if (providerType) entry.assignedProviderType = providerType;
+              if (assignedModel) entry.assignedModel = assignedModel;
               if (opts?.assignedTranscriptProfile) entry.assignedTranscriptProfile = opts.assignedTranscriptProfile;
               entry.dispatchTimestamp = now;
               entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
@@ -51693,24 +51823,27 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
       } catch {
         brains = {};
       }
+      const brainMap = brains ?? {};
       const lines = [
-        "## Brain presets",
+        "## Task difficulty",
         "",
-        "When you pass `difficulty` on `mesh_enqueue_task`, it resolves to this model / thinking level (an explicit model/thinkingLevel on the task overrides it). Pick easy for trivial work to save tokens, difficult for hard reasoning.",
-        ""
+        "Pass `difficulty` on `mesh_enqueue_task` (`easy` / `medium` / `difficult` / `freeform`) to describe how hard the work is. It is a ROUTING HINT: it is matched against each node's capability slots, so a task goes to a slot configured for that difficulty.",
+        "",
+        '**The slot decides the model and thinking level \u2014 not the difficulty.** `difficulty: "difficult"` does not mean "use opus"; it means "route to a slot that handles difficult work", and that slot\'s own model/thinking is what launches. So classify honestly by how hard the task is, and change what a difficulty RUNS ON by editing the node\'s slots (`mesh_node_slots_set`), never by picking a different difficulty. Passing an explicit `model`/`thinkingLevel` still overrides everything for one task.'
       ];
-      for (const key2 of MESH_TASK_DIFFICULTIES) {
-        const slot = brains[key2];
-        if (!slot || !slot.provider && !slot.model && !slot.thinkingLevel) {
-          lines.push(`- **${key2}**: (no preset \u2014 ordinary routing)`);
-          continue;
+      const configured = MESH_TASK_DIFFICULTIES.map((key2) => [key2, brainMap[key2]]).filter(([, slot]) => !!slot && (!!slot.provider || !!slot.model || !!slot.thinkingLevel));
+      if (configured.length) {
+        lines.push("");
+        lines.push("This mesh additionally has EXPLICIT difficulty presets configured, which stamp a model/thinking at enqueue time (a difficulty-matched slot still overrides a preset value):");
+        lines.push("");
+        for (const [key2, slot] of configured) {
+          const parts = [
+            slot.provider ? `provider: \`${slot.provider}\`` : "",
+            slot.model ? `model: \`${slot.model}\`` : "",
+            slot.thinkingLevel ? `thinking: \`${slot.thinkingLevel}\`` : ""
+          ].filter(Boolean).join(" | ");
+          lines.push(`- **${key2}**: ${parts}`);
         }
-        const parts = [
-          slot.provider ? `provider: \`${slot.provider}\`` : "",
-          slot.model ? `model: \`${slot.model}\`` : "",
-          slot.thinkingLevel ? `thinking: \`${slot.thinkingLevel}\`` : ""
-        ].filter(Boolean).join(" | ");
-        lines.push(`- **${key2}**: ${parts}`);
       }
       return lines.join("\n");
     }
@@ -51776,9 +51909,11 @@ ${rules.join("\n")}`;
 - **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh \u2014 they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no \`mesh_task_history\` record. ALL code reading, analysis, RCA, and implementation must be delegated to mesh nodes via \`mesh_enqueue_task\` / \`mesh_send_task\` (use \`task_mode: "live_debug_readonly"\` for read-only investigation), or cross-verified via \`mesh_magi_review\` for read-only fan-out. The coordinator's own actions are limited to \`mesh_*\` tool orchestration and synthesizing results.
 - **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, (d) the user explicitly asks for a different provider/session, or (e) **the delta is a genuinely NEW subject rather than a continuation** \u2014 a new topic appended to an existing session can be dropped or re-run as the previous task, so give it its own task even when a session sits idle. Continuation of the same issue in an already-idle session is allowed and preferred \u2014 this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups. The test is subject continuity, not timing: carrying an investigation forward into its own fix is the SAME subject and belongs in that session (Workflow 3f), while an unrelated bug is a new subject even if the same session just went idle.
+- **Nodes are separate machines with separate checkouts \u2014 not interchangeable execution slots.** Each node is a different physical computer with its own clone of the repo. Work done on another node must be committed, pushed, and pulled back before this machine sees it, and since RELEASE/DEPLOY runs on the coordinator's own machine, sending a code change elsewhere buys a round trip out and another one back. So **default to this coordinator's own machine for code changes** \u2014 its local node (base or a worktree cloned from it). Routing to a DIFFERENT machine is the exception and needs a reason, of which there are exactly two: (a) **platform-specific verification** that cannot be done here \u2014 win32 PATH/registry, a clean install/uninstall on that OS, that machine's package-manager state; or (b) **parallelizing read-only investigation** across machines. "That node is idle" is not a reason. If you catch yourself dispatching a fix to another machine without (a) or (b), route it here instead.
+- **Don't split investigation from the fix.** When a task will plainly end in a code change, dispatch it as \`code_change\` from the start rather than a read-only investigation you hand off afterwards. The session that did the investigating already holds the findings; making a second session redo that context \u2014 especially on a different machine, where the findings have to be rewritten into a new task message \u2014 is pure loss. Carrying an investigation forward into its own fix is the SAME subject and belongs in that session (see the idle-session reuse rule). Split only when the fix genuinely belongs on another machine for reason (a) above.
 - **Base nodes are reserved for environment-specific testing.** Do NOT use a base node for a general code change. If a task does not strictly test OS- or machine-specific physical behavior (win32 PATH/registry, clean install/uninstall on one OS, that machine's package-manager state, OS-dependent runtime behavior), you MUST clone a worktree with \`mesh_clone_node\` and assign the task there; pin genuine environment tasks to the base with \`required_tags\`/\`target_node_id\` instead. Having several nodes available is NOT branch isolation \u2014 every base node is one shared checkout of the same branch \u2014 and cloning is ~10s with auto-launch starting the session, so there is no dispatch-cost reason to skip it.
 - **Worktree affinity.** A worktree is a durable per-branch workspace; keep all of a branch's code_change/fix/review work on its worktree node. Target it with \`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`. Get the id/branch from the \`mesh_clone_node\` result or a live \`mesh_status\` \u2014 the Configured Nodes snapshot won't list a worktree cloned after launch. Untargeted same-branch follow-ups drift to the base node. Only \`convergence\` (merge/push) runs on the base, never pinned to the worktree.
-- **Classify task difficulty to save tokens.** For each task you enqueue, judge its execution difficulty and pass \`difficulty\`: \`easy\` (extraction, renames, doc tweaks, trivial fixes), \`medium\` (ordinary feature/bugfix work), \`difficult\` (architecture, tricky debugging, multi-file refactors, subtle reasoning), or \`freeform\`. The mesh's per-difficulty brain preset then runs easy tasks on a cheaper model at low reasoning effort and hard tasks on a stronger model at high effort \u2014 real token savings on simple work. The current presets are shown in the "Brain presets" section below. You may still pass an explicit \`model\`/\`thinkingLevel\` to override the preset for one task.
+- **Classify task difficulty honestly.** For each task you enqueue, judge its execution difficulty and pass \`difficulty\`: \`easy\` (extraction, renames, doc tweaks, trivial fixes), \`medium\` (ordinary feature/bugfix work), \`difficult\` (architecture, tricky debugging, multi-file refactors, subtle reasoning), or \`freeform\`. This is a ROUTING HINT matched against node capability slots \u2014 the matched slot's OWN model/thinking is what launches, so difficulty does not name a model. Do NOT inflate or deflate difficulty to reach a model you want: fix the node's slots instead (\`mesh_node_slots_set\`). See the "Task difficulty" section below. You may still pass an explicit \`model\`/\`thinkingLevel\` to override for one task.
 - **Retune node profiles when routing is a poor fit \u2014 but only with approval.** A node's capability slots (its provider/model/thinking + difficulty range + capability tags, seen via \`mesh_node_slots_list\`) are what task\u2192node fitness routing matches against. If you notice a persistent mismatch \u2014 e.g. every \`difficult\` task lands on a node whose only slot is a cheap model, or a capability a node clearly has isn't declared \u2014 you MAY propose a slot change with \`mesh_node_slots_set\` (write=false). That returns current-vs-proposed; present that diff to the user with a one-line reason and apply (write=true) ONLY after they approve. It is a WHOLESALE replacement of the node's slots, so include the slots you want to keep. Never rewrite a node's profile silently or without a clear routing reason.
 - **Bootstrap a node's slots from what's actually installed.** When a node has NO slots configured (routing then falls back to "first available provider"), or CLI agents were newly installed on it, call \`mesh_node_slots_propose({ node_id })\` instead of hand-writing a profile. It detects the node's installed CLI agents and drafts a slot list from them \u2014 read-only, it never writes. Present its \`proposedSlots\` with the \`droppedSlots\` / \`destructive\` fields it reports (a wholesale write would delete any existing hand-tuned slot the draft doesn't reproduce, including providers not currently on PATH), then apply with \`mesh_node_slots_set({ slots: proposedSlots, write: true })\` after approval. It flags \`unknownProvider\` / \`provisional\` slots whose placement is a conservative guess rather than an attested one \u2014 call those out rather than presenting them as settled.
 - **Respect explicit provider requests.** Map: Hermes \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`antigravity-cli\`. Never substitute the coordinator's own runtime.
@@ -59929,77 +60064,6 @@ 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;
@@ -60378,12 +60442,18 @@ 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, meshId), providerType);
+      const nodeSlotsForCap = resolveNodeCapabilitySlots(node, meshId);
+      const providerMaxParallel = resolveProviderMaxParallel(nodeSlotsForCap, providerType);
+      const assignedModel = typeof routingDecision?.resolvedModel === "string" && routingDecision.resolvedModel.trim() ? routingDecision.resolvedModel.trim() : void 0;
+      const claimingSlot = nodeSlotsForCap.find((s2) => s2.provider?.trim() === providerType && isModelAllowedBySlot(assignedModel, s2));
+      const slotMaxParallel = claimingSlot ? resolveSlotMaxParallel(nodeSlotsForCap, providerType, claimingSlot.model, isModelAllowedBySlot) : void 0;
       const nodeIsWorktree = node?.isLocalWorktree === true;
       const assignedTranscriptProfile = resolveClaimingSessionTranscriptProfile(components, sessionId);
       const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
         providerType,
         ...providerMaxParallel !== void 0 ? { providerMaxParallel } : {},
+        ...assignedModel ? { assignedModel } : {},
+        ...slotMaxParallel !== void 0 ? { slotMaxParallel } : {},
         nodeIsWorktree,
         ...assignedTranscriptProfile ? { assignedTranscriptProfile } : {}
       });
@@ -60878,6 +60948,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       score += quotaBonus;
       return score;
     }
+    function orderSlotsForProviderSelection(slots, meshId, nodeId, node, task, quotaBonusByProvider) {
+      return [...slots].sort((a, b) => {
+        const capDelta = Number(slotHasCapacity(meshId, nodeId, node, b)) - Number(slotHasCapacity(meshId, nodeId, node, a));
+        if (capDelta !== 0) return capDelta;
+        return scoreSlotForTask(b, task, quotaBonusByProvider?.[b.provider] ?? 0) - scoreSlotForTask(a, task, quotaBonusByProvider?.[a.provider] ?? 0);
+      });
+    }
     function bestSlotForTask(node, task, meshId, quotaBonusByProvider) {
       const slots = resolveNodeCapabilitySlots(node, meshId);
       if (!slots.length) return null;
@@ -60948,12 +61025,31 @@ 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) {
+    function activeSlotAssignedCount(meshId, nodeId, providerType, slot) {
+      return getQueue(meshId, { status: ["assigned"] }).filter((task) => {
+        if (!daemonIdsEquivalent(task.assignedNodeId, nodeId)) return false;
+        if (task.assignedProviderType !== providerType) return false;
+        const assignedModel = task.assignedModel;
+        if (typeof assignedModel !== "string" || !assignedModel.trim()) return true;
+        return isModelAllowedBySlot(assignedModel, slot);
+      }).length;
+    }
+    function slotCapacityRemaining(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;
+      if (!providerType) return { available: false };
+      const slots = resolveNodeCapabilitySlots(node, meshId);
+      const slotCap = resolveSlotMaxParallel(slots, providerType, slot.model, isModelAllowedBySlot);
+      if (slotCap !== void 0 && activeSlotAssignedCount(meshId, nodeId, providerType, slot) >= slotCap) {
+        return { available: false, slotCap };
+      }
+      const providerCap = resolveProviderMaxParallel(slots, providerType);
+      if (providerCap !== void 0 && activeProviderAssignedCount(meshId, nodeId, providerType) >= providerCap) {
+        return { available: false, slotCap, providerCap };
+      }
+      return { available: true, slotCap, providerCap };
+    }
+    function slotHasCapacity(meshId, nodeId, node, slot) {
+      return slotCapacityRemaining(meshId, nodeId, node, slot).available;
     }
     function sessionHasActiveAssignment(meshId, sessionId) {
       if (getQueue(meshId, { status: ["assigned"] }).some((task) => sessionIdsEquivalent(task.assignedSessionId, sessionId))) {
@@ -61098,7 +61194,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const slots = resolveNodeCapabilitySlots(node, meshId);
       if (!slots.length) return { reason: "missing_provider_priority" };
       const quotaBonusByProvider = task ? quotaSpreadBonusByProvider(node, quotaRouting) : void 0;
-      const orderedSlots = task ? [...slots].sort((a, b) => scoreSlotForTask(b, task, quotaBonusByProvider?.[b.provider] ?? 0) - scoreSlotForTask(a, task, quotaBonusByProvider?.[a.provider] ?? 0)) : slots;
+      const orderedSlots = task ? orderSlotsForProviderSelection(slots, meshId ?? "", nodeId, node, task, quotaBonusByProvider) : slots;
       const failed = [];
       for (const slot of orderedSlots) {
         const requestedType = slot.provider;
@@ -79236,6 +79332,7 @@ ${lastSnapshot}`;
     var import_promises4 = require("fs/promises");
     var import_node_path2 = require("path");
     var import_node_util4 = require("util");
+    init_repo_mesh_types();
     init_mesh_config();
     var import_fs12 = require("fs");
     var import_path11 = require("path");
@@ -79730,6 +79827,7 @@ ${lastSnapshot}`;
         );
       }
       if (operation === "clone_worktree") {
+        const planWarnings = [];
         if (!compatibleMesh) {
           return failure2(
             "mesh_not_found",
@@ -79738,14 +79836,20 @@ ${lastSnapshot}`;
             { discovery, membership }
           );
         }
-        if (discovery.dirty) {
+        const dirtyBehavior = mergeAndNormalizePolicy(compatibleMesh.policy, void 0).dirtyWorkspaceBehavior;
+        if (discovery.dirty && dirtyBehavior === "block") {
           return failure2(
             "dirty_workspace",
             `Workspace has ${discovery.changedFileCount} uncommitted change(s); a cloned worktree would not include them.`,
-            "Commit or stash the changes, then re-run the clone plan.",
+            "Commit or stash the changes, then re-run the clone plan. (This mesh's dirtyWorkspaceBehavior is 'block'; set it to 'warn' to allow cloning from a dirty workspace.)",
             { discovery, membership }
           );
         }
+        if (discovery.dirty) {
+          planWarnings.push(
+            `Source workspace has ${discovery.changedFileCount} uncommitted change(s). The new worktree is created from HEAD, so uncommitted changes are NOT included in it \u2014 commit them first if the cloned branch needs them.`
+          );
+        }
         const branch = (options.branch || "").trim();
         if (!branch || !await git(discovery.repoRoot, ["check-ref-format", "--branch", branch], true)) {
           return failure2(
@@ -79773,8 +79877,11 @@ ${lastSnapshot}`;
           compatibleMesh: meshSummary(compatibleMesh),
           plan: {
             kind: "clone_new_worktree",
-            summary: `Create a clean isolated worktree node from '${sourceNode.id}' on branch '${branch}'.`,
-            requiresClean: true,
+            summary: `Create an isolated worktree node from '${sourceNode.id}' on branch '${branch}'.`,
+            // Only a 'block' mesh actually requires a clean source; under the
+            // default 'warn' a dirty workspace is advisory, so reporting true here
+            // would misdescribe the plan the caller is approving.
+            requiresClean: dirtyBehavior === "block",
             approvalRequired: true,
             steps: [{
               command: "clone_mesh_node",
@@ -79791,7 +79898,8 @@ ${lastSnapshot}`;
             alternatives: [{ kind: "add_existing_workspace", summary: "Register the supplied checkout without creating a worktree.", requiresClean: false }]
           },
           suggestedConfig: suggestedConfig2,
-          note: "Read-only plan only. No mesh, config, branch, remote or worktree state was changed."
+          note: "Read-only plan only. No mesh, config, branch, remote or worktree state was changed.",
+          ...planWarnings.length ? { warnings: planWarnings } : {}
         };
       }
       const suggestedConfig = runMeshInit(compatibleMesh || {}, discovery.repoRoot, options.detectedProviders || []);