muonroi-cli 1.6.6 → 1.7.0

package/dist/src/providers/__tests__/reasoning-roundtrip.test.js

@@ -19,7 +19,8 @@
  */
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { streamText } from "ai";
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { transformThinkingModeBody } from "../strategies/thinking-mode.js";
 function makeStubProvider(name, capture) {
     return createOpenAICompatible({
         name,
@@ -113,6 +114,11 @@ describe("reasoning_content round-trip — AI SDK 2.0.42 wire shape", () => {
         expect(Array.isArray(assistantMsg.tool_calls)).toBe(true);
         expect(assistantMsg.tool_calls[0]?.id).toBe("c1");
     });
+    // NOTE: the bare provider correctly omits reasoning_content when a turn has
+    // no reasoning part — but that is exactly the shape SiliconFlow's
+    // thinking-mode validator rejects (code 20015) in a mixed history. The
+    // strategy's transformRequestBody backfills it; see the dedicated describe
+    // block below ("transformThinkingModeBody — backfill / disable").
     it("emits no reasoning_content key when there are no reasoning parts (no false positives)", async () => {
         const capture = { current: null };
         const provider = makeStubProvider("siliconflow", capture);
@@ -132,4 +138,67 @@ describe("reasoning_content round-trip — AI SDK 2.0.42 wire shape", () => {
         expect(assistantMsg.reasoning_content).toBeUndefined();
     });
 });
+describe("transformThinkingModeBody — backfill / disable (code 20015 fix)", () => {
+    const ENV = "MUONROI_DEEPSEEK_DISABLE_THINKING";
+    let saved;
+    beforeEach(() => {
+        saved = process.env[ENV];
+        delete process.env[ENV];
+    });
+    afterEach(() => {
+        if (saved === undefined)
+            delete process.env[ENV];
+        else
+            process.env[ENV] = saved;
+    });
+    it("A (default): backfills reasoning_content on a tool-call turn that lacks it", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "go" },
+                // tool-call turn with NO reasoning (the real bug shape)
+                { role: "assistant", content: null, tool_calls: [{ id: "t1", type: "function" }] },
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        const asst = out.messages.find((m) => m.role === "assistant");
+        expect(asst.reasoning_content).toBe("");
+        expect(Array.isArray(asst.tool_calls)).toBe(true); // tool_calls preserved
+        expect("thinking" in out).toBe(false); // thinking still ON
+    });
+    it("A (default): leaves a real reasoning_content untouched and patches only the gap", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "go" },
+                { role: "assistant", content: null, reasoning_content: "real thought", tool_calls: [{ id: "a" }] },
+                { role: "tool", content: "result" },
+                { role: "assistant", content: null, tool_calls: [{ id: "b" }] }, // gap
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        const asst = out.messages.filter((m) => m.role === "assistant");
+        expect(asst[0].reasoning_content).toBe("real thought"); // untouched
+        expect(asst[1].reasoning_content).toBe(""); // backfilled
+    });
+    it("A (default): does not touch non-assistant messages", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "hi" },
+                { role: "tool", content: "r" },
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        expect("reasoning_content" in out.messages[0]).toBe(false);
+        expect("reasoning_content" in out.messages[1]).toBe(false);
+    });
+    it("B (env=1): disables thinking and does NOT backfill reasoning_content", () => {
+        process.env[ENV] = "1";
+        const body = {
+            messages: [{ role: "assistant", content: null, tool_calls: [{ id: "t1" }] }],
+        };
+        const out = transformThinkingModeBody(body);
+        expect(out.thinking).toEqual({ type: "disabled" });
+        const asst = out.messages.find((m) => m.role === "assistant");
+        expect("reasoning_content" in asst).toBe(false);
+    });
+});
 //# sourceMappingURL=reasoning-roundtrip.test.js.map

package/dist/src/providers/strategies/deepseek.strategy.js

@@ -7,19 +7,7 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { getProviderCapabilities } from "../capabilities.js";
 import { OPENAI_COMPATIBLE_BASE_URLS } from "../endpoints.js";
 import { BaseProviderStrategy } from "./base.strategy.js";
