muonroi-cli 1.8.0 → 1.8.3

package/dist/src/pil/__tests__/renderer-coverage.test.js

@@ -1,42 +0,0 @@
-/**
- * Build-time guard: every PIL response schema must have a UI renderer case in
- * StructuredResponseView (src/ui/app.tsx). Without this, adding a new taskType
- * + schema and forgetting to update the UI silently falls back to raw-JSON
- * dump (or the graceful "renderer missing" warning).
- */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { describe, expect, it } from "vitest";
-describe("StructuredResponseView renderer coverage", () => {
-    it("has a case for every RESPONSE_SCHEMAS key", async () => {
-        // Pull canonical schema map by reading the source — keeps this test
-        // independent of any future re-export shuffling.
-        const responseToolsSrc = readFileSync(resolve("src/pil/response-tools.ts"), "utf8");
-        const mapMatch = responseToolsSrc.match(/RESPONSE_SCHEMAS[^=]*=\s*\{([\s\S]*?)\n\}/);
-        expect(mapMatch, "could not locate RESPONSE_SCHEMAS literal").toBeTruthy();
-        const schemaKeys = Array.from(mapMatch[1].matchAll(/^\s*(\w+)\s*:/gm)).map((m) => m[1]);
-        expect(schemaKeys.length).toBeGreaterThan(0);
-        // The codebase has TWO consumers of sr.taskType: the React renderer
-        // (src/ui/components/structured-response-view.tsx) and the text formatter
-        // (`_formatStructuredResponse` in src/ui/app.tsx). Both must cover every key.
-        // Note: after the app.tsx split, the React renderer switch lives in
-        // structured-response-view.tsx — scan both files.
-        const appSrc = readFileSync(resolve("src/ui/app.tsx"), "utf8");
-        const rendererSrc = readFileSync(resolve("src/ui/components/structured-response-view.tsx"), "utf8");
-        const combinedSrc = `${appSrc}\n${rendererSrc}`;
-        const switchOffsets = [];
-        let idx = 0;
-        while ((idx = combinedSrc.indexOf("switch (sr.taskType)", idx)) !== -1) {
-            switchOffsets.push(idx);
-            idx += 1;
-        }
-        expect(switchOffsets.length, "expected at least 2 switches on sr.taskType").toBeGreaterThanOrEqual(2);
-        for (const start of switchOffsets) {
-            const body = combinedSrc.slice(start, start + 8000);
-            const caseKeys = Array.from(body.matchAll(/case\s+"(\w+)"\s*:/g)).map((m) => m[1]);
-            const missing = schemaKeys.filter((k) => !caseKeys.includes(k));
-            expect(missing, `switch at offset ${start} missing case(s): ${missing.join(", ")}`).toEqual([]);
-        }
-    });
-});
-//# sourceMappingURL=renderer-coverage.test.js.map

package/dist/src/pil/__tests__/response-tools.test.d.ts

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

package/dist/src/pil/__tests__/response-tools.test.js

