diff --git a/.storybook/preview.tsx b/.storybook/preview.tsx
index 3edfc78d..f86bfa88 100644
--- a/.storybook/preview.tsx
+++ b/.storybook/preview.tsx
@@ -249,10 +249,21 @@ const withBrand: Decorator = (Story, context) => {
 // explicit `codeLookup` / `renderCodeSearch` prop) demonstrates offline coded
 // search. Stories that inject their own config still win (explicit overrides
 // context); pass `codeLookup={false}` in a story to demo the plain-text opt-out.
+//
+// The `user` / `device` toolbar globals drive the memory picklist's two gates,
+// and double as the reference for how an app wires them: one decision at the
+// mount point, not per component.
 const withCodeLookup: Decorator = (Story, context) => {
   const locale = (context.globals.locale as string) || 'en';
+  const userId = (context.globals.user as string) || 'anonymous';
+  const trusted = context.globals.device === 'trusted';
   return (
-    <CodeLookupProvider component={CodeLookup} indexUrl="/codify" locale={locale}>
+    <CodeLookupProvider
+      component={CodeLookup}
+      indexUrl="/codify"
+      locale={locale}
+      memory={{ userId, storage: trusted ? 'local' : 'session' }}
+    >
       <Story />
     </CodeLookupProvider>
   );
@@ -264,7 +275,12 @@ const preview: Preview = {
     theme: 'light',
     density: 'standard',
     locale: 'en',
+    user: 'anonymous',
+    device: 'public',
   },
+  // The bar stays one glyph wide but still shows the current value: `title` is
+  // the emoji (or a per-item icon) and the wording moves to the dropdown's
+  // `right` column.
   globalTypes: {
     brand: {
       name: 'Brand',
@@ -272,16 +288,15 @@ const preview: Preview = {
       toolbar: {
         icon: 'paintbrush',
         items: [
-          { value: 'bluehive', title: '🐝 BlueHive' },
-          { value: 'ccme', title: '🌿 ccMe' },
-          { value: 'default', title: '⚪ Default' },
-          { value: 'enterprise-health', title: '🏥 Enterprise Health' },
-          { value: 'mieweb', title: '🟢 MIE Web' },
-          { value: 'ozwell', title: '🤖 Ozwell' },
-          { value: 'waggleline', title: '🍯 Waggleline' },
-          { value: 'webchart', title: '🟠 WebChart' },
+          { value: 'bluehive', title: '🐝', right: 'BlueHive' },
+          { value: 'ccme', title: '🌿', right: 'ccMe' },
+          { value: 'default', title: '⚪', right: 'Default' },
+          { value: 'enterprise-health', title: '🏥', right: 'Enterprise Health' },
+          { value: 'mieweb', title: '🟢', right: 'MIE Web' },
+          { value: 'ozwell', title: '🤖', right: 'Ozwell' },
+          { value: 'waggleline', title: '🍯', right: 'Waggleline' },
+          { value: 'webchart', title: '🟠', right: 'WebChart' },
         ],
-        dynamicTitle: true,
       },
     },
     theme: {
@@ -293,7 +308,7 @@ const preview: Preview = {
           { value: 'light', icon: 'sun', title: 'Light' },
           { value: 'dark', icon: 'moon', title: 'Dark' },
         ],
-        dynamicTitle: true,
+        dynamicTitle: false,
       },
     },
     density: {
@@ -302,10 +317,10 @@ const preview: Preview = {
       toolbar: {
         icon: 'collapse',
         items: [
-          { value: 'standard', title: 'Standard' },
-          { value: 'condensed', title: 'Condensed' },
+          { value: 'standard', icon: 'grow', title: 'Standard' },
+          { value: 'condensed', icon: 'collapse', title: 'Condensed' },
         ],
-        dynamicTitle: true,
+        dynamicTitle: false,
       },
     },
     locale: {
@@ -314,10 +329,46 @@ const preview: Preview = {
       toolbar: {
         icon: 'globe',
         items: [
-          { value: 'en', title: '🇺🇸 English' },
-          { value: 'es', title: '🇪🇸 Español (sample)' },
+          { value: 'en', title: '🇺🇸', right: 'English' },
+          { value: 'es', title: '🇪🇸', right: 'Español (sample)' },
         ],
-        dynamicTitle: true,
+      },
+    },
+    user: {
+      name: 'Signed in as',
+      description:
+        'Simulated session identity. CodeLookup only remembers picked codes for a real user.',
+      toolbar: {
+        icon: 'user',
+        items: [
+          { value: 'anonymous', title: '🚫', right: 'Not signed in' },
+          { value: 'alice', title: '👩‍⚕️', right: 'Dr. Alice' },
+          { value: 'bob', title: '👨‍⚕️', right: 'Dr. Bob' },
+          { value: 'nurse', title: '💉', right: 'Nurse Nia' },
+          { value: 'reception', title: '🧑‍💼', right: 'Reception Rae' },
+          { value: 'patient', title: '🤒', right: 'Patient Pat' },
+        ],
+      },
+    },
+    device: {
+      name: 'Device',
+      description:
+        'Simulates the deployment’s device-trust decision (not an end-user setting): whether picked codes may be cached on this machine.',
+      toolbar: {
+        icon: 'lock',
+        items: [
+          {
+            value: 'public',
+            icon: 'unlock',
+            title: 'Public kiosk — nothing stored',
+          },
+          {
+            value: 'trusted',
+            icon: 'lock',
+            title: 'Trusted workstation — cached',
+          },
+        ],
+        dynamicTitle: false,
       },
     },
   },
diff --git a/code-memory-plan.md b/code-memory-plan.md
new file mode 100644
index 00000000..ba07b4cf
--- /dev/null
+++ b/code-memory-plan.md
@@ -0,0 +1,105 @@
+# CodeLookup "Memory" — frequently-used codes picklist
+
+Personal MRU/frequency picklist for CodeLookup: on focus with an **empty query**, show a
+"Frequently used" menu of the user's most-picked codes, scoped by **(userId, context)**.
+Counts persist in IndexedDB; an optional `serverUrl` seeds the list and receives lazily
+flushed count deltas. On by default wherever the provider names a signed-in user —
+`memory={false}` opts a provider or one box out.
+
+> Working agreement: complete a milestone → check its boxes → run its verification →
+> commit with the listed message (ask before committing, per repo policy).
+
+## Decisions (locked)
+
+- **Storage: IndexedDB** — house pattern (`src/components/AI/voiceprintStore.ts`,
+  `src/components/SuperChat/render/attachmentCache.ts`): promise-wrapped, graceful
+  no-IDB degradation, testable with `fake-indexeddb`.
+- **Server sync: full sync** — GET seed once per (user, context) per session, merge
+  `max(count)`; debounced POST of count deltas; `sendBeacon` on `pagehide`.
+- **Identity: developer-supplied `userId`** — missing → `'anonymous'` bucket.
+  Multi-user in one browser = separate buckets keyed `userId|context|fullid`.
+- **Phase 1 = empty-query menu only** — personal ranking boost while typing is phase 2.
+- **API: single prop** — `memory?: false | CodeLookupMemoryConfig`; absent/false = off.
+
+## API sketch
+
+- `CodeLookupMemoryConfig { context: string; userId?: string; serverUrl?: string; limit?: number /* default 8 */ }`
+- `CodeLookupProps` gains `memory?: false | CodeLookupMemoryConfig`
+- `CodeLookupProviderConfig` gains optional `memory` defaults (`userId`, `serverUrl`);
+  per-instance `context` always comes from the prop.
+- IDB: db `mieweb-codelookup-memory`, store `usage`, key `` `${userId}|${context}|${fullid}` ``,
+  record `{ userId, context, fullid, label, codetype, fullcode, domain, count, lastUsed, pendingDelta }`
+  (full display fields stored — no shard rehydration needed).
+- Sync protocol:
+  - `GET {serverUrl}?user={userId}&context={context}` → `[{fullid,label,codetype,fullcode,domain,count}]`
+  - `POST {serverUrl}` body `{user, context, deltas:[{fullid,label,codetype,fullcode,domain,delta}]}`
+
+---
+
+## Milestone 1 — memory store (pure TS, no React)
+
+`src/components/CodeLookup/memoryStore.ts`, modeled on `voiceprintStore.ts`.
+
+- [x] IDB open/upgrade helper with `hasIndexedDB()` guard; all APIs no-op cleanly without IDB (SSR/tests)
+- [x] `recordUse(scope, result: CodifyResult)` — increment `count` + `pendingDelta`, set `lastUsed`
+- [x] `getTopCodes(scope, limit): Promise<MemoryEntry[]>` — sort `count` desc, `lastUsed` tiebreak
+- [x] `seedFromServer(scope, serverUrl)` — once per scope per session; merge `max(count)`
+- [x] `scheduleFlush(scope, serverUrl)` — debounced POST of pending deltas; `sendBeacon` on `pagehide`; reset `pendingDelta` on success
+- [x] `clearMemory(scope)` — reset for a (user, context) bucket
+
+**Commit:** `feat(CodeLookup): memory store — IndexedDB usage counts with lazy server sync`
+
+## Milestone 2 — store tests
+
+`src/components/CodeLookup/memoryStore.test.ts` (vitest + `fake-indexeddb`, already a devDep).
+
+- [x] record → getTopCodes ordering (count desc, lastUsed tiebreak, limit)
+- [x] multi-user isolation (alice vs bob, same browser/db)
+- [x] context isolation (`med-orders` vs `presenting-meds`, same user)
+- [x] seed merge (server counts vs local counts → max wins; new entries added)
+- [x] delta flush: mocked fetch receives correct payload; `pendingDelta` reset; failure keeps deltas
+- [x] IDB-unavailable → all APIs resolve as no-ops (no throw)
+
+**Verify:** `pnpm vitest run src/components/CodeLookup/memoryStore.test.ts`
+**Commit:** `test(CodeLookup): memory store coverage — isolation, seed merge, delta flush`
+
+## Milestone 3 — CodeLookup wiring
+
+`src/components/CodeLookup/CodeLookup.tsx` + `context.tsx` + `index.ts`.
+
+- [x] `memory` prop; resolve scope from prop + provider defaults (`context.tsx`: add `memory` defaults to `CodeLookupProviderConfig`, instance prop wins)
+- [x] On mount / scope change: `seedFromServer` (if `serverUrl`) then load `getTopCodes` into state
+- [x] Empty-query branch (`!q` in the debounced search effect): show memory entries flagged `viaMemory` instead of clearing/closing; `onFocus` opens when entries exist; `dropdownOpen` gains memory disjunct
+- [x] "Frequently used" group header row (aria-labelled listbox group); existing keyboard-nav machinery reused unchanged
+- [x] `pick(r)`: `recordUse` + `scheduleFlush` + refresh cached top list
+- [x] Respect `initialQuery`/`skipSearchRef` seeded path — menu only on true empty-query focus
+- [x] Export `CodeLookupMemoryConfig`, `MemoryEntry`, `clearMemory` from the component barrel (`index.ts`) — NOT `src/index.ts` (worker bundling constraint)
+
+**Verify:** `pnpm vitest run src/components/CodeLookup/engine.test.ts` (no regressions) + typecheck
+**Commit:** `feat(CodeLookup): memory picklist — frequently-used codes menu on empty-query focus`
+
+## Milestone 4 — story + docs
+
+- [x] `WithMemory` story in `CodeLookup.stories.tsx`: alice/bob user toggle × orders/presenting context toggle demonstrating isolation; stubbed `fetch` for `serverUrl` (or omit serverUrl and demo local-only)
+- [x] `README.md`: document prop, scope semantics (user + context), sync protocol, storage, disable, multi-user
+- [x] Manual pass in Storybook (http://localhost:6006): pick codes → refocus shows count-ordered picklist; user/context switch isolates; page reload persists
+
+**Commit:** `docs(CodeLookup): memory picklist story and README`
+
+## Milestone 5 — final checks
+
+- [x] `pnpm typecheck`
+- [x] `pnpm lint`
+- [x] `pnpm format:fix`
+- [x] Full `pnpm vitest run src/components/CodeLookup/`
+- [ ] Open PR
+
+---
+
+## Phase 2 (explicitly deferred — do not build now)
+
+- Personal-count boost in `searchShards` ranking while typing (compose with population `docPrior`)
+  — *partially delivered*: matching remembered codes are merged ahead of index hits in the
+  component (`matchMemory`); in-engine score composition is still deferred.
+- Wrapper components (MedicationEditor, OrderEditor, AllergyManager, esheet fields) forwarding `memory` contexts through their `codeLookup` configs
+- Reference server endpoint implementation
diff --git a/eslint.config.js b/eslint.config.js
index e4d628c5..5ee721be 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -125,6 +125,8 @@ export default [
         // IndexedDB
         indexedDB: 'readonly',
         IDBDatabase: 'readonly',
+        IDBFactory: 'readonly',
+        IDBKeyRange: 'readonly',
         IDBObjectStore: 'readonly',
         IDBTransactionMode: 'readonly',
         IDBOpenDBRequest: 'readonly',
diff --git a/src/components/CodeLookup/CodeLookup.stories.tsx b/src/components/CodeLookup/CodeLookup.stories.tsx
index 4fb510b8..48db7373 100644
--- a/src/components/CodeLookup/CodeLookup.stories.tsx
+++ b/src/components/CodeLookup/CodeLookup.stories.tsx
@@ -2,6 +2,8 @@ import type { Meta, StoryObj } from '@storybook/react-vite';
 import { useState } from 'react';
 import { CodeLookup, type CodifyDomain } from './CodeLookup';
 import type { CodifyResult } from './engine';
+import { exportMemoryYaml, importMemoryYaml } from './memoryYaml';
+import { Button } from '../Button';
 
 const meta: Meta<typeof CodeLookup> = {
   title: 'Healthcare/CodeLookup',
@@ -160,3 +162,151 @@ export const QualityMeasures: Story = {
     />
   ),
 };
+
+function MemoryTemplate({
+  locale,
+  userId,
+  device,
+}: {
+  locale?: string;
+  userId: string;
+  device: string;
+}) {
+  const [context, setContext] = useState('med-orders');
+  const [selected, setSelected] = useState<CodifyResult | null>(null);
+  const [yamlText, setYamlText] = useState('');
+  const [yamlNote, setYamlNote] = useState('');
+  // bump to remount CodeLookup so an import shows up in the picklist
+  const [reloadKey, setReloadKey] = useState(0);
+  const toggle = (
+    label: string,
+    value: string,
+    options: string[],
+    onChange: (v: string) => void
+  ) => (
+    <label className="flex items-center gap-1.5 text-sm">
+      {label}
+      <select
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+        className="border-border bg-background rounded border px-1.5 py-0.5 text-sm"
+      >
+        {options.map((o) => (
+          <option key={o}>{o}</option>
+        ))}
+      </select>
+    </label>
+  );
+  return (
+    <div className="mx-auto max-w-2xl space-y-3">
+      <div className="flex items-center gap-4">
+        {toggle(
+          'Context',
+          context,
+          ['med-orders', 'presenting-meds'],
+          setContext
+        )}
+        <p className="text-muted-foreground text-xs">
+          Signed in as <strong>{userId}</strong> on a{' '}
+          <strong>{device === 'trusted' ? 'trusted' : 'public'}</strong> device
+          — set both in the toolbar.
+        </p>
+      </div>
+      <CodeLookup
+        // remount on scope change so seeded input state can't linger
+        key={`${userId}|${context}|${device}|${reloadKey}`}
+        indexUrl="/codify"
+        locale={locale}
+        domains={['med']}
+        memory={{ context }}
+        onSelect={setSelected}
+      />
+      {selected && (
+        <pre className="bg-muted overflow-auto rounded-md p-3 text-xs">
+          {JSON.stringify(selected, null, 2)}
+        </pre>
+      )}
+
+      <div className="space-y-2">
+        <div className="flex items-center gap-2">
+          <Button
+            size="sm"
+            variant="secondary"
+            onClick={async () => {
+              setYamlText(await exportMemoryYaml({ userId, context }));
+              setYamlNote(`Exported ${userId} / ${context}`);
+            }}
+          >
+            Export YAML
+          </Button>
+          <Button
+            size="sm"
+            variant="secondary"
+            onClick={async () => {
+              setYamlText(await exportMemoryYaml());
+              setYamlNote('Exported all buckets');
+            }}
+          >
+            Export all
+          </Button>
+          <Button
+            size="sm"
+            onClick={async () => {
+              try {
+                const r = await importMemoryYaml(yamlText, {
+                  scope: { userId, context },
+                });
+                setYamlNote(
+                  `Imported ${r.imported} codes into ${userId} / ${context}` +
+                    (r.skipped ? ` (${r.skipped} skipped)` : '')
+                );
+                setReloadKey((k) => k + 1);
+              } catch (err) {
+                setYamlNote(`Import failed: ${(err as Error).message}`);
+              }
+            }}
+          >
+            Import into this bucket
+          </Button>
+          <span className="text-muted-foreground text-xs" aria-live="polite">
+            {yamlNote}
+          </span>
+        </div>
+        <textarea
+          value={yamlText}
+          onChange={(e) => setYamlText(e.target.value)}
+          aria-label="Memory YAML"
+          placeholder="Export writes YAML here; paste a memory export to import it."
+          className="border-border bg-background h-40 w-full rounded-md border p-2 font-mono text-xs"
+        />
+      </div>
+    </div>
+  );
+}
+
+/** Personal "Frequently used" picklist (the `memory` prop). Pick a few meds,
+ * clear/refocus the empty box — your most-picked codes appear first. Keep
+ * typing and your remembered codes stay pinned above the index hits, marked ☆
+ * with their pick count. Switch **context** here, and **Signed in as** in the
+ * toolbar, to see bucket isolation (alice/med-orders never sees bob's picks,
+ * nor alice's presenting-meds picks).
+ *
+ * Two gates guard the whole feature, both driven from the toolbar:
+ * *Not signed in* remembers nothing at all, and a **public kiosk** device
+ * keeps counts in RAM only — reload and they are gone. Only a **trusted
+ * workstation** caches them in IndexedDB. Local-only here; add `serverUrl` to
+ * make the server the source of truth.
+ *
+ * **Export/Import YAML** below the box: dump a bucket (or all of them) to
+ * YAML, edit it, and merge it back — into the *currently selected* bucket, so
+ * you can hand alice's list to bob or seed a context from a curated starter
+ * set. Counts merge by max, so importing twice changes nothing. */
+export const WithMemory: Story = {
+  render: (_args, { globals }) => (
+    <MemoryTemplate
+      locale={globals.locale}
+      userId={globals.user ?? 'anonymous'}
+      device={globals.device ?? 'public'}
+    />
+  ),
+};
diff --git a/src/components/CodeLookup/CodeLookup.tsx b/src/components/CodeLookup/CodeLookup.tsx
index 8deb87fb..aa9bb630 100644
--- a/src/components/CodeLookup/CodeLookup.tsx
+++ b/src/components/CodeLookup/CodeLookup.tsx
@@ -19,9 +19,20 @@ import {
   AlertCircleIcon,
   ChevronRightIcon,
   ChevronLeftIcon,
+  StarIcon,
 } from '../Icons';
 import type { CodifyResult } from './engine';
 import { familyKey, familyTerm } from './engine';
+import { useCodeLookupConfig } from './context';
+import {
+  recordUse,
+  scheduleFlush,
+  syncFromServer,
+  getTopCodes,
+  matchMemory,
+  setMemoryStorage,
+  type MemoryEntry,
+} from './memoryStore';
 
 // =============================================================================
 // Types
@@ -36,6 +47,29 @@ export type CodifyDomain =
   | 'occupational'
   | 'quality';
 
+/**
+ * Per-instance tuning for the "Frequently used" memory picklist: focusing the
+ * empty search box lists the user's most-picked codes for this context.
+ *
+ * Memory turns on by itself once the provider supplies a signed-in
+ * `memory.userId` — pass this only to override the bucket or the limits, or
+ * `memory={false}` to opt one box out.
+ */
+export interface CodeLookupMemoryConfig {
+  /**
+   * Usage context the counts are scoped to (e.g. 'med-orders'). Defaults to
+   * this box's `domains`, so a med picker and a problem picker never share a
+   * picklist.
+   */
+  context?: string;
+  /** User id for scoping; falls back to the provider default. No id, no memory. */
+  userId?: string;
+  /** Count-sync endpoint (GET sync + POST deltas); provider default fallback. */
+  serverUrl?: string;
+  /** Max entries in the picklist (default 8). */
+  limit?: number;
+}
+
 export interface CodeLookupProps extends Omit<
   React.HTMLAttributes<HTMLDivElement>,
   'className' | 'onSelect'
@@ -111,6 +145,12 @@ export interface CodeLookupProps extends Omit<
    * immediately (defaults to true in bare mode, false otherwise).
    */
   clearOnSelect?: boolean;
+  /**
+   * Tune the "Frequently used" picklist — it is already on wherever the
+   * provider names a signed-in `memory.userId`. Pass `false` to opt this box
+   * out.
+   */
+  memory?: false | CodeLookupMemoryConfig;
   /** Additional CSS classes */
   className?: string;
   /** Test ID for testing */
@@ -151,6 +191,20 @@ const DETAIL_NOUN: Record<string, string> = {
 /** Domains whose drill-down resolves a curated program order set. */
 const PROGRAM_DOMAINS = new Set(['occupational', 'quality']);
 
+/** A remembered entry as a result row (`score` carries the pick count). */
+function toMemoryResult(e: MemoryEntry): CodifyResult {
+  return {
+    fullid: e.fullid,
+    label: e.label,
+    codetype: e.codetype,
+    fullcode: e.fullcode,
+    domain: e.domain,
+    score: e.count,
+    viaAlias: false,
+    viaMemory: true,
+  };
+}
+
 // =============================================================================
 // CodeLookup
 // =============================================================================
@@ -182,6 +236,7 @@ export const CodeLookup = React.forwardRef<HTMLDivElement, CodeLookupProps>(
       placeholder = 'Search conditions, meds, labs… (try "con hea fa", "chf", "lasix")',
       bare = false,
       clearOnSelect,
+      memory,
       className,
       'data-testid': dataTestId,
       ...props
@@ -229,6 +284,54 @@ export const CodeLookup = React.forwardRef<HTMLDivElement, CodeLookupProps>(
       ? preferCodetypes.join(',')
       : null;
 
+    // ---- memory picklist ("Frequently used" on empty-query focus) ----
+    const providerConfig = useCodeLookupConfig();
+    const providerMemory =
+      providerConfig?.memory === false ? null : providerConfig?.memory;
+    // On by default: a provider that names a signed-in user gets the picklist
+    // everywhere. `memory={false}` opts out — on the provider for a public
+    // kiosk, on the instance for one box.
+    const memOff = providerConfig?.memory === false || memory === false;
+    const memCfg = memory === false ? null : memory;
+    const memUserId = memOff
+      ? null
+      : (memCfg?.userId ?? providerMemory?.userId ?? null);
+    const memContext = memOff
+      ? null
+      : (memCfg?.context ?? providerMemory?.context ?? domainsKey ?? 'all');
+    const memServerUrl = memOff
+      ? undefined
+      : (memCfg?.serverUrl ?? providerMemory?.serverUrl);
+    const memLimit = memCfg?.limit || 8;
+    const memStorage = providerMemory?.storage ?? 'session';
+    const [memoryEntries, setMemoryEntries] = React.useState<MemoryEntry[]>([]);
+    /** Mirror for effects that must not re-run when entries refresh. */
+    const memoryCountRef = React.useRef(0);
+    memoryCountRef.current = memoryEntries.length;
+
+    // Declared first so the store knows the device's trust level before the
+    // effect below reads or writes anything.
+    React.useEffect(() => {
+      setMemoryStorage(memStorage);
+    }, [memStorage]);
+
+    React.useEffect(() => {
+      if (!memUserId || !memContext) {
+        setMemoryEntries([]);
+        return;
+      }
+      let cancelled = false;
+      const scope = { userId: memUserId, context: memContext };
+      void (async () => {
+        if (memServerUrl) await syncFromServer(scope, memServerUrl);
+        const top = await getTopCodes(scope, memLimit);
+        if (!cancelled) setMemoryEntries(top);
+      })();
+      return () => {
+        cancelled = true;
+      };
+    }, [memUserId, memContext, memServerUrl, memLimit, memStorage]);
+
     React.useEffect(() => {
       // A new worker starts from scratch — reset all search state so a stale
       // "ready" status (from the previous worker) can't trigger searches
@@ -311,8 +414,10 @@ export const CodeLookup = React.forwardRef<HTMLDivElement, CodeLookupProps>(
       if (!q) {
         setResults([]);
         setTookMs(null);
-        setOpen(false);
         setDrill(null);
+        // With memory entries the empty-query dropdown shows the "Frequently
+        // used" picklist instead of closing (open stays as-is: focus opens it).
+        if (memoryCountRef.current === 0) setOpen(false);
         return;
       }
       const t = setTimeout(() => {
@@ -379,9 +484,39 @@ export const CodeLookup = React.forwardRef<HTMLDivElement, CodeLookupProps>(
       setActiveIndex(-1);
     };
 
-    const list: CodifyResult[] = drill ? (drill.results ?? []) : results;
+    /** Frequently-used picklist rows, shown for a true empty-query dropdown. */
+    const memoryResults = React.useMemo<CodifyResult[]>(
+      () => memoryEntries.map(toMemoryResult),
+      [memoryEntries]
+    );
+    const showMemory =
+      !drill && query.trim() === '' && memoryResults.length > 0;
+
+    /** While typing, matching remembered codes rank ahead of index hits. */
+    const rankedResults = React.useMemo<CodifyResult[]>(() => {
+      const matches = matchMemory(memoryEntries, query.trim());
+      if (matches.length === 0) return results;
+      const seen = new Set(matches.map((m) => m.fullid));
+      return [
+        ...matches.map(toMemoryResult),
+        ...results.filter((r) => !seen.has(r.fullid)),
+      ];
+    }, [memoryEntries, query, results]);
+
+    const list: CodifyResult[] = drill
+      ? (drill.results ?? [])
+      : showMemory
+        ? memoryResults
+        : rankedResults;
 
     const pick = (r: CodifyResult) => {
+      if (memUserId && memContext) {
+        const scope = { userId: memUserId, context: memContext };
+        void recordUse(scope, r).then(() => {
+          if (memServerUrl) scheduleFlush(scope, memServerUrl);
+          return getTopCodes(scope, memLimit).then(setMemoryEntries);
+        });
+      }
       onSelect?.(r);
       setOpen(false);
       setDrill(null);
@@ -540,10 +675,20 @@ export const CodeLookup = React.forwardRef<HTMLDivElement, CodeLookupProps>(
                 aria-label={
                   drill
                     ? `${DETAIL_NOUN[drill.parent.domain] ?? 'related codes'} of ${drill.parent.label}`
-                    : 'Code search results'
+                    : showMemory
+                      ? 'Frequently used codes'
+                      : 'Code search results'
                 }
                 className="divide-border max-h-80 min-h-0 divide-y overflow-y-auto"
               >
+                {showMemory && (
+                  <li
+                    role="presentation"
+                    className="text-muted-foreground bg-muted/50 px-3 py-1 text-[11px] font-semibold tracking-wide uppercase"
+                  >
+                    Frequently used
+                  </li>
+                )}
                 {list.map((r, i) => (
                   <li
                     key={r.fullid}
@@ -570,6 +715,18 @@ export const CodeLookup = React.forwardRef<HTMLDivElement, CodeLookupProps>(
                       <span className="text-foreground min-w-0 flex-1 truncate">
                         {r.label}
                       </span>
+                      {r.viaMemory && !showMemory && (
+                        <span
+                          className="text-primary-600 dark:text-primary-400 flex shrink-0 items-center gap-0.5 text-[11px]"
+                          title={`You've used this ${r.score} time${r.score === 1 ? '' : 's'}`}
+                        >
+                          <StarIcon size={11} aria-hidden="true" />
+                          {r.score}
+                          <span className="sr-only">
+                            frequently used, {r.score} picks
+                          </span>
+                        </span>
+                      )}
                       <span
                         className={cn(
                           'text-muted-foreground shrink-0 text-[11px] whitespace-nowrap',
@@ -678,7 +835,7 @@ export const CodeLookup = React.forwardRef<HTMLDivElement, CodeLookupProps>(
             )}
             {status.state === 'ready' && tookMs !== null && (
               <>
-                {results.length} results in {tookMs.toFixed(1)} ms (local) · ↑↓
+                {list.length} results in {tookMs.toFixed(1)} ms (local) · ↑↓
                 navigate · → drill into a row · Enter selects
               </>
             )}
diff --git a/src/components/CodeLookup/README.md b/src/components/CodeLookup/README.md
index e565a691..204a28d0 100644
--- a/src/components/CodeLookup/README.md
+++ b/src/components/CodeLookup/README.md
@@ -237,6 +237,141 @@ In Storybook, the 🌐 **Language** toolbar global switches the locale for the
 > `new Worker(new URL(...))` pattern needs bundler configuration in the tsup
 > build. Storybook (Vite) handles it natively; see `Healthcare/CodeLookup`.
 
+### Memory — "Frequently used" picklist
+
+**On by default** wherever the provider names a signed-in user: focusing the
+**empty** search box lists that user's most-picked codes for that context
+(count desc, most-recent tiebreak). One decision at the mount point, nothing
+per instance:
+
+```tsx
+<CodeLookupProvider
+  component={CodeLookup}
+  indexUrl="/codify"
+  memory={{ userId: currentUser.id, storage: 'local' }}
+>
+  <App /> {/* every CodeLookup below here remembers */}
+</CodeLookupProvider>
+```
+
+The bucket defaults to the box's own `domains` (`med`, `condition`, …), so two
+lookups over different domains never share a list. The `memory` prop only
+tunes that default — or turns one box off:
+
+```tsx
+<CodeLookup
+  indexUrl="/codify"
+  memory={{
+    context: 'med-orders',      // default: this box's `domains`
+    userId: currentUser.id,     // default: provider `memory.userId`. No id, no memory
+    serverUrl: '/api/code-memory', // count sync; provider default fallback
+    limit: 8,                   // picklist size (default 8)
+  }}
+  onSelect={…}
+/>
+```
+
+- **Scope = (userId, context)** — buckets never mix across users sharing a
+  browser or across contexts (`med-orders` vs `presenting-meds`). Rows carry
+  `viaMemory: true`.
+- **Two gates, both fail closed.** Nothing is remembered unless *both* open:
+  1. **A signed-in user.** Placeholder ids (`anonymous`, `guest`, `kiosk`,
+     `unknown`, empty) are rejected rather than pooled into one shared bucket,
+     so forgetting to wire auth disables the feature instead of showing the
+     last kiosk visitor's codes to the next one.
+  2. **A storage mode** (below) that permits it.
+- **Storage — a property of the *machine*, never guessed.** No browser signal
+  distinguishes a kiosk from a workstation, so the app declares it once on the
+  provider and the library defaults to the safe answer:
+
+  | `memory.storage` | cache | for |
+  | --- | --- | --- |
+  | `'session'` *(default)* | RAM, dies with the tab | public/shared kiosks |
+  | `'local'` | IndexedDB (`mieweb-codelookup-memory` / `usage`), keyed `userId\|context\|fullid` | a per-user machine secured by a browser login |
+  | `'none'` | nothing | opted out |
+
+  Writing to *this* disk therefore needs an affirmative `storage: 'local'` in
+  the app source — greppable at review time, and forgetting it costs a
+  round-trip rather than a disclosure. `'local'` without IndexedDB (SSR)
+  degrades to no-ops.
+- **The server is the source of truth**; the local store is its cache. With
+  `serverUrl`:
+  - revalidate per scope, at most once a minute:
+    `GET {serverUrl}?user={userId}&context={context}` →
+    `[{fullid, label, codetype, fullcode, domain, count}]`, taken as
+    authoritative — a server count may move a local one **down**;
+  - picks accumulate deltas flushed lazily:
+    `POST {serverUrl}` body
+    `{user, context, deltas: [{fullid, label, codetype, fullcode, domain, delta}]}`
+    (debounced — shorter in `'session'` mode, which has no durable cache to
+    retry from; `navigator.sendBeacon` on `pagehide`). Failed flushes keep
+    their deltas for the next attempt.
+  - `count` = the server's total **plus** unflushed local picks, so
+    `pendingDelta` is the only locally-authoritative field and a sync can never
+    drop a pick that hasn't landed yet.
+  - **The server must take identity from the session** (cookie/bearer), not
+    from the `user` parameter — otherwise any user reads any other's list by
+    editing a query string. Treat `user` as a value to *validate* against the
+    session and reject on mismatch. Requests are sent with
+    `credentials: 'include'`.
+- **Provider defaults** — `CodeLookupProvider` accepts
+  `memory={{ userId, serverUrl, context, storage }}` so apps decide identity,
+  sync and device trust once; naming a `userId` is all an instance needs.
+  `memory={false}` on the provider **disables memory everywhere below it**,
+  overriding any component's own config — that's the one-line kiosk switch.
+- **Disable / reset** — pass `memory={false}` (on the provider, or on one
+  instance) to disable; `clearMemory({ userId, context })` empties one bucket
+  and `clearAllMemory()` wipes every bucket whatever the current mode, for
+  logout, kiosk session reset, or a device downgraded from trusted to public.
+- **While typing** — remembered codes matching the query (same word-prefix
+  rule as the index) are pinned above the index hits and marked with a ☆ and
+  their pick count, so typing `f` keeps *Flonase* on top instead of dropping
+  it for the generic matches.
+
+Storybook's **Signed in as** / **Device** toolbar globals feed exactly these
+two gates through the ambient provider in `.storybook/preview.tsx`, which
+doubles as the reference for wiring them in an app: one decision at the mount
+point, not per component.
+
+#### Import / export (`memoryYaml.ts`)
+
+Buckets round-trip through YAML — back up a picklist, move it between
+machines, or ship a curated starter set for a context:
+
+```ts
+import { exportMemoryYaml, importMemoryYaml } from '…/CodeLookup';
+
+const yaml = await exportMemoryYaml({ userId: 'alice', context: 'med-orders' });
+await exportMemoryYaml();                       // every bucket in this browser
+await importMemoryYaml(yaml);                   // into the buckets it names
+await importMemoryYaml(yaml, { scope });        // …or all into one bucket
+```
+
+```yaml
+version: 1
+exported: 2026-07-31T19:00:00.000Z
+buckets:
+  - user: alice
+    context: med-orders
+    codes:
+      - fullid: FDBMEDNAME3722
+        label: Lasix
+        codetype: FDB MEDNAME
+        fullcode: '3722'
+        domain: med
+        count: 3
+        lastUsed: 2026-07-31T18:00:00.000Z
+```
+
+- Import **merges**: `count`/`lastUsed` keep the larger value and pending
+  server deltas are untouched, so re-importing the same file is a no-op and
+  local usage is never lost. `{ scope }` retargets every bucket into one.
+- Only `fullid` is required per code (`count` defaults to 1) — a hand-written
+  starter list is a valid import. Unusable rows are skipped and counted in the
+  result; a document without a `buckets` list, or a newer `version`, throws.
+- `js-yaml` is an **optional peer dependency**, imported lazily on first use,
+  so apps that never import/export don't pay for it.
+
 ## 6. Health surveillance — programs.json
 
 The **occupational** (OSHA/FMCSA/NFPA/FAA/OPM/USCG/MSHA/NIOSH/NRC/DOE/USCIS/
diff --git a/src/components/CodeLookup/context.tsx b/src/components/CodeLookup/context.tsx
index a133deb6..890a12ec 100644
--- a/src/components/CodeLookup/context.tsx
+++ b/src/components/CodeLookup/context.tsx
@@ -29,6 +29,7 @@
 
 import * as React from 'react';
 import type { CodeLookupProps } from './CodeLookup';
+import type { MemoryStorage } from './memoryBackend';
 
 /**
  * The CodeLookup component the provider distributes to consumers.
@@ -43,6 +44,31 @@ export type CodeLookupComponent = (
   props: CodeLookupProps
 ) => React.ReactElement | null;
 
+/**
+ * App-wide defaults for the CodeLookup memory picklist. Naming a signed-in
+ * `userId` here turns the picklist on for every lookup below the provider —
+ * instances need no wiring, and `memory={false}` (here or per-instance) turns
+ * it back off.
+ */
+export interface CodeLookupMemoryDefaults {
+  /** Signed-in user the counts belong to. No id, no memory. */
+  userId?: string;
+  /** Default count-sync endpoint (per-instance prop wins). */
+  serverUrl?: string;
+  /**
+   * Bucket the counts are scoped to. Defaults per instance to that lookup's
+   * `domains`, which keeps a med picker and a problem picker apart; set this
+   * to pool every lookup into one list instead.
+   */
+  context?: string;
+  /**
+   * Where picks are cached on this machine. `'local'` (IndexedDB) asserts a
+   * per-user device secured by a browser login; the default `'session'` keeps
+   * them in RAM for the tab, which is what a public kiosk wants.
+   */
+  storage?: MemoryStorage;
+}
+
 /** Resolved lookup wiring a component consumes (from prop or context). */
 export interface CodeLookupProviderConfig {
   /** The injected CodeLookup component (worker-capable, from the app bundle). */
@@ -51,6 +77,12 @@ export interface CodeLookupProviderConfig {
   indexUrl: string;
   /** Shard-set locale (default 'en'). */
   locale?: string;
+  /**
+   * Defaults for the memory picklist, or `false` to disable it everywhere
+   * below this provider (a public kiosk build). Naming a `userId` here is all
+   * an instance needs; `false` overrides a component's own `memory` config.
+   */
+  memory?: false | CodeLookupMemoryDefaults;
 }
 
 const CodeLookupContext = React.createContext<CodeLookupProviderConfig | null>(
@@ -64,6 +96,8 @@ export interface CodeLookupProviderProps {
   indexUrl?: string;
   /** Shard-set locale (default 'en'). */
   locale?: string;
+  /** Defaults for the memory picklist, or `false` to disable it everywhere. */
+  memory?: false | CodeLookupMemoryDefaults;
   children: React.ReactNode;
 }
 
@@ -71,11 +105,12 @@ export function CodeLookupProvider({
   component,
   indexUrl = '/codify',
   locale = 'en',
+  memory,
   children,
 }: CodeLookupProviderProps): React.ReactElement {
   const value = React.useMemo<CodeLookupProviderConfig>(
-    () => ({ component, indexUrl, locale }),
-    [component, indexUrl, locale]
+    () => ({ component, indexUrl, locale, memory }),
+    [component, indexUrl, locale, memory]
   );
   return (
     <CodeLookupContext.Provider value={value}>
diff --git a/src/components/CodeLookup/engine.ts b/src/components/CodeLookup/engine.ts
index ef1eff8e..6efcbc5d 100644
--- a/src/components/CodeLookup/engine.ts
+++ b/src/components/CodeLookup/engine.ts
@@ -66,6 +66,8 @@ export interface CodifyResult {
   viaFuzzy?: boolean;
   /** true when the match came from the code itself (query looked like a code) */
   viaCode?: boolean;
+  /** true when the row came from the user's frequently-used memory picklist */
+  viaMemory?: boolean;
 }
 
 // =============================================================================
diff --git a/src/components/CodeLookup/index.ts b/src/components/CodeLookup/index.ts
index 816475e6..a9798230 100644
--- a/src/components/CodeLookup/index.ts
+++ b/src/components/CodeLookup/index.ts
@@ -5,7 +5,24 @@ export {
   CodeLookup,
   type CodeLookupProps,
   type CodifyDomain,
+  type CodeLookupMemoryConfig,
 } from './CodeLookup';
+export {
+  clearMemory,
+  clearAllMemory,
+  setMemoryStorage,
+  getMemoryStorage,
+  type MemoryEntry,
+  type MemoryScope,
+  type MemoryStorage,
+} from './memoryStore';
+export {
+  exportMemoryYaml,
+  importMemoryYaml,
+  MEMORY_YAML_VERSION,
+  type ImportMemoryOptions,
+  type ImportMemoryResult,
+} from './memoryYaml';
 export {
   searchShards,
   parseShard,
diff --git a/src/components/CodeLookup/memoryBackend.test.ts b/src/components/CodeLookup/memoryBackend.test.ts
new file mode 100644
index 00000000..46da8e18
--- /dev/null
+++ b/src/components/CodeLookup/memoryBackend.test.ts
@@ -0,0 +1,43 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import {
+  setMemoryStorage,
+  memoryAvailable,
+  memSet,
+  memGetAll,
+} from './memoryBackend';
+import type { MemoryEntry } from './memoryStore';
+
+const entry: MemoryEntry = {
+  userId: 'alice',
+  context: 'ctx',
+  fullid: 'a',
+  label: 'a',
+  codetype: 'ICD10',
+  fullcode: 'A',
+  domain: 'condition',
+  count: 1,
+  lastUsed: 1000,
+  pendingDelta: 1,
+};
+
+describe('memoryBackend session SSR guard', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    setMemoryStorage('session');
+  });
+
+  it('session memory is available in a browser context', () => {
+    setMemoryStorage('session');
+    expect(memoryAvailable()).toBe(true);
+  });
+
+  it('session memory fails closed without a browser (SSR/Node)', async () => {
+    setMemoryStorage('session');
+    vi.stubGlobal('window', undefined);
+
+    expect(memoryAvailable()).toBe(false);
+    await memSet('k', entry); // must be a no-op
+    vi.unstubAllGlobals();
+    expect(await memGetAll()).toEqual([]);
+  });
+});
diff --git a/src/components/CodeLookup/memoryBackend.ts b/src/components/CodeLookup/memoryBackend.ts
new file mode 100644
index 00000000..ae4258b2
--- /dev/null
+++ b/src/components/CodeLookup/memoryBackend.ts
@@ -0,0 +1,227 @@
+/**
+ * Where CodeLookup memory is cached locally — the device-trust switch.
+ *
+ * The server is the source of truth; this is only the cache in front of it.
+ * Which cache you get is a property of the *machine*, declared once by the app
+ * (see `CodeLookupProvider`'s `memory.storage`) and never guessed, because no
+ * browser signal tells you a kiosk from a workstation:
+ *
+ *  - `'local'`   IndexedDB — a per-user machine secured by a browser login.
+ *  - `'session'` a Map that dies with the tab — public/shared kiosks. Default,
+ *                so forgetting to configure costs a round-trip, not a leak.
+ *  - `'none'`    reads are empty, writes are no-ops.
+ *
+ * Keys are opaque strings; `prefix` scans stand in for IndexedDB key ranges so
+ * both backends implement the same five operations.
+ */
+
+import type { MemoryEntry } from './memoryStore';
+
+export type MemoryStorage = 'local' | 'session' | 'none';
+
+let storage: MemoryStorage = 'session';
+
+/** Declare the device's trust level (app-wide — one machine, one answer). */
+export function setMemoryStorage(mode: MemoryStorage): void {
+  storage = mode;
+}
+
+export function getMemoryStorage(): MemoryStorage {
+  return storage;
+}
+
+// =============================================================================
+// IndexedDB backend ('local')
+// =============================================================================
+
+const DB_NAME = 'mieweb-codelookup-memory';
+const STORE = 'usage';
+const DB_VERSION = 1;
+
+function hasIndexedDB(): boolean {
+  try {
+    return typeof indexedDB !== 'undefined' && indexedDB != null;
+  } catch {
+    return false;
+  }
+}
+
+function prefixRange(prefix: string): IDBKeyRange {
+  return IDBKeyRange.bound(prefix, `${prefix}\uffff`);
+}
+
+function openDb(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      if (!req.result.objectStoreNames.contains(STORE))
+        req.result.createObjectStore(STORE);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+    // A version upgrade blocked by another tab would otherwise hang forever.
+    req.onblocked = () =>
+      reject(
+        new Error('IndexedDB open blocked (another tab holds an upgrade lock)')
+      );
+  });
+}
+
+function idbGet(key: string): Promise<MemoryEntry | undefined> {
+  return openDb().then(
+    (db) =>
+      new Promise<MemoryEntry | undefined>((resolve, reject) => {
+        const req = db
+          .transaction(STORE, 'readonly')
+          .objectStore(STORE)
+          .get(key);
+        req.onsuccess = () => {
+          resolve(req.result as MemoryEntry | undefined);
+          db.close();
+        };
+        req.onerror = () => {
+          reject(req.error);
+          db.close();
+        };
+      })
+  );
+}
+
+function idbSet(key: string, value: MemoryEntry): Promise<void> {
+  return openDb().then(
+    (db) =>
+      new Promise<void>((resolve, reject) => {
+        const tx = db.transaction(STORE, 'readwrite');
+        tx.objectStore(STORE).put(value, key);
+        tx.oncomplete = () => {
+          resolve();
+          db.close();
+        };
+        tx.onerror = () => {
+          reject(tx.error);
+          db.close();
+        };
+        tx.onabort = () => {
+          reject(tx.error);
+          db.close();
+        };
+      })
+  );
+}
+
+function idbGetAll(prefix?: string): Promise<MemoryEntry[]> {
+  return openDb().then(
+    (db) =>
+      new Promise<MemoryEntry[]>((resolve, reject) => {
+        const req = db
+          .transaction(STORE, 'readonly')
+          .objectStore(STORE)
+          .getAll(prefix == null ? undefined : prefixRange(prefix));
+        req.onsuccess = () => {
+          resolve((req.result ?? []) as MemoryEntry[]);
+          db.close();
+        };
+        req.onerror = () => {
+          reject(req.error);
+          db.close();
+        };
+      })
+  );
+}
+
+function idbDelete(prefix?: string): Promise<void> {
+  return openDb().then(
+    (db) =>
+      new Promise<void>((resolve, reject) => {
+        const tx = db.transaction(STORE, 'readwrite');
+        const store = tx.objectStore(STORE);
+        if (prefix == null) store.clear();
+        else store.delete(prefixRange(prefix));
+        tx.oncomplete = () => {
+          resolve();
+          db.close();
+        };
+        tx.onerror = () => {
+          reject(tx.error);
+          db.close();
+        };
+        tx.onabort = () => {
+          reject(tx.error);
+          db.close();
+        };
+      })
+  );
+}
+
+// =============================================================================
+// Session backend ('session') — never touches the disk
+// =============================================================================
+
+const sessionEntries = new Map<string, MemoryEntry>();
+
+// =============================================================================
+// Dispatch
+// =============================================================================
+
+function idbActive(): boolean {
+  return storage === 'local' && hasIndexedDB();
+}
+
+/**
+ * True only in a real browser tab. Session memory must never run server-side:
+ * in SSR/Node the module-level Map outlives the request and would bleed one
+ * user's codes into another's render (the 'local' path is already safe because
+ * IndexedDB doesn't exist there).
+ */
+function isBrowser(): boolean {
+  return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+
+/**
+ * False when nothing can be stored: 'none', 'local' without IndexedDB, or
+ * 'session' outside a browser (fail closed — see `isBrowser`).
+ */
+export function memoryAvailable(): boolean {
+  return (storage === 'session' && isBrowser()) || idbActive();
+}
+
+export async function memGet(key: string): Promise<MemoryEntry | undefined> {
+  if (!memoryAvailable()) return undefined;
+  return idbActive() ? idbGet(key) : sessionEntries.get(key);
+}
+
+export async function memSet(key: string, value: MemoryEntry): Promise<void> {
+  if (!memoryAvailable()) return;
+  if (idbActive()) await idbSet(key, value);
+  else sessionEntries.set(key, value);
+}
+
+export async function memGetAll(prefix?: string): Promise<MemoryEntry[]> {
+  if (!memoryAvailable()) return [];
+  if (idbActive()) return idbGetAll(prefix);
+  const all = [...sessionEntries.entries()];
+  return (prefix == null ? all : all.filter(([k]) => k.startsWith(prefix))).map(
+    ([, v]) => v
+  );
+}
+
+export async function memDelete(prefix?: string): Promise<void> {
+  if (!memoryAvailable()) return;
+  if (idbActive()) {
+    await idbDelete(prefix);
+    return;
+  }
+  if (prefix == null) sessionEntries.clear();
+  else
+    for (const key of [...sessionEntries.keys()])
+      if (key.startsWith(prefix)) sessionEntries.delete(key);
+}
+
+/**
+ * Wipe both caches whatever the current mode is — a device downgraded from
+ * trusted to public still has to erase what it wrote while it was trusted.
+ */
+export async function memPurgeAll(): Promise<void> {
+  sessionEntries.clear();
+  if (hasIndexedDB()) await idbDelete();
+}
diff --git a/src/components/CodeLookup/memoryStore.test.ts b/src/components/CodeLookup/memoryStore.test.ts
new file mode 100644
index 00000000..3ea37101
--- /dev/null
+++ b/src/components/CodeLookup/memoryStore.test.ts
@@ -0,0 +1,345 @@
+import 'fake-indexeddb/auto';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  recordUse,
+  getTopCodes,
+  syncFromServer,
+  scheduleFlush,
+  clearMemory,
+  clearAllMemory,
+  matchMemory,
+  setMemoryStorage,
+  type MemoryEntry,
+  type MemoryScope,
+} from './memoryStore';
+
+// `fake-indexeddb/auto` polyfills a real IndexedDB for this file only (vitest
+// isolates modules per test file), so the store exercises its true IDB paths.
+// The default storage mode is 'session', so tests opt into 'local' explicitly.
+beforeEach(() => {
+  setMemoryStorage('local');
+});
+
+const code = (fullid: string, label = fullid) => ({
+  fullid,
+  label,
+  codetype: 'ICD10',
+  fullcode: fullid.toUpperCase(),
+  domain: 'condition',
+});
+
+// Unique contexts per test keep buckets (and the module's session-seed /
+// beacon registries) from bleeding between tests without a reset hook.
+let n = 0;
+const freshScope = (userId = 'alice'): MemoryScope => ({
+  userId,
+  context: `ctx-${++n}`,
+});
+
+describe('memoryStore', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('records picks and returns them count-desc with lastUsed tiebreak', async () => {
+    const scope = freshScope();
+    // fake only Date — fake-indexeddb needs real timers to dispatch events
+    vi.useFakeTimers({ toFake: ['Date'] });
+    vi.setSystemTime(1000);
+    await recordUse(scope, code('a'));
+    await recordUse(scope, code('a'));
+    await recordUse(scope, code('b'));
+    vi.setSystemTime(2000);
+    await recordUse(scope, code('c')); // ties b on count, later lastUsed
+
+    const top = await getTopCodes(scope);
+    expect(top.map((e) => e.fullid)).toEqual(['a', 'c', 'b']);
+    expect(top[0].count).toBe(2);
+    expect(top[0].pendingDelta).toBe(2);
+  });
+
+  it('honors the limit', async () => {
+    const scope = freshScope();
+    for (let i = 0; i < 5; i++) await recordUse(scope, code(`x${i}`));
+    expect(await getTopCodes(scope, 2)).toHaveLength(2);
+  });
+
+  it('isolates users in the same browser/db', async () => {
+    const ctx = `ctx-${++n}`;
+    const alice: MemoryScope = { userId: 'alice', context: ctx };
+    const bob: MemoryScope = { userId: 'bob', context: ctx };
+    await recordUse(alice, code('lasix'));
+    await recordUse(bob, code('metformin'));
+
+    expect((await getTopCodes(alice)).map((e) => e.fullid)).toEqual(['lasix']);
+    expect((await getTopCodes(bob)).map((e) => e.fullid)).toEqual([
+      'metformin',
+    ]);
+  });
+
+  it('isolates contexts for the same user', async () => {
+    const orders: MemoryScope = { userId: 'alice', context: `med-${++n}` };
+    const presenting: MemoryScope = { userId: 'alice', context: `pres-${n}` };
+    await recordUse(orders, code('cbc'));
+    await recordUse(presenting, code('chf'));
+
+    expect((await getTopCodes(orders)).map((e) => e.fullid)).toEqual(['cbc']);
+    expect((await getTopCodes(presenting)).map((e) => e.fullid)).toEqual([
+      'chf',
+    ]);
+  });
+
+  it('takes the server as authoritative, keeping unflushed picks on top', async () => {
+    const scope = freshScope();
+    await recordUse(scope, code('a')); // local count 1, unflushed
+    await recordUse(scope, code('b'));
+    await recordUse(scope, code('b')); // local count 2, unflushed
+
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(
+        JSON.stringify([
+          { ...code('a'), count: 5 },
+          { ...code('b'), count: 1 },
+          { ...code('srv'), count: 3 }, // new from server
+        ])
+      )
+    );
+    await syncFromServer(scope, 'https://api.example/memory');
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      `https://api.example/memory?user=alice&context=${scope.context}`,
+      { credentials: 'include' }
+    );
+    const top = await getTopCodes(scope);
+    const byId = Object.fromEntries(top.map((e) => [e.fullid, e]));
+    expect(byId.a.count).toBe(6); // 5 + 1 unflushed
+    expect(byId.b.count).toBe(3); // 1 + 2 unflushed
+    expect(byId.srv.count).toBe(3);
+    expect(byId.srv.pendingDelta).toBe(0);
+    expect(byId.a.pendingDelta).toBe(1);
+  });
+
+  it('lets the server lower a settled count', async () => {
+    const scope = freshScope();
+    await recordUse(scope, code('a'));
+    await recordUse(scope, code('a'));
+    await recordUse(scope, code('a'));
+
+    vi.useFakeTimers();
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('{}'));
+    scheduleFlush(scope, 'https://api.example/memory', 10);
+    await vi.advanceTimersByTimeAsync(20);
+    vi.useRealTimers();
+    await Promise.resolve();
+    expect((await getTopCodes(scope))[0].pendingDelta).toBe(0);
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify([{ ...code('a'), count: 1 }]))
+    );
+    await syncFromServer(scope, 'https://api.example/memory');
+    expect((await getTopCodes(scope))[0].count).toBe(1);
+  });
+
+  it('revalidates at most once per TTL', async () => {
+    const scope = freshScope();
+    const fetchMock = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('[]'));
+    await syncFromServer(scope, 'https://api.example/memory');
+    await syncFromServer(scope, 'https://api.example/memory');
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('flushes pending deltas and resets them on success', async () => {
+    const scope = freshScope();
+    await recordUse(scope, code('a'));
+    await recordUse(scope, code('a'));
+
+    vi.useFakeTimers();
+    const fetchMock = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('{}', { status: 200 }));
+    scheduleFlush(scope, 'https://api.example/memory', 10);
+    await vi.advanceTimersByTimeAsync(20);
+    vi.useRealTimers();
+    await Promise.resolve(); // let the flush settle
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('https://api.example/memory');
+    const body = JSON.parse(String(init?.body));
+    expect(body.user).toBe('alice');
+    expect(body.context).toBe(scope.context);
+    expect(body.deltas).toEqual([
+      expect.objectContaining({ fullid: 'a', delta: 2 }),
+    ]);
+
+    const [entry] = await getTopCodes(scope);
+    expect(entry.pendingDelta).toBe(0);
+    expect(entry.count).toBe(2);
+  });
+
+  it('keeps deltas pending when the flush fails', async () => {
+    const scope = freshScope();
+    await recordUse(scope, code('a'));
+
+    vi.useFakeTimers();
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response('nope', { status: 500 })
+    );
+    scheduleFlush(scope, 'https://api.example/memory', 10);
+    await vi.advanceTimersByTimeAsync(20);
+    vi.useRealTimers();
+    await Promise.resolve();
+
+    const [entry] = await getTopCodes(scope);
+    expect(entry.pendingDelta).toBe(1);
+  });
+
+  it('debounces repeated scheduleFlush calls into one POST', async () => {
+    const scope = freshScope();
+    await recordUse(scope, code('a'));
+
+    vi.useFakeTimers();
+    const fetchMock = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('{}'));
+    scheduleFlush(scope, 'https://api.example/memory', 50);
+    scheduleFlush(scope, 'https://api.example/memory', 50);
+    scheduleFlush(scope, 'https://api.example/memory', 50);
+    await vi.advanceTimersByTimeAsync(200);
+    vi.useRealTimers();
+    await Promise.resolve();
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('clearMemory resets only the target bucket', async () => {
+    const ctx = `ctx-${++n}`;
+    const alice: MemoryScope = { userId: 'alice', context: ctx };
+    const bob: MemoryScope = { userId: 'bob', context: ctx };
+    await recordUse(alice, code('a'));
+    await recordUse(bob, code('b'));
+
+    await clearMemory(alice);
+    expect(await getTopCodes(alice)).toEqual([]);
+    expect(await getTopCodes(bob)).toHaveLength(1);
+  });
+});
+
+describe('matchMemory', () => {
+  const entry = (label: string): MemoryEntry => ({
+    userId: 'alice',
+    context: 'c',
+    fullid: label,
+    label,
+    codetype: 'FDB',
+    fullcode: '1',
+    domain: 'med',
+    count: 1,
+    lastUsed: 0,
+    pendingDelta: 0,
+  });
+  const entries = [
+    entry('Flonase'),
+    entry('furosemide'),
+    entry('Childrens Tylenol'),
+  ];
+
+  it('matches every token as a word prefix', () => {
+    expect(matchMemory(entries, 'f').map((e) => e.label)).toEqual([
+      'Flonase',
+      'furosemide',
+    ]);
+    expect(matchMemory(entries, 'tyl').map((e) => e.label)).toEqual([
+      'Childrens Tylenol',
+    ]);
+    expect(matchMemory(entries, 'chi tyl').map((e) => e.label)).toEqual([
+      'Childrens Tylenol',
+    ]);
+  });
+
+  it('ignores case, accents and punctuation, and empty queries', () => {
+    expect(matchMemory(entries, 'FLO')).toHaveLength(1);
+    expect(matchMemory(entries, '   ')).toEqual([]);
+    expect(matchMemory(entries, 'zzz')).toEqual([]);
+  });
+});
+
+describe('memoryStore without IndexedDB', () => {
+  let saved: IDBFactory;
+  beforeEach(() => {
+    setMemoryStorage('local');
+    saved = globalThis.indexedDB;
+    // @ts-expect-error — simulate an environment without IndexedDB
+    delete globalThis.indexedDB;
+  });
+  afterEach(() => {
+    globalThis.indexedDB = saved;
+  });
+
+  it('all APIs resolve as no-ops', async () => {
+    const scope: MemoryScope = { userId: 'u', context: 'no-idb' };
+    await expect(recordUse(scope, code('a'))).resolves.toBeUndefined();
+    await expect(getTopCodes(scope)).resolves.toEqual([]);
+    await expect(
+      syncFromServer(scope, 'https://api.example/memory')
+    ).resolves.toBeUndefined();
+    expect(() =>
+      scheduleFlush(scope, 'https://api.example/memory')
+    ).not.toThrow();
+    await expect(clearMemory(scope)).resolves.toBeUndefined();
+  });
+});
+
+describe('identity gate', () => {
+  it('refuses to pool unidentified users into a shared bucket', async () => {
+    for (const userId of ['anonymous', '', 'Guest', ' kiosk ']) {
+      const scope: MemoryScope = { userId, context: 'intake' };
+      await recordUse(scope, code('depression'));
+      expect(await getTopCodes(scope)).toEqual([]);
+    }
+  });
+
+  it('remembers once a real user id arrives', async () => {
+    const scope = freshScope('dr-alice');
+    await recordUse(scope, code('a'));
+    expect(await getTopCodes(scope)).toHaveLength(1);
+  });
+});
+
+describe('storage modes', () => {
+  it('session storage never reaches the disk', async () => {
+    const scope = freshScope();
+    setMemoryStorage('session');
+    await recordUse(scope, code('a'));
+    expect(await getTopCodes(scope)).toHaveLength(1);
+
+    setMemoryStorage('local');
+    expect(await getTopCodes(scope)).toEqual([]);
+  });
+
+  it("'none' stores nothing at all", async () => {
+    const scope = freshScope();
+    setMemoryStorage('none');
+    await recordUse(scope, code('a'));
+    expect(await getTopCodes(scope)).toEqual([]);
+  });
+});
+
+describe('clearAllMemory', () => {
+  it('wipes every bucket, whatever the current mode', async () => {
+    const alice = freshScope('alice');
+    const bob = freshScope('bob');
+    await recordUse(alice, code('a'));
+    setMemoryStorage('session');
+    await recordUse(bob, code('b'));
+
+    await clearAllMemory();
+
+    expect(await getTopCodes(bob)).toEqual([]);
+    setMemoryStorage('local');
+    expect(await getTopCodes(alice)).toEqual([]);
+  });
+});
diff --git a/src/components/CodeLookup/memoryStore.ts b/src/components/CodeLookup/memoryStore.ts
new file mode 100644
index 00000000..2ff43380
--- /dev/null
+++ b/src/components/CodeLookup/memoryStore.ts
@@ -0,0 +1,441 @@
+/**
+ * CodeLookup "memory" — per-(user, context) usage counts for picked codes,
+ * powering the "Frequently used" empty-query picklist.
+ *
+ * `serverUrl` is the source of truth; the local store (see `memoryBackend`) is
+ * a cache whose durability is the device's call — IndexedDB on a trusted
+ * machine, RAM on a kiosk. Two gates must both open before anything is kept:
+ * a real `userId` (never a shared 'anonymous' bucket) and a storage mode.
+ *
+ * Sync:
+ *  - `syncFromServer` GETs `{serverUrl}?user=&context=` (at most once per
+ *    minute per scope) and takes the server's counts as authoritative.
+ *  - `scheduleFlush` debounces a POST of accumulated count deltas
+ *    (`{user, context, deltas:[…]}`); a `pagehide` listener flushes any
+ *    remaining deltas via `navigator.sendBeacon`.
+ *
+ * `count` is therefore "the server's total, plus our unflushed picks":
+ * `pendingDelta` is the only locally-authoritative field, so a server value
+ * can move a count *down* without ever losing a pick that hasn't landed yet.
+ *
+ * The server must take identity from the session, not from the `user`
+ * parameter — see the protocol notes in README.md.
+ */
+
+import type { CodifyResult } from './engine';
+import { normalize } from './engine';
+import {
+  memGet,
+  memSet,
+  memGetAll,
+  memDelete,
+  memPurgeAll,
+  memoryAvailable,
+  getMemoryStorage,
+} from './memoryBackend';
+
+export {
+  setMemoryStorage,
+  getMemoryStorage,
+  type MemoryStorage,
+} from './memoryBackend';
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/** Identifies one memory bucket: counts never leak across users or contexts. */
+export interface MemoryScope {
+  /** Signed-in user id. Placeholders like 'anonymous' disable memory. */
+  userId: string;
+  /** Usage context, e.g. 'med-orders' vs 'presenting-meds'. */
+  context: string;
+}
+
+/** One remembered code with its usage stats (full display fields stored). */
+export interface MemoryEntry {
+  userId: string;
+  context: string;
+  fullid: string;
+  label: string;
+  codetype: string;
+  fullcode: string;
+  domain: string;
+  /** The server's total plus `pendingDelta` (see the module doc). */
+  count: number;
+  /** Epoch ms of the most recent pick (count-tie ordering). */
+  lastUsed: number;
+  /** Picks not yet flushed to the server — the only local truth. */
+  pendingDelta: number;
+}
+
+/** Server seed row (GET response item) / flush delta shape. */
+interface ServerCount {
+  fullid: string;
+  label: string;
+  codetype: string;
+  fullcode: string;
+  domain: string;
+  count: number;
+}
+
+// =============================================================================
+// Keys and gates
+// =============================================================================
+
+function entryKey(scope: MemoryScope, fullid: string): string {
+  return `${scope.userId}|${scope.context}|${fullid}`;
+}
+
+/** Prefix covering every entry in a scope (keys are `user|context|fullid`). */
+function scopePrefix(scope: MemoryScope): string {
+  return `${scope.userId}|${scope.context}|`;
+}
+
+/**
+ * Placeholder ids that mean "nobody is signed in". They would otherwise be
+ * valid bucket keys, pooling every kiosk visitor into one shared picklist.
+ */
+const UNIDENTIFIED = new Set(['', 'anonymous', 'guest', 'kiosk', 'unknown']);
+
+function isIdentified(scope: MemoryScope): boolean {
+  return (
+    !!scope.userId &&
+    !!scope.context &&
+    !UNIDENTIFIED.has(scope.userId.trim().toLowerCase())
+  );
+}
+
+/** Both gates: somewhere to store it, and someone to store it for. */
+function memoryOn(scope: MemoryScope): boolean {
+  return memoryAvailable() && isIdentified(scope);
+}
+
+function getScope(scope: MemoryScope): Promise<MemoryEntry[]> {
+  return memGetAll(scopePrefix(scope));
+}
+
+// =============================================================================
+// Public API
+// =============================================================================
+
+/**
+ * Record a pick: increment `count` and `pendingDelta`, refresh `lastUsed`,
+ * (re)capture the display fields. Best-effort — resolves even without IDB.
+ */
+export async function recordUse(
+  scope: MemoryScope,
+  result: Pick<
+    CodifyResult,
+    'fullid' | 'label' | 'codetype' | 'fullcode' | 'domain'
+  >
+): Promise<void> {
+  if (!memoryOn(scope)) return;
+  try {
+    const key = entryKey(scope, result.fullid);
+    const prev = await memGet(key);
+    const entry: MemoryEntry = {
+      userId: scope.userId,
+      context: scope.context,
+      fullid: result.fullid,
+      label: result.label,
+      codetype: result.codetype,
+      fullcode: result.fullcode,
+      domain: result.domain,
+      count: (prev?.count ?? 0) + 1,
+      lastUsed: Date.now(),
+      pendingDelta: (prev?.pendingDelta ?? 0) + 1,
+    };
+    await memSet(key, entry);
+  } catch {
+    /* best-effort */
+  }
+}
+
+/**
+ * The scope's most-used codes: `count` desc, `lastUsed` desc tiebreak,
+ * capped at `limit`. Resolves `[]` when either gate is closed.
+ */
+export async function getTopCodes(
+  scope: MemoryScope,
+  limit = 8
+): Promise<MemoryEntry[]> {
+  if (!memoryOn(scope)) return [];
+  try {
+    const entries = await getScope(scope);
+    entries.sort((a, b) => b.count - a.count || b.lastUsed - a.lastUsed);
+    return entries.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+
+/** Last server sync per `user|context|serverUrl`, for TTL revalidation. */
+const lastSynced = new Map<string, number>();
+const REVALIDATE_MS = 60_000;
+
+/**
+ * Every stored entry, for one bucket or (no scope) all of them. Resolves `[]`
+ * when nothing is stored locally.
+ */
+export async function getAllEntries(
+  scope?: MemoryScope
+): Promise<MemoryEntry[]> {
+  if (scope ? !memoryOn(scope) : !memoryAvailable()) return [];
+  try {
+    return scope ? await getScope(scope) : await memGetAll();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Merge entries into the store, preserving local `pendingDelta`. `override`
+ * retargets every entry into one bucket (importing a curated set for the
+ * current user). `authoritative` marks the entries as the server's truth, so
+ * counts may move down; otherwise the larger count wins (YAML import, which
+ * must be idempotent). Returns the number merged; best-effort.
+ */
+export async function mergeEntries(
+  entries: readonly MemoryEntry[],
+  override?: MemoryScope,
+  { authoritative = false }: { authoritative?: boolean } = {}
+): Promise<number> {
+  if (!memoryAvailable()) return 0;
+  let merged = 0;
+  for (const e of entries) {
+    try {
+      const scope = override ?? { userId: e.userId, context: e.context };
+      if (!isIdentified(scope)) continue;
+      const key = entryKey(scope, e.fullid);
+      const prev = await memGet(key);
+      const pendingDelta = prev?.pendingDelta ?? 0;
+      await memSet(key, {
+        ...e,
+        userId: scope.userId,
+        context: scope.context,
+        label: e.label || (prev?.label ?? ''),
+        // A flush in flight double-counts until the next sync corrects it.
+        count: authoritative
+          ? e.count + pendingDelta
+          : Math.max(prev?.count ?? 0, e.count),
+        lastUsed: Math.max(prev?.lastUsed ?? 0, e.lastUsed),
+        pendingDelta,
+      });
+      merged++;
+    } catch {
+      /* skip the bad row, keep going */
+    }
+  }
+  return merged;
+}
+
+/**
+ * Refresh the scope from the server (at most once per `REVALIDATE_MS`):
+ * `GET {serverUrl}?user=…&context=…` → `ServerCount[]`, taken as authoritative.
+ * Best-effort — a failed sync leaves the cache in place.
+ */
+export async function syncFromServer(
+  scope: MemoryScope,
+  serverUrl: string
+): Promise<void> {
+  if (!memoryOn(scope)) return;
+  const key = `${scope.userId}|${scope.context}|${serverUrl}`;
+  const last = lastSynced.get(key);
+  if (last != null && Date.now() - last < REVALIDATE_MS) return;
+  lastSynced.set(key, Date.now());
+  try {
+    const url = `${serverUrl}?user=${encodeURIComponent(scope.userId)}&context=${encodeURIComponent(scope.context)}`;
+    const res = await fetch(url, { credentials: 'include' });
+    if (!res.ok) throw new Error(`memory sync failed: ${res.status}`);
+    const rows = (await res.json()) as ServerCount[];
+    if (!Array.isArray(rows)) return;
+    await mergeEntries(
+      rows
+        .filter((row) => row && typeof row.fullid === 'string')
+        .map((row) => ({
+          userId: scope.userId,
+          context: scope.context,
+          fullid: row.fullid,
+          label: row.label ?? '',
+          codetype: row.codetype ?? '',
+          fullcode: row.fullcode ?? '',
+          domain: row.domain ?? '',
+          count: typeof row.count === 'number' ? row.count : 0,
+          lastUsed: 0,
+          pendingDelta: 0,
+        })),
+      scope,
+      { authoritative: true }
+    );
+  } catch {
+    // Retry on the next mount past the TTL; keep serving the cache.
+    lastSynced.delete(key);
+  }
+}
+
+/** Collect the scope's pending deltas as a flush payload (or null if none). */
+async function pendingPayload(scope: MemoryScope): Promise<{
+  body: string;
+  flushed: Map<string, number>;
+} | null> {
+  const entries = await getScope(scope);
+  const deltas: (ServerCount & { delta: number })[] = [];
+  const flushed = new Map<string, number>();
+  for (const e of entries) {
+    if (e.pendingDelta > 0) {
+      deltas.push({
+        fullid: e.fullid,
+        label: e.label,
+        codetype: e.codetype,
+        fullcode: e.fullcode,
+        domain: e.domain,
+        count: e.count,
+        delta: e.pendingDelta,
+      });
+      flushed.set(e.fullid, e.pendingDelta);
+    }
+  }
+  if (deltas.length === 0) return null;
+  const body = JSON.stringify({
+    user: scope.userId,
+    context: scope.context,
+    deltas: deltas.map(({ count: _count, ...d }) => d),
+  });
+  return { body, flushed };
+}
+
+/** After a successful flush, subtract the flushed amounts (new picks may
+ * have landed while the POST was in flight — never blindly zero). */
+async function settleFlushed(
+  scope: MemoryScope,
+  flushed: Map<string, number>
+): Promise<void> {
+  for (const [fullid, delta] of flushed) {
+    const key = entryKey(scope, fullid);
+    const entry = await memGet(key);
+    if (!entry) continue;
+    await memSet(key, {
+      ...entry,
+      pendingDelta: Math.max(0, entry.pendingDelta - delta),
+    });
+  }
+}
+
+async function flushNow(scope: MemoryScope, serverUrl: string): Promise<void> {
+  try {
+    const payload = await pendingPayload(scope);
+    if (!payload) return;
+    const res = await fetch(serverUrl, {
+      method: 'POST',
+      credentials: 'include',
+      headers: { 'Content-Type': 'application/json' },
+      body: payload.body,
+    });
+    if (!res.ok) return; // deltas stay pending; retried on the next flush
+    await settleFlushed(scope, payload.flushed);
+  } catch {
+    /* deltas stay pending */
+  }
+}
+
+/** Debounce timers + registered scopes for the pagehide beacon. */
+const flushTimers = new Map<string, ReturnType<typeof setTimeout>>();
+const beaconScopes = new Map<
+  string,
+  { scope: MemoryScope; serverUrl: string }
+>();
+let pagehideRegistered = false;
+
+function registerPagehide(): void {
+  if (pagehideRegistered || typeof window === 'undefined') return;
+  pagehideRegistered = true;
+  window.addEventListener('pagehide', () => {
+    for (const { scope, serverUrl } of beaconScopes.values()) {
+      // sendBeacon needs a synchronous body; kick off the async read and
+      // beacon inside — pagehide usually gives IDB microtasks time to run,
+      // and failures just leave deltas pending for the next session.
+      void pendingPayload(scope)
+        .then((payload) => {
+          if (payload && typeof navigator.sendBeacon === 'function') {
+            const ok = navigator.sendBeacon(
+              serverUrl,
+              new Blob([payload.body], { type: 'application/json' })
+            );
+            if (ok) return settleFlushed(scope, payload.flushed);
+          }
+          return undefined;
+        })
+        .catch(() => {});
+    }
+  });
+}
+
+/**
+ * Debounce a POST of the scope's pending deltas to `serverUrl`. Also arms a
+ * one-time `pagehide` beacon so deltas survive tab closes. Session storage
+ * flushes fast by default — there is no durable cache to retry from.
+ */
+export function scheduleFlush(
+  scope: MemoryScope,
+  serverUrl: string,
+  debounceMs = getMemoryStorage() === 'session' ? 500 : 5000
+): void {
+  if (!memoryOn(scope)) return;
+  const key = `${scope.userId}|${scope.context}|${serverUrl}`;
+  beaconScopes.set(key, { scope, serverUrl });
+  registerPagehide();
+  const existing = flushTimers.get(key);
+  if (existing) clearTimeout(existing);
+  flushTimers.set(
+    key,
+    setTimeout(() => {
+      flushTimers.delete(key);
+      void flushNow(scope, serverUrl);
+    }, debounceMs)
+  );
+}
+
+/**
+ * Remembered entries whose label matches `query` under the same word-prefix
+ * rule as the index search ("met for" → *metformin*), preserving the caller's
+ * order (`getTopCodes` — count desc). Empty query → no matches.
+ */
+export function matchMemory(
+  entries: MemoryEntry[],
+  query: string
+): MemoryEntry[] {
+  const tokens = normalize(query).split(' ').filter(Boolean);
+  if (tokens.length === 0) return [];
+  return entries.filter((e) => {
+    const words = normalize(e.label).split(' ').filter(Boolean);
+    return tokens.every((t) => words.some((w) => w.startsWith(t)));
+  });
+}
+
+/** Reset one (user, context) bucket entirely. Best-effort. */
+export async function clearMemory(scope: MemoryScope): Promise<void> {
+  const prefix = scopePrefix(scope);
+  // Drop the TTL too, so the next mount re-reads the server instead of
+  // serving the now-empty bucket until it expires.
+  for (const key of lastSynced.keys())
+    if (key.startsWith(prefix)) lastSynced.delete(key);
+  try {
+    await memDelete(prefix);
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Wipe every bucket in this browser — for logout, kiosk session reset, or a
+ * device downgraded from trusted to public.
+ */
+export async function clearAllMemory(): Promise<void> {
+  lastSynced.clear();
+  try {
+    await memPurgeAll();
+  } catch {
+    /* ignore */
+  }
+}
diff --git a/src/components/CodeLookup/memoryYaml.test.ts b/src/components/CodeLookup/memoryYaml.test.ts
new file mode 100644
index 00000000..a0d0817b
--- /dev/null
+++ b/src/components/CodeLookup/memoryYaml.test.ts
@@ -0,0 +1,163 @@
+import 'fake-indexeddb/auto';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  recordUse,
+  getTopCodes,
+  clearMemory,
+  setMemoryStorage,
+} from './memoryStore';
+import { exportMemoryYaml, importMemoryYaml } from './memoryYaml';
+
+beforeEach(() => {
+  setMemoryStorage('local');
+});
+
+const code = (fullid: string, label = fullid) => ({
+  fullid,
+  label,
+  codetype: 'FDB MEDNAME',
+  fullcode: fullid.replace(/\D/g, '') || '1',
+  domain: 'med',
+});
+
+let n = 0;
+const freshScope = (userId = 'alice') => ({
+  userId,
+  context: `yaml-ctx-${++n}`,
+});
+
+describe('memory YAML export/import', () => {
+  it('round-trips a bucket through YAML', async () => {
+    const scope = freshScope();
+    await recordUse(scope, code('med1', 'Lasix'));
+    await recordUse(scope, code('med1', 'Lasix'));
+    await recordUse(scope, code('med2', 'Tylenol'));
+
+    const yaml = await exportMemoryYaml(scope);
+    expect(yaml).toContain('version: 1');
+    expect(yaml).toContain(`context: ${scope.context}`);
+    expect(yaml).toContain('label: Lasix');
+
+    await clearMemory(scope);
+    expect(await getTopCodes(scope)).toEqual([]);
+
+    const result = await importMemoryYaml(yaml);
+    expect(result).toMatchObject({ imported: 2, buckets: 1, skipped: 0 });
+
+    const top = await getTopCodes(scope);
+    expect(top.map((e) => [e.label, e.count])).toEqual([
+      ['Lasix', 2],
+      ['Tylenol', 1],
+    ]);
+    expect(top[0].lastUsed).toBeGreaterThan(0);
+  });
+
+  it('exports every bucket when no scope is given', async () => {
+    const alice = freshScope('alice');
+    const bob = { userId: 'bob', context: alice.context };
+    await recordUse(alice, code('a', 'Aspirin'));
+    await recordUse(bob, code('b', 'Bactrim'));
+
+    const yaml = await exportMemoryYaml();
+    expect(yaml).toContain('user: alice');
+    expect(yaml).toContain('user: bob');
+  });
+
+  it('breaks count ties by most recent, like the picklist', async () => {
+    const scope = freshScope();
+    vi.useFakeTimers({ toFake: ['Date'] });
+    try {
+      vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
+      await recordUse(scope, code('a', 'Amoxicillin'));
+      vi.setSystemTime(new Date('2026-01-02T00:00:00Z'));
+      await recordUse(scope, code('z', 'Zafirlukast'));
+    } finally {
+      vi.useRealTimers();
+    }
+
+    const yaml = await exportMemoryYaml(scope);
+    expect(yaml.indexOf('label: Zafirlukast')).toBeLessThan(
+      yaml.indexOf('label: Amoxicillin')
+    );
+  });
+
+  it('keeps the larger count when merging into existing usage', async () => {
+    const scope = freshScope();
+    await recordUse(scope, code('m', 'Metformin'));
+    await recordUse(scope, code('m', 'Metformin'));
+    await recordUse(scope, code('m', 'Metformin'));
+    const yaml = await exportMemoryYaml(scope); // count 3
+
+    await clearMemory(scope);
+    await recordUse(scope, code('m', 'Metformin')); // local count 1
+    await importMemoryYaml(yaml);
+    expect((await getTopCodes(scope))[0].count).toBe(3);
+
+    // re-importing the same document is idempotent
+    await importMemoryYaml(yaml);
+    expect((await getTopCodes(scope))[0].count).toBe(3);
+  });
+
+  it('retargets buckets into one scope with the scope option', async () => {
+    const source = freshScope('curator');
+    await recordUse(source, code('s1', 'Starter A'));
+    await recordUse(source, code('s2', 'Starter B'));
+    const yaml = await exportMemoryYaml(source);
+
+    const target = freshScope('bob');
+    const result = await importMemoryYaml(yaml, { scope: target });
+    expect(result.imported).toBe(2);
+    expect((await getTopCodes(target)).map((e) => e.label).sort()).toEqual([
+      'Starter A',
+      'Starter B',
+    ]);
+  });
+
+  it('imports a hand-written starter set', async () => {
+    const target = freshScope();
+    const result = await importMemoryYaml(
+      `version: 1
+buckets:
+  - user: ${target.userId}
+    context: ${target.context}
+    codes:
+      - fullid: FDBMEDNAME6808
+        label: Tylenol
+        codetype: FDB MEDNAME
+        fullcode: '6808'
+        domain: med
+        count: 5
+`
+    );
+    expect(result.imported).toBe(1);
+    const [entry] = await getTopCodes(target);
+    expect(entry).toMatchObject({
+      label: 'Tylenol',
+      count: 5,
+      fullcode: '6808',
+    });
+  });
+
+  it('skips unusable rows and rejects foreign documents', async () => {
+    const target = freshScope();
+    const result = await importMemoryYaml(
+      `version: 1
+buckets:
+  - user: ${target.userId}
+    context: ${target.context}
+    codes:
+      - label: no fullid here
+      - fullid: ok1
+        label: Kept
+`
+    );
+    expect(result).toMatchObject({ imported: 1, skipped: 1 });
+
+    await expect(importMemoryYaml('just: a string')).rejects.toThrow(
+      /expected a `buckets` list/
+    );
+    await expect(importMemoryYaml('version: 99\nbuckets: []')).rejects.toThrow(
+      /Unsupported memory export version/
+    );
+  });
+});
diff --git a/src/components/CodeLookup/memoryYaml.ts b/src/components/CodeLookup/memoryYaml.ts
new file mode 100644
index 00000000..e0273c7d
--- /dev/null
+++ b/src/components/CodeLookup/memoryYaml.ts
@@ -0,0 +1,216 @@
+/**
+ * YAML import/export for CodeLookup memory buckets — back up a picklist, move
+ * it to another machine, or ship a curated starter set for a context.
+ *
+ * `js-yaml` is an optional peer dependency, loaded lazily on first use (same
+ * pattern as `MediaEditor/ScriptPanel`), so nothing is pulled into bundles
+ * that never import/export. `yaml.load` uses the safe default schema.
+ *
+ * Document shape (`version: 1`):
+ *
+ * ```yaml
+ * version: 1
+ * exported: 2026-07-31T19:00:00.000Z
+ * buckets:
+ *   - user: alice
+ *     context: med-orders
+ *     codes:
+ *       - fullid: FDBMEDNAME3722
+ *         label: Lasix
+ *         codetype: FDB MEDNAME
+ *         fullcode: '3722'
+ *         domain: med
+ *         count: 3
+ *         lastUsed: 2026-07-31T18:00:00.000Z
+ * ```
+ */
+
+import {
+  getAllEntries,
+  mergeEntries,
+  type MemoryEntry,
+  type MemoryScope,
+} from './memoryStore';
+
+export const MEMORY_YAML_VERSION = 1;
+
+let yamlPromise: Promise<typeof import('js-yaml')> | null = null;
+function loadYaml() {
+  yamlPromise ??= import(/* @vite-ignore */ 'js-yaml').catch(
+    (cause: unknown) => {
+      yamlPromise = null; // let a later install work without a page reload
+      throw new Error(
+        'CodeLookup memory YAML needs the optional peer dependency `js-yaml`. Install it to use exportMemoryYaml/importMemoryYaml.',
+        { cause }
+      );
+    }
+  );
+  return yamlPromise;
+}
+
+interface YamlCode {
+  fullid: string;
+  label: string;
+  codetype: string;
+  fullcode: string;
+  domain: string;
+  count: number;
+  lastUsed?: string;
+}
+
+interface YamlBucket {
+  user: string;
+  context: string;
+  codes: YamlCode[];
+}
+
+interface YamlDoc {
+  version: number;
+  exported?: string;
+  buckets: YamlBucket[];
+}
+
+function isoOrUndefined(ms: number): string | undefined {
+  return ms > 0 ? new Date(ms).toISOString() : undefined;
+}
+
+/** Group entries into buckets, codes ordered as the picklist shows them. */
+function toDoc(entries: readonly MemoryEntry[]): YamlDoc {
+  const grouped = new Map<string, MemoryEntry[]>();
+  for (const e of entries) {
+    const key = `${e.userId}|${e.context}`;
+    const bucket = grouped.get(key);
+    if (bucket) bucket.push(e);
+    else grouped.set(key, [e]);
+  }
+  const buckets = [...grouped.values()].map((list) => {
+    list.sort((a, b) => b.count - a.count || b.lastUsed - a.lastUsed);
+    return {
+      user: list[0].userId,
+      context: list[0].context,
+      codes: list.map((e) => ({
+        fullid: e.fullid,
+        label: e.label,
+        codetype: e.codetype,
+        fullcode: e.fullcode,
+        domain: e.domain,
+        count: e.count,
+        lastUsed: isoOrUndefined(e.lastUsed),
+      })),
+    };
+  });
+  return {
+    version: MEMORY_YAML_VERSION,
+    exported: new Date().toISOString(),
+    buckets: buckets.sort(
+      (a, b) =>
+        a.user.localeCompare(b.user) || a.context.localeCompare(b.context)
+    ),
+  };
+}
+
+/**
+ * Serialize memory to YAML: one bucket when `scope` is given, otherwise every
+ * bucket in this browser.
+ */
+export async function exportMemoryYaml(scope?: MemoryScope): Promise<string> {
+  const [yaml, entries] = await Promise.all([loadYaml(), getAllEntries(scope)]);
+  return yaml.dump(toDoc(entries), { noRefs: true, lineWidth: 100 });
+}
+
+function str(v: unknown): string {
+  return typeof v === 'string' ? v : typeof v === 'number' ? String(v) : '';
+}
+
+/** Read one code row; returns null when it lacks the fields to be usable. */
+function toEntry(
+  raw: unknown,
+  userId: string,
+  context: string
+): MemoryEntry | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const c = raw as Record<string, unknown>;
+  const fullid = str(c.fullid);
+  if (!fullid) return null;
+  const count = typeof c.count === 'number' && c.count > 0 ? c.count : 1;
+  const lastUsed = c.lastUsed
+    ? // js-yaml parses unquoted ISO timestamps into Date objects
+      c.lastUsed instanceof Date
+      ? c.lastUsed.getTime()
+      : Date.parse(str(c.lastUsed))
+    : 0;
+  return {
+    userId,
+    context,
+    fullid,
+    label: str(c.label),
+    codetype: str(c.codetype),
+    fullcode: str(c.fullcode),
+    domain: str(c.domain),
+    count,
+    lastUsed: Number.isFinite(lastUsed) ? lastUsed : 0,
+    pendingDelta: 0,
+  };
+}
+
+export interface ImportMemoryOptions {
+  /**
+   * Merge every bucket in the document into this one bucket instead of the
+   * users/contexts it names — how a curated starter set is handed to the
+   * current user.
+   */
+  scope?: MemoryScope;
+}
+
+export interface ImportMemoryResult {
+  /** Codes merged into the store. */
+  imported: number;
+  /** Buckets read from the document. */
+  buckets: number;
+  /** Rows skipped for missing/invalid fields. */
+  skipped: number;
+}
+
+/**
+ * Merge a YAML document into the store (`count`/`lastUsed` keep the larger
+ * value, so importing is idempotent and never loses local usage). Throws on a
+ * document that isn't a recognizable memory export.
+ */
+export async function importMemoryYaml(
+  text: string,
+  { scope }: ImportMemoryOptions = {}
+): Promise<ImportMemoryResult> {
+  const yaml = await loadYaml();
+  const doc = yaml.load(text) as Partial<YamlDoc> | undefined;
+  if (!doc || typeof doc !== 'object' || !Array.isArray(doc.buckets))
+    throw new Error(
+      'Not a CodeLookup memory export: expected a `buckets` list.'
+    );
+  if (doc.version !== undefined && doc.version > MEMORY_YAML_VERSION)
+    throw new Error(
+      `Unsupported memory export version ${doc.version} (this build reads ${MEMORY_YAML_VERSION}).`
+    );
+
+  const entries: MemoryEntry[] = [];
+  let skipped = 0;
+  for (const bucket of doc.buckets) {
+    if (!bucket || typeof bucket !== 'object') {
+      skipped++;
+      continue;
+    }
+    const userId = scope?.userId ?? str(bucket.user) ?? '';
+    const context = scope?.context ?? str(bucket.context) ?? '';
+    if (!userId || !context || !Array.isArray(bucket.codes)) {
+      skipped++;
+      continue;
+    }
+    for (const raw of bucket.codes) {
+      const entry = toEntry(raw, userId, context);
+      if (entry) entries.push(entry);
+      else skipped++;
+    }
+  }
+
+  const imported = await mergeEntries(entries, scope);
+  return { imported, buckets: doc.buckets.length, skipped };
+}
diff --git a/src/tailwind-preset.ts b/src/tailwind-preset.ts
index aca0adb6..b315bec4 100644
--- a/src/tailwind-preset.ts
+++ b/src/tailwind-preset.ts
@@ -416,6 +416,8 @@ export const miewebUISafelist = [
   'last:border-b-0',
   'border-dashed',
   'text-[11px]',
+  // CodeLookup memory picklist (frequently-used pick count)
+  'text-primary-600',
   // SuperChat (participant chips, unread badge, active/hover states)
   'bg-primary-100',
   'bg-primary-600',