-/**
- * If MUONROI_DEEPSEEK_DISABLE_THINKING=1 (default for self-qa), inject
- * `extra_body.thinking.type="disabled"` into every DeepSeek request per
- * https://api-docs.deepseek.com/guides/thinking_mode . Cuts response time
- * 30-50% and prevents reasoning prose from leaking into JSON outputs.
- *
- * Set MUONROI_DEEPSEEK_DISABLE_THINKING=0 to keep thinking mode on for
- * chat sessions that actually benefit from reasoning.
- */
-function shouldDisableThinking() {
-    const v = process.env["MUONROI_DEEPSEEK_DISABLE_THINKING"];
-    return v === undefined ? false : v === "1" || v.toLowerCase() === "true";
-}
+import { transformThinkingModeBody } from "./thinking-mode.js";
 export class DeepSeekStrategy extends BaseProviderStrategy {
     id = "deepseek";
     capabilities = getProviderCapabilities("deepseek");
@@ -34,15 +22,10 @@ export class DeepSeekStrategy extends BaseProviderStrategy {
             // json_object form for generateObject calls, matching DeepSeek docs:
             // https://api-docs.deepseek.com/guides/json_mode .
             supportsStructuredOutputs: false,
-            transformRequestBody: (body) => {
-                if (shouldDisableThinking()) {
-                    return {
-                        ...body,
-                        thinking: { type: "disabled" },
-                    };
-                }
-                return body;
-            },
+            // Thinking-mode round-trip fix: backfill reasoning_content (default) or
+            // disable thinking (MUONROI_DEEPSEEK_DISABLE_THINKING=1). See
+            // thinking-mode.ts for the full rationale (code 20015 rejection).
+            transformRequestBody: (body) => transformThinkingModeBody(body),
         });
         return (modelId) => p(modelId);
     }

package/dist/src/providers/strategies/siliconflow.strategy.js

@@ -8,6 +8,7 @@ import { getProviderCapabilities } from "../capabilities.js";
 import { OPENAI_COMPATIBLE_BASE_URLS } from "../endpoints.js";
 import { createSiliconflowRepairFetch } from "../siliconflow-sse-repair.js";
 import { BaseProviderStrategy } from "./base.strategy.js";
+import { transformThinkingModeBody } from "./thinking-mode.js";
 export class SiliconflowStrategy extends BaseProviderStrategy {
     id = "siliconflow";
     capabilities = getProviderCapabilities("siliconflow");
@@ -17,6 +18,10 @@ export class SiliconflowStrategy extends BaseProviderStrategy {
             baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS.siliconflow,
             apiKey: opts.apiKey,
             fetch: createSiliconflowRepairFetch(),
+            // Thinking-mode round-trip fix (code 20015): backfill reasoning_content
+            // on every assistant turn, or disable thinking when
+            // MUONROI_DEEPSEEK_DISABLE_THINKING=1. See thinking-mode.ts.
+            transformRequestBody: (body) => transformThinkingModeBody(body),
         });
         return (modelId) => p(modelId);
     }

package/dist/src/providers/strategies/thinking-mode.d.ts

