diff --git a/.claude/skills/verify-openminutes/SKILL.md b/.claude/skills/verify-openminutes/SKILL.md
index 91151e8..3f420e6 100644
--- a/.claude/skills/verify-openminutes/SKILL.md
+++ b/.claude/skills/verify-openminutes/SKILL.md
@@ -14,7 +14,7 @@ description: 在本机隔离启动 OpenMinutes，用无头 Chrome/Edge 验证导
 - **默认复用桌面 Floatboat 的 Host，不另起 Host。** launch 检查 Floatboat 进程、本 appId 最新连接配置、监听端口的进程归属，以及只读 `capabilities.list`。任一步失败便停止，不自动降级；显式 `--no-host` 或 `VERIFY_HOST_MODE=none` 才禁用 Host。
 - **Host 地址属于本机敏感信息。** 只从 `%APPDATA%/floatboat/workbench/connections/*.json` 读取连接配置，只复制 `hostConnection.url` 到本 run 的 `workbench-config.json`。不复制真实数据目录、端口或其它启动字段；不打印地址、不把配置放入证据、不提交它。cleanup 删除临时配置。
 - **真实 ASR/LLM 消耗额度。** 使用 `speech.mjs` 的短语音，每条只点一次转录/归类；失败后先读证据，不盲目重跑配方。`evidence.mjs` 从隔离库统计 `asr.start` 和 `llm.*`，包含自动重试/回退。能力探测不发起计费调用，也不能证明上游模型一定可用。实时字幕/BLE 不在本配方覆盖范围。
-- **BLE 设备不要碰。** 设备页的「连接并检测」「读取清单」「下载」会通过本机 Python + bleak 真正连无线电。launch 已关闭 `auto_connect` / `auto_pull`，驱动时也不要点这几个按钮。
+- **真实录音笔不要碰。** 录音笔页的「连接」「同步录音」「断开连接」「清理已同步的录音」以及列表里的「同步」会通过本机 Python + bleak 真正连无线电；同步大录音还会**真实切换本机 Wi-Fi**（连上录音笔热点、断开外网），清理会删除录音笔上的文件。**禁止对真实录音笔执行同步**，e2e 只用 `--fake-device`。launch 已关闭 `auto_connect` / `auto_pull`；没有 `--fake-device` 时驱动也不要点这些按钮。真机验收交给用户按清单执行。
 - **不要驱动不是本次 run 启动的实例。** 用户的 Floatboat 里可能开着同一个应用（数据在 `%APPDATA%\floatboat\workbench\data\workbench.3bb3830b-…`），那是真实数据，绝不读写、绝不 kill。
 - 多个 run 可以并行：端口随机、数据目录 / 收件目录 / 归档目录 / 浏览器 profile 都按 runId 隔离。
 
@@ -24,8 +24,11 @@ description: 在本机隔离启动 OpenMinutes，用无头 Chrome/Edge 验证导
 node .claude/skills/verify-openminutes/scripts/build.mjs          # ~10s；严格类型检查 + 打包到 dist/，失败时打印诊断并 exit 1
 node .claude/skills/verify-openminutes/scripts/launch.mjs <runId>  # runId 省略则生成 UUID
 node .claude/skills/verify-openminutes/scripts/launch.mjs <runId> --no-host  # 显式验证无 Host 失败路径
+MEMOTALK_TEST_PYTHON=<装了 memotalk-sdk 的解释器> node .claude/skills/verify-openminutes/scripts/launch.mjs <runId> --no-host --fake-device=wifi  # 假录音笔：wifi | ble | absent
 ```
 
+- `--fake-device=<wifi|ble|absent>` 设置 `OPENMINUTES_FAKE_DEVICE`，把 `python_path` 写成 `MEMOTALK_TEST_PYTHON`（缺少时报错退出），并用 ffmpeg 在 `$R/fake-device/` 生成 3 段真实 mp3（约 2.1 MiB、1.2 MiB、160 KiB）作为录音笔里的文件。`wifi` 走无线快传（内存 FTP），`ble` 模拟入网失败以验证「已改用蓝牙」，`absent` 模拟找不到录音笔。假设备 prelude 会让任何 `netsh` / `nmcli` / `networksetup` 调用直接抛错，保证不改动本机网络。模式写进 `run.json`，doctor 会输出当前模式。
+
 - 要验收另一个 worktree 或分支的代码时，给每条命令都加上 `OPENMINUTES_ROOT=<那个 checkout 的绝对路径>`。build、run 目录和证据都会落在那个 checkout 里，不需要往它里面复制 skill。
 - 每次使用全新 runId；即使 cleanup 已执行，旧证据目录仍然保留，launch 会拒绝复用该 id，防止读取旧日志的 ready 地址或混合不同运行的证据。
 - `build.mjs` 调用 `C:/Program Files/Floatboat/resources/workbench-toolchain/compiler.mjs`（可用 `FLOATBOAT_TOOLCHAIN` 覆盖），产物与 Host 构建一致。改了 `src/` 之后必须重新 build 再 launch，否则验证的是旧代码（doctor 会报 `dist/ is older than src/`）。
@@ -42,7 +45,7 @@ node .claude/skills/verify-openminutes/scripts/launch.mjs <runId> --no-host  # 
 node .claude/skills/verify-openminutes/scripts/doctor.mjs <runId>
 ```
 
-只读检查，exit 0 才能继续驱动。它用 run 的 nonce 请求 `/__workbench/health`，确认端口上的进程就是本 run 启动的（pid、generation 一致）；确认隔离设置仍然生效（导入/归档目录指向本 run，四个 auto 开关为 `0`）；确认 `dist/` 不比 `src/` 旧。任何异常（页面空白、接口 404、数据对不上）都先跑它。如果报告设置被改，说明刚才的操作（例如设备页「保存路径」）覆盖了隔离，这个 run 应该 cleanup 后重来。
+只读检查，exit 0 才能继续驱动。它用 run 的 nonce 请求 `/__workbench/health`，确认端口上的进程就是本 run 启动的（pid、generation 一致）；确认隔离设置仍然生效（导入/归档目录指向本 run，四个 auto 开关为 `0`）；确认 `dist/` 不比 `src/` 旧。任何异常（页面空白、接口 404、数据对不上）都先跑它。如果报告设置被改，说明刚才的操作（例如在「设置 › 通用」里保存了目录）覆盖了隔离，这个 run 应该 cleanup 后重来。
 
 Host 模式另检查 Floatboat 监听归属，并发送一次 `capabilities.list`。输出 `host: {mode, available, probe}`，不输出连接地址或能力响应原文；显式无 Host 模式显示 `mode: "none", available: false`，不调用 Host。Floatboat 重启后旧地址可能失效，此时 cleanup 后重新 launch。
 
@@ -55,15 +58,17 @@ node .claude/skills/verify-openminutes/scripts/browse.mjs <runId> <label> '<step
 node .claude/skills/verify-openminutes/scripts/browse.mjs <runId> <label> @steps.json
 ```
 
-步骤与选择器的完整说明写在脚本头部注释里。选择器优先用 `aria=<aria-label>`（例如 `aria=搜索录音`），其次 `text=<完整可见文字>`（例如 `text=立即扫描`），最后才用 CSS（例如 `button.row__main`）。任何一步失败都会打印 `FAIL …` 并以 exit 1 结束，`steps.log` 里保留已完成的步骤。步骤里如果有 `eval`，并且 JS 中含有引号，请先把步骤写进 JSON 文件，再用 `@file` 传入；在 shell 单引号里多层转义很容易写坏，表现为 `SyntaxError: Invalid or unexpected token`。
+步骤与选择器的完整说明写在脚本头部注释里。选择器优先用 `aria=<aria-label>`（例如 `aria=搜索录音`），其次 `text=<完整可见文字>`（例如 `text=扫描并导入`），最后才用 CSS（例如 `button.row__main`）。任何一步失败都会打印 `FAIL …` 并以 exit 1 结束，`steps.log` 里保留已完成的步骤。步骤里如果有 `eval`，并且 JS 中含有引号，请先把步骤写进 JSON 文件，再用 `@file` 传入；在 shell 单引号里多层转义很容易写坏，表现为 `SyntaxError: Invalid or unexpected token`。
 
 示例：打开录音库并进入第一条录音的详情。
 
 ```bash
-node .claude/skills/verify-openminutes/scripts/browse.mjs <runId> open-detail '[{"goto":"#/library"},{"waitFor":"button.row__main"},{"click":"button.row__main"},{"waitText":"返回录音库"},{"eval":"location.hash"},{"screenshot":"detail.png"},{"aria":"detail.aria.txt"}]'
+node .claude/skills/verify-openminutes/scripts/browse.mjs <runId> open-detail '[{"goto":"#/library"},{"waitFor":"button.row__main"},{"click":"button.row__main"},{"waitText":"返回录音"},{"eval":"location.hash"},{"screenshot":"detail.png"},{"aria":"detail.aria.txt"}]'
 ```
 
-页面路由：`#/overview`、`#/library`、`#/rec/<id>`、`#/live`、`#/device`、`#/categories`、`#/settings`。侧边导航是 `navigation "主导航"` 下的按钮（概览 / 录音库 / 实时字幕 / 设备接入 / 分类 / 设置）。
+页面路由：`#/library`（默认，可带 `?stage=failed|ready|transcribed|pending`）、`#/rec/<id>`、`#/device`、`#/live`、`#/calendar`（可带 `?day=YYYY-MM-DD&rec=<id>`）、`#/categories`、`#/settings`、`#/settings/diagnostics`。`#/overview` 和未知哈希会被改写为 `#/library`。侧边导航是 `navigation "主导航"` 下的 6 个按钮：录音 / 录音笔 / 实时字幕 / 日历 / 分类 / 设置，每页 `<h1>` 与导航标签一致。详情页的返回按钮文字随来源变化（「返回录音」「返回日历」）。
+
+入口速查（每个功能只有一个入口）：导入本地文件夹在录音页头「导入」→「扫描并导入」；连接、同步录音、断开连接、清理已同步的录音、停止只在录音笔页；录音与日程的关联只在日历页；本机环境、Python/ffmpeg 路径、传输方式、最近设备操作、设备协议指令参考、手动登记清单只在「设置 › 诊断与高级」（`#/settings/diagnostics`，自动展开 `details#diagnostics`）。错误主行是中文结论，技术原文要点「查看详情」才出现。
 
 **接口**：直接用 curl 打 `run.json` 里的 url，不需要鉴权。响应格式是 `{ ok, data | error }`。
 
@@ -115,7 +120,7 @@ powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \"Name='ch
 | 脚本 | 作用 |
 | --- | --- |
 | `scripts/build.mjs` | 用 Floatboat 编译器构建 `dist/` |
-| `scripts/launch.mjs [runId]` | 启动隔离实例，并写入 `run.json` |
+| `scripts/launch.mjs [runId] [--no-host] [--fake-device=wifi\|ble\|absent]` | 启动隔离实例（可选假录音笔），并写入 `run.json` |
 | `scripts/doctor.mjs <runId>` | 只读体检，exit 0 才可以继续驱动 |
 | `scripts/browse.mjs <runId> <label> <steps>` | 无头浏览器驱动页面，并留存证据 |
 | `scripts/cleanup.mjs <runId>` | 停掉本 run 的进程并删除 scratch，保留证据 |
diff --git a/.claude/skills/verify-openminutes/features/README.md b/.claude/skills/verify-openminutes/features/README.md
index a88196c..fe43736 100644
--- a/.claude/skills/verify-openminutes/features/README.md
+++ b/.claude/skills/verify-openminutes/features/README.md
@@ -26,11 +26,20 @@
 
 ## 功能
 
-- [目录导入](./directory-import.md)：把 MP3 放进收件目录，扫描、复制入库并去重。
+导航固定 6 项：录音 / 录音笔 / 实时字幕 / 日历 / 分类 / 设置，每个功能只有一个入口（入口速查见 SKILL.md「Drive」）。
+
+- [目录导入](./directory-import.md)：录音页头「导入」对话框，扫描收件目录、复制入库并去重。
 - [录音库检索](./library-search.md)：全文搜索、阶段/分类/标签筛选、排序和空结果。
-- [录音详情](./recording-detail.md)：Range 播放、改标题、改分类/重要度/标签、收藏、导出、删除。
+- [录音详情](./recording-detail.md)：面包屑与返回、单一主按钮、Range 播放、改标题、改分类/重要度/标签、收藏、导出、删除、只读日程区。
+- [导航与单一入口](./navigation.md)：6 项导航、`aria-current` 与 h1 一致、`#/overview` 改写、主界面无技术词。
+- [录音笔](./device-connection.md)（只用 `--fake-device`）：点一次「连接」即同步、过程中「暂时断开外网」、诊断里的「无线快传」记录、「清理已同步的录音」、「断开连接」后自动连接暂停；`ble` 模式「已改用蓝牙」；同步中实时字幕被禁用。
+- [错误分两层](./error-detail.md)：`absent` 模式「没有找到录音笔」，「查看详情」或 toast「详情」后才出现 `DeviceNotFound`。
+- [录音与日程关联](./calendar-link.md)：详情页跳到日历、EventLinker 展开、一键关联、每条录音一个关联控件、详情只读。
+- [诊断与高级](./diagnostics.md)：`#/settings/diagnostics` 自动展开，含本机环境、运行时路径、传输方式、最近设备操作、宿主能力、设备协议指令参考、开发者工具；修改 `device_transport` 后用 `/api/settings` 读回。
 - [分类管理](./categories.md)：新建、改名、改色、删除，内置分类不可删。
 - [转录与归类](./transcribe-organize.md)：复用 Floatboat Host 验证单条、批量、人工修正与全文检索；显式无 Host 验证失败。
 - [转录与归类成功路径](./transcribe-success.md)：可选语言的离线 TTS、能力完整性检查和单条/批量 JSON 配方。
 
+2026-11-08 工作台整改的 e2e 结果：[报告](../reports/2026-11-08-workbench-unify.md)。
+
 实测结果与未修应用问题：[2026-10-29 Host 模式报告](../reports/2026-10-29-host-mode.md)。
diff --git a/.claude/skills/verify-openminutes/features/batch-success.steps.json b/.claude/skills/verify-openminutes/features/batch-success.steps.json
index 9401f93..3243380 100644
--- a/.claude/skills/verify-openminutes/features/batch-success.steps.json
+++ b/.claude/skills/verify-openminutes/features/batch-success.steps.json
@@ -1,11 +1,15 @@
 [
-  {"goto":"#/device"},
-  {"eval":"(async () => { const required = { asr: ['start', 'sendFrame', 'events', 'stop'], llm: ['generateObject', 'generateText'] }; const response = await fetch('/api/device/capabilities'); const body = await response.json(); const capabilities = body.data; const ready = (domain, operations) => operations.every(operation => capabilities?.[domain]?.some(item => item.operation === operation && item.declared === true && item.status === 'available')); if (!response.ok || !body.ok || !ready('asr', required.asr) || !ready('llm', required.llm)) throw Error('Host ASR/LLM capabilities incomplete; no paid task submitted'); return capabilities; })()"},
+  {"goto":"#/library"},
+  {"eval":"(async () => { const required = { asr: ['start', 'sendFrame', 'events', 'stop'], llm: ['generateObject', 'generateText'] }; const response = await fetch('/api/environment/capabilities'); const body = await response.json(); const capabilities = body.data; const ready = (domain, operations) => operations.every(operation => capabilities?.[domain]?.some(item => item.operation === operation && item.declared === true && item.status === 'available')); if (!response.ok || !body.ok || !ready('asr', required.asr) || !ready('llm', required.llm)) throw Error('Host ASR/LLM capabilities incomplete; no paid task submitted'); return capabilities; })()"},
+  {"goto":"#/library"},
+  {"waitFor":"aria=搜索录音"},
+  {"click":"text=导入"},
   {"waitText":"3 个音频文件"},
-  {"click":"text=立即扫描"},
-  {"waitText":"导入 2 个文件，跳过 1 个，失败 0 个","timeout":20000},
+  {"click":"text=扫描并导入"},
+  {"waitText":"已导入 2 条，跳过 1 条","timeout":20000},
+  {"click":"text=关闭"},
   {"goto":"#/library"},
-  {"waitText":"命中 3 条录音"},
+  {"waitText":"当前显示 3 条"},
   {"eval":"(async () => { const b = await fetch('/api/recordings').then(r => r.json()); const rows = b.data.items.filter(r => ['REC20261029_150100.mp3', 'REC20261029_150200.mp3'].includes(r.filename)); if (!b.ok || rows.length !== 2 || rows.some(r => r.status !== 'ready')) throw Error('Requires two fresh batch fixtures'); window.__batchIds = rows.map(r => r.id); return b; })()"},
   {"click":"aria=选择 REC20261029_150100.mp3"},
   {"click":"aria=选择 REC20261029_150200.mp3"},
@@ -13,7 +17,7 @@
   {"screenshot":"01-selected.png"},
   {"aria":"01-selected.aria.txt"},
   {"click":"text=批量转录"},
-  {"waitText":"已排队 2 条转录任务"},
+  {"waitText":"已开始转录 2"},
   {"screenshot":"02-transcribe-accepted.png"},
   {"aria":"02-transcribe-accepted.aria.txt"},
   {"eval":"(async () => { const deadline = Date.now() + 120000; while (Date.now() < deadline) { const rows = [...document.querySelectorAll('.table__body .row')]; const target = rows.filter(r => /REC20261029_150[12]00.mp3/.test(r.innerText)); if (target.length === 2 && target.every(r => r.querySelector('.col-status')?.innerText === '待归类')) return target.map(r => r.innerText); if (target.some(r => r.querySelector('.col-status')?.innerText === '失败')) throw Error('Batch ASR failed'); await new Promise(r => setTimeout(r, 200)); } throw Error('List did not refresh to transcribed'); })()"},
@@ -24,10 +28,10 @@
   {"click":"aria=选择 REC20261029_150200.mp3"},
   {"expectText":"已选 2 条"},
   {"click":"text=批量归类"},
-  {"waitText":"已排队 2 条归类任务"},
+  {"waitText":"已开始归类 2"},
   {"screenshot":"04-organize-accepted.png"},
   {"aria":"04-organize-accepted.aria.txt"},
-  {"eval":"(async () => { const deadline = Date.now() + 120000; while (Date.now() < deadline) { const rows = [...document.querySelectorAll('.table__body .row')]; if (rows.length === 3 && rows.every(r => r.querySelector('.col-status')?.innerText === '已归档')) return rows.map(r => r.innerText); await new Promise(r => setTimeout(r, 200)); } throw Error('List did not refresh to organized'); })()"},
+  {"eval":"(async () => { const deadline = Date.now() + 120000; while (Date.now() < deadline) { const rows = [...document.querySelectorAll('.table__body .row')]; if (rows.length === 3 && rows.every(r => r.querySelector('.col-status')?.innerText === '已整理')) return rows.map(r => r.innerText); await new Promise(r => setTimeout(r, 200)); } throw Error('List did not refresh to organized'); })()"},
   {"eval":"(async () => { const list = await fetch('/api/recordings').then(r => r.json()); const details = await Promise.all(window.__batchIds.map(id => fetch('/api/recordings/' + id).then(r => r.json()))); if (!list.ok || list.data.hasActiveTasks || details.some(b => { const d = b.data, r = d?.recording, a = d?.analysis; return !b.ok || r.status !== 'organized' || d.lastError || !r.title || !r.summary || !r.categoryId || !r.categoryName || !r.tags.length || !(r.transcriptChars > 0) || !d.segments.length || !a?.keyPoints.length || !a.actionItems.length || !a.categorySlug || !Number.isInteger(r.importance) || r.importance < 1 || r.importance > 5 || !d.jobs.some(j => j.kind === 'organize' && j.status === 'success' && j.finishedAt); })) throw Error('Batch organization readback failed: ' + JSON.stringify(details)); return { list, details }; })()"},
   {"screenshot":"05-organized.png"},
   {"aria":"05-organized.aria.txt"}
diff --git a/.claude/skills/verify-openminutes/features/calendar-link.md b/.claude/skills/verify-openminutes/features/calendar-link.md
new file mode 100644
index 0000000..253cc29
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/calendar-link.md
@@ -0,0 +1,26 @@
+# 录音与日程关联
+
+关联只在日历页做，每条录音只有一个关联控件（EventLinker），写接口只有 `PATCH /api/recordings/:id {calendarEventId}`。详情页的日程区只读，提供「在日历中关联 / 修改」，跳到 `#/calendar?day=<录制日期>&rec=<id>`，对应的 EventLinker 高亮并展开。
+
+## Sub-features
+
+- `link-jump`：详情页点「在日历中关联」，hash 带 `day`、`rec`，对应 EventLinker 带 `eventlinker--highlight` 且 `aria-expanded=true`。
+- `link-suggest`：点建议项「关联到：<事件>」，出现「已关联日程」，接口读回 `calendarEventId`。
+- `link-single-control`：日历页同一条录音只有一个 `.eventlinker`。
+- `link-readonly`：从日历点录音标题进入详情，显示事件标题和「在日历中修改」，没有可编辑的日程控件；「返回日历」回到日历页。
+
+## How to get to it (user POV)
+
+- 侧边导航「日历」，或详情页日程区的「在日历中关联」链接。
+
+## Driving it with browse.mjs
+
+Preconditions：普通启动；已按 `import-dialog.steps.json` 导入 1 条录音（`$R/inbox/REC20261029_101500.mp3`）。
+
+- 运行 `browse.mjs <runId> calendar-link @.claude/skills/verify-openminutes/features/calendar-link.steps.json`。第一步用 `POST /api/calendar/events` 在录制时间前后各 30 分钟建一个「验证周会」事件。
+- 预期 `eval` 依次返回日历 hash、`controls: 1` 与 `calendarEventId`、`"read-only"`；`console.log` 为空。
+- 更完整的日历回归（导入 .ics、解除关联、纪要失败文案）见 `scripts/verify-calendar.mjs`。
+
+## Gotchas
+
+- 面包屑是三个行内元素，innerText 中间没有空格，用结构断言而不是 `expectText`。
diff --git a/.claude/skills/verify-openminutes/features/calendar-link.steps.json b/.claude/skills/verify-openminutes/features/calendar-link.steps.json
new file mode 100644
index 0000000..6324228
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/calendar-link.steps.json
@@ -0,0 +1,28 @@
+[
+  {"goto":"#/library"},
+  {"waitText":"当前显示"},
+  {"eval":"(async () => { const list = await (await fetch('/api/recordings', {headers: {connection: 'close'}})).json(); const rec = list.data.items.find((item) => item.status !== 'pending'); if (!rec) throw Error('Precondition: import one recording first (import-dialog.steps.json)'); const at = new Date(rec.recordedAt ?? rec.createdAt); const body = { summary: '验证周会', startTime: new Date(at.getTime() - 30 * 60000).toISOString(), endTime: new Date(at.getTime() + 30 * 60000).toISOString() }; const r = await fetch('/api/calendar/events', {method: 'POST', headers: {'content-type': 'application/json', connection: 'close'}, body: JSON.stringify(body)}); const created = await r.json(); if (!created.ok) throw Error('Event not created: ' + JSON.stringify(created)); sessionStorage.setItem('verifyRec', String(rec.id)); location.hash = '#/rec/' + rec.id; return { rec: rec.id, event: created.data.id }; })()"},
+  {"waitText":"还没有关联日程"},
+  {"eval":"(() => { const crumb = document.querySelector('nav[aria-label=\"当前位置\"]'); const first = crumb?.querySelector('a'); if (!first || first.innerText.trim() !== '录音' || first.getAttribute('href') !== '#/library' || !crumb.querySelector('[aria-current=\"page\"]')?.innerText.trim()) throw Error('Missing breadcrumb'); const current = document.querySelector('nav[aria-label=\"主导航\"] [aria-current=\"page\"]')?.querySelector('span')?.innerText.trim(); if (current !== '录音') throw Error('Detail should highlight 录音, got ' + current); return crumb.innerText; })()"},
+  {"screenshot":"01-detail-unlinked.png"},
+  {"aria":"01-detail-unlinked.aria.txt"},
+  {"click":"text=在日历中关联"},
+  {"waitFor":".eventlinker--highlight .eventlinker__body"},
+  {"eval":"(() => { const id = sessionStorage.getItem('verifyRec'); const params = new URLSearchParams(location.hash.split('?')[1] ?? ''); if (!location.hash.startsWith('#/calendar?') || params.get('rec') !== id || !/^\\d{4}-\\d{2}-\\d{2}$/.test(params.get('day') ?? '')) throw Error('Unexpected calendar hash: ' + location.hash); const linker = document.querySelector('.eventlinker--highlight'); if (linker?.getAttribute('data-recording-id') !== id) throw Error('Wrong recording highlighted'); if (linker.querySelector('.eventlinker__toggle')?.getAttribute('aria-expanded') !== 'true') throw Error('EventLinker not expanded'); return location.hash; })()"},
+  {"screenshot":"02-calendar-linker.png"},
+  {"aria":"02-calendar-linker.aria.txt"},
+  {"click":"text=关联到：验证周会"},
+  {"waitText":"已关联日程"},
+  {"eval":"(async () => { const id = sessionStorage.getItem('verifyRec'); const count = document.querySelectorAll('.eventlinker[data-recording-id=\"' + id + '\"]').length; if (count !== 1) throw Error('Expected one link control per recording, got ' + count); const r = await (await fetch('/api/recordings/' + id, {headers: {connection: 'close'}})).json(); if (!r.data.recording.calendarEventId) throw Error('Link not stored: ' + JSON.stringify(r.data.recording)); return { controls: count, calendarEventId: r.data.recording.calendarEventId }; })()"},
+  {"eval":"(() => { const id = sessionStorage.getItem('verifyRec'); const link = document.querySelector('a.calendar-recording-button[href=\"#/rec/' + id + '\"]'); if (!link) throw Error('Recording title should link to the detail page'); link.click(); return link.getAttribute('href'); })()"},
+  {"waitText":"返回日历"},
+  {"waitText":"验证周会"},
+  {"expectText":"在日历中修改"},
+  {"expectNoText":"还没有关联日程"},
+  {"eval":"(() => { const controls = [...document.querySelectorAll('main select, main input[type=\"checkbox\"]')].filter((el) => /日程|事件/.test(el.getAttribute('aria-label') ?? '')); if (controls.length) throw Error('Detail page must not edit the link'); return 'read-only'; })()"},
+  {"screenshot":"03-detail-linked.png"},
+  {"aria":"03-detail-linked.aria.txt"},
+  {"click":"text=返回日历"},
+  {"waitFor":".eventlinker"},
+  {"eval":"(() => { if (!location.hash.startsWith('#/calendar')) throw Error('Back should return to the calendar, got ' + location.hash); return location.hash; })()"}
+]
diff --git a/.claude/skills/verify-openminutes/features/device-connection.md b/.claude/skills/verify-openminutes/features/device-connection.md
new file mode 100644
index 0000000..01a6aff
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/device-connection.md
@@ -0,0 +1,40 @@
+# 录音笔：连接、同步、清理、断开
+
+连接、断开、同步、单条同步、停止、清理只在「录音笔」页。开着「连上录音笔后自动同步」时，点一次「连接」就完成同步。大录音默认走无线快传，期间按钮附近提示「暂时断开外网」；主界面不出现 Wi-Fi、FTP、热点等技术词。无线快传失败时自动改用蓝牙，原因只在「查看详情」里。手动断开后自动连接暂停，直到再点「连接」。
+
+**只用 `--fake-device`。** 真实录音笔的同步会切换本机 Wi-Fi，清理会删除录音笔上的文件，禁止在验证里对真实录音笔操作。
+
+## Sub-features
+
+- `device-one-click`（wifi）：点「连接」后等到「已同步 3 条录音」，过程中出现「暂时断开外网」。
+- `device-diagnostics-log`（wifi）：「设置 › 诊断与高级 › 最近设备操作」里有一条传输为「无线快传」的记录。
+- `device-cleanup`（wifi）：「清理已同步的录音（3 条 · 3.5 MB）」，确认后出现「已清理 3 条」，`cleanable.count` 为 0。
+- `device-disconnect`（wifi）：「断开连接」后显示「已手动断开，自动连接暂停」，`/api/device` 为 `state=disconnected`、`userDisconnected=true`。
+- `device-fallback`（ble）：同步完成后出现「已改用蓝牙」的提示（`role=status`）；点「查看详情」前看不到 `WIFI_JOIN_FAILED`，点之后才看到。
+- `live-busy`（wifi）：同步进行中打开「实时字幕」，「开始实时字幕」被禁用并显示「录音笔正在同步」，同步结束后恢复可用。
+- `live-connecting`（absent）：连接进行中打开「实时字幕」，横幅写「录音笔正在连接，请稍候。」（不是「正在同步」），连接结束后「开始实时字幕」恢复可用。
+
+## How to get to it (user POV)
+
+- 侧边导航「录音笔」→「连接」。设置项「连上录音笔后自动同步」「后台自动同步大录音时也用无线快传」在「设置 › 自动化」，传输方式覆盖在「设置 › 诊断与高级」。
+
+## Driving it with browse.mjs
+
+Preconditions：`MEMOTALK_TEST_PYTHON` 指向装了 `memotalk-sdk==0.1.0` 的解释器（`uv venv .workbench/test-python` + `uv pip install --python .workbench/test-python/Scripts/python.exe memotalk-sdk==0.1.0`）。每个配方用一个新的 runId。
+
+| 配方 | 启动 | 命令 |
+|---|---|---|
+| 一次点击、诊断记录、清理、断开 | `launch.mjs <runId> --no-host --fake-device=wifi` | `browse.mjs <runId> device-connection @.claude/skills/verify-openminutes/features/device-connection.steps.json` |
+| 改用蓝牙与查看详情 | `launch.mjs <runId> --no-host --fake-device=ble` | `browse.mjs <runId> device-fallback @.claude/skills/verify-openminutes/features/device-fallback.steps.json` |
+| 同步中实时字幕被禁用 | `launch.mjs <runId> --no-host --fake-device=wifi` | `browse.mjs <runId> live-busy @.claude/skills/verify-openminutes/features/live-busy.steps.json` |
+| 连接中实时字幕显示「正在连接」而不是「正在同步」 | `launch.mjs <runId> --no-host --fake-device=absent` | `browse.mjs <runId> live-connecting @.claude/skills/verify-openminutes/features/live-connecting.steps.json` |
+
+- 前两个配方的第一步用 `PATCH /api/settings {auto_pull:'1'}` 打开自动同步（launch 默认关闭四个 auto 开关）；live-busy 保持关闭，由 `POST /api/device/sync` 发起同步后立即切到 `#/live`。
+- 预期每个 `eval` 都返回值、`console.log` 为空。读回 JSON 记录在 `steps.log` 里。
+
+## Gotchas
+
+- 无线快传阶段可能短于 1.5 秒的轮询间隔，所以「连接」点击和过程观察放在同一个 `eval` 里，每 30 ms 采样一次页面文字。
+- 清理确认框由 `browse.mjs` 自动接受，确认文字记在 `steps.log`。
+- 假设备 prelude 会让任何 `netsh` / `nmcli` / `networksetup` 调用直接抛错；如果 `server.log` 里出现这类 AssertionError，说明代码绕过了假设备路径，需要修。
+- 假设备的序列号是模拟器自带的占位串（形如 `{{SERIAL_xxxx}}`），只在假设备下出现。
diff --git a/.claude/skills/verify-openminutes/features/device-connection.steps.json b/.claude/skills/verify-openminutes/features/device-connection.steps.json
new file mode 100644
index 0000000..3915548
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/device-connection.steps.json
@@ -0,0 +1,33 @@
+[
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"eval":"(async () => { const r = await fetch('/api/settings', {method: 'PATCH', headers: {'content-type': 'application/json', connection: 'close'}, body: JSON.stringify({values: {auto_pull: '1'}})}); const body = await r.json(); if (!body.ok) throw Error('PATCH auto_pull failed: ' + JSON.stringify(body)); const d = await (await fetch('/api/device', {headers: {connection: 'close'}})).json(); if (d.data.connection.state !== 'disconnected') throw Error('Expected disconnected start'); return 'auto_pull=1'; })()"},
+  {"screenshot":"01-disconnected.png"},
+  {"aria":"01-disconnected.aria.txt"},
+  {"eval":"(async () => { const banned = ['Wi-Fi', 'WiFi', 'FTP', '热点', 'SSID', 'BLE', 'SDK', '退出码']; const seen = { offlineHint: false, banned: [] }; const button = [...document.querySelectorAll('main button')].find((b) => b.innerText.trim() === '连接'); if (!button) throw Error('No 连接 button'); button.click(); const started = Date.now(); while (Date.now() - started < 120000) { const text = document.body.innerText; if (text.includes('暂时断开外网')) seen.offlineHint = true; for (const word of banned) if (text.includes(word) && !seen.banned.includes(word)) seen.banned.push(word); if (text.includes('已同步 3 条录音')) break; await new Promise((r) => setTimeout(r, 30)); } if (!document.body.innerText.includes('已同步 3 条录音')) throw Error('One click did not finish the sync: ' + JSON.stringify(seen)); if (!seen.offlineHint) throw Error('The offline hint never appeared during the Wi-Fi transfer'); if (seen.banned.length) throw Error('Technical words leaked into the main view: ' + seen.banned.join(',')); return { ...seen, ms: Date.now() - started }; })()"},
+  {"expectNoText":"Wi-Fi"},
+  {"expectNoText":"FTP"},
+  {"expectNoText":"热点"},
+  {"expectText":"断开连接"},
+  {"waitText":"清理已同步的录音"},
+  {"screenshot":"02-synced.png"},
+  {"aria":"02-synced.aria.txt"},
+  {"eval":"(async () => { const d = (await (await fetch('/api/device', {headers: {connection: 'close'}})).json()).data; if (d.activity !== null || d.onDevice.length !== 0 || d.lastResult?.transport !== 'wifi' || d.lastResult?.done !== 3) throw Error('Unexpected device view: ' + JSON.stringify(d)); const list = (await (await fetch('/api/recordings', {headers: {connection: 'close'}})).json()).data.items; if (list.length !== 3 || list.some((item) => item.status !== 'ready' && item.status !== 'queued_transcribe')) throw Error('Unexpected recordings: ' + JSON.stringify(list.map((item) => item.status))); return { lastResult: d.lastResult, cleanable: d.cleanable, statuses: list.map((item) => item.status) }; })()"},
+  {"goto":"#/settings/diagnostics"},
+  {"waitFor":"details#diagnostics[open]"},
+  {"waitText":"最近设备操作"},
+  {"eval":"(() => { const section = [...document.querySelectorAll('section')].find((s) => s.querySelector('h3')?.innerText.trim() === '最近设备操作'); if (!section) throw Error('No device log section'); const rows = [...section.querySelectorAll('li.devlog__row:not(.devlog__head)')].map((tr) => tr.innerText); if (!rows.some((row) => row.includes('无线快传'))) throw Error('No 无线快传 entry in the device log: ' + JSON.stringify(rows)); return rows.length; })()"},
+  {"screenshot":"03-diagnostics.png"},
+  {"goto":"#/device"},
+  {"waitText":"清理已同步的录音"},
+  {"eval":"(() => { const button = [...document.querySelectorAll('main button')].find((b) => b.innerText.trim().startsWith('清理已同步的录音')); if (!button) throw Error('No cleanup button'); button.click(); return button.innerText.trim(); })()"},
+  {"waitText":"已清理 3 条","timeout":60000},
+  {"eval":"(async () => { const d = (await (await fetch('/api/device', {headers: {connection: 'close'}})).json()).data; if (d.cleanable?.count !== 0 || d.lastResult?.kind !== 'cleanup') throw Error('Cleanup not reflected: ' + JSON.stringify({ cleanable: d.cleanable, lastResult: d.lastResult })); return d.cleanable; })()"},
+  {"screenshot":"04-cleaned.png"},
+  {"click":"text=断开连接"},
+  {"waitText":"自动连接暂停"},
+  {"waitText":"录音笔未连接"},
+  {"eval":"(async () => { const d = (await (await fetch('/api/device', {headers: {connection: 'close'}})).json()).data; if (d.connection.state !== 'disconnected' || !d.connection.userDisconnected || d.connection.disconnectReason !== 'user') throw Error('Unexpected connection: ' + JSON.stringify(d.connection)); return d.connection; })()"},
+  {"screenshot":"05-disconnected.png"},
+  {"aria":"05-disconnected.aria.txt"}
+]
diff --git a/.claude/skills/verify-openminutes/features/device-fallback.steps.json b/.claude/skills/verify-openminutes/features/device-fallback.steps.json
new file mode 100644
index 0000000..f8672fb
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/device-fallback.steps.json
@@ -0,0 +1,18 @@
+[
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"eval":"(async () => { const r = await fetch('/api/settings', {method: 'PATCH', headers: {'content-type': 'application/json', connection: 'close'}, body: JSON.stringify({values: {auto_pull: '1'}})}); if (!(await r.json()).ok) throw Error('PATCH auto_pull failed'); return 'auto_pull=1'; })()"},
+  {"click":"text=连接"},
+  {"waitText":"已改用蓝牙","timeout":180000},
+  {"waitText":"已同步 3 条录音","timeout":180000},
+  {"expectNoText":"WIFI_JOIN_FAILED"},
+  {"expectNoText":"netsh"},
+  {"screenshot":"01-fallback.png"},
+  {"aria":"01-fallback.aria.txt"},
+  {"eval":"(() => { const notice = [...document.querySelectorAll('.errornotice')].find((n) => n.innerText.includes('已改用蓝牙')); if (!notice) throw Error('No fallback notice'); if (notice.getAttribute('role') !== 'status') throw Error('Fallback must be a notice, not an alert'); const toggle = [...notice.querySelectorAll('button')].find((b) => b.innerText.includes('查看详情')); if (!toggle || toggle.getAttribute('aria-expanded') !== 'false') throw Error('Details should start collapsed'); toggle.click(); return 'expanded'; })()"},
+  {"waitText":"WIFI_JOIN_FAILED"},
+  {"expectText":"复制诊断信息"},
+  {"screenshot":"02-detail.png"},
+  {"aria":"02-detail.aria.txt"},
+  {"eval":"(async () => { const d = (await (await fetch('/api/device', {headers: {connection: 'close'}})).json()).data; const fb = d.lastResult?.fallback; if (fb?.code !== 'WIFI_FALLBACK' || !/WIFI_JOIN_FAILED/.test(fb.detail ?? '') || d.lastResult.transport !== 'ble' || d.lastResult.done !== 3) throw Error('Unexpected lastResult: ' + JSON.stringify(d.lastResult)); return d.lastResult; })()"}
+]
diff --git a/.claude/skills/verify-openminutes/features/diagnostics.md b/.claude/skills/verify-openminutes/features/diagnostics.md
new file mode 100644
index 0000000..4065e2a
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/diagnostics.md
@@ -0,0 +1,24 @@
+# 设置 › 诊断与高级
+
+唯一的技术细节区。默认折叠，从 `#/settings/diagnostics` 进入时自动展开。依次包含本机环境、运行时路径、传输方式（自动 / 始终无线快传 / 始终蓝牙）、最近设备操作、宿主能力、设备协议指令参考（开发者）、开发者工具和「复制诊断报告」。
+
+## Sub-features
+
+- `diag-sections`：上述各分区标题都在。
+- `diag-transport`：把「传输方式」改为「始终蓝牙」，出现「有未保存的修改」，点「保存设置」后 `/api/settings` 读回 `device_transport=ble`，`/api/diagnostics` 的 `transport.setting` 也为 `ble`、`thresholdBytes` 为 1048576。最后改回「自动」，不影响后续配方。
+
+## How to get to it (user POV)
+
+- 侧边导航「设置」→ 展开「诊断与高级」；出错提示里的「在诊断中查看」/「去诊断与修复」也会跳到这里。
+
+## Driving it with browse.mjs
+
+Preconditions：满足基线条件，普通启动，doctor 的 exit 为 0。
+
+- 运行 `browse.mjs <runId> diagnostics @.claude/skills/verify-openminutes/features/diagnostics.steps.json`。
+- 预期两个读回 `eval` 分别返回 `"auto"` 和 `setting: "ble"` 的传输信息，`console.log` 为空。
+
+## Gotchas
+
+- 保存设置会一并提交通用分区的目录输入框；隔离实例里这些值来自 launch，没有改动时保存不会破坏隔离，但不要在这一步编辑目录。
+- 普通启动时「无线网卡」一栏读的是本机真实探测结果（只读的 `netsh wlan show drivers` 等命令）。
diff --git a/.claude/skills/verify-openminutes/features/diagnostics.steps.json b/.claude/skills/verify-openminutes/features/diagnostics.steps.json
new file mode 100644
index 0000000..5f22351
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/diagnostics.steps.json
@@ -0,0 +1,25 @@
+[
+  {"goto":"#/settings/diagnostics"},
+  {"waitFor":"details#diagnostics[open]"},
+  {"waitText":"最近设备操作"},
+  {"expectText":"本机环境"},
+  {"expectText":"运行时路径"},
+  {"expectText":"传输方式"},
+  {"expectText":"无线快传阈值"},
+  {"expectText":"宿主能力"},
+  {"expectText":"设备协议指令参考（开发者）"},
+  {"expectText":"开发者工具"},
+  {"screenshot":"01-before.png"},
+  {"aria":"01-before.aria.txt"},
+  {"eval":"(async () => { const r = await fetch('/api/settings', {headers: {connection: 'close'}}); const body = await r.json(); const value = body.data.find((item) => item.key === 'device_transport')?.value; if (value !== 'auto') throw Error('Expected default auto, got ' + value); return value; })()"},
+  {"select":"aria=传输方式","value":"ble"},
+  {"waitText":"有未保存的修改"},
+  {"click":"text=保存设置"},
+  {"waitText":"设置已保存"},
+  {"eval":"(async () => { const r = await fetch('/api/settings', {headers: {connection: 'close'}}); const body = await r.json(); const value = body.data.find((item) => item.key === 'device_transport')?.value; if (value !== 'ble') throw Error('device_transport not saved: ' + value); const d = await (await fetch('/api/diagnostics', {headers: {connection: 'close'}})).json(); if (d.data.transport.setting !== 'ble' || d.data.transport.thresholdBytes !== 1048576) throw Error('diagnostics transport mismatch: ' + JSON.stringify(d.data.transport)); return d.data.transport; })()"},
+  {"screenshot":"02-saved.png"},
+  {"aria":"02-saved.aria.txt"},
+  {"select":"aria=传输方式","value":"auto"},
+  {"click":"text=保存设置"},
+  {"waitText":"设置已保存"}
+]
diff --git a/.claude/skills/verify-openminutes/features/directory-import.md b/.claude/skills/verify-openminutes/features/directory-import.md
index 3616442..babd946 100644
--- a/.claude/skills/verify-openminutes/features/directory-import.md
+++ b/.claude/skills/verify-openminutes/features/directory-import.md
@@ -1,19 +1,19 @@
 # 目录导入
 
-用户把录音笔里的 MP3（U 盘模式或 Wi-Fi 下载）放进导入目录，在设备接入页点「立即扫描」。应用把文件复制到归档目录的 `yyyy-MM/` 子目录，并在录音库登记一条状态为「待转录」的录音。已经导入过的文件再次扫描时会被跳过。
+用户把录音笔里的 MP3（U 盘模式或其他方式拷出）放进导入目录，在「录音」页头点「导入」，在对话框里点「扫描并导入」。应用把文件复制到归档目录的 `yyyy-MM/` 子目录，并在录音库登记一条状态为「待转录」的录音。已经导入过的文件再次扫描时会被跳过。整个过程停留在 `#/library`，结果在对话框内显示。
 
 ## Sub-features
 
-- `import-scan`：扫描收件目录，导入新的 MP3，并提示导入、跳过、失败各多少个。
-- `import-dedupe`：再次扫描同一个文件时，计入「跳过」，不重复登记。
+- `import-scan`：扫描收件目录，导入新的 MP3，对话框内显示「已导入 N 条」等结果。
+- `import-dedupe`：再次扫描同一个文件时，计入「已跳过」，不重复登记。
 - `import-copy`：源文件留在收件目录，副本落到 `library/<录制年月>/`。
-- `import-empty`：收件目录里没有音频时，提示「目录里还没有可导入的音频文件」。
-- `import-from-library`：录音库右上角的「导入新录音」会跳转到设备接入页。
+- `import-failed-detail`：导入失败的文件主行只显示中文结论，技术原因收在这一行的「查看详情」里，可以展开和复制。配方：`--no-host` 启动后，在 `$R/library/` 下建一个名为 `2026-11` 的普通文件（占住月份目录，让 mkdir 失败），收件目录放 `REC20261115_090000.mp3`，运行 `browse.mjs <runId> import-failed-detail @.claude/skills/verify-openminutes/features/import-failed-detail.steps.json`。
+- `import-empty`：收件目录里没有音频时，对话框提示「文件夹里还没有可以导入的录音文件。」；目录不存在时扫描会自动创建。
+- `import-dialog-path`：对话框显示导入目录完整路径、音频数，提供「复制路径」和「在设置中修改目录」（只是跳转，目录只在「设置 › 通用」里改）。
 
 ## How to get to it (user POV)
 
-- 侧边导航「设备接入」→「扫描导入目录」卡片→「立即扫描」。
-- 录音库页右上角「导入新录音」→ 设备接入页 → 同上。
+- 侧边导航「录音」→ 页头「导入」→「扫描并导入」。这是唯一入口；录音笔页和空状态里没有导入按钮，空状态只有说明文字和链接。
 
 ## Driving it with browse.mjs
 
@@ -22,17 +22,17 @@ Preconditions:
 - 满足基线条件，doctor 的 exit 为 0。
 - 已用 ffmpeg 生成 `$R/inbox/REC20261029_101500.mp3`（6 秒，16 kHz 单声道）。
 
-- **入口与目录状态。** 运行 `browse.mjs <runId> import '[{"goto":"#/library"},{"click":"text=导入新录音"},{"waitText":"扫描导入目录"},{"waitText":"1 个音频文件"},{"eval":"location.hash"},{"screenshot":"01-before.png"},{"aria":"01-before.aria.txt"}]'`。预期 `location.hash` 为 `#/device`，卡片角标显示「1 个音频文件」，路径行显示 `$R\inbox`。
-- **扫描导入。** 运行 `browse.mjs <runId> import-scan '[{"goto":"#/device"},{"waitText":"1 个音频文件"},{"click":"text=立即扫描"},{"waitText":"导入 1 个文件，跳过 0 个，失败 0 个","timeout":15000},{"screenshot":"02-after-scan.png"}]'`。预期页面出现成功 toast，扫描结果里列出该文件。
-- **副作用读回。** 运行 `curl -s "$URL/api/recordings" | tee $E/import-scan/recordings.json`。预期 `total` 为 1，`status` 为 `ready`，`durationSec` 为 6，`hasAudioFile` 为 true。再运行 `ls $R/library/2026-10/`，应该能看到 `REC20261029_101500.mp3`，同时 `$R/inbox/` 里的原文件仍在。
-- **去重。** 不改动收件目录，重复上面的扫描步骤，但把 `waitText` 改成 `"导入 0 个文件，跳过 1 个，失败 0 个"`。之后 `/api/recordings` 的 `total` 仍应为 1。
-- **录音库里可见。** 运行 `browse.mjs <runId> import-library '[{"goto":"#/library"},{"waitText":"REC20261029_101500.mp3"},{"expectText":"命中 1 条录音"},{"screenshot":"03-library.png"}]'`。
+- **入口与目录状态。** 运行 `browse.mjs <runId> import '[{"goto":"#/library"},{"waitFor":"aria=搜索录音"},{"click":"text=导入"},{"waitText":"1 个音频文件"},{"eval":"location.hash"},{"screenshot":"01-before.png"},{"aria":"01-before.aria.txt"}]'`。预期 `location.hash` 仍为 `#/library`，对话框显示「1 个音频文件」，路径行显示 `$R\inbox`。
+- **扫描导入。** 在同一次调用里追加 `{"click":"text=扫描并导入"},{"waitText":"已导入 1 条","timeout":20000},{"screenshot":"02-after-scan.png"},{"click":"text=关闭"}`。预期对话框内列出该文件，hash 仍为 `#/library`。参考 `features/voice-import.steps.json`。
+- **副作用读回。** 运行 `curl -s "$URL/api/recordings" | tee $E/import/recordings.json`。预期 `total` 为 1，`status` 为 `ready`，`durationSec` 为 6，`hasAudioFile` 为 true。再运行 `ls $R/library/2026-10/`，应该能看到 `REC20261029_101500.mp3`，同时 `$R/inbox/` 里的原文件仍在。
+- **去重。** 不改动收件目录，重复上面的扫描步骤，等待对话框内显示「已跳过」。之后 `/api/recordings` 的 `total` 仍应为 1。
+- **录音库里可见。** 运行 `browse.mjs <runId> import-library '[{"goto":"#/library"},{"waitText":"REC20261029_101500.mp3"},{"expectText":"当前显示 1 条"},{"screenshot":"03-library.png"}]'`。
+- **一步跑完。** `browse.mjs <runId> import-dialog @.claude/skills/verify-openminutes/features/import-dialog.steps.json` 依次检查空状态只有说明和「录音笔」链接、对话框显示目录与音频数、「已导入 1 条」、全程 hash 为 `#/library`，最后读回 `/api/recordings`。
 
 ## Gotchas
 
-- 「导入完成后」是一张一直存在的卡片标题，不能用来判断扫描完成。要等 toast「导入 N 个文件…」。
-- 扫描进行中按钮会变灰；如果截图里按钮是灰的，说明截图时扫描还没结束。
-- 不要点同页面的「保存路径」：它会把隔离用的 `import_dir` 覆盖成输入框里的值（输入框可能显示用户真实的 SDK 目录），doctor 会因此报错。
-- 不要点「连接并检测」「读取清单」，它们会通过 BLE 真正连接设备。本机环境卡片显示 Python「未就绪」时，这两个按钮也只会报错。
+- 等对话框内的结果文字，不要用固定延时；扫描进行中按钮显示「正在扫描…」并变灰。
+- 不要在「设置 › 通用」里保存目录：它会把隔离用的 `import_dir` 覆盖成输入框里的值，doctor 会因此报错。
+- 没有 `--fake-device` 时不要去录音笔页点「连接」，它会通过 BLE 真正连接录音笔。
 - 导入目录不能放在系统临时目录下，否则应用会把它改回真实的 `~/memo/memotalk/inbox`。
 - 录制时间是从文件名解析出来的；文件名不符合 `RECyyyyMMdd_HHmmss` 时，会退回到文件时间。
diff --git a/.claude/skills/verify-openminutes/features/error-detail.md b/.claude/skills/verify-openminutes/features/error-detail.md
new file mode 100644
index 0000000..2868dc3
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/error-detail.md
@@ -0,0 +1,26 @@
+# 错误分两层：中文结论 + 查看详情
+
+出错时主行只显示一句中文结论；技术原文（异常类型、退出码、stderr）只在点「查看详情」后展开，展开区提供「复制诊断信息」和「在诊断中查看」。带详情的错误 toast 不会自动消失，toast 上的「详情」打开同样内容的弹窗。
+
+## Sub-features
+
+- `error-headline`（absent）：点「连接」后出现「没有找到录音笔」，页面上没有 `DeviceNotFound`、`Traceback`。
+- `error-expand`：页面内 `ErrorNotice`（`role=alert`）的「查看详情」展开后出现 `DeviceNotFound`、「复制诊断信息」「在诊断中查看」；再点一次收起。
+- `error-toast-modal`：toast 的「详情」打开「出错详情」弹窗，里面是展开状态的同一条错误。弹窗里点「在诊断中查看」后弹窗关闭，页面停在展开的「诊断与高级」（`details#diagnostics[open]`）。
+- `error-readback`：`/api/device` 的 `lastError` 为 `DEVICE_NOT_FOUND`，`message` 是中文，`detail` 含 `DeviceNotFound`。
+
+## How to get to it (user POV)
+
+- 任何出错的位置原地显示；完整的设备操作记录在「设置 › 诊断与高级 › 最近设备操作」。
+
+## Driving it with browse.mjs
+
+Preconditions：`MEMOTALK_TEST_PYTHON` 已设置；`launch.mjs <runId> --no-host --fake-device=absent`，doctor 的 exit 为 0。
+
+- 运行 `browse.mjs <runId> error-detail @.claude/skills/verify-openminutes/features/error-detail.steps.json`。
+- 预期最后一个 `eval` 返回 `lastError`，`console.log` 为空。
+
+## Gotchas
+
+- 同一屏可能同时有 toast 和卡片里的 `ErrorNotice`，步骤用 `main .errornotice--error` 精确定位卡片里的那条。
+- 无 Host 的转录失败也遵守同样的分层，见 `recipes/host-off.json`。
diff --git a/.claude/skills/verify-openminutes/features/error-detail.steps.json b/.claude/skills/verify-openminutes/features/error-detail.steps.json
new file mode 100644
index 0000000..3035deb
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/error-detail.steps.json
@@ -0,0 +1,28 @@
+[
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"click":"text=连接"},
+  {"waitText":"没有找到录音笔","timeout":60000},
+  {"expectNoText":"DeviceNotFound"},
+  {"expectNoText":"Traceback"},
+  {"screenshot":"01-headline.png"},
+  {"aria":"01-headline.aria.txt"},
+  {"eval":"(() => { const notice = document.querySelector('main .errornotice--error'); if (!notice || notice.getAttribute('role') !== 'alert') throw Error('Expected an alert ErrorNotice'); const toggle = [...notice.querySelectorAll('button')].find((b) => b.innerText.includes('查看详情')); if (!toggle) throw Error('No 查看详情'); toggle.click(); return 'expanded'; })()"},
+  {"waitText":"DeviceNotFound"},
+  {"expectText":"复制诊断信息"},
+  {"expectText":"在诊断中查看"},
+  {"screenshot":"02-detail.png"},
+  {"aria":"02-detail.aria.txt"},
+  {"eval":"(() => { const notice = document.querySelector('main .errornotice--error'); [...notice.querySelectorAll('button')].find((b) => b.innerText.includes('查看详情')).click(); return 'collapsed'; })()"},
+  {"waitNoText":"DeviceNotFound"},
+  {"eval":"(() => { const link = [...document.querySelectorAll('.toast button')].find((b) => b.innerText.trim() === '详情'); if (!link) throw Error('The error toast should offer 详情 and stay visible'); link.click(); return 'opened'; })()"},
+  {"waitText":"出错详情"},
+  {"waitText":"DeviceNotFound"},
+  {"screenshot":"03-toast-modal.png"},
+  {"aria":"03-toast-modal.aria.txt"},
+  {"eval":"(() => { const link = [...document.querySelectorAll('[role=dialog] a')].find((a) => a.innerText.includes('在诊断中查看')); if (!link) throw Error('The toast modal should link to diagnostics'); link.click(); return 'navigated'; })()"},
+  {"waitText":"最近设备操作","timeout":15000},
+  {"eval":"(async () => { for (let i = 0; i < 40; i += 1) { if (!document.querySelector('[role=dialog]') && document.querySelector('details#diagnostics[open]')) return location.hash; await new Promise((r) => setTimeout(r, 100)); } throw Error('Modal still open or diagnostics closed: dialog=' + Boolean(document.querySelector('[role=dialog]')) + ' hash=' + location.hash); })()"},
+  {"screenshot":"04-modal-navigated.png"},
+  {"eval":"(async () => { const d = (await (await fetch('/api/device', {headers: {connection: 'close'}})).json()).data; if (d.lastError?.code !== 'DEVICE_NOT_FOUND' || /DeviceNotFound/.test(d.lastError.message) || !/DeviceNotFound/.test(d.lastError.detail ?? '')) throw Error('Unexpected lastError: ' + JSON.stringify(d.lastError)); return d.lastError; })()"}
+]
diff --git a/.claude/skills/verify-openminutes/features/import-dialog.steps.json b/.claude/skills/verify-openminutes/features/import-dialog.steps.json
new file mode 100644
index 0000000..097e0f3
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/import-dialog.steps.json
@@ -0,0 +1,22 @@
+[
+  {"goto":"#/library"},
+  {"waitText":"还没有录音"},
+  {"eval":"(() => { const link = [...document.querySelectorAll('main a')].find((a) => a.innerText.trim() === '录音笔'); if (!link || link.getAttribute('href') !== '#/device') throw Error('Empty state must link to the device page'); const actionButtons = [...document.querySelectorAll('main .empty button')]; if (actionButtons.length) throw Error('Empty state must not offer action buttons: ' + actionButtons.map((b) => b.innerText).join(',')); return 'ok'; })()"},
+  {"screenshot":"01-empty.png"},
+  {"aria":"01-empty.aria.txt"},
+  {"click":"text=导入"},
+  {"waitText":"扫描并导入"},
+  {"waitText":"个音频文件"},
+  {"expectText":"在设置中修改目录"},
+  {"screenshot":"02-dialog.png"},
+  {"aria":"02-dialog.aria.txt"},
+  {"click":"text=扫描并导入"},
+  {"waitText":"已导入 1 条","timeout":20000},
+  {"eval":"(() => { if (location.hash !== '#/library') throw Error('Import must stay on #/library, got ' + location.hash); return location.hash; })()"},
+  {"click":"text=关闭"},
+  {"waitText":"当前显示 1 条"},
+  {"eval":"(() => { if (location.hash !== '#/library') throw Error('Import must stay on #/library, got ' + location.hash); return location.hash; })()"},
+  {"eval":"(async () => { const r = await fetch('/api/recordings', {headers: {connection: 'close'}}); const body = await r.json(); if (body.data.items.length !== 1 || body.data.items[0].status !== 'ready') throw Error('Unexpected library: ' + JSON.stringify(body.data.items)); return body.data.items.map((item) => ({ id: item.id, filename: item.filename, status: item.status })); })()"},
+  {"screenshot":"03-imported.png"},
+  {"aria":"03-imported.aria.txt"}
+]
diff --git a/.claude/skills/verify-openminutes/features/import-failed-detail.steps.json b/.claude/skills/verify-openminutes/features/import-failed-detail.steps.json
new file mode 100644
index 0000000..463178d
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/import-failed-detail.steps.json
@@ -0,0 +1,16 @@
+[
+  {"goto":"#/library"},
+  {"click":"text=导入"},
+  {"waitText":"扫描并导入"},
+  {"waitText":"个音频文件"},
+  {"click":"text=扫描并导入"},
+  {"waitText":"1 条没有导入","timeout":20000},
+  {"eval":"(() => { const row = document.querySelector('.scandetail--failed'); if (!row) throw Error('no failed row'); const notice = row.querySelector('.errornotice'); if (!notice) throw Error('failed row must use the two-layer error notice'); if (row.querySelector('.errornotice__detail')) throw Error('technical detail must stay folded until 查看详情'); const toggle = [...row.querySelectorAll('button')].find((b) => b.innerText.trim() === '查看详情'); if (!toggle) throw Error('failed row must offer 查看详情'); return row.innerText; })()"},
+  {"screenshot":"01-failed-folded.png"},
+  {"aria":"01-failed-folded.aria.txt"},
+  {"click":".scandetail--failed .errornotice button[aria-expanded]"},
+  {"waitFor":".scandetail--failed .errornotice__detail"},
+  {"eval":"(() => { const detail = document.querySelector('.scandetail--failed .errornotice__detail')?.innerText ?? ''; if (!detail.includes('[IMPORT_FAILED]') || detail.split('\\n').length < 2) throw Error('expanded detail must carry the technical cause: ' + detail); const copy = [...document.querySelectorAll('.scandetail--failed button')].find((b) => b.innerText.includes('复制诊断信息')); if (!copy) throw Error('detail must be copyable'); return detail; })()"},
+  {"screenshot":"02-failed-expanded.png"},
+  {"aria":"02-failed-expanded.aria.txt"}
+]
diff --git a/.claude/skills/verify-openminutes/features/library-batch-all.steps.json b/.claude/skills/verify-openminutes/features/library-batch-all.steps.json
new file mode 100644
index 0000000..bf53d71
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/library-batch-all.steps.json
@@ -0,0 +1,25 @@
+[
+  {"goto":"#/library"},
+  {"click":"text=导入"},
+  {"waitText":"扫描并导入"},
+  {"waitText":"个音频文件"},
+  {"click":"text=扫描并导入"},
+  {"waitText":"已导入 1 条","timeout":20000},
+  {"click":"text=关闭"},
+  {"goto":"#/library?stage=ready"},
+  {"waitText":"全部转录（1）"},
+  {"eval":"(async () => { const o = await fetch('/api/overview', {headers: {connection: 'close'}}).then((r) => r.json()); const ready = o.data.byStatus.find((item) => item.status === 'ready')?.count ?? 0; const label = [...document.querySelectorAll('main button')].map((b) => b.innerText.trim()).find((t) => t.startsWith('全部转录')); if (label !== '全部转录（' + ready + '）') throw Error('button count must equal the server stage count: ' + label + ' vs ' + ready); return { label, ready }; })()"},
+  {"screenshot":"01-stage-only.png"},
+  {"aria":"01-stage-only.aria.txt"},
+  {"fill":"aria=搜索录音","value":"没有这个词"},
+  {"waitText":"2 个筛选条件生效"},
+  {"waitNoText":"全部转录（"},
+  {"expectNoText":"全部转录"},
+  {"screenshot":"02-search-hides-all.png"},
+  {"aria":"02-search-hides-all.aria.txt"},
+  {"fill":"aria=搜索录音","value":""},
+  {"waitText":"全部转录（1）"},
+  {"goto":"#/library"},
+  {"waitText":"当前显示 1 条"},
+  {"expectNoText":"全部转录"}
+]
diff --git a/.claude/skills/verify-openminutes/features/library-search.md b/.claude/skills/verify-openminutes/features/library-search.md
index d413ce9..216cb95 100644
--- a/.claude/skills/verify-openminutes/features/library-search.md
+++ b/.claude/skills/verify-openminutes/features/library-search.md
@@ -1,21 +1,22 @@
-# 录音库检索
+# 录音检索
 
-录音库一条录音占一行。用户可以按标题、摘要、转录全文搜索，按处理阶段、分类、标签筛选，并切换排序。没有命中时会显示明确的空状态，和「录音库还是空的」区分开。
+「录音」页一条录音占一行，页头统计条的「失败 N」可直接切到失败筛选。用户可以按标题、摘要、转录全文搜索，按处理阶段、分类、标签筛选，并切换排序。没有命中时会显示明确的空状态，和「还没有录音」区分开。
 
 ## Sub-features
 
-- `library-list`：列出全部录音，表头显示「命中 N 条录音」。
+- `library-list`：列出全部录音，表头显示「当前显示 N 条」。
 - `library-search`：搜索框按标题、摘要、转录全文匹配；无结果时显示「没有符合条件的录音」。
-- `library-stage`：分段控件「全部 / 待转录 / 待归类 / 已归档 / 失败」。
+- `library-stage`：分段控件「全部 / 在录音笔中 / 待转录 / 待归类 / 已整理 / 失败」。
 - `library-category-tag`：「按分类筛选」「按标签筛选」两个下拉框。
 - `library-sort`：「排序方式」可选最近入库、录音时间、时长最长、重要度高。
 - `library-auto-refresh`：有排队或进行中的任务时（`/api/recordings` 返回 `hasActiveTasks: true`），列表会自动刷新到终态，然后停止轮询。配方见 [转录与归类](./transcribe-organize.md) 的「批量转录自动刷新」。
-- `library-empty`：实例里一条录音都没有时，显示「录音库还是空的」。
+- `library-empty`：实例里一条录音都没有时，显示「还没有录音」。
+- `library-batch-all`：只有「待转录」或「待归类」阶段是唯一筛选条件时，才出现「全部转录（N）」/「全部归类（N）」。N 取 `/api/overview` 的同口径阶段计数（不含已归档）。加了搜索、分类或标签后，按钮隐藏，因为服务端只按阶段选录音。配方：`--no-host` 启动，收件目录放一个 MP3，运行 `browse.mjs <runId> library-batch-all @.claude/skills/verify-openminutes/features/library-batch-all.steps.json`（不点按钮，不发起转录）。
 
 ## How to get to it (user POV)
 
-- 侧边导航「录音库」，或直接访问 `#/library`。
-- 详情页的「返回录音库」。
+- 侧边导航「录音」，或直接访问 `#/library`。
+- 详情页的「返回录音」。
 
 ## Driving it with browse.mjs
 
@@ -24,17 +25,17 @@ Preconditions:
 - 满足基线条件。按 [目录导入](./directory-import.md) 导入两个文件：`REC20261029_101500.mp3`（6 秒）和 `REC20261029_113000.mp3`（4 秒）。
 - 以下基础配方先把第一条录音标题改成「产品评审」（见 [录音详情](./recording-detail.md)）。要证明全文检索，使用 [Host 单条配方](./transcribe-organize.md)：在归类前搜索 TTS 的「蓝色铅笔」，接口确认标题/摘要为空且只命中已转录录音，避免把标题匹配误当全文匹配。
 
-- **空库。** 在导入任何文件之前运行 `browse.mjs <runId> lib-empty '[{"goto":"#/library"},{"waitText":"录音库还是空的"},{"screenshot":"empty.png"}]'`。
-- **列表。** 运行 `browse.mjs <runId> lib '[{"goto":"#/library"},{"waitText":"命中 2 条录音"},{"screenshot":"01-list.png"},{"aria":"01-list.aria.txt"}]'`。
-- **搜索命中。** 在同一次调用里追加 `{"fill":"aria=搜索录音","value":"产品评审"},{"waitText":"命中 1 条录音"},{"expectNoText":"REC20261029_113000.mp3"},{"screenshot":"02-hit.png"}`。
+- **空库。** 在导入任何文件之前运行 `browse.mjs <runId> lib-empty '[{"goto":"#/library"},{"waitText":"还没有录音"},{"screenshot":"empty.png"}]'`。
+- **列表。** 运行 `browse.mjs <runId> lib '[{"goto":"#/library"},{"waitText":"当前显示 2 条"},{"screenshot":"01-list.png"},{"aria":"01-list.aria.txt"}]'`。
+- **搜索命中。** 在同一次调用里追加 `{"fill":"aria=搜索录音","value":"产品评审"},{"waitText":"当前显示 1 条"},{"expectNoText":"REC20261029_113000.mp3"},{"screenshot":"02-hit.png"}`。
 - **搜索无结果。** 追加 `{"fill":"aria=搜索录音","value":"zzz-no-match"},{"waitText":"没有符合条件的录音"},{"screenshot":"03-miss.png"}`。
-- **清空搜索。** 追加 `{"fill":"aria=搜索录音","value":""},{"waitText":"命中 2 条录音"}`。
-- **阶段筛选。** 此失败配方须使用 `--no-host` 启动。先在第一条详情页点「开始转录」，让它因为 `HOST_NOT_CONNECTED` 进入失败状态（见 [转录与归类](./transcribe-organize.md)）。然后追加 `{"click":"text=失败"},{"waitText":"命中 1 条录音"},{"screenshot":"04-failed.png"}`，再用 `curl -s "$URL/api/recordings?stage=failed"` 核对，`total` 应为 1。
-- **排序。** 追加 `{"click":"text=全部"},{"waitText":"命中 2 条录音"},{"select":"aria=排序方式","value":"duration"},{"sleep":300},{"eval":"[...document.querySelectorAll('.row__title')].map(e => e.innerText)"}`。预期 6 秒的那条排在前面。
+- **清空搜索。** 追加 `{"fill":"aria=搜索录音","value":""},{"waitText":"当前显示 2 条"}`。
+- **阶段筛选。** 此失败配方须使用 `--no-host` 启动。先在第一条详情页点「开始转录」，让它因为 `HOST_NOT_CONNECTED` 进入失败状态（见 [转录与归类](./transcribe-organize.md)）。然后追加 `{"click":"text=失败"},{"waitText":"当前显示 1 条"},{"screenshot":"04-failed.png"}`，再用 `curl -s "$URL/api/recordings?stage=failed"` 核对，`total` 应为 1。
+- **排序。** 追加 `{"click":"text=全部"},{"waitText":"当前显示 2 条"},{"select":"aria=排序方式","value":"duration"},{"sleep":300},{"eval":"[...document.querySelectorAll('.row__title')].map(e => e.innerText)"}`。预期 6 秒的那条排在前面。
 
 ## Gotchas
 
-- 搜索带防抖。要等「命中 N 条录音」或空状态文字出现，不要截完图马上断言。
-- 表头的「命中 N 条录音」后面可能接「· K 个筛选条件生效」，所以断言时用包含匹配，不要用完全相等。
+- 搜索带防抖。要等「当前显示 N 条」或空状态文字出现，不要截完图马上断言。
+- 表头的「当前显示 N 条」后面可能接「· K 个筛选条件生效」，所以断言时用包含匹配，不要用完全相等。
 - 「失败」既是阶段按钮，也是行内状态标签的文字。`text=失败` 会命中第一个可见的元素，也就是工具栏里的那个按钮；如果要点行内的标签，请改用 CSS 选择器。
 - 分类和标签下拉框的 option value 是 id 或名称，而不是显示文字；显示文字里还附带「（条数）」。
diff --git a/.claude/skills/verify-openminutes/features/live-busy.steps.json b/.claude/skills/verify-openminutes/features/live-busy.steps.json
new file mode 100644
index 0000000..8374ffa
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/live-busy.steps.json
@@ -0,0 +1,13 @@
+[
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"click":"text=连接"},
+  {"waitText":"断开连接","timeout":60000},
+  {"eval":"(async () => { const r = await fetch('/api/device/sync', {method: 'POST', headers: {'content-type': 'application/json', connection: 'close'}, body: '{}'}); const body = await r.json(); if (!body.ok) throw Error('sync did not start: ' + JSON.stringify(body)); location.hash = '#/live'; const started = Date.now(); while (Date.now() - started < 20000) { const start = [...document.querySelectorAll('main button')].find((b) => b.innerText.trim() === '开始实时字幕'); if (document.body.innerText.includes('录音笔正在同步') && start?.disabled) return { jobId: body.data.jobId, ms: Date.now() - started }; await new Promise((resolve) => setTimeout(resolve, 30)); } throw Error('Live page did not block 开始 while syncing'); })()"},
+  {"expectText":"去录音笔查看"},
+  {"screenshot":"01-live-blocked.png"},
+  {"aria":"01-live-blocked.aria.txt"},
+  {"waitNoText":"录音笔正在同步","timeout":180000},
+  {"eval":"(() => { const start = [...document.querySelectorAll('main button')].find((b) => b.innerText.trim() === '开始实时字幕'); if (!start || start.disabled) throw Error('开始 should be enabled again after the sync'); return 'enabled'; })()"},
+  {"screenshot":"02-live-free.png"}
+]
diff --git a/.claude/skills/verify-openminutes/features/live-connecting.steps.json b/.claude/skills/verify-openminutes/features/live-connecting.steps.json
new file mode 100644
index 0000000..cddee27
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/live-connecting.steps.json
@@ -0,0 +1,11 @@
+[
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"eval":"(async () => { fetch('/api/device/connect', {method: 'POST', headers: {'content-type': 'application/json', connection: 'close'}, body: '{}'}).catch(() => undefined); await new Promise((r) => setTimeout(r, 50)); location.hash = '#/live'; const started = Date.now(); while (Date.now() - started < 15000) { const text = document.body.innerText; const start = [...document.querySelectorAll('main button')].find((b) => b.innerText.trim() === '开始实时字幕'); if (text.includes('录音笔正在同步')) throw Error('connecting must not be described as syncing'); if (text.includes('录音笔正在连接，请稍候。') && start?.disabled) return { ms: Date.now() - started }; await new Promise((r) => setTimeout(r, 30)); } throw Error('Live page never showed the connecting banner'); })()"},
+  {"screenshot":"01-live-connecting.png"},
+  {"aria":"01-live-connecting.aria.txt"},
+  {"waitNoText":"录音笔正在连接","timeout":60000},
+  {"expectNoText":"录音笔正在同步"},
+  {"eval":"(() => { const start = [...document.querySelectorAll('main button')].find((b) => b.innerText.trim() === '开始实时字幕'); if (!start || start.disabled) throw Error('开始 should be enabled again after the connect attempt'); return 'enabled'; })()"},
+  {"screenshot":"02-live-free.png"}
+]
diff --git a/.claude/skills/verify-openminutes/features/navigation.md b/.claude/skills/verify-openminutes/features/navigation.md
new file mode 100644
index 0000000..e262312
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/navigation.md
@@ -0,0 +1,27 @@
+# 导航与单一入口
+
+侧栏固定 6 项：录音、录音笔、实时字幕、日历、分类、设置。每页的 `<h1>` 与导航标签一致，当前页按钮带 `aria-current="page"`。详情页高亮「录音」，`#/settings/diagnostics` 高亮「设置」并自动展开「诊断与高级」。旧的 `#/overview` 和未知哈希都改写为 `#/library`。
+
+## Sub-features
+
+- `nav-six`：`nav[aria-label="主导航"] button` 恰好 6 个，顺序固定。
+- `nav-current`：逐个点击后 hash、`aria-current` 和 h1 三者一致。
+- `nav-rewrite`：`#/overview` 落到录音页；页面上不出现「概览」「导入新录音」。
+- `nav-diagnostics`：`#/settings/diagnostics` 高亮「设置」并展开 `details#diagnostics`；从别的页面进 `#/settings` 时默认折叠。
+- `nav-no-jargon`：录音笔页不出现 SDK、BLE、退出码、热点、SSID、读取清单、手动登记、导入目录；实时字幕页不出现 0x90、BLE。
+
+## How to get to it (user POV)
+
+- 打开应用即落在「录音」；左侧导航是唯一的页面切换方式，其他页面只放跳转链接。
+
+## Driving it with browse.mjs
+
+Preconditions：满足基线条件，普通启动（不需要 `--fake-device`），doctor 的 exit 为 0。
+
+- 运行 `browse.mjs <runId> navigation @.claude/skills/verify-openminutes/features/navigation.steps.json`。
+- 预期每个 `eval` 都返回值，最后一步返回 `"collapsed"`；`$E/navigation/console.log` 为空。
+
+## Gotchas
+
+- 导航按钮的 innerText 含徽标数字（例如「录音笔 3」），断言只读按钮里第一个 `span`。
+- 同一个设置页从 `#/settings/diagnostics` 原地切到 `#/settings` 时保留展开状态，这是预期行为；验证默认折叠要先离开设置页。
diff --git a/.claude/skills/verify-openminutes/features/navigation.steps.json b/.claude/skills/verify-openminutes/features/navigation.steps.json
new file mode 100644
index 0000000..8ff736c
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/navigation.steps.json
@@ -0,0 +1,38 @@
+[
+  {"goto":"#/overview"},
+  {"waitFor":"aria=主导航"},
+  {"eval":"(async () => { for (let i = 0; i < 50 && location.hash !== '#/library'; i += 1) await new Promise((r) => setTimeout(r, 100)); if (location.hash !== '#/library') throw Error('#/overview was not rewritten: ' + location.hash); return location.hash; })()"},
+  {"eval":"(() => { const items = [...document.querySelectorAll('nav[aria-label=\"主导航\"] button')].map((b) => b.querySelector('span')?.innerText.trim()); const want = ['录音', '录音笔', '实时字幕', '日历', '分类', '设置']; if (JSON.stringify(items) !== JSON.stringify(want)) throw Error('Unexpected nav: ' + JSON.stringify(items)); return items; })()"},
+  {"expectNoText":"概览"},
+  {"expectNoText":"导入新录音"},
+  {"screenshot":"01-library.png"},
+  {"aria":"01-library.aria.txt"},
+  {"eval":"(async () => { const want = [['录音', '#/library'], ['录音笔', '#/device'], ['实时字幕', '#/live'], ['日历', '#/calendar'], ['分类', '#/categories'], ['设置', '#/settings']]; const seen = []; for (const [label, hash] of want) { const button = [...document.querySelectorAll('nav[aria-label=\"主导航\"] button')].find((b) => b.querySelector('span')?.innerText.trim() === label); button.click(); let ok = false; for (let i = 0; i < 50; i += 1) { await new Promise((r) => setTimeout(r, 100)); const current = document.querySelector('nav[aria-label=\"主导航\"] [aria-current=\"page\"]'); const h1 = document.querySelector('main h1')?.innerText.trim(); if (location.hash.split('?')[0] === hash && current?.querySelector('span')?.innerText.trim() === label && h1 === label) { ok = true; break; } } if (!ok) throw Error('Nav ' + label + ' failed: hash=' + location.hash + ' h1=' + document.querySelector('main h1')?.innerText); seen.push([label, location.hash]); } return seen; })()"},
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"expectNoText":"SDK"},
+  {"expectNoText":"BLE"},
+  {"expectNoText":"退出码"},
+  {"expectNoText":"热点"},
+  {"expectNoText":"SSID"},
+  {"expectNoText":"读取清单"},
+  {"expectNoText":"手动登记"},
+  {"expectNoText":"导入目录"},
+  {"screenshot":"02-device.png"},
+  {"aria":"02-device.aria.txt"},
+  {"goto":"#/live"},
+  {"waitText":"开始实时字幕"},
+  {"expectNoText":"0x90"},
+  {"expectNoText":"BLE"},
+  {"goto":"#/settings/diagnostics"},
+  {"waitFor":"details#diagnostics[open]"},
+  {"waitText":"最近设备操作"},
+  {"eval":"(() => { const current = document.querySelector('nav[aria-label=\"主导航\"] [aria-current=\"page\"]')?.querySelector('span')?.innerText.trim(); if (current !== '设置') throw Error('Diagnostics should highlight 设置, got ' + current); return current; })()"},
+  {"screenshot":"03-diagnostics.png"},
+  {"aria":"03-diagnostics.aria.txt"},
+  {"goto":"#/library"},
+  {"waitText":"还没有录音"},
+  {"goto":"#/settings"},
+  {"waitText":"保存设置"},
+  {"eval":"(() => { if (document.querySelector('details#diagnostics')?.open) throw Error('Diagnostics should start collapsed'); return 'collapsed'; })()"}
+]
diff --git a/.claude/skills/verify-openminutes/features/recording-detail-actions.steps.json b/.claude/skills/verify-openminutes/features/recording-detail-actions.steps.json
new file mode 100644
index 0000000..1c5ad68
--- /dev/null
+++ b/.claude/skills/verify-openminutes/features/recording-detail-actions.steps.json
@@ -0,0 +1,46 @@
+[
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"click":"text=连接"},
+  {"waitText":"断开连接","timeout":60000},
+  {"eval":"(async () => { const d = (await (await fetch('/api/device', {headers: {connection: 'close'}})).json()).data; if (d.lastResult) throw Error('auto_pull must be 0 for this recipe'); const serial = d.device.serial; const sizes = { 'REC20261020_103000.mp3': 2097152, 'REC20261020_143000.mp3': 1572864, 'REC20261021_090000.mp3': 204800 }; const names = Object.keys(sizes); const r = await fetch('/api/ingest/manifest', {method: 'POST', headers: {'content-type': 'application/json', connection: 'close'}, body: JSON.stringify({serial, entries: names.map((name) => ({ name, sizeBytes: sizes[name] }))})}); const body = await r.json(); if (!body.ok || body.data.accepted !== 3) throw Error('Manifest not registered: ' + JSON.stringify(body)); return { serial, ids: body.data.ids }; })()"},
+  {"goto":"#/library"},
+  {"waitText":"当前显示"},
+  {"goto":"#/device"},
+  {"waitText":"还在录音笔里（3）"},
+  {"eval":"(() => { const rows = [...document.querySelectorAll('.pulllist li')]; const small = rows.find((li) => li.innerText.includes('REC20261021_090000.mp3')); if (!small || small.innerText.includes('无线快传')) throw Error('A small recording must not be marked for the hotspot'); return rows.filter((li) => li.innerText.includes('无线快传')).length; })()"},
+  {"eval":"(() => { const row = [...document.querySelectorAll('.pulllist li')].find((li) => li.innerText.includes('REC20261021_090000.mp3')); if (!row) throw Error('Row missing'); row.querySelector('button').click(); return 'pull one'; })()"},
+  {"waitText":"已同步 1 条录音","timeout":120000},
+  {"waitText":"还在录音笔里（2）"},
+  {"eval":"(() => { const rows = [...document.querySelectorAll('.pulllist li')].map((li) => li.innerText); const big = rows.filter((t) => t.includes('无线快传')); if (rows.length !== 2 || big.length !== 2) throw Error('Large single-item syncs should be marked: ' + JSON.stringify(rows)); if (!document.querySelector('.pulllist__hint')?.innerText.includes('暂时断开外网')) throw Error('Missing offline hint under the list'); return rows; })()"},
+  {"screenshot":"01-one-synced.png"},
+  {"eval":"(async () => { const items = (await (await fetch('/api/recordings', {headers: {connection: 'close'}})).json()).data.items; const pending = items.filter((item) => item.status === 'pending'); const ready = items.filter((item) => item.status === 'ready'); if (pending.length !== 2 || ready.length !== 1) throw Error('Unexpected statuses: ' + JSON.stringify(items.map((item) => [item.filename, item.status]))); sessionStorage.setItem('pendingId', String(pending[0].id)); sessionStorage.setItem('readyId', String(ready[0].id)); location.hash = '#/rec/' + pending[0].id; return { pending: pending.map((item) => item.id), ready: ready[0].id }; })()"},
+  {"waitText":"这条录音还在录音笔里"},
+  {"expectNoText":"从设备拉取音频"},
+  {"expectNoText":"开始转录"},
+  {"expectNoText":"执行记录"},
+  {"expectText":"处理记录"},
+  {"screenshot":"02-pending-detail.png"},
+  {"aria":"02-pending-detail.aria.txt"},
+  {"click":"text=去录音笔同步"},
+  {"waitText":"还在录音笔里（2）"},
+  {"eval":"(() => { if (location.hash !== '#/device') throw Error('Expected #/device, got ' + location.hash); return location.hash; })()"},
+  {"eval":"(() => { location.hash = '#/rec/' + sessionStorage.getItem('readyId'); return location.hash; })()"},
+  {"waitText":"开始转录"},
+  {"eval":"(() => { const primaries = [...document.querySelectorAll('.detail__actions .btn--primary, .detail__actions button.primary')]; const labels = [...document.querySelectorAll('.detail__actions button')].map((b) => b.innerText.trim()).filter(Boolean); if (!labels.includes('开始转录')) throw Error('Missing primary 开始转录: ' + JSON.stringify(labels)); for (const extra of ['重新转录', '重新归类', 'AI 归类', '从设备拉取音频']) if (labels.includes(extra)) throw Error('Unexpected header action ' + extra + ': ' + JSON.stringify(labels)); const crumb = document.querySelector('nav[aria-label=\"当前位置\"]'); if (crumb?.querySelector('a')?.innerText.trim() !== '录音') throw Error('Missing breadcrumb'); return { labels, primaries: primaries.length }; })()"},
+  {"screenshot":"03-ready-detail.png"},
+  {"aria":"03-ready-detail.aria.txt"},
+  {"goto":"#/calendar?day=2026-10-21"},
+  {"waitFor":"a.calendar-recording-button"},
+  {"eval":"(() => { const link = document.querySelector('a.calendar-recording-button[href=\"#/rec/' + sessionStorage.getItem('readyId') + '\"]'); if (!link) throw Error('Recording not on the 2026-10-21 calendar day'); link.click(); return link.getAttribute('href'); })()"},
+  {"waitText":"返回日历"},
+  {"click":"text=返回日历"},
+  {"waitFor":"a.calendar-recording-button"},
+  {"eval":"(() => { if (!location.hash.startsWith('#/calendar')) throw Error('Back should return to the calendar, got ' + location.hash); return location.hash; })()"},
+  {"eval":"(async () => { const p = await (await fetch('/api/settings', {method: 'PATCH', headers: {'content-type': 'application/json', connection: 'close'}, body: JSON.stringify({values: {auto_pull: '1'}})})).json(); if (!p.ok) throw Error('PATCH failed'); const d = await (await fetch('/api/device/disconnect', {method: 'POST', headers: {'content-type': 'application/json', connection: 'close'}, body: '{}'})).json(); if (!d.ok) throw Error('disconnect failed: ' + JSON.stringify(d)); return d.data.connection.state; })()"},
+  {"goto":"#/device"},
+  {"waitText":"录音笔未连接"},
+  {"waitText":"连上后会自动同步，较大的录音将通过无线快传，期间电脑会暂时断开外网"},
+  {"screenshot":"04-offline-hint-before-connect.png"},
+  {"eval":"(async () => { const d = (await (await fetch('/api/device', {headers: {connection: 'close'}})).json()).data; if (d.connection.state !== 'disconnected' || !d.syncPlan?.willGoOffline || !d.autoConnect.syncOnConnect) throw Error('Unexpected preview: ' + JSON.stringify({ state: d.connection.state, syncPlan: d.syncPlan, auto: d.autoConnect })); const p = await (await fetch('/api/settings', {method: 'PATCH', headers: {'content-type': 'application/json', connection: 'close'}, body: JSON.stringify({values: {auto_pull: '0'}})})).json(); if (!p.ok) throw Error('restore auto_pull failed'); return d.syncPlan; })()"}
+]
diff --git a/.claude/skills/verify-openminutes/features/recording-detail.md b/.claude/skills/verify-openminutes/features/recording-detail.md
index 0a14f0c..a7c14ed 100644
--- a/.claude/skills/verify-openminutes/features/recording-detail.md
+++ b/.claude/skills/verify-openminutes/features/recording-detail.md
@@ -1,20 +1,24 @@
 # 录音详情
 
-用户在录音库里点开一条录音，进入详情页。详情页可以播放音频（支持拖动进度条，后端用 HTTP Range 实现），可以人工修正标题、分类、重要度和标签，可以收藏、归档、导出到本机目录，也可以删除（音频文件会移到 `_trash`）。
+用户在「录音」页点开一条录音，进入详情页。侧栏仍高亮「录音」，页头面包屑为「录音 › <标题>」。详情页可以播放音频（支持拖动进度条，后端用 HTTP Range 实现），可以人工修正标题、分类、重要度和标签，可以收藏、导出到本机目录；归档、删除（音频文件会移到 `_trash`）、重新转录、重新归类放在「更多」菜单里。
 
 ## Sub-features
 
-- `detail-open`：点击行标题进入 `#/rec/<id>`；「返回录音库」回到列表。
+- `detail-open`：点击行标题进入 `#/rec/<id>`；返回按钮回到应用内的上一个页面（从录音页进入显示「返回录音」，从日历进入显示「返回日历」），没有上一页时回到 `#/library`。
+- `detail-primary`：页头只有一个随状态切换的主按钮：待转录显示「开始转录」，待归类显示「AI 归类」，已整理时不显示。还在录音笔里的录音不显示主按钮，只有「这条录音还在录音笔里…」说明和「去录音笔同步」链接（跳到 `#/device`），没有「从设备拉取音频」。
 - `detail-playback`：`<audio>` 从 `/api/recordings/<id>/audio` 读取音频；Range 请求返回 206，越界返回 416。
 - `detail-title`：「编辑标题」→ 填写「录音标题」→ 回车或「保存标题」，提示「标题已更新」。
 - `detail-organize-fields`：右侧「整理」栏可以改分类下拉框、「重要度 N」按钮和「添加标签」输入框。
-- `detail-favorite-archive`：「收藏」「归档」可以来回切换，按钮文字随之变化。
+- `detail-favorite-archive`：「收藏」在页头，「归档」在「更多」里，都可以来回切换，文字随之变化。
 - `detail-export`：「导出」把文件复制到导入目录，提示「已导出到本机目录」。
-- `detail-delete`：「删除」弹出确认框，删除后提示「录音已删除」，并返回录音库。
+- `detail-delete`：「更多」→「删除」弹出确认框，删除后提示「录音已删除」，并返回录音库。
+- `detail-calendar-readonly`：「日程」区只读。未关联时显示「还没有关联日程。」和「在日历中关联」链接；已关联时显示事件标题、时间和「在日历中修改」。链接为 `#/calendar?day=<录制日期>&rec=<id>`，关联只在日历页完成。
+- `detail-jobs`：tab「处理记录 N」只显示中文；失败提示是 ErrorNotice，技术原文点「查看详情」才出现。
 
 ## How to get to it (user POV)
 
-- 录音库里点击某一行的标题区域（`button.row__main`）。
+- 「录音」页里点击某一行的标题区域（`button.row__main`）。
+- 日历页里点录音标题。
 - 直接访问 `#/rec/<id>`。
 
 ## Driving it with browse.mjs
@@ -23,17 +27,20 @@ Preconditions:
 
 - 满足基线条件。已按 [目录导入](./directory-import.md) 导入 `REC20261029_101500.mp3`，它的 id 为 1。
 
-- **打开详情。** 运行 `browse.mjs <runId> detail '[{"goto":"#/library"},{"waitFor":"button.row__main"},{"click":"button.row__main"},{"waitText":"返回录音库"},{"eval":"location.hash"},{"screenshot":"01-open.png"},{"aria":"01-open.aria.txt"}]'`。预期 hash 为 `#/rec/1`，元数据里的「音频文件」指向 `$R\library\2026-10\…`。
+- **打开详情。** 运行 `browse.mjs <runId> detail '[{"goto":"#/library"},{"waitFor":"button.row__main"},{"click":"button.row__main"},{"waitText":"返回录音"},{"eval":"location.hash"},{"screenshot":"01-open.png"},{"aria":"01-open.aria.txt"}]'`。预期 hash 为 `#/rec/1`，元数据里的「音频文件」指向 `$R\library\2026-10\…`。
 - **音频可加载。** 在同一次调用里追加 `{"eval":"new Promise(r => { const a = document.querySelector('audio'); if (a.readyState >= 1) r(a.duration); else a.addEventListener('loadedmetadata', () => r(a.duration)); })"}`。预期结果为 `6`。
 - **Range 协议。** 运行 `curl -s -D - -o /dev/null -H 'Range: bytes=100-199' "$URL/api/recordings/1/audio" | tee $E/detail/range.txt`。预期看到 `206`、`content-range: bytes 100-199/<size>` 和 `accept-ranges: bytes`。再用 `-H 'Range: bytes=999999-'` 请求一次，预期返回 `416`。
 - **改标题。** 追加 `{"click":"aria=编辑标题"},{"fill":"aria=录音标题","value":"产品评审"},{"press":"Enter"},{"waitText":"标题已更新"},{"expectText":"产品评审"},{"screenshot":"02-title.png"}`。读回验证：`curl -s "$URL/api/recordings/1"` 返回的 `title` 应为「产品评审」。
 - **重要度与标签。** 追加 `{"click":"aria=重要度 4"},{"waitText":"重要度设为 4"},{"fill":"aria=添加标签","value":"周会"},{"press":"Enter"},{"waitText":"已添加标签「周会」"},{"screenshot":"03-fields.png"}`。读回验证：`importance` 为 4，`tags` 包含「周会」。
 - **导出。** 收件目录里还留着同名的原文件，直接 `ls` 无法区分是不是导出的。所以先运行 `rm $R/inbox/REC20261029_101500.mp3`，再追加 `{"click":"text=导出"},{"waitText":"已导出到本机目录"}`。然后运行 `ls $R/inbox/ | tee $E/detail/export.txt`，被删掉的文件应该重新出现。
-- **删除。** 追加 `{"click":"text=删除"},{"waitText":"录音已删除"}`。`steps.log` 里应记录 `dialog confirm: 音频文件会移动到数据目录的 _trash 子目录… -> accepted`。之后 `curl -s "$URL/api/recordings"` 的 `total` 减 1。
+- **删除。** 追加 `{"click":"details.moremenu > summary"},{"click":"text=删除"},{"waitText":"录音已删除"}`（先展开「更多」）。`steps.log` 里应记录 `dialog confirm: 音频文件会移到数据目录的回收站，确认删除这条录音？ -> accepted`。之后 `curl -s "$URL/api/recordings"` 的 `total` 减 1。
+
+- **单一主按钮与在录音笔中的录音（假录音笔）。** 新 runId、`launch.mjs <runId> --no-host --fake-device=wifi`（保持 `auto_pull=0`），运行 `browse.mjs <runId> recording-detail-actions @.claude/skills/verify-openminutes/features/recording-detail-actions.steps.json`。步骤用开发者接口 `POST /api/ingest/manifest` 只登记清单、在录音笔页同步其中 1 条，然后检查：在录音笔中的详情显示「这条录音还在录音笔里」，没有「从设备拉取音频」和「开始转录」，「去录音笔同步」到达 `#/device`；待转录的详情页头只有「开始转录」一个主动作，面包屑为「录音 › …」；从日历进入详情再「返回日历」回到日历页。另外检查断网提示：200 KB 的录音不标「无线快传」，剩下两条较大的标出并在列表下说明会暂时断开外网；最后在 `auto_pull=1` 下断开，「连接」按钮下方显示「连上后会自动同步，较大的录音将通过无线快传，期间电脑会暂时断开外网」。清单登记要带 `sizeBytes`，大小未知的记录不参与提示。
 
 ## Gotchas
 
-- 「录音标题」输入框只在点了「编辑标题」之后才存在。判断详情页是否加载完成，请等「返回录音库」。
+- 「录音标题」输入框只在点了「编辑标题」之后才存在。判断详情页是否加载完成，请等「返回录音」（从日历进入时是「返回日历」）。
+- 「更多」是 `<details class="moremenu">`，里面的菜单项只有展开后才可点击。
 - `browse.mjs` 会自动接受 `window.confirm`。要验证「取消删除」这条路径，目前做不到，报告里写「未验证」。
 - 每个修改都有自己的 toast：「重要度设为 N」「已添加标签「X」」「标签已移除」「分类已更新」「已收藏」「已归档」。等 toast 出现，再读回接口确认。
 - 音频不可用时（文件丢失），分段时标会退回纯文本，播放器也不会出现。这种情况属于另一个场景，需要先手动删掉 `library/` 里的文件来制造。
diff --git a/.claude/skills/verify-openminutes/features/transcribe-organize.md b/.claude/skills/verify-openminutes/features/transcribe-organize.md
index 82a4889..8683c35 100644
--- a/.claude/skills/verify-openminutes/features/transcribe-organize.md
+++ b/.claude/skills/verify-openminutes/features/transcribe-organize.md
@@ -6,14 +6,14 @@
 
 - 单条转录：详情页原地由排队/转录中到分段全文，切换纯文本，点击非零时标起播。
 - 全文检索：归类前标题/摘要仍为空，搜索「蓝色铅笔」命中，再搜索不存在的词得到空结果。
-- 单条 AI 归类：标题、摘要、分类、标签、要点、待办、重要度落库，详情与执行记录可见。
+- 单条 AI 归类：标题、摘要、分类、标签、要点、待办、重要度落库，详情与处理记录可见。
 - 人工修正：改标题、分类、重要度、添加标签，返回列表再打开，UI 与 GET 读回一致。摘要/要点/待办目前没有人工编辑入口，不宣称覆盖。
 - 批量：仅选择两条新录音，批量转录后批量归类，列表自动更新到终态。
 - 预算：3 段约 15–19 秒语音，3 个转录任务、3 个归类任务。应用可能重连 ASR 或从 `generateObject` 回退到 `generateText`，必须统计实际调用，不能用任务数代替计费调用数。遇到失败先停止并留证，不自动重放。
 
 ## 前置与单条
 
-Floatboat 桌面端运行且曾打开本应用；已有中文 Windows TTS 声音和 ffmpeg。只操作隔离页面，不驱动 Floatboat 原工作台，不碰 BLE。
+Floatboat 桌面端运行且曾打开本应用；已有中文 Windows TTS 声音和 ffmpeg。只操作隔离页面，不驱动 Floatboat 原工作台，不碰真实录音笔。
 
 ```powershell
 node .claude/skills/verify-openminutes/scripts/build.mjs
@@ -26,7 +26,7 @@ node .claude/skills/verify-openminutes/scripts/evidence.mjs host-success single
 
 每条命令成功后才执行下一条。`doctor` 必须报告 `host.mode=floatboat`、`available=true`、`problems=[]`。TTS 变体 1 生成 `REC20261029_120001.mp3`；固定日期用于可复现的录音时间，不代表当前时间。
 
-`host-single.json` 从设备页「立即扫描」导入一条，然后点详情「开始转录」。它等待 `.segment__jump`，并断言状态 `transcribed`、全文非空、至少两个分段、hash 始终为 `#/rec/1`。点击第二段后断言播放器未暂停，`currentTime` 与接口的 `startMs/1000` 差小于 2 秒。最后通过 UI 和 GET 验证全文搜索。
+`host-single.json` 从录音页头「导入」→「扫描并导入」导入一条，然后点详情页头唯一的主按钮「开始转录」。它等待 `.segment__jump`，并断言状态 `transcribed`、全文非空、至少两个分段、hash 始终为 `#/rec/1`。点击第二段后断言播放器未暂停，`currentTime` 与接口的 `startMs/1000` 差小于 2 秒。最后通过 UI 和 GET 验证全文搜索。
 
 证据 `$E/single/` 包含排队、分段、跳转播放、纯文本、搜索命中/未命中的截图或 ARIA，以及 `detail-1.json`、`job_runs.json`。`steps.log` 记录播放头、接口读回与断言结果。成功后再跑 AI，避免标题/摘要污染全文搜索的证明。
 
@@ -39,7 +39,7 @@ node .claude/skills/verify-openminutes/scripts/browse.mjs host-success correct '
 node .claude/skills/verify-openminutes/scripts/evidence.mjs host-success correct
 ```
 
-归类配方等按钮恢复且出现「重新归类」，再查看 AI 结论和执行记录，不用固定延时猜完成。接口断言所有结构化字段存在，录音标题/摘要/重要度与分析一致。`$E/organize/03-analysis.*` 展示摘要、要点、待办及右侧整理字段；`04-jobs.*` 展示成功记录。
+归类配方等状态变为「已整理」、页头主按钮消失（「重新归类」在「更多」菜单里），再查看 AI 结论和处理记录，不用固定延时猜完成。接口断言所有结构化字段存在，录音标题/摘要/重要度与分析一致。`$E/organize/03-analysis.*` 展示摘要、要点、待办及右侧整理字段；`04-jobs.*` 展示成功记录。
 
 人工修正配方将标题改为「人工确认的发布计划」、分类 id 改为 2、重要度改为 2、添加「人工复核」。`$E/correct/02-reopened.*` 与 `detail-1.json` 证明重新打开后仍一致。分类 id 依赖当前内置迁移；若迁移改变，先 GET 分类再调整配方。分析记录是 AI 历史快照，不要求它被人工修正覆盖。
 
@@ -65,7 +65,7 @@ node .claude/skills/verify-openminutes/scripts/cleanup.mjs host-success
 
 ## 显式无 Host 失败配方
 
-另开 `launch.mjs host-off --no-host`，doctor 显示 `mode=none, available=false`，这是预期而不是失败。生成语音变体 1 并按目录导入配方导入。详情点击「开始转录」，等待 `HOST_NOT_CONNECTED`，断言错误条可见、状态 `failed`、`jobs[0].status=failure`、全文为空。此流程不产生真实 Host 调用。
+另开 `launch.mjs host-off --no-host`，doctor 显示 `mode=none, available=false`，这是预期而不是失败。生成语音变体 1 并按目录导入配方导入。详情点击「开始转录」，等待失败提示：主行是中文结论，看不到 `HOST_NOT_CONNECTED`；点「查看详情」后才出现 `HOST_NOT_CONNECTED`。断言状态 `failed`、`lastError` 为中文、`lastErrorDetail` 含 `HOST_NOT_CONNECTED`、`jobs[0].status=failure`、全文为空。此流程不产生真实 Host 调用。
 
 可执行步骤（配方包含导入，运行前不要重复导入）：
 
@@ -82,8 +82,8 @@ node .claude/skills/verify-openminutes/scripts/cleanup.mjs host-off
 
 ## 边界与已知行为
 
-- 自动连接、拉取、转录、归类开关均为 0，导入后必须手动触发。
+- 自动连接、自动同步、转录、归类开关均为 0，导入后必须手动触发。
 - 排队状态由队列计算，不落数据库，筛选仍按持久化状态统计。
 - 能力探测成功只证明连接可用，不保证某个上游模型成功。`LLM_OBJECT_INVALID` 后文本回退成功时，归类 job 可以成功，Host 调用记录仍保留失败请求。
-- 实时字幕、长录音续传、BLE、多说话人、其它转录入口与终态停止轮询的请求计数不在上述成功配方覆盖范围。
+- 实时字幕、长录音续传、录音笔同步、多说话人、其它转录入口与终态停止轮询的请求计数不在上述成功配方覆盖范围。
 - 无 Host 场景不能写成“转录可用”；Host 成功也不能代替未执行的入口。
diff --git a/.claude/skills/verify-openminutes/features/transcribe-success.md b/.claude/skills/verify-openminutes/features/transcribe-success.md
index 44dca09..0d5c620 100644
--- a/.claude/skills/verify-openminutes/features/transcribe-success.md
+++ b/.claude/skills/verify-openminutes/features/transcribe-success.md
@@ -6,7 +6,7 @@
 
 - 先按 SKILL.md 完成 build → launch → doctor。仅驱动本 run 的隔离实例，保留四个自动开关为 `0`，不使用用户 Floatboat 应用的数据库。
 - `launch.mjs` 默认连接运行中的 Floatboat Host；显式 `--no-host` 仅验证独立模式。按 SKILL.md 的 Host 启动说明创建 run，不要手工拼 IPC 配置或操作用户的真实实例。
-- Host 模式必须通过该版本 doctor，并在设备页「本机环境」确认「语音识别」「文本模型」就绪。将环境截图与 ARIA 保存到 `$E/host-preflight/`。只看到 Host 进程在运行不算通过；`HOST_NOT_CONNECTED`、权限不足或额度不足时停止。
+- Host 模式必须通过该版本 doctor，并在「设置 › 诊断与高级 › 本机环境」（`#/settings/diagnostics`）确认「语音识别与 AI 整理」分组就绪。将环境截图与 ARIA 保存到 `$E/host-preflight/`。只看到 Host 进程在运行不算通过；`HOST_NOT_CONNECTED`、权限不足或额度不足时停止。
 - ASR/LLM 会消耗用户额度。确认允许使用额度后，单条只转录一次、归类一次；批量只处理另外两条。正常共 3 个转录任务、3 个归类任务、最多 18 秒源音频。上游重连或模型结构化输出重试可能增加实际请求数，这不是计费硬上限。失败后保留证据并停止，不自动重试、不点「重新转录」「重新归类」。
 - 以下 PowerShell 示例的 runId 为 `voice-success-20261029`。每次换新 runId；`$S`、`$R`、`$E` 先设为实际路径。单条录音必须是新库里的 id 1，批量文件名固定如下。配方含前置断言，不能在已有任务的库里重复执行。
 
@@ -30,7 +30,7 @@ node "$S/browse.mjs" voice-success-20261029 voice-import "@$F/voice-import.steps
 
 英语只证明英语路径，不能据此宣称中文 ASR 通过。英文验收须复制下面的步骤文件到 `$R`，把关键词「评审」改为 `review`，人工修改标题等中文 UI 文案不用改。音色/系统版本可能改变 MP3 字节，复现以相同文本、语言和媒体参数为准，保留本次音色与哈希用于追踪。
 
-`voice-import.steps.json` 走录音库 → 导入新录音 → 立即扫描 → 录音库 → 详情。它断言 `recording.status=ready`、`hasAudioFile=true`、`transcriptChars=0`、`jobs=[]`，随后通过浏览器原生音频 API 播放并等待 `currentTime>0.25`、`paused=false`、`error=null`，不只验证有 `<audio>` 元素。它不点击 ASR/LLM。
+`voice-import.steps.json` 走录音页 → 页头「导入」→「扫描并导入」→ 关闭对话框 → 录音页 → 详情。它断言 `recording.status=ready`、`hasAudioFile=true`、`transcriptChars=0`、`jobs=[]`，随后通过浏览器原生音频 API 播放并等待 `currentTime>0.25`、`paused=false`、`error=null`，不只验证有 `<audio>` 元素。它不点击 ASR/LLM。
 
 证据在 `$E/voice-import/`：`01-empty`、`02-imported`、`03-playable` 的 PNG/ARIA，完整接口读回和播放状态在 `steps.log`，`console.log` 应为空。另外保存独立响应、媒体和磁盘副作用证据，cleanup 前执行：
 
@@ -45,7 +45,7 @@ Get-FileHash "$R/inbox/REC20261029_150000.mp3","$R/library/2026-10/REC20261029_1
   ConvertTo-Json | Set-Content "$E/voice-import/file-hashes.json"
 ```
 
-预期列表只有一条录音、`durationSec` 约为 5（应用取整）；源文件和归档副本均存在且 SHA-256 相同。本配方不更改「保存路径」。
+预期列表只有一条录音、`durationSec` 约为 5（应用取整）；源文件和归档副本均存在且 SHA-256 相同。本配方不在「设置」里保存目录。
 
 ## 2. 单条转录、全文检索、分段跳播
 
@@ -67,10 +67,10 @@ node "$S/browse.mjs" voice-success-20261029 single-success "@$F/transcribe-succe
 
 同一份 `transcribe-success.steps.json` 接着执行：
 
-1. 从检索结果回详情，点击「AI 归类」，保存 `07-organize-accepted` PNG/ARIA。过渡状态为 `queued_organize` / `analyzing`（归类已排队 / 归类中），终态是 `organized`，UI 叫「已归档」。等待终态上限 120 秒，不能仅凭 toast 判断成功。
+1. 从检索结果回详情，点击「AI 归类」，保存 `07-organize-accepted` PNG/ARIA。过渡状态为 `queued_organize` / `analyzing`（归类已排队 / 归类中），终态是 `organized`，UI 叫「已整理」。等待终态上限 120 秒，不能仅凭 toast 判断成功。
 2. 打开「AI 结论」，读回 `GET /api/recordings/1`，按下表逐项核对；`08-organized` PNG/ARIA 必须包含页面标题、摘要、分类、标签、要点、待办和重要度。模型措辞不做完全相等断言，但这句会议通知应提取会议主题及提前到场事项；字段为空或语义不符均需报告，不重试掩盖。
 3. 点击「编辑标题」，填「人工确认的项目评审」，点「保存标题」，等「标题已更新」。重新 GET 确认 `recording.title` 精确相等、状态仍是 `organized`，原始 `analysis` 不变。保存 `09-edited` PNG/ARIA 与响应。这里验证人工标题入口，不声称其它人工字段入口已验证。
-4. 打开「执行记录 2」，保存 `10-jobs` PNG/ARIA，确认转录、归类各一条成功。数据库表名是 `job_runs`，详情 API 的字段叫 `data.jobs`，没有 `data.job_runs`。本配方不直接写库。
+4. 打开「处理记录 2」，保存 `10-jobs` PNG/ARIA，确认转录、归类各一条成功。数据库表名是 `job_runs`，详情 API 的字段叫 `data.jobs`，没有 `data.job_runs`。本配方不直接写库。
 
 | 验收概念 | 实际读回字段与期望 |
 | --- | --- |
@@ -97,7 +97,7 @@ node "$S/browse.mjs" voice-success-20261029 batch-success "@$F/batch-success.ste
 
 每条命令成功后才执行下一条。脚本扫描新增两条，进入录音库精确勾选这两个文件（不全选已有成功录音），点击「批量转录」，等待「已排队 2 条转录任务」。它不刷新页面、不重新导航，按 `.table__body .row .col-status` 等待两行自动变为「待归类」，而非等待工具栏始终存在的文字。
 
-转录完成后重新勾选这两行，点击「批量归类」，等「已排队 2 条归类任务」，仍在同一页面等三行都成为「已归档」。每阶段最多等 120 秒。`01-selected`、`02-transcribe-accepted`、`03-transcribed`、`04-organize-accepted`、`05-organized` 各保留 PNG/ARIA。
+转录完成后重新勾选这两行，点击「批量归类」，等「已排队 2 条归类任务」，仍在同一页面等三行都成为「已整理」。每阶段最多等 120 秒。`01-selected`、`02-transcribe-accepted`、`03-transcribed`、`04-organize-accepted`、`05-organized` 各保留 PNG/ARIA。
 
 读回 `/api/recordings`，两阶段终态都要求 `hasActiveTasks=false`；分别 GET 两个新 id，转录后要求 `status=transcribed`、`transcriptChars>0`、全文含「评审」、`segments` 非空、转录 job 成功。归类后要求 `status=organized` 及第 3 节字段表的完整断言。脚本保留列表与详情响应于 `steps.log`，人工再按表核对模型语义、分类 slug 和字段一致性，并保存各 id 的 `detail-<id>.json`。
 
diff --git a/.claude/skills/verify-openminutes/features/transcribe-success.steps.json b/.claude/skills/verify-openminutes/features/transcribe-success.steps.json
index 51f16db..5f2cdf7 100644
--- a/.claude/skills/verify-openminutes/features/transcribe-success.steps.json
+++ b/.claude/skills/verify-openminutes/features/transcribe-success.steps.json
@@ -1,7 +1,7 @@
 [
   {"goto":"#/rec/1"},
-  {"waitText":"返回录音库"},
-  {"eval":"(async () => { const required = { asr: ['start', 'sendFrame', 'events', 'stop'], llm: ['generateObject', 'generateText'] }; const response = await fetch('/api/device/capabilities'); const body = await response.json(); const capabilities = body.data; const ready = (domain, operations) => operations.every(operation => capabilities?.[domain]?.some(item => item.operation === operation && item.declared === true && item.status === 'available')); if (!response.ok || !body.ok || !ready('asr', required.asr) || !ready('llm', required.llm)) throw Error('Host ASR/LLM capabilities incomplete; no paid task submitted'); const b = await fetch('/api/recordings/1').then(r => r.json()); if (!b.ok || b.data.recording.status !== 'ready' || b.data.jobs.length) throw Error('Requires fresh recording 1; do not rerun paid calls'); window.__route = location.hash; return b; })()"},
+  {"waitText":"返回录音"},
+  {"eval":"(async () => { const required = { asr: ['start', 'sendFrame', 'events', 'stop'], llm: ['generateObject', 'generateText'] }; const response = await fetch('/api/environment/capabilities'); const body = await response.json(); const capabilities = body.data; const ready = (domain, operations) => operations.every(operation => capabilities?.[domain]?.some(item => item.operation === operation && item.declared === true && item.status === 'available')); if (!response.ok || !body.ok || !ready('asr', required.asr) || !ready('llm', required.llm)) throw Error('Host ASR/LLM capabilities incomplete; no paid task submitted'); const b = await fetch('/api/recordings/1').then(r => r.json()); if (!b.ok || b.data.recording.status !== 'ready' || b.data.jobs.length) throw Error('Requires fresh recording 1; do not rerun paid calls'); window.__route = location.hash; return b; })()"},
   {"screenshot":"01-before.png"},
   {"aria":"01-before.aria.txt"},
   {"click":"text=开始转录"},
@@ -25,21 +25,21 @@
   {"eval":"(async () => { const a = document.querySelector('audio'); const deadline = Date.now() + 8000; while (Date.now() < deadline) { if (window.__seeked !== null && !a.paused && a.currentTime > window.__seekTarget + 0.1) { if (Math.abs(window.__seeked - window.__seekTarget) > 0.5) throw Error('Seek landed at wrong time'); const result = { target: window.__seekTarget, seeked: window.__seeked, currentTime: a.currentTime, paused: a.paused }; a.pause(); return result; } if (a.error) throw Error('Audio error'); await new Promise(r => setTimeout(r, 50)); } throw Error('Timestamp did not seek and play'); })()"},
   {"screenshot":"05-seek.png"},
   {"aria":"05-seek.aria.txt"},
-  {"click":"text=返回录音库"},
+  {"click":"text=返回录音"},
   {"waitFor":"aria=搜索录音"},
   {"fill":"aria=搜索录音","value":"评审"},
   {"waitText":"1 个筛选条件生效"},
-  {"waitText":"命中 1 条录音"},
+  {"waitText":"当前显示 1 条"},
   {"eval":"(async () => { const b = await fetch('/api/recordings?q=' + encodeURIComponent('评审')).then(r => r.json()); if (!b.ok || !b.data.items.some(r => r.id === 1)) throw Error('Transcript search missed recording'); return b; })()"},
   {"screenshot":"06-search.png"},
   {"aria":"06-search.aria.txt"},
   {"click":"button.row__main"},
-  {"waitText":"返回录音库"},
+  {"waitText":"返回录音"},
   {"click":"text=AI 归类"},
   {"waitText":"归类任务已排队"},
   {"screenshot":"07-organize-accepted.png"},
   {"aria":"07-organize-accepted.aria.txt"},
-  {"waitText":"已归档","timeout":120000},
+  {"waitText":"已整理","timeout":120000},
   {"click":"text=AI 结论"},
   {"waitFor":".analysis"},
   {"eval":"(async () => { const b = await fetch('/api/recordings/1').then(r => r.json()); const d = b.data, r = d.recording, a = d.analysis; if (!b.ok || r.status !== 'organized' || d.lastError || !a || !r.title?.trim() || !r.summary?.trim() || !r.categoryId || !r.categoryName || !a.categorySlug || !r.tags.length || !a.keyPoints.length || !a.actionItems.length || !Number.isInteger(r.importance) || r.importance < 1 || r.importance > 5 || r.title !== a.title || r.summary !== a.summary || r.importance !== a.importance || JSON.stringify(r.tags.map(t => t.name).sort()) !== JSON.stringify([...a.tags].sort()) || !d.jobs.some(j => j.kind === 'organize' && j.status === 'success' && j.finishedAt)) throw Error('Organization readback failed: ' + JSON.stringify(b)); const text = document.body.innerText; for (const value of [r.title, r.summary, ...r.tags.map(t => t.name), ...a.keyPoints, ...a.actionItems]) if (!text.includes(value)) throw Error('Missing UI field: ' + value); if (document.querySelector('.detail__side select')?.selectedOptions[0]?.textContent !== r.categoryName || document.querySelector('[aria-label=\"重要度 ' + r.importance + '\"]')?.getAttribute('aria-pressed') !== 'true') throw Error('Category/importance UI mismatch'); window.__analysis = a; return b; })()"},
@@ -54,7 +54,7 @@
   {"eval":"(async () => { const b = await fetch('/api/recordings/1').then(r => r.json()); if (!b.ok || b.data.recording.title !== '人工确认的项目评审' || b.data.recording.status !== 'organized' || JSON.stringify(b.data.analysis) !== JSON.stringify(window.__analysis)) throw Error('Manual title did not persist or changed analysis'); return b; })()"},
   {"screenshot":"09-edited.png"},
   {"aria":"09-edited.aria.txt"},
-  {"click":"text=执行记录 2"},
+  {"click":"text=处理记录 2"},
   {"waitFor":".jobs"},
   {"screenshot":"10-jobs.png"},
   {"aria":"10-jobs.aria.txt"}
diff --git a/.claude/skills/verify-openminutes/features/voice-import.steps.json b/.claude/skills/verify-openminutes/features/voice-import.steps.json
index d78a0cc..8f50152 100644
--- a/.claude/skills/verify-openminutes/features/voice-import.steps.json
+++ b/.claude/skills/verify-openminutes/features/voice-import.steps.json
@@ -1,21 +1,24 @@
 [
   {"goto":"#/library"},
-  {"waitText":"录音库还是空的"},
+  {"waitText":"还没有录音"},
   {"screenshot":"01-empty.png"},
   {"aria":"01-empty.aria.txt"},
-  {"click":"text=导入新录音"},
+  {"goto":"#/library"},
+  {"waitFor":"aria=搜索录音"},
+  {"click":"text=导入"},
   {"waitText":"1 个音频文件"},
-  {"click":"text=立即扫描"},
-  {"waitText":"导入 1 个文件，跳过 0 个，失败 0 个","timeout":20000},
+  {"click":"text=扫描并导入"},
+  {"waitText":"已导入 1 条","timeout":20000},
+  {"click":"text=关闭"},
   {"screenshot":"02-imported.png"},
   {"aria":"02-imported.aria.txt"},
   {"goto":"#/library"},
-  {"waitText":"命中 1 条录音"},
+  {"waitText":"当前显示 1 条"},
   {"click":"button.row__main"},
-  {"waitText":"返回录音库"},
+  {"waitText":"返回录音"},
   {"expectText":"待转录"},
   {"eval":"(async () => { const id = location.hash.split('/').pop(); const r = await fetch('/api/recordings/' + id); const body = await r.json(); const d = body.data; if (!r.ok || !body.ok || d.recording.status !== 'ready' || !d.recording.hasAudioFile || d.recording.transcriptChars !== 0 || d.jobs.length !== 0) throw Error('Unexpected imported recording: ' + JSON.stringify(body)); return body; })()"},
-  {"eval":"(async () => { const a = document.querySelector('audio'); if (!a) throw Error('Missing audio'); await a.play(); await new Promise((resolve, reject) => { const timeout = setTimeout(() => { a.removeEventListener('timeupdate', check); reject(Error('Playback did not advance')); }, 8000); function check() { if (a.currentTime > 0.25 && !a.paused && !a.error) { clearTimeout(timeout); a.removeEventListener('timeupdate', check); resolve(); } } a.addEventListener('timeupdate', check); check(); }); const result = { src: a.currentSrc, duration: a.duration, currentTime: a.currentTime, paused: a.paused, error: a.error }; if (!(a.duration >= 3 && a.duration <= 6)) throw Error('Unexpected duration'); a.pause(); return result; })()"},
+  {"eval":"(async () => { const a = document.querySelector('audio'); if (!a) throw Error('Missing audio'); await a.play(); await new Promise((resolve, reject) => { const timeout = setTimeout(() => { a.removeEventListener('timeupdate', check); reject(Error('Playback did not advance')); }, 8000); function check() { if (a.currentTime > 0.25 && !a.paused && !a.error) { clearTimeout(timeout); a.removeEventListener('timeupdate', check); resolve(); } } a.addEventListener('timeupdate', check); check(); }); const result = { src: a.currentSrc, duration: a.duration, currentTime: a.currentTime, paused: a.paused, error: a.error }; const id = location.hash.split('/').pop(); const rec = (await (await fetch('/api/recordings/' + id, {headers: {connection: 'close'}})).json()).data.recording; result.durationSec = rec.durationSec; if (!(a.duration >= 1 && typeof rec.durationSec === 'number' && Math.abs(a.duration - rec.durationSec) <= 1.5)) throw Error('Unexpected duration: audio=' + a.duration + ' api=' + rec.durationSec); a.pause(); return result; })()"},
   {"screenshot":"03-playable.png"},
   {"aria":"03-playable.aria.txt"}
 ]
diff --git a/.claude/skills/verify-openminutes/recipes/host-batch.json b/.claude/skills/verify-openminutes/recipes/host-batch.json
index b432562..c8aaac5 100644
--- a/.claude/skills/verify-openminutes/recipes/host-batch.json
+++ b/.claude/skills/verify-openminutes/recipes/host-batch.json
@@ -1,33 +1,36 @@
 [
-  {"goto":"#/device"},
+  {"goto":"#/library"},
+  {"waitFor":"aria=搜索录音"},
+  {"click":"text=导入"},
   {"waitText":"3 个音频文件"},
-  {"click":"text=立即扫描"},
-  {"waitText":"导入 2 个文件，跳过 1 个，失败 0 个","timeout":15000},
+  {"click":"text=扫描并导入"},
+  {"waitText":"已导入 2 条，跳过 1 条","timeout":20000},
+  {"click":"text=关闭"},
   {"goto":"#/library"},
-  {"waitText":"命中 3 条录音"},
+  {"waitText":"当前显示 3 条"},
   {"click":"text=待转录"},
-  {"waitText":"命中 2 条录音"},
+  {"waitText":"当前显示 2 条"},
   {"screenshot":"01-before.png"},
   {"aria":"01-before.aria.txt"},
   {"click":"aria=全选当前页"},
   {"click":"text=批量转录"},
-  {"waitText":"已排队 2 条转录任务"},
+  {"waitText":"已开始转录 2"},
   {"screenshot":"02-transcribe-queued.png"},
   {"click":"text=全部"},
-  {"waitText":"命中 3 条录音"},
+  {"waitText":"当前显示 3 条"},
   {"waitNoText":"转录已排队","timeout":120000},
   {"waitNoText":"转录中","timeout":120000},
   {"eval":"fetch('/api/recordings').then(r => r.json()).then(({data:d}) => { const items = d.items.filter(r => r.id !== 1); if (items.length !== 2 || items.some(r => r.status !== 'transcribed' || !r.transcriptChars) || d.hasActiveTasks) throw Error('batch transcription incomplete'); return d; })"},
   {"screenshot":"03-transcribed.png"},
   {"aria":"03-transcribed.aria.txt"},
   {"click":"text=待归类"},
-  {"waitText":"命中 2 条录音"},
+  {"waitText":"当前显示 2 条"},
   {"click":"aria=全选当前页"},
   {"click":"text=批量归类"},
-  {"waitText":"已排队 2 条归类任务"},
+  {"waitText":"已开始归类 2"},
   {"screenshot":"04-organize-queued.png"},
   {"click":"text=全部"},
-  {"waitText":"命中 3 条录音"},
+  {"waitText":"当前显示 3 条"},
   {"waitNoText":"归类已排队","timeout":120000},
   {"waitNoText":"归类中","timeout":120000},
   {"eval":"fetch('/api/recordings').then(r => r.json()).then(({data:d}) => { if (d.hasActiveTasks || d.items.length !== 3 || d.items.some(r => r.status !== 'organized' || !r.summary || !r.categoryId || !r.tags.length)) throw Error('batch organization incomplete'); return d; })"},
diff --git a/.claude/skills/verify-openminutes/recipes/host-correct.json b/.claude/skills/verify-openminutes/recipes/host-correct.json
index 4a06855..7974e9e 100644
--- a/.claude/skills/verify-openminutes/recipes/host-correct.json
+++ b/.claude/skills/verify-openminutes/recipes/host-correct.json
@@ -1,6 +1,6 @@
 [
   {"goto":"#/rec/1"},
-  {"waitText":"返回录音库"},
+  {"waitText":"返回录音"},
   {"screenshot":"01-before.png"},
   {"click":"aria=编辑标题"},
   {"fill":"aria=录音标题","value":"人工确认的发布计划"},
diff --git a/.claude/skills/verify-openminutes/recipes/host-off.json b/.claude/skills/verify-openminutes/recipes/host-off.json
index 290ee20..8d99e01 100644
--- a/.claude/skills/verify-openminutes/recipes/host-off.json
+++ b/.claude/skills/verify-openminutes/recipes/host-off.json
@@ -1,19 +1,24 @@
 [
-  {"goto":"#/device"},
+  {"goto":"#/library"},
+  {"waitFor":"aria=搜索录音"},
+  {"click":"text=导入"},
   {"waitText":"1 个音频文件"},
-  {"click":"text=立即扫描"},
-  {"waitText":"导入 1 个文件，跳过 0 个，失败 0 个","timeout":15000},
+  {"click":"text=扫描并导入"},
+  {"waitText":"已导入 1 条","timeout":20000},
+  {"click":"text=关闭"},
   {"goto":"#/rec/1"},
   {"waitText":"还没有转录文本"},
   {"screenshot":"01-before.png"},
   {"aria":"01-before.aria.txt"},
   {"click":"text=开始转录"},
   {"waitText":"转录任务已排队"},
-  {"waitText":"HOST_NOT_CONNECTED","timeout":15000},
-  {"expectText":"上次处理未成功"},
-  {"eval":"fetch('/api/recordings/1').then(r => r.json()).then(({data:d}) => { if (d.recording.status !== 'failed' || d.recording.transcriptChars !== 0 || d.jobs[0].status !== 'failure' || !d.lastError.includes('HOST_NOT_CONNECTED')) throw Error('unexpected no-host outcome'); return d; })"},
+  {"waitText":"上次处理未成功","timeout":15000},
+  {"expectNoText":"HOST_NOT_CONNECTED"},
+  {"click":"text=查看详情"},
+  {"waitText":"HOST_NOT_CONNECTED"},
+  {"eval":"fetch('/api/recordings/1').then(r => r.json()).then(({data:d}) => { if (d.recording.status !== 'failed' || d.recording.transcriptChars !== 0 || d.jobs[0].status !== 'failure' || !d.lastError || !(d.lastErrorDetail || '').includes('HOST_NOT_CONNECTED')) throw Error('unexpected no-host outcome'); return d; })"},
   {"screenshot":"02-failed.png"},
   {"aria":"02-failed.aria.txt"},
-  {"click":"text=执行记录 1"},
+  {"click":"text=处理记录 1"},
   {"screenshot":"03-jobs.png"}
 ]
diff --git a/.claude/skills/verify-openminutes/recipes/host-organize.json b/.claude/skills/verify-openminutes/recipes/host-organize.json
index cc2ce38..feb4976 100644
--- a/.claude/skills/verify-openminutes/recipes/host-organize.json
+++ b/.claude/skills/verify-openminutes/recipes/host-organize.json
@@ -7,15 +7,17 @@
   {"waitText":"归类任务已排队"},
   {"screenshot":"02-queued.png"},
   {"aria":"02-queued.aria.txt"},
-  {"waitFor":".detail__actions button[title='用 AI 归类并生成摘要']:not(:disabled)","timeout":120000},
+  {"waitText":"已整理","timeout":120000},
+  {"click":"text=更多"},
   {"expectText":"重新归类"},
+  {"click":"text=更多"},
   {"expectNoText":"上次处理未成功"},
   {"click":"text=AI 结论"},
   {"waitFor":".analysis"},
   {"screenshot":"03-analysis.png"},
   {"aria":"03-analysis.aria.txt"},
   {"eval":"fetch('/api/recordings/1').then(r => r.json()).then(({data:d}) => { const a = d.analysis, r = d.recording; if (!a || r.status !== 'organized' || !r.title || !r.summary || !r.categoryId || !r.tags.length || !a.keyPoints.length || !a.actionItems.length || r.importance < 1 || r.importance > 5) throw Error('incomplete AI result'); if (r.title !== a.title || r.summary !== a.summary || r.importance !== a.importance) throw Error('AI persistence mismatch'); if (location.hash !== '#/rec/1') throw Error('route changed'); return d; })"},
-  {"click":"text=执行记录 2"},
+  {"click":"text=处理记录 2"},
   {"expectText":"成功"},
   {"screenshot":"04-jobs.png"},
   {"aria":"04-jobs.aria.txt"}
diff --git a/.claude/skills/verify-openminutes/recipes/host-single.json b/.claude/skills/verify-openminutes/recipes/host-single.json
index ce5dfab..97d3883 100644
--- a/.claude/skills/verify-openminutes/recipes/host-single.json
+++ b/.claude/skills/verify-openminutes/recipes/host-single.json
@@ -1,9 +1,12 @@
 [
-  {"goto":"#/device"},
-  {"waitText":"1 个音频文件"},
   {"screenshot":"01-import-before.png"},
-  {"click":"text=立即扫描"},
-  {"waitText":"导入 1 个文件，跳过 0 个，失败 0 个","timeout":15000},
+  {"goto":"#/library"},
+  {"waitFor":"aria=搜索录音"},
+  {"click":"text=导入"},
+  {"waitText":"1 个音频文件"},
+  {"click":"text=扫描并导入"},
+  {"waitText":"已导入 1 条","timeout":20000},
+  {"click":"text=关闭"},
   {"goto":"#/rec/1"},
   {"waitText":"还没有转录文本"},
   {"aria":"02-before.aria.txt"},
@@ -24,11 +27,11 @@
   {"waitFor":".transcript-plain"},
   {"aria":"06-plain.aria.txt"},
   {"goto":"#/library"},
-  {"waitText":"命中 1 条录音"},
+  {"waitText":"当前显示 1 条"},
   {"screenshot":"07-search-before.png"},
   {"fill":"aria=搜索录音","value":"蓝色铅笔"},
   {"waitText":"1 个筛选条件生效"},
-  {"expectText":"命中 1 条录音"},
+  {"expectText":"当前显示 1 条"},
   {"eval":"fetch('/api/recordings?q=' + encodeURIComponent('蓝色铅笔')).then(r => r.json()).then(({data:d}) => { if (d.total !== 1 || d.items[0].title || d.items[0].summary) throw Error('not transcript-only search'); return d; })"},
   {"screenshot":"08-search-hit.png"},
   {"aria":"08-search-hit.aria.txt"},
diff --git a/.claude/skills/verify-openminutes/reports/2026-11-08-workbench-unify.md b/.claude/skills/verify-openminutes/reports/2026-11-08-workbench-unify.md
new file mode 100644
index 0000000..e02c4ef
--- /dev/null
+++ b/.claude/skills/verify-openminutes/reports/2026-11-08-workbench-unify.md
@@ -0,0 +1,37 @@
+# 2026-11-08 工作台整改（统一入口 · 默认无线快传 · 错误分层）验收记录
+
+分支 `redreamality/workbench-unify-entry-wifi`，未提交的工作区。所有运行都是隔离实例（`--no-host`），没有接触真实 Floatboat 数据，也没有对真实录音笔执行任何操作；录音笔一律是 `--fake-device`。假设备 prelude 会让 `netsh` / `nmcli` / `networksetup` 调用直接抛错，各 run 的 `server.log` 里没有出现这类错误。
+
+## 单元测试
+
+- `MEMOTALK_TEST_PYTHON=.workbench/test-python/Scripts/python.exe pnpm test:ci`：exit 0。`pnpm test` 154 项全过、0 跳过（含 `tests/sdk.test.ts` 的 Wi-Fi 三平台序列、回退、取消、关热点未确认、密码不外泄、启动恢复）；`pnpm test:verification` 31 项全过。
+- 新增：`device-transport`、`device-errors`、`http-envelope`、`network-gate`、`device-service`、`device-sync`、`device-routes`、`router`；扩充 `preflight`（分组与 label 不含包名）、`pipeline-routes`（批量 `{stage}`）。夹具在 `tests/support/device-fixture.ts`（TS 假 worker）。
+
+## e2e
+
+| 步骤文件 | runId | 启动 | 结果 | 证据 |
+|---|---|---|---|---|
+| `features/navigation.steps.json` | `wsd-nav-1` | 普通 | 通过 | `.workbench/verify-evidence/wsd-nav-1/navigation2/` |
+| `features/import-dialog.steps.json` | `wsd-nav-1` | 普通 | 通过 | `.workbench/verify-evidence/wsd-nav-1/import-dialog/` |
+| `features/diagnostics.steps.json` | `wsd-nav-1` | 普通 | 通过 | `.workbench/verify-evidence/wsd-nav-1/diagnostics/` |
+| `features/calendar-link.steps.json` | `wsd-nav-1` | 普通 | 通过 | `.workbench/verify-evidence/wsd-nav-1/calendar-link2/` |
+| `features/device-connection.steps.json` | `wsd-wifi-2` | `--fake-device=wifi` | 通过：一次点击 7.6 秒同步 3 条，过程中出现「暂时断开外网」，主视图未出现技术词 | `.workbench/verify-evidence/wsd-wifi-2/device-connection/` |
+| `features/recording-detail-actions.steps.json` | `wsd-detail-1` | `--fake-device=wifi` | 通过 | `.workbench/verify-evidence/wsd-detail-1/recording-detail-actions/` |
+| `features/live-busy.steps.json` | `wsd-live-1` | `--fake-device=wifi` | 通过：发起同步 65 ms 后「开始实时字幕」已禁用 | `.workbench/verify-evidence/wsd-live-1/live-busy/` |
+| `features/device-fallback.steps.json` | `wsd-ble-1` | `--fake-device=ble` | 通过 | `.workbench/verify-evidence/wsd-ble-1/device-fallback/` |
+| `features/error-detail.steps.json` | `wsd-absent-1` | `--fake-device=absent` | 通过 | `.workbench/verify-evidence/wsd-absent-1/error-detail/` |
+| `tests/e2e-preflight.mjs`（无 Host + 模拟 Host） | `preflight-nohost-1794081139629`、`preflight-fixture-1794081153975` | 脚本自起 | 通过 | 同名证据目录 |
+
+- 每个 label 的 `console.log` 都是 0 字节；接口读回 JSON 记在各自的 `steps.log`。
+- 首次尝试记录：`wsd-nav-1/navigation`、`calendar-link`、`wsd-wifi-1/device-connection` 是步骤本身的断言写错（默认折叠的检查方式、面包屑无空格、设备记录是 `li` 不是表格），修正步骤后用新 label 或新 runId 重跑通过。
+- 每个 run 结束后都执行了 `cleanup.mjs <runId>`，没有遇到 EPERM；`.workbench/verify/` 下没有遗留的 run 目录。
+
+## 测试中发现并修复的问题
+
+- `src/server/device/service.ts`：主动断开时 worker 退出回调先把状态改成 `disconnected / device_sleep`，`disconnect()` 之后才写入真实原因。页面轮询可能短暂显示「录音笔已休眠或离开范围」，自动连接的 tick 也可能在这个窗口里抢先重连，随后被 `disconnect()` 覆盖状态。现在只有仍是当前 worker 的意外退出才走「已休眠」分支。由 `device-service.test.ts` 的后台会话用例覆盖（断开过程中只允许出现 `auto-done`）。
+- `scripts/doctor.mjs`：`tests/e2e-preflight.mjs` 的模拟 Host 分支在 HEAD 上就会报 `HOST_MODE_CONFIG_MISMATCH`。新增 `hostMode: 'fixture'`（只接受回环地址、不探测），测试在 run.json 里声明该模式。
+
+## 未覆盖
+
+- 真实录音笔与真实 Wi-Fi 切换（Windows netsh 实网、定位权限关闭、实测吞吐）按计划 §8.5 由用户本人执行。
+- macOS / Linux 入网只有桩测。
diff --git a/.claude/skills/verify-openminutes/scripts/capability-gate.test.mjs b/.claude/skills/verify-openminutes/scripts/capability-gate.test.mjs
index deb2b80..0100701 100644
--- a/.claude/skills/verify-openminutes/scripts/capability-gate.test.mjs
+++ b/.claude/skills/verify-openminutes/scripts/capability-gate.test.mjs
@@ -24,7 +24,7 @@ async function runGate(expression, capabilities) {
     location: { hash: '#/rec/1' },
     fetch: async (url) => {
       calls.push(url);
-      if (url === '/api/device/capabilities') return { ok: true, json: async () => ({ ok: true, data: capabilities }) };
+      if (url === '/api/environment/capabilities') return { ok: true, json: async () => ({ ok: true, data: capabilities }) };
       if (url === '/api/recordings/1') return { ok: true, json: async () => ({ ok: true, data: { recording: { status: 'ready' }, jobs: [] } }) };
       throw new Error(`unexpected request: ${url}`);
     },
@@ -49,7 +49,7 @@ test('partial capabilities fail closed before any paid recording request', async
       error = caught;
     }
     assert.match(error?.message ?? '', /capabilities incomplete/);
-    assert.deepEqual(error.calls, ['/api/device/capabilities']);
+    assert.deepEqual(error.calls, ['/api/environment/capabilities']);
   }
 });
 
@@ -57,8 +57,8 @@ test('complete ASR and LLM capabilities pass the gate before the recording preco
   for (const expression of Object.values(recipes)) {
     const result = await runGate(expression, complete());
     const expected = expression.includes('/api/recordings/1')
-      ? ['/api/device/capabilities', '/api/recordings/1']
-      : ['/api/device/capabilities'];
+      ? ['/api/environment/capabilities', '/api/recordings/1']
+      : ['/api/environment/capabilities'];
     assert.deepEqual(result.calls, expected);
   }
 });
diff --git a/.claude/skills/verify-openminutes/scripts/doctor.mjs b/.claude/skills/verify-openminutes/scripts/doctor.mjs
index 9b421bd..fd0472a 100644
--- a/.claude/skills/verify-openminutes/scripts/doctor.mjs
+++ b/.claude/skills/verify-openminutes/scripts/doctor.mjs
@@ -22,6 +22,8 @@ const run = readRun(root, runId);
 const problems = [];
 const report = { runId, url: run.url, pid: run.pid };
 report.host = { mode: run.hostMode ?? 'none', available: false };
+// Only a fake recorder may be driven: a real one switches this computer's Wi-Fi during sync.
+report.fakeDevice = run.fakeDevice ?? 'none';
 try {
   const config = JSON.parse(readFileSync(join(run.runDir, 'workbench-config.json'), 'utf8'));
   if (config.dataDirectory !== run.dirs.data || config.sourceDirectory !== root
@@ -31,6 +33,10 @@ try {
   if (report.host.mode === 'floatboat') {
     assertHostListener(config.hostConnection);
     Object.assign(report.host, await probeHost(config.hostConnection));
+  } else if (report.host.mode === 'fixture') {
+    // tests/e2e-preflight.mjs 自带的模拟 Host：只允许本机回环地址，不探测、不接触 Floatboat。
+    const hostname = config.hostConnection?.url ? new URL(config.hostConnection.url).hostname : '';
+    if (hostname !== '127.0.0.1' && hostname !== 'localhost') problems.push('HOST_FIXTURE_NOT_LOOPBACK');
   } else if (config.hostConnection) {
     problems.push('HOST_MODE_CONFIG_MISMATCH');
   }
diff --git a/.claude/skills/verify-openminutes/scripts/launch.mjs b/.claude/skills/verify-openminutes/scripts/launch.mjs
index d5622dd..357f6f4 100644
--- a/.claude/skills/verify-openminutes/scripts/launch.mjs
+++ b/.claude/skills/verify-openminutes/scripts/launch.mjs
@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // Starts a fresh, pre-isolated instance. Failed launches retain evidence but stop their child.
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
@@ -9,8 +9,25 @@ import { DatabaseSync } from 'node:sqlite';
 import { assertIdentity, localOrigin, runPaths, waitStopped } from './run-safety.mjs';
 import { discoverHost, probeHost } from './host.mjs';
 
-export async function launch(root, runId, { readyTimeout = 30000, hostMode = 'none' } = {}) {
+// Fake recorder audio: real MP3 bytes so device-reported sizes match what lands on disk.
+const FAKE_AUDIO = [['REC20261020_103000.mp3', 140], ['REC20261020_143000.mp3', 80], ['REC20261021_090000.mp3', 10]];
+
+function makeFakeAudio(dir) {
+  mkdirSync(dir);
+  const ffmpeg = process.env.FFMPEG ?? 'ffmpeg';
+  for (const [name, seconds] of FAKE_AUDIO) {
+    const made = spawnSync(ffmpeg, ['-v', 'error', '-f', 'lavfi', '-i', `sine=frequency=440:duration=${seconds}`,
+      '-ac', '1', '-b:a', '128k', join(dir, name)], { stdio: 'pipe', windowsHide: true });
+    if (made.status !== 0) throw new Error(`ffmpeg could not generate fake recorder audio: ${made.stderr}`);
+  }
+}
+
+export async function launch(root, runId, { readyTimeout = 30000, hostMode = 'none', fakeDevice = null } = {}) {
   if (!['none', 'floatboat'].includes(hostMode)) throw new Error('Invalid Host mode');
+  if (fakeDevice !== null && !['wifi', 'ble', 'absent'].includes(fakeDevice)) throw new Error('Invalid fake device mode');
+  // A real recorder switches this computer's Wi-Fi during sync; verification only drives the fake one.
+  const fakeInterpreter = fakeDevice ? process.env.MEMOTALK_TEST_PYTHON : undefined;
+  if (fakeDevice && !fakeInterpreter) throw new Error('--fake-device requires MEMOTALK_TEST_PYTHON (an interpreter with memotalk-sdk)');
   const paths = runPaths(root, runId);
   root = paths.root;
   const { runDir, evidenceDir } = paths;
@@ -30,9 +47,12 @@ export async function launch(root, runId, { readyTimeout = 30000, hostMode = 'no
     library: join(runDir, 'library'), browserProfile: join(runDir, 'browser-profile'),
   };
   for (const dir of Object.values(dirs)) mkdirSync(dir);
+  const fakeAudioDir = fakeDevice ? join(runDir, 'fake-device') : null;
+  if (fakeAudioDir) makeFakeAudio(fakeAudioDir);
   const values = {
     import_dir: dirs.inbox, library_dir: dirs.library,
     auto_connect: '0', auto_pull: '0', auto_transcribe: '0', auto_analyze: '0',
+    ...(fakeInterpreter ? { python_path: resolve(fakeInterpreter) } : {}),
   };
   // The initial migration uses CREATE IF NOT EXISTS and INSERT OR IGNORE for settings.
   // Seed only this table so isolation is effective before any application code runs.
@@ -59,7 +79,10 @@ export async function launch(root, runId, { readyTimeout = 30000, hostMode = 'no
   try {
     log = openSync(logPath, 'wx');
     child = spawn(process.execPath, ['--enable-source-maps', entry], {
-      cwd: root, env: { ...process.env, FLOATBOAT_WORKBENCH_CONFIG: configPath },
+      cwd: root, env: {
+        ...process.env, FLOATBOAT_WORKBENCH_CONFIG: configPath,
+        ...(fakeDevice ? { OPENMINUTES_FAKE_DEVICE: fakeDevice, OPENMINUTES_FAKE_DEVICE_AUDIO_DIR: fakeAudioDir } : {}),
+      },
       detached: true, windowsHide: true, stdio: ['ignore', log, log],
     });
     child.on('error', (error) => { spawnError = error; });
@@ -79,7 +102,7 @@ export async function launch(root, runId, { readyTimeout = 30000, hostMode = 'no
       await new Promise((done) => setTimeout(done, 100));
     }
     if (!url) throw new Error(`Server not ready; see ${logPath}`);
-    const run = { runId, url, pid: child.pid, nonce, root, runDir, evidenceDir, dirs, hostMode, startedAt: new Date().toISOString() };
+    const run = { runId, url, pid: child.pid, nonce, root, runDir, evidenceDir, dirs, hostMode, fakeDevice, startedAt: new Date().toISOString() };
     await assertIdentity(run);
     const response = await fetch(`${url}/api/settings`, {
       method: 'PATCH', headers: { 'content-type': 'application/json' },
@@ -103,11 +126,13 @@ export async function launch(root, runId, { readyTimeout = 30000, hostMode = 'no
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
-  const args = process.argv.slice(2).filter((arg) => arg !== '--no-host');
-  if (args.length > 1) throw new Error('usage: launch.mjs [runId] [--no-host]');
+  const fakeArg = process.argv.find((arg) => arg.startsWith('--fake-device='));
+  const args = process.argv.slice(2).filter((arg) => arg !== '--no-host' && arg !== fakeArg);
+  if (args.length > 1) throw new Error('usage: launch.mjs [runId] [--no-host] [--fake-device=wifi|ble|absent]');
+  const fakeDevice = fakeArg ? fakeArg.slice('--fake-device='.length) : null;
   const root = resolve(process.env.OPENMINUTES_ROOT ?? resolve(import.meta.dirname, '../../../..'));
   const runId = args[0] ?? `run-${randomUUID()}`;
   const hostMode = process.argv.includes('--no-host') ? 'none' : (process.env.VERIFY_HOST_MODE ?? 'floatboat');
-  const run = await launch(root, runId, { hostMode });
-  console.log(JSON.stringify({ runId, url: run.url, pid: run.pid, runDir: run.runDir, evidenceDir: run.evidenceDir, hostMode }, null, 2));
+  const run = await launch(root, runId, { hostMode, fakeDevice });
+  console.log(JSON.stringify({ runId, url: run.url, pid: run.pid, runDir: run.runDir, evidenceDir: run.evidenceDir, hostMode, fakeDevice }, null, 2));
 }
diff --git a/AGENTS.md b/AGENTS.md
index 1ba5797..2f5c107 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,6 +2,14 @@
 
 本仓库的 agent 规则与避坑记录只写在这个文件里，不新建 `CLAUDE.md`。
 
+## 产品约束
+
+- 一个功能一个入口。新功能先在 `DESIGN.md`「设计规则」里确定唯一入口再实现；其他页面只放跳转链接，不放执行同一动作的第二个按钮，也不为同一资源再加一套写接口。
+- 遵守 `DESIGN.md` 的术语表：主界面用「录音笔」「同步」「在录音笔中」「已整理」「无线快传 / 蓝牙」「AI 整理」「Floatboat 助手」「处理记录」。BLE、0x 指令码、SDK、bridge、退出码、stdout/stderr、runId、idempotencyKey、agent、LLM、Host、SSID、FTP、热点等字样只能出现在「设置 › 诊断与高级」和错误的「查看详情」里。
+- 技术细节只放在诊断区或 `detail`：错误的 `error` 是一句中文结论，原文进 `detail`。
+- 后台任务不得改变系统网络：自动同步默认只用蓝牙，无线快传只在用户手动同步或用户显式开启 `auto_pull_wifi` 时发生。
+- 设备 SDK（memotalk-sdk）只由 `src/server/device/service.ts` 持有，其他模块不得自己 spawn Python 访问录音笔；宿主 SDK（`sdk/`）不改动。
+
 ## 验证
 
 - 要证明页面或接口行为可用时，使用 `.claude/skills/verify-openminutes`（build → launch → doctor → browse → cleanup）。它会把实例隔离在 `.workbench/verify/<runId>/`，不会碰 Floatboat 里的真实数据。
@@ -27,6 +35,9 @@
 - GitHub 网络偶尔出现 EOF 或 TLS 握手超时。`gh pr create` 失败后，先用 `gh pr list --head <branch> --state all` 确认 PR 没有建成再重试，避免重复开 PR。
 - 独立启动的服务不能把导入目录放在系统临时目录（`%TEMP%`），否则应用会把它改回真实的 `~/memo/memotalk/inbox`。scratch 数据放在 `.workbench/` 下（已被 gitignore）。
 - PowerShell 调用 `browse.mjs` 时，`@file` 参数必须整体加引号，例如 `'@.claude/skills/verify-openminutes/recipes/host-single.json'`；裸写 `@.claude/...` 会被 PowerShell 解析成语法而报错。
+- 用 `perl -0pi -e` 改 TS 源码时，替换串里的 `'\n'` 会被写成真实换行，JS 字符串字面量被截断成两行（2026-11-08 两次出现，typecheck 才暴露）。替换内容含 `\n`、反引号、`${}` 或多层引号时，直接用 Edit 工具；在 bash 双引号里写 `${...}` 还会报 `bad substitution`。
+- PreToolUse hook 会拦截文本中出现 `python` 字样的 Bash 命令（即使命令本身不运行 Python，例如编辑含 `python_path` 的脚本）。这类编辑改用 Edit/Write；需要带解释器路径运行的流程写成 `.mjs` 驱动脚本，在脚本里拼路径。
+- 设置了 `OPENMINUTES_FAKE_DEVICE` 之外的同步会真实切换本机 Wi-Fi：验证里不得对真实录音笔执行同步，只用 `launch.mjs --fake-device=wifi|ble|absent`（需 `MEMOTALK_TEST_PYTHON`）；真机验收交给用户按清单执行。
 - Windows 下 `rg` 的目录参数不要写 `sdk/*`，使用 `rg <pattern> sdk` 或 `rg --files sdk -g '<glob>'`。先用 `rg --files` 定位再读文件；Floatboat 的 SDK 位于 `resources/workbench-sdk/`，不在 `workbench-toolchain/sdk/`。
 ## Repository rules
 
@@ -59,3 +70,14 @@
 - Do not persist `sys.executable` from `uv run --with ...`: it can point to an ephemeral environment removed at exit (observed ENOENT in SDK tests). Create a checkout-local environment with `uv venv`, install with `uv pip --python`, and run Python checks with `uv run --python <venv>`.
 - Windows E2E cleanup can fail with EPERM while a browser profile is releasing file handles. Close owned browsers via CDP `Browser.close`, wait for exit, then retry the same nonce-scoped cleanup. Never kill by process name or delete a broader directory to bypass the lock.
 - A GitHub HTTPS connection timeout is not a rejected commit. Retry the same ordinary push and verify the remote SHA; do not force-push, change credentials, or rewrite the remote to work around transient connectivity.
+- 在 Bash 工具里用 `cat >> file <<'EOF'` 追加含 `'` 的内容（CSS、JSX）会报 `unexpected EOF while looking for matching '`，文件一字未写；`node -e "..."` 里的反引号模板串会被 bash 当命令替换执行，`\d` 等反斜杠也会被吃掉。写源码、JSON 步骤、正则一律用 Write/Edit 工具，写完 grep 复查。
+- `browse.mjs` 的 `fill` 对受控 `<input type="date">` 不生效（Delete 清空后 React 立刻还原旧值）。日历页要定位日期时用 `#/calendar?day=YYYY-MM-DD` 路由，不要 fill 日期框。
+- `tests/e2e-preflight.mjs` 需要 `OPENMINUTES_VERIFY_SCRIPTS=<checkout>/.claude/skills/verify-openminutes/scripts`，缺少时在第 14 行断言失败。它的模拟 Host 分支在 run.json 里写 `hostMode: 'fixture'`，doctor 只接受回环地址；不要为了让它通过而改回 `none` 或 `floatboat`。
+- Bash 工具每次调用都是新 shell，上一条里 `export MEMOTALK_TEST_PYTHON=...` 不会保留；`launch.mjs --fake-device` 因此报 `requires MEMOTALK_TEST_PYTHON` 且不写 run.json，后续 doctor 报 `no run.json`。每条命令都内联写 `MEMOTALK_TEST_PYTHON=.workbench/test-python/Scripts/python.exe node .../launch.mjs ...`。
+- `browse.mjs` 偶尔报 `timed out waiting for DevToolsActivePort`（无头浏览器启动慢），实例本身没问题。直接用同一个 runId 和 label 重跑一次即可，不要 kill 浏览器进程或删 profile 目录。
+- 「断开连接」时 `device_user_disconnected` 先落库、worker 后退出（约 5–7 秒）。e2e 读回 `/api/device` 要轮询到 `state==='disconnected'`，不要在看到「自动连接暂停」后立即断言。
+- Bash 工具里把多行 Python 用 `uv run python - <<'EOF'` 喂进去，内容含引号时报 `unexpected EOF while looking for matching ''`，整条命令不执行。批量改文件时先用 Write 工具把脚本写到 `.workbench/<任务>/x.py`（已 gitignore），再 `uv run python -I .workbench/<任务>/x.py <参数>`。
+- 本仓库没有 `typescript` 依赖，`pnpm exec tsc` 报 `Command "tsc" not found`。严格类型检查用 `node .claude/skills/verify-openminutes/scripts/build.mjs`（Floatboat 编译器，输出 `typecheck: passed`）；`pnpm test` 走 tsx，不做类型检查。
+- 导入对话框的「扫描并导入」在目录读回之前是禁用的，配方里直接 `click` 会静默无效，随后 `waitText 已导入` 超时。点击前先 `{"waitText":"个音频文件"}`。
+- 设备 e2e 配方共享一台假录音笔：在跑过 `device-connection` 的 run 上再跑 `live-busy`，文件已经同步完，同步瞬间结束，报 `Live page did not block 开始 while syncing`。每个设备配方都 cleanup 后用新的 runId 重新 launch。
+- 验证某个回归测试是否真能抓住旧 bug 时，用脚本把旧代码临时换回去跑一次，确认失败后立刻换回来，再 `grep` 核对源码已恢复。时序类竞态要在测试里人为制造窗口（例如 prelude 里让占锁的命令 sleep），否则旧代码也会碰巧通过。
diff --git a/DESIGN.md b/DESIGN.md
index 4eb889b..11af94a 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -7,7 +7,7 @@
 
 ## 最频繁的操作
 
-1. 把新录音导入进来（扫描目录 / 拉取设备清单）。
+1. 把新录音同步进来（录音笔页点一次「连接」即连接并同步；或在录音页「导入」本地文件夹）。
 2. 批量转录成文字。
 3. 浏览清单、按分类与标签过滤、搜索正文。
 4. 打开单条录音看摘要、要点与待办。
@@ -16,7 +16,7 @@
 ## 数据密度与主流程
 
 列表优先：一条录音一行，含标题、时间、字数、分类、标签、时长、状态。
-主流程为 `导入 → 转录 → 归类 → 检索`，每个阶段在列表上都有明确状态标签（待拉取 / 待转录 / 转录已排队 / 转录中 / 待归类 / 归类已排队 / 归类中 / 已归档 / 失败），批量操作按当前选择执行。
+主流程为 `同步 → 转录 → 归类 → 检索`，每个阶段在列表上都有明确状态标签（在录音笔中 / 待转录 / 转录已排队 / 转录中 / 待归类 / 归类已排队 / 归类中 / 已整理 / 失败），批量操作按当前选择执行；筛选「待转录 / 待归类」且未勾选时提供「全部转录（N）/ 全部归类（N）」。
 
 - 「转录已排队 / 归类已排队」对应 `queued_transcribe` / `queued_organize`，由服务端从内存队列临时投影，不落库；执行中的数据库状态优先。代码依据：`src/server/repo.ts:59`、`src/ui/components/ui.tsx:125`。
 - 详情页在当前录音排队或执行中时每 2600ms 轮询，进入非忙碌状态后停止。录音库根据列表响应的全库 `hasActiveTasks` 轮询，不因当前筛选结果中没有活跃录音而停止；全库任务结束后停止。代码依据：`src/ui/pages/Detail.tsx:51`、`src/contracts/recording-status.ts:1`、`src/ui/pages/Library.tsx:54`、`src/server/repo.ts:150`。
@@ -24,17 +24,53 @@
 
 ## 页面与适用状态
 
-| 页面 | 内容 |
-| --- | --- |
-| 概览 | 设备连接状态与连接/刷新操作、四个关键指标、分类分布条、最近入库、失败提醒 |
-| 录音库 | 搜索 + 阶段分段控件 + 分类/标签/排序下拉 + 批量操作 + 表格 |
-| 详情 | 标题就地编辑、操作条、播放器、转录全文/AI 结论/执行记录三分区、整理侧栏 |
-| 设备接入 | 环境自检、导入目录设置、读取清单、待拉取录音、手动登记、扫描导入、SDK 指令库 |
-| 实时字幕 | 开始/停止、设备连接与识别状态、实时文本、保存后的录音入口 |
-| 分类 | 新增与就地改名/改色/删除；内置分类不能删除 |
-| 设置 | 录音库/导入目录、Python/ffmpeg 路径，自动转录/归类/重连/拉取与说话人分离开关、重连间隔、热词与语言 |
+左侧导航固定 6 项，`<h1>` 与导航标签完全一致。旧的 `#/overview`、空哈希和未知哈希都改写为 `#/library`。
+
+| 导航 / 页面 | 路由 | 内容 |
+| --- | --- | --- |
+| 录音（默认页） | `#/library?stage=…` | 统计条（点「失败 N」切换筛选）、搜索 + 阶段分段控件 + 分类/标签/排序下拉 + 批量与「全部」操作 + 表格；页头「导入」对话框 |
+| 录音 › 详情 | `#/rec/:id` | 面包屑「录音 › 标题」、返回上一个应用内页面；标题就地编辑、一个随状态切换的主按钮（重新转录/归类、归档、删除在「更多」里）、播放器、转录全文/AI 结论/处理记录三分区、整理侧栏、只读日程区（链接到日历） |
+| 录音笔 | `#/device` | 环境提示条（仅在有 fail 项时）、录音笔卡片（连接/断开、电量与空间、同步进度与停止、清理已同步）、自动连接状态行、「还在录音笔里」列表与单条同步 |
+| 实时字幕 | `#/live` | 开始/停止、识别状态、实时文本、保存后的录音入口；录音笔同步中禁用「开始」并写明原因 |
+| 日历 | `#/calendar?day=…&rec=…` | 按日查看事件与录音、每条录音一个关联控件（建议项一键关联 / 选择其他事件 / 新建事件 / 解除关联）、导入 `.ics`、生成纪要 |
+| 分类 | `#/categories` | 新增与就地改名/改色/删除，每个分类的条数与总时长；内置分类不能删除 |
+| 设置 | `#/settings`、`#/settings/diagnostics` | 通用 / 自动化 / 识别 / 诊断与高级（默认折叠，从 `#/settings/diagnostics` 进入时自动展开） |
+
+设置页的语言选项目前只写入文件转录结果元数据，未传给 ASR；实时识别不读取文件转录的热词、语言与说话人分离设置。
+
+## 设计规则
 
-设备页不配置 SDK 源码目录。设置页的语言选项目前只写入文件转录结果元数据，未传给 ASR；实时识别不读取文件转录的热词、语言与说话人分离设置。自动拉取由后台自动连接成功触发，不由手动「连接并检测」触发。
+- **一个功能一个入口。** 连接、断开、同步、单条同步、停止、清理只在录音笔页；导入本地文件夹只在录音页头的「导入」对话框；录音与日程的关联只在日历页（唯一写接口 `PATCH /api/recordings/:id {calendarEventId}`）；所有路径只在设置里编辑。其他页面只放跳转链接（环境提示条、详情页「去录音笔同步」「在日历中关联 / 修改」、录音笔页状态行「调整」、实时字幕页「去录音笔查看」），不放执行同一动作的第二个按钮。新功能先确定唯一入口再实现。
+- **错误分两层。** 错误信封为 `{ok:false, error, code, detail?, action?}`。主行只显示一句中文结论（`error`）和可选的跳转（`action`）或「重试」；`detail` 只在点「查看详情」后展开，可复制诊断信息或跳到诊断区。带 detail 的 toast 不会自动消失，「详情」按钮打开同样的内容。
+- **唯一的技术细节区是「设置 › 诊断与高级」。** 主界面不出现 BLE、0x 指令码、SDK、bridge、退出码、stdout/stderr、runId、idempotencyKey、agent、LLM、Host、SSID、FTP 等字样。
+- **空状态只放说明文字和指向唯一入口的链接**，不放执行按钮。名为动作的按钮必须原地执行，名为跳转的用链接样式。
+- **后台不切网。** 后台自动同步默认只用蓝牙拉小文件，不改变本机网络；只有用户手动同步，或显式开启 `auto_pull_wifi`，才走无线快传。
+
+### 术语表
+
+| 用 | 不用 |
+| --- | --- |
+| 录音笔 | 设备、硬件、BLE 设备 |
+| 同步（录音笔 → 电脑） | 拉取、下载、读取清单、登记 |
+| 在录音笔中（状态 pending） | 待拉取 |
+| 已整理（状态 organized） | 已归档（与「归档」按钮重名） |
+| 无线快传 / 蓝牙（只在回退提示和诊断里出现） | Wi-Fi 热点、FTP、BLE、0x84 |
+| AI 整理 | LLM |
+| Floatboat 助手 | agent、Host |
+| 处理记录（详情页 tab） | 执行记录 |
+
+## 录音笔连接与传输
+
+连接状态：`disconnected → connecting → connected ⇄ busy`，实时字幕占用时为 `live`。
+
+- 点「连接」后，开着「连上录音笔后自动同步新录音」（默认开）就直接开始同步，一次点击完成主任务。「同步录音（N）」只在已连接且还有没同步的录音时出现。
+- 用户连接的会话空闲 10 分钟后自动断开（灰字说明，不当作错误）；自动连接建立的会话任务一结束就断开；录音笔休眠或离开范围时显示灰字「录音笔已休眠或离开范围」。
+- 用户手动「断开连接」后自动连接暂停，状态写入数据库，重启后仍然有效，直到再次点「连接」。状态行显示「已手动断开，自动连接暂停」。
+- 同一时间只有一个设备操作；同步中申请实时字幕返回「录音笔正在同步」。实时字幕结束后，如果之前是用户手动连接的，会自动恢复连接。
+- 用户触发的同步：本批 ≥ 1 MiB（或含大小未知的录音）且本机有无线网卡时默认走无线快传，按钮下方提示「将通过无线快传，期间电脑会暂时断开外网」；进度依次显示「等待当前转录完成」「正在准备无线快传（暂时断开外网）」「x/y · 百分比」「正在恢复网络」。
+- 无线快传任何阶段失败都改用蓝牙继续，只显示一行「无线快传不可用，已改用蓝牙（较慢）」，原因放在「查看详情」。
+- 后台自动同步有推迟的大录音时，状态行说明「另有 N 条较大的录音等你点「同步录音」」。
+- 清理已同步的录音需要二次确认，只删除库中存在、本地文件存在且大小一致的文件。
 
 每个数据区域都实现 loading、空态、失败重试、禁用与处理中反馈；搜索无结果与"库为空"使用不同文案与不同操作。
 
@@ -45,19 +81,19 @@
 - 状态一律用文字 + 颜色双编码，不只靠颜色区分；流程中状态带动画小图标并尊重 `prefers-reduced-motion`。
 - 图标使用 Lucide，仅图标按钮都提供 `aria-label` 与 title；分段控件用 `aria-pressed`。
 - 音频播放器失败时提供「导出到本机目录」，默认复制到 `import_dir`（默认 `~/memo/memotalk/inbox`），成功后展示实际目标路径；没有音频文件时导出也会失败，不能把导出当作文件丢失的补救。API 可显式指定 `directory`，详情页使用默认目录。
-- 导入目录卡片直接展示完整路径（可换行、可全选）并给出「复制路径」，因为应用无法唤起系统文件选择器；目录缺失时主按钮改为「创建目录并扫描」，把失败态变成可继续的动作。
+- 「导入」对话框直接展示导入目录的完整路径（可换行、可全选）并给出「复制路径」与「在设置中修改目录」，因为应用无法唤起系统文件选择器；目录缺失时扫描会自动创建，结果在对话框内显示。
 - 转录分段的时标是按钮：点一下定位到该句继续播放，播放中当前句浅色高亮；拿不到音频时时标退回不可点的纯文本，不摆假按钮。
 - 时长、体积、时间统一走 `format.ts`，表格数字使用 tabular-nums 保持纵向对齐。
 
 ## 目录与删除
 
-- 导入目录是扫描来源和默认导出目标；录音库目录是持久音频位置，默认 `~/memo/memotalk/raw`，按 `<yyyy-MM>` 分目录。BLE 拉取先暂存到 Host 的 `audio/_incoming`，再复制到录音库；实时录音也保存到录音库月目录。
+- 导入目录是扫描来源和默认导出目标；录音库目录是持久音频位置，默认 `~/memo/memotalk/raw`，按 `<yyyy-MM>` 分目录。录音笔同步先暂存到 Host 的 `audio/_incoming/<任务 ID>/`，大小校验通过后复制到录音库；实时录音也保存到录音库月目录。
 - 修改目录设置不迁移旧文件。新版记录保存完整目标路径，历史相对文件名仍兼容 Host 的 `audio` 资源。
 - 删除会尝试把音频移到当前 `<library_dir>/_trash/<毫秒时间戳>-<原存储文件名>`，并删除相关业务记录；文件移动失败也不阻止记录删除。当前没有回收站浏览或恢复页面/API。
 
 ## 响应式
 
-按内容宽度而非窗口宽度校验：1080px 收起标签列，860px 导航转为顶部横条并收起分类/时长列，560px 指标与筛选堆叠。表格横向滚动只保留在 SDK 指令库这类真需要横向比较的区域。
+按内容宽度而非窗口宽度校验：1080px 收起标签列，860px 导航转为顶部横条并收起分类/时长列，560px 指标与筛选堆叠。表格横向滚动只保留在诊断区的设备协议指令参考这类真需要横向比较的区域。
 
 ## 参考来源
 
diff --git a/ENGINEERING.md b/ENGINEERING.md
index 272d8a5..bc4d3fa 100644
--- a/ENGINEERING.md
+++ b/ENGINEERING.md
@@ -2,44 +2,119 @@
 
 ## 入口与装配
 
-- `src/server/index.ts`：创建 `createWorkbenchServer`、按领域注册路由并启动后台自动重连。
-- `src/ui/main.tsx` 挂载页面；`src/ui/App.tsx` 负责侧边导航与哈希路由（`#/overview`、`#/library`、`#/rec/:id`、`#/device`、`#/categories`、`#/live`、`#/settings`）。
-- `src/contracts/` 保存跨端 DTO（`app.ts`）、不可信输入校验（`input.ts`）及排队/执行中状态判定（`recording-status.ts`）；浏览器端不得导入服务端模块。
-- `migrations/` 只追加。`0001_initial.sql` 包含业务表与初始种子；`0002_auto_runtime_settings.sql` 增加录音库、自动转录与重连设置，`0003_auto_pull.sql` 增加自动拉取设置，`0004_remove_sdk_dir.sql` 删除旧 SDK 目录设置。
+- `src/server/index.ts`：创建 `createWorkbenchServer`、创建设备服务 `createDeviceService`，按领域注册路由并启动自动连接调度器。
+- `src/ui/main.tsx` 挂载页面；`src/ui/App.tsx` 负责 6 项侧边导航；`src/ui/router.ts` 是纯函数哈希路由（`parseHash` / `buildHash` / `navKey`）：`#/library?stage=failed|ready|transcribed|pending`、`#/rec/:id`、`#/device`、`#/live`、`#/calendar?day=YYYY-MM-DD&rec=<id>`、`#/categories`、`#/settings`、`#/settings/diagnostics`。`#/overview`、空哈希与未知哈希用 `history.replaceState` 改写为 `#/library`。详情页的返回按钮回到应用内的上一条路由，没有时回到 `#/library`。
+- `src/contracts/` 保存跨端 DTO（`app.ts`、`device.ts`、`calendar.ts`、`preflight.ts`）、错误模型（`errors.ts`）、不可信输入校验（`input.ts`）及排队/执行中状态判定（`recording-status.ts`）；浏览器端不得导入服务端模块。
+- `migrations/` 只追加。`0001_initial.sql` 包含业务表与初始种子；`0002_auto_runtime_settings.sql` 增加录音库、自动转录与重连设置，`0003_auto_pull.sql` 增加自动同步设置，`0004_remove_sdk_dir.sql` 删除旧 SDK 目录设置，`0005_calendar.sql` 增加日历事件与录音关联，`0006_environment_repair.sql` 增加环境修复状态，`0007_device_service.sql` 增加 `last_error_code` / `last_error_detail`、`devices.ble_address` 以及 `device_transport`、`auto_pull_wifi`、`device_user_disconnected` 设置。
+- 两个 SDK 的称呼固定：**宿主 SDK**（`sdk/`，Floatboat runtime/host/db/resources，本仓库不改动）与**设备 SDK**（PyPI `memotalk-sdk`）。
 - 源码是编辑入口，`dist/` 由 Host 生成；类型与构建通过 `check_workbench_project`，`workbench_runtime open` 应用更新。
 
 ## 模块职责
 
 | 模块 | 职责 |
 | --- | --- |
-| `server/http.ts` | 统一 `{ ok: true, data }` / `{ ok: false, error: string, code: string }` 信封与错误码映射 |
+| `server/http.ts` | 统一 `{ ok: true, data }` / `{ ok: false, error, code, detail?, action? }` 信封与错误映射（见下文「错误模型」） |
 | `server/sql.ts` | node:sqlite 薄封装、设置读写、任务记录、标签同步 |
-| `server/repo.ts` | 录音列表/详情/分类/总览查询；组合内存队列与数据库状态，投影排队状态并计算全库 `hasActiveTasks` |
-| `server/app-route.ts` | `/api/app`、`/api/overview`、`/api/tags` |
+| `server/repo.ts` | 录音列表/详情/分类/统计查询；组合内存队列与数据库状态，投影排队状态并计算全库 `hasActiveTasks` |
+| `server/app-route.ts` | `/api/app`、`/api/overview`（统计与 `byCategory`）、`/api/tags` |
 | `server/library.ts` | 录音库根目录、分月归档与历史路径兼容 |
 | `server/ingest.ts` | 目录扫描导入、设备清单登记、下载文件挂接、去重与命名冲突处理 |
-| `server/pull.ts` | BLE 下载暂存、挂接入库与按预算拉取待下载文件 |
-| `server/auto-connect.ts` | 后台定时探测设备，自动连接成功后按开关触发拉取 |
+| `server/device/service.ts` | 设备 SDK 的唯一所有者：连接状态机、单一互斥、活动与进度、空闲断开、实时字幕占用、诊断环形缓冲（最近 50 条）、热点残留自愈 |
+| `server/device/worker.ts`、`server/device/worker-script.ts` | 常驻 Python worker：运行时写成 `<dataDir>/tools/device/worker.py`，持有一个 `MemoTalkClient`，JSON-lines RPC，按平台入网与恢复、取消、删除 |
+| `server/device/sync.ts` | 同步编排：list → `registerDeviceManifest` → `planTransfer` → 网络闸门 → pull → 大小校验 → `attachDownloadedFile` → 自动转录；清理已同步 |
+| `server/device/transport.ts` | 纯函数 `planTransfer`、`probeWifiCapable`（缓存 10 分钟） |
+| `server/device/errors.ts` | `classifyDeviceError`：设备 SDK 异常类型 → `AppError` |
+| `server/device/auto-connect.ts` | 调度器：每 30 秒检查一次，到期且未被用户手动断开时连接、按开关后台同步、用完即断 |
+| `server/device/fake-device.ts` | 假录音笔 prelude（仅测试） |
+| `server/network-gate.ts` | 无线快传断网窗口：`acquireOffline` 等进行中的 Host 任务、`whenOnline`、`assertOnline` |
 | `server/media.ts` | ffmpeg 探测、时长解析、16kHz 单声道 PCM16 分帧解码 |
 | `server/transcribe.ts` | Host ASR 会话：参数降级启动、推流、事件收集、收尾与错误归类 |
 | `server/organize.ts` | Host LLM 结构化归类：提示词、JSON Schema、文本回退与结论落库 |
-| `server/pipeline.ts` | 转录/归类状态机：`job_runs` 记录、失败可重试、自动归类开关 |
-| `server/queue.ts` | 串行执行任务；保留等待/运行中标签至任务结束，提供快照、单条排队状态与全库录音任务查询 |
-| `server/jobs.ts` | `trackTask` 与队列装配、导入/拉取后自动转录 |
-| `server/bridge.ts`、`server/sdk-script.ts` | 探测 Python/bleak/SDK/ffmpeg，以固定 Python 脚本调用 SDK API |
-| `server/live.ts`、`server/live-script.ts` | 实时采集、音频落盘与停止后的录音/文本保存 |
+| `server/pipeline.ts` | 转录/归类状态机：`job_runs` 记录、失败可重试、自动归类开关；失败分列写 `last_error` / `last_error_code` / `last_error_detail` |
+| `server/queue.ts` | 串行执行任务；保留等待/运行中标签至任务结束，提供快照、单条排队状态与全库录音任务查询；`transcribe:` / `organize:` 任务执行前等待网络闸门 |
+| `server/jobs.ts` | `trackTask` 与队列装配、导入/同步后自动转录 |
+| `server/calendar.ts`、`calendar-import.ts`、`calendar-digest.ts` | 日历事件、`.ics` 导入、录音关联与建议、会议纪要/日报（调用 Host 前 `assertOnline`） |
+| `server/preflight.ts` | 本机环境自检（分组 device/audio/ai/storage，技术原文进 `detail`）；`listHostCapabilities` 是宿主能力的唯一来源 |
+| `server/environment-repair.ts`、`server/repair-store.ts` | 让 Floatboat 助手修复本机环境，状态持久化（调用 Host 前 `assertOnline`） |
+| `server/runtime-probe.ts`、`server/tools.ts`、`server/paths.ts` | 探测 Python/bleak/设备 SDK/ffmpeg 与工具路径 |
+| `server/live.ts`、`server/live-script.ts` | 实时字幕会话、音频落盘与停止后的录音/文本保存；采集进程由设备服务派生 |
 | `server/live-audio.ts` | 实时 MP3 解码参数与按秒分帧的 PCM 流 |
 | `server/live-asr.ts` | 按需开启实时识别会话、推流与会话重建 |
 | `server/routes/*` | 按领域拆分的 HTTP 路由 |
 
 ## 设置与 API
 
-- 完整 API 列表见中英文 README；`/api/device` 含 SDK 指令参考库，`/api/device/capabilities` 返回的是 Host ASR/LLM 能力，不是 BLE 指令。
-- `PATCH /api/settings` 使用 `{ values: { key: string } }`，先校验所有键再写入。路径键为 `import_dir`、`library_dir`、`python_path`、`ffmpeg_path`；开关键为 `auto_transcribe`、`auto_analyze`、`auto_connect`、`auto_pull`、`speaker_diarization`，值只接受 `"0"` / `"1"`。
-- `auto_connect_minutes` 接受 1~120 的整数字符串，默认 3；文本键为 `asr_hotwords`、`asr_language`、`device_serial`。路径、热词、语言、序列号的长度上限分别为 500、300、20、64 字符。`sdk_dir` 读取隐藏、提交忽略；其他未知键拒绝。运行时的 `last_auto_connect_at` / `last_auto_pull_at` 可以读取，不能由该接口修改。
-- 设置页编辑上述路径、开关、间隔、热词与语言，设备页仅编辑导入目录；序列号由设备操作或 API 保存。五个开关的迁移默认值均为 `"1"`。
+- 完整 API 列表见中英文 README。设备协议指令参考只在 `GET /api/diagnostics`；宿主 ASR/LLM 能力只在 `GET /api/environment/capabilities`（与诊断视图共用 `listHostCapabilities`）。`GET /api/device` 只读内存与 preflight 缓存，1.5 秒轮询不派生任何子进程。
+- 旧的设备细粒度接口（读状态、读清单、单条下载、环境检查、能力清单、摘要、删除设备记录）、创建导入目录接口和 `PUT /api/recordings/:id` 已删除，不保留兼容别名；对应能力分别并入上述设备任务接口、`/api/environment/*` 与 `PATCH /api/recordings/:id`。
+- `PATCH /api/settings` 使用 `{ values: { key: string } }`，先校验所有键再写入。路径键为 `import_dir`、`library_dir`、`python_path`、`ffmpeg_path`；开关键为 `auto_transcribe`、`auto_analyze`、`auto_connect`、`auto_pull`、`auto_pull_wifi`、`speaker_diarization`，值只接受 `"0"` / `"1"`；枚举键 `device_transport` 取 `auto` / `wifi` / `ble`。
+- `auto_connect_minutes` 接受 1~120 的整数字符串，默认 3；文本键为 `asr_hotwords`、`asr_language`，长度上限 300、20 字符；路径上限 500 字符。`sdk_dir` 读取隐藏、提交忽略；其他未知键拒绝。运行时写入的 `device_serial`、`device_user_disconnected`、`last_auto_connect_at`、`last_auto_pull_at` 可以读取，不能由该接口修改。
+- 设置页分为通用（目录）/ 自动化 / 识别 / 诊断与高级（Python/ffmpeg 路径、传输方式）。`auto_pull_wifi` 默认 `"0"`，其余五个开关默认 `"1"`。
 - `asr_language` 当前只写入文件转录结果元数据，未从流水线传给 ASR；实时识别仅传固定 PCM 参数，不读取热词、语言或说话人分离设置。
-- 自动重连由服务端每 30 秒检查是否到期，受间隔、新鲜设备状态和 SDK 忙碌状态限制；成功后按 `auto_pull` 拉取。手动 `/api/device/status` 不触发自动拉取。
+- 自动连接调度器每 30 秒检查：`auto_connect==='1'`、`device_user_disconnected!=='1'`、当前未连接且不在实时字幕中、已到 `nextAttemptAt`。满足后以 `origin:'auto'` 连接，`auto_pull==='1'` 时后台同步，结束后断开。
+
+## 设备服务
+
+### 连接状态机
+
+`state: disconnected | connecting | connected | busy | live`，`origin: user | auto`，`disconnectReason: user | idle | auto-done | device_sleep | lost | live`。
+
+- `connect` 幂等：connecting 时返回同一个 promise，已连接直接返回，busy 时返回当前状态不报错。成功后 upsert 设备、写 `devices.ble_address` 与 `device_serial`；用户来源清除 `device_user_disconnected`，并在 `auto_pull==='1'` 时立即同步。
+- `disconnect` 有活动时先协作式取消；热点阶段最多等 90 秒、蓝牙阶段 15 秒，再发 `disconnect`，5 秒未退出才终止进程。只有超过 90 秒的硬超时才会杀掉热点阶段的 worker，之后由下次连接的热点自检和 `wifi-restore.json` 恢复。
+- 用户会话最后一次操作 10 分钟后以 `idle` 断开；自动会话任务结束后以 `auto-done` 断开（按结束时的 origin 判断）。用户在自动会话里点「连接」或「同步录音」会接管会话：origin 改为 `user`、清除手动断开标记，不再用完即断；正在进行的后台同步结束后，若有推迟的大录音，按用户规则再同步一次；调度器发现 origin 已不是 `auto` 就不再同步或断开。实时字幕结束后的恢复连接只恢复会话（`autoSync:false`），不触发同步，也就不会切到热点；worker 报 `disconnected` 或进程退出时进入 `device_sleep` / `lost`。
+- 所有 worker 命令走同一条 promise 链。同步/单条同步/清理进行中为 busy，此时再申请 `sync` / `pull` / `cleanup` / 实时字幕一律 `DEVICE_BUSY`。
+- 实时字幕：`startLiveCapture` 记下是否为用户连接，断开 worker 后由服务派生采集脚本并交给 `live.ts`；`releaseFromLive` 结束后按需恢复用户连接。
+
+### worker 协议（stdin / stdout JSON-lines）
+
+启动：`<python> -X utf8 -u <dataDir>/tools/device/worker.py --state-dir <dataDir>/tools/device [--prefer <ble_address>] [--fake-prelude <path>] [--net-platform win32|darwin|linux]`。后两个参数只供测试；不加 `-I`，以免屏蔽用户 site-packages 里的设备 SDK。脚本写成文件再执行，避开 Windows 命令行长度与引号问题。
+
+- 命令：`connect`、`status`、`list`、`pull {files, outDir, transport}`、`cancel`、`delete {names}`、`disconnect`。
+- 输出：`result` / `error {kind, message}` 按 `id` 对应；`event` 有 `progress {phase, file, transport, bytes, total, index, count}`、`fallback {from, to, reason, detail}`、`warning`（如 `HOTSPOT_CLOSE_UNCONFIRMED`）、`disconnected`；另有 `log`。
+- `connect` 后先 `sync_time()`（失败不致命），再读 `wifi.hotspot_state()`，残留热点立即 `wifi.disable()` 并回报 `hotspotWasOn`。连接期间每 5 秒检查一次 `is_connected`。
+- stdin 由后台线程读取再投递给 asyncio（Windows Proactor 不能对管道 `add_reader`）。stdin EOF 按取消 + 断开处理，先跑完热点会话的 finally（恢复网络、关热点）再退出。
+- 所有输出经过 `emit()`：字段名含 `password` / `keyMaterial` / `psk` 的替换为 `***`，当前热点与 FTP 密码字面值全局替换。FTP 下载先写 `<name>.part`，大小校验通过后再改名。
+
+### 传输规划与无线快传
+
+- `planTransfer`：`device_transport==='ble'` 全走蓝牙；平台不是 win32/darwin/linux 或没有无线网卡时不走 Wi-Fi；`origin==='auto' && !auto_pull_wifi` 时只用蓝牙拉大小已知且 < `WIFI_MIN_BATCH_BYTES`（1 MiB）的文件，受 `BACKGROUND_BLE_LIMIT`（3 个 / 150 秒）限制，其余计入 deferred；其他情况本批 ≥ 1 MiB 或含大小未知的文件时走 Wi-Fi。
+- 无线网卡探测：win32 `netsh wlan show drivers`（含定位权限提示也算有网卡）；darwin `networksetup -listallhardwareports` 含 `Wi-Fi`；linux `nmcli -t -f TYPE dev` 含 `wifi`。结果缓存 10 分钟；假设备模式直接返回 true。
+- 同步前读 `recordingState`，录音或暂停中返回 `DEVICE_RECORDING`，不开热点。只同步 `device_serial = 当前序列号` 的 pending 记录；只挂接 worker 返回的路径，且本地大小必须等于设备上报的 `sizeBytes`，否则按 `TRANSFER_FAILED`。
+- Wi-Fi 路径：`dev.wifi.session()` 开热点 → 按平台入网（Windows 写 `wifi-restore.json` 后用 hex SSID、`connectionMode=manual` 的临时 profile，定位权限失败时不带 `interface=`；macOS 用 `join_hotspot(iface)`；Linux 用 `nmcli` + 0600 passwd-file）→ 对 `ftp_config.host:port` 做 TCP 可达性探测（最多 20 秒）→ FTP 串行 `retrbinary` → finally 中离网、删临时 profile → 退出 session 由设备 SDK 关热点并确认 → 重连原网络并删除 `wifi-restore.json` → 若开热点前能连上公网（TCP 探测 223.5.5.5 / 1.1.1.1 / 8.8.8.8 的 53 端口），就等到再次连通才上报 `fallback` 或结果（最多 25 秒，Windows 等到一半时再发一次 `netsh wlan connect`）；超时发 `NETWORK_RESTORE_TIMEOUT` 警告进设备日志。
+- 第 1–4 步任一失败都发 `fallback`（`WIFI_UNSUPPORTED` / `WIFI_ENABLE_FAILED` / `WIFI_JOIN_FAILED` / `WIFI_UNREACHABLE` / `WIFI_FTP_FAILED` / `WIFI_TRANSFER_FAILED`），先恢复网络，再用 `files.download` 逐个走蓝牙。worker 启动时发现 `wifi-restore.json` 会先恢复网络。
+- 取消是协作式的：FTP 写回调或蓝牙进度回调抛 `CancelledTransfer`；蓝牙再调用 `files.sync_control(name, SyncOp.CANCEL)`。热点阶段绝不硬中断：被中断的热点开关会让录音笔拒绝录音。
+
+### 网络闸门
+
+- 走 Wi-Fi 前 `acquireOffline('device-hotspot', { waitForInFlightMs: 180_000 })`：先暂停新任务，再等进行中的 `transcribe:` / `organize:` 任务结束；超时恢复闸门并返回 null，本批改走蓝牙（`fallback` 原因 `NETWORK_IN_USE`）。收到 `fallback` 或最终结果后立即 `release()`。
+- 断网期间新的转录/归类任务排队等待，不报错；队列外的 Host 调用（日历纪要、环境修复）先 `assertOnline()`，断网时抛 `NETWORK_PAUSED`。
+
+### 假设备（只用于测试）
+
+设置 `OPENMINUTES_FAKE_DEVICE=wifi|ble|absent` 时，worker 加载 `fake-device.ts` 写出的 prelude：用设备 SDK 自带的 `FakeMemoTalk` 替换真实录音笔，`OPENMINUTES_FAKE_DEVICE_AUDIO_DIR` 提供真实 mp3 字节；`subprocess` 遇到 `netsh` / `nmcli` / `networksetup` 直接抛错。`wifi` 模式用内存 FTP；`ble` 模式入网失败以测试回退；`absent` 模式连接抛 `DeviceNotFound`。verify skill 的 `launch.mjs --fake-device=<mode>` 负责设置这些变量。
+
+### 设备 SDK 能力矩阵
+
+| memotalk-sdk 能力 | 去向 |
+| --- | --- |
+| `connect()` / `close()`（`prefer`） | worker `connect` / `disconnect`，`prefer = devices.ble_address` |
+| `info()` / `battery()` / `firmware()` / `identity()` / `free_space()`、`record.state()` | worker `status` → 录音笔卡片；同步前检查录音状态 |
+| `sync_time()` | 连接后自动执行，无入口 |
+| `record.*` / `stream.*` / `set_realtime` | 只由实时字幕采集脚本使用，由设备服务派生 |
+| `files.list()` / `files.download()` / `files.sync_control(CANCEL)` / `files.delete()` | worker `list` / 蓝牙 `pull` / 「停止」/ 「清理已同步的录音」 |
+| `wifi.session()`、`NetworkSession.open_ftp` / `list_audio_files`、`join_hotspot()`（仅 macOS） | worker `pull` 的无线快传部分 |
+| `wifi.hotspot_state()` / `disable()` | 连接时关闭残留热点 |
+| `wifi.credentials()` | 只在 session 内部使用，不展示、不记录 |
+| `files.download_all()` | 不用：由编排逐个下载，才能报告进度、支持取消 |
+| `files.clear_all()` | 不接入：不可逆，「清理已同步」已覆盖安全子集 |
+| `settings.*`（休眠时长、最长录音、U 盘模式）、`has_import_file()`、`raw.*` | 本次不接入（录音笔设置见 REQUIREMENTS「待评估」） |
+
+## 错误模型
+
+- `src/contracts/errors.ts` 定义 `AppError(code, message?, detail?, action?)`、`AppErrorView` 与 `ERROR_COPY`（每个 code 的默认中文文案和可选 action），UI 与服务端共用。
+- `http.ts` 的判断顺序：`AppError` 原样输出 → `BadInput` 为 `INVALID_INPUT` → Node 系统错误（带 `errno` / `syscall`）按 errno 映射：EACCES/EPERM → `NO_PERMISSION`、ENOSPC → `DISK_FULL`、ENOENT → `FILE_MOVED`，其余 `INTERNAL_ERROR`，原文进 `detail` → 带字符串 `code` 的业务错误保留 message → 其他异常为 `INTERNAL_ERROR`，stack 截断 2000 字进 `detail`。
+- `device/errors.ts` 把设备 SDK 异常类型映射为 `DEVICE_NOT_FOUND`、`DEVICE_DISCONNECTED`、`DEVICE_TIMEOUT`、`DEVICE_RECORDING`、`FILE_NOT_ON_DEVICE`、`DELETE_FAILED`、`TRANSFER_FAILED`、`BLUETOOTH_UNAVAILABLE`、`RUNTIME_MISSING`、`DEVICE_ERROR`；`detail` 为 `kind: message`、操作与退出码、stderr 尾部。
+- 转录、归类、实时字幕、日历纪要、环境修复、导入同样只把中文结论放进 `error` / `last_error`，宿主错误码、requestId、ffmpeg stderr、runId、幂等键一律进 `detail`。`job_runs.message` 只写中文，原文写进 `detail_json`。
+- UI 用 `ErrorNotice` 显示：主行中文 + 可选 action + 「重试」；有 detail 时「查看详情」展开 code 与 detail，可「复制诊断信息」或「在诊断中查看」。toast 只显示 message，带 detail 时附「详情」并且不自动消失。
 
 ## 排队状态与轮询
 
@@ -51,11 +126,11 @@
 
 ## 持久化对象
 
-`devices`、`recordings`、`transcripts`、`analyses`、`categories`、`tags`、`recording_tags`、`job_runs`、`sdk_commands`、`settings`。
+`devices`、`recordings`、`transcripts`、`analyses`、`categories`、`tags`、`recording_tags`、`job_runs`、`sdk_commands`、`settings`、`calendar_events`、`environment_repairs`。
 
-- `library.ts` 统一录音库位置与路径解析。`library_dir` 默认 `~/memo/memotalk/raw`；目录导入与设备下载复制到 `<library_dir>/<yyyy-MM>/`，实时录音也写入月目录。月份使用本地时区，录制时间无法解析时回退到当前月份。
+- `library.ts` 统一录音库位置与路径解析。`library_dir` 默认 `~/memo/memotalk/raw`；目录导入与录音笔同步复制到 `<library_dir>/<yyyy-MM>/`，实时录音也写入月目录。月份使用本地时区，录制时间无法解析时回退到当前月份。
 - 新版 `recordings.storage_path` 保存完整目标路径，默认目录或绝对路径配置下为绝对路径。目录配置应使用绝对路径或 `~/...`；当前设置校验并不拒绝相对路径。历史相对文件名由 `resolveAudioFile` 从 Host 数据资源 `audio` 解析，`resolveStoredPath` 则使用调用方提供的兜底目录。修改 `library_dir` 不会迁移已有文件或重写其路径。
-- BLE 下载先暂存到 `app.resources.path('audio', '_incoming', 'write')`，再复制进录音库；`import_dir` 不是 BLE 暂存目录。目录扫描只处理当前层支持的音频文件，不递归，且保留来源文件。
+- 录音笔同步先暂存到 `app.resources.path('audio', '_incoming', 'write')` 下每个任务独立的 `<jobId>/` 目录，大小校验通过后复制进录音库，任务结束删除该目录；`import_dir` 不是同步暂存目录。目录扫描只处理当前层支持的音频文件，不递归，且保留来源文件。
 - 删除录音时尝试 `rename` 到当前 `<library_dir>/_trash/<毫秒时间戳>-<原存储文件名>`。无论移动是否成功，随后都会删除录音、转录、分析、标签关联、任务记录并清理孤立标签；移动失败返回 `audioMovedToTrash: null`。没有恢复接口，不应把回收站视为完整的数据备份。
 - `POST /api/recordings/:id/export` 只复制音频，默认目标为解析后的 `import_dir`（默认 `~/memo/memotalk/inbox`），请求体 `directory` 可覆盖目标。目录自动创建，文件使用原始 `filename`，同名目标可能被覆盖；不存在独立的导出目录设置。
 
@@ -63,8 +138,10 @@
 
 - **Host ASR**：把本机音频解码后流式送出，只保存文本与分段，不上传音频原件。
 - **Host LLM**：只发送转写文本与分类说明，返回结构化 JSON Schema 校验后的对象。
-- **本机进程**：`ffmpeg` 用于解码/探测；`python` 以固定脚本和参数调用 PyPI `memotalk-sdk` 的 `MemoTalkClient`（状态、清单、下载及实时流），不接受用户拼接的任意命令，也不加载 SDK 源码目录。
-- 文件转录与归类流水线维护录音状态和 `job_runs`，失败保存 `last_error`；这不是所有外部操作的统一保证。例如导入按文件返回结果，设备操作返回 SDK 结果，自动重连异常静默处理。
+- **本机进程**：`ffmpeg` 用于解码/探测；`python` 只由设备服务派生两类固定脚本：常驻设备 worker（连接、状态、清单、同步、删除）和实时字幕采集脚本，同一时间只有一个进程占用录音笔。不接受用户拼接的任意命令，也不加载 SDK 源码目录。
+- **本机网络**：手动同步走无线快传时，worker 会临时连上录音笔热点（Windows `netsh`、macOS `networksetup` / `join_hotspot`、Linux `nmcli`），完成后删除临时 profile 并连回原网络。热点密码只在 worker 内存里使用。后台任务默认不改变网络。
+- **录音笔存储**：「清理已同步的录音」会删除录音笔上的文件（不可逆）。删除前重新读清单，只删库中有记录、本地文件存在且大小一致的文件，并要求用户二次确认，结果写入诊断记录。
+- 文件转录与归类流水线维护录音状态和 `job_runs`，失败分列保存 `last_error` / `last_error_code` / `last_error_detail`。设备操作的结果写入设备服务的 `lastResult` / `lastError` 和诊断环形缓冲；导入按文件返回 `{outcome, reason, detail}`。
 
 ## 可执行验证
 
@@ -73,7 +150,8 @@
 3. 用 16kHz 单声道 MP3（与设备格式一致）验证 ffmpeg 解码与 ASR 帧序，确认 `transcripts.text` 与 `segments_json` 落库。
 4. 用 `curl -H 'Range: bytes=100-199' GET /api/recordings/:id/audio` 验证 206 + `content-range` + `accept-ranges`，并在页面播放中拖动进度条，确认 `currentTime` 从新位置继续前进。
 5. 点详情页分段时标，确认 `audio.currentTime` 跳到该句 `startMs`、播放从新位置继续、当前句高亮；音频不可用时时标退回纯文本。
-6. 无 `bleak` 时应验证设备页如实报告「未就绪」，且目录导入路径仍可用。
+6. 无 `bleak` 时应验证录音笔页提示「录音笔组件还没准备好」并链接到诊断区，且「导入」对话框仍可用。
+7. 设备流程只用假录音笔验证（verify skill 的 `launch.mjs --fake-device=wifi|ble|absent`）。对真实录音笔执行同步会真实切换本机 Wi-Fi，agent 不执行；真机验收由用户按清单进行（无线快传进度与网络恢复、关闭定位服务后的回退、停止、断开后不自动重连、同步期间转录排队）。
 
 ## 容错策略
 
@@ -83,10 +161,13 @@
 - LLM 优先 `generateObject`；若服务端拒绝该 JSON Schema，回退 `generateText` 并本地抽取 JSON，再做字段收敛与分类枚举校验。
 - 实时字幕的识别会话**按需开启**：只在收到第一帧 PCM 时才 `asr.start`，避免连接/等待阶段空转到 60 秒被服务端回收；会话被回收或上游异常时自动重建（连续失败 4 次熔断并提示重开）。
 - 工具路径（python/ffmpeg）按「设置值 → Floatboat 内置工具 → PATH → 命令名」探测，避免依赖进程 PATH。
-- `resolveImportDir` 在 `import_dir` 为空或位于系统临时目录时回落到 `~/memo/memotalk/inbox`；只有非空的临时目录配置会被写回默认值。`POST /api/ingest/scan` 显式传入 `directory` 时直接使用并保存该路径，不经过这项回退；`/api/ingest/directory/ensure` 则在保存后重新解析目录。扫描前若目录不存在会先创建，创建失败报告 `DIR_NOT_CREATABLE`。
+- `resolveImportDir` 在 `import_dir` 为空或位于系统临时目录时回落到 `~/memo/memotalk/inbox`；只有非空的临时目录配置会被写回默认值。`POST /api/ingest/scan` 显式传入 `directory` 时直接使用并保存该路径，不经过这项回退。扫描前若目录不存在会先创建，创建失败报告 `DIR_NOT_CREATABLE`。
+- 录音笔同步：无线快传任何阶段失败自动改用蓝牙；关热点未确认时记 `HOTSPOT_CLOSE_UNCONFIRMED` 警告，下次连接先检查并关闭残留热点；进程被硬杀后，下次启动 worker 按 `wifi-restore.json` 恢复网络。
 
 ## 已知边界
 
-- 应用不会伪造设备连接成功；BLE 通道依赖用户本机 Python + bleak + 真实设备。
+- 应用不会伪造设备连接成功；录音笔连接依赖用户本机 Python + bleak + 设备 SDK + 真实录音笔。
+- 无线快传的 Windows 路径必须真机验收；macOS 与 Linux 只有桩测，属于实验性支持。`WIFI_MIN_BATCH_BYTES`（1 MiB）需要按真机实测的无线与蓝牙吞吐调整。
+- 无线快传窗口内 Floatboat Host 自身的联网行为（登录心跳等）不受本应用控制，需在真机验收中观察。
 - 内嵌播放的拖动进度条依赖 `GET /api/recordings/:id/audio` 自身实现的 HTTP Range 支持（`206` + `content-range` + `accept-ranges: bytes`，含 `bytes=-N` 后缀区间、越界 `416`）。只回 `200` 全量时浏览器无法 seek，播放头会退回拖动前的位置。
 - 播放依赖 Host 对 `Response` 与流式 body 的透传；确实拿不到时页面提示改用「导出」。
diff --git a/README.md b/README.md
index 87dc304..3198b5c 100644
--- a/README.md
+++ b/README.md
@@ -16,26 +16,41 @@ English | [简体中文](README.zh-CN.md)
 
 ### OpenMinutes Workbench
 
-![OpenMinutes recording overview with device status, recording statistics, categories, and recent recordings](docs/images/openminutes-workbench.png)
+![OpenMinutes workbench UI](docs/images/openminutes-workbench.png)
 
 ## Why OpenMinutes?
 
 Recordings accumulate every day, but finding a particular conversation or listening back to everything becomes difficult.
 
-This workbench connects import, transcription, classification, and search in one workflow. Each recording has a clear stage label: awaiting download, awaiting transcription, transcription queued, transcribing, awaiting classification, classification queued, classifying, archived, or failed. Batch operations use the selected recordings.
+This workbench connects sync, transcription, classification, and search in one workflow. Each recording has a clear stage label: on recorder, awaiting transcription, transcription queued, transcribing, awaiting classification, classification queued, classifying, organized, or failed. Batch operations use the selected recordings, or every recording in the current stage.
 
 ## Features
 
-| Capability | Description |
+The left navigation has six fixed items. Every feature has exactly one entry point, and each page title matches its navigation label (the UI is in Chinese; English names are given here):
+
+| Navigation | What the page owns |
 | --- | --- |
-| Three import methods | Scan a directory, register a device file manifest, or download directly over BLE (requires local Python, `bleak`, and a physical device) |
-| Streaming transcription | Decode audio to 16 kHz mono PCM16 with `ffmpeg`, stream it through Host ASR, and store the full text and timestamped segments |
-| AI classification | Use the Host LLM to generate structured titles, summaries, categories, tags, key points, action items, and importance levels, with manual editing |
-| Search and review | Search transcript text, titles, and summaries; filter by category, tag, or stage; sort by time; and process recordings in batches |
-| Recording details and playback | Play audio with HTTP Range support, seek to sentence timestamps, and review separate transcript, AI analysis, and execution-history sections |
-| Category management | Create, rename inline, recolor, and delete custom categories; built-in categories cannot be deleted |
-| Device setup | Check the environment (Python, `bleak`, SDK, and `ffmpeg`), configure the import directory, browse the SDK command reference, and register recordings manually |
-| Live captions | Stream device audio through Host ASR, then save the recording and any transcript when stopped |
+| Recordings (录音, default) | Stats bar (click "failed N" to filter failures), full-text search over transcripts, titles, and summaries, stage/category/tag filters and sorting, batch or "transcribe all / organize all (N)", and the **Import** dialog that scans a local folder. A recording's detail page offers HTTP Range playback, sentence-timestamp seeking, transcript / AI analysis / processing-history sections, manual edits, export, and deletion; its header has a single primary action that follows the recording's state |
+| Recorder (录音笔) | Connect / disconnect, battery and free space, sync (with progress and **Stop**), the "still on the recorder" list with per-item sync, cleanup of already-synced recordings to free recorder space, and auto-connect status. The recorder clock is synced on connect |
+| Live captions (实时字幕) | Stream recorder audio through Floatboat speech recognition, then save the recording and any text when stopped |
+| Calendar (日历) | Day view of events and recordings, linking recordings to events (the only place to do so), new events, `.ics` import, and meeting digests |
+| Categories (分类) | Create, rename inline, recolor, and delete custom categories (built-in ones cannot be deleted); each shows its recording count and total duration |
+| Settings (设置) | General (folders) / Automation / Recognition / Diagnostics & advanced. Diagnostics & advanced is the single place for technical detail: environment checks and "let the Floatboat assistant repair", Python/ffmpeg paths, transport, recent recorder operations, Host capabilities, the device protocol reference, and developer tools |
+
+Transcription decodes audio to 16 kHz mono PCM16 with `ffmpeg` and streams it through Host ASR, storing the full text and timestamped segments. AI classification uses the Host LLM to produce structured titles, summaries, categories, tags, key points, action items, and importance.
+
+Errors show a one-sentence Chinese conclusion and a next step. Technical detail (exception type, exit code, Host error code) appears only after clicking "view details", and the full log lives in Settings › Diagnostics & advanced.
+
+### Recorder transport
+
+- For a user-initiated sync, a batch totalling at least 1 MiB (or containing recordings of unknown size) uses the recorder's **wireless fast transfer** (Wi-Fi hotspot + FTP) by default; smaller batches use Bluetooth. A note under the button warns that the computer will be briefly offline.
+- During wireless fast transfer the computer joins the recorder's hotspot and loses internet access. Running transcription/classification tasks finish first (up to 3 minutes; otherwise the batch uses Bluetooth), new AI tasks queue, and other online operations such as calendar digests return "try again later". Afterwards the computer reconnects to its original network and the recorder's hotspot is turned off.
+- If wireless fast transfer fails at any stage, sync continues over Bluetooth. The UI shows a single "switched to Bluetooth" notice; the reason is under "view details".
+- Sync does not start while the recorder is recording. A download is attached to the library only if its size matches what the recorder reported.
+- Background auto-sync never switches networks by default: it uses Bluetooth for recordings under 1 MiB (at most 3 per round) and leaves larger ones for a manual sync. Enable `auto_pull_wifi` under Settings › Automation to allow wireless fast transfer in the background.
+- A fixed transport (auto / always wireless / always Bluetooth) is set under Settings › Diagnostics & advanced.
+- A user-initiated connection disconnects after 10 idle minutes to save recorder battery; auto-connect sessions disconnect as soon as their work is done. After a manual **Disconnect**, auto-connect stays paused until you click **Connect** again.
+- Platform requirements: Windows needs a wireless adapter (uses the built-in `netsh`); macOS needs Wi-Fi; Linux needs NetworkManager (`nmcli`). macOS and Linux support is experimental and falls back to Bluetooth on failure.
 
 ## Getting started
 
@@ -56,11 +71,11 @@ Then use Floatboat's `check_workbench_project` to run type checks and build the
 | Dependency | Purpose | Behavior when missing |
 | --- | --- | --- |
 | `ffmpeg` | Audio probing and decoding | Transcription is unavailable, and the UI reports it |
-| `python` + `bleak` + `memotalk-sdk` | Download device recordings over BLE | The device page reports "not ready"; directory import remains available |
+| `python` + `bleak` + `memotalk-sdk` | Connect to the recorder, sync recordings, and live captions | The recorder page says the recorder component is not ready and links to diagnostics; local folder import remains available |
 
 Tool discovery tries configured paths, Floatboat's bundled tools, `PATH`, and command names in that order, so it does not rely solely on the process `PATH`.
 
-Check the device page for the Python interpreter in use, then install the SDK into that same environment:
+Check Settings › Diagnostics & advanced › Environment for the Python interpreter in use, then install the device SDK into that same environment:
 
 ```bash
 uv pip install --python "/path/to/python" "memotalk-sdk>=0.1.0"
@@ -72,11 +87,13 @@ The SDK installs `bleak` automatically; you do not need to clone its source or c
 The app uses `from memotalk import MemoTalkClient` for device APIs and live audio streaming.
 Upgrading removes the old `sdk_dir` setting while preserving other path, recognition, and automation settings.
 
-### SDK regression tests
+For hardware specifications and firmware questions, join the Floatboat official community group (see [Community](#community)).
+
+### Device SDK regression tests
 
-`pnpm test` runs the server tests. SDK integration tests use the package's simulated device and do not connect to a physical recorder.
+`pnpm test` runs the server tests. Device SDK integration tests drive the device worker (connect, listing, Bluetooth and wireless transfer, cancellation, network restore) with the package's simulated device. They do not connect to a physical recorder or call the real `netsh` / `nmcli` / `networksetup`.
 Set the `MEMOTALK_TEST_PYTHON` environment variable to the path of a Python interpreter with `memotalk-sdk` installed before running them.
-Without this variable, SDK integration tests are skipped; settings API and migration tests still run.
+Without this variable, these tests are skipped; settings API and migration tests still run.
 
 ### CI
 
@@ -96,33 +113,43 @@ verification steps under `.claude/skills/verify-openminutes`.
 
 ```text
 src/
-  contracts/       Shared DTOs (app.ts), input validation (input.ts), busy states (recording-status.ts)
+  contracts/       Shared DTOs (app.ts, device.ts, calendar.ts, preflight.ts), error model (errors.ts), input validation (input.ts), busy states (recording-status.ts)
   server/          Node server: assembly, routing, and domain logic
-    index.ts       Server assembly and automatic-connection startup
+    index.ts       Server assembly: device service, auto-connect scheduler, route registration
     routes/        HTTP routes grouped by domain
-    app-route.ts   App metadata, overview, and tag-list routes
-    http.ts        Shared API envelope and top-level error/code mapping
+    app-route.ts   App metadata, statistics, and tag-list routes
+    http.ts        Shared API envelope; AppError / system errors -> Chinese error + code + detail
     sql.ts         Thin node:sqlite wrapper, settings, and job records
     repo.ts        Queries, transient queued-status projection, and library-wide hasActiveTasks
     library.ts     Library root, monthly folders, and legacy audio-path resolution
-    ingest.ts      Directory scanning, manifest registration, deduplication, naming conflicts
-    pull.ts        BLE download staging, library attachment, and pending-file pulls
-    auto-connect.ts Background device checks and optional automatic pulls
+    ingest.ts      Directory scanning, manifest registration, download attachment, deduplication, naming conflicts
+    device/        Sole owner of the device SDK (memotalk-sdk)
+      service.ts     Connection state machine, single mutex, idle disconnect, live-caption handoff, diagnostics log
+      sync.ts        Sync orchestration (list -> register -> transfer -> size check -> attach) and cleanup
+      transport.ts   Transport planning (wireless fast transfer / Bluetooth) and wireless-adapter probing
+      worker.ts      Spawns the resident Python worker and speaks JSON-lines RPC
+      worker-script.ts Worker Python source: connect, list, sync, delete, network join and restore
+      errors.ts      Device SDK exceptions -> Chinese error codes
+      auto-connect.ts Auto-connect scheduler (disconnects when done; paused after manual disconnect)
+      fake-device.ts Fake recorder (tests only; loaded when OPENMINUTES_FAKE_DEVICE is set)
+    network-gate.ts Network gate during wireless transfer: pauses AI tasks, fails off-queue calls fast
     media.ts       ffmpeg probing, duration parsing, and PCM16 framing
     transcribe.ts  Host ASR sessions: parameter fallback, streaming, resumption, error classification
     organize.ts    Host LLM structured classification and text fallback
     pipeline.ts    Transcription/classification state machines and retries
-    jobs.ts        Task scheduling and automatic transcription after import/download
+    jobs.ts        Task scheduling and automatic transcription after import/sync
     queue.ts       Serial task execution, pending/running labels, and task-state queries
-    bridge.ts      memotalk-sdk Python API bridge (fixed arguments, no concatenated commands)
-    sdk-script.ts  Python script for SDK status, listing, and download actions
-    live.ts        Live audio capture, file storage, and session persistence
+    calendar*.ts   Calendar events, .ics import, recording links, and meeting digests
+    preflight.ts   Environment checks and the Host capability list
+    environment-repair.ts, repair-store.ts Floatboat-assistant environment repair
+    runtime-probe.ts, tools.ts, paths.ts Python / bleak / device SDK / ffmpeg discovery and paths
+    live.ts        Live-caption sessions, file storage, and saving (capture process spawned by the device service)
     live-audio.ts  Live MP3 decoder arguments and one-second PCM framing
     live-asr.ts    On-demand live ASR sessions and frame streaming
-    live-script.ts Python script for SDK live audio streaming
-  ui/              React UI: overview / library / details / device / categories / live / settings
-migrations/        Append-only SQLite migrations
-sdk/               Host-provided Workbench runtime, clients, contracts, and types
+    live-script.ts Python script for device SDK live audio streaming
+  ui/              React UI: recordings / details / recorder / live captions / calendar / categories / settings (incl. diagnostics)
+migrations/        Append-only SQLite migrations (0001-0007)
+sdk/               Host SDK: Host-provided Workbench runtime, clients, contracts, and types (not modified)
 tests/             Server tests
 manifest.json      Host entry points, build profile, capabilities, and audio resource
 index.html         UI build entry point
@@ -132,13 +159,15 @@ Related documentation (in Chinese): [requirements](REQUIREMENTS.md), [engineerin
 
 ## Data model
 
-`devices`, `recordings`, `transcripts`, `analyses`, `categories`, `tags`, `recording_tags`, `job_runs`, `sdk_commands`, and `settings`.
+`devices`, `recordings`, `transcripts`, `analyses`, `categories`, `tags`, `recording_tags`, `job_runs`, `sdk_commands`, `settings`, `calendar_events`, and `environment_repairs`.
+
+Transcription/classification failures are stored in three columns: `recordings.last_error` (Chinese conclusion), `last_error_code`, and `last_error_detail` (technical text). `devices.ble_address` remembers the last connected recorder so the next connection prefers it; no serial number needs to be entered.
 
 ### Storage and directories
 
 - `import_dir` is the scan source and the default audio export destination, defaulting to `~/memo/memotalk/inbox`. Scans create a missing directory, read only its immediate files, and copy supported audio (`.mp3`, `.wav`, `.m4a`, `.aac`, `.ogg`, `.flac`, `.amr`, `.opus`) into the library without removing the originals.
-- `library_dir` defaults to `~/memo/memotalk/raw`. Imports and BLE downloads are copied into `<library_dir>/<yyyy-MM>/`, using the recording month inferred from the filename or a fallback date. Live recordings also go into monthly folders. Use an absolute path or `~/...` for these directory settings; changing the library setting does not relocate existing files.
-- New `recordings.storage_path` values store the full destination path (absolute with the default or an absolute library directory). Historical relative filenames resolve against the Host's `audio` data resource. BLE downloads first use the Host's `audio/_incoming` staging directory, not `import_dir`.
+- `library_dir` defaults to `~/memo/memotalk/raw`. Imports and recorder syncs are copied into `<library_dir>/<yyyy-MM>/`, using the recording month inferred from the filename or a fallback date. Live recordings also go into monthly folders. Use an absolute path or `~/...` for these directory settings; changing the library setting does not relocate existing files.
+- New `recordings.storage_path` values store the full destination path (absolute with the default or an absolute library directory). Historical relative filenames resolve against the Host's `audio` data resource. Recorder syncs first stage files in the Host's `audio/_incoming/<job id>/` (one directory per sync, removed afterwards), not `import_dir`.
 - Deletion attempts to move audio to `<library_dir>/_trash/<milliseconds>-<basename>` using the **current** library setting, then deletes the recording and its transcript, analysis, tag links, and job history. If the move fails, database deletion still proceeds; `audioMovedToTrash` is then `null`. There is no restore API.
 - Export copies the audio under its original `filename` into `import_dir`, or into the request body's optional `directory`. It creates missing destination directories and can overwrite a same-named file. The detail page uses the default destination. There is no separate export-directory setting.
 
@@ -146,55 +175,78 @@ When resolving `import_dir`, an empty value falls back to the default; a path in
 
 ## Settings
 
-The settings page edits paths, automation, and recognition options. The device page edits only `import_dir`. `PATCH /api/settings` accepts `{ "values": { "key": "value" } }`; all values must be strings.
+The settings page has four sections, and every path is edited only here:
+
+| Section | Contents |
+| --- | --- |
+| General | `library_dir`, `import_dir` |
+| Automation | `auto_transcribe`, `auto_analyze`, `auto_connect`, `auto_connect_minutes`, `auto_pull` (sync new recordings after connecting), `auto_pull_wifi` (allow wireless fast transfer for large recordings in background sync) |
+| Recognition | `speaker_diarization`, `asr_hotwords`, `asr_language` |
+| Diagnostics & advanced (`#/settings/diagnostics`, collapsed by default) | Environment, `python_path` / `ffmpeg_path`, `device_transport`, recent recorder operations, Host capabilities, device protocol reference, developer tools (manual manifest registration), copy diagnostics report |
+
+`PATCH /api/settings` accepts `{ "values": { "key": "value" } }`; all values must be strings.
 
 | Keys | Behavior and defaults |
 | --- | --- |
 | `library_dir`, `import_dir` | Empty by default; resolved as described above; at most 500 characters each |
 | `python_path`, `ffmpeg_path` | Empty by default for automatic discovery; at most 500 characters each |
-| `auto_transcribe`, `auto_analyze` | Automatically transcribe after import/download and classify after transcription; both default to `"1"` |
-| `auto_connect`, `auto_pull` | Background device checks and pending-file downloads after a successful automatic connection; both default to `"1"` |
+| `auto_transcribe`, `auto_analyze` | Automatically transcribe after import/sync and classify after transcription; both default to `"1"` |
+| `auto_connect`, `auto_pull` | Auto-connect to the recorder on an interval; sync new recordings once connected (a manual **Connect** also starts a sync right away); both default to `"1"` |
+| `auto_pull_wifi` | Whether background sync may use wireless fast transfer (briefly offline), default `"0"` |
+| `device_transport` | `auto` (default) / `wifi` / `ble`; fixes the transport |
 | `auto_connect_minutes` | Integer string from `"1"` to `"120"`, default `"3"` |
 | `speaker_diarization` | File-transcription speaker separation, default `"1"` |
 | `asr_hotwords` | File-transcription hotwords, empty by default; at most 300 characters |
 | `asr_language` | At most 20 characters; the UI offers automatic (empty), `zh`, `en`, and `ja`. Currently saved as file-transcription metadata, but not passed to ASR |
-| `device_serial` | At most 64 characters; saved by device operations or via the API, not a field on the settings page |
 
-Flags accept only `"0"` or `"1"`. Background checks run while the workbench server is open; manual status checks do not trigger automatic pulls. Live ASR currently uses fixed PCM parameters rather than the file-transcription hotword, language, or speaker settings. `GET /api/settings` can also return runtime-written `last_auto_connect_at` and `last_auto_pull_at`; these are not writable through PATCH. The removed `sdk_dir` is hidden on reads and ignored on writes; other unknown keys are rejected.
+Flags accept only `"0"` or `"1"`. Auto-connect runs while the workbench server is open and disconnects when done. Live ASR currently uses fixed PCM parameters rather than the file-transcription hotword, language, or speaker settings. `GET /api/settings` can also return runtime-written `device_serial`, `device_user_disconnected`, `last_auto_connect_at`, and `last_auto_pull_at`; these are not writable through PATCH (`device_user_disconnected` is set only by **Disconnect** and cleared by **Connect**). The removed `sdk_dir` is hidden on reads and ignored on writes; other unknown keys are rejected.
 
 ## API overview
 
 | Method | Path | Description |
 | --- | --- | --- |
 | `GET` | `/api/app` | Application name and version |
-| `GET` | `/api/overview` | Recording statistics, device status, and overview data |
+| `GET` | `/api/overview` | Recording statistics (total, duration, awaiting transcription, failed, on-recorder `pendingCount`) and per-category counts/durations `byCategory` |
 | `GET` | `/api/tags` | Tag names for filtering |
 | `GET` | `/api/recordings` | List recordings with search, stage/category/tag/favorite/archive filters, sorting, and pagination; data contains `items`, `total`, and library-wide `hasActiveTasks` |
-| `GET` | `/api/recordings/:id` | Details: metadata, transcript, AI analysis, and execution history |
+| `GET` | `/api/recordings/:id` | Details: metadata, transcript, AI analysis, and processing history |
 | `GET` | `/api/recordings/:id/tags` | Tag IDs and names for one recording |
-| `PATCH` | `/api/recordings/:id` | Edit title, summary, category, tags, importance, favorite, and archive flags |
+| `PATCH` | `/api/recordings/:id` | Edit title, summary, category, tags, importance, favorite, and archive flags; `calendarEventId` (positive integer or `null`) is the only write path for recording-event links |
 | `DELETE` | `/api/recordings/:id` | Delete a recording; attempt to move audio to `<library_dir>/_trash/<milliseconds>-<basename>` |
 | `GET` | `/api/recordings/:id/audio` | Audio stream with HTTP Range support (206 and `content-range`; 416 for out-of-range requests) |
 | `POST` | `/api/recordings/:id/export` | Copy audio to `import_dir` by default; optional body field `directory` overrides it |
 | `POST` | `/api/recordings/:id/transcribe` | Queue transcription; after prerequisite checks, reject already queued/running recordings with `BUSY` |
 | `POST` | `/api/recordings/:id/organize` | Queue AI classification; after prerequisite checks, reject already queued/running recordings with `BUSY` |
-| `POST` | `/api/recordings/batch/transcribe`, `/api/recordings/batch/organize` | Queue transcription or classification for body field `ids`; skip already queued/running or otherwise ineligible recordings |
+| `POST` | `/api/recordings/batch/transcribe`, `/api/recordings/batch/organize` | Queue transcription or classification for body field `ids`, or pass `{ stage: "ready" }` / `{ stage: "transcribed" }` to let the server select every recording in that stage (up to 400). Skip already queued/running or otherwise ineligible recordings |
 | `GET` | `/api/ingest/directory` | Read import directory information |
-| `POST` | `/api/ingest/directory/ensure` | Create the import directory |
-| `POST` | `/api/ingest/scan` | Scan the import directory |
-| `POST` | `/api/ingest/manifest` | Register device manifest entries |
-| `GET` | `/api/device` | Environment checks, SDK command reference, Host capability summary, device records, and settings |
-| `GET` | `/api/device/summary` | Device/local recording counts and device/category counts |
-| `GET` | `/api/device/capabilities` | Host ASR/LLM operation availability, not BLE commands |
-| `DELETE` | `/api/device/:id` | Remove a local device record and clear its matching saved serial; does not delete recordings or device files |
-| `POST` | `/api/device/check`, `/api/device/list`, `/api/device/download`, `/api/device/status` | Environment check, file listing, BLE download, and status |
+| `POST` | `/api/ingest/scan` | Scan the import directory (created if missing) |
+| `POST` | `/api/ingest/manifest` | Manually register recorder manifest entries (diagnostics developer tool only) |
+| `GET` | `/api/device` | Recorder view: connection state, battery and space, sync progress, last result, recordings still on the recorder, cleanable count, auto-connect status. Reads memory and caches only; never spawns probes |
+| `POST` | `/api/device/connect` | Connect and sync the recorder clock; starts a sync right away when `auto_pull` is on. Returns the recorder view |
+| `POST` | `/api/device/disconnect` | Disconnect and pause auto-connect until the next manual connect |
+| `POST` | `/api/device/sync` | Sync all new recordings (list, register, transfer); returns `{ jobId }` immediately |
+| `POST` | `/api/device/pull` | Sync specific recordings, body `{ ids }` (1-100); returns `{ jobId }` |
+| `POST` | `/api/device/cancel` | Stop the running sync (cooperative; wireless transfer restores the network first) |
+| `POST` | `/api/device/cleanup` | Delete already-synced, size-verified recordings from the recorder; returns `{ jobId }` |
+| `GET` | `/api/diagnostics` | Diagnostics data: environment, recent recorder operations, transport setting and measured speeds, device protocol reference, Host capabilities |
+| `GET` | `/api/environment` | Environment check report and repair task state |
+| `POST` | `/api/environment/check` | Re-run the environment check |
+| `POST` | `/api/environment/repair` | Ask the Floatboat assistant to repair the environment |
+| `GET` | `/api/environment/capabilities` | Host ASR/LLM operation availability |
 | `GET` | `/api/live` | Live caption status |
-| `POST` | `/api/live/start`, `/api/live/stop` | Start or stop live captions |
+| `POST` | `/api/live/start`, `/api/live/stop` | Start or stop live captions; returns `DEVICE_BUSY` while the recorder is syncing |
+| `GET`, `POST` | `/api/calendar/events` | List events in a time range, or create an event |
+| `GET` | `/api/calendar/events/:id` | One event |
+| `GET` | `/api/calendar/events/:id/recordings`, `/api/calendar/recordings` | Recordings linked to an event, or recordings in a time range |
+| `GET`, `POST` | `/api/calendar/events/:id/digest` | Read or generate an event's meeting digest |
+| `POST` | `/api/calendar/digest` | Generate a daily digest |
+| `POST` | `/api/calendar/import` | Import an `.ics` file |
+| `GET` | `/api/recordings/:id/calendar-suggestions` | Suggest events to link based on the recording time |
 | `GET`, `POST` | `/api/categories` | List or create categories |
 | `PATCH`, `DELETE` | `/api/categories/:id` | Update or delete a category |
 | `GET`, `PATCH` | `/api/settings` | Read settings or update the writable keys listed above |
 
-JSON responses use the `{ ok: true, data }` / `{ ok: false, error: string, code: string }` envelope. The audio endpoint returns an audio stream on success.
+JSON responses use the `{ ok: true, data }` / `{ ok: false, error, code, detail?, action? }` envelope: `error` is a one-sentence Chinese conclusion, `detail` holds the technical text (shown only under "view details"), and `action` is an optional link to the next step. Node system errors are mapped by errno to Chinese messages (no permission, disk full, file moved). The audio endpoint returns an audio stream on success. Online operations return `NETWORK_PAUSED` during wireless fast transfer.
 
 ### Queued tasks and polling
 
@@ -206,7 +258,10 @@ JSON responses use the `{ ok: true, data }` / `{ ok: false, error: string, code:
 
 ## Design principles
 
-- Report failures honestly. If BLE is not ready, audio cannot play, or upstream ASR fails, the UI reports the problem and offers a next action.
+- One entry point per feature. Connect, disconnect, sync, and cleanup live only on the Recorder page; import only in the Recordings header; recording-event links only on the Calendar page; paths only in Settings. Other pages only link there.
+- Two-layer errors. The main UI shows a Chinese conclusion and a next step; technical detail appears only under "view details", with the full log in Settings › Diagnostics & advanced.
+- Background work never changes the network. Wireless fast transfer runs only for manual syncs, or in the background when `auto_pull_wifi` is enabled.
+- Report failures honestly. If the recorder component is not ready, audio cannot play, or upstream ASR fails, the UI reports the problem and offers a next action.
 - Communicate status with both text and color, never color alone. Animations respect `prefers-reduced-motion`.
 - Prioritize lists. Each recording occupies one row, content is at most 1220 px wide, and table numbers use `tabular-nums` for alignment.
 - Support accessibility. Icon-only buttons have `aria-label` and `title`; segmented controls use `aria-pressed`.
@@ -215,7 +270,11 @@ See [DESIGN.md](DESIGN.md) for more design decisions.
 
 ## Related repositories
 
-- [`floatboatai/memotalk-sdk`](https://github.com/floatboatai/memotalk-sdk): Python BLE client and CLI for the MemoTalk S1
+- [`floatboatai/memotalk-sdk`](https://github.com/floatboatai/memotalk-sdk): Python client (Bluetooth, Wi-Fi hotspot, and FTP) and CLI for the MemoTalk S1
+
+## Community
+
+Hardware details for MemoTalk S1 are shared in the Floatboat official WeChat community group — scan the QR code in [README.zh-CN.md](README.zh-CN.md#加入-floatboat-官方交流群).
 
 ## License
 
diff --git a/README.zh-CN.md b/README.zh-CN.md
index a5cff76..14b036a 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -16,26 +16,41 @@
 
 ### OpenMinutes 工作台
 
-![OpenMinutes 录音概览，展示设备状态、录音统计、分类分布和最近入库记录](docs/images/openminutes-workbench.png)
+![OpenMinutes 工作台界面](docs/images/openminutes-workbench.png)
 
 ## 它解决什么问题
 
 录音笔的典型困境：素材每天在增长，但你听不回去、也找不回来。
 
-这个工作台把「导入 → 转录 → 归类 → 检索」做成一条闭环流水线，每条录音在列表上都有明确阶段标签（待拉取 / 待转录 / 转录已排队 / 转录中 / 待归类 / 归类已排队 / 归类中 / 已归档 / 失败），批量操作按勾选的录音执行。
+这个工作台把「同步 → 转录 → 归类 → 检索」做成一条闭环流水线，每条录音在列表上都有明确阶段标签（在录音笔中 / 待转录 / 转录已排队 / 转录中 / 待归类 / 归类已排队 / 归类中 / 已整理 / 失败），批量操作按勾选的录音或当前阶段的全部录音执行。
 
 ## 功能
 
-| 能力 | 说明 |
+左侧导航固定 6 项，每个功能只有一个入口，页面标题与导航名称一致：
+
+| 导航 | 拥有的功能 |
 | --- | --- |
-| 三种接入入口 | 目录扫描导入、设备文件清单登记、BLE 直连拉取（依赖本机 Python + `bleak` + 真实设备） |
-| 流式转录 | `ffmpeg` 解码为 16 kHz 单声道 PCM16，经 Host ASR 流式识别，落库全文与分段时间轴 |
-| AI 归类 | Host LLM 结构化输出标题、摘要、分类、标签、要点、待办、重要度，并支持人工修正 |
-| 检索复盘 | 全文搜索（正文 + 标题 + 摘要）、分类/标签/阶段筛选、时间排序、批量处理 |
-| 详情播放 | HTTP Range 分段播放、按句时标跳转，转录全文、AI 结论与执行记录分区展示 |
-| 分类管理 | 新增、就地改名、改色、删除自定义分类；内置分类不能删除 |
-| 设备接入页 | 环境自检（Python / `bleak` / SDK / `ffmpeg`）、导入目录设置、SDK 指令参考库、手动登记 |
-| 实时字幕 | 设备音频流经 Host ASR 实时识别，停止后保存录音及已有转录文本 |
+| 录音（默认页） | 统计条（点「失败 N」直接筛出失败录音）、全文搜索（正文 + 标题 + 摘要）、阶段/分类/标签筛选与排序、勾选批量或「全部转录（N）/ 全部归类（N）」、页头「导入」对话框扫描本地文件夹。点开一条进入详情：HTTP Range 播放、按句时标跳转、转录全文 / AI 结论 / 处理记录分区、人工修正、导出与删除；页头只有一个随状态切换的主按钮 |
+| 录音笔 | 连接 / 断开连接、电量与剩余空间、同步录音（带进度与「停止」）、「还在录音笔里」列表与单条同步、清理已同步的录音（释放录音笔空间）、自动连接状态。连接时自动校时 |
+| 实时字幕 | 录音笔音频流经 Floatboat 语音识别实时出字，停止后保存录音及已有文本 |
+| 日历 | 按日查看事件与录音、录音与日程的关联（唯一入口）、新建事件、导入 `.ics`、生成会议纪要 |
+| 分类 | 新增、就地改名、改色、删除自定义分类（内置分类不能删除），每个分类显示条数与总时长 |
+| 设置 | 通用（目录）/ 自动化 / 识别 / 诊断与高级。「诊断与高级」是唯一的技术细节区：本机环境自检与「让 Floatboat 助手修复」、Python/ffmpeg 路径、传输方式、最近设备操作、宿主能力、设备协议指令参考与开发者工具 |
+
+转录用 `ffmpeg` 解码为 16 kHz 单声道 PCM16，经 Host ASR 流式识别，落库全文与分段时间轴；AI 归类由 Host LLM 结构化输出标题、摘要、分类、标签、要点、待办和重要度。
+
+出错时主界面只显示一句中文结论和下一步；技术原文（异常类型、退出码、宿主错误码等）要点「查看详情」才展开，也可以在「设置 › 诊断与高级」里查看完整记录。
+
+### 录音笔传输
+
+- 用户手动同步时，本批待同步总量 ≥ 1 MiB（或含大小未知的录音）就默认走录音笔的**无线快传**（Wi-Fi 热点 + FTP），否则走蓝牙。按钮下方会提示「期间电脑会暂时断开外网」。
+- 无线快传期间电脑临时连上录音笔热点、断开外网：进行中的转录/归类先完成（最多等 3 分钟，超时本批改走蓝牙），新的 AI 任务自动排队，日历纪要等需要联网的操作暂时返回「请稍后再试」；完成后自动连回原网络，并关闭录音笔热点。
+- 无线快传在任何阶段失败都会自动改用蓝牙继续，界面只提示一行「已改用蓝牙」，原因在「查看详情」里。
+- 录音笔正在录音时不会开始同步。下载结果与录音笔上报的大小一致才入库。
+- 后台自动同步默认不切网：只用蓝牙同步小于 1 MiB 的录音（每轮最多 3 条），大录音留给手动同步；可在「设置 › 自动化」开启「后台自动同步大录音时也用无线快传」。
+- 固定传输方式（自动 / 始终无线快传 / 始终蓝牙）在「设置 › 诊断与高级」中设置。
+- 用户手动连接的会话空闲 10 分钟自动断开以节省录音笔电量；自动连接建立的会话用完即断。手动「断开连接」后自动连接暂停，直到再次点「连接」。
+- 平台要求：Windows 需要无线网卡（使用系统自带的 `netsh`）；macOS 需要 Wi-Fi；Linux 需要 NetworkManager（`nmcli`）。macOS 与 Linux 为实验性支持，失败时自动回退蓝牙。
 
 ## 快速上手
 
@@ -56,11 +71,11 @@ pnpm install          # 安装 UI 依赖、类型定义和测试工具
 | 依赖 | 用途 | 缺失时行为 |
 | --- | --- | --- |
 | `ffmpeg` | 音频探测与解码 | 转录不可用，页面如实提示 |
-| `python` + `bleak` + `memotalk-sdk` | BLE 拉取设备录音 | 设备页报告「未就绪」，目录导入路径仍可用 |
+| `python` + `bleak` + `memotalk-sdk` | 连接录音笔、同步录音与实时字幕 | 录音笔页提示「录音笔组件还没准备好」并链接到诊断区，本地文件夹导入仍可用 |
 
 工具路径按「设置值 → Floatboat 内置工具 → `PATH` → 命令名」逐级探测，不仅依赖进程 `PATH`。
 
-在设备页查看实际使用的 Python 解释器，将 SDK 安装到同一个环境：
+在「设置 › 诊断与高级 › 本机环境」查看实际使用的 Python 解释器，将设备 SDK 安装到同一个环境：
 
 ```bash
 uv pip install --python "/path/to/python" "memotalk-sdk>=0.1.0"
@@ -72,11 +87,13 @@ SDK 会自动安装 `bleak`；无需克隆 SDK 源码或配置 SDK 目录。
 应用通过 `from memotalk import MemoTalkClient` 调用设备 API 和实时音频流。
 升级时会清理旧的 `sdk_dir` 配置，其余路径、识别与自动化设置保留。
 
-### SDK 回归验证
+硬件参数与固件问题，请加入文末的 Floatboat 官方交流群。
+
+### 设备 SDK 回归验证
 
-`pnpm test` 运行服务端测试。SDK 集成测试使用包内模拟设备，不连接真实录音笔；
+`pnpm test` 运行服务端测试。设备 SDK 集成测试用包内模拟设备驱动设备 worker（连接、清单、蓝牙与无线快传、取消、网络恢复），不连接真实录音笔，也不调用真实的 `netsh` / `nmcli` / `networksetup`；
 设置环境变量 `MEMOTALK_TEST_PYTHON` 为安装了 `memotalk-sdk` 的解释器路径后运行。
-未设置时跳过 SDK 集成用例，设置接口与迁移测试仍会执行。
+未设置时跳过这些用例，设置接口与迁移测试仍会执行。
 
 ### CI
 
@@ -93,33 +110,43 @@ Floatboat 编译器构建、浏览器验收、真实 BLE 设备和付费 ASR/LLM
 
 ```text
 src/
-  contracts/       跨端 DTO（app.ts）、输入校验（input.ts）、忙碌状态（recording-status.ts）
+  contracts/       跨端 DTO（app.ts、device.ts、calendar.ts、preflight.ts）、错误模型（errors.ts）、输入校验（input.ts）、忙碌状态（recording-status.ts）
   server/          Node 服务端：装配、路由、领域逻辑
-    index.ts       服务装配与自动重连启动
+    index.ts       服务装配：设备服务、自动连接调度、路由注册
     routes/        按领域拆分的 HTTP 路由
-    app-route.ts   应用信息、概览与标签列表路由
-    http.ts        统一 API 信封与顶层 error/code 映射
+    app-route.ts   应用信息、统计与标签列表路由
+    http.ts        统一 API 信封；AppError / 系统错误 → 中文 error + code + detail
     sql.ts         node:sqlite 薄封装、设置读写、任务记录
     repo.ts        读取查询、临时排队状态投影与全库 hasActiveTasks
     library.ts     录音库根目录、月目录与历史音频路径解析
-    ingest.ts      目录扫描、清单登记、去重与命名冲突处理
-    pull.ts        BLE 下载暂存、挂接入库与待拉取文件处理
-    auto-connect.ts 后台设备探测与可选的自动拉取
+    ingest.ts      目录扫描、清单登记、下载文件挂接、去重与命名冲突处理
+    device/        设备 SDK（memotalk-sdk）的唯一所有者
+      service.ts     连接状态机、单一互斥、空闲断开、实时字幕占用、诊断记录
+      sync.ts        同步编排（清单 → 登记 → 传输 → 大小校验 → 入库）与清理已同步
+      transport.ts   传输规划（无线快传 / 蓝牙）与无线网卡探测
+      worker.ts      常驻 Python worker 的派生与 JSON-lines RPC
+      worker-script.ts worker 的 Python 源码：连接、清单、同步、删除、入网与网络恢复
+      errors.ts      设备 SDK 异常 → 中文错误码
+      auto-connect.ts 自动连接调度器（用完即断，手动断开后暂停）
+      fake-device.ts 假录音笔（仅测试，设置 OPENMINUTES_FAKE_DEVICE 时加载）
+    network-gate.ts 无线快传期间的网络闸门：暂停 AI 任务、队列外调用快速失败
     media.ts       ffmpeg 探测、时长解析、PCM16 分帧
     transcribe.ts  Host ASR 会话：参数降级、推流、续传、错误归类
     organize.ts    Host LLM 结构化归类与文本回退
     pipeline.ts    转录/归类状态机与重试
-    jobs.ts        任务调度与导入/拉取后的自动转录
+    jobs.ts        任务调度与导入/同步后的自动转录
     queue.ts       串行执行、等待/运行中任务标签与任务状态查询
-    bridge.ts      memotalk-sdk Python API 桥接（固定参数，不接受拼接命令）
-    sdk-script.ts  SDK 状态、清单、下载操作的 Python 脚本
-    live.ts        实时音频采集、文件落盘与会话保存
+    calendar*.ts   日历事件、.ics 导入、录音关联与会议纪要
+    preflight.ts   本机环境自检与宿主能力清单
+    environment-repair.ts, repair-store.ts 让 Floatboat 助手修复本机环境
+    runtime-probe.ts, tools.ts, paths.ts Python / bleak / 设备 SDK / ffmpeg 探测与路径
+    live.ts        实时字幕会话、文件落盘与保存（采集进程由设备服务派生）
     live-audio.ts  实时 MP3 解码参数与按秒分帧的 PCM 流
     live-asr.ts    按需开启的实时 ASR 会话与推流
-    live-script.ts SDK 实时音频流的 Python 脚本
-  ui/              React 界面：概览 / 录音库 / 详情 / 设备 / 分类 / 实时 / 设置
-migrations/        只追加的 SQLite 迁移
-sdk/               Host 提供的 Workbench 运行时、客户端、契约与类型
+    live-script.ts 设备 SDK 实时音频流的 Python 脚本
+  ui/              React 界面：录音 / 详情 / 录音笔 / 实时字幕 / 日历 / 分类 / 设置（含诊断与高级）
+migrations/        只追加的 SQLite 迁移（0001–0007）
+sdk/               宿主 SDK：Host 提供的 Workbench 运行时、客户端、契约与类型（不改动）
 tests/             服务端测试
 manifest.json      Host 入口、构建配置、能力与 audio 资源声明
 index.html         UI 构建入口
@@ -129,13 +156,15 @@ index.html         UI 构建入口
 
 ## 数据模型
 
-`devices`、`recordings`、`transcripts`、`analyses`、`categories`、`tags`、`recording_tags`、`job_runs`、`sdk_commands`、`settings`。
+`devices`、`recordings`、`transcripts`、`analyses`、`categories`、`tags`、`recording_tags`、`job_runs`、`sdk_commands`、`settings`、`calendar_events`、`environment_repairs`。
+
+转录/归类失败分三列存储：`recordings.last_error`（中文结论）、`last_error_code`、`last_error_detail`（技术原文）。`devices.ble_address` 记住上次连接的录音笔，下次连接优先找它，不需要手填序列号。
 
 ### 存储与目录
 
 - `import_dir` 是扫描来源，也是默认音频导出目录，默认值为 `~/memo/memotalk/inbox`。扫描会创建缺失的目录，只读取当前层文件，将支持的音频（`.mp3`、`.wav`、`.m4a`、`.aac`、`.ogg`、`.flac`、`.amr`、`.opus`）复制进录音库，保留原文件。
-- `library_dir` 默认为 `~/memo/memotalk/raw`。目录导入与 BLE 拉取均复制到 `<library_dir>/<yyyy-MM>/`，月份按文件名推断的录制时间或兜底时间确定。实时录音也写入月目录。这些目录设置请使用绝对路径或 `~/...`；修改录音库设置不会迁移已有文件。
-- 新版 `recordings.storage_path` 保存完整目标路径（默认目录或绝对路径配置下为绝对路径）。历史相对文件名仍从 Host 的 `audio` 数据资源解析。BLE 下载先暂存到 Host 的 `audio/_incoming`，不是 `import_dir`。
+- `library_dir` 默认为 `~/memo/memotalk/raw`。目录导入与录音笔同步均复制到 `<library_dir>/<yyyy-MM>/`，月份按文件名推断的录制时间或兜底时间确定。实时录音也写入月目录。这些目录设置请使用绝对路径或 `~/...`；修改录音库设置不会迁移已有文件。
+- 新版 `recordings.storage_path` 保存完整目标路径（默认目录或绝对路径配置下为绝对路径）。历史相对文件名仍从 Host 的 `audio` 数据资源解析。录音笔同步先暂存到 Host 的 `audio/_incoming/<任务 ID>/`（每次同步一个独立目录，完成后删除），不是 `import_dir`。
 - 删除时先尝试把音频移动到**当前**录音库设置下的 `<library_dir>/_trash/<毫秒时间戳>-<原存储文件名>`，再删除录音及其转录、分析、标签关联和任务历史。移动失败仍会删除数据库记录，此时 `audioMovedToTrash` 为 `null`。目前没有恢复 API。
 - 导出按原始 `filename` 将音频复制到 `import_dir`，也可由请求体的 `directory` 指定目标目录。缺失的目标目录会自动创建，同名文件可能被覆盖。详情页使用默认目标，没有独立的导出目录设置。
 
@@ -143,55 +172,78 @@ index.html         UI 构建入口
 
 ## 设置
 
-设置页编辑路径、自动化与识别选项，设备页只编辑 `import_dir`。`PATCH /api/settings` 接收 `{ "values": { "key": "value" } }`，所有值必须是字符串。
+设置页分四个分区，所有路径只在这里编辑：
+
+| 分区 | 内容 |
+| --- | --- |
+| 通用 | `library_dir`、`import_dir` |
+| 自动化 | `auto_transcribe`、`auto_analyze`、`auto_connect`、`auto_connect_minutes`、`auto_pull`（连上录音笔后自动同步新录音）、`auto_pull_wifi`（后台自动同步大录音时也用无线快传） |
+| 识别 | `speaker_diarization`、`asr_hotwords`、`asr_language` |
+| 诊断与高级（`#/settings/diagnostics`，默认折叠） | 本机环境、`python_path` / `ffmpeg_path`、`device_transport`、最近设备操作、宿主能力、设备协议指令参考、开发者工具（手动登记清单）、复制诊断报告 |
+
+`PATCH /api/settings` 接收 `{ "values": { "key": "value" } }`，所有值必须是字符串。
 
 | 设置键 | 行为与默认值 |
 | --- | --- |
 | `library_dir`, `import_dir` | 默认空值，按上文规则解析；各最多 500 字符 |
 | `python_path`, `ffmpeg_path` | 默认空值，自动探测；各最多 500 字符 |
-| `auto_transcribe`, `auto_analyze` | 导入/拉取后自动转录、转录后自动归类；均默认 `"1"` |
-| `auto_connect`, `auto_pull` | 后台探测设备、自动连接成功后下载待拉取文件；均默认 `"1"` |
+| `auto_transcribe`, `auto_analyze` | 导入/同步后自动转录、转录后自动归类；均默认 `"1"` |
+| `auto_connect`, `auto_pull` | 后台按间隔自动连接录音笔；连上后自动同步新录音（手动点「连接」也会直接开始同步）；均默认 `"1"` |
+| `auto_pull_wifi` | 后台自动同步时是否允许无线快传（会暂时断开外网），默认 `"0"` |
+| `device_transport` | `auto`（默认）/ `wifi` / `ble`，固定传输方式 |
 | `auto_connect_minutes` | `"1"` 到 `"120"` 的整数字符串，默认 `"3"` |
 | `speaker_diarization` | 文件转录的说话人分离，默认 `"1"` |
 | `asr_hotwords` | 文件转录热词，默认空值，最多 300 字符 |
 | `asr_language` | 最多 20 字符；界面提供自动（空值）、`zh`、`en`、`ja`。目前只写入文件转录的结果元数据，未传给 ASR |
-| `device_serial` | 最多 64 字符；由设备操作或 API 保存，不是设置页字段 |
 
-开关只接受 `"0"` 或 `"1"`。后台探测在工作台服务运行期间执行；手动读取设备状态不会触发自动拉取。实时 ASR 当前使用固定 PCM 参数，不读取文件转录的热词、语言或说话人设置。`GET /api/settings` 还可能返回运行时写入的 `last_auto_connect_at`、`last_auto_pull_at`，这两项不能通过 PATCH 修改。已移除的 `sdk_dir` 在读取时隐藏、写入时忽略，其他未知键会被拒绝。
+开关只接受 `"0"` 或 `"1"`。后台自动连接在工作台服务运行期间执行，用完即断开。实时 ASR 当前使用固定 PCM 参数，不读取文件转录的热词、语言或说话人设置。`GET /api/settings` 还可能返回运行时写入的 `device_serial`、`device_user_disconnected`、`last_auto_connect_at`、`last_auto_pull_at`，这些键不能通过 PATCH 修改（`device_user_disconnected` 只由「断开连接」写入、由「连接」清除）。已移除的 `sdk_dir` 在读取时隐藏、写入时忽略，其他未知键会被拒绝。
 
 ## API 速览
 
 | 方法 | 路径 | 说明 |
 | --- | --- | --- |
 | `GET` | `/api/app` | 应用名称与版本 |
-| `GET` | `/api/overview` | 录音统计、设备状态与概览数据 |
+| `GET` | `/api/overview` | 录音统计（总数、时长、待转录、失败、在录音笔中 `pendingCount`）与按分类的条数/时长 `byCategory` |
 | `GET` | `/api/tags` | 用于筛选的标签名称列表 |
 | `GET` | `/api/recordings` | 列表：搜索 / 阶段 / 分类 / 标签 / 收藏 / 归档筛选 / 排序 / 分页；data 含 `items`、`total` 和全库 `hasActiveTasks` |
-| `GET` | `/api/recordings/:id` | 详情（元数据 + 转录 + AI 结论 + 执行记录） |
+| `GET` | `/api/recordings/:id` | 详情（元数据 + 转录 + AI 结论 + 处理记录） |
 | `GET` | `/api/recordings/:id/tags` | 单条录音的标签 ID 与名称 |
-| `PATCH` | `/api/recordings/:id` | 人工修正标题、摘要、分类、标签、重要度、收藏与归档标记 |
+| `PATCH` | `/api/recordings/:id` | 人工修正标题、摘要、分类、标签、重要度、收藏与归档标记；`calendarEventId`（正整数或 `null`）是录音与日程关联的唯一写接口 |
 | `DELETE` | `/api/recordings/:id` | 删除录音，尝试将音频移入 `<library_dir>/_trash/<毫秒时间戳>-<原存储文件名>` |
 | `GET` | `/api/recordings/:id/audio` | 音频流，HTTP Range（206 + `content-range`，越界 416） |
 | `POST` | `/api/recordings/:id/export` | 默认复制音频到 `import_dir`，可用请求体字段 `directory` 覆盖目标目录 |
 | `POST` | `/api/recordings/:id/transcribe` | 排队转录；前置条件校验后，已排队/执行中的录音返回 `BUSY` |
 | `POST` | `/api/recordings/:id/organize` | 排队 AI 归类；前置条件校验后，已排队/执行中的录音返回 `BUSY` |
-| `POST` | `/api/recordings/batch/transcribe`, `/api/recordings/batch/organize` | 按请求体 `ids` 排队转录或归类，跳过已排队/执行中及其他不符合条件的录音 |
+| `POST` | `/api/recordings/batch/transcribe`, `/api/recordings/batch/organize` | 按请求体 `ids` 排队转录或归类；或传 `{ stage: "ready" }` / `{ stage: "transcribed" }` 由服务端选出该阶段的全部录音（上限 400）。跳过已排队/执行中及其他不符合条件的录音 |
 | `GET` | `/api/ingest/directory` | 读取导入目录信息 |
-| `POST` | `/api/ingest/directory/ensure` | 创建导入目录 |
-| `POST` | `/api/ingest/scan` | 扫描导入目录 |
-| `POST` | `/api/ingest/manifest` | 登记设备清单条目 |
-| `GET` | `/api/device` | 环境自检、SDK 指令参考库、Host 能力摘要、设备记录与设置 |
-| `GET` | `/api/device/summary` | 设备/本地录音数及设备/分类数 |
-| `GET` | `/api/device/capabilities` | Host ASR/LLM 操作的可用性，不是 BLE 指令 |
-| `DELETE` | `/api/device/:id` | 删除本机设备记录并清空匹配的已存序列号，不删除录音或设备文件 |
-| `POST` | `/api/device/check`, `/api/device/list`, `/api/device/download`, `/api/device/status` | 环境自检、读清单、BLE 拉取、状态 |
+| `POST` | `/api/ingest/scan` | 扫描导入目录（目录不存在时自动创建） |
+| `POST` | `/api/ingest/manifest` | 手动登记录音笔清单条目（只供诊断区开发者工具使用） |
+| `GET` | `/api/device` | 录音笔视图：连接状态、电量与空间、同步进度、上次结果、还在录音笔里的录音、可清理数量、自动连接状态。只读内存与缓存，不派生探测进程 |
+| `POST` | `/api/device/connect` | 连接录音笔并自动校时；`auto_pull` 开启时随即开始同步。返回录音笔视图 |
+| `POST` | `/api/device/disconnect` | 断开连接并暂停自动连接，直到再次连接 |
+| `POST` | `/api/device/sync` | 同步全部新录音（读清单、登记、传输），立即返回 `{ jobId }` |
+| `POST` | `/api/device/pull` | 同步指定录音，请求体 `{ ids }`（1–100 个），返回 `{ jobId }` |
+| `POST` | `/api/device/cancel` | 停止进行中的同步（协作式取消，无线快传会先恢复网络） |
+| `POST` | `/api/device/cleanup` | 从录音笔删除已同步且大小一致的录音，返回 `{ jobId }` |
+| `GET` | `/api/diagnostics` | 诊断区数据：本机环境、最近设备操作、传输方式与实测速度、设备协议指令参考、宿主能力 |
+| `GET` | `/api/environment` | 本机环境自检结果与修复任务状态 |
+| `POST` | `/api/environment/check` | 重新检测本机环境 |
+| `POST` | `/api/environment/repair` | 让 Floatboat 助手修复本机环境 |
+| `GET` | `/api/environment/capabilities` | 宿主 ASR/LLM 操作的可用性 |
 | `GET` | `/api/live` | 实时字幕状态 |
-| `POST` | `/api/live/start`, `/api/live/stop` | 开始或停止实时字幕 |
+| `POST` | `/api/live/start`, `/api/live/stop` | 开始或停止实时字幕；录音笔同步中返回 `DEVICE_BUSY` |
+| `GET`, `POST` | `/api/calendar/events` | 按时间范围列出事件，或新建事件 |
+| `GET` | `/api/calendar/events/:id` | 单个事件 |
+| `GET` | `/api/calendar/events/:id/recordings`, `/api/calendar/recordings` | 某事件关联的录音，或时间范围内的录音 |
+| `GET`, `POST` | `/api/calendar/events/:id/digest` | 读取或生成单个事件的会议纪要 |
+| `POST` | `/api/calendar/digest` | 生成某一天的日报 |
+| `POST` | `/api/calendar/import` | 导入 `.ics` 文件 |
+| `GET` | `/api/recordings/:id/calendar-suggestions` | 按录音时间推荐可关联的事件 |
 | `GET`, `POST` | `/api/categories` | 列出或新增分类 |
 | `PATCH`, `DELETE` | `/api/categories/:id` | 修改或删除分类 |
 | `GET`, `PATCH` | `/api/settings` | 读取设置，或修改上文列出的可写设置键 |
 
-JSON 响应统一为 `{ ok: true, data }` / `{ ok: false, error: string, code: string }` 信封。音频接口成功时返回音频流。
+JSON 响应统一为 `{ ok: true, data }` / `{ ok: false, error, code, detail?, action? }` 信封：`error` 是一句中文结论，`detail` 是技术原文（只在「查看详情」中显示），`action` 是可选的跳转建议。Node 系统错误按 errno 映射为中文（例如没有权限、磁盘空间不足、文件已被移走）。音频接口成功时返回音频流。无线快传期间需要联网的操作返回 `NETWORK_PAUSED`。
 
 ### 排队任务与轮询
 
@@ -203,7 +255,10 @@ JSON 响应统一为 `{ ok: true, data }` / `{ ok: false, error: string, code: s
 
 ## 设计原则（节选）
 
-- **不伪造成功**：BLE 通道未就绪、音频无法播放、ASR 上游失败，页面一律如实报告，并把失败态变成可继续的动作。
+- **一个功能一个入口**：连接、断开、同步、清理只在「录音笔」页；导入只在「录音」页头；录音与日程的关联只在「日历」页；路径只在「设置」。其他页面只放跳转链接。
+- **错误分两层**：主界面只给一句中文结论和下一步，技术原文点「查看详情」才出现，完整记录在「设置 › 诊断与高级」。
+- **后台不切网**：后台任务不改变本机网络；只有用户手动同步，或显式开启 `auto_pull_wifi`，才会走无线快传。
+- **不伪造成功**：录音笔组件未就绪、音频无法播放、ASR 上游失败，页面一律如实报告，并把失败态变成可继续的动作。
 - **状态双编码**：一律「文字 + 颜色」，不只靠颜色区分；动画尊重 `prefers-reduced-motion`。
 - **列表优先**：一条录音一行，正文最大宽度 1220 px，表格数字使用 `tabular-nums` 保持纵向对齐。
 - **可访问**：仅图标按钮均带 `aria-label` 与 `title`，分段控件用 `aria-pressed`。
@@ -212,7 +267,13 @@ JSON 响应统一为 `{ ok: true, data }` / `{ ok: false, error: string, code: s
 
 ## 相关仓库
 
-- [`floatboatai/memotalk-sdk`](https://github.com/floatboatai/memotalk-sdk)：MemoTalk S1 的 Python BLE 客户端与命令行工具
+- [`floatboatai/memotalk-sdk`](https://github.com/floatboatai/memotalk-sdk)：MemoTalk S1 的 Python 客户端（蓝牙、Wi-Fi 热点与 FTP）与命令行工具
+
+## 加入 Floatboat 官方交流群
+
+微信扫码（手机上可长按识别二维码）加入 Floatboat 官方交流群，获取 MemoTalk S1 录音笔的硬件详细信息、固件说明与使用支持。群满 200 人会自动创建新群，二维码长期有效；加群遇到问题可在 Floatboat 公众号后台留言。
+
+<img src="docs/images/floatboat-wechat-group.png" alt="Floatboat 官方交流群二维码" width="280">
 
 ## 许可证
 
diff --git a/REQUIREMENTS.md b/REQUIREMENTS.md
index 992b2cb..c783673 100644
--- a/REQUIREMENTS.md
+++ b/REQUIREMENTS.md
@@ -3,15 +3,19 @@
 MemoTalk S1 录音笔的录音资产管理中枢。把录音笔采集的 MP3 录音导入本地后，完成「转录 → AI 归类 → 检索复盘」的闭环。
 
 业务主流程：
-1) 接入：三种入口。a) 目录导入：扫描 `import_dir` 当前层的音频文件（MP3、WAV、M4A、AAC、OGG、FLAC、AMR、OPUS），复制到 `<library_dir>/<yyyy-MM>/` 并登记，保留来源文件；b) 设备清单：粘贴/录入设备 0x13 文件列表条目（文件名、格式、时间戳、大小、时长秒）登记为待导入；c) 设备拉取：调用用户本机配置的 Python 和从 PyPI 安装的 memotalk-sdk 执行 BLE 拉取，先下载到 Host 的 `audio/_incoming` 再复制进录音库月目录（需自检 Python、bleak 和 memotalk 包导入，缺失时如实报告未就绪，不得伪造成功）。
+1) 接入：每个功能只有一个入口。a) 录音笔同步（「录音笔」页）：调用用户本机配置的 Python 和从 PyPI 安装的设备 SDK（memotalk-sdk），由设备服务持有唯一的录音笔会话。点「连接」后自动校时，并在开启自动同步时直接同步（读清单、登记、传输）。用户手动同步时大录音默认走录音笔无线快传（Wi-Fi 热点 + FTP，期间电脑暂时断开外网），失败自动改用蓝牙；后台自动同步默认不切网。下载先暂存到 Host 的 `audio/_incoming/<任务 ID>/`，大小与设备上报一致才复制进录音库月目录。同一页提供断开连接、停止同步、单条同步、清理已同步的录音（只删已入库且大小一致的文件）。需自检 Python、bleak 和 memotalk 包导入，缺失时如实报告未就绪，不得伪造成功。b) 本地文件夹导入（「录音」页头「导入」对话框）：扫描 `import_dir` 当前层的音频文件（MP3、WAV、M4A、AAC、OGG、FLAC、AMR、OPUS），复制到 `<library_dir>/<yyyy-MM>/` 并登记，保留来源文件。c) 手动登记设备 0x13 文件列表条目只作为开发者工具，放在「设置 › 诊断与高级」。
 2) 转录：用 ffmpeg 把 MP3 解码为 16kHz 单声道 PCM16，通过 Host ASR 流式识别，落库完整文本与分段；记录字节数与耗时，失败保留可重试状态。
 3) 归类：调用 Host LLM 结构化输出，生成标题、摘要、分类、标签、要点、待办事项、重要度，写回录音记录并支持用户手工修正。
-4) 检索：列表支持全文搜索（转录文本+标题+摘要）、分类筛选、标签筛选、状态筛选、时间排序；详情页展示元数据、转录全文、AI 结论、操作历史。
-5) 设备页：展示初始种子中的 24 条 BLE 指令参考库、环境自检结果、导入目录设置、连接状态与待拉取录音。没有 SDK 源码路径设置；Python 与 ffmpeg 路径在设置页编辑。
-6) 实时字幕：从设备接收实时音频并识别，停止后有音频或文本时保存录音；音频写入录音库月目录，已有文本可按自动归类开关继续处理。
-7) 设置：录音库/导入目录、Python/ffmpeg 路径，自动转录、自动归类、自动重连、自动拉取、说话人分离开关，1~120 分钟重连间隔（默认 3），热词与语言。开关默认启用。当前语言只写入文件转录结果元数据，未传给 ASR；实时识别不读取这些热词、语言与说话人设置。具体 API 与可写键见 README。
+4) 检索：「录音」页支持全文搜索（转录文本+标题+摘要）、分类筛选、标签筛选、状态筛选、时间排序；详情页展示元数据、转录全文、AI 结论、处理记录，页头只有一个随状态切换的主按钮。
+5) 录音笔页：只展示用户需要的状态与动作（连接/断开、电量与空间、同步进度、还在录音笔里的录音、自动连接状态），不出现协议、传输与命令细节。初始种子中的 24 条设备协议指令参考、环境自检结果、最近设备操作只在「设置 › 诊断与高级」。没有 SDK 源码路径设置；Python 与 ffmpeg 路径在诊断区编辑。
+6) 实时字幕：从录音笔接收实时音频并识别，停止后有音频或文本时保存录音；音频写入录音库月目录，已有文本可按自动归类开关继续处理。录音笔同步中不能开始实时字幕。
+7) 日历：按日查看事件与录音，录音与日程的关联只在日历页完成；新建事件、导入 .ics、生成会议纪要。
+8) 设置：通用（录音库/导入目录）、自动化（自动转录、自动归类、自动连接及 1~120 分钟间隔（默认 3）、连上后自动同步、后台无线快传（默认关））、识别（说话人分离、热词与语言）、诊断与高级（本机环境与修复、Python/ffmpeg 路径、传输方式、设备操作记录、宿主能力、协议指令参考、开发者工具）。当前语言只写入文件转录结果元数据，未传给 ASR；实时识别不读取这些热词、语言与说话人设置。具体 API 与可写键见 README。
+9) 错误：主界面只显示一句中文结论与下一步，技术原文只在点击「查看详情」后或诊断区中出现。
 
-持久化对象：devices、recordings、transcripts、analyses、categories、tags、recording_tags、job_runs、sdk_commands、settings。全部使用正式 SQLite 迁移建表，分类与 SDK 指令做种子数据。
+待评估：录音笔设置（休眠时长、最长录音、U 盘模式）。设备 SDK 已支持，本次不接入，录音笔页不增加设置项。
+
+持久化对象：devices、recordings、transcripts、analyses、categories、tags、recording_tags、job_runs、sdk_commands、settings、calendar_events、environment_repairs。全部使用正式 SQLite 迁移建表，分类与 SDK 指令做种子数据。
 
 任务反馈以当前实现为准：
 - 服务端将内存队列临时投影为 `queued_transcribe`（转录已排队）/ `queued_organize`（归类已排队），不落库；执行中的数据库状态优先。代码依据：`src/server/queue.ts:25`、`src/server/repo.ts:59`。
diff --git a/docs/images/floatboat-wechat-group.png b/docs/images/floatboat-wechat-group.png
new file mode 100644
index 0000000..d7620c5
Binary files /dev/null and b/docs/images/floatboat-wechat-group.png differ
diff --git a/migrations/0007_device_service.sql b/migrations/0007_device_service.sql
new file mode 100644
index 0000000..fb0c3bf
--- /dev/null
+++ b/migrations/0007_device_service.sql
@@ -0,0 +1,6 @@
+-- 设备服务：失败原因分层存储；记住录音笔 BLE 地址；传输方式与后台无线快传；用户手动断开后暂停自动连接。
+ALTER TABLE recordings ADD COLUMN last_error_code TEXT;
+ALTER TABLE recordings ADD COLUMN last_error_detail TEXT;
+ALTER TABLE devices ADD COLUMN ble_address TEXT;
+INSERT OR IGNORE INTO settings (key, value) VALUES
+  ('device_transport', 'auto'), ('auto_pull_wifi', '0'), ('device_user_disconnected', '0');
diff --git a/scripts/verify-calendar.mjs b/scripts/verify-calendar.mjs
index 8efb186..9fe9f08 100644
--- a/scripts/verify-calendar.mjs
+++ b/scripts/verify-calendar.mjs
@@ -40,7 +40,7 @@ const upload = `(() => {
   return input.accept;
 })()`;
 browse('calendar-import', [
-  { goto: '#/calendar' }, { waitText: '日历视图' },
+  { goto: '#/calendar' }, { waitText: '导入日历' },
   { screenshot: '01-before-import.png' }, { eval: upload },
   { waitText: '已导入 4 个日历事件' },
   { waitText: '产品项目评审' }, { screenshot: '02-calendar-main.png' },
@@ -53,11 +53,11 @@ assert.ok(event);
 command('ffmpeg', ['-hide_banner', '-loglevel', 'error', '-f', 'lavfi', '-i', 'sine=frequency=440:duration=6',
   '-ar', '16000', '-ac', '1', '-b:a', '32k', join(run.dirs.inbox, 'REC20261029_101500.mp3')]);
 browse('calendar-audio-import', [
-  { goto: '#/library' }, { click: 'text=导入新录音' },
+  { goto: '#/library' }, { waitFor: 'aria=搜索录音' }, { click: 'text=导入' },
   { waitText: '1 个音频文件' }, { screenshot: 'before-scan.png' },
-  { click: 'text=立即扫描' },
-  { waitText: '导入 1 个文件，跳过 0 个，失败 0 个', timeout: 15000 },
-  { screenshot: 'after-scan.png' },
+  { click: 'text=扫描并导入' },
+  { waitText: '已导入 1 条', timeout: 15000 },
+  { screenshot: 'after-scan.png' }, { click: 'text=关闭' },
 ]);
 const library = await readback('/api/recordings', 'recordings-imported.json');
 assert.equal(library.total, 1);
@@ -68,25 +68,31 @@ assert.ok(readdirSync(join(run.dirs.library, '2026-10')).some((name) => name.end
 const suggestions = await readback(`/api/recordings/${recording.id}/calendar-suggestions`, 'suggestions.json');
 assert.equal(suggestions[0].event.id, event.id);
 browse('calendar-suggestions', [
-  { goto: `#/rec/${recording.id}` }, { waitText: `建议关联到：${event.summary}` },
+  // 详情页只读：关联只能在日历页的 EventLinker 里做。
+  { goto: `#/rec/${recording.id}` }, { waitText: '在日历中关联' },
+  { click: 'text=在日历中关联' }, { waitText: `关联到：${event.summary}` },
+  { eval: `(() => { if (!location.hash.includes('rec=${recording.id}') || !location.hash.includes('day=2026-10-29')) throw Error('calendar context missing: ' + location.hash); const rows = document.querySelectorAll('.calendar-recording').length; const linkers = document.querySelectorAll('.calendar-recording .eventlinker').length; const stray = [...document.querySelectorAll('.calendar-recording select')].filter((el) => !el.closest('.eventlinker')).length; if (!rows || rows !== linkers || stray) throw Error('expected exactly one link control per recording'); return { rows, linkers }; })()` },
   { screenshot: '03-recording-suggestion.png' }, { aria: 'recording-suggestion.aria.txt' },
-  { click: `text=建议关联到：${event.summary}` }, { waitText: '录音关联已更新' },
+  { click: `text=关联到：${event.summary}` }, { waitText: '已关联日程' },
   { waitText: '解除关联' }, { screenshot: '04-suggested-link.png' },
   { click: 'text=解除关联' }, { waitText: '已解除关联' },
 ]);
 assert.equal((await readback(`/api/recordings/${recording.id}`, 'unlinked-recording.json')).recording.calendarEventId, null);
 browse('calendar-manual-link', [
-  { goto: '#/calendar' },
-  { fill: 'aria=日历截止日期', value: '2026-10-29' },
+  { goto: '#/calendar?day=2026-10-29' },
   { waitText: recording.filename },
   { screenshot: '05-before-link.png' },
-  { select: `aria=关联事件：${recording.filename}`, value: String(event.id) },
-  { waitText: '录音关联已更新' }, { waitText: '已关联事件' },
+  { click: '.eventlinker__toggle' },
+  { select: `aria=选择其他事件：${recording.filename}`, value: String(event.id) },
+  { waitText: '已关联日程' }, { waitText: `已关联：${event.summary}` },
+  // 从日历进入详情：详情页只读显示日程，返回后回到日历的同一天。
+  { click: '.calendar-recording-button' }, { waitText: '返回日历' }, { waitText: event.summary },
+  { expectText: '在日历中修改' }, { screenshot: '07-recording-detail.png' },
+  { click: 'text=返回日历' }, { waitText: recording.filename },
+  { eval: `(() => { if (!location.hash.startsWith('#/calendar') || !location.hash.includes('day=2026-10-29')) throw Error('did not return to calendar day: ' + location.hash); return location.hash; })()` },
   { click: 'details[open] .calendar-event:nth-of-type(2)' }, { waitText: '生成事件纪要' },
   { waitText: recording.filename }, { screenshot: '06-event-associated.png' },
-  { click: '.calendar-recording-button' }, { waitText: '尚无转录文本' },
-  { screenshot: '07-recording-detail.png' },
-  { click: 'text=生成事件纪要' }, { waitText: 'LLM 不可用' },
+  { click: 'text=生成事件纪要' }, { waitText: 'AI 整理暂不可用' },
   { screenshot: '08-digest-result.png' }, { aria: 'digest-result.aria.txt' },
 ]);
 assert.equal((await readback(`/api/recordings/${recording.id}`, 'linked-recording.json')).recording.calendarEventId, event.id);
diff --git a/src/contracts/app.ts b/src/contracts/app.ts
index 285d59a..fbeba04 100644
--- a/src/contracts/app.ts
+++ b/src/contracts/app.ts
@@ -1,5 +1,9 @@
 // ABOUTME: 页面与服务端共用的录音业务契约；页面只依赖本文件的类型。
 
+import type { AppErrorView } from './errors';
+
+export type { ParsedDeviceFile } from './device';
+
 export type RecordingStatus =
   | 'pending'
   | 'ready'
@@ -106,6 +110,9 @@ export interface RecordingDetail {
   analysis: AnalysisRecord | null;
   jobs: JobRun[];
   lastError: string | null;
+  /** 失败原因分层：code 供页面判断，detail 只在「查看详情」里显示。 */
+  lastErrorCode: string | null;
+  lastErrorDetail: string | null;
   storagePath: string | null;
 }
 
@@ -128,18 +135,7 @@ export interface LiveState {
   partial: string;
   deviceName: string | null;
   lastSaved: { recordingId: number; filePath: string; chars: number } | null;
-}
-
-export interface DeviceHero {
-  serial: string;
-  model: string;
-  firmware: string | null;
-  batteryPct: number | null;
-  freeSpacePct: number | null;
-  lastSeenAt: string | null;
-  connected: boolean;
-  pendingPulls: number;
-  readyToTranscribe: number;
+  error: AppErrorView | null;
 }
 
 export interface Overview {
@@ -154,7 +150,6 @@ export interface Overview {
   byCategory: Array<{ id: number; name: string; color: string; count: number; durationSec: number }>;
   byStatus: Array<{ status: RecordingStatus; count: number }>;
   recent: RecordingSummary[];
-  device: DeviceHero | null;
 }
 
 export interface SettingEntry {
@@ -186,59 +181,6 @@ export interface SdkCommand {
   caution: boolean;
 }
 
-export interface CapabilityState {
-  domain: string;
-  ok: boolean;
-  detail: string;
-}
-
-export interface DeviceState {
-  env: DeviceEnv;
-  commands: SdkCommand[];
-  capabilities: CapabilityState[];
-  devices: Array<{
-    id: number;
-    serial: string;
-    model: string;
-    firmware: string | null;
-    batteryPct: number | null;
-    freeSpacePct: number | null;
-    lastSeenAt: string | null;
-  }>;
-  settings: SettingEntry[];
-}
-
-export interface DeviceStatus {
-  serial: string | null;
-  mac: string | null;
-  firmware: string | null;
-  batteryPct: number | null;
-  freeSpacePct: number | null;
-  storageFormat: string | null;
-  recordingState: string | null;
-  hotspotSsid: string | null;
-}
-
-export interface BridgeRunResult {
-  ok: boolean;
-  action: string;
-  command: string;
-  exitCode: number | null;
-  stdout: string;
-  stderr: string;
-  parsedFiles: ParsedDeviceFile[];
-  parsedStatus: DeviceStatus | null;
-  message: string;
-}
-
-export interface ParsedDeviceFile {
-  name: string;
-  format: string;
-  sizeBytes: number | null;
-  durationSec: number | null;
-  timestamp: number | null;
-}
-
 export interface ImportDirectoryState {
   /** 实际生效的目录：未配置时是默认收件目录 */
   directory: string;
@@ -251,7 +193,7 @@ export interface ImportDirectoryState {
   resetFrom: string | null;
   /** 目录里前几个音频文件名，供空态提示展示 */
   sample: string[];
-  /** 本次调用是否新建了目录（仅 directory/ensure 返回） */
+  /** 本次调用是否新建了目录 */
   created?: boolean;
 }
 
@@ -260,7 +202,7 @@ export interface IngestScanResult {
   skipped: number;
   failed: number;
   ids: number[];
-  files: Array<{ filename: string; outcome: 'imported' | 'skipped' | 'failed'; reason?: string }>;
+  files: Array<{ filename: string; outcome: 'imported' | 'skipped' | 'failed'; reason?: string; detail?: string }>;
   /** 实际扫描的目录 */
   directory: string;
   /** 扫描前目录不存在，已自动创建 */
diff --git a/src/contracts/device.ts b/src/contracts/device.ts
new file mode 100644
index 0000000..3d7bd24
--- /dev/null
+++ b/src/contracts/device.ts
@@ -0,0 +1,149 @@
+// ABOUTME: 录音笔设备服务契约：连接状态、同步活动、诊断记录，页面与服务端共用。
+
+import type { AppErrorView } from './errors';
+import type { PreflightReport } from './preflight';
+import type { SdkCommand } from './app';
+
+export type DeviceConnectionState = 'disconnected' | 'connecting' | 'connected' | 'busy' | 'live';
+export type Transport = 'wifi' | 'ble';
+export type TransportSetting = 'auto' | 'wifi' | 'ble';
+export type DisconnectReason = 'user' | 'idle' | 'auto-done' | 'device_sleep' | 'lost' | 'live';
+export type DeviceOrigin = 'user' | 'auto';
+export type DeviceActivityKind = 'sync' | 'pull' | 'cleanup';
+export type DeviceActivityPhase =
+  | 'connecting'
+  | 'listing'
+  | 'waiting-network'
+  | 'preparing'
+  | 'transferring'
+  | 'restoring'
+  | 'finishing'
+  | 'deleting';
+
+/** 设备 0x13 清单里的一条文件。 */
+export interface ParsedDeviceFile {
+  name: string;
+  format: string;
+  sizeBytes: number | null;
+  durationSec: number | null;
+  timestamp: number | null;
+}
+
+export interface DeviceInfo {
+  serial: string;
+  model: string;
+  firmware: string | null;
+  batteryPct: number | null;
+  freeSpacePct: number | null;
+  lastSeenAt: string | null;
+}
+
+export interface DeviceActivity {
+  jobId: string;
+  kind: DeviceActivityKind;
+  phase: DeviceActivityPhase;
+  transport: Transport | null;
+  file: string | null;
+  index: number;
+  count: number;
+  bytesDone: number;
+  bytesTotal: number | null;
+  startedAt: string;
+  offline: boolean;
+  fallback: AppErrorView | null;
+  cancelling: boolean;
+}
+
+export interface DeviceRecordingOnDevice {
+  id: number;
+  filename: string;
+  sizeBytes: number | null;
+  durationSec: number | null;
+  recordedAt: string | null;
+}
+
+export interface DeviceLastResult {
+  jobId: string;
+  kind: DeviceActivityKind;
+  origin: DeviceOrigin;
+  done: number;
+  failed: number;
+  deferred: number;
+  transport: Transport | null;
+  fallback: AppErrorView | null;
+  error: AppErrorView | null;
+  cancelled: boolean;
+  finishedAt: string;
+}
+
+export interface DeviceView {
+  connection: {
+    state: DeviceConnectionState;
+    origin: DeviceOrigin | null;
+    userDisconnected: boolean;
+    disconnectReason: DisconnectReason | null;
+    since: string | null;
+    idleDisconnectAt: string | null;
+  };
+  device: DeviceInfo | null;
+  activity: DeviceActivity | null;
+  lastResult: DeviceLastResult | null;
+  onDevice: DeviceRecordingOnDevice[];
+  /** 用于按钮下方的一行提示。 */
+  syncPlan: { transport: Transport; willGoOffline: boolean } | null;
+  /** 单条同步达到这个字节数时走无线快传、暂时断开外网；null 表示不会走无线快传。 */
+  wifiFromBytes: number | null;
+  /** 本次连接内列过清单后才有值。 */
+  cleanable: { count: number; bytes: number } | null;
+  autoConnect: {
+    enabled: boolean;
+    intervalMinutes: number;
+    nextAttemptAt: string | null;
+    lastRunAt: string | null;
+    backgroundWifi: boolean;
+    /** 「连上后自动同步」：用户点「连接」时会直接同步。 */
+    syncOnConnect: boolean;
+  };
+  lastError: AppErrorView | null;
+  environment: { failCount: number };
+}
+
+export type DeviceOp = 'connect' | 'status' | 'list' | 'pull' | 'delete' | 'disconnect' | 'cancel' | 'live';
+
+export interface DeviceCallRecord {
+  at: string;
+  op: DeviceOp;
+  origin: DeviceOrigin;
+  ok: boolean;
+  code: string | null;
+  transport: Transport | null;
+  bytes: number | null;
+  durationMs: number;
+  detail: string;
+}
+
+export interface HostCapability {
+  operation: string;
+  status: string;
+  declared: boolean;
+}
+
+export interface HostCapabilities {
+  asr: HostCapability[];
+  llm: HostCapability[];
+}
+
+export interface DiagnosticsView {
+  environment: PreflightReport;
+  /** 最近 50 条，内存环形缓冲。 */
+  deviceLog: DeviceCallRecord[];
+  transport: {
+    setting: TransportSetting;
+    wifiCapable: boolean;
+    platform: string;
+    thresholdBytes: number;
+    measured: { wifiBps: number | null; bleBps: number | null };
+  };
+  commands: SdkCommand[];
+  capabilities: HostCapabilities;
+}
diff --git a/src/contracts/errors.ts b/src/contracts/errors.ts
new file mode 100644
index 0000000..5eeb0c7
--- /dev/null
+++ b/src/contracts/errors.ts
@@ -0,0 +1,73 @@
+// ABOUTME: 页面与服务端共用的错误模型：一句中文结论 + 可选技术详情 + 可选跳转动作。
+
+export interface ErrorAction {
+  label: string;
+  href: string;
+}
+
+export interface AppErrorView {
+  code: string;
+  message: string;
+  detail?: string;
+  action?: ErrorAction;
+}
+
+export const DIAGNOSTICS_ACTION: ErrorAction = { label: '去诊断与修复', href: '#/settings/diagnostics' };
+
+/** code → 默认中文文案；抛错处没有给 message 时使用。 */
+export const ERROR_COPY: Record<string, { message: string; action?: ErrorAction }> = {
+  DEVICE_NOT_FOUND: { message: '没有找到录音笔。请按一下录音笔按键唤醒，放在电脑旁边后重试。' },
+  DEVICE_DISCONNECTED: { message: '和录音笔的连接断开了，可能已休眠或离开范围。' },
+  DEVICE_TIMEOUT: { message: '录音笔没有及时响应，请稍后重试。' },
+  DEVICE_BUSY: { message: '录音笔正在同步或用于实时字幕，请等它结束后再试。' },
+  DEVICE_RECORDING: { message: '录音笔正在录音，停止录音后再同步。' },
+  BLUETOOTH_UNAVAILABLE: { message: '电脑的蓝牙不可用，请打开蓝牙后重试。' },
+  RUNTIME_MISSING: { message: '录音笔组件还没准备好。', action: DIAGNOSTICS_ACTION },
+  FILE_NOT_ON_DEVICE: { message: '录音笔里已经没有这条录音。' },
+  TRANSFER_FAILED: { message: '同步中断了，已同步的录音不受影响，可以重试。' },
+  DELETE_FAILED: { message: '有录音没能从录音笔删除，可以稍后重试。' },
+  DEVICE_ERROR: { message: '录音笔操作没有完成，请重试。' },
+  WIFI_FALLBACK: { message: '无线快传不可用，已改用蓝牙（较慢）。' },
+  NETWORK_PAUSED: { message: '录音笔正在无线快传，电脑暂时断开了外网，完成后再试。' },
+  ASR_START_FAILED: { message: '语音识别暂时不可用，请确认已在 Floatboat 登录并开启语音识别。' },
+  ASR_UNSTABLE: { message: '识别服务连接不稳定，进度已保存，可以稍后重试。' },
+  ASR_EMPTY: { message: '没有识别到可用的语音内容，请确认录音里有人声。' },
+  DECODE_FAILED: { message: '音频文件无法读取，可能已损坏。' },
+  LLM_UNAVAILABLE: { message: 'AI 整理暂不可用，请在 Floatboat 中登录并选择模型。' },
+  LLM_INCOMPLETE: { message: 'AI 整理没有完成，请重试。' },
+  NO_PERMISSION: { message: '没有这个文件夹的读写权限，请在设置里换一个文件夹。', action: { label: '去设置', href: '#/settings' } },
+  DISK_FULL: { message: '磁盘空间不足。' },
+  FILE_MOVED: { message: '文件已被移走或删除。' },
+  INTERNAL_ERROR: { message: '操作没有完成，请重试。' },
+  HTTP_ERROR: { message: '应用服务暂时没有响应，请稍后重试。' },
+  BAD_RESPONSE: { message: '应用服务返回了异常数据，请刷新页面。' },
+};
+
+export class AppError extends Error {
+  readonly code: string;
+  readonly detail?: string;
+  readonly action?: ErrorAction;
+  readonly retryable: boolean;
+
+  constructor(code: string, message?: string, detail?: string, action?: ErrorAction, retryable = true) {
+    super(message ?? ERROR_COPY[code]?.message ?? ERROR_COPY.INTERNAL_ERROR.message);
+    this.name = 'AppError';
+    this.code = code;
+    this.detail = detail;
+    this.action = action ?? ERROR_COPY[code]?.action;
+    this.retryable = retryable;
+  }
+
+  toView(): AppErrorView {
+    return {
+      code: this.code,
+      message: this.message,
+      ...(this.detail ? { detail: this.detail } : {}),
+      ...(this.action ? { action: this.action } : {}),
+    };
+  }
+}
+
+export function errorView(code: string, detail?: string, message?: string): AppErrorView {
+  return new AppError(code, message, detail).toView();
+}
diff --git a/src/contracts/preflight.ts b/src/contracts/preflight.ts
index fdc74b8..3832313 100644
--- a/src/contracts/preflight.ts
+++ b/src/contracts/preflight.ts
@@ -1,8 +1,15 @@
+export type PreflightGroup = 'device' | 'audio' | 'ai' | 'storage';
+
 export interface PreflightItem {
   id: string;
   label: string;
+  /** 展示分组：录音笔组件 / 音频处理 / 语音识别与 AI 整理 / 存储目录。 */
+  group: PreflightGroup;
   status: 'ok' | 'warn' | 'fail';
+  /** 一句中文结论。 */
   reason: string;
+  /** 技术原文（探测输出、uv 命令、平台说明），只在「查看详情」里显示。 */
+  detail?: string;
   autoRepair: boolean;
   action: string;
 }
diff --git a/src/server/auto-connect.ts b/src/server/auto-connect.ts
deleted file mode 100644
index d65f8f5..0000000
--- a/src/server/auto-connect.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-// ABOUTME: 自动重连：按间隔静默探测录音笔，读到状态就更新设备与首页。
-
-import type { WorkbenchServer } from '../../sdk/runtime.mjs';
-import { isSdkBusy, runSdkAction } from './bridge';
-import { upsertDevice } from './ingest';
-import { pullPending } from './pull';
-import { nowIso, readSetting, row, str, writeSetting } from './sql';
-
-let timer: NodeJS.Timeout | null = null;
-let nextAttemptAt = 0;
-let running = false;
-
-const TICK_MS = 30_000;
-
-export function startAutoConnect(app: WorkbenchServer): void {
-  if (timer) return;
-  timer = setInterval(() => {
-    void tick(app);
-  }, TICK_MS);
-  timer.unref?.();
-}
-
-export function stopAutoConnect(): void {
-  if (!timer) return;
-  clearInterval(timer);
-  timer = null;
-}
-
-async function tick(app: WorkbenchServer): Promise<void> {
-  if (running || isSdkBusy()) return;
-  if (readSetting(app.database, 'auto_connect', '1') !== '1') return;
-
-  const intervalMinutes = Number(readSetting(app.database, 'auto_connect_minutes', '3')) || 3;
-  if (Date.now() < nextAttemptAt) return;
-  nextAttemptAt = Date.now() + intervalMinutes * 60_000;
-
-  // 已经有新鲜状态时不做无谓的无线电连接。
-  const newest = row(
-    app.database,
-    'SELECT last_seen_at FROM devices ORDER BY COALESCE(last_seen_at, created_at) DESC LIMIT 1',
-  );
-  const lastSeenAt = newest ? str(newest.last_seen_at) : null;
-  const fresh =
-    lastSeenAt !== null && Date.now() - new Date(lastSeenAt).getTime() < (intervalMinutes - 1) * 60_000;
-  if (fresh) return;
-
-  running = true;
-  try {
-    const outcome = await runSdkAction(app.database, 'status', {}, 45_000);
-    const device = outcome.result.parsedStatus;
-    if (!device?.serial) return; // 设备休眠/不在范围内：保持静默，下一轮再试
-    upsertDevice(app.database, device.serial, {
-      firmware: device.firmware,
-      storageFormat: device.storageFormat,
-      batteryPct: device.batteryPct,
-      freeSpacePct: device.freeSpacePct,
-    });
-    writeSetting(app.database, 'device_serial', device.serial);
-    writeSetting(app.database, 'last_auto_connect_at', nowIso());
-
-    if (readSetting(app.database, 'auto_pull', '1') === '1') {
-      const pulled = await pullPending(app, { maxFiles: 3, budgetMs: 150_000 });
-      if (pulled.pulled > 0 || pulled.registered > 0) {
-        writeSetting(app.database, 'last_auto_pull_at', nowIso());
-      }
-    }
-  } catch {
-    // 自动探测不写入错误状态，避免把偶发失败显示成故障
-  } finally {
-    running = false;
-  }
-}
diff --git a/src/server/bridge.ts b/src/server/bridge.ts
deleted file mode 100644
index 6192dac..0000000
--- a/src/server/bridge.ts
+++ /dev/null
@@ -1,223 +0,0 @@
-// ABOUTME: 录音笔 SDK 桥接：探测 Python/bleak/ffmpeg/SDK，并以固定参数调用 SDK 命令行。
-
-import { spawn } from 'node:child_process';
-import type { DatabaseSync } from 'node:sqlite';
-import type { BridgeRunResult, DeviceEnv, DeviceStatus, EnvProbe, ParsedDeviceFile } from '../contracts/app';
-import { terminateChild } from './media';
-import { findFfmpeg, probePython, probeBleak, probeSdk, pythonRuntimeEnv as pythonEnvFor } from './tools';
-export { pythonCandidates, ffmpegCandidates, userSiteDir, pythonRuntimeEnv, probePython, probeBleak, probeSdk } from './tools';
-import { nowIso, readSetting } from './sql';
-import { SDK_ACTION_SCRIPT } from './sdk-script';
-
-export async function resolveFfmpeg(db: DatabaseSync): Promise<string | null> {
-  return findFfmpeg(readSetting(db, 'ffmpeg_path'));
-}
-
-function textField(stdout: string, key: string): string | null {
-  for (const line of stdout.split(/\r?\n/)) {
-    if (!line.includes(key)) continue;
-    const index = Math.max(line.indexOf(':'), line.indexOf('：'));
-    if (index < 0) continue;
-    const value = line.slice(index + 1).trim();
-    if (value) return value;
-  }
-  return null;
-}
-
-function firstNumber(value: string | null): number | null {
-  if (!value) return null;
-  const matched = /(\d+)/.exec(value);
-  return matched ? Number(matched[1]) : null;
-}
-
-/** 解析 SDK `--action status` 输出的设备体检报告。 */
-export function parseStatus(stdout: string): DeviceStatus | null {
-  const serial = textField(stdout, '设备序列号');
-  const battery = textField(stdout, '当前电量');
-  const freeSpace = textField(stdout, '剩余存储空间');
-  if (!serial && !battery && !freeSpace) return null;
-  const firmwareRaw = textField(stdout, '固件版本号');
-  const versionMatch = firmwareRaw ? /\(([^)]+)\)/.exec(firmwareRaw) : null;
-  return {
-    serial,
-    mac: textField(stdout, '蓝牙 MAC'),
-    firmware: versionMatch ? versionMatch[1] : firmwareRaw,
-    batteryPct: firstNumber(battery),
-    freeSpacePct: firstNumber(freeSpace),
-    storageFormat: textField(stdout, '存储音频格式'),
-    recordingState: textField(stdout, '当前录音状态'),
-    hotspotSsid: textField(stdout, '热点 SSID'),
-  };
-}
-
-export async function probeEnvironment(db: DatabaseSync): Promise<DeviceEnv> {
-  const { probe: python, command } = await probePython(readSetting(db, 'python_path'));
-  const bleak = await probeBleak(command);
-  const sdk = await probeSdk(command);
-  const ffmpegPath = await resolveFfmpeg(db);
-  const ffmpeg: EnvProbe = ffmpegPath
-    ? { ok: true, detail: ffmpegPath, resolvedPath: ffmpegPath }
-    : { ok: false, detail: '未找到 ffmpeg，可在设置中填写绝对路径', resolvedPath: null };
-  return { python, ffmpeg, bleak, sdk, checkedAt: nowIso() };
-}
-
-export type SdkAction = 'status' | 'list' | 'download';
-
-let sdkBusy = false;
-
-/** 是否有 SDK 调用在进行中；自动重连据此避让。 */
-export function isSdkBusy(): boolean {
-  return sdkBusy;
-}
-
-export interface SdkRunOptions {
-  file?: string;
-  outDir?: string;
-}
-
-export interface BridgeOutcome {
-  result: BridgeRunResult;
-  serial: string | null;
-}
-
-/** SDK 命令行走的是打印式输出，失败原因通常写在 [X] / [!] 开头的行里。 */
-function sdkFailureHint(stdout: string): string | null {
-  const line = stdout
-    .split(/\r?\n/)
-    .map((item) => item.trim())
-    .find((item) => item.startsWith('[X]') || item.startsWith('[!]'));
-  return line ? line.replace(/^\[[Xx!]\]\s*/, '') : null;
-}
-
-function parseFileLines(stdout: string): ParsedDeviceFile[] {
-  const files: ParsedDeviceFile[] = [];
-  const line = /^\s*\d+\.\s+(.+?)\s*\|\s*格式=([^\s|]+)\s*\|\s*大小=([\d,]+)\s*B\s*\|\s*时长=(\d+)s\s*\|\s*时间戳=(\d+)\s*$/gm;
-  for (const match of stdout.matchAll(line)) {
-    const [, name, format, size, duration, timestamp] = match;
-    files.push({
-      name: name.trim(),
-      format,
-      sizeBytes: Number(size.replace(/,/g, '')) || null,
-      durationSec: Number(duration) || null,
-      timestamp: Number(timestamp) || null,
-    });
-  }
-  return files;
-}
-
-function parseSerial(stdout: string): string | null {
-  const patterns = [/SN[:\s=]+([A-Za-z0-9-]{4,32})/i, /序列号[:\s=]+([A-Za-z0-9-]{4,32})/];
-  for (const pattern of patterns) {
-    const matched = pattern.exec(stdout);
-    if (matched?.[1]) return matched[1];
-  }
-  return null;
-}
-
-/** 按固定参数运行 SDK 命令行；不接受用户拼接的任意命令。 */
-export async function runSdkAction(
-  db: DatabaseSync,
-  action: SdkAction,
-  options: SdkRunOptions = {},
-  timeoutMs = 90000,
-): Promise<BridgeOutcome> {
-  const env = await probeEnvironment(db);
-  const pythonCommand = env.python.resolvedPath;
-  const commandLabel = `MemoTalkClient: ${action}${action === 'download' ? ` (${options.file ?? ''} -> ${options.outDir ?? ''})` : ''}`;
-
-  if (!pythonCommand || !env.sdk.ok || !env.bleak.ok) {
-    const message = !pythonCommand
-      ? '缺少可用的 Python 解释器，无法调用 SDK。'
-      : `当前 Python 的 memotalk-sdk 或 bleak 依赖不可用。请执行：uv pip install --python "${pythonCommand}" memotalk-sdk`;
-    return {
-      result: {
-        ok: false,
-        action,
-        command: commandLabel,
-        exitCode: null,
-        stdout: '',
-        stderr: '',
-        parsedFiles: [],
-        parsedStatus: null,
-        message,
-      },
-      serial: null,
-    };
-  }
-
-  const pythonEnv = await pythonEnvFor(pythonCommand);
-  const callArgs =
-    action === 'download'
-      ? ['-X', 'utf8', '-c', SDK_ACTION_SCRIPT, '--action', action, '--file', options.file ?? '', '--out-dir', options.outDir ?? '']
-      : ['-X', 'utf8', '-c', SDK_ACTION_SCRIPT, '--action', action];
-
-  sdkBusy = true;
-  const outcome = await new Promise<{ code: number | null; stdout: string; stderr: string }>((resolve) => {
-    let stdout = '';
-    let stderr = '';
-    let settled = false;
-    const child = spawn(pythonCommand, callArgs, {
-      windowsHide: true,
-      ...(pythonEnv ? { env: pythonEnv } : {}),
-    });
-    child.stdin.end();
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      terminateChild(child);
-      resolve({ code: null, stdout, stderr: `${stderr}\n[超时] SDK 调用超过 ${timeoutMs}ms` });
-    }, timeoutMs);
-    child.stdout?.on('data', (chunk: Buffer) => {
-      if (stdout.length < 400000) stdout += chunk.toString('utf8');
-    });
-    child.stderr?.on('data', (chunk: Buffer) => {
-      if (stderr.length < 400000) stderr += chunk.toString('utf8');
-    });
-    child.on('error', (error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve({ code: null, stdout, stderr: `${stderr}\n${error.message}` });
-    });
-    child.on('close', (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve({ code, stdout, stderr });
-    });
-  }).finally(() => {
-    sdkBusy = false;
-  });
-
-  const parsedFiles = parseFileLines(outcome.stdout);
-  const parsedStatus = parseStatus(outcome.stdout);
-  const crashed = /ModuleNotFoundError|Traceback/.test(`${outcome.stdout}${outcome.stderr}`);
-  const ok = outcome.code === 0 && !crashed;
-  const hint = sdkFailureHint(`${outcome.stdout}\n${outcome.stderr}`);
-  const message = crashed
-    ? 'SDK 运行失败，请检查 Python 依赖（bleak）与设备连接状态。'
-    : ok
-      ? action === 'status'
-        ? `已连接设备${parsedStatus?.serial ? `：${parsedStatus.serial}` : ''}`
-        : action === 'download'
-        ? 'SDK 下载流程已结束，请查看下方输出确认结果。'
-        : parsedFiles.length > 0
-          ? `已读取 ${parsedFiles.length} 条设备文件记录。`
-          : 'SDK 调用完成，但设备没有返回录音文件。'
-      : hint ?? `SDK 调用未成功（退出码 ${outcome.code ?? '未知'}）。`;
-
-  return {
-    result: {
-      ok,
-      action,
-      command: commandLabel,
-      exitCode: outcome.code,
-      stdout: outcome.stdout.slice(-20000),
-      stderr: outcome.stderr.slice(-8000),
-      parsedFiles,
-      parsedStatus,
-      message,
-    },
-    serial: parsedStatus?.serial ?? parseSerial(outcome.stdout) ?? readSetting(db, 'device_serial') ?? null,
-  };
-}
diff --git a/src/server/calendar-digest.ts b/src/server/calendar-digest.ts
index 050773b..78935d6 100644
--- a/src/server/calendar-digest.ts
+++ b/src/server/calendar-digest.ts
@@ -1,6 +1,8 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { HostClient } from '../../sdk/host.mjs';
 import type { CalendarEvent } from '../contracts/calendar';
+import { AppError } from '../contracts/errors';
+import { networkGate } from './network-gate';
 import { calendarRecordings, getCalendarEvent, listCalendarEvents } from './calendar';
 import { row, strOr, run } from './sql';
 
@@ -41,13 +43,14 @@ async function generateText(host: DigestHost, prompt: string, compact = false):
     const result = await host.llm.generateText({
       system: SYSTEM, prompt, temperature: 0.2, maxOutputTokens: compact ? 1800 : 6000,
     }, { timeoutMs: 120000 });
-    if (result.finishReason === 'length') throw new Error('LLM 输出被截断，请缩小整理范围后重试');
-    if (!result.text?.trim()) throw new Error('LLM 返回了空内容，请重试');
+    if (result.finishReason === 'length') throw new AppError('LLM_INCOMPLETE', 'AI 整理的内容过长被截断，请缩小整理范围后重试。', 'finishReason=length');
+    if (!result.text?.trim()) throw new AppError('LLM_INCOMPLETE', 'AI 整理返回了空内容，请重试。', `finishReason=${result.finishReason ?? '-'}`);
     return result.text.trim();
   } catch (error) {
+    if (error instanceof AppError) throw error;
     if (error && typeof error === 'object' && 'code' in error &&
         typeof error.code === 'string' && /HOST|CAPABILITY|ACCOUNT|LLM/.test(error.code)) {
-      throw Object.assign(new Error('LLM 不可用，请在 Floatboat 中连接 Host 并配置模型后重试'), { code: error.code });
+      throw new AppError('LLM_UNAVAILABLE', undefined, `${error.code}: ${error instanceof Error ? error.message : String(error)}`);
     }
     throw error;
   }
@@ -64,7 +67,7 @@ async function condense(host: DigestHost, text: string, label: string): Promise<
       ].join('\n'), true));
     }
     const next = parts.join('\n\n');
-    if (next.length >= current.length) throw new Error('LLM 未能压缩长文本，请缩小整理范围后重试');
+    if (next.length >= current.length) throw new AppError('LLM_INCOMPLETE', 'AI 整理未能压缩长文本，请缩小整理范围后重试。');
     current = next;
   }
   if (current.length > 10000) throw new Error('资料过长，请减少关联录音后重试');
@@ -109,6 +112,7 @@ async function exclusive<T>(db: DatabaseSync, key: string, task: () => Promise<T
 }
 
 export function generateEventDigest(db: DatabaseSync, host: DigestHost, id: number): Promise<{ digest: string }> {
+  networkGate.assertOnline();
   return exclusive(db, `event:${id}`, async () => {
     const event = getCalendarEvent(db, id);
     const recordings = digestRecordings(db, { eventId: id });
@@ -123,6 +127,7 @@ export function generateEventDigest(db: DatabaseSync, host: DigestHost, id: numb
 }
 
 export function generateDayDigest(db: DatabaseSync, host: DigestHost, start: string, end: string, day: string): Promise<{ digest: string }> {
+  networkGate.assertOnline();
   return exclusive(db, `day:${day}`, async () => {
     const events = listCalendarEvents(db, new Date(Date.parse(start) - 86400000).toISOString(), new Date(Date.parse(end) + 86400000).toISOString())
       .filter((event) => event.allDay ? event.startTime.slice(0, 10) <= day && event.endTime.slice(0, 10) > day : event.startTime < end && event.endTime > start);
diff --git a/src/server/device/auto-connect.ts b/src/server/device/auto-connect.ts
new file mode 100644
index 0000000..e6a8290
--- /dev/null
+++ b/src/server/device/auto-connect.ts
@@ -0,0 +1,63 @@
+// ABOUTME: 自动连接调度器：按间隔连上录音笔，按设置后台同步，用完即断；用户手动断开后暂停。
+
+import type { DatabaseSync } from 'node:sqlite';
+import { nowIso, readSetting, writeSetting } from '../sql';
+import type { DeviceService } from './service';
+
+const TICK_MS = 30_000;
+
+export interface AutoConnectDeps {
+  db: DatabaseSync;
+  service: Pick<DeviceService, 'view' | 'connect' | 'sync' | 'disconnect' | 'setNextAttempt'>;
+  now?: () => number;
+}
+
+/** 单轮调度；返回是否真的尝试了连接（测试用）。 */
+export async function autoConnectTick(deps: AutoConnectDeps, state: { nextAttemptAt: number; running: boolean }): Promise<boolean> {
+  const now = deps.now ?? Date.now;
+  if (state.running) return false;
+  if (readSetting(deps.db, 'auto_connect', '1') !== '1') return false;
+  if (readSetting(deps.db, 'device_user_disconnected', '0') === '1') return false;
+  const view = deps.service.view();
+  if (view.connection.state !== 'disconnected') return false;
+  if (now() < state.nextAttemptAt) return false;
+
+  const intervalMinutes = Number(readSetting(deps.db, 'auto_connect_minutes', '3')) || 3;
+  state.nextAttemptAt = now() + intervalMinutes * 60_000;
+  deps.service.setNextAttempt(state.nextAttemptAt);
+  state.running = true;
+  try {
+    await deps.service.connect({ origin: 'auto' });
+    writeSetting(deps.db, 'last_auto_connect_at', nowIso());
+    // 连接期间用户点了连接/同步：会话已归用户，后台不再同步，也不断开。
+    if (!backgroundOwned(deps)) return true;
+    if (readSetting(deps.db, 'auto_pull', '1') === '1') {
+      // 同步结束后服务会以 auto-done 自行断开。
+      const outcome = await deps.service.sync({ origin: 'auto' });
+      if (outcome.done > 0) writeSetting(deps.db, 'last_auto_pull_at', nowIso());
+    } else {
+      await deps.service.disconnect({ reason: 'auto-done' });
+    }
+  } catch {
+    // 录音笔休眠或不在范围内是常态：保持静默，下一轮再试。
+    if (deps.service.view().connection.state === 'connected' && backgroundOwned(deps)) {
+      await deps.service.disconnect({ reason: 'auto-done' }).catch(() => undefined);
+    }
+  } finally {
+    state.running = false;
+  }
+  return true;
+}
+
+function backgroundOwned(deps: AutoConnectDeps): boolean {
+  return deps.service.view().connection.origin === 'auto';
+}
+
+export function startAutoConnect(deps: AutoConnectDeps): () => void {
+  const state = { nextAttemptAt: 0, running: false };
+  const timer = setInterval(() => {
+    void autoConnectTick(deps, state);
+  }, TICK_MS);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
diff --git a/src/server/device/errors.ts b/src/server/device/errors.ts
new file mode 100644
index 0000000..e13da1a
--- /dev/null
+++ b/src/server/device/errors.ts
@@ -0,0 +1,58 @@
+// ABOUTME: 设备 SDK（memotalk-sdk）异常类型 → 中文 AppError；英文原文只放进 detail。
+
+import { AppError } from '../../contracts/errors';
+
+export interface DeviceErrorContext {
+  op: string;
+  exitCode?: number | null;
+  stderrTail?: string;
+}
+
+const BLUETOOTH_PATTERN = /bluetooth|radio|powered|not available|adapter|not ready/i;
+
+export function deviceErrorCode(kind: string, message: string, op: string): string {
+  switch (kind) {
+    case 'DeviceNotFound':
+    case 'BleakDeviceNotFoundError':
+      return 'DEVICE_NOT_FOUND';
+    case 'ConnectionLost':
+    case 'TransportError':
+      return 'DEVICE_DISCONNECTED';
+    case 'MemoTalkTimeout':
+    case 'TimeoutError':
+      return 'DEVICE_TIMEOUT';
+    case 'RecordingRejected':
+    case 'OperationForbidden':
+      return 'DEVICE_RECORDING';
+    case 'FileNotFoundOnDevice':
+      return 'FILE_NOT_ON_DEVICE';
+    case 'DeleteFailed':
+      return 'DELETE_FAILED';
+    case 'ProtocolError':
+    case 'CrcError':
+      return op === 'pull' ? 'TRANSFER_FAILED' : 'DEVICE_ERROR';
+    case 'ModuleNotFoundError':
+    case 'ImportError':
+      return 'RUNTIME_MISSING';
+    case 'DeviceRejected':
+    case 'DeviceErrorResponse':
+    case 'InvalidParameter':
+      return 'DEVICE_ERROR';
+    default:
+      if (kind.startsWith('Bleak') && BLUETOOTH_PATTERN.test(message)) return 'BLUETOOTH_UNAVAILABLE';
+      if (kind === 'BleakError') return op === 'pull' ? 'TRANSFER_FAILED' : 'DEVICE_ERROR';
+      return op === 'pull' ? 'TRANSFER_FAILED' : 'DEVICE_ERROR';
+  }
+}
+
+export function deviceErrorDetail(kind: string, message: string, context: DeviceErrorContext): string {
+  const lines = [`${kind}: ${message}`, `[op=${context.op} exit=${context.exitCode ?? '-'}]`];
+  if (context.stderrTail?.trim()) lines.push(context.stderrTail.trim().slice(-2000));
+  return lines.join('\n');
+}
+
+/** 把 Python 端报回的异常类型和原文映射为面向用户的错误。 */
+export function classifyDeviceError(kind: string, message: string, context: DeviceErrorContext | string): AppError {
+  const ctx = typeof context === 'string' ? { op: context } : context;
+  return new AppError(deviceErrorCode(kind, message, ctx.op), undefined, deviceErrorDetail(kind, message, ctx));
+}
diff --git a/src/server/device/fake-device.ts b/src/server/device/fake-device.ts
new file mode 100644
index 0000000..98f486d
--- /dev/null
+++ b/src/server/device/fake-device.ts
@@ -0,0 +1,164 @@
+// ABOUTME: 假设备 prelude（只用于测试）：设置 OPENMINUTES_FAKE_DEVICE 时由 worker 加载，用 SDK 自带模拟器替换真实录音笔，并禁止调用系统网络命令。
+
+export const FAKE_DEVICE_PRELUDE = String.raw`
+"""Fake recorder for OpenMinutes tests. Modes: wifi | ble | absent."""
+
+import asyncio
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import memotalk
+from memotalk.client import NetworkSession
+from memotalk.fake import FakeMemoTalk, FakeTransport, make_file_entry
+
+worker = sys.modules["__main__"]
+MODE = os.environ.get("OPENMINUTES_FAKE_DEVICE", "wifi")
+AUDIO_DIR = os.environ.get("OPENMINUTES_FAKE_DEVICE_AUDIO_DIR")
+FORBIDDEN = {"netsh", "netsh.exe", "nmcli", "networksetup"}
+
+_real_run = subprocess.run
+_real_popen = subprocess.Popen
+
+
+def _guard(args):
+    head = args[0] if isinstance(args, (list, tuple)) and args else str(args).split(" ")[0]
+    if Path(str(head)).name.lower() in FORBIDDEN:
+        raise AssertionError("fake device must never touch the system network: %s" % head)
+
+
+def _run(args, *rest, **kwargs):
+    _guard(args)
+    return _real_run(args, *rest, **kwargs)
+
+
+class _Popen(_real_popen):
+    def __init__(self, args, *rest, **kwargs):
+        _guard(args)
+        super().__init__(args, *rest, **kwargs)
+
+
+subprocess.run = _run
+subprocess.Popen = _Popen
+
+# Deleted files survive worker restarts, like a real recorder.
+deleted_path = worker.STATE_DIR / "fake-deleted.json"
+try:
+    deleted = set(json.loads(deleted_path.read_text(encoding="utf-8")))
+except Exception:
+    deleted = set()
+
+blobs = {}
+entries = []
+base_ts = 1792492200
+if AUDIO_DIR and Path(AUDIO_DIR).is_dir():
+    for index, path in enumerate(sorted(Path(AUDIO_DIR).glob("*.mp3"))):
+        data = path.read_bytes()
+        name = path.name
+        blobs[name] = data
+        entries.append(make_file_entry(name, size=len(data), duration_sec=max(1, len(data) * 8 // 128000),
+                                       timestamp=base_ts + index * 3600))
+else:
+    for index, (name, size) in enumerate([
+        ("REC20261020_103000.mp3", 2 * 1024 * 1024),
+        ("REC20261020_143000.mp3", 1536 * 1024),
+        ("REC20261021_090000.mp3", 200 * 1024),
+    ]):
+        entries.append(make_file_entry(name, size=size, duration_sec=max(1, size * 8 // 128000),
+                                       timestamp=base_ts + index * 3600))
+entries = [entry for entry in entries if entry.name not in deleted]
+
+device = FakeMemoTalk(files=entries)
+_pseudo = device._file_bytes
+device._file_bytes = lambda entry: blobs.get(entry.name) or _pseudo(entry)
+_delete = device._cmd_92
+
+
+def _cmd_92(payload, channel):
+    answer = _delete(payload, channel)
+    deleted.add(payload.decode("ascii", errors="replace"))
+    deleted_path.write_text(json.dumps(sorted(deleted)), encoding="utf-8")
+    return answer
+
+
+device._cmd_92 = _cmd_92
+
+
+class PacedTransport(FakeTransport):
+    """The stock simulator queues every 0x84 packet at once and overflows the SDK's
+    4096-slot subscription; real BLE trickles packets, so deliver them in batches."""
+
+    async def write(self, channel, frame):
+        if not self._connected:
+            raise memotalk.ConnectionLost("fake link is down")
+        responses = self.device.on_write(channel, frame)
+
+        async def pump():
+            for index, (out_channel, response) in enumerate(responses):
+                if not self._connected:
+                    return
+                self._dispatch(out_channel, response)
+                if index % 256 == 255:
+                    await asyncio.sleep(0.002)
+
+        asyncio.get_running_loop().create_task(pump())
+
+
+class AbsentTransport(PacedTransport):
+    async def connect(self, target=None, *, timeout=None):
+        raise memotalk.DeviceNotFound("no MemoTalk S1 / AI-PEN found (simulated)")
+
+
+transport = AbsentTransport(device) if MODE == "absent" else PacedTransport(device)
+_real_client = memotalk.MemoTalkClient
+memotalk.MemoTalkClient = lambda **kwargs: _real_client(transport=transport)
+
+
+class FakeFtp:
+    """In-memory FTP over the simulator's files: LIST / TYPE / SIZE / RETR."""
+
+    def _entry(self, name):
+        return next((item for item in device.files if item.name == name), None)
+
+    def retrlines(self, cmd, callback):
+        for item in device.files:
+            callback("-rw-r--r-- 1 ftp ftp %d Oct 20 10:30 %s" % (item.size, item.name))
+
+    def voidcmd(self, cmd):
+        return "200 ok"
+
+    def size(self, name):
+        item = self._entry(name)
+        return item.size if item else None
+
+    def retrbinary(self, cmd, callback, blocksize=8192):
+        name = cmd.split(" ", 1)[1]
+        item = self._entry(name)
+        if item is None:
+            raise OSError("550 %s not found" % name)
+        data = device._file_bytes(item)
+        for offset in range(0, len(data), blocksize):
+            callback(data[offset:offset + blocksize])
+
+    def close(self):
+        pass
+
+
+def _noop_join(net):
+    state = {"platform": "fake", "iface": None, "profile": None, "ssid": net.ssid}
+    worker.write_restore(state)
+    return state
+
+
+def _failing_join(net):
+    raise worker.WifiJoinFailed("simulated: this computer cannot join the recorder hotspot")
+
+
+worker.join_network = _noop_join if MODE == "wifi" else _failing_join
+worker.leave_network = lambda state: None
+worker.reconnect_original = lambda state: worker.clear_restore()
+worker.wait_reachable = lambda host, port, timeout, cancelled: True
+NetworkSession.open_ftp = lambda self, timeout=10.0: FakeFtp()
+`;
diff --git a/src/server/device/service.ts b/src/server/device/service.ts
new file mode 100644
index 0000000..461e229
--- /dev/null
+++ b/src/server/device/service.ts
@@ -0,0 +1,731 @@
+// ABOUTME: 设备服务：录音笔 SDK 的唯一所有者。连接状态机、单一互斥、同步/清理编排、空闲断开、实时字幕占用、诊断环形缓冲。
+
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
+import type {
+  DeviceActivity,
+  DeviceActivityKind,
+  DeviceCallRecord,
+  DeviceConnectionState,
+  DeviceInfo,
+  DeviceLastResult,
+  DeviceOrigin,
+  DeviceRecordingOnDevice,
+  DeviceView,
+  DisconnectReason,
+  ParsedDeviceFile,
+  Transport,
+  TransportSetting,
+} from '../../contracts/device';
+import { AppError, type AppErrorView } from '../../contracts/errors';
+import { upsertDevice } from '../ingest';
+import { autoTranscribeIfEnabled } from '../jobs';
+import { libraryRoot } from '../library';
+import { networkGate, type NetworkGate } from '../network-gate';
+import { resolveFfmpeg } from '../runtime-probe';
+import { nowIso, numOr, readSetting, rows, strOr, writeSetting } from '../sql';
+import { classifyDeviceError } from './errors';
+import { cleanupCandidates, pendingRecords, runCleanup, runSync, type CleanupOutcome, type SyncOutcome, type SyncRuntime, type WorkerStatus } from './sync';
+import { cachedWifiCapable, parseTransportSetting, planTransfer, probeWifiCapable, WIFI_MIN_BATCH_BYTES } from './transport';
+import { spawnDeviceWorker, type RequestOptions, type SpawnWorker, type WorkerCommand, type WorkerHandle } from './worker';
+
+export const IDLE_DISCONNECT_MS = 10 * 60_000;
+const HOTSPOT_CANCEL_WAIT_MS = 90_000;
+const BLE_CANCEL_WAIT_MS = 15_000;
+const MEASURED_KEYS = { wifi: 'device_wifi_bps', ble: 'device_ble_bps' } as const;
+
+export interface DeviceServiceOptions {
+  resolvePython: () => Promise<string | null>;
+  spawnWorker?: SpawnWorker;
+  platform?: NodeJS.Platform | string;
+  env?: NodeJS.ProcessEnv;
+  gate?: NetworkGate;
+  idleDisconnectMs?: number;
+  /** 拉取多久没有任何进度事件就算卡住（测试可调小）。 */
+  pullStallMs?: number;
+  logLimit?: number;
+}
+
+export interface LiveCaptureOptions {
+  scriptPath: string;
+  pythonCommand: string;
+  env: NodeJS.ProcessEnv;
+  scanTimeoutSec: number;
+}
+
+function newActivity(jobId: string, kind: DeviceActivityKind): DeviceActivity {
+  return {
+    jobId,
+    kind,
+    phase: 'connecting',
+    transport: null,
+    file: null,
+    index: 0,
+    count: 0,
+    bytesDone: 0,
+    bytesTotal: null,
+    startedAt: new Date().toISOString(),
+    offline: false,
+    fallback: null,
+    cancelling: false,
+  };
+}
+
+export class DeviceService {
+  private readonly app: WorkbenchServer;
+  private readonly resolvePython: () => Promise<string | null>;
+  private readonly platform: string;
+  private readonly env: NodeJS.ProcessEnv;
+  private readonly logLimit: number;
+  private readonly idleDisconnectMs: number;
+  private readonly pullStallMs: number | undefined;
+  private readonly spawnWorker: SpawnWorker;
+  private readonly gate: NetworkGate;
+
+  private state: DeviceConnectionState = 'disconnected';
+  private origin: DeviceOrigin | null = null;
+  private disconnectReason: DisconnectReason | null = null;
+  private stateSince = new Date();
+  private worker: WorkerHandle | null = null;
+  private connecting: Promise<void> | null = null;
+  private activity: DeviceActivity | null = null;
+  private activityDone: Promise<unknown> = Promise.resolve();
+  private lastResult: DeviceLastResult | null = null;
+  private lastError: AppErrorView | null = null;
+  private status: WorkerStatus | null = null;
+  private serial: string | null = null;
+  private listing: ParsedDeviceFile[] | null = null;
+  private cleanable: { count: number; bytes: number } | null = null;
+  private readonly deviceLog: DeviceCallRecord[] = [];
+  private resumeAfterLive = false;
+  private liveHandle: { child: ChildProcessWithoutNullStreams; release: () => Promise<void> } | null = null;
+  private idleTimer: NodeJS.Timeout | null = null;
+  private idleDeadline: number | null = null;
+  private abort: AbortController | null = null;
+  private nextAttemptAt = 0;
+  /** 用户接管了正在进行的后台同步：结束后若有推迟的录音，再按用户规则同步一次。 */
+  private followUpSync = false;
+
+  constructor(app: WorkbenchServer, options: DeviceServiceOptions) {
+    this.app = app;
+    this.resolvePython = options.resolvePython;
+    this.platform = options.platform ?? process.platform;
+    this.env = options.env ?? process.env;
+    this.logLimit = options.logLimit ?? 50;
+    this.idleDisconnectMs = options.idleDisconnectMs ?? IDLE_DISCONNECT_MS;
+    this.pullStallMs = options.pullStallMs;
+    this.spawnWorker = options.spawnWorker ?? spawnDeviceWorker;
+    this.gate = options.gate ?? networkGate;
+  }
+
+  private get db() {
+    return this.app.database;
+  }
+
+  // -- view ------------------------------------------------------------------
+  view(): DeviceView {
+    const intervalMinutes = Number(readSetting(this.db, 'auto_connect_minutes', '3')) || 3;
+    const lastRun = readSetting(this.db, 'last_auto_connect_at');
+    return {
+      connection: {
+        state: this.state,
+        origin: this.origin,
+        userDisconnected: readSetting(this.db, 'device_user_disconnected', '0') === '1',
+        disconnectReason: this.disconnectReason,
+        since: this.stateSince.toISOString(),
+        idleDisconnectAt: this.state === 'connected' && this.origin === 'user' && this.idleDeadline !== null
+          ? new Date(this.idleDeadline).toISOString()
+          : null,
+      },
+      device: this.deviceInfo(),
+      activity: this.activity ? { ...this.activity } : null,
+      lastResult: this.lastResult,
+      onDevice: this.listing ? this.onDevice() : [],
+      syncPlan: this.planPreview(),
+      wifiFromBytes: this.wifiFromBytes(),
+      cleanable: this.cleanable,
+      autoConnect: {
+        enabled: readSetting(this.db, 'auto_connect', '1') === '1',
+        intervalMinutes,
+        nextAttemptAt: this.nextAttemptAt ? new Date(this.nextAttemptAt).toISOString() : null,
+        lastRunAt: lastRun || null,
+        backgroundWifi: readSetting(this.db, 'auto_pull_wifi', '0') === '1',
+        syncOnConnect: this.autoPullOn(),
+      },
+      lastError: this.lastError,
+      environment: { failCount: 0 },
+    };
+  }
+
+  /** 自动连接调度器写入下次尝试时间；页面据此显示倒计时。 */
+  setNextAttempt(at: number): void {
+    this.nextAttemptAt = at;
+  }
+
+  private deviceInfo(): DeviceInfo | null {
+    if (!this.status?.serial) return null;
+    return {
+      serial: this.status.serial,
+      model: this.status.model || 'MemoTalk S1',
+      firmware: this.status.firmware ?? null,
+      batteryPct: this.status.batteryPct ?? null,
+      freeSpacePct: this.status.freeSpacePct ?? null,
+      lastSeenAt: nowIso(),
+    };
+  }
+
+  private onDevice(): DeviceRecordingOnDevice[] {
+    if (!this.listing || !this.serial) return [];
+    const known = new Map(
+      rows(this.db, `SELECT id, filename, size_bytes, duration_sec, recorded_at FROM recordings
+        WHERE device_serial = ? AND status = 'pending' AND (storage_path IS NULL OR storage_path = '')`, [this.serial])
+        .map((item) => [strOr(item.filename, ''), item]),
+    );
+    return this.listing
+      .map((file) => {
+        const record = known.get(file.name);
+        if (!record) return null;
+        return {
+          id: numOr(record.id, 0),
+          filename: file.name,
+          sizeBytes: file.sizeBytes,
+          durationSec: file.durationSec,
+          recordedAt: record.recorded_at ? strOr(record.recorded_at, '') : null,
+        };
+      })
+      .filter((item): item is DeviceRecordingOnDevice => item !== null);
+  }
+
+  /**
+   * 按钮下方的一行提示：这批待同步录音会用哪种传输方式。
+   * 未连接时按库里已知的待同步记录估算，「连接」前就能提示会不会暂时断开外网。
+   */
+  private planPreview(): { transport: Transport; willGoOffline: boolean } | null {
+    if (this.state === 'busy' || this.activity || this.state === 'live' || this.state === 'connecting') return null;
+    const serial = this.serial ?? readSetting(this.db, 'device_serial');
+    const pending = this.listing
+      ? this.onDevice().map((item) => ({ name: item.filename, sizeBytes: item.sizeBytes }))
+      : serial
+        ? pendingRecords(this.db, serial)
+          // 只登记了清单、大小未知的记录不算：连上后会按录音笔里的实际大小决定。
+          .filter((item) => item.sizeBytes !== null)
+          .map((item) => ({ name: item.filename, sizeBytes: item.sizeBytes }))
+        : [];
+    if (pending.length === 0) return null;
+    const plan = planTransfer({
+      setting: this.transportSetting(),
+      origin: 'user',
+      allowBackgroundWifi: true,
+      files: pending,
+      wifiCapable: cachedWifiCapable() ?? true,
+      platform: this.platform,
+    });
+    return { transport: plan.transport, willGoOffline: plan.transport === 'wifi' };
+  }
+
+  /** 单条同步达到这个大小就走无线快传（会暂时断开外网）；null 表示不会用无线快传。 */
+  private wifiFromBytes(): number | null {
+    const setting = this.transportSetting();
+    const probe = planTransfer({
+      setting,
+      origin: 'user',
+      allowBackgroundWifi: true,
+      files: [{ name: 'probe', sizeBytes: WIFI_MIN_BATCH_BYTES }],
+      wifiCapable: cachedWifiCapable() ?? true,
+      platform: this.platform,
+    });
+    if (probe.transport !== 'wifi') return null;
+    return setting === 'wifi' ? 0 : WIFI_MIN_BATCH_BYTES;
+  }
+
+  transportSetting(): TransportSetting {
+    return parseTransportSetting(readSetting(this.db, 'device_transport', 'auto'));
+  }
+
+  private allowBackgroundWifi(): boolean {
+    return readSetting(this.db, 'auto_pull_wifi', '0') === '1';
+  }
+
+  // -- diagnostics -----------------------------------------------------------
+  log(record: Omit<DeviceCallRecord, 'at'>): void {
+    this.deviceLog.push({ at: nowIso(), ...record });
+    if (this.deviceLog.length > this.logLimit) {
+      this.deviceLog.splice(0, this.deviceLog.length - this.logLimit);
+    }
+  }
+
+  logSnapshot(): DeviceCallRecord[] {
+    return this.deviceLog.slice();
+  }
+
+  measuredSpeeds(): { wifiBps: number | null; bleBps: number | null } {
+    const read = (key: string): number | null => {
+      const value = Number(readSetting(this.db, key));
+      return Number.isFinite(value) && value > 0 ? value : null;
+    };
+    return { wifiBps: read(MEASURED_KEYS.wifi), bleBps: read(MEASURED_KEYS.ble) };
+  }
+
+  // -- connection ------------------------------------------------------------
+  isConnected(): boolean {
+    return this.state === 'connected' || this.state === 'busy';
+  }
+
+  private setState(state: DeviceConnectionState, reason: DisconnectReason | null = null): void {
+    this.state = state;
+    if (reason !== null) this.disconnectReason = reason;
+    this.stateSince = new Date();
+  }
+
+  private armIdleTimer(): void {
+    this.disarmIdleTimer();
+    if (this.origin !== 'user') return;
+    const timer = setTimeout(() => {
+      this.idleTimer = null;
+      this.idleDeadline = null;
+      // 传输或连接进行中不算空闲；活动结束时 finishActivity 会重新计时。
+      if (this.activity || this.connecting) return;
+      void this.disconnect({ reason: 'idle' }).catch(() => undefined);
+    }, this.idleDisconnectMs);
+    timer.unref?.();
+    this.idleTimer = timer;
+    this.idleDeadline = Date.now() + this.idleDisconnectMs;
+  }
+
+  private disarmIdleTimer(): void {
+    this.idleDeadline = null;
+    if (!this.idleTimer) return;
+    clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+  }
+
+  /**
+   * autoSync 默认跟随来源：用户点「连接」= 连上并按设置同步；
+   * 实时字幕结束后的恢复连接传 false，只恢复会话，不悄悄同步（也就不会切热点）。
+   */
+  connect(options: { origin: DeviceOrigin; autoSync?: boolean }): Promise<DeviceView> {
+    if (this.state === 'live') return Promise.reject(new AppError('DEVICE_BUSY', undefined, '实时字幕正在使用录音笔'));
+    const autoSync = options.autoSync ?? options.origin === 'user';
+    if (options.origin === 'user') this.promoteToUser(autoSync);
+    // 放在 connecting 清空之后再同步，否则同步会被「正在连接」拦下。
+    if (this.connecting) return this.connecting.then(() => this.afterUserConnect(options.origin, autoSync));
+    if (this.state === 'busy' || this.state === 'connected') return Promise.resolve(this.afterUserConnect(options.origin, autoSync));
+    return this.sharedConnect(options).then(() => this.afterUserConnect(options.origin, autoSync));
+  }
+
+  /** 一次点击完成主任务：用户连接且「连上后自动同步」开启时立即同步。 */
+  private afterUserConnect(origin: DeviceOrigin, autoSync: boolean): DeviceView {
+    if (origin === 'user' && autoSync && this.autoPullOn() && !this.activity && this.state === 'connected') {
+      void this.sync({ origin: 'user' }).catch(() => undefined);
+    }
+    return this.view();
+  }
+
+  private autoPullOn(): boolean {
+    return readSetting(this.db, 'auto_pull', '1') === '1';
+  }
+
+  /**
+   * 用户在后台会话（正在自动连接、已连上或正在后台同步）中点了连接/同步：
+   * 会话改为用户会话，不再「用完即断」；后台同步因限制推迟的大录音，结束后按用户规则补同步。
+   */
+  private promoteToUser(autoSync: boolean): void {
+    if (this.origin !== 'auto' || (!this.connecting && !this.isConnected())) return;
+    this.origin = 'user';
+    this.lastError = null;
+    writeSetting(this.db, 'device_user_disconnected', '0');
+    this.log({ op: 'connect', origin: 'user', ok: true, code: null, transport: null, bytes: null, durationMs: 0,
+      detail: 'user took over the background session' });
+    if (this.activity) {
+      if (autoSync && this.autoPullOn()) this.followUpSync = true;
+    } else if (this.state === 'connected') {
+      this.armIdleTimer();
+    }
+  }
+
+  /** 所有连接都经过这里，保证同一时间只有一个 worker 在连录音笔。 */
+  private sharedConnect(options: { origin: DeviceOrigin }): Promise<void> {
+    if (this.connecting) return this.connecting;
+    const run = this.doConnect(options).finally(() => {
+      this.connecting = null;
+    });
+    this.connecting = run;
+    return run;
+  }
+
+  private async doConnect(options: { origin: DeviceOrigin }): Promise<void> {
+    this.setState('connecting');
+    this.origin = options.origin;
+    if (options.origin === 'user') this.lastError = null;
+    let handle: WorkerHandle;
+    try {
+      const python = await this.resolvePython();
+      if (!python) {
+        throw new AppError('RUNTIME_MISSING', undefined, '环境自检没有找到可用的 Python 解释器；请到「设置 › 诊断与高级」重新检测。');
+      }
+      handle = await this.spawnWorker({
+        python,
+        stateDir: await this.stateDir(),
+        prefer: this.rememberedAddress(),
+        env: this.env,
+      });
+    } catch (error) {
+      this.handleFailure(error, 'connect', this.origin ?? options.origin);
+      throw error;
+    }
+    this.worker = handle;
+    handle.onExit(() => {
+      // 主动断开时 terminateWorker 已先摘下 worker，断开原因由调用方设置；
+      // 否则这里会短暂显示「已休眠」，自动连接也可能在这个窗口里抢先重连。
+      if (this.worker !== handle) {
+        this.status = null;
+        return;
+      }
+      this.onWorkerExit();
+    });
+    try {
+      const connected = await handle.request<{ address: string | null; hotspotWasOn: boolean; timeSynced: boolean }>(
+        'connect', {}, { timeoutMs: 45_000 },
+      );
+      if (connected.hotspotWasOn) {
+        this.log({ op: 'connect', origin: options.origin, ok: true, code: 'HOTSPOT_RESIDUE_CLOSED', transport: null,
+          bytes: null, durationMs: 0, detail: '已关闭上次中断残留的录音笔热点' });
+      }
+      const status = await handle.request<WorkerStatus>('status', {}, { timeoutMs: 15_000 });
+      if (!status?.serial) throw new AppError('DEVICE_ERROR', undefined, '录音笔没有上报序列号');
+      this.status = status;
+      this.serial = status.serial;
+      this.persistDevice(connected.address, status);
+      // 连接过程中可能已被用户接管（promoteToUser），按当前来源处理。
+      if (this.origin === 'user') writeSetting(this.db, 'device_user_disconnected', '0');
+      this.setState('connected', null);
+      this.armIdleTimer();
+    } catch (error) {
+      await this.terminateWorker(true);
+      this.handleFailure(error, 'connect', this.origin ?? options.origin);
+      throw error;
+    }
+  }
+
+  private rememberedAddress(): string | null {
+    const found = rows(this.db,
+      'SELECT ble_address AS value FROM devices WHERE ble_address IS NOT NULL ORDER BY COALESCE(last_seen_at, created_at) DESC LIMIT 1');
+    const value = found[0] ? strOr(found[0].value, '') : '';
+    return value || null;
+  }
+
+  private persistDevice(address: string | null, status: WorkerStatus): void {
+    if (!status.serial) return;
+    upsertDevice(this.db, status.serial, {
+      firmware: status.firmware ?? undefined,
+      storageFormat: status.storageFormat ?? undefined,
+      batteryPct: status.batteryPct ?? undefined,
+      freeSpacePct: status.freeSpacePct ?? undefined,
+    });
+    writeSetting(this.db, 'device_serial', status.serial);
+    if (address) {
+      const update = this.db.prepare('UPDATE devices SET ble_address = ? WHERE serial = ?');
+      update.run(address, status.serial);
+    }
+  }
+
+  async refreshStatus(): Promise<WorkerStatus> {
+    if (!this.worker) return this.status ?? emptyStatus();
+    const status = await this.worker.request<WorkerStatus>('status', {}, { timeoutMs: 15_000 });
+    this.status = status;
+    if (status.serial) {
+      this.serial = status.serial;
+      this.persistDevice(null, status);
+    }
+    return status;
+  }
+
+  private toAppError(error: unknown, op: string): AppError {
+    if (error instanceof AppError) return error;
+    const record = error as { kind?: string; message?: string };
+    return classifyDeviceError(record.kind ?? 'Error', record.message ?? String(error), op);
+  }
+
+  /** 后台来源的失败（录音笔休眠、不在范围内）只进诊断日志，不在页面上显示为错误。 */
+  private handleFailure(error: unknown, op: DeviceCallRecord['op'], origin: DeviceOrigin): void {
+    const appError = this.toAppError(error, op);
+    if (origin === 'user') this.lastError = appError.toView();
+    this.log({ op, origin, ok: false, code: appError.code, transport: null, bytes: null, durationMs: 0, detail: appError.detail ?? '' });
+    if (this.state !== 'live') this.setState('disconnected', origin === 'user' ? 'lost' : null);
+  }
+
+  private onWorkerExit(): void {
+    this.worker = null;
+    this.status = null;
+    // 录音笔已不在：不再提供逐条同步和清理入口。
+    this.listing = null;
+    this.cleanable = null;
+    if (this.state === 'live' || this.state === 'disconnected') return;
+    this.setState('disconnected', 'device_sleep');
+    this.disarmIdleTimer();
+  }
+
+  private async stateDir(): Promise<string> {
+    const audioDir = await this.app.resources.path('audio', undefined, 'write');
+    return path.join(path.dirname(audioDir), 'tools', 'device');
+  }
+
+  private async terminateWorker(polite: boolean): Promise<void> {
+    const handle = this.worker;
+    this.worker = null;
+    if (!handle) return;
+    if (polite) await handle.request('disconnect', {}, { timeoutMs: 8000 }).catch(() => undefined);
+    await handle.close(5000).catch(() => undefined);
+    if (!handle.exited) handle.kill();
+  }
+
+  async disconnect(options: { reason: DisconnectReason }): Promise<DeviceView> {
+    if (this.state === 'live') throw new AppError('DEVICE_BUSY', undefined, '实时字幕正在使用录音笔');
+    if (options.reason === 'user') writeSetting(this.db, 'device_user_disconnected', '1');
+    if (this.activity) {
+      await this.cancel({ timeoutMs: this.activity.transport === 'wifi' ? HOTSPOT_CANCEL_WAIT_MS : BLE_CANCEL_WAIT_MS });
+    }
+    await this.activityDone.catch(() => undefined);
+    this.disarmIdleTimer();
+    const started = Date.now();
+    await this.terminateWorker(true);
+    this.log({ op: 'disconnect', origin: this.origin ?? 'user', ok: true, code: null, transport: null, bytes: null,
+      durationMs: Date.now() - started, detail: `reason=${options.reason}` });
+    this.setState('disconnected', options.reason);
+    this.followUpSync = false;
+    this.origin = null;
+    this.listing = null;
+    this.cleanable = null;
+    return this.view();
+  }
+
+  // -- activity --------------------------------------------------------------
+  private busyGuard(liveMessage: string): void {
+    if (this.state === 'live') throw new AppError('DEVICE_BUSY', undefined, liveMessage);
+    if (this.connecting) throw new AppError('DEVICE_BUSY', '录音笔正在连接，请稍候再试。', 'connect in progress');
+    if (this.activity) {
+      throw new AppError('DEVICE_BUSY', undefined, `录音笔正在${this.activity.kind === 'cleanup' ? '清理' : '同步'}录音`);
+    }
+  }
+
+  sync(options: { ids?: number[]; origin: DeviceOrigin }): Promise<SyncOutcome> {
+    this.busyGuard('实时字幕正在使用录音笔');
+    // 用户在后台会话里点同步：会话归用户，同步完不再自动断开。
+    if (options.origin === 'user') this.promoteToUser(false);
+    if (options.origin === 'user') this.lastError = null;
+    const jobId = randomUUID();
+    const activity = newActivity(jobId, options.ids ? 'pull' : 'sync');
+    this.activity = activity;
+    this.abort = new AbortController();
+    this.setState('busy', null);
+    this.disarmIdleTimer();
+    const runtime = this.runtimeFor(activity, options.origin, (ids) => autoTranscribeIfEnabled(this.app, ids));
+    const run = runSync(runtime, { ids: options.ids }).catch((error: unknown) => {
+      const appError = this.toAppError(error, 'pull');
+      if (options.origin === 'user') this.lastError = appError.toView();
+      this.log({ op: 'pull', origin: options.origin, ok: false, code: appError.code, transport: null, bytes: null,
+        durationMs: Date.now() - new Date(activity.startedAt).getTime(), detail: appError.detail ?? '' });
+      throw appError;
+    });
+    this.activityDone = run.then(() => undefined, () => undefined);
+    return this.finishActivity(jobId, activity, options.origin, run);
+  }
+
+  cleanup(options: { origin: DeviceOrigin }): Promise<CleanupOutcome> {
+    this.busyGuard('实时字幕正在使用录音笔');
+    if (options.origin === 'user') this.lastError = null;
+    const jobId = randomUUID();
+    const activity = newActivity(jobId, 'cleanup');
+    activity.phase = 'listing';
+    this.activity = activity;
+    this.abort = new AbortController();
+    this.setState('busy', null);
+    this.disarmIdleTimer();
+    const runtime = this.runtimeFor(activity, options.origin, () => 0);
+    const run = runCleanup(runtime).catch((error: unknown) => {
+      const appError = this.toAppError(error, 'delete');
+      if (options.origin === 'user') this.lastError = appError.toView();
+      this.log({ op: 'delete', origin: options.origin, ok: false, code: appError.code, transport: null, bytes: null,
+        durationMs: Date.now() - new Date(activity.startedAt).getTime(), detail: appError.detail ?? '' });
+      throw appError;
+    });
+    this.activityDone = run.then(() => undefined, () => undefined);
+    return this.finishActivity(jobId, activity, options.origin, run);
+  }
+
+  private runtimeFor(activity: DeviceActivity, origin: DeviceOrigin, afterImport: (ids: number[]) => number): SyncRuntime {
+    const signal = (this.abort ?? new AbortController()).signal;
+    return {
+      db: this.db,
+      origin,
+      activity,
+      gate: this.gate,
+      platform: this.platform,
+      isConnected: () => this.worker !== null && !this.worker.exited,
+      ensureConnected: async () => {
+        // 活动进行中连接：走共享的连接入口，连上后保持 busy，不计空闲。
+        await this.sharedConnect({ origin });
+        this.disarmIdleTimer();
+        this.setState('busy', null);
+      },
+      request: <T>(cmd: WorkerCommand, args?: Record<string, unknown>, opts?: RequestOptions) => {
+        const handle = this.worker;
+        if (!handle) throw new AppError('DEVICE_DISCONNECTED');
+        return handle.request<T>(cmd, args, opts);
+      },
+      refreshStatus: () => this.refreshStatus(),
+      serial: () => this.serial,
+      setListing: (files) => {
+        this.listing = files;
+        this.refreshCleanable();
+      },
+      incomingRoot: () => this.app.resources.path('audio', '_incoming', 'write'),
+      libraryRoot: () => libraryRoot(this.db),
+      ffmpeg: async () => (await resolveFfmpeg(this.db)) ?? 'ffmpeg',
+      afterImport,
+      transportSetting: () => this.transportSetting(),
+      allowBackgroundWifi: () => this.allowBackgroundWifi(),
+      wifiCapable: () => probeWifiCapable(undefined, this.platform, this.env),
+      isCancelled: () => activity.cancelling,
+      signal,
+      cancelWorker: () => this.worker?.cancel(),
+      killWorker: () => {
+        if (this.worker && !this.worker.exited) this.worker.kill();
+      },
+      cancelGraceMs: () => (activity.transport === 'wifi' ? HOTSPOT_CANCEL_WAIT_MS : BLE_CANCEL_WAIT_MS),
+      pullStallMs: this.pullStallMs,
+      bleBps: () => this.measuredSpeeds().bleBps,
+      log: (record) => this.log(record),
+      measured: (transport, bps) => writeSetting(this.db, MEASURED_KEYS[transport], String(bps)),
+    };
+  }
+
+  private finishActivity<T extends { done: number; failed: number; deferred: number; transport: Transport | null; fallback: AppErrorView | null; error: AppErrorView | null; cancelled: boolean }>(
+    jobId: string,
+    activity: DeviceActivity,
+    origin: DeviceOrigin,
+    run: Promise<T>,
+  ): Promise<T> {
+    let deferred = 0;
+    return run
+      .then((result) => {
+        deferred = result.deferred;
+        this.lastResult = {
+          jobId,
+          kind: activity.kind,
+          origin,
+          done: result.done,
+          failed: result.failed,
+          deferred: result.deferred,
+          transport: result.transport,
+          fallback: result.fallback,
+          error: result.error,
+          cancelled: result.cancelled,
+          finishedAt: new Date().toISOString(),
+        };
+        return result;
+      })
+      .finally(() => {
+        this.activity = null;
+        this.abort = null;
+        // 清单是同步开始时读的；挂接完成后重新计算可清理的录音。
+        this.refreshCleanable();
+        // 来源按结束时判断：后台同步途中被用户接管后，保持连接。
+        const autoSession = this.origin === 'auto';
+        const followUp = this.followUpSync;
+        this.followUpSync = false;
+        if (!this.worker) {
+          if (this.state !== 'disconnected') this.setState('disconnected', 'lost');
+        } else if (autoSession) {
+          void this.disconnect({ reason: 'auto-done' }).catch(() => undefined);
+        } else {
+          this.setState('connected', null);
+          this.armIdleTimer();
+          if (followUp && deferred > 0) void this.sync({ origin: 'user' }).catch(() => undefined);
+        }
+      });
+  }
+
+  private refreshCleanable(): void {
+    if (!this.listing || !this.serial) {
+      this.cleanable = null;
+      return;
+    }
+    const candidates = cleanupCandidates(this.db, this.serial, this.listing, libraryRoot(this.db));
+    this.cleanable = { count: candidates.length, bytes: candidates.reduce((sum, file) => sum + (file.sizeBytes ?? 0), 0) };
+  }
+
+  /** 协作式取消；热点阶段给足恢复网络的时间，超时才强制结束 worker。 */
+  async cancel(options: { timeoutMs?: number } = {}): Promise<DeviceView> {
+    const activity = this.activity;
+    if (!activity) return this.view();
+    activity.cancelling = true;
+    // 等网阶段 worker 还没开始传输：中止等待即可，不碰 worker。
+    const waitingNetwork = activity.phase === 'waiting-network';
+    this.abort?.abort();
+    this.worker?.cancel();
+    const timeout = options.timeoutMs ?? (activity.transport === 'wifi' ? HOTSPOT_CANCEL_WAIT_MS : BLE_CANCEL_WAIT_MS);
+    const timedOut = await Promise.race([
+      this.activityDone.then(() => false),
+      new Promise<true>((resolve) => {
+        const timer = setTimeout(() => resolve(true), timeout);
+        timer.unref?.();
+      }),
+    ]);
+    if (timedOut && !waitingNetwork && this.worker && !this.worker.exited) this.worker.kill();
+    await this.activityDone.catch(() => undefined);
+    return this.view();
+  }
+
+  // -- live caption ----------------------------------------------------------
+  /** 实时字幕需要独占录音笔：先断开 worker，结束后按需恢复连接。 */
+  async claimForLive(handle: LiveCaptureOptions): Promise<ChildProcessWithoutNullStreams> {
+    if (this.state === 'live') throw new AppError('DEVICE_BUSY', '实时字幕已经在运行');
+    if (this.activity || this.connecting) throw new AppError('DEVICE_BUSY', '录音笔正在同步录音，请等它结束后再开始实时字幕。');
+    this.resumeAfterLive = this.state === 'connected' && this.origin === 'user';
+    const resume = this.resumeAfterLive;
+    this.disarmIdleTimer();
+    // 同一时间只有一个进程占用录音笔：等 worker 完全退出再派生采集脚本。
+    this.setState('live', 'live');
+    await this.terminateWorker(true);
+    this.origin = null;
+    this.listing = null;
+    this.log({ op: 'live', origin: 'user', ok: true, code: null, transport: null, bytes: null, durationMs: 0,
+      detail: `claimed for live caption; resumeAfter=${resume}` });
+    let child: ChildProcessWithoutNullStreams;
+    try {
+      child = spawn(handle.pythonCommand, ['-X', 'utf8', handle.scriptPath, '--scan-timeout', String(handle.scanTimeoutSec)], {
+        windowsHide: true,
+        env: handle.env,
+      });
+    } catch (error) {
+      this.setState('disconnected', 'live');
+      throw new AppError('RUNTIME_MISSING', undefined, `cannot start live capture: ${String(error)}`);
+    }
+    const release = async () => {
+      this.liveHandle = null;
+      this.setState('disconnected', 'live');
+      // 只恢复会话，不触发同步：停止实时字幕不应让电脑切到录音笔热点。
+      if (resume) await this.connect({ origin: 'user', autoSync: false }).catch(() => undefined);
+    };
+    this.liveHandle = { child, release };
+    return child;
+  }
+
+  async releaseFromLive(): Promise<void> {
+    const live = this.liveHandle;
+    this.liveHandle = null;
+    this.setState('disconnected', 'live');
+    if (live) await live.release();
+  }
+}
+
+function emptyStatus(): WorkerStatus {
+  return { serial: '', model: '', firmware: null, batteryPct: null, freeSpacePct: null, recordingState: null, storageFormat: null };
+}
+
+export function createDeviceService(app: WorkbenchServer, options: DeviceServiceOptions): DeviceService {
+  return new DeviceService(app, options);
+}
diff --git a/src/server/device/sync.ts b/src/server/device/sync.ts
new file mode 100644
index 0000000..3b10d20
--- /dev/null
+++ b/src/server/device/sync.ts
@@ -0,0 +1,434 @@
+// ABOUTME: 同步编排：读清单 → 登记 → 规划传输 → 网络闸门 → 拉取 → 大小校验 → 挂接 → 自动转录；以及清理已同步的录音。
+
+import { statSync } from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import path from 'node:path';
+import type { DatabaseSync } from 'node:sqlite';
+import type { DeviceActivity, DeviceCallRecord, DeviceOrigin, ParsedDeviceFile, Transport, TransportSetting } from '../../contracts/device';
+import { AppError, errorView, type AppErrorView } from '../../contracts/errors';
+import { attachDownloadedFile, registerDeviceManifest, sanitizeFilename } from '../ingest';
+import { resolveStoredPath } from '../library';
+import type { NetworkGate } from '../network-gate';
+import { containsPath } from '../paths';
+import { num, row, rows, str, strOr } from '../sql';
+import { classifyDeviceError } from './errors';
+import { planTransfer, type TransferPlan } from './transport';
+import type { RequestOptions, WorkerCommand, WorkerEvent } from './worker';
+
+export interface WorkerStatus {
+  serial: string;
+  model: string;
+  firmware: string | null;
+  batteryPct: number | null;
+  freeSpacePct: number | null;
+  recordingState: string | null;
+  storageFormat: string | null;
+}
+
+interface PulledFile {
+  name: string;
+  ok: boolean;
+  path?: string;
+  sizeBytes?: number;
+  transport?: Transport;
+  error?: { kind: string; message: string };
+}
+
+/** 设备服务交给编排层的最小能力面，测试可以直接实现它。 */
+export interface SyncRuntime {
+  db: DatabaseSync;
+  origin: DeviceOrigin;
+  activity: DeviceActivity;
+  gate: NetworkGate;
+  platform: string;
+  isConnected(): boolean;
+  ensureConnected(): Promise<void>;
+  request<T>(cmd: WorkerCommand, args?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+  refreshStatus(): Promise<WorkerStatus>;
+  serial(): string | null;
+  setListing(files: ParsedDeviceFile[]): void;
+  incomingRoot(): Promise<string>;
+  libraryRoot(): string;
+  ffmpeg(): Promise<string>;
+  afterImport(ids: number[]): number;
+  transportSetting(): TransportSetting;
+  allowBackgroundWifi(): boolean;
+  wifiCapable(): Promise<boolean>;
+  isCancelled(): boolean;
+  /** 用户停止或断开时触发；用于中止等网之类不经过 worker 的等待。 */
+  signal?: AbortSignal;
+  /** 协作式取消当前 worker 请求。 */
+  cancelWorker?(): void;
+  /** 宽限期过后仍不返回时强制结束 worker。 */
+  killWorker?(): void;
+  /** 取消后等待 worker 自行收尾的时长；热点阶段要给足恢复网络的时间。 */
+  cancelGraceMs?(): number;
+  /** 拉取多久没有任何事件就算卡住。 */
+  pullStallMs?: number;
+  /** 实测蓝牙吞吐，用于后台同步的时长预算。 */
+  bleBps?(): number | null;
+  log(record: Omit<DeviceCallRecord, 'at'>): void;
+  measured(transport: Transport, bytesPerSecond: number): void;
+}
+
+export interface SyncOutcome {
+  done: number;
+  failed: number;
+  deferred: number;
+  transport: Transport | null;
+  fallback: AppErrorView | null;
+  error: AppErrorView | null;
+  cancelled: boolean;
+  ids: number[];
+  queued: number;
+}
+
+export const RECORDING_STATES = new Set(['RECORDING', 'PAUSED', 'RESUMED']);
+const NETWORK_WAIT_MS = 180_000;
+
+interface PendingRecord {
+  id: number;
+  filename: string;
+  sizeBytes: number | null;
+}
+
+/** 只取当前录音笔、还没有音频文件的待同步记录。 */
+export function pendingRecords(db: DatabaseSync, serial: string, ids?: number[]): PendingRecord[] {
+  const base = `SELECT id, filename, size_bytes FROM recordings
+     WHERE status = 'pending' AND (storage_path IS NULL OR storage_path = '') AND device_serial = ?`;
+  const list = ids && ids.length > 0
+    ? rows(db, `${base} AND id IN (${ids.map(() => '?').join(',')}) ORDER BY COALESCE(recorded_at, created_at) DESC`, [serial, ...ids])
+    : rows(db, `${base} ORDER BY COALESCE(recorded_at, created_at) DESC`, [serial]);
+  return list.map((item) => ({ id: num(item.id) ?? 0, filename: strOr(item.filename, ''), sizeBytes: num(item.size_bytes) }))
+    .filter((item) => item.filename);
+}
+
+/** 带大小的传输时长预算：慢速蓝牙按 3 KB/s 估算，再加两分钟余量。仅作为卡死检测之外的总上限参考。 */
+export function pullTimeoutMs(totalBytes: number): number {
+  return Math.min(2 * 3600_000, 120_000 + Math.round(totalBytes / 3));
+}
+
+/** 连续这么久没有任何进度事件才算卡住；热点入网、FTP 连接都在这个窗口内会上报。 */
+export const PULL_STALL_MS = 180_000;
+/** worker 请求自身不再计时：卡死由进度看门狗判断，并先协作取消再强制结束。 */
+const NO_REQUEST_TIMEOUT = 2_147_483_647;
+
+function applyProgress(activity: DeviceActivity, data: Record<string, unknown>): void {
+  const phase = String(data.phase ?? '');
+  if (phase === 'preparing' || phase === 'transferring' || phase === 'restoring') activity.phase = phase;
+  if (data.transport === 'wifi' || data.transport === 'ble') activity.transport = data.transport;
+  activity.file = typeof data.file === 'string' ? data.file : activity.file;
+  if (typeof data.index === 'number') activity.index = data.index;
+  if (typeof data.count === 'number') activity.count = data.count;
+  if (typeof data.bytes === 'number') activity.bytesDone = data.bytes;
+  activity.bytesTotal = typeof data.total === 'number' ? data.total : activity.bytesTotal;
+}
+
+/** 下载结果必须落在本任务目录内，并与设备上报的大小一致才挂接。 */
+function verifiedPath(outDir: string, file: PulledFile, expected: number | null): { path: string } | { error: AppError } {
+  if (!file.path || !path.isAbsolute(file.path) || !containsPath(outDir, path.resolve(file.path), process.platform)) {
+    return { error: new AppError('TRANSFER_FAILED', undefined, `unexpected path from worker: ${file.path ?? '(none)'}`) };
+  }
+  let size: number;
+  try {
+    size = statSync(file.path).size;
+  } catch (error) {
+    return { error: new AppError('TRANSFER_FAILED', undefined, `downloaded file missing: ${String(error)}`) };
+  }
+  if (expected !== null && expected > 0 && size !== expected) {
+    return { error: new AppError('TRANSFER_FAILED', undefined, `${file.name}: ${size} bytes on disk, device reported ${expected}`) };
+  }
+  return { path: file.path };
+}
+
+async function listDevice(rt: SyncRuntime): Promise<ParsedDeviceFile[]> {
+  rt.activity.phase = 'listing';
+  const listed = await rt.request<{ files: ParsedDeviceFile[] }>('list', {}, { timeoutMs: 60_000 });
+  rt.setListing(listed.files);
+  return listed.files;
+}
+
+/**
+ * 用户来源会先连接；后台来源未连接时直接返回。
+ * 传 ids 时只同步这些记录（单条同步），否则读清单并登记新录音后同步全部。
+ */
+export async function runSync(rt: SyncRuntime, options: { ids?: number[] } = {}): Promise<SyncOutcome> {
+  const outcome: SyncOutcome = {
+    done: 0, failed: 0, deferred: 0, transport: null, fallback: null, error: null, cancelled: false, ids: [], queued: 0,
+  };
+  if (!rt.isConnected()) {
+    if (rt.origin === 'auto') return outcome;
+    rt.activity.phase = 'connecting';
+    await rt.ensureConnected();
+  }
+
+  const status = await rt.refreshStatus();
+  if (status.recordingState && RECORDING_STATES.has(status.recordingState)) {
+    throw new AppError('DEVICE_RECORDING', undefined, `recordingState=${status.recordingState}`);
+  }
+  const serial = status.serial || rt.serial();
+  if (!serial) throw new AppError('DEVICE_ERROR', undefined, 'device did not report a serial number');
+
+  const listing = await listDevice(rt);
+  if (!options.ids) registerDeviceManifest(rt.db, serial, listing);
+  const byName = new Map(listing.map((file) => [sanitizeFilename(file.name), file]));
+
+  const records = pendingRecords(rt.db, serial, options.ids);
+  const present = records.filter((record) => byName.has(record.filename));
+  for (const missing of records.filter((record) => !byName.has(record.filename))) {
+    outcome.failed += 1;
+    rt.log({ op: 'pull', origin: rt.origin, ok: false, code: 'FILE_NOT_ON_DEVICE', transport: null, bytes: null, durationMs: 0,
+      detail: `${missing.filename} is not in the device listing` });
+  }
+  if (present.length === 0) {
+    rt.activity.phase = 'finishing';
+    return outcome;
+  }
+
+  const files = present.map((record) => {
+    const device = byName.get(record.filename);
+    return { record, name: device?.name ?? record.filename, sizeBytes: device?.sizeBytes ?? record.sizeBytes };
+  });
+  const plan: TransferPlan = planTransfer({
+    setting: rt.transportSetting(),
+    origin: rt.origin,
+    allowBackgroundWifi: rt.allowBackgroundWifi(),
+    files: files.map((file) => ({ name: file.name, sizeBytes: file.sizeBytes })),
+    wifiCapable: await rt.wifiCapable(),
+    platform: rt.platform,
+    bleBps: rt.bleBps?.() ?? null,
+  });
+  outcome.deferred = plan.deferred.length;
+  const included = files.filter((file) => plan.include.includes(file.name));
+  if (included.length === 0) {
+    rt.activity.phase = 'finishing';
+    return outcome;
+  }
+
+  let transport: Transport = plan.transport;
+  let release: (() => void) | null = null;
+  if (transport === 'wifi') {
+    rt.activity.phase = 'waiting-network';
+    rt.activity.transport = 'wifi';
+    release = await rt.gate.acquireOffline('device-hotspot', { waitForInFlightMs: NETWORK_WAIT_MS, signal: rt.signal });
+    if (rt.isCancelled()) {
+      release?.();
+      rt.activity.offline = false;
+      outcome.cancelled = true;
+      return outcome;
+    }
+    if (!release) {
+      transport = 'ble';
+      outcome.fallback = errorView('WIFI_FALLBACK', 'NETWORK_IN_USE: transcription tasks did not finish within 180s');
+      rt.activity.fallback = outcome.fallback;
+    } else {
+      rt.activity.offline = true;
+    }
+  }
+  if (rt.isCancelled()) {
+    release?.();
+    rt.activity.offline = false;
+    outcome.cancelled = true;
+    return outcome;
+  }
+  const releaseGate = () => {
+    release?.();
+    release = null;
+    rt.activity.offline = false;
+  };
+
+  rt.activity.transport = transport;
+  rt.activity.count = included.length;
+  rt.activity.index = 0;
+  const jobDir = path.join(await rt.incomingRoot(), rt.activity.jobId);
+  await mkdir(jobDir, { recursive: true });
+  const started = Date.now();
+  let lastEventAt = Date.now();
+  const onEvent = (event: WorkerEvent) => {
+    lastEventAt = Date.now();
+    if (event.event === 'progress') {
+      applyProgress(rt.activity, event.data);
+      if (rt.activity.transport === 'ble') releaseGate();
+    } else if (event.event === 'fallback') {
+      releaseGate();
+      const detail = `${String(event.data.reason ?? 'WIFI_TRANSFER_FAILED')}\n${String(event.data.detail ?? '')}`.trim();
+      outcome.fallback = errorView('WIFI_FALLBACK', detail);
+      rt.activity.fallback = outcome.fallback;
+      rt.activity.transport = 'ble';
+      rt.log({ op: 'pull', origin: rt.origin, ok: false, code: String(event.data.reason ?? 'WIFI_FALLBACK'), transport: 'wifi',
+        bytes: null, durationMs: Date.now() - started, detail });
+    } else if (event.event === 'warning') {
+      rt.log({ op: 'pull', origin: rt.origin, ok: false, code: String(event.data.code ?? 'WARNING'), transport: 'wifi',
+        bytes: null, durationMs: 0, detail: String(event.data.detail ?? '') });
+    }
+  };
+
+  // 卡死看门狗：长时间没有事件时先协作取消，等 worker 自己恢复网络并返回；宽限期过后才强制结束。
+  const stallMs = rt.pullStallMs ?? PULL_STALL_MS;
+  let stalled: AppError | null = null;
+  let killTimer: NodeJS.Timeout | null = null;
+  const watchdog = setInterval(() => {
+    if (stalled || Date.now() - lastEventAt < stallMs) return;
+    stalled = new AppError('DEVICE_TIMEOUT', undefined,
+      `pull made no progress for ${Math.round((Date.now() - lastEventAt) / 1000)}s (phase=${rt.activity.phase}, transport=${rt.activity.transport ?? '-'})`);
+    rt.log({ op: 'pull', origin: rt.origin, ok: false, code: 'DEVICE_TIMEOUT', transport: rt.activity.transport, bytes: null,
+      durationMs: Date.now() - started, detail: stalled.detail ?? '' });
+    rt.cancelWorker?.();
+    killTimer = setTimeout(() => rt.killWorker?.(), rt.cancelGraceMs?.() ?? 15_000);
+    killTimer.unref?.();
+  }, Math.max(10, Math.min(5_000, Math.floor(stallMs / 4))));
+  watchdog.unref?.();
+  const stopWatchdog = () => {
+    clearInterval(watchdog);
+    if (killTimer) clearTimeout(killTimer);
+  };
+
+  let pulled: { files: PulledFile[]; cancelled: boolean };
+  try {
+    pulled = await rt.request<{ files: PulledFile[]; cancelled: boolean }>('pull', {
+      files: included.map((file) => ({ name: file.name, size: file.sizeBytes })),
+      outDir: jobDir,
+      transport,
+    }, { timeoutMs: NO_REQUEST_TIMEOUT, onEvent });
+  } catch (error) {
+    stopWatchdog();
+    releaseGate();
+    await removeJobDir(rt, jobDir);
+    throw stalled ?? error;
+  }
+  stopWatchdog();
+  releaseGate();
+
+  rt.activity.phase = 'finishing';
+  // 卡住后 worker 自行停下：已经落盘的文件照常挂接，没有返回的算失败，并给出超时原因。
+  outcome.cancelled = pulled.cancelled && !stalled;
+  if (stalled) {
+    const returned = new Set(pulled.files.map((file) => file.name));
+    const missing = included.filter((file) => !returned.has(file.name)).length;
+    if (missing > 0) {
+      outcome.failed += missing;
+      outcome.error = (stalled as AppError).toView();
+    }
+  }
+  const ffmpeg = await rt.ffmpeg();
+  const bytesBy: Record<Transport, number> = { wifi: 0, ble: 0 };
+  for (const file of pulled.files) {
+    const entry = included.find((item) => item.name === file.name);
+    if (!entry) continue;
+    if (!file.ok) {
+      outcome.failed += 1;
+      const failure = classifyDeviceError(file.error?.kind ?? 'Error', file.error?.message ?? '', 'pull');
+      outcome.error = outcome.error ?? failure.toView();
+      continue;
+    }
+    const checked = verifiedPath(jobDir, file, entry.sizeBytes);
+    if ('error' in checked) {
+      outcome.failed += 1;
+      outcome.error = outcome.error ?? checked.error.toView();
+      rt.log({ op: 'pull', origin: rt.origin, ok: false, code: checked.error.code, transport: file.transport ?? transport,
+        bytes: file.sizeBytes ?? null, durationMs: 0, detail: checked.error.detail ?? '' });
+      continue;
+    }
+    const attached = await attachDownloadedFile(rt.db, rt.libraryRoot(), ffmpeg, checked.path, entry.record.filename, serial);
+    if (attached.ok && attached.id) {
+      outcome.done += 1;
+      outcome.ids.push(attached.id);
+      bytesBy[file.transport ?? transport] += file.sizeBytes ?? 0;
+    } else {
+      outcome.failed += 1;
+    }
+  }
+  const durationMs = Math.max(1, Date.now() - started);
+  const usedWifi = bytesBy.wifi > 0;
+  outcome.transport = usedWifi ? 'wifi' : (bytesBy.ble > 0 ? 'ble' : transport);
+  for (const kind of ['wifi', 'ble'] as const) {
+    if (bytesBy[kind] > 0 && (bytesBy.wifi === 0 || bytesBy.ble === 0)) rt.measured(kind, Math.round(bytesBy[kind] * 1000 / durationMs));
+  }
+  const totalDone = bytesBy.wifi + bytesBy.ble;
+  rt.log({
+    op: 'pull', origin: rt.origin, ok: outcome.failed === 0, code: outcome.error?.code ?? null, transport: outcome.transport,
+    bytes: totalDone, durationMs,
+    detail: `${outcome.done} ok, ${outcome.failed} failed, ${outcome.deferred} deferred; ${transportLabel(outcome.transport)} ${Math.round(totalDone * 1000 / durationMs)} B/s${outcome.cancelled ? '; cancelled' : ''}`,
+  });
+
+  outcome.queued = rt.afterImport(outcome.ids);
+  await removeJobDir(rt, jobDir);
+  await rt.refreshStatus().catch(() => undefined);
+  return outcome;
+}
+
+function transportLabel(transport: Transport | null): string {
+  return transport === 'wifi' ? '无线快传' : transport === 'ble' ? '蓝牙' : '-';
+}
+
+async function removeJobDir(rt: SyncRuntime, jobDir: string): Promise<void> {
+  const root = await rt.incomingRoot();
+  const resolved = path.resolve(jobDir);
+  if (!path.isAbsolute(resolved) || resolved === path.resolve(root) || !containsPath(root, resolved, process.platform)) return;
+  await rm(resolved, { recursive: true, force: true }).catch(() => undefined);
+}
+
+/** 只删库中存在、属于当前录音笔、本地文件仍在且大小与设备一致的录音。 */
+export function cleanupCandidates(db: DatabaseSync, serial: string, listing: ParsedDeviceFile[], libraryDir: string): ParsedDeviceFile[] {
+  const out: ParsedDeviceFile[] = [];
+  for (const file of listing) {
+    if (!file.sizeBytes) continue;
+    const found = row(db,
+      `SELECT storage_path FROM recordings
+        WHERE device_serial = ? AND filename = ? AND storage_path IS NOT NULL AND storage_path <> ''
+        ORDER BY id DESC LIMIT 1`,
+      [serial, sanitizeFilename(file.name)]);
+    const stored = resolveStoredPath(found ? str(found.storage_path) : null, libraryDir);
+    if (!stored) continue;
+    try {
+      if (statSync(stored).size === file.sizeBytes) out.push(file);
+    } catch {
+      /* 本地文件已不在：不删设备上的副本 */
+    }
+  }
+  return out;
+}
+
+export interface CleanupOutcome {
+  done: number;
+  failed: number;
+  deferred: number;
+  transport: Transport | null;
+  fallback: AppErrorView | null;
+  error: AppErrorView | null;
+  cancelled: boolean;
+  bytes: number;
+}
+
+export async function runCleanup(rt: SyncRuntime): Promise<CleanupOutcome> {
+  if (!rt.isConnected()) throw new AppError('DEVICE_DISCONNECTED');
+  const status = await rt.refreshStatus();
+  const serial = status.serial || rt.serial();
+  if (!serial) throw new AppError('DEVICE_ERROR', undefined, 'device did not report a serial number');
+  const listing = await listDevice(rt);
+  const candidates = cleanupCandidates(rt.db, serial, listing, rt.libraryRoot());
+  const outcome: CleanupOutcome = { done: 0, failed: 0, deferred: 0, transport: null, fallback: null, error: null, cancelled: false, bytes: 0 };
+  if (candidates.length === 0) return outcome;
+  rt.activity.phase = 'deleting';
+  rt.activity.count = candidates.length;
+  const started = Date.now();
+  const result = await rt.request<{ files: Array<{ name: string; ok: boolean; error?: { kind: string; message: string } }> }>(
+    'delete', { names: candidates.map((file) => file.name) }, { timeoutMs: 30_000 + candidates.length * 5_000 });
+  const deleted = new Set<string>();
+  for (const file of result.files) {
+    if (file.ok) {
+      outcome.done += 1;
+      deleted.add(file.name);
+      outcome.bytes += candidates.find((item) => item.name === file.name)?.sizeBytes ?? 0;
+    } else {
+      outcome.failed += 1;
+      outcome.error = outcome.error ?? classifyDeviceError(file.error?.kind ?? 'DeleteFailed', file.error?.message ?? '', 'delete').toView();
+    }
+  }
+  rt.setListing(listing.filter((file) => !deleted.has(file.name)));
+  rt.log({ op: 'delete', origin: rt.origin, ok: outcome.failed === 0, code: outcome.error?.code ?? null, transport: 'ble',
+    bytes: outcome.bytes, durationMs: Date.now() - started,
+    detail: `deleted ${[...deleted].join(', ') || '-'}${outcome.failed ? `; ${outcome.failed} failed` : ''}` });
+  await rt.refreshStatus().catch(() => undefined);
+  return outcome;
+}
diff --git a/src/server/device/transport.ts b/src/server/device/transport.ts
new file mode 100644
index 0000000..a0f0e91
--- /dev/null
+++ b/src/server/device/transport.ts
@@ -0,0 +1,150 @@
+// ABOUTME: 传输规划：按来源、批量大小与本机无线网卡决定走无线快传（热点 + FTP）还是蓝牙。
+
+import type { DeviceOrigin, Transport, TransportSetting } from '../../contracts/device';
+import { runCommand, type CommandOutcome } from '../media';
+
+export type { TransportSetting } from '../../contracts/device';
+
+/** 真机验收后按实测吞吐调整（见计划 §8.5）。 */
+export const WIFI_MIN_BATCH_BYTES = 1_048_576;
+export const BACKGROUND_BLE_LIMIT = { maxFiles: 3, budgetMs: 150_000 };
+/** 还没有实测蓝牙吞吐时的保守估算（与拉取超时的 3 KB/s 一致）。 */
+export const DEFAULT_BLE_BPS = 3_000;
+
+const WIFI_PLATFORMS: ReadonlySet<string> = new Set(['win32', 'darwin', 'linux']);
+
+export interface PlanInput {
+  setting: TransportSetting;
+  origin: DeviceOrigin;
+  allowBackgroundWifi: boolean;
+  files: Array<{ name: string; sizeBytes: number | null }>;
+  wifiCapable: boolean;
+  platform: NodeJS.Platform | string;
+  /** 实测蓝牙吞吐（字节/秒）；后台同步按它估算是否超出单轮时长预算。 */
+  bleBps?: number | null;
+}
+
+export interface TransferPlan {
+  transport: Transport;
+  include: string[];
+  deferred: string[];
+  reason: 'forced' | 'large-batch' | 'small-batch' | 'no-wifi-adapter' | 'unsupported-platform' | 'background-no-wifi';
+}
+
+type PlanFile = PlanInput['files'][number];
+
+/**
+ * 后台蓝牙单轮最多 maxFiles 个，且估算耗时不超过 budgetMs；大小未知的无法估算，留给下一次用户同步。
+ * 超出预算的文件挪到 deferred，保持录音笔按时释放、会话按时自动断开。
+ */
+function limitBackground(files: PlanFile[], bleBps: number | null | undefined): { include: string[]; deferred: string[] } {
+  const bps = bleBps && bleBps > 0 ? bleBps : DEFAULT_BLE_BPS;
+  const include: string[] = [];
+  const deferred: string[] = [];
+  let spentMs = 0;
+  for (const file of files) {
+    const costMs = file.sizeBytes === null ? Number.POSITIVE_INFINITY : (file.sizeBytes / bps) * 1000;
+    if (include.length < BACKGROUND_BLE_LIMIT.maxFiles && spentMs + costMs <= BACKGROUND_BLE_LIMIT.budgetMs) {
+      include.push(file.name);
+      spentMs += costMs;
+    } else {
+      deferred.push(file.name);
+    }
+  }
+  return { include, deferred };
+}
+
+export function parseTransportSetting(value: string): TransportSetting {
+  return value === 'wifi' || value === 'ble' ? value : 'auto';
+}
+
+export function planTransfer(input: PlanInput): TransferPlan {
+  const names = input.files.map((file) => file.name);
+  if (input.setting === 'ble') {
+    if (input.origin === 'auto') return { transport: 'ble', ...limitBackground(input.files, input.bleBps), reason: 'forced' };
+    return { transport: 'ble', include: names, deferred: [], reason: 'forced' };
+  }
+
+  const platformOk = WIFI_PLATFORMS.has(input.platform);
+  const wifiOk = input.setting === 'wifi' || (platformOk && input.wifiCapable);
+
+  if (input.origin === 'auto' && !input.allowBackgroundWifi) {
+    const small = input.files.filter((file) => file.sizeBytes !== null && file.sizeBytes < WIFI_MIN_BATCH_BYTES);
+    const smallNames = small.map((file) => file.name);
+    const limited = limitBackground(small, input.bleBps);
+    const deferred = [...names.filter((name) => !smallNames.includes(name)), ...limited.deferred];
+    return { transport: 'ble', include: limited.include, deferred, reason: 'background-no-wifi' };
+  }
+
+  const background = input.origin === 'auto';
+  if (!wifiOk) {
+    const reason = platformOk ? 'no-wifi-adapter' : 'unsupported-platform';
+    return background
+      ? { transport: 'ble', ...limitBackground(input.files, input.bleBps), reason }
+      : { transport: 'ble', include: names, deferred: [], reason };
+  }
+  if (input.setting === 'wifi') return { transport: 'wifi', include: names, deferred: [], reason: 'forced' };
+
+  const unknownSize = input.files.some((file) => file.sizeBytes === null);
+  const total = input.files.reduce((sum, file) => sum + (file.sizeBytes ?? 0), 0);
+  if (unknownSize || total >= WIFI_MIN_BATCH_BYTES) {
+    return { transport: 'wifi', include: names, deferred: [], reason: 'large-batch' };
+  }
+  return background
+    ? { transport: 'ble', ...limitBackground(input.files, input.bleBps), reason: 'small-batch' }
+    : { transport: 'ble', include: names, deferred: [], reason: 'small-batch' };
+}
+
+export type ExecFn = (command: string, args: string[]) => Promise<CommandOutcome>;
+
+const defaultExec: ExecFn = (command, args) => runCommand(command, args, 8000);
+
+/** Windows 24H2 起 netsh 可能因定位权限拒绝输出，但这本身说明本机有无线网卡。 */
+const LOCATION_HINT = /location|定位|位置/i;
+
+export function parseWifiProbe(platform: string, outcome: CommandOutcome): boolean {
+  const text = `${outcome.stdout}\n${outcome.stderr}`;
+  if (platform === 'win32') {
+    if (/no wireless interface|没有无线接口|wlansvc|is not running|未运行/i.test(text)) return false;
+    if (LOCATION_HINT.test(text)) return true;
+    if (!outcome.ok) return false;
+    if (/(Interface name|接口名称|Driver|驱动程序)\s*:/i.test(text)) return true;
+    // 非 UTF-8 代码页下字段名可能乱码；有多行 “字段 : 值” 的驱动块也算有网卡。
+    return outcome.stdout.split(/\r?\n/).filter((line) => /^\s*\S.*\s:\s+\S/.test(line)).length >= 3;
+  }
+  if (platform === 'darwin') return outcome.ok && /Wi-?Fi|AirPort/i.test(outcome.stdout);
+  if (platform === 'linux') return outcome.ok && /^wifi$/im.test(outcome.stdout);
+  return false;
+}
+
+function probeCommand(platform: string): [string, string[]] | null {
+  if (platform === 'win32') return ['netsh', ['wlan', 'show', 'drivers']];
+  if (platform === 'darwin') return ['networksetup', ['-listallhardwareports']];
+  if (platform === 'linux') return ['nmcli', ['-t', '-f', 'TYPE', 'dev']];
+  return null;
+}
+
+const CACHE_MS = 10 * 60_000;
+let cached: { platform: string; value: boolean; at: number } | null = null;
+
+export function resetWifiProbeCache(): void {
+  cached = null;
+}
+
+/** 缓存 10 分钟；假设备模式直接返回 true，保证测试走到无线快传分支。 */
+export async function probeWifiCapable(
+  exec: ExecFn = defaultExec,
+  platform: string = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<boolean> {
+  if (env.OPENMINUTES_FAKE_DEVICE) return true;
+  if (cached && cached.platform === platform && Date.now() - cached.at < CACHE_MS) return cached.value;
+  const command = probeCommand(platform);
+  const value = command ? parseWifiProbe(platform, await exec(command[0], command[1])) : false;
+  cached = { platform, value, at: Date.now() };
+  return value;
+}
+
+export function cachedWifiCapable(): boolean | null {
+  return cached ? cached.value : null;
+}
diff --git a/src/server/device/worker-script.ts b/src/server/device/worker-script.ts
new file mode 100644
index 0000000..00e98b2
--- /dev/null
+++ b/src/server/device/worker-script.ts
@@ -0,0 +1,765 @@
+// ABOUTME: 设备 worker 的 Python 源码：持有一个 MemoTalkClient，按 JSON-lines RPC 执行连接、清单、同步（无线快传优先，蓝牙回退）与删除。
+
+const NETWORK_PART = String.raw`#!/usr/bin/env python3
+"""OpenMinutes device worker.
+
+stdin:  one JSON command per line  {"id": 1, "cmd": "connect", "args": {...}}
+stdout: one JSON message per line  result / error / event / log
+Secrets (hotspot and FTP passwords) are only held in memory and scrubbed from every output.
+"""
+
+import argparse
+import asyncio
+import contextlib
+import json
+import os
+import re
+import runpy
+import socket
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+
+SECRETS = set()
+SECRET_KEYS = ("password", "keymaterial", "psk")
+OUT_LOCK = threading.Lock()
+LOCATION_HINT = re.compile(r"location|定位|位置", re.I)
+HOTSPOT_PROFILE = "openminutes-hotspot"
+STATE_DIR = Path(".")
+NET_PLATFORM = "linux"
+
+
+def scrub(value):
+    if isinstance(value, dict):
+        return {
+            key: ("***" if any(word in str(key).lower() for word in SECRET_KEYS) else scrub(item))
+            for key, item in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return [scrub(item) for item in value]
+    if isinstance(value, str):
+        for secret in SECRETS:
+            if secret:
+                value = value.replace(secret, "***")
+        return value
+    return value
+
+
+class ScrubbingStream:
+    def __init__(self, stream):
+        self._stream = stream
+
+    def write(self, text):
+        return self._stream.write(scrub(text))
+
+    def flush(self):
+        return self._stream.flush()
+
+    def __getattr__(self, name):
+        return getattr(self._stream, name)
+
+
+def emit(payload):
+    line = json.dumps(scrub(payload), ensure_ascii=False)
+    with OUT_LOCK:
+        sys.stdout.write(line + "\n")
+        sys.stdout.flush()
+
+
+def log(message, level="info"):
+    emit({"type": "log", "level": level, "message": message})
+
+
+def error_payload(error):
+    return {"kind": type(error).__name__, "message": str(error)[:2000]}
+
+
+class CancelledTransfer(Exception):
+    """Raised from progress callbacks when the user asked to stop."""
+
+
+class WifiJoinFailed(Exception):
+    pass
+
+
+class WifiUnreachable(Exception):
+    pass
+
+
+class SizeMismatch(Exception):
+    pass
+
+
+# ---------------------------------------------------------------------------
+# platform networking (module level so tests and the fake prelude can replace it)
+# ---------------------------------------------------------------------------
+def oem_encoding():
+    if sys.platform != "win32":
+        return "utf-8"
+    try:
+        import ctypes
+
+        return "cp%d" % ctypes.windll.kernel32.GetOEMCP()
+    except Exception:
+        return "utf-8"
+
+
+def decode_output(raw):
+    if raw is None:
+        return ""
+    if isinstance(raw, str):
+        return raw
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return raw.decode(oem_encoding(), errors="replace")
+
+
+def run_cmd(args, timeout=25):
+    proc = subprocess.run(args, capture_output=True, timeout=timeout)
+    return proc.returncode, decode_output(proc.stdout), decode_output(proc.stderr)
+
+
+def restore_path():
+    return STATE_DIR / "wifi-restore.json"
+
+
+def write_restore(state):
+    restore_path().write_text(json.dumps(state, ensure_ascii=False), encoding="utf-8")
+
+
+def read_restore():
+    try:
+        return json.loads(restore_path().read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def clear_restore():
+    with contextlib.suppress(FileNotFoundError):
+        restore_path().unlink()
+
+
+def parse_interfaces(text):
+    iface = None
+    profile = None
+    for line in text.splitlines():
+        key, sep, value = line.partition(":")
+        if not sep:
+            continue
+        key = key.strip().lower()
+        value = value.strip()
+        if key in ("name", "名称") and iface is None:
+            iface = value or None
+        elif key in ("profile", "配置文件") and profile is None:
+            profile = value or None
+    return iface, profile
+
+
+def xml_escape(text):
+    return (
+        text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        .replace('"', "&quot;").replace("'", "&apos;")
+    )
+
+
+def profile_xml(ssid, password):
+    hex_ssid = ssid.encode("utf-8").hex().upper()
+    return (
+        '<?xml version="1.0"?>\n'
+        '<WLANProfile xmlns="http://www.microsoft.com/networking/WLAN/profile/v1">\n'
+        "  <name>" + xml_escape(ssid) + "</name>\n"
+        "  <SSIDConfig><SSID><hex>" + hex_ssid + "</hex><name>" + xml_escape(ssid) + "</name></SSID></SSIDConfig>\n"
+        "  <connectionType>ESS</connectionType>\n"
+        "  <connectionMode>manual</connectionMode>\n"
+        "  <MSM><security>\n"
+        "    <authEncryption><authentication>WPA2PSK</authentication><encryption>AES</encryption><useOneX>false</useOneX></authEncryption>\n"
+        "    <sharedKey><keyType>passPhrase</keyType><protected>false</protected><keyMaterial>"
+        + xml_escape(password)
+        + "</keyMaterial></sharedKey>\n"
+        "  </security></MSM>\n"
+        "</WLANProfile>\n"
+    )
+
+
+def tail(text, limit=300):
+    return (text or "").strip()[-limit:]
+
+
+def join_windows(net):
+    code, out, err = run_cmd(["netsh", "wlan", "show", "interfaces"])
+    iface, profile = (None, None)
+    if code == 0 and not LOCATION_HINT.search(out + err):
+        iface, profile = parse_interfaces(out)
+    state = {"platform": "win32", "iface": iface, "profile": profile, "ssid": net.ssid}
+    write_restore(state)
+    xml_path = STATE_DIR / ("hotspot-%d.xml" % os.getpid())
+    xml_path.write_text(profile_xml(net.ssid, net.password), encoding="utf-8")
+    try:
+        code, out, err = run_cmd(["netsh", "wlan", "add", "profile", "filename=" + str(xml_path), "user=current"])
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            xml_path.unlink()
+    if code != 0:
+        raise WifiJoinFailed("netsh add profile failed: " + tail(out + err))
+    args = ["netsh", "wlan", "connect", "name=" + net.ssid, "ssid=" + net.ssid]
+    if iface:
+        args.append("interface=" + iface)
+    code, out, err = run_cmd(args)
+    if code != 0:
+        raise WifiJoinFailed("netsh connect failed: " + tail(out + err))
+    return state
+
+
+def mac_wifi_device(text):
+    lines = text.splitlines()
+    for index, line in enumerate(lines):
+        if re.search(r"Hardware Port:\s*(Wi-?Fi|AirPort)", line, re.I):
+            for follow in lines[index + 1 : index + 3]:
+                matched = re.match(r"\s*Device:\s*(\S+)", follow)
+                if matched:
+                    return matched.group(1)
+    return None
+
+
+def join_darwin(net):
+    code, out, err = run_cmd(["networksetup", "-listallhardwareports"])
+    iface = mac_wifi_device(out) if code == 0 else None
+    if not iface:
+        raise WifiJoinFailed("no Wi-Fi hardware port found: " + tail(out + err))
+    state = {"platform": "darwin", "iface": iface, "profile": None, "ssid": net.ssid}
+    write_restore(state)
+    address = net.join_hotspot(iface)
+    if not address:
+        raise WifiJoinFailed("joined hotspot but no address on " + iface)
+    return state
+
+
+def join_linux(net):
+    state = {"platform": "linux", "iface": None, "profile": HOTSPOT_PROFILE, "ssid": net.ssid}
+    write_restore(state)
+    run_cmd(["nmcli", "connection", "delete", HOTSPOT_PROFILE])
+    code, out, err = run_cmd([
+        "nmcli", "connection", "add", "type", "wifi", "con-name", HOTSPOT_PROFILE, "ssid", net.ssid,
+        "wifi-sec.key-mgmt", "wpa-psk", "connection.autoconnect", "no",
+    ])
+    if code != 0:
+        raise WifiJoinFailed("nmcli add failed: " + tail(out + err))
+    secret = STATE_DIR / ("nm-%d.pass" % os.getpid())
+    fd = os.open(str(secret), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write("802-11-wireless-security.psk:" + net.password + "\n")
+        code, out, err = run_cmd(["nmcli", "--wait", "20", "connection", "up", HOTSPOT_PROFILE, "passwd-file", str(secret)])
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            secret.unlink()
+    if code != 0:
+        raise WifiJoinFailed("nmcli up failed: " + tail(out + err))
+    return state
+
+
+def join_network(net):
+    if NET_PLATFORM == "win32":
+        return join_windows(net)
+    if NET_PLATFORM == "darwin":
+        return join_darwin(net)
+    if NET_PLATFORM == "linux":
+        return join_linux(net)
+    raise WifiJoinFailed("unsupported platform " + NET_PLATFORM)
+
+
+def leave_network(state):
+    """Leave the hotspot and remove the temporary profile. Best effort, never raises."""
+    if not state:
+        return
+    plat = state.get("platform")
+    iface = state.get("iface")
+    ssid = state.get("ssid") or ""
+    try:
+        if plat == "win32":
+            args = ["netsh", "wlan", "disconnect"] + (["interface=" + iface] if iface else [])
+            run_cmd(args)
+            if ssid:
+                run_cmd(["netsh", "wlan", "delete", "profile", "name=" + ssid])
+        elif plat == "darwin" and iface and ssid:
+            run_cmd(["networksetup", "-removepreferredwirelessnetwork", iface, ssid])
+        elif plat == "linux":
+            run_cmd(["nmcli", "connection", "delete", HOTSPOT_PROFILE])
+    except Exception as error:  # noqa: BLE001
+        log("leave network failed: %s: %s" % (type(error).__name__, error), "warn")
+
+
+def reconnect_original(state):
+    """Reconnect the network we were on; macOS and Linux rely on auto-reconnect."""
+    try:
+        if state and state.get("platform") == "win32" and state.get("profile"):
+            args = ["netsh", "wlan", "connect", "name=" + state["profile"]]
+            if state.get("iface"):
+                args.append("interface=" + state["iface"])
+            run_cmd(args)
+    except Exception as error:  # noqa: BLE001
+        log("reconnect failed: %s: %s" % (type(error).__name__, error), "warn")
+    finally:
+        clear_restore()
+
+
+NETWORK_RESTORE_WAIT = 25.0
+PROBE_HOSTS = (("223.5.5.5", 53), ("1.1.1.1", 53), ("8.8.8.8", 53))
+
+
+def network_usable():
+    """True when at least one well-known public host accepts a TCP connection."""
+    for host, port in PROBE_HOSTS:
+        try:
+            socket.create_connection((host, port), timeout=1.0).close()
+            return True
+        except OSError:
+            continue
+    return False
+
+
+def wait_network_back(state, timeout=None):
+    """netsh connect only queues the request and macOS/Linux rejoin on their own:
+    poll until traffic flows again so queued AI jobs do not start while still offline.
+    Returns (usable, seconds waited)."""
+    timeout = NETWORK_RESTORE_WAIT if timeout is None else timeout
+    started = time.monotonic()
+    retried = False
+    while True:
+        if network_usable():
+            return True, time.monotonic() - started
+        elapsed = time.monotonic() - started
+        if elapsed >= timeout:
+            return False, elapsed
+        if not retried and elapsed >= timeout / 2 and state and state.get("platform") == "win32" and state.get("profile"):
+            retried = True
+            args = ["netsh", "wlan", "connect", "name=" + state["profile"]]
+            if state.get("iface"):
+                args.append("interface=" + state["iface"])
+            with contextlib.suppress(Exception):
+                run_cmd(args)
+        time.sleep(1.0)
+
+
+def wait_reachable(host, port, timeout, cancelled):
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if cancelled():
+            return False
+        try:
+            socket.create_connection((host, port), timeout=1.0).close()
+            return True
+        except OSError:
+            time.sleep(1.0)
+    return False
+`;
+
+const WORKER_PART = String.raw`
+
+# ---------------------------------------------------------------------------
+# worker
+# ---------------------------------------------------------------------------
+WIFI_REASONS = {
+    "enable": "WIFI_ENABLE_FAILED",
+    "join": "WIFI_JOIN_FAILED",
+    "reach": "WIFI_UNREACHABLE",
+    "ftp": "WIFI_FTP_FAILED",
+    "transfer": "WIFI_TRANSFER_FAILED",
+}
+RECORDING_STATES = ("RECORDING", "PAUSED", "RESUMED")
+
+
+class Worker:
+    def __init__(self, args, memotalk):
+        self.args = args
+        self.memotalk = memotalk
+        self.dev = None
+        self.loop = None
+        self.inbox = None
+        self.lock = asyncio.Lock()
+        self.cancel = threading.Event()
+        self.tasks = set()
+        self.closing = False
+        self.stopped = False
+
+    # -- plumbing ------------------------------------------------------------
+    def read_stdin(self):
+        try:
+            for line in sys.stdin:
+                self.loop.call_soon_threadsafe(self.inbox.put_nowait, line)
+        except Exception:
+            pass
+        self.loop.call_soon_threadsafe(self.inbox.put_nowait, None)
+
+    def progress(self, req_id, **data):
+        emit({"id": req_id, "type": "event", "event": "progress", "data": data})
+
+    async def main(self):
+        self.loop = asyncio.get_running_loop()
+        self.inbox = asyncio.Queue()
+        pending = read_restore()
+        if pending:
+            log("restoring network left by an interrupted hotspot session")
+            await asyncio.to_thread(leave_network, pending)
+            await asyncio.to_thread(reconnect_original, pending)
+        threading.Thread(target=self.read_stdin, daemon=True).start()
+        watchdog = asyncio.create_task(self.watch())
+        try:
+            while not self.stopped:
+                line = await self.inbox.get()
+                if line is None:
+                    # Node went away: stop transfers, let hotspot cleanup finish, then close.
+                    self.cancel.set()
+                    await self.drain()
+                    await self.close_device()
+                    break
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    message = json.loads(line)
+                except ValueError:
+                    log("ignored non-JSON input", "warn")
+                    continue
+                if message.get("cmd") == "cancel":
+                    self.cancel.set()
+                    emit({"id": message.get("id"), "type": "result", "data": {"cancelling": True}})
+                    continue
+                if message.get("cmd") in ("pull", "delete"):
+                    # Clear here, in arrival order: a cancel that follows this line must still win,
+                    # even if it is read before the task gets to run.
+                    self.cancel.clear()
+                task = asyncio.create_task(self.dispatch(message))
+                self.tasks.add(task)
+                task.add_done_callback(self.tasks.discard)
+            await self.drain()
+        finally:
+            watchdog.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await watchdog
+
+    async def drain(self):
+        while self.tasks:
+            await asyncio.gather(*list(self.tasks), return_exceptions=True)
+
+    async def watch(self):
+        while True:
+            await asyncio.sleep(5.0)
+            if self.dev is None or self.closing or self.lock.locked():
+                continue
+            if not self.dev.is_connected:
+                emit({"type": "event", "event": "disconnected", "data": {"reason": "ConnectionLost"}})
+                self.dev = None
+                self.stopped = True
+                self.inbox.put_nowait("")
+                return
+
+    async def dispatch(self, message):
+        req_id = message.get("id")
+        cmd = message.get("cmd")
+        args = message.get("args") or {}
+        async with self.lock:
+            handler = getattr(self, "cmd_" + str(cmd), None)
+            if handler is None:
+                emit({"id": req_id, "type": "error", "error": {"kind": "UnknownCommand", "message": str(cmd)}})
+                return
+            try:
+                data = await handler(req_id, args)
+                emit({"id": req_id, "type": "result", "data": data})
+            except Exception as error:  # noqa: BLE001
+                emit({"id": req_id, "type": "error", "error": error_payload(error)})
+
+    def require_device(self):
+        if self.dev is None or not self.dev.is_connected:
+            raise self.memotalk.ConnectionLost("recorder is not connected")
+        return self.dev
+
+    async def close_device(self):
+        if self.dev is None:
+            return
+        self.closing = True
+        with contextlib.suppress(Exception):
+            await self.dev.close()
+        self.dev = None
+
+    # -- commands ------------------------------------------------------------
+    async def cmd_connect(self, req_id, args):
+        if self.dev is not None and self.dev.is_connected:
+            target = self.dev.transport.target
+            return {"address": getattr(target, "address", None), "hotspotWasOn": False, "timeSynced": False}
+        options = {"scan_timeout": 6.0}
+        if self.args.prefer:
+            options["prefer"] = self.args.prefer
+        dev = self.memotalk.MemoTalkClient(**options)
+        await dev.connect()
+        self.dev = dev
+        time_synced = False
+        try:
+            time_synced = bool(await dev.sync_time())
+        except Exception as error:  # noqa: BLE001
+            log("sync_time failed: %s: %s" % (type(error).__name__, error), "warn")
+        hotspot_was_on = False
+        try:
+            if await dev.wifi.hotspot_state():
+                hotspot_was_on = True
+                await dev.wifi.disable()
+        except Exception as error:  # noqa: BLE001
+            log("hotspot self-check failed: %s: %s" % (type(error).__name__, error), "warn")
+        target = dev.transport.target
+        return {"address": getattr(target, "address", None), "hotspotWasOn": hotspot_was_on, "timeSynced": time_synced}
+
+    async def cmd_status(self, req_id, args):
+        dev = self.require_device()
+        identity = await dev.identity()
+        battery = await dev.battery()
+        firmware = await dev.firmware()
+        free_space = await dev.free_space()
+        record = await dev.record.state()
+        version = getattr(firmware, "version", None) or getattr(firmware, "raw", None)
+        return {
+            "serial": identity.serial,
+            "model": "MemoTalk S1",
+            "firmware": version,
+            "batteryPct": battery.percent,
+            "freeSpacePct": free_space.percent,
+            "recordingState": record.state.name,
+            "storageFormat": identity.format_name,
+        }
+
+    async def cmd_list(self, req_id, args):
+        dev = self.require_device()
+        files = []
+        for entry in await dev.files.list():
+            files.append({
+                "name": entry.name,
+                "format": entry.format_name,
+                "sizeBytes": entry.size,
+                "durationSec": entry.duration_sec,
+                "timestamp": entry.timestamp,
+            })
+        return {"files": files}
+
+    async def cmd_delete(self, req_id, args):
+        dev = self.require_device()
+        results = []
+        for name in args.get("names") or []:
+            try:
+                await dev.files.delete(str(name))
+                results.append({"name": name, "ok": True})
+            except Exception as error:  # noqa: BLE001
+                results.append({"name": name, "ok": False, "error": error_payload(error)})
+        return {"files": results}
+
+    async def cmd_disconnect(self, req_id, args):
+        await self.close_device()
+        self.stopped = True
+        self.inbox.put_nowait("")
+        return {"disconnected": True}
+
+    async def cmd_pull(self, req_id, args):
+        dev = self.require_device()
+        files = [f for f in (args.get("files") or []) if f.get("name")]
+        out_dir = Path(args.get("outDir") or ".")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        results = {}
+        remaining = list(files)
+        counter = {"index": 0, "count": len(files)}
+        if args.get("transport") == "wifi" and remaining:
+            remaining = await self.pull_wifi(req_id, dev, remaining, out_dir, results, counter)
+        if remaining and not self.cancel.is_set():
+            await self.pull_ble(req_id, dev, remaining, out_dir, results, counter)
+        ordered = [results[f["name"]] for f in files if f["name"] in results]
+        return {"files": ordered, "cancelled": self.cancel.is_set()}
+
+    # -- Wi-Fi hotspot + FTP -------------------------------------------------
+    async def pull_wifi(self, req_id, dev, files, out_dir, results, counter):
+        remaining = list(files)
+        stage = "enable"
+        failure = None
+        joined = None
+        online_before = False
+        self.progress(req_id, phase="preparing", transport="wifi", file=None, bytes=0, total=None,
+                      index=0, count=counter["count"])
+        try:
+            async with dev.wifi.session() as net:
+                SECRETS.add(net.password)
+                SECRETS.add(net.ftp_config.password)
+                try:
+                    if self.cancel.is_set():
+                        raise CancelledTransfer()
+                    # Only wait for the network to come back afterwards if it was usable before.
+                    online_before = await asyncio.to_thread(network_usable)
+                    stage = "join"
+                    joined = await asyncio.to_thread(join_network, net)
+                    stage = "reach"
+                    reachable = await asyncio.to_thread(
+                        wait_reachable, net.ftp_config.host, net.ftp_config.port, 20.0, self.cancel.is_set)
+                    if self.cancel.is_set():
+                        raise CancelledTransfer()
+                    if not reachable:
+                        raise WifiUnreachable("%s not reachable within 20s" % net.ftp_config.address)
+                    stage = "ftp"
+                    ftp = await asyncio.to_thread(net.open_ftp)
+                    try:
+                        names = await asyncio.to_thread(net.list_audio_files, ftp)
+                        by_lower = {name.lower(): name for name in names}
+                        stage = "transfer"
+                        for item in list(remaining):
+                            if self.cancel.is_set():
+                                raise CancelledTransfer()
+                            remote = by_lower.get(item["name"].lower())
+                            if remote is None:
+                                continue  # left for BLE
+                            counter["index"] += 1
+                            path, size = await asyncio.to_thread(
+                                self.ftp_fetch, ftp, remote, item, out_dir, req_id, counter)
+                            results[item["name"]] = {"name": item["name"], "path": str(path), "sizeBytes": size,
+                                                     "transport": "wifi", "ok": True}
+                            remaining.remove(item)
+                    finally:
+                        with contextlib.suppress(Exception):
+                            ftp.close()
+                except CancelledTransfer:
+                    pass
+                except Exception as error:  # noqa: BLE001
+                    failure = (stage, error)
+                finally:
+                    self.progress(req_id, phase="restoring", transport="wifi", file=None, bytes=0, total=None,
+                                  index=counter["index"], count=counter["count"])
+                    await asyncio.to_thread(leave_network, joined or read_restore())
+        except Exception as error:  # noqa: BLE001
+            if failure is None:
+                failure = (stage, error)
+        report = dev.wifi.last_close_report
+        if report is not None and not report.get("confirmed", True):
+            emit({"id": req_id, "type": "event", "event": "warning",
+                  "data": {"code": "HOTSPOT_CLOSE_UNCONFIRMED", "detail": str(report.get("error") or "")}})
+        restore = joined or read_restore()
+        await asyncio.to_thread(reconnect_original, restore)
+        if restore and online_before:
+            # Node reopens the network gate on our result/fallback: report only once the network works.
+            usable, waited = await asyncio.to_thread(wait_network_back, restore)
+            if not usable:
+                emit({"id": req_id, "type": "event", "event": "warning",
+                      "data": {"code": "NETWORK_RESTORE_TIMEOUT",
+                               "detail": "original network not usable %.0fs after leaving the hotspot" % waited}})
+        if failure is not None and remaining and not self.cancel.is_set():
+            stage_name, error = failure
+            unsupported = type(error).__name__ == "CapabilityUnavailable"
+            reason = "WIFI_UNSUPPORTED" if unsupported else WIFI_REASONS.get(stage_name, "WIFI_TRANSFER_FAILED")
+            emit({"id": req_id, "type": "event", "event": "fallback",
+                  "data": {"from": "wifi", "to": "ble", "reason": reason,
+                           "detail": "%s: %s" % (type(error).__name__, error)}})
+        return remaining
+
+    def ftp_fetch(self, ftp, remote, item, out_dir, req_id, counter):
+        expected = item.get("size") or None
+        total = expected
+        with contextlib.suppress(Exception):
+            ftp.voidcmd("TYPE I")
+            reported = ftp.size(remote)
+            if reported:
+                total = int(reported)
+        part = out_dir / (item["name"] + ".part")
+        state = {"done": 0, "last": 0.0}
+
+        def write(chunk):
+            if self.cancel.is_set():
+                raise CancelledTransfer()
+            handle.write(chunk)
+            state["done"] += len(chunk)
+            now = time.monotonic()
+            if now - state["last"] >= 0.25:
+                state["last"] = now
+                self.progress(req_id, phase="transferring", transport="wifi", file=item["name"],
+                              bytes=state["done"], total=total, index=counter["index"], count=counter["count"])
+
+        try:
+            with open(part, "wb") as handle:
+                ftp.retrbinary("RETR " + remote, write, blocksize=32768)
+            size = part.stat().st_size
+            if expected and size != expected:
+                raise SizeMismatch("%s: got %d bytes, device reported %d" % (item["name"], size, expected))
+            final = out_dir / item["name"]
+            os.replace(part, final)
+            return final, size
+        except BaseException:
+            with contextlib.suppress(FileNotFoundError):
+                part.unlink()
+            raise
+
+    # -- BLE -----------------------------------------------------------------
+    async def pull_ble(self, req_id, dev, files, out_dir, results, counter):
+        sync_op = self.memotalk.SyncOp
+        for item in files:
+            if self.cancel.is_set():
+                return
+            name = item["name"]
+            counter["index"] += 1
+            size = item.get("size") or None
+            state = {"last": 0.0}
+
+            def on_progress(received, total_packets, _name=name, _size=size):
+                if self.cancel.is_set():
+                    raise CancelledTransfer()
+                now = time.monotonic()
+                if now - state["last"] >= 0.25 or received == total_packets:
+                    state["last"] = now
+                    done = received * 320
+                    if _size:
+                        done = min(done, _size)
+                    self.progress(req_id, phase="transferring", transport="ble", file=_name, bytes=done,
+                                  total=_size, index=counter["index"], count=counter["count"])
+
+            try:
+                path = await dev.files.download(name, out_dir, size=size, overwrite=True, progress=on_progress)
+                results[name] = {"name": name, "path": str(path), "sizeBytes": Path(path).stat().st_size,
+                                 "transport": "ble", "ok": True}
+            except CancelledTransfer:
+                with contextlib.suppress(Exception):
+                    await dev.files.sync_control(name, sync_op.CANCEL)
+                return
+            except Exception as error:  # noqa: BLE001
+                results[name] = {"name": name, "transport": "ble", "ok": False, "error": error_payload(error)}
+                if not dev.is_connected:
+                    return
+
+
+def main():
+    global STATE_DIR, NET_PLATFORM
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--state-dir", required=True)
+    parser.add_argument("--prefer")
+    parser.add_argument("--fake-prelude")
+    parser.add_argument("--net-platform", choices=["win32", "darwin", "linux"])
+    args = parser.parse_args()
+    STATE_DIR = Path(args.state_dir)
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    platform = sys.platform
+    NET_PLATFORM = args.net_platform or ("linux" if platform.startswith("linux") else platform)
+    sys.stderr = ScrubbingStream(sys.stderr)
+
+    try:
+        import memotalk
+    except Exception as error:  # noqa: BLE001
+        emit({"type": "event", "event": "fatal", "data": error_payload(error)})
+        return 3
+    if args.fake_prelude:
+        runpy.run_path(args.fake_prelude, run_name="openminutes_fake_prelude")
+
+    worker = Worker(args, memotalk)
+    try:
+        asyncio.run(worker.main())
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+`;
+
+export const DEVICE_WORKER_SCRIPT = NETWORK_PART + WORKER_PART;
diff --git a/src/server/device/worker.ts b/src/server/device/worker.ts
new file mode 100644
index 0000000..7266772
--- /dev/null
+++ b/src/server/device/worker.ts
@@ -0,0 +1,217 @@
+// ABOUTME: 设备 worker 客户端：写出脚本、派生 Python 进程、按 id 关联 JSON-lines 请求与响应、超时与终止。
+
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { AppError } from '../../contracts/errors';
+import { terminateChild } from '../media';
+import { pythonRuntimeEnv } from '../tools';
+import { classifyDeviceError } from './errors';
+import { FAKE_DEVICE_PRELUDE } from './fake-device';
+import { DEVICE_WORKER_SCRIPT } from './worker-script';
+
+export type WorkerCommand = 'connect' | 'status' | 'list' | 'pull' | 'delete' | 'disconnect';
+
+export interface WorkerEvent {
+  id?: number;
+  event: string;
+  data: Record<string, unknown>;
+}
+
+export interface RequestOptions {
+  timeoutMs: number;
+  onEvent?: (event: WorkerEvent) => void;
+}
+
+export interface WorkerHandle {
+  request<T>(cmd: WorkerCommand, args?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+  /** 协作式取消：worker 在安全点停下，热点会话照常恢复网络。 */
+  cancel(): void;
+  /** 关闭 stdin 让 worker 自行收尾，超时后强制结束。 */
+  close(timeoutMs?: number): Promise<void>;
+  kill(): void;
+  onEvent(listener: (event: WorkerEvent) => void): void;
+  onExit(listener: (code: number | null) => void): void;
+  readonly exited: boolean;
+  stderrTail(): string;
+}
+
+export interface SpawnWorkerOptions {
+  python: string;
+  stateDir: string;
+  prefer: string | null;
+  env?: NodeJS.ProcessEnv;
+  netPlatform?: 'win32' | 'darwin' | 'linux';
+}
+
+export type SpawnWorker = (options: SpawnWorkerOptions) => Promise<WorkerHandle>;
+
+interface Pending {
+  cmd: WorkerCommand;
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  onEvent?: (event: WorkerEvent) => void;
+  timer: NodeJS.Timeout;
+}
+
+/** 脚本写成文件再执行，避开 Windows 命令行长度与引号问题。 */
+export async function writeWorkerFiles(stateDir: string, env: NodeJS.ProcessEnv = process.env): Promise<{ script: string; prelude: string | null }> {
+  await mkdir(stateDir, { recursive: true });
+  const script = path.join(stateDir, 'worker.py');
+  await writeFile(script, DEVICE_WORKER_SCRIPT, 'utf8');
+  if (!env.OPENMINUTES_FAKE_DEVICE) return { script, prelude: null };
+  const prelude = path.join(stateDir, 'fake_device.py');
+  await writeFile(prelude, FAKE_DEVICE_PRELUDE, 'utf8');
+  return { script, prelude };
+}
+
+export function attachWorker(child: ChildProcessWithoutNullStreams): WorkerHandle {
+  const pending = new Map<number, Pending>();
+  const eventListeners: Array<(event: WorkerEvent) => void> = [];
+  const exitListeners: Array<(code: number | null) => void> = [];
+  let nextId = 1;
+  let exited = false;
+  let stderr = '';
+  let stdoutBuffer = '';
+  let fatal: { kind: string; message: string } | null = null;
+
+  const failAll = (code: number | null) => {
+    for (const [id, item] of pending) {
+      clearTimeout(item.timer);
+      pending.delete(id);
+      item.reject(fatal
+        ? classifyDeviceError(fatal.kind, fatal.message, { op: item.cmd, exitCode: code, stderrTail: stderr })
+        : new AppError('DEVICE_DISCONNECTED', undefined, `worker exited (code ${code ?? '-'})\n${stderr.slice(-2000)}`));
+    }
+  };
+
+  const handleLine = (line: string) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let message: Record<string, unknown>;
+    try {
+      message = JSON.parse(trimmed) as Record<string, unknown>;
+    } catch {
+      stderr = `${stderr}${trimmed}\n`.slice(-8000);
+      return;
+    }
+    const id = typeof message.id === 'number' ? message.id : undefined;
+    const item = id !== undefined ? pending.get(id) : undefined;
+    if (message.type === 'result' || message.type === 'error') {
+      if (!item || id === undefined) return;
+      clearTimeout(item.timer);
+      pending.delete(id);
+      if (message.type === 'result') item.resolve(message.data ?? null);
+      else {
+        const error = (message.error ?? {}) as { kind?: string; message?: string };
+        item.reject(classifyDeviceError(error.kind ?? 'Error', error.message ?? '', { op: item.cmd, stderrTail: stderr }));
+      }
+      return;
+    }
+    if (message.type === 'event') {
+      const event: WorkerEvent = {
+        id,
+        event: String(message.event ?? ''),
+        data: (message.data ?? {}) as Record<string, unknown>,
+      };
+      if (event.event === 'fatal') fatal = event.data as { kind: string; message: string };
+      item?.onEvent?.(event);
+      for (const listener of eventListeners) listener(event);
+      return;
+    }
+    if (message.type === 'log') {
+      const event: WorkerEvent = { event: 'log', data: { level: message.level, message: message.message } };
+      for (const listener of eventListeners) listener(event);
+    }
+  };
+
+  child.stdout.on('data', (chunk: Buffer) => {
+    stdoutBuffer += chunk.toString('utf8');
+    const lines = stdoutBuffer.split(/\r?\n/);
+    stdoutBuffer = lines.pop() ?? '';
+    for (const line of lines) handleLine(line);
+  });
+  child.stderr.on('data', (chunk: Buffer) => {
+    stderr = `${stderr}${chunk.toString('utf8')}`.slice(-8000);
+  });
+  child.stdin.on('error', () => undefined);
+  const onExit = (code: number | null) => {
+    if (exited) return;
+    exited = true;
+    if (stdoutBuffer) handleLine(stdoutBuffer);
+    failAll(code);
+    for (const listener of exitListeners) listener(code);
+  };
+  child.on('close', onExit);
+  child.on('error', (error) => {
+    stderr = `${stderr}${error.message}\n`.slice(-8000);
+    if (!fatal) fatal = { kind: 'ModuleNotFoundError', message: `cannot start Python: ${error.message}` };
+    onExit(null);
+  });
+
+  const send = (payload: Record<string, unknown>) => {
+    if (exited || child.stdin.destroyed) return false;
+    child.stdin.write(`${JSON.stringify(payload)}\n`);
+    return true;
+  };
+
+  return {
+    request<T>(cmd: WorkerCommand, args: Record<string, unknown> = {}, options: RequestOptions = { timeoutMs: 60_000 }) {
+      return new Promise<T>((resolve, reject) => {
+        if (exited) {
+          reject(new AppError('DEVICE_DISCONNECTED', undefined, `worker already exited\n${stderr.slice(-2000)}`));
+          return;
+        }
+        const id = nextId++;
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new AppError('DEVICE_TIMEOUT', undefined, `worker command ${cmd} exceeded ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+        timer.unref?.();
+        pending.set(id, { cmd, resolve: resolve as (value: unknown) => void, reject, onEvent: options.onEvent, timer });
+        send({ id, cmd, args });
+      });
+    },
+    cancel() {
+      send({ id: nextId++, cmd: 'cancel' });
+    },
+    async close(timeoutMs = 5000) {
+      if (exited) return;
+      const done = new Promise<void>((resolve) => exitListeners.push(() => resolve()));
+      child.stdin.end();
+      const timer = setTimeout(() => {
+        if (!exited) terminateChild(child);
+      }, timeoutMs);
+      timer.unref?.();
+      await done;
+      clearTimeout(timer);
+    },
+    kill() {
+      if (!exited) terminateChild(child);
+    },
+    onEvent(listener) {
+      eventListeners.push(listener);
+    },
+    onExit(listener) {
+      exitListeners.push(listener);
+    },
+    get exited() {
+      return exited;
+    },
+    stderrTail() {
+      return stderr.slice(-4000);
+    },
+  };
+}
+
+export const spawnDeviceWorker: SpawnWorker = async (options) => {
+  const env = options.env ?? process.env;
+  const { script, prelude } = await writeWorkerFiles(options.stateDir, env);
+  const args = ['-X', 'utf8', '-u', script, '--state-dir', options.stateDir];
+  if (options.prefer) args.push('--prefer', options.prefer);
+  if (prelude) args.push('--fake-prelude', prelude);
+  if (options.netPlatform) args.push('--net-platform', options.netPlatform);
+  const runtimeEnv = await pythonRuntimeEnv(options.python, env);
+  const child = spawn(options.python, args, { windowsHide: true, env: runtimeEnv });
+  return attachWorker(child);
+};
diff --git a/src/server/environment-repair.ts b/src/server/environment-repair.ts
index 26578ef..79212a0 100644
--- a/src/server/environment-repair.ts
+++ b/src/server/environment-repair.ts
@@ -1,8 +1,10 @@
 import { randomUUID } from 'node:crypto';
+import { AppError } from '../contracts/errors';
 import type { HostClient } from '../../sdk/host-contracts.mjs';
 import type { PreflightReport, RepairState } from '../contracts/preflight';
 import { hostChecks } from './preflight';
 import type { RepairStore } from './repair-store';
+import type { NetworkGate } from './network-gate';
 
 export function repairPrompt(report: PreflightReport, workingDirectory: string): string {
   return [
@@ -27,6 +29,8 @@ export function createEnvironmentRepair(options: {
   workingDirectory: string;
   store: RepairStore;
   pollMs?: number;
+  /** 录音笔无线快传期间电脑断开外网，修复请求快速失败。 */
+  gate?: Pick<NetworkGate, 'assertOnline'>;
 }) {
   let state = options.store.load();
   let pending: Promise<RepairState> | null = null;
@@ -55,7 +59,7 @@ export function createEnvironmentRepair(options: {
         ? await options.host.agent.get({ runId: current.runId })
         : await options.host.agent.findByIdempotencyKey({ idempotencyKey: current.idempotencyKey });
       if (disposed) return;
-      if (!run) throw new Error('Host 暂未找到任务，不能据此确认提交未执行');
+      if (!run) throw new AppError('REPAIR_NOT_FOUND', '修复任务暂时找不到，请重试', `runId=${current.runId ?? '-'} idempotencyKey=${current.idempotencyKey}`);
       if (run.status === 'running' || run.status === 'cancelling') {
         save({ ...current, runId: run.runId, status: 'running', text: run.text || `已恢复 Host 任务：${run.status}` });
         schedule();
@@ -71,17 +75,21 @@ export function createEnvironmentRepair(options: {
       }
     } catch (error) {
       if (disposed) return;
-      state = { ...current, status: 'unknown', text: `提交结果未知，禁止重复提交。正在恢复任务 ${current.idempotencyKey}：${String(error)}` };
+      state = { ...current, status: 'unknown', text: `提交结果未知，禁止重复提交，正在恢复修复任务。
+${String(error)}` };
       try { options.store.save(state); } catch { /* The prior durable intent still blocks after restart. */ }
       schedule();
     }
   }
   async function begin(): Promise<RepairState> {
     if (active(state)) return state;
+    options.gate?.assertOnline();
     const report = await options.report();
     const agent = (await hostChecks(options.host)).find((item) => item.id === 'host-agent');
-    if (agent?.status !== 'ok') throw new Error(agent?.reason ?? 'agent 不可用');
-    if (!report.items.some((item) => item.status === 'fail' && item.autoRepair)) throw new Error('没有可自动修复的失败项');
+    if (agent?.status !== 'ok') {
+      throw new AppError('HOST_AGENT_UNAVAILABLE', 'Floatboat 助手暂不可用', `agent 不可用：${agent?.detail ?? agent?.reason ?? 'unknown'}`);
+    }
+    if (!report.items.some((item) => item.status === 'fail' && item.autoRepair)) throw new AppError('NOTHING_TO_REPAIR', '没有可自动修复的失败项');
     const idempotencyKey = `openminutes-preflight-${randomUUID()}`;
     if (disposed) return state;
     save({ status: 'starting', idempotencyKey, runId: null, text: '已保存提交意图，正在请求 Floatboat 助手。' });
diff --git a/src/server/http.ts b/src/server/http.ts
index 3f46cd6..a68e49c 100644
--- a/src/server/http.ts
+++ b/src/server/http.ts
@@ -1,29 +1,63 @@
-// ABOUTME: 统一 API 响应信封与错误映射，页面只需判断 ok 字段。
+// ABOUTME: 统一 API 响应信封与错误映射，页面只需判断 ok 字段；技术原文只进 detail。
 
 import type { RouteContext } from '../../sdk/runtime.mjs';
 import { BadInput } from '../contracts/input';
-
-export type ApiResult<T> = { ok: true; data: T } | { ok: false; error: string; code: string };
+import { AppError, ERROR_COPY, type ErrorAction } from '../contracts/errors';
 
 export interface ApiFailure {
   ok: false;
   error: string;
   code: string;
+  detail?: string;
+  action?: ErrorAction;
+}
+
+export type ApiResult<T> = { ok: true; data: T } | ApiFailure;
+
+const ERRNO_CODES: Record<string, string> = {
+  EACCES: 'NO_PERMISSION',
+  EPERM: 'NO_PERMISSION',
+  ENOSPC: 'DISK_FULL',
+  ENOENT: 'FILE_MOVED',
+};
+
+function isSystemError(error: unknown): error is NodeJS.ErrnoException {
+  if (error === null || typeof error !== 'object') return false;
+  const record = error as Record<string, unknown>;
+  return typeof record.errno === 'number' || typeof record.syscall === 'string';
 }
 
-function errorCode(error: unknown): string {
-  if (error instanceof BadInput) return 'INVALID_INPUT';
-  if (error !== null && typeof error === 'object') {
-    const record = error as Record<string, unknown>;
-    if (typeof record.code === 'string' && record.code) return record.code;
+function failure(code: string, message: string, detail?: string, action?: ErrorAction): ApiFailure {
+  return {
+    ok: false,
+    error: message,
+    code,
+    ...(detail ? { detail } : {}),
+    ...(action ? { action } : {}),
+  };
+}
+
+/** 把任意异常映射为失败信封：系统错误换成中文结论，原文进 detail。 */
+export function toFailure(error: unknown): ApiFailure {
+  if (error instanceof AppError) return failure(error.code, error.message, error.detail, error.action);
+  if (error instanceof BadInput) return failure('INVALID_INPUT', error.message);
+  if (isSystemError(error)) {
+    const code = ERRNO_CODES[String(error.code ?? '')] ?? 'INTERNAL_ERROR';
+    const copy = ERROR_COPY[code] ?? ERROR_COPY.INTERNAL_ERROR;
+    return failure(code, copy.message, String(error.message ?? error).slice(0, 2000), copy.action);
+  }
+  if (error instanceof Error) {
+    const code = (error as { code?: unknown }).code;
+    if (typeof code === 'string' && code) return failure(code, error.message || ERROR_COPY.INTERNAL_ERROR.message);
+    return failure('INTERNAL_ERROR', ERROR_COPY.INTERNAL_ERROR.message, String(error.stack ?? error.message).slice(0, 2000));
   }
-  return 'INTERNAL_ERROR';
+  return failure('INTERNAL_ERROR', ERROR_COPY.INTERNAL_ERROR.message, String(error).slice(0, 2000));
 }
 
 export function errorMessage(error: unknown): string {
   if (error instanceof Error && error.message) return error.message;
   if (typeof error === 'string' && error) return error;
-  return '操作失败，请稍后重试';
+  return ERROR_COPY.INTERNAL_ERROR.message;
 }
 
 export type Handler<T> = (context: RouteContext) => T | Promise<T>;
@@ -34,7 +68,7 @@ export function api<T>(handler: Handler<T>): (context: RouteContext) => Promise<
     try {
       return { ok: true, data: await handler(context) };
     } catch (error) {
-      return { ok: false, error: errorMessage(error), code: errorCode(error) };
+      return toFailure(error);
     }
   };
 }
diff --git a/src/server/index.ts b/src/server/index.ts
index 79234bf..dfba144 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -1,11 +1,14 @@
-// ABOUTME: 组装服务入口，业务路由按领域拆分在 routes/ 下。
+// ABOUTME: 组装服务入口，业务路由按领域拆分在 routes/ 下；设备服务是录音笔的唯一所有者。
 
 import { createWorkbenchServer } from '../../sdk/runtime.mjs';
+import { AppError } from '../contracts/errors';
 import { registerAppRoute } from './app-route';
-import { startAutoConnect } from './auto-connect';
+import { startAutoConnect } from './device/auto-connect';
+import { createDeviceService } from './device/service';
 import { registerCategoryRoutes } from './routes/categories';
 import { registerCalendarRoutes } from './routes/calendar';
 import { registerDeviceRoutes } from './routes/device';
+import { registerDiagnosticsRoutes } from './routes/diagnostics';
 import { registerIngestRoutes } from './routes/ingest';
 import { registerLiveRoutes } from './routes/live';
 import { registerMediaRoutes } from './routes/media';
@@ -25,11 +28,25 @@ registerPipelineRoutes(app);
 registerCategoryRoutes(app);
 registerIngestRoutes(app);
 registerMediaRoutes(app);
-registerLiveRoutes(app);
 const preflight = registerEnvironmentRoutes(app);
-registerDeviceRoutes(app, preflight);
+
+const device = createDeviceService(app, {
+  // 环境自检已知 Python 或设备 SDK 不可用时直接报 RUNTIME_MISSING，不派生 worker。
+  resolvePython: async () => {
+    let { env } = await preflight.get();
+    if (!env.python.resolvedPath || !env.sdk.ok || !env.bleak.ok) ({ env } = await preflight.get(true));
+    if (!env.python.resolvedPath || !env.sdk.ok || !env.bleak.ok) {
+      const failed = [env.python, env.bleak, env.sdk].filter((probe) => !probe.ok).map((probe) => probe.detail);
+      throw new AppError('RUNTIME_MISSING', undefined, failed.join('\n'));
+    }
+    return env.python.resolvedPath;
+  },
+});
+registerDeviceRoutes(app, device, preflight);
+registerDiagnosticsRoutes(app, device, preflight);
+registerLiveRoutes(app, device);
 registerSettingRoutes(app);
 
-startAutoConnect(app);
+startAutoConnect({ db: app.database, service: device });
 await app.listen();
 void preflight.get().catch((error) => console.error('preflight failed', error));
diff --git a/src/server/ingest.ts b/src/server/ingest.ts
index ba20125..f54197c 100644
--- a/src/server/ingest.ts
+++ b/src/server/ingest.ts
@@ -5,7 +5,10 @@ import { existsSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import type { DatabaseSync } from 'node:sqlite';
-import type { ImportDirectoryState, IngestScanResult, ParsedDeviceFile } from '../contracts/app';
+import type { ImportDirectoryState, IngestScanResult } from '../contracts/app';
+import type { ParsedDeviceFile } from '../contracts/device';
+import { AppError } from '../contracts/errors';
+import { toFailure } from './http';
 import { fileSize, probeDurationSec } from './media';
 import { nowIso, num, row, run, str, strOr, touchRecording, writeSetting } from './sql';
 import { ensureMonthDir, expandHome, resolveStoredPath } from './library';
@@ -103,7 +106,7 @@ export interface ImportOneInput {
   source: 'folder_import' | 'device_pull';
 }
 
-export type ImportOutcome = { outcome: 'imported'; id: number } | { outcome: 'skipped'; reason: string } | { outcome: 'failed'; reason: string };
+export type ImportOutcome = { outcome: 'imported'; id: number } | { outcome: 'skipped'; reason: string } | { outcome: 'failed'; reason: string; detail?: string };
 
 /** 复制单个音频文件并登记；重复文件按 dedupe_key 跳过而不是覆盖。 */
 export async function importAudioFile(input: ImportOneInput): Promise<ImportOutcome> {
@@ -130,7 +133,8 @@ export async function importAudioFile(input: ImportOneInput): Promise<ImportOutc
     ).lastId;
     return { outcome: 'imported', id };
   } catch (error) {
-    return { outcome: 'failed', reason: error instanceof Error ? error.message : '写入失败' };
+    const failure = toFailure(error);
+    return { outcome: 'failed', reason: failure.error, detail: failure.detail ?? (error instanceof Error ? error.message : String(error)) };
   }
 }
 
@@ -178,7 +182,7 @@ export async function scanImportDirectory(
       result.files.push({ filename: entry.name, outcome: 'skipped', reason: outcome.reason });
     } else {
       result.failed += 1;
-      result.files.push({ filename: entry.name, outcome: 'failed', reason: outcome.reason });
+      result.files.push({ filename: entry.name, outcome: 'failed', reason: outcome.reason, ...(outcome.detail ? { detail: outcome.detail } : {}) });
     }
   }
   return result;
@@ -314,7 +318,9 @@ export async function ensureImportDir(directory: string): Promise<boolean> {
     return true;
   } catch (error) {
     const detail = error instanceof Error ? error.message : '未知错误';
-    throw new IngestError('DIR_NOT_CREATABLE', `无法创建导入目录：${directory}（${detail}）`);
+    const failure = toFailure(error);
+    throw new AppError(failure.code === 'INTERNAL_ERROR' ? 'DIR_NOT_CREATABLE' : failure.code,
+      failure.code === 'INTERNAL_ERROR' ? '无法创建导入目录，请在设置里换一个文件夹。' : failure.error, `${directory}: ${detail}`, failure.action);
   }
 }
 
diff --git a/src/server/live-asr.ts b/src/server/live-asr.ts
index 563fef4..5854978 100644
--- a/src/server/live-asr.ts
+++ b/src/server/live-asr.ts
@@ -13,10 +13,25 @@ export interface AsrBridgeState {
   restarts: number;
   pcmBytes: number;
   message: string | null;
+  /** 宿主错误码与原文，只在「查看详情」里显示；保留最近 4 KB。 */
+  detail?: string;
   partial: string;
   finals: string[];
 }
 
+const RECONNECTING = '识别连接中断，正在重连…';
+
+export function appendDetail(rt: { detail?: string }, text: string): void {
+  rt.detail = `${rt.detail ?? ''}${text}
+`.slice(-4096);
+}
+
+function errorText(error: unknown): string {
+  if (error === null || typeof error !== 'object') return String(error);
+  const record = error as Record<string, unknown>;
+  return [record.code, record.message].filter((part) => typeof part === 'string' && part).join(': ') || String(error);
+}
+
 function isSessionGone(error: unknown): boolean {
   if (error === null || typeof error !== 'object') return false;
   const record = error as Record<string, unknown>;
@@ -34,7 +49,10 @@ function consumeEvents(rt: AsrBridgeState, streamId: string): Promise<void> {
         if (event.type === 'done') break;
         if (event.type === 'result') {
           const status = event.session.status;
-          if (event.session.errorCode) rt.message = event.session.errorCode;
+          if (event.session.errorCode) {
+            rt.message = RECONNECTING;
+            appendDetail(rt, `session ${event.session.status}: ${event.session.errorCode}`);
+          }
           if (status === 'cancelled' || status === 'failed' || status === 'completed') {
             const text = event.session.text.trim();
             if (text && rt.finals.length === firstFinal) rt.finals.push(text);
@@ -45,9 +63,8 @@ function consumeEvents(rt: AsrBridgeState, streamId: string): Promise<void> {
         }
         const progress = event.event;
         if (progress.type === 'error') {
-          rt.message = progress.errorCode
-            ? `识别服务异常（${progress.errorCode}），正在重连…`
-            : '识别服务异常，正在重连…';
+          rt.message = RECONNECTING;
+          if (progress.errorCode) appendDetail(rt, `event error: ${progress.errorCode}`);
           rt.streamId = null;
           rt.seq = 0;
           continue;
@@ -82,7 +99,8 @@ async function ensureStream(rt: AsrBridgeState): Promise<boolean> {
     rt.eventsDone = consumeEvents(rt, started.streamId);
     return true;
   } catch (error) {
-    rt.message = `识别服务启动失败：${error instanceof Error ? error.message : '未知错误'}`;
+    rt.message = '语音识别暂时不可用，请确认已在 Floatboat 登录并开启语音识别。';
+    appendDetail(rt, `asr.start: ${errorText(error)}`);
     return false;
   }
 }
@@ -115,7 +133,8 @@ async function drainFrames(rt: AsrBridgeState): Promise<void> {
     } catch (error) {
       rt.queue.shift();
       if (!isSessionGone(error)) {
-        rt.message = error instanceof Error ? error.message : '识别推流中断';
+        rt.message = RECONNECTING;
+        appendDetail(rt, `asr.sendFrame: ${errorText(error)}`);
         continue;
       }
       // 会话被回收/上游异常：丢掉旧 streamId，下一帧自动重建。
@@ -123,7 +142,7 @@ async function drainFrames(rt: AsrBridgeState): Promise<void> {
       rt.seq = 0;
       rt.restarts += 1;
       if (rt.restarts > 4) {
-        rt.message = '识别服务连续失败，请点「停止并归档」后重新开始';
+        rt.message = '识别服务连续失败，请点「停止并保存」后重新开始';
         break;
       }
       rt.message = '识别会话已重置，正在自动重连…';
@@ -139,9 +158,13 @@ export async function finishLiveAsr(rt: AsrBridgeState): Promise<string> {
     try {
       const final = await rt.app.host.asr.stop({ streamId: rt.streamId });
       fallback = final.text.trim();
-      if (final.errorCode) rt.message = final.errorCode;
+      if (final.errorCode) {
+        rt.message = '识别收尾没有完成，已识别的字幕不受影响。';
+        appendDetail(rt, `asr.stop: ${final.errorCode}`);
+      }
     } catch (error) {
-      rt.message = `识别收尾失败：${error instanceof Error ? error.message : '未知错误'}`;
+      rt.message = '识别收尾没有完成，已识别的字幕不受影响。';
+      appendDetail(rt, `asr.stop: ${errorText(error)}`);
     }
   }
   if (rt.eventsDone) {
diff --git a/src/server/live-script.ts b/src/server/live-script.ts
index fee2c23..d55e34b 100644
--- a/src/server/live-script.ts
+++ b/src/server/live-script.ts
@@ -32,7 +32,7 @@ def main():
     try:
         from memotalk import MemoTalkClient
     except Exception as error:  # noqa: BLE001
-        log("error", stage="import", message="%s: %s" % (type(error).__name__, error))
+        log("error", stage="import", kind=type(error).__name__, message=str(error))
         return 3
 
     loop_holder = {}
@@ -110,7 +110,7 @@ def main():
                 log("stopped", audio_bytes=total)
             return 0
         except Exception as error:  # noqa: BLE001
-            log("error", stage="stream", message="%s: %s" % (type(error).__name__, error))
+            log("error", stage="stream", kind=type(error).__name__, message=str(error))
             return 4
 
     try:
diff --git a/src/server/live.ts b/src/server/live.ts
index e8af1f4..7739c01 100644
--- a/src/server/live.ts
+++ b/src/server/live.ts
@@ -1,18 +1,21 @@
 // ABOUTME: 实时字幕会话：编排采集脚本、ffmpeg 解码与 Host ASR 流式识别。
 
 import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { AppError, type AppErrorView } from '../contracts/errors';
+import type { DeviceService } from './device/service';
+import { classifyDeviceError } from './device/errors';
 import { createWriteStream, type WriteStream } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import type { WorkbenchServer } from '../../sdk/runtime.mjs';
 import type { LiveState } from '../contracts/app';
-import { probePython, probeSdk, pythonRuntimeEnv, resolveFfmpeg } from './bridge';
+import { probePython, probeSdk, pythonRuntimeEnv, resolveFfmpeg } from './runtime-probe';
 import { autoTranscribeIfEnabled, queueOrganization } from './jobs';
 import { ensureMonthDir, libraryRoot } from './library';
 import { fileSize, terminateChild } from './media';
 import { nowIso, readSetting, row, run } from './sql';
 import { liveScriptSource } from './live-script';
-import { finishLiveAsr, pumpFrames } from './live-asr';
+import { appendDetail, finishLiveAsr, pumpFrames } from './live-asr';
 import { createPcmFramer, LIVE_DECODER_ARGS } from './live-audio';
 
 const PCM_BYTES_PER_SECOND = 32_000;
@@ -21,6 +24,10 @@ interface Runtime {
   app: WorkbenchServer;
   status: 'starting' | 'listening' | 'error';
   message: string | null;
+  detail?: string;
+  error: AppErrorView | null;
+  service: DeviceService | null;
+  released: boolean;
   startedAt: number;
   endedAt: number | null;
   finals: string[];
@@ -51,13 +58,24 @@ interface SavedLive {
 let current: Runtime | null = null;
 let lastSaved: SavedLive | null = null;
 
-export class LiveError extends Error {
-  readonly code: string;
-  constructor(code: string, message: string) {
-    super(message);
-    this.name = 'LiveError';
-    this.code = code;
-  }
+/** 页面只显示 message；脚本与识别服务的原文合并进 detail。 */
+function liveError(rt: Runtime): AppErrorView | null {
+  if (!rt.error) return null;
+  const detail = [rt.error.detail, rt.detail].filter(Boolean).join('\n');
+  return detail ? { ...rt.error, detail } : rt.error;
+}
+
+function fail(rt: Runtime, error: AppError): void {
+  rt.status = 'error';
+  rt.message = error.message;
+  rt.error = error.toView();
+}
+
+/** 采集结束后把录音笔交还设备服务（只交还一次）。 */
+function releaseDevice(rt: Runtime): void {
+  if (rt.released || !rt.service) return;
+  rt.released = true;
+  void rt.service.releaseFromLive().catch(() => undefined);
 }
 
 export function getLiveState(): LiveState {
@@ -74,6 +92,7 @@ export function getLiveState(): LiveState {
       partial: '',
       deviceName: null,
       lastSaved,
+      error: null,
     };
   }
   return {
@@ -88,6 +107,7 @@ export function getLiveState(): LiveState {
     partial: current.partial,
     deviceName: current.deviceName,
     lastSaved,
+    error: liveError(current),
   };
 }
 
@@ -109,7 +129,8 @@ function handleStderrLine(rt: Runtime, line: string): void {
   const trimmed = line.trim();
   if (!trimmed) return;
   if (!trimmed.startsWith('{')) {
-    rt.message = rt.message ?? trimmed.slice(0, 200);
+    // 非 JSON 的输出（traceback 等）只进技术详情，不直接显示给用户。
+    appendDetail(rt, trimmed.slice(0, 500));
     return;
   }
   try {
@@ -119,29 +140,35 @@ function handleStderrLine(rt: Runtime, line: string): void {
     if (event === 'streaming') {
       rt.status = 'listening';
       rt.message = null;
+      rt.error = null;
     }
     if (event === 'error') {
-      rt.status = 'error';
-      rt.message = String(payload.message ?? '采集脚本报错');
+      const kind = String(payload.kind ?? 'Error');
+      fail(rt, classifyDeviceError(kind, String(payload.message ?? ''), { op: 'live', stderrTail: rt.detail }));
     }
   } catch {
-    /* 非法 JSON 行忽略 */
+    appendDetail(rt, trimmed.slice(0, 500));
   }
 }
 
-export async function startLive(app: WorkbenchServer): Promise<LiveState> {
-  if (current && !current.exited) throw new LiveError('ALREADY_RUNNING', '实时字幕已经在运行');
+function runtimeMissing(detail: string): AppError {
+  return new AppError('RUNTIME_MISSING', undefined, detail);
+}
+
+export async function startLive(app: WorkbenchServer, service: DeviceService): Promise<LiveState> {
+  if (current && !current.exited) throw new AppError('LIVE_RUNNING', '实时字幕已经在运行');
 
   const db = app.database;
-  const { command: pythonCommand } = await probePython(readSetting(db, 'python_path'));
-  if (!pythonCommand) throw new LiveError('NO_PYTHON', '未找到 Python 解释器，无法启动采集脚本');
+  const { command: pythonCommand, probe } = await probePython(readSetting(db, 'python_path'));
+  if (!pythonCommand) throw runtimeMissing(probe.detail);
   const sdk = await probeSdk(pythonCommand);
-  if (!sdk.ok) throw new LiveError('NO_SDK', sdk.detail);
+  if (!sdk.ok) throw runtimeMissing(sdk.detail);
   const ffmpegPath = await resolveFfmpeg(db);
-  if (!ffmpegPath) throw new LiveError('NO_FFMPEG', '未找到 ffmpeg，无法解码音频流');
+  if (!ffmpegPath) throw runtimeMissing('ffmpeg not found; set ffmpeg_path in 设置 › 诊断与高级');
 
   const dataDir = await resolveDataDirectory(app);
   const script = await ensureScript(dataDir);
+  const env = await pythonRuntimeEnv(pythonCommand);
 
   lastSaved = null;
   const startedAt = Date.now();
@@ -149,10 +176,16 @@ export async function startLive(app: WorkbenchServer): Promise<LiveState> {
   const stamp = new Date(startedAt).toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '_');
   const filePath = path.join(monthDir, `LIVE_${stamp}.mp3`);
 
+  // 设备服务是录音笔的唯一所有者：由它断开 worker 并派生采集脚本；同步中会抛 DEVICE_BUSY。
+  const python = await service.claimForLive({ pythonCommand, scriptPath: script, env, scanTimeoutSec: 12 });
+
   const session: Runtime = {
     app,
     status: 'starting',
     message: null,
+    error: null,
+    service,
+    released: false,
     startedAt,
     endedAt: null,
     finals: [],
@@ -161,7 +194,7 @@ export async function startLive(app: WorkbenchServer): Promise<LiveState> {
     audioBytes: 0,
     filePath,
     deviceName: null,
-    python: null,
+    python,
     ffmpeg: null,
     fileStream: null,
     streamId: null,
@@ -176,29 +209,18 @@ export async function startLive(app: WorkbenchServer): Promise<LiveState> {
   current = session;
 
   try {
-    const env = await pythonRuntimeEnv(pythonCommand);
-    const python = spawn(pythonCommand, ['-X', 'utf8', script, '--scan-timeout', '12'], {
-      windowsHide: true,
-      ...(env ? { env } : {}),
-    });
-    const ffmpeg = spawn(
-      ffmpegPath,
-      LIVE_DECODER_ARGS,
-      { windowsHide: true },
-    );
-    session.python = python;
+    const ffmpeg = spawn(ffmpegPath, LIVE_DECODER_ARGS, { windowsHide: true });
     session.ffmpeg = ffmpeg;
     for (const child of [python, ffmpeg]) {
       child.stdin.on('error', (error) => {
         if (!session.stopping) {
-          session.status = 'error';
-          session.message = error.message;
+          appendDetail(session, `stdin: ${error.message}`);
+          fail(session, new AppError('DECODE_FAILED', undefined, error.message));
         }
       });
     }
     ffmpeg.on('error', (error) => {
-      session.status = 'error';
-      session.message = error.message;
+      fail(session, new AppError('RUNTIME_MISSING', undefined, `ffmpeg: ${error.message}`));
       terminateChild(python);
     });
     session.fileStream = createWriteStream(filePath);
@@ -226,26 +248,27 @@ export async function startLive(app: WorkbenchServer): Promise<LiveState> {
       session.exited = true;
       session.endedAt = Date.now();
       if (!session.stopping && session.status !== 'error') {
-        session.status = 'error';
-        session.message = session.message ?? `采集脚本退出（退出码 ${code ?? '未知'}）`;
+        fail(session, new AppError('DEVICE_DISCONNECTED', undefined, `live capture exited (code ${code ?? '-'})\n${session.detail ?? ''}`));
       }
       if (!ffmpeg.stdin.destroyed) ffmpeg.stdin.end();
+      // 用户主动停止时由 stopLive 在保存后交还；意外退出立即交还。
+      if (!session.stopping) releaseDevice(session);
     });
     python.on('error', (error) => {
       session.exited = true;
       session.endedAt = Date.now();
-      session.status = 'error';
-      session.message = `采集脚本启动失败：${error.message}`;
+      fail(session, new AppError('RUNTIME_MISSING', undefined, `cannot start live capture: ${error.message}`));
+      releaseDevice(session);
     });
 
     return getLiveState();
   } catch (error) {
     session.exited = true;
     session.endedAt = Date.now();
-    session.status = 'error';
-    session.message = error instanceof Error ? error.message : '启动失败';
+    terminateChild(python);
+    releaseDevice(session);
     current = null;
-    throw error instanceof LiveError ? error : new LiveError('START_FAILED', session.message ?? '启动失败');
+    throw error instanceof AppError ? error : new AppError('INTERNAL_ERROR', undefined, String(error));
   }
 }
 
@@ -298,12 +321,14 @@ export async function stopLive(app: WorkbenchServer): Promise<LiveState> {
     await closeFileStream(session.fileStream);
 
     if (session.audioBytes === 0 && !text) {
-      session.message = session.message ?? '这次没有采集到音频（设备可能未唤醒或未进入录音）';
+      session.message = session.message ?? '这次没有采集到音频（录音笔可能未唤醒或未在录音）';
     } else {
       lastSaved = await persistSession(app, session, text);
     }
   } finally {
     current = null;
+    // 采集脚本已退出：把录音笔交还设备服务，之前是用户连接的会自动恢复连接。
+    releaseDevice(session);
   }
   return getLiveState();
 }
diff --git a/src/server/network-gate.ts b/src/server/network-gate.ts
new file mode 100644
index 0000000..2415626
--- /dev/null
+++ b/src/server/network-gate.ts
@@ -0,0 +1,97 @@
+// ABOUTME: 网络闸门：录音笔无线快传期间电脑会断开外网，暂停 Host 任务并让队列外调用快速失败。
+
+import { AppError } from '../contracts/errors';
+
+export interface AcquireOptions {
+  /** 等待进行中的网络任务结束的上限；超时则放弃断网并返回 null。 */
+  waitForInFlightMs: number;
+  /** 中止时恢复闸门并立即返回 null（用户停止或断开）。 */
+  signal?: AbortSignal;
+}
+
+export class NetworkGate {
+  private offlineReason: string | null = null;
+  private inFlight = 0;
+  private onlineWaiters: Array<() => void> = [];
+  private idleWaiters: Array<() => void> = [];
+
+  isOffline(): boolean {
+    return this.offlineReason !== null;
+  }
+
+  reason(): string | null {
+    return this.offlineReason;
+  }
+
+  runningNetworkTasks(): number {
+    return this.inFlight;
+  }
+
+  whenOnline(): Promise<void> {
+    if (!this.offlineReason) return Promise.resolve();
+    return new Promise((resolve) => this.onlineWaiters.push(resolve));
+  }
+
+  /** 队列外的 Host 调用在断网期间快速失败。 */
+  assertOnline(): void {
+    if (this.offlineReason) throw new AppError('NETWORK_PAUSED', undefined, `network gate held by ${this.offlineReason}`);
+  }
+
+  /** 网络任务先等闸门打开；检查与计数在同一同步段内完成，避免与断网申请交错。 */
+  async runNetworkTask<T>(task: () => Promise<T>): Promise<T> {
+    while (this.offlineReason) await this.whenOnline();
+    this.inFlight += 1;
+    try {
+      return await task();
+    } finally {
+      this.inFlight -= 1;
+      if (this.inFlight === 0) this.flush('idle');
+    }
+  }
+
+  /** 先关闸，再等进行中的网络任务结束；超时恢复闸门并返回 null。 */
+  async acquireOffline(reason: string, options: AcquireOptions): Promise<(() => void) | null> {
+    if (this.offlineReason || options.signal?.aborted) return null;
+    this.offlineReason = reason;
+    if (this.inFlight > 0) {
+      const idle = await new Promise<boolean>((resolve) => {
+        const finish = (value: boolean) => {
+          clearTimeout(timer);
+          options.signal?.removeEventListener('abort', onAbort);
+          this.idleWaiters = this.idleWaiters.filter((waiter) => waiter !== done);
+          resolve(value);
+        };
+        const timer = setTimeout(() => finish(false), options.waitForInFlightMs);
+        timer.unref?.();
+        const done = () => finish(true);
+        const onAbort = () => finish(false);
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        this.idleWaiters.push(done);
+      });
+      if (!idle) {
+        this.open();
+        return null;
+      }
+    }
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.open();
+    };
+  }
+
+  private open(): void {
+    this.offlineReason = null;
+    this.flush('online');
+  }
+
+  private flush(kind: 'online' | 'idle'): void {
+    const waiters = kind === 'online' ? this.onlineWaiters : this.idleWaiters;
+    if (kind === 'online') this.onlineWaiters = [];
+    else this.idleWaiters = [];
+    for (const waiter of waiters) waiter();
+  }
+}
+
+export const networkGate = new NetworkGate();
diff --git a/src/server/pipeline.ts b/src/server/pipeline.ts
index 37a1c8e..c76e75c 100644
--- a/src/server/pipeline.ts
+++ b/src/server/pipeline.ts
@@ -3,9 +3,11 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { HostClient } from '../../sdk/host.mjs';
 import { finishJob, num, nowIso, pruneTags, readSetting, row, run, startJob, str, strOr, touchRecording } from './sql';
-import { transcribeAudioFile } from './transcribe';
-import { organizeRecording } from './organize';
-import { resolveFfmpeg } from './bridge';
+import { TranscribeError, transcribeAudioFile } from './transcribe';
+import { OrganizeError, organizeRecording } from './organize';
+import { resolveFfmpeg } from './runtime-probe';
+import { AppError, ERROR_COPY } from '../contracts/errors';
+import { toFailure } from './http';
 import { isBusyStatus } from '../contracts/recording-status';
 
 export { isBusyStatus } from '../contracts/recording-status';
@@ -21,14 +23,57 @@ export interface PipelineResult {
   message: string;
 }
 
-export function describeError(error: unknown): string {
-  if (error !== null && typeof error === 'object') {
-    const record = error as Record<string, unknown>;
-    const code = typeof record.code === 'string' ? record.code : null;
-    const message = typeof record.message === 'string' ? record.message : null;
-    if (message) return code ? `${message}（${code}）` : message;
+export interface DescribedError {
+  code: string;
+  message: string;
+  detail: string | null;
+}
+
+/** 引擎/宿主错误码 → 面向用户的统一 code；原文全部进 detail。 */
+const STAGE_CODES: Record<string, string> = {
+  ASR_START_FAILED: 'ASR_START_FAILED',
+  ASR_UNSTABLE: 'ASR_UNSTABLE',
+  ASR_TIMEOUT: 'ASR_UNSTABLE',
+  ASR_EMPTY: 'ASR_EMPTY',
+  DECODE_FAILED: 'DECODE_FAILED',
+  AUDIO_EMPTY: 'DECODE_FAILED',
+  LLM_OBJECT_INVALID: 'LLM_INCOMPLETE',
+  BAD_MODEL_OUTPUT: 'LLM_INCOMPLETE',
+};
+
+const HOST_CODE = /HOST|CAPABILITY|ACCOUNT|PERMISSION|AUTH|QUOTA|MODEL/;
+
+export function describeError(error: unknown, stage: 'transcribe' | 'organize' = 'transcribe'): DescribedError {
+  if (error instanceof AppError) return { code: error.code, message: error.message, detail: error.detail ?? null };
+  const record = (error !== null && typeof error === 'object' ? error : {}) as Record<string, unknown>;
+  const rawCode = typeof record.code === 'string' ? record.code : null;
+  const rawMessage = typeof record.message === 'string' ? record.message : error instanceof Error ? error.message : String(error);
+  const requestId = typeof record.requestId === 'string' ? `\nrequestId=${record.requestId}` : '';
+  const detail = `${rawCode ? `${rawCode}: ` : ''}${rawMessage}${requestId}`.slice(0, 4000);
+  if (typeof record.errno === 'number' || typeof record.syscall === 'string') {
+    const failure = toFailure(error);
+    return { code: failure.code, message: failure.error, detail: failure.detail ?? detail };
   }
-  return error instanceof Error ? error.message : '未知错误';
+  let code = rawCode ? STAGE_CODES[rawCode] : undefined;
+  if (!code && rawCode && HOST_CODE.test(rawCode)) code = stage === 'transcribe' ? 'ASR_START_FAILED' : 'LLM_UNAVAILABLE';
+  if (code) return { code, message: ERROR_COPY[code]?.message ?? rawMessage, detail };
+  if (rawCode && ERROR_COPY[rawCode]) return { code: rawCode, message: ERROR_COPY[rawCode].message, detail };
+  // 只有本应用自己抛出的业务错误自带中文提示，可以直接展示；
+  // Host 或引擎的其它原始 code 一律收敛为通用文案，原文只进 detail。
+  if (rawCode && (error instanceof TranscribeError || error instanceof OrganizeError)) {
+    return { code: rawCode, message: rawMessage, detail };
+  }
+  const fallback = rawCode && stage === 'transcribe' ? 'ASR_START_FAILED' : 'INTERNAL_ERROR';
+  return { code: fallback, message: ERROR_COPY[fallback].message, detail };
+}
+
+function failRecording(db: DatabaseSync, recordingId: number, status: string, failure: DescribedError): void {
+  touchRecording(db, recordingId, {
+    status,
+    last_error: failure.message,
+    last_error_code: failure.code,
+    last_error_detail: failure.detail,
+  });
 }
 
 function settingOn(db: DatabaseSync, key: string): boolean {
@@ -52,19 +97,19 @@ export async function runTranscription(deps: PipelineDeps, recordingId: number):
 
   const storagePath = str(recording.storage_path);
   if (!storagePath) {
-    const message = '这条录音还没有音频文件，请先完成设备拉取或目录导入。';
-    touchRecording(db, recordingId, { status: 'failed', last_error: message });
+    const message = '这条录音还没有音频文件，请先在「录音笔」页同步或导入。';
+    failRecording(db, recordingId, 'failed', { code: 'NO_AUDIO_FILE', message, detail: null });
     return { ok: false, message };
   }
 
   const ffmpegPath = await resolveFfmpeg(db);
   if (!ffmpegPath) {
-    const message = '未找到 ffmpeg，无法解码音频。请在设置中填写 ffmpeg 的绝对路径。';
-    touchRecording(db, recordingId, { status: 'failed', last_error: message });
-    return { ok: false, message };
+    const failure = { code: 'RUNTIME_MISSING', message: '还没有找到音频处理工具，无法读取音频。', detail: 'ffmpeg not found; set ffmpeg_path in 设置 › 诊断与高级' };
+    failRecording(db, recordingId, 'failed', failure);
+    return { ok: false, message: failure.message };
   }
   const jobId = startJob(db, 'transcribe', recordingId);
-  touchRecording(db, recordingId, { status: 'transcribing', last_error: null });
+  touchRecording(db, recordingId, { status: 'transcribing', last_error: null, last_error_code: null, last_error_detail: null });
 
   try {
     const absolute = await deps.resolveAudio(storagePath);
@@ -107,6 +152,8 @@ export async function runTranscription(deps: PipelineDeps, recordingId: number):
       duration_sec: durationSec,
       status: 'transcribed',
       last_error: null,
+      last_error_code: null,
+      last_error_detail: null,
     });
     finishJob(db, jobId, 'success', `识别 ${outcome.text.length} 字`, {
       chars: outcome.text.length,
@@ -120,12 +167,12 @@ export async function runTranscription(deps: PipelineDeps, recordingId: number):
     }
     return { ok: true, message: '转录完成' };
   } catch (error) {
-    const message = describeError(error);
-    touchRecording(db, recordingId, { status: 'failed', last_error: message });
+    const failure = describeError(error, 'transcribe');
+    failRecording(db, recordingId, 'failed', failure);
     const trace = (error as { trace?: { events: unknown[] } } | null)?.trace?.events;
-    console.error(`[transcribe] recording ${recordingId} failed: ${message}`);
-    finishJob(db, jobId, 'failure', message, trace ? { trace } : undefined);
-    return { ok: false, message };
+    console.error(`[transcribe] recording ${recordingId} failed: ${failure.code} ${failure.detail ?? failure.message}`);
+    finishJob(db, jobId, 'failure', failure.message, { code: failure.code, detail: failure.detail, ...(trace ? { trace } : {}) });
+    return { ok: false, message: failure.message };
   }
 }
 
@@ -139,7 +186,7 @@ export async function runOrganization(deps: PipelineDeps, recordingId: number):
   if (strOr(recording.status, '') === 'analyzing') return { ok: false, message: '该录音正在归类中' };
 
   const jobId = startJob(db, 'organize', recordingId);
-  touchRecording(db, recordingId, { status: 'analyzing', last_error: null });
+  touchRecording(db, recordingId, { status: 'analyzing', last_error: null, last_error_code: null, last_error_detail: null });
   try {
     const result = await organizeRecording(db, deps.host, recordingId);
     finishJob(db, jobId, 'success', `已归入「${result.categorySlug}」`, {
@@ -151,9 +198,9 @@ export async function runOrganization(deps: PipelineDeps, recordingId: number):
     pruneTags(db);
     return { ok: true, message: '归类完成' };
   } catch (error) {
-    const message = describeError(error);
-    touchRecording(db, recordingId, { status: 'transcribed', last_error: message });
-    finishJob(db, jobId, 'failure', message);
-    return { ok: false, message };
+    const failure = describeError(error, 'organize');
+    failRecording(db, recordingId, 'transcribed', failure);
+    finishJob(db, jobId, 'failure', failure.message, { code: failure.code, detail: failure.detail });
+    return { ok: false, message: failure.message };
   }
 }
diff --git a/src/server/preflight.ts b/src/server/preflight.ts
index 2908d00..e3cf23e 100644
--- a/src/server/preflight.ts
+++ b/src/server/preflight.ts
@@ -1,3 +1,5 @@
+// ABOUTME: 本机环境自检：系统、录音笔组件、音频处理、语音识别与 AI 整理、存储目录；技术原文进 detail。
+
 import { mkdtemp, mkdir, writeFile, unlink, rmdir } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -5,29 +7,34 @@ import { randomUUID } from 'node:crypto';
 import type { WorkbenchServer } from '../../sdk/runtime.mjs';
 import type { HostClient } from '../../sdk/host-contracts.mjs';
 import type { DeviceEnv } from '../contracts/app';
+import type { HostCapabilities, HostCapability } from '../contracts/device';
 import type { PreflightItem, PreflightReport } from '../contracts/preflight';
-import { probeEnvironment, pythonRuntimeEnv } from './bridge';
+import { probeEnvironment, pythonRuntimeEnv } from './runtime-probe';
 import { libraryRoot } from './library';
 import { resolveImportDir } from './ingest';
 import { runCommand, verifyDecodable } from './media';
 
 export function systemCheck(platform: string, arch: string): PreflightItem {
   const supported = ['win32', 'darwin', 'linux'].includes(platform) && ['x64', 'arm64'].includes(arch);
-  return { id: 'system', label: '系统与架构', status: supported ? 'ok' : 'fail',
-    reason: `${platform} / ${arch}`, autoRepair: false, action: supported ? '' : '请使用支持的 Windows、macOS 或 Linux x64/arm64 环境。' };
+  return { id: 'system', label: '系统与架构', group: 'device', status: supported ? 'ok' : 'fail',
+    reason: supported ? '系统受支持' : '当前系统不受支持', detail: `${platform} / ${arch}`, autoRepair: false,
+    action: supported ? '' : '请使用支持的 Windows、macOS 或 Linux x64/arm64 环境。' };
 }
 
+const RUNTIME_ACTION = '在本应用目录执行 uv venv --python 3.12 .venv，再执行 uv pip install --python .venv bleak memotalk-sdk（已有 .venv 不要覆盖）。用 uv run --no-project --python .venv python -c "import bleak, memotalk" 验证，再重新检测；自定义解释器需在设置中切换。';
+
 export function dependencyChecks(env: DeviceEnv): PreflightItem[] {
   return ([
-    ['python', 'Python >=3.10', env.python],
-    ['bleak', 'bleak', env.bleak],
-    ['sdk', 'memotalk-sdk', env.sdk],
-    ['ffmpeg', 'ffmpeg', env.ffmpeg],
-  ] as const).map(([id, label, probe]) => ({
-    id, label, status: probe.ok ? 'ok' : 'fail', reason: probe.detail, autoRepair: !probe.ok,
+    ['python', 'Python 运行环境', 'device', env.python, '已就绪', '没有找到可用的 Python'],
+    ['bleak', '蓝牙组件', 'device', env.bleak, '已就绪', '蓝牙组件不可用'],
+    ['sdk', '录音笔组件', 'device', env.sdk, '已就绪', '录音笔组件不可用'],
+    ['ffmpeg', '音频处理工具', 'audio', env.ffmpeg, '已就绪', '没有找到音频处理工具'],
+  ] as const).map(([id, label, group, probe, okText, failText]) => ({
+    id, label, group, status: probe.ok ? 'ok' : 'fail', reason: probe.ok ? okText : failText, detail: probe.detail,
+    autoRepair: !probe.ok,
     action: probe.ok ? '' : id === 'ffmpeg'
       ? '安装用户级 ffmpeg，或在设置中填写已安装的 ffmpeg 绝对路径；系统级安装需先确认。'
-      : '在本应用目录执行 uv venv --python 3.12 .venv，再执行 uv pip install --python .venv bleak memotalk-sdk（已有 .venv 不要覆盖）。用 uv run --no-project --python .venv python -c "import bleak, memotalk" 验证，再重新检测；自定义解释器需在设置中切换。',
+      : RUNTIME_ACTION,
   }));
 }
 
@@ -37,13 +44,17 @@ const requiredOperations: Record<string, string[]> = {
   agent: ['start', 'get'],
 };
 
+const capabilityLabels: Record<string, string> = { asr: '语音识别', llm: 'AI 整理', agent: 'Floatboat 助手' };
+
 export function capabilityCheck(domain: string, entries: Array<{ operation: string; declared: boolean; status: string }>): PreflightItem {
   const available = new Set(entries.filter((entry) => entry.declared && entry.status === 'available')
     .map((entry) => entry.operation.startsWith(`${domain}.`) ? entry.operation.slice(domain.length + 1) : entry.operation));
   const missing = (requiredOperations[domain] ?? []).filter((operation) => !available.has(operation));
+  const label = capabilityLabels[domain] ?? domain;
   return {
-    id: `host-${domain}`, label: `Host ${domain}`, status: missing.length ? 'warn' : 'ok', autoRepair: false,
-    reason: missing.length ? `${domain} 不可用：${missing.join(', ')}` : '能力已声明且可用；调用授权由 Host 检查',
+    id: `host-${domain}`, label, group: 'ai', status: missing.length ? 'warn' : 'ok', autoRepair: false,
+    reason: missing.length ? `${label}暂不可用` : '可用',
+    detail: missing.length ? `${domain} 不可用：${missing.join(', ')}` : '能力已声明且可用；调用授权由 Host 检查',
     action: missing.length ? '在 Floatboat 中打开应用，授权对应能力并检查模型账户配置。' : '',
   };
 }
@@ -53,36 +64,52 @@ export async function hostChecks(host: Pick<HostClient, 'capabilities'>): Promis
     try {
       return capabilityCheck(domain, (await host.capabilities.list({ domain })).capabilities);
     } catch (error) {
-      return { ...capabilityCheck(domain, []), reason: `${domain} 不可用：${error instanceof Error ? error.message : String(error)}` };
+      return { ...capabilityCheck(domain, []), detail: `${domain} 不可用：${error instanceof Error ? error.message : String(error)}` };
     }
   }));
 }
 
+/** 宿主能力清单的唯一来源：诊断页与验证脚本都读它。 */
+export async function listHostCapabilities(host: Pick<HostClient, 'capabilities'>): Promise<HostCapabilities> {
+  const pick = async (domain: string): Promise<HostCapability[]> => {
+    try {
+      const result = await host.capabilities.list({ domain });
+      return result.capabilities
+        .filter((item) => item.declared || item.status !== 'not-declared')
+        .map((item) => ({ operation: item.operation, status: item.status, declared: item.declared }));
+    } catch (error) {
+      return [{ operation: 'error', status: error instanceof Error ? error.message : String(error), declared: false }];
+    }
+  };
+  return { asr: await pick('asr'), llm: await pick('llm') };
+}
+
 export async function writableDirectory(id: string, label: string, directory: string): Promise<PreflightItem> {
   const target = path.join(directory, `.openminutes-preflight-${randomUUID()}`);
   try {
     await mkdir(directory, { recursive: true });
     await writeFile(target, '', { flag: 'wx' });
     await unlink(target);
-    return { id, label, status: 'ok', reason: directory, autoRepair: false, action: '' };
+    return { id, label, group: 'storage', status: 'ok', reason: '可写', detail: directory, autoRepair: false, action: '' };
   } catch (error) {
-    return { id, label, status: 'fail', reason: `${directory}: ${error instanceof Error ? error.message : String(error)}`,
+    return { id, label, group: 'storage', status: 'fail', reason: '没有写入权限',
+      detail: `${directory}: ${error instanceof Error ? error.message : String(error)}`,
       autoRepair: true, action: '在应用设置中选择当前用户可写目录；不得删除录音、修改系统权限或移动已有数据。' };
   }
 }
 
-export function bluetoothPermission(value: string): Pick<PreflightItem, 'status' | 'reason'> {
-  if (value === '3') return { status: 'ok', reason: 'CoreBluetooth 已授权；设备发现仍需实际连接验证（标识为 UUID）。' };
-  if (value === '0') return { status: 'warn', reason: '蓝牙权限尚未请求。首次连接时需在 macOS 授权；本次未扫描设备。' };
-  if (value === '1' || value === '2') return { status: 'fail', reason: 'macOS 蓝牙权限被限制或拒绝。' };
-  return { status: 'warn', reason: '无法确认蓝牙授权，需在 macOS 真机首次连接时验证。' };
+export function bluetoothPermission(value: string): Pick<PreflightItem, 'status' | 'reason' | 'detail'> {
+  if (value === '3') return { status: 'ok', reason: '蓝牙已授权', detail: 'CoreBluetooth 已授权；设备发现仍需实际连接验证（标识为 UUID）。' };
+  if (value === '0') return { status: 'warn', reason: '首次连接时需要授权蓝牙', detail: '蓝牙权限尚未请求。首次连接时需在 macOS 授权；本次未扫描设备。' };
+  if (value === '1' || value === '2') return { status: 'fail', reason: '蓝牙权限被拒绝', detail: 'macOS 蓝牙权限被限制或拒绝。' };
+  return { status: 'warn', reason: '无法确认蓝牙授权', detail: '无法确认蓝牙授权，需在 macOS 真机首次连接时验证。' };
 }
 
 export async function bluetoothCheck(platform: NodeJS.Platform, env: DeviceEnv): Promise<PreflightItem> {
-  const item: PreflightItem = { id: 'bluetooth', label: '蓝牙', status: 'warn',
-    reason: '未连接设备；蓝牙可用性尚未确认。', autoRepair: false,
+  const item: PreflightItem = { id: 'bluetooth', label: '蓝牙', group: 'device', status: 'warn',
+    reason: '蓝牙可用性尚未确认', detail: '未连接设备；蓝牙可用性尚未确认。', autoRepair: false,
     action: '启用蓝牙；macOS 在系统设置 > 隐私与安全性 > 蓝牙中授权实际发起请求的应用。不得通过修改 TCC 数据库绕过授权。' };
-  if (!env.bleak.ok || !env.python.resolvedPath) return { ...item, reason: '请先修复 Python/bleak，再检查蓝牙。' };
+  if (!env.bleak.ok || !env.python.resolvedPath) return { ...item, reason: '请先修复蓝牙组件', detail: '请先修复 Python/bleak，再检查蓝牙。' };
   if (platform === 'darwin') {
     const result = await runCommand(env.python.resolvedPath,
       ['-c', 'from CoreBluetooth import CBManager;print(CBManager.authorization())'], 8000,
@@ -91,25 +118,28 @@ export async function bluetoothCheck(platform: NodeJS.Platform, env: DeviceEnv):
     if (permission.status !== 'ok') return { ...item, ...permission };
     const hardware = await runCommand('/usr/sbin/system_profiler', ['SPBluetoothDataType', '-json'], 12000);
     const powered = hardware.ok && /"controller_state"\s*:\s*"attrib_on"/.test(hardware.stdout);
-    return { ...item, status: powered ? 'ok' : 'warn', reason: `${permission.reason} ${powered ? '控制器已开启。' : '控制器状态未确认，请检查蓝牙开关。'}` };
+    return { ...item, status: powered ? 'ok' : 'warn', reason: powered ? '蓝牙已开启' : '请检查蓝牙开关',
+      detail: `${permission.detail} ${powered ? '控制器已开启。' : '控制器状态未确认，请检查蓝牙开关。'}` };
   }
   if (platform === 'win32') {
     const result = await runCommand('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
       '@(Get-PnpDevice -Class Bluetooth -PresentOnly -ErrorAction Stop | Where-Object Status -eq OK).Count'], 12000);
-    return { ...item, status: result.ok && Number(result.stdout.trim()) > 0 ? 'ok' : 'warn',
-      reason: result.ok && Number(result.stdout.trim()) > 0 ? '已发现正常的蓝牙设备；未扫描或连接录音笔。' : '未确认可用蓝牙适配器，请检查蓝牙开关和驱动。' };
+    const ok = result.ok && Number(result.stdout.trim()) > 0;
+    return { ...item, status: ok ? 'ok' : 'warn', reason: ok ? '蓝牙已就绪' : '请检查蓝牙开关和驱动',
+      detail: ok ? '已发现正常的蓝牙设备；未扫描或连接录音笔。' : `未确认可用蓝牙适配器。${result.stderr.trim().slice(-300)}` };
   }
   if (platform === 'linux') {
     const result = await runCommand('bluetoothctl', ['show'], 8000);
-    return { ...item, status: result.ok && /Powered:\s*yes/.test(result.stdout) ? 'ok' : 'warn',
-      reason: result.ok && /Powered:\s*yes/.test(result.stdout) ? 'BlueZ 控制器已开启；未扫描设备。' : '未确认 BlueZ 控制器，检查 bluetoothd、蓝牙开关和 D-Bus 权限。' };
+    const ok = result.ok && /Powered:\s*yes/.test(result.stdout);
+    return { ...item, status: ok ? 'ok' : 'warn', reason: ok ? '蓝牙已开启' : '请检查蓝牙开关',
+      detail: ok ? 'BlueZ 控制器已开启；未扫描设备。' : '未确认 BlueZ 控制器，检查 bluetoothd、蓝牙开关和 D-Bus 权限。' };
   }
   return item;
 }
 
 export async function decodeCheck(ffmpeg: string | null): Promise<PreflightItem> {
-  const base: PreflightItem = { id: 'decode', label: '音频解码', status: 'fail', reason: '缺少 ffmpeg', autoRepair: true,
-    action: '安装支持 WAV/PCM 和 MP3 解码的 ffmpeg，并在设置中填写路径。' };
+  const base: PreflightItem = { id: 'decode', label: '音频解码', group: 'audio', status: 'fail', reason: '还不能解码音频',
+    detail: '缺少 ffmpeg', autoRepair: true, action: '安装支持 WAV/PCM 和 MP3 解码的 ffmpeg，并在设置中填写路径。' };
   if (!ffmpeg) return base;
   let directory: string | null = null;
   try {
@@ -122,9 +152,10 @@ export async function decodeCheck(ffmpeg: string | null): Promise<PreflightItem>
     wav.writeUInt16LE(16, 34); wav.write('data', 36); wav.writeUInt32LE(3200, 40);
     await writeFile(file, wav);
     const result = await verifyDecodable(ffmpeg, file);
-    return { ...base, status: result.ok ? 'ok' : 'fail', reason: result.message, autoRepair: !result.ok, action: result.ok ? '' : base.action };
+    return { ...base, status: result.ok ? 'ok' : 'fail', reason: result.ok ? '可以解码' : base.reason, detail: result.message,
+      autoRepair: !result.ok, action: result.ok ? '' : base.action };
   } catch (error) {
-    return { ...base, reason: `无法完成解码检查：${String(error)}`, autoRepair: false,
+    return { ...base, reason: '无法完成解码检查', detail: String(error), autoRepair: false,
       action: '检查系统临时目录是否可写及磁盘剩余空间，然后重新检测。' };
   } finally {
     if (directory) {
@@ -142,9 +173,14 @@ export interface PreflightDependencies {
   decode: (ffmpeg: string | null) => Promise<PreflightItem>;
 }
 
+export interface PreflightSnapshot {
+  report: PreflightReport;
+  env: DeviceEnv;
+}
+
 export function createPreflight(platform: NodeJS.Platform, arch: string, dependencies: PreflightDependencies) {
-  let cached: { report: PreflightReport; env: DeviceEnv } | null = null;
-  let pending: Promise<{ report: PreflightReport; env: DeviceEnv }> | null = null;
+  let cached: PreflightSnapshot | null = null;
+  let pending: Promise<PreflightSnapshot> | null = null;
   async function inspect() {
     const env = await dependencies.environment();
     const [directories, host, bluetooth, decode] = await Promise.all([
@@ -162,6 +198,10 @@ export function createPreflight(platform: NodeJS.Platform, arch: string, depende
       pending = inspect().finally(() => { pending = null; });
       return pending;
     },
+    /** 只读缓存，不触发探测；轮询接口用它。 */
+    peek(): PreflightSnapshot | null {
+      return cached;
+    },
   };
 }
 
@@ -170,7 +210,7 @@ export function appPreflight(app: WorkbenchServer) {
     environment: () => probeEnvironment(app.database),
     directories: () => Promise.all([
       writableDirectory('import-dir', '导入目录', resolveImportDir(app.database).directory),
-      writableDirectory('library-dir', '归档目录', libraryRoot(app.database)),
+      writableDirectory('library-dir', '录音库目录', libraryRoot(app.database)),
     ]),
     host: () => hostChecks(app.host),
     bluetooth: (env) => bluetoothCheck(process.platform, env),
diff --git a/src/server/pull.ts b/src/server/pull.ts
deleted file mode 100644
index cca0e30..0000000
--- a/src/server/pull.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-// ABOUTME: 设备拉取服务：单文件下载与「连上后自动补齐待拉取录音」。
-
-import { mkdir, readdir, stat } from 'node:fs/promises';
-import path from 'node:path';
-import type { WorkbenchServer } from '../../sdk/runtime.mjs';
-import type { BridgeRunResult } from '../contracts/app';
-import { resolveFfmpeg, runSdkAction } from './bridge';
-import { attachDownloadedFile, registerDeviceManifest } from './ingest';
-import { autoTranscribeIfEnabled } from './jobs';
-import { libraryRoot } from './library';
-import { readSetting, row, rows, strOr } from './sql';
-
-export interface AttachedFile {
-  filename: string;
-  ok: boolean;
-  message: string;
-  id: number | null;
-}
-
-export interface DownloadOutcome {
-  result: BridgeRunResult;
-  attached: AttachedFile[];
-  queued: number;
-}
-
-function currentSerial(app: WorkbenchServer): string {
-  const found = row(
-    app.database,
-    `SELECT serial FROM devices WHERE firmware IS NOT NULL OR battery_pct IS NOT NULL
-      ORDER BY COALESCE(last_seen_at, created_at) DESC LIMIT 1`,
-  );
-  const serial = found ? strOr(found.serial, '') : '';
-  return serial || readSetting(app.database, 'device_serial') || 'MemoTalk-S1';
-}
-
-/** 通过 BLE(0x84) 拉取单个文件并挂到已登记的记录上。 */
-export async function downloadOne(app: WorkbenchServer, file: string, serial: string): Promise<DownloadOutcome> {
-  const incoming = await app.resources.path('audio', '_incoming', 'write');
-  await mkdir(incoming, { recursive: true });
-
-  const run = await runSdkAction(app.database, 'download', { file, outDir: incoming }, 240000);
-  const attached: AttachedFile[] = [];
-
-  if (run.result.ok) {
-    const ffmpegPath = (await resolveFfmpeg(app.database)) ?? 'ffmpeg';
-    const target = libraryRoot(app.database);
-    try {
-      for (const entry of await readdir(incoming, { withFileTypes: true })) {
-        if (!entry.isFile()) continue;
-        const absolute = path.join(incoming, entry.name);
-        const info = await stat(absolute);
-        if (Date.now() - info.mtimeMs > 15 * 60 * 1000) continue;
-        const outcome = await attachDownloadedFile(app.database, target, ffmpegPath, absolute, entry.name, serial);
-        attached.push({ filename: entry.name, ok: outcome.ok, message: outcome.message, id: outcome.id });
-      }
-    } catch {
-      /* 目录不可读时保留 SDK 原始输出供人工判断 */
-    }
-  }
-
-  const ids = attached.flatMap((item) => (item.ok && item.id ? [item.id] : []));
-  return { result: run.result, attached, queued: autoTranscribeIfEnabled(app, ids) };
-}
-
-export interface PullPendingResult {
-  serial: string;
-  registered: number;
-  pulled: number;
-  failed: number;
-  queued: number;
-  files: AttachedFile[];
-}
-
-/**
- * 设备刚连上时调用：先读清单登记新录音，再按预算逐个拉取待拉取文件。
- * BLE 串行且慢，因此限制单轮文件数与总耗时。
- */
-export async function pullPending(
-  app: WorkbenchServer,
-  options: { maxFiles?: number; budgetMs?: number } = {},
-): Promise<PullPendingResult> {
-  const db = app.database;
-  const serial = currentSerial(app);
-  const maxFiles = options.maxFiles ?? 3;
-  const budgetMs = options.budgetMs ?? 150_000;
-
-  let registered = 0;
-  const listing = await runSdkAction(db, 'list', {}, 60_000);
-  if (listing.result.ok && listing.result.parsedFiles.length > 0) {
-    registered = registerDeviceManifest(db, serial, listing.result.parsedFiles).accepted;
-  }
-
-  const pending = rows(
-    db,
-    `SELECT filename FROM recordings
-      WHERE status = 'pending' AND (storage_path IS NULL OR storage_path = '')
-      ORDER BY COALESCE(recorded_at, created_at) DESC LIMIT ?`,
-    [maxFiles],
-  ).map((item) => strOr(item.filename, ''));
-
-  const started = Date.now();
-  const files: AttachedFile[] = [];
-  let pulled = 0;
-  let failed = 0;
-  let queued = 0;
-
-  for (const filename of pending) {
-    if (!filename) continue;
-    if (Date.now() - started > budgetMs) break;
-    try {
-      const outcome = await downloadOne(app, filename, serial);
-      queued += outcome.queued;
-      files.push(...outcome.attached);
-      if (outcome.attached.some((item) => item.ok)) pulled += 1;
-      else failed += 1;
-    } catch {
-      failed += 1;
-    }
-  }
-
-  return { serial, registered, pulled, failed, queued, files };
-}
diff --git a/src/server/queue.ts b/src/server/queue.ts
index 171ebf5..650dce5 100644
--- a/src/server/queue.ts
+++ b/src/server/queue.ts
@@ -1,17 +1,35 @@
-// ABOUTME: 串行任务队列；Host ASR 有并发上限，接入类任务一次只跑一条。
+// ABOUTME: 串行任务队列；Host ASR 有并发上限，接入类任务一次只跑一条。断网窗口内网络任务排队等待。
+
+import { networkGate, type NetworkGate } from './network-gate';
 
 type Task = () => Promise<unknown>;
 
 let chain: Promise<void> = Promise.resolve();
 const pending: string[] = [];
+let running: string | null = null;
+let gate: NetworkGate = networkGate;
+
+/** 只供测试替换闸门实例。 */
+export function useNetworkGate(next: NetworkGate): void {
+  gate = next;
+}
+
+export function isNetworkTask(label: string): boolean {
+  return label.startsWith('transcribe:') || label.startsWith('organize:');
+}
 
 export function enqueue(label: string, task: Task): void {
   pending.push(label);
+  const body = isNetworkTask(label) ? () => gate.runNetworkTask(task) : task;
   chain = chain
-    .then(task)
+    .then(() => {
+      running = label;
+      return body();
+    })
     .then(() => undefined)
     .catch(() => undefined)
     .finally(() => {
+      if (running === label) running = null;
       const index = pending.indexOf(label);
       if (index >= 0) pending.splice(index, 1);
     });
@@ -21,6 +39,10 @@ export function queueSnapshot(): string[] {
   return [...pending];
 }
 
+export function runningTask(): string | null {
+  return running;
+}
+
 /** 队列包含等待和正在执行的任务，直到 finally 清理才算结束。 */
 export function queuedRecordingStatus(recordingId: number): 'queued_transcribe' | 'queued_organize' | null {
   if (pending.includes(`transcribe:${recordingId}`)) return 'queued_transcribe';
diff --git a/src/server/repo.ts b/src/server/repo.ts
index 29d194d..7ec9fed 100644
--- a/src/server/repo.ts
+++ b/src/server/repo.ts
@@ -30,6 +30,9 @@ const RECORDING_SELECT = `
 const STAGE_FILTERS: Record<string, string> = {
   'need-transcribe': "r.status IN ('pending', 'ready')",
   'need-organize': "r.status = 'transcribed'",
+  pending: "r.status = 'pending'",
+  ready: "r.status = 'ready'",
+  transcribed: "r.status = 'transcribed'",
   busy: "r.status IN ('transcribing', 'analyzing')",
   done: "r.status = 'organized'",
   failed: "r.status = 'failed'",
@@ -201,7 +204,7 @@ function toAnalysis(source: Record<string, unknown> | undefined): AnalysisRecord
 }
 
 export function readRecordingDetail(db: DatabaseSync, id: number): RecordingDetail | null {
-  const detail = row(db, 'SELECT id, storage_path, last_error FROM recordings WHERE id = ?', [id]);
+  const detail = row(db, 'SELECT id, storage_path, last_error, last_error_code, last_error_detail FROM recordings WHERE id = ?', [id]);
   if (!detail) return null;
   const summary = readRecordingSummary(db, id);
   if (!summary) return null;
@@ -247,6 +250,8 @@ export function readRecordingDetail(db: DatabaseSync, id: number): RecordingDeta
     analysis,
     jobs,
     lastError: str(detail.last_error),
+    lastErrorCode: str(detail.last_error_code),
+    lastErrorDetail: str(detail.last_error_detail),
     storagePath: str(detail.storage_path),
   };
 }
@@ -324,35 +329,6 @@ export function buildOverview(db: DatabaseSync): Overview {
     'SELECT status, COUNT(*) AS n FROM recordings WHERE is_archived = 0 GROUP BY status',
   ).map((item) => ({ status: strOr(item.status, 'pending') as RecordingStatus, count: numOr(item.n, 0) }));
 
-  const deviceRow = row(
-    db,
-    `SELECT serial, model, firmware, battery_pct, free_space_pct, last_seen_at
-       FROM devices ORDER BY COALESCE(last_seen_at, created_at) DESC LIMIT 1`,
-  );
-  const lastSeenAt = deviceRow ? str(deviceRow.last_seen_at) : null;
-  const seenRecently = lastSeenAt ? Date.now() - new Date(lastSeenAt).getTime() < 6 * 60 * 1000 : false;
-  const pendingPulls = numOr(
-    row(db, "SELECT COUNT(*) AS n FROM recordings WHERE is_archived = 0 AND status = 'pending'")?.n,
-    0,
-  );
-  const readyToTranscribe = numOr(
-    row(db, "SELECT COUNT(*) AS n FROM recordings WHERE is_archived = 0 AND status = 'ready'")?.n,
-    0,
-  );
-  const device = deviceRow
-    ? {
-        serial: strOr(deviceRow.serial, ''),
-        model: strOr(deviceRow.model, 'MemoTalk S1'),
-        firmware: str(deviceRow.firmware),
-        batteryPct: num(deviceRow.battery_pct),
-        freeSpacePct: num(deviceRow.free_space_pct),
-        lastSeenAt,
-        connected: seenRecently,
-        pendingPulls,
-        readyToTranscribe,
-      }
-    : null;
-
   return {
     totalRecordings: numOr(totals?.total, 0),
     totalDurationSec: numOr(totals?.duration, 0),
@@ -365,6 +341,5 @@ export function buildOverview(db: DatabaseSync): Overview {
     byCategory,
     byStatus,
     recent: listRecordings(db, { limit: 5, sort: 'recorded' }).items,
-    device,
   };
 }
diff --git a/src/server/routes/calendar.ts b/src/server/routes/calendar.ts
index 4a3ab97..352335e 100644
--- a/src/server/routes/calendar.ts
+++ b/src/server/routes/calendar.ts
@@ -2,9 +2,8 @@ import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
 import { asObject, BadInput, pathParam, reqString } from '../../contracts/input';
 import { importCalendarFile } from '../calendar-import';
 import { generateDayDigest, generateEventDigest } from '../calendar-digest';
-import { calendarRange, calendarRecordings, getCalendarEvent, linkCalendarRecording, listCalendarEvents, parseCalendarInput, recordingSuggestions, saveCalendarEvent } from '../calendar';
+import { calendarRange, calendarRecordings, getCalendarEvent, listCalendarEvents, parseCalendarInput, recordingSuggestions, saveCalendarEvent } from '../calendar';
 import { api } from '../http';
-import { readRecordingDetail } from '../repo';
 
 export function registerCalendarRoutes(app: WorkbenchServer): void {
   app.route('GET', '/api/calendar/events/:id/digest', api((context) => ({
@@ -42,13 +41,4 @@ export function registerCalendarRoutes(app: WorkbenchServer): void {
     return calendarRecordings(context.database, { start, end });
   }));
   app.route('GET', '/api/recordings/:id/calendar-suggestions', api((context) => recordingSuggestions(context.database, pathParam(context.params, 'id'))));
-  app.route('PUT', '/api/recordings/:id', api((context) => {
-    const id = pathParam(context.params, 'id');
-    const value = asObject(context.body).calendar_event_id;
-    if (value !== null && (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0)) {
-      throw new BadInput('calendar_event_id 必须是正整数或 null');
-    }
-    linkCalendarRecording(context.database, id, value);
-    return readRecordingDetail(context.database, id);
-  }));
 }
diff --git a/src/server/routes/device.ts b/src/server/routes/device.ts
index b83a180..90388d1 100644
--- a/src/server/routes/device.ts
+++ b/src/server/routes/device.ts
@@ -1,219 +1,74 @@
-// ABOUTME: 设备页路由：环境自检、SDK 指令库、设备清单拉取与单文件下载。
+// ABOUTME: 录音笔路由：连接/断开、同步全部/单条、停止、清理已同步的录音。全部经由设备服务。
 
-import { mkdir, readdir, stat } from 'node:fs/promises';
-import path from 'node:path';
 import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
-import type { DeviceState, ParsedDeviceFile, SdkCommand } from '../../contracts/app';
-import { asObject, optString, reqString } from '../../contracts/input';
+import type { DeviceView } from '../../contracts/device';
+import { AppError } from '../../contracts/errors';
+import { asObject, BadInput, optIntArray } from '../../contracts/input';
 import { api } from '../http';
-import { probeEnvironment, resolveFfmpeg, runSdkAction } from '../bridge';
-import { registerDeviceManifest, upsertDevice } from '../ingest';
-import { libraryRoot } from '../library';
-import { downloadOne } from '../pull';
-import { listCategories } from '../repo';
-import { num, numOr, readSetting, readSettings, row, rows, run, str, strOr, writeSetting } from '../sql';
 import type { appPreflight } from '../preflight';
+import type { DeviceService } from '../device/service';
 
+const CONNECT_WAIT_MS = 30_000;
 
-async function readCapabilities(host: { capabilities: { list: (input?: { domain?: string }) => Promise<{ capabilities: Array<{ operation: string; status: string; declared: boolean }> }> } }) {
-  const domains = [
-    { domain: 'asr', label: '语音识别' },
-    { domain: 'llm', label: '文本模型' },
-  ];
-  const results: Array<{ domain: string; ok: boolean; detail: string }> = [];
-  for (const item of domains) {
-    try {
-      const listed = await host.capabilities.list({ domain: item.domain });
-      const declared = listed.capabilities.filter((entry) => entry.declared);
-      const available = declared.filter((entry) => entry.status === 'available');
-      results.push({
-        domain: item.label,
-        ok: available.length > 0,
-        detail:
-          declared.length === 0
-            ? '清单未声明该能力'
-            : `${available.length}/${declared.length} 个接口可用`,
-      });
-    } catch (error) {
-      results.push({ domain: item.label, ok: false, detail: error instanceof Error ? error.message : '无法读取能力清单' });
-    }
-  }
-  return results;
-}
-
-function readCommands(app: WorkbenchServer): SdkCommand[] {
-  return rows(app.database, 'SELECT * FROM sdk_commands ORDER BY sort_order').map((item) => ({
-    cmdCode: strOr(item.cmd_code, ''),
-    name: strOr(item.name, ''),
-    direction: strOr(item.direction, 'read') as SdkCommand['direction'],
-    channel: strOr(item.channel, 'FFF1'),
-    requestHex: strOr(item.request_hex, ''),
-    responseRule: strOr(item.response_rule, ''),
-    caution: numOr(item.caution, 0) === 1,
-  }));
-}
+type Preflight = ReturnType<typeof appPreflight>;
 
-
-/** 最近一次真正连上并读到信息的设备（有固件或电量），用于回填登记序列号。 */
-function latestDeviceSerial(app: WorkbenchServer): string {
-  const found = row(
-    app.database,
-    `SELECT serial FROM devices
-      WHERE firmware IS NOT NULL OR battery_pct IS NOT NULL
-      ORDER BY COALESCE(last_seen_at, created_at) DESC LIMIT 1`,
-  );
-  return found ? strOr(found.serial, '') : '';
+/** GET /api/device 每 1.5 秒轮询一次：只读内存和 preflight 缓存，绝不派生探测进程。 */
+export function deviceView(service: DeviceService, preflight?: Preflight): DeviceView {
+  const view = service.view();
+  const report = preflight?.peek()?.report;
+  view.environment = { failCount: report ? report.items.filter((item) => item.status === 'fail').length : 0 };
+  return view;
 }
 
-function readDevices(app: WorkbenchServer): DeviceState['devices'] {
-  return rows(app.database, 'SELECT * FROM devices ORDER BY COALESCE(last_seen_at, created_at) DESC LIMIT 20').map((item) => ({
-    id: numOr(item.id, 0),
-    serial: strOr(item.serial, ''),
-    model: strOr(item.model, 'MemoTalk S1'),
-    firmware: str(item.firmware),
-    batteryPct: num(item.battery_pct),
-    freeSpacePct: num(item.free_space_pct),
-    lastSeenAt: str(item.last_seen_at),
-  }));
+function startedJob(service: DeviceService): { jobId: string } {
+  const jobId = service.view().activity?.jobId;
+  if (!jobId) throw new AppError('INTERNAL_ERROR', undefined, 'activity was not registered');
+  return { jobId };
 }
 
-export function registerDeviceRoutes(app: WorkbenchServer, preflight?: ReturnType<typeof appPreflight>): void {
-  app.route(
-    'GET',
-    '/api/device',
-    api(async (context): Promise<DeviceState> => {
-      const settings = readSettings(context.database);
-      return {
-        env: preflight ? (await preflight.get()).env : await probeEnvironment(context.database),
-        commands: readCommands(app),
-        capabilities: await readCapabilities(context.host),
-        devices: readDevices(app),
-        settings: [...settings.entries()].map(([key, value]) => ({ key, value })),
-      };
-    }),
-  );
-
-  app.route(
-    'POST',
-    '/api/device/status',
-    api(async (context) => {
-      const run = await runSdkAction(context.database, 'status', {}, 60000);
-      const device = run.result.parsedStatus;
-      if (device?.serial) {
-        upsertDevice(context.database, device.serial, {
-          firmware: device.firmware,
-          storageFormat: device.storageFormat,
-          batteryPct: device.batteryPct,
-          freeSpacePct: device.freeSpacePct,
-        });
-        writeSetting(context.database, 'device_serial', device.serial);
-      }
-      return { result: run.result, device };
-    }),
-  );
-
-  app.route(
-    'POST',
-    '/api/device/list',
-    api(async (context) => {
-      const body = asObject(context.body ?? {});
-      const serialInput = optString(body, 'serial', 64) ?? '';
-      const run = await runSdkAction(context.database, 'list');
-      if (!run.result.ok || run.result.parsedFiles.length === 0) {
-        return { result: run.result, registered: 0, skipped: 0 };
-      }
-      const serial =
-        serialInput || run.serial || latestDeviceSerial(app) || readSetting(context.database, 'device_serial') || 'MemoTalk-S1';
-      const registered = registerDeviceManifest(context.database, serial, run.result.parsedFiles);
-      return { result: run.result, registered: registered.accepted, skipped: registered.skipped, serial };
-    }),
-  );
+export function registerDeviceRoutes(app: WorkbenchServer, service: DeviceService, preflight?: Preflight): void {
+  app.route('GET', '/api/device', api(() => deviceView(service, preflight)));
 
   app.route(
     'POST',
-    '/api/device/download',
-    api(async (context) => {
-      const body = asObject(context.body);
-      const file = reqString(body, 'file', 160);
-      const serial = (optString(body, 'serial', 64) || readSetting(context.database, 'device_serial') || 'MemoTalk-S1').trim();
-      const outcome = await downloadOne(app, file, serial);
-      return { result: outcome.result, attached: outcome.attached, queued: outcome.queued };
+    '/api/device/connect',
+    api(async () => {
+      const connecting = service.connect({ origin: 'user' });
+      connecting.catch(() => undefined);
+      const timer = new Promise<'pending'>((resolve) => {
+        const handle = setTimeout(() => resolve('pending'), CONNECT_WAIT_MS);
+        handle.unref?.();
+      });
+      // 连接最多等 30 秒；超过时返回当前状态，页面继续轮询。
+      await Promise.race([connecting, timer]);
+      return deviceView(service, preflight);
     }),
   );
 
+  app.route('POST', '/api/device/disconnect', api(async () => {
+    await service.disconnect({ reason: 'user' });
+    return deviceView(service, preflight);
+  }));
 
-  app.route(
-    'GET',
-    '/api/device/capabilities',
-    api(async (context) => {
-      const pick = async (domain: string) => {
-        try {
-          const result = await context.host.capabilities.list({ domain });
-          return result.capabilities
-            .filter((item) => item.declared || item.status !== 'not-declared')
-            .map((item) => ({ operation: item.operation, status: item.status, declared: item.declared }));
-        } catch (error) {
-          return [{ operation: 'error', status: error instanceof Error ? error.message : String(error), declared: false }];
-        }
-      };
-      return { asr: await pick('asr'), llm: await pick('llm') };
-    }),
-  );
-
+  app.route('POST', '/api/device/sync', api(() => {
+    void service.sync({ origin: 'user' }).catch(() => undefined);
+    return startedJob(service);
+  }));
 
-  app.route(
-    'DELETE',
-    '/api/device/:id',
-    api((context) => {
-      const id = Number(context.params.id);
-      if (!Number.isInteger(id) || id <= 0) throw Object.assign(new Error('非法的设备 ID'), { code: 'INVALID_INPUT' });
-      const found = row(context.database, 'SELECT serial FROM devices WHERE id = ?', [id]);
-      if (!found) throw Object.assign(new Error('设备记录不存在'), { code: 'NOT_FOUND' });
-      const serial = strOr(found.serial, '');
-      run(context.database, 'DELETE FROM devices WHERE id = ?', [id]);
-      if (readSetting(context.database, 'device_serial') === serial) writeSetting(context.database, 'device_serial', '');
-      return { removed: true, id };
-    }),
-  );
+  app.route('POST', '/api/device/pull', api((context) => {
+    const ids = optIntArray(asObject(context.body), 'ids', 100) ?? [];
+    if (ids.length === 0) throw new BadInput('ids 至少包含 1 条录音');
+    void service.sync({ ids, origin: 'user' }).catch(() => undefined);
+    return startedJob(service);
+  }));
 
-  app.route(
-    'GET',
-    '/api/device/summary',
-    api((context) => {
-      const totals = row(
-        context.database,
-        `SELECT COUNT(*) AS total,
-                SUM(CASE WHEN device_serial IS NULL THEN 1 ELSE 0 END) AS local
-           FROM recordings`,
-      );
-      return {
-        deviceRecordings: numOr(totals?.total, 0) - numOr(totals?.local, 0),
-        localRecordings: numOr(totals?.local, 0),
-        devices: readDevices(app).length,
-        categories: listCategories(context.database).length,
-      };
-    }),
-  );
-}
+  app.route('POST', '/api/device/cancel', api(() => {
+    void service.cancel();
+    return deviceView(service, preflight);
+  }));
 
-export function parseManifestEntries(value: unknown): ParsedDeviceFile[] {
-  if (!Array.isArray(value)) throw Object.assign(new Error('entries 必须是数组'), { code: 'INVALID_INPUT' });
-  const items: ParsedDeviceFile[] = [];
-  for (const entry of value.slice(0, 500)) {
-    if (entry === null || typeof entry !== 'object') continue;
-    const record = entry as Record<string, unknown>;
-    const name = typeof record.name === 'string' ? record.name.trim() : '';
-    if (!name) continue;
-    const size = Number(record.sizeBytes);
-    const duration = Number(record.durationSec);
-    const timestamp = Number(record.timestamp);
-    items.push({
-      name,
-      format: typeof record.format === 'string' ? record.format : 'MP3',
-      sizeBytes: Number.isFinite(size) ? size : null,
-      durationSec: Number.isFinite(duration) ? duration : null,
-      timestamp: Number.isFinite(timestamp) ? timestamp : null,
-    });
-  }
-  return items;
+  app.route('POST', '/api/device/cleanup', api(() => {
+    void service.cleanup({ origin: 'user' }).catch(() => undefined);
+    return startedJob(service);
+  }));
 }
diff --git a/src/server/routes/diagnostics.ts b/src/server/routes/diagnostics.ts
new file mode 100644
index 0000000..112dd87
--- /dev/null
+++ b/src/server/routes/diagnostics.ts
@@ -0,0 +1,43 @@
+// ABOUTME: 诊断路由：唯一的技术细节出口——环境、最近设备操作、传输方式、协议指令参考与宿主能力。
+
+import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
+import type { SdkCommand } from '../../contracts/app';
+import type { DiagnosticsView } from '../../contracts/device';
+import { api } from '../http';
+import type { appPreflight } from '../preflight';
+import { listHostCapabilities } from '../preflight';
+import { numOr, rows, strOr } from '../sql';
+import type { DeviceService } from '../device/service';
+import { probeWifiCapable, WIFI_MIN_BATCH_BYTES } from '../device/transport';
+
+export function readCommands(app: WorkbenchServer): SdkCommand[] {
+  return rows(app.database, 'SELECT * FROM sdk_commands ORDER BY sort_order').map((item) => ({
+    cmdCode: strOr(item.cmd_code, ''),
+    name: strOr(item.name, ''),
+    direction: strOr(item.direction, 'read') as SdkCommand['direction'],
+    channel: strOr(item.channel, 'FFF1'),
+    requestHex: strOr(item.request_hex, ''),
+    responseRule: strOr(item.response_rule, ''),
+    caution: numOr(item.caution, 0) === 1,
+  }));
+}
+
+export function registerDiagnosticsRoutes(app: WorkbenchServer, service: DeviceService, preflight: ReturnType<typeof appPreflight>): void {
+  app.route(
+    'GET',
+    '/api/diagnostics',
+    api(async (context): Promise<DiagnosticsView> => ({
+      environment: (await preflight.get()).report,
+      deviceLog: service.logSnapshot().reverse(),
+      transport: {
+        setting: service.transportSetting(),
+        wifiCapable: await probeWifiCapable(),
+        platform: process.platform,
+        thresholdBytes: WIFI_MIN_BATCH_BYTES,
+        measured: service.measuredSpeeds(),
+      },
+      commands: readCommands(app),
+      capabilities: await listHostCapabilities(context.host),
+    })),
+  );
+}
diff --git a/src/server/routes/environment.ts b/src/server/routes/environment.ts
index 5d2e199..f0922c8 100644
--- a/src/server/routes/environment.ts
+++ b/src/server/routes/environment.ts
@@ -1,7 +1,10 @@
+// ABOUTME: 本机环境路由：自检、重新检测、Floatboat 助手修复与宿主能力清单（设置 › 诊断与高级）。
+
 import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
 import { api } from '../http';
-import { appPreflight } from '../preflight';
+import { appPreflight, listHostCapabilities } from '../preflight';
 import { createEnvironmentRepair } from '../environment-repair';
+import { networkGate } from '../network-gate';
 import { toolContext } from '../tools';
 import { sqliteRepairStore } from '../repair-store';
 
@@ -16,12 +19,14 @@ export function registerEnvironmentRoutes(app: WorkbenchServer) {
     },
     workingDirectory: toolContext().cwd,
     store: sqliteRepairStore(app.database, toolContext().cwd),
+    gate: networkGate,
   });
   app.route('GET', '/api/environment', api(async () => ({
     report: (await preflight.get()).report,
     repair: repair.get(),
   })));
+  app.route('POST', '/api/environment/check', api(async () => (await preflight.get(true)).report));
   app.route('POST', '/api/environment/repair', api(() => repair.start()));
-  app.route('POST', '/api/device/check', api(async () => (await preflight.get(true)).report));
+  app.route('GET', '/api/environment/capabilities', api((context) => listHostCapabilities(context.host)));
   return preflight;
 }
diff --git a/src/server/routes/ingest.ts b/src/server/routes/ingest.ts
index 89b768c..19701cc 100644
--- a/src/server/routes/ingest.ts
+++ b/src/server/routes/ingest.ts
@@ -1,16 +1,37 @@
-// ABOUTME: 录音导入路由：目录扫描、设备清单登记与导入目录状态。
+// ABOUTME: 录音导入路由：导入目录状态、扫描导入（目录不存在时自动创建）与诊断区的手动登记清单。
 
 import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
 import type { ImportDirectoryState, IngestScanResult } from '../../contracts/app';
-import { asObject, optString, reqString } from '../../contracts/input';
+import type { ParsedDeviceFile } from '../../contracts/device';
+import { asObject, BadInput, optString, reqString } from '../../contracts/input';
 import { api } from '../http';
 import { readSetting, writeSetting } from '../sql';
-import { resolveFfmpeg } from '../bridge';
-import { describeImportDir, ensureImportDir, registerDeviceManifest, resolveImportDir, scanImportDirectory } from '../ingest';
+import { resolveFfmpeg } from '../runtime-probe';
+import { describeImportDir, registerDeviceManifest, resolveImportDir, scanImportDirectory } from '../ingest';
 import { expandHome, libraryRoot } from '../library';
 import { autoTranscribeIfEnabled } from '../jobs';
-import { parseManifestEntries } from './device';
 
+export function parseManifestEntries(value: unknown): ParsedDeviceFile[] {
+  if (!Array.isArray(value)) throw new BadInput('entries 必须是数组');
+  const items: ParsedDeviceFile[] = [];
+  for (const entry of value.slice(0, 500)) {
+    if (entry === null || typeof entry !== 'object') continue;
+    const record = entry as Record<string, unknown>;
+    const name = typeof record.name === 'string' ? record.name.trim() : '';
+    if (!name) continue;
+    const size = Number(record.sizeBytes);
+    const duration = Number(record.durationSec);
+    const timestamp = Number(record.timestamp);
+    items.push({
+      name,
+      format: typeof record.format === 'string' ? record.format : 'MP3',
+      sizeBytes: Number.isFinite(size) ? size : null,
+      durationSec: Number.isFinite(duration) ? duration : null,
+      timestamp: Number.isFinite(timestamp) ? timestamp : null,
+    });
+  }
+  return items;
+}
 
 export function registerIngestRoutes(app: WorkbenchServer): void {
   app.route(
@@ -19,20 +40,6 @@ export function registerIngestRoutes(app: WorkbenchServer): void {
     api((context): Promise<ImportDirectoryState> => describeImportDir(context.database)),
   );
 
-  // 目录不存在时建出来：用户点一次就能拿到一个真实可用的收件目录。
-  app.route(
-    'POST',
-    '/api/ingest/directory/ensure',
-    api(async (context): Promise<ImportDirectoryState> => {
-      const body = asObject(context.body ?? {});
-      const requested = optString(body, 'directory', 500);
-      if (requested) writeSetting(context.database, 'import_dir', expandHome(requested));
-      const state = await describeImportDir(context.database);
-      const created = await ensureImportDir(state.directory);
-      return { ...state, exists: true, created };
-    }),
-  );
-
   app.route(
     'POST',
     '/api/ingest/scan',
@@ -50,6 +57,7 @@ export function registerIngestRoutes(app: WorkbenchServer): void {
     }),
   );
 
+  // 只有「设置 › 诊断与高级 › 开发者工具」使用。
   app.route(
     'POST',
     '/api/ingest/manifest',
diff --git a/src/server/routes/live.ts b/src/server/routes/live.ts
index 8517afd..53bd748 100644
--- a/src/server/routes/live.ts
+++ b/src/server/routes/live.ts
@@ -4,8 +4,9 @@ import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
 import type { LiveState } from '../../contracts/app';
 import { api } from '../http';
 import { getLiveState, startLive, stopLive } from '../live';
+import type { DeviceService } from '../device/service';
 
-export function registerLiveRoutes(app: WorkbenchServer): void {
+export function registerLiveRoutes(app: WorkbenchServer, service: DeviceService): void {
   app.route(
     'GET',
     '/api/live',
@@ -15,7 +16,7 @@ export function registerLiveRoutes(app: WorkbenchServer): void {
   app.route(
     'POST',
     '/api/live/start',
-    api(async (): Promise<LiveState> => startLive(app)),
+    api(async (): Promise<LiveState> => startLive(app, service)),
   );
 
   app.route(
diff --git a/src/server/routes/pipeline.ts b/src/server/routes/pipeline.ts
index 6090dff..eb84461 100644
--- a/src/server/routes/pipeline.ts
+++ b/src/server/routes/pipeline.ts
@@ -1,22 +1,33 @@
 // ABOUTME: 转录与归类触发路由；长任务进后台队列，页面轮询详情获取进度。
 
+import type { DatabaseSync } from 'node:sqlite';
 import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
 import type { BatchResult } from '../../contracts/app';
-import { asObject, optIntArray, pathParam } from '../../contracts/input';
+import { asObject, BadInput, optIntArray, optString, pathParam } from '../../contracts/input';
 import { api } from '../http';
 import { isBusyStatus } from '../pipeline';
 import { queueOrganization, queueTranscription } from '../jobs';
-import { row, strOr } from '../sql';
+import { num, row, rows, strOr } from '../sql';
 import { queuedRecordingStatus } from '../queue';
 
+/** 批量接口除 {ids} 外支持 {stage}：由服务端选出该阶段的全部录音（上限 400）。 */
+function batchIds(context: { database: DatabaseSync; body: unknown }, stage: 'ready' | 'transcribed'): number[] {
+  const body = asObject(context.body);
+  const requested = optString(body, 'stage', 20);
+  if (requested === undefined) return optIntArray(body, 'ids', 400) ?? [];
+  if (requested !== stage) throw new BadInput(`stage 只能是 ${stage}`);
+  return rows(context.database,
+    'SELECT id FROM recordings WHERE status = ? AND is_archived = 0 ORDER BY COALESCE(recorded_at, created_at) DESC LIMIT 400', [stage])
+    .map((item) => num(item.id) ?? 0).filter((id) => id > 0);
+}
+
 export function registerPipelineRoutes(app: WorkbenchServer): void {
   // 路由按注册顺序匹配，batch 必须先于 :id。
   app.route(
     'POST',
     '/api/recordings/batch/transcribe',
     api((context): BatchResult => {
-      const body = asObject(context.body);
-      const ids = optIntArray(body, 'ids', 400) ?? [];
+      const ids = batchIds(context, 'ready');
       const eligible: number[] = [];
       for (const id of ids) {
         const found = row(context.database, 'SELECT id, status, storage_path FROM recordings WHERE id = ?', [id]);
@@ -36,8 +47,7 @@ export function registerPipelineRoutes(app: WorkbenchServer): void {
     'POST',
     '/api/recordings/batch/organize',
     api((context): BatchResult => {
-      const body = asObject(context.body);
-      const ids = optIntArray(body, 'ids', 400) ?? [];
+      const ids = batchIds(context, 'transcribed');
       const eligible: number[] = [];
       for (const id of ids) {
         const found = row(context.database, 'SELECT id, status, transcript_text FROM recordings WHERE id = ?', [id]);
@@ -61,7 +71,7 @@ export function registerPipelineRoutes(app: WorkbenchServer): void {
       const found = row(context.database, 'SELECT id, status, storage_path FROM recordings WHERE id = ?', [id]);
       if (!found) throw Object.assign(new Error('录音不存在'), { code: 'NOT_FOUND' });
       if (!strOr(found.storage_path, '')) {
-        throw Object.assign(new Error('这条录音还没有音频文件，请先导入或拉取'), { code: 'NO_AUDIO_FILE' });
+        throw Object.assign(new Error('这条录音还没有音频文件，请先在「录音笔」页同步或导入'), { code: 'NO_AUDIO_FILE' });
       }
       if (queuedRecordingStatus(id) || isBusyStatus(strOr(found.status, ''))) {
         throw Object.assign(new Error('该录音已有任务在执行'), { code: 'BUSY' });
diff --git a/src/server/routes/recordings.ts b/src/server/routes/recordings.ts
index edff22f..46e00f8 100644
--- a/src/server/routes/recordings.ts
+++ b/src/server/routes/recordings.ts
@@ -4,11 +4,12 @@ import { mkdir, rename } from 'node:fs/promises';
 import path from 'node:path';
 import type { WorkbenchServer } from '../../../sdk/runtime.mjs';
 import type { RecordingDetail, RecordingListResult } from '../../contracts/app';
-import { asObject, optBool, optInt, optString, optStringArray, pathParam } from '../../contracts/input';
+import { asObject, BadInput, optBool, optInt, optString, optStringArray, pathParam } from '../../contracts/input';
 import { api } from '../http';
 import { listRecordings, readRecordingDetail } from '../repo';
 import { pruneTags, readTags, row, run, str, syncTags } from '../sql';
 import { libraryRoot, resolveAudioFile } from '../library';
+import { linkCalendarRecording } from '../calendar';
 
 export function registerRecordingRoutes(app: WorkbenchServer): void {
   app.route(
@@ -65,6 +66,11 @@ export function registerRecordingRoutes(app: WorkbenchServer): void {
       const isFavorite = optBool(body, 'isFavorite');
       const isArchived = optBool(body, 'isArchived');
       const tags = optStringArray(body, 'tags', 24);
+      const calendarEventId = body.calendarEventId;
+      if (calendarEventId !== undefined && calendarEventId !== null
+        && (typeof calendarEventId !== 'number' || !Number.isSafeInteger(calendarEventId) || calendarEventId <= 0)) {
+        throw new BadInput('calendarEventId 必须是正整数或 null');
+      }
 
       if (title !== undefined) run(context.database, 'UPDATE recordings SET title = ? WHERE id = ?', [title || null, id]);
       if (summary !== undefined) run(context.database, 'UPDATE recordings SET summary = ? WHERE id = ?', [summary || null, id]);
@@ -76,6 +82,8 @@ export function registerRecordingRoutes(app: WorkbenchServer): void {
         if (!category) throw Object.assign(new Error('分类不存在'), { code: 'BAD_CATEGORY' });
         run(context.database, 'UPDATE recordings SET category_id = ? WHERE id = ?', [categoryId, id]);
       }
+      // 录音与日程的唯一关联入口（日历页 EventLinker）。
+      if (calendarEventId !== undefined) linkCalendarRecording(context.database, id, calendarEventId as number | null);
       if (tags !== undefined) {
         syncTags(context.database, id, tags, 'user', true);
         pruneTags(context.database);
diff --git a/src/server/routes/settings.ts b/src/server/routes/settings.ts
index 558224b..cd6dec1 100644
--- a/src/server/routes/settings.ts
+++ b/src/server/routes/settings.ts
@@ -7,8 +7,10 @@ import { api } from '../http';
 import { readSettings, writeSetting } from '../sql';
 
 const PATH_KEYS = new Set(['import_dir', 'python_path', 'ffmpeg_path', 'library_dir']);
-const FLAG_KEYS = new Set(['auto_analyze', 'speaker_diarization', 'auto_transcribe', 'auto_connect', 'auto_pull']);
-const TEXT_KEYS: Record<string, number> = { asr_hotwords: 300, device_serial: 64, asr_language: 20 };
+const FLAG_KEYS = new Set(['auto_analyze', 'speaker_diarization', 'auto_transcribe', 'auto_connect', 'auto_pull', 'auto_pull_wifi']);
+const ENUM_KEYS: Record<string, readonly string[]> = { device_transport: ['auto', 'wifi', 'ble'] };
+// 序列号自动识别、device_user_disconnected 只由「断开连接」写入，都不对外开放。
+const TEXT_KEYS: Record<string, number> = { asr_hotwords: 300, asr_language: 20 };
 const NUMBER_KEYS: Record<string, [number, number]> = { auto_connect_minutes: [1, 120] };
 
 function normalize(key: string, raw: unknown): string {
@@ -22,6 +24,11 @@ function normalize(key: string, raw: unknown): string {
     if (value !== '0' && value !== '1') throw Object.assign(new Error(`${key} 只能是 0 或 1`), { code: 'INVALID_INPUT' });
     return value;
   }
+  const allowed = ENUM_KEYS[key];
+  if (allowed) {
+    if (!allowed.includes(value)) throw Object.assign(new Error(`${key} 只能是 ${allowed.join(' / ')}`), { code: 'INVALID_INPUT' });
+    return value;
+  }
   const range = NUMBER_KEYS[key];
   if (range) {
     const parsed = Number(value);
diff --git a/src/server/runtime-probe.ts b/src/server/runtime-probe.ts
new file mode 100644
index 0000000..5d2cabe
--- /dev/null
+++ b/src/server/runtime-probe.ts
@@ -0,0 +1,23 @@
+// ABOUTME: 运行时探测：Python / bleak / 设备 SDK（memotalk-sdk）/ ffmpeg。设备操作统一走 device/service.ts。
+
+import type { DatabaseSync } from 'node:sqlite';
+import type { DeviceEnv, EnvProbe } from '../contracts/app';
+import { findFfmpeg, probeBleak, probePython, probeSdk } from './tools';
+import { nowIso, readSetting } from './sql';
+
+export { pythonCandidates, ffmpegCandidates, userSiteDir, pythonRuntimeEnv, probePython, probeBleak, probeSdk } from './tools';
+
+export async function resolveFfmpeg(db: DatabaseSync): Promise<string | null> {
+  return findFfmpeg(readSetting(db, 'ffmpeg_path'));
+}
+
+export async function probeEnvironment(db: DatabaseSync): Promise<DeviceEnv> {
+  const { probe: python, command } = await probePython(readSetting(db, 'python_path'));
+  const bleak = await probeBleak(command);
+  const sdk = await probeSdk(command);
+  const ffmpegPath = await resolveFfmpeg(db);
+  const ffmpeg: EnvProbe = ffmpegPath
+    ? { ok: true, detail: ffmpegPath, resolvedPath: ffmpegPath }
+    : { ok: false, detail: '未找到 ffmpeg，可在设置中填写绝对路径', resolvedPath: null };
+  return { python, ffmpeg, bleak, sdk, checkedAt: nowIso() };
+}
diff --git a/src/server/sdk-script.ts b/src/server/sdk-script.ts
deleted file mode 100644
index 666b6d4..0000000
--- a/src/server/sdk-script.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-// ABOUTME: 用已安装的 memotalk SDK 生成桥接层现有的设备报告。
-
-export const SDK_ACTION_SCRIPT = String.raw`
-import argparse
-import asyncio
-import sys
-from memotalk import MemoTalkClient, commands, parsers
-from memotalk.constants import Cmd
-from memotalk.errors import MemoTalkError
-
-
-async def run(args):
-    async with MemoTalkClient() as dev:
-        if args.action == "status":
-            info = await dev.info()
-            print("设备序列号: " + info.identity.serial)
-            print("蓝牙 MAC: " + info.record.mac)
-            print("固件版本号: (" + info.firmware.version + ")")
-            print("当前电量: %s%%" % info.battery.percent)
-            print("剩余存储空间: %s%%" % info.free_space.percent)
-            print("存储音频格式: " + info.identity.format_name)
-            print("当前录音状态: " + info.record.state.name)
-            # Hotspot metadata is optional; never read or print its password.
-            try:
-                reply = await dev.raw.request(commands.read_wifi_ssid(), code=Cmd.WIFI_SSID, timeout=2.0)
-                print("热点 SSID: " + parsers.parse_text(reply))
-            except MemoTalkError:
-                pass
-        elif args.action == "list":
-            for index, entry in enumerate(await dev.files.list(), 1):
-                print("%s. %s | 格式=%s | 大小=%s B | 时长=%ss | 时间戳=%s" % (
-                    index, entry.name, entry.format_name, entry.size,
-                    entry.duration_sec, entry.timestamp))
-        else:
-            saved = await dev.files.download(args.file, args.out_dir, overwrite=True)
-            print("saved " + str(saved))
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--action", choices=["status", "list", "download"], required=True)
-    parser.add_argument("--file")
-    parser.add_argument("--out-dir")
-    args = parser.parse_args()
-    if args.action == "download" and (not args.file or not args.out_dir):
-        parser.error("download requires --file and --out-dir")
-    try:
-        asyncio.run(run(args))
-    except Exception as error:
-        print("[X] %s: %s" % (type(error).__name__, error), file=sys.stderr)
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
-`;
diff --git a/src/server/transcribe.ts b/src/server/transcribe.ts
index 1e1dfc2..a217a77 100644
--- a/src/server/transcribe.ts
+++ b/src/server/transcribe.ts
@@ -342,8 +342,9 @@ export async function transcribeAudioFile(host: HostClient, options: TranscribeO
     .join('')
     .trim();
   if (!text) {
-    const reason = lastAsrError ? `识别接口返回错误：${lastAsrError}` : '没有识别到可用的语音内容';
-    throw new TranscribeError('ASR_EMPTY', reason, trace);
+    // 识别接口报过错：原文只进详情，主文案由 describeError 按 ASR_UNSTABLE 给出。
+    if (lastAsrError) throw new TranscribeError('ASR_UNSTABLE', `识别接口返回错误：${lastAsrError}`, trace);
+    throw new TranscribeError('ASR_EMPTY', '没有识别到可用的语音内容', trace);
   }
 
   const audioMs = Math.round((decodedBytes / PCM_BYTES_PER_SECOND) * 1000);
diff --git a/src/ui/App.tsx b/src/ui/App.tsx
index c284979..4bb0959 100644
--- a/src/ui/App.tsx
+++ b/src/ui/App.tsx
@@ -1,12 +1,13 @@
-// ABOUTME: 工作台外壳：侧边导航、哈希路由与页面装配。
+// ABOUTME: 工作台外壳：6 项侧栏导航、哈希路由与页面装配；每个功能只在一个页面里有入口。
 
-import { useEffect, useState } from 'react';
-import { AudioLines, CalendarDays, Captions, FolderTree, HardDriveDownload, LayoutDashboard, LibraryBig, Settings2 } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { AudioLines, CalendarDays, Captions, FolderTree, LibraryBig, Mic, Settings2 } from 'lucide-react';
 import { api } from './api';
 import type { AppInfo, Overview } from '../contracts/app';
+import type { EnvironmentState } from '../contracts/preflight';
 import { useAsyncData } from './useApi';
+import { buildHash, DEFAULT_ROUTE, navKey, parseHash, type NavKey, type Route } from './router';
 import { ToastProvider } from './components/ui';
-import { OverviewPage } from './pages/Overview';
 import { LibraryPage } from './pages/Library';
 import { DetailPage } from './pages/Detail';
 import { DevicePage } from './pages/Device';
@@ -16,50 +17,41 @@ import { SettingsPage } from './pages/Settings';
 import { CalendarPage } from './pages/Calendar';
 import './calendar.css';
 
-type Route =
-  | { name: 'overview' }
-  | { name: 'library' }
-  | { name: 'device' }
-  | { name: 'categories' }
-  | { name: 'settings' }
-  | { name: 'live' }
-  | { name: 'calendar' }
-  | { name: 'detail'; id: number };
-
-const NAV = [
-  { key: 'overview', label: '概览', icon: LayoutDashboard },
-  { key: 'library', label: '录音库', icon: LibraryBig },
-  { key: 'calendar', label: '日历视图', icon: CalendarDays },
+const NAV: ReadonlyArray<{ key: NavKey; label: string; icon: typeof Mic }> = [
+  { key: 'library', label: '录音', icon: LibraryBig },
+  { key: 'device', label: '录音笔', icon: Mic },
   { key: 'live', label: '实时字幕', icon: Captions },
-  { key: 'device', label: '设备接入', icon: HardDriveDownload },
+  { key: 'calendar', label: '日历', icon: CalendarDays },
   { key: 'categories', label: '分类', icon: FolderTree },
   { key: 'settings', label: '设置', icon: Settings2 },
-] as const;
-
-function parseHash(): Route {
-  const raw = window.location.hash.replace(/^#\/?/, '');
-  if (raw.startsWith('rec/')) {
-    const id = Number(raw.slice(4));
-    if (Number.isInteger(id) && id > 0) return { name: 'detail', id };
-    return { name: 'library' };
-  }
-  if (raw === 'library' || raw === 'device' || raw === 'categories' || raw === 'settings' || raw === 'live' || raw === 'calendar') {
-    return { name: raw };
-  }
-  return { name: 'overview' };
-}
+];
 
-function routeKey(route: Route): string {
-  return route.name === 'detail' ? 'library' : route.name;
+/** 未知或已移除的哈希（含 #/overview）改写为 #/library，不留历史记录。 */
+function currentRoute(): Route {
+  const parsed = parseHash(window.location.hash);
+  if (parsed) return parsed;
+  window.history.replaceState(null, '', buildHash(DEFAULT_ROUTE));
+  return DEFAULT_ROUTE;
 }
 
 export function App() {
-  const [route, setRoute] = useState<Route>(parseHash);
+  const [route, setRoute] = useState<Route>(currentRoute);
+  const [revision, setRevision] = useState(0);
+  // 详情页的返回按钮回到应用内的上一条路由（含页面用 replaceState 写进哈希的筛选与日期）。
+  const previousRoute = useRef<Route | null>(null);
+  const key = navKey(route);
   const info = useAsyncData<AppInfo>(() => api.get<AppInfo>('/api/app'), 'app');
-  const overview = useAsyncData<Overview>(() => api.get<Overview>('/api/overview'), routeKey(route));
+  const overview = useAsyncData<Overview>(() => api.get<Overview>('/api/overview'), `${key}:${revision}`);
+  const environment = useAsyncData<EnvironmentState>(() => api.get<EnvironmentState>('/api/environment'), `env:${key}`);
+  const envFailCount = environment.data?.report.items.filter((item) => item.status === 'fail').length ?? 0;
 
   useEffect(() => {
-    const onHash = () => setRoute(parseHash());
+    const onHash = (event: HashChangeEvent) => {
+      const next = currentRoute();
+      const from = parseHash(new URL(event.oldURL).hash);
+      if (next.name === 'detail' && from && from.name !== 'detail') previousRoute.current = from;
+      setRoute(next);
+    };
     window.addEventListener('hashchange', onHash);
     return () => window.removeEventListener('hashchange', onHash);
   }, []);
@@ -68,16 +60,17 @@ export function App() {
     if (info.data) document.title = info.data.name;
   }, [info.data]);
 
-  const navigate = (target: string) => {
-    window.location.hash = `#/${target}`;
-    window.scrollTo({ top: 0 });
-  };
-  const openRecording = (id: number) => {
-    window.location.hash = `#/rec/${id}`;
+  const navigate = (target: Route) => {
+    window.location.hash = buildHash(target);
     window.scrollTo({ top: 0 });
   };
+  const openRecording = (id: number) => navigate({ name: 'detail', id });
+  const changed = useCallback(() => setRevision((value) => value + 1), []);
 
-  const pending = overview.data?.pendingCount ?? 0;
+  const back = previousRoute.current ?? DEFAULT_ROUTE;
+  const backNav = NAV.find((item) => item.key === navKey(back));
+  // 徽标只数「在录音笔中」（pending）；overview.pendingCount 还包含待转录。
+  const pending = overview.data?.byStatus.find((item) => item.status === 'pending')?.count ?? 0;
 
   return (
     <ToastProvider>
@@ -89,24 +82,29 @@ export function App() {
             </span>
             <span className="brand__text">
               <strong>{info.data?.name ?? '录音笔工作台'}</strong>
-              <span className="brand__sub">录音 → 转录 → 归类</span>
+              <span className="brand__sub">录音笔 → 转录 → 归类</span>
             </span>
           </div>
           <nav className="nav" aria-label="主导航">
             {NAV.map((item) => {
               const Icon = item.icon;
-              const active = routeKey(route) === item.key;
+              const active = key === item.key;
               return (
                 <button
                   key={item.key}
                   type="button"
                   className={`nav__item${active ? ' nav__item--active' : ''}`}
-                  onClick={() => navigate(item.key)}
+                  onClick={() => navigate({ name: item.key } as Route)}
                   aria-current={active ? 'page' : undefined}
                 >
                   <Icon size={16} aria-hidden="true" />
                   <span>{item.label}</span>
-                  {item.key === 'library' && pending > 0 ? <span className="nav__badge">{pending}</span> : null}
+                  {item.key === 'device' && pending > 0 ? (
+                    <span className="nav__badge" aria-label={`${pending} 条在录音笔中`}>
+                      {pending}
+                    </span>
+                  ) : null}
+                  {item.key === 'settings' && envFailCount > 0 ? <span className="nav__dot" aria-label="本机环境有待处理项" /> : null}
                 </button>
               );
             })}
@@ -118,16 +116,25 @@ export function App() {
         </aside>
 
         <main className="main">
-          {route.name === 'overview' ? <OverviewPage onOpen={openRecording} onNavigate={navigate} /> : null}
-          {route.name === 'library' ? <LibraryPage onOpen={openRecording} onNavigate={navigate} /> : null}
-          {route.name === 'calendar' ? <CalendarPage /> : null}
+          {route.name === 'library' ? (
+            <LibraryPage stage={route.stage} overview={overview.data} envFailCount={envFailCount} onOpen={openRecording} onChanged={changed} />
+          ) : null}
+          {route.name === 'device' ? <DevicePage envFailCount={envFailCount} onChanged={changed} /> : null}
+          {route.name === 'live' ? <LivePage onOpen={openRecording} /> : null}
+          {route.name === 'calendar' ? <CalendarPage day={route.day} rec={route.rec} /> : null}
+          {route.name === 'categories' ? <CategoriesPage overview={overview.data} onChanged={changed} /> : null}
+          {route.name === 'settings' ? <SettingsPage section={route.section} /> : null}
           {route.name === 'detail' ? (
-            <DetailPage id={route.id} onBack={() => navigate('library')} onRemoved={() => navigate('library')} />
+            <DetailPage
+              id={route.id}
+              backLabel={`返回${backNav?.label ?? '录音'}`}
+              onBack={() => navigate(back)}
+              onRemoved={() => {
+                changed();
+                navigate(DEFAULT_ROUTE);
+              }}
+            />
           ) : null}
-          {route.name === 'live' ? <LivePage onOpen={openRecording} onNavigate={navigate} /> : null}
-          {route.name === 'device' ? <DevicePage onNavigate={navigate} /> : null}
-          {route.name === 'categories' ? <CategoriesPage /> : null}
-          {route.name === 'settings' ? <SettingsPage /> : null}
         </main>
       </div>
     </ToastProvider>
diff --git a/src/ui/api.ts b/src/ui/api.ts
index 09e01d0..6e5daf8 100644
--- a/src/ui/api.ts
+++ b/src/ui/api.ts
@@ -1,13 +1,18 @@
-// ABOUTME: 页面侧 API 客户端，统一解包 { ok, data } 信封并抛出可读错误。
+// ABOUTME: 页面侧 API 客户端，统一解包 { ok, data } 信封；失败时保留中文结论、技术详情与跳转动作。
 
+import { ERROR_COPY, type AppErrorView, type ErrorAction } from '../contracts/errors';
 import { pageConnection } from './connection';
 
 export class ApiError extends Error {
   readonly code: string;
-  constructor(message: string, code: string) {
+  readonly detail?: string;
+  readonly action?: ErrorAction;
+  constructor(message: string, code: string, detail?: string, action?: ErrorAction) {
     super(message);
     this.name = 'ApiError';
     this.code = code;
+    this.detail = detail;
+    this.action = action;
   }
 }
 
@@ -18,17 +23,20 @@ async function request<T>(path: string, init?: RequestInit): Promise<T> {
     headers: { 'content-type': 'application/json', ...(init?.headers ?? {}) },
   });
   if (!response.ok) {
-    throw new ApiError(`服务返回 ${response.status}`, 'HTTP_ERROR');
+    throw new ApiError(ERROR_COPY.HTTP_ERROR.message, 'HTTP_ERROR', `HTTP ${response.status} ${path}`);
   }
   let payload: unknown;
   try {
     payload = await response.json();
-  } catch {
-    throw new ApiError('服务返回了无法解析的内容', 'BAD_RESPONSE');
+  } catch (cause) {
+    throw new ApiError(ERROR_COPY.BAD_RESPONSE.message, 'BAD_RESPONSE', `${path}: ${String(cause)}`);
   }
   if (payload !== null && typeof payload === 'object' && 'ok' in payload) {
-    const envelope = payload as { ok: boolean; data?: unknown; error?: string; code?: string };
-    if (!envelope.ok) throw new ApiError(envelope.error ?? '请求失败', envelope.code ?? 'UNKNOWN');
+    const envelope = payload as { ok: boolean; data?: unknown; error?: string; code?: string; detail?: string; action?: ErrorAction };
+    if (!envelope.ok) {
+      const code = envelope.code ?? 'INTERNAL_ERROR';
+      throw new ApiError(envelope.error ?? ERROR_COPY.INTERNAL_ERROR.message, code, envelope.detail, envelope.action ?? ERROR_COPY[code]?.action);
+    }
     return envelope.data as T;
   }
   return payload as T;
@@ -40,13 +48,24 @@ export const api = {
     request<T>(path, { method: 'POST', body: JSON.stringify(body ?? {}) }),
   patch: <T>(path: string, body?: unknown) =>
     request<T>(path, { method: 'PATCH', body: JSON.stringify(body ?? {}) }),
-  put: <T>(path: string, body?: unknown) =>
-    request<T>(path, { method: 'PUT', body: JSON.stringify(body ?? {}) }),
   remove: <T>(path: string) => request<T>(path, { method: 'DELETE' }),
 };
 
+/** 任意异常 → 可展示的错误视图：主文案中文，原文进 detail。 */
+export function toErrorView(error: unknown): AppErrorView {
+  if (error instanceof ApiError) {
+    return {
+      code: error.code,
+      message: error.message,
+      ...(error.detail ? { detail: error.detail } : {}),
+      ...(error.action ? { action: error.action } : {}),
+    };
+  }
+  const raw = error instanceof Error ? error.stack ?? error.message : String(error);
+  return { code: 'INTERNAL_ERROR', message: ERROR_COPY.INTERNAL_ERROR.message, detail: raw.slice(0, 2000) };
+}
+
+/** 只用在需要拼接纯文本的地方；界面提示请用 ErrorNotice 或 toast.error。 */
 export function errorText(error: unknown): string {
-  if (error instanceof ApiError) return error.message;
-  if (error instanceof Error) return error.message;
-  return '操作失败，请稍后重试';
+  return toErrorView(error).message;
 }
diff --git a/src/ui/calendar.css b/src/ui/calendar.css
index d671387..f62953e 100644
--- a/src/ui/calendar.css
+++ b/src/ui/calendar.css
@@ -34,12 +34,8 @@
 .calendar-link > span { color: var(--app-muted); }
 .calendar-results { background: var(--app-surface); }
 .calendar-markdown { font: inherit; line-height: 1.8; white-space: pre-wrap; overflow-wrap: anywhere; margin: 0; }
-.calendar-transcript h3 { font-size: 14px; margin-top: 24px; margin-bottom: 8px; }
-.calendar-transcript ul { list-style: disc; padding-left: 20px; }
 .calendar-form { display: grid; gap: 14px; }
 .calendar-form input { width: 100%; }
-.calendar-suggestion { padding: 10px 0; font-size: 12px; }
-.calendar-suggestion button { text-align: left; white-space: normal; height: auto; }
 .calendar-page button:focus-visible, .calendar-page summary:focus-visible { outline: 2px solid var(--app-primary); outline-offset: 2px; }
 @media (max-width: 1180px) {
   .calendar-layout { grid-template-columns: minmax(180px, .8fr) minmax(250px, 1.4fr); }
diff --git a/src/ui/components/CalendarAssociation.tsx b/src/ui/components/CalendarAssociation.tsx
deleted file mode 100644
index c4d3348..0000000
--- a/src/ui/components/CalendarAssociation.tsx
+++ /dev/null
@@ -1,32 +0,0 @@
-import { CalendarDays, Link2, Unlink } from 'lucide-react';
-import type { CalendarEvent, CalendarSuggestion } from '../../contracts/calendar';
-import { api, errorText } from '../api';
-import { useAsyncData } from '../useApi';
-import { Button, useToast } from './ui';
-import { useState } from 'react';
-
-export function CalendarAssociation({ id, eventId, revision = '', onChanged }: {
-  id: number; eventId: number | null; revision?: string; onChanged: () => void;
-}) {
-  const toast = useToast();
-  const [busy, setBusy] = useState(false);
-  const suggestions = useAsyncData(() => api.get<CalendarSuggestion[]>(`/api/recordings/${id}/calendar-suggestions`), `suggestions:${id}:${eventId}:${revision}`);
-  const linked = useAsyncData(() => eventId ? api.get<CalendarEvent>(`/api/calendar/events/${eventId}`) : Promise.resolve(null), `linked:${eventId}`);
-  const link = (target: number | null) => {
-    setBusy(true);
-    void api.put(`/api/recordings/${id}`, { calendar_event_id: target }).then(() => {
-      suggestions.reload(); linked.reload(); onChanged(); toast.push(target ? '录音关联已更新' : '已解除关联', 'success');
-    }).catch((cause: unknown) => toast.push(errorText(cause), 'error')).finally(() => setBusy(false));
-  };
-  return <div className="calendar-suggestion">
-    {eventId ? <>
-      <p><CalendarDays size={14} /> {linked.data?.summary ?? `日历事件 #${eventId}`}</p>
-      <Button size="sm" icon={<Unlink size={13} />} disabled={busy} onClick={() => link(null)}>解除关联</Button>
-    </> : suggestions.data?.map(({ event, reason }) => <div key={event.id}>
-      <Button size="sm" icon={<Link2 size={13} />} disabled={busy} onClick={() => link(event.id)}>建议关联到：{event.summary}</Button>
-      <p className="muted">{reason}</p>
-    </div>)}
-    {suggestions.error ? <p role="alert">{suggestions.error}</p> : null}
-    {linked.error ? <p role="alert">{linked.error}</p> : null}
-  </div>;
-}
diff --git a/src/ui/components/DeviceCard.tsx b/src/ui/components/DeviceCard.tsx
new file mode 100644
index 0000000..e80e02a
--- /dev/null
+++ b/src/ui/components/DeviceCard.tsx
@@ -0,0 +1,263 @@
+// ABOUTME: 录音笔卡片：连接/断开、电量与空间、同步（进度、停止）与清理已同步的录音，全部在这一处。
+
+import { BatteryCharging, Bluetooth, Loader2, PlugZap, RefreshCw, Square, Trash2, Unplug, Usb } from 'lucide-react';
+import type { DeviceActivity, DeviceView } from '../../contracts/device';
+import { formatBytes, formatTime, relativeTime } from '../format';
+import type { DeviceHook } from '../useDevice';
+import { ErrorNotice } from './ErrorNotice';
+import { Button } from './ui';
+
+function level(pct: number | null, thresholds: [number, number]): 'good' | 'warn' | 'low' {
+  if (pct === null) return 'low';
+  if (pct >= thresholds[0]) return 'good';
+  if (pct >= thresholds[1]) return 'warn';
+  return 'low';
+}
+
+function Ring({ pct, label, tone }: { pct: number | null; label: string; tone: 'good' | 'warn' | 'low' }) {
+  const radius = 40;
+  const circumference = 2 * Math.PI * radius;
+  const value = Math.min(100, Math.max(0, pct ?? 0));
+  const offset = circumference - (circumference * value) / 100;
+  return (
+    <div className={`ring ring--${tone}`}>
+      <svg viewBox="0 0 100 100" aria-hidden="true">
+        <circle className="ring__track" cx="50" cy="50" r={radius} />
+        <circle
+          className="ring__value"
+          cx="50"
+          cy="50"
+          r={radius}
+          strokeDasharray={circumference}
+          strokeDashoffset={offset}
+          transform="rotate(-90 50 50)"
+        />
+      </svg>
+      <span className="ring__label">
+        <strong>{pct === null ? '--' : pct}</strong>
+        <em>%</em>
+        <span className="ring__caption">{label}</span>
+      </span>
+    </div>
+  );
+}
+
+/** 断开后的灰字说明：休眠、空闲断开都不是错误。 */
+function offlineLine(view: DeviceView): string {
+  const lastSeen = view.device?.lastSeenAt ? `上次在线 ${formatTime(view.device.lastSeenAt)}` : '';
+  switch (view.connection.disconnectReason) {
+    case 'user':
+      return '已断开连接。';
+    case 'idle':
+      return '空闲 10 分钟，已自动断开以节省录音笔电量。';
+    case 'device_sleep':
+    case 'lost':
+      return '录音笔已休眠或离开范围。';
+    case 'live':
+      return '实时字幕结束后会恢复连接。';
+    default:
+      return lastSeen ? `${lastSeen}。` : '唤醒录音笔并放在电脑旁边，点「连接」。';
+  }
+}
+
+const PHASE_TEXT: Record<DeviceActivity['phase'], string> = {
+  connecting: '正在连接录音笔',
+  listing: '正在查看录音笔里的录音',
+  'waiting-network': '等待当前转录完成',
+  preparing: '正在准备无线快传（暂时断开外网）',
+  transferring: '正在传输',
+  restoring: '正在恢复网络',
+  finishing: '正在保存到录音库',
+  deleting: '正在从录音笔删除',
+};
+
+function phaseText(activity: DeviceActivity): string {
+  if (activity.phase === 'transferring' && activity.offline) return '无线快传中（暂时断开外网）';
+  return PHASE_TEXT[activity.phase];
+}
+
+function progressPct(activity: DeviceActivity): number | null {
+  if (!activity.bytesTotal || activity.bytesTotal <= 0) return null;
+  return Math.min(100, Math.round((activity.bytesDone / activity.bytesTotal) * 100));
+}
+
+function Progress({ activity, onCancel, cancelling }: { activity: DeviceActivity; onCancel: () => void; cancelling: boolean }) {
+  const pct = progressPct(activity);
+  const title =
+    activity.kind === 'cleanup'
+      ? '正在清理已同步的录音'
+      : `正在同步${activity.count > 0 ? ` ${Math.max(1, activity.index)}/${activity.count}` : ''}${pct !== null ? ` · ${pct}%` : ''}`;
+  return (
+    <div className="devicecard__progress" role="status" aria-live="polite">
+      <div className="devicecard__progresshead">
+        <strong>{title}</strong>
+        <Button
+          size="sm"
+          variant="quiet"
+          icon={<Square size={13} aria-hidden="true" />}
+          disabled={cancelling || activity.cancelling}
+          onClick={onCancel}
+        >
+          {activity.cancelling ? '正在停止…' : '停止'}
+        </Button>
+      </div>
+      <div className="progressbar" aria-hidden="true">
+        <span className={`progressbar__fill${pct === null ? ' progressbar__fill--indeterminate' : ''}`} style={pct === null ? undefined : { width: `${pct}%` }} />
+      </div>
+      <p className="devicecard__phase">{phaseText(activity)}</p>
+    </div>
+  );
+}
+
+interface Props {
+  device: DeviceHook;
+  /** 还没读过清单时用库里的待同步条数估算。 */
+  pendingCount: number;
+}
+
+export function DeviceCard({ device, pendingCount }: Props) {
+  const view = device.view;
+  if (!view) return null;
+  const { state } = view.connection;
+  const info = view.device;
+  const fallback = view.activity?.fallback ?? (state === 'connected' ? view.lastResult?.fallback ?? null : null);
+  const listed = view.cleanable !== null;
+  const onDeviceCount = listed ? view.onDevice.length : pendingCount;
+  const lastError = view.lastError ?? (state === 'connected' ? view.lastResult?.error ?? null : null);
+
+  if (state === 'disconnected' || state === 'connecting') {
+    const connecting = state === 'connecting' || device.pending === 'connect';
+    // 点「连接」会直接开始同步：断网提示必须在点之前就能看到。
+    const offlineHint = !connecting && view.autoConnect.syncOnConnect && view.syncPlan?.willGoOffline;
+    return (
+      <section className="devicehero devicehero--off devicecard">
+        <div className="devicehero__offmain">
+          <span className="devicehero__officon" aria-hidden="true">
+            <Bluetooth size={22} />
+          </span>
+          <div className="devicehero__offtext">
+            <h2>{connecting ? '正在连接录音笔…' : '录音笔未连接'}</h2>
+            <p className="muted">{connecting ? '请保持录音笔在电脑旁边。' : offlineLine(view)}</p>
+          </div>
+        </div>
+        <div className="devicecard__primary devicecard__primary--off">
+          <Button
+            variant="primary"
+            icon={connecting ? <Loader2 size={15} className="spin" aria-hidden="true" /> : <PlugZap size={15} aria-hidden="true" />}
+            disabled={connecting}
+            onClick={() => void device.connect()}
+          >
+            {connecting ? '正在连接…' : '连接'}
+          </Button>
+          {offlineHint ? (
+            <span className="devicecard__hint">连上后会自动同步，较大的录音将通过无线快传，期间电脑会暂时断开外网</span>
+          ) : null}
+        </div>
+        {lastError && !connecting ? (
+          <div className="devicecard__notice">
+            <ErrorNotice error={lastError} />
+          </div>
+        ) : null}
+      </section>
+    );
+  }
+
+  if (state === 'live') {
+    return (
+      <section className="devicehero devicehero--off devicecard">
+        <div className="devicehero__offmain">
+          <span className="devicehero__officon" aria-hidden="true">
+            <Bluetooth size={22} />
+          </span>
+          <div className="devicehero__offtext">
+            <h2>实时字幕正在使用录音笔</h2>
+            <p className="muted">实时字幕进行时无法同步录音，结束后会恢复连接。</p>
+          </div>
+        </div>
+        <a className="linkbtn" href="#/live">
+          去实时字幕
+        </a>
+      </section>
+    );
+  }
+
+  const busy = state === 'busy' || Boolean(view.activity);
+  const syncLabel = onDeviceCount > 0 ? `同步录音（${onDeviceCount}）` : listed ? '检查新录音' : '同步录音';
+  const cleanable = view.cleanable && view.cleanable.count > 0 ? view.cleanable : null;
+
+  const confirmCleanup = () => {
+    if (!cleanable) return;
+    if (!window.confirm(`从录音笔删除 ${cleanable.count} 条已经同步到电脑的录音（${formatBytes(cleanable.bytes)}）？电脑上的录音不受影响，录音笔上的删除不可恢复。`)) return;
+    void device.cleanup();
+  };
+
+  return (
+    <section className="devicehero devicehero--on devicecard">
+      <div className="devicehero__aurora" aria-hidden="true" />
+      <div className="devicehero__meters">
+        <Ring pct={info?.batteryPct ?? null} label="电量" tone={level(info?.batteryPct ?? null, [50, 20])} />
+        <Ring pct={info?.freeSpacePct ?? null} label="剩余" tone={level(info?.freeSpacePct ?? null, [30, 10])} />
+      </div>
+
+      <div className="devicehero__info">
+        <div className="devicehero__title">
+          <h2>{info?.model ?? '录音笔'}</h2>
+          <span className="devicehero__online">
+            <span className="pulse" aria-hidden="true" />
+            已连接{info?.lastSeenAt ? ` · ${relativeTime(info.lastSeenAt)}` : ''}
+          </span>
+        </div>
+        <p className="devicehero__meta">
+          {info?.serial ? <code>{info.serial}</code> : null}
+          {info?.firmware ? <span>固件 {info.firmware}</span> : null}
+          <span>
+            <BatteryCharging size={13} aria-hidden="true" /> {info?.batteryPct ?? '--'}%
+          </span>
+          <span>
+            <Usb size={13} aria-hidden="true" /> 剩余 {info?.freeSpacePct ?? '--'}%
+          </span>
+        </p>
+
+        {busy && view.activity ? (
+          <Progress activity={view.activity} cancelling={device.pending === 'cancel'} onCancel={() => void device.cancel()} />
+        ) : (
+          <div className="devicecard__actions">
+            <div className="devicecard__primary">
+              <Button
+                variant="primary"
+                icon={device.pending === 'sync' ? <Loader2 size={15} className="spin" aria-hidden="true" /> : <RefreshCw size={15} aria-hidden="true" />}
+                disabled={device.pending !== null}
+                onClick={() => void device.sync()}
+              >
+                {syncLabel}
+              </Button>
+              {view.syncPlan?.willGoOffline ? (
+                <span className="devicecard__hint">将通过无线快传，期间电脑会暂时断开外网（约 1 分钟）</span>
+              ) : null}
+            </div>
+            <Button
+              icon={<Unplug size={15} aria-hidden="true" />}
+              disabled={device.pending !== null}
+              onClick={() => void device.disconnect()}
+            >
+              断开连接
+            </Button>
+            {cleanable ? (
+              <Button
+                variant="quiet"
+                icon={<Trash2 size={14} aria-hidden="true" />}
+                disabled={device.pending !== null}
+                onClick={confirmCleanup}
+              >
+                清理已同步的录音（{cleanable.count} 条 · {formatBytes(cleanable.bytes)}）
+              </Button>
+            ) : null}
+          </div>
+        )}
+
+        {fallback ? <ErrorNotice error={fallback} tone="notice" /> : null}
+        {lastError && !busy ? <ErrorNotice error={lastError} onRetry={() => void device.sync()} /> : null}
+      </div>
+    </section>
+  );
+}
diff --git a/src/ui/components/DeviceHero.tsx b/src/ui/components/DeviceHero.tsx
deleted file mode 100644
index a9e1af1..0000000
--- a/src/ui/components/DeviceHero.tsx
+++ /dev/null
@@ -1,151 +0,0 @@
-// ABOUTME: 首页设备卡：已连接时展示电量与容量仪表，未连接时给出连接入口。
-
-import { BatteryCharging, Bluetooth, HardDriveDownload, ListTree, Loader2, RefreshCw, Usb } from 'lucide-react';
-import type { DeviceHero } from '../../contracts/app';
-import { relativeTime } from '../format';
-import { Button } from './ui';
-
-interface Props {
-  device: DeviceHero | null;
-  refreshing: boolean;
-  connecting: boolean;
-  onConnect: () => void;
-  onRefresh: () => void;
-  onNavigate: (route: string) => void;
-}
-
-function level(pct: number | null, thresholds: [number, number]): 'good' | 'warn' | 'low' {
-  if (pct === null) return 'low';
-  if (pct >= thresholds[0]) return 'good';
-  if (pct >= thresholds[1]) return 'warn';
-  return 'low';
-}
-
-function Ring({ pct, label, tone }: { pct: number | null; label: string; tone: 'good' | 'warn' | 'low' }) {
-  const radius = 40;
-  const circumference = 2 * Math.PI * radius;
-  const value = Math.min(100, Math.max(0, pct ?? 0));
-  const offset = circumference - (circumference * value) / 100;
-  return (
-    <div className={`ring ring--${tone}`}>
-      <svg viewBox="0 0 100 100" aria-hidden="true">
-        <circle className="ring__track" cx="50" cy="50" r={radius} />
-        <circle
-          className="ring__value"
-          cx="50"
-          cy="50"
-          r={radius}
-          strokeDasharray={circumference}
-          strokeDashoffset={offset}
-          transform="rotate(-90 50 50)"
-        />
-      </svg>
-      <span className="ring__label">
-        <strong>{pct === null ? '--' : pct}</strong>
-        <em>%</em>
-        <span className="ring__caption">{label}</span>
-      </span>
-    </div>
-  );
-}
-
-export function DeviceHeroCard({ device, refreshing, connecting, onConnect, onRefresh, onNavigate }: Props) {
-  if (!device || !device.connected) {
-    return (
-      <section className="devicehero devicehero--off">
-        <div className="devicehero__offmain">
-          <span className="devicehero__officon" aria-hidden="true">
-            <Bluetooth size={22} />
-          </span>
-          <div className="devicehero__offtext">
-            <h2>录音笔未连接</h2>
-            <p>
-              {device?.lastSeenAt
-                ? `上次连接于 ${relativeTime(device.lastSeenAt)}。唤醒录音笔后点右侧按钮即可直接连接。`
-                : '把录音笔唤醒并放在电脑旁边，点右侧按钮直接连接，就能看到电量、剩余容量与待拉取录音。'}
-            </p>
-          </div>
-        </div>
-        <Button
-          variant="primary"
-          icon={
-            connecting ? (
-              <Loader2 size={15} className="spin" aria-hidden="true" />
-            ) : (
-              <Bluetooth size={15} aria-hidden="true" />
-            )
-          }
-          disabled={connecting}
-          onClick={onConnect}
-        >
-          {connecting ? '连接中…' : '连接设备'}
-        </Button>
-      </section>
-    );
-  }
-
-  const batteryTone = level(device.batteryPct, [50, 20]);
-  const storageTone = level(device.freeSpacePct, [30, 10]);
-
-  return (
-    <section className="devicehero devicehero--on">
-      <div className="devicehero__aurora" aria-hidden="true" />
-      <div className="devicehero__waves" aria-hidden="true">
-        {Array.from({ length: 7 }, (_, index) => (
-          <span key={index} style={{ animationDelay: `${index * 90}ms` }} />
-        ))}
-      </div>
-
-      <div className="devicehero__meters">
-        <Ring pct={device.batteryPct} label="电量" tone={batteryTone} />
-        <Ring pct={device.freeSpacePct} label="剩余" tone={storageTone} />
-      </div>
-
-      <div className="devicehero__info">
-        <div className="devicehero__title">
-          <h2>{device.model}</h2>
-          <span className="devicehero__online">
-            <span className="pulse" aria-hidden="true" />
-            在线 · {relativeTime(device.lastSeenAt)}
-          </span>
-        </div>
-        <p className="devicehero__meta">
-          <code>{device.serial}</code>
-          {device.firmware ? <span>固件 {device.firmware}</span> : null}
-          <span>
-            <BatteryCharging size={13} aria-hidden="true" /> {device.batteryPct ?? '--'}%
-          </span>
-          <span>
-            <Usb size={13} aria-hidden="true" /> 剩余 {device.freeSpacePct ?? '--'}%
-          </span>
-        </p>
-        <p className="devicehero__queue">
-          {device.pendingPulls > 0 ? (
-            <button type="button" className="devicehero__link" onClick={() => onNavigate('device')}>
-              还有 {device.pendingPulls} 条录音待拉取 →
-            </button>
-          ) : (
-            <span className="muted">设备清单已全部拉取</span>
-          )}
-          {device.readyToTranscribe > 0 ? (
-            <button type="button" className="devicehero__link" onClick={() => onNavigate('library')}>
-              {device.readyToTranscribe} 条待转录 →
-            </button>
-          ) : null}
-        </p>
-      </div>
-
-      <div className="devicehero__actions">
-        <Button size="sm" icon={<RefreshCw size={14} aria-hidden="true" />} disabled={refreshing} onClick={onRefresh}>
-          {refreshing ? '读取中' : '刷新状态'}
-        </Button>
-        <Button size="sm" icon={<ListTree size={14} aria-hidden="true" />} onClick={() => onNavigate('device')}>
-          读取清单
-        </Button>
-        <Button size="sm" variant="quiet" icon={<HardDriveDownload size={14} aria-hidden="true" />} onClick={() => onNavigate('device')}>
-          拉取录音
-        </Button>
-      </div>
-    </section>
-  );
-}
diff --git a/src/ui/components/DeviceRecordingList.tsx b/src/ui/components/DeviceRecordingList.tsx
new file mode 100644
index 0000000..d7bbfdd
--- /dev/null
+++ b/src/ui/components/DeviceRecordingList.tsx
@@ -0,0 +1,60 @@
+// ABOUTME: 「还在录音笔里」列表：单条同步的唯一入口；同步中或实时字幕占用时禁用并写明原因。
+
+import { RefreshCw } from 'lucide-react';
+import type { DeviceRecordingOnDevice } from '../../contracts/device';
+import { formatBytes, formatDateTime, formatDuration } from '../format';
+import { Button, Card } from './ui';
+
+interface Props {
+  items: DeviceRecordingOnDevice[];
+  /** 禁用原因；null 表示可以同步。 */
+  blockedReason: string | null;
+  /** 单条达到这个大小会走无线快传、暂时断开外网；null 表示不会。 */
+  wifiFromBytes: number | null;
+  onPull: (id: number) => void;
+}
+
+function goesOffline(item: DeviceRecordingOnDevice, wifiFromBytes: number | null): boolean {
+  if (wifiFromBytes === null) return false;
+  // 大小未知（只登记了清单）时不提示：真正同步前会先读录音笔里的实际大小。
+  return item.sizeBytes !== null && item.sizeBytes >= wifiFromBytes;
+}
+
+export function DeviceRecordingList({ items, blockedReason, wifiFromBytes, onPull }: Props) {
+  const anyOffline = items.some((item) => goesOffline(item, wifiFromBytes));
+  return (
+    <Card title={`还在录音笔里${items.length > 0 ? `（${items.length}）` : ''}`}>
+      {items.length === 0 ? (
+        <p className="muted">录音笔里的录音都已同步到电脑。</p>
+      ) : (
+        <ul className="pulllist">
+          {items.map((item) => {
+            const offline = goesOffline(item, wifiFromBytes);
+            return (
+              <li key={item.id}>
+                <span className="pulllist__name">{item.filename}</span>
+                <span className="pulllist__meta">
+                  {item.recordedAt ? `${formatDateTime(item.recordedAt)} · ` : ''}
+                  {formatDuration(item.durationSec)} · {formatBytes(item.sizeBytes)}{offline ? ' · 无线快传' : ''}
+                </span>
+                <Button
+                  size="sm"
+                  icon={<RefreshCw size={13} aria-hidden="true" />}
+                  disabled={blockedReason !== null}
+                  title={blockedReason ?? (offline ? '将通过无线快传，期间电脑会暂时断开外网' : undefined)}
+                  onClick={() => onPull(item.id)}
+                >
+                  同步
+                </Button>
+              </li>
+            );
+          })}
+        </ul>
+      )}
+      {anyOffline && !blockedReason ? (
+        <p className="muted pulllist__hint">标「无线快传」的录音较大，同步期间电脑会暂时断开外网。</p>
+      ) : null}
+      {blockedReason && items.length > 0 ? <p className="muted">{blockedReason}</p> : null}
+    </Card>
+  );
+}
diff --git a/src/ui/components/EnvironmentBanner.tsx b/src/ui/components/EnvironmentBanner.tsx
new file mode 100644
index 0000000..3d329b1
--- /dev/null
+++ b/src/ui/components/EnvironmentBanner.tsx
@@ -0,0 +1,16 @@
+// ABOUTME: 本机环境有失败项时的提示条；只是跳转到「设置 › 诊断与高级」，本身不执行修复。
+
+import { CircleAlert } from 'lucide-react';
+
+export function EnvironmentBanner({ failCount }: { failCount: number }) {
+  if (failCount <= 0) return null;
+  return (
+    <div className="envbanner" role="status">
+      <CircleAlert size={15} aria-hidden="true" />
+      <span>本机有 {failCount} 项组件还没准备好，部分功能可能用不了。</span>
+      <a className="linkbtn" href="#/settings/diagnostics">
+        去诊断与修复
+      </a>
+    </div>
+  );
+}
diff --git a/src/ui/components/EnvironmentPanel.tsx b/src/ui/components/EnvironmentPanel.tsx
index 7a2317b..12de8ef 100644
--- a/src/ui/components/EnvironmentPanel.tsx
+++ b/src/ui/components/EnvironmentPanel.tsx
@@ -1,21 +1,70 @@
+// ABOUTME: 本机环境自检（设置 › 诊断与高级）：按 4 个分组显示，每行可展开详情；重新检测与 Floatboat 助手修复。
+
 import { useEffect, useState } from 'react';
-import { Wrench } from 'lucide-react';
-import type { EnvironmentState, RepairState } from '../../contracts/preflight';
-import { api, errorText } from '../api';
-import { Button, Card } from './ui';
+import { RefreshCw, Wrench } from 'lucide-react';
+import type { AppErrorView } from '../../contracts/errors';
+import type { EnvironmentState, PreflightGroup, PreflightItem, RepairState } from '../../contracts/preflight';
+import { api, toErrorView } from '../api';
 import { formatDateTime } from '../format';
+import { ErrorNotice } from './ErrorNotice';
+import { Button, useToast } from './ui';
 
-const statusText = { ok: '就绪', warn: '待确认', fail: '失败' };
+const statusText = { ok: '就绪', warn: '待确认', fail: '没准备好' };
 const repairText = {
   idle: '尚未请求修复', starting: '正在提交', running: '修复中',
   recovering: '正在恢复上次修复', unknown: '修复结果未知，已禁止重复提交',
-  completed: '任务已结束', failed: '任务失败', cancelled: '任务已取消', interrupted: '任务已中断',
+  completed: '修复已结束', failed: '修复没有完成', cancelled: '修复已取消', interrupted: '修复被中断',
 };
+const GROUPS: Array<{ key: PreflightGroup; label: string }> = [
+  { key: 'device', label: '录音笔组件' },
+  { key: 'audio', label: '音频处理' },
+  { key: 'ai', label: '语音识别与 AI 整理' },
+  { key: 'storage', label: '存储目录' },
+];
+
+function EnvRow({ item }: { item: PreflightItem }) {
+  const [open, setOpen] = useState(false);
+  return (
+    <li className={`env__row env__row--${item.status}`} data-preflight-id={item.id}>
+      <span className="env__dot" aria-hidden="true" />
+      <span className="env__label">{item.label}</span>
+      <span className="env__detail">
+        {item.reason}
+        {item.status !== 'ok' && item.action ? <span className="env__action">{item.action}</span> : null}
+      </span>
+      <span className="env__state">{statusText[item.status]}</span>
+      {item.detail && item.status !== 'ok' ? (
+        <button type="button" className="linkbtn env__more" aria-expanded={open} onClick={() => setOpen((value) => !value)}>
+          查看详情
+        </button>
+      ) : null}
+      {open && item.detail ? <pre className="errornotice__detail env__pre">{item.detail}</pre> : null}
+    </li>
+  );
+}
 
-export function EnvironmentPanel({ revision }: { revision: number }) {
+function RepairStatus({ repair }: { repair: RepairState }) {
+  if (repair.status === 'idle') return null;
+  return (
+    <section className="environment-repair" aria-live="polite">
+      <p>{repairText[repair.status]}</p>
+      {repair.text ? <pre>{repair.text}</pre> : null}
+      <details className="env__ids">
+        <summary>查看详情</summary>
+        <p className="muted">任务编号：{repair.runId ?? '—'}</p>
+        <p className="muted">提交编号：{repair.idempotencyKey}</p>
+      </details>
+    </section>
+  );
+}
+
+export function EnvironmentPanel() {
+  const toast = useToast();
   const [state, setState] = useState<EnvironmentState | null>(null);
-  const [error, setError] = useState('');
+  const [error, setError] = useState<AppErrorView | null>(null);
   const [submitting, setSubmitting] = useState(false);
+  const [checking, setChecking] = useState(false);
+  const [revision, setRevision] = useState(0);
   useEffect(() => {
     let disposed = false;
     let timer: ReturnType<typeof setTimeout>;
@@ -24,10 +73,10 @@ export function EnvironmentPanel({ revision }: { revision: number }) {
         const next = await api.get<EnvironmentState>('/api/environment');
         if (!disposed) {
           setState(next);
-          setError('');
+          setError(null);
         }
       } catch (failure) {
-        if (!disposed) setError(errorText(failure));
+        if (!disposed) setError(toErrorView(failure));
       } finally {
         if (!disposed) timer = setTimeout(() => void refresh(), 2500);
       }
@@ -36,41 +85,66 @@ export function EnvironmentPanel({ revision }: { revision: number }) {
     return () => { disposed = true; clearTimeout(timer); };
   }, [revision]);
 
+  const recheck = async () => {
+    setChecking(true);
+    setError(null);
+    try {
+      await api.post('/api/environment/check');
+      setRevision((value) => value + 1);
+      toast.push('环境检测已刷新', 'success');
+    } catch (failure) {
+      setError(toErrorView(failure));
+    } finally {
+      setChecking(false);
+    }
+  };
+
   const repair = async () => {
     setSubmitting(true);
-    setError('');
+    setError(null);
     try {
       const next = await api.post<RepairState>('/api/environment/repair');
       setState((previous) => previous ? { ...previous, repair: next } : previous);
     } catch (failure) {
-      setError(errorText(failure));
+      setError(toErrorView(failure));
     } finally {
       setSubmitting(false);
     }
   };
-  const available = state?.report.items.find((item) => item.id === 'host-agent')?.status === 'ok';
-  const fixable = state?.report.items.some((item) => item.status === 'fail' && item.autoRepair);
+  const items = state?.report.items ?? [];
+  const available = items.find((item) => item.id === 'host-agent')?.status === 'ok';
+  const fixable = items.some((item) => item.status === 'fail' && item.autoRepair);
   const running = state !== null && ['running', 'starting', 'recovering', 'unknown'].includes(state.repair.status);
-  return <div className="environment-panel"><Card title="本机环境" action={<span className="muted">{state ? `检测于 ${formatDateTime(state.report.checkedAt)}` : '正在检测'}</span>}>
-    {error ? <p className="notice" role="alert">{error}</p> : null}
-    <ul className="env">
-      {state?.report.items.map((item) => <li key={item.id} className={`env__row env__row--${item.status}`} data-preflight-id={item.id}>
-        <span className="env__dot" aria-hidden="true" />
-        <span className="env__label">{item.label}</span>
-        <span className="env__detail">{item.reason}</span>
-        <span className="env__state">{statusText[item.status]}</span>
-        {item.status !== 'ok' && item.action ? <span className="env__action">{item.action}</span> : null}
-      </li>)}
-    </ul>
-    {fixable ? <Button icon={<Wrench size={15} aria-hidden="true" />} disabled={!available || submitting || running} onClick={() => void repair()}>
-      让 Floatboat 助手修复
-    </Button> : null}
-    {state && !available ? <p className="notice">agent 不可用。请按失败项的手动步骤修复，或在 Floatboat 中授权 agent 能力后重新检测。</p> : null}
-    {state && state.repair.status !== 'idle' ? <section className="environment-repair" aria-live="polite">
-      <p>{repairText[state.repair.status]}</p>
-      <pre>{state.repair.text}</pre>
-      {state.repair.runId ? <p className="muted">Host 任务：{state.repair.runId}</p> : null}
-      <p className="muted">任务键：{state.repair.idempotencyKey}</p>
-    </section> : null}
-  </Card></div>;
+  return (
+    <div className="environment-panel">
+      <div className="diag__head">
+        <span className="muted">{state ? `检测于 ${formatDateTime(state.report.checkedAt)}` : '正在检测'}</span>
+        <Button size="sm" icon={<RefreshCw size={14} aria-hidden="true" />} disabled={checking} onClick={() => void recheck()}>
+          {checking ? '正在检测…' : '重新检测'}
+        </Button>
+      </div>
+      {error ? <ErrorNotice error={error} /> : null}
+      {GROUPS.map((group) => {
+        const rows = items.filter((item) => (item.group ?? 'storage') === group.key);
+        if (rows.length === 0) return null;
+        return (
+          <div key={group.key} className="env__group">
+            <h4>{group.label}</h4>
+            <ul className="env">
+              {rows.map((item) => <EnvRow key={item.id} item={item} />)}
+            </ul>
+          </div>
+        );
+      })}
+      {fixable ? (
+        <Button icon={<Wrench size={15} aria-hidden="true" />} disabled={!available || submitting || running} onClick={() => void repair()}>
+          让 Floatboat 助手修复
+        </Button>
+      ) : null}
+      {state && fixable && !available ? (
+        <p className="notice">Floatboat 助手暂不可用。请按失败项的提示手动处理，或在 Floatboat 中开启助手后重新检测。</p>
+      ) : null}
+      {state ? <RepairStatus repair={state.repair} /> : null}
+    </div>
+  );
 }
diff --git a/src/ui/components/ErrorNotice.tsx b/src/ui/components/ErrorNotice.tsx
new file mode 100644
index 0000000..79f518a
--- /dev/null
+++ b/src/ui/components/ErrorNotice.tsx
@@ -0,0 +1,70 @@
+// ABOUTME: 两层错误提示：主行一句中文结论，技术原文只在点「查看详情」后展开。
+
+import { useState } from 'react';
+import { ChevronDown, ChevronRight, CircleAlert, Copy, Info, RefreshCw } from 'lucide-react';
+import type { AppErrorView } from '../../contracts/errors';
+
+interface Props {
+  error: AppErrorView;
+  /** notice 用于回退提示等非错误信息。 */
+  tone?: 'error' | 'notice';
+  onRetry?: () => void;
+  /** 在 Modal 里使用时默认展开详情。 */
+  defaultOpen?: boolean;
+}
+
+export function diagnosticText(error: AppErrorView): string {
+  return [`[${error.code}] ${error.message}`, error.detail ?? ''].filter(Boolean).join('\n');
+}
+
+export function ErrorNotice({ error, tone = 'error', onRetry, defaultOpen = false }: Props) {
+  const [open, setOpen] = useState(defaultOpen);
+  const [copied, setCopied] = useState(false);
+  const copy = async () => {
+    try {
+      await navigator.clipboard.writeText(diagnosticText(error));
+      setCopied(true);
+      window.setTimeout(() => setCopied(false), 1600);
+    } catch {
+      setCopied(false);
+    }
+  };
+  return (
+    <div className={`errornotice errornotice--${tone}`} role={tone === 'error' ? 'alert' : 'status'}>
+      <div className="errornotice__main">
+        {tone === 'error' ? <CircleAlert size={15} aria-hidden="true" /> : <Info size={15} aria-hidden="true" />}
+        <span className="errornotice__message">{error.message}</span>
+        <span className="errornotice__actions">
+          {error.action ? (
+            <a className="linkbtn" href={error.action.href}>
+              {error.action.label}
+            </a>
+          ) : null}
+          {onRetry ? (
+            <button type="button" className="linkbtn" onClick={onRetry}>
+              <RefreshCw size={12} aria-hidden="true" /> 重试
+            </button>
+          ) : null}
+          {error.detail ? (
+            <button type="button" className="linkbtn" aria-expanded={open} onClick={() => setOpen((value) => !value)}>
+              {open ? <ChevronDown size={12} aria-hidden="true" /> : <ChevronRight size={12} aria-hidden="true" />} 查看详情
+            </button>
+          ) : null}
+        </span>
+      </div>
+      {open && error.detail ? (
+        <div className="errornotice__more">
+          <pre className="errornotice__detail">{diagnosticText(error)}</pre>
+          <span className="errornotice__tools">
+            <button type="button" className="linkbtn" onClick={() => void copy()}>
+              <Copy size={12} aria-hidden="true" /> {copied ? '已复制' : '复制诊断信息'}
+            </button>
+            <a className="linkbtn" href="#/settings/diagnostics">
+              在诊断中查看
+            </a>
+          </span>
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/src/ui/components/EventLinker.tsx b/src/ui/components/EventLinker.tsx
new file mode 100644
index 0000000..e63fe80
--- /dev/null
+++ b/src/ui/components/EventLinker.tsx
@@ -0,0 +1,104 @@
+// ABOUTME: 录音 ↔ 日程关联的唯一控件：建议一键关联、选择其他事件、新建事件、解除关联。
+
+import { useState } from 'react';
+import { ChevronDown, ChevronRight, Link2, Plus, Unlink } from 'lucide-react';
+import type { CalendarEvent, CalendarRecording, CalendarSuggestion } from '../../contracts/calendar';
+import { api } from '../api';
+import { useAsyncData } from '../useApi';
+import { Button, useToast } from './ui';
+
+interface Props {
+  recording: CalendarRecording;
+  events: CalendarEvent[];
+  expanded: boolean;
+  highlighted?: boolean;
+  onToggle: () => void;
+  /** 打开新建事件对话框；创建成功后用回调把这条录音关联过去。 */
+  onCreateEvent: (linkTo: (eventId: number) => Promise<void>) => void;
+  onChanged: () => void;
+}
+
+export function EventLinker({ recording, events, expanded, highlighted, onToggle, onCreateEvent, onChanged }: Props) {
+  const toast = useToast();
+  const [busy, setBusy] = useState(false);
+  const linkedId = recording.calendarEventId;
+  const linked = events.find((event) => event.id === linkedId);
+  const suggestions = useAsyncData<CalendarSuggestion[]>(
+    () => (expanded ? api.get<CalendarSuggestion[]>(`/api/recordings/${recording.id}/calendar-suggestions`) : Promise.resolve([])),
+    `linker:${recording.id}:${linkedId ?? 0}:${expanded ? 1 : 0}`,
+  );
+
+  const link = async (target: number | null) => {
+    setBusy(true);
+    try {
+      await api.patch(`/api/recordings/${recording.id}`, { calendarEventId: target });
+      toast.push(target ? '已关联日程' : '已解除关联', 'success');
+      onChanged();
+    } catch (error) {
+      toast.error(error);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const status = linkedId ? `已关联：${linked?.summary ?? '其他日期的日程'}` : '未关联日程';
+  const offered = (suggestions.data ?? []).filter((item) => item.event.id !== linkedId);
+
+  return (
+    <div className={`eventlinker${highlighted ? ' eventlinker--highlight' : ''}`} data-recording-id={recording.id}>
+      <button type="button" className="eventlinker__toggle" aria-expanded={expanded} onClick={onToggle}>
+        {expanded ? <ChevronDown size={13} aria-hidden="true" /> : <ChevronRight size={13} aria-hidden="true" />}
+        <span>{status}</span>
+        <span className="eventlinker__cta">{linkedId ? '修改' : '关联'}</span>
+      </button>
+      {expanded ? (
+        <div className="eventlinker__body">
+          {offered.length > 0 ? (
+            <ul className="eventlinker__suggestions" aria-label="建议关联">
+              {offered.map(({ event, reason }) => (
+                <li key={event.id}>
+                  <Button size="sm" icon={<Link2 size={13} aria-hidden="true" />} disabled={busy} onClick={() => void link(event.id)}>
+                    关联到：{event.summary}
+                  </Button>
+                  <span className="muted">{reason}</span>
+                </li>
+              ))}
+            </ul>
+          ) : suggestions.loading ? null : (
+            <p className="muted">没有时间上接近的日程。</p>
+          )}
+          <label className="calendar-link">
+            <span>选择其他事件</span>
+            <select
+              aria-label={`选择其他事件：${recording.title}`}
+              disabled={busy}
+              value={linkedId ?? ''}
+              onChange={(event) => {
+                const value = Number(event.target.value);
+                if (value) void link(value);
+              }}
+            >
+              <option value="">请选择</option>
+              {linkedId && !linked ? <option value={linkedId}>当前关联的日程</option> : null}
+              {events.map((event) => (
+                <option key={event.id} value={event.id}>
+                  {event.summary} · {event.startTime.slice(0, 10)}
+                </option>
+              ))}
+            </select>
+          </label>
+          <div className="eventlinker__tools">
+            <Button size="sm" variant="quiet" icon={<Plus size={13} aria-hidden="true" />} disabled={busy} onClick={() => onCreateEvent((eventId) => link(eventId))}>
+              新建事件
+            </Button>
+            {linkedId ? (
+              <Button size="sm" variant="quiet" icon={<Unlink size={13} aria-hidden="true" />} disabled={busy} onClick={() => void link(null)}>
+                解除关联
+              </Button>
+            ) : null}
+          </div>
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/src/ui/components/ImportDialog.tsx b/src/ui/components/ImportDialog.tsx
new file mode 100644
index 0000000..f2ba05b
--- /dev/null
+++ b/src/ui/components/ImportDialog.tsx
@@ -0,0 +1,124 @@
+// ABOUTME: 「导入」对话框：导入本地文件夹的唯一入口；目录只在设置里修改，结果在对话框内显示。
+
+import { useState } from 'react';
+import { Copy, ScanLine } from 'lucide-react';
+import type { ImportDirectoryState, IngestScanResult } from '../../contracts/app';
+import type { AppErrorView } from '../../contracts/errors';
+import { api, toErrorView } from '../api';
+import { useAsyncData } from '../useApi';
+import { ErrorNotice } from './ErrorNotice';
+import { Button, Loading, Modal, useToast } from './ui';
+
+const OUTCOME_TEXT: Record<IngestScanResult['files'][number]['outcome'], string> = {
+  imported: '已导入',
+  skipped: '已跳过',
+  failed: '没有导入',
+};
+
+export function ImportDialog({ onClose, onImported }: { onClose: () => void; onImported: (result: IngestScanResult) => void }) {
+  const toast = useToast();
+  const directory = useAsyncData<ImportDirectoryState>(() => api.get<ImportDirectoryState>('/api/ingest/directory'), 'import-directory');
+  const [busy, setBusy] = useState(false);
+  const [result, setResult] = useState<IngestScanResult | null>(null);
+  const [error, setError] = useState<AppErrorView | null>(null);
+  const dir = directory.data;
+
+  const scan = async () => {
+    setBusy(true);
+    setError(null);
+    try {
+      const next = await api.post<IngestScanResult>('/api/ingest/scan', {});
+      setResult(next);
+      directory.reload();
+      onImported(next);
+    } catch (cause) {
+      setError(toErrorView(cause));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const copyPath = async () => {
+    if (!dir) return;
+    try {
+      await navigator.clipboard.writeText(dir.directory);
+      toast.push('路径已复制，可以粘贴到文件管理器的地址栏', 'success');
+    } catch {
+      toast.push(`复制没有成功，请手动记下路径：${dir.directory}`, 'info');
+    }
+  };
+
+  const summary = (() => {
+    if (!result) return null;
+    if (result.imported === 0 && result.skipped === 0 && result.failed === 0) {
+      return result.created ? '已建好导入文件夹，把录音文件放进去后再扫描一次。' : '文件夹里还没有可以导入的录音文件。';
+    }
+    const parts = [`已导入 ${result.imported} 条`];
+    if (result.skipped > 0) parts.push(`跳过 ${result.skipped} 条`);
+    if (result.failed > 0) parts.push(`${result.failed} 条没有导入`);
+    return `${parts.join('，')}。`;
+  })();
+
+  return (
+    <Modal
+      title="导入录音"
+      onClose={onClose}
+      footer={
+        <>
+          <Button variant="quiet" onClick={onClose}>
+            关闭
+          </Button>
+          <Button variant="primary" icon={<ScanLine size={15} aria-hidden="true" />} disabled={busy || !dir} onClick={() => void scan()}>
+            {busy ? '正在扫描…' : '扫描并导入'}
+          </Button>
+        </>
+      }
+    >
+      <p className="muted">把录音文件（MP3、WAV、M4A 等）放进下面的文件夹，再点「扫描并导入」。</p>
+      {directory.loading && !dir ? <Loading label="正在读取导入文件夹" /> : null}
+      {directory.error ? <ErrorNotice error={directory.error} onRetry={directory.reload} /> : null}
+      {dir ? (
+        <>
+          <div className="pathrow">
+            <code className="pathrow__path" title={dir.directory}>
+              {dir.directory}
+            </code>
+            <Button size="sm" icon={<Copy size={14} aria-hidden="true" />} onClick={() => void copyPath()}>
+              复制路径
+            </Button>
+          </div>
+          <p className="hintline">
+            {dir.exists ? `文件夹里有 ${dir.audioFiles} 个音频文件。` : '文件夹还不存在，扫描时会自动创建。'}{' '}
+            <a className="linkbtn" href="#/settings" onClick={onClose}>
+              在设置中修改目录
+            </a>
+          </p>
+          {dir.resetFrom ? (
+            <p className="notice">原先保存的文件夹位于可能被系统清理的临时目录，已改用默认文件夹。</p>
+          ) : null}
+        </>
+      ) : null}
+      {error ? <ErrorNotice error={error} onRetry={() => void scan()} /> : null}
+      {summary ? (
+        <p className="importdialog__summary" role="status">
+          {summary}
+        </p>
+      ) : null}
+      {result && result.files.length > 0 ? (
+        <ul className="scandetail">
+          {result.files.map((file) => (
+            <li key={file.filename} className={`scandetail--${file.outcome}`}>
+              <span>{file.filename}</span>
+              {file.outcome === 'failed' && file.detail ? (
+                // 失败原因一句话在主行，技术原文收在「查看详情」里，可展开、可复制。
+                <ErrorNotice error={{ code: 'IMPORT_FAILED', message: file.reason ?? OUTCOME_TEXT.failed, detail: file.detail }} />
+              ) : (
+                <span>{file.outcome === 'imported' ? OUTCOME_TEXT.imported : file.reason ?? OUTCOME_TEXT[file.outcome]}</span>
+              )}
+            </li>
+          ))}
+        </ul>
+      ) : null}
+    </Modal>
+  );
+}
diff --git a/src/ui/components/PendingPullList.tsx b/src/ui/components/PendingPullList.tsx
deleted file mode 100644
index cbe5876..0000000
--- a/src/ui/components/PendingPullList.tsx
+++ /dev/null
@@ -1,49 +0,0 @@
-// ABOUTME: 待拉取录音列表，管理单条与批量 BLE 拉取。
-
-import { HardDriveDownload } from 'lucide-react';
-import type { RecordingSummary } from '../../contracts/app';
-import { formatBytes, formatDuration } from '../format';
-import { Button, Card } from './ui';
-
-interface Props {
-  items: RecordingSummary[];
-  busy: boolean;
-  note: string;
-  onPull: (filename: string) => void;
-  onPullAll: () => void;
-}
-
-export function PendingPullList({ items, busy, note, onPull, onPullAll }: Props) {
-  return (
-    <Card
-      title={`待拉取的录音${items.length > 0 ? `（${items.length}）` : ''}`}
-      action={
-        items.length > 0 ? (
-          <Button size="sm" icon={<HardDriveDownload size={14} aria-hidden="true" />} disabled={busy} onClick={onPullAll}>
-            全部拉取
-          </Button>
-        ) : null
-      }
-    >
-      {items.length === 0 ? (
-        <p className="muted">没有待拉取的录音。先用上方「读取清单」把设备里的录音登记进来。</p>
-      ) : (
-        <ul className="pulllist">
-          {items.map((item) => (
-            <li key={item.id}>
-              <span className="pulllist__name">{item.filename}</span>
-              <span className="pulllist__meta">
-                {formatDuration(item.durationSec)} · {formatBytes(item.sizeBytes)}
-              </span>
-              <Button size="sm" disabled={busy} onClick={() => onPull(item.filename)}>
-                拉取
-              </Button>
-            </li>
-          ))}
-        </ul>
-      )}
-      {note ? <p className="muted">{note}</p> : null}
-      <p className="muted">BLE 单文件串行传输，大文件较慢；拉取完成后到录音库批量转录即可。</p>
-    </Card>
-  );
-}
diff --git a/src/ui/components/SdkCommandTable.tsx b/src/ui/components/SdkCommandTable.tsx
index 335c94c..fa0cc2c 100644
--- a/src/ui/components/SdkCommandTable.tsx
+++ b/src/ui/components/SdkCommandTable.tsx
@@ -1,12 +1,13 @@
-// ABOUTME: SDK 指令库表格，只读展示 memotalk-sdk 的协议指令。
+// ABOUTME: 设备协议指令参考表（开发者），只读展示设备 SDK（memotalk-sdk）的协议指令；只在诊断区出现。
 
 import { Activity } from 'lucide-react';
 import type { SdkCommand } from '../../contracts/app';
-import { Card, Empty } from './ui';
+import { Empty } from './ui';
 
 export function SdkCommandTable({ commands }: { commands: SdkCommand[] }) {
   return (
-    <Card title="SDK 指令库" action={<span className="muted">{commands.length} 条 · 来自 memotalk-sdk</span>}>
+    <div className="cmdtable-wrap">
+      <p className="muted">{commands.length} 条 · 来自设备 SDK（memotalk-sdk）</p>
       {commands.length === 0 ? (
         <Empty title="没有指令数据" />
       ) : (
@@ -37,8 +38,8 @@ export function SdkCommandTable({ commands }: { commands: SdkCommand[] }) {
         </div>
       )}
       <p className="muted cmdtable__foot">
-        <Activity size={13} aria-hidden="true" /> 指令定义来自 SDK 协议文档；本应用只自动执行「读取清单」与「下载文件」两条安全流程。
+        <Activity size={13} aria-hidden="true" /> 本应用只自动执行连接、读取状态与清单、校时、下载，以及删除已同步且校验一致的录音。
       </p>
-    </Card>
+    </div>
   );
 }
diff --git a/src/ui/components/recording-parts.tsx b/src/ui/components/recording-parts.tsx
index c5b4d9b..42aba99 100644
--- a/src/ui/components/recording-parts.tsx
+++ b/src/ui/components/recording-parts.tsx
@@ -1,4 +1,4 @@
-// ABOUTME: 详情页的展示型片段：转录分段、AI 结论、执行记录与元数据。
+// ABOUTME: 详情页的展示型片段：转录分段、AI 结论、处理记录与元数据。
 
 import type { AnalysisRecord, JobRun, RecordingSummary, TranscriptSegment } from '../../contracts/app';
 import { formatDateTime, formatMs } from '../format';
@@ -101,7 +101,7 @@ export function AnalysisView({ analysis }: { analysis: AnalysisRecord }) {
 }
 
 const JOB_STATUS: Record<string, string> = {
-  running: '执行中',
+  running: '进行中',
   success: '成功',
   failure: '失败',
   interrupted: '中断',
@@ -124,8 +124,8 @@ export function JobsTable({ jobs }: { jobs: JobRun[] }) {
 
 const SOURCE_LABEL: Record<string, string> = {
   folder_import: '目录导入',
-  device_manifest: '设备清单',
-  device_pull: '设备拉取',
+  device_manifest: '录音笔（未同步）',
+  device_pull: '录音笔同步',
   manual: '手动登记',
   live_caption: '实时字幕',
 };
@@ -138,8 +138,8 @@ export function MetaList({ recording, storagePath }: { recording: RecordingSumma
         <dd>{SOURCE_LABEL[recording.source] ?? recording.source}</dd>
       </div>
       <div>
-        <dt>设备</dt>
-        <dd>{recording.deviceSerial ?? '未关联设备'}</dd>
+        <dt>录音笔</dt>
+        <dd>{recording.deviceSerial ?? '—'}</dd>
       </div>
       <div>
         <dt>入库时间</dt>
diff --git a/src/ui/components/ui.tsx b/src/ui/components/ui.tsx
index f0e84f3..4609a98 100644
--- a/src/ui/components/ui.tsx
+++ b/src/ui/components/ui.tsx
@@ -1,8 +1,11 @@
 // ABOUTME: 通用界面原子组件与轻量提示系统。
 
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
-import { CircleAlert, CircleCheck, Info, Loader2, RefreshCw, X } from 'lucide-react';
+import { CircleAlert, CircleCheck, Info, Loader2, X } from 'lucide-react';
 import type { RecordingStatus } from '../../contracts/app';
+import type { AppErrorView } from '../../contracts/errors';
+import { toErrorView } from '../api';
+import { ErrorNotice } from './ErrorNotice';
 
 // ------------------------------------------------------------------ 提示
 
@@ -11,26 +14,45 @@ interface ToastItem {
   id: number;
   message: string;
   tone: ToastTone;
+  error?: AppErrorView;
 }
 
 interface ToastApi {
   push: (message: string, tone?: ToastTone) => void;
+  /** 只显示中文结论；有技术详情时附「详情」按钮，且不会自动消失。 */
+  error: (error: unknown) => void;
 }
 
-const ToastContext = createContext<ToastApi>({ push: () => undefined });
+const ToastContext = createContext<ToastApi>({ push: () => undefined, error: () => undefined });
 
 export function ToastProvider({ children }: { children: ReactNode }) {
   const [items, setItems] = useState<ToastItem[]>([]);
+  const [opened, setOpened] = useState<AppErrorView | null>(null);
   const counter = useRef(0);
 
-  const push = useCallback((message: string, tone: ToastTone = 'info') => {
+  const dismiss = useCallback((id: number) => setItems((current) => current.filter((item) => item.id !== id)), []);
+
+  // 详情弹窗挂在整个外壳上：换页后必须关掉，否则跳转看起来像没反应。
+  useEffect(() => {
+    const close = () => setOpened(null);
+    window.addEventListener('hashchange', close);
+    return () => window.removeEventListener('hashchange', close);
+  }, []);
+
+  const add = useCallback((item: Omit<ToastItem, 'id'>, sticky: boolean) => {
     counter.current += 1;
     const id = counter.current;
-    setItems((current) => [...current, { id, message, tone }]);
-    window.setTimeout(() => setItems((current) => current.filter((item) => item.id !== id)), 5200);
-  }, []);
+    setItems((current) => [...current, { ...item, id }]);
+    if (!sticky) window.setTimeout(() => dismiss(id), 5200);
+  }, [dismiss]);
 
-  const value = useMemo<ToastApi>(() => ({ push }), [push]);
+  const push = useCallback((message: string, tone: ToastTone = 'info') => add({ message, tone }, false), [add]);
+  const error = useCallback((cause: unknown) => {
+    const view = toErrorView(cause);
+    add({ message: view.message, tone: 'error', error: view }, Boolean(view.detail));
+  }, [add]);
+
+  const value = useMemo<ToastApi>(() => ({ push, error }), [push, error]);
 
   return (
     <ToastContext.Provider value={value}>
@@ -42,9 +64,29 @@ export function ToastProvider({ children }: { children: ReactNode }) {
             {item.tone === 'error' ? <CircleAlert size={16} aria-hidden="true" /> : null}
             {item.tone === 'info' ? <Info size={16} aria-hidden="true" /> : null}
             <span>{item.message}</span>
+            {item.error?.detail ? (
+              <button type="button" className="toast__link" onClick={() => setOpened(item.error ?? null)}>
+                详情
+              </button>
+            ) : null}
+            {item.error?.detail ? (
+              <button type="button" className="toast__close" aria-label="关闭提示" onClick={() => dismiss(item.id)}>
+                <X size={13} aria-hidden="true" />
+              </button>
+            ) : null}
           </div>
         ))}
       </div>
+      {opened ? (
+        <Modal title="出错详情" onClose={() => setOpened(null)}>
+          {/* 链接指向当前页时不会触发 hashchange，点击时也要关闭弹窗。 */}
+          <div onClickCapture={(event) => {
+            if ((event.target as HTMLElement).closest('a[href^="#"]')) setOpened(null);
+          }}>
+            <ErrorNotice error={opened} defaultOpen />
+          </div>
+        </Modal>
+      ) : null}
     </ToastContext.Provider>
   );
 }
@@ -120,14 +162,14 @@ export function IconButton({ label, onClick, active, disabled, children }: IconB
 // ------------------------------------------------------------------ 状态
 
 const STATUS_META: Record<RecordingStatus, { label: string; tone: string }> = {
-  pending: { label: '待拉取', tone: 'neutral' },
+  pending: { label: '在录音笔中', tone: 'neutral' },
   ready: { label: '待转录', tone: 'info' },
   queued_transcribe: { label: '转录已排队', tone: 'busy' },
   queued_organize: { label: '归类已排队', tone: 'busy' },
   transcribing: { label: '转录中', tone: 'busy' },
   transcribed: { label: '待归类', tone: 'info' },
   analyzing: { label: '归类中', tone: 'busy' },
-  organized: { label: '已归档', tone: 'success' },
+  organized: { label: '已整理', tone: 'success' },
   failed: { label: '失败', tone: 'danger' },
 };
 
@@ -195,17 +237,10 @@ export function Empty({ title, description, action }: { title: string; descripti
   );
 }
 
-export function ErrorState({ message, onRetry }: { message: string; onRetry?: () => void }) {
+export function ErrorState({ error, onRetry }: { error: AppErrorView; onRetry?: () => void }) {
   return (
-    <div className="empty empty--error">
-      <CircleAlert size={22} aria-hidden="true" />
-      <p className="empty__title">加载失败</p>
-      <p className="empty__desc">{message}</p>
-      {onRetry ? (
-        <Button size="sm" icon={<RefreshCw size={14} aria-hidden="true" />} onClick={onRetry}>
-          重试
-        </Button>
-      ) : null}
+    <div className="errorstate">
+      <ErrorNotice error={error} onRetry={onRetry} />
     </div>
   );
 }
diff --git a/src/ui/format.ts b/src/ui/format.ts
index 6241218..ca18d85 100644
--- a/src/ui/format.ts
+++ b/src/ui/format.ts
@@ -65,3 +65,18 @@ export function relativeTime(iso: string | null | undefined): string {
   if (days <= 7) return `${days} 天前`;
   return formatDateTime(iso);
 }
+
+export function formatTime(iso: string | null | undefined): string {
+  if (!iso) return '—';
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return '—';
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+/** 录音时间 → 本地日期 YYYY-MM-DD，用于跳到日历对应的那一天。 */
+export function localDayOf(iso: string | null | undefined): string | null {
+  if (!iso) return null;
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return null;
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
diff --git a/src/ui/pages/Calendar.tsx b/src/ui/pages/Calendar.tsx
index c5f2752..dd2ff3b 100644
--- a/src/ui/pages/Calendar.tsx
+++ b/src/ui/pages/Calendar.tsx
@@ -1,12 +1,16 @@
-import { useRef, useState } from 'react';
+// ABOUTME: 日历页：按日查看事件与录音、录音与日程的唯一关联入口（EventLinker）、新建事件、导入日历与生成纪要。
+
+import { useEffect, useRef, useState } from 'react';
 import { CalendarDays, ChevronLeft, ChevronRight, Copy, Download, FileAudio, Plus, RefreshCw, Sparkles, Upload } from 'lucide-react';
 import type { CalendarEvent, CalendarRecording } from '../../contracts/calendar';
-import type { RecordingDetail } from '../../contracts/app';
-import { api, errorText } from '../api';
+import type { AppErrorView } from '../../contracts/errors';
+import { api, ApiError, toErrorView } from '../api';
 import { useAsyncData } from '../useApi';
 import { Button, Empty, ErrorState, Field, IconButton, Loading, Modal, useToast } from '../components/ui';
 import { formatDuration } from '../format';
-import { CalendarAssociation } from '../components/CalendarAssociation';
+import { buildHash } from '../router';
+import { ErrorNotice } from '../components/ErrorNotice';
+import { EventLinker } from '../components/EventLinker';
 
 export function localDay(date: Date): string {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
@@ -45,7 +49,7 @@ export function DigestDocument({ title, text }: { title: string; text: string })
       <h2>{title}</h2>
       <div className="page__actions">
         <IconButton label="复制 Markdown" onClick={() => void navigator.clipboard.writeText(text).then(
-          () => toast.push('已复制纪要', 'success'), (error: unknown) => toast.push(errorText(error), 'error'),
+          () => toast.push('已复制纪要', 'success'), (error: unknown) => toast.error(error),
         )}><Copy size={16} /></IconButton>
         <IconButton label="导出 Markdown" onClick={() => {
           const url = URL.createObjectURL(new Blob([text], { type: 'text/markdown;charset=utf-8' }));
@@ -61,33 +65,18 @@ export function DigestDocument({ title, text }: { title: string; text: string })
   </section>;
 }
 
-export function CalendarRecordingDetail({ id }: { id: number }) {
-  const detail = useAsyncData(() => api.get<RecordingDetail>(`/api/recordings/${id}`), `calendar-detail:${id}`);
-  if (detail.error) return <ErrorState message={detail.error} onRetry={detail.reload} />;
-  if (detail.loading || !detail.data) return <Loading />;
-  const data = detail.data;
-  return <section className="calendar-transcript">
-    <div className="calendar-panel-head"><h2>{data.recording.title || data.recording.filename}</h2></div>
-    <a href={`#/rec/${id}`}>打开录音详情</a>
-    <h3>摘要</h3><p>{data.recording.summary || '尚无摘要'}</p>
-    {data.analysis ? <><h3>关键点</h3><ul>{data.analysis.keyPoints.map((point, i) => <li key={i}>{point}</li>)}</ul>
-      <h3>待办事项</h3><ul>{data.analysis.actionItems.map((point, i) => <li key={i}>{point}</li>)}</ul></> : null}
-    <h3>转录全文</h3><p className="calendar-markdown">{data.transcript?.text || '尚无转录文本'}</p>
-  </section>;
-}
-
 function CreateEvent({ day, onClose, onCreated }: { day: string; onClose: () => void; onCreated: (event: CalendarEvent) => void }) {
   const [summary, setSummary] = useState('');
   const [start, setStart] = useState(`${day}T09:00`);
   const [end, setEnd] = useState(`${day}T10:00`);
   const [location, setLocation] = useState('');
   const [attendees, setAttendees] = useState('');
-  const [error, setError] = useState('');
+  const [error, setError] = useState<AppErrorView | null>(null);
   const [busy, setBusy] = useState(false);
   return <Modal title="新建日历事件" onClose={onClose}>
     <form className="calendar-form" onSubmit={(event) => {
       event.preventDefault();
-      setBusy(true); setError('');
+      setBusy(true); setError(null);
       void (async () => {
         try {
           const created = await api.post<CalendarEvent>('/api/calendar/events', {
@@ -95,7 +84,7 @@ function CreateEvent({ day, onClose, onCreated }: { day: string; onClose: () =>
             location, attendees: attendees.split(/[,，]/).map((item) => item.trim()).filter(Boolean),
           });
           onCreated(created);
-        } catch (cause) { setError(errorText(cause)); } finally { setBusy(false); }
+        } catch (cause) { setError(toErrorView(cause)); } finally { setBusy(false); }
       })();
     }}>
       <Field label="事件标题"><input required maxLength={300} value={summary} onChange={(e) => setSummary(e.target.value)} /></Field>
@@ -103,23 +92,30 @@ function CreateEvent({ day, onClose, onCreated }: { day: string; onClose: () =>
       <Field label="结束时间"><input required type="datetime-local" value={end} onChange={(e) => setEnd(e.target.value)} /></Field>
       <Field label="地点"><input maxLength={1000} value={location} onChange={(e) => setLocation(e.target.value)} /></Field>
       <Field label="参会人"><input placeholder="姓名，以逗号分隔" value={attendees} onChange={(e) => setAttendees(e.target.value)} /></Field>
-      {error ? <p className="alert" role="alert">{error}</p> : null}
+      {error ? <ErrorNotice error={error} /> : null}
       <Button type="submit" variant="primary" disabled={busy} icon={<Plus size={15} />}>{busy ? '正在创建' : '创建事件'}</Button>
     </form>
   </Modal>;
 }
 
 type Selection = { kind: 'day'; day: string } | { kind: 'event'; day: string; id: number };
-type Panel = { kind: 'empty' } | { kind: 'recording'; id: number } | { kind: 'digest'; title: string; text: string };
+type Panel = { kind: 'empty' } | { kind: 'digest'; title: string; text: string };
 
-export function CalendarPage() {
+/** 截止日不早于目标日、且目标日落在 7 天窗口内。 */
+function windowEndFor(day: string, today: string): string {
+  return day > shiftDay(today, -7) && day <= today ? today : day;
+}
+
+export function CalendarPage({ day: focusDay, rec: focusRec }: { day?: string; rec?: number }) {
   const today = localDay(new Date());
-  const [endingDay, setEndingDay] = useState(today);
-  const [selection, setSelection] = useState<Selection>({ kind: 'day', day: today });
+  const initialDay = focusDay ?? today;
+  const [endingDay, setEndingDay] = useState(windowEndFor(initialDay, today));
+  const [selection, setSelection] = useState<Selection>({ kind: 'day', day: initialDay });
   const [panel, setPanel] = useState<Panel>({ kind: 'empty' });
-  const [creating, setCreating] = useState(false);
+  const [creating, setCreating] = useState<{ linkTo: ((eventId: number) => Promise<void>) | null } | null>(null);
+  const [expanded, setExpanded] = useState<number | null>(focusRec ?? null);
   const [busy, setBusy] = useState(false);
-  const [generationError, setGenerationError] = useState('');
+  const [generationError, setGenerationError] = useState<AppErrorView | null>(null);
   const fileInput = useRef<HTMLInputElement>(null);
   const toast = useToast();
   const firstDay = shiftDay(endingDay, -6);
@@ -131,8 +127,26 @@ export function CalendarPage() {
     ? `/api/calendar/events/${selection.id}/recordings`
     : `/api/calendar/recordings?${queryRange(selection.day)}`), `calendar-recordings:${JSON.stringify(selection)}`);
   const refresh = () => { events.reload(); recordings.reload(); };
+
+  // 从详情页带着 ?day=&rec= 进来：定位到那一天并展开那条录音的关联控件。
+  useEffect(() => {
+    if (!focusDay && !focusRec) return;
+    const day = focusDay ?? today;
+    setEndingDay(windowEndFor(day, today));
+    setSelection({ kind: 'day', day });
+    setPanel({ kind: 'empty' });
+    setExpanded(focusRec ?? null);
+  }, [focusDay, focusRec, today]);
+
+  useEffect(() => {
+    if (!focusRec || !recordings.data) return;
+    document.querySelector(`[data-recording-id="${focusRec}"]`)?.scrollIntoView({ block: 'center' });
+  }, [focusRec, recordings.data]);
+
   const choose = (next: Selection, event?: CalendarEvent) => {
-    setSelection(next); setGenerationError('');
+    setSelection(next); setGenerationError(null);
+    // 选中的日期写进哈希：从详情页返回时回到同一天。
+    window.history.replaceState(null, '', buildHash({ name: 'calendar', day: next.day }));
     setPanel(event?.digest ? { kind: 'digest', title: `${event.summary}纪要`, text: event.digest } : { kind: 'empty' });
   };
   const moveWeek = (offset: number) => {
@@ -140,18 +154,38 @@ export function CalendarPage() {
     setEndingDay(day); choose({ kind: 'day', day });
   };
   const generate = async (daily: boolean) => {
-    setBusy(true); setGenerationError(''); setPanel({ kind: 'empty' });
+    setBusy(true); setGenerationError(null); setPanel({ kind: 'empty' });
     try {
       const result = await api.post<{ digest: string }>(daily
         ? '/api/calendar/digest' : `/api/calendar/events/${selectedEvent?.id}/digest`,
       daily ? { ...dayRange(selection.day), day: selection.day } : {});
       setPanel({ kind: 'digest', title: daily ? `${selection.day} 日报` : `${selectedEvent?.summary}纪要`, text: result.digest });
       events.reload();
-    } catch (cause) { setGenerationError(errorText(cause)); } finally { setBusy(false); }
+    } catch (cause) { setGenerationError(toErrorView(cause)); } finally { setBusy(false); }
+  };
+  const importFile = (file: File) => {
+    if (file.size > 2 * 1024 * 1024) { toast.push('日历文件不能超过 2 MB', 'info'); return; }
+    setBusy(true);
+    void file.text().then((content) => {
+      const body = { filename: file.name, content };
+      if (new TextEncoder().encode(JSON.stringify(body)).length > 2000000) {
+        throw new ApiError('日历内容超出上传限制，请拆分后导入', 'INVALID_INPUT');
+      }
+      return api.post<{ imported: number; events: CalendarEvent[] }>('/api/calendar/import', body);
+    })
+      .then((result) => {
+        toast.push(`已导入 ${result.imported} 个日历事件`, 'success');
+        const first = result.events[0];
+        if (first) {
+          const day = first.allDay ? first.startTime.slice(0, 10) : localDay(new Date(first.startTime));
+          setEndingDay(day); choose({ kind: 'event', id: first.id, day }, first);
+        }
+        refresh();
+      }).catch((cause: unknown) => toast.error(cause)).finally(() => setBusy(false));
   };
   return <div className="page calendar-page">
     <header className="page__head">
-      <div><h1><CalendarDays size={22} /> 日历视图</h1><p className="page__sub">{firstDay} 至 {endingDay}</p></div>
+      <div><h1><CalendarDays size={22} aria-hidden="true" /> 日历</h1><p className="page__sub">{firstDay} 至 {endingDay}</p></div>
       <div className="page__actions">
         <IconButton label="上一周" disabled={busy} onClick={() => moveWeek(-7)}><ChevronLeft size={17} /></IconButton>
         <input aria-label="日历截止日期" type="date" value={endingDay} disabled={busy} onChange={(e) => {
@@ -160,33 +194,15 @@ export function CalendarPage() {
         <IconButton label="下一周" disabled={busy} onClick={() => moveWeek(7)}><ChevronRight size={17} /></IconButton>
         <IconButton label="刷新日历" onClick={refresh}><RefreshCw size={16} /></IconButton>
         <Button icon={<Upload size={15} />} disabled={busy} onClick={() => fileInput.current?.click()}>导入日历</Button>
-        <Button icon={<Plus size={15} />} disabled={busy} onClick={() => setCreating(true)}>新建事件</Button>
+        <Button icon={<Plus size={15} />} disabled={busy} onClick={() => setCreating({ linkTo: null })}>新建事件</Button>
         <input ref={fileInput} type="file" accept=".ics,text/calendar" hidden aria-label="日历文件" onChange={(e) => {
           const file = e.target.files?.[0];
           e.target.value = '';
-          if (!file) return;
-          if (file.size > 2 * 1024 * 1024) { toast.push('日历文件不能超过 2 MB', 'error'); return; }
-          setBusy(true);
-          void file.text().then((content) => {
-            const body = { filename: file.name, content };
-            if (new TextEncoder().encode(JSON.stringify(body)).length > 2000000) {
-              throw new Error('日历内容超出上传限制，请拆分后导入');
-            }
-            return api.post<{ imported: number; events: CalendarEvent[] }>('/api/calendar/import', body);
-          })
-            .then((result) => {
-              toast.push(`已导入 ${result.imported} 个日历事件`, 'success');
-              const first = result.events[0];
-              if (first) {
-                const day = first.allDay ? first.startTime.slice(0, 10) : localDay(new Date(first.startTime));
-                setEndingDay(day); choose({ kind: 'event', id: first.id, day }, first);
-              }
-              refresh();
-            }).catch((cause: unknown) => toast.push(errorText(cause), 'error')).finally(() => setBusy(false));
+          if (file) importFile(file);
         }} />
       </div>
     </header>
-    {events.error ? <ErrorState message={events.error} onRetry={events.reload} /> : null}
+    {events.error ? <ErrorState error={events.error} onRetry={events.reload} /> : null}
     <div className="calendar-layout">
       <aside className="calendar-timeline" aria-label="日历时间轴">
         {events.loading && !events.data ? <Loading /> : days.map((day) => {
@@ -194,14 +210,14 @@ export function CalendarPage() {
           return <details key={day} open={day === selection.day || undefined}>
             <summary><span>{day === today ? '今天' : day.slice(5)} <span className="muted">{new Date(`${day}T12:00:00`).toLocaleDateString('zh-CN', { weekday: 'short' })}</span></span><span>{dayEvents.length}</span></summary>
             <button className={`calendar-event${selection.kind === 'day' && selection.day === day ? ' is-selected' : ''}`} disabled={busy} onClick={() => choose({ kind: 'day', day })}>
-              <strong>当日录音 / 未关联事件</strong>
+              <strong>当天全部录音</strong>
             </button>
             {dayEvents.map((event) => <button key={event.id} disabled={busy}
               className={`calendar-event${selectedEvent?.id === event.id ? ' is-selected' : ''}`}
               onClick={() => choose({ kind: 'event', day, id: event.id }, event)}>
               <span className="calendar-event-time">{eventTime(event)}</span>
               <strong>{event.summary}</strong>
-              <span className="calendar-event-meta"><span>{event.recordingCount} 段录音</span><span className={event.digest ? 'calendar-done' : 'muted'}>{event.digest ? '已整理' : '未整理'}</span></span>
+              <span className="calendar-event-meta"><span>{event.recordingCount} 段录音</span><span className={event.digest ? 'calendar-done' : 'muted'}>{event.digest ? '已有纪要' : '未生成纪要'}</span></span>
             </button>)}
           </details>;
         })}
@@ -220,44 +236,37 @@ export function CalendarPage() {
           {busy ? '正在处理' : selection.day === today ? '生成今日总结' : '生成当日总结'}
         </Button>}
         <h3 className="calendar-list-title">录音 <span className="muted">{recordings.loading ? '' : recordings.data?.length ?? 0}</span></h3>
-        {recordings.loading ? <Loading /> : recordings.error ? <ErrorState message={recordings.error} onRetry={recordings.reload} /> : !recordings.data?.length ? <Empty title="暂无录音" /> :
+        {recordings.loading ? <Loading /> : recordings.error ? <ErrorState error={recordings.error} onRetry={recordings.reload} /> : !recordings.data?.length ? <Empty title="这一天没有录音" /> :
           recordings.data.map((recording) => <div className="calendar-recording" key={recording.id}>
-            <button className={`calendar-recording-button${panel.kind === 'recording' && panel.id === recording.id ? ' is-selected' : ''}`}
-              onClick={() => { setPanel({ kind: 'recording', id: recording.id }); setGenerationError(''); }}>
-              <FileAudio size={16} /><span><strong>{recording.title}</strong>
-                <small>{recording.recordedAt ? new Date(recording.recordedAt).toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' }) : '录音时间未知'} · {formatDuration(recording.durationSec)}</small>
-                <small>{recording.calendarEventId ? '已关联事件' : '未关联事件'}</small></span>
-            </button>
-            <RecordingLinkSlot recording={recording} events={events.data ?? []} onChanged={() => { setPanel({ kind: 'empty' }); refresh(); }} />
-            {!recording.calendarEventId ? <CalendarAssociation id={recording.id} eventId={null} onChanged={() => { setPanel({ kind: 'empty' }); refresh(); }} /> : null}
+            <a className="calendar-recording-button" href={`#/rec/${recording.id}`}>
+              <FileAudio size={16} aria-hidden="true" /><span><strong>{recording.title}</strong>
+                <small>{recording.recordedAt ? new Date(recording.recordedAt).toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' }) : '录音时间未知'} · {formatDuration(recording.durationSec)}</small></span>
+            </a>
+            <EventLinker
+              recording={recording}
+              events={events.data ?? []}
+              expanded={expanded === recording.id}
+              highlighted={focusRec === recording.id}
+              onToggle={() => setExpanded((current) => (current === recording.id ? null : recording.id))}
+              onCreateEvent={(linkTo) => setCreating({ linkTo })}
+              onChanged={refresh}
+            />
           </div>)}
       </section>
-      <aside className="calendar-results" aria-label="转录与纪要">
-        {busy ? <Loading label="正在处理，请稍候" /> : generationError ? <div className="alert" role="alert"><h2>纪要未生成</h2><p>{generationError}</p></div> :
-          panel.kind === 'recording' ? <CalendarRecordingDetail key={panel.id} id={panel.id} /> :
+      <aside className="calendar-results" aria-label="纪要">
+        {busy ? <Loading label="正在处理，请稍候" /> : generationError ? <div className="calendar-results__error"><h2>纪要没有生成</h2><ErrorNotice error={generationError} /></div> :
           panel.kind === 'digest' ? <DigestDocument title={panel.title} text={panel.text} /> :
-          <Empty title="转录与纪要" />}
+          <Empty title="纪要" description="选中一个日程或一天，点「生成事件纪要」或「生成当日总结」后在这里查看。" />}
       </aside>
     </div>
-    {creating ? <CreateEvent day={selection.day} onClose={() => setCreating(false)} onCreated={(event) => {
-      setCreating(false); refresh(); const day = localDay(new Date(event.startTime)); setEndingDay(day); choose({ kind: 'event', id: event.id, day }, event);
+    {creating ? <CreateEvent day={selection.day} onClose={() => setCreating(null)} onCreated={(event) => {
+      const linkTo = creating.linkTo;
+      setCreating(null);
+      if (linkTo) {
+        void linkTo(event.id);
+        return;
+      }
+      refresh(); const day = localDay(new Date(event.startTime)); setEndingDay(day); choose({ kind: 'event', id: event.id, day }, event);
     }} /> : null}
   </div>;
 }
-
-function RecordingLinkSlot({ recording, events, onChanged }: { recording: CalendarRecording; events: CalendarEvent[]; onChanged: () => void }) {
-  const toast = useToast();
-  const [busy, setBusy] = useState(false);
-  return <label className="calendar-link"><span>关联事件</span><select aria-label={`关联事件：${recording.title}`} disabled={busy} value={recording.calendarEventId ?? ''}
-    onChange={(e) => {
-      setBusy(true);
-      void api.put(`/api/recordings/${recording.id}`, { calendar_event_id: e.target.value ? Number(e.target.value) : null })
-        .then(() => { toast.push('录音关联已更新', 'success'); onChanged(); })
-        .catch((cause: unknown) => toast.push(errorText(cause), 'error')).finally(() => setBusy(false));
-    }}>
-    <option value="">未关联事件</option>
-    {recording.calendarEventId && !events.some((event) => event.id === recording.calendarEventId)
-      ? <option value={recording.calendarEventId}>已关联事件 #{recording.calendarEventId}</option> : null}
-    {events.map((event) => <option key={event.id} value={event.id}>{event.summary} · {event.startTime.slice(0, 10)}</option>)}
-  </select></label>;
-}
diff --git a/src/ui/pages/Categories.tsx b/src/ui/pages/Categories.tsx
index 613ffad..a90bcce 100644
--- a/src/ui/pages/Categories.tsx
+++ b/src/ui/pages/Categories.tsx
@@ -1,15 +1,16 @@
-// ABOUTME: 分类管理：新增、改名、改色、删除自定义分类。
+// ABOUTME: 分类页：分类增删改，以及每个分类的录音条数与总时长。
 
 import { useState } from 'react';
 import { Plus, Trash2 } from 'lucide-react';
-import type { Category } from '../../contracts/app';
-import { api, errorText } from '../api';
+import type { Category, Overview } from '../../contracts/app';
+import { api } from '../api';
+import { formatDuration } from '../format';
 import { useAsyncData } from '../useApi';
 import { Button, Card, Empty, ErrorState, Field, Loading, useToast } from '../components/ui';
 
 const PALETTE = ['#2563eb', '#7c3aed', '#d97706', '#dc2626', '#0891b2', '#be185d', '#059669', '#475569'];
 
-export function CategoriesPage() {
+export function CategoriesPage({ overview, onChanged }: { overview: Overview | null; onChanged: () => void }) {
   const toast = useToast();
   const state = useAsyncData<Category[]>(() => api.get<Category[]>('/api/categories'), 'categories');
   const [name, setName] = useState('');
@@ -19,6 +20,7 @@ export function CategoriesPage() {
 
   const categories = state.data ?? [];
   const total = categories.reduce((sum, item) => sum + item.recordingCount, 0);
+  const durations = new Map((overview?.byCategory ?? []).map((item) => [item.id, item.durationSec]));
 
   const add = async () => {
     if (!name.trim()) return;
@@ -30,7 +32,7 @@ export function CategoriesPage() {
       toast.push('分类已创建', 'success');
       state.reload();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     } finally {
       setBusy(false);
     }
@@ -43,7 +45,7 @@ export function CategoriesPage() {
       toast.push('分类已更新', 'success');
       state.reload();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     }
   };
 
@@ -52,7 +54,7 @@ export function CategoriesPage() {
       await api.patch(`/api/categories/${category.id}`, { color: nextColor });
       state.reload();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     }
   };
 
@@ -62,19 +64,20 @@ export function CategoriesPage() {
       await api.remove(`/api/categories/${category.id}`);
       toast.push('分类已删除', 'success');
       state.reload();
+      onChanged();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     }
   };
 
   if (state.loading && !state.data) return <Loading label="正在读取分类" />;
-  if (state.error) return <ErrorState message={state.error} onRetry={state.reload} />;
+  if (state.error) return <ErrorState error={state.error} onRetry={state.reload} />;
 
   return (
     <div className="page page--categories">
       <header className="page__head">
         <div>
-          <h1>分类体系</h1>
+          <h1>分类</h1>
           <p className="page__sub">
             共 {categories.length} 个分类，覆盖 {total} 条录音。AI 归类时会从这些分类中选择最贴切的一个。
           </p>
@@ -132,7 +135,10 @@ export function CategoriesPage() {
                     aria-label={`${category.name} 的名称`}
                   />
                   <span className="catlist__desc">{category.description ?? '—'}</span>
-                  <span className="catlist__count">{category.recordingCount} 条</span>
+                  <span className="catlist__count">
+                    {category.recordingCount} 条
+                    {durations.get(category.id) ? <span className="muted"> · {formatDuration(durations.get(category.id))}</span> : null}
+                  </span>
                   {category.isSystem ? (
                     <span className="muted catlist__lock">内置</span>
                   ) : (
diff --git a/src/ui/pages/Detail.tsx b/src/ui/pages/Detail.tsx
index 16c2edc..0a8556c 100644
--- a/src/ui/pages/Detail.tsx
+++ b/src/ui/pages/Detail.tsx
@@ -1,11 +1,13 @@
-// ABOUTME: 录音详情页：编排元数据、试听、转录、AI 结论与手工整理操作。
+// ABOUTME: 录音详情页：试听、转录、AI 结论与手工整理；页头只有一个随状态切换的主按钮。
 
-import { useEffect, useRef, useState } from 'react';
-import { Archive, ArrowLeft, Check, Download, FileAudio, HardDriveDownload, Pencil, Sparkles, Star, Trash2, Waves } from 'lucide-react';
-import type { Category, RecordingDetail } from '../../contracts/app';
+import { useEffect, useRef, useState, type ReactNode } from 'react';
+import { Archive, ArrowLeft, CalendarDays, Check, ChevronDown, Download, FileAudio, Pencil, RotateCcw, Sparkles, Star, Trash2, Waves } from 'lucide-react';
+import type { Category, RecordingDetail, RecordingSummary } from '../../contracts/app';
+import type { CalendarEvent } from '../../contracts/calendar';
 import { isBusyStatus } from '../../contracts/recording-status';
-import { api, errorText } from '../api';
-import { formatBytes, formatDateTime, formatDuration } from '../format';
+import { api } from '../api';
+import { formatBytes, formatDateTime, formatDuration, localDayOf } from '../format';
+import { buildHash } from '../router';
 import { useAsyncData, usePolling } from '../useApi';
 import {
   Button,
@@ -22,17 +24,55 @@ import {
   useToast,
 } from '../components/ui';
 import { AnalysisView, JobsTable, MetaList, TranscriptSegments } from '../components/recording-parts';
-import { CalendarAssociation } from '../components/CalendarAssociation';
+import { ErrorNotice } from '../components/ErrorNotice';
 
 interface Props {
   id: number;
+  backLabel: string;
   onBack: () => void;
   onRemoved: () => void;
 }
 
 type Tab = 'transcript' | 'analysis' | 'jobs';
 
-export function DetailPage({ id, onBack, onRemoved }: Props) {
+/** 日程区只读：关联只在日历页做，这里只给带上下文的跳转。 */
+function CalendarLink({ recording }: { recording: RecordingSummary }) {
+  const eventId = recording.calendarEventId;
+  const linked = useAsyncData<CalendarEvent | null>(
+    () => (eventId ? api.get<CalendarEvent>(`/api/calendar/events/${eventId}`) : Promise.resolve(null)),
+    `detail-event:${eventId ?? 0}`,
+  );
+  const href = buildHash({
+    name: 'calendar',
+    ...(localDayOf(recording.recordedAt ?? recording.createdAt) ? { day: localDayOf(recording.recordedAt ?? recording.createdAt) ?? undefined } : {}),
+    rec: recording.id,
+  });
+  if (!eventId) {
+    return (
+      <p className="calendarlink">
+        <span className="muted">还没有关联日程。</span>
+        <a className="linkbtn" href={href}>
+          在日历中关联
+        </a>
+      </p>
+    );
+  }
+  const event = linked.data;
+  return (
+    <div className="calendarlink">
+      <p className="calendarlink__event">
+        <CalendarDays size={14} aria-hidden="true" />
+        <strong>{event?.summary ?? '已关联的日程'}</strong>
+      </p>
+      {event ? <p className="muted">{event.allDay ? `${event.startTime.slice(0, 10)} 全天` : formatDateTime(event.startTime)}</p> : null}
+      <a className="linkbtn" href={href}>
+        在日历中修改
+      </a>
+    </div>
+  );
+}
+
+export function DetailPage({ id, backLabel, onBack, onRemoved }: Props) {
   const toast = useToast();
   const [tab, setTab] = useState<Tab>('transcript');
   const [plain, setPlain] = useState(false);
@@ -64,11 +104,13 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
   }, [id]);
 
   if (detail.loading && !data) return <Loading label="正在读取录音详情" />;
-  if (detail.error) return <ErrorState message={detail.error} onRetry={detail.reload} />;
+  if (detail.error) return <ErrorState error={detail.error} onRetry={detail.reload} />;
   if (!data) return <Loading />;
 
   const recording = data.recording;
   const hasTranscript = Boolean(data.transcript?.text);
+  const onDevice = recording.status === 'pending' && !recording.hasAudioFile;
+  const title = recording.title || recording.filename;
 
   const run = async (task: () => Promise<unknown>, successText: string) => {
     setPending(true);
@@ -77,7 +119,7 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
       toast.push(successText, 'success');
       detail.reload();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     } finally {
       setPending(false);
     }
@@ -85,6 +127,20 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
 
   const transcribe = () => void run(() => api.post(`/api/recordings/${id}/transcribe`), '转录任务已排队');
   const organize = () => void run(() => api.post(`/api/recordings/${id}/organize`), '归类任务已排队');
+
+  /** 主动作随状态切换：在录音笔中 → 去同步；待转录 → 开始转录；待归类 → AI 归类；已整理 → 无。 */
+  const primary: { label: string; icon: ReactNode; run: () => void } | null = (() => {
+    if (busy || onDevice || recording.status === 'organized') return null;
+    if (recording.status === 'transcribed' || (recording.status === 'failed' && hasTranscript)) {
+      return { label: 'AI 归类', icon: <Sparkles size={14} aria-hidden="true" />, run: organize };
+    }
+    if (recording.hasAudioFile && !hasTranscript) {
+      return { label: '开始转录', icon: <Waves size={14} aria-hidden="true" />, run: transcribe };
+    }
+    return null;
+  })();
+  const canRetranscribe = recording.hasAudioFile && hasTranscript && !busy;
+  const canReorganize = hasTranscript && Boolean(data.analysis) && !busy;
   const patch = (body: Record<string, unknown>, message: string) =>
     void run(() => api.patch(`/api/recordings/${id}`, body), message);
 
@@ -121,8 +177,13 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
     <div className="page page--detail">
       <div className="detail__topbar">
         <Button variant="quiet" size="sm" icon={<ArrowLeft size={15} aria-hidden="true" />} onClick={onBack}>
-          返回录音库
+          {backLabel}
         </Button>
+        <nav className="breadcrumb" aria-label="当前位置">
+          <a href="#/library">录音</a>
+          <span aria-hidden="true">›</span>
+          <span aria-current="page">{title}</span>
+        </nav>
         <StatusChip status={recording.status} />
       </div>
 
@@ -165,41 +226,19 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
           ) : null}
         </p>
         <div className="detail__actions">
-          <Button
-            variant="primary"
-            size="sm"
-            icon={<Waves size={14} aria-hidden="true" />}
-            disabled={pending || busy || !recording.hasAudioFile}
-            title={recording.hasAudioFile ? '用 Host ASR 识别录音内容' : '缺少音频文件'}
-            onClick={transcribe}
-          >
-            {hasTranscript ? '重新转录' : '开始转录'}
-          </Button>
-          {recording.status === 'pending' && !recording.hasAudioFile ? (
-            <Button
-              variant="primary"
-              size="sm"
-              icon={<HardDriveDownload size={14} aria-hidden="true" />}
-              disabled={pending || busy}
-              onClick={() =>
-                void run(
-                  () => api.post('/api/device/download', { file: recording.filename, serial: recording.deviceSerial ?? '' }),
-                  '已发起拉取，完成后状态会变为待转录',
-                )
-              }
-            >
-              从设备拉取音频
+          {onDevice ? (
+            <p className="detail__ondevice">
+              这条录音还在录音笔里，同步后即可播放和转录。
+              <a className="linkbtn" href="#/device">
+                去录音笔同步
+              </a>
+            </p>
+          ) : null}
+          {primary ? (
+            <Button variant="primary" size="sm" icon={primary.icon} disabled={pending} onClick={primary.run}>
+              {primary.label}
             </Button>
           ) : null}
-          <Button
-            size="sm"
-            icon={<Sparkles size={14} aria-hidden="true" />}
-            disabled={pending || busy || !hasTranscript}
-            title={hasTranscript ? '用 AI 归类并生成摘要' : '需要先完成转录'}
-            onClick={organize}
-          >
-            {data.analysis ? '重新归类' : 'AI 归类'}
-          </Button>
           <Button
             size="sm"
             variant={recording.isFavorite ? 'primary' : 'ghost'}
@@ -221,27 +260,45 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
           >
             导出
           </Button>
-          <Button
-            size="sm"
-            icon={<Archive size={14} aria-hidden="true" />}
-            onClick={() => patch({ isArchived: !recording.isArchived }, recording.isArchived ? '已取消归档' : '已归档')}
-          >
-            {recording.isArchived ? '取消归档' : '归档'}
-          </Button>
-          <Button
-            size="sm"
-            variant="danger"
-            icon={<Trash2 size={14} aria-hidden="true" />}
-            onClick={() => {
-              if (!window.confirm('音频文件会移动到数据目录的 _trash 子目录，确认删除这条记录？')) return;
-              void run(async () => {
-                await api.remove(`/api/recordings/${id}`);
-                onRemoved();
-              }, '录音已删除');
-            }}
-          >
-            删除
-          </Button>
+          <details className="moremenu">
+            <summary className="btn btn--ghost btn--sm">
+              <span>更多</span>
+              <ChevronDown size={13} aria-hidden="true" />
+            </summary>
+            <div className="moremenu__list" role="menu">
+              {canRetranscribe ? (
+                <button type="button" role="menuitem" disabled={pending} onClick={transcribe}>
+                  <RotateCcw size={13} aria-hidden="true" /> 重新转录
+                </button>
+              ) : null}
+              {canReorganize ? (
+                <button type="button" role="menuitem" disabled={pending} onClick={organize}>
+                  <Sparkles size={13} aria-hidden="true" /> 重新归类
+                </button>
+              ) : null}
+              <button
+                type="button"
+                role="menuitem"
+                onClick={() => patch({ isArchived: !recording.isArchived }, recording.isArchived ? '已取消归档' : '已归档')}
+              >
+                <Archive size={13} aria-hidden="true" /> {recording.isArchived ? '取消归档' : '归档'}
+              </button>
+              <button
+                type="button"
+                role="menuitem"
+                className="moremenu__danger"
+                onClick={() => {
+                  if (!window.confirm('音频文件会移到数据目录的回收站，确认删除这条录音？')) return;
+                  void run(async () => {
+                    await api.remove(`/api/recordings/${id}`);
+                    onRemoved();
+                  }, '录音已删除');
+                }}
+              >
+                <Trash2 size={13} aria-hidden="true" /> 删除
+              </button>
+            </div>
+          </details>
         </div>
         {exported ? <p className="detail__export">已复制到：{exported}</p> : null}
       </header>
@@ -260,15 +317,22 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
       ) : null}
 
       {!busy && data.lastError ? (
-        <div className="alert" role="alert">
-          <strong>上次处理未成功：</strong> {data.lastError}
-        </div>
+        <ErrorNotice
+          error={{
+            code: data.lastErrorCode ?? 'INTERNAL_ERROR',
+            message: `上次处理未成功：${data.lastError}`,
+            ...(data.lastErrorDetail ? { detail: data.lastErrorDetail } : {}),
+          }}
+          onRetry={primary?.run}
+        />
       ) : null}
 
       <div className="detail__grid">
         <div className="detail__main">
           <Card tight>
-            {audioBroken ? (
+            {!recording.hasAudioFile ? (
+              <p className="muted">{onDevice ? '同步到电脑后即可播放。' : '这条录音缺少音频文件。'}</p>
+            ) : audioBroken ? (
               <p className="notice">当前环境无法内嵌播放这段音频，请用「导出」交给本机播放器。</p>
             ) : (
               <audio
@@ -298,7 +362,7 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
               options={[
                 { value: 'transcript', label: '转录全文' },
                 { value: 'analysis', label: 'AI 结论' },
-                { value: 'jobs', label: `执行记录${data.jobs.length > 0 ? ` ${data.jobs.length}` : ''}` },
+                { value: 'jobs', label: `处理记录${data.jobs.length > 0 ? ` ${data.jobs.length}` : ''}` },
               ]}
               onChange={(value) => setTab(value as Tab)}
             />
@@ -317,14 +381,12 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
                   title="还没有转录文本"
                   description={
                     recording.hasAudioFile
-                      ? '点击「开始转录」，会用本机 ffmpeg 解码后送入语音识别。'
-                      : '这条录音缺少音频文件，请先在设备页完成拉取或导入。'
-                  }
-                  action={
-                    <Button size="sm" variant="primary" disabled={pending || busy || !recording.hasAudioFile} onClick={transcribe}>
-                      开始转录
-                    </Button>
+                      ? '点页面上方的「开始转录」，识别结果会显示在这里。'
+                      : onDevice
+                        ? '同步到电脑后才能转录。'
+                        : '这条录音缺少音频文件。'
                   }
+                  action={onDevice ? <a className="linkbtn" href="#/device">去录音笔同步</a> : undefined}
                 />
               ) : plain ? (
                 <p className="transcript-plain">{data.transcript?.text}</p>
@@ -345,24 +407,18 @@ export function DetailPage({ id, onBack, onRemoved }: Props) {
               ) : (
                 <Empty
                   title="还没有 AI 归类结果"
-                  description="归类会生成标题、摘要、分类、标签、要点与待办事项。"
-                  action={
-                    <Button size="sm" variant="primary" disabled={pending || busy || !hasTranscript} onClick={organize}>
-                      AI 归类
-                    </Button>
-                  }
+                  description={hasTranscript ? '点页面上方的「AI 归类」，会生成标题、摘要、分类、标签、要点与待办事项。' : '转录完成后才能进行 AI 归类。'}
                 />
               )}
             </Card>
           ) : null}
 
-          {tab === 'jobs' ? <Card>{data.jobs.length === 0 ? <Empty title="还没有执行记录" /> : <JobsTable jobs={data.jobs} />}</Card> : null}
+          {tab === 'jobs' ? <Card>{data.jobs.length === 0 ? <Empty title="还没有处理记录" /> : <JobsTable jobs={data.jobs} />}</Card> : null}
         </div>
 
         <aside className="detail__side">
-          <Card title="日历事件">
-            <CalendarAssociation id={id} eventId={recording.calendarEventId} revision={recording.status} onChanged={detail.reload} />
-            <a href="#/calendar">在日历视图中关联或新建事件</a>
+          <Card title="日程">
+            <CalendarLink recording={recording} />
           </Card>
           <Card title="整理">
             <Field label="分类">
diff --git a/src/ui/pages/Device.tsx b/src/ui/pages/Device.tsx
index cf436e9..088c459 100644
--- a/src/ui/pages/Device.tsx
+++ b/src/ui/pages/Device.tsx
@@ -1,462 +1,121 @@
-// ABOUTME: 设备接入页：环境自检、设备清单拉取与导入目录扫描。
+// ABOUTME: 录音笔页：连接/断开、同步、单条同步、停止与清理的唯一入口；不展示任何传输细节。
 
-import { useState } from 'react';
-import { Copy, FolderPlus, HardDriveDownload, ListTree, PlugZap, RefreshCw, ScanLine, TerminalSquare } from 'lucide-react';
-import type {
-  BridgeRunResult,
-  DeviceState,
-  DeviceStatus,
-  ImportDirectoryState,
-  IngestScanResult,
-  ParsedDeviceFile,
-  RecordingListResult,
-} from '../../contracts/app';
-import { api, errorText } from '../api';
-import { formatBytes, formatDateTime, formatDuration } from '../format';
+import type { RecordingListResult, SettingEntry } from '../../contracts/app';
+import type { DeviceLastResult, DeviceRecordingOnDevice, DeviceView } from '../../contracts/device';
+import { api } from '../api';
+import { formatTime } from '../format';
 import { useAsyncData } from '../useApi';
-import { Button, Card, ErrorState, Field, Loading, useToast } from '../components/ui';
-import { SdkCommandTable } from '../components/SdkCommandTable';
-import { PendingPullList } from '../components/PendingPullList';
-import { EnvironmentPanel } from '../components/EnvironmentPanel';
+import { useDevice } from '../useDevice';
+import { ErrorState, Loading, useToast } from '../components/ui';
+import { DeviceCard } from '../components/DeviceCard';
+import { DeviceRecordingList } from '../components/DeviceRecordingList';
+import { EnvironmentBanner } from '../components/EnvironmentBanner';
 
 interface Props {
-  onNavigate: (route: string) => void;
+  envFailCount: number;
+  onChanged: () => void;
 }
 
-function parseManifestText(text: string): ParsedDeviceFile[] {
-  return text
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      const [name, size, duration, timestamp] = line.split(/[,|\t ]+/);
-      return {
-        name: name ?? '',
-        format: 'MP3',
-        sizeBytes: Number(size) || null,
-        durationSec: Number(duration) || null,
-        timestamp: Number(timestamp) || null,
-      };
-    })
-    .filter((entry) => entry.name.length > 0);
+function finishedText(result: DeviceLastResult, autoTranscribe: boolean): { message: string; tone: 'success' | 'info' } | null {
+  if (result.origin === 'auto') return null;
+  if (result.kind === 'cleanup') {
+    return result.done > 0
+      ? { message: `已清理 ${result.done} 条，录音笔空间已释放`, tone: 'success' }
+      : { message: '没有可以清理的录音', tone: 'info' };
+  }
+  if (result.cancelled) return { message: `已停止同步${result.done > 0 ? `，已同步 ${result.done} 条录音` : ''}`, tone: 'info' };
+  if (result.done > 0) {
+    return { message: `已同步 ${result.done} 条录音${autoTranscribe ? '，已开始转录' : ''}`, tone: 'success' };
+  }
+  if (result.failed === 0) return { message: '录音笔里没有新录音', tone: 'info' };
+  return null;
 }
 
-export function DevicePage({ onNavigate }: Props) {
-  const toast = useToast();
-  const state = useAsyncData<DeviceState>(() => api.get<DeviceState>('/api/device'), 'device');
-  const directory = useAsyncData<ImportDirectoryState>(() => api.get('/api/ingest/directory'), 'directory');
-  const [serial, setSerial] = useState('');
-  const [manifestText, setManifestText] = useState('');
-  const [busy, setBusy] = useState<string | null>(null);
-  const [bridge, setBridge] = useState<BridgeRunResult | null>(null);
-  const [statusInfo, setStatusInfo] = useState<DeviceStatus | null>(null);
-  const [pullNote, setPullNote] = useState('');
-  const pendingList = useAsyncData<RecordingListResult>(() => api.get<RecordingListResult>('/api/recordings?limit=100'), 'device-pending');
-  const [scan, setScan] = useState<IngestScanResult | null>(null);
-  const [importDir, setImportDir] = useState<string | null>(null);
-  const [environmentRevision, setEnvironmentRevision] = useState(0);
-
-  if (state.loading && !state.data) return <Loading label="正在检测本机环境" />;
-  if (state.error) return <ErrorState message={state.error} onRetry={state.reload} />;
-  const data = state.data;
-  if (!data) return <Loading />;
-
-  const importState = directory.data;
-  // 目录由服务端解析：设置值优先，空值或失效的临时目录回落到默认收件目录。
-  const effectiveImport = importDir ?? importState?.directory ?? '';
-
-  const check = async () => {
-    setBusy('check');
-    try {
-      await api.post('/api/device/check');
-      setEnvironmentRevision((value) => value + 1);
-      state.reload();
-      toast.push('环境检测已刷新', 'success');
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const savePaths = async () => {
-    setBusy('save');
-    try {
-      await api.patch('/api/settings', {
-        values: { import_dir: effectiveImport },
-      });
-      toast.push('路径设置已保存', 'success');
-      state.reload();
-      directory.reload();
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const connect = async () => {
-    setBusy('status');
-    try {
-      const result = await api.post<{ result: BridgeRunResult; device: DeviceStatus | null }>('/api/device/status', {});
-      setBridge(result.result);
-      setStatusInfo(result.device);
-      if (result.device) {
-        if (result.device.serial) setSerial(result.device.serial);
-        toast.push(`已连接 ${result.device.serial ?? '录音笔'}`, 'success');
-        state.reload();
-      } else {
-        toast.push(result.result.message, 'error');
-      }
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const pullList = async () => {
-    setBusy('list');
-    try {
-      const result = await api.post<{ result: BridgeRunResult; registered: number; skipped: number; serial?: string }>(
-        '/api/device/list',
-        { serial },
-      );
-      setBridge(result.result);
-      toast.push(
-        result.registered > 0
-          ? `已登记 ${result.registered} 条设备录音${result.skipped > 0 ? `，跳过 ${result.skipped} 条` : ''}`
-          : result.result.message,
-        result.registered > 0 ? 'success' : 'error',
-      );
-      if (result.registered > 0) {
-        state.reload();
-        directory.reload();
-        pendingList.reload();
-      }
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const submitManifest = async () => {
-    const entries = parseManifestText(manifestText);
-    if (entries.length === 0) {
-      toast.push('请先粘贴设备文件清单，每行一个文件', 'error');
-      return;
-    }
-    setBusy('manifest');
-    try {
-      const result = await api.post<{ accepted: number; skipped: number }>('/api/ingest/manifest', {
-        serial: serial || 'MemoTalk-S1',
-        entries,
-      });
-      toast.push(`已登记 ${result.accepted} 条，跳过 ${result.skipped} 条`, 'success');
-      setManifestText('');
-      state.reload();
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const pendingFiles = (pendingList.data?.items ?? []).filter((item) => item.status === 'pending');
+function AutoConnectLine({ view }: { view: DeviceView }) {
+  const auto = view.autoConnect;
+  const last = view.lastResult;
+  let text: string;
+  if (view.connection.userDisconnected) {
+    text = '已手动断开，自动连接暂停。点「连接」恢复。';
+  } else if (auto.enabled) {
+    text = `自动连接已开启 · 每 ${auto.intervalMinutes} 分钟${auto.nextAttemptAt && view.connection.state === 'disconnected' ? ` · 下次 ${formatTime(auto.nextAttemptAt)}` : ''}`;
+  } else {
+    text = '自动连接已关闭';
+  }
+  return (
+    <div className="statusline">
+      <span>{text}</span>
+      {!view.connection.userDisconnected ? (
+        <a className="linkbtn" href="#/settings">
+          调整
+        </a>
+      ) : null}
+      {last && last.origin === 'auto' && last.kind !== 'cleanup' && (last.done > 0 || last.deferred > 0) ? (
+        <span className="statusline__extra">
+          {`自动同步了 ${last.done} 条${last.deferred > 0 ? `，另有 ${last.deferred} 条较大的录音等你点「同步录音」` : ''}`}
+        </span>
+      ) : null}
+    </div>
+  );
+}
 
-  const pullFile = async (filename: string) => {
-    setBusy('pull');
-    setPullNote(`正在拉取 ${filename}…`);
-    try {
-      const result = await api.post<{
-        result: BridgeRunResult;
-        attached: Array<{ filename: string; ok: boolean; message: string; id: number | null }>;
-        queued: number;
-      }>('/api/device/download', {
-        file: filename,
-        serial: serial || statusInfo?.serial || '',
-      });
-      setBridge(result.result);
-      const attached = result.attached[0];
-      const ok = Boolean(attached?.ok);
-      const suffix = ok && result.queued > 0 ? '，已排队转录' : '';
-      setPullNote(ok ? `已拉取 ${filename}${suffix}` : result.result.message);
-      toast.push(ok ? `已拉取 ${filename}${suffix}` : result.result.message, ok ? 'success' : 'error');
+export function DevicePage({ envFailCount, onChanged }: Props) {
+  const toast = useToast();
+  const settings = useAsyncData<SettingEntry[]>(() => api.get<SettingEntry[]>('/api/settings'), 'device-settings');
+  const autoTranscribe = settings.data?.find((entry) => entry.key === 'auto_transcribe')?.value === '1';
+  const device = useDevice({
+    onFinished: (result) => {
+      const text = finishedText(result, autoTranscribe);
+      if (text) toast.push(text.message, text.tone);
       pendingList.reload();
-      state.reload();
-    } catch (error) {
-      setPullNote(errorText(error));
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const pullAll = async () => {
-    const queue = [...pendingFiles];
-    if (queue.length === 0) return;
-    for (const item of queue) {
-      await pullFile(item.filename);
-    }
-    setPullNote(`队列处理完毕，共 ${queue.length} 个文件。`);
-    pendingList.reload();
-  };
-
-  const runScan = async () => {
-    setBusy('scan');
-    try {
-      const result = await api.post<IngestScanResult>('/api/ingest/scan', { directory: effectiveImport || undefined });
-      setScan(result);
-      if (result.imported === 0 && result.skipped === 0 && result.failed === 0) {
-        toast.push(result.created ? '已建好导入目录，把 MP3 放进去后再扫描一次' : '目录里还没有可导入的音频文件', 'info');
-      } else {
-        toast.push(`导入 ${result.imported} 个文件，跳过 ${result.skipped} 个，失败 ${result.failed} 个`, result.failed > 0 ? 'error' : 'success');
-      }
-      state.reload();
-      directory.reload();
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
-
-  const createDir = async () => {
-    setBusy('mkdir');
-    try {
-      const next = await api.post<ImportDirectoryState>('/api/ingest/directory/ensure', {
-        directory: importDir ?? undefined,
-      });
-      setImportDir(null);
-      directory.reload();
-      state.reload();
-      toast.push(next.created ? '导入目录已创建，把 MP3 放进去后点「立即扫描」' : '导入目录已就绪', 'success');
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(null);
-    }
-  };
+      onChanged();
+    },
+    onError: (error) => toast.error(error),
+  });
+  const view = device.view;
+  const revision = `${view?.lastResult?.jobId ?? ''}:${view?.activity ? 'busy' : 'idle'}:${view?.connection.state ?? ''}`;
+  const pendingList = useAsyncData<RecordingListResult>(
+    () => api.get<RecordingListResult>('/api/recordings?stage=pending&limit=100&sort=recorded'),
+    `device-pending:${revision}`,
+  );
 
-  const copyPath = async () => {
-    if (!effectiveImport) return;
-    try {
-      await navigator.clipboard.writeText(effectiveImport);
-      toast.push('目录路径已复制，可粘贴到资源管理器地址栏', 'success');
-    } catch {
-      toast.push(`复制失败，请手动记下路径：${effectiveImport}`, 'error');
-    }
-  };
+  if (!view && device.error) return <ErrorState error={device.error} onRetry={device.reload} />;
+  if (!view) return <Loading label="正在读取录音笔状态" />;
+
+  const listed = view.cleanable !== null;
+  const items: DeviceRecordingOnDevice[] = listed
+    ? view.onDevice
+    : (pendingList.data?.items ?? []).map((item) => ({
+        id: item.id,
+        filename: item.filename,
+        sizeBytes: item.sizeBytes,
+        durationSec: item.durationSec,
+        recordedAt: item.recordedAt,
+      }));
+  const state = view.connection.state;
+  const blockedReason =
+    state === 'live'
+      ? '实时字幕进行中，结束后才能同步。'
+      : state === 'busy' || view.activity
+        ? '正在同步，完成后可以继续。'
+        : device.pending !== null
+          ? '请稍候…'
+          : null;
 
   return (
     <div className="page page--device">
       <header className="page__head">
         <div>
-          <h1>设备接入</h1>
-          <p className="page__sub">先确认本机运行环境，再从录音笔拉取清单或扫描本地导入目录。</p>
-        </div>
-        <div className="page__actions">
-          <Button icon={<RefreshCw size={15} aria-hidden="true" />} disabled={busy === 'check'} onClick={() => void check()}>
-            重新检测
-          </Button>
+          <h1>录音笔</h1>
+          <p className="page__sub">连上录音笔就会把新录音同步到电脑；用完可以断开，录音笔会更省电。</p>
         </div>
       </header>
 
-      <div className="device-grid">
-        <EnvironmentPanel revision={environmentRevision} />
-
-        <Card title="路径设置">
-          <Field label="导入目录" hint="录音笔文件下载到这个目录后，扫描即可入库；留空时使用默认收件目录">
-            <input value={effectiveImport} onChange={(event) => setImportDir(event.target.value)} placeholder="~/memo/memotalk/inbox" />
-          </Field>
-          <div className="card__actions">
-            <Button variant="primary" size="sm" disabled={busy === 'save'} onClick={() => void savePaths()}>
-              保存路径
-            </Button>
-          </div>
-        </Card>
-
-        <Card
-          title="连接录音笔"
-          action={<span className="muted">{data.devices.length > 0 ? `最近设备：${data.devices[0].serial}` : '尚未连接设备'}</span>}
-        >
-          <Field label="设备序列号" hint="用于把清单对应到具体设备；留空时自动识别或使用默认值">
-            <input value={serial} onChange={(event) => setSerial(event.target.value)} placeholder="MemoTalk-S1" />
-          </Field>
-          <div className="card__actions">
-            <Button
-              variant="primary"
-              size="sm"
-              icon={<PlugZap size={14} aria-hidden="true" />}
-              disabled={busy === 'status'}
-              onClick={() => void connect()}
-            >
-              连接并检测
-            </Button>
-            <Button
-              size="sm"
-              icon={<ListTree size={14} aria-hidden="true" />}
-              disabled={busy === 'list'}
-              onClick={() => void pullList()}
-            >
-              读取清单
-            </Button>
-            <Button size="sm" onClick={() => onNavigate('library')}>
-              去录音库
-            </Button>
-          </div>
-          {statusInfo ? (
-            <dl className="devicestatus">
-              <div>
-                <dt>序列号</dt>
-                <dd>{statusInfo.serial ?? '—'}</dd>
-              </div>
-              <div>
-                <dt>电量</dt>
-                <dd>{statusInfo.batteryPct !== null ? `${statusInfo.batteryPct}%` : '—'}</dd>
-              </div>
-              <div>
-                <dt>剩余空间</dt>
-                <dd>{statusInfo.freeSpacePct !== null ? `${statusInfo.freeSpacePct}%` : '—'}</dd>
-              </div>
-              <div>
-                <dt>固件</dt>
-                <dd>{statusInfo.firmware ?? '—'}</dd>
-              </div>
-              <div>
-                <dt>录音状态</dt>
-                <dd>{statusInfo.recordingState ?? '—'}</dd>
-              </div>
-              <div>
-                <dt>热点</dt>
-                <dd>{statusInfo.hotspotSsid ?? '—'}</dd>
-              </div>
-            </dl>
-          ) : null}
-          {bridge ? (
-            <div className="bridge">
-              <p className={`bridge__msg${bridge.ok ? '' : ' bridge__msg--bad'}`}>{bridge.message}</p>
-              <p className="bridge__cmd">
-                <TerminalSquare size={13} aria-hidden="true" /> {bridge.command}
-                {bridge.exitCode !== null ? ` · 退出码 ${bridge.exitCode}` : ''}
-              </p>
-              {bridge.parsedFiles.length > 0 ? (
-                <p className="muted">解析到 {bridge.parsedFiles.length} 条文件记录。</p>
-              ) : null}
-              <details className="bridge__raw">
-                <summary>SDK 原始输出</summary>
-                <pre>{bridge.stdout || bridge.stderr || '（无输出）'}</pre>
-              </details>
-            </div>
-          ) : null}
-        </Card>
-
-        <PendingPullList
-          items={pendingFiles}
-          busy={busy === 'pull'}
-          note={pullNote}
-          onPull={(filename) => void pullFile(filename)}
-          onPullAll={() => void pullAll()}
-        />
-
-        <Card title="手动登记清单" action={<span className="muted">每行：文件名 大小 时长秒 时间戳</span>}>
-          <textarea
-            className="manifest-input"
-            value={manifestText}
-            onChange={(event) => setManifestText(event.target.value)}
-            rows={5}
-            placeholder={'REC20261020_103000.mp3 1048576 65 1761000000\nREC20261020_114500.mp3 2097152 132 1761004500'}
-            aria-label="设备文件清单"
-          />
-          <div className="card__actions">
-            <Button size="sm" icon={<PlugZap size={14} aria-hidden="true" />} disabled={busy === 'manifest'} onClick={() => void submitManifest()}>
-              登记为待拉取
-            </Button>
-          </div>
-        </Card>
-
-        <Card
-          title="扫描导入目录"
-          action={
-            <span className={`dirstate ${importState?.exists ? 'dirstate--ok' : 'dirstate--idle'}`}>
-              {importState ? (importState.exists ? `${importState.audioFiles} 个音频文件` : '目录待创建') : '—'}
-            </span>
-          }
-        >
-          <p className="muted">把录音笔通过 U 盘模式或 Wi-Fi 下载的 MP3 放进导入目录，扫描后会复制进本应用的数据区。</p>
-          <div className="pathrow">
-            <code className="pathrow__path" title={effectiveImport || undefined}>
-              {effectiveImport || '尚未设置导入目录'}
-            </code>
-            <Button size="sm" icon={<Copy size={14} aria-hidden="true" />} disabled={!effectiveImport} onClick={() => void copyPath()}>
-              复制路径
-            </Button>
-          </div>
-          {importState?.isDefault ? (
-            <p className="hintline">正在使用默认收件目录，直接把 MP3 放进去即可；也可以在「路径设置」里换成自己的文件夹。</p>
-          ) : null}
-          {importState?.resetFrom ? (
-            <p className="notice">
-              原先保存的目录 <code>{importState.resetFrom}</code> 位于可能被系统清理的临时目录，这里已自动改用默认收件目录。
-            </p>
-          ) : null}
-          <div className="card__actions">
-            <Button
-              variant="primary"
-              size="sm"
-              icon={<ScanLine size={14} aria-hidden="true" />}
-              disabled={busy === 'scan'}
-              onClick={() => void runScan()}
-            >
-              {importState && !importState.exists ? '创建目录并扫描' : '立即扫描'}
-            </Button>
-            {importState && !importState.exists ? (
-              <Button
-                size="sm"
-                icon={<FolderPlus size={14} aria-hidden="true" />}
-                disabled={busy === 'mkdir'}
-                onClick={() => void createDir()}
-              >
-                只创建目录
-              </Button>
-            ) : null}
-          </div>
-          {scan ? (
-            <ul className="scanresult">
-              <li>导入 {scan.imported} 个</li>
-              <li>跳过 {scan.skipped} 个</li>
-              <li>失败 {scan.failed} 个</li>
-            </ul>
-          ) : null}
-          {scan && scan.files.length === 0 ? (
-            <p className="hintline">这次没有扫到音频文件。把录音笔里的 MP3 复制到上面的目录，再点一次「立即扫描」。</p>
-          ) : null}
-          {scan && scan.files.length > 0 ? (
-            <details className="bridge__raw">
-              <summary>处理明细</summary>
-              <ul className="scandetail">
-                {scan.files.map((file) => (
-                  <li key={file.filename} className={`scandetail--${file.outcome}`}>
-                    <span>{file.filename}</span>
-                    <span>{file.outcome === 'imported' ? '已导入' : file.reason ?? file.outcome}</span>
-                  </li>
-                ))}
-              </ul>
-            </details>
-          ) : null}
-        </Card>
-      </div>
-
-      <SdkCommandTable commands={data.commands} />
-
-      <Card title="导入完成后">
-        <div className="card__actions">
-          <Button icon={<HardDriveDownload size={14} aria-hidden="true" />} onClick={() => onNavigate('library')}>
-            去录音库批量转录
-          </Button>
-        </div>
-      </Card>
+      <EnvironmentBanner failCount={Math.max(envFailCount, view.environment.failCount)} />
+      {device.error ? <ErrorState error={device.error} onRetry={device.reload} /> : null}
+      <DeviceCard device={device} pendingCount={items.length} />
+      <AutoConnectLine view={view} />
+      <DeviceRecordingList items={items} blockedReason={blockedReason} wifiFromBytes={view.wifiFromBytes} onPull={(id) => void device.pull([id])} />
     </div>
   );
 }
diff --git a/src/ui/pages/Library.tsx b/src/ui/pages/Library.tsx
index 0fd8e2d..4c1c62a 100644
--- a/src/ui/pages/Library.tsx
+++ b/src/ui/pages/Library.tsx
@@ -1,22 +1,26 @@
-// ABOUTME: 录音库：搜索、筛选、批量转录与批量归类。
+// ABOUTME: 录音页：统计条、搜索筛选、批量与「全部」转录/归类，以及「导入」对话框入口。
 
-import { useMemo, useState } from 'react';
-import { Mic, Search, Sparkles, Star, Waves } from 'lucide-react';
-import type { Category, RecordingListResult, RecordingSummary } from '../../contracts/app';
-import { api, errorText } from '../api';
+import { useEffect, useMemo, useState } from 'react';
+import { FolderDown, Search, Sparkles, Star, Waves } from 'lucide-react';
+import type { BatchResult, Category, Overview, RecordingListResult, RecordingSummary } from '../../contracts/app';
+import { api } from '../api';
 import { formatDateTime, formatDuration } from '../format';
+import { buildHash, type LibraryStage } from '../router';
 import { useAsyncData, useDebounced, usePolling } from '../useApi';
 import { Button, Empty, ErrorState, Loading, Segmented, StatusChip, Tag, useToast } from '../components/ui';
+import { ImportDialog } from '../components/ImportDialog';
+import { EnvironmentBanner } from '../components/EnvironmentBanner';
 
-const STAGES = [
+type Stage = 'all' | LibraryStage;
+
+const STAGES: Array<{ value: Stage; label: string }> = [
   { value: 'all', label: '全部' },
-  { value: 'need-transcribe', label: '待转录' },
-  { value: 'need-organize', label: '待归类' },
-  { value: 'done', label: '已归档' },
+  { value: 'pending', label: '在录音笔中' },
+  { value: 'ready', label: '待转录' },
+  { value: 'transcribed', label: '待归类' },
+  { value: 'done', label: '已整理' },
   { value: 'failed', label: '失败' },
-] as const;
-
-type Stage = (typeof STAGES)[number]['value'];
+];
 
 const SORTS = [
   { value: 'newest', label: '最近入库' },
@@ -26,21 +30,59 @@ const SORTS = [
 ];
 
 interface Props {
+  stage?: LibraryStage;
+  overview: Overview | null;
+  envFailCount: number;
   onOpen: (id: number) => void;
-  onNavigate: (route: string) => void;
+  onChanged: () => void;
 }
 
-export function LibraryPage({ onOpen, onNavigate }: Props) {
+function StatsBar({ overview, onFailed }: { overview: Overview | null; onFailed: () => void }) {
+  if (!overview) return null;
+  const ready = overview.byStatus.find((item) => item.status === 'ready')?.count ?? 0;
+  return (
+    <div className="statsbar" aria-label="录音统计">
+      <span>
+        共 <strong>{overview.totalRecordings}</strong> 条
+      </span>
+      <span>
+        累计 <strong>{formatDuration(overview.totalDurationSec)}</strong>
+      </span>
+      <span>
+        待转录 <strong>{ready}</strong>
+      </span>
+      {overview.failedCount > 0 ? (
+        <button type="button" className="statsbar__failed" onClick={onFailed}>
+          失败 <strong>{overview.failedCount}</strong>
+        </button>
+      ) : null}
+    </div>
+  );
+}
+
+export function LibraryPage({ stage: routeStage, overview, envFailCount, onOpen, onChanged }: Props) {
   const [query, setQuery] = useState('');
-  const [stage, setStage] = useState<Stage>('all');
+  const [stage, setStageState] = useState<Stage>(routeStage ?? 'all');
   const [categoryId, setCategoryId] = useState('all');
   const [tag, setTag] = useState('all');
   const [sort, setSort] = useState('newest');
   const [selected, setSelected] = useState<number[]>([]);
   const [busy, setBusy] = useState(false);
+  const [importing, setImporting] = useState(false);
   const debouncedQuery = useDebounced(query, 260);
   const toast = useToast();
 
+  // 从统计条或外部链接带着 ?stage= 进来时同步筛选。
+  useEffect(() => {
+    setStageState(routeStage ?? 'all');
+  }, [routeStage]);
+
+  const setStage = (next: Stage) => {
+    setStageState(next);
+    setSelected([]);
+    window.history.replaceState(null, '', buildHash(next === 'all' ? { name: 'library' } : { name: 'library', stage: next }));
+  };
+
   const search = new URLSearchParams();
   if (debouncedQuery.trim()) search.set('q', debouncedQuery.trim());
   if (stage !== 'all') search.set('stage', stage);
@@ -62,23 +104,21 @@ export function LibraryPage({ onOpen, onNavigate }: Props) {
     setSelected((current) => (current.includes(id) ? current.filter((item) => item !== id) : [...current, id]));
   };
 
-  const runBatch = async (kind: 'transcribe' | 'organize') => {
-    if (selected.length === 0) return;
+  const runBatch = async (kind: 'transcribe' | 'organize', body: { ids: number[] } | { stage: 'ready' | 'transcribed' }) => {
     setBusy(true);
     try {
-      const result = await api.post<{ accepted: number; skipped: number }>(`/api/recordings/batch/${kind}`, {
-        ids: selected,
-      });
+      const result = await api.post<BatchResult>(`/api/recordings/batch/${kind}`, body);
       toast.push(
         result.accepted > 0
-          ? `已排队 ${result.accepted} 条${kind === 'transcribe' ? '转录' : '归类'}任务${result.skipped > 0 ? `，${result.skipped} 条被跳过` : ''}`
-          : '没有可处理的录音（可能缺少音频或不满足条件）',
+          ? `已开始${kind === 'transcribe' ? '转录' : '归类'} ${result.accepted} 条${result.skipped > 0 ? `，${result.skipped} 条不满足条件已跳过` : ''}`
+          : '没有可以处理的录音（可能缺少音频或还没转录）',
         result.accepted > 0 ? 'success' : 'info',
       );
       setSelected([]);
       list.reload();
+      onChanged();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     } finally {
       setBusy(false);
     }
@@ -89,23 +129,42 @@ export function LibraryPage({ onOpen, onNavigate }: Props) {
     [stage, categoryId, tag, debouncedQuery],
   );
 
+  const clearFilters = () => {
+    setQuery('');
+    setStage('all');
+    setCategoryId('all');
+    setTag('all');
+  };
+
+  const total = list.data?.total ?? 0;
+  // 「全部…」由服务端按阶段选录音（不看搜索、分类、标签），所以只在阶段是唯一筛选条件时出现，
+  // 数量取服务端同口径的阶段计数（不含已归档，上限 400），保证按钮上的数字就是实际处理的条数。
+  const onlyStageFilter = activeFilters === 1 && !query.trim();
+  const stageCount = stage === 'ready' || stage === 'transcribed'
+    ? Math.min(400, overview?.byStatus.find((item) => item.status === stage)?.count ?? 0)
+    : 0;
+  const showAll = selected.length === 0 && onlyStageFilter && stageCount > 0;
+
   return (
     <div className="page page--library">
       <header className="page__head">
         <div>
-          <h1>录音库</h1>
+          <h1>录音</h1>
           <p className="page__sub">
-            {list.data ? `命中 ${list.data.total} 条录音` : '正在统计'}
+            {list.data ? `当前显示 ${total} 条` : '正在统计'}
             {activeFilters > 0 ? ` · ${activeFilters} 个筛选条件生效` : ''}
           </p>
         </div>
         <div className="page__actions">
-          <Button icon={<Mic size={15} aria-hidden="true" />} onClick={() => onNavigate('device')}>
-            导入新录音
+          <Button icon={<FolderDown size={15} aria-hidden="true" />} onClick={() => setImporting(true)}>
+            导入
           </Button>
         </div>
       </header>
 
+      <EnvironmentBanner failCount={envFailCount} />
+      <StatsBar overview={overview} onFailed={() => setStage('failed')} />
+
       <div className="toolbar">
         <div className="search">
           <Search size={15} aria-hidden="true" />
@@ -117,7 +176,7 @@ export function LibraryPage({ onOpen, onNavigate }: Props) {
             aria-label="搜索录音"
           />
         </div>
-        <Segmented label="处理阶段" value={stage} options={STAGES.map((item) => ({ ...item }))} onChange={(value) => setStage(value as Stage)} />
+        <Segmented label="处理阶段" value={stage} options={STAGES} onChange={setStage} />
         <div className="toolbar__selects">
           <select value={categoryId} onChange={(event) => setCategoryId(event.target.value)} aria-label="按分类筛选">
             <option value="all">全部分类</option>
@@ -148,10 +207,10 @@ export function LibraryPage({ onOpen, onNavigate }: Props) {
       {selected.length > 0 ? (
         <div className="batchbar" role="region" aria-label="批量操作">
           <span>已选 {selected.length} 条</span>
-          <Button size="sm" disabled={busy} icon={<Waves size={14} aria-hidden="true" />} onClick={() => void runBatch('transcribe')}>
+          <Button size="sm" disabled={busy} icon={<Waves size={14} aria-hidden="true" />} onClick={() => void runBatch('transcribe', { ids: selected })}>
             批量转录
           </Button>
-          <Button size="sm" disabled={busy} icon={<Sparkles size={14} aria-hidden="true" />} onClick={() => void runBatch('organize')}>
+          <Button size="sm" disabled={busy} icon={<Sparkles size={14} aria-hidden="true" />} onClick={() => void runBatch('organize', { ids: selected })}>
             批量归类
           </Button>
           <Button size="sm" variant="quiet" onClick={() => setSelected([])}>
@@ -160,37 +219,44 @@ export function LibraryPage({ onOpen, onNavigate }: Props) {
         </div>
       ) : null}
 
+      {showAll ? (
+        <div className="batchbar" role="region" aria-label="全部处理">
+          {stage === 'ready' ? (
+            <Button size="sm" variant="primary" disabled={busy} icon={<Waves size={14} aria-hidden="true" />} onClick={() => void runBatch('transcribe', { stage: 'ready' })}>
+              全部转录（{stageCount}）
+            </Button>
+          ) : (
+            <Button size="sm" variant="primary" disabled={busy} icon={<Sparkles size={14} aria-hidden="true" />} onClick={() => void runBatch('organize', { stage: 'transcribed' })}>
+              全部归类（{stageCount}）
+            </Button>
+          )}
+        </div>
+      ) : null}
+
       {list.loading && !list.data ? <Loading label="正在读取录音" /> : null}
-      {list.error ? <ErrorState message={list.error} onRetry={list.reload} /> : null}
+      {list.error ? <ErrorState error={list.error} onRetry={list.reload} /> : null}
 
       {list.data && items.length === 0 ? (
-        <Empty
-          title={activeFilters > 0 ? '没有符合条件的录音' : '录音库还是空的'}
-          description={
-            activeFilters > 0
-              ? '试着放宽筛选条件，或清空搜索关键词。'
-              : '先到设备页扫描导入目录或从录音笔拉取文件清单。'
-          }
-          action={
-            activeFilters > 0 ? (
-              <Button
-                size="sm"
-                onClick={() => {
-                  setQuery('');
-                  setStage('all');
-                  setCategoryId('all');
-                  setTag('all');
-                }}
-              >
+        activeFilters > 0 ? (
+          <Empty
+            title="没有符合条件的录音"
+            description="试着放宽筛选条件，或清空搜索关键词。"
+            action={
+              <button type="button" className="linkbtn" onClick={clearFilters}>
                 清空筛选
-              </Button>
-            ) : (
-              <Button size="sm" variant="primary" onClick={() => onNavigate('device')}>
-                去导入录音
-              </Button>
-            )
-          }
-        />
+              </button>
+            }
+          />
+        ) : (
+          <Empty
+            title="还没有录音"
+            action={
+              <p className="empty__desc">
+                连上录音笔后在「<a href="#/device">录音笔</a>」页同步，或点右上角「导入」。
+              </p>
+            }
+          />
+        )
       ) : null}
 
       {items.length > 0 ? (
@@ -224,6 +290,19 @@ export function LibraryPage({ onOpen, onNavigate }: Props) {
           </ul>
         </div>
       ) : null}
+
+      {importing ? (
+        <ImportDialog
+          onClose={() => setImporting(false)}
+          onImported={(result) => {
+            if (result.imported > 0) {
+              list.reload();
+              tags.reload();
+              onChanged();
+            }
+          }}
+        />
+      ) : null}
     </div>
   );
 }
@@ -252,7 +331,7 @@ function Row({
         <span className="row__meta">
           {formatDateTime(item.recordedAt ?? item.createdAt)}
           {item.transcriptChars > 0 ? ` · ${item.transcriptChars} 字转写` : ''}
-          {item.hasAudioFile ? '' : ' · 缺音频文件'}
+          {item.hasAudioFile || item.status === 'pending' ? '' : ' · 缺音频文件'}
         </span>
       </button>
       <span className="col-category">
diff --git a/src/ui/pages/Live.tsx b/src/ui/pages/Live.tsx
index 2f06cc7..41ab898 100644
--- a/src/ui/pages/Live.tsx
+++ b/src/ui/pages/Live.tsx
@@ -1,30 +1,41 @@
-// ABOUTME: 实时字幕页：启动采集、滚动字幕与收尾归档。
+// ABOUTME: 实时字幕页：开始/停止、滚动字幕，结束后整段录音自动保存。
 
 import { useEffect, useRef, useState } from 'react';
-import { AlertTriangle, ArrowRight, Captions, Mic, Square, Waves } from 'lucide-react';
+import { ArrowRight, Captions, Mic, Square, Waves } from 'lucide-react';
 import type { LiveState } from '../../contracts/app';
-import { api, errorText } from '../api';
+import { api } from '../api';
 import { formatBytes, formatClock } from '../format';
 import { useAsyncData, usePolling } from '../useApi';
+import { useDevice } from '../useDevice';
 import { Button, Card, useToast } from '../components/ui';
+import { ErrorNotice } from '../components/ErrorNotice';
 
 interface Props {
   onOpen: (id: number) => void;
-  onNavigate: (route: string) => void;
 }
 
 const STATUS_TEXT: Record<LiveState['status'], string> = {
   idle: '未开始',
   starting: '正在连接录音笔…',
-  listening: '录音中 · 实时回传',
+  listening: '录音中 · 实时转写',
   error: '出现问题',
 };
 
-export function LivePage({ onOpen, onNavigate }: Props) {
+export function LivePage({ onOpen }: Props) {
   const toast = useToast();
   const state = useAsyncData<LiveState>(() => api.get<LiveState>('/api/live'), 'live');
   const [busy, setBusy] = useState(false);
   const captionRef = useRef<HTMLDivElement>(null);
+  const device = useDevice();
+  const deviceState = device.view?.connection.state;
+  const deviceActivity = device.view?.activity ?? null;
+  const deviceBusy = deviceState === 'busy' || Boolean(deviceActivity) || deviceState === 'connecting';
+  // 按真实状态说明为什么暂时不能开始：连接中、清理中、同步中各有各的说法。
+  const deviceBusyText = deviceActivity?.kind === 'cleanup'
+    ? '录音笔正在清理已同步的录音，结束后才能开始实时字幕。'
+    : deviceActivity || deviceState === 'busy'
+      ? '录音笔正在同步，结束后才能开始实时字幕。'
+      : '录音笔正在连接，请稍候。';
 
   const live = state.data;
   const active = Boolean(live?.active);
@@ -44,7 +55,8 @@ export function LivePage({ onOpen, onNavigate }: Props) {
       toast.push('已开始采集，说话即出字幕', 'success');
       state.reload();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
+      state.reload();
     } finally {
       setBusy(false);
     }
@@ -57,7 +69,7 @@ export function LivePage({ onOpen, onNavigate }: Props) {
       toast.push(result.lastSaved ? `已保存，共 ${result.lastSaved.chars} 字` : '已停止', 'success');
       state.reload();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     } finally {
       setBusy(false);
     }
@@ -71,27 +83,35 @@ export function LivePage({ onOpen, onNavigate }: Props) {
         <div>
           <h1>实时字幕</h1>
           <p className="page__sub">
-            录音笔录音的同时把音频回传到本机，边说边出字。停止后音频与文字一起归档到录音库。
+            录音笔录音的同时把声音传到电脑，边说边出字。停止后录音和文字会一起保存到录音库。
           </p>
         </div>
         <div className="page__actions">
           {active ? (
             <Button variant="danger" icon={<Square size={14} aria-hidden="true" />} disabled={busy} onClick={() => void stop()}>
-              停止并归档
+              停止并保存
             </Button>
           ) : (
-            <Button variant="primary" icon={<Mic size={15} aria-hidden="true" />} disabled={busy} onClick={() => void start()}>
+            <Button variant="primary" icon={<Mic size={15} aria-hidden="true" />} disabled={busy || deviceBusy} onClick={() => void start()}>
               开始实时字幕
             </Button>
           )}
         </div>
       </header>
 
-      {live?.message ? (
-        <div className="alert" role="alert">
-          <AlertTriangle size={14} aria-hidden="true" />
-          <span>{live.message}</span>
-        </div>
+      {deviceBusy && !active ? (
+        <p className="notice" role="status">
+          {deviceBusyText}{' '}
+          <a className="linkbtn" href="#/device">
+            去录音笔查看
+          </a>
+        </p>
+      ) : null}
+      {live?.error ? <ErrorNotice error={live.error} onRetry={active ? undefined : () => void start()} /> : null}
+      {!live?.error && live?.message ? (
+        <p className="notice" role="status">
+          {live.message}
+        </p>
       ) : null}
 
       <Card tight>
@@ -115,7 +135,7 @@ export function LivePage({ onOpen, onNavigate }: Props) {
         <div className={`live__caption${finals.length === 0 && !live?.partial ? ' live__caption--empty' : ''}`} ref={captionRef}>
           {finals.length === 0 && !live?.partial ? (
             <p className="live__hint">
-              {active ? '正在等待第一句话…' : '点右上角「开始实时字幕」，录音笔会自动开始录音并把声音实时传回来。'}
+              {active ? '正在等待第一句话…' : '点右上角「开始实时字幕」，录音笔会开始录音并把声音实时传到电脑。'}
             </p>
           ) : (
             <>
@@ -136,28 +156,21 @@ export function LivePage({ onOpen, onNavigate }: Props) {
       </Card>
 
       {live?.lastSaved ? (
-        <Card title="刚刚归档">
-          <p className="live__saved">
-            已保存到录音库：<code>{live.lastSaved.filePath}</code>（{live.lastSaved.chars} 字）
-          </p>
+        <Card title="刚刚保存">
+          <p className="live__saved">已保存到录音库（{live.lastSaved.chars} 字）。</p>
           <div className="card__actions">
             <Button size="sm" icon={<ArrowRight size={14} aria-hidden="true" />} onClick={() => onOpen(live.lastSaved!.recordingId)}>
               打开这条录音
             </Button>
-            <Button size="sm" onClick={() => onNavigate('library')}>
-              去录音库
-            </Button>
           </div>
         </Card>
       ) : null}
 
-      <Card title="使用前提与限制">
+      <Card title="使用前提">
         <ul className="bullets">
-          <li>录音笔需要先按一下物理键唤醒，并保持在电脑旁边；深度休眠后无法被远程唤醒。</li>
-          <li>实时回传走 BLE 的 0x90 流，设备必须处于录音中；连接中断时这一段音频不会补发。</li>
-          <li>开启实时音频流后，设备不再上报实时音量电平（0xA4 是二选一）。</li>
-          <li>长时间开着会明显耗电。长会议建议录完再拉取（那条链路更稳、更省电）。</li>
-          <li>停止时会自动归档 MP3 与文字；开启「转录后自动归类」还会顺带生成摘要与分类。</li>
+          <li>先按一下录音笔按键唤醒，并放在电脑附近；开始后录音笔会自动录音。</li>
+          <li>实时字幕进行时无法同步录音。</li>
+          <li>结束后整段录音会自动保存到录音库。</li>
         </ul>
       </Card>
     </div>
diff --git a/src/ui/pages/Overview.tsx b/src/ui/pages/Overview.tsx
deleted file mode 100644
index 1009425..0000000
--- a/src/ui/pages/Overview.tsx
+++ /dev/null
@@ -1,200 +0,0 @@
-// ABOUTME: 概览页：设备连接状态、录音总览、分类分布与最近入库。
-
-import { useState, type ReactNode } from 'react';
-import { ArrowRight, Clock, FolderDown, HardDriveDownload, Layers, Mic, Sparkles } from 'lucide-react';
-import type { BridgeRunResult, DeviceStatus, Overview } from '../../contracts/app';
-import { api, errorText } from '../api';
-import { formatDateTime, formatDuration } from '../format';
-import { useAsyncData, usePolling } from '../useApi';
-import { Button, Card, Empty, ErrorState, Loading, StatusChip, useToast } from '../components/ui';
-import { DeviceHeroCard } from '../components/DeviceHero';
-
-interface Props {
-  onOpen: (id: number) => void;
-  onNavigate: (route: string) => void;
-}
-
-function Stat({ label, value, hint, icon }: { label: string; value: string; hint?: string; icon: ReactNode }) {
-  return (
-    <div className="stat">
-      <span className="stat__icon" aria-hidden="true">{icon}</span>
-      <span className="stat__label">{label}</span>
-      <strong className="stat__value">{value}</strong>
-      {hint ? <span className="stat__hint">{hint}</span> : null}
-    </div>
-  );
-}
-
-export function OverviewPage({ onOpen, onNavigate }: Props) {
-  const toast = useToast();
-  const state = useAsyncData<Overview>(() => api.get<Overview>('/api/overview'), 'overview');
-  const [refreshing, setRefreshing] = useState(false);
-  const [connecting, setConnecting] = useState(false);
-  // 自动重连可能在任何时刻接上设备，首页保持轻量轮询让状态自动翻新。
-  usePolling(state.reload, 20000, true);
-
-  /** 首页直接连接设备：不跳转，连上后原地刷新成仪表状态。 */
-  const connectDevice = async (mode: 'connect' | 'refresh') => {
-    const setBusy = mode === 'connect' ? setConnecting : setRefreshing;
-    setBusy(true);
-    try {
-      const result = await api.post<{ result: BridgeRunResult; device: DeviceStatus | null }>('/api/device/status', {});
-      if (result.device) {
-        toast.push(mode === 'connect' ? `已连接 ${result.device.serial ?? '录音笔'}` : `已刷新 ${result.device.serial ?? '设备'} 状态`, 'success');
-        state.reload();
-      } else {
-        toast.push(result.result?.message ?? '没有读到设备状态，请确认录音笔已唤醒', 'error');
-      }
-    } catch (error) {
-      toast.push(errorText(error), 'error');
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  if (state.loading && !state.data) return <Loading label="正在读取录音概览" />;
-  if (state.error) return <ErrorState message={state.error} onRetry={state.reload} />;
-  const data = state.data;
-  if (!data) return <Loading />;
-
-  const device = data.device;
-  const connected = Boolean(device?.connected);
-  const untranscribed = data.byStatus
-    .filter((item) => item.status === 'pending' || item.status === 'ready')
-    .reduce((sum, item) => sum + item.count, 0);
-  const totalFiles = Math.max(data.totalRecordings, 1);
-
-  const subtitle = (() => {
-    if (connected) {
-      const parts = [`已连接 ${device?.model ?? '录音笔'}`];
-      if (device && device.pendingPulls > 0) parts.push(`卡里还有 ${device.pendingPulls} 条待拉取`);
-      if (data.totalRecordings > 0) parts.push(`库里 ${data.totalRecordings} 条录音，累计 ${formatDuration(data.totalDurationSec)}`);
-      return `${parts.join('，')}。`;
-    }
-    if (data.totalRecordings === 0) {
-      return '还没有录音入库。先连接录音笔或指定一个导入目录，就能开始转录与归类。';
-    }
-    return `共 ${data.totalRecordings} 条录音，累计 ${formatDuration(data.totalDurationSec)}。`;
-  })();
-
-  return (
-    <div className="page page--overview">
-      <header className="page__head">
-        <div>
-          <h1>录音概览</h1>
-          <p className="page__sub">{subtitle}</p>
-        </div>
-        <div className="page__actions">
-          <Button icon={<FolderDown size={15} aria-hidden="true" />} onClick={() => onNavigate('device')}>
-            导入录音
-          </Button>
-          {connected ? (
-            <span className="page__status">
-              <span className="pulse" aria-hidden="true" />
-              设备已连接
-            </span>
-          ) : null}
-        </div>
-      </header>
-
-      <DeviceHeroCard
-        device={device}
-        refreshing={refreshing}
-        connecting={connecting}
-        onConnect={() => void connectDevice('connect')}
-        onRefresh={() => void connectDevice('refresh')}
-        onNavigate={onNavigate}
-      />
-
-      <div className="stat-row">
-        <Stat label="录音总数" value={String(data.totalRecordings)} icon={<Mic size={16} />} hint={`${data.favoriteCount} 条收藏`} />
-        <Stat label="累计时长" value={formatDuration(data.totalDurationSec)} icon={<Clock size={16} />} hint="全部录音合计" />
-        <Stat label="已转录" value={String(data.transcribedCount)} icon={<Layers size={16} />} hint={`${untranscribed} 条待转录`} />
-        <Stat label="已归类" value={String(data.organizedCount)} icon={<Sparkles size={16} />} hint={`${data.unreviewedToday} 条今日待处理`} />
-      </div>
-
-      <div className="overview-grid">
-        <Card
-          title="分类分布"
-          action={
-            <Button size="sm" variant="quiet" onClick={() => onNavigate('categories')}>
-              管理分类
-            </Button>
-          }
-        >
-          {data.byCategory.length === 0 ? (
-            <Empty title="还没有分类数据" />
-          ) : (
-            <ul className="bars">
-              {data.byCategory.map((item) => (
-                <li key={item.id} className="bars__row">
-                  <span className="bars__name">
-                    <span className="bars__dot" style={{ background: item.color }} aria-hidden="true" />
-                    {item.name}
-                  </span>
-                  <span className="bars__track">
-                    <span
-                      className="bars__fill"
-                      style={{ width: `${Math.round((item.count / totalFiles) * 100)}%`, background: item.color }}
-                    />
-                  </span>
-                  <span className="bars__value">{item.count}</span>
-                  <span className="bars__meta">{formatDuration(item.durationSec)}</span>
-                </li>
-              ))}
-            </ul>
-          )}
-        </Card>
-
-        <Card
-          title="最近入库"
-          action={
-            <Button size="sm" variant="quiet" icon={<ArrowRight size={14} aria-hidden="true" />} onClick={() => onNavigate('library')}>
-              全部录音
-            </Button>
-          }
-        >
-          {data.recent.length === 0 ? (
-            <Empty
-              title="还没有录音"
-              description={connected ? '设备已连接，去「设备接入」读取清单并拉取录音。' : '连接录音笔拉取，或扫描本地导入目录。'}
-              action={
-                <Button size="sm" icon={<HardDriveDownload size={14} aria-hidden="true" />} onClick={() => onNavigate('device')}>
-                  去读取清单
-                </Button>
-              }
-            />
-          ) : (
-            <ul className="recent">
-              {data.recent.map((item) => (
-                <li key={item.id}>
-                  <button type="button" className="recent__item" onClick={() => onOpen(item.id)}>
-                    <span className="recent__main">
-                      <span className="recent__title">{item.title || item.filename}</span>
-                      <span className="recent__meta">
-                        {formatDateTime(item.recordedAt ?? item.createdAt)} · {formatDuration(item.durationSec)}
-                        {item.categoryName ? ` · ${item.categoryName}` : ''}
-                      </span>
-                    </span>
-                    <StatusChip status={item.status} />
-                  </button>
-                </li>
-              ))}
-            </ul>
-          )}
-        </Card>
-      </div>
-
-      {data.failedCount > 0 ? (
-        <Card title="需要注意">
-          <p className="notice">
-            有 {data.failedCount} 条录音处理失败，通常是音频文件缺失或识别中断。打开录音查看原因后可以重试。
-          </p>
-          <Button size="sm" onClick={() => onNavigate('library')}>
-            查看失败录音
-          </Button>
-        </Card>
-      ) : null}
-    </div>
-  );
-}
diff --git a/src/ui/pages/Settings.tsx b/src/ui/pages/Settings.tsx
index 922a6db..42cd158 100644
--- a/src/ui/pages/Settings.tsx
+++ b/src/ui/pages/Settings.tsx
@@ -1,96 +1,123 @@
-// ABOUTME: 设置页：录音库位置、自动转录与自动重连、识别参数。
+// ABOUTME: 设置页：通用 / 自动化 / 识别 / 诊断与高级四个分区；所有路径只在这里编辑。
 
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import { Save } from 'lucide-react';
 import type { SettingEntry } from '../../contracts/app';
-import { api, errorText } from '../api';
+import { api } from '../api';
 import { useAsyncData } from '../useApi';
 import { Button, Card, ErrorState, Field, Loading, useToast } from '../components/ui';
+import { DiagnosticsSection } from './settings/DiagnosticsSection';
 
-const TEXT_FIELDS: Array<{ key: string; label: string; hint: string; placeholder: string }> = [
+const GENERAL_FIELDS: Array<{ key: string; label: string; hint: string; placeholder: string }> = [
   {
     key: 'library_dir',
     label: '录音库目录',
-    hint: '留空默认 ~/memo/memotalk/raw，拉取的录音按 YYYY-MM 自动分月归档',
+    hint: '留空默认 ~/memo/memotalk/raw；同步和导入的录音按年月自动分文件夹保存',
     placeholder: '~/memo/memotalk/raw',
   },
-  { key: 'import_dir', label: '导入目录', hint: '扫描导入时读取的本地目录', placeholder: '~/Downloads' },
-  { key: 'python_path', label: 'Python 解释器', hint: '留空时自动使用 Floatboat 内置 Python', placeholder: 'python' },
-  { key: 'ffmpeg_path', label: 'ffmpeg 路径', hint: '留空时使用 Floatboat 内置 ffmpeg；转录依赖它解码音频', placeholder: 'ffmpeg' },
+  {
+    key: 'import_dir',
+    label: '导入目录',
+    hint: '「录音 › 导入」从这个文件夹读取录音文件；留空使用默认文件夹',
+    placeholder: '~/memo/memotalk/inbox',
+  },
 ];
 
-const FLAG_FIELDS: Array<{ key: string; label: string; hint: string }> = [
-  { key: 'auto_transcribe', label: '拉取/导入后自动转录', hint: '新录音进库后立即排队识别，无需手动点「开始转录」' },
-  { key: 'auto_analyze', label: '转录后自动归类', hint: '转录完成立即调用 AI 生成摘要与分类' },
-  { key: 'auto_connect', label: '自动重连录音笔', hint: '工作台打开时定期静默探测，设备唤醒后自动接上；不唤醒已休眠的设备' },
+const AUTOMATION_FLAGS: Array<{ key: string; label: string; hint: string }> = [
+  { key: 'auto_transcribe', label: '新录音进库后自动转录', hint: '同步或导入完成后立即开始转录，不用手动点「开始转录」' },
+  { key: 'auto_analyze', label: '转录后自动 AI 归类', hint: '转录完成后自动生成标题、摘要与分类' },
+  { key: 'auto_connect', label: '自动连接录音笔', hint: '工作台打开时定期尝试连接，录音笔唤醒后自动接上；手动断开后会暂停' },
+  { key: 'auto_pull', label: '连上录音笔后自动同步新录音', hint: '点「连接」后直接开始同步；后台自动连接时只同步较小的录音' },
   {
-    key: 'auto_pull',
-    label: '连上后自动拉取',
-    hint: '连上设备即读清单并逐个下载待拉取录音；单轮最多 3 个文件、约 2.5 分钟预算',
+    key: 'auto_pull_wifi',
+    label: '后台自动同步大录音时也用无线快传（会暂时断开外网）',
+    hint: '默认关闭：后台不会切换电脑的网络，大录音留到你手动同步',
   },
-  { key: 'speaker_diarization', label: '启用说话人分离', hint: '让识别结果区分不同说话人；较长录音耗时略增' },
 ];
 
-const NUM_FIELDS: Array<{ key: string; label: string; hint: string; min: number; max: number }> = [
-  { key: 'auto_connect_minutes', label: '自动重连间隔（分钟）', hint: '每次探测约占用设备 10 秒；间隔越短越及时，也越耗电', min: 1, max: 120 },
+const RECOGNITION_FLAGS: Array<{ key: string; label: string; hint: string }> = [
+  { key: 'speaker_diarization', label: '区分说话人', hint: '识别结果区分不同说话人；较长录音耗时略增' },
 ];
 
-export function SettingsPage() {
+const DIAGNOSTIC_TEXT_KEYS = ['python_path', 'ffmpeg_path'];
+
+export function SettingsPage({ section }: { section?: 'diagnostics' }) {
   const toast = useToast();
   const state = useAsyncData<SettingEntry[]>(() => api.get<SettingEntry[]>('/api/settings'), 'settings');
   const [draft, setDraft] = useState<Record<string, string>>({});
   const [busy, setBusy] = useState(false);
 
-  useEffect(() => {
-    if (state.data) {
-      const next: Record<string, string> = {};
-      for (const entry of state.data) next[entry.key] = entry.value;
-      setDraft(next);
-    }
+  const saved = useMemo(() => {
+    const next: Record<string, string> = {};
+    for (const entry of state.data ?? []) next[entry.key] = entry.value;
+    return next;
   }, [state.data]);
 
-  if (state.loading && !state.data) return <Loading label="正在读取设置" />;
-  if (state.error) return <ErrorState message={state.error} onRetry={state.reload} />;
+  useEffect(() => {
+    setDraft(saved);
+  }, [saved]);
 
   const value = (key: string): string => draft[key] ?? '';
   const update = (key: string, next: string) => setDraft((current) => ({ ...current, [key]: next }));
+  const dirty = Object.keys(draft).some((key) => (draft[key] ?? '') !== (saved[key] ?? ''));
+
+  if (state.loading && !state.data) return <Loading label="正在读取设置" />;
+  if (state.error) return <ErrorState error={state.error} onRetry={state.reload} />;
 
   const save = async () => {
     setBusy(true);
     try {
       const values: Record<string, string> = {};
-      for (const field of TEXT_FIELDS) values[field.key] = value(field.key);
-      for (const field of FLAG_FIELDS) values[field.key] = value(field.key) === '1' ? '1' : '0';
-      for (const field of NUM_FIELDS) values[field.key] = value(field.key) || String(field.min);
+      for (const field of GENERAL_FIELDS) values[field.key] = value(field.key);
+      for (const key of DIAGNOSTIC_TEXT_KEYS) values[key] = value(key);
+      for (const field of [...AUTOMATION_FLAGS, ...RECOGNITION_FLAGS]) values[field.key] = value(field.key) === '1' ? '1' : '0';
+      values.auto_connect_minutes = value('auto_connect_minutes') || '3';
+      values.device_transport = value('device_transport') || 'auto';
       values.asr_hotwords = value('asr_hotwords');
       values.asr_language = value('asr_language');
       await api.patch('/api/settings', { values });
       toast.push('设置已保存', 'success');
       state.reload();
     } catch (error) {
-      toast.push(errorText(error), 'error');
+      toast.error(error);
     } finally {
       setBusy(false);
     }
   };
 
+  const flag = (field: { key: string; label: string; hint: string }, disabled = false) => (
+    <label key={field.key} className="switch switch--row">
+      <input
+        type="checkbox"
+        checked={value(field.key) === '1'}
+        disabled={disabled}
+        onChange={(event) => update(field.key, event.target.checked ? '1' : '0')}
+      />
+      <span>
+        <span className="switch__label">{field.label}</span>
+        <span className="switch__hint">{field.hint}</span>
+      </span>
+    </label>
+  );
+
   return (
     <div className="page page--settings">
       <header className="page__head">
         <div>
           <h1>设置</h1>
-          <p className="page__sub">这些设置只保存在本机应用数据里，不会上传任何凭据。</p>
+          <p className="page__sub">设置只保存在本机，不会上传任何凭据。</p>
         </div>
         <div className="page__actions">
-          <Button variant="primary" icon={<Save size={15} aria-hidden="true" />} disabled={busy} onClick={() => void save()}>
+          {dirty ? <span className="settings__dirty">有未保存的修改</span> : null}
+          <Button variant="primary" icon={<Save size={15} aria-hidden="true" />} disabled={busy || !dirty} onClick={() => void save()}>
             保存设置
           </Button>
         </div>
       </header>
 
       <div className="device-grid">
-        <Card title="路径">
-          {TEXT_FIELDS.map((field) => (
+        <Card title="通用">
+          {GENERAL_FIELDS.map((field) => (
             <Field key={field.key} label={field.label} hint={field.hint}>
               <input value={value(field.key)} placeholder={field.placeholder} onChange={(event) => update(field.key, event.target.value)} />
             </Field>
@@ -98,34 +125,23 @@ export function SettingsPage() {
         </Card>
 
         <Card title="自动化">
-          {FLAG_FIELDS.map((field) => (
-            <label key={field.key} className="switch switch--row">
-              <input
-                type="checkbox"
-                checked={value(field.key) === '1'}
-                onChange={(event) => update(field.key, event.target.checked ? '1' : '0')}
-              />
-              <span>
-                <span className="switch__label">{field.label}</span>
-                <span className="switch__hint">{field.hint}</span>
-              </span>
-            </label>
-          ))}
-          {NUM_FIELDS.map((field) => (
-            <Field key={field.key} label={field.label} hint={field.hint}>
-              <input
-                type="number"
-                min={field.min}
-                max={field.max}
-                value={value(field.key)}
-                disabled={value('auto_connect') !== '1'}
-                onChange={(event) => update(field.key, event.target.value)}
-              />
-            </Field>
-          ))}
+          {AUTOMATION_FLAGS.slice(0, 3).map((field) => flag(field))}
+          <Field label="自动连接间隔（分钟）" hint="间隔越短越及时，也越耗录音笔电量">
+            <input
+              type="number"
+              min={1}
+              max={120}
+              value={value('auto_connect_minutes')}
+              disabled={value('auto_connect') !== '1'}
+              onChange={(event) => update('auto_connect_minutes', event.target.value)}
+            />
+          </Field>
+          {flag(AUTOMATION_FLAGS[3])}
+          {flag(AUTOMATION_FLAGS[4], value('auto_pull') !== '1' || value('auto_connect') !== '1')}
         </Card>
 
         <Card title="识别">
+          {RECOGNITION_FLAGS.map((field) => flag(field))}
           <Field label="识别热词" hint="用逗号分隔，提升专有名词识别率">
             <input
               value={value('asr_hotwords')}
@@ -143,6 +159,8 @@ export function SettingsPage() {
           </Field>
         </Card>
       </div>
+
+      <DiagnosticsSection focus={section === 'diagnostics'} value={value} update={update} />
     </div>
   );
 }
diff --git a/src/ui/pages/settings/DiagnosticsSection.tsx b/src/ui/pages/settings/DiagnosticsSection.tsx
new file mode 100644
index 0000000..703127a
--- /dev/null
+++ b/src/ui/pages/settings/DiagnosticsSection.tsx
@@ -0,0 +1,220 @@
+// ABOUTME: 设置 › 诊断与高级：全应用唯一的技术细节区（本机环境、运行时路径、传输方式、设备操作记录、宿主能力、协议指令与开发者工具）。
+
+import { useEffect, useRef, useState } from 'react';
+import { Copy } from 'lucide-react';
+import type { DeviceCallRecord, DiagnosticsView, TransportSetting } from '../../../contracts/device';
+import { api } from '../../api';
+import { formatBytes, formatDateTime } from '../../format';
+import { useAsyncData } from '../../useApi';
+import { Button, ErrorState, Field, Loading, useToast } from '../../components/ui';
+import { EnvironmentPanel } from '../../components/EnvironmentPanel';
+import { SdkCommandTable } from '../../components/SdkCommandTable';
+import { ManifestTool } from './ManifestTool';
+
+interface Props {
+  focus: boolean;
+  value: (key: string) => string;
+  update: (key: string, next: string) => void;
+}
+
+const TRANSPORT_OPTIONS: Array<{ value: TransportSetting; label: string }> = [
+  { value: 'auto', label: '自动（推荐）' },
+  { value: 'wifi', label: '始终无线快传' },
+  { value: 'ble', label: '始终蓝牙' },
+];
+
+const OP_TEXT: Record<DeviceCallRecord['op'], string> = {
+  connect: '连接',
+  status: '读取状态',
+  list: '读取清单',
+  pull: '同步',
+  delete: '删除',
+  disconnect: '断开',
+  cancel: '停止',
+  live: '实时字幕',
+};
+
+const TRANSPORT_TEXT = { wifi: '无线快传', ble: '蓝牙' };
+
+function speed(bps: number | null): string {
+  return bps && bps > 0 ? `${formatBytes(bps)}/s` : '还没有测到';
+}
+
+function DeviceLogRow({ record }: { record: DeviceCallRecord }) {
+  const [open, setOpen] = useState(false);
+  return (
+    <li className={`devlog__row${record.ok ? '' : ' devlog__row--bad'}`}>
+      <span>{formatDateTime(record.at)}</span>
+      <span>{OP_TEXT[record.op] ?? record.op}</span>
+      <span>{record.origin === 'auto' ? '自动' : '手动'}</span>
+      <span>{record.ok ? '成功' : record.code ?? '失败'}</span>
+      <span>{record.transport ? TRANSPORT_TEXT[record.transport] : '—'}</span>
+      <span>{record.bytes ? formatBytes(record.bytes) : '—'}</span>
+      <span>{(record.durationMs / 1000).toFixed(1)} 秒</span>
+      {record.detail ? (
+        <button type="button" className="linkbtn" aria-expanded={open} onClick={() => setOpen((current) => !current)}>
+          详情
+        </button>
+      ) : (
+        <span />
+      )}
+      {open ? <pre className="errornotice__detail devlog__detail">{record.detail}</pre> : null}
+    </li>
+  );
+}
+
+function DiagnosticsBody({ value, update }: Omit<Props, 'focus'>) {
+  const toast = useToast();
+  const diagnostics = useAsyncData<DiagnosticsView>(() => api.get<DiagnosticsView>('/api/diagnostics'), 'diagnostics');
+  const data = diagnostics.data;
+
+  const copyReport = async () => {
+    if (!data) return;
+    try {
+      await navigator.clipboard.writeText(JSON.stringify({ ...data, commands: undefined }, null, 2));
+      toast.push('诊断报告已复制', 'success');
+    } catch {
+      toast.push('复制没有成功，请手动选择上面的内容', 'info');
+    }
+  };
+
+  return (
+    <div className="diag">
+      <section className="diag__section">
+        <h3>本机环境</h3>
+        <EnvironmentPanel />
+      </section>
+
+      <section className="diag__section">
+        <h3>运行时路径</h3>
+        <Field label="Python 解释器" hint="留空时自动使用 Floatboat 内置 Python；录音笔组件依赖它">
+          <input value={value('python_path')} placeholder="python" onChange={(event) => update('python_path', event.target.value)} />
+        </Field>
+        <Field label="ffmpeg 路径" hint="留空时使用 Floatboat 内置 ffmpeg；转录依赖它解码音频">
+          <input value={value('ffmpeg_path')} placeholder="ffmpeg" onChange={(event) => update('ffmpeg_path', event.target.value)} />
+        </Field>
+      </section>
+
+      <section className="diag__section">
+        <h3>传输方式</h3>
+        <Field label="同步录音时使用" hint="自动：较大的录音走无线快传（录音笔 Wi-Fi 热点 + FTP，期间电脑暂时断开外网），失败时改用蓝牙">
+          <select aria-label="传输方式" value={value('device_transport') || 'auto'} onChange={(event) => update('device_transport', event.target.value)}>
+            {TRANSPORT_OPTIONS.map((option) => (
+              <option key={option.value} value={option.value}>
+                {option.label}
+              </option>
+            ))}
+          </select>
+        </Field>
+        {data ? (
+          <dl className="meta">
+            <div>
+              <dt>无线网卡</dt>
+              <dd>{data.transport.wifiCapable ? '有' : '没有检测到'}（{data.transport.platform}）</dd>
+            </div>
+            <div>
+              <dt>无线快传阈值</dt>
+              <dd>本批合计 ≥ {formatBytes(data.transport.thresholdBytes)}</dd>
+            </div>
+            <div>
+              <dt>实测速度</dt>
+              <dd>无线快传 {speed(data.transport.measured.wifiBps)} · 蓝牙 {speed(data.transport.measured.bleBps)}</dd>
+            </div>
+          </dl>
+        ) : null}
+      </section>
+
+      {diagnostics.loading && !data ? <Loading label="正在读取诊断信息" /> : null}
+      {diagnostics.error ? <ErrorState error={diagnostics.error} onRetry={diagnostics.reload} /> : null}
+
+      {data ? (
+        <>
+          <section className="diag__section">
+            <div className="diag__head">
+              <h3>最近设备操作</h3>
+              <Button size="sm" variant="quiet" onClick={diagnostics.reload}>
+                刷新
+              </Button>
+            </div>
+            {data.deviceLog.length === 0 ? (
+              <p className="muted">这次启动后还没有设备操作。</p>
+            ) : (
+              <ul className="devlog">
+                <li className="devlog__row devlog__head">
+                  <span>时间</span>
+                  <span>操作</span>
+                  <span>来源</span>
+                  <span>结果</span>
+                  <span>传输</span>
+                  <span>字节</span>
+                  <span>耗时</span>
+                  <span />
+                </li>
+                {data.deviceLog.map((record, index) => (
+                  <DeviceLogRow key={`${record.at}-${index}`} record={record} />
+                ))}
+              </ul>
+            )}
+          </section>
+
+          <section className="diag__section">
+            <h3>宿主能力</h3>
+            <ul className="caplist">
+              {[...data.capabilities.asr.map((item) => ({ ...item, domain: '语音识别' })), ...data.capabilities.llm.map((item) => ({ ...item, domain: 'AI 整理' }))].map((item) => (
+                <li key={`${item.domain}-${item.operation}`}>
+                  <span>{item.domain}</span>
+                  <code>{item.operation}</code>
+                  <span className={item.status === 'available' ? 'caplist__ok' : 'muted'}>{item.status}</span>
+                  <span className="muted">{item.declared ? '已声明' : '未声明'}</span>
+                </li>
+              ))}
+            </ul>
+          </section>
+
+          <section className="diag__section">
+            <h3>设备协议指令参考（开发者）</h3>
+            <SdkCommandTable commands={data.commands} />
+          </section>
+
+          <section className="diag__section">
+            <h3>开发者工具</h3>
+            <ManifestTool />
+          </section>
+
+          <div className="card__actions">
+            <Button size="sm" icon={<Copy size={14} aria-hidden="true" />} onClick={() => void copyReport()}>
+              复制诊断报告
+            </Button>
+          </div>
+        </>
+      ) : null}
+    </div>
+  );
+}
+
+export function DiagnosticsSection({ focus, value, update }: Props) {
+  const ref = useRef<HTMLDetailsElement>(null);
+  const [open, setOpen] = useState(focus);
+
+  useEffect(() => {
+    if (!focus) return;
+    setOpen(true);
+    window.setTimeout(() => ref.current?.scrollIntoView({ block: 'start' }), 0);
+  }, [focus]);
+
+  return (
+    <details
+      id="diagnostics"
+      ref={ref}
+      className="card diagnostics"
+      open={open}
+      onToggle={(event) => setOpen(event.currentTarget.open)}
+    >
+      <summary className="diagnostics__summary">
+        <h2>诊断与高级</h2>
+        <span className="muted">本机环境、传输方式与设备操作记录，排查问题时再展开</span>
+      </summary>
+      <div className="card__body">{open ? <DiagnosticsBody value={value} update={update} /> : null}</div>
+    </details>
+  );
+}
diff --git a/src/ui/pages/settings/ManifestTool.tsx b/src/ui/pages/settings/ManifestTool.tsx
new file mode 100644
index 0000000..c7945ba
--- /dev/null
+++ b/src/ui/pages/settings/ManifestTool.tsx
@@ -0,0 +1,79 @@
+// ABOUTME: 开发者工具：手动登记录音笔文件清单（只在「设置 › 诊断与高级」里出现）。
+
+import { useState } from 'react';
+import { ClipboardList } from 'lucide-react';
+import type { ParsedDeviceFile } from '../../../contracts/device';
+import { api } from '../../api';
+import { Button, useToast } from '../../components/ui';
+
+export function parseManifestText(text: string): ParsedDeviceFile[] {
+  return text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [name, size, duration, timestamp] = line.split(/[,|\t ]+/);
+      return {
+        name: name ?? '',
+        format: 'MP3',
+        sizeBytes: Number(size) || null,
+        durationSec: Number(duration) || null,
+        timestamp: Number(timestamp) || null,
+      };
+    })
+    .filter((entry) => entry.name.length > 0);
+}
+
+export function ManifestTool() {
+  const toast = useToast();
+  const [serial, setSerial] = useState('');
+  const [text, setText] = useState('');
+  const [busy, setBusy] = useState(false);
+
+  const submit = async () => {
+    const entries = parseManifestText(text);
+    if (entries.length === 0) {
+      toast.push('请先粘贴文件清单，每行一个文件', 'info');
+      return;
+    }
+    setBusy(true);
+    try {
+      const result = await api.post<{ accepted: number; skipped: number }>('/api/ingest/manifest', {
+        serial: serial.trim() || 'MemoTalk-S1',
+        entries,
+      });
+      toast.push(`已登记 ${result.accepted} 条，跳过 ${result.skipped} 条`, 'success');
+      setText('');
+    } catch (error) {
+      toast.error(error);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="manifest-tool">
+      <p className="muted">手动登记清单（每行：文件名 大小 时长秒 时间戳），用于调试同步流程。</p>
+      <input
+        className="manifest-serial"
+        value={serial}
+        onChange={(event) => setSerial(event.target.value)}
+        placeholder="序列号（留空为 MemoTalk-S1）"
+        aria-label="清单序列号"
+      />
+      <textarea
+        className="manifest-input"
+        value={text}
+        onChange={(event) => setText(event.target.value)}
+        rows={4}
+        placeholder={'REC20261020_103000.mp3 1048576 65 1761000000\nREC20261020_114500.mp3 2097152 132 1761004500'}
+        aria-label="文件清单"
+      />
+      <div className="card__actions">
+        <Button size="sm" icon={<ClipboardList size={14} aria-hidden="true" />} disabled={busy} onClick={() => void submit()}>
+          登记清单
+        </Button>
+      </div>
+    </div>
+  );
+}
diff --git a/src/ui/router.ts b/src/ui/router.ts
new file mode 100644
index 0000000..1001a9b
--- /dev/null
+++ b/src/ui/router.ts
@@ -0,0 +1,86 @@
+// ABOUTME: 哈希路由的纯函数：解析、生成与侧栏高亮键；不依赖 window，便于单测。
+
+export type LibraryStage = 'pending' | 'ready' | 'transcribed' | 'done' | 'failed';
+
+export type Route =
+  | { name: 'library'; stage?: LibraryStage }
+  | { name: 'device' }
+  | { name: 'live' }
+  | { name: 'calendar'; day?: string; rec?: number }
+  | { name: 'categories' }
+  | { name: 'settings'; section?: 'diagnostics' }
+  | { name: 'detail'; id: number };
+
+export type NavKey = 'library' | 'device' | 'live' | 'calendar' | 'categories' | 'settings';
+
+const STAGES: readonly LibraryStage[] = ['pending', 'ready', 'transcribed', 'done', 'failed'];
+const DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+function positiveInt(raw: string | null): number | undefined {
+  if (!raw) return undefined;
+  const value = Number(raw);
+  return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+/** 未知或已移除的哈希（含 #/overview）返回 null，由调用方改写为 #/library。 */
+export function parseHash(hash: string): Route | null {
+  const raw = hash.replace(/^#\/?/, '');
+  const [path = '', query = ''] = raw.split('?', 2);
+  const params = new URLSearchParams(query);
+  if (path.startsWith('rec/')) {
+    const id = positiveInt(path.slice(4));
+    return id ? { name: 'detail', id } : null;
+  }
+  switch (path) {
+    case 'library': {
+      const stage = params.get('stage');
+      return STAGES.includes(stage as LibraryStage) ? { name: 'library', stage: stage as LibraryStage } : { name: 'library' };
+    }
+    case 'device':
+    case 'live':
+    case 'categories':
+      return { name: path };
+    case 'calendar': {
+      const day = params.get('day');
+      const rec = positiveInt(params.get('rec'));
+      return {
+        name: 'calendar',
+        ...(day && DAY_PATTERN.test(day) ? { day } : {}),
+        ...(rec ? { rec } : {}),
+      };
+    }
+    case 'settings':
+      return { name: 'settings' };
+    case 'settings/diagnostics':
+      return { name: 'settings', section: 'diagnostics' };
+    default:
+      return null;
+  }
+}
+
+export function buildHash(route: Route): string {
+  switch (route.name) {
+    case 'detail':
+      return `#/rec/${route.id}`;
+    case 'library':
+      return route.stage ? `#/library?stage=${route.stage}` : '#/library';
+    case 'calendar': {
+      const params = new URLSearchParams();
+      if (route.day) params.set('day', route.day);
+      if (route.rec) params.set('rec', String(route.rec));
+      const query = params.toString();
+      return query ? `#/calendar?${query}` : '#/calendar';
+    }
+    case 'settings':
+      return route.section ? `#/settings/${route.section}` : '#/settings';
+    default:
+      return `#/${route.name}`;
+  }
+}
+
+/** 详情页高亮「录音」，设置子路由高亮「设置」。 */
+export function navKey(route: Route): NavKey {
+  return route.name === 'detail' ? 'library' : route.name;
+}
+
+export const DEFAULT_ROUTE: Route = { name: 'library' };
diff --git a/src/ui/style.css b/src/ui/style.css
index 44be25e..2b27d57 100644
--- a/src/ui/style.css
+++ b/src/ui/style.css
@@ -288,29 +288,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
   to { transform: translate3d(18%, 6%, 0) scale(1.18); }
 }
 
-.devicehero__waves {
-  position: absolute;
-  right: 12%;
-  bottom: 14px;
-  display: flex;
-  align-items: flex-end;
-  gap: 4px;
-  height: 34px;
-  opacity: 0.16;
-  pointer-events: none;
-}
-.devicehero__waves span {
-  width: 3px;
-  border-radius: 2px;
-  background: var(--app-primary);
-  height: 30%;
-  animation: wave-breathe 2.4s ease-in-out infinite;
-}
-@keyframes wave-breathe {
-  0%, 100% { height: 18%; }
-  50% { height: 100%; }
-}
-
 .devicehero__meters { display: flex; gap: 14px; position: relative; z-index: 1; }
 
 .ring { position: relative; width: 96px; height: 96px; flex-shrink: 0; }
@@ -367,21 +344,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
 }
 .devicehero__meta code { font-size: 12px; color: var(--app-text); }
 .devicehero__meta span { display: inline-flex; align-items: center; gap: 4px; }
-.devicehero__queue { display: flex; gap: 14px; margin: 2px 0 0; font-size: 12.5px; flex-wrap: wrap; }
-.devicehero__link {
-  border: 0;
-  background: transparent;
-  padding: 0;
-  color: var(--app-primary);
-  font-size: 12.5px;
-  font-weight: 600;
-  border-bottom: 1px solid transparent;
-}
-.devicehero__link:hover { border-bottom-color: currentColor; }
-.devicehero__link:focus-visible { outline: 2px solid var(--app-primary); outline-offset: 2px; border-radius: 3px; }
-
-.devicehero__actions { position: relative; z-index: 1; display: flex; gap: 8px; flex-wrap: wrap; justify-content: flex-end; }
-
 .devicehero--off {
   grid-template-columns: minmax(0, 1fr) auto;
   border: 1px dashed var(--app-border);
@@ -405,8 +367,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
 @media (max-width: 900px) {
   .devicehero { grid-template-columns: minmax(0, 1fr); gap: 16px; }
   .devicehero--off { grid-template-columns: minmax(0, 1fr); }
-  .devicehero__actions { justify-content: flex-start; }
-  .devicehero__waves { display: none; }
 }
 
 @media (max-width: 480px) {
@@ -414,58 +374,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
   .ring { width: 84px; height: 84px; }
 }
 
-/* ---------------------------------------------------------------- 统计 */
-
-.stat-row { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; }
-.stat {
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-  padding: 14px 16px;
-  background: var(--app-surface);
-  border: 1px solid var(--app-border);
-  border-radius: var(--radius);
-  box-shadow: var(--shadow);
-}
-.stat__icon { color: var(--app-primary); }
-.stat__label { font-size: 12px; color: var(--app-muted); }
-.stat__value { font-size: 24px; line-height: 1.25; font-variant-numeric: tabular-nums; }
-.stat__hint { font-size: 11.5px; color: var(--app-muted); }
-
-.overview-grid { display: grid; grid-template-columns: minmax(0, 1.15fr) minmax(0, 1fr); gap: 14px; align-items: start; }
-
-.bars { display: flex; flex-direction: column; gap: 9px; }
-.bars__row {
-  display: grid;
-  grid-template-columns: 96px minmax(0, 1fr) 30px 68px;
-  align-items: center;
-  gap: 10px;
-  font-size: 12.5px;
-}
-.bars__name { display: inline-flex; align-items: center; gap: 6px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.bars__dot { width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0; }
-.bars__track { height: 7px; border-radius: 4px; background: var(--app-surface-2); overflow: hidden; }
-.bars__fill { display: block; height: 100%; border-radius: 4px; min-width: 2px; }
-.bars__value { text-align: right; font-variant-numeric: tabular-nums; font-weight: 600; }
-.bars__meta { text-align: right; color: var(--app-muted); font-variant-numeric: tabular-nums; }
-
-.recent { display: flex; flex-direction: column; }
-.recent__item {
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  width: 100%;
-  padding: 9px 8px;
-  border: 0;
-  border-radius: var(--radius-sm);
-  background: transparent;
-  text-align: left;
-}
-.recent__item:hover { background: var(--app-surface-2); }
-.recent__main { display: flex; flex-direction: column; gap: 1px; min-width: 0; flex: 1; }
-.recent__title { font-size: 13.5px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.recent__meta { font-size: 11.5px; color: var(--app-muted); }
-
 .notice {
   margin: 0;
   padding: 10px 12px;
@@ -664,20 +572,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
 .modal__body { padding: 16px; overflow: auto; }
 .modal__footer { display: flex; justify-content: flex-end; gap: 8px; padding: 12px 16px; border-top: 1px solid var(--app-border); }
 
-.devicestatus {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 9px 14px;
-  margin: 0;
-  padding: 10px 12px;
-  border-radius: var(--radius-sm);
-  background: var(--app-surface-2);
-  border: 1px solid var(--app-border);
-}
-.devicestatus > div { display: flex; flex-direction: column; gap: 1px; min-width: 0; }
-.devicestatus dt { font-size: 11px; color: var(--app-muted); }
-.devicestatus dd { margin: 0; font-size: 12.5px; font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
-
 .pulllist { display: flex; flex-direction: column; }
 .pulllist li {
   display: grid;
@@ -874,13 +768,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
 .env__state { text-align: right; color: var(--tone-danger); font-size: 11.5px; }
 .env__row--ok .env__state { color: var(--tone-success); }
 
-.bridge { display: flex; flex-direction: column; gap: 6px; }
-.bridge__msg { margin: 0; font-size: 12.5px; }
-.bridge__msg--bad { color: var(--tone-danger); }
-.bridge__cmd { display: flex; align-items: center; gap: 5px; margin: 0; font-size: 11.5px; color: var(--app-muted); font-family: ui-monospace, monospace; overflow-wrap: anywhere; }
-.bridge__raw summary { cursor: pointer; font-size: 12px; color: var(--app-muted); }
-.bridge__raw pre { margin: 6px 0 0; padding: 10px; max-height: 220px; overflow: auto; border-radius: var(--radius-sm); background: var(--app-surface-2); border: 1px solid var(--app-border); font-size: 11.5px; line-height: 1.6; white-space: pre-wrap; overflow-wrap: anywhere; }
-
 .manifest-input {
   width: 100%;
   padding: 9px 10px;
@@ -892,9 +779,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
   line-height: 1.6;
   resize: vertical;
 }
-.dirstate { font-size: 11.5px; padding: 2px 9px; border-radius: 999px; background: var(--app-surface-2); color: var(--app-muted); white-space: nowrap; }
-.dirstate--ok { background: var(--tone-success-soft); color: var(--tone-success); }
-.dirstate--idle { background: var(--tone-warn-soft); color: var(--tone-warn); }
 .pathrow { display: flex; align-items: flex-start; gap: 8px; }
 .pathrow__path {
   flex: 1; min-width: 0; padding: 7px 10px; border: 1px solid var(--app-border); border-radius: var(--radius-sm);
@@ -903,7 +787,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
 }
 .hintline { margin: 0; font-size: 12px; color: var(--app-muted); }
 .notice code { color: inherit; }
-.scanresult { display: flex; gap: 14px; font-size: 12.5px; color: var(--app-muted); }
 .scandetail { display: flex; flex-direction: column; gap: 3px; margin-top: 6px; font-size: 11.5px; max-height: 200px; overflow: auto; }
 .scandetail li { display: flex; justify-content: space-between; gap: 10px; }
 .scandetail--failed { color: var(--tone-danger); }
@@ -951,7 +834,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
 
 @media (max-width: 1080px) {
   .detail__grid { grid-template-columns: minmax(0, 1fr); }
-  .overview-grid { grid-template-columns: minmax(0, 1fr); }
   .table__head, .row { grid-template-columns: 34px minmax(0, 1fr) 104px 74px 92px 28px; }
   .col-tags { display: none; }
 }
@@ -963,7 +845,6 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
   .nav { flex-direction: row; gap: 2px; }
   .nav__item { padding: 6px 9px; font-size: 12.5px; flex: 0 0 auto; white-space: nowrap; }
   .main { padding: 18px 16px 48px; }
-  .stat-row { grid-template-columns: repeat(2, minmax(0, 1fr)); }
   .analysis__cols { grid-template-columns: minmax(0, 1fr); }
   .table__head, .row { grid-template-columns: 30px minmax(0, 1fr) 92px 28px; }
   .col-category, .col-duration { display: none; }
@@ -976,17 +857,12 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
 @media (max-width: 560px) {
   .sidebar { flex-direction: column; align-items: stretch; overflow: visible; }
   .nav { overflow-x: auto; min-width: 0; padding-bottom: 4px; }
-  .stat-row { grid-template-columns: minmax(0, 1fr); }
   .page__head { flex-direction: column; align-items: stretch; }
   .segments { gap: 8px; }
   .segment { grid-template-columns: minmax(44px, max-content) minmax(0, 1fr); }
   .search { flex-basis: 100%; }
 }
 
-@media (max-width: 560px) {
-  .devicestatus { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-}
-
 @media (prefers-reduced-motion: reduce) {
   *, *::before, *::after { animation-duration: 0.01ms !important; animation-iteration-count: 1 !important; transition-duration: 0.01ms !important; }
 }
@@ -1005,3 +881,171 @@ code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0
   .environment-panel .env__state { grid-column: 3; grid-row: 1; }
   .environment-panel .env__detail, .environment-panel .env__action { grid-column: 2 / -1; }
 }
+
+/* ---------------------------------------------------------------- 错误提示（两层） */
+
+.linkbtn {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: var(--app-primary);
+  font: inherit;
+  font-size: 12.5px;
+  font-weight: 600;
+  text-decoration: none;
+  cursor: pointer;
+}
+.linkbtn:hover { text-decoration: underline; }
+.linkbtn:focus-visible { outline: 2px solid var(--app-primary); outline-offset: 2px; border-radius: 3px; }
+
+.errornotice {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px 12px;
+  border-radius: var(--radius-sm);
+  font-size: 12.5px;
+}
+.errornotice--error { border: 1px solid color-mix(in srgb, var(--tone-danger) 30%, transparent); background: var(--tone-danger-soft); color: var(--tone-danger); }
+.errornotice--notice { border: 1px solid color-mix(in srgb, var(--tone-info) 25%, transparent); background: var(--tone-info-soft); color: var(--tone-info); }
+.errornotice__main { display: flex; align-items: flex-start; gap: 7px; flex-wrap: wrap; }
+.errornotice__main > svg { flex-shrink: 0; margin-top: 2px; }
+.errornotice__message { flex: 1; min-width: 12ch; overflow-wrap: anywhere; }
+.errornotice__actions { display: inline-flex; gap: 12px; flex-wrap: wrap; }
+.errornotice__more { display: flex; flex-direction: column; gap: 6px; }
+.errornotice__detail {
+  margin: 0;
+  padding: 9px 10px;
+  max-height: 240px;
+  overflow: auto;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--app-border);
+  background: var(--app-surface);
+  color: var(--app-text);
+  font-family: ui-monospace, monospace;
+  font-size: 11.5px;
+  line-height: 1.6;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+.errornotice__tools { display: flex; gap: 14px; flex-wrap: wrap; }
+.errorstate { padding: 14px 0; }
+.toast__link { margin-left: 6px; padding: 0; border: 0; background: transparent; color: inherit; font: inherit; font-weight: 600; text-decoration: underline; cursor: pointer; }
+.toast__close { margin-left: auto; padding: 0 2px; border: 0; background: transparent; color: inherit; cursor: pointer; }
+
+/* ---------------------------------------------------------------- 导航与页头 */
+
+.nav__dot { margin-left: auto; width: 7px; height: 7px; border-radius: 50%; background: var(--tone-danger); }
+.envbanner {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  padding: 9px 12px;
+  border-radius: var(--radius-sm);
+  background: var(--tone-warn-soft);
+  color: var(--tone-warn);
+  font-size: 12.5px;
+}
+.statsbar { display: flex; gap: 18px; flex-wrap: wrap; align-items: center; font-size: 12.5px; color: var(--app-muted); }
+.statsbar strong { color: var(--app-text); font-variant-numeric: tabular-nums; }
+.statsbar__failed { padding: 2px 9px; border: 1px solid color-mix(in srgb, var(--tone-danger) 30%, transparent); border-radius: 999px; background: var(--tone-danger-soft); color: var(--tone-danger); font-size: 12px; cursor: pointer; }
+.statsbar__failed strong { color: inherit; }
+.empty__desc a { color: var(--app-primary); font-weight: 600; }
+.settings__dirty { font-size: 12px; color: var(--tone-warn); }
+
+/* ---------------------------------------------------------------- 录音笔页 */
+
+.devicecard.devicehero--on { grid-template-columns: auto minmax(0, 1fr); align-items: start; }
+.devicecard__notice { grid-column: 1 / -1; }
+.devicecard__actions { display: flex; align-items: flex-start; gap: 8px; flex-wrap: wrap; margin-top: 6px; }
+.devicecard__primary { display: flex; flex-direction: column; gap: 4px; }
+.devicecard__hint { font-size: 11.5px; color: var(--app-muted); max-width: 32ch; }
+.devicecard__primary--off { align-items: flex-end; text-align: right; }
+@media (max-width: 900px) {
+  .devicecard__primary--off { align-items: flex-start; text-align: left; }
+}
+.pulllist__hint { margin: 8px 0 0; font-size: 12px; }
+.devicecard__progress { display: flex; flex-direction: column; gap: 6px; margin-top: 6px; max-width: 520px; }
+.devicecard__progresshead { display: flex; align-items: center; justify-content: space-between; gap: 10px; font-size: 13px; }
+.devicecard__phase { margin: 0; font-size: 12px; color: var(--app-muted); }
+.progressbar { height: 7px; border-radius: 4px; background: var(--app-surface-2); border: 1px solid var(--app-border); overflow: hidden; }
+.progressbar__fill { display: block; height: 100%; border-radius: 4px; background: var(--app-primary); transition: width 400ms ease; }
+.progressbar__fill--indeterminate { width: 35%; animation: progress-slide 1.4s ease-in-out infinite; }
+@keyframes progress-slide { from { transform: translateX(-100%); } to { transform: translateX(300%); } }
+.statusline { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; font-size: 12.5px; color: var(--app-muted); }
+.statusline__extra { flex-basis: 100%; }
+
+/* ---------------------------------------------------------------- 详情页 */
+
+.breadcrumb { display: inline-flex; align-items: center; gap: 6px; min-width: 0; font-size: 12.5px; color: var(--app-muted); }
+.breadcrumb a { color: var(--app-primary); text-decoration: none; }
+.breadcrumb [aria-current] { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 36ch; }
+.detail__ondevice { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; margin: 0; font-size: 12.5px; color: var(--app-muted); }
+.moremenu { position: relative; }
+.moremenu > summary { list-style: none; cursor: pointer; }
+.moremenu > summary::-webkit-details-marker { display: none; }
+.moremenu__list {
+  position: absolute;
+  right: 0;
+  top: calc(100% + 4px);
+  z-index: 20;
+  display: flex;
+  flex-direction: column;
+  min-width: 140px;
+  padding: 4px;
+  border: 1px solid var(--app-border);
+  border-radius: var(--radius-sm);
+  background: var(--app-surface);
+  box-shadow: var(--shadow);
+}
+.moremenu__list button { display: flex; align-items: center; gap: 7px; padding: 7px 9px; border: 0; border-radius: 4px; background: transparent; color: var(--app-text); font-size: 12.5px; text-align: left; cursor: pointer; }
+.moremenu__list button:hover:not(:disabled) { background: var(--app-surface-2); }
+.moremenu__list .moremenu__danger { color: var(--tone-danger); }
+.calendarlink { display: flex; flex-direction: column; gap: 4px; margin: 0; font-size: 12.5px; }
+.calendarlink p { margin: 0; }
+.calendarlink__event { display: flex; align-items: center; gap: 6px; }
+
+/* ---------------------------------------------------------------- 日历关联 */
+
+.eventlinker { margin-top: 6px; border-radius: var(--radius-sm); }
+.eventlinker--highlight { outline: 2px solid var(--app-primary); outline-offset: 3px; }
+.eventlinker__toggle { display: flex; align-items: center; gap: 6px; width: 100%; padding: 4px 2px; border: 0; background: transparent; color: var(--app-muted); font-size: 12px; text-align: left; cursor: pointer; }
+.eventlinker__cta { margin-left: auto; color: var(--app-primary); font-weight: 600; }
+.eventlinker__body { display: flex; flex-direction: column; gap: 8px; padding: 6px 0 4px 18px; font-size: 12px; }
+.eventlinker__suggestions { display: flex; flex-direction: column; gap: 6px; }
+.eventlinker__suggestions li { display: flex; flex-direction: column; gap: 2px; }
+.eventlinker__suggestions button { text-align: left; white-space: normal; height: auto; }
+.eventlinker__tools { display: flex; gap: 8px; flex-wrap: wrap; }
+.calendar-recording-button { color: inherit; text-decoration: none; }
+.calendar-results__error { display: flex; flex-direction: column; gap: 10px; }
+.importdialog__summary { margin: 8px 0 0; font-weight: 600; }
+
+/* ---------------------------------------------------------------- 诊断与高级 */
+
+.diagnostics { padding: 0; }
+.diagnostics__summary { display: flex; align-items: baseline; gap: 12px; flex-wrap: wrap; padding: 14px 18px; cursor: pointer; }
+.diagnostics__summary h2 { display: inline; font-size: 14.5px; }
+.diagnostics[open] .diagnostics__summary { border-bottom: 1px solid var(--app-border); }
+.diag { display: flex; flex-direction: column; gap: 22px; }
+.diag__section { display: flex; flex-direction: column; gap: 10px; min-width: 0; }
+.diag__section h3 { font-size: 13.5px; }
+.diag__head { display: flex; align-items: center; justify-content: space-between; gap: 10px; }
+.env__group h4 { margin: 6px 0 2px; font-size: 12px; color: var(--app-muted); font-weight: 600; }
+.env__detail .env__action { display: block; margin-top: 2px; color: var(--app-text); }
+.env__more { grid-column: 2 / -1; justify-self: start; font-size: 11.5px; }
+.env__pre { grid-column: 2 / -1; }
+.env__ids summary { cursor: pointer; font-size: 12px; color: var(--app-muted); }
+.devlog { display: flex; flex-direction: column; font-size: 12px; overflow-x: auto; }
+.devlog__row { display: grid; grid-template-columns: 128px 64px 40px minmax(70px, 1fr) 64px 64px 56px 36px; gap: 8px; padding: 6px 2px; border-bottom: 1px solid var(--app-border); align-items: center; min-width: 620px; }
+.devlog__head { color: var(--app-muted); font-size: 11.5px; }
+.devlog__row--bad { color: var(--tone-danger); }
+.devlog__detail { grid-column: 1 / -1; }
+.caplist { display: flex; flex-direction: column; gap: 4px; font-size: 12px; }
+.caplist li { display: grid; grid-template-columns: 72px minmax(0, 1fr) 90px 56px; gap: 8px; }
+.caplist__ok { color: var(--tone-success); }
+.manifest-tool { display: flex; flex-direction: column; gap: 8px; }
+.manifest-serial { height: 32px; padding: 0 9px; border: 1px solid var(--app-border); border-radius: var(--radius-sm); background: var(--app-surface-2); font-size: 12.5px; max-width: 260px; }
diff --git a/src/ui/useApi.ts b/src/ui/useApi.ts
index 4064a2e..dc88a01 100644
--- a/src/ui/useApi.ts
+++ b/src/ui/useApi.ts
@@ -1,11 +1,12 @@
 // ABOUTME: 页面数据加载与轮询的小型 hook，避免每个页面重复处理 loading/error。
 
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { errorText } from './api';
+import type { AppErrorView } from '../contracts/errors';
+import { toErrorView } from './api';
 
 export interface AsyncState<T> {
   data: T | null;
-  error: string | null;
+  error: AppErrorView | null;
   loading: boolean;
   reload: () => void;
 }
@@ -13,7 +14,7 @@ export interface AsyncState<T> {
 /** key 变化时重新加载；loader 通过 ref 保持最新，不重置定时器。 */
 export function useAsyncData<T>(loader: () => Promise<T>, key: string): AsyncState<T> {
   const [data, setData] = useState<T | null>(null);
-  const [error, setError] = useState<string | null>(null);
+  const [error, setError] = useState<AppErrorView | null>(null);
   const [loading, setLoading] = useState(true);
   const [nonce, setNonce] = useState(0);
   const loaderRef = useRef(loader);
@@ -32,7 +33,7 @@ export function useAsyncData<T>(loader: () => Promise<T>, key: string): AsyncSta
       })
       .catch((cause: unknown) => {
         if (disposed) return;
-        setError(errorText(cause));
+        setError(toErrorView(cause));
         setLoading(false);
       });
     return () => {
diff --git a/src/ui/useDevice.ts b/src/ui/useDevice.ts
new file mode 100644
index 0000000..d991c86
--- /dev/null
+++ b/src/ui/useDevice.ts
@@ -0,0 +1,117 @@
+// ABOUTME: 录音笔状态与动作的唯一 hook：设备写接口只从这里发出，录音笔页与实时字幕页共用。
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { DeviceLastResult, DeviceView } from '../contracts/device';
+import type { AppErrorView } from '../contracts/errors';
+import { api, toErrorView } from './api';
+
+export interface DeviceHook {
+  view: DeviceView | null;
+  /** 读取状态失败（应用服务没响应）；录音笔本身的失败在 view.lastError。 */
+  error: AppErrorView | null;
+  /** 正在提交的动作，用于按钮的禁用与「正在…」文案。 */
+  pending: 'connect' | 'disconnect' | 'sync' | 'pull' | 'cancel' | 'cleanup' | null;
+  connect: () => Promise<void>;
+  disconnect: () => Promise<void>;
+  sync: () => Promise<void>;
+  pull: (ids: number[]) => Promise<void>;
+  cancel: () => Promise<void>;
+  cleanup: () => Promise<void>;
+  reload: () => void;
+}
+
+interface Options {
+  /** 一次同步或清理结束时回调一次（按 jobId 去重）。 */
+  onFinished?: (result: DeviceLastResult) => void;
+  /** 动作提交失败（例如录音笔正忙）。 */
+  onError?: (error: unknown) => void;
+}
+
+const FAST_MS = 1500;
+const SLOW_MS = 8000;
+
+export function useDevice(options: Options = {}): DeviceHook {
+  const [view, setView] = useState<DeviceView | null>(null);
+  const [error, setError] = useState<AppErrorView | null>(null);
+  const [pending, setPending] = useState<DeviceHook['pending']>(null);
+  const [nonce, setNonce] = useState(0);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const seenJob = useRef<string | null | undefined>(undefined);
+
+  const accept = useCallback((next: DeviceView) => {
+    setView(next);
+    setError(null);
+    const finished = next.lastResult;
+    // 首次加载只记下已有结果，不重复提示上一次会话的同步。
+    if (seenJob.current === undefined) {
+      seenJob.current = finished?.jobId ?? null;
+      return;
+    }
+    if (finished && finished.jobId !== seenJob.current && !next.activity) {
+      seenJob.current = finished.jobId;
+      optionsRef.current.onFinished?.(finished);
+    }
+  }, []);
+
+  const reload = useCallback(() => setNonce((value) => value + 1), []);
+
+  const state = view?.connection.state;
+  const fast = state === 'connecting' || state === 'busy' || Boolean(view?.activity) || pending !== null;
+
+  useEffect(() => {
+    let disposed = false;
+    let timer: number | undefined;
+    const tick = async () => {
+      if (!document.hidden) {
+        try {
+          const next = await api.get<DeviceView>('/api/device');
+          if (!disposed) accept(next);
+        } catch (cause) {
+          if (!disposed) setError(toErrorView(cause));
+        }
+      }
+      if (!disposed) timer = window.setTimeout(() => void tick(), fast ? FAST_MS : SLOW_MS);
+    };
+    void tick();
+    const onVisible = () => {
+      if (!document.hidden) reload();
+    };
+    document.addEventListener('visibilitychange', onVisible);
+    return () => {
+      disposed = true;
+      window.clearTimeout(timer);
+      document.removeEventListener('visibilitychange', onVisible);
+    };
+  }, [accept, fast, nonce, reload]);
+
+  const perform = useCallback(
+    async (kind: NonNullable<DeviceHook['pending']>, task: () => Promise<DeviceView | { jobId: string }>) => {
+      setPending(kind);
+      try {
+        const result = await task();
+        if ('connection' in result) accept(result);
+        else reload();
+      } catch (cause) {
+        optionsRef.current.onError?.(cause);
+        reload();
+      } finally {
+        setPending(null);
+      }
+    },
+    [accept, reload],
+  );
+
+  return {
+    view,
+    error,
+    pending,
+    connect: () => perform('connect', () => api.post<DeviceView>('/api/device/connect')),
+    disconnect: () => perform('disconnect', () => api.post<DeviceView>('/api/device/disconnect')),
+    sync: () => perform('sync', () => api.post<{ jobId: string }>('/api/device/sync')),
+    pull: (ids: number[]) => perform('pull', () => api.post<{ jobId: string }>('/api/device/pull', { ids })),
+    cancel: () => perform('cancel', () => api.post<DeviceView>('/api/device/cancel')),
+    cleanup: () => perform('cleanup', () => api.post<{ jobId: string }>('/api/device/cleanup')),
+    reload,
+  };
+}
diff --git a/tests/calendar-routes.test.ts b/tests/calendar-routes.test.ts
index 0cd605d..f63adb0 100644
--- a/tests/calendar-routes.test.ts
+++ b/tests/calendar-routes.test.ts
@@ -42,15 +42,19 @@ test('calendar HTTP import, range, creation, linking, detail and Host error enve
     assert.equal(manual.data.summary, '手动归档');
     app.database.exec("INSERT INTO recordings(id,filename,dedupe_key,recorded_at) VALUES (1,'test.mp3','test','2026-10-29T00:15:00.000Z')");
     assert.equal((await request('/api/recordings/1/calendar-suggestions')).data[0].event.id, id);
-    assert.equal((await request('/api/recordings/1', 'PUT', { calendar_event_id: 'bad' })).code, 'INVALID_INPUT');
-    assert.equal((await request('/api/recordings/1', 'PUT', { calendar_event_id: 999 })).code, 'NOT_FOUND');
-    assert.equal((await request('/api/recordings/1', 'PUT', { calendar_event_id: id })).data.recording.calendarEventId, id);
+    assert.equal((await request('/api/recordings/1', 'PATCH', { calendarEventId: 'bad' })).code, 'INVALID_INPUT');
+    assert.equal((await request('/api/recordings/1', 'PATCH', { calendarEventId: 999 })).code, 'NOT_FOUND');
+    assert.equal((await request('/api/recordings/1', 'PATCH', { calendarEventId: null })).data.recording.calendarEventId, null);
+    assert.equal((await request('/api/recordings/1', 'PATCH', { calendarEventId: id })).data.recording.calendarEventId, id);
+    // The legacy PUT alias is gone: one write path per resource.
+    const legacy = await fetch(`${url}/api/recordings/1`, { method: 'PUT', headers: { 'content-type': 'application/json' }, body: '{}' });
+    assert.equal(legacy.status, 404);
     assert.equal((await request('/api/recordings/1')).data.recording.calendarEventId, id);
     assert.equal((await request(`/api/calendar/events/${id}/recordings`)).data.length, 1);
     assert.equal((await request(`/api/calendar/recordings${range}`)).data.length, 1);
     assert.equal((await request(`/api/calendar/events/${id}/digest`)).data.digest, null);
-    assert.match((await request(`/api/calendar/events/${id}/digest`, 'POST', {})).error, /LLM 不可用/);
-    assert.equal((await request('/api/recordings/1', 'PUT', { calendar_event_id: null })).data.recording.calendarEventId, null);
+    assert.match((await request(`/api/calendar/events/${id}/digest`, 'POST', {})).error, /AI 整理暂不可用/);
+    assert.equal((await request('/api/recordings/1', 'PATCH', { calendarEventId: null })).data.recording.calendarEventId, null);
     assert.equal((await request('/api/calendar/events/999/digest')).code, 'NOT_FOUND');
   } finally {
     await close?.();
diff --git a/tests/calendar.test.ts b/tests/calendar.test.ts
index 33ed6a1..2eb8643 100644
--- a/tests/calendar.test.ts
+++ b/tests/calendar.test.ts
@@ -158,7 +158,7 @@ test('standalone Host reports LLM unavailable without storing a fake digest', as
   using db = database();
   const event = importCalendarFile(db, fixture, 'sample.ics').events[0];
   db.prepare("INSERT INTO recordings(filename,dedupe_key,calendar_event_id) VALUES ('a','a',?)").run(event.id);
-  await assert.rejects(() => generateEventDigest(db, createHostClient(null), event.id), /LLM 不可用/);
+  await assert.rejects(() => generateEventDigest(db, createHostClient(null), event.id), /AI 整理暂不可用/);
   assert.equal(getCalendarEvent(db, event.id).digest, null);
 });
 
diff --git a/tests/device-errors.test.ts b/tests/device-errors.test.ts
new file mode 100644
index 0000000..3d14dd8
--- /dev/null
+++ b/tests/device-errors.test.ts
@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { AppError, ERROR_COPY } from '../src/contracts/errors.ts';
+import { classifyDeviceError } from '../src/server/device/errors.ts';
+
+const cases: Array<[kind: string, message: string, op: string, code: string]> = [
+  ['DeviceNotFound', 'no MemoTalk S1 advertising nearby', 'connect', 'DEVICE_NOT_FOUND'],
+  ['BleakDeviceNotFoundError', 'Device with address AA:BB was not found', 'connect', 'DEVICE_NOT_FOUND'],
+  ['ConnectionLost', 'peer disconnected', 'status', 'DEVICE_DISCONNECTED'],
+  ['TransportError', 'write failed', 'list', 'DEVICE_DISCONNECTED'],
+  ['MemoTalkTimeout', 'no response to 0x84 within 5s', 'status', 'DEVICE_TIMEOUT'],
+  ['RecordingRejected', 'device is recording', 'pull', 'DEVICE_RECORDING'],
+  ['OperationForbidden', 'busy recording', 'delete', 'DEVICE_RECORDING'],
+  ['FileNotFoundOnDevice', 'REC001.mp3', 'pull', 'FILE_NOT_ON_DEVICE'],
+  ['DeleteFailed', 'REC001.mp3 status=0x02', 'delete', 'DELETE_FAILED'],
+  ['ProtocolError', 'unexpected frame', 'pull', 'TRANSFER_FAILED'],
+  ['ProtocolError', 'unexpected frame', 'status', 'DEVICE_ERROR'],
+  ['CrcError', 'crc mismatch', 'pull', 'TRANSFER_FAILED'],
+  ['CrcError', 'crc mismatch', 'list', 'DEVICE_ERROR'],
+  ['BleakError', 'Bluetooth device is turned off', 'connect', 'BLUETOOTH_UNAVAILABLE'],
+  ['BleakError', 'No Bluetooth adapter found', 'connect', 'BLUETOOTH_UNAVAILABLE'],
+  ['BleakError', 'Bluetooth radio not powered', 'pull', 'BLUETOOTH_UNAVAILABLE'],
+  ['BleakError', 'GATT write failed', 'pull', 'TRANSFER_FAILED'],
+  ['BleakError', 'GATT write failed', 'status', 'DEVICE_ERROR'],
+  ['ModuleNotFoundError', "No module named 'memotalk'", 'connect', 'RUNTIME_MISSING'],
+  ['ImportError', 'cannot import name MemoTalkClient', 'connect', 'RUNTIME_MISSING'],
+  ['DeviceRejected', 'hotspot enable rejected', 'status', 'DEVICE_ERROR'],
+  ['DeviceErrorResponse', 'error 0x05', 'list', 'DEVICE_ERROR'],
+  ['InvalidParameter', 'bad name', 'delete', 'DEVICE_ERROR'],
+  ['RuntimeError', 'boom', 'pull', 'TRANSFER_FAILED'],
+  ['RuntimeError', 'boom', 'connect', 'DEVICE_ERROR'],
+];
+
+test('every device SDK exception kind maps to a Chinese headline with the original text in detail', () => {
+  for (const [kind, message, op, code] of cases) {
+    const error = classifyDeviceError(kind, message, op);
+    assert.ok(error instanceof AppError);
+    assert.equal(error.code, code, `${kind} (${op})`);
+    assert.equal(error.message, ERROR_COPY[code].message, `${kind} headline`);
+    // The headline never leaks English exception names or the raw message.
+    assert.doesNotMatch(error.message, /[A-Za-z]{4,}Error|DeviceNotFound|ConnectionLost|Bleak|0x/, `${kind} headline`);
+    assert.ok(error.detail?.startsWith(`${kind}: ${message}`), `${kind} detail`);
+    assert.match(error.detail ?? '', new RegExp(`\\[op=${op} exit=-\\]`));
+  }
+});
+
+test('detail carries the exit code and stderr tail; runtime errors point to diagnostics', () => {
+  const error = classifyDeviceError('ModuleNotFoundError', "No module named 'bleak'", {
+    op: 'connect', exitCode: 1, stderrTail: 'Traceback (most recent call last):\n  ...\n',
+  });
+  assert.equal(error.code, 'RUNTIME_MISSING');
+  assert.match(error.detail ?? '', /\[op=connect exit=1\]/);
+  assert.match(error.detail ?? '', /Traceback/);
+  assert.deepEqual(error.action, { label: '去诊断与修复', href: '#/settings/diagnostics' });
+  assert.equal(error.toView().code, 'RUNTIME_MISSING');
+  assert.equal(classifyDeviceError('DeviceNotFound', 'x', 'connect').action, undefined);
+});
diff --git a/tests/device-routes.test.ts b/tests/device-routes.test.ts
new file mode 100644
index 0000000..e73c22b
--- /dev/null
+++ b/tests/device-routes.test.ts
@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { DeviceService } from '../src/server/device/service.ts';
+import { NetworkGate } from '../src/server/network-gate.ts';
+import type { appPreflight } from '../src/server/preflight.ts';
+import { registerDeviceRoutes } from '../src/server/routes/device.ts';
+import { registerDiagnosticsRoutes } from '../src/server/routes/diagnostics.ts';
+import { registerIngestRoutes } from '../src/server/routes/ingest.ts';
+import { registerRecordingRoutes } from '../src/server/routes/recordings.ts';
+import { registerSettingRoutes } from '../src/server/routes/settings.ts';
+import { readSetting, writeSetting } from '../src/server/sql.ts';
+import { createTestApp, FakeDevice, MiB, waitFor } from './support/device-fixture.ts';
+
+// 诊断路由会探测无线网卡；假设备模式下直接返回 true，不派生 netsh/nmcli。
+process.env.OPENMINUTES_FAKE_DEVICE = 'wifi';
+
+type Preflight = ReturnType<typeof appPreflight>;
+
+function stubPreflight(failCount: number): Preflight {
+  const report = {
+    checkedAt: new Date().toISOString(),
+    items: Array.from({ length: failCount }, (_, index) => ({
+      id: `fail-${index}`, label: '录音笔组件', group: 'device', status: 'fail', reason: '未安装', detail: 'uv pip install memotalk-sdk', autoRepair: false, action: '',
+    })),
+  };
+  return { get: async () => ({ report }), peek: () => ({ report }) } as unknown as Preflight;
+}
+
+test('device HTTP API: one route per task, Chinese failures with detail, removed routes are gone', async () => {
+  const t = await createTestApp('device-routes');
+  const device = new FakeDevice({ files: [{ name: 'REC20261103_090000.mp3', sizeBytes: 2 * MiB }, { name: 'REC20261103_100000.mp3', sizeBytes: 64 * 1024 }] });
+  const service = new DeviceService(t.app, {
+    resolvePython: async () => 'python',
+    spawnWorker: device.spawn,
+    platform: 'win32',
+    env: { OPENMINUTES_FAKE_DEVICE: 'wifi' },
+    gate: new NetworkGate(),
+  });
+  const preflight = stubPreflight(1);
+  registerDeviceRoutes(t.app, service, preflight);
+  registerDiagnosticsRoutes(t.app, service, preflight);
+  registerIngestRoutes(t.app);
+  registerRecordingRoutes(t.app);
+  registerSettingRoutes(t.app);
+  writeSetting(t.app.database, 'auto_pull', '1');
+  try {
+    const { url } = await t.app.listen();
+    const request = async (route: string, method = 'GET', body?: unknown) => {
+      const response = await fetch(`${url}${route}`, {
+        method, headers: { 'content-type': 'application/json', connection: 'close' },
+        body: body === undefined ? undefined : JSON.stringify(body),
+      });
+      return { status: response.status, json: response.status === 404 ? null : await response.json() };
+    };
+    const get = async (route: string) => (await request(route)).json;
+    const post = async (route: string, body: unknown = {}) => (await request(route, 'POST', body)).json;
+
+    const idle = await get('/api/device');
+    assert.equal(idle.ok, true);
+    assert.equal(idle.data.connection.state, 'disconnected');
+    assert.deepEqual(idle.data.environment, { failCount: 1 });
+    assert.equal(device.spawns.length, 0, 'polling never spawns a worker');
+
+    // One click: connecting also syncs because auto_pull is on.
+    const connected = await post('/api/device/connect');
+    assert.equal(connected.ok, true);
+    assert.ok(['connected', 'busy'].includes(connected.data.connection.state));
+    await waitFor(() => service.view().lastResult !== null, 15_000);
+    const synced = (await get('/api/device')).data;
+    assert.equal(synced.lastResult.done, 2);
+    assert.equal(synced.lastResult.transport, 'wifi');
+    assert.equal(synced.cleanable.count, 2);
+
+    const pullBad = await post('/api/device/pull', { ids: [] });
+    assert.equal(pullBad.ok, false);
+    assert.equal(pullBad.code, 'INVALID_INPUT');
+    assert.equal((await post('/api/device/pull', { ids: ['x'] })).code, 'INVALID_INPUT');
+
+    const cleanup = await post('/api/device/cleanup');
+    assert.equal(cleanup.ok, true);
+    assert.equal(typeof cleanup.data.jobId, 'string');
+    await waitFor(() => service.view().lastResult?.kind === 'cleanup');
+    assert.equal((await get('/api/device')).data.cleanable.count, 0);
+
+    const sync = await post('/api/device/sync');
+    assert.equal(typeof sync.data.jobId, 'string');
+    await waitFor(() => service.view().activity === null);
+    assert.equal((await post('/api/device/cancel')).data.activity, null);
+
+    const diagnostics = (await get('/api/diagnostics')).data;
+    assert.ok(diagnostics.deviceLog.some((record: { op: string; transport: string }) => record.op === 'pull' && record.transport === 'wifi'));
+    assert.equal(diagnostics.transport.setting, 'auto');
+    assert.equal(diagnostics.transport.thresholdBytes, MiB);
+    assert.equal(diagnostics.transport.wifiCapable, true);
+    assert.ok(diagnostics.transport.measured.wifiBps > 0);
+    assert.ok(Array.isArray(diagnostics.commands));
+    // Newest entries first.
+    assert.ok(diagnostics.deviceLog[0].at >= diagnostics.deviceLog.at(-1).at);
+
+    const disconnected = await post('/api/device/disconnect');
+    assert.equal(disconnected.data.connection.state, 'disconnected');
+    assert.equal(disconnected.data.connection.userDisconnected, true);
+
+    // Transport override and background Wi-Fi are validated settings; the pause flag is not writable.
+    const settings = await request('/api/settings', 'PATCH', { values: { device_transport: 'ble', auto_pull_wifi: '1' } });
+    assert.equal(settings.json.ok, true);
+    assert.equal(readSetting(t.app.database, 'device_transport'), 'ble');
+    assert.equal((await request('/api/settings', 'PATCH', { values: { device_transport: 'ftp' } })).json.code, 'INVALID_INPUT');
+    assert.equal((await request('/api/settings', 'PATCH', { values: { device_user_disconnected: '0' } })).json.code, 'UNKNOWN_SETTING');
+    assert.equal(readSetting(t.app.database, 'device_user_disconnected'), '1');
+
+    for (const [method, route] of [
+      ['POST', '/api/device/status'], ['POST', '/api/device/list'], ['POST', '/api/device/download'], ['POST', '/api/device/check'],
+      ['GET', '/api/device/capabilities'], ['GET', '/api/device/summary'], ['DELETE', '/api/device/1'],
+      ['POST', '/api/ingest/directory/ensure'], ['PUT', '/api/recordings/1'],
+    ] as const) {
+      assert.equal((await request(route, method, method === 'GET' || method === 'DELETE' ? undefined : {})).status, 404, `${method} ${route}`);
+    }
+  } finally {
+    await service.disconnect({ reason: 'user' }).catch(() => undefined);
+    await t.close();
+  }
+});
+
+test('a missing pen yields a Chinese headline; the SDK exception is only in detail', async () => {
+  const t = await createTestApp('device-routes');
+  const device = new FakeDevice({ connectError: { kind: 'DeviceNotFound', message: 'no MemoTalk S1 advertising nearby' } });
+  const service = new DeviceService(t.app, { resolvePython: async () => 'python', spawnWorker: device.spawn, env: { OPENMINUTES_FAKE_DEVICE: 'absent' } });
+  registerDeviceRoutes(t.app, service, stubPreflight(0));
+  try {
+    const { url } = await t.app.listen();
+    const response = await fetch(`${url}/api/device/connect`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' });
+    const body = await response.json();
+    assert.equal(body.ok, false);
+    assert.equal(body.code, 'DEVICE_NOT_FOUND');
+    assert.match(body.error, /没有找到录音笔/);
+    assert.doesNotMatch(body.error, /DeviceNotFound/);
+    assert.match(body.detail, /DeviceNotFound: no MemoTalk S1/);
+    // The same error stays on the view for the page to show after polling.
+    const view = await (await fetch(`${url}/api/device`)).json();
+    assert.equal(view.data.lastError.code, 'DEVICE_NOT_FOUND');
+    assert.equal(view.data.connection.state, 'disconnected');
+  } finally {
+    await t.close();
+  }
+});
diff --git a/tests/device-service.test.ts b/tests/device-service.test.ts
new file mode 100644
index 0000000..de8a0d9
--- /dev/null
+++ b/tests/device-service.test.ts
@@ -0,0 +1,615 @@
+import assert from 'node:assert/strict';
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { test } from 'node:test';
+import { AppError } from '../src/contracts/errors.ts';
+import { autoConnectTick } from '../src/server/device/auto-connect.ts';
+import { DeviceService } from '../src/server/device/service.ts';
+import { NetworkGate } from '../src/server/network-gate.ts';
+import { readSetting, row, writeSetting } from '../src/server/sql.ts';
+import { createTestApp, FakeDevice, MiB, SERIAL, waitFor, type FakeDeviceOptions, type TestApp } from './support/device-fixture.ts';
+
+const FILES = [
+  { name: 'REC20261102_090000.mp3', sizeBytes: 2 * MiB },
+  { name: 'REC20261102_100000.mp3', sizeBytes: Math.round(1.5 * MiB) },
+  { name: 'REC20261102_110000.mp3', sizeBytes: 200 * 1024 },
+];
+
+interface Harness {
+  t: TestApp;
+  device: FakeDevice;
+  service: DeviceService;
+}
+
+async function harness(options: FakeDeviceOptions = {}, settings: Record<string, string> = {}, idleDisconnectMs?: number): Promise<Harness> {
+  const t = await createTestApp('device-service');
+  writeSetting(t.app.database, 'auto_pull', '0');
+  for (const [key, value] of Object.entries(settings)) writeSetting(t.app.database, key, value);
+  const device = new FakeDevice({ files: FILES, ...options });
+  const gate = new NetworkGate();
+  device.isOffline = () => gate.isOffline();
+  const service = new DeviceService(t.app, {
+    resolvePython: async () => 'python',
+    spawnWorker: device.spawn,
+    platform: 'win32',
+    env: { OPENMINUTES_FAKE_DEVICE: 'wifi' },
+    gate,
+    idleDisconnectMs,
+  });
+  return { t, device, service };
+}
+
+async function finish(h: Harness): Promise<void> {
+  if (h.service.view().connection.state !== 'live') await h.service.disconnect({ reason: 'user' }).catch(() => undefined);
+  await h.t.close();
+}
+
+const isCode = (code: string) => (error: unknown) => error instanceof AppError && error.code === code;
+
+test('connect is idempotent, remembers the device and logs a closed hotspot residue', async () => {
+  const h = await harness({ hotspotWasOn: true });
+  try {
+    const [first, second] = await Promise.all([h.service.connect({ origin: 'user' }), h.service.connect({ origin: 'user' })]);
+    assert.equal(h.device.spawns.length, 1);
+    assert.equal(first.connection.state, 'connected');
+    assert.equal(second.connection.state, 'connected');
+    assert.equal((await h.service.connect({ origin: 'user' })).connection.state, 'connected');
+    assert.equal(h.device.spawns.length, 1);
+    assert.deepEqual(h.device.commands(), ['connect', 'status']);
+
+    const view = h.service.view();
+    assert.equal(view.connection.origin, 'user');
+    assert.equal(view.device?.serial, SERIAL);
+    assert.equal(view.device?.batteryPct, 80);
+    assert.ok(view.connection.idleDisconnectAt);
+    const stored = row(h.t.app.database, 'SELECT ble_address FROM devices WHERE serial = ?', [SERIAL]);
+    assert.equal(stored?.ble_address, 'AA:BB:CC:DD:EE:FF');
+    assert.equal(readSetting(h.t.app.database, 'device_serial'), SERIAL);
+    assert.ok(h.service.logSnapshot().some((record) => record.code === 'HOTSPOT_RESIDUE_CLOSED'));
+
+    // The remembered address is preferred on the next connection.
+    await h.service.disconnect({ reason: 'user' });
+    await h.service.connect({ origin: 'user' });
+    assert.equal(h.device.spawns[1].prefer, 'AA:BB:CC:DD:EE:FF');
+  } finally {
+    await finish(h);
+  }
+});
+
+test('a failed connection maps to a Chinese error and keeps the SDK text in detail', async () => {
+  const h = await harness({ connectError: { kind: 'DeviceNotFound', message: 'no MemoTalk S1 advertising nearby' } });
+  try {
+    await assert.rejects(h.service.connect({ origin: 'user' }), isCode('DEVICE_NOT_FOUND'));
+    const view = h.service.view();
+    assert.equal(view.connection.state, 'disconnected');
+    assert.equal(view.lastError?.code, 'DEVICE_NOT_FOUND');
+    assert.match(view.lastError?.message ?? '', /没有找到录音笔/);
+    assert.doesNotMatch(view.lastError?.message ?? '', /DeviceNotFound/);
+    assert.match(view.lastError?.detail ?? '', /DeviceNotFound: no MemoTalk S1/);
+    assert.ok(h.device.workers[0].exited, 'the worker is shut down after a failed connect');
+  } finally {
+    await finish(h);
+  }
+});
+
+test('missing Python fails fast with RUNTIME_MISSING and never spawns a worker', async () => {
+  const t = await createTestApp('device-service');
+  const device = new FakeDevice({ files: FILES });
+  const service = new DeviceService(t.app, { resolvePython: async () => null, spawnWorker: device.spawn, env: { OPENMINUTES_FAKE_DEVICE: 'wifi' } });
+  try {
+    await assert.rejects(service.connect({ origin: 'user' }), isCode('RUNTIME_MISSING'));
+    assert.equal(device.spawns.length, 0);
+    assert.equal(service.view().lastError?.action?.href, '#/settings/diagnostics');
+  } finally {
+    await t.close();
+  }
+});
+
+test('one click: a user connect with auto_pull=1 syncs everything right away', async () => {
+  const h = await harness({}, { auto_pull: '1' });
+  try {
+    await h.service.connect({ origin: 'user' });
+    await waitFor(() => h.service.view().lastResult !== null, 15_000);
+    const view = h.service.view();
+    assert.equal(view.lastResult?.kind, 'sync');
+    assert.equal(view.lastResult?.origin, 'user');
+    assert.equal(view.lastResult?.done, 3);
+    assert.equal(view.lastResult?.transport, 'wifi');
+    assert.equal(view.connection.state, 'connected');
+    assert.deepEqual(h.device.commands().filter((cmd) => cmd === 'pull'), ['pull']);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('a user disconnect pauses auto-connect until the user connects again', async () => {
+  const h = await harness({}, { auto_connect: '1' });
+  try {
+    await h.service.connect({ origin: 'user' });
+    const view = await h.service.disconnect({ reason: 'user' });
+    assert.equal(view.connection.state, 'disconnected');
+    assert.equal(view.connection.disconnectReason, 'user');
+    assert.equal(view.connection.userDisconnected, true);
+    assert.equal(readSetting(h.t.app.database, 'device_user_disconnected'), '1');
+    assert.ok(h.device.workers[0].exited);
+    assert.ok(h.device.commands().includes('disconnect'));
+
+    const state = { nextAttemptAt: 0, running: false };
+    assert.equal(await autoConnectTick({ db: h.t.app.database, service: h.service }, state), false);
+    assert.equal(h.device.spawns.length, 1, 'no automatic reconnect after a manual disconnect');
+
+    await h.service.connect({ origin: 'user' });
+    assert.equal(h.service.view().connection.userDisconnected, false);
+    await h.service.disconnect({ reason: 'idle' });
+    assert.equal(readSetting(h.t.app.database, 'device_user_disconnected'), '0', 'only a user disconnect pauses auto-connect');
+    assert.equal(await autoConnectTick({ db: h.t.app.database, service: h.service }, state), true);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('a user session disconnects itself after the idle window, without an error', async () => {
+  const h = await harness({}, {}, 60);
+  try {
+    await h.service.connect({ origin: 'user' });
+    await waitFor(() => h.service.view().connection.state === 'disconnected');
+    const view = h.service.view();
+    assert.equal(view.connection.disconnectReason, 'idle');
+    assert.equal(view.connection.userDisconnected, false);
+    assert.equal(view.lastError, null);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('the background session syncs small files over BLE, defers large ones and disconnects when done', async () => {
+  const h = await harness({}, { auto_connect: '1', auto_pull: '1', auto_pull_wifi: '0' });
+  try {
+    const state = { nextAttemptAt: 0, running: false };
+    let now = 1_000_000;
+    const deps = { db: h.t.app.database, service: h.service, now: () => now };
+    assert.equal(await autoConnectTick(deps, state), true);
+    // 断开过程中不能出现「已休眠」之类的中间原因。
+    const reasons = new Set<string | null>();
+    await waitFor(() => {
+      const current = h.service.view().connection;
+      if (current.state === 'disconnected') reasons.add(current.disconnectReason);
+      return current.state === 'disconnected' && current.disconnectReason === 'auto-done';
+    });
+    assert.deepEqual([...reasons], ['auto-done']);
+    const view = h.service.view();
+    assert.equal(view.connection.disconnectReason, 'auto-done');
+    assert.equal(view.lastResult?.origin, 'auto');
+    assert.equal(view.lastResult?.done, 1);
+    assert.equal(view.lastResult?.deferred, 2);
+    assert.equal(view.lastResult?.transport, 'ble');
+    assert.equal(h.device.last('pull')?.args.transport, 'ble');
+    assert.equal(h.device.last('pull')?.offline, false);
+    assert.ok(!h.service.logSnapshot().some((record) => record.transport === 'wifi'), 'no Wi-Fi in the background');
+    assert.ok(readSetting(h.t.app.database, 'last_auto_connect_at'));
+    assert.ok(view.autoConnect.nextAttemptAt);
+
+    // Too early for the next round.
+    assert.equal(await autoConnectTick(deps, state), false);
+    now += 3 * 60_000;
+    // With background Wi-Fi allowed, the deferred large files go over the hotspot.
+    writeSetting(h.t.app.database, 'auto_pull_wifi', '1');
+    assert.equal(await autoConnectTick(deps, state), true);
+    await waitFor(() => h.service.view().connection.state === 'disconnected');
+    assert.equal(h.service.view().lastResult?.transport, 'wifi');
+    assert.equal(h.service.view().lastResult?.done, 2);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('auto-connect stays quiet when the pen is asleep and when the feature is off', async () => {
+  const h = await harness({ connectError: { kind: 'DeviceNotFound', message: 'asleep' } }, { auto_connect: '1' });
+  try {
+    const state = { nextAttemptAt: 0, running: false };
+    assert.equal(await autoConnectTick({ db: h.t.app.database, service: h.service }, state), true);
+    const view = h.service.view();
+    assert.equal(view.connection.state, 'disconnected');
+    // 后台连不上是常态：只进诊断日志，页面上不出现红色错误，也不改断开原因。
+    assert.equal(view.lastError, null);
+    assert.equal(view.connection.disconnectReason, null);
+    assert.ok(h.service.logSnapshot().some((record) => record.origin === 'auto' && record.code === 'DEVICE_NOT_FOUND'));
+    writeSetting(h.t.app.database, 'auto_connect', '0');
+    state.nextAttemptAt = 0;
+    assert.equal(await autoConnectTick({ db: h.t.app.database, service: h.service }, state), false);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('the idle timer never fires during a transfer and counts down to a fixed deadline', async () => {
+  const hold = Promise.withResolvers<void>();
+  const h = await harness({ holdPull: hold.promise }, {}, 80);
+  try {
+    await h.service.connect({ origin: 'user' });
+    const first = h.service.view().connection.idleDisconnectAt;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.equal(h.service.view().connection.idleDisconnectAt, first, 'the deadline does not move on every poll');
+
+    const running = h.service.sync({ origin: 'user' });
+    await waitFor(() => h.service.view().activity?.phase === 'transferring');
+    // 远超空闲窗口的长传输：既不能被空闲断开，也不能取消进行中的同步。
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    assert.equal(h.service.view().connection.state, 'busy');
+    assert.equal(h.service.view().activity?.cancelling, false);
+    assert.equal(h.device.workers[0].exited, false);
+    hold.resolve();
+    assert.equal((await running).done, 3);
+    // 活动结束后重新开始计时，随后照常空闲断开。
+    assert.equal(h.service.view().connection.state, 'connected');
+    assert.ok(h.service.view().connection.idleDisconnectAt);
+    await waitFor(() => h.service.view().connection.state === 'disconnected');
+    assert.equal(h.service.view().connection.disconnectReason, 'idle');
+  } finally {
+    hold.resolve();
+    await finish(h);
+  }
+});
+
+test('sync and cleanup are refused while a connection is in progress, so only one worker ever exists', async () => {
+  const hold = Promise.withResolvers<void>();
+  const h = await harness({ holdConnect: hold.promise });
+  try {
+    const connecting = h.service.connect({ origin: 'auto' });
+    await waitFor(() => h.service.view().connection.state === 'connecting');
+    assert.throws(() => h.service.sync({ origin: 'user', ids: [1] }), isCode('DEVICE_BUSY'));
+    assert.throws(() => h.service.sync({ origin: 'user' }), isCode('DEVICE_BUSY'));
+    assert.throws(() => h.service.cleanup({ origin: 'user' }), isCode('DEVICE_BUSY'));
+    hold.resolve();
+    await connecting;
+    assert.equal(h.device.spawns.length, 1);
+  } finally {
+    hold.resolve();
+    await finish(h);
+  }
+});
+
+test('when the worker goes away, per-recording sync rows disappear with it', async () => {
+  // 一条大小不一致的录音留在「还在录音笔里」，另外两条可清理。
+  const h = await harness({ wrongSize: ['REC20261102_110000.mp3'] });
+  try {
+    await h.service.connect({ origin: 'user' });
+    await h.service.sync({ origin: 'user' });
+    assert.equal(h.service.view().onDevice.length, 1);
+    assert.equal(h.service.view().cleanable?.count, 2);
+    h.device.workers[0].exit(0);
+    const view = h.service.view();
+    assert.deepEqual(view.onDevice, []);
+    assert.equal(view.cleanable, null);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('stop during the network wait returns at once, reopens the gate and leaves the worker alone', async () => {
+  const t = await createTestApp('device-service');
+  writeSetting(t.app.database, 'auto_pull', '0');
+  const device = new FakeDevice({ files: FILES });
+  const gate = new NetworkGate();
+  device.isOffline = () => gate.isOffline();
+  const service = new DeviceService(t.app, {
+    resolvePython: async () => 'python', spawnWorker: device.spawn, platform: 'win32', env: { OPENMINUTES_FAKE_DEVICE: 'wifi' }, gate,
+  });
+  const asr = Promise.withResolvers<void>();
+  const inFlight = gate.runNetworkTask(() => asr.promise);
+  try {
+    await service.connect({ origin: 'user' });
+    const running = service.sync({ origin: 'user' });
+    await waitFor(() => service.view().activity?.phase === 'waiting-network');
+    assert.equal(gate.isOffline(), true);
+    const started = Date.now();
+    await service.disconnect({ reason: 'user' });
+    assert.ok(Date.now() - started < 2000, 'disconnect does not wait out the 180 s network window');
+    assert.equal(gate.isOffline(), false, 'the network was never cut, so the gate reopens');
+    assert.equal((await running).cancelled, true);
+    assert.equal(device.workers[0].killed, false);
+    assert.ok(!device.commands().includes('pull'));
+    assert.equal(service.view().connection.disconnectReason, 'user');
+  } finally {
+    asr.resolve();
+    await inFlight;
+    await t.close();
+  }
+});
+
+test('a stalled pull is cancelled cooperatively; the gate stays closed until the worker has restored the network', async () => {
+  const t = await createTestApp('device-service');
+  writeSetting(t.app.database, 'auto_pull', '0');
+  const hold = Promise.withResolvers<void>();
+  const device = new FakeDevice({ files: FILES, holdPull: hold.promise, ignoreCancel: true });
+  const gate = new NetworkGate();
+  device.isOffline = () => gate.isOffline();
+  const service = new DeviceService(t.app, {
+    resolvePython: async () => 'python', spawnWorker: device.spawn, platform: 'win32', env: { OPENMINUTES_FAKE_DEVICE: 'wifi' }, gate,
+    pullStallMs: 60,
+  });
+  try {
+    await service.connect({ origin: 'user' });
+    const running = service.sync({ origin: 'user' });
+    await waitFor(() => device.commands().includes('cancel'));
+    // 卡住后先协作取消：worker 仍在热点上，闸门不能提前打开，也不能马上强杀。
+    assert.equal(gate.isOffline(), true);
+    assert.equal(device.workers[0].killed, false);
+    assert.equal(service.view().connection.state, 'busy');
+    hold.resolve();
+    // worker 自己收尾返回：落盘的文件照常挂接，闸门此时才打开，worker 也没被强杀。
+    const outcome = await running;
+    assert.equal(outcome.done, 3);
+    assert.equal(outcome.cancelled, false);
+    assert.equal(gate.isOffline(), false);
+    assert.equal(device.workers[0].killed, false);
+    assert.equal(service.view().connection.state, 'connected');
+    assert.ok(service.logSnapshot().some((record) => record.code === 'DEVICE_TIMEOUT'));
+  } finally {
+    hold.resolve();
+    await service.disconnect({ reason: 'user' }).catch(() => undefined);
+    await t.close();
+  }
+
+  // worker 响应取消、什么都没传完：结果是超时失败，而不是「已停止」。
+  const k = await createTestApp('device-service');
+  writeSetting(k.app.database, 'auto_pull', '0');
+  const stuck = Promise.withResolvers<void>();
+  const pen = new FakeDevice({ files: FILES, holdPull: stuck.promise });
+  const quiet = new DeviceService(k.app, {
+    resolvePython: async () => 'python', spawnWorker: pen.spawn, platform: 'win32', env: { OPENMINUTES_FAKE_DEVICE: 'wifi' },
+    gate: new NetworkGate(), pullStallMs: 60,
+  });
+  try {
+    await quiet.connect({ origin: 'user' });
+    const outcome = await quiet.sync({ origin: 'user' });
+    assert.equal(outcome.done, 0);
+    assert.equal(outcome.failed, 3);
+    assert.equal(outcome.cancelled, false);
+    assert.equal(outcome.error?.code, 'DEVICE_TIMEOUT');
+    assert.equal(quiet.view().lastResult?.error?.code, 'DEVICE_TIMEOUT');
+    assert.equal(pen.workers[0].killed, false);
+  } finally {
+    stuck.resolve();
+    await quiet.disconnect({ reason: 'user' }).catch(() => undefined);
+    await k.close();
+  }
+});
+
+test('while busy, sync/pull/cleanup/live are refused but connect just returns the state', async () => {
+  const hold = Promise.withResolvers<void>();
+  const h = await harness({ holdPull: hold.promise });
+  try {
+    await h.service.connect({ origin: 'user' });
+    const running = h.service.sync({ origin: 'user' });
+    await waitFor(() => h.service.view().activity?.phase === 'transferring');
+    const view = h.service.view();
+    assert.equal(view.connection.state, 'busy');
+    assert.equal(view.activity?.transport, 'wifi');
+    assert.equal(view.activity?.offline, true);
+    assert.equal(view.activity?.count, 3);
+    assert.equal(view.syncPlan, null);
+    assert.throws(() => h.service.sync({ origin: 'user' }), isCode('DEVICE_BUSY'));
+    assert.throws(() => h.service.sync({ origin: 'user', ids: [1] }), isCode('DEVICE_BUSY'));
+    assert.throws(() => h.service.cleanup({ origin: 'user' }), isCode('DEVICE_BUSY'));
+    await assert.rejects(h.service.claimForLive({ scriptPath: 'x', pythonCommand: 'python', env: {}, scanTimeoutSec: 1 }), isCode('DEVICE_BUSY'));
+    assert.equal((await h.service.connect({ origin: 'user' })).connection.state, 'busy');
+    hold.resolve();
+    assert.equal((await running).done, 3);
+    assert.equal(h.service.view().connection.state, 'connected');
+  } finally {
+    hold.resolve();
+    await finish(h);
+  }
+});
+
+test('cancel is cooperative: the worker stops on its own and stays alive', async () => {
+  const hold = Promise.withResolvers<void>();
+  const h = await harness({ holdPull: hold.promise });
+  try {
+    await h.service.connect({ origin: 'user' });
+    const running = h.service.sync({ origin: 'user' });
+    await waitFor(() => h.service.view().activity?.phase === 'transferring');
+    const view = await h.service.cancel();
+    assert.equal(view.activity, null);
+    const outcome = await running;
+    assert.equal(outcome.cancelled, true);
+    assert.equal(outcome.done, 0);
+    assert.ok(h.device.commands().includes('cancel'));
+    assert.equal(h.device.workers[0].killed, false);
+    assert.equal(h.service.view().lastResult?.cancelled, true);
+    assert.equal(h.service.view().connection.state, 'connected');
+  } finally {
+    hold.resolve();
+    await finish(h);
+  }
+});
+
+test('during the hotspot phase cancel waits instead of killing; only an explicit deadline kills', async () => {
+  const hold = Promise.withResolvers<void>();
+  const h = await harness({ holdPull: hold.promise, ignoreCancel: true });
+  try {
+    await h.service.connect({ origin: 'user' });
+    const running = h.service.sync({ origin: 'user' });
+    await waitFor(() => h.service.view().activity?.phase === 'transferring');
+    const cancelling = h.service.cancel();
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    assert.equal(h.device.workers[0].killed, false, 'a worker restoring the network must not be killed early');
+    assert.equal(h.service.view().activity?.cancelling, true);
+    hold.resolve();
+    await cancelling;
+    assert.equal((await running).done, 3);
+  } finally {
+    hold.resolve();
+    await finish(h);
+  }
+
+  const stuck = Promise.withResolvers<void>();
+  const k = await harness({ holdPull: stuck.promise, ignoreCancel: true });
+  try {
+    await k.service.connect({ origin: 'user' });
+    const running = k.service.sync({ origin: 'user' }).catch((error: unknown) => error);
+    await waitFor(() => k.service.view().activity?.phase === 'transferring');
+    await k.service.cancel({ timeoutMs: 30 });
+    assert.equal(k.device.workers[0].killed, true);
+    assert.ok(await running instanceof AppError);
+    assert.equal(k.service.view().connection.state, 'disconnected');
+    assert.equal(k.service.view().activity, null);
+  } finally {
+    stuck.resolve();
+    await finish(k);
+  }
+});
+
+test('a worker that exits on its own leaves the service disconnected with a reason', async () => {
+  const h = await harness();
+  try {
+    await h.service.connect({ origin: 'user' });
+    h.device.workers[0].exit(0);
+    const view = h.service.view();
+    assert.equal(view.connection.state, 'disconnected');
+    assert.equal(view.connection.disconnectReason, 'device_sleep');
+    assert.equal(view.connection.userDisconnected, false);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('live captions claim the pen exclusively and restore a user connection afterwards', async () => {
+  const h = await harness();
+  try {
+    await h.service.connect({ origin: 'user' });
+    const script = path.join(h.t.root, 'capture.js');
+    await writeFile(script, 'process.exit(0)\n');
+    // Node rejects the -X flag and exits immediately; only the hand-over matters here.
+    const child = await h.service.claimForLive({ scriptPath: script, pythonCommand: process.execPath, env: process.env, scanTimeoutSec: 1 });
+    await new Promise((resolve) => child.once('close', resolve));
+    assert.ok(h.device.workers[0].exited, 'the worker exits before live capture starts');
+    assert.equal(h.service.view().connection.state, 'live');
+    await assert.rejects(h.service.connect({ origin: 'user' }), isCode('DEVICE_BUSY'));
+    assert.throws(() => h.service.sync({ origin: 'user' }), isCode('DEVICE_BUSY'));
+    await assert.rejects(h.service.claimForLive({ scriptPath: script, pythonCommand: process.execPath, env: process.env, scanTimeoutSec: 1 }), isCode('DEVICE_BUSY'));
+    await h.service.releaseFromLive();
+    await waitFor(() => h.service.view().connection.state === 'connected');
+    assert.equal(h.device.spawns.length, 2);
+    assert.equal(h.service.view().connection.origin, 'user');
+  } finally {
+    await finish(h);
+  }
+});
+
+test('live captions do not reconnect when nobody was connected before', async () => {
+  const h = await harness();
+  try {
+    const script = path.join(h.t.root, 'capture.js');
+    await writeFile(script, 'process.exit(0)\n');
+    const child = await h.service.claimForLive({ scriptPath: script, pythonCommand: process.execPath, env: process.env, scanTimeoutSec: 1 });
+    await new Promise((resolve) => child.once('close', resolve));
+    await h.service.releaseFromLive();
+    assert.equal(h.service.view().connection.state, 'disconnected');
+    assert.equal(h.device.spawns.length, 0);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('the device log is a bounded ring buffer', async () => {
+  const t = await createTestApp('device-service');
+  const service = new DeviceService(t.app, { resolvePython: async () => 'python', spawnWorker: new FakeDevice().spawn, logLimit: 5 });
+  try {
+    for (let index = 0; index < 8; index += 1) {
+      service.log({ op: 'status', origin: 'user', ok: true, code: null, transport: null, bytes: null, durationMs: index, detail: String(index) });
+    }
+    assert.deepEqual(service.logSnapshot().map((record) => record.detail), ['3', '4', '5', '6', '7']);
+  } finally {
+    await t.close();
+  }
+});
+
+test('a user connect during a background connect takes over: it syncs everything and stays connected', async () => {
+  let releaseConnect!: () => void;
+  const holdConnect = new Promise<void>((resolve) => { releaseConnect = resolve; });
+  const h = await harness({ holdConnect }, { auto_connect: '1', auto_pull: '1', auto_pull_wifi: '0' });
+  try {
+    const state = { nextAttemptAt: 0, running: false };
+    const tick = autoConnectTick({ db: h.t.app.database, service: h.service }, state);
+    await waitFor(() => h.service.view().connection.state === 'connecting');
+    const userConnect = h.service.connect({ origin: 'user' });
+    releaseConnect();
+    await userConnect;
+    assert.equal(await tick, true);
+    await waitFor(() => h.service.view().lastResult !== null, 15_000);
+    const view = h.service.view();
+    assert.equal(h.device.spawns.length, 1, 'both callers share one connection');
+    assert.equal(view.connection.origin, 'user');
+    assert.equal(view.connection.state, 'connected');
+    assert.equal(view.lastResult?.origin, 'user');
+    assert.equal(view.lastResult?.done, 3);
+    assert.equal(view.lastResult?.deferred, 0);
+    assert.equal(view.lastResult?.transport, 'wifi');
+    assert.deepEqual(h.device.commands().filter((cmd) => cmd === 'pull'), ['pull'], 'the background tick does not sync a second time');
+    assert.notEqual(view.connection.disconnectReason, 'auto-done');
+  } finally {
+    await finish(h);
+  }
+});
+
+test('a user connect during a background sync keeps the session and syncs the deferred large files', async () => {
+  let releasePull!: () => void;
+  const holdPull = new Promise<void>((resolve) => { releasePull = resolve; });
+  const h = await harness({ holdPull }, { auto_connect: '1', auto_pull: '1', auto_pull_wifi: '0' });
+  try {
+    const state = { nextAttemptAt: 0, running: false };
+    const tick = autoConnectTick({ db: h.t.app.database, service: h.service }, state);
+    await waitFor(() => h.service.view().activity?.phase === 'transferring' || h.device.commands().includes('pull'), 15_000);
+    assert.equal(h.service.view().connection.origin, 'auto');
+    await h.service.connect({ origin: 'user' });
+    assert.equal(h.service.view().connection.origin, 'user');
+    releasePull();
+    assert.equal(await tick, true);
+    await waitFor(() => h.service.view().lastResult?.origin === 'user' && !h.service.view().activity, 15_000);
+    const view = h.service.view();
+    assert.equal(view.connection.state, 'connected');
+    assert.equal(view.lastResult?.transport, 'wifi');
+    assert.equal(view.lastResult?.done, 2, 'the follow-up sync fetches what the background sync deferred');
+    assert.equal(readSetting(h.t.app.database, 'device_user_disconnected'), '0');
+  } finally {
+    await finish(h);
+  }
+});
+
+test('a user sync inside a background session keeps the connection afterwards', async () => {
+  const h = await harness({}, { auto_pull: '0' });
+  try {
+    await h.service.connect({ origin: 'auto' });
+    assert.equal(h.service.view().connection.origin, 'auto');
+    await h.service.sync({ origin: 'user' });
+    const view = h.service.view();
+    assert.equal(view.connection.origin, 'user');
+    assert.equal(view.connection.state, 'connected');
+    assert.equal(view.lastResult?.done, 3);
+  } finally {
+    await finish(h);
+  }
+});
+
+test('ending live captions restores the user connection without starting a sync', async () => {
+  const h = await harness({}, { auto_pull: '1' });
+  try {
+    writeSetting(h.t.app.database, 'auto_pull', '0');
+    await h.service.connect({ origin: 'user' });
+    writeSetting(h.t.app.database, 'auto_pull', '1');
+    const script = path.join(h.t.root, 'capture.js');
+    await writeFile(script, 'process.exit(0)\n');
+    const child = await h.service.claimForLive({ scriptPath: script, pythonCommand: process.execPath, env: process.env, scanTimeoutSec: 1 });
+    await new Promise((resolve) => child.once('close', resolve));
+    await h.service.releaseFromLive();
+    await waitFor(() => h.service.view().connection.state === 'connected');
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    assert.equal(h.service.view().activity, null);
+    assert.equal(h.service.view().lastResult, null);
+    assert.ok(!h.device.commands().includes('pull'), 'no sync, so no silent switch to the hotspot');
+  } finally {
+    await finish(h);
+  }
+});
diff --git a/tests/device-sync.test.ts b/tests/device-sync.test.ts
new file mode 100644
index 0000000..a979e1d
--- /dev/null
+++ b/tests/device-sync.test.ts
@@ -0,0 +1,282 @@
+import assert from 'node:assert/strict';
+import { existsSync, readdirSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { test } from 'node:test';
+import { AppError } from '../src/contracts/errors.ts';
+import { DeviceService } from '../src/server/device/service.ts';
+import { cleanupCandidates, pendingRecords, pullTimeoutMs } from '../src/server/device/sync.ts';
+import { NetworkGate } from '../src/server/network-gate.ts';
+import { rows, writeSetting } from '../src/server/sql.ts';
+import { createTestApp, FakeDevice, MiB, SERIAL, type FakeDeviceOptions, type TestApp } from './support/device-fixture.ts';
+
+const FILES = [
+  { name: 'REC20261101_090000.mp3', sizeBytes: 2 * MiB },
+  { name: 'REC20261101_100000.mp3', sizeBytes: Math.round(1.5 * MiB) },
+  { name: 'REC20261101_110000.mp3', sizeBytes: 200 * 1024 },
+];
+
+interface Harness {
+  t: TestApp;
+  device: FakeDevice;
+  gate: NetworkGate;
+  service: DeviceService;
+}
+
+async function harness(options: FakeDeviceOptions = {}, gate = new NetworkGate(), platform = 'win32'): Promise<Harness> {
+  const t = await createTestApp('device-sync');
+  // 连接本身不触发自动同步，由测试显式调用 sync。
+  writeSetting(t.app.database, 'auto_pull', '0');
+  const device = new FakeDevice({ files: FILES, ...options });
+  device.isOffline = () => gate.isOffline();
+  const service = new DeviceService(t.app, {
+    resolvePython: async () => 'python',
+    spawnWorker: device.spawn,
+    platform,
+    env: { OPENMINUTES_FAKE_DEVICE: 'wifi' },
+    gate,
+  });
+  return { t, device, gate, service };
+}
+
+function recordings(h: Harness) {
+  return rows(h.t.app.database, 'SELECT id, filename, status, storage_path, device_serial FROM recordings ORDER BY id');
+}
+
+function incomingEntries(h: Harness): string[] {
+  const dir = path.join(h.t.root, 'data', 'audio', '_incoming');
+  return existsSync(dir) ? readdirSync(dir) : [];
+}
+
+test('a user sync pulls every pending file over Wi-Fi while the network gate is held', async () => {
+  const h = await harness();
+  try {
+    await h.service.connect({ origin: 'user' });
+    const outcome = await h.service.sync({ origin: 'user' });
+    assert.equal(outcome.done, 3);
+    assert.equal(outcome.failed, 0);
+    assert.equal(outcome.transport, 'wifi');
+    assert.equal(outcome.fallback, null);
+    const pull = h.device.last('pull');
+    assert.equal(pull?.args.transport, 'wifi');
+    assert.equal(pull?.offline, true, 'the gate is offline while the hotspot is used');
+    assert.equal(h.gate.isOffline(), false, 'the gate reopens after the pull');
+    for (const item of recordings(h)) {
+      assert.equal(item.status, 'ready');
+      assert.equal(item.device_serial, SERIAL);
+      assert.ok(String(item.storage_path).startsWith(h.t.libraryDir));
+    }
+    assert.deepEqual(incomingEntries(h), [], 'the per-job incoming directory is removed');
+    const view = h.service.view();
+    assert.equal(view.connection.state, 'connected');
+    assert.equal(view.activity, null);
+    assert.deepEqual(view.onDevice, []);
+    assert.equal(view.lastResult?.transport, 'wifi');
+    assert.deepEqual(view.cleanable, { count: 3, bytes: FILES.reduce((sum, file) => sum + file.sizeBytes, 0) });
+    const log = h.service.logSnapshot().filter((record) => record.op === 'pull');
+    assert.equal(log.at(-1)?.transport, 'wifi');
+    assert.match(log.at(-1)?.detail ?? '', /无线快传/);
+    assert.ok(h.service.measuredSpeeds().wifiBps);
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('a small batch goes over BLE and never takes the network offline', async () => {
+  const h = await harness({ files: [FILES[2]] });
+  try {
+    await h.service.connect({ origin: 'user' });
+    const outcome = await h.service.sync({ origin: 'user' });
+    assert.equal(outcome.transport, 'ble');
+    assert.equal(h.device.last('pull')?.offline, false);
+    assert.ok(h.service.measuredSpeeds().bleBps);
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('a Wi-Fi join failure falls back to BLE, reopens the gate and keeps the reason in detail', async () => {
+  const h = await harness({ wifiFails: true });
+  try {
+    await h.service.connect({ origin: 'user' });
+    const outcome = await h.service.sync({ origin: 'user' });
+    assert.equal(outcome.done, 3);
+    assert.equal(outcome.transport, 'ble');
+    assert.equal(outcome.fallback?.code, 'WIFI_FALLBACK');
+    assert.equal(outcome.fallback?.message, '无线快传不可用，已改用蓝牙（较慢）。');
+    assert.match(outcome.fallback?.detail ?? '', /WIFI_JOIN_FAILED/);
+    assert.doesNotMatch(outcome.fallback?.message ?? '', /WIFI_JOIN_FAILED|netsh/);
+    assert.equal(h.gate.isOffline(), false);
+    assert.equal(h.service.view().lastResult?.fallback?.code, 'WIFI_FALLBACK');
+    assert.ok(h.service.logSnapshot().some((record) => record.code === 'WIFI_JOIN_FAILED'));
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+class BusyGate extends NetworkGate {
+  override async acquireOffline(): Promise<(() => void) | null> {
+    return null;
+  }
+}
+
+test('when transcriptions do not finish in time, the batch switches to BLE with NETWORK_IN_USE', async () => {
+  const h = await harness({}, new BusyGate());
+  try {
+    await h.service.connect({ origin: 'user' });
+    const outcome = await h.service.sync({ origin: 'user' });
+    assert.equal(h.device.last('pull')?.args.transport, 'ble');
+    assert.equal(outcome.transport, 'ble');
+    assert.equal(outcome.fallback?.code, 'WIFI_FALLBACK');
+    assert.match(outcome.fallback?.detail ?? '', /NETWORK_IN_USE/);
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('only pending records of the connected serial are pulled', async () => {
+  const h = await harness();
+  try {
+    h.t.app.database.exec(`INSERT INTO recordings (filename, dedupe_key, device_serial, source, status)
+      VALUES ('OTHER_DEVICE.mp3', 'other', 'MT-OTHER', 'device_manifest', 'pending')`);
+    await h.service.connect({ origin: 'user' });
+    const outcome = await h.service.sync({ origin: 'user' });
+    assert.equal(outcome.failed, 0);
+    const requested = (h.device.last('pull')?.args.files as Array<{ name: string }>).map((file) => file.name);
+    assert.deepEqual([...requested].sort(), FILES.map((file) => file.name).sort());
+    assert.equal(recordings(h).find((item) => item.filename === 'OTHER_DEVICE.mp3')?.status, 'pending');
+    assert.deepEqual(pendingRecords(h.t.app.database, 'MT-OTHER').map((item) => item.filename), ['OTHER_DEVICE.mp3']);
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('size mismatches and paths outside the job directory are never attached', async () => {
+  const h = await harness({ wrongSize: [FILES[0].name], outsidePath: [FILES[1].name] });
+  try {
+    await h.service.connect({ origin: 'user' });
+    const outcome = await h.service.sync({ origin: 'user' });
+    assert.equal(outcome.done, 1);
+    assert.equal(outcome.failed, 2);
+    assert.equal(outcome.error?.code, 'TRANSFER_FAILED');
+    const byName = new Map(recordings(h).map((item) => [item.filename, item]));
+    assert.equal(byName.get(FILES[0].name)?.status, 'pending');
+    assert.equal(byName.get(FILES[1].name)?.status, 'pending');
+    assert.equal(byName.get(FILES[2].name)?.status, 'ready');
+    const failures = h.service.logSnapshot().filter((record) => record.code === 'TRANSFER_FAILED');
+    assert.ok(failures.some((record) => /device reported/.test(record.detail)));
+    assert.ok(failures.some((record) => /unexpected path/.test(record.detail)));
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('a recording in progress blocks the sync before any transfer', async () => {
+  const h = await harness({ status: { recordingState: 'RECORDING' } });
+  try {
+    await h.service.connect({ origin: 'user' });
+    await assert.rejects(h.service.sync({ origin: 'user' }), (error: unknown) => error instanceof AppError && error.code === 'DEVICE_RECORDING');
+    assert.equal(h.device.last('pull'), undefined);
+    assert.equal(h.service.view().lastError?.code, 'DEVICE_RECORDING');
+    assert.equal(h.service.view().connection.state, 'connected');
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('single-file sync only pulls the requested ids', async () => {
+  const h = await harness();
+  try {
+    const insert = h.t.app.database.prepare(`INSERT INTO recordings (filename, dedupe_key, device_serial, source, size_bytes, status)
+      VALUES (?, ?, ?, 'device_manifest', ?, 'pending')`);
+    for (const file of FILES) insert.run(file.name, `device::${SERIAL}::${file.name}::${file.sizeBytes}`, SERIAL, file.sizeBytes);
+    const ids = recordings(h).map((item) => Number(item.id));
+    await h.service.connect({ origin: 'user' });
+    const outcome = await h.service.sync({ origin: 'user', ids: [ids[2]] });
+    assert.equal(outcome.done, 1);
+    assert.deepEqual((h.device.last('pull')?.args.files as Array<{ name: string }>).map((file) => file.name), [FILES[2].name]);
+    assert.deepEqual(recordings(h).map((item) => item.status), ['pending', 'pending', 'ready']);
+    assert.equal(h.service.view().lastResult?.kind, 'pull');
+    // 两条仍在录音笔中，列表给出它们，按钮提示会走无线快传（合计 ≥ 1 MiB）。
+    assert.deepEqual(h.service.view().onDevice.map((item) => item.id).sort(), [ids[0], ids[1]].sort());
+    assert.deepEqual(h.service.view().syncPlan, { transport: 'wifi', willGoOffline: true });
+    // 不存在的 id 什么也不拉。
+    const pulls = h.device.calls.filter((call) => call.cmd === 'pull').length;
+    await h.service.sync({ origin: 'user', ids: [99_999] });
+    assert.equal(h.device.calls.filter((call) => call.cmd === 'pull').length, pulls);
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('cleanup deletes only files that are in the library with a matching local size', async () => {
+  const h = await harness();
+  try {
+    await h.service.connect({ origin: 'user' });
+    await h.service.sync({ origin: 'user' });
+    // 一条本地文件被删掉，一条本地文件大小不一致：都不能删设备上的副本。
+    const stored = new Map(recordings(h).map((item) => [String(item.filename), String(item.storage_path)]));
+    const { rm } = await import('node:fs/promises');
+    await rm(stored.get(FILES[0].name)!);
+    await writeFile(stored.get(FILES[1].name)!, Buffer.alloc(10));
+    // 设备上另有一条库里没有的录音。
+    h.device.files.push({ name: 'UNKNOWN.mp3', sizeBytes: 4096 });
+    assert.deepEqual(cleanupCandidates(h.t.app.database, SERIAL, h.device.files.map((file) => ({
+      name: file.name, format: 'MP3', sizeBytes: file.sizeBytes, durationSec: null, timestamp: null,
+    })), h.t.libraryDir).map((file) => file.name), [FILES[2].name]);
+
+    const outcome = await h.service.cleanup({ origin: 'user' });
+    assert.equal(outcome.done, 1);
+    assert.equal(outcome.bytes, FILES[2].sizeBytes);
+    assert.deepEqual(h.device.last('delete')?.args.names, [FILES[2].name]);
+    assert.deepEqual(h.device.files.map((file) => file.name).sort(), [FILES[0].name, FILES[1].name, 'UNKNOWN.mp3'].sort());
+    assert.deepEqual(h.service.view().cleanable, { count: 0, bytes: 0 });
+    assert.ok(h.service.logSnapshot().some((record) => record.op === 'delete' && record.ok));
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('a failed delete is reported as DELETE_FAILED', async () => {
+  const h = await harness({ files: [FILES[2]], deleteFails: [FILES[2].name] });
+  try {
+    await h.service.connect({ origin: 'user' });
+    await h.service.sync({ origin: 'user' });
+    const outcome = await h.service.cleanup({ origin: 'user' });
+    assert.equal(outcome.failed, 1);
+    assert.equal(outcome.error?.code, 'DELETE_FAILED');
+    assert.equal(h.device.files.length, 1);
+  } finally {
+    await h.service.disconnect({ reason: 'user' });
+    await h.t.close();
+  }
+});
+
+test('cleanupCandidates skips entries without a size and pull timeouts scale with size', async () => {
+  const t = await createTestApp('device-cleanup');
+  try {
+    const local = path.join(t.libraryDir, 'a.mp3');
+    await mkdir(t.libraryDir, { recursive: true });
+    await writeFile(local, Buffer.alloc(5));
+    t.app.database.prepare(`INSERT INTO recordings (filename, dedupe_key, device_serial, source, status, storage_path)
+      VALUES ('a.mp3', 'a', ?, 'device_manifest', 'ready', ?)`).run(SERIAL, local);
+    const entry = { name: 'a.mp3', format: 'MP3', durationSec: null, timestamp: null };
+    assert.equal(cleanupCandidates(t.app.database, SERIAL, [{ ...entry, sizeBytes: 5 }], t.libraryDir).length, 1);
+    assert.equal(cleanupCandidates(t.app.database, SERIAL, [{ ...entry, sizeBytes: null }], t.libraryDir).length, 0);
+    assert.equal(cleanupCandidates(t.app.database, 'MT-OTHER', [{ ...entry, sizeBytes: 5 }], t.libraryDir).length, 0);
+  } finally {
+    await t.close();
+  }
+  assert.equal(pullTimeoutMs(0), 120_000);
+  assert.ok(pullTimeoutMs(10 * MiB) > pullTimeoutMs(MiB));
+  assert.equal(pullTimeoutMs(1e12), 2 * 3600_000);
+});
diff --git a/tests/device-transport.test.ts b/tests/device-transport.test.ts
new file mode 100644
index 0000000..33be4e2
--- /dev/null
+++ b/tests/device-transport.test.ts
@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import type { CommandOutcome } from '../src/server/media.ts';
+import {
+  BACKGROUND_BLE_LIMIT,
+  DEFAULT_BLE_BPS,
+  parseTransportSetting,
+  parseWifiProbe,
+  planTransfer,
+  probeWifiCapable,
+  resetWifiProbeCache,
+  WIFI_MIN_BATCH_BYTES,
+  type PlanInput,
+} from '../src/server/device/transport.ts';
+
+const MiB = 1_048_576;
+const big = (name: string) => ({ name, sizeBytes: 2 * MiB });
+const small = (name: string) => ({ name, sizeBytes: 100 * 1024 });
+
+function plan(patch: Partial<PlanInput>) {
+  return planTransfer({
+    setting: 'auto', origin: 'user', allowBackgroundWifi: false, files: [], wifiCapable: true, platform: 'win32', ...patch,
+  });
+}
+
+test('user sync picks Wi-Fi for large or unknown-size batches and BLE for small ones', () => {
+  assert.equal(WIFI_MIN_BATCH_BYTES, MiB);
+  for (const platform of ['win32', 'darwin', 'linux']) {
+    assert.deepEqual(plan({ platform, files: [big('a.mp3')] }),
+      { transport: 'wifi', include: ['a.mp3'], deferred: [], reason: 'large-batch' });
+  }
+  // Several small files whose total crosses the threshold still count as a large batch.
+  const many = Array.from({ length: 11 }, (_, index) => small(`s${index}.mp3`));
+  assert.equal(plan({ files: many }).transport, 'wifi');
+  assert.equal(plan({ files: [{ name: 'x.mp3', sizeBytes: null }] }).reason, 'large-batch');
+  assert.equal(plan({ files: [{ name: 'x.mp3', sizeBytes: MiB }] }).transport, 'wifi');
+  assert.deepEqual(plan({ files: [{ name: 'x.mp3', sizeBytes: MiB - 1 }] }),
+    { transport: 'ble', include: ['x.mp3'], deferred: [], reason: 'small-batch' });
+});
+
+test('missing adapter or unsupported platform falls back to BLE for every file', () => {
+  assert.deepEqual(plan({ wifiCapable: false, files: [big('a.mp3')] }),
+    { transport: 'ble', include: ['a.mp3'], deferred: [], reason: 'no-wifi-adapter' });
+  assert.deepEqual(plan({ platform: 'freebsd', files: [big('a.mp3')] }),
+    { transport: 'ble', include: ['a.mp3'], deferred: [], reason: 'unsupported-platform' });
+});
+
+test('forced settings override the size rule', () => {
+  assert.deepEqual(plan({ setting: 'wifi', files: [small('a.mp3')] }),
+    { transport: 'wifi', include: ['a.mp3'], deferred: [], reason: 'forced' });
+  // Forced Wi-Fi does not need a detected adapter; the worker falls back on failure.
+  assert.equal(plan({ setting: 'wifi', wifiCapable: false, files: [small('a.mp3')] }).transport, 'wifi');
+  assert.deepEqual(plan({ setting: 'ble', files: [big('a.mp3'), big('b.mp3')] }),
+    { transport: 'ble', include: ['a.mp3', 'b.mp3'], deferred: [], reason: 'forced' });
+});
+
+test('background sync never switches Wi-Fi unless allowed, and respects the BLE budget', () => {
+  const files = [big('big1.mp3'), small('s1.mp3'), { name: 'unknown.mp3', sizeBytes: null }, small('s2.mp3'),
+    small('s3.mp3'), small('s4.mp3'), big('big2.mp3')];
+  const background = plan({ origin: 'auto', files });
+  assert.equal(background.transport, 'ble');
+  assert.equal(background.reason, 'background-no-wifi');
+  assert.deepEqual(background.include, ['s1.mp3', 's2.mp3', 's3.mp3']);
+  assert.equal(background.include.length, BACKGROUND_BLE_LIMIT.maxFiles);
+  assert.deepEqual([...background.deferred].sort(), ['big1.mp3', 'big2.mp3', 's4.mp3', 'unknown.mp3']);
+
+  const allowed = plan({ origin: 'auto', allowBackgroundWifi: true, files });
+  assert.equal(allowed.transport, 'wifi');
+  assert.equal(allowed.deferred.length, 0);
+
+  // Allowed but small: BLE with the background budget applied.
+  const smallOnly = plan({ origin: 'auto', allowBackgroundWifi: true, files: [small('a'), small('b'), small('c'), small('d')] });
+  assert.deepEqual(smallOnly, { transport: 'ble', include: ['a', 'b', 'c'], deferred: ['d'], reason: 'small-batch' });
+
+  // Forced BLE in the background is still budgeted (fast measured BLE: the file cap applies).
+  const fast = 200_000;
+  const forced = plan({ origin: 'auto', setting: 'ble', bleBps: fast, files: [big('a'), big('b'), big('c'), big('d')] });
+  assert.deepEqual(forced, { transport: 'ble', include: ['a', 'b', 'c'], deferred: ['d'], reason: 'forced' });
+
+  const noAdapter = plan({ origin: 'auto', allowBackgroundWifi: true, wifiCapable: false, bleBps: fast, files: [big('a'), big('b'), big('c'), big('d')] });
+  assert.deepEqual(noAdapter, { transport: 'ble', include: ['a', 'b', 'c'], deferred: ['d'], reason: 'no-wifi-adapter' });
+});
+
+test('a background BLE round stays within the time budget, using the measured BLE speed', () => {
+  assert.equal(BACKGROUND_BLE_LIMIT.budgetMs, 150_000);
+  // Without a measurement the conservative 3 KB/s estimate applies: 2 MiB would take ~12 minutes.
+  const unmeasured = plan({ origin: 'auto', setting: 'ble', files: [big('a'), small('b')] });
+  assert.deepEqual(unmeasured, { transport: 'ble', include: ['b'], deferred: ['a'], reason: 'forced' });
+  assert.equal(DEFAULT_BLE_BPS, 3_000);
+
+  // 10 KB/s measured: 600 KB = 60 s each, so only two fit into 150 s.
+  const kb600 = (name: string) => ({ name, sizeBytes: 600_000 });
+  const measured = plan({ origin: 'auto', bleBps: 10_000, files: [kb600('a'), kb600('b'), kb600('c')] });
+  assert.deepEqual(measured.include, ['a', 'b']);
+  assert.deepEqual(measured.deferred, ['c']);
+
+  // Unknown sizes cannot be bounded and wait for a user sync; user syncs are never budgeted.
+  const unknown = plan({ origin: 'auto', setting: 'ble', bleBps: 200_000, files: [{ name: 'u', sizeBytes: null }, small('s')] });
+  assert.deepEqual(unknown, { transport: 'ble', include: ['s'], deferred: ['u'], reason: 'forced' });
+  assert.deepEqual(plan({ setting: 'ble', files: [big('a'), big('b')] }).deferred, []);
+});
+
+test('parseTransportSetting accepts only the three values', () => {
+  assert.equal(parseTransportSetting('wifi'), 'wifi');
+  assert.equal(parseTransportSetting('ble'), 'ble');
+  assert.equal(parseTransportSetting('auto'), 'auto');
+  assert.equal(parseTransportSetting('ftp'), 'auto');
+});
+
+const outcome = (stdout: string, ok = true, stderr = ''): CommandOutcome => ({ ok, code: ok ? 0 : 1, stdout, stderr });
+
+test('Wi-Fi adapter probe parses each platform, including the Windows location prompt', () => {
+  const drivers = 'Interface name: Wi-Fi\r\n\r\n    Driver                    : Intel(R) Wi-Fi 6 AX201\r\n    Vendor                    : Intel\r\n';
+  assert.equal(parseWifiProbe('win32', outcome(drivers)), true);
+  assert.equal(parseWifiProbe('win32', outcome('接口名称: WLAN\r\n    驱动程序 : Intel\r\n')), true);
+  assert.equal(parseWifiProbe('win32', outcome('Network shell commands need location permission to access WLAN information.', false)), true);
+  assert.equal(parseWifiProbe('win32', outcome('There is no wireless interface on the system.', false)), false);
+  assert.equal(parseWifiProbe('win32', outcome('', false, 'The Wireless AutoConfig Service (wlansvc) is not running.')), false);
+  assert.equal(parseWifiProbe('win32', outcome('', false)), false);
+  assert.equal(parseWifiProbe('darwin', outcome('Hardware Port: Wi-Fi\nDevice: en0\n')), true);
+  assert.equal(parseWifiProbe('darwin', outcome('Hardware Port: Ethernet\nDevice: en1\n')), false);
+  assert.equal(parseWifiProbe('linux', outcome('ethernet\nwifi\nloopback\n')), true);
+  assert.equal(parseWifiProbe('linux', outcome('ethernet\nloopback\n')), false);
+  assert.equal(parseWifiProbe('linux', outcome('', false)), false);
+  assert.equal(parseWifiProbe('aix', outcome('wifi')), false);
+});
+
+test('probeWifiCapable caches per platform and short-circuits in fake-device mode', async () => {
+  resetWifiProbeCache();
+  const calls: string[] = [];
+  const exec = async (command: string, args: string[]) => {
+    calls.push(`${command} ${args.join(' ')}`);
+    return outcome('ethernet\nwifi\n');
+  };
+  assert.equal(await probeWifiCapable(exec, 'linux', {}), true);
+  assert.equal(await probeWifiCapable(exec, 'linux', {}), true);
+  assert.deepEqual(calls, ['nmcli -t -f TYPE dev']);
+
+  assert.equal(await probeWifiCapable(async (command, args) => {
+    calls.push(`${command} ${args.join(' ')}`);
+    return outcome('Hardware Port: Ethernet');
+  }, 'darwin', {}), false);
+  assert.equal(calls.at(-1), 'networksetup -listallhardwareports');
+
+  resetWifiProbeCache();
+  assert.equal(await probeWifiCapable(async (command, args) => {
+    calls.push(`${command} ${args.join(' ')}`);
+    return outcome('There is no wireless interface on the system.', false);
+  }, 'win32', {}), false);
+  assert.equal(calls.at(-1), 'netsh wlan show drivers');
+
+  resetWifiProbeCache();
+  const before = calls.length;
+  assert.equal(await probeWifiCapable(async () => {
+    throw new Error('must not spawn in fake-device mode');
+  }, 'win32', { OPENMINUTES_FAKE_DEVICE: 'ble' }), true);
+  assert.equal(calls.length, before);
+  resetWifiProbeCache();
+});
diff --git a/tests/e2e-preflight.mjs b/tests/e2e-preflight.mjs
index ad5dcf4..5c825e2 100644
--- a/tests/e2e-preflight.mjs
+++ b/tests/e2e-preflight.mjs
@@ -101,7 +101,7 @@ for (const simulated of [false, true]) {
     }
     assert.ok(url, log);
     await writeFile(path.join(runDir, 'run.json'), JSON.stringify({
-      runId, url, pid: child.pid, nonce, root, runDir, evidenceDir, dirs, startedAt: new Date().toISOString(),
+      runId, url, pid: child.pid, nonce, root, runDir, evidenceDir, dirs, hostMode: simulated ? 'fixture' : 'none', startedAt: new Date().toISOString(),
     }));
     registered = true;
     await script('doctor.mjs', [runId]);
@@ -111,8 +111,8 @@ for (const simulated of [false, true]) {
     assert.equal(requests.filter((call) => call.domain === 'agent').length, 0);
     const checkedAt = initial.data.report.checkedAt;
     const steps = [
-      { goto: '#/device' }, { waitText: '本机环境', timeout: 60000 },
-      { waitText: simulated ? 'Host agent' : 'agent 不可用', timeout: 60000 },
+      { goto: '#/settings/diagnostics' }, { waitText: '本机环境', timeout: 60000 },
+      { waitText: simulated ? 'Floatboat 助手' : 'Floatboat 助手暂不可用', timeout: 60000 },
       { aria: 'before.aria.txt' }, { screenshot: 'before.png' },
       { click: 'text=重新检测' }, { waitText: '环境检测已刷新', timeout: 60000 },
       ...(simulated ? [
@@ -120,12 +120,12 @@ for (const simulated of [false, true]) {
         { waitText: '修复中', timeout: 60000 },
         { waitText: '模拟 Host：未执行安装或修改。', timeout: 60000 },
         { expectText: '模拟 Host：未执行安装或修改。' },
-      ] : [{ expectText: 'agent 不可用' }]),
+      ] : [{ expectText: 'Floatboat 助手暂不可用' }]),
       { aria: 'after.aria.txt' }, { screenshot: 'after.png' },
     ];
     const stepsPath = path.join(runDir, 'steps.json');
     await writeFile(stepsPath, JSON.stringify(steps));
-    await script('browse.mjs', [runId, 'device', `@${stepsPath}`]);
+    await script('browse.mjs', [runId, 'diagnostics', `@${stepsPath}`]);
     await checkMobile({ runDir, evidenceDir, url });
     const after = await fetch(`${url}/api/environment`).then((response) => response.json());
     assert.notEqual(after.data.report.checkedAt, checkedAt);
@@ -157,11 +157,11 @@ for (const simulated of [false, true]) {
       }
       assert.ok(url, log);
       await writeFile(path.join(runDir, 'run.json'), JSON.stringify({
-        runId, url, pid: child.pid, nonce, root, runDir, evidenceDir, dirs, startedAt: new Date().toISOString(),
+        runId, url, pid: child.pid, nonce, root, runDir, evidenceDir, dirs, hostMode: simulated ? 'fixture' : 'none', startedAt: new Date().toISOString(),
       }));
       await script('doctor.mjs', [runId]);
       await writeFile(stepsPath, JSON.stringify([
-        { goto: '#/device' }, { waitText: '修复结果未知，已禁止重复提交', timeout: 60000 },
+        { goto: '#/settings/diagnostics' }, { waitText: '修复结果未知，已禁止重复提交', timeout: 60000 },
         { eval: "(() => { const b = [...document.querySelectorAll('button')].find(b => b.textContent.includes('让 Floatboat 助手修复')); if (!b?.disabled) throw new Error('repair must be disabled'); return true; })()" },
         { aria: 'unknown.aria.txt' }, { screenshot: 'unknown.png' },
       ]));
@@ -171,13 +171,13 @@ for (const simulated of [false, true]) {
       assert.equal(blocked.data.idempotencyKey, starts[0].input.idempotencyKey);
       recoveryMode = 'running';
       await writeFile(stepsPath, JSON.stringify([
-        { goto: '#/device' }, { waitText: '修复中', timeout: 60000 },
+        { goto: '#/settings/diagnostics' }, { waitText: '修复中', timeout: 60000 },
         { aria: 'running.aria.txt' }, { screenshot: 'running.png' },
       ]));
       await script('browse.mjs', [runId, 'restart-running', `@${stepsPath}`]);
       recoveryMode = 'completed';
       await writeFile(stepsPath, JSON.stringify([
-        { goto: '#/device' }, { waitText: '已重新检测', timeout: 60000 },
+        { goto: '#/settings/diagnostics' }, { waitText: '已重新检测', timeout: 60000 },
         { aria: 'completed.aria.txt' }, { screenshot: 'completed.png' },
       ]));
       await script('browse.mjs', [runId, 'restart-completed', `@${stepsPath}`]);
@@ -189,10 +189,11 @@ for (const simulated of [false, true]) {
     } else {
       const denied = await fetch(`${url}/api/environment/repair`, { method: 'POST' }).then((response) => response.json());
       assert.equal(denied.ok, false);
-      assert.match(denied.error, /agent 不可用/);
+      assert.match(denied.error, /Floatboat 助手暂不可用/);
+      assert.match(denied.detail ?? '', /agent 不可用/);
       await writeFile(path.join(evidenceDir, 'repair-denied.json'), JSON.stringify(denied, null, 2));
     }
-    assert.equal((await readFile(path.join(evidenceDir, 'device', 'console.log'), 'utf8')).trim(), '');
+    assert.equal((await readFile(path.join(evidenceDir, 'diagnostics', 'console.log'), 'utf8')).trim(), '');
     await writeFile(path.join(evidenceDir, 'environment.json'), JSON.stringify(after, null, 2));
     await writeFile(path.join(evidenceDir, 'host-fixture-requests.json'), JSON.stringify(requests, null, 2));
     await writeFile(path.join(evidenceDir, 'server.log'), log);
diff --git a/tests/environment-repair.test.ts b/tests/environment-repair.test.ts
index a95e3de..888c31d 100644
--- a/tests/environment-repair.test.ts
+++ b/tests/environment-repair.test.ts
@@ -23,7 +23,7 @@ test('unavailable agent cannot submit a task', async (t) => {
   const repair = createEnvironmentRepair({
     host: createHostClient(undefined), report: async () => report, workingDirectory: '/app', store: testStore(t),
   });
-  await assert.rejects(repair.start(), /agent 不可用/);
+  await assert.rejects(repair.start(), /Floatboat 助手暂不可用/);
   assert.equal(repair.get().status, 'idle');
   repair.dispose();
 });
diff --git a/tests/http-envelope.test.ts b/tests/http-envelope.test.ts
new file mode 100644
index 0000000..5e2bef2
--- /dev/null
+++ b/tests/http-envelope.test.ts
@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { AppError } from '../src/contracts/errors.ts';
+import { BadInput } from '../src/contracts/input.ts';
+import { api, toFailure } from '../src/server/http.ts';
+
+function systemError(code: string, syscall: string, message: string): NodeJS.ErrnoException {
+  return Object.assign(new Error(message), { code, syscall, errno: -2 });
+}
+
+test('AppError passes through with detail and action', () => {
+  const failure = toFailure(new AppError('RUNTIME_MISSING', undefined, 'uv pip install memotalk-sdk'));
+  assert.deepEqual(failure, {
+    ok: false,
+    error: '录音笔组件还没准备好。',
+    code: 'RUNTIME_MISSING',
+    detail: 'uv pip install memotalk-sdk',
+    action: { label: '去诊断与修复', href: '#/settings/diagnostics' },
+  });
+  assert.deepEqual(toFailure(new AppError('NOT_FOUND', '录音不存在')), { ok: false, error: '录音不存在', code: 'NOT_FOUND' });
+});
+
+test('BadInput becomes INVALID_INPUT and keeps its message', () => {
+  assert.deepEqual(toFailure(new BadInput('ids 至少包含 1 条录音')), { ok: false, error: 'ids 至少包含 1 条录音', code: 'INVALID_INPUT' });
+});
+
+test('Node system errors become Chinese headlines; the raw path only appears in detail', () => {
+  const missing = toFailure(systemError('ENOENT', 'open', "ENOENT: no such file or directory, open 'C:\\Users\\x\\a.mp3'"));
+  assert.equal(missing.code, 'FILE_MOVED');
+  assert.equal(missing.error, '文件已被移走或删除。');
+  assert.doesNotMatch(missing.error, /ENOENT|C:\\/);
+  assert.match(missing.detail ?? '', /ENOENT: no such file/);
+
+  const denied = toFailure(systemError('EPERM', 'mkdir', 'EPERM: operation not permitted, mkdir'));
+  assert.equal(denied.code, 'NO_PERMISSION');
+  assert.match(denied.error, /读写权限/);
+  assert.deepEqual(denied.action, { label: '去设置', href: '#/settings' });
+  assert.equal(toFailure(systemError('EACCES', 'open', 'EACCES')).code, 'NO_PERMISSION');
+
+  const full = toFailure(systemError('ENOSPC', 'write', 'ENOSPC: no space left on device'));
+  assert.equal(full.code, 'DISK_FULL');
+  assert.equal(full.error, '磁盘空间不足。');
+  assert.match(full.detail ?? '', /ENOSPC/);
+
+  const other = toFailure(systemError('ECONNRESET', 'read', 'read ECONNRESET'));
+  assert.equal(other.code, 'INTERNAL_ERROR');
+  assert.equal(other.error, '操作没有完成，请重试。');
+  assert.match(other.detail ?? '', /ECONNRESET/);
+});
+
+test('business errors with a string code keep their message without detail', () => {
+  const failure = toFailure(Object.assign(new Error('任务已在队列中'), { code: 'BUSY' }));
+  assert.deepEqual(failure, { ok: false, error: '任务已在队列中', code: 'BUSY' });
+});
+
+test('unknown exceptions show a generic headline and keep the stack in detail', () => {
+  const failure = toFailure(new TypeError("Cannot read properties of undefined (reading 'x')"));
+  assert.equal(failure.code, 'INTERNAL_ERROR');
+  assert.equal(failure.error, '操作没有完成，请重试。');
+  assert.match(failure.detail ?? '', /TypeError: Cannot read properties/);
+  assert.ok((failure.detail ?? '').length <= 2000);
+  const thrown = toFailure('plain string');
+  assert.equal(thrown.error, '操作没有完成，请重试。');
+  assert.equal(thrown.detail, 'plain string');
+});
+
+test('api() wraps results and failures in the shared envelope', async () => {
+  const context = {} as Parameters<ReturnType<typeof api>>[0];
+  assert.deepEqual(await api(() => 42)(context), { ok: true, data: 42 });
+  assert.deepEqual(await api(async () => {
+    throw new AppError('DEVICE_BUSY');
+  })(context), { ok: false, error: '录音笔正在同步或用于实时字幕，请等它结束后再试。', code: 'DEVICE_BUSY' });
+});
diff --git a/tests/mobile-preflight.mjs b/tests/mobile-preflight.mjs
index 8969659..8a0ac20 100644
--- a/tests/mobile-preflight.mjs
+++ b/tests/mobile-preflight.mjs
@@ -45,7 +45,7 @@ export async function checkMobile(run) {
     });
     await send('Runtime.enable');
     await send('Emulation.setDeviceMetricsOverride', { width: 390, height: 844, deviceScaleFactor: 1, mobile: false });
-    await send('Page.navigate', { url: `${run.url}/#/device` });
+    await send('Page.navigate', { url: `${run.url}/#/settings/diagnostics` });
     let ready = false;
     for (let attempt = 0; attempt < 120 && !ready; attempt++) {
       const value = await send('Runtime.evaluate', { expression: '!!document.querySelector("[data-preflight-id=system]")', returnByValue: true });
@@ -55,6 +55,11 @@ export async function checkMobile(run) {
     assert.ok(ready, 'mobile preflight rendered');
     const measured = await send('Runtime.evaluate', { returnByValue: true, expression: `({
       viewport: innerWidth,
+      nav: [...document.querySelectorAll('nav[aria-label="主导航"] button')].map(button => {
+        button.scrollIntoView({ inline: 'nearest', block: 'nearest' });
+        const box = button.getBoundingClientRect();
+        return { label: button.innerText.trim(), reachable: box.width > 0 && box.height > 0 && box.left >= 0 && box.right <= innerWidth + 1 };
+      }),
       width: document.documentElement.scrollWidth,
       rows: [...document.querySelectorAll('.environment-panel .env__row')].map(row => ({
         id: row.dataset.preflightId,
@@ -64,6 +69,8 @@ export async function checkMobile(run) {
       }))
     })` });
     assert.equal(measured.result.value.viewport, 390);
+    assert.deepEqual(measured.result.value.nav.map((item) => item.label.replace(/\s*\d+$/, '')), ['录音', '录音笔', '实时字幕', '日历', '分类', '设置']);
+    assert.ok(measured.result.value.nav.every((item) => item.reachable), JSON.stringify(measured.result.value.nav));
     assert.ok(measured.result.value.width <= 390, JSON.stringify(measured.result.value));
     assert.ok(measured.result.value.rows.every((row) => !row.overflow));
     assert.deepEqual(errors, []);
diff --git a/tests/network-gate.test.ts b/tests/network-gate.test.ts
new file mode 100644
index 0000000..61d1ae1
--- /dev/null
+++ b/tests/network-gate.test.ts
@@ -0,0 +1,112 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { AppError } from '../src/contracts/errors.ts';
+import { NetworkGate } from '../src/server/network-gate.ts';
+import { enqueue, isNetworkTask, useNetworkGate } from '../src/server/queue.ts';
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 10));
+
+test('isNetworkTask only covers transcription and organisation', () => {
+  assert.equal(isNetworkTask('transcribe:1'), true);
+  assert.equal(isNetworkTask('organize:2'), true);
+  assert.equal(isNetworkTask('scan:inbox'), false);
+  assert.equal(isNetworkTask('device:sync'), false);
+});
+
+test('while offline, queued network tasks wait in order and other tasks keep running', async () => {
+  const gate = new NetworkGate();
+  useNetworkGate(gate);
+  try {
+    const release = await gate.acquireOffline('device-hotspot', { waitForInFlightMs: 1000 });
+    assert.ok(release);
+    assert.equal(gate.isOffline(), true);
+    assert.equal(gate.reason(), 'device-hotspot');
+    const order: string[] = [];
+    const done = Promise.withResolvers<void>();
+    enqueue('transcribe:1', async () => {
+      order.push('transcribe:1');
+    });
+    enqueue('organize:1', async () => {
+      order.push('organize:1');
+    });
+    enqueue('scan:inbox', async () => {
+      order.push('scan:inbox');
+      done.resolve();
+    });
+    await tick();
+    // The serial queue holds behind the first network task; nothing has failed.
+    assert.deepEqual(order, []);
+    assert.throws(() => gate.assertOnline(), (error: unknown) => error instanceof AppError && error.code === 'NETWORK_PAUSED');
+    release();
+    release(); // idempotent
+    await done.promise;
+    assert.deepEqual(order, ['transcribe:1', 'organize:1', 'scan:inbox']);
+    assert.equal(gate.isOffline(), false);
+    gate.assertOnline();
+  } finally {
+    useNetworkGate(new NetworkGate());
+  }
+});
+
+test('non-network work is not blocked by the gate', async () => {
+  const gate = new NetworkGate();
+  useNetworkGate(gate);
+  try {
+    const release = await gate.acquireOffline('device-hotspot', { waitForInFlightMs: 1000 });
+    const done = Promise.withResolvers<string>();
+    enqueue('scan:inbox', async () => done.resolve('ran'));
+    assert.equal(await done.promise, 'ran');
+    release?.();
+  } finally {
+    useNetworkGate(new NetworkGate());
+  }
+});
+
+test('acquireOffline waits for in-flight network tasks before going offline', async () => {
+  const gate = new NetworkGate();
+  const running = Promise.withResolvers<void>();
+  const task = gate.runNetworkTask(() => running.promise);
+  assert.equal(gate.runningNetworkTasks(), 1);
+  let acquired = false;
+  const pending = gate.acquireOffline('device-hotspot', { waitForInFlightMs: 5000 }).then((release) => {
+    acquired = true;
+    return release;
+  });
+  await tick();
+  assert.equal(acquired, false);
+  // The gate is already closed: new tasks queue instead of starting.
+  assert.equal(gate.isOffline(), true);
+  let lateStarted = false;
+  const late = gate.runNetworkTask(async () => {
+    lateStarted = true;
+  });
+  await tick();
+  assert.equal(lateStarted, false);
+  running.resolve();
+  await task;
+  const release = await pending;
+  assert.ok(release);
+  assert.equal(acquired, true);
+  assert.equal(lateStarted, false);
+  release();
+  await late;
+  assert.equal(lateStarted, true);
+});
+
+test('acquireOffline times out, reopens the gate and returns null', async () => {
+  const gate = new NetworkGate();
+  const running = Promise.withResolvers<void>();
+  const task = gate.runNetworkTask(() => running.promise);
+  const release = await gate.acquireOffline('device-hotspot', { waitForInFlightMs: 30 });
+  assert.equal(release, null);
+  assert.equal(gate.isOffline(), false);
+  gate.assertOnline();
+  running.resolve();
+  await task;
+  // A second holder is refused while the first one is active.
+  const first = await gate.acquireOffline('a', { waitForInFlightMs: 10 });
+  assert.ok(first);
+  assert.equal(await gate.acquireOffline('b', { waitForInFlightMs: 10 }), null);
+  first();
+  assert.equal(gate.isOffline(), false);
+});
diff --git a/tests/pipeline-errors.test.ts b/tests/pipeline-errors.test.ts
new file mode 100644
index 0000000..db674bc
--- /dev/null
+++ b/tests/pipeline-errors.test.ts
@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { ERROR_COPY } from '../src/contracts/errors.ts';
+import { OrganizeError } from '../src/server/organize.ts';
+import { describeError } from '../src/server/pipeline.ts';
+import { TranscribeError } from '../src/server/transcribe.ts';
+
+test('an ASR error behind an empty transcript shows Chinese copy and keeps the engine text in detail', () => {
+  const failure = describeError(new TranscribeError('ASR_UNSTABLE', '识别接口返回错误：upstream 502 Bad Gateway'));
+  assert.equal(failure.code, 'ASR_UNSTABLE');
+  assert.equal(failure.message, ERROR_COPY.ASR_UNSTABLE.message);
+  assert.doesNotMatch(failure.message, /502|Bad Gateway/);
+  assert.match(failure.detail ?? '', /upstream 502 Bad Gateway/);
+
+  const empty = describeError(new TranscribeError('ASR_EMPTY', '没有识别到可用的语音内容'));
+  assert.equal(empty.code, 'ASR_EMPTY');
+  assert.match(empty.message, /没有识别到可用的语音内容/);
+});
+
+test('an unmapped raw Host code never reaches the main line', () => {
+  const hostError = Object.assign(new Error('stream closed by peer (code=1011)'), { code: 'STREAM_RESET', requestId: 'r-1' });
+  const transcribe = describeError(hostError, 'transcribe');
+  assert.equal(transcribe.code, 'ASR_START_FAILED');
+  assert.equal(transcribe.message, ERROR_COPY.ASR_START_FAILED.message);
+  assert.match(transcribe.detail ?? '', /STREAM_RESET: stream closed by peer/);
+  assert.match(transcribe.detail ?? '', /requestId=r-1/);
+
+  const organize = describeError(hostError, 'organize');
+  assert.equal(organize.code, 'INTERNAL_ERROR');
+  assert.equal(organize.message, ERROR_COPY.INTERNAL_ERROR.message);
+});
+
+test('business errors raised by the app keep their own Chinese message', () => {
+  const missing = describeError(new OrganizeError('NO_TRANSCRIPT', '还没有转写文本，请先完成转录'), 'organize');
+  assert.deepEqual([missing.code, missing.message], ['NO_TRANSCRIPT', '还没有转写文本，请先完成转录']);
+  const timeout = describeError(new TranscribeError('TRANSCRIBE_TIMEOUT', '单次转录超过 60 分钟，已中止'));
+  assert.deepEqual([timeout.code, timeout.message], ['TRANSCRIBE_TIMEOUT', '单次转录超过 60 分钟，已中止']);
+  // 已有统一文案的 code 使用统一文案。
+  const paused = describeError(Object.assign(new Error('network gate held by device-hotspot'), { code: 'NETWORK_PAUSED' }));
+  assert.equal(paused.message, ERROR_COPY.NETWORK_PAUSED.message);
+});
diff --git a/tests/pipeline-routes.test.ts b/tests/pipeline-routes.test.ts
index cc7cd7e..057166f 100644
--- a/tests/pipeline-routes.test.ts
+++ b/tests/pipeline-routes.test.ts
@@ -35,7 +35,9 @@ test('HTTP enqueue exposes waiting tasks, rejects duplicates, and publishes term
         (1, 'one.mp3', 'one', 'one.mp3', 'ready', 'text'),
         (2, 'two.mp3', 'two', 'two.mp3', 'transcribed', 'text'),
         (3, 'three.mp3', 'three', 'three.mp3', 'ready', 'text'),
-        (4, 'four.mp3', 'four', 'four.mp3', 'transcribed', 'text');
+        (4, 'four.mp3', 'four', 'four.mp3', 'transcribed', 'text'),
+        (5, 'five.mp3', 'five', 'five.mp3', 'ready', 'text'),
+        (6, 'six.mp3', 'six', NULL, 'pending', NULL);
     `);
     const { url } = await app.listen();
     const get = async (route: string) => (await fetch(`${url}${route}`)).json();
@@ -56,17 +58,24 @@ test('HTTP enqueue exposes waiting tasks, rejects duplicates, and publishes term
       { accepted: 1, skipped: 2, ids: [3] });
     assert.deepEqual((await post('/api/recordings/batch/organize', { ids: [1, 2, 4] })).data,
       { accepted: 1, skipped: 2, ids: [4] });
+    // The {stage} form selects every recording at that stage on the server; queued ones are skipped.
+    assert.deepEqual((await post('/api/recordings/batch/transcribe', { stage: 'ready' })).data,
+      { accepted: 1, skipped: 2, ids: [5] });
+    assert.deepEqual((await post('/api/recordings/batch/organize', { stage: 'transcribed' })).data,
+      { accepted: 0, skipped: 2, ids: [] });
+    assert.equal((await post('/api/recordings/batch/organize', { stage: 'ready' })).code, 'INVALID_INPUT');
+    assert.equal((await post('/api/recordings/batch/transcribe', { stage: 'pending' })).code, 'INVALID_INPUT');
     const list = (await get('/api/recordings?stage=failed&limit=1')).data;
     assert.equal(list.items.length, 0);
     assert.equal(list.hasActiveTasks, true);
 
     // Exercise the real pipeline's preflight failure without requiring ffmpeg or audio.
-    app.database.exec('UPDATE recordings SET storage_path = NULL WHERE id IN (1, 3)');
+    app.database.exec('UPDATE recordings SET storage_path = NULL WHERE id IN (1, 3, 5)');
     enqueue('test:drain', async () => drained.resolve());
     drainQueued = true;
     blocker.resolve();
     await drained.promise;
-    for (const id of [1, 3]) {
+    for (const id of [1, 3, 5]) {
       const detail = (await get(`/api/recordings/${id}`)).data;
       assert.equal(detail.recording.status, 'failed');
       assert.match(detail.lastError, /音频文件/);
@@ -74,7 +83,10 @@ test('HTTP enqueue exposes waiting tasks, rejects duplicates, and publishes term
     for (const id of [2, 4]) {
       const detail = (await get(`/api/recordings/${id}`)).data;
       assert.equal(detail.recording.status, 'transcribed');
-      assert.match(detail.lastError, /HOST_NOT_CONNECTED/);
+      // The headline is Chinese; the Host code only appears in the detail layer.
+      assert.doesNotMatch(detail.lastError, /HOST_NOT_CONNECTED/);
+      assert.equal(detail.lastErrorCode, 'LLM_UNAVAILABLE');
+      assert.match(detail.lastErrorDetail, /HOST_NOT_CONNECTED/);
       assert.equal(detail.jobs[0].status, 'failure');
     }
     assert.equal((await get('/api/recordings')).data.hasActiveTasks, false);
diff --git a/tests/preflight.test.ts b/tests/preflight.test.ts
index a15a12d..218b544 100644
--- a/tests/preflight.test.ts
+++ b/tests/preflight.test.ts
@@ -16,6 +16,18 @@ test('dependency failures expose actions but healthy dependencies do not offer r
   assert.match(result.find((item) => item.id === 'sdk')?.action ?? '', /uv run/);
 });
 
+test('items are grouped and labels stay free of package names; raw probe text lives in detail', () => {
+  const failed = { ok: false, detail: "ModuleNotFoundError: No module named 'memotalk' (uv pip install memotalk-sdk bleak)", resolvedPath: null };
+  const items = dependencyChecks({ python: failed, bleak: failed, sdk: failed, ffmpeg: failed, checkedAt: '' });
+  assert.deepEqual(items.map((item) => item.group), ['device', 'device', 'device', 'audio']);
+  for (const item of items) {
+    assert.doesNotMatch(`${item.label} ${item.reason}`, /bleak|memotalk|uv |ModuleNotFound/i, item.id);
+    assert.match(item.detail ?? '', /memotalk-sdk/);
+  }
+  assert.equal(capabilityCheck('asr', []).group, 'ai');
+  assert.equal(capabilityCheck('llm', []).label, 'AI 整理');
+});
+
 for (const platform of ['win32', 'darwin', 'linux'] as const) {
   test(`${platform}: cache and concurrent refresh run only one inspection`, async () => {
     let calls = 0;
@@ -58,7 +70,7 @@ test('Host checks require actual operations and declaration; unavailable Host is
     throw new Error('HOST_NOT_CONNECTED');
   } } });
   assert.deepEqual(calls.sort(), ['agent', 'asr', 'llm']);
-  assert.ok(result.every((item) => item.status === 'warn' && /HOST_NOT_CONNECTED/.test(item.reason)));
+  assert.ok(result.every((item) => item.status === 'warn' && /HOST_NOT_CONNECTED/.test(item.detail ?? '') && !/HOST_NOT_CONNECTED/.test(item.reason)));
 });
 
 test('directory probe creates only its marker and removes it; blocked paths fail', async () => {
diff --git a/tests/router.test.ts b/tests/router.test.ts
new file mode 100644
index 0000000..19a1180
--- /dev/null
+++ b/tests/router.test.ts
@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { buildHash, DEFAULT_ROUTE, navKey, parseHash, type Route } from '../src/ui/router.ts';
+
+test('each nav page parses and round-trips', () => {
+  const routes: Route[] = [
+    { name: 'library' },
+    { name: 'library', stage: 'failed' },
+    { name: 'library', stage: 'ready' },
+    { name: 'device' },
+    { name: 'live' },
+    { name: 'calendar' },
+    { name: 'calendar', day: '2026-11-08' },
+    { name: 'calendar', day: '2026-11-08', rec: 12 },
+    { name: 'categories' },
+    { name: 'settings' },
+    { name: 'settings', section: 'diagnostics' },
+    { name: 'detail', id: 7 },
+  ];
+  for (const route of routes) assert.deepEqual(parseHash(buildHash(route)), route, buildHash(route));
+  assert.equal(buildHash({ name: 'calendar', day: '2026-11-08', rec: 3 }), '#/calendar?day=2026-11-08&rec=3');
+  assert.equal(buildHash({ name: 'settings', section: 'diagnostics' }), '#/settings/diagnostics');
+  assert.equal(buildHash({ name: 'library', stage: 'transcribed' }), '#/library?stage=transcribed');
+  assert.deepEqual(DEFAULT_ROUTE, { name: 'library' });
+});
+
+test('removed and unknown hashes return null so the app rewrites them to #/library', () => {
+  for (const hash of ['', '#', '#/', '#/overview', '#/nope', '#/rec/', '#/rec/abc', '#/rec/0', '#/rec/-3', '#/settings/paths']) {
+    assert.equal(parseHash(hash), null, hash);
+  }
+});
+
+test('invalid query values are dropped instead of breaking the page', () => {
+  assert.deepEqual(parseHash('#/library?stage=bogus'), { name: 'library' });
+  assert.deepEqual(parseHash('#/calendar?day=11/08/2026&rec=x'), { name: 'calendar' });
+  assert.deepEqual(parseHash('#/calendar?rec=5'), { name: 'calendar', rec: 5 });
+  assert.deepEqual(parseHash('#device'), { name: 'device' });
+});
+
+test('navKey highlights library for details and settings for its sub-route', () => {
+  assert.equal(navKey({ name: 'detail', id: 1 }), 'library');
+  assert.equal(navKey({ name: 'settings', section: 'diagnostics' }), 'settings');
+  assert.equal(navKey({ name: 'calendar', day: '2026-11-08', rec: 1 }), 'calendar');
+  for (const name of ['library', 'device', 'live', 'categories', 'settings'] as const) {
+    assert.equal(navKey({ name } as Route), name);
+  }
+});
diff --git a/tests/sdk.test.ts b/tests/sdk.test.ts
index 1db3816..43889dc 100644
--- a/tests/sdk.test.ts
+++ b/tests/sdk.test.ts
@@ -1,15 +1,17 @@
 import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdtemp, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { test } from 'node:test';
-import { parseStatus, probeSdk, pythonRuntimeEnv } from '../src/server/bridge.ts';
-import { SDK_ACTION_SCRIPT } from '../src/server/sdk-script.ts';
+import { probeSdk, pythonRuntimeEnv } from '../src/server/runtime-probe.ts';
+import { attachWorker, writeWorkerFiles, type WorkerEvent, type WorkerHandle } from '../src/server/device/worker.ts';
 import { LIVE_CAPTION_SCRIPT } from '../src/server/live-script.ts';
 
 const python = process.env.MEMOTALK_TEST_PYTHON;
 const simulated = { skip: !python && 'Set MEMOTALK_TEST_PYTHON to a Python with memotalk-sdk installed' };
+const SECRETS = ['TESTwifi', 'ESqn3Dvc'];
 const setup = `
 import memotalk
 from memotalk.fake import FakeMemoTalk, FakeTransport
@@ -27,6 +29,149 @@ function execute(script: string, args: string[] = [], prefix = setup) {
   });
 }
 
+/**
+ * Test prelude: SDK simulator + recorded subprocess calls. Network commands never run; their
+ * argv lands in calls.json so each platform's join/restore sequence can be asserted anywhere.
+ */
+function testPrelude(options: { files?: Array<[string, number]>; wifiOn?: boolean; ignoreClose?: number; joinFails?: boolean; locationDenied?: boolean; slowFtp?: boolean; probes?: boolean[]; restoreWait?: number } = {}) {
+  const files = options.files ?? [['REC20261020_103000.mp3', 40_000], ['REC20261020_143000.mp3', 30_000]];
+  return `
+import json, subprocess, sys, time
+from pathlib import Path
+import memotalk
+from memotalk.client import NetworkSession
+from memotalk.fake import FakeMemoTalk, FakeTransport, make_file_entry
+worker = sys.modules["__main__"]
+device = FakeMemoTalk(files=[make_file_entry(n, size=s) for n, s in ${JSON.stringify(files)}])
+device.wifi_on = ${options.wifiOn ? 'True' : 'False'}
+device.wifi_ignore_close = ${options.ignoreClose ?? 0}
+transport = FakeTransport(device)
+real_client = memotalk.MemoTalkClient
+memotalk.MemoTalkClient = lambda **kwargs: real_client(transport=transport)
+calls_path = worker.STATE_DIR / "calls.json"
+
+class Done:
+    def __init__(self, code=0, out=b"", err=b""):
+        self.returncode, self.stdout, self.stderr = code, out, err
+
+def fake_run(args, *rest, **kwargs):
+    args = [str(a) for a in args]
+    record = {"argv": args}
+    for a in args:
+        if a.startswith("filename="):
+            xml = Path(a.split("=", 1)[1]).read_text(encoding="utf-8")
+            record["xmlHasHex"] = "<hex>" in xml and "manual" in xml
+    if args[:2] == ["nmcli", "--wait"]:
+        record["passwdFile"] = Path(args[-1]).exists()
+    calls = json.loads(calls_path.read_text()) if calls_path.exists() else []
+    calls.append(record)
+    calls_path.write_text(json.dumps(calls))
+    if args[:4] == ["netsh", "wlan", "show", "interfaces"]:
+        if ${options.locationDenied ? 'True' : 'False'}:
+            return Done(1, b"Network shell commands need location permission to access WLAN information.")
+        return Done(0, "    Name                   : Wi-Fi\\n    Profile                : HomeNet\\n".encode())
+    if args[:2] == ["networksetup", "-listallhardwareports"]:
+        return Done(0, b"Hardware Port: Wi-Fi\\nDevice: en1\\n")
+    if ${options.joinFails ? 'True' : 'False'} and ("connect" in args or "up" in args):
+        return Done(1, b"", b"join refused")
+    return Done(0)
+
+subprocess.run = fake_run
+NetworkSession.join_hotspot = lambda self, iface="en0", wait=15.0: "192.168.4.2"
+worker.wait_reachable = lambda host, port, timeout, cancelled: True
+probe_results = ${JSON.stringify((options.probes ?? [true]).map((value) => (value ? 1 : 0)))}
+probe_path = worker.STATE_DIR / "probes.json"
+
+def fake_usable():
+    probes = json.loads(probe_path.read_text()) if probe_path.exists() else []
+    result = bool(probe_results[min(len(probes), len(probe_results) - 1)])
+    probes.append(result)
+    probe_path.write_text(json.dumps(probes))
+    return result
+
+worker.network_usable = fake_usable
+worker.NETWORK_RESTORE_WAIT = ${options.restoreWait ?? 10}
+
+class FakeFtp:
+    def _entry(self, name):
+        return next((f for f in device.files if f.name == name), None)
+    def retrlines(self, cmd, cb):
+        for f in device.files:
+            cb("-rw-r--r-- 1 ftp ftp %d Oct 20 10:30 %s" % (f.size, f.name.lower()))
+    def voidcmd(self, cmd):
+        return "200"
+    def size(self, name):
+        return self._entry(name.upper().replace(".MP3", ".mp3")).size
+    def retrbinary(self, cmd, cb, blocksize=8192):
+        entry = self._entry(cmd.split(" ", 1)[1].upper().replace(".MP3", ".mp3"))
+        data = device._file_bytes(entry)
+        for i in range(0, len(data), 4096):
+            if ${options.slowFtp ? 'True' : 'False'}:
+                time.sleep(0.05)
+            cb(data[i:i + 4096])
+    def close(self):
+        pass
+
+NetworkSession.open_ftp = lambda self, timeout=10.0: FakeFtp()
+`;
+}
+
+interface Harness {
+  worker: WorkerHandle;
+  root: string;
+  stateDir: string;
+  events: WorkerEvent[];
+  output: () => string;
+  calls: () => Promise<Array<{ argv: string[]; xmlHasHex?: boolean; passwdFile?: boolean }>>;
+  close: () => Promise<void>;
+}
+
+async function harness(prelude: string, netPlatform?: string, preexisting?: (stateDir: string) => Promise<void>): Promise<Harness> {
+  assert.ok(python);
+  const root = await mkdtemp(path.join(os.tmpdir(), 'openminutes-worker-'));
+  const stateDir = path.join(root, 'state');
+  const { script } = await writeWorkerFiles(stateDir, {});
+  await preexisting?.(stateDir);
+  const preludePath = path.join(stateDir, 'test_prelude.py');
+  await writeFile(preludePath, prelude, 'utf8');
+  const args = ['-X', 'utf8', '-u', script, '--state-dir', stateDir, '--fake-prelude', preludePath];
+  if (netPlatform) args.push('--net-platform', netPlatform);
+  const child = spawn(python, args, { windowsHide: true, env: await pythonRuntimeEnv(python) });
+  let raw = '';
+  child.stdout.on('data', (chunk: Buffer) => { raw += chunk.toString('utf8'); });
+  child.stderr.on('data', (chunk: Buffer) => { raw += chunk.toString('utf8'); });
+  const worker = attachWorker(child);
+  const events: WorkerEvent[] = [];
+  worker.onEvent((event) => events.push(event));
+  return {
+    worker, root, stateDir, events,
+    output: () => raw,
+    calls: async () => {
+      const file = path.join(stateDir, 'calls.json');
+      return existsSync(file) ? JSON.parse(await readFile(file, 'utf8')) : [];
+    },
+    close: async () => {
+      await worker.close(5000);
+      await rm(root, { recursive: true, force: true });
+    },
+  };
+}
+
+type PullResult = { files: Array<{ name: string; ok: boolean; path?: string; sizeBytes?: number; transport?: string; error?: { kind: string } }>; cancelled: boolean };
+
+async function connectAndList(h: Harness) {
+  await h.worker.request('connect', {}, { timeoutMs: 20000 });
+  return h.worker.request<{ files: Array<{ name: string; sizeBytes: number }> }>('list', {}, { timeoutMs: 20000 });
+}
+
+function pullArgs(h: Harness, files: Array<{ name: string; sizeBytes: number }>, transport: 'wifi' | 'ble') {
+  return { files: files.map((file) => ({ name: file.name, size: file.sizeBytes })), outDir: path.join(h.root, 'out'), transport };
+}
+
+function assertNoSecrets(h: Harness) {
+  for (const secret of SECRETS) assert.ok(!h.output().includes(secret), `worker output leaked ${secret}`);
+}
+
 test('missing Python reports SDK unavailable', async () => {
   assert.equal((await probeSdk(null)).ok, false);
 });
@@ -50,35 +195,318 @@ test('installed package is probed using the selected interpreter', simulated, as
   assert.match(probe.detail, /memotalk-sdk/);
 });
 
-test('SDK status adapter preserves the device report contract', simulated, () => {
-  const result = execute(SDK_ACTION_SCRIPT, ['--action', 'status']);
-  assert.equal(result.status, 0, result.stderr);
-  const status = parseStatus(result.stdout);
-  assert.equal(status?.serial, 'L0m0J06000074305');
-  assert.equal(status?.batteryPct, 50);
-  assert.equal(status?.firmware, '2.0.6');
-  assert.equal(status?.freeSpacePct, 99);
-  assert.equal(status?.hotspotSsid, 'MemoTalk-S1-TEST');
-});
-
-test('SDK list and download use package APIs without a source directory', simulated, async () => {
-  const list = execute(SDK_ACTION_SCRIPT, ['--action', 'list']);
-  assert.equal(list.status, 0, list.stderr);
-  assert.match(list.stdout, /格式=MP3.*大小=\d+ B.*时长=\d+s.*时间戳=\d+/);
-  const root = await mkdtemp(path.join(os.tmpdir(), 'openminutes-download-'));
+test('worker connect syncs time, closes a leftover hotspot, and reports status and listing as JSON', simulated, async () => {
+  const h = await harness(testPrelude({ wifiOn: true }));
   try {
-    const name = /1\. (.*?) \|/.exec(list.stdout)?.[1];
-    assert.ok(name);
-    const download = execute(SDK_ACTION_SCRIPT, ['--action', 'download', '--file', name, '--out-dir', root]);
-    assert.equal(download.status, 0, download.stderr);
-    assert.ok((await readFile(path.join(root, name))).length > 0);
-    const missing = execute(SDK_ACTION_SCRIPT, ['--action', 'download', '--file', 'missing.mp3', '--out-dir', root]);
-    assert.equal(missing.status, 1);
-    assert.match(missing.stderr, /\[X\]/);
-    const invalid = execute(SDK_ACTION_SCRIPT, ['--action', 'download']);
-    assert.equal(invalid.status, 2);
+    const connected = await h.worker.request<{ hotspotWasOn: boolean; timeSynced: boolean }>('connect', {}, { timeoutMs: 20000 });
+    assert.equal(connected.hotspotWasOn, true);
+    assert.equal(connected.timeSynced, true);
+    const status = await h.worker.request<{ serial: string; batteryPct: number; freeSpacePct: number; recordingState: string }>('status', {}, { timeoutMs: 20000 });
+    assert.equal(status.serial, 'L0m0J06000074305');
+    assert.equal(status.freeSpacePct, 99);
+    assert.equal(status.recordingState, 'STOPPED');
+    const listed = await h.worker.request<{ files: Array<{ name: string; sizeBytes: number; format: string }> }>('list', {}, { timeoutMs: 20000 });
+    assert.deepEqual(listed.files.map((file) => [file.name, file.sizeBytes, file.format]),
+      [['REC20261020_103000.mp3', 40000, 'MP3'], ['REC20261020_143000.mp3', 30000, 'MP3']]);
   } finally {
-    await rm(root, { recursive: true, force: true });
+    await h.close();
+  }
+});
+
+test('BLE pull writes files and reports their path and size; delete removes them from the device', simulated, async () => {
+  const h = await harness(testPrelude());
+  try {
+    const listed = await connectAndList(h);
+    const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'ble'), { timeoutMs: 60000 });
+    for (const file of pulled.files) {
+      assert.equal(file.ok, true);
+      assert.equal(file.transport, 'ble');
+      assert.equal((await stat(file.path!)).size, file.sizeBytes);
+    }
+    const deleted = await h.worker.request<{ files: Array<{ ok: boolean }> }>('delete', { names: [listed.files[0].name, 'missing.mp3'] }, { timeoutMs: 20000 });
+    assert.deepEqual(deleted.files.map((file) => file.ok), [true, false]);
+    const after = await h.worker.request<{ files: unknown[] }>('list', {}, { timeoutMs: 20000 });
+    assert.equal(after.files.length, 1);
+  } finally {
+    await h.close();
+  }
+});
+
+test('Windows Wi-Fi pull joins with a temporary manual profile, restores the original network, and never leaks secrets', simulated, async () => {
+  const h = await harness(testPrelude(), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+    assert.deepEqual(pulled.files.map((file) => [file.ok, file.transport]), [[true, 'wifi'], [true, 'wifi']]);
+    for (const file of pulled.files) assert.equal((await stat(file.path!)).size, file.sizeBytes);
+    const calls = await h.calls();
+    const verbs = calls.map((call) => call.argv.slice(0, 3).join(' '));
+    assert.deepEqual(verbs, ['netsh wlan show', 'netsh wlan add', 'netsh wlan connect', 'netsh wlan disconnect', 'netsh wlan delete', 'netsh wlan connect']);
+    assert.equal(calls[1].xmlHasHex, true);
+    assert.ok(calls[2].argv.includes('interface=Wi-Fi'));
+    assert.ok(calls[5].argv.includes('name=HomeNet'));
+    const leftovers = await readdir(h.stateDir);
+    assert.ok(!leftovers.some((name) => name.endsWith('.xml')), leftovers.join(','));
+    assert.ok(!leftovers.includes('wifi-restore.json'));
+    assert.ok(!h.events.some((event) => event.event === 'fallback'));
+    assertNoSecrets(h);
+  } finally {
+    await h.close();
+  }
+});
+
+test('Windows without location permission connects without interface and relies on auto-reconnect', simulated, async () => {
+  const h = await harness(testPrelude({ locationDenied: true }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+    assert.ok(pulled.files.every((file) => file.ok && file.transport === 'wifi'));
+    const calls = await h.calls();
+    const connects = calls.filter((call) => call.argv[2] === 'connect');
+    assert.equal(connects.length, 1, 'no explicit reconnect when the original profile is unknown');
+    assert.ok(!connects[0].argv.some((arg) => arg.startsWith('interface=')));
+  } finally {
+    await h.close();
+  }
+});
+
+async function probes(h: Harness): Promise<boolean[]> {
+  const file = path.join(h.stateDir, 'probes.json');
+  return existsSync(file) ? JSON.parse(await readFile(file, 'utf8')) : [];
+}
+
+test('after leaving the hotspot the pull only returns once the original network carries traffic again', simulated, async () => {
+  const h = await harness(testPrelude({ probes: [true, false, false, true] }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+    assert.ok(pulled.files.every((file) => file.ok && file.transport === 'wifi'));
+    assert.deepEqual(await probes(h), [true, false, false, true], 'probed before joining, then polled until usable');
+    assert.ok(!h.events.some((event) => event.event === 'warning'));
+  } finally {
+    await h.close();
+  }
+});
+
+test('a network that does not come back in time is reported, with one extra reconnect on Windows', simulated, async () => {
+  const h = await harness(testPrelude({ probes: [true, false], restoreWait: 1.5 }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+    assert.ok(pulled.files.every((file) => file.ok));
+    const warning = h.events.find((event) => event.event === 'warning');
+    assert.equal(warning?.data.code, 'NETWORK_RESTORE_TIMEOUT');
+    const reconnects = (await h.calls()).filter((call) => call.argv[2] === 'connect' && call.argv.includes('name=HomeNet'));
+    assert.equal(reconnects.length, 2);
+  } finally {
+    await h.close();
+  }
+});
+
+test('a computer that was offline before the sync does not wait for the network afterwards', simulated, async () => {
+  const h = await harness(testPrelude({ probes: [false] }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+    assert.deepEqual(await probes(h), [false]);
+    assert.ok(!h.events.some((event) => event.event === 'warning'));
+  } finally {
+    await h.close();
+  }
+});
+
+test('macOS and Linux join sequences use the platform tools and clean up', simulated, async () => {
+  for (const platform of ['darwin', 'linux'] as const) {
+    const h = await harness(testPrelude(), platform);
+    try {
+      const listed = await connectAndList(h);
+      const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+      assert.ok(pulled.files.every((file) => file.ok && file.transport === 'wifi'), platform);
+      const calls = await h.calls();
+      if (platform === 'darwin') {
+        assert.deepEqual(calls.map((call) => call.argv[0] + ' ' + call.argv[1]),
+          ['networksetup -listallhardwareports', 'networksetup -removepreferredwirelessnetwork']);
+        assert.equal(calls[1].argv[2], 'en1');
+      } else {
+        const up = calls.find((call) => call.argv.includes('up'));
+        assert.equal(up?.passwdFile, true, 'password is passed through a file, not argv');
+        assert.deepEqual(calls.at(-1)?.argv, ['nmcli', 'connection', 'delete', 'openminutes-hotspot']);
+        assert.ok(!(await readdir(h.stateDir)).some((name) => name.endsWith('.pass')));
+      }
+      for (const call of calls) for (const secret of SECRETS) assert.ok(!call.argv.join(' ').includes(secret));
+      assertNoSecrets(h);
+    } finally {
+      await h.close();
+    }
+  }
+});
+
+test('a failed hotspot join falls back to BLE for the remaining files and restores the network', simulated, async () => {
+  const h = await harness(testPrelude({ joinFails: true }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+    assert.deepEqual(pulled.files.map((file) => [file.ok, file.transport]), [[true, 'ble'], [true, 'ble']]);
+    const fallback = h.events.find((event) => event.event === 'fallback');
+    assert.equal(fallback?.data.reason, 'WIFI_JOIN_FAILED');
+    const verbs = (await h.calls()).map((call) => call.argv[2]);
+    assert.ok(verbs.includes('disconnect') && verbs.includes('delete'), verbs.join(','));
+    assert.ok(!existsSync(path.join(h.stateDir, 'wifi-restore.json')));
+    assertNoSecrets(h);
+  } finally {
+    await h.close();
+  }
+});
+
+test('an unconfirmed hotspot close is reported as a warning', simulated, async () => {
+  const h = await harness(testPrelude({ ignoreClose: 10 }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    await h.worker.request<PullResult>('pull', pullArgs(h, listed.files.slice(0, 1), 'wifi'), { timeoutMs: 120000 });
+    const warning = h.events.find((event) => event.event === 'warning');
+    assert.equal(warning?.data.code, 'HOTSPOT_CLOSE_UNCONFIRMED');
+  } finally {
+    await h.close();
+  }
+});
+
+test('cancelling a Wi-Fi transfer still leaves the hotspot network and closes the hotspot', simulated, async () => {
+  const h = await harness(testPrelude({ files: [['REC20261020_103000.mp3', 400_000]], slowFtp: true }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    const pending = h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), {
+      timeoutMs: 60000,
+      onEvent: (event) => { if (event.event === 'progress' && event.data.phase === 'transferring') h.worker.cancel(); },
+    });
+    const pulled = await pending;
+    assert.equal(pulled.cancelled, true);
+    assert.equal(pulled.files.length, 0);
+    const verbs = (await h.calls()).map((call) => call.argv[2]);
+    assert.ok(verbs.includes('disconnect') && verbs.includes('delete'), verbs.join(','));
+    assert.ok(!(await readdir(path.join(h.root, 'out'))).some((name) => name.endsWith('.part')));
+    const status = await h.worker.request<{ recordingState: string }>('status', {}, { timeoutMs: 20000 });
+    assert.equal(status.recordingState, 'STOPPED');
+  } finally {
+    await h.close();
+  }
+});
+
+test('cancelling a BLE transfer tells the device to stop sending', simulated, async () => {
+  const h = await harness(`${testPrelude({ files: [['REC20261020_103000.mp3', 400_000]] })}
+from memotalk.client import FileController
+original_sync_control = FileController.sync_control
+async def sync_control(self, name, op, *args, **kwargs):
+    (worker.STATE_DIR / "cancel.txt").write_text(str(int(op)))
+    return await original_sync_control(self, name, op, *args, **kwargs)
+FileController.sync_control = sync_control
+import asyncio
+async def paced_write(self, channel, frame):
+    responses = self.device.on_write(channel, frame)
+    async def pump():
+        for index, (out_channel, response) in enumerate(responses):
+            if not self._connected:
+                return
+            self._dispatch(out_channel, response)
+            if index % 16 == 15:
+                await asyncio.sleep(0.05)
+    asyncio.get_running_loop().create_task(pump())
+FakeTransport.write = paced_write
+`);
+  try {
+    const listed = await connectAndList(h);
+    const pulled = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'ble'), {
+      timeoutMs: 60000,
+      onEvent: (event) => { if (event.event === 'progress' && event.data.phase === 'transferring') h.worker.cancel(); },
+    });
+    assert.equal(pulled.cancelled, true);
+    assert.equal(await readFile(path.join(h.stateDir, 'cancel.txt'), 'utf8'), '1');
+  } finally {
+    await h.close();
+  }
+});
+
+test('a cancel sent right behind a pull is not lost, and a stale cancel does not stop the next pull', simulated, async () => {
+  const h = await harness(`${testPrelude({ files: [['REC20261020_103000.mp3', 400_000]], slowFtp: true })}
+import asyncio
+original_status = worker.Worker.cmd_status
+async def slow_status(self, req_id, args):
+    await asyncio.sleep(0.5)
+    return await original_status(self, req_id, args)
+worker.Worker.cmd_status = slow_status
+`, 'win32');
+  try {
+    const listed = await connectAndList(h);
+    // 慢的 status 占着设备锁：拉取和取消都在拉取任务真正开始前被读到。
+    // 取消不能被拉取开头的清零吞掉。
+    const busy = h.worker.request('status', {}, { timeoutMs: 20000 });
+    const pending = h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), { timeoutMs: 60000 });
+    h.worker.cancel();
+    await busy;
+    const pulled = await pending;
+    assert.equal(pulled.cancelled, true);
+    assert.equal(pulled.files.length, 0);
+
+    // 没有拉取在跑时收到的取消，不影响下一次拉取。
+    h.worker.cancel();
+    await h.worker.request('status', {}, { timeoutMs: 20000 });
+    const next = await h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'ble'), { timeoutMs: 60000 });
+    assert.equal(next.cancelled, false);
+    assert.deepEqual(next.files.map((file) => file.ok), [true]);
+  } finally {
+    await h.close();
+  }
+});
+
+test('a restore file left by a killed worker is applied at startup', simulated, async () => {
+  const h = await harness(testPrelude(), 'win32', async (stateDir) => {
+    await writeFile(path.join(stateDir, 'wifi-restore.json'),
+      JSON.stringify({ platform: 'win32', iface: 'Wi-Fi', profile: 'HomeNet', ssid: 'MemoTalk-S1-TEST' }));
+  });
+  try {
+    await h.worker.request('connect', {}, { timeoutMs: 20000 });
+    const verbs = (await h.calls()).map((call) => call.argv.slice(2).join(' '));
+    assert.deepEqual(verbs, ['disconnect interface=Wi-Fi', 'delete profile name=MemoTalk-S1-TEST', 'connect name=HomeNet interface=Wi-Fi']);
+    assert.ok(!existsSync(path.join(h.stateDir, 'wifi-restore.json')));
+  } finally {
+    await h.close();
+  }
+});
+
+test('stdin EOF during a hotspot session restores the network before exiting', simulated, async () => {
+  const h = await harness(testPrelude({ files: [['REC20261020_103000.mp3', 400_000]], slowFtp: true }), 'win32');
+  try {
+    const listed = await connectAndList(h);
+    const pending = h.worker.request<PullResult>('pull', pullArgs(h, listed.files, 'wifi'), {
+      timeoutMs: 60000,
+      onEvent: (event) => { if (event.event === 'progress' && event.data.phase === 'transferring') void h.worker.close(30000); },
+    });
+    await pending.catch(() => undefined);
+    await h.worker.close(30000);
+    const verbs = (await h.calls()).map((call) => call.argv[2]);
+    assert.ok(verbs.includes('disconnect') && verbs.includes('delete'), verbs.join(','));
+    assert.ok(!existsSync(path.join(h.stateDir, 'wifi-restore.json')));
+  } finally {
+    await h.close();
+  }
+});
+
+test('a missing recorder is reported with its SDK exception kind', simulated, async () => {
+  const h = await harness(`${testPrelude()}
+from memotalk.fake import FakeTransport as _FT
+class Absent(_FT):
+    async def connect(self, target=None, *, timeout=None):
+        raise memotalk.DeviceNotFound("no MemoTalk S1 found")
+memotalk.MemoTalkClient = lambda **kwargs: real_client(transport=Absent(device))
+`);
+  try {
+    await assert.rejects(h.worker.request('connect', {}, { timeoutMs: 20000 }), (error: { code?: string; detail?: string; message: string }) => {
+      assert.equal(error.code, 'DEVICE_NOT_FOUND');
+      assert.match(error.detail ?? '', /DeviceNotFound/);
+      assert.doesNotMatch(error.message, /DeviceNotFound/);
+      return true;
+    });
+  } finally {
+    await h.close();
   }
 });
 
@@ -137,24 +565,6 @@ sys.exit(code)
   assert.match(result.stderr, /"audio_bytes": 1152/);
 });
 
-test('optional hotspot read failure does not fail the device status report', simulated, () => {
-  const prefix = `${setup}
-from memotalk.client import RawController
-from memotalk.constants import Cmd
-from memotalk.errors import MemoTalkError
-original_request = RawController.request
-async def request(self, frame, **kwargs):
-    if kwargs.get("code") == Cmd.WIFI_SSID:
-        raise MemoTalkError("hotspot unavailable")
-    return await original_request(self, frame, **kwargs)
-RawController.request = request
-`;
-  const result = execute(SDK_ACTION_SCRIPT, ['--action', 'status'], prefix);
-  assert.equal(result.status, 0, result.stderr);
-  assert.equal(parseStatus(result.stdout)?.serial, 'L0m0J06000074305');
-  assert.equal(parseStatus(result.stdout)?.hotspotSsid, null);
-});
-
 test('rejected realtime mode is reported as failure without starting recording', simulated, () => {
   const prefix = `${setup}
 from memotalk.client import RecordController
@@ -169,6 +579,7 @@ RecordController.set_realtime = set_realtime
   const result = execute(LIVE_CAPTION_SCRIPT, [], prefix);
   assert.equal(result.status, 4, result.stderr);
   assert.match(result.stderr, /"event": "error"/);
+  assert.match(result.stderr, /"kind": "RuntimeError"/);
   assert.doesNotMatch(result.stderr, /"event": "recording"|"event": "streaming"/);
   assert.equal(result.stdout, '');
 });
diff --git a/tests/support/device-fixture.ts b/tests/support/device-fixture.ts
new file mode 100644
index 0000000..011356b
--- /dev/null
+++ b/tests/support/device-fixture.ts
@@ -0,0 +1,263 @@
+// ABOUTME: 设备层测试夹具：带 audio 资源的隔离服务器，以及按 worker 协议应答的内存假 worker。
+
+import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createWorkbenchServer, type WorkbenchServer } from '../../sdk/runtime.mjs';
+import { AppError } from '../../src/contracts/errors.ts';
+import { classifyDeviceError } from '../../src/server/device/errors.ts';
+import type { WorkerStatus } from '../../src/server/device/sync.ts';
+import type { RequestOptions, SpawnWorkerOptions, WorkerCommand, WorkerEvent, WorkerHandle } from '../../src/server/device/worker.ts';
+import { writeSetting } from '../../src/server/sql.ts';
+
+export const SERIAL = 'MT-TEST-0001';
+export const MiB = 1_048_576;
+
+// 每个测试都会新建一个服务器实例，它们各自注册进程信号监听。
+process.setMaxListeners(Math.max(process.getMaxListeners(), 64));
+
+export interface TestApp {
+  app: WorkbenchServer;
+  root: string;
+  libraryDir: string;
+  close(): Promise<void>;
+}
+
+export async function createTestApp(prefix: string): Promise<TestApp> {
+  const root = await mkdtemp(path.join(os.tmpdir(), `openminutes-${prefix}-`));
+  await cp(new URL('../../migrations/', import.meta.url), path.join(root, 'migrations'), { recursive: true });
+  await writeFile(path.join(root, 'manifest.json'), JSON.stringify({
+    appId: `${prefix}-test`, name: 'test', version: '1',
+    server: fileURLToPath(import.meta.url), ui: '.', migrations: 'migrations',
+    resources: [{ id: 'audio', kind: 'directory', role: 'data', location: 'data', path: 'audio', access: 'read-write', required: true }],
+  }));
+  const configPath = path.join(root, 'config.json');
+  await writeFile(configPath, JSON.stringify({
+    appId: `${prefix}-test`, generation: '1', nonce: 'test', sourceDirectory: root, dataDirectory: path.join(root, 'data'),
+  }));
+  const app = await createWorkbenchServer(import.meta.url, { configPath });
+  const libraryDir = path.join(root, 'library');
+  await mkdir(libraryDir, { recursive: true });
+  writeSetting(app.database, 'library_dir', libraryDir);
+  // 不让挂接后的自动转录把任务排进全局队列。
+  writeSetting(app.database, 'auto_transcribe', '0');
+  // 不存在的 ffmpeg：时长探测直接返回 null，不会派生真实进程。
+  writeSetting(app.database, 'ffmpeg_path', path.join(root, 'no-ffmpeg'));
+  return {
+    app,
+    root,
+    libraryDir,
+    async close() {
+      await app.close();
+      await rm(root, { recursive: true, force: true });
+    },
+  };
+}
+
+export interface FakeFile {
+  name: string;
+  sizeBytes: number;
+}
+
+export interface FakeDeviceOptions {
+  files?: FakeFile[];
+  status?: Partial<WorkerStatus>;
+  connectError?: { kind: string; message: string };
+  /** connect 在这个 promise 完成前不返回，用来观察「正在连接」窗口。 */
+  holdConnect?: Promise<void>;
+  /** Wi-Fi 入网失败：发出 fallback 事件后改走蓝牙。 */
+  wifiFails?: boolean;
+  hotspotWasOn?: boolean;
+  /** 这些文件落盘时多写 1 字节，模拟大小不一致。 */
+  wrongSize?: string[];
+  /** 这些文件报告一个任务目录之外的路径。 */
+  outsidePath?: string[];
+  /** 拉取在这个 promise 完成或收到取消前不返回。 */
+  holdPull?: Promise<void>;
+  deleteFails?: string[];
+  /** worker 收到取消后不理会，用来验证超时后才强制结束。 */
+  ignoreCancel?: boolean;
+}
+
+export interface FakeCall {
+  cmd: WorkerCommand | 'cancel';
+  args: Record<string, unknown>;
+  offline?: boolean;
+}
+
+/** 一台内存里的录音笔；多次 spawn 共享同一份文件与调用记录。 */
+export class FakeDevice {
+  files: FakeFile[];
+  status: WorkerStatus;
+  options: FakeDeviceOptions;
+  calls: FakeCall[] = [];
+  spawns: SpawnWorkerOptions[] = [];
+  workers: FakeWorker[] = [];
+  isOffline: () => boolean = () => false;
+
+  constructor(options: FakeDeviceOptions = {}) {
+    this.options = options;
+    this.files = (options.files ?? []).map((file) => ({ ...file }));
+    this.status = {
+      serial: SERIAL, model: 'MemoTalk S1', firmware: '206', batteryPct: 80, freeSpacePct: 90,
+      recordingState: 'STOPPED', storageFormat: 'MP3', ...options.status,
+    };
+  }
+
+  spawn = async (options: SpawnWorkerOptions): Promise<WorkerHandle> => {
+    this.spawns.push(options);
+    const worker = new FakeWorker(this);
+    this.workers.push(worker);
+    return worker;
+  };
+
+  commands(): string[] {
+    return this.calls.map((call) => call.cmd);
+  }
+
+  last(cmd: FakeCall['cmd']): FakeCall | undefined {
+    return [...this.calls].reverse().find((call) => call.cmd === cmd);
+  }
+}
+
+export class FakeWorker implements WorkerHandle {
+  private readonly device: FakeDevice;
+  private cancelled = false;
+  private cancelWaiters: Array<() => void> = [];
+  private readonly exitListeners: Array<(code: number | null) => void> = [];
+  private done = false;
+
+  constructor(device: FakeDevice) {
+    this.device = device;
+  }
+
+  get exited(): boolean {
+    return this.done;
+  }
+
+  stderrTail(): string {
+    return '';
+  }
+
+  onEvent(): void {
+    /* 只有请求级事件 */
+  }
+
+  onExit(listener: (code: number | null) => void): void {
+    this.exitListeners.push(listener);
+  }
+
+  /** 模拟录音笔休眠：进程自行退出。 */
+  exit(code: number | null = 0): void {
+    if (this.done) return;
+    this.done = true;
+    for (const waiter of this.cancelWaiters.splice(0)) waiter();
+    for (const listener of this.exitListeners) listener(code);
+  }
+
+  cancel(): void {
+    this.device.calls.push({ cmd: 'cancel', args: {} });
+    if (this.device.options.ignoreCancel) return;
+    this.cancelled = true;
+    for (const waiter of this.cancelWaiters.splice(0)) waiter();
+  }
+
+  async close(): Promise<void> {
+    this.exit(0);
+  }
+
+  killed = false;
+
+  kill(): void {
+    this.killed = true;
+    this.exit(null);
+  }
+
+  async request<T>(cmd: WorkerCommand, args: Record<string, unknown> = {}, options?: RequestOptions): Promise<T> {
+    if (this.done) throw new AppError('DEVICE_DISCONNECTED', undefined, 'worker already exited');
+    const device = this.device;
+    device.calls.push({ cmd, args, offline: device.isOffline() });
+    switch (cmd) {
+      case 'connect': {
+        if (device.options.holdConnect) await device.options.holdConnect;
+        const failure = device.options.connectError;
+        if (failure) throw classifyDeviceError(failure.kind, failure.message, { op: 'connect' });
+        return { address: 'AA:BB:CC:DD:EE:FF', hotspotWasOn: Boolean(device.options.hotspotWasOn), timeSynced: true } as T;
+      }
+      case 'status':
+        return { ...device.status } as T;
+      case 'list':
+        return {
+          files: device.files.map((file) => ({ name: file.name, format: 'MP3', sizeBytes: file.sizeBytes, durationSec: 10, timestamp: null })),
+        } as T;
+      case 'pull':
+        return (await this.pull(args, options?.onEvent)) as T;
+      case 'delete': {
+        const names = (args.names as string[]) ?? [];
+        const fails = new Set(device.options.deleteFails ?? []);
+        const files = names.map((name) => {
+          if (fails.has(name)) return { name, ok: false, error: { kind: 'DeleteFailed', message: `${name} status=0x02` } };
+          device.files = device.files.filter((file) => file.name !== name);
+          return { name, ok: true };
+        });
+        return { files } as T;
+      }
+      case 'disconnect':
+        return {} as T;
+      default:
+        throw new Error(`unexpected command ${cmd}`);
+    }
+  }
+
+  private async pull(args: Record<string, unknown>, onEvent?: (event: WorkerEvent) => void) {
+    const device = this.device;
+    const requested = args.files as Array<{ name: string; size: number | null }>;
+    const outDir = String(args.outDir);
+    let transport = args.transport as 'wifi' | 'ble';
+    if (transport === 'wifi') {
+      onEvent?.({ event: 'progress', data: { phase: 'preparing', transport: 'wifi', index: 0, count: requested.length } });
+      if (device.options.wifiFails) {
+        onEvent?.({ event: 'fallback', data: { from: 'wifi', to: 'ble', reason: 'WIFI_JOIN_FAILED', detail: 'netsh: The network is not available.' } });
+        transport = 'ble';
+      }
+    }
+    if (device.options.holdPull) {
+      onEvent?.({ event: 'progress', data: { phase: 'transferring', transport, file: requested[0]?.name, index: 1, count: requested.length, bytes: 0, total: requested[0]?.size ?? null } });
+      await Promise.race([device.options.holdPull, new Promise<void>((resolve) => this.cancelWaiters.push(resolve))]);
+      if (this.done) throw new AppError('DEVICE_DISCONNECTED', undefined, 'worker killed during pull');
+    }
+    const files: Array<Record<string, unknown>> = [];
+    let index = 0;
+    for (const item of requested) {
+      if (this.cancelled) break;
+      index += 1;
+      const entry = device.files.find((file) => file.name === item.name);
+      if (!entry) {
+        files.push({ name: item.name, ok: false, error: { kind: 'FileNotFoundOnDevice', message: item.name } });
+        continue;
+      }
+      const size = entry.sizeBytes + ((device.options.wrongSize ?? []).includes(item.name) ? 1 : 0);
+      const target = (device.options.outsidePath ?? []).includes(item.name)
+        ? path.join(path.dirname(outDir), `stray-${item.name}`)
+        : path.join(outDir, item.name);
+      await mkdir(path.dirname(target), { recursive: true });
+      await writeFile(target, Buffer.alloc(size, 7));
+      onEvent?.({ event: 'progress', data: { phase: 'transferring', transport, file: item.name, index, count: requested.length, bytes: size, total: size } });
+      files.push({ name: item.name, path: target, sizeBytes: size, transport, ok: true });
+    }
+    if (args.transport === 'wifi' && transport === 'wifi') {
+      onEvent?.({ event: 'progress', data: { phase: 'restoring', transport: 'wifi' } });
+    }
+    return { files, cancelled: this.cancelled };
+  }
+}
+
+/** 等到条件成立；默认 3 秒超时，避免测试挂死。 */
+export async function waitFor(check: () => boolean, timeoutMs = 3000): Promise<void> {
+  const started = Date.now();
+  while (!check()) {
+    if (Date.now() - started > timeoutMs) throw new Error('waitFor timed out');
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}