diff --git a/CLAUDE.md b/CLAUDE.md
index bbb74fc..41720f7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -389,6 +389,31 @@ placing anything. Specifically:
 
 A running log of durable decisions and feedback captured into the project config. Newest first.
 
+- 2026-06-26 — **Build (owner AI intimacy-topic suggester — SPEC 08 §16.5a AI-assist; on `feat/ai-intimacy-topics`,
+  PR pending).** The last item of the 2026-06-26 batch. The owner-only Intimacy Topics settings control gains a
+  **"Suggest with AI"** affordance. **All 3 product/UX forks asked first (user-chosen):** lives **in the existing
+  owner control** (not a separate panel); driven by a **subject box that falls back to a general varied batch when
+  blank** ("Both"); suggestions are added via a **pick-and-edit checklist** ("tick + edit, then Add selected"). Core
+  `@selfos/core/intimacy/suggestService.ts` (`suggestIntimacyTopics`) — one metered **`intimacy.suggestTopics`** pass
+  (budget-gated, meter-BEFORE-parse, tolerant `extractJsonObject` + honest failures, `extendedThinking:false`) that
+  proposes consensual-adult **activity + fantasy** topics and **dedupes** them case-insensitively against the merged
+  inventory (built-in + custom; an all-dupes result is an honest EMPTY). **Persists nothing** — the owner reviews +
+  the existing `addCustomIntimacyTopic` path commits the chosen ones. The consensual-adult boundary lives in the
+  prompt + the model (never a keyword filter); the Owner is the full-access role so the seam is gated `people.manage`
+  (owner-only), and **AI-off is a calm state** (no dead button). IPC `questionnaires:suggestIntimacyTopics` through
+  the full seam + the offline fake-Claude branch (returns a set incl. an existing built-in, so the dedupe is
+  exercised offline). Renderer: the control gains a subject `Textarea` + "Suggest with AI" → a checklist of
+  checkbox+editable rows → "Add selected (N)". Additive schema (`IntimacyTopicSuggestResult` + the usage type) — no
+  migration. Gate green: typecheck (all), lint, **938 core + 854 desktop** unit (4 core suggester [dedup/meter/ground,
+  no-subject, NO_KEY, EMPTY] + 6 control RTL [suggest/pick/edit/add, EMPTY surface, non-owner hidden] + a coreBridge
+  test [owner deduped, member denied, AI-off calm]), **E2E** (the Settings flow: Suggest → checklist → a built-in
+  deduped out → uncheck one → Add selected → persisted across both kinds). Visual QA (real Electron screenshot): the
+  subject box + the pick-and-edit checklist + "Add selected (3)" read clean + cohesive with Settings. Synced spec 08
+  §16.5a. **Lesson: a "suggest then add" feature is cheapest as an EPHEMERAL pass (persist nothing) layered on the
+  existing add path — the suggester only computes deduped candidates, the owner's checklist drives the existing
+  per-topic add, so there's no new persistence, no migration, and the dedupe is the one real guarantee (the prompt's
+  avoid-list just nudges the model).**
+
 - 2026-06-26 — **Build (guided-sessions expansion — fuller therapy/coaching + a Family group + catalog search;
   on `feat/guided-sessions-expansion`, PR pending).** Additive content + one small UI feature (an extension of
   spec 16/48, no new machinery, no schema/IPC). **New `family` group "Family & relationships"** (12
diff --git a/apps/desktop/e2e/launch.spec.ts b/apps/desktop/e2e/launch.spec.ts
index e276a84..e6d9dff 100644
--- a/apps/desktop/e2e/launch.spec.ts
+++ b/apps/desktop/e2e/launch.spec.ts
@@ -4469,7 +4469,7 @@ test('authoring (§16.4): AI draft fills the empty title; Save→Send is a two-s
   }
 });
 