@@ -0,0 +1,35 @@
+/**
+ * src/providers/strategies/thinking-mode.ts
+ *
+ * Shared `transformRequestBody` logic for DeepSeek-family providers
+ * (deepseek + siliconflow) that run a `thinking`/reasoning mode.
+ *
+ * THE BUG (verified on a live SiliconFlow wire body): DeepSeek-V4-Flash in
+ * thinking mode rejects the WHOLE request with HTTP 400 / code 20015
+ * ("The reasoning_content in the thinking mode must be passed back to the
+ * API") whenever the history contains an assistant message that lacks a
+ * `reasoning_content` field. During multi-step tool loops some assistant
+ * turns make a tool call WITHOUT emitting a reasoning segment (e.g. a quick
+ * `todo_write`), so `@ai-sdk/openai-compatible` serializes them as
+ * `{content:null, tool_calls:[...]}` with no `reasoning_content` key — and
+ * the next request blows up. The earlier "reasoning round-trips natively"
+ * conclusion only held for histories where EVERY assistant turn had reasoning.
+ *
+ * Two mitigations, selected by `MUONROI_DEEPSEEK_DISABLE_THINKING`:
+ *
+ *   - Default (A): keep thinking ON, but backfill `reasoning_content: ""` onto
+ *     every assistant message in the wire body that is missing it, so the
+ *     thinking-mode validator always sees the field.
+ *   - Fallback (B, env=1): disable thinking entirely via
+ *     `thinking: { type: "disabled" }` (per the DeepSeek thinking_mode guide).
+ *     Sidesteps the whole class of bug, cuts latency 30-50%, and stops
+ *     reasoning prose from leaking into JSON outputs — at the cost of reasoning.
+ *
+ * https://api-docs.deepseek.com/guides/thinking_mode
+ */
+export declare function shouldDisableThinking(): boolean;
+/**
+ * The shared `transformRequestBody` for deepseek + siliconflow. Runs on the
+ * fully-serialized wire body right before fetch.
+ */
+export declare function transformThinkingModeBody<T extends Record<string, unknown>>(body: T): T;

package/dist/src/providers/strategies/thinking-mode.js

@@ -0,0 +1,73 @@
+/**
+ * src/providers/strategies/thinking-mode.ts
+ *
+ * Shared `transformRequestBody` logic for DeepSeek-family providers
+ * (deepseek + siliconflow) that run a `thinking`/reasoning mode.
+ *
+ * THE BUG (verified on a live SiliconFlow wire body): DeepSeek-V4-Flash in
+ * thinking mode rejects the WHOLE request with HTTP 400 / code 20015
+ * ("The reasoning_content in the thinking mode must be passed back to the
+ * API") whenever the history contains an assistant message that lacks a
+ * `reasoning_content` field. During multi-step tool loops some assistant
+ * turns make a tool call WITHOUT emitting a reasoning segment (e.g. a quick
+ * `todo_write`), so `@ai-sdk/openai-compatible` serializes them as
+ * `{content:null, tool_calls:[...]}` with no `reasoning_content` key — and
+ * the next request blows up. The earlier "reasoning round-trips natively"
+ * conclusion only held for histories where EVERY assistant turn had reasoning.
+ *
+ * Two mitigations, selected by `MUONROI_DEEPSEEK_DISABLE_THINKING`:
+ *
+ *   - Default (A): keep thinking ON, but backfill `reasoning_content: ""` onto
+ *     every assistant message in the wire body that is missing it, so the
+ *     thinking-mode validator always sees the field.
+ *   - Fallback (B, env=1): disable thinking entirely via
+ *     `thinking: { type: "disabled" }` (per the DeepSeek thinking_mode guide).
+ *     Sidesteps the whole class of bug, cuts latency 30-50%, and stops
+ *     reasoning prose from leaking into JSON outputs — at the cost of reasoning.
+ *
+ * https://api-docs.deepseek.com/guides/thinking_mode
+ */
+export function shouldDisableThinking() {
+    const v = process.env["MUONROI_DEEPSEEK_DISABLE_THINKING"];
+    return v === undefined ? false : v === "1" || v.toLowerCase() === "true";
+}
+/**
+ * Backfill `reasoning_content: ""` onto any assistant message that lacks a
+ * (non-empty/present) one, so SiliconFlow's thinking-mode validator never
+ * sees a reasoning-less assistant turn. Assistant turns that already carry a
+ * real `reasoning_content` are left untouched.
+ */
+function backfillReasoningContent(messages) {
+    let mutated = false;
+    const next = messages.map((m) => {
+        if (m?.role !== "assistant")
+            return m;
+        const rc = m.reasoning_content;
+        if (typeof rc === "string")
+            return m; // already present (incl. "")
+        mutated = true;
+        return { ...m, reasoning_content: "" };
+    });
+    return mutated ? next : messages;
+}
+/**
+ * The shared `transformRequestBody` for deepseek + siliconflow. Runs on the
+ * fully-serialized wire body right before fetch.
+ */
+export function transformThinkingModeBody(body) {
+    if (shouldDisableThinking()) {
+        // Fallback B: turn thinking off. No reasoning is produced, so there is
+        // nothing to backfill.
+        return { ...body, thinking: { type: "disabled" } };
+    }
+    // Default A: keep thinking on, but guarantee every assistant message carries
+    // a reasoning_content field so the validator is satisfied.
+    const messages = body["messages"];
+    if (!Array.isArray(messages))
+        return body;
+    const patched = backfillReasoningContent(messages);
+    if (patched === messages)
+        return body;
+    return { ...body, messages: patched };
+}
+//# sourceMappingURL=thinking-mode.js.map

