muonroi-cli 1.4.0 → 1.5.0

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

@@ -1,37 +0,0 @@
-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,
-    );
-  });
-});

package/src/router/step-router.ts

@@ -1,194 +0,0 @@
-/**
- * Step-Aware Model Routing (SAMR)
- *
- * Downgrades the model for tool-execution steps within a single turn.
- * The insight: once the premium model decides WHAT to do (expressed as
- * tool calls in step 0), the remaining work is mechanical — reading
- * tool results, calling more tools, producing the final response.
- * A fast model handles this equally well at a fraction of the cost.
- *
- * Architecture:
- *   Phase 1 (Reasoning): Premium/balanced model, max 1 step
- *     → model thinks, plans, decides on tool calls
- *   Phase 2 (Execution): Fast model, remaining steps
- *     → reads tool results, calls more tools if needed, produces final output
- *
- * DISABLED BY DEFAULT until Phase1→Phase2 transition has soak time + an
- * integration test covering: (a) SDK does not re-emit pending tool_calls on
- * Phase 2 entry, (b) provider-switch keeps tool schema compatible,
- * (c) abort/error during Phase 1 does not strand pending tool_calls.
- * Opt-in via user-settings.json:
- *   "stepRouter": {
- *     "enabled": true,
- *     "toolExecutionTier": "fast",     // "fast" | "balanced"
- *     "premiumSynthesis": false        // switch back to premium for final response
- *   }
- */
-
-import { getModelByTier } from "../models/registry.js";
-import { detectProviderForModel } from "../providers/runtime.js";
-import type { ProviderId } from "../providers/types.js";
-import type { ModelInfo } from "../types/index.js";
-import { isModelDisabled, isProviderDisabled, loadUserSettings } from "../utils/settings.js";
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface StepRouterConfig {
-  /** Whether step-aware routing is enabled. Default: true. */
-  enabled: boolean;
-  /** Tier to use for tool-execution steps (1..N). Default: "fast". */
-  toolExecutionTier: "fast" | "balanced";
-  /** If true, switch back to the original premium model for the very last
-   *  synthesis step (after all tool calls complete). Default: false.
-   *  When false, the fast model produces the final response — which is
-   *  usually good enough and saves an extra API call. */
-  premiumSynthesis: boolean;
-}
-
-export interface StepRouterDecision {
-  /** Model ID for Phase 1 (reasoning / step 0). */
-  phase1ModelId: string;
-  /** Model ID for Phase 2 (execution / steps 1..N).
-   *  null means step routing is not applicable — fall back to single-model. */
-  phase2ModelId: string | null;
-  /** Human-readable reason for the decision. */
-  reason: string;
-}
-
-// ─── Defaults ────────────────────────────────────────────────────────────────
-
-const DEFAULT_CONFIG: StepRouterConfig = {
-  enabled: false,
-  toolExecutionTier: "fast",
-  premiumSynthesis: false,
-};
-
-// ─── Config loader ───────────────────────────────────────────────────────────
-
-/**
- * Double-opt-in: SAMR requires BOTH `stepRouter.enabled=true` in user-settings
- * AND the env var `MUONROI_STEP_ROUTER_ACK=1`. The env var is the user's
- * acknowledgement that they've read the SDK-compatibility caveats in the
- * module docstring (a/b/c conditions). Without it, enabled silently degrades
- * to false and a one-time warning is printed.
- */
-const SAMR_ACK_ENV = "MUONROI_STEP_ROUTER_ACK";
-let _samrWarnedOnce = false;
-
-export function getStepRouterConfig(): StepRouterConfig {
-  const raw = loadUserSettings().stepRouter;
-  if (!raw) return { ...DEFAULT_CONFIG };
-  const userWantsEnabled = raw.enabled ?? DEFAULT_CONFIG.enabled;
-  const ack = process.env[SAMR_ACK_ENV] === "1";
-  if (userWantsEnabled && !ack && !_samrWarnedOnce) {
-    _samrWarnedOnce = true;
-    console.warn(
-      `[step-router] stepRouter.enabled=true ignored: set ${SAMR_ACK_ENV}=1 to acknowledge SDK-compatibility caveats (see src/router/step-router.ts header).`,
-    );
-  }
-  return {
-    enabled: userWantsEnabled && ack,
-    toolExecutionTier: raw.toolExecutionTier ?? DEFAULT_CONFIG.toolExecutionTier,
-    premiumSynthesis: raw.premiumSynthesis ?? DEFAULT_CONFIG.premiumSynthesis,
-  };
-}
-
-// ─── Decision engine ─────────────────────────────────────────────────────────
-
-/**
- * Decide whether to split the turn into two model phases.
- *
- * Returns phase2ModelId=null when step routing is NOT applicable:
- *   - Config disabled
- *   - Execution model is the same as phase 1 model (no benefit)
- *   - No fast model available for the provider
- *   - Execution model's provider is disabled or unreachable
- */
-export function decideStepRouting(
-  phase1ModelId: string,
-  defaultProvider: string,
-  config?: StepRouterConfig,
-): StepRouterDecision {
-  const cfg = config ?? getStepRouterConfig();
-  const _phase1Provider = detectProviderForModel(phase1ModelId);
-
-  if (!cfg.enabled) {
-    return {
-      phase1ModelId,
-      phase2ModelId: null,
-      reason: "step-router disabled",
-    };
-  }
-
-  // Find the cheapest model for the execution provider.
-  // Prefer same provider as phase 1 to keep keychain simple.
-  const execModel = resolveExecutionModel(defaultProvider, cfg.toolExecutionTier, phase1ModelId);
-
-  if (!execModel) {
-    return {
-      phase1ModelId,
-      phase2ModelId: null,
-      reason: `no ${cfg.toolExecutionTier} model available for provider ${defaultProvider}`,
-    };
-  }
-
-  if (execModel.id === phase1ModelId) {
-    return {
-      phase1ModelId,
-      phase2ModelId: null,
-      reason: `phase 1 model is already ${cfg.toolExecutionTier} tier — no downgrade needed`,
-    };
-  }
-
-  // Verify the execution model's provider is reachable
-  const execProvider = execModel.provider as ProviderId;
-  if (isProviderDisabled(execProvider)) {
-    return {
-      phase1ModelId,
-      phase2ModelId: null,
-      reason: `execution model provider ${execProvider} is disabled`,
-    };
-  }
-
-  return {
-    phase1ModelId,
-    phase2ModelId: execModel.id,
-    reason: `${phase1ModelId} (${getModelTier(phase1ModelId)}) → ${execModel.id} (${cfg.toolExecutionTier}) for tool execution steps`,
-  };
-}
-
-// ─── Internal helpers ────────────────────────────────────────────────────────
-
-function resolveExecutionModel(
-  provider: string,
-  tier: "fast" | "balanced",
-  excludeModelId: string,
-): ModelInfo | undefined {
-  // Try same provider first
-  const sameProvider = getModelByTier(tier, provider);
-  if (sameProvider && sameProvider.id !== excludeModelId) {
-    // Guard: check provider-disabled and model-disabled (mirrors cross-provider branch)
-    if (!isProviderDisabled(sameProvider.provider as ProviderId) && !isModelDisabled(sameProvider.id)) {
-      return sameProvider;
-    }
-  }
-  // If no same-provider model in this tier, try any provider
-  const anyProvider = getModelByTier(tier);
-  if (anyProvider && anyProvider.id !== excludeModelId) {
-    // Only use cross-provider if the provider and model aren't disabled
-    if (!isProviderDisabled(anyProvider.provider as ProviderId) && !isModelDisabled(anyProvider.id)) {
-      return anyProvider;
-    }
-  }
-  return undefined;
-}
-
-function getModelTier(modelId: string): string {
-  return getModelByTier("fast")?.id === modelId
-    ? "fast"
-    : getModelByTier("balanced")?.id === modelId
-      ? "balanced"
-      : getModelByTier("premium")?.id === modelId
-        ? "premium"
-        : "unknown";
-}

