feat(settings): set how hard the Coach thinks, cap it as an operator, edit its memory

Thinking depth (Off, Low, Medium, High) sits under the model in the
Coach's quick settings and in Settings → Coach. It renders the resolved
block from the account payload: levels above the operator's cap are
disabled and say so, the field locks with one sentence when the
operator switched reasoning off, and Off reads Minimal where the
provider cannot stop thinking. The provider's own reasoning select
leaves the quick settings and says the Coach has its own.

The operator gets a switch to allow deeper thinking and a select for
the highest depth. The memory list shows where each entry came from,
lets it be edited in place, and is linked from the quick settings with
its count. The deep-linked data section no longer draws a ring.

src/components/insights/coach-panel/__tests__/coach-model-picker.test.tsx

@@ -8,7 +8,6 @@ import type {
 import {
   chainWithFirst,
   modelControlFor,
-  reasoningFieldFor,
   selectableProviders,
   switchDidNotTake,
 } from "../coach-model-picker";
@@ -120,20 +119,3 @@ describe("modelControlFor", () => {
     ).toEqual({ kind: "gateway", value: "qwen3:32b" });
   });
 });
-
-describe("reasoningFieldFor", () => {
-  it("writes the Local and gateway entries' own reasoning fields", () => {
-    expect(
-      reasoningFieldFor("local", userProvider({ localReasoningEffort: "low" })),
-    ).toEqual({ field: "localReasoningEffort", value: "low" });
-    expect(reasoningFieldFor("openai-compatible", userProvider())).toEqual({
-      field: "compatReasoningEffort",
-      value: null,
-    });
-  });
-
-  it("has nothing for providers without a reasoning setting", () => {
-    expect(reasoningFieldFor("openai", userProvider())).toBeNull();
-    expect(reasoningFieldFor("codex", userProvider())).toBeNull();
-  });
-});

src/components/insights/coach-panel/__tests__/coach-reasoning-field.test.tsx

@@ -0,0 +1,129 @@
+/**
+ * v1.41 — the Coach's thinking depth: Off / Low / Medium / High, rendered
+ * from what the server resolved, never recomputed.
+ */
+import { describe, expect, it, vi } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { getServerTranslator } from "@/lib/i18n/server-translator";
+
+const locale = vi.hoisted(() => ({ current: "en" as "en" | "de" }));
+vi.mock("@/lib/i18n/context", () => ({
+  useTranslations: () => ({
+    t: (key: string, params?: Record<string, string | number>) =>
+      getServerTranslator(locale.current).t(key, params),
+  }),
+}));
+
+import {
+  CoachReasoningSelect,
+  reasoningLocked,
+  reasoningOptions,
+  reasoningStateOrDefault,
+  shownReasoningLevel,
+  type CoachReasoningState,
+} from "../coach-reasoning-field";
+
+const OPEN: CoachReasoningState = {
+  level: "medium",
+  preference: "medium",
+  maxLevel: "high",
+  available: true,
+  offIsReal: true,
+  source: "user",
+};
+const ADMIN_OFF: CoachReasoningState = {
+  level: "off",
+  preference: "high",
+  maxLevel: "off",
+  available: false,
+  offIsReal: true,
+  source: "admin_off",
+};
+
+function render(state: CoachReasoningState, value = state.level) {
+  return renderToStaticMarkup(
+    <CoachReasoningSelect
+      id="r"
+      value={value}
+      state={state}
+      onChange={() => {}}
+    />,
+  );
+}
+
+describe("the resolved block", () => {
+  it("reads an older server's missing block as allowed, uncapped, really off", () => {
+    expect(reasoningStateOrDefault(null)).toEqual(OPEN);
+    expect(reasoningStateOrDefault(undefined)).toEqual(OPEN);
+  });
+
+  it("is locked only when the operator switched reasoning off", () => {
+    expect(reasoningLocked(ADMIN_OFF)).toBe(true);
+    expect(reasoningLocked(OPEN)).toBe(false);
+    // A provider that cannot reason does not lock the person's choice.
+    expect(
+      reasoningLocked({ ...OPEN, available: false, source: "unsupported" }),
+    ).toBe(false);
+  });
+});
+
+describe("<CoachReasoningSelect>", () => {
+  it("offers Off, Low, Medium and High with the label and hint", () => {
+    const html = render(OPEN);
+    expect(html).toContain(">Thinking depth<");
+    for (const label of ["Off", "Low", "Medium", "High"]) {
+      expect(html).toContain(`>${label}</option>`);
+    }
+    expect(html).toContain(
+      "Deeper thinking means more precise answers and a little more waiting.",
+    );
+    expect(html).not.toMatch(/<select[^>]*disabled/);
+  });
+
+  it("is locked with one sentence when the admin turned reasoning off", () => {
+    const html = render(ADMIN_OFF, "high");
+    expect(html).toMatch(/<select[^>]*disabled/);
+    expect(html).toContain('data-locked="true"');
+    expect(html).toContain("The admin has turned deeper thinking off.");
+    expect(html).not.toContain("a little more waiting");
+  });
+
+  it("shows the admin's cap: levels above it are disabled and say why", () => {
+    const html = render({ ...OPEN, maxLevel: "medium" });
+    expect(html).toMatch(
+      /<option value="high" disabled="">High \(limited by the admin\)<\/option>/,
+    );
+    expect(html).toMatch(
+      /<option value="medium"( selected="")?>Medium<\/option>/,
+    );
+  });
+
+  it("says Minimal where the provider cannot switch thinking off", () => {
+    const options = reasoningOptions(
+      { ...OPEN, offIsReal: false },
+      getServerTranslator("en").t,
+    );
+    expect(options[0]).toEqual({
+      value: "off",
+      label: "Minimal",
+      disabled: false,
+    });
+  });
+
+  it("shows a choice above the cap at the cap, which is what runs", () => {
+    expect(shownReasoningLevel("high", { ...OPEN, maxLevel: "low" })).toBe(
+      "low",
+    );
+    expect(shownReasoningLevel("low", OPEN)).toBe("low");
+    expect(shownReasoningLevel("high", ADMIN_OFF)).toBe("off");
+  });
+
+  it("reads in German", () => {
+    locale.current = "de";
+    const html = render({ ...OPEN, maxLevel: "low" });
+    locale.current = "en";
+    expect(html).toContain(">Denktiefe<");
+    expect(html).toContain("Hoch (vom Admin begrenzt)");
+  });
+});