package/dist/src/tools/registry.js

@@ -593,58 +593,58 @@ export function createBuiltinTools(bash, mode, opts) {
                     .join("\n");
             },
         });
-        // todo_write — Claude-Code-style task list. Each call REPLACES the agent's
-        // current todo snapshot; the orchestrator post-processes this tool's args
-        // into a task_list_update StreamChunk that the UI renders as a sticky
-        // checklist panel. Status flow: pending → in_progress → completed; only
-        // ONE item should be in_progress at a time. Use this when the user asks
-        // for a multi-step task (≥3 distinct steps) so progress is visible.
-        tools.todo_write = dynamicTool({
-            description: "Write the full current todo list. Replaces the previous list entirely on every call (no partial updates). Use when a user request resolves into ≥3 discrete steps so the UI can show progress. Mark exactly one item as in_progress at a time. Always emit the FULL list, not just the changed items.",
-            inputSchema: jsonSchema({
-                type: "object",
-                properties: {
-                    todos: {
-                        type: "array",
-                        description: "The full ordered list of todo items. Replaces any prior list. Keep order stable across updates so the UI doesn't reshuffle on every call.",
-                        items: {
-                            type: "object",
-                            properties: {
-                                id: { type: "string", description: "Stable id across updates (e.g. '1','2', or a slug)." },
-                                subject: { type: "string", description: "Short imperative title shown in the list." },
-                                activeForm: {
-                                    type: "string",
-                                    description: "Present-continuous form shown while in_progress (e.g. 'Reading files'). Falls back to subject when absent.",
-                                },
-                                status: {
-                                    type: "string",
-                                    enum: ["pending", "in_progress", "completed"],
-                                    description: "Item status. Only ONE item should be in_progress at any time.",
-                                },
+    }
+    // todo_write — Claude-Code-style task list. Each call REPLACES the agent's
+    // current todo snapshot; the orchestrator post-processes this tool's args
+    // into a task_list_update StreamChunk that the UI renders as a sticky
+    // checklist panel. Status flow: pending → in_progress → completed; only
+    // ONE item should be in_progress at a time. Use this when the user asks
+    // for a multi-step task (≥3 distinct steps) so progress is visible.
+    tools.todo_write = dynamicTool({
+        description: "Write the full current todo list. Replaces the previous list entirely on every call (no partial updates). Use when a user request resolves into ≥3 discrete steps so the UI can show progress. Mark exactly one item as in_progress at a time. Always emit the FULL list, not just the changed items.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                todos: {
+                    type: "array",
+                    description: "The full ordered list of todo items. Replaces any prior list. Keep order stable across updates so the UI doesn't reshuffle on every call.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string", description: "Stable id across updates (e.g. '1','2', or a slug)." },
+                            subject: { type: "string", description: "Short imperative title shown in the list." },
+                            activeForm: {
+                                type: "string",
+                                description: "Present-continuous form shown while in_progress (e.g. 'Reading files'). Falls back to subject when absent.",
+                            },
+                            status: {
+                                type: "string",
+                                enum: ["pending", "in_progress", "completed"],
+                                description: "Item status. Only ONE item should be in_progress at any time.",
                             },
-                            required: ["id", "subject", "status"],
                         },
+                        required: ["id", "subject", "status"],
                     },
                 },
-                required: ["todos"],
-            }),
-            execute: async (input) => {
-                const todos = Array.isArray(input?.todos)
-                    ? input.todos
-                    : [];
-                const counts = { completed: 0, inProgress: 0, pending: 0, total: todos.length };
-                for (const t of todos) {
-                    if (t.status === "completed")
-                        counts.completed++;
-                    else if (t.status === "in_progress")
-                        counts.inProgress++;
-                    else
-                        counts.pending++;
-                }
-                return `Tracking ${counts.total} todo${counts.total !== 1 ? "s" : ""}: ${counts.completed} done · ${counts.inProgress} in progress · ${counts.pending} queued.`;
             },
-        });
-    }
+            required: ["todos"],
+        }),
+        execute: async (input) => {
+            const todos = Array.isArray(input?.todos)
+                ? input.todos
+                : [];
+            const counts = { completed: 0, inProgress: 0, pending: 0, total: todos.length };
+            for (const t of todos) {
+                if (t.status === "completed")
+                    counts.completed++;
+                else if (t.status === "in_progress")
+                    counts.inProgress++;
+                else
+                    counts.pending++;
+            }
+            return `Tracking ${counts.total} todo${counts.total !== 1 ? "s" : ""}: ${counts.completed} done · ${counts.inProgress} in progress · ${counts.pending} queued.`;
+        },
+    });
     // Vision-tool gate: drop the 3 vision-proxy tools on turns with no plausible
     // image involvement. Built then deleted (closures are cheap) to avoid
     // re-indenting the tool definitions above. todo_write + core tools untouched.

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.6.6",
+  "version": "1.7.0",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",

