@jmanuelcorral/openteam 0.16.3 → 0.17.1

package/dist/cli.js

@@ -19,7 +19,7 @@ import { randomBytes } from "node:crypto";
 
 // src/config/resolve.ts
 function resolveGraphConfig(config, source) {
-  const configuredMode = config.graph?.mode ?? "shadow";
+  const configuredMode = config.graph?.mode ?? "active";
   const killSwitch = config.graph?.killSwitch ?? false;
   const effectiveMode = killSwitch ? "off" : configuredMode;
   return {
@@ -129,7 +129,8 @@ var AgentRoleProfileSchema = z.object({
   localFirst: z.boolean(),
   requiresLocalRuntime: z.boolean().optional(),
   localRuntimes: z.array(z.string().min(1)).optional(),
-  localModels: z.record(z.string().min(1), z.string().min(1)).optional()
+  localModels: z.record(z.string().min(1), z.string().min(1)).optional(),
+  localModelClass: z.enum(["thinking", "coder"]).optional()
 }).strict();
 var TEAM_ROLES = {
   architect: {
@@ -140,7 +141,8 @@ var TEAM_ROLES = {
     minCodeQualityTier: 5,
     needsToolCallingByDefault: true,
     preferredFrontierModels: ["auto"],
-    localFirst: false
+    localFirst: false,
+    localModelClass: "thinking"
   },
   integration: {
     roleID: "integration",
@@ -150,7 +152,8 @@ var TEAM_ROLES = {
     minCodeQualityTier: 4,
     needsToolCallingByDefault: true,
     preferredFrontierModels: ["auto"],
-    localFirst: false
+    localFirst: false,
+    localModelClass: "coder"
   },
   "local-runtime": {
     roleID: "local-runtime",
@@ -160,7 +163,8 @@ var TEAM_ROLES = {
     minCodeQualityTier: 4,
     needsToolCallingByDefault: true,
     preferredFrontierModels: ["auto"],
-    localFirst: true
+    localFirst: true,
+    localModelClass: "coder"
   },
   "routing-cost": {
     roleID: "routing-cost",
@@ -170,7 +174,8 @@ var TEAM_ROLES = {
     minCodeQualityTier: 4,
     needsToolCallingByDefault: false,
     preferredFrontierModels: ["auto"],
-    localFirst: true
+    localFirst: true,
+    localModelClass: "thinking"
   },
   scribe: {
     roleID: "scribe",
@@ -203,7 +208,8 @@ var TEAM_ROLES = {
     needsToolCallingByDefault: false,
     preferredFrontierModels: [],
     localFirst: true,
-    requiresLocalRuntime: true
+    requiresLocalRuntime: true,
+    localModelClass: "thinking"
   },
   tester: {
     roleID: "tester",
@@ -213,7 +219,8 @@ var TEAM_ROLES = {
     minCodeQualityTier: 3,
     needsToolCallingByDefault: true,
     preferredFrontierModels: ["auto"],
-    localFirst: true
+    localFirst: true,
+    localModelClass: "coder"
   },
   reviewer: {
     roleID: "reviewer",
@@ -223,7 +230,8 @@ var TEAM_ROLES = {
     minCodeQualityTier: 5,
     needsToolCallingByDefault: false,
     preferredFrontierModels: ["auto"],
-    localFirst: true
+    localFirst: true,
+    localModelClass: "coder"
   }
 };
 var LEGACY_TEAM_ROLE_ALIASES = {
@@ -326,11 +334,11 @@ var GraphEngineSchema = z2.enum(["builtin", "langgraph"]);
 var DEFAULT_GRAPH_JOURNAL_ROOT = ".opencode/openteam-local/graph/runs";
 var DEFAULT_GRAPH_WORKTREES_DIR = ".opencode/openteam-local/graph/worktrees";
 var GraphConfigSchema = z2.object({
-  mode: GraphModeSchema.default("shadow"),
+  mode: GraphModeSchema.default("active"),
   engine: GraphEngineSchema.optional(),
   killSwitch: z2.boolean().default(false),
   journalRoot: z2.string().min(1).default(DEFAULT_GRAPH_JOURNAL_ROOT),
-  operatorApproval: z2.boolean().default(false),
+  operatorApproval: z2.boolean().default(true),
   worktrees: z2.object({
     enabled: z2.boolean().default(false)
   }).strict().default({ enabled: false })
@@ -424,6 +432,9 @@ var OrchestratorRolesSchema = z2.record(z2.string().min(1), z2.unknown()).defaul
     if (parsed.data.localModels !== undefined) {
       profile.localModels = parsed.data.localModels;
     }
+    if (parsed.data.localModelClass !== undefined) {
+      profile.localModelClass = parsed.data.localModelClass;
+    }
     parsedRoles[roleID] = profile;
   }
   return parsedRoles;
@@ -450,7 +461,10 @@ var LocalRuntimeSchema = z2.object({
   discovery: z2.enum(["cli", "sdk", "manual"]).optional(),
   defaultModel: ModelRefSchema,
   maxConcurrency: z2.number().int().positive().optional(),
-  reservedInteractiveSlots: z2.number().int().nonnegative().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()
 }).strict().superRefine((runtime, ctx) => {
   const resolvedKind = runtime.kind ?? runtime.id;
   if (!LocalRuntimeKindSchema.safeParse(resolvedKind).success) {
@@ -576,10 +590,10 @@ var OpenTeamConfigObjectSchema = z2.object({
   storage: StorageConfigSchema,
   memory: MemoryConfigSchema.optional(),
   graph: GraphConfigSchema.default({
-    mode: "shadow",
+    mode: "active",
     killSwitch: false,
     journalRoot: DEFAULT_GRAPH_JOURNAL_ROOT,
-    operatorApproval: false,
+    operatorApproval: true,
     worktrees: { enabled: false }
   }),
   orchestrator: OrchestratorConfigSchema.optional()
@@ -669,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) {
@@ -1604,9 +1628,19 @@ function configuredRuntime(runtimeId, config) {
 function runtimeIdOfModel(model, config) {
   return config.local.runtimes.find((runtime) => sameModel(runtime.defaultModel, model))?.id;
 }
-function roleLocalModel(role, runtimeId, fallback) {
+function roleLocalModel(role, runtimeId, fallback, runtime) {
   const pinned = role.localModels?.[runtimeId];
-  return pinned === undefined ? fallback : { ...fallback, modelID: pinned };
+  if (pinned !== undefined) {
+    return { ...fallback, modelID: pinned };
+  }
+  const classModel = runtimeClassModel(role.localModelClass, runtime);
+  return classModel === undefined ? fallback : { ...fallback, modelID: classModel };
+}
+function runtimeClassModel(modelClass, runtime) {
+  if (modelClass === undefined || runtime === undefined) {
+    return;
+  }
+  return modelClass === "thinking" ? runtime.thinkingModel : runtime.coderModel;
 }
 function selectDispatchRuntime(role, decision2, reachable, config) {
   if (decision2.routeKind !== "local") {
@@ -1622,7 +1656,7 @@ function selectDispatchRuntime(role, decision2, reachable, config) {
       if (runtime === undefined) {
         continue;
       }
-      const model = roleLocalModel(role, runtimeId, runtime.defaultModel);
+      const model = roleLocalModel(role, runtimeId, runtime.defaultModel, runtime);
       return {
         runtimeId,
         decision: { ...decision2, selected: model }
@@ -1631,7 +1665,7 @@ function selectDispatchRuntime(role, decision2, reachable, config) {
   }
   const resolvedRuntimeId = runtimeIdOfModel(decision2.selected, config);
   if (resolvedRuntimeId !== undefined) {
-    const pinned = roleLocalModel(role, resolvedRuntimeId, decision2.selected);
+    const pinned = roleLocalModel(role, resolvedRuntimeId, decision2.selected, configuredRuntime(resolvedRuntimeId, config));
     if (pinned !== decision2.selected) {
       return {
         runtimeId: resolvedRuntimeId,
@@ -2267,18 +2301,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 {
@@ -3079,7 +3114,10 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
       "discovery",
       "defaultModel",
       "maxConcurrency",
-      "reservedInteractiveSlots"
+      "modelConcurrency",
+      "reservedInteractiveSlots",
+      "thinkingModel",
+      "coderModel"
     ]
   ],
   ["local.runtimes[].defaultModel", MODEL_REF_KEYS],
@@ -9999,24 +10037,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";
@@ -10245,6 +10400,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;
       }
@@ -10272,6 +10430,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;
     }
@@ -11001,6 +11162,22 @@ function renderConsoleStatus(console_) {
 }
 
 // src/commands/doctor.ts
+function runtimeClassLine(runtime) {
+  if (runtime === undefined) {
+    return;
+  }
+  const thinking = runtime.thinkingModel;
+  const coder = runtime.coderModel;
+  if (thinking === undefined && coder === undefined) {
+    return;
+  }
+  const parts = [
+    `thinking ${thinking ?? "(default)"}`,
+    `coder ${coder ?? "(default)"}`,
+    `default ${runtime.defaultModel.modelID}`
+  ];
+  return `    ↳ ${parts.join(" · ")}`;
+}
 function runtimeLine(snapshot, runtime) {
   const mark = snapshot.reachable ? "✓" : "✗";
   const detail = snapshot.reachable ? `${snapshot.models.length} model(s)` : snapshot.error ?? "unreachable";
@@ -11008,6 +11185,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;
@@ -11257,7 +11442,16 @@ function renderDoctor(input) {
     lines.push("    (no runtime enabled)");
   } else {
     for (const snapshot of input.snapshots) {
-      lines.push(runtimeLine(snapshot, enabledRuntimes.find((r) => r.id === snapshot.id)));
+      const runtime = enabledRuntimes.find((r) => r.id === snapshot.id);
+      lines.push(runtimeLine(snapshot, runtime));
+      const classLine = runtimeClassLine(runtime);
+      if (classLine !== undefined) {
+        lines.push(classLine);
+      }
+      const modelSlots = runtimeModelSlotsLine(runtime);
+      if (modelSlots !== undefined) {
+        lines.push(modelSlots);
+      }
     }
   }
   for (const snapshot of input.snapshots) {
@@ -11993,6 +12187,15 @@ 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;
+    }
+    if (choice.coderModelID !== undefined && choice.coderModelID !== choice.defaultModelID) {
+      runtime.coderModel = choice.coderModelID;
+    }
     if (choice.kind !== undefined && choice.kind !== choice.id) {
       runtime.kind = choice.kind;
     }
@@ -12023,7 +12226,7 @@ function buildOpenTeamConfig(answers) {
     },
     local: { runtimes },
     privacyMode: answers.privacyMode,
-    graph: { mode: "shadow" }
+    graph: { mode: "active" }
   });
 }
 function buildOpencodeConfig(answers) {
@@ -12183,7 +12386,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)`,
@@ -12191,13 +12427,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;
@@ -12233,9 +12466,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?`,
@@ -12254,40 +12491,88 @@ 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, 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({
+      message: `${label} — enter to reuse the default`,
+      placeholder: defaultModelID,
+      initial: defaultModelID
+    });
+    return raw.trim().length > 0 ? raw.trim() : defaultModelID;
+  }
+  return prompt.select({
+    message: label,
+    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 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,
     defaultModelID,
+    thinkingModelID,
+    coderModelID,
     models: connection.models
   };
   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),
@@ -12296,6 +12581,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({
@@ -12317,7 +12612,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];
   }
@@ -12328,7 +12623,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({
@@ -16164,7 +16459,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.16.3",
+  version: "0.17.1",
   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",
@@ -16320,7 +16615,7 @@ async function buildGateInput(config, storage, opencodeVersion, warn, packagedRe
   } catch {}
   const soak = await readAndParseCertificate(storage, SOAK_CERT_PATH, (raw) => parseSoakCertificate(raw, DEFAULT_SOAK_POLICY, soakLedgerDigest), (cert) => cert.digest);
   const migration = "complete";
-  const operatorApproval = config.graph?.operatorApproval ?? false;
+  const operatorApproval = config.graph?.operatorApproval ?? true;
   return { shadow, release, soak, migration, operatorApproval };
 }
 var OPENCODE_VERSION_UNRESOLVED_REASON = "the opencode version is not determinable outside a running opencode session, " + "so the cutover gate cannot be verified here — the running plugin logs the " + "authoritative gate result and warns loudly on a real denial";