@adhdev/mesh-shared 1.0.30-rc.1 → 1.0.30-rc.2

package/dist/index.d.ts

@@ -20,6 +20,7 @@ export * from './daemon-normalize';
 export * from './git-summarize';
 export * from './magi';
 export * from './brain-routing';
+export * from './slot-proposal';
 export * from './interpolation';
 export * from './mesh-tool-names';
 export * from './mesh-status-probe';

package/dist/index.js

@@ -22,11 +22,15 @@ var index_exports = {};
 __export(index_exports, {
   CANONICAL_MESH_TOOL_COUNT: () => CANONICAL_MESH_TOOL_COUNT,
   CANONICAL_MESH_TOOL_NAMES: () => CANONICAL_MESH_TOOL_NAMES,
+  CLI_SLOT_RECIPES: () => CLI_SLOT_RECIPES,
   DEFAULT_DIFFICULTY_BRAINS: () => DEFAULT_DIFFICULTY_BRAINS,
   MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
   MESH_TASK_DIFFICULTIES: () => MESH_TASK_DIFFICULTIES,
   STATUS_PROBE_ARG_KEY: () => STATUS_PROBE_ARG_KEY,
+  UNKNOWN_CLI_SLOT_RECIPE: () => UNKNOWN_CLI_SLOT_RECIPE,
   argsCarryStatusProbeMarker: () => argsCarryStatusProbeMarker,
+  buildMagiPanelProposal: () => buildMagiPanelProposal,
+  buildSlotProposal: () => buildSlotProposal,
   canonicalDaemonId: () => canonicalDaemonId,
   daemonIdsEquivalent: () => daemonIdsEquivalent,
   deriveSlotsFromLegacy: () => deriveSlotsFromLegacy,
@@ -511,6 +515,162 @@ function deriveSlotsFromLegacy(input) {
   });
 }
 