@@ -1,242 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { AnalyzeSchema, buildResponseTools, DebugSchema, DocsSchema, GeneralSchema, GenerateSchema, getResponseTaskType, isResponseTool, PlanSchema, RESPONSE_TOOL_PREFIX, RefactorSchema, shouldHaltOnResponseTool, stepEmittedResponseTool, } from "../response-tools.js";
-const step = (...names) => ({
-    toolCalls: names.map((toolName) => ({ toolName })),
-});
-describe("isResponseTool", () => {
-    it("returns true for response tool names", () => {
-        expect(isResponseTool("respond_refactor")).toBe(true);
-        expect(isResponseTool("respond_debug")).toBe(true);
-        expect(isResponseTool("respond_plan")).toBe(true);
-    });
-    it("returns false for action tools", () => {
-        expect(isResponseTool("bash")).toBe(false);
-        expect(isResponseTool("read_file")).toBe(false);
-        expect(isResponseTool("edit_file")).toBe(false);
-    });
-});
-describe("getResponseTaskType", () => {
-    it("extracts task type from tool name", () => {
-        expect(getResponseTaskType("respond_refactor")).toBe("refactor");
-        expect(getResponseTaskType("respond_debug")).toBe("debug");
-        expect(getResponseTaskType("respond_plan")).toBe("plan");
-        expect(getResponseTaskType("respond_analyze")).toBe("analyze");
-        expect(getResponseTaskType("respond_documentation")).toBe("documentation");
-        expect(getResponseTaskType("respond_generate")).toBe("generate");
-    });
-    it("returns null for unknown task types", () => {
-        expect(getResponseTaskType("respond_unknown")).toBeNull();
-        expect(getResponseTaskType("bash")).toBeNull();
-    });
-});
-describe("buildResponseTools", () => {
-    it("returns a ToolSet with one tool for valid task type", () => {
-        const tools = buildResponseTools("refactor");
-        expect(Object.keys(tools)).toEqual(["respond_refactor"]);
-        expect(tools.respond_refactor.description).toContain("refactor");
-        expect(tools.respond_refactor.inputSchema).toBeDefined();
-        expect(tools.respond_refactor.execute).toBeTypeOf("function");
-    });
-    it("execute returns input unchanged", async () => {
-        const tools = buildResponseTools("debug");
-        const input = {
-            hypothesis: "test",
-            root_cause: "bug",
-            fix: { file: "a.ts", diff: "+" },
-            verify_command: "npm test",
-        };
-        const result = await tools.respond_debug.execute(input, {
-            toolCallId: "1",
-            messages: [],
-            abortSignal: new AbortController().signal,
-        });
-        expect(result).toEqual(input);
-    });
-    it("builds tools for all 6 task types", () => {
-        for (const taskType of ["refactor", "debug", "plan", "analyze", "documentation", "generate"]) {
-            const tools = buildResponseTools(taskType);
-            expect(Object.keys(tools)).toHaveLength(1);
-            expect(Object.keys(tools)[0]).toBe(`${RESPONSE_TOOL_PREFIX}${taskType}`);
-        }
-    });
-});
-describe("stepEmittedResponseTool", () => {
-    it("returns true when a step emitted a response tool", () => {
-        expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "respond_general" }] })).toBe(true);
-        expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "read_file" }, { toolName: "respond_analyze" }] })).toBe(true);
-    });
-    it("returns false for action-only steps", () => {
-        expect(stepEmittedResponseTool({ toolCalls: [{ toolName: "bash" }, { toolName: "read_file" }] })).toBe(false);
-    });
-    it("returns false for steps with no tool calls", () => {
-        expect(stepEmittedResponseTool({ toolCalls: [] })).toBe(false);
-        expect(stepEmittedResponseTool({})).toBe(false);
-        expect(stepEmittedResponseTool(undefined)).toBe(false);
-    });
-    it("ignores malformed entries without a toolName", () => {
-        expect(stepEmittedResponseTool({ toolCalls: [{}, { toolName: undefined }] })).toBe(false);
-    });
-});
-describe("shouldHaltOnResponseTool", () => {
-    it("does not halt when the last step did not emit a response tool", () => {
-        expect(shouldHaltOnResponseTool([step("read_file"), step("grep")])).toBe(false);
-        expect(shouldHaltOnResponseTool([])).toBe(false);
-        expect(shouldHaltOnResponseTool(undefined)).toBe(false);
-    });
-    it("halts on a response tool emitted AFTER real tool work (terminal answer)", () => {
-        // d95113d3 seq=27: 7 grep/read calls, THEN respond_general → halt at call #1.
-        expect(shouldHaltOnResponseTool([step("grep"), step("read_file"), step("read_file"), step("respond_general")])).toBe(true);
-        // Real work + response in the SAME step also counts as investigated.
-        expect(shouldHaltOnResponseTool([step("read_file", "respond_analyze")])).toBe(true);
-        // d95113d3 seq=3: deep investigation → single respond_analyze.
-        expect(shouldHaltOnResponseTool([step("bash"), step("read_file"), step("respond_analyze")])).toBe(true);
-    });
-    it("does NOT halt on a single blind response tool (no prior investigation)", () => {
-        // e4a9d97a90: lone blind respond_general at step 0 — give the model the
-        // step it announced it would use to read code instead of force-stopping.
-        expect(shouldHaltOnResponseTool([step("respond_general")])).toBe(false);
-    });
-    it("halts on a 2nd blind response tool with still no real work (narration loop)", () => {
-        // 9b1b3: 2× blind respond_general, zero investigation → bounded at 2.
-        expect(shouldHaltOnResponseTool([step("respond_general"), step("respond_general")])).toBe(true);
-    });
-    it("treats a blind response then real work then response as terminal (investigated)", () => {
-        // Announce → investigate → answer: the final response is after real work.
-        expect(shouldHaltOnResponseTool([step("respond_general"), step("read_file"), step("respond_general")])).toBe(true);
-    });
-});
-describe("schemas validate correct input", () => {
-    it("RefactorSchema accepts valid input", () => {
-        const result = RefactorSchema.safeParse({
-            summary: "Extract helper function",
-            changes: [{ file: "src/utils.ts", diff: "- old\n+ new" }],
-            verify_command: "bun test",
-        });
-        expect(result.success).toBe(true);
-    });
-    it("RefactorSchema rejects missing changes", () => {
-        const result = RefactorSchema.safeParse({ summary: "test" });
-        expect(result.success).toBe(false);
-    });
-    it("DebugSchema accepts valid input", () => {
-        const result = DebugSchema.safeParse({
-            hypothesis: "Race condition",
-            root_cause: "Shared mutable state",
-            fix: { file: "src/store.ts", diff: "+ const lock = new Mutex();" },
-            verify_command: "bun test",
-        });
-        expect(result.success).toBe(true);
-    });
-    it("PlanSchema accepts valid input", () => {
-        const result = PlanSchema.safeParse({
-            steps: [{ action: "Add tests", criterion: "Coverage > 80%" }],
-            assumptions: ["CI is green"],
-        });
-        expect(result.success).toBe(true);
-    });
-    it("AnalyzeSchema accepts valid input", () => {
-        const result = AnalyzeSchema.safeParse({
-            findings: [{ text: "SQL injection risk", evidence: "src/db.ts:42", severity: "high" }],
-        });
-        expect(result.success).toBe(true);
-    });
-    it("AnalyzeSchema rejects invalid severity", () => {
-        const result = AnalyzeSchema.safeParse({
-            findings: [{ text: "issue", evidence: "file:1", severity: "critical" }],
-        });
-        expect(result.success).toBe(false);
-    });
-    it("DocsSchema accepts valid input", () => {
-        const result = DocsSchema.safeParse({
-            content: "# API Reference\n\nUse `foo()` to...",
-            examples: [{ code: "foo()", description: "Basic usage" }],
-        });
-        expect(result.success).toBe(true);
-    });
-    it("GenerateSchema accepts valid input", () => {
-        const result = GenerateSchema.safeParse({
-            files: [{ path: "src/hello.ts", content: 'console.log("hi")', language: "typescript" }],
-        });
-        expect(result.success).toBe(true);
-    });
-    it("GeneralSchema accepts valid input with response only", () => {
-        const result = GeneralSchema.safeParse({ response: "The answer is 42." });
-        expect(result.success).toBe(true);
-    });
-    it("GeneralSchema accepts valid input with optional reasoning", () => {
-        const result = GeneralSchema.safeParse({ response: "Yes", reasoning: "Because it satisfies the constraints." });
-        expect(result.success).toBe(true);
-    });
-    it("GeneralSchema rejects missing response", () => {
-        const result = GeneralSchema.safeParse({ reasoning: "some reasoning" });
-        expect(result.success).toBe(false);
-    });
-});
-import { normalizeStructuredResponseTaskType } from "../response-tools.js";
-describe("respond_general catch-all tool", () => {
-    it("respond_general tool exists with correct schema", () => {
-        const tools = buildResponseTools("general");
-        expect(Object.keys(tools)).toEqual(["respond_general"]);
-        expect(tools.respond_general.description).toContain("general");
-        expect(tools.respond_general.inputSchema).toBeDefined();
-        expect(tools.respond_general.execute).toBeTypeOf("function");
-    });
-    it("getResponseTaskType returns 'general' for 'respond_general'", () => {
-        expect(getResponseTaskType("respond_general")).toBe("general");
-    });
-    it("isResponseTool returns true for 'respond_general'", () => {
-        expect(isResponseTool("respond_general")).toBe(true);
-    });
-});
-describe("normalizeStructuredResponseTaskType", () => {
-    // Regression: session 48d22fe436f6 — model called respond_analyze but sent
-    // { response: "..." } (general shape). TUI rendered empty findings box.
-    it("normalizes 'analyze' → 'general' when findings missing but response present", () => {
-        expect(normalizeStructuredResponseTaskType("analyze", { response: "Some analysis text" })).toBe("general");
-    });
-    it("keeps 'analyze' when findings array is present", () => {
-        expect(normalizeStructuredResponseTaskType("analyze", {
-            findings: [{ text: "issue", evidence: "file:1", severity: "high" }],
-        })).toBe("analyze");
-    });
-    it("normalizes 'debug' → 'general' when root_cause missing but response present", () => {
-        expect(normalizeStructuredResponseTaskType("debug", { response: "Bug is in the store" })).toBe("general");
-    });
-    it("keeps 'debug' when root_cause is present", () => {
-        expect(normalizeStructuredResponseTaskType("debug", {
-            hypothesis: "race condition",
-            root_cause: "shared mutable state",
-            fix: { file: "src/a.ts", diff: "+x" },
-            verify_command: "bun test",
-        })).toBe("debug");
-    });
-    it("normalizes 'plan' → 'general' when steps missing but response present", () => {
-        expect(normalizeStructuredResponseTaskType("plan", { response: "Step 1: do A" })).toBe("general");
-    });
-    it("normalizes 'refactor' → 'general' when changes missing but response present", () => {
-        expect(normalizeStructuredResponseTaskType("refactor", { response: "Refactored X" })).toBe("general");
-    });
-    it("normalizes 'documentation' → 'general' when content missing but response present", () => {
-        expect(normalizeStructuredResponseTaskType("documentation", { response: "Docs here" })).toBe("general");
-    });
-    it("normalizes 'generate' → 'general' when files missing but response present", () => {
-        expect(normalizeStructuredResponseTaskType("generate", { response: "Generated code" })).toBe("general");
-    });
-    it("keeps 'general' unchanged always", () => {
-        expect(normalizeStructuredResponseTaskType("general", { response: "hello" })).toBe("general");
-        expect(normalizeStructuredResponseTaskType("general", {})).toBe("general");
-    });
-    it("does NOT normalize when response field is empty string", () => {
-        expect(normalizeStructuredResponseTaskType("analyze", { response: "" })).toBe("analyze");
-    });
-    it("does NOT normalize when response field is whitespace-only", () => {
-        expect(normalizeStructuredResponseTaskType("analyze", { response: "   " })).toBe("analyze");
-    });
-    it("does NOT normalize when response field is missing entirely", () => {
-        expect(normalizeStructuredResponseTaskType("analyze", { summary: "Some summary" })).toBe("analyze");
-    });
-    it("keeps unknown taskType unchanged", () => {
-        expect(normalizeStructuredResponseTaskType("unknown_type", { response: "hello" })).toBe("unknown_type");
-    });
-});
-//# sourceMappingURL=response-tools.test.js.map

