diff --git a/packages/sdk/src/client.ts b/packages/sdk/src/client.ts
index 013fb178..b1b50375 100644
--- a/packages/sdk/src/client.ts
+++ b/packages/sdk/src/client.ts
@@ -209,6 +209,8 @@ export interface DataClient {
   aiSearch(query: string, limit?: number): Promise<AiSearchResponse>;
   aiTasks(goal: string, context?: string): Promise<AiTasksResponse>;
   aiDownloadModel(url?: string): Promise<AiStatus['download']>;
+  /** False for clients without a transcription transport (for example the local store). */
+  readonly supportsTranscription?: boolean;
   transcribeAsset(assetId: string, pageId: string): Promise<AiTranscriptionResult>;
   aiComplete(text: string, onToken: (token: string) => void, opts?: {instruction?: string; signal?: AbortSignal}): Promise<string>;
   aiGenerate(prompt: string, onToken: (token: string) => void, opts?: {system?: string; maxTokens?: number; signal?: AbortSignal}): Promise<string>;
diff --git a/packages/server/src/localClient.ts b/packages/server/src/localClient.ts
index 69001f19..11a37682 100644
--- a/packages/server/src/localClient.ts
+++ b/packages/server/src/localClient.ts
@@ -921,6 +921,8 @@ export class LocalDataClient implements DataClient {
     return Promise.reject(this.aiUnavailable());
   }
 
+  readonly supportsTranscription = false;
+
   transcribeAsset(): Promise<AiTranscriptionResult> {
     return Promise.reject(this.aiUnavailable());
   }
diff --git a/packages/ui/src/blockeditor/BlockEditor.tsx b/packages/ui/src/blockeditor/BlockEditor.tsx
index cb8f9675..30e1539a 100644
--- a/packages/ui/src/blockeditor/BlockEditor.tsx
+++ b/packages/ui/src/blockeditor/BlockEditor.tsx
@@ -2584,7 +2584,10 @@ const BlockBody: React.FC<RowShared & {block: BlockMap}> = ({block, ...shared})
               stays live for a reader; `pageReadOnly` is the document's real
               lock, which that override must not hide from a block that offers
               to write somewhere else. See {@link CustomBlockProps.pageReadOnly}. */}
-          <Custom block={block} editor={kitEditor} pageReadOnly={editor.readOnly} />
+          <Custom block={block} editor={kitEditor} pageReadOnly={editor.readOnly}>
+            {custom.type === 'meeting' && blockChildren(block) &&
+              <BlockList list={blockChildren(block)!} {...shared} editor={textEditor} depth={shared.depth + 1} container="group" />}
+          </Custom>
         </div>
       );
     }
