diff --git a/src/components/admin/assistant-section.tsx b/src/components/admin/assistant-section.tsx
index 11872bbb9..3ee132231 100644
--- a/src/components/admin/assistant-section.tsx
+++ b/src/components/admin/assistant-section.tsx
@@ -14,9 +14,23 @@ import {
 } from "@/lib/query-keys";
 import { SettingsToggle } from "./_shared";
 import { apiGet, apiPut } from "@/lib/api/api-fetch";
+import { Label } from "@/components/ui/label";
+import { NativeSelect } from "@/components/ui/native-select";
+import {
+  DEFAULT_REASONING_MAX_EFFORT,
+  REASONING_ADMIN_KEYS,
+  REASONING_LEVEL_LABEL_KEYS,
+  REASONING_MAX_EFFORTS,
+  type ReasoningMaxEffort,
+} from "@/lib/ai/reasoning/levels";
 
 /**
- * Operator-side panel for the five assistant switches. The master stops
+ * Operator-side panel for the five assistant switches, and (v1.41) the two
+ * reasoning controls: whether models may think before they answer at all,
+ * and the highest depth a person may choose. Background jobs follow the
+ * same switch; there is no separate one.
+ *
+ * The five switches: The master stops
  * every AI feature; four sub-switches each stop one cost or egress profile:
  * the Coach, the daily briefing, status notes (per-reading notes, workout
  * notes, reaction lines) and reading documents (the vault, lab scans,
@@ -48,8 +62,16 @@ interface AssistantFlagsResponse {
     insightStatus: boolean;
     documentAi: boolean;
   };
+  /** v1.41 — the operator's reasoning controls; absent before v1.41. */
+  reasoning?: { enabled: boolean; maxEffort: ReasoningMaxEffort };
 }
 
