From aadffde8089600830befc4fd98d7eb13148cdaef Mon Sep 17 00:00:00 2001
From: Eliot Lim <eliot.lim@gmail.com>
Date: Sun, 4 Oct 2026 01:52:18 +0800
Subject: [PATCH 1/6] feat(ui): add meeting recording, transcription and notes
 (MEET-5)

---
 _brief-meet5.md                               |  45 ++++
 _brief.md                                     |  32 ---
 _report.md                                    |  87 -------
 packages/sdk/src/client.ts                    |   2 +
 packages/server/src/localClient.ts            |   2 +
 packages/ui/src/blockeditor/BlockEditor.tsx   |   5 +-
 .../blockeditor/MeetingBlockPlaceholder.tsx   |  14 --
 .../ui/src/blockeditor/MeetingBlockView.tsx   |  96 +++++++
 packages/ui/src/blockeditor/SlashMenu.tsx     |   2 +-
 .../__tests__/meetingRecorder.test.tsx        | 237 ++++++++++++++++++
 packages/ui/src/blockeditor/exportBlocks.ts   |  30 ++-
 packages/ui/src/blockeditor/kit/index.ts      |   2 +-
 .../ui/src/blockeditor/meetingRecorder.ts     | 222 ++++++++++++++++
 packages/ui/src/blockeditor/registry.tsx      |   2 +
 .../ui/src/components/AssetBridgeHost.tsx     |   1 +
 .../ui/src/components/history/VersionDiff.tsx |   2 +
 packages/ui/src/i18n/messages/de.ts           |  36 +++
 packages/ui/src/i18n/messages/en.ts           |  36 +++
 packages/ui/src/i18n/messages/ja.ts           |  36 +++
 packages/ui/src/i18n/messages/zh.ts           |  36 +++
 packages/ui/src/index.css                     |  15 ++
 packages/ui/src/lib/assetBridge.ts            |   6 +
 22 files changed, 808 insertions(+), 138 deletions(-)
 create mode 100644 _brief-meet5.md
 delete mode 100644 _brief.md
 delete mode 100644 _report.md
 delete mode 100644 packages/ui/src/blockeditor/MeetingBlockPlaceholder.tsx
 create mode 100644 packages/ui/src/blockeditor/MeetingBlockView.tsx
 create mode 100644 packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
 create mode 100644 packages/ui/src/blockeditor/meetingRecorder.ts