diff --git a/packages/ui/src/blockeditor/MeetingBlockPlaceholder.tsx b/packages/ui/src/blockeditor/MeetingBlockPlaceholder.tsx
deleted file mode 100644
index c2ee56a1..00000000
--- a/packages/ui/src/blockeditor/MeetingBlockPlaceholder.tsx
+++ /dev/null
@@ -1,14 +0,0 @@
-import {blockChildren, blockProp} from './model';
-import type {CustomBlockDef, CustomBlockProps} from './registry';
-
-/** MEET-5 replaces this shell. The container model already preserves notes;
- * this placeholder deliberately offers no recording controls or slash entry. */
-const MeetingBlockPlaceholder = ({block}: CustomBlockProps) => (
-  <section aria-label="Meeting">
-    <strong>{blockProp<string>(block, 'title') || 'Meeting'}</strong>
-    <p>{blockProp<string>(block, 'status') || 'idle'} — Meeting view coming soon.</p>
-    <p>{blockChildren(block)?.length ?? 0} note blocks saved.</p>
-  </section>
-);
-
-export const MEETING_BLOCK: CustomBlockDef = {type: 'meeting', render: MeetingBlockPlaceholder};
diff --git a/packages/ui/src/blockeditor/MeetingBlockView.tsx b/packages/ui/src/blockeditor/MeetingBlockView.tsx
new file mode 100644
index 00000000..df1edf8a
--- /dev/null
+++ b/packages/ui/src/blockeditor/MeetingBlockView.tsx
@@ -0,0 +1,113 @@
+import {useEffect, useMemo, useState, useSyncExternalStore} from 'react';
+import {t} from '@/i18n';
+import {assetBridge, subscribeAssetBridge} from '@/lib/assetBridge';
+import {getPageIdForDoc} from '@/lib/aiBridge';
+import {blockChildren, blockProp, insertBlock} from './model';
+import type {CustomBlockDef, CustomBlockProps} from './registry';
+import {useKitLock} from './kit/lock';
+import {KitFrame, NameDescriptionFields} from './kit/KitFrame';
+import {chunkKey, meetingRecorder, meetingTime, type MeetingAudio, type MeetingSegment} from './meetingRecorder';
+
+function ChunkAudio({audio, blob}: {audio: MeetingAudio; blob?: Blob}) {
+  const [url, setUrl] = useState('');
+  useEffect(() => {
+    let disposed = false;
+    let objectUrl = '';
+    const load = async (): Promise<void> => {
+      const asset = blob ? null : await assetBridge.getAsset(audio.assetId);
+      const data = blob ?? (asset ? new Blob([new Uint8Array(asset.bytes)], {type: asset.mime}) : null);
+      if (disposed || !data) return;
+      objectUrl = URL.createObjectURL(data); setUrl(objectUrl);
+    };
+    void load().catch(() => {});
+    return () => { disposed = true; if (objectUrl) URL.revokeObjectURL(objectUrl); };
+  }, [audio.assetId, blob]);
+  return url ? <>
+    <audio controls preload="metadata" src={url} aria-label={t('meetingBlock.playback', {time: meetingTime(audio.startedAtMs ?? 0)})} />
+    {blob && <a href={url} download={`meeting-${audio.startedAtMs ?? 0}.${blob.type.includes('mp4') ? 'mp4' : blob.type.includes('ogg') ? 'ogg' : 'webm'}`}>{t('meetingBlock.saveAudio')}</a>}
+  </> : null;
+}
+
+export function MeetingBlockView({block, editor, pageReadOnly, children}: CustomBlockProps) {
+  const locked = useKitLock();
+  const readOnly = editor.readOnly || pageReadOnly || locked;
+  const session = meetingRecorder(editor, block, getPageIdForDoc(editor.doc) ?? '');
+  session.readOnly = readOnly;
+  const chromeEditor = useMemo(() => ({...editor, readOnly}), [editor, readOnly]);
+  useSyncExternalStore(session.subscribe, session.snapshot, session.snapshot);
+  const [, tick] = useState(0);
+  const active = session.active;
+  useEffect(() => {
+    if (!active) return;
+    const timer = setInterval(() => tick((n) => n + 1), 1000);
+    return () => clearInterval(timer);
+  }, [active]);
+  useEffect(() => () => session.stop(), [session]);
+  useEffect(() => { if (readOnly) session.stop(); }, [readOnly, session]);
+  const saved = blockProp<MeetingAudio[]>(block, 'audioChunks') ?? [];
+  const completed = blockProp<string[]>(block, 'transcriptionCompleted') ?? [];
+  const transcript = blockProp<MeetingSegment[]>(block, 'transcript') ?? [];
+  const elapsed = session.elapsedMs;
+  const status = session.active ? session.mode : blockProp<string>(block, 'status') ?? 'idle';
+  const statusLabel = t(`meetingBlock.${status as 'idle' | 'recording' | 'processing' | 'done' | 'paused' | 'requesting'}`);
+  const canTranscribe = useSyncExternalStore(subscribeAssetBridge, assetBridge.canTranscribe, assetBridge.canTranscribe);
+  const control = <section className="obe-meeting" aria-label={t('meetingBlock.label')}>
+    <header>
+      <span role="status" aria-live="polite">{statusLabel}</span>
+      <span className="obe-meeting-elapsed" aria-hidden="true">{meetingTime(elapsed)}</span>
+    </header>
+    {readOnly && <p className="obe-meeting-lock">{t(!pageReadOnly && locked ? 'meetingBlock.locked' : 'meetingBlock.readOnly')}</p>}
+    {session.recordingElsewhere && <p>{t('meetingBlock.elsewhere')}</p>}
+    <div className="obe-meeting-controls">
+      <button type="button" disabled={readOnly || session.mode === 'processing' || session.recordingElsewhere}
+        aria-busy={session.mode === 'requesting'}
+        onClick={() => {
+          if (session.mode === 'recording') session.pause();
+          else if (session.mode === 'paused') session.resume();
+          else void session.start();
+        }}>
+        {t(`meetingBlock.${session.mode === 'recording' ? 'pause' : session.mode === 'paused' ? 'resume' : session.mode === 'requesting' ? 'requesting' : 'record'}`)}
+      </button>
+      <button type="button" disabled={readOnly || !session.active} onClick={() => session.stop()}>{t('meetingBlock.stop')}</button>
+    </div>
+    {session.error && <p role="alert">{session.error}</p>}
+    {!canTranscribe && <p>{t('meetingBlock.noAI')}</p>}
+    <ol className="obe-meeting-chunks">
+      {saved.map((audio) => {
+        const progress = session.chunks.find((chunk) => chunkKey(chunk.audio) === chunkKey(audio));
+        const done = completed.includes(chunkKey(audio));
+        return <li key={chunkKey(audio)}>
+          <span>{meetingTime(audio.startedAtMs ?? 0)} · {meetingTime(audio.durationMs)}</span>
+          <ChunkAudio audio={audio} />
+          <span aria-live="polite">{t(`meetingBlock.${done ? 'transcribed' : progress?.phase === 'transcribing' ? 'transcribing' : 'untranscribed'}`)}</span>
+          {progress?.error && <p role="alert">{progress.error}</p>}
+          {!done && <button type="button" disabled={readOnly || !canTranscribe || progress?.busy} onClick={() => session.retry(audio)}>{t('meetingBlock.retryTranscription')}</button>}
+        </li>;
+      })}
+      {session.chunks.filter((chunk) => chunk.blob).map((chunk) => <li key={chunk.id}>
+        <span role="status">{t(`meetingBlock.${chunk.phase === 'uploadFailed' ? 'uploadFailed' : 'uploading'}`)}</span>
+        <ChunkAudio audio={chunk.audio} blob={chunk.blob} />
+        {chunk.phase === 'uploadFailed' && <button type="button" disabled={readOnly} onClick={() => void session.upload(chunk)}>{t('meetingBlock.retryUpload')}</button>}
+      </li>)}
+    </ol>
+    <section className="obe-meeting-transcript" aria-label={t('meetingBlock.transcript')}>
+      <h4>{t('meetingBlock.transcript')}</h4>
+      {transcript.map((segment, index) => <p key={index}><time>{meetingTime(segment.startMs)}</time> {segment.text}</p>)}
+    </section>
+    {blockProp<string>(block, 'summary') && <p className="obe-meeting-summary">{blockProp<string>(block, 'summary')}</p>}
+    <section className="obe-meeting-notes" aria-label={t('meetingBlock.notes')}><h4>{t('meetingBlock.notes')}</h4>{children}
+      {!readOnly && !blockChildren(block)?.length && <button type="button" onClick={() => editor.doc.transact(() => {
+        const notes = blockChildren(block);
+        if (notes) insertBlock(editor.doc, notes, 0, {type: 'paragraph'});
+      }, 'local')}>{t('meetingBlock.addNote')}</button>}</section>
+  </section>;
+  return <KitFrame block={block} editor={chromeEditor} kind="meeting" defaultName={t('meetingBlock.label')}
+    labelKey="title" symbol={false} control={control}
+    config={<NameDescriptionFields block={block} editor={chromeEditor} nameKey="title" namePlaceholder={t('meetingBlock.label')} />} />;
+}
+
+export const MEETING_BLOCK: CustomBlockDef = {
+  type: 'meeting', render: MeetingBlockView,
+  slash: {label: 'Meeting', hint: 'Record audio, transcribe and take notes', keywords: 'meeting record recorder audio microphone transcript notes', group: 'interactive',
+    make: () => ({type: 'meeting', children: [{type: 'paragraph'}]})},
+};
diff --git a/packages/ui/src/blockeditor/SlashMenu.tsx b/packages/ui/src/blockeditor/SlashMenu.tsx
index 759d6039..95c9b9bc 100644
--- a/packages/ui/src/blockeditor/SlashMenu.tsx
+++ b/packages/ui/src/blockeditor/SlashMenu.tsx
@@ -126,7 +126,7 @@ const TYPE_ICONS: Record<string, IconComp> = {
   // June-2026 additions
   choicecards: GalleryHorizontalEnd, longtext: AlignLeft, richtext: TextQuote,
   searchselect: Search, tagfield: Tag, progressbar: Activity,
-  form: ClipboardList,
+  form: ClipboardList, meeting: Mic,
 };
 const GROUP_ICON: Record<SlashGroup, IconComp> = {
   pages: FileText, basic: Type, interactive: Boxes, extensions: Puzzle, ai: Sparkles,
diff --git a/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
new file mode 100644
index 00000000..34daad4e
--- /dev/null
+++ b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
@@ -0,0 +1,432 @@
+import * as Y from 'yjs';
+import {setLocale, t} from '@/i18n';
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import {act, cleanup, fireEvent, render, screen} from '@testing-library/react';
+import type {AiTranscriptionResult} from '@book.dev/sdk';
+import {setAssetBridge} from '@/lib/assetBridge';
+import {registerBlockEditorDoc} from '@/lib/aiBridge';
+import {AssetBridgeHost} from '@/components/AssetBridgeHost';
+import {DataProvider} from '@/data';
+import type {DataClient} from '@book.dev/sdk';
+import {MeetingRecorder, meetingRecorder, meetingSegments, chunkKey, type MeetingAudio, type RecordingChunk} from '../meetingRecorder';
+import {MeetingBlockView} from '../MeetingBlockView';
+import {blockProp, createDoc, decodeSnapshot, docToJSON, encodeSnapshot, rootBlocks, setBlockProp} from '../model';
+import type {BlockEditorController} from '../useBlockEditor';
+import {BlockEditor} from '../BlockEditor';
+import {registerArtifactKit} from '../kit';
+import {blocksToHtml, blocksToMarkdown, projectBlocksForExport} from '../exportBlocks';
+
+class Recorder {
+  static instances: Recorder[] = [];
+  static isTypeSupported = vi.fn((mime: string) => mime === 'audio/webm;codecs=opus');
+  state = 'inactive';
+  mimeType: string;
+  ondataavailable?: (event: {data: Blob}) => void;
+  onstop?: () => void;
+  onerror?: () => void;
+  start = vi.fn(() => { this.state = 'recording'; });
+  stop = vi.fn(() => {
+    this.state = 'inactive';
+    this.ondataavailable?.({data: new Blob(['standalone audio'], {type: this.mimeType})});
+    this.onstop?.();
+  });
+  constructor(_stream: MediaStream, options: MediaRecorderOptions) {
+    this.mimeType = options.mimeType ?? 'audio/webm'; Recorder.instances.push(this);
+  }
+}
+const track = {stop: vi.fn(), enabled: true};
+const stream = {getTracks: () => [track], getAudioTracks: () => [track]} as unknown as MediaStream;
+const getUserMedia = vi.fn(async () => stream);
+const putAsset = vi.fn(async () => ({id: `asset-${Recorder.instances.length}`}));
+const transcribeAsset = vi.fn(async (): Promise<AiTranscriptionResult> => ({text: 'hello', segments: [{start: 0.25, end: 1.5, text: 'hello'}], durationMs: 2000}));
+function harness(props = {}) {
+  const doc = createDoc([{type: 'meeting', props, children: [{id: 'note', type: 'paragraph', text: 'Manual note'}]}]);
+  const block = rootBlocks(doc).get(0);
+  const editor = {doc, readOnly: false} as BlockEditorController;
+  return {doc, block, editor, session: new MeetingRecorder(editor, block, 'page')};
+}
+const flush = async (): Promise<void> => { for (let i = 0; i < 20; i += 1) await Promise.resolve(); };
+beforeEach(() => {
+  vi.useFakeTimers(); vi.setSystemTime(100000);
+  // The DOM test environment's Blob lacks arrayBuffer; the mock recorder's payload is opaque.
+  vi.stubGlobal('Blob', class extends Blob { async arrayBuffer(): Promise<ArrayBuffer> { return new ArrayBuffer(this.size); } }); vi.stubGlobal('MediaRecorder', Recorder);
+  vi.stubGlobal('URL', Object.assign(URL, {createObjectURL: vi.fn(() => 'blob:test'), revokeObjectURL: vi.fn()}));
+  Object.defineProperty(navigator, 'mediaDevices', {configurable: true, value: {getUserMedia}});
+  Recorder.instances = []; track.enabled = true;
+  getUserMedia.mockReset().mockResolvedValue(stream);
+  putAsset.mockReset().mockImplementation(async () => ({id: `asset-${Recorder.instances.length}`}));
+  transcribeAsset.mockReset().mockResolvedValue({text: 'hello', segments: [{start: 0.25, end: 1.5, text: 'hello'}], durationMs: 2000});
+  setAssetBridge({putAsset, getAsset: async () => null, transcribeAsset});
+});
+afterEach(() => { cleanup(); setLocale('en'); setAssetBridge(null); vi.useRealTimers(); vi.unstubAllGlobals(); });
+
+describe('meeting recording and recovery', () => {
+  it('restarts recorders into independent files, pauses/resumes, saves ordered durations and transcript offsets', async () => {
+    const {session, block, doc} = harness();
+    await session.start();
+    expect(blockProp(block, 'status')).toBe('recording');
+    await vi.advanceTimersByTimeAsync(45000);
+    expect(Recorder.instances).toHaveLength(2);
+    expect(Recorder.instances[0].start).toHaveBeenCalledWith(); // no timeslice
+    expect(putAsset).toHaveBeenCalledWith(expect.any(Uint8Array), 'audio/webm', 'page');
+    await vi.advanceTimersByTimeAsync(2000);
+    session.pause(); await flush();
+    expect(session.mode).toBe('paused'); expect(track.enabled).toBe(false);
+    await vi.advanceTimersByTimeAsync(1000);
+    session.resume(); expect(track.enabled).toBe(true);
+    expect(Recorder.instances).toHaveLength(3);
+    await vi.advanceTimersByTimeAsync(1000);
+    session.stop(); await flush();
+    expect(blockProp(block, 'status')).toBe('done');
+    expect((blockProp<MeetingAudio[]>(block, 'audioChunks') ?? []).map(({durationMs, startedAtMs}) => ({durationMs, startedAtMs}))).toEqual([
+      {durationMs: 45000, startedAtMs: 0}, {durationMs: 2000, startedAtMs: 45000}, {durationMs: 1000, startedAtMs: 47000},
+    ]);
+    expect(blockProp(block, 'transcript')).toEqual([
+      {startMs: 250, endMs: 1500, text: 'hello'}, {startMs: 45250, endMs: 46500, text: 'hello'}, {startMs: 47250, endMs: 48500, text: 'hello'},
+    ]);
+    expect(docToJSON(decodeSnapshot(encodeSnapshot(doc)))).toEqual(docToJSON(doc));
+    expect(track.stop).toHaveBeenCalled();
+  });
+
+  it('keeps audio on upload failure, retries with exponential backoff, then permits manual recovery', async () => {
+    putAsset.mockRejectedValue(new Error('offline'));
+    const {session, block} = harness();
+    await session.start(); await vi.advanceTimersByTimeAsync(1500); session.stop(); await flush();
+    expect(putAsset).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(1000); expect(putAsset).toHaveBeenCalledTimes(2);
+    await vi.advanceTimersByTimeAsync(2000); expect(putAsset).toHaveBeenCalledTimes(3);
+    expect(session.chunks[0].phase).toBe('uploadFailed'); expect(session.unsaved).toBe(true);
+    expect(blockProp(block, 'status')).toBe('done'); expect(transcribeAsset).not.toHaveBeenCalled();
+    putAsset.mockResolvedValue({id: 'recovered'});
+    await session.upload(session.chunks[0]); await flush();
+    expect(session.unsaved).toBe(false); expect(blockProp(block, 'status')).toBe('done');
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')?.[0].assetId).toBe('recovered');
+  });
+
+  it('retains failed transcription, allows retry without duplicate segments, and sorts late results', async () => {
+    let finishFirst!: (result: AiTranscriptionResult) => void;
+    transcribeAsset.mockImplementationOnce(() => new Promise((resolve) => { finishFirst = resolve; }))
+      .mockRejectedValueOnce(new Error('OpenBook request failed (400 Bad Request)'));
+    const {session, block} = harness(); await session.start();
+    await vi.advanceTimersByTimeAsync(45000);
+    await vi.advanceTimersByTimeAsync(2000); session.stop(); await flush();
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')).toHaveLength(2);
+    expect(session.chunks[1].error).toContain('Settings → AI');
+    expect(session.chunks[1].phase).toBe('untranscribed');
+    await session.transcribe(session.chunks[1]);
+    finishFirst({text: 'first', segments: [{start: 0, end: 1, text: 'first'}], durationMs: 1000}); await flush();
+    expect(blockProp(block, 'transcript')).toEqual([{startMs: 0, endMs: 1000, text: 'first'}, {startMs: 45250, endMs: 46500, text: 'hello'}]);
+    await session.transcribe(session.chunks[1]);
+    expect(transcribeAsset).toHaveBeenCalledTimes(3);
+    expect(blockProp(block, 'status')).toBe('done');
+  });
+
+  it('handles permission denial and cancels a late permission grant after stop', async () => {
+    const {session, block} = harness();
+    getUserMedia.mockRejectedValueOnce(new DOMException('denied', 'NotAllowedError'));
+    await session.start(); expect(session.mode).toBe('idle'); expect(session.error).toContain('Microphone');
+    expect(blockProp(block, 'status')).toBeUndefined(); expect(Recorder.instances).toHaveLength(0);
+    let grant!: (stream: MediaStream) => void;
+    getUserMedia.mockImplementationOnce(() => new Promise((resolve) => { grant = resolve; }));
+    const pending = session.start(); session.stop(); grant(stream); await pending;
+    expect(Recorder.instances).toHaveLength(0); expect(session.active).toBe(false);
+    expect(session.mode).toBe('idle'); expect(blockProp(block, 'status')).toBe('idle');
+  });
+
+  it('uses Safari mp4 when opus is unavailable and falls back to plain transcript duration', async () => {
+    Recorder.isTypeSupported.mockImplementationOnce(() => false).mockImplementationOnce(() => false).mockImplementationOnce(() => true);
+    const {session} = harness(); await session.start();
+    expect(Recorder.instances[0].mimeType).toBe('audio/mp4'); session.stop(); await flush();
+    expect(meetingSegments({text: 'plain', durationMs: 1234}, {assetId: 'a', durationMs: 999, startedAtMs: 45000}))
+      .toEqual([{startMs: 45000, endMs: 46234, text: 'plain'}]);
+  });
+});
+
+describe('meeting UI and exports', () => {
+  it('renders editable note children and freezes both notes and recording on read-only pages and locked groups', () => {
+    registerArtifactKit();
+    const {doc} = harness();
+    const view = render(<BlockEditor doc={doc} />);
+    expect(view.container.querySelector('[data-block-text="note"]')?.getAttribute('contenteditable')).toBe('true');
+    expect((screen.getByRole('button', {name: 'Record'}) as HTMLButtonElement).disabled).toBe(false);
+    view.rerender(<BlockEditor doc={doc} readOnly />);
+    expect(view.container.querySelector('[data-block-text="note"]')?.getAttribute('contenteditable')).toBe('false');
+    expect((screen.getByRole('button', {name: 'Record'}) as HTMLButtonElement).disabled).toBe(true);
+    view.unmount();
+    const locked = createDoc([{type: 'group', props: {locked: true}, children: docToJSON(doc)}]);
+    const group = render(<BlockEditor doc={locked} />);
+    expect(group.container.querySelector('[data-block-text="note"]')?.getAttribute('contenteditable')).toBe('false');
+    expect((screen.getByRole('button', {name: 'Record'}) as HTMLButtonElement).disabled).toBe(true);
+  });
+
+  it('wires no-AI client capability through the bridge and disables transcription without disabling recording', async () => {
+    const {editor, block, doc} = harness({audioChunks: [{assetId: 'saved', durationMs: 2000}]});
+    const unregister = registerBlockEditorDoc('page', doc);
+    const client = {supportsTranscription: false, putAsset, getAsset: async () => null, transcribeAsset} as unknown as DataClient;
+    render(<DataProvider client={client}><AssetBridgeHost /><MeetingBlockView editor={editor} block={block} pageReadOnly={false} /></DataProvider>);
+    await act(async () => { await vi.advanceTimersByTimeAsync(1000); });
+    expect(screen.getByText(/Transcription requires a connected/)).toBeTruthy();
+    expect((screen.getByRole('button', {name: 'Retry transcription'}) as HTMLButtonElement).disabled).toBe(true);
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Record'})); await flush(); });
+    expect(screen.getByRole('button', {name: 'Pause'})).toBeTruthy();
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Stop'})); await flush(); });
+    expect(putAsset).toHaveBeenCalled(); expect(transcribeAsset).not.toHaveBeenCalled(); unregister();
+  });
+
+  it('exports title, timestamped transcript, summary and nested notes without raw status in all three projections', () => {
+    const {doc} = harness({title: 'Planning <team>', status: 'done', summary: 'Next steps', transcript: [{startMs: 61500, endMs: 62000, text: 'Discussion <safe>'}]});
+    const blocks = docToJSON(doc);
+    const html = blocksToHtml(blocks); const markdown = blocksToMarkdown(blocks); const standalone = JSON.stringify(projectBlocksForExport(blocks));
+    for (const output of [html, markdown, standalone]) {
+      expect(output).toContain('Planning'); expect(output).not.toContain('done'); expect(output).not.toContain('Transcript incomplete'); expect(output).toContain('1:01');
+      expect(output).toContain('Discussion'); expect(output).toContain('Next steps'); expect(output).toContain('Manual note');
+    }
+    expect(html).toContain('&lt;safe&gt;'); expect(standalone).toContain('&lt;safe&gt;');
+  });
+});
+
+describe('meeting asynchronous boundaries', () => {
+  it('commits audio in capture order when uploads complete in reverse order', async () => {
+    let first!: (asset: {id: string}) => void;
+    putAsset.mockImplementationOnce(() => new Promise((resolve) => { first = resolve; }))
+      .mockResolvedValueOnce({id: 'second'});
+    const {session, block} = harness(); await session.start();
+    await vi.advanceTimersByTimeAsync(45000);
+    await vi.advanceTimersByTimeAsync(1000); session.stop(); await flush();
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')?.[0].assetId).toBe('second');
+    first({id: 'first'}); await flush();
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')?.map((audio) => audio.assetId)).toEqual(['first', 'second']);
+    expect(blockProp(block, 'status')).toBe('done');
+  });
+
+  it('ignores a stale permission rejection after a new recording has started', async () => {
+    let deny!: (error: Error) => void;
+    getUserMedia.mockImplementationOnce(() => new Promise((_resolve, reject) => { deny = reject; }));
+    const {session} = harness(); const oldRequest = session.start(); session.stop();
+    await session.start(); expect(session.mode).toBe('recording');
+    deny(new Error('old permission denied')); await oldRequest;
+    expect(session.mode).toBe('recording'); expect(session.error).toBe('');
+    session.stop(); await flush();
+  });
+
+  it('waits for the final asynchronous data event before declaring done', async () => {
+    const {session, block} = harness(); await session.start();
+    const recorder = Recorder.instances[0];
+    recorder.stop.mockImplementation(() => {
+      recorder.state = 'inactive';
+      setTimeout(() => { recorder.ondataavailable?.({data: new Blob(['last'])}); recorder.onstop?.(); }, 100);
+    });
+    session.stop(); expect(blockProp(block, 'status')).toBe('processing');
+    await vi.advanceTimersByTimeAsync(100);
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')).toHaveLength(1);
+    expect(blockProp(block, 'status')).toBe('done');
+  });
+
+  it.each([403, 404, 502])('keeps audio and a retryable chunk after transcription HTTP %s', async (status) => {
+    transcribeAsset.mockRejectedValue(new Error(`OpenBook request failed (${status})`));
+    const {session, block} = harness(); await session.start(); session.stop(); await flush();
+    await vi.advanceTimersByTimeAsync(3000);
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')).toHaveLength(1);
+    expect(session.chunks[0].phase).toBe('untranscribed');
+    expect(session.chunks[0].error).toBeTruthy(); expect(session.unsaved).toBe(false);
+    expect(blockProp(block, 'status')).toBe('done');
+  });
+
+  it('shows permission errors and actionable configuration errors with working retry buttons', async () => {
+    const {block, editor, doc} = harness(); const unregister = registerBlockEditorDoc('page', doc);
+    render(<MeetingBlockView block={block} editor={editor} pageReadOnly={false} />);
+    getUserMedia.mockRejectedValueOnce(new Error('denied'));
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Record'})); await flush(); });
+    expect(screen.getByRole('alert').textContent).toContain('Allow microphone access');
+    transcribeAsset.mockRejectedValueOnce(new Error('400'));
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Record'})); await flush(); });
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Stop'})); await flush(); });
+    expect(screen.getByRole('alert').textContent).toContain('Settings → AI');
+    expect(screen.getByText('Not transcribed')).toBeTruthy();
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Retry transcription'})); await flush(); });
+    expect(screen.getByText('Transcribed')).toBeTruthy(); expect(screen.getByText('hello')).toBeTruthy();
+    unregister();
+  });
+});
+
+describe('MEET-5 review regressions', () => {
+  it('counts only recorded time across pauses, async finalization, later sessions and reopened blocks', async () => {
+    const {session, block, doc} = harness();
+    await session.start(); await vi.advanceTimersByTimeAsync(2000);
+    expect(session.elapsedMs).toBe(2000);
+    const first = Recorder.instances[0];
+    first.stop.mockImplementation(() => {
+      first.state = 'inactive';
+      setTimeout(() => { first.ondataavailable?.({data: new Blob(['first'])}); first.onstop?.(); }, 100);
+    });
+    session.pause(); expect(session.elapsedMs).toBe(2000);
+    await vi.advanceTimersByTimeAsync(3000); expect(session.elapsedMs).toBe(2000);
+    session.resume(); await vi.advanceTimersByTimeAsync(1000);
+    expect(session.elapsedMs).toBe(3000); session.stop(); await flush();
+    await vi.advanceTimersByTimeAsync(60000); expect(session.elapsedMs).toBe(3000);
+    await session.start(); await vi.advanceTimersByTimeAsync(1000); session.stop(); await flush();
+    expect(session.elapsedMs).toBe(4000);
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')?.map((audio) => audio.startedAtMs)).toEqual([0, 2000, 3000]);
+    const reopened = decodeSnapshot(encodeSnapshot(doc)); const reopenedBlock = rootBlocks(reopened).get(0);
+    const next = new MeetingRecorder({doc: reopened, readOnly: false} as BlockEditorController, reopenedBlock, 'page');
+    await vi.advanceTimersByTimeAsync(60000); await next.start(); await vi.advanceTimersByTimeAsync(1000); next.stop(); await flush();
+    expect(next.elapsedMs).toBe(5000);
+    expect(blockProp<MeetingAudio[]>(reopenedBlock, 'audioChunks')?.slice(-1)[0]?.startedAtMs).toBe(4000);
+  });
+
+  it('keeps oversized audio recoverable without bricking Record or adding idle gaps', async () => {
+    const {editor, block, doc} = harness(); const unregister = registerBlockEditorDoc('page', doc);
+    render(<MeetingBlockView block={block} editor={editor} pageReadOnly={false} />);
+    const session = meetingRecorder(editor, block, 'page');
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Record'})); await flush(); });
+    const recorder = Recorder.instances[0];
+    recorder.stop.mockImplementation(() => {
+      recorder.state = 'inactive';
+      recorder.ondataavailable?.({data: new Blob([new Uint8Array(10 * 1024 * 1024 + 1)])}); recorder.onstop?.();
+    });
+    await act(async () => { await vi.advanceTimersByTimeAsync(2000); fireEvent.click(screen.getByRole('button', {name: 'Stop'})); await flush(); });
+    expect(session.mode).toBe('done'); expect(session.unsaved).toBe(true); expect(putAsset).not.toHaveBeenCalled();
+    expect((screen.getByRole('button', {name: 'Record'}) as HTMLButtonElement).disabled).toBe(false);
+    expect(screen.getByRole('link', {name: 'Save audio copy'})).toBeTruthy();
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Retry upload'})); await flush(); });
+    expect(session.unsaved).toBe(true); expect(session.mode).toBe('done');
+    await act(async () => { await vi.advanceTimersByTimeAsync(60000); fireEvent.click(screen.getByRole('button', {name: 'Record'})); await flush(); });
+    await act(async () => { await vi.advanceTimersByTimeAsync(1000); fireEvent.click(screen.getByRole('button', {name: 'Stop'})); await flush(); });
+    expect(blockProp<MeetingAudio[]>(block, 'audioChunks')?.[0].startedAtMs).toBe(2000);
+    expect(session.elapsedMs).toBe(3000); unregister();
+    // Dispose the recovery guard after checking the retained blob.
+    session.chunks[0].blob = undefined;
+    await act(async () => { await session.start(); session.stop(); await flush(); });
+  });
+
+  it('keeps one focused toggle and announces only status, with no idle timer', async () => {
+    const {editor, block, doc} = harness(); const unregister = registerBlockEditorDoc('page', doc);
+    const interval = vi.spyOn(globalThis, 'setInterval');
+    const view = render(<MeetingBlockView block={block} editor={editor} pageReadOnly={false} />);
+    expect(interval).not.toHaveBeenCalled();
+    const toggle = screen.getByRole('button', {name: 'Record'}); toggle.focus();
+    await act(async () => { fireEvent.click(toggle); await flush(); });
+    expect(screen.getByRole('button', {name: 'Pause'})).toBe(toggle); expect(document.activeElement).toBe(toggle);
+    await act(async () => { await vi.advanceTimersByTimeAsync(2000); });
+    const status = view.container.querySelector('header [role="status"]')!;
+    expect(status.textContent).toBe('Recording');
+    const timer = status.nextElementSibling!;
+    expect(timer.getAttribute('aria-hidden')).toBe('true'); expect(timer.textContent).toBe('0:02');
+    await act(async () => { fireEvent.click(toggle); await flush(); });
+    expect(screen.getByRole('button', {name: 'Resume'})).toBe(toggle); expect(document.activeElement).toBe(toggle);
+    await act(async () => { await vi.advanceTimersByTimeAsync(3000); });
+    expect(timer.textContent).toBe('0:02'); expect(status.textContent).toBe('Paused');
+    await act(async () => { fireEvent.click(toggle); await flush(); });
+    expect(screen.getByRole('button', {name: 'Pause'})).toBe(toggle); expect(document.activeElement).toBe(toggle);
+    const stop = screen.getByRole('button', {name: 'Stop'}); stop.focus();
+    await act(async () => { fireEvent.click(stop); await flush(); });
+    expect(document.activeElement).toBe(stop);
+    expect(vi.getTimerCount()).toBe(0); interval.mockRestore(); unregister();
+  });
+
+  it('edits the durable title through KitFrame and distinguishes page read-only from section locks', () => {
+    registerArtifactKit(); const {doc, block} = harness({title: 'Planning'});
+    const view = render(<BlockEditor doc={doc} />);
+    expect(view.container.querySelector('.obe-kit-meeting')).toBeTruthy();
+    fireEvent.change(screen.getByRole('textbox', {name: 'Display name'}), {target: {value: 'Weekly planning'}});
+    expect(blockProp(block, 'title')).toBe('Weekly planning'); expect(blockProp(block, 'label')).toBeUndefined();
+    view.rerender(<BlockEditor doc={doc} readOnly />);
+    expect(screen.queryByRole('textbox', {name: 'Display name'})).toBeNull();
+    expect(screen.getByText('Read-only meeting')).toBeTruthy(); view.unmount();
+    const locked = createDoc([{type: 'group', props: {locked: true}, children: docToJSON(doc)}]);
+    const group = render(<BlockEditor doc={locked} />);
+    expect(group.container.querySelector('.obe-kit-meeting input')).toBeNull();
+    expect(screen.getByText('Meeting locked by its section')).toBeTruthy();
+  });
+
+  it('does not append a second transcript when a remote completion arrives during the await', async () => {
+    const audio = {assetId: 'shared', durationMs: 1000, startedAtMs: 0};
+    const {editor, block, doc, session} = harness({status: 'done', audioChunks: [audio]});
+    const remoteDoc = decodeSnapshot(encodeSnapshot(doc)); const remoteBlock = rootBlocks(remoteDoc).get(0);
+    const remote = new MeetingRecorder({...editor, doc: remoteDoc}, remoteBlock, 'page');
+    let complete!: (result: AiTranscriptionResult) => void;
+    transcribeAsset.mockImplementationOnce(() => new Promise((resolve) => { complete = resolve; }));
+    const chunk: RecordingChunk = {id: 'local', audio, phase: 'untranscribed'};
+    const pending = session.transcribe(chunk);
+    await remote.transcribe({id: 'remote', audio, phase: 'untranscribed'});
+    Y.applyUpdate(doc, Y.encodeStateAsUpdate(remoteDoc));
+    complete({text: 'duplicate', durationMs: 1000}); await pending;
+    expect(blockProp(block, 'transcript')).toEqual([{startMs: 250, endMs: 1500, text: 'hello'}]);
+    expect(blockProp(block, 'transcriptionCompleted')).toEqual([chunkKey(audio)]);
+    expect(chunk.phase).toBe('done'); expect(chunk.busy).toBe(false);
+  });
+
+  it.each(['recording', 'processing'])('blocks a new local recording when the persisted status is %s', async (status) => {
+    const {doc, block, editor, session} = harness({status});
+    render(<MeetingBlockView block={block} editor={editor} pageReadOnly={false} />);
+    expect((screen.getByRole('button', {name: 'Record'}) as HTMLButtonElement).disabled).toBe(true);
+    expect(screen.getByText('Recording or processing on another client.')).toBeTruthy();
+    await session.start(); expect(getUserMedia).not.toHaveBeenCalled();
+    expect(blockProp(block, 'status')).toBe(status);
+    // A remote completion is observed by the editor and unblocks recording.
+    cleanup(); registerArtifactKit(); const view = render(<BlockEditor doc={doc} />);
+    act(() => doc.transact(() => setBlockProp(block, 'status', 'done')));
+    expect((screen.getByRole('button', {name: 'Record'}) as HTMLButtonElement).disabled).toBe(false);
+    view.unmount();
+  });
+
+  it('abandons a permission grant if another client starts recording first', async () => {
+    const {session, doc, block} = harness(); let grant!: (stream: MediaStream) => void;
+    getUserMedia.mockImplementationOnce(() => new Promise((resolve) => { grant = resolve; }));
+    const pending = session.start(); doc.transact(() => setBlockProp(block, 'status', 'recording'));
+    grant(stream); await pending;
+    expect(Recorder.instances).toHaveLength(0); expect(session.recordingElsewhere).toBe(true);
+    expect(blockProp(block, 'status')).toBe('recording'); expect(blockProp(block, 'startedAt')).toBeUndefined();
+  });
+
+  it('enforces effective read-only inside start, including permission-time changes', async () => {
+    const {block, editor, doc} = harness(); const unregister = registerBlockEditorDoc('page', doc);
+    render(<MeetingBlockView block={block} editor={editor} pageReadOnly />);
+    const session = meetingRecorder(editor, block, 'page');
+    expect(editor.readOnly).toBe(false); await session.start(); expect(getUserMedia).not.toHaveBeenCalled();
+    cleanup(); session.readOnly = false;
+    let grant!: (stream: MediaStream) => void;
+    getUserMedia.mockImplementationOnce(() => new Promise((resolve) => { grant = resolve; }));
+    const pending = session.start(); session.readOnly = true; grant(stream); await pending;
+    expect(Recorder.instances).toHaveLength(0); expect(session.mode).toBe('idle'); unregister();
+  });
+
+  it('never persists done when cancelling a permission prompt without audio or startedAt', async () => {
+    const {session, block} = harness(); const statuses: unknown[] = [];
+    block.observeDeep(() => statuses.push(blockProp(block, 'status')));
+    let grant!: (stream: MediaStream) => void;
+    getUserMedia.mockImplementationOnce(() => new Promise((resolve) => { grant = resolve; }));
+    const pending = session.start(); session.stop(); grant(stream); await pending;
+    expect(statuses).not.toContain('done'); expect(blockProp(block, 'status')).toBe('idle');
+    expect(blockProp(block, 'startedAt')).toBeUndefined(); expect(session.mode).toBe('idle');
+  });
+
+  it('retains the pending audio element identity when an earlier upload leaves the list', async () => {
+    let first!: (asset: {id: string}) => void;
+    putAsset.mockImplementationOnce(() => new Promise((resolve) => { first = resolve; })).mockRejectedValue(new Error('offline'));
+    const {block, editor, doc} = harness(); const unregister = registerBlockEditorDoc('page', doc);
+    const view = render(<MeetingBlockView block={block} editor={editor} pageReadOnly={false} />);
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Record'})); await flush(); await vi.advanceTimersByTimeAsync(45000); });
+    await act(async () => { await vi.advanceTimersByTimeAsync(2000); fireEvent.click(screen.getByRole('button', {name: 'Stop'})); await flush(); });
+    const second = screen.getByLabelText('Play audio chunk starting at 0:45');
+    await act(async () => { first({id: 'first'}); await flush(); });
+    expect(screen.getByLabelText('Play audio chunk starting at 0:45')).toBe(second);
+    await act(async () => { putAsset.mockResolvedValue({id: 'second'}); await vi.advanceTimersByTimeAsync(1000); });
+    expect(view.container.querySelectorAll('audio')).toHaveLength(0); // saved assets are unavailable in this mock bridge
+    unregister();
+  });
+
+  it.each(['en', 'de', 'ja', 'zh'] as const)('exports translated incompleteness and hour timestamps in %s', (locale) => {
+    setLocale(locale);
+    for (const status of ['idle', 'recording', 'processing', 'done']) {
+      const {doc} = harness({status, transcript: [{startMs: 5423000, endMs: 5424000, text: 'Long meeting'}]});
+      const blocks = docToJSON(doc);
+      for (const output of [blocksToHtml(blocks), blocksToMarkdown(blocks), JSON.stringify(projectBlocksForExport(blocks))]) {
+        expect(output).toContain('1:30:23'); expect(output).not.toContain(status);
+        if (status === 'done') expect(output).not.toContain(t('meetingBlock.incomplete'));
+        else expect(output).toContain(t('meetingBlock.incomplete'));
+        expect(output).toContain('Manual note');
+      }
+    }
+  });
+});
diff --git a/packages/ui/src/blockeditor/exportBlocks.ts b/packages/ui/src/blockeditor/exportBlocks.ts
index 385676e6..7a561b65 100644
--- a/packages/ui/src/blockeditor/exportBlocks.ts
+++ b/packages/ui/src/blockeditor/exportBlocks.ts
@@ -8,6 +8,15 @@ import {resolveOptionsFromProps, varNameFromLabel} from './kit/options';
 import {statusOf, type ExportCell} from './kit/scope';
 import type {DbChartSeriesMap} from './kit/chartData';
 import {formSchemaFromProps} from './formBlock';
+import {meetingTime} from './meetingTime';
+
+/** Minimal meeting projection; audio export is intentionally a separate feature. */
+function meetingParagraphs(b: BlockJSON): string[] {
+  const p = b.props ?? {};
+  const segments = Array.isArray(p.transcript) ? p.transcript as {startMs: number; text: string}[] : [];
+  return [String(p.title || t('meetingBlock.label')), ...(p.status !== 'done' ? [t('meetingBlock.incomplete')] : []),
+    ...segments.map((segment) => `[${meetingTime(segment.startMs)}] ${segment.text}`), ...(p.summary ? [String(p.summary)] : [])];
+}
 
 // TextRun is referenced in the kit emit cases below.
 
@@ -251,8 +260,10 @@ const escapeMd = (s: string): string => s.replace(/([\\`*_[\]<>])/g, '\\$1');
 
 /**
  * Whether a block type that fell through the export projection's switch is a
- * CORE type carrying nothing but text — a bare `paragraph` (which has no case
- * of its own), or a container child (`cell`, `tab`, …) orphaned from its parent.
+ * Catalogue text or container type eligible for the fallback text projection.
+ * CONTAINER_BLOCKS includes kit containers, not only core types. Containers
+ * with meaningful props/children (including meeting) need explicit cases above
+ * this fallback; orphaned structural children can use the text projection.
  * Those keep the plain-text projection; every OTHER unhandled type is
  * plugin-contributed or from a newer version and must keep its identity so the
  * renderers can label it instead of silently flattening it (LX-1).
@@ -396,6 +407,10 @@ export function blocksToHtml(blocks: BlockJSON[], opts: DatabaseFormExportOption
       parts.push(`<p>${databaseFormHtml(databaseFormReference(b.props), opts.originPageUrl)}</p>`);
       i += 1;
       break;
+    case 'meeting':
+      parts.push(`<section>${meetingParagraphs(b).map((line) => `<p>${escapeHtml(line)}</p>`).join('')}${blocksToHtml(b.children ?? [], opts)}</section>`);
+      i += 1;
+      break;
     case 'form':
       parts.push(formToStaticHtml(formSchemaFromProps(b.props), opts.originPageUrl));
       i += 1;
@@ -566,6 +581,9 @@ export function blocksToMarkdown(blocks: BlockJSON[], opts: DatabaseFormExportOp
         : `**📋 ${escapeMd(t('slash.custom.dbform.label'))}**`);
       break;
     }
+    case 'meeting':
+      out.push(meetingParagraphs(b).map(escapeMd).join('\n\n'), blocksToMarkdown(b.children ?? [], opts));
+      break;
     case 'form':
       out.push(formToMarkdown(formSchemaFromProps(b.props)));
       break;
@@ -1077,6 +1095,12 @@ export function projectBlocksForExport(
         i += 1;
         break;
       }
+      case 'meeting': {
+        for (const line of meetingParagraphs(b)) sink.push({type: 'paragraph', data: {text: textHtml([{t: line}])}});
+        emit(b.children ?? [], sink);
+        i += 1;
+        break;
+      }
       case 'form': {
         // Keep the exact durable props under `data.props` for FORM-1/FORM-5,
         // while mirroring them at `data.*` for the static export renderers.
diff --git a/packages/ui/src/blockeditor/kit/KitFrame.tsx b/packages/ui/src/blockeditor/kit/KitFrame.tsx
index cd64a65d..f09601b3 100644
--- a/packages/ui/src/blockeditor/kit/KitFrame.tsx
+++ b/packages/ui/src/blockeditor/kit/KitFrame.tsx
@@ -294,6 +294,8 @@ const CommonFields: React.FC<{block: BlockMap; editor: BlockEditorController; de
 );
 
 export interface KitFrameProps {
+  /** Existing display-name prop for containers with their own title contract. */
+  labelKey?: string;
   block: BlockMap;
   editor: BlockEditorController;
   /** Adds the `obe-kit-{kind}` class and is the block's value type. */
@@ -317,6 +319,7 @@ export const KitFrame: React.FC<KitFrameProps> = ({
   block,
   editor,
   kind,
+  labelKey = 'label',
   defaultName,
   control,
   config,
@@ -326,7 +329,7 @@ export const KitFrame: React.FC<KitFrameProps> = ({
 }) => {
   const id = blockId(block);
   const explicitName = blockProp<string>(block, 'name') ?? '';
-  const displayLabel = blockProp<string>(block, 'label') ?? '';
+  const displayLabel = blockProp<string>(block, labelKey) ?? '';
   // The symbol the block publishes under: explicit name, else derived from the
   // display label, else the type's fallback. Mirrors scope.ts `publishedName`.
   const name = explicitName.trim() || varNameFromLabel(displayLabel) || defaultName;
@@ -355,7 +358,7 @@ export const KitFrame: React.FC<KitFrameProps> = ({
             placeholder={name}
             readOnly={editor.readOnly}
             ariaLabel="Display name"
-            onCommit={(v) => kitSet(editor, block, 'label', v)}
+            onCommit={(v) => kitSet(editor, block, labelKey, v)}
           />
           {/* Only render the inline description when it HAS content — an empty
               field that unfurled on hover shifted the layout. Add/edit a
diff --git a/packages/ui/src/blockeditor/kit/index.ts b/packages/ui/src/blockeditor/kit/index.ts
index 1c9dbda5..d4035f6a 100644
--- a/packages/ui/src/blockeditor/kit/index.ts
+++ b/packages/ui/src/blockeditor/kit/index.ts
@@ -4,7 +4,7 @@ import {INPUT2_BLOCKS} from './inputs2';
 import {PROGRESS_BLOCKS} from './progress';
 import {CHART_BLOCKS} from './charts';
 import {CARD_BLOCKS} from './cards';
-import {MEETING_BLOCK} from '../MeetingBlockPlaceholder';
+import {MEETING_BLOCK} from '../MeetingBlockView';
 
 export {evalExpr, formatValue, inputScope, INPUT_TYPES} from './scope';
 export {CHART_KINDS} from './charts';
diff --git a/packages/ui/src/blockeditor/meetingRecorder.ts b/packages/ui/src/blockeditor/meetingRecorder.ts
new file mode 100644
index 00000000..b6e585c7
--- /dev/null
+++ b/packages/ui/src/blockeditor/meetingRecorder.ts
@@ -0,0 +1,259 @@
+import type {AiTranscriptionResult} from '@book.dev/sdk';
+import {assetBridge} from '@/lib/assetBridge';
+import {getPageIdForDoc} from '@/lib/aiBridge';
+import {t} from '@/i18n';
+import {blockProp, setBlockProp, type BlockMap} from './model';
+import type {BlockEditorController} from './useBlockEditor';
+
+export interface MeetingAudio {assetId: string; durationMs: number; startedAtMs?: number}
+export interface MeetingSegment {startMs: number; endMs: number; text: string}
+export interface RecordingChunk {
+  id: string;
+  blob?: Blob;
+  audio: MeetingAudio;
+  phase: 'uploading' | 'uploadFailed' | 'transcribing' | 'untranscribed' | 'done';
+  error?: string;
+  busy?: boolean;
+}
+export const chunkKey = (audio: MeetingAudio): string => `${audio.startedAtMs ?? 0}:${audio.assetId}`;
+export {meetingTime} from './meetingTime';
+
+export function meetingSegments(result: AiTranscriptionResult, audio: MeetingAudio): MeetingSegment[] {
+  const offset = audio.startedAtMs ?? 0;
+  return result.segments?.length
+    ? result.segments.map((s) => ({startMs: offset + s.start * 1000, endMs: offset + s.end * 1000, text: s.text}))
+    : result.text ? [{startMs: offset, endMs: offset + result.durationMs, text: result.text}] : [];
+}
+
+export function transcriptionError(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  const status = (error as {status?: number} | null)?.status;
+  if (status === 400 || /\b400\b/.test(message)) return t('meetingBlock.unconfigured');
+  if (status === 403 || /\b403\b/.test(message)) return t('meetingBlock.forbidden');
+  if (status === 404 || /\b404\b/.test(message)) return t('meetingBlock.missing');
+  return t('meetingBlock.transcriptionFailed');
+}
+
+/** One writer per live block. Failed blobs stay in this session across view remounts;
+ * successful uploads release their bytes. Upload and transcription never gate capture. */
+export class MeetingRecorder {
+  chunks: RecordingChunk[] = [];
+  mode: 'idle' | 'requesting' | 'recording' | 'paused' | 'processing' | 'done' = 'idle';
+  error = '';
+  readOnly: boolean;
+  private capturedMs?: number;
+  private currentStarted?: number;
+  private stream?: MediaStream;
+  private recorder?: MediaRecorder;
+  private timer?: ReturnType<typeof setTimeout>;
+  private generation = 0;
+  private revision = 0;
+  private listeners = new Set<() => void>();
+  private pending = 0;
+  private finalizing = false;
+  constructor(private editor: BlockEditorController, private block: BlockMap, private pageId: string) { this.readOnly = editor.readOnly; }
+  subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  snapshot = (): number => this.revision;
+  private protect = (event: BeforeUnloadEvent): void => { event.preventDefault(); event.returnValue = ''; };
+  private changed(): void {
+    // Retain the recovery guard even after navigating away from the block view.
+    if (this.active || this.unsaved || this.finalizing) window.addEventListener('beforeunload', this.protect);
+    else window.removeEventListener('beforeunload', this.protect);
+    this.revision += 1; this.listeners.forEach((listener) => listener());
+  }
+  private write(props: Record<string, unknown>): void {
+    this.editor.doc.transact(() => {
+      for (const [key, value] of Object.entries(props)) setBlockProp(this.block, key, value);
+    }, 'local');
+    this.changed();
+  }
+  get active(): boolean { return ['requesting', 'recording', 'paused'].includes(this.mode); }
+  get unsaved(): boolean { return this.chunks.some((chunk) => !!chunk.blob); }
+  private closedDuration(): number {
+    const saved = blockProp<MeetingAudio[]>(this.block, 'audioChunks') ?? [];
+    return saved.reduce((total, audio) => total + audio.durationMs, 0)
+      + this.chunks.reduce((total, chunk) => total + (chunk.blob ? chunk.audio.durationMs : 0), 0);
+  }
+  get elapsedMs(): number {
+    const closed = this.active || this.mode === 'processing' ? this.capturedMs ?? this.closedDuration() : this.closedDuration();
+    return closed + (this.mode === 'recording' && this.currentStarted != null ? Math.max(0, Date.now() - this.currentStarted) : 0);
+  }
+  private get persistedBusy(): boolean {
+    return ['recording', 'processing'].includes(blockProp<string>(this.block, 'status') ?? 'idle');
+  }
+  get recordingElsewhere(): boolean {
+    return this.persistedBusy && !this.active && this.mode !== 'processing';
+  }
+  async start(): Promise<void> {
+    if (this.active || this.mode === 'processing' || this.readOnly || this.recordingElsewhere) return;
+    this.pageId = getPageIdForDoc(this.editor.doc) ?? this.pageId;
+    if (!this.pageId || !assetBridge.ready()) { this.error = t('meetingBlock.noStore'); this.changed(); return; }
+    if (!globalThis.MediaRecorder || !navigator.mediaDevices?.getUserMedia) {
+      this.error = t('meetingBlock.unsupported'); this.changed(); return;
+    }
+    this.mode = 'requesting'; this.error = ''; this.changed();
+    const generation = ++this.generation;
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({audio: true});
+      if (generation !== this.generation) { stream.getTracks().forEach((track) => track.stop()); return; }
+      // Another client may have begun recording while this permission prompt was open.
+      if (this.readOnly || this.persistedBusy) {
+        stream.getTracks().forEach((track) => track.stop()); this.mode = 'idle'; this.changed(); return;
+      }
+      this.capturedMs = this.closedDuration();
+      this.stream = stream;
+      if (blockProp<number>(this.block, 'startedAt') == null) this.write({startedAt: Date.now()});
+      this.mode = 'recording';
+      this.beginChunk();
+      this.write({status: 'recording'});
+    } catch {
+      if (generation !== this.generation) return;
+      this.release(); this.mode = 'idle'; this.error = t('meetingBlock.permission'); this.changed();
+    }
+  }
+  private beginChunk(): void {
+    const mimeType = ['audio/webm;codecs=opus', 'audio/ogg;codecs=opus', 'audio/mp4', 'audio/webm']
+      .find((mime) => MediaRecorder.isTypeSupported(mime));
+    const recorder = new MediaRecorder(this.stream!, {audioBitsPerSecond: 64000, ...(mimeType ? {mimeType} : {})});
+    this.recorder = recorder;
+    const started = Date.now();
+    this.currentStarted = started;
+    const offset = this.capturedMs ?? this.closedDuration();
+    const parts: Blob[] = [];
+    let duration: number | undefined;
+    const closeDuration = (): void => {
+      if (duration != null) return;
+      duration = Math.max(0, Date.now() - started);
+      this.capturedMs = offset + duration;
+      this.currentStarted = undefined;
+    };
+    recorder.ondataavailable = (event) => { if (event.data.size) parts.push(event.data); };
+    recorder.onerror = () => { this.error = t('meetingBlock.captureFailed'); this.stop(); };
+    recorder.onstop = () => {
+      closeDuration();
+      this.finishCurrent = undefined;
+      this.finalizing = false;
+      this.recorder = undefined;
+      const blob = new Blob(parts, {type: recorder.mimeType || mimeType || parts[0]?.type || 'audio/webm'});
+      if (blob.size) {
+        const chunk: RecordingChunk = {id: crypto.randomUUID(), blob, audio: {assetId: '', durationMs: duration!, startedAtMs: offset}, phase: 'uploading'};
+        this.chunks.push(chunk);
+        void this.upload(chunk);
+      }
+      if (this.mode === 'recording') {
+        try { this.beginChunk(); } catch { this.error = t('meetingBlock.captureFailed'); this.stop(); }
+      }
+      this.settle(); this.changed();
+    };
+    // Restart, don't request timeslices: each file must have its own container header.
+    recorder.start();
+    this.timer = setTimeout(() => this.finishChunk(), 45000);
+    this.finishCurrent = () => { closeDuration(); recorder.stop(); };
+  }
+  private finishCurrent?: () => void;
+  private finishChunk(): void {
+    clearTimeout(this.timer);
+    if (this.recorder && this.recorder.state !== 'inactive' && !this.finalizing) {
+      this.finalizing = true; this.finishCurrent?.();
+    }
+  }
+  pause(): void {
+    if (this.mode !== 'recording') return;
+    this.mode = 'paused'; this.finishChunk();
+    this.stream?.getAudioTracks().forEach((track) => { track.enabled = false; });
+    this.changed();
+  }
+  resume(): void {
+    if (this.mode !== 'paused' || this.readOnly) return;
+    this.stream?.getAudioTracks().forEach((track) => { track.enabled = true; });
+    this.mode = 'recording';
+    try { if (!this.finalizing) this.beginChunk(); } catch { this.error = t('meetingBlock.captureFailed'); this.stop(); }
+    this.changed();
+  }
+  stop(): void {
+    if (!this.active) return;
+    this.generation += 1;
+    this.mode = 'processing'; this.write({status: 'processing'});
+    this.finishChunk(); this.release(); this.settle();
+  }
+  private release(): void {
+    clearTimeout(this.timer);
+    this.stream?.getTracks().forEach((track) => track.stop()); this.stream = undefined;
+  }
+  private settle(): void {
+    if (this.mode === 'processing' && !this.pending && !this.finalizing) {
+      const empty = !this.chunks.length && !(blockProp<MeetingAudio[]>(this.block, 'audioChunks') ?? []).length;
+      this.mode = empty && blockProp<number>(this.block, 'startedAt') == null ? 'idle' : 'done';
+      this.write({status: this.mode});
+    }
+  }
+  private async backoff<T>(operation: () => Promise<T>): Promise<T> {
+    for (let attempt = 0; ; attempt += 1) {
+      try { return await operation(); } catch (error) {
+        if (attempt >= 2 || /\b(400|403|404|413)\b/.test(String(error))) throw error;
+        await new Promise((resolve) => setTimeout(resolve, 1000 * 2 ** attempt));
+      }
+    }
+  }
+  async upload(chunk: RecordingChunk): Promise<void> {
+    if (chunk.busy || !chunk.blob) return;
+    chunk.busy = true; chunk.phase = 'uploading'; chunk.error = undefined;
+    this.pending += 1; this.changed();
+    try {
+      const blob = chunk.blob;
+      if (blob.size > 10 * 1024 * 1024) throw new Error('413');
+      const bytes = new Uint8Array(await blob.arrayBuffer());
+      const asset = await this.backoff(() => assetBridge.putAsset(bytes, blob.type.split(';')[0], this.pageId));
+      chunk.audio = {...chunk.audio, assetId: asset.id};
+      const existing = blockProp<MeetingAudio[]>(this.block, 'audioChunks') ?? [];
+      this.write({audioChunks: [...existing, chunk.audio].sort((a, b) => (a.startedAtMs ?? 0) - (b.startedAtMs ?? 0))});
+      chunk.blob = undefined; chunk.phase = 'untranscribed';
+    } catch {
+      chunk.phase = 'uploadFailed'; chunk.error = t('meetingBlock.uploadFailed');
+    } finally {
+      chunk.busy = false; this.pending -= 1;
+    }
+    if (chunk.audio.assetId && assetBridge.canTranscribe()) void this.transcribe(chunk);
+    this.settle(); this.changed();
+  }
+  async transcribe(chunk: RecordingChunk): Promise<void> {
+    if (chunk.busy || !chunk.audio.assetId || !assetBridge.canTranscribe()) return;
+    this.pageId = getPageIdForDoc(this.editor.doc) ?? this.pageId;
+    if (!this.pageId) { chunk.error = t('meetingBlock.noStore'); this.changed(); return; }
+    const key = chunkKey(chunk.audio);
+    if ((blockProp<string[]>(this.block, 'transcriptionCompleted') ?? []).includes(key)) { chunk.phase = 'done'; this.changed(); return; }
+    chunk.busy = true; chunk.phase = 'transcribing'; chunk.error = undefined;
+    this.pending += 1; this.changed();
+    try {
+      const result = await this.backoff(() => assetBridge.transcribeAsset(chunk.audio.assetId, this.pageId));
+      const completed = blockProp<string[]>(this.block, 'transcriptionCompleted') ?? [];
+      if (completed.includes(key)) { chunk.phase = 'done'; return; }
+      const transcript = blockProp<MeetingSegment[]>(this.block, 'transcript') ?? [];
+      // Both replacements are one synchronous transaction, read fresh after awaiting.
+      this.write({
+        transcript: [...transcript, ...meetingSegments(result, chunk.audio)].sort((a, b) => a.startMs - b.startMs || a.endMs - b.endMs),
+        transcriptionCompleted: [...completed, key],
+      });
+      chunk.phase = 'done';
+    } catch (error) {
+      chunk.phase = 'untranscribed'; chunk.error = transcriptionError(error);
+    } finally {
+      chunk.busy = false; this.pending -= 1; this.settle(); this.changed();
+    }
+  }
+  retry(audio: MeetingAudio): void {
+    let chunk = this.chunks.find((item) => chunkKey(item.audio) === chunkKey(audio));
+    if (!chunk) { chunk = {id: crypto.randomUUID(), audio, phase: 'untranscribed'}; this.chunks.push(chunk); }
+    void this.transcribe(chunk);
+  }
+}
+
+const sessions = new WeakMap<BlockMap, MeetingRecorder>();
+export function meetingRecorder(editor: BlockEditorController, block: BlockMap, pageId: string): MeetingRecorder {
+  let session = sessions.get(block);
+  if (!session) { session = new MeetingRecorder(editor, block, pageId); sessions.set(block, session); }
+  return session;
+}
diff --git a/packages/ui/src/blockeditor/meetingTime.ts b/packages/ui/src/blockeditor/meetingTime.ts
new file mode 100644
index 00000000..750951ab
--- /dev/null
+++ b/packages/ui/src/blockeditor/meetingTime.ts
@@ -0,0 +1,7 @@
+/** Recorded-time display shared by the recorder and its export projections. */
+export function meetingTime(ms: number): string {
+  const seconds = Math.floor(Math.max(0, ms) / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const tail = String(seconds % 60).padStart(2, '0');
+  return minutes >= 60 ? `${Math.floor(minutes / 60)}:${String(minutes % 60).padStart(2, '0')}:${tail}` : `${minutes}:${tail}`;
+}
diff --git a/packages/ui/src/blockeditor/registry.tsx b/packages/ui/src/blockeditor/registry.tsx
index 89bec3fa..44a6ef99 100644
--- a/packages/ui/src/blockeditor/registry.tsx
+++ b/packages/ui/src/blockeditor/registry.tsx
@@ -16,6 +16,8 @@ import type {BlockEditorController} from './useBlockEditor';
  */
 
 export interface CustomBlockProps {
+  /** Editor-owned nested rows for container renderers. */
+  children?: React.ReactNode;
   block: BlockMap;
   editor: BlockEditorController;
   /**
diff --git a/packages/ui/src/components/AssetBridgeHost.tsx b/packages/ui/src/components/AssetBridgeHost.tsx
index 7ef5ee63..7ae9905b 100644
--- a/packages/ui/src/components/AssetBridgeHost.tsx
+++ b/packages/ui/src/components/AssetBridgeHost.tsx
@@ -14,6 +14,7 @@ export function AssetBridgeHost() {
     setAssetBridge({
       putAsset: (bytes, mime, pageId) => client.putAsset(bytes, mime, pageId),
       getAsset: (id) => client.getAsset(id),
+      transcribeAsset: client.supportsTranscription === false ? undefined : (id, pageId) => client.transcribeAsset(id, pageId),
     });
     return () => setAssetBridge(null);
   }, [client]);
diff --git a/packages/ui/src/components/history/VersionDiff.tsx b/packages/ui/src/components/history/VersionDiff.tsx
index e848c62b..f302f0e0 100644
--- a/packages/ui/src/components/history/VersionDiff.tsx
+++ b/packages/ui/src/components/history/VersionDiff.tsx
@@ -1,3 +1,4 @@
+import {t} from '@/i18n';
 import {Fragment, useEffect, useMemo, useState} from 'react';
 import {useData} from '@/data';
 import {useTranslation} from '@/providers';
@@ -39,6 +40,7 @@ export function blockTypeLabel(type: string): string {
     chart: 'Chart',
     dbview: 'Database view',
     form: 'Form',
+    meeting: t('meetingBlock.label'),
     slider: 'Slider',
     formula: 'Formula',
     status: 'Status',
diff --git a/packages/ui/src/i18n/messages/de.ts b/packages/ui/src/i18n/messages/de.ts
index 789dca6a..74d88ec2 100644
--- a/packages/ui/src/i18n/messages/de.ts
+++ b/packages/ui/src/i18n/messages/de.ts
@@ -636,6 +636,45 @@ export const de: PartialMessages = {
     remove: 'Link entfernen',
     urlLabel: 'Link-URL',
   },
+  meetingBlock: {
+    locked: 'Besprechung durch ihren Abschnitt gesperrt',
+    readOnly: 'Schreibgeschützte Besprechung',
+    elsewhere: 'Aufnahme oder Verarbeitung auf einem anderen Client.',
+    incomplete: 'Transkript unvollständig',
+    addNote: 'Notiz hinzufügen',
+    label: 'Besprechung',
+    hint: 'Audio aufnehmen, transkribieren und Notizen machen',
+    record: 'Aufnehmen',
+    pause: 'Pausieren',
+    resume: 'Fortsetzen',
+    stop: 'Stoppen',
+    idle: 'Bereit',
+    requesting: 'Mikrofon wird angefragt…',
+    recording: 'Aufnahme läuft',
+    paused: 'Pausiert',
+    processing: 'Verarbeitung',
+    done: 'Fertig',
+    playback: 'Audioabschnitt ab {time} abspielen',
+    saveAudio: 'Audiokopie speichern',
+    transcript: 'Transkript',
+    notes: 'Notizen',
+    noAI: 'Die Transkription benötigt einen verbundenen OpenBook-Server. Aufnahme und Notizen bleiben verfügbar.',
+    noStore: 'Verbinde einen Dateispeicher und öffne eine gespeicherte Seite, um aufzunehmen.',
+    unsupported: 'Dieser Browser unterstützt keine Mikrofonaufnahme.',
+    permission: 'Mikrofonzugriff fehlgeschlagen. Erlaube den Zugriff in den Browsereinstellungen und versuche es erneut.',
+    captureFailed: 'Die Aufnahme wurde unerwartet beendet. Das aufgenommene Audio wird gespeichert.',
+    unconfigured: 'Konfiguriere die Transkription unter Einstellungen → KI und versuche es erneut.',
+    forbidden: 'Die Transkription erfordert ein berechtigtes angemeldetes Konto und Seitenzugriff.',
+    missing: 'Audio oder Seite nicht gefunden. Prüfe den Zugriff und versuche es erneut.',
+    transcriptionFailed: 'Transkription fehlgeschlagen. Dein Audio ist gespeichert; versuche es erneut, wenn der Dienst verfügbar ist.',
+    uploading: 'Audio wird gespeichert…',
+    uploadFailed: 'Audio-Upload fehlgeschlagen. Lass diese Seite offen, versuche es erneut oder speichere eine Audiokopie.',
+    retryUpload: 'Upload wiederholen',
+    transcribing: 'Transkription läuft…',
+    untranscribed: 'Nicht transkribiert',
+    transcribed: 'Transkribiert',
+    retryTranscription: 'Transkription wiederholen'
+  },
   formBlock: {
     label: 'Formular',
     databaseReference: {
@@ -804,6 +843,7 @@ export const de: PartialMessages = {
     'ai-continue': {label: 'Weiterschreiben', hint: 'KI schreibt ab hier weiter'},
     'ai-tasks': {label: 'In Aufgaben zerlegen', hint: 'KI entwirft To-dos dafür'},
     custom: {
+      meeting: {'label': 'Besprechung', 'hint': 'Audio aufnehmen, transkribieren und Notizen machen'},
       slider: {label: 'Schieberegler', hint: 'Ein benannter Live-Eingang'},
       formula: {label: 'Formel', hint: 'Live-Code über Eingaben'},
       number: {label: 'Zahlen-Stepper', hint: 'Eine benannte Zahl mit − / + Tasten'},
diff --git a/packages/ui/src/i18n/messages/en.ts b/packages/ui/src/i18n/messages/en.ts
index b2ed5631..298154c9 100644
--- a/packages/ui/src/i18n/messages/en.ts
+++ b/packages/ui/src/i18n/messages/en.ts
@@ -1077,6 +1077,45 @@ export const en = {
     noPages: 'No pages found',
     noDatabases: 'No databases found',
   },
+  meetingBlock: {
+    locked: 'Meeting locked by its section',
+    readOnly: 'Read-only meeting',
+    elsewhere: 'Recording or processing on another client.',
+    incomplete: 'Transcript incomplete',
+    addNote: 'Add note',
+    label: 'Meeting',
+    hint: 'Record audio, transcribe and take notes',
+    record: 'Record',
+    pause: 'Pause',
+    resume: 'Resume',
+    stop: 'Stop',
+    idle: 'Ready',
+    requesting: 'Requesting microphone…',
+    recording: 'Recording',
+    paused: 'Paused',
+    processing: 'Processing',
+    done: 'Done',
+    playback: 'Play audio chunk starting at {time}',
+    saveAudio: 'Save audio copy',
+    transcript: 'Transcript',
+    notes: 'Notes',
+    noAI: 'Transcription requires a connected OpenBook server. Recording and notes are still available.',
+    noStore: 'Connect an asset store and open a saved page to record.',
+    unsupported: 'This browser does not support microphone recording.',
+    permission: 'Microphone access failed. Allow microphone access in browser settings, then try again.',
+    captureFailed: 'Recording stopped unexpectedly. Captured audio is being saved.',
+    unconfigured: 'Configure transcription in Settings → AI, then retry.',
+    forbidden: 'Transcription requires a paid or eligible plan, a signed-in account and page access.',
+    missing: 'Audio asset or page was not found. Check access and retry.',
+    transcriptionFailed: 'Transcription failed. Your audio is saved; retry when the service is available.',
+    uploading: 'Saving audio…',
+    uploadFailed: 'Audio upload failed. Keep this page open, retry or save an audio copy.',
+    retryUpload: 'Retry upload',
+    transcribing: 'Transcribing…',
+    untranscribed: 'Not transcribed',
+    transcribed: 'Transcribed',
+    retryTranscription: 'Retry transcription',
+  },
   formBlock: {
     label: 'Form',
     databaseReference: {
@@ -1256,6 +1295,7 @@ export const en = {
     'ai-continue': {label: 'Continue writing', hint: 'AI continues from here'},
     'ai-tasks': {label: 'Break into tasks', hint: 'AI drafts to-dos for this'},
     custom: {
+      meeting: {'label': 'Meeting', 'hint': 'Record audio, transcribe and take notes'},
       slider: {label: 'Slider', hint: 'A named live input'},
       formula: {label: 'Formula', hint: 'Live code over inputs'},
       number: {label: 'Number stepper', hint: 'A named number with − / + buttons'},
diff --git a/packages/ui/src/i18n/messages/ja.ts b/packages/ui/src/i18n/messages/ja.ts
index 4628f2d4..ab4f9a78 100644
--- a/packages/ui/src/i18n/messages/ja.ts
+++ b/packages/ui/src/i18n/messages/ja.ts
@@ -631,6 +631,45 @@ export const ja: PartialMessages = {
     remove: 'リンクを解除',
     urlLabel: 'リンク URL',
   },
+  meetingBlock: {
+    locked: 'セクションにより会議がロックされています',
+    readOnly: '読み取り専用の会議',
+    elsewhere: '別のクライアントで録音または処理中です。',
+    incomplete: '文字起こしは未完了です',
+    addNote: 'メモを追加',
+    label: '会議',
+    hint: '音声を録音し、文字起こしとメモを作成',
+    record: '録音',
+    pause: '一時停止',
+    resume: '再開',
+    stop: '停止',
+    idle: '準備完了',
+    requesting: 'マイクを要求中…',
+    recording: '録音中',
+    paused: '一時停止中',
+    processing: '処理中',
+    done: '完了',
+    playback: '{time} からの音声チャンクを再生',
+    saveAudio: '音声のコピーを保存',
+    transcript: '文字起こし',
+    notes: 'メモ',
+    noAI: '文字起こしには接続されたOpenBookサーバーが必要です。録音とメモは引き続き利用できます。',
+    noStore: '録音するにはアセットストアに接続し、保存済みページを開いてください。',
+    unsupported: 'このブラウザーはマイク録音に対応していません。',
+    permission: 'マイクにアクセスできません。ブラウザーの設定でアクセスを許可してから再試行してください。',
+    captureFailed: '録音が予期せず停止しました。録音済みの音声を保存しています。',
+    unconfigured: '文字起こしを　設定 → AI　で構成してから再試行してください。',
+    forbidden: '文字起こしには利用資格のあるアカウントへのログインとページへのアクセスが必要です。',
+    missing: '音声またはページが見つかりません。アクセス権を確認して再試行してください。',
+    transcriptionFailed: '文字起こしに失敗しました。音声は保存されています。サービスが利用可能になったら再試行してください。',
+    uploading: '音声を保存中…',
+    uploadFailed: '音声のアップロードに失敗しました。このページを開いたまま再試行するか、音声のコピーを保存してください。',
+    retryUpload: 'アップロードを再試行',
+    transcribing: '文字起こし中…',
+    untranscribed: '未文字起こし',
+    transcribed: '文字起こし済み',
+    retryTranscription: '文字起こしを再試行'
+  },
   formBlock: {
     label: 'フォーム',
     databaseReference: {
@@ -799,6 +838,7 @@ export const ja: PartialMessages = {
     'ai-continue': {label: '続きを書く', hint: 'AI がここから続けます'},
     'ai-tasks': {label: 'タスクに分解', hint: 'AI が To-do を下書きします'},
     custom: {
+      meeting: {'label': '会議', 'hint': '音声を録音し、文字起こしとメモを作成'},
       slider: {label: 'スライダー', hint: '名前付きライブ入力'},
       formula: {label: '数式', hint: '入力値のライブ計算'},
       number: {label: '数値ステッパー', hint: '− / + ボタン付きの名前付き数値'},
diff --git a/packages/ui/src/i18n/messages/zh.ts b/packages/ui/src/i18n/messages/zh.ts
index c31cb9fa..604f6096 100644
--- a/packages/ui/src/i18n/messages/zh.ts
+++ b/packages/ui/src/i18n/messages/zh.ts
@@ -582,7 +582,7 @@ export const zh: PartialMessages = {
     reset: '新对话',
     close: '关闭助手',
     error: '出了点问题：{error}',
-    notReady: '助手需要一个模型——请在 设置 → AI 中启用。',
+    notReady: '助手需要一个模型——请在　设置 → AI　中启用。',
     openSettings: '打开 AI 设置',
     send: '发送',
     stop: '停止',
@@ -628,6 +628,45 @@ export const zh: PartialMessages = {
     remove: '移除链接',
     urlLabel: '链接地址',
   },
+  meetingBlock: {
+    locked: '会议已被所在分区锁定',
+    readOnly: '只读会议',
+    elsewhere: '正在其他客户端上录音或处理。',
+    incomplete: '转写尚未完成',
+    addNote: '添加笔记',
+    label: '会议',
+    hint: '录音、转写并记笔记',
+    record: '录音',
+    pause: '暂停',
+    resume: '继续',
+    stop: '停止',
+    idle: '就绪',
+    requesting: '正在请求麦克风…',
+    recording: '录音中',
+    paused: '已暂停',
+    processing: '处理中',
+    done: '完成',
+    playback: '播放从 {time} 开始的音频片段',
+    saveAudio: '保存音频副本',
+    transcript: '转写文本',
+    notes: '笔记',
+    noAI: '转写需要连接到OpenBook服务器。录音和笔记仍可使用。',
+    noStore: '请连接资源存储并打开已保存的页面以开始录音。',
+    unsupported: '此浏览器不支持麦克风录音。',
+    permission: '无法访问麦克风。请在浏览器设置中允许访问后重试。',
+    captureFailed: '录音意外停止。正在保存已录制的音频。',
+    unconfigured: '请在　设置 → AI　中配置转写，然后重试。',
+    forbidden: '转写需要符合条件的登录账号和页面访问权限。',
+    missing: '未找到音频或页面。请检查访问权限后重试。',
+    transcriptionFailed: '转写失败。音频已保存，请在服务可用时重试。',
+    uploading: '正在保存音频…',
+    uploadFailed: '音频上传失败。请保持此页面打开，重试或保存音频副本。',
+    retryUpload: '重试上传',
+    transcribing: '正在转写…',
+    untranscribed: '未转写',
+    transcribed: '已转写',
+    retryTranscription: '重试转写'
+  },
   formBlock: {
     label: '表单',
     databaseReference: {
@@ -796,6 +835,7 @@ export const zh: PartialMessages = {
     'ai-continue': {label: '继续写作', hint: 'AI 从此处续写'},
     'ai-tasks': {label: '拆解为任务', hint: 'AI 草拟相关待办'},
     custom: {
+      meeting: {'label': '会议', 'hint': '录音、转写并记笔记'},
       slider: {label: '滑块', hint: '具名实时输入'},
       formula: {label: '公式', hint: '基于输入的实时计算'},
       number: {label: '数字步进器', hint: '带 − / + 按钮的具名数字'},
diff --git a/packages/ui/src/index.css b/packages/ui/src/index.css
index a2309601..3250ea45 100644
--- a/packages/ui/src/index.css
+++ b/packages/ui/src/index.css
@@ -3939,3 +3939,18 @@ a.obe-mention {
   transition: border-color 0.12s ease;
 }
 .ob-map-cluster-wrap:hover .ob-map-cluster { border-color: hsl(var(--ring) / 0.55); }
+
+/* Meeting recorder: native playback, copyable transcript and ordinary note rows. */
+.obe-meeting { border: 1px solid var(--color-border); border-radius: var(--radius-md); padding: 16px; }
+.obe-meeting header, .obe-meeting-controls { display: flex; align-items: center; flex-wrap: wrap; gap: 12px; margin-bottom: 12px; }
+.obe-meeting header { justify-content: space-between; }
+.obe-meeting button { border: 1px solid var(--color-border); border-radius: var(--radius-sm); padding: 6px 12px; cursor: pointer; }
+.obe-meeting button:disabled { opacity: 0.5; cursor: default; }
+.obe-meeting button:focus-visible, .obe-meeting a:focus-visible { outline: 2px solid var(--color-ring); outline-offset: 2px; }
+.obe-meeting-chunks { display: grid; gap: 12px; margin-block: 12px; }
+.obe-meeting-chunks li { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; }
+.obe-meeting audio { max-width: 100%; }
+.obe-meeting-transcript { user-select: text; white-space: pre-wrap; }
+.obe-meeting time { color: var(--color-muted-foreground); font-variant-numeric: tabular-nums; }
+.obe-meeting-summary { white-space: pre-wrap; margin-block: 12px; }
+.obe-meeting-notes { border-top: 1px solid var(--color-border); margin-top: 16px; padding-top: 12px; }
diff --git a/packages/ui/src/lib/assetBridge.ts b/packages/ui/src/lib/assetBridge.ts
index a69bb759..406f3454 100644
--- a/packages/ui/src/lib/assetBridge.ts
+++ b/packages/ui/src/lib/assetBridge.ts
@@ -1,3 +1,5 @@
+import type {AiTranscriptionResult} from '@book.dev/sdk';
+
 /**
  * Bridge between the (provider-less) block editor and the app's data client for
  * binary assets — the same singleton pattern as `aiBridge` / `pageLinks`. The
@@ -11,6 +13,7 @@
  */
 
 export interface AssetBridgeImpl {
+  transcribeAsset?: (assetId: string, pageId: string) => Promise<AiTranscriptionResult>;
   /** Upload bytes → the content-addressed store, ref'd to `pageId`; resolves `{id}`. */
   putAsset: (bytes: Uint8Array, mime: string, pageId: string) => Promise<{id: string}>;
   /** Resolve an asset's bytes + mime by content-hash id (or `null` if unreachable). */
@@ -18,14 +21,23 @@ export interface AssetBridgeImpl {
 }
 
 let bridge: AssetBridgeImpl | null = null;
+const listeners = new Set<() => void>();
+export const subscribeAssetBridge = (listener: () => void): (() => void) => {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+};
 
 /** Install (or clear) the live asset bridge. The app calls this from a client-aware host. */
 export const setAssetBridge = (next: AssetBridgeImpl | null): void => {
   bridge = next;
+  listeners.forEach((listener) => listener());
 };
 
 /** The bridge actions, safe to call before the host mounts (upload rejects; get resolves null). */
 export const assetBridge = {
+  canTranscribe: (): boolean => bridge?.transcribeAsset != null,
+  transcribeAsset: (assetId: string, pageId: string): Promise<AiTranscriptionResult> =>
+    bridge?.transcribeAsset ? bridge.transcribeAsset(assetId, pageId) : Promise.reject(new Error('Transcription unavailable')),
   /** Whether an asset store is wired up (⇒ ingest can upload rather than inline a data-URL). */
   ready: (): boolean => bridge != null,
   putAsset: (bytes: Uint8Array, mime: string, pageId: string): Promise<{id: string}> =>