package/dist/src/gsd/__tests__/complexity.test.d.ts

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

package/dist/src/gsd/complexity.d.ts

@@ -1,28 +0,0 @@
-/**
- * src/gsd/complexity.ts
- *
- * Heuristic complexity scorer for incoming prompts.
- * Maps a raw user prompt to one of three tiers that drive the GSD directive
- * injected by layer4:
- *
- *   - "heavy"    → multi-file / multi-repo / architectural / "do everything"
- *                  Triggers the full discuss → research → verify → plan → impl → verify flow.
- *   - "standard" → ordinary feature/bugfix work. GSD-quick mindset.
- *   - "quick"    → trivial single-shot tasks (typo, rename, read-and-explain).
- *
- * The scorer is intentionally cheap: regex + length checks. It runs inside the
- * 200ms PIL budget and must never throw.
- */
-export type ComplexityTier = "quick" | "standard" | "heavy";
-export interface ComplexitySignal {
-    /** Short tag identifying which heuristic fired (e.g. "multi-repo", "wholesale"). */
-    tag: string;
-    /** Weight contributed to the score. Positive = heavier, negative = lighter. */
-    weight: number;
-}
-export interface ComplexityResult {
-    tier: ComplexityTier;
-    score: number;
-    signals: ComplexitySignal[];
-}
-export declare function scoreComplexity(prompt: string): ComplexityResult;

package/dist/src/gsd/complexity.js

