muonroi-cli 1.4.0 → 1.4.1

package/src/pil/__tests__/layer5-context.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { PipelineContext } from "../types";
-
-vi.mock("../../ee/bridge.js", () => ({
-  getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-  searchCollection: vi.fn().mockResolvedValue([]),
-  searchByText: vi.fn().mockResolvedValue([]),
-}));
-
-vi.mock("node:fs", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:fs")>();
-  return {
-    ...actual,
-    promises: {
-      ...actual.promises,
-      readFile: vi.fn().mockRejectedValue(new Error("not found")),
-      readdir: vi.fn().mockRejectedValue(new Error("not found")),
-      stat: vi.fn().mockRejectedValue(new Error("not found")),
-    },
-  };
-});
-
-import { layer5Context } from "../layer5-context";
-
-function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
-  return {
-    raw: "continue working on the auth module",
-    enriched: "continue working on the auth module",
-    taskType: "refactor",
-    domain: null,
-    confidence: 0.9,
-    outputStyle: "concise",
-    tokenBudget: 500,
-    metrics: null,
-    layers: [],
-    ...overrides,
-  };
-}
-
-describe("layer5Context", () => {
-  it("skips workspace context when intentKind === 'chitchat'", async () => {
-    const before = "hi";
-    const result = await layer5Context(
-      makeCtx({
-        raw: before,
-        enriched: before,
-        intentKind: "chitchat",
-        resumeDigest: "should be ignored on chitchat",
-      }),
-    );
-    expect(result.enriched).toBe(before);
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    expect(layer!.applied).toBe(false);
-    expect(layer!.delta).toBe("skip:chitchat");
-  });
-
-  it("injects resume digest when available", async () => {
-    const digest = "Last session: refactored auth middleware, JWT validation working, need to add refresh token logic.";
-    const result = await layer5Context(makeCtx({ resumeDigest: digest }));
-    expect(result.enriched).toContain("[flow-context:");
-    expect(result.enriched).toContain("refactored auth middleware");
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    expect(layer).toBeDefined();
-    expect(layer!.applied).toBe(true);
-    expect(layer!.delta).toContain("digest=");
-  });
-
-  it("no digest, no EE, no flow → applied=false", async () => {
-    const result = await layer5Context(makeCtx({ resumeDigest: null }));
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    expect(layer).toBeDefined();
-    expect(layer!.applied).toBe(false);
-  });
-
-  it("no digest undefined → applied=false (with mocked EE)", async () => {
-    const result = await layer5Context(makeCtx());
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    expect(layer!.applied).toBe(false);
-  });
-
-  it("empty digest → applied=false (with mocked EE)", async () => {
-    const result = await layer5Context(makeCtx({ resumeDigest: "" }));
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    expect(layer!.applied).toBe(false);
-  });
-
-  it("includes digest in delta when present", async () => {
-    const result = await layer5Context(makeCtx({ resumeDigest: "Some digest", activeRunId: "abc123" }));
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    expect(layer!.applied).toBe(true);
-    expect(layer!.delta).toContain("digest=");
-  });
-
-  it("respects tokenBudget — truncates long digest", async () => {
-    const longDigest = "Context: ".repeat(500);
-    const result = await layer5Context(makeCtx({ resumeDigest: longDigest, tokenBudget: 50 }));
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    if (layer?.delta) {
-      const charsMatch = layer.delta.match(/chars=(\d+)/);
-      if (charsMatch) {
-        expect(parseInt(charsMatch[1], 10)).toBeLessThanOrEqual(50 * 4);
-      }
-    }
-  });
-
-  it("adds stale warning when digest is older than 30 minutes", async () => {
-    const result = await layer5Context(makeCtx({ resumeDigest: "Previous work on auth", digestAgeMs: 60 * 60 * 1000 }));
-    expect(result.enriched).toContain("stale");
-    const layer = result.layers.find((l) => l.name === "context-enrichment");
-    expect(layer!.delta).toContain("stale");
-  });
-
-  it("no stale warning when digest is fresh", async () => {
-    const result = await layer5Context(makeCtx({ resumeDigest: "Recent work", digestAgeMs: 5 * 60 * 1000 }));
-    expect(result.enriched).not.toContain("stale");
-  });
-
-  it("no stale warning when digestAgeMs is undefined", async () => {
-    const result = await layer5Context(makeCtx({ resumeDigest: "Some work" }));
-    expect(result.enriched).not.toContain("stale");
-  });
-
-  it("skips fetchPrinciples when ctx._brainData already supplied them", async () => {
-    const { searchByText } = await import("../../ee/bridge.js");
-    vi.mocked(searchByText).mockClear();
-    const { layer5Context } = await import("../layer5-context.js");
-    await layer5Context({
-      raw: "x",
-      enriched: "x",
-      taskType: "debug" as const,
-      domain: null,
-      confidence: 0.85,
-      outputStyle: "balanced" as const,
-      tokenBudget: 2000,
-      metrics: null,
-      layers: [],
-      _brainData: {
-        t0_principles: [{ text: "p", score: 0.9 }],
-        t1_rules: [],
-        t2_patterns: [],
-        retrieval_skipped_reason: null,
-      },
-    });
-    expect(searchByText).not.toHaveBeenCalled();
-  });
-
-  it("preserves existing enriched content", async () => {
-    const result = await layer5Context(
-      makeCtx({
-        enriched: "already enriched prompt\n[personality: concise]",
-        resumeDigest: "Previous session work",
-      }),
-    );
-    expect(result.enriched).toContain("already enriched prompt");
-    expect(result.enriched).toContain("[flow-context:");
-  });
-});

