muonroi-cli 1.3.4 → 1.4.1

package/src/providers/vision-proxy.ts

@@ -1,317 +0,0 @@
-/**
- * Vision proxy layer for text-only models (e.g. DeepSeek V4).
- *
- * When the active model does not support vision, image parts in the message
- * are extracted, sent to a cheap vision model on SiliconFlow
- * (Qwen/Qwen2.5-VL-32B-Instruct @ $0.27/M tokens), and replaced with
- * structured text descriptions before the message reaches the primary model.
- */
-
-import type { ModelMessage } from "ai";
-import { getModelInfo } from "../models/registry.js";
-import { apiBaseFor } from "./endpoints.js";
-import { loadKeyForProvider } from "./keychain.js";
-import { UI_LAYOUT_SCHEMA_HINT } from "./mcp-vision-bridge.js";
-
-const DESIGN_INTENT_PATTERNS = [
-  /\bredesign\b/i,
-  /\bdesign\s*(system|token|spec|review)?\b/i,
-  /\bui\s*(layout|kit|spec|design)\b/i,
-  /\blayout\b/i,
-  /\bmockup\b/i,
-  /\bwireframe\b/i,
-  /\bfigma\b/i,
-  /\bcomponent\s*(library|spec|map)\b/i,
-  /thiết\s*kế|giao\s*diện|bố\s*cục|redesign/i,
-];
-
-function looksLikeDesignIntent(text: string): boolean {
-  if (!text) return false;
-  return DESIGN_INTENT_PATTERNS.some((re) => re.test(text));
-}
-
-const VISION_MODELS = [
-  "Qwen/Qwen3-VL-8B-Instruct",
-  "Qwen/Qwen3-VL-30B-A3B-Instruct",
-  "Qwen/Qwen3-VL-32B-Instruct",
-] as const;
-const SILICONFLOW_BASE = apiBaseFor("siliconflow");
-const REQUEST_TIMEOUT_MS = 90_000;
-
-interface ImagePart {
-  type: "image";
-  image: string; // base64
-  mediaType: string;
-}
-
-interface TextPart {
-  type: "text";
-  text: string;
-}
-
-type ContentPart = TextPart | ImagePart;
-
-export interface VisionProxyResult {
-  messages: ModelMessage[];
-  proxied: boolean;
-  imageCount: number;
-}
-
-/**
- * Returns true when the model cannot handle image content natively.
- */
-export function needsVisionProxy(modelId: string): boolean {
-  const info = getModelInfo(modelId);
-  return info?.supportsVision === false;
-}
-
-/**
- * Process messages through the vision proxy.
- * Only messages with image parts are modified; text-only messages pass through.
- */
-export async function proxyVision(
-  messages: ModelMessage[],
-  modelId: string,
-  signal?: AbortSignal,
-): Promise<VisionProxyResult> {
-  if (!needsVisionProxy(modelId)) {
-    return { messages, proxied: false, imageCount: 0 };
-  }
-
-  let totalImages = 0;
-  const processed: ModelMessage[] = [];
-
-  for (const msg of messages) {
-    if (msg.role !== "user" || typeof msg.content === "string") {
-      processed.push(msg);
-      continue;
-    }
-
-    const parts = msg.content as ContentPart[];
-    const hasImages = parts.some((p) => p.type === "image");
-    if (!hasImages) {
-      processed.push(msg);
-      continue;
-    }
-
-    const imageParts = parts.filter((p): p is ImagePart => p.type === "image");
-    const textParts = parts.filter((p): p is TextPart => p.type === "text");
-    totalImages += imageParts.length;
-
-    const userText = textParts.map((t) => t.text).join("\n");
-    const designIntent = looksLikeDesignIntent(userText);
-
-    const svgFast = trySvgFastPath(imageParts, designIntent);
-    if (svgFast) {
-      processed.push({
-        ...msg,
-        content: [...textParts, { type: "text" as const, text: svgFast }],
-      });
-      continue;
-    }
-
-    const descriptions = await describeImages(imageParts, textParts, signal, designIntent);
-
-    const newContent = [...textParts, { type: "text" as const, text: descriptions }];
-    processed.push({ ...msg, content: newContent });
-  }
-
-  return { messages: processed, proxied: totalImages > 0, imageCount: totalImages };
-}
-
-async function describeImages(
-  images: ImagePart[],
-  contextTexts: TextPart[],
-  signal?: AbortSignal,
-  designIntent = false,
-): Promise<string> {
-  let apiKey: string;
-  try {
-    apiKey = await loadKeyForProvider("siliconflow");
-  } catch {
-    return buildFallbackDescription(images, ["SILICONFLOW_API_KEY not configured"]);
-  }
-
-  const userContext = contextTexts.map((t) => t.text).join("\n");
-
-  const visionContent: Array<Record<string, unknown>> = [];
-  visionContent.push({
-    type: "text",
-    text: designIntent
-      ? buildDesignPrompt(userContext, images.length)
-      : buildAnalysisPrompt(userContext, images.length),
-  });
-
-  for (const img of images) {
-    visionContent.push({
-      type: "image_url",
-      image_url: {
-        url: `data:${img.mediaType};base64,${img.image}`,
-        detail: "high",
-      },
-    });
-  }
-
-  const responseFormat = designIntent ? { type: "json_object" as const } : undefined;
-
-  const failureReasons: string[] = [];
-  for (const model of VISION_MODELS) {
-    try {
-      const result = await callVisionModel(model, visionContent, apiKey, signal, responseFormat);
-      if (result.ok) return formatVisionResult(result.text, images.length, model, designIntent);
-      failureReasons.push(`${model}: ${result.reason}`);
-      console.warn(`[vision-proxy] ${model} failed (${result.reason}), trying next...`);
-    } catch (err) {
-      if (signal?.aborted) throw err;
-      const msg = err instanceof Error ? err.message : String(err);
-      failureReasons.push(`${model}: ${msg}`);
-      console.warn(`[vision-proxy] ${model} threw (${msg}), trying next...`);
-    }
-  }
-
-  return buildFallbackDescription(images, failureReasons);
-}
-
-function trySvgFastPath(images: ImagePart[], designIntent: boolean): string | null {
-  if (images.length === 0) return null;
-  if (!images.every((img) => img.mediaType === "image/svg+xml")) return null;
-
-  const decoded = images
-    .map((img, idx) => {
-      let svg: string;
-      try {
-        svg = Buffer.from(img.image, "base64").toString("utf8");
-      } catch {
-        return `<!-- svg ${idx + 1}: decode failed -->`;
-      }
-      return svg.length > 32_000 ? `${svg.slice(0, 32_000)}\n<!-- truncated -->` : svg;
-    })
-    .join("\n\n");
-
-  const header = `[Vision Proxy — ${images.length} SVG source(s) passed through (fast-path, no vision call)]`;
-  const guidance = designIntent
-    ? `\nThe raw SVG below IS the layout contract. Map nodes to:\n${UI_LAYOUT_SCHEMA_HINT}\n`
-    : "\nThe raw SVG below is vector text — read element attributes (x, y, width, fill, text content) directly.\n";
-  return `\n${header}${guidance}\n\`\`\`svg\n${decoded}\n\`\`\`\n[/Vision Proxy]\n`;
-}
-
-type VisionCallResult = { ok: true; text: string } | { ok: false; reason: string };
-
-async function callVisionModel(
-  model: string,
-  content: Array<Record<string, unknown>>,
-  apiKey: string,
-  signal?: AbortSignal,
-  responseFormat?: { type: "json_object" },
-): Promise<VisionCallResult> {
-  const controller = new AbortController();
-  let timedOut = false;
-  const timeout = setTimeout(() => {
-    timedOut = true;
-    controller.abort();
-  }, REQUEST_TIMEOUT_MS);
-
-  if (signal) {
-    signal.addEventListener("abort", () => controller.abort(), { once: true });
-  }
-
-  let res: Response;
-  try {
-    res = await fetch(`${SILICONFLOW_BASE}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify({
-        model,
-        messages: [{ role: "user", content }],
-        max_tokens: 3072,
-        temperature: 0.1,
-        ...(responseFormat ? { response_format: responseFormat } : {}),
-      }),
-      signal: controller.signal,
-    });
-  } catch (err) {
-    clearTimeout(timeout);
-    if (timedOut) return { ok: false, reason: `timeout after ${REQUEST_TIMEOUT_MS}ms` };
-    if (signal?.aborted) throw err;
-    return { ok: false, reason: `network error: ${err instanceof Error ? err.message : String(err)}` };
-  }
-
-  clearTimeout(timeout);
-
-  if (!res.ok) {
-    const errText = await res.text().catch(() => "unknown error");
-    return { ok: false, reason: `HTTP ${res.status} ${errText.slice(0, 200)}` };
-  }
-
-  const data = (await res.json().catch(() => null)) as { choices?: Array<{ message?: { content?: string } }> } | null;
-  const text = data?.choices?.[0]?.message?.content;
-  if (!text) return { ok: false, reason: "empty response body" };
-  return { ok: true, text };
-}
-
-function buildAnalysisPrompt(userContext: string, imageCount: number): string {
-  const plural = imageCount > 1 ? `${imageCount} images` : "the image";
-  return [
-    `You are a vision model. Analyze ${plural} for a software developer working in a coding CLI tool.`,
-    "Use your full vision capability — do NOT refuse on the basis of being text-only.",
-    "Focus on:",
-    "- UI layout and component structure (if screenshot)",
-    "- All visible text, labels, buttons, and form elements",
-    "- Colors, spacing, and visual hierarchy",
-    "- Code visible in the image (transcribe exactly)",
-    "- Error messages, console output, or terminal content",
-    "- Any diagram, flowchart, or architectural sketch",
-    "",
-    "Be precise and structured. Use markdown formatting.",
-    userContext ? `\nDeveloper's context: "${userContext}"` : "",
-  ].join("\n");
-}
-
-function formatVisionResult(description: string, imageCount: number, model?: string, designIntent = false): string {
-  const usedModel = model ?? VISION_MODELS[0];
-  const tag = designIntent ? "design contract via" : "analyzed via";
-  const single = designIntent ? "design contract via" : "analyzed via";
-  const header =
-    imageCount > 1
-      ? `[Vision Proxy — ${imageCount} images ${tag} ${usedModel}]`
-      : `[Vision Proxy — image ${single} ${usedModel}]`;
-  return `\n${header}\n${description}\n[/Vision Proxy]\n`;
-}
-
-function buildDesignPrompt(userContext: string, imageCount: number): string {
-  const plural = imageCount > 1 ? `${imageCount} images` : "the image";
-  return [
-    `Analyze ${plural} as a UI/UX design contract for a software developer who CANNOT see the image.`,
-    "Output will be consumed by another AI agent to recreate or redesign this UI, so precision matters more than prose.",
-    "",
-    "Return ONLY a single JSON object matching this exact shape (no markdown, no commentary, no code fences):",
-    UI_LAYOUT_SCHEMA_HINT,
-    "",
-    "Extraction rules:",
-    "- bbox: pixel coordinates relative to the visible image (origin top-left). Estimate when unsure but never omit.",
-    "- Colors: 6-digit lowercase hex (#rrggbb). Sample dominant pixel.",
-    "- Typography sizePx: estimate from cap-height, round to nearest 2.",
-    "- spacingScalePx / radiusScalePx: distinct observed values, sorted ascending.",
-    "- components[]: every visible interactive or content element. Stable IDs like 'btn_signup'.",
-    "- children[]: component IDs nested inside this component.",
-    "- hierarchy[]: visual reading order of headings — level 1 hero, 2 section, 3 sub.",
-    "- text: EXACT visible string. null only when no text (icon-only).",
-    "- notes[]: things schema cannot capture — gradients, illustrations, motion.",
-    "",
-    "If a field is genuinely not determinable, use null. Never invent values.",
-    userContext ? `\nDeveloper's context: "${userContext}"` : "",
-  ].join("\n");
-}
-
-function buildFallbackDescription(images: ImagePart[], reasons: string[] = []): string {
-  const count = images.length;
-  const types = [...new Set(images.map((i) => i.mediaType))].join(", ");
-  const detail =
-    reasons.length > 0
-      ? `Reason(s): ${reasons.join(" | ")}`
-      : "Reason: unknown — check SILICONFLOW_API_KEY and model availability.";
-  return `\n[Vision Proxy — unavailable, ${count} image(s) (${types}) could not be analyzed. ${detail}]\n`;
-}

package/src/providers/wire-debug.ts

@@ -1,163 +0,0 @@
-/**
- * src/providers/wire-debug.ts
- *
- * Optional deep wire-level logging of LLM provider traffic. Disabled unless
- * MUONROI_DEBUG_LLM_WIRE=1 is set. Used to capture evidence (message shape,
- * stream chunks, raw error bodies) when diagnosing provider-side errors that
- * cost-forensics alone cannot explain — e.g. SiliconFlow's
- * "reasoning_content must be passed back" failure on DeepSeek reasoning
- * models, where we need to see the exact assistant-message shape the SDK
- * round-tripped.
- *
- * Log format: one JSON object per line, written to
- *   $MUONROI_DEBUG_LLM_WIRE_PATH or ~/.muonroi-cli/llm-wire.log
- *
- * Fail-open: any logging error is swallowed so we never break the main flow.
- */
-import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-const ENABLED = process.env.MUONROI_DEBUG_LLM_WIRE === "1";
-
-const LOG_FILE = process.env.MUONROI_DEBUG_LLM_WIRE_PATH ?? join(homedir(), ".muonroi-cli", "llm-wire.log");
-
-// Cap individual log files at ~25 MB. When exceeded we rotate to .1 and start
-// fresh. A single noisy /ideal session produces ~2 MB; the cap leaves room for
-// ~10 sessions before older evidence is dropped.
-const MAX_LOG_BYTES = 25 * 1024 * 1024;
-let _dirEnsured = false;
-let _rotateChecked = false;
-
-function ensureDirAndRotate(): void {
-  if (_dirEnsured && _rotateChecked) return;
-  try {
-    if (!_dirEnsured) {
-      mkdirSync(dirname(LOG_FILE), { recursive: true });
-      _dirEnsured = true;
-    }
-    if (!_rotateChecked && existsSync(LOG_FILE)) {
-      const size = statSync(LOG_FILE).size;
-      if (size > MAX_LOG_BYTES) {
-        const rotated = LOG_FILE + ".1";
-        if (existsSync(rotated)) {
-          try {
-            unlinkSync(rotated);
-          } catch {
-            /* fail-open */
-          }
-        }
-        renameSync(LOG_FILE, rotated);
-      }
-    }
-    _rotateChecked = true;
-  } catch {
-    /* fail-open */
-  }
-}
-
-function append(label: string, data: unknown): void {
-  if (!ENABLED) return;
-  try {
-    ensureDirAndRotate();
-    const line = JSON.stringify({ t: new Date().toISOString(), label, data });
-    appendFileSync(LOG_FILE, line + "\n", "utf8");
-  } catch {
-    /* fail-open */
-  }
-}
-
-interface MessageShape {
-  role: string;
-  contentKind: "string" | "parts";
-  textChars: number;
-  partTypes?: string[];
-  toolCallIds?: string[];
-}
-
-function summarizeMessage(m: unknown): MessageShape {
-  const msg = m as { role?: string; content?: unknown };
-  const role = String(msg?.role ?? "?");
-  const content = msg?.content;
-  if (typeof content === "string") {
-    return { role, contentKind: "string", textChars: content.length };
-  }
-  if (Array.isArray(content)) {
-    const partTypes: string[] = [];
-    const toolCallIds: string[] = [];
-    let textChars = 0;
-    for (const p of content) {
-      const part = p as Record<string, unknown>;
-      const t = String(part.type ?? part.kind ?? "unknown");
-      partTypes.push(t);
-      if (typeof part.text === "string") textChars += part.text.length;
-      if (typeof part.toolCallId === "string") toolCallIds.push(part.toolCallId);
-    }
-    return { role, contentKind: "parts", textChars, partTypes, toolCallIds };
-  }
-  return { role, contentKind: "string", textChars: 0 };
-}
-
-export const wireDebug = {
-  enabled: ENABLED,
-
-  /** Log an outgoing streamText/streamObject call. */
-  logRequest(meta: {
-    providerId: string;
-    modelId: string;
-    messages: readonly unknown[];
-    systemChars?: number;
-    toolNames?: readonly string[];
-    providerOptions?: unknown;
-  }): void {
-    if (!ENABLED) return;
-    const messages = meta.messages.map(summarizeMessage);
-    const roleCounts: Record<string, number> = {};
-    for (const m of messages) roleCounts[m.role] = (roleCounts[m.role] ?? 0) + 1;
-    append("request", {
-      providerId: meta.providerId,
-      modelId: meta.modelId,
-      systemChars: meta.systemChars ?? 0,
-      messageCount: messages.length,
-      roleCounts,
-      lastFiveMessages: messages.slice(-5),
-      toolCount: meta.toolNames?.length ?? 0,
-      hasProviderOptions: meta.providerOptions != null,
-    });
-  },
-
-  /** Log a single fullStream chunk type (lightweight — no content). */
-  logChunk(providerId: string, chunkType: string, extra?: Record<string, unknown>): void {
-    if (!ENABLED) return;
-    append("chunk", { providerId, type: chunkType, ...(extra ?? {}) });
-  },
-
-  /** Log a stream-level error with full provider response body if available. */
-  logError(providerId: string, err: unknown): void {
-    if (!ENABLED) return;
-    const e = err as Record<string, unknown>;
-    append("error", {
-      providerId,
-      name: typeof e?.name === "string" ? e.name : undefined,
-      message: typeof e?.message === "string" ? e.message : String(err),
-      statusCode: typeof e?.statusCode === "number" ? e.statusCode : undefined,
-      url: typeof e?.url === "string" ? e.url : undefined,
-      responseBody: typeof e?.responseBody === "string" ? e.responseBody.slice(0, 4000) : undefined,
-      cause:
-        e?.cause && typeof e.cause === "object"
-          ? {
-              message:
-                typeof (e.cause as Record<string, unknown>).message === "string"
-                  ? (e.cause as Record<string, unknown>).message
-                  : undefined,
-              name:
-                typeof (e.cause as Record<string, unknown>).name === "string"
-                  ? (e.cause as Record<string, unknown>).name
-                  : undefined,
-            }
-          : undefined,
-    });
-  },
-};
-
-export const _internals = { summarizeMessage };

package/src/router/__tests__/step-router.test.ts

@@ -1,150 +0,0 @@
-/**
- * Tests for Step-Aware Model Routing (SAMR).
- */
-
-import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
-import { loadCatalog, MODELS } from "../../models/registry.js";
-import { decideStepRouting, getStepRouterConfig, type StepRouterConfig } from "../step-router.js";
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function mockConfig(overrides: Partial<StepRouterConfig> = {}): StepRouterConfig {
-  return {
-    enabled: true,
-    toolExecutionTier: "fast",
-    premiumSynthesis: false,
-    ...overrides,
-  };
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-describe("decideStepRouting", () => {
-  beforeAll(async () => {
-    await loadCatalog();
-  });
-
-  it("returns phase2ModelId=null when disabled", () => {
-    const decision = decideStepRouting("claude-sonnet-4-6", "anthropic", mockConfig({ enabled: false }));
-    expect(decision.phase2ModelId).toBeNull();
-    expect(decision.reason).toContain("disabled");
-  });
-
-  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) 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) return;
-
-    const decision = decideStepRouting(premiumModel.id, premiumModel.provider, mockConfig());
-
-    if (decision.phase2ModelId) {
-      expect(decision.phase2ModelId).not.toBe(premiumModel.id);
-      expect(decision.reason).toContain("→");
-    }
-  });
-
-  it("respects toolExecutionTier setting", () => {
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider);
-    if (!premiumModel || !premiumModel.provider) return;
-
-    const balancedCfg = mockConfig({ toolExecutionTier: "balanced" });
-    const decision = decideStepRouting(premiumModel.id, premiumModel.provider, balancedCfg);
-
-    if (decision.phase2ModelId) {
-      const execModel = MODELS.find((m) => m.id === decision.phase2ModelId);
-      expect(execModel?.tier).toBe("balanced");
-    }
-  });
-
-  it("phase1ModelId is always preserved", () => {
-    const decision = decideStepRouting("claude-sonnet-4-6", "anthropic", mockConfig({ enabled: false }));
-    expect(decision.phase1ModelId).toBe("claude-sonnet-4-6");
-  });
-});
-
-describe("getStepRouterConfig", () => {
-  it("returns a well-formed config (values depend on user-settings)", () => {
-    const config = getStepRouterConfig();
-    expect(typeof config.enabled).toBe("boolean");
-    expect(["fast", "balanced"]).toContain(config.toolExecutionTier);
-    expect(typeof config.premiumSynthesis).toBe("boolean");
-  });
-});
-
-describe("default-off safety", () => {
-  // SAMR is opt-in: default off until Phase1→Phase2 transition is covered
-  // by an integration test against the real AI SDK. This test asserts the
-  // DEFAULT_CONFIG behavior by passing { enabled: false } explicitly — what
-  // a user with no stepRouter setting would get.
-  it("explicit enabled=false returns phase2ModelId=null", () => {
-    const decision = decideStepRouting("claude-opus-4-7", "anthropic", mockConfig({ enabled: false }));
-    expect(decision.phase2ModelId).toBeNull();
-    expect(decision.reason).toContain("disabled");
-  });
-});
-
-describe("resolveExecutionModel disability checks (Phase 19)", () => {
-  beforeAll(async () => {
-    await loadCatalog();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("does not return same-provider candidate when provider is disabled", async () => {
-    const settingsMod = await import("../../utils/settings.js");
-    vi.spyOn(settingsMod, "isProviderDisabled").mockImplementation((p) => p === "anthropic");
-    vi.spyOn(settingsMod, "isModelDisabled").mockReturnValue(false);
-
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider === "anthropic");
-    if (!premiumModel) return; // skip if no anthopic premium model loaded
-
-    const decision = decideStepRouting(premiumModel.id, "anthropic", mockConfig());
-    if (decision.phase2ModelId) {
-      const execModel = MODELS.find((m) => m.id === decision.phase2ModelId);
-      expect(execModel?.provider).not.toBe("anthropic");
-    } else {
-      // No alternative model found — acceptable (disabled provider, no cross-provider fallback)
-      expect(decision.phase2ModelId).toBeNull();
-    }
-  });
-
-  it("does not return a model that is in disabledModels", async () => {
-    const settingsMod = await import("../../utils/settings.js");
-    vi.spyOn(settingsMod, "isProviderDisabled").mockReturnValue(false);
-
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider);
-    if (!premiumModel) return;
-    const fastModel = MODELS.find((m) => m.tier === "fast" && m.provider === premiumModel.provider);
-    if (!fastModel) return;
-
-    vi.spyOn(settingsMod, "isModelDisabled").mockImplementation((id) => id === fastModel.id);
-
-    const decision = decideStepRouting(premiumModel.id, premiumModel.provider!, mockConfig());
-    expect(decision.phase2ModelId).not.toBe(fastModel.id);
-  });
-
-  it("falls through to cross-provider when same-provider model is disabled", async () => {
-    const settingsMod = await import("../../utils/settings.js");
-    const premiumModel = MODELS.find((m) => m.tier === "premium" && m.provider === "anthropic");
-    if (!premiumModel) return;
-    const sameFast = MODELS.find((m) => m.tier === "fast" && m.provider === "anthropic");
-    if (!sameFast) return;
-
-    // Disable the same-provider fast model; allow cross-provider
-    vi.spyOn(settingsMod, "isModelDisabled").mockImplementation((id) => id === sameFast.id);
-    vi.spyOn(settingsMod, "isProviderDisabled").mockReturnValue(false);
-
-    const decision = decideStepRouting(premiumModel.id, "anthropic", mockConfig());
-    // Either a different model is chosen or null — but NOT sameFast.id
-    expect(decision.phase2ModelId).not.toBe(sameFast.id);
-  });
-});