src/components/insights/coach-panel/__tests__/coach-settings-overlay.test.tsx

@@ -109,13 +109,13 @@ describe("<CoachSettingsBody>", () => {
 
   it("locks the reasoning select while a change is saving", async () => {
     // Two writes in flight at once could land out of order and lose one;
-    // the provider and model selects already lock, the reasoning one too.
+    // the provider and model selects already lock, the thinking depth too.
     const source = (await import("node:fs")).readFileSync(
-      new URL("../coach-model-picker.tsx", import.meta.url),
+      new URL("../coach-reasoning-field.tsx", import.meta.url),
       "utf8",
     );
-    const field = source.match(/<ReasoningEffortField[\s\S]*?\/>/)?.[0];
-    expect(field).toMatch(/disabled=\{busy\}/);
+    expect(source).toMatch(/disabled=\{locked \|\| busy\}/);
+    expect(source).toMatch(/busy=\{save\.isPending\}/);
   });
 
   it("names the data section so a deep link can land on it", () => {

src/components/insights/coach-panel/coach-model-picker.tsx

@@ -8,7 +8,6 @@ import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { NativeSelect } from "@/components/ui/native-select";
-import { ReasoningEffortField } from "@/components/settings/ai/reasoning-effort-field";
 import {
   ANTHROPIC_MODEL_PRESETS,
   LOCAL_MODEL_PRESETS,
@@ -16,7 +15,6 @@ import {
   uiToLegacyProviderEnum,
   type ProviderChainData,
   type ProviderType,
-  type ReasoningEffort,
   type UserAIProvider,
 } from "@/components/settings/ai/shared";
 import { apiGet, apiPatch, apiPut } from "@/lib/api/api-fetch";
@@ -29,7 +27,9 @@ import {
 
 /**
  * The quick model choice in the Coach's settings overlay: which provider
- * answers, which model it uses, and how hard a reasoning model thinks.
+ * answers and which model it uses. How hard the Coach thinks is the Coach's
+ * own setting since v1.41 (`coach-reasoning-field.tsx`); the provider's
+ * reasoning select stays in Settings → AI for everything else.
  *
  * It is a shortcut onto the same settings Settings → AI writes, never a second
  * copy of them. Keys, base URLs, the Codex sign-in and the order of the
@@ -38,7 +38,7 @@ import {
  *  - Provider: `PUT /api/insights/provider-chain` with the chosen entry moved
  *    to the front and every other entry in its current order. The entries'
  *    reasoning settings are not sent, so the server keeps what it stored.
- *  - Model and reasoning: `PATCH /api/user/ai-provider`, only where a person
+ *  - Model: `PATCH /api/user/ai-provider`, only where a person
  *    owns the setting (their own key's provider, or their gateway). The
  *    operator's shared provider and Codex show their state read-only.
  * Every write invalidates the AI input keys, so the capability on
@@ -127,29 +127,6 @@ export function modelControlFor(
   return { kind: "managed" };
 }
 
-/** The reasoning setting the active provider carries, if any. */
-export function reasoningFieldFor(
-  active: ProviderType | null,
-  userProvider: UserAIProvider | null | undefined,
-): {
-  field: "localReasoningEffort" | "compatReasoningEffort";
-  value: ReasoningEffort | null;
-} | null {
-  if (active === "local") {
-    return {
-      field: "localReasoningEffort",
-      value: userProvider?.localReasoningEffort ?? null,
-    };
-  }
-  if (active === "openai-compatible") {
-    return {
-      field: "compatReasoningEffort",
-      value: userProvider?.compatReasoningEffort ?? null,
-    };
-  }
-  return null;
-}
-
 export function CoachModelPicker() {
   const { t } = useTranslations();
   const queryClient = useQueryClient();
@@ -212,7 +189,6 @@ export function CoachModelPicker() {
   const active = chain?.activeProvider ?? null;
   const options = chain ? selectableProviders(chain.configuredChain) : [];
   const model = modelControlFor(active, userProvider);
-  const reasoning = reasoningFieldFor(active, userProvider);
   const busy = switchProvider.isPending || patchProvider.isPending;
   // The server may answer with `admin-codex`, which the UI's type omits.
   const unlisted = activeOutsideOptions(active as string | null, options);
@@ -339,16 +315,6 @@ export function CoachModelPicker() {
         </p>
       )}
 
-      {reasoning ? (
-        <ReasoningEffortField
-          id="coach-quick-reasoning"
-          noColon
-          value={reasoning.value}
-          disabled={busy}
-          onChange={(next) => patchProvider.mutate({ [reasoning.field]: next })}
-        />
-      ) : null}
-
       {busy ? (
         <p role="status" className="text-muted-foreground text-xs">
           {t("insights.coach.frame.saving")}

src/components/insights/coach-panel/coach-reasoning-field.tsx

@@ -0,0 +1,196 @@
+"use client";
+
+/**
+ * v1.41 — how hard the Coach thinks before it answers: one select, Off / Low
+ * / Medium / High, Medium by default.
+ *
+ * The person's own choice lives in `coachPrefsJson.reasoning`. What the
+ * server resolved from it rides `/api/auth/me` as `coachReasoning`: whether
+ * the operator allows reasoning at all, the highest level they allow, and
+ * whether "off" is really off on the active provider. The field renders from
+ * that and never recomputes it:
+ *  - the operator switched reasoning off: the select is locked and one
+ *    sentence says so;
+ *  - a level above the operator's cap is offered but disabled, with
+ *    "(limited by the admin)";
+ *  - where the provider cannot switch thinking off, "Off" reads "Minimal".
+ * A server older than v1.41 sends no block; the field then reads as allowed,
+ * uncapped and really off.
+ *
+ * Two homes, one field: the Coach's quick settings (saves on change) and
+ * Settings → Coach (part of that card's draft and save).
+ */
+import { useQueryClient } from "@tanstack/react-query";
+
+import { Label } from "@/components/ui/label";
+import { NativeSelect } from "@/components/ui/native-select";
+import { useTranslations } from "@/lib/i18n/context";
+import { useCoachReasoning } from "@/hooks/use-ai-capability";
+import { useCoachPrefs, useSaveCoachPrefs } from "@/hooks/use-coach-prefs";
+import { queryKeys } from "@/lib/query-keys";
+import {
+  DEFAULT_REASONING_LEVEL,
+  REASONING_LEVELS,
+  REASONING_LEVEL_LABEL_KEYS,
+  REASONING_SETTING_KEYS,
+  isReasoningLevel,
+  type ReasoningLevel,
+} from "@/lib/ai/reasoning/levels";
+import type { CoachReasoningState } from "@/lib/ai/reasoning/resolve";
+import { coachReasoningLevel } from "@/lib/validations/coach-prefs";
+
+export type { CoachReasoningState };
+
+/**
+ * The block as the field reads it: the server's answer, or for a server that
+ * does not publish one (older than v1.41) "allowed, uncapped, really off" at
+ * the default level.
+ */
+export function reasoningStateOrDefault(
+  state: CoachReasoningState | null | undefined,
+): CoachReasoningState {
+  return (
+    state ?? {
+      level: DEFAULT_REASONING_LEVEL,
+      preference: DEFAULT_REASONING_LEVEL,
+      maxLevel: "high",
+      available: true,
+      offIsReal: true,
+      source: "user",
+    }
+  );
+}
+
+/** True when the operator switched reasoning off: the field is locked. */
+export function reasoningLocked(state: CoachReasoningState): boolean {
+  return state.maxLevel === "off" || state.source === "admin_off";
+}
+
+export interface ReasoningOption {
+  value: ReasoningLevel;
+  label: string;
+  disabled: boolean;
+}
+
+/** The four options in order, labelled and capped for this account. */
+export function reasoningOptions(
+  state: CoachReasoningState,
+  t: (key: string) => string,
+): ReasoningOption[] {
+  const locked = reasoningLocked(state);
+  const cap = REASONING_LEVELS.indexOf(state.maxLevel);
+  return REASONING_LEVELS.map((value, index) => {
+    const base = t(
+      value === "off" && !state.offIsReal
+        ? REASONING_LEVEL_LABEL_KEYS.minimal
+        : REASONING_LEVEL_LABEL_KEYS[value],
+    );
+    // Above the cap is "(limited by the admin)"; while reasoning is off the
+    // one sentence under the field says it, not every option.
+    const capped = !locked && index > cap;
+    return {
+      value,
+      label: capped ? `${base} ${t(REASONING_SETTING_KEYS.capped)}` : base,
+      disabled: capped,
+    };
+  });
+}
+
+/**
+ * The level the select shows: the person's choice, lowered to the cap when
+ * it is above it (that is what runs), and the resolved level while the
+ * operator has reasoning off.
+ */
+export function shownReasoningLevel(
+  choice: ReasoningLevel,
+  state: CoachReasoningState,
+): ReasoningLevel {
+  if (reasoningLocked(state)) return state.level;
+  return REASONING_LEVELS.indexOf(choice) >
+    REASONING_LEVELS.indexOf(state.maxLevel)
+    ? state.maxLevel
+    : choice;
+}
+
+export interface CoachReasoningSelectProps {
+  id: string;
+  value: ReasoningLevel;
+  state: CoachReasoningState;
+  /** Locks the select while a write is in flight. */
+  busy?: boolean;
+  onChange: (next: ReasoningLevel) => void;
+}
+
+/** The field itself, without data: what the tests render. */
+export function CoachReasoningSelect({
+  id,
+  value,
+  state,
+  busy = false,
+  onChange,
+}: CoachReasoningSelectProps) {
+  const { t } = useTranslations();
+  const options = reasoningOptions(state, t);
+  const locked = reasoningLocked(state);
+  return (
+    <div data-slot="coach-reasoning-field">
+      <Label htmlFor={id} noColon>
+        {t(REASONING_SETTING_KEYS.label)}
+      </Label>
+      <NativeSelect
+        id={id}
+        data-slot="coach-reasoning-select"
+        data-locked={locked ? "true" : undefined}
+        className="mt-1"
+        value={shownReasoningLevel(value, state)}
+        disabled={locked || busy}
+        aria-describedby={`${id}-hint`}
+        onChange={(e) => {
+          const next = e.target.value;
+          if (isReasoningLevel(next) && next !== value) onChange(next);
+        }}
+      >
+        {options.map((option) => (
+          <option
+            key={option.value}
+            value={option.value}
+            disabled={option.disabled}
+          >
+            {option.label}
+          </option>
+        ))}
+      </NativeSelect>
+      <p id={`${id}-hint`} className="text-muted-foreground mt-1 text-xs">
+        {t(
+          locked
+            ? REASONING_SETTING_KEYS.disabled
+            : REASONING_SETTING_KEYS.hint,
+        )}
+      </p>
+    </div>
+  );
+}
+
+/** The quick-settings field: reads the saved choice and saves on change. */
+export function CoachReasoningField({ id }: { id: string }) {
+  const queryClient = useQueryClient();
+  const reasoning = useCoachReasoning();
+  const prefs = useCoachPrefs();
+  const save = useSaveCoachPrefs({
+    // The resolved block on `/me` follows the saved choice.
+    onSuccess: () =>
+      void queryClient.invalidateQueries({ queryKey: queryKeys.authMe() }),
+  });
+  if (!prefs.data) return null;
+  const current = prefs.data;
+  const state = reasoningStateOrDefault(reasoning);
+  return (
+    <CoachReasoningSelect
+      id={id}
+      value={coachReasoningLevel(current)}
+      state={state}
+      busy={save.isPending}
+      onChange={(reasoning) => save.mutate({ ...current, reasoning })}
+    />
+  );
+}

src/components/insights/coach-panel/coach-settings-body.tsx

@@ -2,27 +2,63 @@
 
 import { useEffect, useRef } from "react";
 import Link from "next/link";
-import { Cpu } from "lucide-react";
+import { Brain, ChevronRight, Cpu } from "lucide-react";
 
 import { Button } from "@/components/ui/button";
 import { useTranslations } from "@/lib/i18n/context";
 
+import { COACH_MEMORY_LIST_KEYS } from "@/lib/ai/coach/memory/shared";
+
 import { CoachModelPicker } from "./coach-model-picker";
+import { CoachReasoningField } from "./coach-reasoning-field";
+import { useCoachFacts } from "./use-coach-facts";
 import { SourcesRail } from "./sources-rail";
 
 /**
  * The content of the Coach's quick settings (see `coach-settings-overlay`):
- * the model choice, "What I can see" (the existing sources rail, wired to the
- * saved Coach preferences: data areas and how far back the Coach looks) and
- * a way on to the full AI settings.
+ * the model choice and how hard the Coach thinks, a way to what it remembers,
+ * "What I can see" (the existing sources rail, wired to the saved Coach
+ * preferences: data areas and how far back the Coach looks) and a way on to
+ * the full AI settings.
  *
  * `focusData` lands focus on the "What I can see" section when the body
  * mounts, for the `/coach?settings=data` deep link. It runs here rather than
  * in the overlay because the body loads on demand and may arrive after the
- * popover or sheet has already placed focus.
+ * popover or sheet has already placed focus. The section draws no focus
+ * ring: it is where the link lands, not a control, and a ring drawn on every
+ * deep link reads as a highlight nobody asked for.
  */
 export const COACH_SETTINGS_DATA_SECTION_ID = "coach-settings-data";
 
+/** Where the memory list lives: Settings → Coach, its memory card. */
+export const COACH_MEMORY_HREF = "/settings/coach#coach-memory";
+
+/** "Memory (8)": a link to the list, with how much it holds. */
+function CoachMemoryLink() {
+  const { t } = useTranslations();
+  const facts = useCoachFacts();
+  const count = facts.data?.length ?? 0;
+  return (
+    <Link
+      href={COACH_MEMORY_HREF}
+      data-slot="coach-settings-memory-link"
+      className="text-foreground hover:bg-muted focus-visible:ring-ring/50 -mx-2 flex min-h-11 items-center gap-2 rounded-md px-2 text-sm outline-none focus-visible:ring-2 sm:min-h-9"
+    >
+      <Brain
+        className="text-muted-foreground size-4 shrink-0"
+        aria-hidden="true"
+      />
+      <span className="min-w-0 flex-1">
+        {t(COACH_MEMORY_LIST_KEYS.link, { count })}
+      </span>
+      <ChevronRight
+        className="text-muted-foreground size-4 shrink-0"
+        aria-hidden="true"
+      />
+    </Link>
+  );
+}
+
 export function CoachSettingsBody({
   focusData = false,
 }: {
@@ -53,6 +89,8 @@ export function CoachSettingsBody({
           {t("insights.coach.frame.modelSection")}
         </h3>
         <CoachModelPicker />
+        <CoachReasoningField id="coach-quick-reasoning" />
+        <CoachMemoryLink />
       </section>
       <section
         ref={dataRef}
@@ -60,7 +98,7 @@ export function CoachSettingsBody({
         data-slot="coach-settings-data"
         tabIndex={-1}
         aria-label={t("insights.coach.sourcesTitle")}
-        className="border-border focus-visible:ring-ring/50 border-t pt-4 outline-none focus-visible:ring-2"
+        className="border-border border-t pt-4 outline-none"
       >
         <SourcesRail className="h-auto p-0" />
       </section>