package/src/pil/__tests__/layer6-output.test.ts

@@ -1,362 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { applyPilSuffix, getResponseToolSet, layer6Output } from "../layer6-output.js";
-import type { OutputStyle, PipelineContext, TaskType } from "../types.js";
-
-// Mock bridge for PIL-03 classifyViaBrain tests
-vi.mock("../../ee/bridge.js", () => ({
-  classifyViaBrain: vi.fn().mockResolvedValue(null),
-}));
-
-async function getMockBrain() {
-  const { classifyViaBrain } = await import("../../ee/bridge.js");
-  return vi.mocked(classifyViaBrain);
-}
-
-const makeCtx = (taskType: TaskType | null = null, outputStyle: OutputStyle | null = null): PipelineContext => ({
-  raw: "test prompt for output style detection",
-  enriched: "test prompt for output style detection",
-  taskType,
-  domain: null,
-  confidence: 0,
-  outputStyle,
-  tokenBudget: 500,
-  metrics: null,
-  layers: [],
-});
-
-describe("applyPilSuffix — per-task-type suffixes", () => {
-  const taskTypes: TaskType[] = ["refactor", "debug", "plan", "analyze", "documentation", "generate"];
-
-  it.each(taskTypes)("appends correct OUTPUT RULES for taskType=%s", (tt) => {
-    const ctx = makeCtx(tt);
-    const result = applyPilSuffix("SYSTEM", ctx);
-    expect(result).toContain("SYSTEM");
-    expect(result).toContain(`OUTPUT RULES (${tt})`);
-    expect(result.length).toBeGreaterThan("SYSTEM".length);
-  });
-
-  it("each task type has a distinct suffix", () => {
-    const suffixes = taskTypes.map((tt) => applyPilSuffix("", makeCtx(tt)));
-    const unique = new Set(suffixes);
-    expect(unique.size).toBe(taskTypes.length);
-  });
-
-  it("returns system prompt unchanged when taskType is null", () => {
-    const system = "You are a helpful assistant.";
-    expect(applyPilSuffix(system, makeCtx(null))).toBe(system);
-  });
-
-  it("defaults to concise when outputStyle is null", () => {
-    const ctxNullStyle = makeCtx("debug", null);
-    const ctxConcise = makeCtx("debug", "concise");
-    expect(applyPilSuffix("S", ctxNullStyle)).toBe(applyPilSuffix("S", ctxConcise));
-  });
-
-  it("PIL-04 Tier 1.2: appends OUTPUT BUDGET hint per task type", () => {
-    const result = applyPilSuffix("S", makeCtx("debug", "concise"));
-    expect(result).toMatch(/OUTPUT BUDGET: aim for ≤500 tokens/);
-    const genResult = applyPilSuffix("S", makeCtx("generate", "concise"));
-    expect(genResult).toMatch(/OUTPUT BUDGET: aim for ≤1200 tokens/);
-  });
-
-  it("PIL-04 Tier 1.3: appends FORBIDDEN OPENERS rule for all styles", () => {
-    for (const style of ["concise", "balanced", "detailed"] as OutputStyle[]) {
-      const result = applyPilSuffix("S", makeCtx("plan", style));
-      expect(result).toMatch(/FORBIDDEN OPENERS/);
-      expect(result).toMatch(/Tôi sẽ/); // bilingual
-    }
-  });
-
-  it("PIL-04: response-tools path skips budget+preamble (tool already enforces structure)", () => {
-    const result = applyPilSuffix("S", makeCtx("analyze", "balanced"), true);
-    expect(result).toContain("respond_analyze");
-    expect(result).not.toMatch(/OUTPUT BUDGET/);
-    expect(result).not.toMatch(/FORBIDDEN OPENERS/);
-  });
-
-  it("general response-tool turn appends the human-UX note + no-footer clause (session 9e3fb3e2e0c9)", () => {
-    // A general/question response-tool turn must steer the answer toward a
-    // human reader: lead with the answer, no implementation plan, no process
-    // narration, and crucially NO evidence-provenance footer ("all facts from
-    // this turn / did not infer unopened files") — that compliance bookkeeping
-    // leaked into the user-facing reply.
-    const result = applyPilSuffix("S", makeCtx("general", "concise"), true);
-    expect(result).toContain("respond_general");
-    expect(result).toMatch(/for the HUMAN who asked/);
-    expect(result).toMatch(/do NOT narrate your own process/);
-    expect(result).toMatch(/Do NOT append an evidence-provenance footer/);
-  });
-});
-
-describe("getResponseToolSet — PIL-04 Tier 1.1 gating", () => {
-  it("returns response tool for analyze (list-shaped, JSON wins)", () => {
-    const tools = getResponseToolSet(makeCtx("analyze", null));
-    expect(Object.keys(tools)).toContain("respond_analyze");
-  });
-
-  it("returns response tool for plan (list-shaped, JSON wins)", () => {
-    const tools = getResponseToolSet(makeCtx("plan", null));
-    expect(Object.keys(tools)).toContain("respond_plan");
-  });
-
-  it("returns empty toolset for generate (code-heavy, markdown wins)", () => {
-    expect(getResponseToolSet(makeCtx("generate", null))).toEqual({});
-  });
-
-  it("returns empty toolset for refactor (diff-heavy, markdown wins)", () => {
-    expect(getResponseToolSet(makeCtx("refactor", null))).toEqual({});
-  });
-
-  it("returns response tool for debug (bounded schema, structural enforcement wins)", () => {
-    const tools = getResponseToolSet(makeCtx("debug", null));
-    expect(Object.keys(tools)).toContain("respond_debug");
-  });
-
-  it("returns empty toolset for documentation (prose-heavy)", () => {
-    expect(getResponseToolSet(makeCtx("documentation", null))).toEqual({});
-  });
-
-  it("returns response tool for general when no providerId is passed (back-compat)", () => {
-    const tools = getResponseToolSet(makeCtx("general", null));
-    expect(Object.keys(tools)).toContain("respond_general");
-  });
-
-  it("drops respond_general when providerId is deepseek (token leak quirk)", () => {
-    expect(getResponseToolSet(makeCtx("general", null), "deepseek")).toEqual({});
-    expect(getResponseToolSet(makeCtx("general", null), "siliconflow")).toEqual({});
-  });
-
-  it("keeps respond_general for openai/anthropic/google", () => {
-    for (const id of ["openai", "anthropic", "google", "xai"] as const) {
-      const tools = getResponseToolSet(makeCtx("general", null), id);
-      expect(Object.keys(tools)).toContain("respond_general");
-    }
-  });
-
-  it("returns empty toolset when taskType is null", () => {
-    expect(getResponseToolSet(makeCtx(null, null))).toEqual({});
-  });
-
-  it("drops respond_<task> on an IMPLEMENTATION-intent prompt (no premature terminal answer)", () => {
-    // Live (grok session 19fa8895c41c): an "Improve … implement these fixes"
-    // prompt classified `debug` got respond_debug; the model called it mid-task
-    // as a plan and the turn ended before the edits completed. Implementation
-    // turns must fall through to markdown OUTPUT RULES, not a terminal tool.
-    const impl = (raw: string, t: TaskType) => ({ ...makeCtx(t, null), raw });
-    expect(
-      getResponseToolSet(impl("Improve the story-list screen. Implement these prioritized fixes: …", "debug")),
-    ).toEqual({});
-    expect(getResponseToolSet(impl("Edit ONLY these two files and fix the empty span", "debug"))).toEqual({});
-    expect(getResponseToolSet(impl("refactor the genre dropdown and wire up keyboard handlers", "analyze"))).toEqual(
-      {},
-    );
-    expect(getResponseToolSet(impl("triển khai các cải tiến đã đề xuất", "plan"))).toEqual({});
-  });
-
-  it("KEEPS respond_<task> for pure analysis/plan prompts (narrowness guard)", () => {
-    // The deliverable here IS a structured report — must not be suppressed.
-    const ana = (raw: string, t: TaskType) => ({ ...makeCtx(t, null), raw });
-    expect(Object.keys(getResponseToolSet(ana("analyze the orchestrator for cost leaks", "analyze")))).toContain(
-      "respond_analyze",
-    );
-    expect(Object.keys(getResponseToolSet(ana("why does the build fail intermittently?", "debug")))).toContain(
-      "respond_debug",
-    );
-    expect(Object.keys(getResponseToolSet(ana("plan the migration to the new auth flow", "plan")))).toContain(
-      "respond_plan",
-    );
-    expect(Object.keys(getResponseToolSet(ana("review the auth module and explain the design", "analyze")))).toContain(
-      "respond_analyze",
-    );
-  });
-});
-
-describe("applyPilSuffix — outputStyle variants", () => {
-  const styles: OutputStyle[] = ["concise", "detailed", "balanced"];
-
-  it("each style produces a different suffix for the same taskType (using non-action task)", () => {
-    // Action tasks (debug/refactor/generate) coerce style=detailed → concise
-    // unless the prompt literally asks for detail, so they only have 2 distinct
-    // suffix shapes from the 3 inputs. Use a non-action task (plan) to verify
-    // style variants are still routed through.
-    const suffixes = styles.map((s) => applyPilSuffix("", makeCtx("plan", s)));
-    const unique = new Set(suffixes);
-    expect(unique.size).toBe(styles.length);
-  });
-
-  it.each(styles)("debug suffix always present for style=%s", (style) => {
-    const result = applyPilSuffix("", makeCtx("debug", style));
-    expect(result).toContain("OUTPUT RULES (debug)");
-  });
-
-  it("detailed suffix allows explanation on non-action task (plan)", () => {
-    // Action-task coercion: refactor+detailed → concise (no "full rationale").
-    // The behavior we care about — that "detailed" really carries through to a
-    // longer suffix — is still observable on plan.
-    const result = applyPilSuffix("", makeCtx("plan", "detailed"));
-    expect(result).toContain("full rationale");
-  });
-
-  it("concise suffix restricts prose", () => {
-    const result = applyPilSuffix("", makeCtx("refactor", "concise"));
-    expect(result).toContain("No prose");
-  });
-
-  it("coerces refactor+detailed → concise when prompt has no detail-request keywords (session 127140a47b56)", () => {
-    const ctx = makeCtx("refactor", "detailed");
-    ctx.raw = "rename foo to bar across the repo";
-    const result = applyPilSuffix("", ctx);
-    expect(result).toContain("No prose");
-    expect(result).not.toContain("full rationale");
-  });
-
-  it("honors refactor+detailed when the prompt explicitly asks for detail", () => {
-    const ctx = makeCtx("refactor", "detailed");
-    ctx.raw = "refactor this module and explain in detail what you changed";
-    const result = applyPilSuffix("", ctx);
-    expect(result).toContain("full rationale");
-  });
-
-  it("honors refactor+detailed when the Vietnamese prompt asks for chi tiết", () => {
-    const ctx = makeCtx("refactor", "detailed");
-    ctx.raw = "refactor module này và giải thích chi tiết cho tôi";
-    const result = applyPilSuffix("", ctx);
-    expect(result).toContain("full rationale");
-  });
-});
-
-describe("layer6Output — style resolution", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("uses ctx.outputStyle from L1 directly when already set — no brain call", async () => {
-    const brain = await getMockBrain();
-    const result = await layer6Output(makeCtx("debug", "concise"));
-    expect(result.layers[0].delta).toContain("style=concise");
-    expect(result.layers[0].delta).toContain("src=inherited");
-    expect(brain).not.toHaveBeenCalled();
-  });
-
-  it("uses detailed style when passed from L1", async () => {
-    const result = await layer6Output(makeCtx("plan", "detailed"));
-    expect(result.layers[0].delta).toContain("style=detailed");
-    expect(result.layers[0].delta).toContain("src=inherited");
-  });
-
-  it("when ctx.taskType is null, layer is not applied", async () => {
-    const result = await layer6Output(makeCtx(null, null));
-    expect(result.layers[0].applied).toBe(false);
-  });
-
-  it("PIL-03a: rescues outputStyle via brain when L1 returns null", async () => {
-    const brain = await getMockBrain();
-    brain.mockResolvedValueOnce("detailed");
-    const result = await layer6Output(makeCtx("plan", null));
-    expect(result.outputStyle).toBe("detailed");
-    expect(result.layers[0].delta).toContain("style=detailed");
-    expect(result.layers[0].delta).toContain("src=brain-rescue");
-  });
-
-  // PIL-L6 verbosity fix — debug default flipped to "concise" to stop the
-  // model from padding root-cause analysis with rationale prose.
-  it("PIL-03b: uses task-type heuristic when brain returns null (debug→concise)", async () => {
-    const result = await layer6Output(makeCtx("debug", null));
-    expect(result.outputStyle).toBe("concise");
-    expect(result.layers[0].delta).toContain("style=concise");
-    expect(result.layers[0].delta).toContain("src=task-heuristic");
-  });
-
-  it("PIL-03b: task-heuristic for plan→balanced (not detailed — avoids generating extra sections)", async () => {
-    const result = await layer6Output(makeCtx("plan", null));
-    expect(result.outputStyle).toBe("balanced");
-    expect(result.layers[0].delta).toContain("style=balanced");
-  });
-
-  it("PIL-03b: task-heuristic for generate→concise", async () => {
-    const result = await layer6Output(makeCtx("generate", null));
-    expect(result.outputStyle).toBe("concise");
-    expect(result.layers[0].delta).toContain("style=concise");
-  });
-
-  it("PIL-03b: task-heuristic for refactor→concise", async () => {
-    const result = await layer6Output(makeCtx("refactor", null));
-    expect(result.outputStyle).toBe("concise");
-  });
-
-  it("skips classifyViaBrain rescue when ctx._brainData is populated (style guaranteed by L1)", async () => {
-    const brain = await getMockBrain();
-    brain.mockClear();
-    const ctx: PipelineContext = {
-      ...makeCtx("plan", "balanced"),
-      _brainData: { t0_principles: [], t1_rules: [], t2_patterns: [], retrieval_skipped_reason: null },
-    };
-    await layer6Output(ctx);
-    expect(brain).not.toHaveBeenCalled();
-  });
-
-  it("PIL-03: resolved outputStyle propagated back onto ctx", async () => {
-    // PIL-L6 verbosity fix — analyze default also flipped to "concise".
-    const result = await layer6Output(makeCtx("analyze", null));
-    expect(result.outputStyle).not.toBeNull();
-    expect(result.outputStyle).toBe("concise");
-  });
-});
-
-describe("layer6Output", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("with taskType=debug — applied=true, delta contains suffix=debug and style", async () => {
-    const { classifyViaBrain } = await import("../../ee/bridge.js");
-    vi.mocked(classifyViaBrain).mockResolvedValue(null);
-
-    const result = await layer6Output(makeCtx("debug", "concise"));
-    expect(result.layers).toHaveLength(1);
-    expect(result.layers[0].applied).toBe(true);
-    expect(result.layers[0].delta).toMatch(/suffix=debug/);
-    expect(result.layers[0].delta).toMatch(/style=concise/);
-    expect(result.layers[0].delta).toMatch(/chars=\d+/);
-  });
-
-  it("with taskType=refactor — applied=true, delta contains suffix=refactor", async () => {
-    const { classifyViaBrain } = await import("../../ee/bridge.js");
-    vi.mocked(classifyViaBrain).mockResolvedValue(null);
-
-    const result = await layer6Output(makeCtx("refactor", "detailed"));
-    expect(result.layers[0].applied).toBe(true);
-    expect(result.layers[0].delta).toMatch(/suffix=refactor/);
-    expect(result.layers[0].delta).toMatch(/style=detailed/);
-  });
-
-  it("with taskType=null — applied=false, delta=null", async () => {
-    const result = await layer6Output(makeCtx(null));
-    expect(result.layers[0].applied).toBe(false);
-    expect(result.layers[0].delta).toBeNull();
-  });
-
-  it("chitchat short-circuit: skips suffix work, marks delta=skip:chitchat", async () => {
-    const brain = await getMockBrain();
-    const ctx: PipelineContext = { ...makeCtx("general", "concise"), intentKind: "chitchat" };
-    const result = await layer6Output(ctx);
-    expect(result.layers[0].applied).toBe(false);
-    expect(result.layers[0].delta).toBe("skip:chitchat");
-    expect(brain).not.toHaveBeenCalled();
-  });
-
-  it("applyPilSuffix: returns prompt unchanged when intentKind=chitchat", () => {
-    const ctx: PipelineContext = { ...makeCtx("general", "concise"), intentKind: "chitchat" };
-    const system = "SYSTEM";
-    expect(applyPilSuffix(system, ctx)).toBe(system);
-  });
-
-  it("enriched unchanged (Layer 6 modifies system prompt only)", async () => {
-    const { classifyViaBrain } = await import("../../ee/bridge.js");
-    vi.mocked(classifyViaBrain).mockResolvedValue(null);
-
-    const ctx = makeCtx("generate");
-    const result = await layer6Output(ctx);
-    expect(result.enriched).toBe(ctx.enriched);
-  });
-});

