muonroi-cli 1.8.3 → 1.8.5

package/dist/src/council/leader.d.ts

@@ -33,11 +33,37 @@ export interface LeaderResolution {
     /** Set when no configured leader existed and one was picked by tier. */
     defaulted?: boolean;
 }
+/** Plan-council leader — always premium-tier within session provider (telemetry: plan-council). */
+export declare function resolvePlanCouncilLeader(sessionModelId: string): Promise<LeaderResolution>;
 export declare function resolveLeaderModelDetailed(sessionModelId: string): Promise<LeaderResolution>;
 /** Back-compat sync wrapper. Returns the modelId only; no reachability check. */
 export declare function resolveLeaderModel(sessionModelId: string): string;
 export declare function hasMultiProviderConfig(roleModels: Partial<Record<ModelRole, string>>): boolean;
+/**
+ * Count debate roles available for auto-council gating.
+ * Uses explicit roleModels when ≥2 configured; otherwise catalog council slots.
+ */
+export declare function getEffectiveCouncilRoleCount(): number;
 export declare function resolveParticipants(sessionModelId: string, preferMultiProvider: boolean): Promise<Array<{
     role: ModelRole;
     model: string;
 }>>;
+/** A model the leader may pick for a task-aware debate panel (U3). */
+export interface CouncilCandidate {
+    model: string;
+    tier?: string;
+    provider?: string;
+    roles?: string[];
+    description: string;
+}
+/**
+ * Build the pool of models the leader may choose from when assembling a
+ * task-aware panel (U3). Seeded with the default roster (guaranteed reachable),
+ * then expanded with other reachable, routable models on the same providers.
+ * Capped so the selection prompt stays bounded. Never throws — a provider probe
+ * failure simply yields a smaller pool, and the caller falls back to the roster.
+ */
+export declare function buildCouncilCandidatePool(defaultRoster: Array<{
+    role: ModelRole;
+    model: string;
+}>): Promise<CouncilCandidate[]>;

package/dist/src/council/leader.js

@@ -1,6 +1,8 @@
-import { getModelByTier, getModelInfo, getModelsForProvider } from "../models/registry.js";
+import { resolveGsdPremiumModel } from "../gsd/model-tier.js";
+import { getCatalogCouncilRouting, getModelInfo, getModelsForProvider } from "../models/registry.js";
 import { getConfiguredProviders } from "../providers/keychain.js";
 import { detectProviderForModel } from "../providers/runtime.js";