+// src/slot-proposal.ts
+var CLI_SLOT_RECIPES = Object.freeze({
+  "claude-cli": [
+    {
+      model: "sonnet",
+      thinkingLevel: "high",
+      difficulty: ["medium", "easy"],
+      maxParallel: 5,
+      rationale: "Primary workhorse \u2014 widest parallelism for routine work."
+    },
+    {
+      model: "opus",
+      thinkingLevel: "high",
+      difficulty: ["difficult"],
+      maxParallel: 1,
+      rationale: "Reserved for hard tasks; capped at 1 to bound cost."
+    }
+  ],
+  "kimi": [
+    {
+      model: "kimi-code/k3",
+      difficulty: ["medium", "difficult"],
+      maxParallel: 2,
+      rationale: "Independent second opinion on mid/hard work."
+    }
+  ],
+  "codex-cli": [
+    {
+      difficulty: ["medium", "difficult", "freeform"],
+      maxParallel: 2,
+      rationale: "Broad range including freeform; no model pin."
+    }
+  ],
+  "antigravity-cli": [
+    {
+      model: "Gemini 3.1 Pro (High)",
+      difficulty: ["easy"],
+      maxParallel: 2,
+      rationale: "Cheap capacity for easy tasks."
+    }
+  ],
+  "cursor-cli": [
+    {
+      model: "auto",
+      difficulty: ["easy"],
+      maxParallel: 1,
+      rationale: "Easy tasks only; auto model selection."
+    }
+  ],
+  "hermes-cli": [
+    {
+      difficulty: ["medium"],
+      maxParallel: 2,
+      provisional: true,
+      // NOTE: ESTIMATE, NOT OBSERVED. hermes-cli is absent from the live
+      // slot configuration this table was seeded from, so `medium` is a
+      // conservative placement rather than a transcription. Revisit once
+      // it has real usage data.
+      rationale: "ESTIMATE \u2014 no live slot to transcribe; conservative mid placement. Adjust after real use."
+    }
+  ]
+});
+var UNKNOWN_CLI_SLOT_RECIPE = Object.freeze({
+  difficulty: ["medium"],
+  maxParallel: 1,
+  provisional: true,
+  rationale: "Unrecognized provider \u2014 conservative default (medium, maxParallel 1). Review before relying on it."
+});
+function slotKey(slot) {
+  return [
+    slot.provider,
+    slot.model ?? "",
+    slot.thinkingLevel ?? "",
+    [...slot.difficulty ?? []].sort().join("|"),
+    [...slot.capability ?? []].sort().join("|"),
+    slot.maxParallel ?? ""
+  ].join("\0");
+}
+function dedupeDetected(detected) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const d of detected) {
+    const type = typeof d?.type === "string" ? d.type.trim() : "";
+    if (!type || seen.has(type)) continue;
+    seen.add(type);
+    out.push({ ...d, type });
+  }
+  return out;
+}
+function buildSlotProposal(detected, currentSlots = []) {
+  const providers = dedupeDetected(detected ?? []);
+  const proposedSlots = [];
+  const entries = [];
+  const unknownProviders = [];
+  const provisionalProviders = [];
+  for (const provider of providers) {
+    const known = CLI_SLOT_RECIPES[provider.type];
+    const recipes = known ?? [UNKNOWN_CLI_SLOT_RECIPE];
+    const isUnknown = !known;
+    if (isUnknown) unknownProviders.push(provider.type);
+    let providerProvisional = false;
+    for (const recipe of recipes) {
+      const slot = normalizeNodeCapabilitySlot({
+        provider: provider.type,
+        model: recipe.model,
+        thinkingLevel: recipe.thinkingLevel,
+        difficulty: recipe.difficulty,
+        maxParallel: recipe.maxParallel
+      });
+      if (!slot) continue;
+      const provisional = recipe.provisional === true;
+      if (provisional) providerProvisional = true;
+      proposedSlots.push(slot);
+      entries.push({
+        slot,
+        unknownProvider: isUnknown,
+        provisional,
+        ...recipe.rationale ? { rationale: recipe.rationale } : {}
+      });
+    }
+    if (providerProvisional) provisionalProviders.push(provider.type);
+  }
+  const proposedKeys = new Set(proposedSlots.map(slotKey));
+  const droppedSlots = currentSlots.filter((slot) => !proposedKeys.has(slotKey(slot)));
+  const proposedProviders = new Set(proposedSlots.map((s) => s.provider));
+  const droppedProviders = [...new Set(
+    droppedSlots.map((s) => s.provider).filter((p) => !proposedProviders.has(p))
+  )];
+  return {
+    proposedSlots,
+    entries,
+    unknownProviders,
+    provisionalProviders,
+    droppedSlots,
+    droppedProviders,
+    destructive: droppedSlots.length > 0
+  };
+}
+function buildMagiPanelProposal(detected, opts = {}) {
+  const providers = dedupeDetected(detected ?? []);
+  const tableOrder = Object.keys(CLI_SLOT_RECIPES);
+  const rank = (type) => {
+    const i = tableOrder.indexOf(type);
+    return i === -1 ? Number.MAX_SAFE_INTEGER : i;
+  };
+  const ordered = [...providers].sort((a, b) => rank(a.type) - rank(b.type));
+  const limit = Number.isFinite(opts.maxSlots) && opts.maxSlots > 0 ? Math.floor(opts.maxSlots) : ordered.length;
+  return ordered.slice(0, limit).map((p) => ({
+    ...opts.nodeId ? { nodeId: opts.nodeId } : {},
+    provider: p.type
+    // A model is intentionally NOT pinned: the panel's job is cross-provider
+    // independence, and pinning models here would silently couple the panel
+    // to this table's cost assumptions rather than to review quality.
+  }));
+}
+
 // src/interpolation.ts
 function interpolateArgs(args, context) {
   const result = {};
@@ -578,7 +738,8 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_magi_kind_panel_set",
   "mesh_magi_kind_panel_list",
   "mesh_node_slots_set",
-  "mesh_node_slots_list"
+  "mesh_node_slots_list",
+  "mesh_node_slots_propose"
 ];
 var CANONICAL_MESH_TOOL_COUNT = CANONICAL_MESH_TOOL_NAMES.length;
 
@@ -599,11 +760,15 @@ function stripStatusProbeMarker(args) {
 0 && (module.exports = {
   CANONICAL_MESH_TOOL_COUNT,
   CANONICAL_MESH_TOOL_NAMES,
+  CLI_SLOT_RECIPES,
   DEFAULT_DIFFICULTY_BRAINS,
   MAGI_RAW_ANSWER_CAP,
   MESH_TASK_DIFFICULTIES,
   STATUS_PROBE_ARG_KEY,
+  UNKNOWN_CLI_SLOT_RECIPE,
   argsCarryStatusProbeMarker,
+  buildMagiPanelProposal,
+  buildSlotProposal,
   canonicalDaemonId,
   daemonIdsEquivalent,
   deriveSlotsFromLegacy,