diff --git a/_brief-meet5.md b/_brief-meet5.md
new file mode 100644
index 00000000..2ba8a8fd
--- /dev/null
+++ b/_brief-meet5.md
@@ -0,0 +1,45 @@
+# MEET-5 — Recorder UI: meeting block view, progressive transcript, manual notes
+
+You are Ellis, an OpenBook Worker agent. Work in THIS worktree (`/Users/eliot/Workspaces/OpenBook-wt-meet-4`). Do NOT push. Conventional commits (`feat(ui): … (MEET-5)`), committed incrementally. DISK IS NEARLY FULL (~1.5 GiB free): do not download models or create worktrees; clean any large temp artifacts you produce.
+
+## Branch setup (do this first, carefully)
+1. `git checkout -b feat/meet-5-recorder-ui` (from current HEAD = feat/meet-4-meeting-catalogue).
+2. `git merge feat/meet-1-audio-assets` then `git merge feat/meet-2-transcribe`. Expected conflicts are trivial:
+   - `packages/server/src/ableOidc.test.ts`: all three branches contain the identical code line `expiresAt: new Date(Date.now() + 60_000)`; conflicts are comment-only. Resolve keeping MEET-2's comment wording (PAT validation uses the database clock, not the injected OIDC clock).
+   - Possible add/add in `packages/sdk/src/index.ts` export lines — keep BOTH exports, watch for duplicated re-export lines (known trap).
+   - `_brief.md`/`_report.md` conflicts: resolve by DELETING these files (they're being stripped from all branches).
+3. After the merges, run `pnpm build:libs` (semantic-conflict check) before starting feature work.
+
+## What you're building
+The real `meeting` block UI, replacing MEET-4's placeholder shell (registered via registerArtifactKit — find it and replace its renderer; keep registration/drift-guard structure intact).
+
+### Contracts you MUST follow (already merged into your branch)
+- **Block props (MEET-4 contract, in `_report.md` at git ref 1f97ba06 — read `git show 1f97ba06:_report.md`):** props `status ('idle'|'recording'|'processing'|'done')`, `audioChunks [{assetId, durationMs, startedAtMs?}]` (startedAtMs = offset from meeting start), `transcript [{startMs, endMs, text}]` (offsets relative to meeting start, ms), `summary` (plain string), `startedAt` (epoch ms), `title?`. Arrays replace wholesale — batch and serialize your writes (single writer: the recording client). Manual notes = ordinary CRDT child blocks; MEET-4's shell stored them — render them as an editable notes region (children editing inside a kit block: see how form/KitFrame handles nested content; follow useKitLock + editor.readOnly semantics, BlockEditor.tsx ~:2429-2449).
+- **Transcription API (MEET-2):** `client.transcribeAsset(assetId, pageId)` → `{text, segments?[{start,end,text}] (SECONDS), durationMs}`. Convert segment seconds → ms and offset by the chunk's startedAtMs when appending to `transcript`. Errors: 400 (unconfigured → show actionable copy pointing at Settings → AI), 403 (guest/paid gate), 404, 502. LocalDataClient rejects AI — degrade gracefully (recording + notes still work; transcription affordance disabled with clear copy).
+- **Audio upload (MEET-1):** audio mimes webm/ogg/mpeg/mp4/wav accepted by the asset store; 10 MiB/asset cap. Upload chunks via the assetBridge (ui/src/lib/assetBridge.ts; ImageBlockView.tsx is the bytes↔objectURL reference).
+
+### Recording behavior
+- getUserMedia + MediaRecorder. **Restart MediaRecorder per ~45s chunk so every chunk is a standalone playable file** (do NOT use one recorder with timeslice — those blobs aren't independently decodable). Prefer `audio/webm;codecs=opus`, probe with MediaRecorder.isTypeSupported and fall back (Safari → audio/mp4).
+- Controls: record / pause / resume / stop; elapsed timer; per-chunk progress. Status prop transitions idle→recording→processing→done.
+- Per chunk pipeline: finalize blob → upload asset → append to audioChunks prop → transcribeAsset → append converted segments to transcript prop. Transcript grows during the meeting. Chunk upload MUST succeed/retry even if transcription fails (flag untranscribed chunks, offer per-chunk retry). Exponential backoff; never lose audio; ephemeral state (recorder handle, retry queue, errors) in React state, durable state in props within editor.doc.transact.
+- Mic-permission denied → graceful copy, no crash. Playback: simple per-chunk <audio> playback from object URLs is sufficient for v1.
+
+### Surfaces
+- Slash-menu entry + icon for `meeting` (SlashMenu.tsx pattern ~:242-249).
+- i18n ×4 (en/de/ja/zh — follow the formBlock namespace pattern), obe-* CSS in ui/src/index.css, VersionDiff label.
+- Export serializers: minimal stub — transcript as timestamped paragraphs + summary text in exportBlocks.ts so exports don't break; full export work is MEET-7 (do not build audio export).
+- a11y: controls labelled, recording status via aria-live, transcript selectable/copyable.
+
+## Acceptance (each maps to a test; ui unit tests with mocked MediaRecorder/getUserMedia/assetBridge/client)
+1. State machine incl. pause/resume and permission-denied path.
+2. Chunking: recorder restarted per chunk; chunk blob uploaded; audioChunks appended in order with durations.
+3. Transcription append: seconds→ms conversion + startedAtMs offset correct; failed transcription leaves chunk flagged + retryable; transcript ordering stable.
+4. Props persistence through serialize round-trip; notes children render and stay editable per lock/readOnly semantics; read-only page → no recording controls active.
+5. No-AI (LocalDataClient) and unconfigured (400) degradation copy.
+6. Drift guards still green (registryCatalogue both directions), existing MEET-4 catalogue tests untouched.
+
+## Definition of done
+- `pnpm verify` green FOREGROUND (serialize with VITEST_MAX_WORKERS=1 if parallel flakes on money.test.ts — known host-load flake, do not modify that test).
+- All committed; no push. Write `_report-meet5.md`: outcome, head sha, merge-resolution notes, criterion→test map, deviations, open questions. Terse.
+- Do NOT produce Playwright captures (your sandbox can't launch Chromium; the manager handles captures at PR time).
+- Never delete/weaken existing tests. If wedged after a real attempt, commit and report where.
diff --git a/_brief.md b/_brief.md
deleted file mode 100644
index 81d6e5cf..00000000
--- a/_brief.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# MEET-4 — Block catalogue + prop schemas + MCP surface for `meeting`
-
-You are a Worker agent on the OpenBook team. Work ONLY in this worktree (`/Users/eliot/Workspaces/OpenBook-wt-meet-4`, branch `feat/meet-4-meeting-catalogue`). Do NOT push. Do NOT touch main. Conventional commits (`feat(sdk,mcp): … (MEET-4)`).
-
-## Task
-Register a new `meeting` block type in the single-source catalogue so sdk/mcp/server stay drift-free. The UI view lands later (MEET-5) — your job is the type system + MCP/agent surface + docs. Anchors (recon-time hints — trust the code):
-- `CATALOGUE_LITERAL` `packages/sdk/src/blockCatalogue.ts:62-113` — entries `{type, category, nature, parent?, props, kitValue?, hint}`. Study how `form` (kit) is declared; mirror its decisions (commit 63969ae3 / FORM-3 is the template epic).
-- Prop schemas: `packages/sdk/src/blockPropSchemas.ts` `fields` :51-75 + `CATALOGUE_LITERAL` entry; exports `BLOCK_PROP_SCHEMAS`/`BLOCK_PROP_JSON_SCHEMAS`.
-- MCP: `packages/mcp/src/server.ts` picks types up from the catalogue; update `mcp/README.md` prop table (enforced by `mcp/scripts/readme.test.mts` + `blockTypes.test.mts`); regenerate `docs/audits/block-api-coverage.md` via `mcp/scripts/coverage.test.mts` (EXEMPT entries need a written reason — avoid unless truly necessary).
-- Server agent validators: `server/src/ai/agentBlockTypes.test.ts`.
-- IMPORTANT: ui's `registryCatalogue.test.tsx` requires catalogue kit entries ↔ registered custom blocks to match BOTH directions. The ui view doesn't exist yet. If adding `meeting` as a kit entry breaks that guard, register a minimal placeholder kit registration the way the catalogue/tests structurally require OR structure the entry so the guard passes — pick the smallest honest solution and DOCUMENT it in your report (MEET-5 replaces it). Breaking `pnpm verify` is not acceptable.
-
-## Representation decision (you make it, then document it — MEET-5/6/7 build against it)
-Derive prop shapes from what the component will need, favoring existing catalogue idioms (existing tests/conventions win over this brief):
-- `status`: 'idle' | 'recording' | 'processing' | 'done'
-- audio chunks: ordered list of `{assetId, durationMs, startedAtMs?}` (or parallel arrays if object-arrays aren't idiomatic — check how other blocks store structured props)
-- transcript segments: `{startMs, endMs, text}` list — decide props vs child blocks after reading how `form` stores structured kitValue; prefer props unless size/CRDT concerns say otherwise; justify in one paragraph.
-- `summary` (string/rich), `startedAt`, `title?`
-- manual notes: child blocks (the block should be a container or have a notes container slot — follow the catalogue's `nature`/`parent` idioms, see how form/kit blocks nest).
-Write the final representation contract as a short `docs/`-level or in-code doc comment AND in `_report.md` — MEET-5 consumes it verbatim.
-
-## Acceptance
-- `list_block_types` returns `meeting` with propsSchema; `add_blocks` / `update_block_props` validate it; invalid props rejected (test).
-- All drift guards green: mcp readme/blockTypes/coverage tests, server agentBlockTypes test, ui registryCatalogue guard.
-- Coverage matrix regenerated and committed.
-
-## Definition of done
-- `pnpm verify` green FOREGROUND here, output in report. (Provisioned; artifact-failure symptom → rebuild viewer/server/mcp bundles.)
-- All committed, not pushed. `_report.md`: outcome first, head sha, criterion→test map, THE REPRESENTATION CONTRACT, deviations, open questions. Terse.
-
-## Rules
-Never poll external state. Stuck after a real attempt → commit + report. Never delete/weaken existing tests (reviewers check the commit RANGE).
diff --git a/_report.md b/_report.md
deleted file mode 100644
index 12e57ec2..00000000
--- a/_report.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# MEET-4 — Drew
-
-MEET-4 complete. `pnpm verify` passed in the foreground (exit 0); implementation and report committed separately. Not pushed.
-
-Implementation HEAD: `888f8956cc347a544912c342c7f3d8d77d1c08f6`. The following report-only commit records this verified implementation SHA; final HEAD is the report commit.
-
-## Criterion → test map
-
-| Criterion | Evidence |
-| --- | --- |
-| Catalogue, schemas, defaults/patch semantics, invalid nested values | `packages/sdk/src/blockCatalogue.test.ts` |
-| `list_block_types` exposes meeting + propsSchema; MCP creation/update acceptance and rejection | `packages/mcp/scripts/blockTypes.test.mts` (67 checks) |
-| Agent `add_blocks` and `update_block_props` validate before suggesting | `packages/server/src/ai/agentBlockTypes.test.ts` (13 tests) |
-| Runtime kit registry matches catalogue; notes/props survive UI serialization | `packages/ui/src/blockeditor/registryCatalogue.test.tsx` |
-| README and generated matrix drift guards | `packages/mcp/scripts/readme.test.mts`, `coverage.test.mts`; 45 catalogue types + 9 plugin blocks, no exemptions |
-| Workspace definition of done | `pnpm verify`, foreground, exit 0 (outside sandbox for filesystem watchers) |
-
-## Validation output
-
-Full output: [verification log](/Users/eliot/.bb/thread-storage/meet-4-verify-888f8956.log). Command: `pnpm verify`, foreground, outside sandbox; exit **0**.
-
-```text
-SDK:    32 files, 565 tests passed
-UI:     244 files, 2320 tests passed
-App:    2 files, 7 tests passed
-Server: 97 files, 1327 passed / 6 existing skipped (1333)
-MCP:    All 45 catalogue types + 9 plugin blocks have MCP API coverage; exemptions: none.
-Server e2e: ALL 256 CHECKS PASSED
-MCP e2e:    ALL 70 CHECKS PASSED
-```
-
-ESLint-rule tests, builds, generated-file guard, workspace typechecks and lint also passed. Pre-commit ESLint/typechecks and commitlint passed.
-
-## THE REPRESENTATION CONTRACT
-
-`meeting` is a `kit` block with `nature: 'container'`, no required parent, and
-`kitValue: false`. It publishes no reactive value. Its `children` are ordinary
-manual-note blocks (paragraphs, todos, headings, groups, etc.), not transcript
-segments. No dedicated notes slot or child-only type is required.
-
-All top-level props are optional. Missing status means `idle`; missing arrays
-mean empty lists; missing summary/title mean empty text; missing startedAt means
-not started. These are consumer defaults, not schema-inserted persisted values.
-As with other block props, patches shallow-merge; `null` removes a top-level key.
-Unknown top-level props remain allowed for forward compatibility.
-
-| Prop | Stored shape and meaning |
-| --- | --- |
-| `status` | `'idle' \| 'recording' \| 'processing' \| 'done'`. Validation checks the enum, not state transitions. |
-| `audioChunks` | Ordered array of `{assetId: string, durationMs: number, startedAtMs?: number}`. `assetId` is a nonempty asset reference (max 512 characters), never inline audio. `durationMs` is the chunk duration; optional `startedAtMs` is an offset from meeting start, **not** Unix time. Array order is capture/playback order. |
-| `transcript` | Ordered array of `{startMs: number, endMs: number, text: string}`. Offsets are relative to meeting start; `endMs >= startMs`. Text is plain text. Array order is display order; overlapping segments are allowed. |
-| `summary` | Plain string; no rich-text runs or Markdown interpretation is required. |
-| `startedAt` | Unix epoch milliseconds, a finite nonnegative number. |
-| `title` | Optional plain string. |
-
-All durations and offsets are finite nonnegative numbers in milliseconds;
-fractional milliseconds are accepted. Every listed nested field is required
-except `startedAtMs`; nested objects reject extra keys and null fields. Empty
-arrays and empty transcript text are valid. Cross-field `endMs >= startMs` is
-checked at runtime and described in the JSON schema (standard JSON Schema cannot
-express a comparison to a sibling field). Asset existence, timeline sorting,
-status transitions, and transcription size limits are producer responsibilities.
-
-Audio chunks and transcript segments use structured props, following existing
-kit option/rich-run arrays and the form's structured schema prop. They are
-machine-produced snapshots, while manual notes need independently editable CRDT
-children. Each array is one prop value: updates replace the whole array, with
-no per-segment merge guarantee. Recording/transcription producers should batch
-updates and serialize writes to avoid concurrent array replacement losing data.
-This keeps the first representation small and consistent; large-transcript
-storage migration, if needed later, must explicitly version this contract.
-
-MEET-4 registers a minimal meeting shell through `registerArtifactKit` in both
-editor and viewer hosts. It displays title, status, and saved note-block count;
-notes remain stored but are not yet rendered/editable inside the shell. It has
-no slash-menu entry or recording controls. MEET-5 replaces this renderer and
-must render the existing child blocks rather than migrate them into props.
-
-## Deviations and open questions
-
-- The first full verification attempt hit transient `EADDRINUSE` on MCP port 4410. The listener had exited on inspection; no process was killed and no test was weakened.
-- The new negative test exposed that creation paths previously validated structure but skipped props. Added shared SDK `invalidBlockTreeProps` to MCP creation/append/insert and agent `add_blocks`, validating all declared schemas recursively before writes or suggestions. Existing update validation remains shared.
-- Full verification exposed an unrelated dated fixture in `ableOidc.test.ts`: its purportedly valid PAT expired at fixed September 8, 2026 time, while SQL validates against `now()`. Reproduced the 401-versus-302 failure; changed only the fixture to `Date.now() + 60_000`, preserving every assertion. The focused regression passed afterward.
-- A later full run ended without a normal summary after export fixture failures and zero-test collection failures while the host disk was nearly full. The export suite (`bookFolder.test.ts`) passed all 12 tests unchanged in isolation; both end-to-end suites also passed (256 server / 70 MCP checks). Restarted full verification, including bundle rebuilds.
-- Diagnosed filesystem-watch failures: the unchanged mirror integration suite produced `EMFILE` inside the sandbox despite a 1,048,575 descriptor limit, then passed all 3 tests outside it. Stopped only this worktree’s already-failed sandboxed test process and reran full foreground verification outside the sandbox after automatic approval. No tests or assertions were disabled.
-- Minimal kit registration is intentional, not a drift-guard exemption. MEET-5 replaces the placeholder; notes are preserved but not yet displayed/editable in it.
-- No unresolved MEET-4 questions. MEET-5/6/7 must follow the contract above, including epoch vs relative timestamps and whole-array replacement. Recording controls, transcription transport, and large-transcript storage policy remain later work.
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..6fe8ffef
--- /dev/null
+++ b/packages/ui/src/blockeditor/MeetingBlockView.tsx
@@ -0,0 +1,96 @@
+import {useEffect, useState, useSyncExternalStore} from 'react';
+import {t} from '@/i18n';
+import {assetBridge} 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 {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')} />
+    {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) ?? '');
+  useSyncExternalStore(session.subscribe, session.snapshot, session.snapshot);
+  const [, tick] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => tick((n) => n + 1), 1000);
+    return () => { clearInterval(timer); 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 startedAt = blockProp<number>(block, 'startedAt');
+  const elapsed = session.active && startedAt != null ? Date.now() - startedAt
+    : Math.max(0, ...saved.map((audio) => (audio.startedAtMs ?? 0) + audio.durationMs));
+  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 = assetBridge.canTranscribe();
+  return <section className="obe-meeting" aria-label={t('meetingBlock.label')}>
+    <header><strong>{blockProp<string>(block, 'title') || t('meetingBlock.label')}</strong>
+      <span role="status" aria-live="polite">{statusLabel} · {meetingTime(elapsed)}</span></header>
+    <div className="obe-meeting-controls">
+      {!session.active && <button type="button" disabled={readOnly || session.mode === 'processing'} onClick={() => void session.start()}>{t('meetingBlock.record')}</button>}
+      {session.mode === 'recording' && <button type="button" disabled={readOnly} onClick={() => session.pause()}>{t('meetingBlock.pause')}</button>}
+      {session.mode === 'paused' && <button type="button" disabled={readOnly} onClick={() => session.resume()}>{t('meetingBlock.resume')}</button>}
+      {session.active && <button type="button" disabled={readOnly} 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, index) => <li key={`pending-${index}`}>
+        <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>;
+}
+
+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..621aa9cc
--- /dev/null
+++ b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
@@ -0,0 +1,237 @@
+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, meetingSegments, type MeetingAudio} from '../meetingRecorder';
+import {MeetingBlockView} from '../MeetingBlockView';
+import {blockProp, createDoc, decodeSnapshot, docToJSON, encodeSnapshot, rootBlocks} 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);
+  // jsdom'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(); 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: 48000},
+    ]);
+    expect(blockProp(block, 'transcript')).toEqual([
+      {startMs: 250, endMs: 1500, text: 'hello'}, {startMs: 45250, endMs: 46500, text: 'hello'}, {startMs: 48250, endMs: 49500, 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('processing'); 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);
+  });
+
+  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, status, timestamped transcript, summary and nested notes 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).toContain('done'); 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('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();
+  });
+});
diff --git a/packages/ui/src/blockeditor/exportBlocks.ts b/packages/ui/src/blockeditor/exportBlocks.ts
index 385676e6..cd4c88c8 100644
--- a/packages/ui/src/blockeditor/exportBlocks.ts
+++ b/packages/ui/src/blockeditor/exportBlocks.ts
@@ -9,6 +9,17 @@ import {statusOf, type ExportCell} from './kit/scope';
 import type {DbChartSeriesMap} from './kit/chartData';
 import {formSchemaFromProps} from './formBlock';
 