+import { getRoutedModelByTier } from "../router/peak-hour.js";
 import { getRoleModel, getRoleModels, isProviderDisabled } from "../utils/settings.js";
 const TIER_RANK = { fast: 1, balanced: 2, premium: 3 };
 function tierOf(modelId) {
@@ -51,7 +53,7 @@ export function pickCouncilTaskModel(task, leaderModelId, costAware) {
     catch {
         return leaderModelId;
     }
-    const candidate = getModelByTier(targetTier, leaderProvider);
+    const candidate = getRoutedModelByTier(targetTier, leaderProvider);
     // Only accept a candidate that's on the same provider as the leader.
     // getModelByTier may fall back to "any provider" — reject that to avoid
     // billing surprises and silent key-misses.
@@ -94,6 +96,29 @@ async function isProviderReachable(provider) {
     const configured = await getConfiguredProviders();
     return configured.includes(provider);
 }
+/** Plan-council leader — always premium-tier within session provider (telemetry: plan-council). */
+export async function resolvePlanCouncilLeader(sessionModelId) {
+    const sessionProviderId = detectProviderForModel(sessionModelId);
+    const sessionDisabled = isProviderDisabled(sessionProviderId);
+    const sessionReachable = !sessionDisabled && (await isProviderReachable(sessionProviderId));
+    if (!sessionReachable) {
+        return { modelId: getRoleModel("leader") ?? sessionModelId };
+    }
+    const catalogLeader = getModelsForProvider(sessionProviderId).find((m) => m.roles?.includes("leader"));
+    if (catalogLeader) {
+        return { modelId: catalogLeader.id };
+    }
+    const premiumId = resolveGsdPremiumModel(sessionModelId);
+    const sessionTier = tierOf(sessionModelId);
+    const premiumTier = tierOf(premiumId);
+    if (premiumId !== sessionModelId && premiumTier && sessionTier && TIER_RANK[premiumTier] > TIER_RANK[sessionTier]) {
+        return { modelId: premiumId, promotedFrom: { modelId: sessionModelId, tier: sessionTier } };
+    }
+    if (premiumId !== sessionModelId) {
+        return { modelId: premiumId, defaulted: true };
+    }
+    return { modelId: sessionModelId, defaulted: true };
+}
 export async function resolveLeaderModelDetailed(sessionModelId) {
     const sessionProviderId = detectProviderForModel(sessionModelId);
     const configured = getRoleModel("leader");
@@ -104,6 +129,13 @@ export async function resolveLeaderModelDetailed(sessionModelId) {
     if (!sessionReachable) {
         return { modelId: configured ?? sessionModelId };
     }
+    // 1. If not manually configured, and session provider has a catalog model with "leader" role, use it!
+    if (!configured) {
+        const catalogLeader = getModelsForProvider(sessionProviderId).find((m) => m.roles?.includes("leader"));
+        if (catalogLeader) {
+            return { modelId: catalogLeader.id };
+        }
+    }
     // Build candidate set ON THE SESSION PROVIDER ONLY.
     const candidates = new Map();
     for (const m of getModelsForProvider(sessionProviderId)) {
@@ -146,11 +178,14 @@ export async function resolveLeaderModelDetailed(sessionModelId) {
             promotedFrom: { modelId: configured, tier: configuredTier },
         };
     }
-    // No usable configured leader — use the session model itself. We intentionally
-    // do NOT silently promote to the highest-tier model on the provider: the
-    // user's account/key may not have access to that tier (e.g. SiliconFlow Pro),
-    // which would cause 401s on every leader call. Tier-upgrade is a deliberate
-    // choice — opt in by setting roleModels.leader in config.
+    // Fallback: no configured leader AND the provider tags no model with the
+    // "leader" role. Promoting the leader to the provider's highest tier IS the
+    // intended design, but only when there's an EXPLICIT signal for it — a catalog
+    // model tagged role:"leader" (handled at the top of this function) or a
+    // configured roleModels.leader (promoted up to the best tier above). With
+    // neither signal we do NOT guess a top-tier model here: an arbitrary *-pro the
+    // key isn't entitled to would 401 on every leader call. So we keep the session
+    // model itself.
     return { modelId: sessionModelId, defaulted: true };
 }
 /** Back-compat sync wrapper. Returns the modelId only; no reachability check. */
@@ -158,6 +193,10 @@ export function resolveLeaderModel(sessionModelId) {
     const configured = getRoleModel("leader");
     if (configured)
         return configured;
+    const sessionProviderId = detectProviderForModel(sessionModelId);
+    const catalogLeader = getModelsForProvider(sessionProviderId).find((m) => m.roles?.includes("leader"));
+    if (catalogLeader)
+        return catalogLeader.id;
     // See resolveLeaderModelDetailed for why we no longer silently upgrade to
     // the premium tier on the session provider (user may not have access).
     return sessionModelId;
@@ -170,6 +209,56 @@ export function hasMultiProviderConfig(roleModels) {
     }
     return providers.size >= 2;
 }
+/**
+ * Count debate roles available for auto-council gating.
+ * Uses explicit roleModels when ≥2 configured; otherwise catalog council slots.
+ */
+export function getEffectiveCouncilRoleCount() {
+    const explicit = Object.values(getRoleModels()).filter(Boolean).length;
+    if (explicit >= 2)
+        return explicit;
+    const catalog = getCatalogCouncilRouting();
+    if (catalog?.participants?.length && catalog.participants.length >= 2) {
+        return catalog.participants.length;
+    }
+    return explicit;
+}
+async function resolveCatalogCouncilParticipants() {
+    const config = getCatalogCouncilRouting();
+    if (!config?.participants?.length)
+        return [];
+    const candidates = [];
+    const usedModels = new Set();
+    for (const slot of config.participants) {
+        const role = slot.role;
+        const provider = slot.provider;
+        if (isProviderDisabled(provider))
+            continue;
+        if (!(await isProviderReachable(provider)))
+            continue;
+        let modelId;
+        if (slot.model_id) {
+            const info = getModelInfo(slot.model_id);
+            if (info?.provider === provider)
+                modelId = slot.model_id;
+        }
+        if (!modelId && slot.tier) {
+            const m = getRoutedModelByTier(slot.tier, provider);
+            if (m?.provider === provider)
+                modelId = m.id;
+        }
+        if (!modelId) {
+            const models = getModelsForProvider(provider);
+            const routable = models.find((m) => m.tierRouting !== false);
+            modelId = routable?.id ?? models[0]?.id;
+        }
+        if (!modelId || usedModels.has(modelId))
+            continue;
+        candidates.push({ role, model: modelId });
+        usedModels.add(modelId);
+    }
+    return candidates.length >= 2 ? candidates : [];
+}
 export async function resolveParticipants(sessionModelId, preferMultiProvider) {
     const ALL_ROLES = ["implement", "verify", "research"];
     const candidates = [];
@@ -190,6 +279,12 @@ export async function resolveParticipants(sessionModelId, preferMultiProvider) {
         if (candidates.length >= 2)
             return candidates;
     }
+    // Catalog-defined multi-provider lineup (default for deepseek+zai+opencode-go+xai stack).
+    if (preferMultiProvider) {
+        const catalogCandidates = await resolveCatalogCouncilParticipants();
+        if (catalogCandidates.length >= 2)
+            return catalogCandidates;
+    }
     const mainProviderId = detectProviderForModel(sessionModelId);
     // Skip same-provider resolution if the provider is disabled
     if (!isProviderDisabled(mainProviderId)) {
@@ -204,6 +299,49 @@ export async function resolveParticipants(sessionModelId, preferMultiProvider) {
     }
     return [];
 }
+/**
+ * Build the pool of models the leader may choose from when assembling a
+ * task-aware panel (U3). Seeded with the default roster (guaranteed reachable),
+ * then expanded with other reachable, routable models on the same providers.
+ * Capped so the selection prompt stays bounded. Never throws — a provider probe
+ * failure simply yields a smaller pool, and the caller falls back to the roster.
+ */
+export async function buildCouncilCandidatePool(defaultRoster) {
+    const byId = new Map();
+    const add = (modelId) => {
+        if (!modelId || byId.has(modelId))
+            return;
+        const info = getModelInfo(modelId);
+        byId.set(modelId, {
+            model: modelId,
+            tier: info?.tier,
+            provider: info?.provider ?? detectProviderForModel(modelId),
+            roles: info?.roles,
+            description: info?.description ?? "",
+        });
+    };
+    for (const r of defaultRoster)
+        add(r.model);
+    const providers = new Set();
+    for (const r of defaultRoster)
+        providers.add(detectProviderForModel(r.model));
+    for (const provider of providers) {
+        if (byId.size >= 8)
+            break;
+        if (isProviderDisabled(provider))
+            continue;
+        if (!(await isProviderReachable(provider)))
+            continue;
+        for (const m of getModelsForProvider(provider)) {
+            if (m.tierRouting === false)
+                continue;
+            add(m.id);
+            if (byId.size >= 8)
+                break;
+        }
+    }
+    return [...byId.values()];
+}
 async function resolveSameProviderCandidates(providerId, sessionModelId, roles) {
     if (isProviderDisabled(providerId))
         return [];
@@ -222,8 +360,11 @@ async function resolveSameProviderCandidates(providerId, sessionModelId, roles)
     const usedModels = new Set();
     const candidates = [];
     for (const role of roles) {
-        const prefs = tierPreference[role] ?? ["balanced", "fast", "premium"];
-        let picked = providerModels.find((m) => prefs.some((t) => m.tier === t) && !usedModels.has(m.id));
+        let picked = providerModels.find((m) => m.roles?.includes(role) && !usedModels.has(m.id));
+        if (!picked) {
+            const prefs = tierPreference[role] ?? ["balanced", "fast", "premium"];
+            picked = providerModels.find((m) => prefs.some((t) => m.tier === t) && !usedModels.has(m.id));
+        }
         if (!picked)
             picked = providerModels.find((m) => !usedModels.has(m.id));
         if (!picked)

package/dist/src/council/llm.d.ts

@@ -1,6 +1,27 @@
 import type { BashTool } from "../tools/bash.js";
 import type { AgentMode, CouncilStatusPhase, StreamChunk } from "../types/index.js";
 import type { CouncilLLM, CouncilStats } from "./types.js";
+/**
+ * Record a council LLM call into the `usage_events` table with source="council".
+ *
+ * This is the SINGLE source of truth for council usage accounting: it fires from
+ * inside every council generate/debate/research call so ALL council entry points
+ * (the /council slash path, auto-council, and every /ideal phase — clarifier,
+ * research, generate, sprint) land in usage_events. Before this existed, only
+ * the loop-driver's `runDebate` call site externally wrapped usage recording, so
+ * `runCouncilV2` (/council + auto-council) and the non-debate /ideal phases never
+ * recorded — their token cost was invisible to session totals, the StatusBar,
+ * `usage forensics`, and the cost caps (root cause of session f24c28b6dcb3:
+ * council ran but produced 0 source="council" usage_events).
+ *
+ * Best-effort: a null sessionId (no chat session FK) or a DB failure must never
+ * break the council run, but per the No-Silent-Catch rule we log the failure.
+ */
+export declare function recordCouncilUsage(sessionId: string | undefined, modelId: string, usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+}): void;
 declare global {
     var __muonroiMockLlm: any;
 }
@@ -24,6 +45,17 @@ interface TracedGenerateArgs {
  * Returns the generated text via the AsyncGenerator return value.
  */
 export declare function tracedGenerate(llm: CouncilLLM, args: TracedGenerateArgs): AsyncGenerator<StreamChunk, string, unknown>;
+/**
+ * Run {@link tracedGenerate} across a list of models, returning the first
+ * non-empty completion. A model that throws (e.g. a flaky proxy returning
+ * "Upstream request failed") or yields only whitespace advances to the next
+ * candidate; fallback attempts are labelled so the timeline shows the retry.
+ * Returns null when every candidate fails — the caller decides the degraded
+ * fallback (e.g. a single-criterion spec). Dedupes the model list in order.
+ */
+export declare function tracedGenerateWithFallback(llm: CouncilLLM, args: Omit<TracedGenerateArgs, "modelId"> & {
+    models: string[];
+}): AsyncGenerator<StreamChunk, string | null, unknown>;
 interface TracedAsyncArgs {
     phase: CouncilStatusPhase;
     label: string;