package/src/router/store.ts

@@ -1,47 +0,0 @@
-/**
- * Subscribable router state atom (Zustand-like, zero deps).
- *
- * Holds current tier, degraded flag, and last routing decision.
- * Plan 06 status bar subscribes to this store.
- */
-import type { RouteDecision, Tier } from "./types.js";
-
-export interface RouterState {
-  tier: Tier;
-  degraded: boolean;
-  lastDecision: RouteDecision | null;
-  lastHealthCheckAtMs: number;
-  /** taskHash from the last EE routing decision (for feedback loop). */
-  taskHash: string | null;
-  /** source of the last routing decision (e.g. "keyword", "history", "brain"). */
-  source: string | null;
-}
-
-type Listener = (s: RouterState) => void;
-
-function makeStore() {
-  let state: RouterState = {
-    tier: "hot",
-    degraded: false,
-    lastDecision: null,
-    lastHealthCheckAtMs: 0,
-    taskHash: null,
-    source: null,
-  };
-  const listeners = new Set<Listener>();
-  return {
-    getState: () => state,
-    setState: (patch: Partial<RouterState>) => {
-      state = { ...state, ...patch };
-      for (const l of listeners) l(state);
-    },
-    subscribe: (fn: Listener) => {
-      listeners.add(fn);
-      return () => {
-        listeners.delete(fn);
-      };
-    },
-  };
-}
-
-export const routerStore = makeStore();

