fix(ai): step 3 — preserve Luna headroom and diagnostics

Checkpoint: keeps a safe completion cap and logs sanitized provider error metadata.
Reviewed against testing/hotfix-luna-chat-no-explicit-reasoning.md.

Author: Atharva-Kanherkar

web/src/lib/ai-coach.test.ts

@@ -22,6 +22,22 @@ function mockOpenAi(content: string, ok = true, status = 200) {
   } as unknown as Response);
 }
 
+function mockOpenAiError(message: string, status = 400) {
+  return vi.fn().mockResolvedValue({
+    ok: false,
+    status,
+    headers: new Headers({ "x-request-id": "req-test" }),
+    json: async () => ({
+      error: {
+        message,
+        type: "invalid_request_error",
+        param: "reasoning_effort",
+        code: "unsupported_value",
+      },
+    }),
+  } as unknown as Response);
+}
+
 function mockOpenAiStream(content: string) {
   const body = new ReadableStream({
     start(controller) {
@@ -101,8 +117,18 @@ describe("runCoach", () => {
   });
 
   it("throws on an OpenAI HTTP error", async () => {
-    vi.stubGlobal("fetch", mockOpenAi("", false, 429));
-    await expect(runCoach("sk-test", "gpt-4.1-nano", baseReq)).rejects.toThrow("openai_429");
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+    vi.stubGlobal("fetch", mockOpenAiError("Unsupported value", 400));
+    await expect(runCoach("sk-test", "gpt-4.1-nano", baseReq)).rejects.toThrow("openai_400");
+    expect(errorSpy).toHaveBeenCalledWith(
+      "[ai-coach] OpenAI request failed",
+      expect.objectContaining({
+        operation: "explain",
+        status: 400,
+        requestId: "req-test",
+        providerError: expect.objectContaining({ param: "reasoning_effort" }),
+      })
+    );
   });
 
   it("throws when the model returns no usable content", async () => {
@@ -186,7 +212,7 @@ describe("reasoning model tuning", () => {
     const none = completionTuning("gpt-5.6-luna", { temperature: 0.4, maxTokens: 400, effort: "none" });
     const low = completionTuning("gpt-5.6-luna", { temperature: 0.4, maxTokens: 400, effort: "low" });
     const max = completionTuning("gpt-5.6-luna", { temperature: 0.4, maxTokens: 400, effort: "max" });
-    expect(omitted).toEqual({ max_completion_tokens: 4400 });
+    expect(omitted).toEqual({ max_completion_tokens: 25400 });
     expect(none.max_completion_tokens).toBe(400);
     expect(low.max_completion_tokens).toBe(2400);
     expect(max.max_completion_tokens).toBe(25400);

web/src/lib/ai-coach.ts

@@ -138,7 +138,9 @@ export function completionTuning(
   // lower efforts stay deliberately tighter for latency-sensitive background
   // calls.
   const headroom =
-    effort === "none"
+    !opts.effort
+      ? 25_000
+      : effort === "none"
       ? 0
       : effort === "minimal"
         ? 1_000
@@ -154,6 +156,33 @@ export function completionTuning(
     max_completion_tokens: opts.maxTokens + headroom,
   };
 }
+
+async function openAiHttpError(res: Response, operation: string): Promise<Error> {
+  let providerError: Record<string, string> = {};
+  try {
+    const payload = (await res.json()) as {
+      error?: { message?: unknown; type?: unknown; param?: unknown; code?: unknown };
+    };
+    const error = payload.error;
+    const copy = (key: "message" | "type" | "param" | "code", max = 500) => {
+      const value = error?.[key];
+      if (typeof value === "string" && value) providerError[key] = value.slice(0, max);
+    };
+    copy("message");
+    copy("type", 100);
+    copy("param", 100);
+    copy("code", 100);
+  } catch {
+    providerError = { message: "unreadable_error_body" };
+  }
+  console.error("[ai-coach] OpenAI request failed", {
+    operation,
+    status: res.status,
+    requestId: res.headers?.get("x-request-id") || undefined,
+    providerError,
+  });
+  return new Error(`openai_${res.status}`);
+}
 // Enforced monthly caps derive from the advertised tiers in site.ts, so the
 // number a user is billed against is the same number the pricing UI shows.
 // Overridable via FREE_/PRO_/MAX_AI_CALLS_PER_MONTH env.
@@ -369,9 +398,7 @@ export async function runCoach(
     }),
   });
 
-  if (!res.ok) {
-    throw new Error(`openai_${res.status}`);
-  }
+  if (!res.ok) throw await openAiHttpError(res, req.mode);
 
   const data = (await res.json()) as {
     choices?: { message?: { content?: string } }[];
@@ -450,7 +477,7 @@ async function runChatCoach(
     }),
   });
 
-  if (!res.ok) throw new Error(`openai_${res.status}`);
+  if (!res.ok) throw await openAiHttpError(res, "chat");
 
   const data = (await res.json()) as { choices?: { message?: { content?: string } }[] };
   const reply = (data.choices?.[0]?.message?.content || "").trim();
@@ -480,7 +507,7 @@ export async function* streamChatCoach(
     }),
   });
 
-  if (!res.ok) throw new Error(`openai_${res.status}`);
+  if (!res.ok) throw await openAiHttpError(res, "chat_stream");
   if (!res.body) throw new Error("openai_no_body");
 
   const reader = res.body.getReader();

web/src/lib/reasoning-callers.test.ts

@@ -69,6 +69,24 @@ describe("reasoning-model callers", () => {
     expect(body).not.toHaveProperty("max_tokens");
   });
 
+  it("omits the default notebook effort while retaining reasoning headroom", async () => {
+    const fetchMock = mockOpenAi({ weakSpots: ["verbs"], reviewPrompts: ["Use 見る in a sentence."] });
+    vi.stubGlobal("fetch", fetchMock);
+    const notebook: Notebook = {
+      id: "n2",
+      name: "Episode two",
+      createdAt: "2026-08-06T00:00:00Z",
+      updatedAt: "2026-08-06T00:00:00Z",
+      entries: [],
+    };
+
+    await runNotebookSummary("sk-test", "gpt-5.6-luna", notebook);
+
+    const body = JSON.parse((fetchMock.mock.calls[0][1] as RequestInit).body as string);
+    expect(body).not.toHaveProperty("reasoning_effort");
+    expect(body.max_completion_tokens).toBe(25_600);
+  });
+
   it("preserves classic sampling fields for a non-reasoning override", async () => {
     const fetchMock = mockOpenAi({ word: "見る" });
     vi.stubGlobal("fetch", fetchMock);