@@ -1,103 +0,0 @@
-/**
- * src/gsd/complexity.ts
- *
- * Heuristic complexity scorer for incoming prompts.
- * Maps a raw user prompt to one of three tiers that drive the GSD directive
- * injected by layer4:
- *
- *   - "heavy"    → multi-file / multi-repo / architectural / "do everything"
- *                  Triggers the full discuss → research → verify → plan → impl → verify flow.
- *   - "standard" → ordinary feature/bugfix work. GSD-quick mindset.
- *   - "quick"    → trivial single-shot tasks (typo, rename, read-and-explain).
- *
- * The scorer is intentionally cheap: regex + length checks. It runs inside the
- * 200ms PIL budget and must never throw.
- */
-/** Patterns that strongly suggest a large, multi-step undertaking. */
-const HEAVY_PATTERNS = [
-    { tag: "wholesale", pattern: /\b(toàn bộ|all of|entire|whole|everything|tất cả)\b/i, weight: 3 },
-    { tag: "deep-map", pattern: /\b(deep[-\s]?map|repo[-\s]?map|map (the )?(codebase|project|repo))\b/i, weight: 3 },
-    { tag: "redo", pattern: /\b(redo|rewrite|rebuild|migrate (the )?entire|port (the )?(whole|entire))\b/i, weight: 3 },
-    {
-        tag: "from-scratch",
-        pattern: /\b(from[-\s]scratch|greenfield|new project|khởi tạo (project|dự án))\b/i,
-        weight: 2,
-    },
-    { tag: "architecture", pattern: /\b(architect(?:ure)?|system design|design contract|domain model)\b/i, weight: 2 },
-    { tag: "milestone", pattern: /\b(milestone|roadmap|epic|phase \d+|sprint \d+)\b/i, weight: 2 },
-    { tag: "multi-repo", pattern: /\b(multi[-\s]repo|across repos|every repo|all repos|cross[-\s]repo)\b/i, weight: 3 },
-    { tag: "refactor-wide", pattern: /\b(refactor (the )?(entire|whole|all))\b/i, weight: 3 },
-    { tag: "i18n", pattern: /\b(i18n|internationali[sz]e|localization|translation pipeline)\b/i, weight: 2 },
-    { tag: "auth-system", pattern: /\b(auth(entication)? system|sso|oauth flow|rbac)\b/i, weight: 2 },
-    { tag: "many-files", pattern: /\b(\d{2,})\s+(files?|modules?|services?)\b/i, weight: 2 },
-];
-/** Patterns that suggest a tiny, one-shot task. */
-const QUICK_PATTERNS = [
-    { tag: "typo", pattern: /\b(typo|misspell|spelling)\b/i, weight: -3 },
-    { tag: "rename", pattern: /\b(rename (this|the|a) (var|variable|function|file)|đổi tên)\b/i, weight: -2 },
-    {
-        tag: "read-explain",
-        pattern: /^(what (does|is)|how (does|do|is)|explain|giải thích|là gì|nghĩa là)\b/i,
-        weight: -2,
-    },
-    { tag: "single-line", pattern: /\b(one[-\s]liner|single line|một dòng)\b/i, weight: -2 },
-    { tag: "lookup", pattern: /\b(where is|find the|locate|tìm)\b/i, weight: -1 },
-];
-/** Words that, when stacked, indicate orchestration vs single task. */
-const COORDINATION_MARKERS = [
-    /\b(?:and then|sau đó|tiếp theo|after that|followed by)\b/gi,
-    /\b(?:multiple|several|many|nhiều)\b/gi,
-];
-const HEAVY_THRESHOLD = 4;
-const QUICK_THRESHOLD = -2;
-const LONG_PROMPT_CHARS = 500;
-const SHORT_PROMPT_CHARS = 60;
-export function scoreComplexity(prompt) {
-    const signals = [];
-    let score = 0;
-    if (!prompt || prompt.trim().length === 0) {
-        return { tier: "quick", score: 0, signals: [{ tag: "empty", weight: 0 }] };
-    }
-    for (const { tag, pattern, weight } of HEAVY_PATTERNS) {
-        if (pattern.test(prompt)) {
-            signals.push({ tag, weight });
-            score += weight;
-        }
-    }
-    for (const { tag, pattern, weight } of QUICK_PATTERNS) {
-        if (pattern.test(prompt)) {
-            signals.push({ tag, weight });
-            score += weight;
-        }
-    }
-    // Coordination words: each match adds 1 point (capped at +3).
-    let coordinationHits = 0;
-    for (const re of COORDINATION_MARKERS) {
-        const matches = prompt.match(re);
-        if (matches)
-            coordinationHits += matches.length;
-    }
-    if (coordinationHits > 0) {
-        const weight = Math.min(coordinationHits, 3);
-        signals.push({ tag: "coordination", weight });
-        score += weight;
-    }
-    // Length heuristics.
-    if (prompt.length >= LONG_PROMPT_CHARS) {
-        signals.push({ tag: "long-prompt", weight: 1 });
-        score += 1;
-    }
-    else if (prompt.length <= SHORT_PROMPT_CHARS) {
-        signals.push({ tag: "short-prompt", weight: -1 });
-        score -= 1;
-    }
-    let tier;
-    if (score >= HEAVY_THRESHOLD)
-        tier = "heavy";
-    else if (score <= QUICK_THRESHOLD)
-        tier = "quick";
-    else
-        tier = "standard";
-    return { tier, score, signals };
-}
-//# sourceMappingURL=complexity.js.map