+/** What the route accepts: any of the switches, and the reasoning pair. */
+type AssistantFlagsPatch = Partial<AssistantFlagsResponse["raw"]> & {
+  aiReasoningEnabled?: boolean;
+  aiReasoningMaxEffort?: ReasoningMaxEffort;
+};
+
 function useAssistantFlags() {
   return useQuery({
     queryKey: queryKeys.adminAssistantFlags(),
@@ -66,7 +88,7 @@ function useUpdateAssistantFlags() {
   const { t } = useTranslations();
   return useMutation({
     mutationFn: async (
-      patch: Partial<AssistantFlagsResponse["raw"]>,
+      patch: AssistantFlagsPatch,
     ): Promise<AssistantFlagsResponse> => {
       return apiPut<AssistantFlagsResponse>(
         "/api/admin/settings/assistant-flags",
@@ -102,6 +124,7 @@ export function AssistantSection() {
   const raw = data?.raw;
   const masterOn = raw?.assistantEnabled ?? true;
   const disabledSubs = !masterOn || mutation.isPending;
+  const reasoningOn = data?.reasoning?.enabled ?? true;
 
   return (
     <SettingsCard>
@@ -159,6 +182,49 @@ export function AssistantSection() {
             disabled={disabledSubs}
           />
         </div>
+
+        {/* v1.41 — reasoning: allowed at all, and how deep at most. */}
+        <div
+          data-slot="admin-assistant-reasoning"
+          className="border-border space-y-4 border-t pt-4"
+        >
+          <SettingsToggle
+            label={t(REASONING_ADMIN_KEYS.enabled)}
+            description={t("admin.assistant.reasoning.description")}
+            checked={reasoningOn}
+            onCheckedChange={(checked) =>
+              mutation.mutate({ aiReasoningEnabled: checked })
+            }
+            disabled={disabledSubs}
+          />
+          <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between sm:gap-4">
+            <Label
+              htmlFor="admin-reasoning-max"
+              noColon
+              className="text-sm font-medium"
+            >
+              {t(REASONING_ADMIN_KEYS.max)}
+            </Label>
+            <NativeSelect
+              id="admin-reasoning-max"
+              data-slot="admin-reasoning-max"
+              className="sm:w-48"
+              value={data?.reasoning?.maxEffort ?? DEFAULT_REASONING_MAX_EFFORT}
+              disabled={disabledSubs || !reasoningOn}
+              onChange={(e) =>
+                mutation.mutate({
+                  aiReasoningMaxEffort: e.target.value as ReasoningMaxEffort,
+                })
+              }
+            >
+              {REASONING_MAX_EFFORTS.map((effort) => (
+                <option key={effort} value={effort}>
+                  {t(REASONING_LEVEL_LABEL_KEYS[effort])}
+                </option>
+              ))}
+            </NativeSelect>
+          </div>
+        </div>
       </div>
     </SettingsCard>
   );
diff --git a/src/components/insights/coach-panel/__tests__/coach-model-picker.test.tsx b/src/components/insights/coach-panel/__tests__/coach-model-picker.test.tsx
index 2d4a8af6a..d24b0fca0 100644
--- a/src/components/insights/coach-panel/__tests__/coach-model-picker.test.tsx
+++ b/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();
-  });
-});
diff --git a/src/components/insights/coach-panel/__tests__/coach-reasoning-field.test.tsx b/src/components/insights/coach-panel/__tests__/coach-reasoning-field.test.tsx
new file mode 100644
index 000000000..25ec4c284
--- /dev/null
+++ b/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)");
+  });
+});
diff --git a/src/components/insights/coach-panel/__tests__/coach-settings-overlay.test.tsx b/src/components/insights/coach-panel/__tests__/coach-settings-overlay.test.tsx
index bb595f401..726f4b5d3 100644
--- a/src/components/insights/coach-panel/__tests__/coach-settings-overlay.test.tsx
+++ b/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", () => {
diff --git a/src/components/insights/coach-panel/coach-model-picker.tsx b/src/components/insights/coach-panel/coach-model-picker.tsx
index 8c73b35a1..3c6a3d543 100644
--- a/src/components/insights/coach-panel/coach-model-picker.tsx
+++ b/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")}
diff --git a/src/components/insights/coach-panel/coach-reasoning-field.tsx b/src/components/insights/coach-panel/coach-reasoning-field.tsx
new file mode 100644
index 000000000..8ea3a5038
--- /dev/null
+++ b/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 })}
+    />
+  );
+}
diff --git a/src/components/insights/coach-panel/coach-settings-body.tsx b/src/components/insights/coach-panel/coach-settings-body.tsx
index 2a844cbb9..31b8da580 100644
--- a/src/components/insights/coach-panel/coach-settings-body.tsx
+++ b/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>
diff --git a/src/components/settings/__tests__/coach-links-without-coach.test.tsx b/src/components/settings/__tests__/coach-links-without-coach.test.tsx
index 4a2ecb8da..5025a769a 100644
--- a/src/components/settings/__tests__/coach-links-without-coach.test.tsx
+++ b/src/components/settings/__tests__/coach-links-without-coach.test.tsx
@@ -15,6 +15,8 @@ vi.mock("@/hooks/use-ai-capability", () => ({
     reason: coachState.available ? null : "no_provider",
     onDeviceAllowed: false,
   }),
+  // v1.41 — the thinking depth reads the resolved block; none here.
+  useCoachReasoning: () => null,
 }));
 vi.mock("next/navigation", () => ({
   useRouter: () => ({ push: vi.fn(), replace: vi.fn() }),
diff --git a/src/components/settings/__tests__/coach-memory-section.test.tsx b/src/components/settings/__tests__/coach-memory-section.test.tsx
index c5ca68404..d93d4b891 100644
--- a/src/components/settings/__tests__/coach-memory-section.test.tsx
+++ b/src/components/settings/__tests__/coach-memory-section.test.tsx
@@ -25,10 +25,17 @@ import { CoachMemorySection } from "../coach-memory-section";
 
 interface SeedFact {
   id: string;
-  category: "preference" | "condition" | "goal" | "constraint" | "context";
+  category:
+    | "preference"
+    | "condition"
+    | "goal"
+    | "constraint"
+    | "context"
+    | "medication";
   text: string;
   confidence: number;
   createdAt: string;
+  source?: "user" | "coach" | "extracted" | "pattern";
 }
 
 const NOW = "2026-06-04T12:00:00.000Z";
@@ -152,4 +159,45 @@ describe("Settings — CoachMemorySection", () => {
     expect(withFacts).toContain("rolling summary");
     expect(empty).toContain("rolling summary");
   });
+
+  it("says where each fact came from, and offers to edit it", () => {
+    const html = render([
+      { ...buildFacts()[0], source: "user" },
+      { ...buildFacts()[1], source: "coach" },
+      { ...buildFacts()[2], source: "extracted" },
+      {
+        id: "fact-med-1",
+        category: "medication",
+        text: "Takes ramipril in the morning",
+        confidence: 1,
+        createdAt: NOW,
+        source: "user",
+      },
+    ]);
+    expect(
+      html.match(/data-slot="settings-coach-memory-source"/g),
+    ).toHaveLength(4);
+    expect(html).toContain("from you");
+    expect(html).toContain("from the Coach");
+    expect(html.match(/data-slot="settings-coach-memory-edit"/g)).toHaveLength(
+      4,
+    );
+    expect(html).toMatch(
+      /data-slot="settings-coach-memory-edit"[^>]*aria-label="Edit"/,
+    );
+    // Medications get their own group.
+    expect(html).toContain(
+      'data-testid="settings-coach-memory-group-medication"',
+    );
+    expect(html).toContain("Medications");
+    // The quick settings land here.
+    expect(html).toMatch(/<section[^>]*id="coach-memory"/);
+  });
+
+  it("lists goals first", () => {
+    const html = render(buildFacts());
+    expect(html.indexOf("group-goal")).toBeLessThan(
+      html.indexOf("group-preference"),
+    );
+  });
 });
diff --git a/src/components/settings/__tests__/coach-prefs-sources-summary.test.tsx b/src/components/settings/__tests__/coach-prefs-sources-summary.test.tsx
index a1d4158a6..23d8317c5 100644
--- a/src/components/settings/__tests__/coach-prefs-sources-summary.test.tsx
+++ b/src/components/settings/__tests__/coach-prefs-sources-summary.test.tsx
@@ -13,6 +13,8 @@ vi.mock("@/hooks/use-ai-capability", () => ({
     reason: null,
     onDeviceAllowed: false,
   }),
+  // v1.41 — the thinking depth reads the resolved block; none here.
+  useCoachReasoning: () => null,
 }));
 vi.mock("next/navigation", () => ({
   useRouter: () => ({ push: vi.fn(), replace: vi.fn() }),
diff --git a/src/components/settings/__tests__/coach-section.test.tsx b/src/components/settings/__tests__/coach-section.test.tsx
index 20c9689d2..157b489e1 100644
--- a/src/components/settings/__tests__/coach-section.test.tsx
+++ b/src/components/settings/__tests__/coach-section.test.tsx
@@ -36,6 +36,8 @@ vi.mock("@/hooks/use-ai-capability", () => ({
     reason: null,
     onDeviceAllowed: true,
   }),
+  // v1.41 — the thinking depth reads the resolved block; none here.
+  useCoachReasoning: () => null,
 }));
 
 const authState: {
diff --git a/src/components/settings/ai/reasoning-effort-field.tsx b/src/components/settings/ai/reasoning-effort-field.tsx
index fee0f4e3f..c6698b641 100644
--- a/src/components/settings/ai/reasoning-effort-field.tsx
+++ b/src/components/settings/ai/reasoning-effort-field.tsx
@@ -4,6 +4,8 @@
  * Reasoning select (#1126) for the Local and OpenAI-compatible forms.
  * Same Label + NativeSelect + hint layout as the model field above it.
  * The empty value is Default: nothing is sent and the model decides.
+ * v1.41 — the Coach reads its own thinking depth from the Coach settings;
+ * a line under the hint says so.
  * ──────────────────────────────────────────────────────────────── */
 
 import { Label } from "@/components/ui/label";
@@ -56,6 +58,14 @@ export function ReasoningEffortField({
       <p id={`${id}-hint`} className="text-muted-foreground mt-1 text-xs">
         {t("settings.ai.reasoning.hint")}
       </p>
+      {/* v1.41 — the Coach has its own thinking depth; this select is the
+          default for everything else the provider does. */}
+      <p
+        data-slot="reasoning-effort-coach-note"
+        className="text-muted-foreground mt-1 text-xs"
+      >
+        {t("settings.ai.reasoning.coachNote")}
+      </p>
     </div>
   );
 }
diff --git a/src/components/settings/coach-memory-section.tsx b/src/components/settings/coach-memory-section.tsx
index 79b61e663..19a80593f 100644
--- a/src/components/settings/coach-memory-section.tsx
+++ b/src/components/settings/coach-memory-section.tsx
@@ -16,6 +16,12 @@
  * every read/write routes its key through `queryKeys.coachFacts()` so
  * a forget invalidates the list.
  *
+ * v1.41 — the Coach's one memory. Each entry says where it came from
+ * ("from you" for what the person asked it to keep, "from the Coach" for what
+ * it kept or worked out itself), and can be edited in place
+ * (`PATCH /api/insights/coach/facts/{id}`) as well as forgotten. The Coach's
+ * quick settings link here (`#coach-memory`).
+ *
  * v1.39 — never gated on the Coach. What the Coach stored is the person's
  * own record: it stays readable and deletable while the Coach is off for any
  * reason (the operator's switch, Hide Coach, no provider, no consent). The
@@ -24,9 +30,9 @@
  * shows this card; while that page is not reachable, Settings → AI shows it
  * through `<StoredCoachMemory>` below, whenever rows exist.
  */
-import { useMemo } from "react";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { Brain, Loader2, Trash2 } from "lucide-react";
+import { useMemo, useState } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { Brain, Loader2, Pencil, Trash2 } from "lucide-react";
 
 import {
   AlertDialog,
@@ -50,42 +56,192 @@ import { SettingsCardHeader } from "@/components/settings/_card-header";
 import { useTranslations } from "@/lib/i18n/context";
 import { queryKeys } from "@/lib/query-keys";
 import { toast } from "sonner";
-import { apiDelete, apiGet } from "@/lib/api/api-fetch";
+import { apiDelete } from "@/lib/api/api-fetch";
+import { Textarea } from "@/components/ui/textarea";
+import {
+  COACH_MEMORY_LIST_KEYS,
+  REMEMBER_FACT_MAX_CHARS,
+} from "@/lib/ai/coach/memory/shared";
+import {
+  useCoachFacts,
+  useEditCoachFact,
+  useForgetCoachFact,
+  type CoachFactDTO,
+} from "@/components/insights/coach-panel/use-coach-facts";
 import { CoachConversationsMemoryCard } from "@/components/settings/coach-conversations-memory-card";
 import { CoachRemindersSection } from "@/components/settings/coach-reminders-section";
 import { CoachPlansMemoryCard } from "@/components/settings/coach-plans-memory-card";
 
-/** Closed enum mirrored from the server `CoachFact.category` column. */
+/**
+ * The categories in the order the list shows them: goals first, then how the
+ * person likes things, then health, then the rest.
+ */
 const FACT_CATEGORIES = [
+  "goal",
   "preference",
   "condition",
-  "goal",
+  "medication",
   "constraint",
   "context",
 ] as const;
 type FactCategory = (typeof FACT_CATEGORIES)[number];
 
-interface CoachFact {
-  id: string;
-  category: FactCategory;
-  text: string;
-  confidence: number;
-  createdAt: string;
-}
-
 const CATEGORY_LABEL_KEY: Record<FactCategory, string> = {
+  goal: "settings.ai.coachMemory.categoryGoal",
   preference: "settings.ai.coachMemory.categoryPreference",
   condition: "settings.ai.coachMemory.categoryCondition",
-  goal: "settings.ai.coachMemory.categoryGoal",
+  medication: COACH_MEMORY_LIST_KEYS.categoryMedication,
   constraint: "settings.ai.coachMemory.categoryConstraint",
   context: "settings.ai.coachMemory.categoryContext",
 };
 
-async function fetchFacts(): Promise<CoachFact[]> {
-  const data = await apiGet<{ facts?: CoachFact[] } | undefined>(
-    "/api/insights/coach/facts",
+/** "from you" for what the person asked to keep; everything else the Coach. */
+export function factSourceKey(
+  fact: Pick<CoachFactDTO, "source">,
+): string | null {
+  if (!fact.source) return null;
+  return fact.source === "user"
+    ? COACH_MEMORY_LIST_KEYS.sourceUser
+    : COACH_MEMORY_LIST_KEYS.sourceCoach;
+}
+
+/** One entry, read or being edited. */
+function FactRow({
+  fact,
+  isAuthenticated,
+  forgetting,
+  onForget,
+}: {
+  fact: CoachFactDTO;
+  isAuthenticated: boolean;
+  forgetting: boolean;
+  onForget: () => void;
+}) {
+  const { t } = useTranslations();
+  const [editing, setEditing] = useState(false);
+  const [draft, setDraft] = useState(fact.text);
+  const edit = useEditCoachFact({
+    // The edited words in place are the confirmation.
+    onSuccess: () => setEditing(false),
+    onError: () => toast.error(t("admin.settingsSaveError")),
+  });
+  const sourceKey = factSourceKey(fact);
+  const trimmed = draft.trim();
+  const inputId = `coach-memory-edit-${fact.id}`;
+  return (
+    <li
+      data-testid="settings-coach-memory-fact"
+      data-source={fact.source}
+      className="border-border bg-background flex flex-col gap-2 rounded-lg border p-3"
+    >
+      {editing ? (
+        <form
+          className="flex flex-col gap-2"
+          onSubmit={(e) => {
+            e.preventDefault();
+            if (trimmed && trimmed !== fact.text) {
+              edit.mutate({ id: fact.id, fact: trimmed });
+            } else {
+              setEditing(false);
+            }
+          }}
+        >
+          <label htmlFor={inputId} className="sr-only">
+            {t(COACH_MEMORY_LIST_KEYS.edit)}
+          </label>
+          <Textarea
+            id={inputId}
+            data-slot="settings-coach-memory-edit-input"
+            value={draft}
+            maxLength={REMEMBER_FACT_MAX_CHARS}
+            rows={2}
+            onChange={(e) => setDraft(e.target.value)}
+            className="text-sm"
+          />
+          <div className="flex flex-wrap items-center justify-end gap-2">
+            <Button
+              type="button"
+              variant="outline"
+              size="sm"
+              className="min-h-11 sm:min-h-9"
+              onClick={() => {
+                setDraft(fact.text);
+                setEditing(false);
+              }}
+            >
+              {t("settings.ai.coachMemory.cancel")}
+            </Button>
+            <Button
+              type="submit"
+              size="sm"
+              className="min-h-11 sm:min-h-9"
+              data-slot="settings-coach-memory-edit-save"
+              disabled={!trimmed || edit.isPending}
+            >
+              {edit.isPending ? (
+                <Loader2
+                  className="size-3.5 animate-spin motion-reduce:animate-none"
+                  aria-hidden
+                />
+              ) : null}
+              {t("settings.ai.saveCta")}
+            </Button>
+          </div>
+        </form>
+      ) : (
+        <div className="flex items-start justify-between gap-3">
+          <div className="min-w-0">
+            <p className="text-sm break-words">{fact.text}</p>
+            <p className="text-muted-foreground mt-1 text-xs">
+              {t("settings.ai.coachMemory.learnedPrefix", {
+                when: formatDateOrRelative(fact.createdAt, t),
+              })}
+              {sourceKey ? (
+                <span data-slot="settings-coach-memory-source">
+                  <span aria-hidden="true"> · </span>
+                  <span className="sr-only">, </span>
+                  {t(sourceKey)}
+                </span>
+              ) : null}
+            </p>
+          </div>
+          <div className="flex shrink-0 items-center gap-1">
+            <Button
+              type="button"
+              variant="ghost"
+              size="icon"
+              data-slot="settings-coach-memory-edit"
+              aria-label={t(COACH_MEMORY_LIST_KEYS.edit)}
+              title={t(COACH_MEMORY_LIST_KEYS.edit)}
+              disabled={!isAuthenticated}
+              className="size-11 sm:size-9"
+              onClick={() => {
+                setDraft(fact.text);
+                setEditing(true);
+              }}
+            >
+              <Pencil className="size-4" aria-hidden />
+            </Button>
+            <ConfirmButton
+              slot="settings-coach-memory-forget"
+              variant="ghost"
+              size="sm"
+              className="min-h-11 sm:min-h-9"
+              ariaLabel={t("settings.ai.coachMemory.forgetAria")}
+              icon={<Trash2 className="size-4" aria-hidden />}
+              label={t("settings.ai.coachMemory.forget")}
+              title={t("settings.ai.coachMemory.forgetTitle")}
+              body={t("settings.ai.coachMemory.forgetBody")}
+              confirmLabel={t("settings.ai.coachMemory.forgetConfirm")}
+              disabled={!isAuthenticated}
+              pending={forgetting}
+              onConfirm={onForget}
+            />
+          </div>
+        </div>
+      )}
+    </li>
   );
-  return data?.facts ?? [];
 }
 
 export function CoachMemorySection({
@@ -99,25 +255,11 @@ export function CoachMemorySection({
   const { t } = useTranslations();
   const queryClient = useQueryClient();
 
-  const query = useQuery({
-    queryKey: queryKeys.coachFacts(),
-    queryFn: fetchFacts,
-    enabled: isAuthenticated,
-  });
+  const query = useCoachFacts({ enabled: isAuthenticated });
 
-  const forgetOne = useMutation({
-    mutationKey: queryKeys.coachFacts(),
-    mutationFn: async (id: string) => {
-      await apiDelete(`/api/insights/coach/facts/${encodeURIComponent(id)}`);
-      return id;
-    },
-    onSuccess: () => {
-      toast.success(t("settings.ai.coachMemory.forgotToast"));
-      queryClient.invalidateQueries({ queryKey: queryKeys.coachFacts() });
-    },
-    onError: () => {
-      toast.error(t("settings.ai.coachMemory.forgotError"));
-    },
+  const forgetOne = useForgetCoachFact({
+    onSuccess: () => toast.success(t("settings.ai.coachMemory.forgotToast")),
+    onError: () => toast.error(t("settings.ai.coachMemory.forgotError")),
   });
 
   const forgetAll = useMutation({
@@ -144,9 +286,16 @@ export function CoachMemorySection({
   // Group by category in the canonical category order so the panel
   // reads the same way every render regardless of insertion order.
   const grouped = useMemo(() => {
+    // A category the list does not know (an older extraction's) reads as
+    // context rather than vanishing.
+    const known = new Set<string>(FACT_CATEGORIES);
     return FACT_CATEGORIES.map((category) => ({
       category,
-      items: facts.filter((f) => f.category === category),
+      items: facts.filter((f) =>
+        known.has(f.category)
+          ? f.category === category
+          : category === "context",
+      ),
     })).filter((g) => g.items.length > 0);
   }, [facts]);
 
@@ -156,6 +305,8 @@ export function CoachMemorySection({
   return (
     <SettingsCard
       as="section"
+      id="coach-memory"
+      className="scroll-mt-28"
       aria-labelledby="settings-ai-coach-memory-title"
       data-testid="settings-coach-memory-card"
     >
@@ -193,42 +344,16 @@ export function CoachMemorySection({
               </h3>
               <ul className="space-y-2">
                 {group.items.map((fact) => (
-                  <li
+                  <FactRow
                     key={fact.id}
-                    data-testid="settings-coach-memory-fact"
-                    className="border-border bg-background flex items-start justify-between gap-3 rounded-lg border p-3"
-                  >
-                    <div className="min-w-0">
-                      <p className="text-sm break-words">{fact.text}</p>
-                      <p className="text-muted-foreground mt-1 text-xs">
-                        {t("settings.ai.coachMemory.learnedPrefix", {
-                          when: formatDateOrRelative(fact.createdAt, t),
-                        })}
-                      </p>
-                    </div>
-                    <ConfirmButton
-                      slot="settings-coach-memory-forget"
-                      variant="ghost"
-                      size="sm"
-                      className="min-h-11 sm:min-h-9"
-                      ariaLabel={t("settings.ai.coachMemory.forgetAria")}
-                      icon={<Trash2 className="size-4" aria-hidden />}
-                      label={t("settings.ai.coachMemory.forget")}
-                      title={t("settings.ai.coachMemory.forgetTitle")}
-                      body={t("settings.ai.coachMemory.forgetBody")}
-                      confirmLabel={t("settings.ai.coachMemory.forgetConfirm")}
-                      disabled={!isAuthenticated}
-                      // v1.11.2 — per-id pending: only the row being
-                      // deleted disables/spins. `forgetOne.variables` holds
-                      // the id passed to the in-flight `mutate()`, so a
-                      // single shared mutation no longer greys out every
-                      // other row's forget button during one delete.
-                      pending={
-                        forgetOne.isPending && forgetOne.variables === fact.id
-                      }
-                      onConfirm={() => forgetOne.mutate(fact.id)}
-                    />
-                  </li>
+                    fact={fact}
+                    isAuthenticated={isAuthenticated}
+                    // Per-id pending: only the row being deleted spins.
+                    forgetting={
+                      forgetOne.isPending && forgetOne.variables === fact.id
+                    }
+                    onForget={() => forgetOne.mutate(fact.id)}
+                  />
                 ))}
               </ul>
             </div>
diff --git a/src/components/settings/coach-prefs-section.tsx b/src/components/settings/coach-prefs-section.tsx
index 1e1756575..123363f4a 100644
--- a/src/components/settings/coach-prefs-section.tsx
+++ b/src/components/settings/coach-prefs-section.tsx
@@ -39,13 +39,18 @@ import { SettingsCard } from "@/components/settings/settings-card";
 import { SettingsCardHeader } from "@/components/settings/_card-header";
 import { useTranslations } from "@/lib/i18n/context";
 import { useCoachPrefs, useSaveCoachPrefs } from "@/hooks/use-coach-prefs";
-import { useAiCapability } from "@/hooks/use-ai-capability";
+import {
+  CoachReasoningSelect,
+  reasoningStateOrDefault,
+} from "@/components/insights/coach-panel/coach-reasoning-field";
+import { useAiCapability, useCoachReasoning } from "@/hooks/use-ai-capability";
 import { COACH_FOLLOW_UP_UI_KEYS } from "@/lib/ai/coach/dialog-keys";
 import { HISTORY_REACH_DAYS, lookbackText } from "@/lib/ai/coach/history-reach";
 import {
   DEFAULT_COACH_CLUSTERS,
   DEFAULT_COACH_PREFS,
   coachDataClusterEnum,
+  coachReasoningLevel,
   type CoachExcludeMetric,
   type CoachPrefs,
   type CoachTone,
@@ -106,6 +111,7 @@ export interface CoachPrefsSectionProps {
 export function CoachPrefsSection({ isAuthenticated }: CoachPrefsSectionProps) {
   const { t } = useTranslations();
   const coach = useAiCapability("coach");
+  const reasoningState = reasoningStateOrDefault(useCoachReasoning());
 
   const { data: persisted } = useCoachPrefs({ enabled: isAuthenticated });
 
@@ -252,6 +258,17 @@ export function CoachPrefsSection({ isAuthenticated }: CoachPrefsSectionProps) {
             </div>
           </div>
 
+          {/* v1.41 — how hard the Coach thinks; the same field sits in the
+              Coach's quick settings. */}
+          <CoachReasoningSelect
+            id="coach-prefs-reasoning"
+            value={coachReasoningLevel(draft)}
+            state={reasoningState}
+            onChange={(reasoning) =>
+              setDraft((prev) => ({ ...prev, reasoning }))
+            }
+          />
+
           {/* Data clusters + analysis window live on ONE owner: "What I
               can see" behind the Coach's settings gear, which
               `/coach?settings=data` opens directly. This card used to render