package/dist/src/pil/__tests__/schema.test.d.ts

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

package/dist/src/pil/__tests__/schema.test.js

@@ -1,202 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { OutputStyleSchema, PilContextResponseSchema, PipelineContextSchema, PipelineMetricsSchema, TaskTypeSchema, } from "../schema.js";
-describe("PipelineContextSchema", () => {
-    const validCtx = {
-        raw: "test",
-        enriched: "test",
-        taskType: "refactor",
-        domain: null,
-        confidence: 0.85,
-        outputStyle: "concise",
-        tokenBudget: 500,
-        metrics: null,
-        layers: [{ name: "intent-detection", applied: true, delta: "taskType=refactor" }],
-    };
-    it("accepts valid PipelineContext", () => {
-        const result = PipelineContextSchema.safeParse(validCtx);
-        expect(result.success).toBe(true);
-    });
-    it("accepts null taskType and outputStyle", () => {
-        const result = PipelineContextSchema.safeParse({
-            ...validCtx,
-            taskType: null,
-            outputStyle: null,
-        });
-        expect(result.success).toBe(true);
-    });
-    it("rejects confidence > 1", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, confidence: 1.5 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects confidence < 0", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, confidence: -0.1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid taskType", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, taskType: "invalid" });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid outputStyle", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, outputStyle: "verbose" });
-        expect(result.success).toBe(false);
-    });
-    it("rejects tokenBudget <= 0", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, tokenBudget: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("safeParse never throws", () => {
-        expect(() => PipelineContextSchema.safeParse(null)).not.toThrow();
-        expect(() => PipelineContextSchema.safeParse(undefined)).not.toThrow();
-        expect(() => PipelineContextSchema.safeParse(42)).not.toThrow();
-        expect(() => PipelineContextSchema.safeParse("string")).not.toThrow();
-    });
-    it("accepts valid metrics object", () => {
-        const result = PipelineContextSchema.safeParse({
-            ...validCtx,
-            metrics: {
-                totalMs: 5,
-                layerTimings: [{ name: "l1", ms: 2 }],
-                inputChars: 10,
-                outputChars: 10,
-                suffixInstructionTokens: 20,
-                enrichmentTokensAdded: 0,
-            },
-        });
-        expect(result.success).toBe(true);
-    });
-    it("accepts null metrics", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, metrics: null });
-        expect(result.success).toBe(true);
-    });
-});
-describe("PipelineMetricsSchema", () => {
-    it("accepts valid metrics", () => {
-        const result = PipelineMetricsSchema.safeParse({
-            totalMs: 10,
-            layerTimings: [],
-            inputChars: 5,
-            outputChars: 5,
-            suffixInstructionTokens: 0,
-            enrichmentTokensAdded: 0,
-        });
-        expect(result.success).toBe(true);
-    });
-    it("rejects negative totalMs", () => {
-        const result = PipelineMetricsSchema.safeParse({
-            totalMs: -1,
-            layerTimings: [],
-            inputChars: 0,
-            outputChars: 0,
-            suffixInstructionTokens: 0,
-            enrichmentTokensAdded: 0,
-        });
-        expect(result.success).toBe(false);
-    });
-});
-describe("TaskTypeSchema", () => {
-    it.each(["refactor", "debug", "plan", "analyze", "documentation", "generate"])("accepts %s", (t) => {
-        expect(TaskTypeSchema.safeParse(t).success).toBe(true);
-    });
-    it("rejects unknown type", () => {
-        expect(TaskTypeSchema.safeParse("unknown").success).toBe(false);
-    });
-});
-describe("OutputStyleSchema", () => {
-    it.each(["concise", "detailed", "balanced"])("accepts %s", (s) => {
-        expect(OutputStyleSchema.safeParse(s).success).toBe(true);
-    });
-    it("rejects unknown style", () => {
-        expect(OutputStyleSchema.safeParse("verbose").success).toBe(false);
-    });
-});
-describe("PilContextResponseSchema", () => {
-    const validResponse = {
-        taskType: "debug",
-        intentKind: "task",
-        outputStyle: "balanced",
-        confidence: 0.85,
-        domain: "typescript",
-        gsd_phase: "execute",
-        gsd_route_source: "ee",
-        t0_principles: [{ text: "principle one", score: 0.9 }],
-        t1_rules: ["always run tests after edit"],
-        t2_patterns: [{ text: "pattern one", score: 0.7 }],
-        retrieval_skipped_reason: null,
-        cache_hit: false,
-        inference_ms: 1234,
-        schema_version: "1.0",
-    };
-    it("accepts a complete valid response", () => {
-        const result = PilContextResponseSchema.safeParse(validResponse);
-        expect(result.success).toBe(true);
-    });
-    it("accepts nullable taskType / intentKind / domain / gsd_phase", () => {
-        const r = PilContextResponseSchema.safeParse({
-            ...validResponse,
-            taskType: null,
-            intentKind: null,
-            domain: null,
-            gsd_phase: null,
-        });
-        expect(r.success).toBe(true);
-    });
-    it("rejects when outputStyle is missing (must always be provided)", () => {
-        const { outputStyle, ...rest } = validResponse;
-        void outputStyle;
-        const r = PilContextResponseSchema.safeParse(rest);
-        expect(r.success).toBe(false);
-    });
-    it("rejects when confidence is out of [0,1]", () => {
-        const r = PilContextResponseSchema.safeParse({ ...validResponse, confidence: 1.5 });
-        expect(r.success).toBe(false);
-    });
-    it("rejects when schema_version is missing", () => {
-        const { schema_version, ...rest } = validResponse;
-        void schema_version;
-        const r = PilContextResponseSchema.safeParse(rest);
-        expect(r.success).toBe(false);
-    });
-    it("ignores unknown fields (forward-compat for v1.1)", () => {
-        const r = PilContextResponseSchema.safeParse({ ...validResponse, whoami_directives: ["x"] });
-        expect(r.success).toBe(true);
-    });
-});
-describe("PipelineContext _brainData field", () => {
-    it("PipelineContextSchema accepts optional _brainData", () => {
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-            _brainData: {
-                t0_principles: [{ text: "a", score: 0.8 }],
-                t1_rules: ["b"],
-                t2_patterns: [],
-                retrieval_skipped_reason: null,
-            },
-        };
-        const r = PipelineContextSchema.safeParse(ctx);
-        expect(r.success).toBe(true);
-    });
-    it("PipelineContextSchema accepts missing _brainData (legacy path)", () => {
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const r = PipelineContextSchema.safeParse(ctx);
-        expect(r.success).toBe(true);
-    });
-});
-//# sourceMappingURL=schema.test.js.map

