@@ -134,6 +134,8 @@ Checkout and portal functions create Stripe sessions after authenticated ownersh
 
 All model requests use the single OpenRouter backend route and `OPENROUTER_API_KEY`. The shared ten-model catalog, its defaults (Claude Haiku 5.5 for Basic, Claude Opus 5.5 for Pro), Pro-only entries, retired-ID successors, and request controls live in [`supabase/functions/_shared/model-catalog.ts`](../supabase/functions/_shared/model-catalog.ts). OpenRouter usage remains raw in the audit row, and the reported charge is unknown when the provider does not return a complete cost. The opponent's voice is the one exception to the OpenRouter route: the `voice` function calls ElevenLabs with `ELEVENLABS_API_KEY`. ElevenLabs reports billed characters, not dollars, so [`supabase/functions/_shared/cost.ts`](../supabase/functions/_shared/cost.ts) prices those rows from a dated list-price snapshot; promotions and plan credits are not modelled, so a voice row can overstate the charge.
 
+Every model call asks for JSON. Calls whose shape the server checks in code (the Crossfire next turn and debrief, the Ask search decision, and research follow-up queries) send a strict JSON Schema, so OpenRouter routes them only to endpoints that enforce it; the other features use plain JSON mode. [`supabase/functions/ai/provider.ts`](../supabase/functions/ai/provider.ts) fixes common slips in a reply locally (markdown fences, prose around the object, trailing commas, raw line breaks in strings) before it pays for one repair retry, and it does not retry a reply the provider cut off at the output token cap.
+
 `Auto Fast` and `Auto Pro` are virtual selections, not provider model IDs. The Edge Functions resolve them through TypeSafe Jev on OpenRouter before calling the concrete writing model. Auto Fast is available to Basic accounts, routes only among the Basic models (Claude Haiku 5.5, GPT-6 Luna, Muse Spark 1.3 Contributor), and normally resolves to Claude Haiku 5.5. Auto Pro remains Pro-only and normally resolves to Claude Opus 5.5. Provider calls, usage rows, and response metadata record the concrete resolved model, while response metadata also retains the requested automatic selection. A Jev router call uses the same OpenRouter key and does not consume a second daily quota unit.
 
 ## Observability
 
@@ -1,3 +1,5 @@
+import type { JsonOutputSchema } from "./research.ts";
+
 export const MAX_CROSSFIRE_REPLY_CHARS = 2_500;
 export const MAX_CROSSFIRE_DEBRIEF_ITEMS = 8;
 export const MAX_CROSSFIRE_REFERENCE_IDS = 6;
@@ -81,6 +83,56 @@ function crossfireDebriefItem(
   return { value: { turnIds: turnIds.value, claim: value.claim.trim() } };
 }
 
+/**
+ * The provider-side shape of a debrief, mirroring validateCrossfireDebrief.
+ * Turn IDs are pinned to the transcript's, so a reply cannot cite a turn that
+ * does not exist. Counts, lengths, and duplicates stay with the validator.
+ */
+export function crossfireDebriefSchema(transcript: Array<{ id: string }>): JsonOutputSchema {
+  const ids = [...new Set(transcript.map((turn) => turn.id))];
+  const turnIds = { type: "array", items: ids.length ? { type: "string", enum: ids } : { type: "string" } };
+  const item = {
+    type: "object",
+    properties: { turnIds, claim: { type: "string" } },
+    required: ["turnIds", "claim"],
+    additionalProperties: false,
+  };
+  const items = { type: "array", items: item };
+  return {
+    name: "crossfire_debrief",
+    schema: {
+      type: "object",
+      properties: {
+        concessionsSecured: items,
+        controlledQuestions: items,
+        weakOrRepetitiveQuestions: items,
+        evasiveOrIncompleteAnswers: items,
+        missedFollowUps: items,
+        betterFollowUpQuestions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { turnIds, question: { type: "string" }, reason: { type: "string" } },
+            required: ["turnIds", "question", "reason"],
+            additionalProperties: false,
+          },
+        },
+        strongestExchange: { anyOf: [item, { type: "null" }] },
+      },
+      required: [
+        "concessionsSecured",
+        "controlledQuestions",
+        "weakOrRepetitiveQuestions",
+        "evasiveOrIncompleteAnswers",
+        "missedFollowUps",
+        "betterFollowUpQuestions",
+        "strongestExchange",
+      ],
+      additionalProperties: false,
+    },
+  };
+}
+
 export function validateCrossfireDebrief(
   value: unknown,
   transcript: Array<{ id: string }>,
 
@@ -80,9 +80,42 @@ export interface ResearchDeps {
     messages: Array<{ role: string; content: string }>;
     reasoningEffort: ReasoningEffort;
     signal?: AbortSignal;
+    outputSchema?: JsonOutputSchema;
   }) => Promise<{ output: unknown }>;
 }
 