-test('intimacy topics (§16.5a): the owner manages custom topics in Settings + an inline builder add, persisted', async () => {
+test('intimacy topics (§16.5a): the owner manages custom topics in Settings + AI suggest + an inline builder add, persisted', async () => {
   const { userData, vault } = await seedReadyVault({ 'ai.enabled': true });
   await createNodeSecretStore(userData, passthrough).set('anthropic.apiKey', 'sk-ant-e2e');
   const fs = createNodeFileSystem(vault);
@@ -4494,6 +4494,25 @@ test('intimacy topics (§16.5a): the owner manages custom topics in Settings + a
       .poll(async () => (await readCustomIntimacyTopics(fs)).activities)
       .toContain('Sploshing');
 
+    // Suggest with AI: the offline fake proposes a set that INCLUDES an existing built-in ('Sensual
+    // massage') — which is deduped out of the checklist. Uncheck one fresh suggestion, add the rest.
+    await w.getByRole('button', { name: 'Suggest with AI' }).click();
+    await expect(w.getByLabel('Include Mutual edging')).toBeVisible();
+    await expect(w.getByLabel('Include Temperature contrast play')).toBeVisible();
+    await expect(w.getByLabel('Include Sensual massage')).toHaveCount(0); // a built-in → deduped
+    await w.getByLabel('Include Temperature contrast play').uncheck();
+    await w.getByRole('button', { name: /Add selected/ }).click();
+    // The picked suggestions persist (across both kinds); the unchecked one does not.
+    await expect
+      .poll(async () => (await readCustomIntimacyTopics(fs)).activities)
+      .toContain('Mutual edging');
+    await expect
+      .poll(async () => (await readCustomIntimacyTopics(fs)).fantasies)
+      .toContain('Rivals-to-lovers roleplay');
+    expect((await readCustomIntimacyTopics(fs)).activities).not.toContain(
+      'Temperature contrast play',
+    );
+
     // The inline builder add (owner) writes to the SAME shared list: author an intimacy/unfiltered
     // questionnaire and add a fantasy from the AI panel.
     await w.getByRole('link', { name: 'Questionnaires' }).click();
diff --git a/apps/desktop/src/main/claude/anthropicClient.ts b/apps/desktop/src/main/claude/anthropicClient.ts
index 47eb62d..b0872ed 100644
--- a/apps/desktop/src/main/claude/anthropicClient.ts
+++ b/apps/desktop/src/main/claude/anthropicClient.ts
@@ -234,6 +234,19 @@ export function fakeClaudeClient(): ClaudeClient {
         });
       }
 
+      // The owner intimacy-topic suggester (08 §16.5a AI assist) — the brief lists what the owner already
+      // has. Return a small {activities, fantasies} set; include one EXISTING topic ('Sensual massage', a
+      // built-in) so the post-parse dedupe is exercised in the offline path (37 §10).
+      if (userText.includes('Topics the Owner ALREADY has')) {
+        return Promise.resolve({
+          text: JSON.stringify({
+            activities: ['Sensual massage', 'Mutual edging', 'Temperature contrast play'],
+            fantasies: ['Rivals-to-lovers roleplay', 'Voyeurism'],
+          }),
+          usage: { inputTokens: 90, outputTokens: 50, cacheWriteTokens: 0, cacheReadTokens: 0 },
+        });
+      }
+
       // The session-analysis turn (09 §5) asks to "summarize this session" as a JSON object. Return a
       // valid SessionAnalysisDraft so the offline End & summarize path parses + produces facts/mood.
       if (userText.includes('summarize this session')) {
diff --git a/apps/desktop/src/main/ipc.ts b/apps/desktop/src/main/ipc.ts
index 47ae396..a2a5ee5 100644
--- a/apps/desktop/src/main/ipc.ts
+++ b/apps/desktop/src/main/ipc.ts
@@ -291,6 +291,10 @@ export function registerIpcHandlers(): void {
   handle(IpcChannels.questionnairesIntimacyTopics, bridge.questionnairesIntimacyTopics);
   handle(IpcChannels.questionnairesAddIntimacyTopic, bridge.questionnairesAddIntimacyTopic);
   handle(IpcChannels.questionnairesRemoveIntimacyTopic, bridge.questionnairesRemoveIntimacyTopic);
+  handle(
+    IpcChannels.questionnairesSuggestIntimacyTopics,
+    bridge.questionnairesSuggestIntimacyTopics,
+  );
   handle(IpcChannels.questionnairesStoreImage, bridge.questionnairesStoreImage);
   handle(IpcChannels.questionnairesGetImage, bridge.questionnairesGetImage);
   handle(IpcChannels.questionnairesDeleteImage, bridge.questionnairesDeleteImage);
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index c032d2e..2c70768 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -132,6 +132,8 @@ const bridge: SelfosBridge = {
     ipcRenderer.invoke(IpcChannels.questionnairesAddIntimacyTopic, input),
   questionnairesRemoveIntimacyTopic: (input) =>
     ipcRenderer.invoke(IpcChannels.questionnairesRemoveIntimacyTopic, input),
+  questionnairesSuggestIntimacyTopics: (input) =>
+    ipcRenderer.invoke(IpcChannels.questionnairesSuggestIntimacyTopics, input),
   questionnairesStoreImage: (input) =>
     ipcRenderer.invoke(IpcChannels.questionnairesStoreImage, input),
   questionnairesGetImage: (imagePath) =>
diff --git a/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.module.css b/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.module.css
index a8f082c..066c23e 100644
--- a/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.module.css
+++ b/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.module.css
@@ -34,3 +34,36 @@
   background: var(--color-border);
   color: var(--color-text-primary);
 }
+
+/* The owner-only "Suggest with AI" block — a calm bordered card distinct from the manual add rows. */
+.suggestBox {
+  padding: var(--space-3);
+  background: var(--color-surface-alt);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+}
+
+.suggestions {
+  padding-top: var(--space-1);
+}
+
+/* One reviewable suggestion: a checkbox + an editable label, on a single row. */
+.pickRow {
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+  min-width: 0;
+}
+
+.pickRow > :last-child {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.pickCheck {
+  flex: none;
+  width: 16px;
+  height: 16px;
+  accent-color: var(--color-accent);
+  cursor: pointer;
+}
diff --git a/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.test.tsx b/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.test.tsx
index 74e1e88..06ed9b6 100644
--- a/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.test.tsx
+++ b/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.test.tsx
@@ -96,5 +96,60 @@ describe('IntimacyTopicsControl (§16.5a)', () => {
     expect(screen.getByText('Wax play')).toBeInTheDocument(); // still shown, just not removable
     expect(screen.queryByRole('button', { name: 'Remove Wax play' })).not.toBeInTheDocument();
     expect(screen.queryByLabelText(/Add activities/i)).not.toBeInTheDocument();
+    // The owner-only AI suggester is hidden for a non-owner.
+    expect(screen.queryByRole('button', { name: 'Suggest with AI' })).not.toBeInTheDocument();
+  });
+
+  it('suggests with AI, then adds only the picked + edited suggestions', async () => {
+    asOwner();
+    const add = vi.fn((input: { kind: 'activities' | 'fantasies'; name: string }) =>
+      Promise.resolve(view({ activities: [input.name], fantasies: [] })),
+    );
+    const suggest = vi.fn(() =>
+      Promise.resolve({
+        ok: true as const,
+        suggestions: { activities: ['Wax play', 'Edging'], fantasies: ['Roleplay'] },
+      }),
+    );
+    installMockBridge({
+      questionnairesIntimacyTopics: () => Promise.resolve(view({ activities: [], fantasies: [] })),
+      questionnairesSuggestIntimacyTopics: suggest,
+      questionnairesAddIntimacyTopic: add,
+    });
+    render(<IntimacyTopicsControl />);
+
+    await userEvent.click(await screen.findByRole('button', { name: 'Suggest with AI' }));
+    // Suggestions render as an editable checklist (all checked by default).
+    expect(await screen.findByLabelText('Edit suggestion: Wax play')).toBeInTheDocument();
+    // Uncheck 'Edging'.
+    await userEvent.click(screen.getByLabelText('Include Edging'));
+    // Edit 'Roleplay' → 'Pirate roleplay' (the label keys on the original text, so it still resolves).
+    const roleplay = screen.getByLabelText('Edit suggestion: Roleplay');
+    await userEvent.clear(roleplay);
+    await userEvent.type(roleplay, 'Pirate roleplay');
+
+    await userEvent.click(screen.getByRole('button', { name: /Add selected \(2\)/ }));
+    await waitFor(() => {
+      expect(add).toHaveBeenCalledWith({ kind: 'activities', name: 'Wax play' });
+      expect(add).toHaveBeenCalledWith({ kind: 'fantasies', name: 'Pirate roleplay' });
+    });
+    expect(add).not.toHaveBeenCalledWith({ kind: 'activities', name: 'Edging' }); // unchecked
+  });
+
+  it('surfaces an AI-suggestion failure calmly (nothing fresh)', async () => {
+    asOwner();
+    installMockBridge({
+      questionnairesIntimacyTopics: () => Promise.resolve(view({ activities: [], fantasies: [] })),
+      questionnairesSuggestIntimacyTopics: () =>
+        Promise.resolve({
+          ok: false as const,
+          reason: 'EMPTY' as const,
+          message: 'No fresh topics came back — try a different subject.',
+        }),
+    });
+    render(<IntimacyTopicsControl />);
+
+    await userEvent.click(await screen.findByRole('button', { name: 'Suggest with AI' }));
+    expect(await screen.findByText(/No fresh topics came back/)).toBeInTheDocument();
   });
 });
diff --git a/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.tsx b/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.tsx
index c1de18d..fe9b6be 100644
--- a/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.tsx
+++ b/apps/desktop/src/renderer/src/settings/IntimacyTopicsControl.tsx
@@ -1,11 +1,21 @@
 import { useEffect, useState } from 'react';
-import { X } from 'lucide-react';
+import { Sparkles, X } from 'lucide-react';
 import type { IntimacyTopicsView } from '@shared/channels';
-import { Banner, Button, Field, Stack, Text, Textarea } from '../design-system/components';
+import {
+  Banner,
+  Button,
+  Field,
+  Stack,
+  Text,
+  Textarea,
+  TextInput,
+} from '../design-system/components';
 import { useSessionStore } from '../stores/sessionStore';
 import styles from './IntimacyTopicsControl.module.css';
 
 type Kind = 'activities' | 'fantasies';
+/** A reviewable suggestion in the checklist: its kind, whether it's ticked, and the (editable) label. */
+type Pick = { kind: Kind; checked: boolean; text: string };
 
 const EMPTY_VIEW: IntimacyTopicsView = {
   builtIn: { activities: [], fantasies: [] },
@@ -16,9 +26,11 @@ const EMPTY_VIEW: IntimacyTopicsView = {
  * Owner-only management of the shared **intimacy topic inventory** (08-questionnaires §16.5a). The Owner
  * adds/removes custom activities + fantasies (household-wide, vault-stored); the merged inventory (built-in
  * + custom) seeds AI generation for intimacy questionnaires AND the personal intake. Built-ins are shown
- * read-only; only custom additions are removable. 18+ / consensual-adult only — additions are trusted free
- * text (the Owner is the full-access role); the boundary is enforced by the generation prompt + the model.
- * Add/remove is **owner-only** (`people.manage`); a non-owner admin sees the list read-only.
+ * read-only; only custom additions are removable. The Owner can also **suggest topics with AI** — name a
+ * subject (or leave it blank for a varied mix), review the deduped suggestions in a checklist (tick + edit),
+ * then add the chosen ones. 18+ / consensual-adult only — additions are trusted free text (the Owner is the
+ * full-access role); the boundary is enforced by the prompt + the model. Add/suggest is **owner-only**
+ * (`people.manage`); a non-owner admin sees the list read-only.
  */
 export function IntimacyTopicsControl(): JSX.Element {
   const canManage = useSessionStore((s) => s.can('people.manage'));
@@ -28,6 +40,17 @@ export function IntimacyTopicsControl(): JSX.Element {
   const [busy, setBusy] = useState<Kind | null>(null);
   const [error, setError] = useState<string | null>(null);
 
+  // AI suggestions.
+  const [subject, setSubject] = useState('');
+  const [suggesting, setSuggesting] = useState(false);
+  const [suggestError, setSuggestError] = useState<string | null>(null);
+  const [suggestions, setSuggestions] = useState<{
+    activities: string[];
+    fantasies: string[];
+  } | null>(null);
+  const [picks, setPicks] = useState<Record<string, Pick>>({});
+  const [addingSelected, setAddingSelected] = useState(false);
+
   const load = (): void => {
     void window.selfos
       ?.questionnairesIntimacyTopics()
@@ -64,6 +87,61 @@ export function IntimacyTopicsControl(): JSX.Element {
     }
   };
 
+  const onSuggest = async (): Promise<void> => {
+    if (suggesting) return;
+    setSuggesting(true);
+    setSuggestError(null);
+    setSuggestions(null);
+    try {
+      const res = await window.selfos?.questionnairesSuggestIntimacyTopics({
+        subject: subject.trim(),
+      });
+      if (!res) {
+        setSuggestError('Suggestions aren’t available right now.');
+        return;
+      }
+      if (!res.ok) {
+        setSuggestError(res.message);
+        return;
+      }
+      setSuggestions(res.suggestions);
+      const init: Record<string, Pick> = {};
+      for (const kind of ['activities', 'fantasies'] as const)
+        for (const text of res.suggestions[kind])
+          init[`${kind}:${text}`] = { kind, checked: true, text };
+      setPicks(init);
+    } catch {
+      setSuggestError('Couldn’t get suggestions. Only the household owner can use this.');
+    } finally {
+      setSuggesting(false);
+    }
+  };
+
+  const selected = Object.values(picks).filter((p) => p.checked && p.text.trim() !== '');
+
+  const onAddSelected = async (): Promise<void> => {
+    if (addingSelected || selected.length === 0) return;
+    setAddingSelected(true);
+    setError(null);
+    try {
+      let latest: IntimacyTopicsView | undefined;
+      for (const p of selected) {
+        latest = await window.selfos?.questionnairesAddIntimacyTopic({
+          kind: p.kind,
+          name: p.text.trim(),
+        });
+      }
+      if (latest) setView(latest);
+      setSuggestions(null);
+      setPicks({});
+      setSubject('');
+    } catch {
+      setError('Couldn’t add the selected topics.');
+    } finally {
+      setAddingSelected(false);
+    }
+  };
+
   if (!view) return <Text tone="tertiary">Loading…</Text>;
 
   return (
@@ -79,6 +157,94 @@ export function IntimacyTopicsControl(): JSX.Element {
         </Text>
       ) : null}
 
+      {canManage ? (
+        <Stack gap={2} className={styles.suggestBox}>
+          <Text weight={600}>
+            <Sparkles size={14} aria-hidden="true" /> Suggest with AI
+          </Text>
+          <Text size="sm" tone="tertiary">
+            Name a theme to explore (or leave it blank for a varied mix). SelfOS proposes fresh
+            topics — review and edit them before adding.
+          </Text>
+          <Field label="Subject (optional)">
+            {(props) => (
+              <Textarea
+                {...props}
+                rows={1}
+                value={subject}
+                placeholder="e.g. sensory play, role-play"
+                onChange={(e) => setSubject(e.target.value)}
+              />
+            )}
+          </Field>
+          <div>
+            <Button variant="secondary" onClick={() => void onSuggest()} disabled={suggesting}>
+              {suggesting ? 'Thinking…' : 'Suggest with AI'}
+            </Button>
+          </div>
+          {suggestError ? <Banner tone="warning">{suggestError}</Banner> : null}
+          {suggestions ? (
+            <Stack gap={3} className={styles.suggestions}>
+              {(['activities', 'fantasies'] as const).map((kind) =>
+                suggestions[kind].length > 0 ? (
+                  <Stack key={kind} gap={1}>
+                    <Text size="sm" weight={600}>
+                      {kind === 'activities' ? 'Suggested activities' : 'Suggested fantasies'}
+                    </Text>
+                    {suggestions[kind].map((orig) => {
+                      const id = `${kind}:${orig}`;
+                      const pick = picks[id];
+                      return (
+                        <div key={id} className={styles.pickRow}>
+                          <input
+                            type="checkbox"
+                            className={styles.pickCheck}
+                            checked={pick?.checked ?? false}
+                            aria-label={`Include ${orig}`}
+                            onChange={(e) =>
+                              setPicks((p) => ({
+                                ...p,
+                                [id]: {
+                                  kind,
+                                  checked: e.target.checked,
+                                  text: p[id]?.text ?? orig,
+                                },
+                              }))
+                            }
+                          />
+                          <TextInput
+                            value={pick?.text ?? orig}
+                            aria-label={`Edit suggestion: ${orig}`}
+                            onChange={(e) =>
+                              setPicks((p) => ({
+                                ...p,
+                                [id]: {
+                                  kind,
+                                  checked: p[id]?.checked ?? true,
+                                  text: e.target.value,
+                                },
+                              }))
+                            }
+                          />
+                        </div>
+                      );
+                    })}
+                  </Stack>
+                ) : null,
+              )}
+              <div>
+                <Button
+                  onClick={() => void onAddSelected()}
+                  disabled={addingSelected || selected.length === 0}
+                >
+                  {addingSelected ? 'Adding…' : `Add selected (${selected.length})`}
+                </Button>
+              </div>
+            </Stack>
+          ) : null}
+        </Stack>
+      ) : null}
+
       {(['activities', 'fantasies'] as const).map((kind) => (
         <Stack key={kind} gap={2}>
           <Text weight={600}>{kind === 'activities' ? 'Activities' : 'Fantasies'}</Text>
diff --git a/apps/desktop/src/renderer/src/test-utils/bridge.ts b/apps/desktop/src/renderer/src/test-utils/bridge.ts
index ea2279c..602b682 100644
--- a/apps/desktop/src/renderer/src/test-utils/bridge.ts
+++ b/apps/desktop/src/renderer/src/test-utils/bridge.ts
@@ -248,6 +248,11 @@ export function installMockBridge(overrides: Partial<SelfosBridge> = {}): Selfos
         builtIn: { activities: [], fantasies: [] },
         custom: { activities: [], fantasies: [] },
       }),
+    questionnairesSuggestIntimacyTopics: () =>
+      Promise.resolve({
+        ok: true as const,
+        suggestions: { activities: [], fantasies: [] },
+      }),
     questionnairesStoreImage: (input) =>
       Promise.resolve({ imagePath: 'questionnaires/media/mock.enc', mime: input.mime }),
     questionnairesGetImage: () => Promise.resolve(null),
diff --git a/apps/desktop/src/shared/channels.ts b/apps/desktop/src/shared/channels.ts
index 5138c36..9e22086 100644
--- a/apps/desktop/src/shared/channels.ts
+++ b/apps/desktop/src/shared/channels.ts
@@ -54,6 +54,7 @@ import type {
   InboxAssignmentDetail,
   InboxItem,
   IntimacyTopicsView,
+  IntimacyTopicSuggestResult,
   InviteSummary,
   Insight,
   InsightFact,
@@ -201,6 +202,7 @@ export const IpcChannels = {
   questionnairesIntimacyTopics: 'questionnaires:intimacyTopics',
   questionnairesAddIntimacyTopic: 'questionnaires:addIntimacyTopic',
   questionnairesRemoveIntimacyTopic: 'questionnaires:removeIntimacyTopic',
+  questionnairesSuggestIntimacyTopics: 'questionnaires:suggestIntimacyTopics',
   questionnairesStoreImage: 'questionnaires:storeImage',
   questionnairesGetImage: 'questionnaires:getImage',
   questionnairesDeleteImage: 'questionnaires:deleteImage',
@@ -697,6 +699,10 @@ export interface SelfosBridge {
     kind: 'activities' | 'fantasies';
     name: string;
   }): Promise<IntimacyTopicsView>;
+  /** Owner-only: AI-suggest fresh intimacy topics around an optional subject (deduped). Persists nothing. */
+  questionnairesSuggestIntimacyTopics(input: {
+    subject?: string;
+  }): Promise<IntimacyTopicSuggestResult>;
   /** Encrypt + store an author-attached question image (base64 in); returns its vault path + mime. */
   questionnairesStoreImage(input: { base64: string; mime: string }): Promise<{
     imagePath: string;
diff --git a/apps/desktop/src/shared/coreBridge.test.ts b/apps/desktop/src/shared/coreBridge.test.ts
index bc0cfef..6d1a0ed 100644
--- a/apps/desktop/src/shared/coreBridge.test.ts
+++ b/apps/desktop/src/shared/coreBridge.test.ts
@@ -143,6 +143,17 @@ function makeHost(): {
           usage: { inputTokens: 1, outputTokens: 1, cacheWriteTokens: 0, cacheReadTokens: 0 },
         });
       }
+      // The owner intimacy-topic suggester (08 §16.5a) — the brief lists existing topics. Return a set
+      // including one EXISTING built-in ('Sensual massage') so the bridge test exercises the dedupe.
+      if (userText.includes('Topics the Owner ALREADY has')) {
+        return Promise.resolve({
+          text: JSON.stringify({
+            activities: ['Sensual massage', 'Mutual edging'],
+            fantasies: ['Rivals-to-lovers roleplay'],
+          }),
+          usage: { inputTokens: 1, outputTokens: 1, cacheWriteTokens: 0, cacheReadTokens: 0 },
+        });
+      }
       // Compatibility alignment → a report object (items merge by canonicalId in the service).
       if (userText.includes('compatibility report JSON')) {
         return Promise.resolve({
@@ -2145,6 +2156,36 @@ describe('createCoreBridge', () => {
     expect(afterRemove.custom.fantasies).toEqual(['Pirate roleplay']);
   });
 
+  it('intimacy topics AI suggest (§16.5a): owner gets DEDUPED suggestions; a member is denied; AI-off is calm', async () => {
+    const { bridge, ownerId } = await freshOwner();
+    await bridge.setSetting({ key: 'ai.enabled', value: true, scope: 'vault' });
+    await bridge.secretSet({ id: ANTHROPIC_API_KEY_ID, value: 'sk-test' });
+
+    const res = await bridge.questionnairesSuggestIntimacyTopics({ subject: 'sensory play' });
+    expect(res.ok).toBe(true);
+    if (!res.ok) throw new Error('expected ok');
+    // The fake returns a built-in ('Sensual massage') + fresh ones → the built-in is deduped out.
+    expect(res.suggestions.activities).toEqual(['Mutual edging']);
+    expect(res.suggestions.fantasies).toEqual(['Rivals-to-lovers roleplay']);
+
+    // A member cannot suggest (owner-only, people.manage) — a calm failure, never a throw.
+    const member = await bridge.peopleSave({ displayName: 'Mem', isSubject: true, tags: [] });
+    await bridge.accessSetAccount({ personId: member.id, roleId: 'member', pin: null });
+    await bridge.sessionSetActive({ personId: member.id });
+    const denied = await bridge.questionnairesSuggestIntimacyTopics({ subject: 'x' });
+    expect(denied.ok).toBe(false);
+    if (denied.ok) throw new Error('expected denial');
+    expect(denied.reason).toBe('ERROR');
+
+    // AI off → a calm AI_OFF for the owner (no dead button).
+    await bridge.sessionSetActive({ personId: ownerId, pin: '1234' });
+    await bridge.setSetting({ key: 'ai.enabled', value: false, scope: 'vault' });
+    const off = await bridge.questionnairesSuggestIntimacyTopics({});
+    expect(off.ok).toBe(false);
+    if (off.ok) throw new Error('expected AI_OFF');
+    expect(off.reason).toBe('AI_OFF');
+  });
+
   it('stores, reads back, and deletes an encrypted question image; gated + validated', async () => {
     const { bridge } = await freshOwner();
     const base64 = toBase64(new Uint8Array([0x89, 0x50, 0x4e, 0x47, 1, 2, 3, 4]));
diff --git a/apps/desktop/src/shared/coreBridge.ts b/apps/desktop/src/shared/coreBridge.ts
index a0b21da..65cbbc2 100644
--- a/apps/desktop/src/shared/coreBridge.ts
+++ b/apps/desktop/src/shared/coreBridge.ts
@@ -79,6 +79,7 @@ import {
   type ChallengeSuggestionResult,
   type Insight,
   type IntimacyTopicsView,
+  type IntimacyTopicSuggestResult,
   type MemoryReconcileResult,
   type MemoryReconcileState,
   type OutboundSharing,
@@ -265,7 +266,12 @@ import {
   synthesizeRelationship,
   type GoalRaiseGoal,
 } from '@selfos/core/coaching';
-import { INTIMACY_ACTIVITIES, INTIMACY_FANTASIES } from '@selfos/core/intimacy';
+import {
+  INTIMACY_ACTIVITIES,
+  INTIMACY_FANTASIES,
+  mergedIntimacyTopics,
+  suggestIntimacyTopics,
+} from '@selfos/core/intimacy';
 import {
   addCustomIntimacyTopic,
   addCustomType,
@@ -648,6 +654,7 @@ const IntimacyTopicSchema = z.object({
   kind: z.enum(['activities', 'fantasies']),
   name: z.string().min(1),
 });
+const SuggestIntimacyTopicsSchema = z.object({ subject: z.string().optional() });
 const AssignmentsCreateSchema = z.object({
   questionnaireId: z.string().min(1),
   // No recipient here — it's bound to the questionnaire at creation (08 §17.3) and read from the def.
@@ -2238,6 +2245,24 @@ export function createCoreBridge(host: BridgeHost): SelfosBridge {
         custom: await readCustomIntimacyTopics(ctx.fs),
       };
     },
+    questionnairesSuggestIntimacyTopics: async (input): Promise<IntimacyTopicSuggestResult> => {
+      // Owner-only (the topics are household-wide) — gated `people.manage`, like the manual add.
+      const ctx = await host.vaultAndKey();
+      if (!ctx || !(await activePersonCan(ctx.fs, ctx.key, 'people.manage'))) {
+        return { ok: false, reason: 'ERROR', message: 'Not permitted.' };
+      }
+      if ((await readVaultSettingsValues(ctx.fs))['ai.enabled'] === false) {
+        return { ok: false, reason: 'AI_OFF', message: 'Turn on AI in Settings to use this.' };
+      }
+      const deps = await aiDeps('people.manage');
+      if (!deps) return { ok: false, reason: 'ERROR', message: 'Not available.' };
+      const { subject } = SuggestIntimacyTopicsSchema.parse(input ?? {});
+      const existing = mergedIntimacyTopics(await readCustomIntimacyTopics(ctx.fs));
+      return suggestIntimacyTopics(deps, {
+        existing,
+        ...(subject?.trim() ? { subject: subject.trim() } : {}),
+      });
+    },
     questionnairesStoreImage: async (input): Promise<{ imagePath: string; mime: string }> => {
       const ctx = await host.vaultAndKey();
       if (!ctx || !(await activePersonCan(ctx.fs, ctx.key, 'questionnaires.create'))) {
diff --git a/docs/specs/08-questionnaires.md b/docs/specs/08-questionnaires.md
index b17ce04..48955c2 100644
--- a/docs/specs/08-questionnaires.md
+++ b/docs/specs/08-questionnaires.md
@@ -1558,6 +1558,13 @@ explicitness the **intake** intimacy block already ships, within the **same** co
 > list** (`INTIMACY_ACTIVITIES` = the entry labels); the category/tier metadata is exposed via new symbols only.
 > Generation MAY (08-owned, not required) use the category metadata to seed from a family.
 
+> **AI-assist (Built, 2026-06-26).** The owner control gains a **"Suggest with AI"** affordance: the Owner
+> optionally types a subject (blank → a varied spread) and one metered `intimacy.suggestTopics` pass
+> (`suggestIntimacyTopics`, owner-gated `people.manage`, meter-before-parse, tolerant) proposes consensual-adult
+> **activity + fantasy** topics **deduped** against the merged inventory. It **persists nothing** — the Owner
+> reviews them in a **pick-and-edit checklist** and the existing add path commits the chosen ones. The
+> consensual-adult boundary is in the prompt + the model (never a keyword filter); AI-off is a calm state.
+
 The in-policy topic inventory that seeds generation (and that the **intake** intimacy block already uses as its
 `ACTIVITIES`/`commonFantasies` lists, [`18`](18-personal-onboarding.md)) becomes **one shared, owner-extensible
 source of truth**:
diff --git a/packages/core/src/intimacy/index.ts b/packages/core/src/intimacy/index.ts
index 1860e38..672ed75 100644
--- a/packages/core/src/intimacy/index.ts
+++ b/packages/core/src/intimacy/index.ts
@@ -1,3 +1,4 @@
 export * from './topics';
 export * from './activityRows';
 export * from './grouping';
+export * from './suggestService';
diff --git a/packages/core/src/intimacy/suggestService.test.ts b/packages/core/src/intimacy/suggestService.test.ts
new file mode 100644
index 0000000..9692e76
--- /dev/null
+++ b/packages/core/src/intimacy/suggestService.test.ts
@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { generateMasterKey } from '../crypto';
+import { memFileSystem } from '../host/memFileSystem';
+import type { ClaudeClient, FileSystem } from '../host';
+import { queryUsage } from '../usage';
+import { type SuggestTopicsDeps, suggestIntimacyTopics } from './suggestService';
+import type { IntimacyTopics } from './topics';
+
+const key = generateMasterKey();
+const now = new Date('2026-06-26T12:00:00.000Z');
+let fs: FileSystem;
+beforeEach(() => {
+  fs = memFileSystem();
+});
+
+/** A fake client capturing the system + the user brief and returning a JSON payload. */
+function jsonClient(payload: { activities: string[]; fantasies: string[] }): {
+  client: ClaudeClient;
+  system: () => string;
+  brief: () => string;
+} {
+  let system = '';
+  let brief = '';
+  return {
+    system: () => system,
+    brief: () => brief,
+    client: {
+      send: () => Promise.resolve(''),
+      stream: (options) => {
+        system = options.system ?? '';
+        brief = options.messages
+          .map((m) => (typeof m.content === 'string' ? m.content : ''))
+          .join('\n');
+        return Promise.resolve({
+          text: JSON.stringify(payload),
+          usage: { inputTokens: 80, outputTokens: 40, cacheWriteTokens: 0, cacheReadTokens: 0 },
+        });
+      },
+    },
+  };
+}
+
+const existing: IntimacyTopics = { activities: ['Sensual massage'], fantasies: ['Domination'] };
+
+function deps(client: ClaudeClient, over: Partial<SuggestTopicsDeps> = {}): SuggestTopicsDeps {
+  return {
+    fs,
+    key,
+    client,
+    apiKey: 'sk-ant',
+    model: 'claude-sonnet-4-6',
+    personId: 'owner-1',
+    now,
+    ...over,
+  };
+}
+
+describe('suggestIntimacyTopics (08 §16.5a AI assist)', () => {
+  it('returns deduped fresh activities + fantasies, meters before parse, and grounds the prompt', async () => {
+    const { client, system, brief } = jsonClient({
+      activities: ['Sensual massage', 'Wax play', 'WAX PLAY', '  '], // existing dup + in-list dup + blank
+      fantasies: ['Voyeurism', 'Domination'], // 2nd is an existing dup
+    });
+    const res = await suggestIntimacyTopics(deps(client), { subject: 'sensory play', existing });
+
+    expect(res.ok).toBe(true);
+    if (!res.ok) throw new Error('expected ok');
+    expect(res.suggestions.activities).toEqual(['Wax play']); // existing + in-list dup + blank dropped
+    expect(res.suggestions.fantasies).toEqual(['Voyeurism']); // 'Domination' (existing) dropped
+
+    // The subject + the avoid-list reached the model; the consensual-adult boundary is in the system prompt.
+    expect(brief()).toContain('sensory play');
+    expect(brief()).toContain('Sensual massage'); // the "already have, do not repeat" list
+    expect(system()).toMatch(/consensual ADULTS only/i);
+
+    // Metered as intimacy.suggestTopics (before parse / dedup).
+    const usage = await queryUsage(fs, key, {
+      from: '2026-06-01T00:00:00.000Z',
+      to: '2026-07-01T00:00:00.000Z',
+      personId: 'owner-1',
+    });
+    expect(usage.some((u) => u.type === 'intimacy.suggestTopics')).toBe(true);
+  });
+
+  it('with no subject, asks for a varied spread (and still works)', async () => {
+    const { client, brief } = jsonClient({ activities: ['Edging together'], fantasies: [] });
+    const res = await suggestIntimacyTopics(deps(client), { existing });
+    expect(res.ok).toBe(true);
+    expect(brief()).toMatch(/No specific subject/i);
+  });
+
+  it('NO_KEY without an API key (no spend)', async () => {
+    const { client } = jsonClient({ activities: ['x'], fantasies: [] });
+    const res = await suggestIntimacyTopics(deps(client, { apiKey: null }), { existing });
+    expect(res.ok).toBe(false);
+    if (res.ok) throw new Error('expected failure');
+    expect(res.reason).toBe('NO_KEY');
+    const usage = await queryUsage(fs, key, {
+      from: '2026-06-01T00:00:00.000Z',
+      to: '2026-07-01T00:00:00.000Z',
+      personId: 'owner-1',
+    });
+    expect(usage).toHaveLength(0);
+  });
+
+  it('EMPTY when every suggestion already exists (the model only echoed the inventory)', async () => {
+    const { client } = jsonClient({ activities: ['sensual massage'], fantasies: ['DOMINATION'] });
+    const res = await suggestIntimacyTopics(deps(client), { existing });
+    expect(res.ok).toBe(false);
+    if (res.ok) throw new Error('expected failure');
+    expect(res.reason).toBe('EMPTY');
+  });
+});
diff --git a/packages/core/src/intimacy/suggestService.ts b/packages/core/src/intimacy/suggestService.ts
new file mode 100644
index 0000000..83def34
--- /dev/null
+++ b/packages/core/src/intimacy/suggestService.ts
@@ -0,0 +1,186 @@
+import { z } from 'zod';
+import { classifyParseOutcome, extractJsonObject } from '../ai/jsonSalvage';
+import type { ClaudeClient, FileSystem } from '../host';
+import type { IntimacyTopicSuggestResult, UsageEvent } from '../schemas';
+import { uuid } from '../id';
+import { checkBudget, costOf, recordUsage } from '../usage';
+import { PERSONA, SAFETY } from '../conversations/promptBuilder';
+import type { IntimacyTopics } from './topics';
+
+/**
+ * The owner-only AI **intimacy-topic suggester** (08-questionnaires §16.5a, the AI-assist follow-up). The
+ * Owner optionally types a subject/theme and the model proposes consensual-adult **activity** + **fantasy**
+ * topics to add to the shared inventory — deduped against what already exists, in the calm wellness register
+ * the rest of the intimacy work uses. It PERSISTS NOTHING: the owner reviews the suggestions in a checklist,
+ * edits, and the existing add path commits the chosen ones. The only AI spend is one `intimacy.suggestTopics`
+ * pass, metered BEFORE parse (spec 06 / 37).
+ *
+ * Boundary (§8, in the prompt + the model, never a keyword filter): consensual adults only; taboo content
+ * strictly as fantasy/roleplay; never minors, real non-consent, or illegal acts. The Owner is the full-access
+ * role, so this is gated `people.manage` at the seam, like the manual add.
+ */
+
+const MAX_PER_KIND = 12;
+
+function guidance(): string {
+  return `You are helping the Owner of a private wellness app curate a shared, consensual-adult intimacy \
+"topic inventory" — short labels (a few words each) that people later RATE in a self-reflection (e.g. \
+"Sensual massage", "Light bondage (cuffs / ties)"). These are topics to rate, NOT instructions or how-to \
+content. Write in a frank, plain, clinical-but-warm wellness register — like a sexual-health questionnaire, \
+never erotica.
+
+Suggest concise topics across two lists: "activities" (things partners do together) and "fantasies" \
+(themes/roleplay people fantasize about). Boundary: consensual ADULTS only; taboo content ONLY as clearly \
+pre-agreed fantasy/roleplay between adults (e.g. CNC as ravishment roleplay); NEVER anything involving \
+minors, real non-consent, incest, or illegal acts. Do not repeat any topic the Owner already has (a list is \
+provided to avoid). Keep each label short and rateable; aim for 6–10 fresh topics per list (fewer is fine if \
+the subject is narrow). If a subject is given, stay close to it; if not, suggest a varied spread across \
+gentle→adventurous.
+
+Respond with ONLY a JSON object: {"activities": string[], "fantasies": string[]}.`;
+}
+
+function buildBrief(subject: string | undefined, existing: IntimacyTopics): string {
+  const subjectLine = subject?.trim()
+    ? `Subject to suggest around: ${subject.trim()}`
+    : 'No specific subject — suggest a varied spread across gentle→adventurous.';
+  const avoid = [...existing.activities, ...existing.fantasies];
+  // Bound the avoid-list so a huge custom inventory can't blow the prompt; the post-parse dedupe is the
+  // real guarantee, this just nudges the model.
+  const avoidLine = `Topics the Owner ALREADY has (do not repeat these): ${avoid.slice(0, 160).join(', ')}`;
+  return [subjectLine, avoidLine].join('\n\n');
+}
+
+const DraftSchema = z.object({
+  activities: z.array(z.string()).catch([]).default([]),
+  fantasies: z.array(z.string()).catch([]).default([]),
+});
+
+/** Case-insensitive: keep only fresh, non-empty, in-list-unique labels not already in `taken`. */
+function freshen(values: string[], taken: Set<string>): string[] {
+  const out: string[] = [];
+  const seen = new Set(taken);
+  for (const raw of values) {
+    const label = raw.trim();
+    const norm = label.toLocaleLowerCase();
+    if (label === '' || seen.has(norm)) continue;
+    seen.add(norm);
+    out.push(label);
+    if (out.length >= MAX_PER_KIND) break;
+  }
+  return out;
+}
+
+function buildUsage(
+  model: string,
+  personId: string,
+  at: string,
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteTokens: number;
+    cacheReadTokens: number;
+  },
+): UsageEvent {
+  return {
+    id: uuid(),
+    schemaVersion: 1,
+    type: 'intimacy.suggestTopics',
+    personId,
+    model,
+    at,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheWriteTokens: usage.cacheWriteTokens,
+    cacheReadTokens: usage.cacheReadTokens,
+    costUsd: costOf(model, usage),
+  };
+}
+
+export interface SuggestTopicsDeps {
+  fs: FileSystem;
+  key: Uint8Array;
+  client: ClaudeClient;
+  apiKey: string | null;
+  model: string;
+  /** The Owner — for usage attribution (the topics are household-wide). */
+  personId: string;
+  now: Date;
+  override?: boolean;
+}
+
+/**
+ * Run the suggester: budget-gated → one Claude call → meter (`intimacy.suggestTopics`, BEFORE parse) →
+ * tolerant parse → dedupe against the existing inventory (case-insensitive). Returns ephemeral candidates;
+ * nothing is written. An empty result after dedupe is an honest EMPTY (the model only echoed existing topics).
+ */
+export async function suggestIntimacyTopics(
+  deps: SuggestTopicsDeps,
+  input: { subject?: string; existing: IntimacyTopics },
+): Promise<IntimacyTopicSuggestResult> {
+  const { fs, key, client, apiKey, model, personId, now } = deps;
+  if (!apiKey) return { ok: false, reason: 'NO_KEY', message: 'Add your Claude API key first.' };
+
+  const person = await checkBudget(fs, key, {
+    scope: 'person',
+    personId,
+    now,
+    override: deps.override,
+  });
+  const app = await checkBudget(fs, key, { scope: 'app', now, override: deps.override });
+  if (person.state === 'over' || app.state === 'over') {
+    return { ok: false, reason: 'BUDGET', message: 'AI budget reached for this period.' };
+  }
+
+  const at = now.toISOString();
+  let result;
+  try {
+    result = await client.stream(
+      {
+        apiKey,
+        model,
+        system: [PERSONA, SAFETY, guidance()].join('\n\n'),
+        messages: [{ role: 'user', content: buildBrief(input.subject, input.existing) }],
+        maxTokens: 800,
+        extendedThinking: false, // a bounded structured-JSON call — keep the whole budget for output
+      },
+      () => {},
+    );
+  } catch {
+    return {
+      ok: false,
+      reason: 'ERROR',
+      message: 'The suggestions couldn’t be written. Please try again.',
+    };
+  }
+
+  // Meter BEFORE parse — a paid call whose JSON fails is still billed (spec 06 / 37).
+  await recordUsage(fs, key, buildUsage(model, personId, at, result.usage));
+
+  const obj = extractJsonObject(result.text);
+  const parsed = obj ? DraftSchema.safeParse(obj) : null;
+  if (!parsed?.success) {
+    const { reason, message } = classifyParseOutcome(result.text, 'topic suggestions');
+    return { ok: false, reason, message };
+  }
+
+  const taken = new Set(
+    [...input.existing.activities, ...input.existing.fantasies].map((t) => t.toLocaleLowerCase()),
+  );
+  const activities = freshen(parsed.data.activities, taken);
+  // Fantasies dedupe against the fantasy + activity sets too, so the two suggestion lists don't overlap.
+  const fantasies = freshen(
+    parsed.data.fantasies,
+    new Set([...taken, ...activities.map((a) => a.toLocaleLowerCase())]),
+  );
+
+  if (activities.length === 0 && fantasies.length === 0) {
+    return {
+      ok: false,
+      reason: 'EMPTY',
+      message:
+        'No fresh topics came back — try a different subject, or you may already have them all.',
+    };
+  }
+  return { ok: true, suggestions: { activities, fantasies } };
+}
diff --git a/packages/core/src/schemas.ts b/packages/core/src/schemas.ts
index 47e6c89..8d97634 100644
--- a/packages/core/src/schemas.ts
+++ b/packages/core/src/schemas.ts
@@ -836,6 +836,33 @@ export type ChallengeSuggestionResult =
       message: string;
     };
 
+/**
+ * AI-suggested intimacy topics for the owner to review (08-questionnaires §16.5a, AI-assist follow-up).
+ * Deduped activity + fantasy candidates the owner picks/edits before adding to the shared inventory — the
+ * suggester PERSISTS NOTHING (the owner's "Add selected" reuses the existing add path). The only AI spend is
+ * the `intimacy.suggestTopics` pass, owner-gated + metered before parse.
+ */
+export interface IntimacyTopicSuggestions {
+  activities: string[];
+  fantasies: string[];
+}
+
+export type IntimacyTopicSuggestResult =
+  | { ok: true; suggestions: IntimacyTopicSuggestions }
+  | {
+      ok: false;
+      reason:
+        | 'NO_KEY'
+        | 'BUDGET'
+        | 'AI_OFF'
+        | 'EMPTY'
+        | 'REFUSED'
+        | 'TRUNCATED'
+        | 'MALFORMED'
+        | 'ERROR';
+      message: string;
+    };
+
 /**
  * The result of an inline check-in (52 §6). The status + outcome ALWAYS persist (free, no AI); the optional
  * reflection → Insight bridge (§5.4) is deterministic in v1, so a check-in never spends. `challenge` carries
diff --git a/packages/core/src/usageTypes.ts b/packages/core/src/usageTypes.ts
index adda009..205b2e1 100644
--- a/packages/core/src/usageTypes.ts
+++ b/packages/core/src/usageTypes.ts
@@ -21,6 +21,7 @@ export const USAGE_TYPE_LABELS: Record<string, string> = {
   'relationship.synthesize': 'Memory — relationship insights',
   'test.narrate': 'Self-assessment — what it means',
   'challenge.suggest': 'Challenge suggestion',
+  'intimacy.suggestTopics': 'Intimacy topics — AI suggestions',
 };
 
 export function usageTypeLabel(type: string): string {