package/src/router/types.ts

@@ -1,20 +0,0 @@
-export type Tier = "hot" | "warm" | "cold" | "degraded";
-
-export interface ClassifierResult {
-  tier: "hot" | "abstain";
-  confidence: number; // 0..1
-  reason: string; // 'regex:create-file' | 'tree-sitter:typescript' | 'low-confidence' etc
-  tierHint?: "fast" | "balanced" | "premium";
-}
-
-export interface RouteDecision {
-  tier: Tier;
-  model: string;
-  provider: string; // ProviderId -- kept loose to avoid circular import
-  reason: string;
-  confidence?: number;
-  cap_overridden?: boolean;
-  taskHash?: string;
-  source?: string;
-  reasoningEffort?: "low" | "medium" | "high";
-}

package/src/router/warm.test.ts

@@ -1,234 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { type StubHandle, startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient } from "../ee/client.js";
-import { setDefaultEEClient } from "../ee/intercept.js";
-import { getModelByTier, loadCatalog } from "../models/registry.js";
-import { callWarmRoute } from "./warm.js";
-
-// ─── Bridge cascade tests ────────────────────────────────────────────────────
-
-vi.mock("../ee/bridge.js", () => ({
-  routeModel: vi.fn(),
-}));
-
-import { routeModel as bridgeRouteModel } from "../ee/bridge.js";
-
-const mockBridgeRouteModel = vi.mocked(bridgeRouteModel);
-
-describe("callWarmRoute bridge cascade", () => {
-  let stub: StubHandle;
-
-  beforeAll(async () => {
-    stub = await startStubEEServer({
-      routeModel: (_req) => ({
-        model: "qwen2.5-coder",
-        tier: "balanced" as const,
-        confidence: 0.7,
-        reason: "remote",
-        source: "brain",
-        taskHash: "http-hash",
-      }),
-    });
-  });
-
-  beforeEach(() => {
-    // Re-pin the global EE client before each test so the second describe
-    // block's beforeAll cannot leave a stale client pointing at a different port.
-    setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-  });
-
-  afterAll(async () => {
-    await stub.stop();
-  });
-
-  afterEach(() => {
-    mockBridgeRouteModel.mockReset();
-  });
-
-  it("returns bridge result without calling HTTP when bridge succeeds", async () => {
-    mockBridgeRouteModel.mockResolvedValue({
-      tier: "balanced",
-      model: "deepseek-v4-flash",
-      reasoningEffort: "medium",
-      confidence: 0.95,
-      source: "brain",
-      reason: "bridge-match",
-      taskHash: "bridge-hash",
-    });
-
-    const result = await callWarmRoute("write a function", {
-      tenantId: "default",
-      cwd: "/tmp",
-    });
-
-    expect(result).not.toBeNull();
-    expect(result!.model).toBe("deepseek-v4-flash");
-    expect(result!.reason).toMatch(/^warm:bridge:/);
-    expect(result!.confidence).toBe(0.95);
-    expect(result!.taskHash).toBe("bridge-hash");
-    expect(result!.source).toBe("brain");
-    expect(result!.reasoningEffort).toBe("medium");
-  });
-
-  it("falls through to HTTP when bridge returns null", async () => {
-    mockBridgeRouteModel.mockResolvedValue(null);
-
-    const result = await callWarmRoute("write a function", {
-      tenantId: "default",
-      cwd: "/tmp",
-    });
-
-    expect(result).not.toBeNull();
-    expect(result!.model).toBe("qwen2.5-coder"); // HTTP stub model
-    expect(result!.reason).toMatch(/^warm:/);
-    expect(result!.reason).not.toMatch(/^warm:bridge:/);
-    expect(result!.taskHash).toBe("http-hash");
-  });
-
-  it("derives the EE runtime from the session provider (not hardcoded 'claude')", async () => {
-    mockBridgeRouteModel.mockResolvedValue({
-      tier: "balanced",
-      model: "gpt-5.3-codex",
-      confidence: 0.9,
-      source: "brain",
-      reason: "x",
-      taskHash: null,
-    });
-
-    await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "openai" });
-    expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("codex");
-
-    await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "google" });
-    expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("gemini");
-
-    await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "anthropic" });
-    expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("claude");
-
-    // Providers without an EE runtime ladder pass "" so EE returns tier only.
-    await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "deepseek" });
-    expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("");
-  });
-
-  it("emits PROVIDER_INHERIT on the bridge path so constrainToProvider governs", async () => {
-    mockBridgeRouteModel.mockResolvedValue({
-      tier: "balanced",
-      model: "gpt-5.3-codex",
-      confidence: 0.9,
-      source: "brain",
-      reason: "x",
-      taskHash: null,
-    });
-    const result = await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "openai" });
-    expect(result!.provider).toBe(""); // PROVIDER_INHERIT
-  });
-
-  it("falls back to the catalog model when EE returns a null model (no EE runtime)", async () => {
-    await loadCatalog();
-    const fastDeepseek = getModelByTier("fast", "deepseek");
-    // Skip gracefully if the test catalog has no deepseek-fast entry.
-    if (!fastDeepseek) return;
-    mockBridgeRouteModel.mockResolvedValue({
-      // EE returns the tier but a null model for a runtime it cannot resolve.
-      tier: "fast",
-      model: null as unknown as string,
-      confidence: 0.8,
-      source: "keyword",
-      reason: "fast complexity",
-      taskHash: null,
-    });
-    const result = await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "deepseek" });
-    expect(result).not.toBeNull();
-    expect(result!.model).toBe(fastDeepseek.id);
-    expect(result!.provider).toBe(""); // still PROVIDER_INHERIT
-  });
-
-  it("maps bridge tier 'fast' to 'hot' and 'premium' to 'cold'", async () => {
-    mockBridgeRouteModel.mockResolvedValue({
-      tier: "fast",
-      model: "gpt-4o-mini",
-      confidence: 0.9,
-      source: "brain",
-      reason: "fast-task",
-      taskHash: null,
-    });
-
-    const fast = await callWarmRoute("quick task", { tenantId: "default", cwd: "/tmp" });
-    expect(fast!.tier).toBe("hot");
-
-    mockBridgeRouteModel.mockResolvedValue({
-      tier: "premium",
-      model: "o1-pro",
-      confidence: 0.85,
-      source: "brain",
-      reason: "complex-task",
-      taskHash: null,
-    });
-
-    const premium = await callWarmRoute("complex analysis", { tenantId: "default", cwd: "/tmp" });
-    expect(premium!.tier).toBe("cold");
-  });
-});
-
-describe("callWarmRoute", () => {
-  let stub: StubHandle;
-
-  beforeAll(async () => {
-    stub = await startStubEEServer({
-      routeModel: (_req) => ({
-        model: "qwen2.5-coder",
-        tier: "balanced" as const,
-        confidence: 0.7,
-        reason: "remote",
-        source: "brain",
-        taskHash: "test-hash",
-      }),
-    });
-  });
-
-  beforeEach(() => {
-    setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-  });
-
-  afterAll(async () => {
-    await stub.stop();
-  });
-
-  it("returns RouteDecision when stub responds successfully", async () => {
-    const result = await callWarmRoute("write a function", {
-      tenantId: "default",
-      cwd: "/tmp",
-    });
-    expect(result).not.toBeNull();
-    expect(result!.tier).toBe("warm");
-    expect(result!.model).toBe("qwen2.5-coder");
-    expect(result!.provider).toBe("");
-    expect(result!.reason).toContain("warm:");
-    expect(result!.confidence).toBe(0.7);
-  });
-
-  it("returns null when warm path times out (>250ms)", async () => {
-    // Create a slow stub
-    const slowStub = await startStubEEServer({
-      latencyMs: 500,
-      routeModel: () => ({
-        model: "qwen2.5-coder",
-        tier: "balanced" as const,
-        confidence: 0.7,
-        reason: "remote",
-        source: "brain",
-        taskHash: "test-hash",
-      }),
-    });
-    setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${slowStub.port}` }));
-
-    const result = await callWarmRoute("write a function", {
-      tenantId: "default",
-      cwd: "/tmp",
-    });
-    expect(result).toBeNull();
-
-    // Restore original stub
-    setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-    await slowStub.stop();
-  });
-});

package/src/router/warm.ts

@@ -1,93 +0,0 @@
-/**
- * Warm-path router tier.
- *
- * Calls EE /api/route-model with a hard 250ms timeout.
- * Returns null on timeout/5xx/network error (graceful degradation).
- */
-import { routeModel as bridgeRouteModel } from "../ee/bridge.js";
-import { getDefaultEEClient } from "../ee/intercept.js";
-import { getModelByTier } from "../models/registry.js";
-import { PROVIDER_INHERIT } from "./provider-sentinel.js";
-import type { RouteDecision } from "./types.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: Readonly<Record<string, string>> = Object.freeze({
-  anthropic: "claude",
-  openai: "codex",
-  google: "gemini",
-});
-
-function eeRuntimeForProvider(provider: string | undefined): string {
-  return (provider && PROVIDER_TO_EE_RUNTIME[provider]) || "";
-}
-
-const TIER_TO_CATALOG_TIER = { fast: "fast", balanced: "balanced", premium: "premium" } as const;
-
-export async function callWarmRoute(
-  prompt: string,
-  opts: {
-    tenantId: string;
-    cwd: string;
-    signal?: AbortSignal;
-    context?: Record<string, unknown>;
-    /** Active session provider — derives the EE runtime + catalog fallback. */
-    defaultProvider?: string;
-  },
-): Promise<RouteDecision | null> {
-  // ── Bridge cascade: try in-process first (~5ms) before HTTP (~250ms) ──
-  // 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) {
-    // 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 as keyof typeof TIER_TO_CATALOG_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 as RouteDecision["reasoningEffort"],
-      };
-    }
-  }
-
-  // ── HTTP fallback: EE server route-model endpoint ──
-  const r = await getDefaultEEClient().routeModel(
-    { task: prompt, tenantId: opts.tenantId, cwd: opts.cwd, context: opts.context as never },
-    opts.signal,
-  );
-  if (!r) return null;
-  return {
-    tier: r.tier === "fast" ? "hot" : r.tier === "premium" ? "cold" : "warm",
-    model: r.model,
-    // PROVIDER_INHERIT signals constrainToProvider() to leave the EE's
-    // model choice intact rather than re-routing it to the session default
-    // provider. Populating this would silently override warm decisions
-    // whenever EE picks a different provider than the session
-    // (see src/router/warm.test.ts:137 and src/router/decide.test.ts:64).
-    provider: PROVIDER_INHERIT,
-    reason: `warm:${r.reason}`,
-    confidence: r.confidence,
-    taskHash: r.taskHash,
-    source: r.source,
-    reasoningEffort: r.reasoningEffort,
-  };
-}