@jmanuelcorral/openteam 0.17.0 → 0.17.2

package/.opencode/openteam.example.json

@@ -36,13 +36,18 @@
       {
         "id": "lemonade",
         "enabled": false,
-        "baseURL": "http://localhost:8000/api/v1",
+        "baseURL": "http://localhost:13305/api/v1",
         "defaultModel": {
           "providerID": "lemonade",
           "modelID": "Qwen3-Coder-30B-A3B-Instruct-GGUF"
         },
         "thinkingModel": "Qwen3-30B-A3B-Thinking-GGUF",
-        "coderModel": "Qwen3-Coder-30B-A3B-Instruct-GGUF"
+        "coderModel": "Qwen3-Coder-30B-A3B-Instruct-GGUF",
+        "maxConcurrency": 3,
+        "modelConcurrency": {
+          "Qwen3-Coder-30B-A3B-Instruct-GGUF": 3,
+          "Qwen3-30B-A3B-Thinking-GGUF": 1
+        }
       },
       {
         "id": "foundry-local",

package/README.es.md

@@ -52,7 +52,7 @@ El router mantiene una garantía de privacidad: con `privacyMode: "forceLocalOnS
 - Runtimes locales opcionales:
   - Ollama en `http://localhost:11434/v1`.
   - LM Studio en `http://localhost:1234/v1`.
-  - Lemonade Server en `http://localhost:8000/api/v1`.
+  - Lemonade Server en `http://localhost:13305/api/v1`.
   - Foundry Local con puerto dinámico descubierto por CLI en Windows.
 
 ## Instalación
@@ -373,6 +373,7 @@ ejecutas desde un subdirectorio verás "provider not configured" y debes hacer
 | `local.runtimes[].discovery` | `"cli" \| "sdk" \| "manual"` opcional | sin default por item | Discovery de Foundry Local; el registry usa CLI si está configurado y no es `manual`. |
 | `local.runtimes[].defaultModel` | `ModelRef` | requerido | Modelo por defecto de ese runtime. |
 | `local.runtimes[].maxConcurrency` | entero positivo opcional | `4` | Límite de generaciones concurrentes de esta instancia (su número real de slots). Se aplica por instancia. |
+| `local.runtimes[].modelConcurrency` | `Record<modelID, entero positivo>` opcional | ninguno | Slots por modelo, porque los slots pertenecen al modelo cargado y no al servidor: un mismo host Lemonade puede servir un modelo con `--parallel 3` y otro con `--parallel 1` a la vez. Cada modelo declarado obtiene su propia cola; el resto comparte el pool de `maxConcurrency` de la instancia. `openteam setup` lo rellena solo cuando el runtime informa de sus slots. |
 | `budgets.sessionUSD` | `number` positivo opcional | sin límite | Presupuesto frontier por sesión. |
 | `budgets.monthlyUSD` | `number` positivo opcional | sin límite | Presupuesto frontier mensual. |
 | `budgets.frontierTokensPerSession` | `number` entero positivo opcional | sin límite | Límite de tokens frontier por sesión. |
@@ -729,7 +730,7 @@ Invoke-RestMethod -Uri "http://localhost:1234/v1/models" -Method Get
 ### Lemonade Server
 
 ```powershell
-Invoke-RestMethod -Uri "http://localhost:8000/api/v1/models" -Method Get
+Invoke-RestMethod -Uri "http://localhost:13305/api/v1/models" -Method Get
 ```
 
 ### Foundry Local
@@ -824,7 +825,7 @@ Consulta [docs/compatibility.md](docs/compatibility.md). Resumen verificado el `
 
 | Superficie | Versión / contrato |
 | --- | --- |
-| openteam | `0.17.0`; versión actual del paquete |
+| openteam | `0.17.2`; versión actual del paquete |
 | `@opencode-ai/plugin` | `1.18.19` |
 | `@opencode-ai/sdk` | `1.18.19` |
 | Hook de routing | `chat.message`; no `chat.params` para cambiar modelo |

package/README.md

@@ -61,7 +61,7 @@ The router keeps a privacy guarantee: with `privacyMode: "forceLocalOnSensitive"
 - Optional local runtimes:
   - Ollama at `http://localhost:11434/v1`.
   - LM Studio at `http://localhost:1234/v1`.
-  - Lemonade Server at `http://localhost:8000/api/v1`.
+  - Lemonade Server at `http://localhost:13305/api/v1`.
   - Foundry Local with a dynamic port discovered via CLI on Windows.
 
 > Local runtimes are **optional**. You can run openteam **frontier-only**, or point it at an Ollama / LM Studio / Lemonade Server running on **another machine on your LAN**.
@@ -325,6 +325,7 @@ configured" and should `cd` to the project root first.
 | `local.runtimes[].discovery` | `"cli" \| "sdk" \| "manual"` optional | none per item | Foundry Local discovery; the registry uses CLI when configured and not `manual`. |
 | `local.runtimes[].defaultModel` | `ModelRef` | required | Default model for that runtime. |
 | `local.runtimes[].maxConcurrency` | positive integer, optional | `4` | Concurrent-generation cap for this instance (its real slot count). Applied per instance. |
+| `local.runtimes[].modelConcurrency` | `Record<modelID, positive integer>`, optional | none | Per-model slot counts, because slots belong to the loaded model rather than to the server: a single Lemonade host can serve one model at `--parallel 3` and another at `--parallel 1` simultaneously. Each declared model gets its own queue; every other model shares the instance-wide `maxConcurrency` pool. Populated automatically by `openteam setup` when the runtime reports its slots. |
 | `budgets.sessionUSD` | positive number, optional | unlimited | Frontier budget per session. |
 | `budgets.monthlyUSD` | positive number, optional | unlimited | Monthly frontier budget. |
 | `budgets.frontierTokensPerSession` | positive integer, optional | unlimited | Frontier token limit per session. |
@@ -622,7 +623,7 @@ Invoke-RestMethod -Uri "http://localhost:1234/v1/models" -Method Get
 ### Lemonade Server
 
 ```powershell
-Invoke-RestMethod -Uri "http://localhost:8000/api/v1/models" -Method Get
+Invoke-RestMethod -Uri "http://localhost:13305/api/v1/models" -Method Get
 ```
 
 ### Foundry Local
@@ -713,7 +714,7 @@ See [docs/compatibility.md](docs/compatibility.md). Verified summary as of `2026
 
 | Surface | Version / contract |
 | --- | --- |
-| openteam | `0.17.0`; current package version |
+| openteam | `0.17.2`; current package version |
 | `@opencode-ai/plugin` | `1.18.19` |
 | `@opencode-ai/sdk` | `1.18.19` |
 | Routing hook | `chat.message`; not `chat.params` for model changes |

package/dist/certificates/graph-release-certificate.json

@@ -34,12 +34,12 @@
       "idempotent": true
     },
     "performance": {
-      "p95Millis": 0.4712040000000002,
+      "p95Millis": 0.462524999999971,
       "budgetMillis": 50,
       "samples": 100
     }
   },
   "verdict": "pass",
   "failedGates": [],
-  "digest": "c2bae4d5fdfb94e26393cce05e69eacb8829647b091f82d64ce7c6d1a956c891"
+  "digest": "1f51bbf60529fba584b0d050615a88ae6456b85bd19b91aca60c80b650161333"
 }

package/dist/certificates/graph-shadow-certificate.json

@@ -20,7 +20,7 @@
       "rawFindings": 0
     },
     "overhead": {
-      "p95Millis": 0.34261300000000006,
+      "p95Millis": 0.35418200000000866,
       "budgetMillis": 25,
       "samples": 1000
     },
@@ -35,5 +35,5 @@
   },
   "verdict": "pass",
   "failedGates": [],
-  "digest": "2ceb71a2556e57ea51007d88b1e94bf0081ae975eb756b1fad05641bb4515332"
+  "digest": "8c2d475944be4285bdb807ad34543e43291724d3e2f695febf20b0704b255b42"
 }

package/dist/cli/setupAdapters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupAdapters.d.ts","sourceRoot":"","sources":["../../src/cli/setupAdapters.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EACV,eAAe,EAEf,QAAQ,EAET,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,KAAK,QAAQ,EAEd,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAyBrD,qDAAqD;AACrD,eAAO,MAAM,aAAa,EAAE,QA8E3B,CAAC;AA6BF;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,OAAO,CACzD,sBAAsB,EAAE,CACzB,CAcA;AACD,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,OAAO,CAAC,eAAe,EAAE,CAAC,CAuB7E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,GACb,CAAC,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CA2BnE"}
+{"version":3,"file":"setupAdapters.d.ts","sourceRoot":"","sources":["../../src/cli/setupAdapters.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EACV,eAAe,EAEf,QAAQ,EAET,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,KAAK,QAAQ,EAEd,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAyBrD,qDAAqD;AACrD,eAAO,MAAM,aAAa,EAAE,QA8E3B,CAAC;AA6BF;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,OAAO,CACzD,sBAAsB,EAAE,CACzB,CAcA;AACD,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,OAAO,CAAC,eAAe,EAAE,CAAC,CA6B7E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,GACb,CAAC,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CA8BnE"}

package/dist/cli.js

@@ -461,6 +461,7 @@ var LocalRuntimeSchema = z2.object({
   discovery: z2.enum(["cli", "sdk", "manual"]).optional(),
   defaultModel: ModelRefSchema,
   maxConcurrency: z2.number().int().positive().optional(),
+  modelConcurrency: z2.record(z2.string().min(1), z2.number().int().positive()).optional(),
   reservedInteractiveSlots: z2.number().int().nonnegative().optional(),
   thinkingModel: z2.string().min(1).optional(),
   coderModel: z2.string().min(1).optional()
@@ -682,6 +683,16 @@ function classifyHeuristic(task) {
   };
 }
 
+// src/local/slotPool.ts
+var POOL_SEPARATOR = "::";
+function slotPoolKey(runtime, modelID) {
+  if (modelID === undefined) {
+    return runtime.id;
+  }
+  const declared = runtime.modelConcurrency?.[modelID];
+  return declared === undefined ? runtime.id : `${runtime.id}${POOL_SEPARATOR}${modelID}`;
+}
+
 // src/capabilities/budget.ts
 var WARNING_UTILIZATION = 0.8;
 function projectedSpend(current, estimatedCostUSD) {
@@ -965,9 +976,6 @@ function chooseModel(input) {
       noLocalRationale: "forced-local-unavailable"
     }));
   }
-  if (override === "alwaysFrontier") {
-    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["explicit-always-frontier"], []));
-  }
   if (input.config.router.localOnly) {
     if (local === null) {
       return finalizeDecision(input, tier, frontier, budgetAction, blockedDecision(frontier.model, ["router-local-only", "forced-local-none-configured"], "forced-local-none-configured"));
@@ -978,6 +986,9 @@ function chooseModel(input) {
       noLocalRationale: "forced-local-unavailable"
     }));
   }
+  if (override === "alwaysFrontier") {
+    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["explicit-always-frontier"], []));
+  }
   if (input.config.router.frontierOnly) {
     return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["router-frontier-only"], []));
   }
@@ -1969,8 +1980,8 @@ function roleLocalReachable(role, batch) {
 function permissionsFor(roleID) {
   return ROLE_PERMISSIONS[roleID] ?? [];
 }
-function roleRequiresFrontier(role, task) {
-  return task.explicitOverride === undefined && role.localFirst === false && role.defaultTier === "hard" && role.preferredFrontierModels.length > 0;
+function roleRequiresFrontier(role, task, config) {
+  return task.explicitOverride === undefined && config.router.localOnly !== true && role.localFirst === false && role.defaultTier === "hard" && role.preferredFrontierModels.length > 0;
 }
 function roleAdjustedTask(role, input, requirement) {
   const task = {
@@ -1980,11 +1991,19 @@ function roleAdjustedTask(role, input, requirement) {
   if (requirement.needsTools) {
     task.requiresTools = true;
   }
-  if (roleRequiresFrontier(role, task)) {
+  if (roleRequiresFrontier(role, task, input.config)) {
     task.explicitOverride = "alwaysFrontier";
   }
   return task;
 }
+function roleAdjustedTaskForRole(input) {
+  const role = roleFor(input);
+  const tier = elevateTierForPermissions(classifyHeuristic({
+    ...input.task,
+    prompt: input.task.prompt ?? input.prompt
+  }).tier, permissionsFor(role.roleID));
+  return roleAdjustedTask(role, input, roleToRequirement(role, input.task, tier));
+}
 function satisfiesRoleRequirement(requirement, profile) {
   return profile.kind === "frontier" && profile.availability !== "unavailable" && profile.contextWindow >= requirement.minContextWindow && profile.reasoningTier >= requirement.minReasoningTier && profile.codeQualityTier >= requirement.minCodeQualityTier && (!requirement.needsTools || profile.supportsToolCalling) && (!requirement.needsVision || profile.supportsVision);
 }
@@ -2002,7 +2021,7 @@ function routingInput(input, role) {
   const permissionTier = elevateTierForPermissions(classifiedTier, permissionsFor(role.roleID));
   const tier = permissionTier;
   const requirement = roleToRequirement(role, input.task, tier);
-  const task = roleAdjustedTask(role, input, requirement);
+  const task = roleAdjustedTaskForRole(input);
   const baseInput = {
     config: input.config,
     task,
@@ -2290,18 +2309,19 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch) {
   if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
     const limiter = deps.runtimeLimiter;
     const priority = priorityForRole(role);
-    release = limiter.tryAcquire(runtimeId, priority);
+    const poolKey = slotPoolKey(configuredRuntime(runtimeId, input.config) ?? { id: runtimeId }, decision2.selected.modelID);
+    release = limiter.tryAcquire(poolKey, priority);
     let waitedMs = 0;
     if (release === undefined) {
-      const acquisition = await limiter.acquire(runtimeId, priority);
+      const acquisition = await limiter.acquire(poolKey, priority);
       release = acquisition.release;
       waitedMs = acquisition.waitedMs;
     }
     queueObservation = {
       runtimeId,
       waitedMs,
-      activeCount: limiter.activeCount(runtimeId),
-      queuedCount: limiter.queuedCount(runtimeId)
+      activeCount: limiter.activeCount(poolKey),
+      queuedCount: limiter.queuedCount(poolKey)
     };
   }
   try {
@@ -3102,6 +3122,7 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
       "discovery",
       "defaultModel",
       "maxConcurrency",
+      "modelConcurrency",
       "reservedInteractiveSlots",
       "thinkingModel",
       "coderModel"
@@ -10024,24 +10045,141 @@ function ensureFoundryV1BaseURL(endpoint) {
 }
 
 // src/local/lemonade.ts
-var LEMONADE_DEFAULT_BASE_URL = "http://localhost:8000/api/v1";
+var LEMONADE_DEFAULT_BASE_URL = "http://localhost:13305/api/v1";
+var NON_TEXT_LABELS = new Set([
+  "image",
+  "tts",
+  "transcription",
+  "embedding",
+  "reranking"
+]);
+var PARALLEL_ARG = /(?:^|\s)(?:--parallel|-np)[\s=]+(\d+)(?!\d)/;
 function createLemonadeAdapter() {
+  const listModels = async (options) => {
+    const baseURL = normalizeBaseURL(options.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
+    const downloaded = await listLemonadeModels(baseURL, options.fetch);
+    const loaded = await readLoadedModels(baseURL, options.fetch);
+    return enrichWithLoadState(downloaded, loaded);
+  };
   return {
     id: "lemonade",
     defaultBaseURL: LEMONADE_DEFAULT_BASE_URL,
-    listModels(options) {
-      return listOpenAICompatibleModels(normalizeBaseURL(options.baseURL ?? LEMONADE_DEFAULT_BASE_URL), options.fetch);
-    },
-    probe(options) {
-      return probeOpenAICompatibleRuntime({
-        id: "lemonade",
-        baseURL: options.baseURL ?? LEMONADE_DEFAULT_BASE_URL,
-        fetch: options.fetch,
-        probedAt: options.probedAt
-      });
+    listModels,
+    async probe(options) {
+      const baseURL = normalizeBaseURL(options.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
+      try {
+        return {
+          id: "lemonade",
+          baseURL,
+          reachable: true,
+          models: await listModels({ ...options, baseURL }),
+          probedAt: options.probedAt
+        };
+      } catch (error) {
+        return unavailableSnapshot({
+          id: "lemonade",
+          baseURL,
+          probedAt: options.probedAt,
+          error
+        });
+      }
     }
   };
 }
+async function listLemonadeModels(baseURL, fetch2) {
+  const response = await fetch2(`${baseURL}/models`, {
+    method: "GET",
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`GET /models failed with HTTP ${response.status}`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (error) {
+    throw new Error(`Malformed JSON from /models: ${errorMessage(error)}`);
+  }
+  const nonText = readNonTextModelIDs(payload);
+  return parseOpenAIModels(payload).filter((model) => !nonText.has(model.modelID));
+}
+function readNonTextModelIDs(payload) {
+  const ids = new Set;
+  if (!isObject3(payload) || !Array.isArray(payload.data)) {
+    return ids;
+  }
+  for (const entry of payload.data) {
+    if (!isObject3(entry) || typeof entry.id !== "string") {
+      continue;
+    }
+    if (isNonTextModel(entry)) {
+      ids.add(entry.id);
+    }
+  }
+  return ids;
+}
+function isNonTextModel(entry) {
+  if (!Array.isArray(entry.labels)) {
+    return false;
+  }
+  return entry.labels.some((label) => typeof label === "string" && NON_TEXT_LABELS.has(label));
+}
+async function readLoadedModels(baseURL, fetch2) {
+  let payload;
+  try {
+    const response = await fetch2(`${baseURL}/health`, {
+      method: "GET",
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) {
+      return;
+    }
+    payload = await response.json();
+  } catch {
+    return;
+  }
+  if (!isObject3(payload) || !Array.isArray(payload.all_models_loaded)) {
+    return;
+  }
+  const loaded = new Map;
+  for (const entry of payload.all_models_loaded) {
+    if (!isObject3(entry) || typeof entry.model_name !== "string") {
+      continue;
+    }
+    if (entry.loaded === false) {
+      continue;
+    }
+    loaded.set(entry.model_name, { slots: readSlotCount(entry) });
+  }
+  return loaded;
+}
+function readSlotCount(entry) {
+  const options = entry.recipe_options;
+  if (!isObject3(options) || typeof options.llamacpp_args !== "string") {
+    return;
+  }
+  const match = PARALLEL_ARG.exec(options.llamacpp_args);
+  if (match === null) {
+    return;
+  }
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function enrichWithLoadState(models, loaded) {
+  if (loaded === undefined) {
+    return [...models];
+  }
+  return models.map((model) => {
+    const hit = loaded.get(model.modelID);
+    if (hit === undefined) {
+      return { ...model, loaded: false };
+    }
+    return hit.slots === undefined ? { ...model, loaded: true } : { ...model, loaded: true, slots: hit.slots };
+  });
+}
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/local/lmstudio.ts
 var LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
@@ -10270,6 +10408,9 @@ function createDetect(exec) {
         reachable: snapshot.reachable,
         models: snapshot.models.map((model) => model.modelID)
       };
+      if (snapshot.models.some((model) => model.loaded !== undefined)) {
+        detected.modelInfo = snapshot.models;
+      }
       if (snapshot.error !== undefined) {
         detected.error = snapshot.error;
       }
@@ -10297,6 +10438,9 @@ function createProbeRuntime(exec) {
       reachable: snapshot?.reachable ?? false,
       models: snapshot?.models.map((model) => model.modelID) ?? []
     };
+    if (snapshot?.models.some((model) => model.loaded !== undefined) === true) {
+      detected.modelInfo = snapshot.models;
+    }
     if (snapshot?.error !== undefined) {
       detected.error = snapshot.error;
     }
@@ -11049,6 +11193,14 @@ function runtimeLine(snapshot, runtime) {
   const slots = declared === undefined ? ` · ${DEFAULT_LOCAL_MAX_CONCURRENCY} slot(s) (default)` : ` · ${declared} slot(s) (declared)`;
   return `  ${mark} ${snapshot.id.padEnd(14)} ${snapshot.baseURL || "(no baseURL)"} — ${detail}${slots}`;
 }
+function runtimeModelSlotsLine(runtime) {
+  const entries = Object.entries(runtime?.modelConcurrency ?? {});
+  if (entries.length === 0) {
+    return;
+  }
+  const detail = entries.map(([modelID, slots]) => `${modelID} ${slots} slot(s)`).join(" · ");
+  return `    ↳ per-model slots: ${detail}`;
+}
 function isNetworkRuntime(baseURL) {
   if (baseURL.length === 0) {
     return false;
@@ -11304,6 +11456,10 @@ function renderDoctor(input) {
       if (classLine !== undefined) {
         lines.push(classLine);
       }
+      const modelSlots = runtimeModelSlotsLine(runtime);
+      if (modelSlots !== undefined) {
+        lines.push(modelSlots);
+      }
     }
   }
   for (const snapshot of input.snapshots) {
@@ -12039,6 +12195,9 @@ function buildOpenTeamConfig(answers) {
       },
       maxConcurrency: choice.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY
     };
+    if (choice.modelConcurrency !== undefined && Object.keys(choice.modelConcurrency).length > 0) {
+      runtime.modelConcurrency = { ...choice.modelConcurrency };
+    }
     if (choice.thinkingModelID !== undefined && choice.thinkingModelID !== choice.defaultModelID) {
       runtime.thinkingModel = choice.thinkingModelID;
     }
@@ -12235,7 +12394,40 @@ async function chooseFrontier(prompt, profiles) {
   }
   return parseFrontierRef(selected);
 }
-async function chooseRuntimeModel(prompt, models, meta) {
+function orderModelChoices(models, modelInfo) {
+  const byID = new Map((modelInfo ?? []).map((model) => [model.modelID, model]));
+  const anyLoadState = (modelInfo ?? []).some((model) => model.loaded !== undefined);
+  const decorated = models.map((modelID, index) => {
+    const info = byID.get(modelID);
+    return {
+      modelID,
+      index,
+      loaded: info?.loaded === true,
+      slots: info?.slots
+    };
+  });
+  if (!anyLoadState) {
+    return decorated.map((entry) => ({
+      value: entry.modelID,
+      label: entry.modelID
+    }));
+  }
+  return [...decorated].sort((a, b) => a.loaded === b.loaded ? a.index - b.index : a.loaded ? -1 : 1).map((entry) => ({
+    value: entry.modelID,
+    label: `${entry.modelID} ${modelStateSuffix(entry.loaded, entry.slots)}`
+  }));
+}
+function modelStateSuffix(loaded, slots) {
+  if (!loaded) {
+    return "(not loaded)";
+  }
+  return slots === undefined ? "(loaded)" : `(loaded · ${slots} slot${slots === 1 ? "" : "s"})`;
+}
+function preferredModelID(models, modelInfo) {
+  const loaded = (modelInfo ?? []).find((model) => model.loaded === true && models.includes(model.modelID));
+  return loaded?.modelID ?? models[0];
+}
+async function chooseRuntimeModel(prompt, models, meta, modelInfo) {
   if (models.length === 0) {
     return prompt.text({
       message: `Default model for ${meta.label} (no models detected)`,
@@ -12243,13 +12435,10 @@ async function chooseRuntimeModel(prompt, models, meta) {
       initial: meta.fallbackModelID
     });
   }
-  const first = models[0];
+  const first = preferredModelID(models, modelInfo);
   const opts = {
     message: `Default local model for ${meta.label}`,
-    choices: models.map((modelID) => ({
-      value: modelID,
-      label: modelID
-    }))
+    choices: orderModelChoices(models, modelInfo)
   };
   if (first !== undefined) {
     opts.initial = first;
@@ -12285,9 +12474,13 @@ function normalizeRemoteBaseURL(raw, defaultBaseURL) {
   }
   return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
 }
+function connectionOf(info) {
+  const models = info?.models ?? [];
+  return info?.modelInfo === undefined ? { models } : { models, modelInfo: info.modelInfo };
+}
 async function resolveRuntimeConnection(deps, meta, info) {
   if (meta.defaultBaseURL === undefined) {
-    return { models: info?.models ?? [] };
+    return connectionOf(info);
   }
   const location = await deps.prompt.select({
     message: `Where does ${meta.label} run?`,
@@ -12306,23 +12499,22 @@ async function resolveRuntimeConnection(deps, meta, info) {
   });
   if (location === RUNTIME_LOCATION_LOCAL) {
     const baseURL2 = info?.baseURL !== undefined && info.baseURL.length > 0 ? info.baseURL : meta.defaultBaseURL;
-    return { baseURL: baseURL2, models: info?.models ?? [] };
+    return { baseURL: baseURL2, ...connectionOf(info) };
   }
   const entered = await deps.prompt.text({
     message: `${meta.label} URL on the network (OpenAI-compatible endpoint)`,
     placeholder: remoteBaseURLExample(meta)
   });
   const baseURL = normalizeRemoteBaseURL(entered, meta.defaultBaseURL);
-  let models = [];
+  let probedRuntime;
   if (deps.probeRuntime !== undefined) {
     try {
-      const probed = await deps.probeRuntime(meta.id, baseURL);
-      models = probed.models;
+      probedRuntime = await deps.probeRuntime(meta.id, baseURL);
     } catch {}
   }
-  return { baseURL, models };
+  return { baseURL, ...connectionOf(probedRuntime) };
 }
-async function chooseClassModel(prompt, models, meta, defaultModelID, modelClass) {
+async function chooseClassModel(prompt, models, meta, defaultModelID, modelClass, modelInfo) {
   const label = modelClass === "thinking" ? `Thinking model for ${meta.label} (design, analysis, review reasoning)` : `Coder model for ${meta.label} (writing and editing code)`;
   if (models.length === 0) {
     const raw = await prompt.text({
@@ -12334,18 +12526,18 @@ async function chooseClassModel(prompt, models, meta, defaultModelID, modelClass
   }
   return prompt.select({
     message: label,
-    choices: models.map((modelID) => ({
-      value: modelID,
-      label: modelID === defaultModelID ? `${modelID} (default)` : modelID
+    choices: orderModelChoices(models, modelInfo).map((choice) => ({
+      value: choice.value,
+      label: choice.value === defaultModelID ? `${choice.label} — default` : choice.label
     })),
     initial: defaultModelID
   });
 }
 async function resolveEnabledRuntime(deps, meta, info) {
   const connection = await resolveRuntimeConnection(deps, meta, info);
-  const defaultModelID = await chooseRuntimeModel(deps.prompt, connection.models, meta);
-  const thinkingModelID = await chooseClassModel(deps.prompt, connection.models, meta, defaultModelID, "thinking");
-  const coderModelID = await chooseClassModel(deps.prompt, connection.models, meta, defaultModelID, "coder");
+  const defaultModelID = await chooseRuntimeModel(deps.prompt, connection.models, meta, connection.modelInfo);
+  const thinkingModelID = await chooseClassModel(deps.prompt, connection.models, meta, defaultModelID, "thinking", connection.modelInfo);
+  const coderModelID = await chooseClassModel(deps.prompt, connection.models, meta, defaultModelID, "coder", connection.modelInfo);
   const choice = {
     id: meta.id,
     enabled: true,
@@ -12357,12 +12549,38 @@ async function resolveEnabledRuntime(deps, meta, info) {
   if (connection.baseURL !== undefined) {
     choice.baseURL = connection.baseURL;
   }
+  const modelConcurrency = reportedModelSlots(connection.modelInfo, [
+    defaultModelID,
+    thinkingModelID,
+    coderModelID
+  ]);
+  if (modelConcurrency !== undefined) {
+    choice.modelConcurrency = modelConcurrency;
+  }
   return choice;
 }
+function reportedModelSlots(modelInfo, usedModelIDs) {
+  if (modelInfo === undefined) {
+    return;
+  }
+  const used = new Set(usedModelIDs);
+  const slots = {};
+  for (const model of modelInfo) {
+    if (model.slots !== undefined && used.has(model.modelID)) {
+      slots[model.modelID] = model.slots;
+    }
+  }
+  return Object.keys(slots).length > 0 ? slots : undefined;
+}
 function instanceSuffix(index) {
   return index < 26 ? String.fromCharCode(97 + index) : String(index + 1);
 }
-async function promptSlotCount(prompt, meta) {
+async function promptSlotCount(prompt, meta, reported) {
+  const detected = reportedSlotSummary(reported);
+  if (detected !== undefined) {
+    prompt.note(`${meta.label} reported its slots per model: ${detected.summary}. ` + "Slots belong to the loaded model, not the server, so openteam queues " + "each model against its own capacity instead of one shared number.", "Detected concurrency");
+    return detected.max;
+  }
   const raw = await prompt.text({
     message: `How many concurrent generation slots does ${meta.label} have? (match its real capacity; leaving one free keeps interactive work responsive)`,
     placeholder: String(DEFAULT_LOCAL_MAX_CONCURRENCY),
@@ -12371,6 +12589,16 @@ async function promptSlotCount(prompt, meta) {
   const parsed = Number.parseInt(raw.trim(), 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_LOCAL_MAX_CONCURRENCY;
 }
+function reportedSlotSummary(reported) {
+  const entries = Object.entries(reported ?? {});
+  if (entries.length === 0) {
+    return;
+  }
+  return {
+    summary: entries.map(([modelID, slots]) => `${modelID} = ${slots}`).join(", "),
+    max: Math.max(...entries.map(([, slots]) => slots))
+  };
+}
 async function promptInstanceId(prompt, meta, defaultId, usedIds) {
   for (;; ) {
     const raw = await prompt.text({
@@ -12392,7 +12620,7 @@ async function resolveRuntimeInstances(deps, meta, info, usedIds) {
   });
   if (!fleet) {
     const choice = await resolveEnabledRuntime(deps, meta, info);
-    choice.maxConcurrency = await promptSlotCount(deps.prompt, meta);
+    choice.maxConcurrency = await promptSlotCount(deps.prompt, meta, choice.modelConcurrency);
     usedIds.add(choice.id);
     return [choice];
   }
@@ -12403,7 +12631,7 @@ async function resolveRuntimeInstances(deps, meta, info, usedIds) {
     const choice = await resolveEnabledRuntime(deps, meta, info);
     choice.id = id;
     choice.kind = meta.id;
-    choice.maxConcurrency = await promptSlotCount(deps.prompt, meta);
+    choice.maxConcurrency = await promptSlotCount(deps.prompt, meta, choice.modelConcurrency);
     usedIds.add(id);
     instances.push(choice);
     const another = await deps.prompt.confirm({
@@ -16239,7 +16467,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.17.0",
+  version: "0.17.2",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",