muonroi-cli 1.3.4 → 1.4.1

package/dist/src/reporter/index.js

@@ -0,0 +1,167 @@
+/**
+ * src/reporter/index.ts
+ *
+ * P8 Reporter Agent — main loop.
+ *
+ * Runs as a separate long-lived process: muonroi reporter --run <runId>
+ * Polls the product's Discord channel for messages, classifies them,
+ * dispatches to handlers, and posts replies.
+ *
+ * Manual smoke test:
+ *   1. Start a worker: muonroi ideal "build X" in terminal A.
+ *   2. In terminal B: muonroi reporter --run <runId> --product-slug <slug>
+ *   3. In the product's Discord channel, type "progress?"
+ *   4. Reporter should reply within 5s with a ProgressSnapshot markdown card.
+ *
+ * Worker process is UNTOUCHED — reporter is read-only on all worker artifacts
+ * (backlog.json, sprint-plan.json, interaction_logs). Only writes:
+ *   - Discord messages
+ *   - reporter-budget.json (LLM spend tracking)
+ *   - interaction_logs (heartbeat rows with event_type="reporter")
+ */
+import { getDatabase } from "../storage/db.js";
+import { buildUnauthorizedReply, checkStakeholder } from "./acl-check.js";
+import { handleFreeformQuery, handleItemQuery, handleProgressQuery, handleSprintQuery, } from "./handlers.js";
+import { classifyQuery } from "./query-router.js";
+// ─── Heartbeat ────────────────────────────────────────────────────────────────
+const HEARTBEAT_EVERY_N_POLLS = 12; // ~60s at default 5s poll interval
+function emitHeartbeat(runId) {
+    try {
+        const db = getDatabase();
+        db.prepare(`INSERT INTO interaction_logs (session_id, event_type, event_subtype, metadata_json, created_at)
+       VALUES (?, 'reporter', 'heartbeat', '{}', ?)`).run(runId, new Date().toISOString());
+    }
+    catch {
+        // Best-effort — never crash the reporter over a heartbeat write failure.
+    }
+}
+// ─── Main loop ────────────────────────────────────────────────────────────────
+/**
+ * Run the reporter loop until signal fires or an unrecoverable error occurs.
+ *
+ * Separating deps (injectable, testable) from config (runtime scalars) allows
+ * unit tests to inject mock chat + llm without touching the CLI layer.
+ */
+export async function runReporter(deps, config) {
+    const { chat, llm, leaderModelId } = deps;
+    const { runId, flowDir, productSlug, channelId } = config;
+    const pollIntervalMs = config.pollIntervalMs ?? 5_000;
+    const dailyBudget = config.dailyLlmBudgetUsd ?? 0.5;
+    const signal = config.signal;
+    const handlerDeps = {
+        flowDir,
+        runId,
+        productSlug,
+        llm,
+        leaderModelId,
+        dailyBudget,
+    };
+    // Prime the cursor — skip messages that existed before reporter started.
+    let lastSeenId;
+    try {
+        const seed = await chat.getChannelMessages(channelId, { limit: 1 });
+        lastSeenId = seed.length > 0 ? seed[0].id : undefined;
+    }
+    catch {
+        lastSeenId = undefined;
+    }
+    let botId;
+    try {
+        botId = await chat.getCurrentUserId();
+    }
+    catch (err) {
+        throw new Error(`Reporter: failed to get bot user id — ${err.message}`);
+    }
+    let pollCount = 0;
+    while (true) {
+        if (signal?.aborted)
+            break;
+        // Heartbeat
+        pollCount++;
+        if (pollCount % HEARTBEAT_EVERY_N_POLLS === 0) {
+            emitHeartbeat(runId);
+        }
+        // Fetch new messages
+        let messages;
+        try {
+            messages = await chat.getChannelMessages(channelId, {
+                afterId: lastSeenId,
+                limit: 50,
+            });
+        }
+        catch (err) {
+            console.error(`[reporter] Discord poll error: ${err.message}`);
+            await sleep(pollIntervalMs, signal);
+            continue;
+        }
+        // Process messages in chronological order (Discord returns newest-first).
+        const ordered = [...messages].reverse();
+        for (const msg of ordered) {
+            if (signal?.aborted)
+                break;
+            // Skip bot's own messages to avoid reply loops.
+            if (msg.author.id === botId)
+                continue;
+            // Update cursor before handling (so a crash doesn't re-process).
+            lastSeenId = msg.id;
+            // ACL check
+            let aclResult;
+            try {
+                aclResult = await checkStakeholder(productSlug, msg.author.id);
+            }
+            catch {
+                aclResult = { authorized: false, stakeholderUsernames: [] };
+            }
+            if (!aclResult.authorized) {
+                const reply = buildUnauthorizedReply(aclResult);
+                await chat.postMessage(channelId, reply).catch((e) => {
+                    console.error(`[reporter] postMessage (acl deny) failed: ${e.message}`);
+                });
+                continue;
+            }
+            // Classify + dispatch
+            const classified = classifyQuery(msg.content);
+            let reply;
+            try {
+                switch (classified.kind) {
+                    case "progress":
+                        reply = await handleProgressQuery(handlerDeps);
+                        break;
+                    case "sprint":
+                        reply = await handleSprintQuery(handlerDeps, classified.sprintNumber ?? 1);
+                        break;
+                    case "item":
+                        reply = await handleItemQuery(handlerDeps, classified.itemQuery ?? "");
+                        break;
+                    default:
+                        reply = await handleFreeformQuery(handlerDeps, msg.content);
+                        break;
+                }
+            }
+            catch (err) {
+                reply = `Reporter encountered an error: ${err.message}`;
+            }
+            await chat.postMessage(channelId, reply).catch((e) => {
+                console.error(`[reporter] postMessage failed: ${e.message}`);
+            });
+        }
+        // Update cursor to the last message in the batch even if we skipped bot msgs.
+        if (ordered.length > 0) {
+            lastSeenId = ordered[ordered.length - 1].id;
+        }
+        if (signal?.aborted)
+            break;
+        await sleep(pollIntervalMs, signal);
+    }
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/src/reporter/query-router.d.ts

@@ -0,0 +1,21 @@
+/**
+ * src/reporter/query-router.ts
+ *
+ * Classifies a user's Discord message into a query kind using deterministic
+ * pattern matching — no LLM, fast, zero cost.
+ */
+export type QueryKind = "progress" | "sprint" | "item" | "freeform";
+export interface ClassifiedQuery {
+    kind: QueryKind;
+    /** Populated when kind="sprint" — the sprint number requested. */
+    sprintNumber?: number;
+    /** Populated when kind="item" — the user's item search string. */
+    itemQuery?: string;
+    rawText: string;
+}
+/**
+ * Classify a raw user message text into a QueryKind.
+ *
+ * Priority: progress > sprint > item > freeform
+ */
+export declare function classifyQuery(text: string): ClassifiedQuery;

package/dist/src/reporter/query-router.js

@@ -0,0 +1,32 @@
+/**
+ * src/reporter/query-router.ts
+ *
+ * Classifies a user's Discord message into a query kind using deterministic
+ * pattern matching — no LLM, fast, zero cost.
+ */
+const PROGRESS_RE = /^(progress|status|ti[eế]n\s*[đd][oộ]|b[aá]o\s*c[aá]o|how\s+is\s+it\s+going|how's\s+it\s+going|\/status)\??\s*$/iu;
+const SPRINT_NUMBER_RE = /^(?:show\s+)?sprint\s+(\d+)/i;
+// Matches: "show item X", "tell me about item X", "explain feature X", "show task X"
+const ITEM_RE = /^(?:show|tell(?:\s+me\s+about)?|explain)\s+(?:item|task|feature)\s+(.+)/i;
+/**
+ * Classify a raw user message text into a QueryKind.
+ *
+ * Priority: progress > sprint > item > freeform
+ */
+export function classifyQuery(text) {
+    const trimmed = text.trim();
+    if (PROGRESS_RE.test(trimmed)) {
+        return { kind: "progress", rawText: trimmed };
+    }
+    const sprintMatch = SPRINT_NUMBER_RE.exec(trimmed);
+    if (sprintMatch) {
+        return { kind: "sprint", sprintNumber: Number(sprintMatch[1]), rawText: trimmed };
+    }
+    const itemMatch = ITEM_RE.exec(trimmed);
+    if (itemMatch) {
+        // Group [1] is the query text after "item|task|feature <query>"
+        return { kind: "item", itemQuery: itemMatch[1]?.trim(), rawText: trimmed };
+    }
+    return { kind: "freeform", rawText: trimmed };
+}
+//# sourceMappingURL=query-router.js.map

package/dist/src/router/__tests__/step-router.test.js

@@ -25,14 +25,14 @@ describe("decideStepRouting", () => {
     });
     it("returns phase2ModelId=null when phase 1 model is already fast tier", () => {
         const fastModel = MODELS.find((m) => m.tier === "fast" && m.provider);
-        if (!fastModel || !fastModel.provider)
+        if (!fastModel?.provider)
             return;
         const decision = decideStepRouting(fastModel.id, fastModel.provider, mockConfig({ toolExecutionTier: "fast" }));
         expect(decision.phase1ModelId).toBe(fastModel.id);
     });
     it("returns a fast execution model for premium phase 1", () => {
         const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider);
-        if (!premiumModel || !premiumModel.provider)
+        if (!premiumModel?.provider)
             return;
         const decision = decideStepRouting(premiumModel.id, premiumModel.provider, mockConfig());
         if (decision.phase2ModelId) {
@@ -42,7 +42,7 @@ describe("decideStepRouting", () => {
     });
     it("respects toolExecutionTier setting", () => {
         const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider);
-        if (!premiumModel || !premiumModel.provider)
+        if (!premiumModel?.provider)
             return;
         const balancedCfg = mockConfig({ toolExecutionTier: "balanced" });
         const decision = decideStepRouting(premiumModel.id, premiumModel.provider, balancedCfg);

package/dist/src/router/classifier/regex.js

@@ -6,7 +6,38 @@ const PATTERNS = [
         confidence: 0.85,
         tierHint: "fast",
     },
-    { re: /\b(edit|modify|update|change|fix|patch)\s+(the\s+)?\S+/i, intent: "edit", confidence: 0.8, tierHint: "fast" },
+    // PIL-L6 fix — bug-fix / CI-debug signals MUST land in `debug` not `edit`.
+    // The broader edit regex below catches "fix X" generically and previously
+    // misclassified "fix ci fail" → edit → generate. Order matters: this rule
+    // runs BEFORE the generic edit pattern.
+    {
+        re: /\b(ci|build|test|action|workflow|pipeline|deploy|deployment)\s+(is\s+)?(fail(?:s|ed|ing)?|broken|red)\b/i,
+        intent: "debug",
+        confidence: 0.85,
+        tierHint: "balanced",
+    },
+    {
+        re: /\bfix\s+(the\s+)?(ci|build|test|action|workflow|pipeline|deploy|bug|error|crash|fail(?:ure)?|broken|red)\b/i,
+        intent: "debug",
+        confidence: 0.85,
+        tierHint: "balanced",
+    },
+    // Narrow debug pattern — "error" / "fail" alone is too generic ("error
+    // boundaries", "fail-safe", "failover" are architecture terms, not bugs).
+    // Require a brokenness verb / context word nearby OR a specific signature
+    // (traceback / stack trace / segfault — these are pure bug signals).
+    {
+        re: /\b(traceback|stack\s*trace|segfault|panic|core\s*dump)\b|\b(error|exception|crash|fail(?:s|ed|ing)?|broken|not\s+working)\b\s+(occurred|thrown|raised|happening|coming|appearing)\b|\b(getting|having|seeing|throwing)\b\s+(an?\s+)?(error|exception|crash|fail(?:ure)?)\b/i,
+        intent: "debug",
+        confidence: 0.78,
+        tierHint: "balanced",
+    },
+    // PIL-L6 v2 — free-form catch-all: confidence below brain threshold (0.7)
+    // so L1 cascades into the unified pilContext / LLM fallback to disambiguate.
+    // "fix cho tôi" or "fix the bug" would otherwise win at 0.8 and skip brain,
+    // misclassifying CI-debug as taskType=generate. Specific verb+noun rules
+    // (above this one) still score 0.85 and bypass brain when unambiguous.
+    { re: /\b(edit|modify|update|change|fix|patch)\s+(the\s+)?\S+/i, intent: "edit", confidence: 0.55, tierHint: "fast" },
     {
         re: /\b(run|execute|exec)\s+(the\s+)?(command|script|npm|bun|tsc|test|build)\b/i,
         intent: "run-command",
@@ -59,7 +90,23 @@ const PATTERNS = [
         confidence: 0.85,
         tierHint: "fast",
     },
-    { re: /(sửa|fix|chỉnh|update|cập nhật|patch)\s+\S+/i, intent: "edit", confidence: 0.8, tierHint: "fast" },
+    // PIL-L6 fix — Vietnamese bug-fix / CI-fail signals MUST land in `debug`.
+    // Same ordering rule as the English block: must precede the broad VN edit.
+    {
+        re: /(ci|build|test|action|workflow|pipeline|deploy(?:ment)?)\s*(đang|bị|là)?\s*(fail|fails|failed|failing|hỏng|hong|đỏ|do|broken|báo lỗi|bao loi)/i,
+        intent: "debug",
+        confidence: 0.85,
+        tierHint: "balanced",
+    },
+    {
+        re: /(sửa|fix|chỉnh)\s+(lại\s+)?(ci|build|test|action|workflow|pipeline|deploy|bug|lỗi|loi|crash|fail|broken|hỏng|hong)/i,
+        intent: "debug",
+        confidence: 0.85,
+        tierHint: "balanced",
+    },
+    // PIL-L6 v2 — same brain-trigger reasoning as the EN catch-all above.
+    // VN "fix cho tôi" / "sửa giúp" must NOT skip brain.
+    { re: /(sửa|fix|chỉnh|update|cập nhật|patch)\s+\S+/i, intent: "edit", confidence: 0.55, tierHint: "fast" },
     {
         re: /(chạy|run|thực thi)\s+(lệnh|command|script|test|build)/i,
         intent: "run-command",

package/dist/src/router/classifier/regex.test.js

@@ -15,7 +15,9 @@ describe("matchRegex", () => {
     describe("seed intents (>= 7 patterns at >= 0.55 confidence)", () => {
         const seeds = [
             { prompt: "create a file called app.ts", intent: "create-file" },
-            { prompt: "edit the main.ts file to fix the bug", intent: "edit" },
+            // PIL-L6 fix — "fix the bug" now correctly routes to debug, not edit.
+            // Use a pure-edit prompt without bug/error/fix-the-X cues here.
+            { prompt: "edit the main.ts file to change the layout", intent: "edit" },
             { prompt: "run the test command", intent: "run-command" },
             { prompt: "explain what this code does", intent: "explain" },
             { prompt: "refactor the auth module", intent: "refactor" },

package/dist/src/router/decide.d.ts

@@ -39,4 +39,22 @@ export declare function clearRouteCache(): void;
  * @param duration - Turn duration in ms (optional)
  */
 export declare function reportRouteOutcome(taskHash: string, outcome: RouteOutcome, duration?: number): void;
+/**
+ * Decide whether a user-configured role→model override should be honored.
+ *
+ * A role model is honored only when its provider is usable in the current
+ * session. Specifically a CROSS-provider role model (one whose provider differs
+ * from the user's active `defaultProvider`) is honored ONLY when the user
+ * explicitly opted into multi-provider council (`councilPreferMultiProvider`).
+ *
+ * Why: live observation showed a stale roleModel (left pointing at deepseek
+ * after the user switched their active provider to openai) silently routed the
+ * council/sprint role phases back to deepseek and failed mid-task with 402.
+ * Honoring only same-provider role models (unless multi-provider is on) keeps
+ * "I switched to provider X" meaning "everything uses X".
+ */
+export declare function shouldUseRoleModel(roleProvider: string, defaultProvider: string, opts: {
+    providerDisabled: boolean;
+    multiProviderPreferred: boolean;
+}): boolean;
 export declare function decide(prompt: string, opts: DecideOpts): Promise<RouteDecision>;

package/dist/src/router/decide.js

@@ -10,11 +10,11 @@ import { getModelByTier, getModelInfo, getModelsForProvider } from "../models/re
 import { taskTypeToRole } from "../pil/task-tier-map.js";
 import { detectProviderForModel } from "../providers/runtime.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
-import { DOWNGRADE_CHAIN, downgradeChain, emitDowngrade } from "../usage/downgrade.js";
+import { downgradeChain, emitDowngrade, getDowngradeChain } from "../usage/downgrade.js";
 import { release, reserve } from "../usage/ledger.js";
 import { midstreamPolicy } from "../usage/midstream.js";
 import { CapBreachError } from "../usage/types.js";
-import { getRoleModel, isProviderDisabled } from "../utils/settings.js";
+import { getRoleModel, isCouncilMultiProviderPreferred, isProviderDisabled } from "../utils/settings.js";
 import { classify } from "./classifier/index.js";
 import { callColdRoute } from "./cold.js";
 import { isInheritProvider } from "./provider-sentinel.js";
@@ -129,9 +129,17 @@ function resolveTierModel(tier, defaultProvider) {
 // ─── Provider constraint: never route to a provider the user lacks a key for ─
 function constrainToProvider(decision, opts) {
     // Inherit-sentinel: warm path may emit an empty provider to signal
-    // "trust upstream choice" — see PROVIDER_INHERIT in provider-sentinel.ts.
-    if (isInheritProvider(decision.provider))
+    // "trust upstream choice". Resolve the actual provider from the model ID
+    // so disabled-provider checks still apply.
+    if (isInheritProvider(decision.provider)) {
+        const resolved = detectProviderForModel(decision.model);
+        if (resolved && !isProviderDisabled(resolved))
+            return decision;
+        if (resolved && isProviderDisabled(resolved)) {
+            return constrainToProvider({ ...decision, provider: resolved }, opts);
+        }
         return decision;
+    }
     // Provider-only UX: the user enables N providers and pins one as default.
     // Routing rules:
     //   - decision.provider is enabled → keep it (router may switch across
@@ -193,7 +201,7 @@ export function reportRouteOutcome(taskHash, outcome, duration) {
 async function capCheck(dec, homeOverride) {
     let current = { ...dec };
     let attempts = 0;
-    while (attempts++ < DOWNGRADE_CHAIN.length) {
+    while (attempts++ < getDowngradeChain().length) {
         // If midstream policy already refuses, halt immediately
         if (midstreamPolicy.refuseNext()) {
             return {
@@ -250,6 +258,27 @@ async function capCheck(dec, homeOverride) {
         cap_overridden: true,
     };
 }
+/**
+ * Decide whether a user-configured role→model override should be honored.
+ *
+ * A role model is honored only when its provider is usable in the current
+ * session. Specifically a CROSS-provider role model (one whose provider differs
+ * from the user's active `defaultProvider`) is honored ONLY when the user
+ * explicitly opted into multi-provider council (`councilPreferMultiProvider`).
+ *
+ * Why: live observation showed a stale roleModel (left pointing at deepseek
+ * after the user switched their active provider to openai) silently routed the
+ * council/sprint role phases back to deepseek and failed mid-task with 402.
+ * Honoring only same-provider role models (unless multi-provider is on) keeps
+ * "I switched to provider X" meaning "everything uses X".
+ */
+export function shouldUseRoleModel(roleProvider, defaultProvider, opts) {
+    if (opts.providerDisabled)
+        return false;
+    if (roleProvider !== defaultProvider && !opts.multiProviderPreferred)
+        return false;
+    return true;
+}
 export async function decide(prompt, opts) {
     const cacheKey = routeCacheKey(opts.pil);
     if (cacheKey) {
@@ -270,9 +299,12 @@ export async function decide(prompt, opts) {
     if (role) {
         const roleModelId = getRoleModel(role);
         if (roleModelId) {
-            const info = getModelInfo(roleModelId);
+            const _info = getModelInfo(roleModelId);
             const provider = detectProviderForModel(roleModelId);
-            if (!isProviderDisabled(provider)) {
+            if (shouldUseRoleModel(provider, opts.defaultProvider, {
+                providerDisabled: isProviderDisabled(provider),
+                multiProviderPreferred: isCouncilMultiProviderPreferred(),
+            })) {
                 const d = {
                     tier: "hot",
                     model: roleModelId,

package/dist/src/router/decide.test.js

@@ -1,7 +1,9 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { getTestModels, getTestProviders } from "../__test-helpers__/catalog-fixtures.js";
 import { startStubEEServer } from "../__test-stubs__/ee-server.js";
 import { createEEClient } from "../ee/client.js";
 import { setDefaultEEClient } from "../ee/intercept.js";
+import { loadCatalog } from "../models/registry.js";
 import { decide } from "./decide.js";
 import { routerStore } from "./store.js";
 // Mock bridge to always return null so tests go through HTTP path
@@ -12,16 +14,20 @@ vi.mock("../ee/bridge.js", () => ({
     getEmbeddingRaw: vi.fn().mockResolvedValue(null),
     routeTask: vi.fn().mockResolvedValue(null),
 }));
-const BASE_OPTS = {
-    tenantId: "default",
-    cwd: "/tmp",
-    defaultModel: "claude-sonnet-4-20250514",
-    defaultProvider: "anthropic",
-    threshold: 0.55,
-};
+let BASE_OPTS;
 describe("decide()", () => {
     let stub;
     beforeAll(async () => {
+        await loadCatalog();
+        const models = getTestModels();
+        const providers = getTestProviders();
+        BASE_OPTS = {
+            tenantId: "default",
+            cwd: "/tmp",
+            defaultModel: models.balanced,
+            defaultProvider: providers.default,
+            threshold: 0.55,
+        };
         stub = await startStubEEServer({
             routeModel: (_req) => ({
                 model: "qwen2.5-coder",
@@ -82,7 +88,7 @@ describe("decide()", () => {
         const deadStub = await startStubEEServer({});
         setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${deadStub.port}` }));
         const result = await decide("I need to analyze and restructure the payment processing module with proper error boundaries and retry logic across multiple services", BASE_OPTS);
-        expect(result.model).toBe("claude-sonnet-4-20250514");
+        expect(result.model).toBe(BASE_OPTS.defaultModel);
         expect(result.reason).toBe("fallback:ee-unreachable");
         setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
         await deadStub.stop();
@@ -98,6 +104,50 @@ describe("decide()", () => {
         await deadStub.stop();
     });
 });
+describe("provider constraint with PROVIDER_INHERIT", () => {
+    let stub;
+    beforeAll(async () => {
+        await loadCatalog();
+    });
+    afterAll(async () => {
+        await stub?.stop();
+        vi.restoreAllMocks();
+    });
+    beforeEach(() => {
+        routerStore.setState({
+            tier: "hot",
+            degraded: false,
+            lastDecision: null,
+            lastHealthCheckAtMs: 0,
+        });
+    });
+    it("constrains warm-path model when its provider is disabled", async () => {
+        stub = await startStubEEServer({
+            routeModel: () => ({
+                model: "claude-sonnet-4-6",
+                tier: "balanced",
+                confidence: 0.8,
+                reason: "ee-warm",
+                source: "brain",
+                taskHash: "test-hash",
+            }),
+        });
+        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
+        const settingsMod = await import("../utils/settings.js");
+        vi.spyOn(settingsMod, "isProviderDisabled").mockImplementation((p) => p === "anthropic");
+        const fallbackModel = getTestModels().fast;
+        const fallbackProvider = getTestProviders().default;
+        const result = await decide("I need to analyze and restructure the payment processing module with proper error boundaries and retry logic across multiple services", {
+            tenantId: "default",
+            cwd: "/tmp",
+            defaultModel: fallbackModel,
+            defaultProvider: fallbackProvider,
+            threshold: 0.55,
+        });
+        expect(result.model).not.toBe("claude-sonnet-4-6");
+        expect(result.reason).toContain("provider-constrained");
+    });
+});
 describe("routerStore", () => {
     it("exposes subscribe/getState/setState and emits on changes", () => {
         const changes = [];

package/dist/src/router/role-override.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/router/role-override.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { shouldUseRoleModel } from "./decide.js";
+/**
+ * Regression for the "stale roleModel after provider switch" failure observed
+ * live: user switched active provider to openai (gpt-5.4-mini) but their
+ * user-settings.roleModels still pointed at deepseek-v4-flash. The council /
+ * sprint role phases blindly honored the deepseek roleModel and failed
+ * mid-task with 402 Insufficient Balance. A cross-provider role model must only
+ * be honored when the user explicitly opted into multi-provider council.
+ */
+describe("shouldUseRoleModel", () => {
+    it("honors a role model whose provider matches the active provider", () => {
+        expect(shouldUseRoleModel("openai", "openai", { providerDisabled: false, multiProviderPreferred: false })).toBe(true);
+    });
+    it("SKIPS a cross-provider role model when multi-provider is OFF (stale after switch)", () => {
+        // roleModel resolves to deepseek but the user is now on openai, multi off.
+        expect(shouldUseRoleModel("deepseek", "openai", { providerDisabled: false, multiProviderPreferred: false })).toBe(false);
+    });
+    it("honors a cross-provider role model when multi-provider is ON (explicit opt-in)", () => {
+        expect(shouldUseRoleModel("deepseek", "openai", { providerDisabled: false, multiProviderPreferred: true })).toBe(true);
+    });
+    it("SKIPS when the role model provider is disabled, even if it matches", () => {
+        expect(shouldUseRoleModel("anthropic", "anthropic", { providerDisabled: true, multiProviderPreferred: true })).toBe(false);
+    });
+});
+//# sourceMappingURL=role-override.test.js.map

package/dist/src/router/step-router.js

@@ -71,7 +71,7 @@ export function getStepRouterConfig() {
  */
 export function decideStepRouting(phase1ModelId, defaultProvider, config) {
     const cfg = config ?? getStepRouterConfig();
-    const phase1Provider = detectProviderForModel(phase1ModelId);
+    const _phase1Provider = detectProviderForModel(phase1ModelId);
     if (!cfg.enabled) {
         return {
             phase1ModelId,

package/dist/src/router/warm.d.ts

@@ -4,4 +4,6 @@ export declare function callWarmRoute(prompt: string, opts: {
     cwd: string;
     signal?: AbortSignal;
     context?: Record<string, unknown>;
+    /** Active session provider — derives the EE runtime + catalog fallback. */
+    defaultProvider?: string;
 }): Promise<RouteDecision | null>;

package/dist/src/router/warm.js

@@ -6,22 +6,52 @@
  */
 import { routeModel as bridgeRouteModel } from "../ee/bridge.js";
 import { getDefaultEEClient } from "../ee/intercept.js";
-import { detectProviderForModel } from "../providers/runtime.js";
+import { getModelByTier } from "../models/registry.js";
 import { PROVIDER_INHERIT } from "./provider-sentinel.js";
+/**
+ * Map the session's provider to the EE runtime whose tier ladder the EE serves.
+ * EE keys its `getModelTiers()` ladders by agent runtime, not provider, and only
+ * the catalog-backed runtimes (claude/codex/gemini) resolve to a non-null model.
+ * Providers without an EE runtime (deepseek/siliconflow/xai) map to "" — EE then
+ * returns the routing TIER with a null model and we resolve the concrete model
+ * from the shared catalog for the session provider. This removes the old
+ * hardcoded `runtime:"claude"`, which leaked EE's stale `claude-*` ids into the
+ * CLI for every session regardless of the active provider.
+ */
+const PROVIDER_TO_EE_RUNTIME = Object.freeze({
+    anthropic: "claude",
+    openai: "codex",
+    google: "gemini",
+});
+function eeRuntimeForProvider(provider) {
+    return (provider && PROVIDER_TO_EE_RUNTIME[provider]) || "";
+}
+const TIER_TO_CATALOG_TIER = { fast: "fast", balanced: "balanced", premium: "premium" };
 export async function callWarmRoute(prompt, opts) {
     // ── Bridge cascade: try in-process first (~5ms) before HTTP (~250ms) ──
-    const bridgeResult = await bridgeRouteModel(prompt, opts.context ?? {}, "claude");
+    // Runtime is derived from the session provider, NOT hardcoded to "claude".
+    const runtime = eeRuntimeForProvider(opts.defaultProvider);
+    const bridgeResult = await bridgeRouteModel(prompt, opts.context ?? {}, runtime);
     if (bridgeResult) {
-        return {
-            tier: bridgeResult.tier === "fast" ? "hot" : bridgeResult.tier === "premium" ? "cold" : "warm",
-            model: bridgeResult.model,
-            provider: detectProviderForModel(bridgeResult.model),
-            reason: `warm:bridge:${bridgeResult.reason}`,
-            confidence: bridgeResult.confidence,
-            taskHash: bridgeResult.taskHash ?? undefined,
-            source: bridgeResult.source,
-            reasoningEffort: bridgeResult.reasoningEffort,
-        };
+        // EE returns a model only for catalog-backed runtimes; otherwise resolve the
+        // concrete model from the catalog for the session provider + decided tier.
+        const catalogTier = TIER_TO_CATALOG_TIER[bridgeResult.tier] ?? "balanced";
+        const model = bridgeResult.model || getModelByTier(catalogTier, opts.defaultProvider)?.id;
+        if (model) {
+            return {
+                tier: bridgeResult.tier === "fast" ? "hot" : bridgeResult.tier === "premium" ? "cold" : "warm",
+                model,
+                // Unify with the HTTP path on PROVIDER_INHERIT: let constrainToProvider()
+                // resolve the provider from the model and apply the disabled-provider
+                // policy uniformly, instead of pinning a concrete provider here.
+                provider: PROVIDER_INHERIT,
+                reason: `warm:bridge:${bridgeResult.reason}`,
+                confidence: bridgeResult.confidence,
+                taskHash: bridgeResult.taskHash ?? undefined,
+                source: bridgeResult.source,
+                reasoningEffort: bridgeResult.reasoningEffort,
+            };
+        }
     }
     // ── HTTP fallback: EE server route-model endpoint ──
     const r = await getDefaultEEClient().routeModel({ task: prompt, tenantId: opts.tenantId, cwd: opts.cwd, context: opts.context }, opts.signal);