package/dist/src/pil/__tests__/scoreComplexity.test.d.ts

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

package/dist/src/pil/__tests__/scoreComplexity.test.js

@@ -1,119 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { scoreComplexity } from "../layer1-intent.js";
-// Helper: build a string of exactly `n` characters (plain ASCII 'a').
-const str = (n) => "a".repeat(n);
-describe("scoreComplexity — signal isolation", () => {
-    it("1. empty text → score 0, complexity low", () => {
-        const out = scoreComplexity({ rawText: "", taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(0);
-        expect(out.complexity).toBe("low");
-    });
-    it("2. 100-char text → score 1 (length +1), complexity low", () => {
-        const out = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(1);
-        expect(out.complexity).toBe("low");
-    });
-    it("3. 250-char text → score 2 (length +2), complexity low", () => {
-        const out = scoreComplexity({ rawText: str(250), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(2);
-        expect(out.complexity).toBe("low");
-    });
-    it("4. 800-char text → score 3 (length +3), complexity medium", () => {
-        const out = scoreComplexity({ rawText: str(800), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(3);
-        expect(out.complexity).toBe("medium");
-    });
-    it("5. text with 2 file references + 60-char length → score 2, complexity low", () => {
-        // 60 chars ensures length +1; 2 file refs → +1; total = 2 → low
-        const base = "Update foo.ts and bar.py";
-        const padded = base + " ".repeat(60 - base.length);
-        const out = scoreComplexity({ rawText: padded, taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(2);
-        expect(out.complexity).toBe("low");
-    });
-    it("6. 'fix typo in readme' → keyword -3, score negative, complexity low", () => {
-        const out = scoreComplexity({
-            rawText: "fix typo in readme",
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(out.score).toBeLessThan(0);
-        expect(out.complexity).toBe("low");
-    });
-    it("7. high-complexity keywords → score ≥ 3 (medium/high), never low", () => {
-        // 'Architecture migration plan for multi-tenant SaaS' is 49 chars → length +0,
-        // FORCE_HIGH_RE matches → +3; score = 3 → medium per the bucketing table.
-        // A longer variant (200+ chars) pushes it to high.
-        const shortOut = scoreComplexity({
-            rawText: "Architecture migration plan for multi-tenant SaaS",
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(shortOut.score).toBeGreaterThanOrEqual(3);
-        expect(shortOut.complexity).not.toBe("low");
-        // 250-char version: length +2 + FORCE_HIGH_RE +3 = 5 → medium; still not low.
-        const medOut = scoreComplexity({
-            rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(200)}`,
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(medOut.score).toBeGreaterThanOrEqual(5);
-        expect(medOut.complexity).not.toBe("low");
-        // 600-char version: length +3 + FORCE_HIGH_RE +3 = 6 → high.
-        const highOut = scoreComplexity({
-            rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(560)}`,
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(highOut.score).toBeGreaterThanOrEqual(6);
-        expect(highOut.complexity).toBe("high");
-    });
-    it("8. hasMaxSprintsOne=true with short text → score -2, low", () => {
-        const out = scoreComplexity({ rawText: str(20), taskType: null, t0HitCount: 0, hasMaxSprintsOne: true });
-        // length=0, hasMaxSprintsOne=-2 → -2
-        expect(out.score).toBe(-2);
-        expect(out.complexity).toBe("low");
-    });
-    it("9. t0HitCount=5 reduces score by 1", () => {
-        const baseline = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        const withHits = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 5, hasMaxSprintsOne: false });
-        expect(withHits.score).toBe(baseline.score - 1);
-    });
-    it("10. taskType='debug' adds +1 (medium boundary case)", () => {
-        // 250 chars → length +2, debug +1 → 3 → medium
-        const out = scoreComplexity({ rawText: str(250), taskType: "debug", t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(3);
-        expect(out.complexity).toBe("medium");
-    });
-});
-describe("scoreComplexity — integration", () => {
-    it("11a. 'fix typo in README' → low", () => {
-        const out = scoreComplexity({
-            rawText: "fix typo in README.md",
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(out.complexity).toBe("low");
-    });
-    it("11b. 'refactor the auth subsystem' (60 chars + refactor keyword) → high", () => {
-        const text = "refactor the auth subsystem".padEnd(60, " ");
-        const out = scoreComplexity({ rawText: text, taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        // length=60 → +1, refactor kw → +3 → 4 → medium, but let's check actual
-        // 'refactor' matches FORCE_HIGH_RE (+3) + length 60 chars (+1) = 4 → medium
-        // The plan says "high" but 4 is medium with the current table.
-        // Per the plan: "60 chars + refactor kw → high" — reconcile: 60 chars = +1, refactor = +3 → 4 = medium.
-        // The plan description appears to be approximate; trust the heuristic table.
-        expect(out.score).toBeGreaterThanOrEqual(3);
-        expect(["medium", "high"]).toContain(out.complexity);
-    });
-    it("11c. 'build a counter' (short, no keywords) → low", () => {
-        const out = scoreComplexity({ rawText: "build a counter", taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.complexity).toBe("low");
-    });
-});
-//# sourceMappingURL=scoreComplexity.test.js.map

package/dist/src/pil/__tests__/scoreSufficiency.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Unit tests for scoreSufficiency — the context-sufficiency gate that decides
- * whether the /ideal dispatcher MUST force the Council path (and AskCard
- * discovery) regardless of complexity. Vague briefs like "todo app" are
- * exactly the case where an Agile team would stop and discover, not
- * scaffold-and-pray.
- */
-export {};