fix(ai): step 1 — omit default Luna reasoning effort

Checkpoint: removes the production max-effort override while preserving explicit caller tuning.
Reviewed against testing/hotfix-luna-chat-no-explicit-reasoning.md.

Author: Atharva-Kanherkar

web/.env.example

@@ -6,8 +6,8 @@ NEXT_PUBLIC_CLERK_SIGN_UP_FALLBACK_REDIRECT_URL=/app
 # AI coach (issue #13). In production set OPENAI_API_KEY as a Worker secret instead.
 OPENAI_API_KEY=sk-your-openai-key
 AI_COACH_MODEL=gpt-5.6-luna
-# none | low | medium | high | xhigh | max — only applies to reasoning models.
-AI_COACH_REASONING_EFFORT=max
+# Optional: none | low | medium | high | xhigh | max. Omit to use OpenAI's
+# documented medium default for GPT-5.6.
 # Two meters — keep in sync with TIERS in src/lib/site.ts and wrangler.jsonc.
 # *_AI_CALLS_PER_MONTH is the advertised allowance (explain / hooks / chat /
 # notebook summaries). *_AUTO_* covers what the extension fires on its own

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

@@ -4,7 +4,6 @@ import {
   coachCacheKey,
   completionTuning,
   DEFAULT_COACH_MODEL,
-  DEFAULT_COACH_REASONING_EFFORT,
   isReasoningModel,
   normalizeCoachRequest,
   normalizeReasoningEffort,
@@ -99,23 +98,23 @@ describe("runCoach", () => {
     await expect(runCoach("sk-test", "gpt-4.1-nano", baseReq)).rejects.toThrow("openai_empty");
   });
 
-  it("sends reasoning params (not temperature/max_tokens) for the luna default model", async () => {
+  it("uses Luna's documented default effort without sending the rejected flag", async () => {
     const fetchMock = mockOpenAi(JSON.stringify({ meaning: "to see", nuance: "casual" }));
     vi.stubGlobal("fetch", fetchMock);
     await runCoach("sk-test", DEFAULT_COACH_MODEL, baseReq);
     const body = JSON.parse((fetchMock.mock.calls[0][1] as RequestInit).body as string);
     expect(body.model).toBe("gpt-5.6-luna");
-    expect(body.reasoning_effort).toBe("max");
+    expect(body).not.toHaveProperty("reasoning_effort");
     expect(body.max_completion_tokens).toBeGreaterThan(400);
     expect(body).not.toHaveProperty("temperature");
     expect(body).not.toHaveProperty("max_tokens");
   });
 });
 
 describe("reasoning model tuning", () => {
-  it("defaults the coach to gpt-5.6-luna at max effort", () => {
+  it("defaults the coach to gpt-5.6-luna and OpenAI's medium effort", () => {
     expect(DEFAULT_COACH_MODEL).toBe("gpt-5.6-luna");
-    expect(DEFAULT_COACH_REASONING_EFFORT).toBe("max");
+    expect(reasoningEffortForModel(DEFAULT_COACH_MODEL)).toBe("medium");
   });
 
   it("classifies model families", () => {
@@ -133,14 +132,17 @@ describe("reasoning model tuning", () => {
   });
 
   it("gives reasoning tokens headroom scaled by effort", () => {
+    const omitted = completionTuning("gpt-5.6-luna", { temperature: 0.4, maxTokens: 400 });
     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(none.max_completion_tokens).toBe(400);
     expect(low.max_completion_tokens).toBe(2400);
     expect(max.max_completion_tokens).toBe(25400);
     expect(max.max_completion_tokens).toBeGreaterThanOrEqual(25_000);
     expect(max.reasoning_effort).toBe("max");
+    expect(low.reasoning_effort).toBe("low");
   });
 
   it("uses conservative defaults but preserves explicit model overrides", () => {

web/src/lib/ai-coach.ts

@@ -73,29 +73,24 @@ export type CoachResult = ExplainResult | HooksResult | ChatResult;
 
 // Verified August 2026: gpt-5.6-luna (released 2026-07-09) is $0.20 / 1M input,
 // $1.20 / 1M output, $0.02 / 1M cached input. It is a reasoning model; at the
-// "max" effort we run the coach on, reasoning tokens are billed as output. The
-// actual cost is workload-dependent and can exceed the backend's $0.002/call
-// assumption, so usage must be monitored. Overridable via AI_COACH_MODEL /
-// AI_COACH_REASONING_EFFORT env.
+// reasoning tokens are billed as output. The actual cost is workload-dependent
+// and can exceed the backend's $0.002/call assumption, so usage must be
+// monitored. The model is overridable via AI_COACH_MODEL; reasoning effort is
+// optional and otherwise uses OpenAI's documented default.
 export const DEFAULT_COACH_MODEL = "gpt-5.6-luna";
 
 export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 
-// "Max mode": the highest reasoning effort Luna offers. The coach is a
-// user-facing quality surface (the whole reason we left gpt-4.1-nano), so it
-// defaults to max; background callers pass something cheaper.
-export const DEFAULT_COACH_REASONING_EFFORT: ReasoningEffort = "max";
-
 const REASONING_EFFORTS: readonly ReasoningEffort[] = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 const GPT_56_EFFORTS: readonly ReasoningEffort[] = ["none", "low", "medium", "high", "xhigh", "max"];
 
 export function normalizeReasoningEffort(value: unknown): ReasoningEffort | null {
   return REASONING_EFFORTS.includes(value as ReasoningEffort) ? (value as ReasoningEffort) : null;
 }
 
-/** GPT-5.6 is the only model for which this app chooses `max` by default.
- * Explicit operator overrides are preserved: silently changing `none`, `xhigh`,
- * or `max` changes latency, cost, and quality, and model capabilities evolve. */
+/** Resolve the effective effort used for token-budget headroom. OpenAI documents
+ * `medium` as GPT-5.6's default when the request omits `reasoning_effort`.
+ * Explicit operator overrides are preserved after model validation. */
 export function reasoningEffortForModel(model: string, requested?: ReasoningEffort): ReasoningEffort {
   if (requested && isReasoningModel(model)) {
     const supported = supportedReasoningEfforts(model);
@@ -104,7 +99,7 @@ export function reasoningEffortForModel(model: string, requested?: ReasoningEffo
     }
   }
   if (requested) return requested;
-  return /^gpt-5\.6(?:-|$)/.test(model) ? DEFAULT_COACH_REASONING_EFFORT : "medium";
+  return "medium";
 }
 
 function supportedReasoningEfforts(model: string): readonly ReasoningEffort[] | null {
@@ -155,7 +150,7 @@ export function completionTuning(
             ? 25_000
             : 16_000;
   return {
-    reasoning_effort: effort,
+    ...(opts.effort ? { reasoning_effort: effort } : {}),
     max_completion_tokens: opts.maxTokens + headroom,
   };
 }

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

@@ -9,7 +9,7 @@ vi.mock("@opennextjs/cloudflare", () => ({
   },
 }));
 
-const { currentMonth, getUsage, incrementUsage, quotaFor, refundUsage, reserveUsage } =
+const { currentMonth, getCoachConfig, getUsage, incrementUsage, quotaFor, refundUsage, reserveUsage } =
   await import("./ai-store");
 
 const MONTH = "2026-08";
@@ -73,6 +73,19 @@ describe("quotaFor", () => {
   });
 });
 
+describe("getCoachConfig", () => {
+  it("omits explicit reasoning effort by default", async () => {
+    const config = await getCoachConfig();
+    expect(config.model).toBe("gpt-5.6-luna");
+    expect(config.reasoningEffort).toBeUndefined();
+  });
+
+  it("preserves an explicit supported operator override", async () => {
+    vi.stubEnv("AI_COACH_REASONING_EFFORT", "low");
+    expect((await getCoachConfig()).reasoningEffort).toBe("low");
+  });
+});
+
 describe("reserveUsage", () => {
   it("claims a slot and reports the post-claim count", async () => {
     const user = "res-basic";

web/src/lib/ai-store.ts

@@ -70,7 +70,7 @@ export async function getOpenAiKey(): Promise<string | null> {
 
 export async function getCoachConfig(): Promise<{
   model: string;
-  reasoningEffort: ReasoningEffort;
+  reasoningEffort?: ReasoningEffort;
   freeLimit: number;
   proLimit: number;
   maxLimit: number;
@@ -89,7 +89,9 @@ export async function getCoachConfig(): Promise<{
   };
   return {
     model,
-    reasoningEffort: reasoningEffortForModel(model, configuredEffort ?? undefined),
+    reasoningEffort: configuredEffort
+      ? reasoningEffortForModel(model, configuredEffort)
+      : undefined,
     freeLimit: num(process.env.FREE_AI_CALLS_PER_MONTH || env.FREE_AI_CALLS_PER_MONTH, DEFAULT_FREE_LIMIT),
     proLimit: num(process.env.PRO_AI_CALLS_PER_MONTH || env.PRO_AI_CALLS_PER_MONTH, DEFAULT_PRO_LIMIT),
     maxLimit: num(process.env.MAX_AI_CALLS_PER_MONTH || env.MAX_AI_CALLS_PER_MONTH, DEFAULT_MAX_LIMIT),

web/wrangler.jsonc

@@ -30,14 +30,13 @@
   ],
   // AI coach (issue #13). OPENAI_API_KEY is a Worker secret, not a var:
   //   npx wrangler secret put OPENAI_API_KEY
-  // gpt-5.6-luna at max reasoning effort ($0.20/$1.20 per 1M tokens as of
-  // Aug 2026; reasoning tokens bill as output). Actual cost varies by task and
-  // must be monitored. Background auto calls (word extraction, anime context) run
-  // the same model at low effort. Limits are per Clerk user per month,
+  // gpt-5.6-luna ($0.20/$1.20 per 1M tokens as of Aug 2026; reasoning tokens
+  // bill as output). Omitted reasoning effort uses OpenAI's documented medium
+  // default. Background auto calls (word extraction, anime context) explicitly
+  // use low effort. Limits are per Clerk user per month,
   // gated by plan (free/pro/max) from Clerk publicMetadata — see resolvePlan.
   "vars": {
     "AI_COACH_MODEL": "gpt-5.6-luna",
-    "AI_COACH_REASONING_EFFORT": "max",
     // Two meters. *_AI_CALLS_PER_MONTH is what the pricing page advertises and
     // covers only AI the learner asks for (explain / hooks / chat / notebook
     // summaries). *_AUTO_AI_CALLS_PER_MONTH covers what the extension fires by