muonroi-cli 1.2.0

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

@@ -0,0 +1,139 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { applyPilSuffix, 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),
+}));
+
+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));
+  });
+});
+
+describe("applyPilSuffix — outputStyle variants", () => {
+  const styles: OutputStyle[] = ["concise", "detailed", "balanced"];
+
+  it("each style produces a different suffix for the same taskType", () => {
+    const suffixes = styles.map((s) => applyPilSuffix("", makeCtx("refactor", s)));
+    const unique = new Set(suffixes);
+    expect(unique.size).toBe(styles.length);
+  });
+
+  it.each(styles)("detailed suffix is longer than concise for taskType=debug (style=%s check)", (style) => {
+    const result = applyPilSuffix("", makeCtx("debug", style));
+    expect(result).toContain("OUTPUT RULES (debug)");
+  });
+
+  it("detailed suffix allows explanation", () => {
+    const result = applyPilSuffix("", makeCtx("refactor", "detailed"));
+    expect(result).toContain("full rationale");
+  });
+
+  it("concise suffix restricts prose", () => {
+    const result = applyPilSuffix("", makeCtx("refactor", "concise"));
+    expect(result).toContain("No prose");
+  });
+});
+
+describe("layer6Output — style usage (detection moved to L1)", () => {
+  it("uses ctx.outputStyle from L1/L2 directly — no brain call", async () => {
+    const result = await layer6Output(makeCtx("debug", "concise"));
+    expect(result.layers[0].delta).toContain("style=concise");
+  });
+
+  it("defaults to concise when ctx.outputStyle is null", async () => {
+    const result = await layer6Output(makeCtx("debug", null));
+    expect(result.layers[0].delta).toContain("style=concise");
+  });
+
+  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("uses detailed style when passed from L1", async () => {
+    const result = await layer6Output(makeCtx("plan", "detailed"));
+    expect(result.layers[0].delta).toContain("style=detailed");
+  });
+});
+
+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("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__/ollama-classify.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ollamaClassify } from "../ollama-classify.js";
+
+const originalFetch = globalThis.fetch;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+function mockFetch(response: unknown, ok = true) {
+  globalThis.fetch = vi.fn().mockResolvedValue({
+    ok,
+    json: () => Promise.resolve(response),
+  });
+}
+
+describe("ollamaClassify", () => {
+  it("returns taskType when Ollama responds with valid category", async () => {
+    mockFetch({ response: "debug" });
+    const result = await ollamaClassify("something is broken");
+    expect(result).toEqual({ taskType: "debug", confidence: 0.55 });
+  });
+
+  it('returns taskType for "refactor" response', async () => {
+    mockFetch({ response: "refactor" });
+    const result = await ollamaClassify("clean up this code");
+    expect(result).toEqual({ taskType: "refactor", confidence: 0.55 });
+  });
+
+  it('returns null when Ollama responds with "none"', async () => {
+    mockFetch({ response: "none" });
+    const result = await ollamaClassify("hello world");
+    expect(result).toBeNull();
+  });
+
+  it("returns null when Ollama responds with unrecognized text", async () => {
+    mockFetch({ response: "I think this is a question about cooking" });
+    const result = await ollamaClassify("how to make pasta");
+    expect(result).toBeNull();
+  });
+
+  it("returns null when fetch throws (Ollama unavailable)", async () => {
+    globalThis.fetch = vi.fn().mockRejectedValue(new Error("ECONNREFUSED"));
+    const result = await ollamaClassify("test prompt");
+    expect(result).toBeNull();
+  });
+
+  it("returns null when response is not ok (500)", async () => {
+    mockFetch({}, false);
+    const result = await ollamaClassify("test prompt");
+    expect(result).toBeNull();
+  });
+
+  it("returns null when fetch is aborted (timeout)", async () => {
+    globalThis.fetch = vi.fn().mockRejectedValue(new DOMException("Aborted", "AbortError"));
+    const result = await ollamaClassify("test prompt");
+    expect(result).toBeNull();
+  });
+
+  it("confidence is always 0.55 for Ollama results", async () => {
+    mockFetch({ response: "plan" });
+    const result = await ollamaClassify("design the architecture");
+    expect(result?.confidence).toBe(0.55);
+  });
+
+  it("handles empty response field gracefully", async () => {
+    mockFetch({ response: "" });
+    const result = await ollamaClassify("test");
+    expect(result).toBeNull();
+  });
+
+  it("handles missing response field gracefully", async () => {
+    mockFetch({});
+    const result = await ollamaClassify("test");
+    expect(result).toBeNull();
+  });
+});

package/src/pil/__tests__/orchestrator-integration.test.ts

@@ -0,0 +1,107 @@
+/**
+ * src/pil/__tests__/orchestrator-integration.test.ts
+ *
+ * Integration-level unit tests verifying the PIL orchestrator contract:
+ * - enriched message is used when pipeline succeeds
+ * - applyPilSuffix injects OUTPUT RULES suffix for coding taskTypes
+ * - applyPilSuffix skips suffix when taskType is null
+ * - catch fallback uses raw message (fail-open contract)
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PipelineContext } from "../types.js";
+
+// Mock classifier and EE bridge 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),
+}));
+
+import { applyPilSuffix, runPipeline } from "../index.js";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("PIL orchestrator contract", () => {
+  it("enriched message is used when pipeline succeeds", async () => {
+    const ctx = await runPipeline("refactor this function");
+    // Layer 2 personality now appends hints, so enriched starts with raw
+    expect(ctx.enriched.startsWith("refactor this function")).toBe(true);
+    expect(ctx.layers).toHaveLength(6);
+  });
+
+  it("applyPilSuffix appends OUTPUT RULES suffix for coding taskType (non-null)", () => {
+    const codingCtx: PipelineContext = {
+      raw: "refactor the loop",
+      enriched: "refactor the loop",
+      taskType: "refactor",
+      domain: null,
+      confidence: 0.85,
+      outputStyle: "concise",
+      tokenBudget: 500,
+      metrics: null,
+      layers: [],
+    };
+    const base = "You are a helpful assistant.";
+    const result = applyPilSuffix(base, codingCtx);
+    expect(result).toContain("OUTPUT RULES");
+    expect(result.startsWith(base)).toBe(true);
+  });
+
+  it("applyPilSuffix does NOT append suffix when taskType is null", () => {
+    const nullCtx: PipelineContext = {
+      raw: "hello world",
+      enriched: "hello world",
+      taskType: null,
+      domain: null,
+      confidence: 0,
+      outputStyle: null,
+      tokenBudget: 500,
+      metrics: null,
+      layers: [],
+    };
+    const base = "You are a helpful assistant.";
+    const result = applyPilSuffix(base, nullCtx);
+    expect(result).toBe(base);
+    expect(result).not.toContain("OUTPUT RULES");
+  });
+
+  it("catch fallback uses raw userMessage (fail-open contract matches orchestrator .catch())", async () => {
+    // Simulate the catch block in orchestrator:
+    // const pilCtx = await runPipeline(userMessage).catch(() => ({
+    //   raw: userMessage, enriched: userMessage, taskType: null, domain: null, layers: [],
+    // }));
+    const userMessage = "some user prompt";
+    const fallback: PipelineContext = {
+      raw: userMessage,
+      enriched: userMessage,
+      taskType: null,
+      domain: null,
+      confidence: 0,
+      outputStyle: null,
+      tokenBudget: 500,
+      metrics: null,
+      layers: [],
+    };
+    // Verify fallback structure matches orchestrator catch shape
+    expect(fallback.enriched).toBe(userMessage);
+    expect(fallback.taskType).toBeNull();
+    expect(fallback.layers).toHaveLength(0);
+    // applyPilSuffix must return base unchanged for this fallback (taskType null)
+    const base = "System prompt";
+    expect(applyPilSuffix(base, fallback)).toBe(base);
+  });
+
+  it("runPipeline stores result — getPilLastResult returns same reference", async () => {
+    const { getPilLastResult } = await import("../index.js");
+    const ctx = await runPipeline("check store after pipeline");
+    const stored = getPilLastResult();
+    expect(stored).toBe(ctx);
+  });
+});

package/src/pil/__tests__/pipeline.test.ts

@@ -0,0 +1,173 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PipelineContext } from "../types.js";
+
+// 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),
+}));
+
+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 6 LayerResults for normal input", async () => {
+    const ctx = await runPipeline("refactor this function");
+    expect(ctx.raw).toBe("refactor this function");
+    expect(ctx.layers).toHaveLength(6);
+  });
+
+  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(6);
+  });
+
+  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(6);
+    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.taskType).toBeNull();
+  });
+
+  it("coding task runs all 6 layers normally (no skip)", async () => {
+    const ctx = await runPipeline("refactor this function");
+    expect(ctx.layers).toHaveLength(6);
+    expect(ctx.taskType).toBe("refactor");
+    // layers 2-5 should NOT have skipped delta
+    for (let i = 1; i <= 4; i++) {
+      expect(ctx.layers[i].delta).not.toBe("skipped:null-taskType");
+    }
+  });
+
+  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 6 entries", async () => {
+    const ctx = await runPipeline("refactor this");
+    expect(ctx.metrics!.layerTimings).toHaveLength(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");
+    expect(ctx.metrics).not.toBeNull();
+    expect(ctx.metrics!.enrichmentTokensAdded).toBeGreaterThanOrEqual(0);
+  });
+
+  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: PipelineContext = {
+      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: PipelineContext) => {
+        // This will never resolve in the fake timer context before we advance
+        await new Promise<void>((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: PipelineContext = {
+      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();
+  });
+});

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

@@ -0,0 +1,165 @@
+import { describe, expect, it } from "vitest";
+import {
+  AnalyzeSchema,
+  buildResponseTools,
+  DebugSchema,
+  DocsSchema,
+  GeneralSchema,
+  GenerateSchema,
+  getResponseTaskType,
+  isResponseTool,
+  PlanSchema,
+  RefactorSchema,
+  RESPONSE_TOOL_PREFIX,
+} from "../response-tools";
+
+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"] as const) {
+      const tools = buildResponseTools(taskType);
+      expect(Object.keys(tools)).toHaveLength(1);
+      expect(Object.keys(tools)[0]).toBe(`${RESPONSE_TOOL_PREFIX}${taskType}`);
+    }
+  });
+});
+
+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);
+  });
+});
+
+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);
+  });
+});