+/**
+ * A JSON Schema the provider must hold the reply to. Only for outputs the
+ * server already validates in code: with `strict` every property is required,
+ * so the schema has to match that validator exactly. Keep to keywords every
+ * routed provider accepts: type, properties, required, items, enum, anyOf,
+ * and additionalProperties false.
+ */
+export interface JsonOutputSchema {
+  name: string;
+  schema: Record<string, unknown>;
+}
+
+const QUERIES_SCHEMA: JsonOutputSchema = {
+  name: "follow_up_queries",
+  schema: {
+    type: "object",
+    properties: { queries: { type: "array", items: { type: "string" } } },
+    required: ["queries"],
+    additionalProperties: false,
+  },
+};
+
+const SEARCH_DECISION_SCHEMA: JsonOutputSchema = {
+  name: "search_decision",
+  schema: {
+    type: "object",
+    properties: { shouldSearch: { type: "boolean" }, query: { type: "string" } },
+    required: ["shouldSearch", "query"],
+    additionalProperties: false,
+  },
+};
+
 export function emptyResearchContext(): ResearchContext {
   return { searches: [], rankedResults: [], readContent: [], verifiedUrls: new Set() };
 }
@@ -377,6 +410,7 @@ export async function decideAskSearch(
       messages: [{ role: "user", content: prompt }],
       reasoningEffort: deps.reasoningEffort,
       signal: deps.signal,
+      outputSchema: SEARCH_DECISION_SCHEMA,
     });
     const decision = decisionResult.output;
     if (decision && typeof decision === "object") {
@@ -415,6 +449,7 @@ async function generateFollowUpQueries(
       messages: [{ role: "user", content: prompt }],
       reasoningEffort: deps.reasoningEffort,
       signal: deps.signal,
+      outputSchema: QUERIES_SCHEMA,
     });
     const parsed = typeof result.output === "object" && result.output !== null ? result.output : {};
     if (Array.isArray((parsed as { queries?: string[] }).queries)) {
 
@@ -15,6 +15,7 @@ import {
   type PromptSource,
 } from "../../_shared/prompts.ts";
 import { MAX_CROSSFIRE_REPLY_CHARS } from "../../_shared/crossfire-response.ts";
+import type { JsonOutputSchema } from "../../_shared/research.ts";
 import { hasOnlyKeys, isRecord, sanitizePromptInput } from "../request.ts";
 import { sparringIntegritySecret, supabase } from "../runtime.ts";
 
@@ -290,6 +291,19 @@ export function boundCrossfireSources(value: unknown, enabled: boolean): { value
   return { value: bounded, truncated };
 }
 
+/** The provider-side shape of a next turn, mirroring crossfireReplyOutput. */
+export function crossfireReplySchema(expectedReply: "question" | "answer"): JsonOutputSchema {
+  return {
+    name: "crossfire_turn",
+    schema: {
+      type: "object",
+      properties: { type: { type: "string", enum: [expectedReply] }, text: { type: "string" } },
+      required: ["type", "text"],
+      additionalProperties: false,
+    },
+  };
+}
+
 export function crossfireReplyOutput(value: unknown, expectedReply: "question" | "answer"): { value: { type: "question" | "answer"; text: string } } | { error: string } {
   if (!isRecord(value) || !hasOnlyKeys(value, ["type", "text"])) return { error: "Crossfire next-turn response must contain only type and text" };
   if (value.type !== expectedReply) return { error: `Crossfire response type must be ${expectedReply}` };
 
@@ -3,11 +3,12 @@ import { callAI } from "../provider.ts";
 import { cleanGeneratedText, getCurrentDateContext } from "../text.ts";
 import { buildCrossfireNextTurnPrompt, buildCrossfireDebriefPrompt } from "../prompt-builder.ts";
 import { buildSystemPrompt, type DebatePromptContext, type PromptSource } from "../../_shared/prompts.ts";
-import { validateCrossfireDebrief } from "../../_shared/crossfire-response.ts";
+import { crossfireDebriefSchema, validateCrossfireDebrief } from "../../_shared/crossfire-response.ts";
 import {
   createCrossfireSignalToken,
   type CrossfireInput,
   crossfireReplyOutput,
+  crossfireReplySchema,
   MAX_CROSSFIRE_PROMPT_CHARS,
 } from "./crossfire-input.ts";
 import { prepareVoiceReply, type VoicePayload } from "../../_shared/voice-token.ts";
@@ -65,6 +66,9 @@ export async function handleCrossfire(ctx: FeatureContext, options: CrossfireHan
     reasoningEffort,
     workSignal,
     ctx.stream,
+    crossfireInput.operation === "next-turn"
+      ? crossfireReplySchema(crossfireInput.expectedReply)
+      : crossfireDebriefSchema(crossfireInput.transcript),
   ));
   const cleanedOutput = cleanGeneratedText(aiResult.output);
   const output = crossfireInput.operation === "next-turn"
 
@@ -638,7 +638,7 @@ export async function handleRequest(req: Request): Promise<Response> {
     },
     callModel: async (args) => {
       try {
-        const result = await callAI(args.provider, args.model, args.systemPrompt, args.messages, args.reasoningEffort, args.signal);
+        const result = await callAI(args.provider, args.model, args.systemPrompt, args.messages, args.reasoningEffort, args.signal, undefined, args.outputSchema);
         // A provider that ignores cancellation must not append usage after the
         // research timeout has already been finalized by the parent request.
         if (result.usage && !args.signal?.aborted) researchUsage.push(result.usage);
 
@@ -1,4 +1,4 @@
-import { assertEquals } from "jsr:@std/assert@1.0.19";
+import { assertEquals, assertRejects, assertThrows } from "jsr:@std/assert@1.0.19";
 for (const [key, value] of Object.entries({
   SUPABASE_URL: "https://supabase.test", SUPABASE_ANON_KEY: "test-anon-key",
   SUPABASE_SERVICE_ROLE_KEY: "test-service-key", OPENROUTER_API_KEY: "test-provider-key",
@@ -40,3 +40,40 @@ Deno.test("AI JSON and SSE failures never expose provider response bodies", asyn
     }
   } finally { globalThis.fetch = originalFetch; }
 });
+
+Deno.test("common JSON slips are repaired locally instead of paying for a retry", async () => {
+  const { parseJsonFromText } = await import("./provider.ts");
+  const parse = (text: string) => parseJsonFromText(text, "OpenRouter");
+  assertEquals(parse('```JSON\n{"a":1}\n```'), { a: 1 });
+  assertEquals(parse('```\n{"a":1}\n```'), { a: 1 });
+  assertEquals(parse('Here you go: {"a":"x"} Note: {not json}'), { a: "x" });
+  assertEquals(parse('Use {braces} like so. {"a":[1,2,],}'), { a: [1, 2] });
+  assertEquals(parse('{"a":"line one\nline two\t!"}'), { a: "line one\nline two\t!" });
+  assertEquals(parse('{"a":"keep , ] inside strings",}'), { a: "keep , ] inside strings" });
+  // A broken outer object never yields one of its nested objects.
+  assertThrows(() => parse('{"case": {"title": "x"}, oops}'));
+  // A reply cut off mid-object is not completed.
+  assertThrows(() => parse('{"contentions": [{"title": "x"}, {"title": "y"'));
+});
+
+Deno.test("a reply cut at the output cap is not retried, and a schema is sent as strict json_schema", async () => {
+  const { callAI } = await import("./provider.ts");
+  const originalFetch = globalThis.fetch;
+  const bodies: Array<Record<string, unknown>> = [];
+  globalThis.fetch = (async (_input: Request | URL | string, init?: RequestInit) => {
+    bodies.push(JSON.parse(String(init?.body)));
+    return Response.json({
+      choices: [{ message: { content: '{"queries": ["a", "b' }, finish_reason: "length" }],
+      usage: { prompt_tokens: 10, completion_tokens: 5, cost: 0.01 },
+    });
+  }) as typeof fetch;
+  try {
+    const schema = { name: "follow_up_queries", schema: { type: "object" } };
+    const error = await assertRejects(() =>
+      callAI("openrouter", "openai/gpt-6-luna", "system", [{ role: "user", content: "hi" }], "low", undefined, undefined, schema)
+    ) as { usage?: { inputTokens?: number } };
+    assertEquals(bodies.length, 1);
+    assertEquals(bodies[0].response_format, { type: "json_schema", json_schema: { name: "follow_up_queries", strict: true, schema: { type: "object" } } });
+    assertEquals(error.usage?.inputTokens, 10);
+  } finally { globalThis.fetch = originalFetch; }
+});