muonroi-cli 1.8.1 → 1.8.4

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

@@ -1,188 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Mock all layer dependencies before importing pipeline
-vi.mock("../../router/classifier/index.js", () => ({
-    classify: vi.fn().mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" }),
-}));
-vi.mock("../../ee/bridge.js", () => ({
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    routeTask: vi.fn().mockResolvedValue(null),
-    getWhoAmIProfile: vi.fn(() => null),
-    outputStyleFromProfile: vi.fn(() => null),
-}));
-import { classify } from "../../router/classifier/index.js";
-import { runPipeline } from "../pipeline.js";
-import { getPilLastResult } from "../store.js";
-const mockClassify = vi.mocked(classify);
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-});
-describe("runPipeline()", () => {
-    it("returns PipelineContext with 7 LayerResults for normal input", async () => {
-        const ctx = await runPipeline("refactor this function");
-        expect(ctx.raw).toBe("refactor this function");
-        expect(ctx.layers).toHaveLength(7);
-    });
-    it("returns enriched that starts with raw (layers may append hints)", async () => {
-        const ctx = await runPipeline("some prompt");
-        expect(ctx.enriched.startsWith(ctx.raw)).toBe(true);
-    });
-    it("if layer2 throws, pipeline still returns a valid context (fail-open)", async () => {
-        vi.doMock("../layer2-personality.js", () => ({
-            layer2Personality: vi.fn().mockRejectedValue(new Error("layer2 failed")),
-        }));
-        const ctx = await runPipeline("some prompt");
-        expect(ctx).toBeDefined();
-        expect(ctx.raw).toBeDefined();
-    });
-    it("after runPipeline(), getPilLastResult() returns the result", async () => {
-        const ctx = await runPipeline("test prompt for store");
-        const stored = getPilLastResult();
-        expect(stored).toBe(ctx);
-    });
-    it('runPipeline("") returns valid PipelineContext with raw="" and enriched=""', async () => {
-        const ctx = await runPipeline("");
-        expect(ctx.raw).toBe("");
-        expect(ctx.enriched.startsWith(ctx.raw)).toBe(true);
-        expect(ctx.layers).toHaveLength(7);
-    });
-    it("conversational turn (taskType=null) skips layers 2-5 with delta=skipped:null-taskType", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        const ctx = await runPipeline("hello how are you");
-        expect(ctx.layers).toHaveLength(7);
-        expect(ctx.layers[1].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[2].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[3].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[4].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[5].delta).toBe("skipped:null-taskType");
-        expect(ctx.taskType).toBeNull();
-    });
-    it("coding task runs all 7 layers normally (no skip)", async () => {
-        const ctx = await runPipeline("refactor this function");
-        expect(ctx.layers).toHaveLength(7);
-        expect(ctx.taskType).toBe("refactor");
-        // layers 2-5 (which include indices 1 to 5) should NOT have skipped delta
-        for (let i = 1; i <= 5; i++) {
-            expect(ctx.layers[i].delta).not.toBe("skipped:null-taskType");
-        }
-    });
-    it("felt-experience prompt injects the session snapshot even when taskType is null", async () => {
-        // Regression: the felt-experience injection was first placed INSIDE the
-        // `taskType !== null` branch, so a "cảm nhận trong CLI" question that
-        // classifies to null (not a coding task) silently skipped it. It must run
-        // regardless of taskType.
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        const ctx = await runPipeline("bạn có bị mù context không trong session này, cảm nhận thế nào");
-        expect(ctx.taskType).toBeNull();
-        expect(ctx.layers.find((l) => l.name === "session-experience")?.applied).toBe(true);
-        expect(ctx.enriched).toContain("[session experience —");
-        expect(ctx.enriched).toMatch(/not by reading the CLI source/i);
-    });
-    it("plain evaluate-the-CLI prompt does NOT inject the session snapshot", async () => {
-        const ctx = await runPipeline("đánh giá agent bên trong cli và đề xuất cải thiện");
-        expect(ctx.layers.find((l) => l.name === "session-experience")).toBeUndefined();
-        expect(ctx.enriched).not.toContain("[session experience —");
-    });
-    it("metrics.totalMs is a non-negative number", async () => {
-        const ctx = await runPipeline("refactor this");
-        expect(ctx.metrics).not.toBeNull();
-        expect(ctx.metrics.totalMs).toBeGreaterThanOrEqual(0);
-    });
-    it("metrics.layerTimings has 7 entries (6 layers + discovery phase)", async () => {
-        const ctx = await runPipeline("refactor this");
-        // 6 standard layer timings + 1 discovery phase timing when discovery is enabled
-        expect(ctx.metrics.layerTimings.length).toBeGreaterThanOrEqual(6);
-    });
-    it("metrics.inputChars equals raw.length", async () => {
-        const ctx = await runPipeline("hello world");
-        if (ctx.metrics) {
-            expect(ctx.metrics.inputChars).toBe("hello world".length);
-        }
-        else {
-            // Pipeline timed out (200ms race) — fallback context has null metrics. Acceptable.
-            expect(ctx.raw).toBe("hello world");
-        }
-    });
-    it("metrics.enrichmentTokensAdded is a non-negative number", async () => {
-        const ctx = await runPipeline("refactor this function");
-        if (ctx.metrics) {
-            expect(ctx.metrics.enrichmentTokensAdded).toBeGreaterThanOrEqual(0);
-        }
-        else {
-            // Pipeline timed out (200ms race) — fallback context has null metrics. Acceptable.
-            expect(ctx.raw).toBe("refactor this function");
-        }
-    });
-    it("metrics.enrichmentTokensAdded is 0 for conversational turn", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        const ctx = await runPipeline("hello how are you");
-        expect(ctx.metrics.enrichmentTokensAdded).toBe(0);
-    });
-    it("fallback/timeout path has metrics: null", async () => {
-        // The fallback object has metrics: null
-        const { resolveAfter } = await import("../timeout.js");
-        const fallback = {
-            raw: "x",
-            enriched: "x",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const result = await resolveAfter(1, fallback);
-        expect(result.metrics).toBeNull();
-    });
-    it("timeout scenario: pipeline resolving after 200ms returns fallback ctx with layers=[]", async () => {
-        vi.useFakeTimers();
-        // Import a version where we can control timing
-        // We'll mock the layer execution to be slow
-        vi.doMock("../layer1-intent.js", () => ({
-            layer1Intent: vi.fn().mockImplementation(async (ctx) => {
-                // This will never resolve in the fake timer context before we advance
-                await new Promise((resolve) => setTimeout(resolve, 5000));
-                return ctx;
-            }),
-        }));
-        // We need a fresh import of pipeline with the slow mock
-        // Since vitest module caching is complex, we test the timeout logic directly
-        // by verifying the fallback structure
-        const { resolveAfter } = await import("../timeout.js");
-        // Verify resolveAfter returns value after ms
-        const fallback = {
-            raw: "timeout-test",
-            enriched: "timeout-test",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const resultPromise = resolveAfter(200, fallback);
-        vi.advanceTimersByTime(201);
-        const result = await resultPromise;
-        expect(result).toBe(fallback);
-        expect(result.layers).toHaveLength(0);
-        expect(result.taskType).toBeNull();
-        vi.useRealTimers();
-    });
-    it("skip-path timings use canonical layerN-* names (no 'layer-' prefix)", async () => {
-        // Force classifier to abstain so taskType stays null and skip-path triggers.
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0, reason: "regex:no-match" });
-        const { runPipeline } = await import("../pipeline.js");
-        const result = await runPipeline("@@@@@ @@@@@ @@@@@ @@@@@");
-        const timingNames = result.metrics?.layerTimings.map((t) => t.name) ?? [];
-        expect(timingNames).toContain("layer2-personality");
-        expect(timingNames).toContain("layer3-ee-injection");
-        expect(timingNames).toContain("layer4-gsd-structuring");
-        expect(timingNames).toContain("layer5-context-enrichment");
-        expect(timingNames).not.toContain("layer-personality-adaptation");
-    });
-});
-//# sourceMappingURL=pipeline.test.js.map

package/dist/src/pil/__tests__/renderer-coverage.test.d.ts

@@ -1,7 +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).
- */
-export {};

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 {};