package/src/router/classifier/grammars.ts

@@ -1,17 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-
-export type GrammarId = "typescript" | "python";
-
-export const GRAMMARS: Record<GrammarId, string> = {
-  typescript: "tree-sitter-typescript/tree-sitter-typescript.wasm",
-  python: "tree-sitter-python/tree-sitter-python.wasm",
-};
-
-export async function loadGrammarBytes(id: GrammarId): Promise<Uint8Array> {
-  const rel = GRAMMARS[id];
-  // Resolve under node_modules -- works under Bun + Node
-  const p = path.join(process.cwd(), "node_modules", rel);
-  const buf = await fs.readFile(p);
-  return new Uint8Array(buf);
-}

package/src/router/classifier/index.test.ts

@@ -1,33 +0,0 @@
-import { beforeAll, describe, expect, it } from "vitest";
-import { classify, warm } from "./index.js";
-
-describe("classify orchestrator", () => {
-  beforeAll(async () => {
-    await warm();
-  }, 30_000);
-
-  it("returns hot for generic greeting (short message fast path)", () => {
-    const result = classify("hi");
-    expect(result.tier).toBe("hot");
-    expect(result.confidence).toBe(0.6);
-    expect(result.reason).toBe("regex:short-message");
-  });
-
-  it("returns hot for regex-matchable prompts", () => {
-    const result = classify("create a file called hello.ts");
-    expect(result.tier).toBe("hot");
-    expect(result.confidence).toBeGreaterThanOrEqual(0.55);
-  });
-
-  it("threshold gating: prompt scoring 0.6 returns abstain when threshold is 0.8", () => {
-    // "explain something" matches regex with ~0.70 confidence
-    const result = classify("explain what this does", 0.8);
-    expect(result.tier).toBe("abstain");
-  });
-
-  it("returns hot for tree-sitter-detectable code prompts", () => {
-    const result = classify("```ts\nconst x: number = 1;\n```");
-    expect(result.tier).toBe("hot");
-    expect(result.confidence).toBeGreaterThanOrEqual(0.55);
-  });
-});