+/** 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')), String(p.status ?? 'idle'),
+    ...segments.map((segment) => {
+      const seconds = Math.floor(segment.startMs / 1000);
+      return `[${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')}] ${segment.text}`;
+    }), ...(p.summary ? [String(p.summary)] : [])];
+}
+
 // TextRun is referenced in the kit emit cases below.
 
 /**
@@ -251,8 +262,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 +409,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 +583,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 +1097,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/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..05955312
--- /dev/null
+++ b/packages/ui/src/blockeditor/meetingRecorder.ts
@@ -0,0 +1,222 @@
+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 {
+  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 const meetingTime = (ms: number): string => `${Math.floor(ms / 60000)}:${String(Math.floor(ms / 1000) % 60).padStart(2, '0')}`;
+
+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 = '';
+  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) {}
+  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) 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); }
+  async start(): Promise<void> {
+    if (this.active || this.mode === 'processing' || this.editor.readOnly) 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; }
+      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 {
+      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();
+    const offset = Math.max(0, started - (blockProp<number>(this.block, 'startedAt') ?? started));
+    const parts: Blob[] = [];
+    let ended = started;
+    recorder.ondataavailable = (event) => { if (event.data.size) parts.push(event.data); };
+    recorder.onerror = () => { this.error = t('meetingBlock.captureFailed'); this.stop(); };
+    recorder.onstop = () => {
+      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 = {blob, audio: {assetId: '', durationMs: Math.max(0, ended - started), 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 = () => { ended = Date.now(); 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.finalizing) return;
+    this.stream?.getAudioTracks().forEach((track) => { track.enabled = true; });
+    this.mode = 'recording';
+    try { 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 && !this.unsaved) {
+      this.mode = 'done'; this.write({status: 'done'});
+    }
+  }
+  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)) 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 transcript = blockProp<MeetingSegment[]>(this.block, 'transcript') ?? [];
+      const completed = blockProp<string[]>(this.block, 'transcriptionCompleted') ?? [];
+      // 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 = {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/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..5b4d29d1 100644
--- a/packages/ui/src/i18n/messages/de.ts
+++ b/packages/ui/src/i18n/messages/de.ts
@@ -636,6 +636,41 @@ export const de: PartialMessages = {
     remove: 'Link entfernen',
     urlLabel: 'Link-URL',
   },
+  meetingBlock: {
+    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 abspielen',
+    'saveAudio': 'Audiokopie speichern',
+    'transcript': 'Transkript',
+    'notes': 'Manuelle 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 +839,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..648772b5 100644
--- a/packages/ui/src/i18n/messages/en.ts
+++ b/packages/ui/src/i18n/messages/en.ts
@@ -1077,6 +1077,41 @@ export const en = {
     noPages: 'No pages found',
     noDatabases: 'No databases found',
   },
+  meetingBlock: {
+    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',
+    'saveAudio': 'Save audio copy',
+    'transcript': 'Transcript',
+    'notes': 'Manual 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 an eligible 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 +1291,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..89f4b22b 100644
--- a/packages/ui/src/i18n/messages/ja.ts
+++ b/packages/ui/src/i18n/messages/ja.ts
@@ -631,6 +631,41 @@ export const ja: PartialMessages = {
     remove: 'リンクを解除',
     urlLabel: 'リンク URL',
   },
+  meetingBlock: {
+    addNote: 'メモを追加',
+    'label': '会議',
+    'hint': '音声を録音し、文字起こしとメモを作成',
+    'record': '録音',
+    'pause': '一時停止',
+    'resume': '再開',
+    'stop': '停止',
+    'idle': '準備完了',
+    'requesting': 'マイクを要求中…',
+    'recording': '録音中',
+    'paused': '一時停止中',
+    'processing': '処理中',
+    'done': '完了',
+    'playback': '音声チャンクを再生',
+    '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 +834,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..f8c09fa7 100644
--- a/packages/ui/src/i18n/messages/zh.ts
+++ b/packages/ui/src/i18n/messages/zh.ts
@@ -628,6 +628,41 @@ export const zh: PartialMessages = {
     remove: '移除链接',
     urlLabel: '链接地址',
   },
+  meetingBlock: {
+    addNote: '添加笔记',
+    'label': '会议',
+    'hint': '录音、转写并记笔记',
+    'record': '录音',
+    'pause': '暂停',
+    'resume': '继续',
+    'stop': '停止',
+    'idle': '就绪',
+    'requesting': '正在请求麦克风…',
+    'recording': '录音中',
+    'paused': '已暂停',
+    'processing': '处理中',
+    'done': '完成',
+    'playback': '播放音频片段',
+    '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 +831,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..d30abbb5 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: 8px; 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: 6px; 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..ef1977e7 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). */
@@ -26,6 +29,9 @@ export const setAssetBridge = (next: AssetBridgeImpl | null): void => {
 
 /** 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}> =>

From 17458a3de34c22a5b186c184d64a59f4186f17f0 Mon Sep 17 00:00:00 2001
From: Eliot Lim <eliot.lim@gmail.com>
Date: Sun, 4 Oct 2026 03:02:46 +0800
Subject: [PATCH 2/6] fix(ui): ignore stale microphone permission failures
 (MEET-5)

---
 .../src/blockeditor/__tests__/meetingRecorder.test.tsx | 10 ++++++++++
 packages/ui/src/blockeditor/meetingRecorder.ts         |  1 +
 2 files changed, 11 insertions(+)

diff --git a/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
index 621aa9cc..bd5ea850 100644
--- a/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
+++ b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
@@ -196,6 +196,16 @@ describe('meeting asynchronous boundaries', () => {
     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];
diff --git a/packages/ui/src/blockeditor/meetingRecorder.ts b/packages/ui/src/blockeditor/meetingRecorder.ts
index 05955312..3a600541 100644
--- a/packages/ui/src/blockeditor/meetingRecorder.ts
+++ b/packages/ui/src/blockeditor/meetingRecorder.ts
@@ -86,6 +86,7 @@ export class MeetingRecorder {
       this.beginChunk();
       this.write({status: 'recording'});
     } catch {
+      if (generation !== this.generation) return;
       this.release(); this.mode = 'idle'; this.error = t('meetingBlock.permission'); this.changed();
     }
   }

From 970983e3032b71107a64ac346c9c84481f55c0ba Mon Sep 17 00:00:00 2001
From: Eliot Lim <eliot.lim@gmail.com>
Date: Sun, 4 Oct 2026 03:03:45 +0800
Subject: [PATCH 3/6] docs: report meeting recorder completion (MEET-5)

---
 _report-meet5.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 _report-meet5.md

diff --git a/_report-meet5.md b/_report-meet5.md
new file mode 100644
index 00000000..c8f64081
--- /dev/null
+++ b/_report-meet5.md
@@ -0,0 +1,46 @@
+# MEET-5 — Ellis
+
+MEET-5 complete. Implemented recorder UI on `feat/meet-5-recorder-ui`: standalone 45-second audio files, pause/resume/stop, progressive transcription, upload/transcription recovery, playback, editable CRDT notes, four locales, slash entry/icon, history label, and exports including note children. No push, models, new worktrees, or Playwright captures.
+
+Verified implementation HEAD: `17458a3de34c22a5b186c184d64a59f4186f17f0`. The following report-only commit records this SHA; final branch HEAD is that report commit.
+
+## Verification
+
+`VITEST_MAX_WORKERS=1 pnpm verify` passed in the foreground, **exit 0**, outside the filesystem sandbox (MEET-4 documented sandbox watcher failures). [Full verification log](/Users/eliot/.bb/thread-storage/meet5-verify.log).
+
+- SDK: 32 files / 565 tests passed.
+- UI: 245 files / 2,335 tests passed (15 new MEET-5 tests).
+- App: 2 files / 7 tests passed.
+- Server: 98 files / 1,347 passed / 6 existing skipped. This suite took about 58 minutes.
+- MCP: all 45 catalogue types + 9 plugin blocks covered; no exemptions.
+- E2E: server 256 checks; MCP 70 checks; all passed.
+- ESLint-rule tests, builds, generated-file checks, workspace typechecks and lint passed.
+
+## Criterion → test map
+
+`packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx` (15 tests):
+
+| Criterion | Tests |
+| --- | --- |
+| 1. State machine, permission denial | independent-file pause/resume/stop; permission denial/late grant; stale rejection; UI permission copy |
+| 2. Standalone chunks, ordered audio, recovery | restart without timeslice; durations; exponential upload retries/manual recovery; reverse upload completion; asynchronous final data event; Safari MP4 |
+| 3. Transcription timing/order/retries | segment seconds + chunk offsets; plain-text fallback; delayed first result; 400/403/404/502 recovery; retry deduplication |
+| 4. Persistence, notes, read-only | encode/decode round trip; real BlockEditor note contenteditable assertions; page/group locks disable recording |
+| 5. No-AI / unconfigured | client capability through AssetBridgeHost; recording continues without AI; disabled transcription; Settings → AI error and UI retry |
+| 6. Catalogue drift | unchanged `packages/ui/src/blockeditor/registryCatalogue.test.tsx`, both registry directions and MEET-4 round-trip checks |
+| Addendum: exports | all three projections include title/status/transcript/summary + note children; HTML escaping; corrected fallback comment |
+
+## Merge resolutions
+
+- Merged `feat/meet-1-audio-assets` (`6e5e12de`) then `feat/meet-2-transcribe` (`5ac196b5`).
+- The only content conflict was `ableOidc.test.ts` comments: retained MEET-2 wording, “PAT validation uses the database clock, not the injected OIDC clock.”
+- SDK exports combined without duplicate re-exports; post-merge `pnpm build:libs` passed before feature work.
+- Removed `_brief.md` and `_report.md` as instructed, including the manager addendum. Existing catalogue tests remain untouched.
+
+## Decisions / limits
+
+- Optional `DataClient.supportsTranscription` is false on LocalDataClient; AssetBridgeHost omits transcription there. An unconfigured server still allows retry after Settings → AI changes.
+- Added the forward-compatible top-level `transcriptionCompleted` string array (`offset:assetId`) to remember successful chunks, including silent ones, and prevent duplicate retries after reopening. Existing contracted fields retain their shapes.
+- One in-memory recording session per live CRDT block serializes synchronous prop transactions. The view subscribes through React's external-store hook; failed audio survives view remounts while that document stays alive. Uploads release bytes only after their asset reference is persisted. Failed blobs have retry/download controls and an unload guard; forced browser termination cannot preserve in-memory audio.
+- Transcription is independent of subsequent chunk uploads. Three automatic attempts with 1s/2s backoff, then manual retry; permanent HTTP failures offer immediate actionable recovery.
+- The final review also fixed a cancelled microphone request rejecting after a newer recording began; its regression is included in the green run. No open implementation questions. Full audio export remains MEET-7.

From 9da6774618a47eb87059c1e437339ead8ae99bb1 Mon Sep 17 00:00:00 2001
From: Eliot Lim <eliot.lim@gmail.com>
Date: Sun, 4 Oct 2026 03:21:55 +0800
Subject: [PATCH 4/6] fix(ui): address meeting recorder review findings
 (MEET-5)

---
 .../ui/src/blockeditor/MeetingBlockView.tsx   |  49 +++--
 .../__tests__/meetingRecorder.test.tsx        | 201 +++++++++++++++++-
 packages/ui/src/blockeditor/exportBlocks.ts   |   8 +-
 packages/ui/src/blockeditor/kit/KitFrame.tsx  |   7 +-
 .../ui/src/blockeditor/meetingRecorder.ts     |  66 ++++--
 packages/ui/src/blockeditor/meetingTime.ts    |   7 +
 packages/ui/src/i18n/messages/de.ts           |  68 +++---
 packages/ui/src/i18n/messages/en.ts           |  68 +++---
 packages/ui/src/i18n/messages/ja.ts           |  68 +++---
 packages/ui/src/i18n/messages/zh.ts           |  70 +++---
 packages/ui/src/index.css                     |   4 +-
 packages/ui/src/lib/assetBridge.ts            |   6 +
 12 files changed, 444 insertions(+), 178 deletions(-)
 create mode 100644 packages/ui/src/blockeditor/meetingTime.ts

diff --git a/packages/ui/src/blockeditor/MeetingBlockView.tsx b/packages/ui/src/blockeditor/MeetingBlockView.tsx
index 6fe8ffef..25da2e48 100644
--- a/packages/ui/src/blockeditor/MeetingBlockView.tsx
+++ b/packages/ui/src/blockeditor/MeetingBlockView.tsx
@@ -1,10 +1,11 @@
-import {useEffect, useState, useSyncExternalStore} from 'react';
+import {useEffect, useMemo, useState, useSyncExternalStore} from 'react';
 import {t} from '@/i18n';
-import {assetBridge} from '@/lib/assetBridge';
+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}) {
@@ -22,7 +23,7 @@ function ChunkAudio({audio, blob}: {audio: MeetingAudio; blob?: Blob}) {
     return () => { disposed = true; if (objectUrl) URL.revokeObjectURL(objectUrl); };
   }, [audio.assetId, blob]);
   return url ? <>
-    <audio controls preload="metadata" src={url} aria-label={t('meetingBlock.playback')} />
+    <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;
 }
@@ -31,29 +32,42 @@ export function MeetingBlockView({block, editor, pageReadOnly, children}: Custom
   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); session.stop(); };
-  }, [session]);
+    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 startedAt = blockProp<number>(block, 'startedAt');
-  const elapsed = session.active && startedAt != null ? Date.now() - startedAt
-    : Math.max(0, ...saved.map((audio) => (audio.startedAtMs ?? 0) + audio.durationMs));
+  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 = assetBridge.canTranscribe();
-  return <section className="obe-meeting" aria-label={t('meetingBlock.label')}>
-    <header><strong>{blockProp<string>(block, 'title') || t('meetingBlock.label')}</strong>
-      <span role="status" aria-live="polite">{statusLabel} · {meetingTime(elapsed)}</span></header>
+  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">
-      {!session.active && <button type="button" disabled={readOnly || session.mode === 'processing'} onClick={() => void session.start()}>{t('meetingBlock.record')}</button>}
-      {session.mode === 'recording' && <button type="button" disabled={readOnly} onClick={() => session.pause()}>{t('meetingBlock.pause')}</button>}
-      {session.mode === 'paused' && <button type="button" disabled={readOnly} onClick={() => session.resume()}>{t('meetingBlock.resume')}</button>}
+      <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>
       {session.active && <button type="button" disabled={readOnly} onClick={() => session.stop()}>{t('meetingBlock.stop')}</button>}
     </div>
     {session.error && <p role="alert">{session.error}</p>}
@@ -70,7 +84,7 @@ export function MeetingBlockView({block, editor, pageReadOnly, children}: Custom
           {!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, index) => <li key={`pending-${index}`}>
+      {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>}
@@ -87,6 +101,9 @@ export function MeetingBlockView({block, editor, pageReadOnly, children}: Custom
         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 = {
diff --git a/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
index bd5ea850..0aa95e58 100644
--- a/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
+++ b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
@@ -1,3 +1,5 @@
+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';
@@ -6,9 +8,9 @@ import {registerBlockEditorDoc} from '@/lib/aiBridge';
 import {AssetBridgeHost} from '@/components/AssetBridgeHost';
 import {DataProvider} from '@/data';
 import type {DataClient} from '@book.dev/sdk';
-import {MeetingRecorder, meetingSegments, type MeetingAudio} from '../meetingRecorder';
+import {MeetingRecorder, meetingRecorder, meetingSegments, chunkKey, type MeetingAudio, type RecordingChunk} from '../meetingRecorder';
 import {MeetingBlockView} from '../MeetingBlockView';
-import {blockProp, createDoc, decodeSnapshot, docToJSON, encodeSnapshot, rootBlocks} from '../model';
+import {blockProp, createDoc, decodeSnapshot, docToJSON, encodeSnapshot, rootBlocks, setBlockProp} from '../model';
 import type {BlockEditorController} from '../useBlockEditor';
 import {BlockEditor} from '../BlockEditor';
 import {registerArtifactKit} from '../kit';
@@ -46,7 +48,7 @@ function harness(props = {}) {
 const flush = async (): Promise<void> => { for (let i = 0; i < 20; i += 1) await Promise.resolve(); };
 beforeEach(() => {
   vi.useFakeTimers(); vi.setSystemTime(100000);
-  // jsdom's Blob lacks arrayBuffer; the mock recorder's payload is opaque.
+  // 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}});
@@ -56,7 +58,7 @@ beforeEach(() => {
   transcribeAsset.mockReset().mockResolvedValue({text: 'hello', segments: [{start: 0.25, end: 1.5, text: 'hello'}], durationMs: 2000});
   setAssetBridge({putAsset, getAsset: async () => null, transcribeAsset});
 });
-afterEach(() => { cleanup(); setAssetBridge(null); vi.useRealTimers(); vi.unstubAllGlobals(); });
+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 () => {
@@ -77,10 +79,10 @@ describe('meeting recording and recovery', () => {
     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: 48000},
+      {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: 48250, endMs: 49500, text: 'hello'},
+      {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();
@@ -94,7 +96,7 @@ describe('meeting recording and recovery', () => {
     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('processing'); expect(transcribeAsset).not.toHaveBeenCalled();
+    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');
@@ -128,6 +130,7 @@ describe('meeting recording and recovery', () => {
     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 () => {
@@ -170,12 +173,12 @@ describe('meeting UI and exports', () => {
     expect(putAsset).toHaveBeenCalled(); expect(transcribeAsset).not.toHaveBeenCalled(); unregister();
   });
 
-  it('exports title, status, timestamped transcript, summary and nested notes in all three projections', () => {
+  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).toContain('done'); expect(output).toContain('1:01');
+      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;');
@@ -245,3 +248,183 @@ describe('meeting asynchronous boundaries', () => {
     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);
+    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Stop'})); await flush(); });
+    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 cd4c88c8..7a561b65 100644
--- a/packages/ui/src/blockeditor/exportBlocks.ts
+++ b/packages/ui/src/blockeditor/exportBlocks.ts
@@ -8,16 +8,14 @@ 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')), String(p.status ?? 'idle'),
-    ...segments.map((segment) => {
-      const seconds = Math.floor(segment.startMs / 1000);
-      return `[${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')}] ${segment.text}`;
-    }), ...(p.summary ? [String(p.summary)] : [])];
+  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.
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/meetingRecorder.ts b/packages/ui/src/blockeditor/meetingRecorder.ts
index 3a600541..b6e585c7 100644
--- a/packages/ui/src/blockeditor/meetingRecorder.ts
+++ b/packages/ui/src/blockeditor/meetingRecorder.ts
@@ -8,6 +8,7 @@ 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';
@@ -15,7 +16,7 @@ export interface RecordingChunk {
   busy?: boolean;
 }
 export const chunkKey = (audio: MeetingAudio): string => `${audio.startedAtMs ?? 0}:${audio.assetId}`;
-export const meetingTime = (ms: number): string => `${Math.floor(ms / 60000)}:${String(Math.floor(ms / 1000) % 60).padStart(2, '0')}`;
+export {meetingTime} from './meetingTime';
 
 export function meetingSegments(result: AiTranscriptionResult, audio: MeetingAudio): MeetingSegment[] {
   const offset = audio.startedAtMs ?? 0;
@@ -39,6 +40,9 @@ 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>;
@@ -47,7 +51,7 @@ export class MeetingRecorder {
   private listeners = new Set<() => void>();
   private pending = 0;
   private finalizing = false;
-  constructor(private editor: BlockEditorController, private block: BlockMap, private pageId: string) {}
+  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);
@@ -56,7 +60,7 @@ export class MeetingRecorder {
   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) window.addEventListener('beforeunload', this.protect);
+    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());
   }
@@ -68,8 +72,23 @@ export class MeetingRecorder {
   }
   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.editor.readOnly) return;
+    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) {
@@ -80,6 +99,11 @@ export class MeetingRecorder {
     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';
@@ -96,17 +120,26 @@ export class MeetingRecorder {
     const recorder = new MediaRecorder(this.stream!, {audioBitsPerSecond: 64000, ...(mimeType ? {mimeType} : {})});
     this.recorder = recorder;
     const started = Date.now();
-    const offset = Math.max(0, started - (blockProp<number>(this.block, 'startedAt') ?? started));
+    this.currentStarted = started;
+    const offset = this.capturedMs ?? this.closedDuration();
     const parts: Blob[] = [];
-    let ended = started;
+    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 = {blob, audio: {assetId: '', durationMs: Math.max(0, ended - started), startedAtMs: offset}, phase: 'uploading'};
+        const chunk: RecordingChunk = {id: crypto.randomUUID(), blob, audio: {assetId: '', durationMs: duration!, startedAtMs: offset}, phase: 'uploading'};
         this.chunks.push(chunk);
         void this.upload(chunk);
       }
@@ -118,7 +151,7 @@ export class MeetingRecorder {
     // Restart, don't request timeslices: each file must have its own container header.
     recorder.start();
     this.timer = setTimeout(() => this.finishChunk(), 45000);
-    this.finishCurrent = () => { ended = Date.now(); recorder.stop(); };
+    this.finishCurrent = () => { closeDuration(); recorder.stop(); };
   }
   private finishCurrent?: () => void;
   private finishChunk(): void {
@@ -134,10 +167,10 @@ export class MeetingRecorder {
     this.changed();
   }
   resume(): void {
-    if (this.mode !== 'paused' || this.finalizing) return;
+    if (this.mode !== 'paused' || this.readOnly) return;
     this.stream?.getAudioTracks().forEach((track) => { track.enabled = true; });
     this.mode = 'recording';
-    try { this.beginChunk(); } catch { this.error = t('meetingBlock.captureFailed'); this.stop(); }
+    try { if (!this.finalizing) this.beginChunk(); } catch { this.error = t('meetingBlock.captureFailed'); this.stop(); }
     this.changed();
   }
   stop(): void {
@@ -151,8 +184,10 @@ export class MeetingRecorder {
     this.stream?.getTracks().forEach((track) => track.stop()); this.stream = undefined;
   }
   private settle(): void {
-    if (this.mode === 'processing' && !this.pending && !this.finalizing && !this.unsaved) {
-      this.mode = 'done'; this.write({status: 'done'});
+    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> {
@@ -189,13 +224,14 @@ export class MeetingRecorder {
     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)) return;
+    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 transcript = blockProp<MeetingSegment[]>(this.block, 'transcript') ?? [];
       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),
@@ -210,7 +246,7 @@ export class MeetingRecorder {
   }
   retry(audio: MeetingAudio): void {
     let chunk = this.chunks.find((item) => chunkKey(item.audio) === chunkKey(audio));
-    if (!chunk) { chunk = {audio, phase: 'untranscribed'}; this.chunks.push(chunk); }
+    if (!chunk) { chunk = {id: crypto.randomUUID(), audio, phase: 'untranscribed'}; this.chunks.push(chunk); }
     void this.transcribe(chunk);
   }
 }
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/i18n/messages/de.ts b/packages/ui/src/i18n/messages/de.ts
index 5b4d29d1..74d88ec2 100644
--- a/packages/ui/src/i18n/messages/de.ts
+++ b/packages/ui/src/i18n/messages/de.ts
@@ -637,39 +637,43 @@ export const de: PartialMessages = {
     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 abspielen',
-    'saveAudio': 'Audiokopie speichern',
-    'transcript': 'Transkript',
-    'notes': 'Manuelle 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'
+    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',
diff --git a/packages/ui/src/i18n/messages/en.ts b/packages/ui/src/i18n/messages/en.ts
index 648772b5..298154c9 100644
--- a/packages/ui/src/i18n/messages/en.ts
+++ b/packages/ui/src/i18n/messages/en.ts
@@ -1078,39 +1078,43 @@ export const en = {
     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',
-    'saveAudio': 'Save audio copy',
-    'transcript': 'Transcript',
-    'notes': 'Manual 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 an eligible 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'
+    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',
diff --git a/packages/ui/src/i18n/messages/ja.ts b/packages/ui/src/i18n/messages/ja.ts
index 89f4b22b..ab4f9a78 100644
--- a/packages/ui/src/i18n/messages/ja.ts
+++ b/packages/ui/src/i18n/messages/ja.ts
@@ -632,39 +632,43 @@ export const ja: PartialMessages = {
     urlLabel: 'リンク URL',
   },
   meetingBlock: {
+    locked: 'セクションにより会議がロックされています',
+    readOnly: '読み取り専用の会議',
+    elsewhere: '別のクライアントで録音または処理中です。',
+    incomplete: '文字起こしは未完了です',
     addNote: 'メモを追加',
-    'label': '会議',
-    'hint': '音声を録音し、文字起こしとメモを作成',
-    'record': '録音',
-    'pause': '一時停止',
-    'resume': '再開',
-    'stop': '停止',
-    'idle': '準備完了',
-    'requesting': 'マイクを要求中…',
-    'recording': '録音中',
-    'paused': '一時停止中',
-    'processing': '処理中',
-    'done': '完了',
-    'playback': '音声チャンクを再生',
-    'saveAudio': '音声のコピーを保存',
-    'transcript': '文字起こし',
-    'notes': '手動メモ',
-    'noAI': '文字起こしには接続されたOpenBookサーバーが必要です。録音とメモは引き続き利用できます。',
-    'noStore': '録音するにはアセットストアに接続し、保存済みページを開いてください。',
-    'unsupported': 'このブラウザーはマイク録音に対応していません。',
-    'permission': 'マイクにアクセスできません。ブラウザーの設定でアクセスを許可してから再試行してください。',
-    'captureFailed': '録音が予期せず停止しました。録音済みの音声を保存しています。',
-    'unconfigured': '設定 → AIで文字起こしを構成してから再試行してください。',
-    'forbidden': '文字起こしには利用資格のあるアカウントへのログインとページへのアクセスが必要です。',
-    'missing': '音声またはページが見つかりません。アクセス権を確認して再試行してください。',
-    'transcriptionFailed': '文字起こしに失敗しました。音声は保存されています。サービスが利用可能になったら再試行してください。',
-    'uploading': '音声を保存中…',
-    'uploadFailed': '音声のアップロードに失敗しました。このページを開いたまま再試行するか、音声のコピーを保存してください。',
-    'retryUpload': 'アップロードを再試行',
-    'transcribing': '文字起こし中…',
-    'untranscribed': '未文字起こし',
-    'transcribed': '文字起こし済み',
-    'retryTranscription': '文字起こしを再試行'
+    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: 'フォーム',
diff --git a/packages/ui/src/i18n/messages/zh.ts b/packages/ui/src/i18n/messages/zh.ts
index f8c09fa7..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: '停止',
@@ -629,39 +629,43 @@ export const zh: PartialMessages = {
     urlLabel: '链接地址',
   },
   meetingBlock: {
+    locked: '会议已被所在分区锁定',
+    readOnly: '只读会议',
+    elsewhere: '正在其他客户端上录音或处理。',
+    incomplete: '转写尚未完成',
     addNote: '添加笔记',
-    'label': '会议',
-    'hint': '录音、转写并记笔记',
-    'record': '录音',
-    'pause': '暂停',
-    'resume': '继续',
-    'stop': '停止',
-    'idle': '就绪',
-    'requesting': '正在请求麦克风…',
-    'recording': '录音中',
-    'paused': '已暂停',
-    'processing': '处理中',
-    'done': '完成',
-    'playback': '播放音频片段',
-    'saveAudio': '保存音频副本',
-    'transcript': '转写文本',
-    'notes': '手动笔记',
-    'noAI': '转写需要连接到OpenBook服务器。录音和笔记仍可使用。',
-    'noStore': '请连接资源存储并打开已保存的页面以开始录音。',
-    'unsupported': '此浏览器不支持麦克风录音。',
-    'permission': '无法访问麦克风。请在浏览器设置中允许访问后重试。',
-    'captureFailed': '录音意外停止。正在保存已录制的音频。',
-    'unconfigured': '请在设置 → AI中配置转写，然后重试。',
-    'forbidden': '转写需要符合条件的登录账号和页面访问权限。',
-    'missing': '未找到音频或页面。请检查访问权限后重试。',
-    'transcriptionFailed': '转写失败。音频已保存，请在服务可用时重试。',
-    'uploading': '正在保存音频…',
-    'uploadFailed': '音频上传失败。请保持此页面打开，重试或保存音频副本。',
-    'retryUpload': '重试上传',
-    'transcribing': '正在转写…',
-    'untranscribed': '未转写',
-    'transcribed': '已转写',
-    'retryTranscription': '重试转写'
+    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: '表单',
diff --git a/packages/ui/src/index.css b/packages/ui/src/index.css
index d30abbb5..3250ea45 100644
--- a/packages/ui/src/index.css
+++ b/packages/ui/src/index.css
@@ -3941,10 +3941,10 @@ a.obe-mention {
 .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: 8px; padding: 16px; }
+.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: 6px; padding: 6px 12px; cursor: pointer; }
+.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; }
diff --git a/packages/ui/src/lib/assetBridge.ts b/packages/ui/src/lib/assetBridge.ts
index ef1977e7..406f3454 100644
--- a/packages/ui/src/lib/assetBridge.ts
+++ b/packages/ui/src/lib/assetBridge.ts
@@ -21,10 +21,16 @@ 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). */

From 4d27b957738cfa179dfaba20e2b87593b903be06 Mon Sep 17 00:00:00 2001
From: Eliot Lim <eliot.lim@gmail.com>
Date: Sun, 4 Oct 2026 04:31:32 +0800
Subject: [PATCH 5/6] chore: drop worker artifacts (MEET-5)

---
 _brief-meet5.md  | 45 ---------------------------------------------
 _report-meet5.md | 46 ----------------------------------------------
 2 files changed, 91 deletions(-)
 delete mode 100644 _brief-meet5.md
 delete mode 100644 _report-meet5.md

diff --git a/_brief-meet5.md b/_brief-meet5.md
deleted file mode 100644
index 2ba8a8fd..00000000
--- a/_brief-meet5.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# MEET-5 — Recorder UI: meeting block view, progressive transcript, manual notes
-
-You are Ellis, an OpenBook Worker agent. Work in THIS worktree (`/Users/eliot/Workspaces/OpenBook-wt-meet-4`). Do NOT push. Conventional commits (`feat(ui): … (MEET-5)`), committed incrementally. DISK IS NEARLY FULL (~1.5 GiB free): do not download models or create worktrees; clean any large temp artifacts you produce.
-
-## Branch setup (do this first, carefully)
-1. `git checkout -b feat/meet-5-recorder-ui` (from current HEAD = feat/meet-4-meeting-catalogue).
-2. `git merge feat/meet-1-audio-assets` then `git merge feat/meet-2-transcribe`. Expected conflicts are trivial:
-   - `packages/server/src/ableOidc.test.ts`: all three branches contain the identical code line `expiresAt: new Date(Date.now() + 60_000)`; conflicts are comment-only. Resolve keeping MEET-2's comment wording (PAT validation uses the database clock, not the injected OIDC clock).
-   - Possible add/add in `packages/sdk/src/index.ts` export lines — keep BOTH exports, watch for duplicated re-export lines (known trap).
-   - `_brief.md`/`_report.md` conflicts: resolve by DELETING these files (they're being stripped from all branches).
-3. After the merges, run `pnpm build:libs` (semantic-conflict check) before starting feature work.
-
-## What you're building
-The real `meeting` block UI, replacing MEET-4's placeholder shell (registered via registerArtifactKit — find it and replace its renderer; keep registration/drift-guard structure intact).
-
-### Contracts you MUST follow (already merged into your branch)
-- **Block props (MEET-4 contract, in `_report.md` at git ref 1f97ba06 — read `git show 1f97ba06:_report.md`):** props `status ('idle'|'recording'|'processing'|'done')`, `audioChunks [{assetId, durationMs, startedAtMs?}]` (startedAtMs = offset from meeting start), `transcript [{startMs, endMs, text}]` (offsets relative to meeting start, ms), `summary` (plain string), `startedAt` (epoch ms), `title?`. Arrays replace wholesale — batch and serialize your writes (single writer: the recording client). Manual notes = ordinary CRDT child blocks; MEET-4's shell stored them — render them as an editable notes region (children editing inside a kit block: see how form/KitFrame handles nested content; follow useKitLock + editor.readOnly semantics, BlockEditor.tsx ~:2429-2449).
-- **Transcription API (MEET-2):** `client.transcribeAsset(assetId, pageId)` → `{text, segments?[{start,end,text}] (SECONDS), durationMs}`. Convert segment seconds → ms and offset by the chunk's startedAtMs when appending to `transcript`. Errors: 400 (unconfigured → show actionable copy pointing at Settings → AI), 403 (guest/paid gate), 404, 502. LocalDataClient rejects AI — degrade gracefully (recording + notes still work; transcription affordance disabled with clear copy).
-- **Audio upload (MEET-1):** audio mimes webm/ogg/mpeg/mp4/wav accepted by the asset store; 10 MiB/asset cap. Upload chunks via the assetBridge (ui/src/lib/assetBridge.ts; ImageBlockView.tsx is the bytes↔objectURL reference).
-
-### Recording behavior
-- getUserMedia + MediaRecorder. **Restart MediaRecorder per ~45s chunk so every chunk is a standalone playable file** (do NOT use one recorder with timeslice — those blobs aren't independently decodable). Prefer `audio/webm;codecs=opus`, probe with MediaRecorder.isTypeSupported and fall back (Safari → audio/mp4).
-- Controls: record / pause / resume / stop; elapsed timer; per-chunk progress. Status prop transitions idle→recording→processing→done.
-- Per chunk pipeline: finalize blob → upload asset → append to audioChunks prop → transcribeAsset → append converted segments to transcript prop. Transcript grows during the meeting. Chunk upload MUST succeed/retry even if transcription fails (flag untranscribed chunks, offer per-chunk retry). Exponential backoff; never lose audio; ephemeral state (recorder handle, retry queue, errors) in React state, durable state in props within editor.doc.transact.
-- Mic-permission denied → graceful copy, no crash. Playback: simple per-chunk <audio> playback from object URLs is sufficient for v1.
-
-### Surfaces
-- Slash-menu entry + icon for `meeting` (SlashMenu.tsx pattern ~:242-249).
-- i18n ×4 (en/de/ja/zh — follow the formBlock namespace pattern), obe-* CSS in ui/src/index.css, VersionDiff label.
-- Export serializers: minimal stub — transcript as timestamped paragraphs + summary text in exportBlocks.ts so exports don't break; full export work is MEET-7 (do not build audio export).
-- a11y: controls labelled, recording status via aria-live, transcript selectable/copyable.
-
-## Acceptance (each maps to a test; ui unit tests with mocked MediaRecorder/getUserMedia/assetBridge/client)
-1. State machine incl. pause/resume and permission-denied path.
-2. Chunking: recorder restarted per chunk; chunk blob uploaded; audioChunks appended in order with durations.
-3. Transcription append: seconds→ms conversion + startedAtMs offset correct; failed transcription leaves chunk flagged + retryable; transcript ordering stable.
-4. Props persistence through serialize round-trip; notes children render and stay editable per lock/readOnly semantics; read-only page → no recording controls active.
-5. No-AI (LocalDataClient) and unconfigured (400) degradation copy.
-6. Drift guards still green (registryCatalogue both directions), existing MEET-4 catalogue tests untouched.
-
-## Definition of done
-- `pnpm verify` green FOREGROUND (serialize with VITEST_MAX_WORKERS=1 if parallel flakes on money.test.ts — known host-load flake, do not modify that test).
-- All committed; no push. Write `_report-meet5.md`: outcome, head sha, merge-resolution notes, criterion→test map, deviations, open questions. Terse.
-- Do NOT produce Playwright captures (your sandbox can't launch Chromium; the manager handles captures at PR time).
-- Never delete/weaken existing tests. If wedged after a real attempt, commit and report where.
diff --git a/_report-meet5.md b/_report-meet5.md
deleted file mode 100644
index c8f64081..00000000
--- a/_report-meet5.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# MEET-5 — Ellis
-
-MEET-5 complete. Implemented recorder UI on `feat/meet-5-recorder-ui`: standalone 45-second audio files, pause/resume/stop, progressive transcription, upload/transcription recovery, playback, editable CRDT notes, four locales, slash entry/icon, history label, and exports including note children. No push, models, new worktrees, or Playwright captures.
-
-Verified implementation HEAD: `17458a3de34c22a5b186c184d64a59f4186f17f0`. The following report-only commit records this SHA; final branch HEAD is that report commit.
-
-## Verification
-
-`VITEST_MAX_WORKERS=1 pnpm verify` passed in the foreground, **exit 0**, outside the filesystem sandbox (MEET-4 documented sandbox watcher failures). [Full verification log](/Users/eliot/.bb/thread-storage/meet5-verify.log).
-
-- SDK: 32 files / 565 tests passed.
-- UI: 245 files / 2,335 tests passed (15 new MEET-5 tests).
-- App: 2 files / 7 tests passed.
-- Server: 98 files / 1,347 passed / 6 existing skipped. This suite took about 58 minutes.
-- MCP: all 45 catalogue types + 9 plugin blocks covered; no exemptions.
-- E2E: server 256 checks; MCP 70 checks; all passed.
-- ESLint-rule tests, builds, generated-file checks, workspace typechecks and lint passed.
-
-## Criterion → test map
-
-`packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx` (15 tests):
-
-| Criterion | Tests |
-| --- | --- |
-| 1. State machine, permission denial | independent-file pause/resume/stop; permission denial/late grant; stale rejection; UI permission copy |
-| 2. Standalone chunks, ordered audio, recovery | restart without timeslice; durations; exponential upload retries/manual recovery; reverse upload completion; asynchronous final data event; Safari MP4 |
-| 3. Transcription timing/order/retries | segment seconds + chunk offsets; plain-text fallback; delayed first result; 400/403/404/502 recovery; retry deduplication |
-| 4. Persistence, notes, read-only | encode/decode round trip; real BlockEditor note contenteditable assertions; page/group locks disable recording |
-| 5. No-AI / unconfigured | client capability through AssetBridgeHost; recording continues without AI; disabled transcription; Settings → AI error and UI retry |
-| 6. Catalogue drift | unchanged `packages/ui/src/blockeditor/registryCatalogue.test.tsx`, both registry directions and MEET-4 round-trip checks |
-| Addendum: exports | all three projections include title/status/transcript/summary + note children; HTML escaping; corrected fallback comment |
-
-## Merge resolutions
-
-- Merged `feat/meet-1-audio-assets` (`6e5e12de`) then `feat/meet-2-transcribe` (`5ac196b5`).
-- The only content conflict was `ableOidc.test.ts` comments: retained MEET-2 wording, “PAT validation uses the database clock, not the injected OIDC clock.”
-- SDK exports combined without duplicate re-exports; post-merge `pnpm build:libs` passed before feature work.
-- Removed `_brief.md` and `_report.md` as instructed, including the manager addendum. Existing catalogue tests remain untouched.
-
-## Decisions / limits
-
-- Optional `DataClient.supportsTranscription` is false on LocalDataClient; AssetBridgeHost omits transcription there. An unconfigured server still allows retry after Settings → AI changes.
-- Added the forward-compatible top-level `transcriptionCompleted` string array (`offset:assetId`) to remember successful chunks, including silent ones, and prevent duplicate retries after reopening. Existing contracted fields retain their shapes.
-- One in-memory recording session per live CRDT block serializes synchronous prop transactions. The view subscribes through React's external-store hook; failed audio survives view remounts while that document stays alive. Uploads release bytes only after their asset reference is persisted. Failed blobs have retry/download controls and an unload guard; forced browser termination cannot preserve in-memory audio.
-- Transcription is independent of subsequent chunk uploads. Three automatic attempts with 1s/2s backoff, then manual retry; permanent HTTP failures offer immediate actionable recovery.
-- The final review also fixed a cancelled microphone request rejecting after a newer recording began; its regression is included in the green run. No open implementation questions. Full audio export remains MEET-7.

From e7da15bdf95dc45c076240b003e887993d1c0c59 Mon Sep 17 00:00:00 2001
From: Eliot Lim <eliot.lim@gmail.com>
Date: Sun, 4 Oct 2026 04:37:22 +0800
Subject: [PATCH 6/6] fix(ui): keep focus after stopping a recording (MEET-5)

---
 packages/ui/src/blockeditor/MeetingBlockView.tsx              | 2 +-
 .../ui/src/blockeditor/__tests__/meetingRecorder.test.tsx     | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/ui/src/blockeditor/MeetingBlockView.tsx b/packages/ui/src/blockeditor/MeetingBlockView.tsx
index 25da2e48..df1edf8a 100644
--- a/packages/ui/src/blockeditor/MeetingBlockView.tsx
+++ b/packages/ui/src/blockeditor/MeetingBlockView.tsx
@@ -68,7 +68,7 @@ export function MeetingBlockView({block, editor, pageReadOnly, children}: Custom
         }}>
         {t(`meetingBlock.${session.mode === 'recording' ? 'pause' : session.mode === 'paused' ? 'resume' : session.mode === 'requesting' ? 'requesting' : 'record'}`)}
       </button>
-      {session.active && <button type="button" disabled={readOnly} onClick={() => session.stop()}>{t('meetingBlock.stop')}</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>}
diff --git a/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
index 0aa95e58..34daad4e 100644
--- a/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
+++ b/packages/ui/src/blockeditor/__tests__/meetingRecorder.test.tsx
@@ -318,7 +318,9 @@ describe('MEET-5 review regressions', () => {
     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);
-    await act(async () => { fireEvent.click(screen.getByRole('button', {name: 'Stop'})); await flush(); });
+    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();
   });