package/src/pil/__tests__/llm-classify.test.ts

@@ -1,140 +0,0 @@
-import { afterEach, beforeAll, describe, expect, it } from "vitest";
-import { installMockModel, textOnlyStream } from "../../agent-harness/mock-model.js";
-import { loadCatalog } from "../../models/registry.js";
-import { createLlmClassifier } from "../llm-classify.js";
-
-describe("createLlmClassifier (PIL Layer 1 Pass 4)", () => {
-  beforeAll(async () => {
-    await loadCatalog();
-  });
-
-  let cleanup: (() => void) | null = null;
-  afterEach(() => {
-    cleanup?.();
-    cleanup = null;
-  });
-
-  it("parses a clean two-word reply into TaskType + style", async () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-    cleanup = handle.uninstall;
-
-    // Build a stub factory — installMockModel routes everything through the mock anyway.
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-    const result = await classify("ci action github fail, fix giúp tôi");
-
-    expect(result).not.toBeNull();
-    expect(result?.taskType).toBe("debug");
-    expect(result?.outputStyle).toBe("concise");
-    expect(result?.confidence).toBeGreaterThan(0.5);
-  });
-
-  it("returns null when the reply cannot be parsed", async () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("¯\\_(ツ)_/¯") } });
-    cleanup = handle.uninstall;
-
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-    const result = await classify("hello");
-
-    expect(result).toBeNull();
-  });
-
-  it("accepts a taskType-only reply (style optional)", async () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("plan") } });
-    cleanup = handle.uninstall;
-
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-    const result = await classify("design a sharded queue");
-
-    expect(result?.taskType).toBe("plan");
-    expect(result?.outputStyle).toBeNull();
-  });
-
-  it("ignores noisy formatting (markdown, quotes, newlines)", async () => {
-    const handle = installMockModel({
-      fixture: { stream: textOnlyStream('**"refactor, balanced"**\n\nrationale: ...') },
-    });
-    cleanup = handle.uninstall;
-
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-    const result = await classify("tái cấu trúc auth module");
-
-    expect(result?.taskType).toBe("refactor");
-    expect(result?.outputStyle).toBe("balanced");
-  });
-
-  // Reasoning models (grok-4.3, deepseek-v4-flash) consumed the doomed 16-token
-  // budget on reasoning tokens FIRST → emitted zero text-delta → parseResponse
-  // saw "" → returned null. 5/5 live grok sessions showed `llm=fail`. Fix: give
-  // reasoning models a real output budget + force the lowest reasoning effort the
-  // provider supports, so the 2-word answer actually streams back.
-  it("gives a reasoning model a real output budget (not the doomed 16)", async () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-    cleanup = handle.uninstall;
-
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "grok-4.3"); // reasoning:true
-    const result = await classify("fix the failing CI build");
-
-    expect(result?.taskType).toBe("debug");
-    const call = handle.calls[0] as { maxOutputTokens?: number };
-    expect(call.maxOutputTokens).toBeGreaterThanOrEqual(1024);
-  });
-
-  it("forces low reasoning effort for reasoning models that support it", async () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-    cleanup = handle.uninstall;
-
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "grok-4.3"); // xai, supports_effort:true
-    await classify("fix the failing CI build");
-
-    const call = handle.calls[0] as {
-      providerOptions?: Record<string, Record<string, unknown>>;
-    };
-    expect(call.providerOptions?.xai?.reasoningEffort).toBe("low");
-  });
-
-  it("recovers the verdict from the reasoning channel when text is empty", async () => {
-    // Some reasoning models route the whole 2-word answer into reasoning parts
-    // and commit no text. The classifier must still recover it.
-    const reasoningOnly = [
-      { type: "stream-start", warnings: [] },
-      { type: "reasoning-start", id: "r1" },
-      { type: "reasoning-delta", id: "r1", delta: "debug,concise" },
-      { type: "reasoning-end", id: "r1" },
-      {
-        type: "finish",
-        finishReason: { unified: "stop" as const, raw: undefined },
-        usage: {
-          inputTokens: { total: 10, noCache: 10, cacheRead: undefined, cacheWrite: undefined },
-          outputTokens: { total: 5, text: 0, reasoning: 5 },
-        },
-      },
-    ] as never;
-    const handle = installMockModel({ fixture: { stream: reasoningOnly } });
-    cleanup = handle.uninstall;
-
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "grok-4.3");
-    const result = await classify("fix the failing CI build");
-
-    expect(result?.taskType).toBe("debug");
-    expect(result?.outputStyle).toBe("concise");
-  });
-
-  it("keeps the tiny 16-token budget for non-reasoning models", async () => {
-    const handle = installMockModel({ fixture: { stream: textOnlyStream("generate,concise") } });
-    cleanup = handle.uninstall;
-
-    const factory = (() => handle.model) as never;
-    const classify = createLlmClassifier(factory, "Qwen/Qwen3-8B"); // reasoning:false
-    await classify("add a new endpoint");
-
-    const call = handle.calls[0] as { maxOutputTokens?: number };
-    expect(call.maxOutputTokens).toBe(16);
-  });
-});