fix: stream Claude audit + engine catalog contract test

- claude-engine.ts: messages.parse → messages.stream + finalMessage.
  High-effort adaptive thinking + web_search/web_fetch routinely
  pushed the request past the SDK's 10-minute non-streaming HTTP
  ceiling, throwing "Streaming is required for operations that may
  take longer than 10 minutes." The streaming path preserves the
  exact parsed_output semantics we rely on.
- tests/contract/engines.test.ts: locks in the engine catalog
  (kimi stays disabled, cost math, dedupe, availability) so a future
  edit can't quietly re-enable kimi or change rule's free status.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ralyodio

lib/audit/claude-engine.ts

@@ -118,15 +118,15 @@ export async function claudeAudit(targetUrl: string): Promise<ClaudeAuditResult>
 
   const userPrompt = `Audit this URL: ${targetUrl}\nCompany name (for the report header): ${company}\n\nPretend you've never heard of this company. Use only the public web. Use web_fetch and web_search.`;
 
-  const response = await client.messages.parse({
+  // Stream the request — high-effort adaptive thinking + web tools routinely
+  // pushes past the SDK's 10-minute non-streaming HTTP timeout. `.finalMessage()`
+  // gives us the same ParsedMessage shape `.parse()` did.
+  const stream = client.messages.stream({
     model: "claude-opus-4-7",
     max_tokens: 64000,
     thinking: { type: "adaptive" },
     output_config: {
       effort: "high",
-      // SDK helper's type definition still expects v3 schemas; runtime is fine
-      // because the helper imports zod/v4 internally. Cast to any to silence
-      // the structural mismatch.
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       format: zodOutputFormat(ResultSchema as any),
     },
@@ -139,6 +139,7 @@ export async function claudeAudit(targetUrl: string): Promise<ClaudeAuditResult>
     ],
     messages: [{ role: "user", content: userPrompt }],
   });
+  const response = await stream.finalMessage();
 
   const parsed = response.parsed_output;
   if (!parsed) {

tests/contract/engines.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+import {
+  ENGINES,
+  type Engine,
+  dedupeEngines,
+  engineAvailable,
+  engineCost,
+  selectionCost,
+} from "@/lib/credits";
+
+const ALL_ENGINES: Engine[] = [
+  "rule",
+  "claude",
+  "openai",
+  "qwen",
+  "kimi",
+  "gemini",
+  "deepseek",
+];
+
+describe("ENGINES catalog", () => {
+  it("includes every engine the action accepts", () => {
+    for (const e of ALL_ENGINES) {
+      expect(ENGINES[e]).toBeDefined();
+      expect(typeof ENGINES[e].label).toBe("string");
+      expect(typeof ENGINES[e].blurb).toBe("string");
+      expect(typeof ENGINES[e].cost).toBe("number");
+      expect(typeof ENGINES[e].available).toBe("boolean");
+    }
+  });
+
+  it("rule is the only free engine", () => {
+    expect(ENGINES.rule.cost).toBe(0);
+    for (const e of ALL_ENGINES) {
+      if (e === "rule") continue;
+      expect(ENGINES[e].cost).toBeGreaterThan(0);
+    }
+  });
+
+  it("kimi stays disabled (Moonshot balance / 429 regression)", () => {
+    expect(ENGINES.kimi.available).toBe(false);
+  });
+
+  it("all engines except kimi are available", () => {
+    for (const e of ALL_ENGINES) {
+      if (e === "kimi") continue;
+      expect(ENGINES[e].available).toBe(true);
+    }
+  });
+});
+
+describe("engineCost / engineAvailable", () => {
+  it("engineCost matches the catalog", () => {
+    expect(engineCost("rule")).toBe(0);
+    expect(engineCost("claude")).toBe(1);
+    expect(engineCost("openai")).toBe(1);
+  });
+
+  it("engineAvailable reflects the available flag", () => {
+    expect(engineAvailable("rule")).toBe(true);
+    expect(engineAvailable("claude")).toBe(true);
+    expect(engineAvailable("kimi")).toBe(false);
+  });
+});
+
+describe("selectionCost", () => {
+  it("returns 0 for rule-only", () => {
+    expect(selectionCost(["rule"])).toBe(0);
+  });
+
+  it("sums one credit per paid engine, rule rides free", () => {
+    expect(selectionCost(["rule", "claude"])).toBe(1);
+    expect(selectionCost(["claude", "openai"])).toBe(2);
+    expect(selectionCost(["rule", "claude", "openai", "gemini"])).toBe(3);
+  });
+
+  it("returns 0 for an empty selection", () => {
+    expect(selectionCost([])).toBe(0);
+  });
+});
+
+describe("dedupeEngines", () => {
+  it("preserves first-seen order", () => {
+    expect(dedupeEngines(["claude", "rule", "openai"])).toEqual([
+      "claude",
+      "rule",
+      "openai",
+    ]);
+  });
+
+  it("collapses duplicates", () => {
+    expect(dedupeEngines(["rule", "rule", "claude", "claude"])).toEqual([
+      "rule",
+      "claude",
+    ]);
+  });
+
+  it("drops unknown engine names without throwing", () => {
+    const out = dedupeEngines([
+      "rule",
+      "not-an-engine" as Engine,
+      "claude",
+    ]);
+    expect(out).toEqual(["rule", "claude"]);
+  });
+
+  it("returns empty for empty input", () => {
+    expect(dedupeEngines([])).toEqual([]);
+  });
+});