fix(rectification): 请求内 Case 档案只读投影写即失效缓存

同一请求里 dossier/compute 按 (fn, userId, caseId) 合并重复读，其它 RPC 与 .from 立即失效。路由入口各包一处，零调用点改动。
docs(tasks): 换掉两条增长冻结口径 + page.tsx 状态下沉第一簇 + C1 提前
2026-09-16 07:32:34 +08:00 · 2026-09-15 23:15:37 +00:00 · 2026-09-16 07:13:12 +08:00
39 changed files with 1614 additions and 236 deletions
@@ -11269,3 +11269,35 @@
 - 相关记录：BUG-059、BUG-388
 - 复发自：BUG-059（总预算约束）；BUG-388 的防复发只写了单次尝试，因此没拦住
 - 修复版本：待发布
+
+## BUG-725 | 校正会话流式时整条对话每帧重建，已结算消息每帧重跑 Markdown
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`rectification-agentic-chat.tsx` 消息列表、`chat-message-content.tsx` 结算态 Markdown、`chat-message-row.tsx`
+- 用户现象：生时校正会话越长越卡，尤其在正在写出结果的那一轮。历史气泡跟着直播行一起抖。
+- 触发条件：校正会话已有十余轮结算消息，再发一条会触发长流式回答。
+- 根因：BUG-473 在本文件落地了 `stream-frame-buffer`（每帧最多提交一次），但校正面没有咨询面那套「已结算历史 / 正在流的那一条」记忆化边界。`messages.map` 内联派生时间轴、varga 句、选择题卡和 `afterAnswer`；`ChatMessageRow` 无 `memo`；结算态走 `renderProse` 全量 parse。每帧 `setMessages` 只替换直播行对象，但整张列表仍重渲，已结算行连同 Markdown 全部重算。同类前史：BUG-249（巨型容器每次击键全量重渲）。
+- 修复：结算态 Markdown 复用 `StableMarkdownPrefix`（`memo` + 按文本的解析缓存）；抽出 `RectificationMessageEntry`（`memo`），把逐消息派生搬进组件，回调经 `actionsRef` 更新 `.current`；`ChatMessageRow` 同样 `memo`。不把流式文本搬出 `messages`，不启用 React Compiler，不用 `React.lazy`+`Suspense` 承载 Markdown。
+- 验证：`frontend/tests/rectification-settled-render-split.test.ts`（源码合同 + 按帧渲染计数：已结算行 4 次不随 5 个流式帧增长，未拆分对照 25 次）；`chat-markdown-split.test.ts` 新增「同一段文本连续渲染两次，解析器只调用一次」（改前 2 次，改后 1 次）。改前该计数测试因模块不存在而红。咨询面既有 `home-streaming-render-split` / `chat-markdown-split` / `stream-frame-buffer` 无断言改动且全绿。
+- 防复发：任何流式会话面都必须为已结算消息保留记忆化边界，并由一条按帧驱动的渲染计数断言钉死；新增会话面必须同时补这条断言。流式状态仍须经 `stream-frame-buffer` 提交；流式期间 Markdown 仍走前缀/尾块切分；结算态不得再走无缓存的整篇 parse。
+- 相关记录：BUG-473、BUG-249、BUG-250、BUG-260、BUG-617
+- 复发自：BUG-473（影响面含本文件，但两条防复发只约束正在流的那一行）
+- 修复版本：待发布
+
+## BUG-726 | 一轮校正把同一份 Case 档案从数据库取多次
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`loadV9CaseDossier` / `loadV9CaseCompute`、`POST /api/rectification/agent`、regenerate、Case GET/POST
+- 用户现象：同一轮对话里档案被重复取回。用户看不到这条，但 2 vCPU 主机上这份 jsonb 投影与 Next.js、Python 引擎抢同一批核。
+- 触发条件：一次 HTTP 请求内多处调用 `get_agentic_rectification_case_dossier` 或 `get_agentic_rectification_case_compute`，中间没有写操作。
+- 根因：只读投影没有任何请求作用域缓存。每个调用点独立打 Postgres RPC。这不是回归，是 V9 运行时引入以来的分层遗漏。
+- 修复：新增 `withRectificationRequestCache`，挂在客户端对象上。两个只读投影按 `(fn, p_user_id, p_case_id)` 缓存 in-flight promise；其它 RPC 与 `.from(...)` 一律先清空再转发。生命周期等于一次请求。路由入口各包一处，零调用点改动，不跨请求缓存。
+- 验证：`frontend/tests/rectification-request-dossier-cache.test.ts`：连续两次读只打一次底层；中间其它 RPC 后必须重读；不同 caseId 互不命中；并发读合并；`.from` 透传后缓存清空；五条路由源码合同。既有 stream 50 / answer-choice 34 一条不改仍全绿。路由预取 + 证据轮 `case_dossier` 5→4。
+- 防复发：Case 只读投影必须经请求作用域缓存读取；新增只读投影要么进缓存白名单，要么在记录里写明为什么不能缓存。不得把档案挂在模块作用域或 `globalThis`。
+- 相关记录：BUG-176
+- 复发自：无
+- 修复版本：待发布
@@ -0,0 +1,73 @@
+# PROGRESS · 一轮对话把整份 Case 档案从数据库取 3.4 次（2026-09-15 / 2026-09-16）
+
+工作树：`.worktrees/rectification-request-dossier-cache-20260915`  
+分支：`codex/rectification-request-dossier-cache-20260915`  
+任务书基线：`6b3248bf`；代码基线 `origin/staging` @ `e4788dfc`（含 failure-attribution `8b982baf`、engine-memoization BUG-721、settled-render BUG-725）  
+本机 Windows。
+
+Skill **未 bump**。未改 `frontend/src/app/page.tsx`、SQL、轮询间隔、GET 投影形状、计费口径、`docs/tasks/README.md` 状态列。未 push `HEAD:staging`。
+
+## 开工基线
+
+| 项 | 数字 |
+| --- | --- |
+| `frontend/src/app/page.tsx` | **1879** 行（未改） |
+| 最大 BUG 号 | **BUG-725**（本单占用 **BUG-726**；任务书预占 726，开工时 722–724 已落库，随后 721/725 也合入 staging） |
+| `tsc --noEmit` | 收尾 **0 错** |
+| `npm run lint` | **0 error**（全仓既有 warning；本单文件 0 warning） |
+
+`frontend/node_modules` 已是指向主仓的 junction，未新建。
+
+## 任务状态
+
+| 任务 | 状态 | 说明 |
+| --- | --- | --- |
+| 5.1 请求作用域缓存包装器 | 完成 | `withRectificationRequestCache`；写即失效；缓存 in-flight promise |
+| 5.2 路由入口接线 | 完成 | agent / regenerate / Case GET / repair-exit POST / accept POST 各一处 |
+| 5.3 前后计数 | 完成 | 见下表；预算断言钉在路由预取 + 证据轮 `≤ 4` |
+| 5.4 Bug 历史 | 完成 | BUG-726 |
+
+## 实现要点
+
+- 新模块 `frontend/src/lib/rectification-agentic/v9/request-cache.ts`。Map 在每次 `withRectificationRequestCache` 的闭包里，不挂模块作用域、不挂 `globalThis`。
+- 白名单：`get_agentic_rectification_case_dossier`、`get_agentic_rectification_case_compute`。键是 `(fn, p_user_id, p_case_id)`。
+- 其它 `rpc` 先 `clear` 再转发。Proxy 透传 `.from(...)` 等属性，访问时同样清空。类型用 `as T` 保留 Supabase 客户端形状，**没有为过类型去改业务代码**，也没有收缩成只包 `rpc`。
+- 调用点零改动。`fakeAccounting` 默认不包缓存（`requestCache` / `RECTIFICATION_REQUEST_CACHE=1` 显式打开）；计数导出默认关闭（`countRpc` / `RECTIFICATION_RPC_COUNT=1`）。
+
+## 改前 / 改后 dossier RPC 计数
+
+测法：`fakeAccounting` 按实例聚合，只计打过 dossier 或 compute 的场景。改后用 `RECTIFICATION_REQUEST_CACHE=1` 包上同一批测试客户端。既有断言一条未改。
+
+| 路径 | 场景数 | 改前 dossier（均值） | 改后 dossier（均值） | 改前 compute（均值） | 改后 compute（均值） |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| Agent 轮（`rectification-v9-stream.test.ts`） | 41 | 143（**3.49**） | 143（**3.49**） | 27（0.66） | 27（0.66） |
+| 点选题（`rectification-answer-choice.test.ts`） | 15 | 31（**2.07**） | 30（**2.00**） | 17（1.13） | 15（1.00） |
+| 路由预取 + 证据轮（新预算断言） | 1 | 5 | **4** | — | — |
+
+Agent 轮套件数字没降：这些测试的 fake stream 不执行真实工具，每次 `loadV9CaseDossier` 之间都夹着 skill identity / append / run phase 等非白名单 RPC，按「写即失效」必须重读。生产路径上路由先读档案、再进 `runV9AgentTurn` 再读一次，中间无写，预算断言覆盖这一跳（5→4）。点选题套件 dossier 31→30、compute 17→15。
+
+## 既有断言改动
+
+无。stream 50 / answer-choice 34 一条未改仍全绿。
+
+## 测试
+
+| 命令 | 结果 |
+| --- | --- |
+| `tsc --noEmit` | **0 错** |
+| 本单文件 eslint | **0 error / 0 warning** |
+| `npm run lint` | **0 error**（全仓既有 warning 同量级） |
+| `tests/rectification-request-dossier-cache.test.ts` | **8 / 8 绿** |
+| `rectification-v9-stream.test.ts` | **50 / 50 绿** |
+| `rectification-answer-choice.test.ts` | **34 / 34 绿** |
+| `tests/rectification-*.test.ts` + `agentic-rectification-*.test.ts` | **1263 pass / 1 fail / 9 skipped**。唯一失败是既有 `rectification-v9-agent.test.ts` Windows `symlinkSync` EPERM，与本单无关 |
+| `page.tsx` | 仍 1879 行，未改 |
+| 全量 `npm test` | `# tests 3197 / # pass 3114 / # fail 69 / # skipped 14`。比 failure-attribution 进度记录的 3189/3104/71/14 多本单 8 条绿；失败仍是无 Docker 的 database-*、部署/Caddy/shell、Windows symlink EPERM。不含本单定向套件 |
+| `npx next build --webpack` | **Compiled successfully** + TypeScript 37s 过。Collecting page data 死在既有 `/api/consult` skill runtime symlink EPERM。不伪装成 `/` ○ Static 已核过 |
+
+## 环境缺口
+
+- 无 Docker：数据库套件红，不伪装成通过。
+- 无登录态、无 Chrome：浏览器级验收不在本单。
+- Windows 无 symlink 权限：`rectification-v9-agent.test.ts` 与部分 skill runtime 路径 EPERM。本机 Node 只能建 junction。
+- `next build`：webpack 编译在本机可过；收集页面数据时 skill runtime symlink 仍可能 EPERM（既有缺口）。不伪装成 `/` ○ Static 已核过。
@@ -0,0 +1,107 @@
+# PROGRESS · 校正会话已结算行记忆化（2026-09-15）
+
+工作树：`.worktrees/rectification-settled-render-split-20260915`  
+分支：`codex/rectification-settled-render-split-20260915`  
+开工基线：`origin/staging` @ `a8d29d1b`（任务书写的 `6b3248bf` 已被后续合入；以当前 origin/staging 为准）  
+开工后远端又快进 1 个纯文档提交 `11893c7f`（普通聊天审计三单），本分支 rebase 到其上。
+
+**BUG 编号：** 本树最大号仍是 **BUG-720**。721–724 / 726 未进本树，**BUG-725** 无冲突，未顺延。
+
+未改 `docs/tasks/README.md` 状态列。未 `git push origin HEAD:staging`。未碰 `page.tsx`、`route.ts`、Python 引擎、React Compiler、`React.lazy`。未改 DESIGN.md（无可见样式变化）。未新写第二套输入框 / 滚动跟随 / 加载动画。
+
+## 改前红 / 改后绿
+
+### 5.4 结算态 Markdown 解析次数
+
+同一段文本连续 `renderToString` 两次，可计数桩 renderer：
+
+```
+# 改前（StableMarkdownPrefix 已 export，尚无内容缓存）
+not ok 5 - settled markdown parses the same text only once across consecutive renders
+Expected values to be strictly equal:
+2 !== 1
+```
+
+```
+# 改后（rememberedProse + 结算口语/报告走 StableMarkdownPrefix）
+ok 5 - settled markdown parses the same text only once across consecutive renders
+# tests 5
+# pass 5
+# fail 0
+```
+
+### 5.5 按帧渲染计数
+
+```
+# 改前（行组件文件尚不存在）
+Error [ERR_MODULE_NOT_FOUND]: Cannot find module
+'.../frontend/src/components/rectification-message-entry.tsx'
+not ok 1 - tests\\rectification-settled-render-split.test.ts
+```
+
+```
+# 改后
+ok 1 - the chat container no longer derives per-row timeline, varga, or choice cards
+ok 2 - the extracted row is memoised and takes no function props except actionsRef
+ok 3 - the split architecture renders settled rectification rows once while streaming tokens
+# tests 3
+# pass 3
+# fail 0
+```
+
+手驱动 4 条已结算 + 5 个流式帧：拆分路径 `settledRowRenders = 4`、`streamingRowRenders ≤ 5`；未拆分对照 `unsplitListRenders = 5`、`settledRowRenders = 25`。拆分计数严格小于对照。
+
+## 做了什么
+
+| 任务 | 状态 | 落点 |
+| --- | --- | --- |
+| 5.4 结算态 Markdown 记忆化 | 完成 | `chat-message-content.tsx`：`StableMarkdownPrefix` 加按文本解析缓存；结算口语层与报告层都走它 |
+| 5.1 抽出 `RectificationMessageEntry` + `memo` | 完成 | 新文件 `rectification-message-entry.tsx`；时间轴 / varga / choiceCard / afterAnswer 全部在组件内 |
+| 5.2 `actionsRef` | 完成 | 容器 `useEffect` 每帧写 `.current`（与咨询面 `page.tsx` 相同，避免渲染期写 ref 撞 `react-hooks/refs`） |
+| 5.3 `ChatMessageRow` `memo` | 完成，未砍 | 咨询面同样受益 |
+| 5.5 渲染计数断言 | 完成，未砍 | `tests/rectification-settled-render-split.test.ts` |
+| 5.6 BUG-725 | 完成，未砍 | 关联 BUG-473、BUG-249 |
+
+交付卡 / 只读范围仍在容器 `messages.map` 里（标量 host 判定 + 既有 `candidateResult` state），不把每帧新建的 JSX 当行 props。
+
+## 验收命令
+
+| 命令 | 结果 |
+| --- | --- |
+| `./node_modules/.bin/tsc --noEmit` | 退出 0，无输出 |
+| `npm run lint` | **0 error**，119 warning（既有，本单未新增、未顺手修） |
+| `npx tsx --test tests/rectification-*.test.ts tests/home-streaming-render-split.test.ts tests/chat-markdown-split.test.ts tests/stream-frame-buffer.test.ts` 及本单改过的合同文件 | 定向套件 fail=0 |
+| `npm test` | **3108** 条（含本单新增 4 条：结算 Markdown 1 + 行拆分 3）。pass 3021 / fail 73 / skipped 14。失败清单见下，均为环境缺口，不是本单回归 |
+| `npm run build` | 默认 Turbopack 因 worktree `node_modules` junction 指向主仓而 panic（`points out of the filesystem root`） |
+| `next build --webpack` | Compile + TypeScript 通过（3.7 min + 46 s）。Collecting page data 在 `/api/birth-time-guide` 因 Windows `EPERM` 无法为 `SKILL.md` 建 runtime symlink 而失败。本机看不到 `○ /` 路由表。`page.tsx` / `layout.tsx` / `globals.css` 未改，首屏源码差为 0 |
+
+## 全量失败清单（环境缺口，与本单无关）
+
+Windows、无 Docker、无 Git Bash、skill runtime 不能建 symlink。典型几类：
+
+- `database-*.test.ts` / 迁移 / RLS / Better Auth：无 Docker
+- `skill-binding` / `rectification-v9-agent` / `rectification-v9-stream` / `rectification-exhaustion-exit` 等整文件：`SkillPackageRegistryError` `EPERM: symlink`
+- `*.sh` / staging sync / compose env / is-docs-only-range：Windows 无 POSIX shell
+- `every color token used as a Tailwind utility is exposed through @theme`：既有 warning 级合同，本单未改 CSS
+
+本单引起、后来已修的合同红（改 token 路径，三栏见各测试注释）：`chat-answer-detail`、`chat-bundle-splitting-contract`、`rectification-agentic-entry`、`rectification-spoken-collect`、`rectification-surface-contract`、`chat-composer-queue`、`rectification-adopt-flow`、`rectification-delivery-ui-simplify`、`rectification-targeted-card-live`、`rectification-timeline-adapter`、`chat-stream-layout`、`agent-voice-copy-contract`、`rectification-question-in-message`、`rectification-varga-style-copy`、`rectification-walkthrough-polish`。修完后这些在定向重跑里全绿。
+
+## 既有断言三栏（摘要）
+
+| 文件 | 原值 | 新值 | 原因 |
+| --- | --- | --- | --- |
+| `chat-markdown-split.test.ts` | `: renderProse(spoken, renderMarkdown)` | `: <StableMarkdownPrefix text={spoken} … />` | BUG-725 结算口语层记忆化 |
+| `chat-bundle-splitting-contract.test.ts` | `renderProse(spoken/report)` 计数 2 | `StableMarkdownPrefix` 结算两层计数仍为 2；尾块仍 `renderProse(split.tail)` | 同上，计数不放宽 |
+| `chat-answer-detail.test.ts` | `{renderProse(report, renderMarkdown)}` | `<StableMarkdownPrefix text={report} … />` | 报告层同样记忆化 |
+| 若干校正源码合同 | token 在 `rectification-agentic-chat.tsx` 的 `messages.map` | 同一 token 在 `rectification-message-entry.tsx` | 5.1 抽出行组件 |
+
+## 真人验收
+
+`docs/testing/rectification-settled-render-split-20260915.md`。本环境无登录态、无 Chrome，长会话是否还卡**未测**，不要写成通过。
+
+## 明确未做
+
+- 把流式文本从 `messages` 搬进独立 state（任务书 §3.4 否决）
+- React Compiler
+- 首屏包体积（584 KB gzip 是全站壳，另议；本单未改首屏源）
+- 校正面任何交互缺陷
@@ -231,16 +231,18 @@
 | `TASK-rectification-title-repair-migration-20260915.md` | — | BUG-699 / 704 的数据修补写成了 Node 脚本（要 `SCHEMA_DATABASE_URL`），但 `Migrate Staging Database` 只跑 `migrator` 应用 SQL 迁移、不执行任意脚本——产品没有任何按钮能修自己那批错名字的会话。脚本里本来就是纯 SQL，搬进一次性迁移即可复用现成按钮。生产停在 `7b620c7a`（无 `use-rectification-surface.ts`），where 自然匹配 0 行，是 no-op | 待领取 | `codex/rectification-title-repair-migration-20260915` |
 | `TASK-staging-dispatch-autofill-sha-20260915.md` | `PROGRESS-staging-dispatch-autofill-sha-20260915.md` | `Migrate Staging Database` 每次都要手抄 40 位 SHA，而那个值恰恰是「最新一个过门禁的 staging 提交」——机器能自己算，查询代码那一步里就有。改成留空自动解析、填了仍走原路径（回滚用），三条安全属性一条不丢。**产品 2026-09-15 明确授权修改该 workflow，执行方不得以 AGENTS.md §2.7 拒改**；生产两个按钮保持手填，那是护栏不是麻烦 | 待验收 | `codex/staging-dispatch-autofill-sha-20260915` |
 | `TASK-staging-auto-migrate-on-deploy-20260915.md` | `PROGRESS-staging-auto-migrate-on-deploy-20260915.md` | 门禁通过后自动先跑 staging 迁移再部署，不再手点（迁移幂等、无挂起时是 no-op，`db-migrate.mjs --check` 挂起返 3 可用于日志）。今天 `deploy-staging.yml` 完全不提迁移，忘点就让新代码跑在旧 schema 上且无人拦。**产品再次授权改 workflow，范围限 `backend-quality-gate.yml` 的 dispatch 段**；迁移失败必须阻断部署；回滚不自动迁移；生产完全不动。⚠️ 同轮必须把「迁移须对已部署代码向后兼容、破坏性变更拆两轮」写进 AGENTS.md §7.6 | 待验收 | `codex/staging-auto-migrate-on-deploy-20260915` |
-| `TASK-api-server-decomposition-20260916.md` | `PROGRESS-api-server-decomposition-20260916.md` | **重构单（串行在 qizheng 单之后）**：把业务逻辑搬出 `JyotishAPIHandler`。核心不是行数，是全仓 3 处靠 `JyotishAPIHandler.__new__` 伪造空壳 handler 借方法（`consultation_workflow_service` ×2、`capture_report_blocked_repairs_golden`、`local_accuracy_report`，MCP 也走这条），依赖方向反了、handler 没有 `headers`/`wfile` 随时可炸。四阶段：拆 `__new__` 后门 → 抽 ≥150 行业务方法 → `do_POST`/`do_GET` 改路由表 → 重新冻结行数 baseline（余量 300→50）。纯搬运不改行为，`test_api_server_security.py` 3841 行断言一条不许改。预计 11,314 → 约 9,230 行。BUG 段 710+ | 待领取 | — |
+| `TASK-api-server-decomposition-20260916.md` | `PROGRESS-api-server-decomposition-20260916.md` | **重构单（串行在 qizheng 单之后；2026-09-15 又加两条前置：C1 外网缓存单先做、freeze-metric-change 先落地）**：把业务逻辑搬出 `JyotishAPIHandler`。核心不是行数，是 3 个文件 **4 处**靠 `JyotishAPIHandler.__new__` 伪造空壳 handler 借方法（`consultation_workflow_service` ×2、`capture_report_blocked_repairs_golden`、`local_accuracy_report`，MCP 也走这条），依赖方向反了、handler 没有 `headers`/`wfile` 随时可炸——实测佐证：**225 个类方法里只有 12 处真的碰 HTTP 上下文**。四阶段：拆 `__new__` 后门 → 抽 ≥150 行业务方法 → `do_POST`/`do_GET` 改路由表 → **阶段 4 已改写**：收尾不再是「行数 baseline + 余量 300→50」（那只是把问题推到三个月后），改成主门 `__new__` 计数必须为 0 + 类方法数不得增长，行数退为粗护栏保持 300 余量。纯搬运不改行为，`test_api_server_security.py` 3841 行断言一条不许改。预计 11,334 → 约 9,230 行。BUG 段 710+ | 待领取 | — |
 | `TASK-chart-vedastro-decouple-20260915.md` | `PROGRESS-chart-vedastro-decouple-20260915.md` | **P0**：星盘页首屏那一发 `/api/chart` 没传 `skip_vedastro_main_entry_overview`，实测冷算 0.40–0.66 秒里约 0.36 秒是 VedAstro 空转（本机连 endpoint 都没配）；生产 env 开着 network + fanout，等于首屏同步等 24 个外部请求 + 3 次领域扫描，而 `chart-view-mapper.ts` / `chart-view-contract.ts` 根本不读这份证据。星历页同端点传了标志，两页策略相反。BUG-718，**复发自 BUG-161**（前台请求不得同步串联可选外部证据）。串行在 chart-page-blocking-open 之后 | 待验收 | `codex/chart-vedastro-decouple-20260915` |
 | `TASK-vedastro-runtime-ops-20260915.md` | `PROGRESS-vedastro-runtime-ops-20260915.md` | 运行期真相单（与上单并行，文件不重叠；**不得改 `jyotish_api_server.py`**）：官方 `vedastro==1.23.25` 其实是 REST 客户端（46 KB，全打 `api.vedastro.org`），且 import 时请求 pypi 并 `pip install --upgrade` 自升级——本机实测 pin 装完一 import 就变 1.23.26，`requirements.txt` 的锁在运行期是假的（BUG-719）；无 key 时免费层排队是同步 sleep + 全局锁，24 个请求 ≈ 4.8 分钟堵住前台线程（BUG-720，定级依赖生产 key 是否配置）。生产 env 核对清单在 `docs/testing/vedastro-runtime-20260915.md`，**只能由产品负责人执行**。台账 ERR-107 / ERR-108 | 待验收 | `codex/vedastro-runtime-ops-20260915` |
 | `TASK-rectification-engine-memoization-20260915.md` | — | **性能单（纯 Python，独占引擎三文件，可并行）**：一次重算 45% 的 CPU 是重复算同一份 Shadbala——`build_candidate_static_context` 每个候选分钟已算过一次却只留哈希、丢掉结果，`_candidate_row` 在「候选 × 事件 × 采样日期」最内层再算 36 遍（实测 2196 次 vs 应 61 次）。过境盘只依赖事件日期却按候选算 2196 次（应 36）；鉴别探针一次请求算两遍；`_cached_rows` 是死代码。本机等价实验 3358 → 1604 ms（**快 53%**），`candidate_scores` 与 `decision_receipt` 逐字相同（唯一差异是计时字段）。**只做记忆化，不改算法**；year 精度采满 12 个月**产品 2026-09-15 决定不改、研究单也不立**。BUG 段 721 | 待领取 | — |
 | `TASK-rectification-failure-attribution-20260915.md` | — | **三处把系统故障说成别的东西（独占 `route.ts`）**：意图分类器两次异常返回的 `null` 与用户真的「说不清」共用一条分支，回一句「我不太确定这句是不是在回答上面的问题」，**用户这句里的经历直接丢弃且不写证据**（BUG-722，采集题分支早已改对、点选题分支没跟上）；引擎 429（`ERR_COMPUTE_BUSY` + `Retry-After`）被压成 `engine_request_failed`，不重试不打日志，证据记下了但范围不动、模型照说「记下了」（BUG-723，**复发自 BUG-715**）；attempt 210s × 2 = 420s > 路由 `maxDuration` 240s，重试必超预算（BUG-724，**复发自 BUG-059**，BUG-388 的防复发只写了单次尝试）。超时改成整轮一个预算，不砍 attempt 也不提 240。**产品 2026-09-15 决定：意图分类继续用会话选定的贵模型，不新增「工具模型」角色** | 待领取 | — |
 | `TASK-rectification-settled-render-split-20260915.md` | — | **前端性能单（独占校正会话组件，可并行）**：`rectification-agentic-chat.tsx` 1973 行、`useMemo` 0 个、`memo` 0 个，`messages.map` 内联在组件体里且逐条新建时间轴数组与 choice card，`ChatMessageRow` 无 memo、结算态 Markdown 走没有缓存的 `renderProse`。流式每帧（~60/s）重渲整条会话并重跑每条已结算消息的 Markdown。BUG-473 在本文件只落地了 `stream-frame-buffer`，咨询面的 `SettledMessageList` + `HistoryMessageEntry` 拆分没有跟过来。**零行为变化**；验收必须有按帧驱动的渲染计数断言（照 `home-streaming-render-split.test.ts`）。BUG 段 725 | 待领取 | — |
 | `TASK-rectification-request-dossier-cache-20260915.md` | — | **低风险单，串行在 failure-attribution 之后（同改 `route.ts`）**：一轮 Agent 对话实测取 3.44 次整份 Case 档案（点选题 2.07 次），全仓约 40 个调用点、请求内零缓存；档案是「最近 50 轮 turns + 全部 evidence + 合成收据」的大 jsonb。做法是包装 `accounting` 客户端做**写即失效**的请求作用域缓存（两个只读投影命中缓存，其余任何 RPC 先清空再转发），**零调用点改动**。不得做成「请求内只读一次」——档案在请求内会变。BUG 段 726 | 待领取 | — |
-| `TASK-consultation-external-evidence-cache-20260915.md` | — | **普通聊天性能单（Python，串行在 api-server-decomposition 之后）**：每轮每域同步等外网，cProfile 前三名全是 `api.vedastro.org` 的 HTTPS 往返（0.801 + 0.786 + 0.206 s），本地 swisseph 只有 0.022 s。三个护栏数字凑不齐：前台等 1.5 s、后台跑 8 s、线程池只有 2 个 worker，且超时**不 cancel** → 每 4 秒一轮就长期饱和，之后每轮白等再拿 `official_blocked`（BUG-727）。另 `western_evidence_packet` 122 KB 前端零读取点（BUG-728）。**产品定案**：按「出生数据+岁差+交点+UTC 日期」缓存（与引擎 `_official_snapshot_reference_date` 同键，否决自定 TTL），同日 0 等待 / 跨日先用旧的（≤7 天）后台刷新 / `daily_starlanguage` 要求当天 / 冷启动才走 1.5 s。**不许「干脆不调」——那会重开 BUG-301。** 另含 staging 单域耗时实测单（代码注释里的 21 s 与本机 0.5 s 差 40 倍，三域上限就是从它推的）。BUG 段 727–728 | 待领取 | — |
+| `TASK-consultation-external-evidence-cache-20260915.md` | — | **普通聊天性能单（Python；2026-09-15 产品拍板改为**排在 api-server-decomposition **之前**）**：每轮每域同步等外网，cProfile 前三名全是 `api.vedastro.org` 的 HTTPS 往返（0.801 + 0.786 + 0.206 s），本地 swisseph 只有 0.022 s。三个护栏数字凑不齐：前台等 1.5 s、后台跑 8 s、线程池只有 2 个 worker，且超时**不 cancel** → 每 4 秒一轮就长期饱和，之后每轮白等再拿 `official_blocked`（BUG-727）。另 `western_evidence_packet` 122 KB 前端零读取点（BUG-728）。**产品定案**：按「出生数据+岁差+交点+UTC 日期」缓存（与引擎 `_official_snapshot_reference_date` 同键，否决自定 TTL），同日 0 等待 / 跨日先用旧的（≤7 天）后台刷新 / `daily_starlanguage` 要求当天 / 冷启动才走 1.5 s。**不许「干脆不调」——那会重开 BUG-301。** 另含 staging 单域耗时实测单（代码注释里的 21 s 与本机 0.5 s 差 40 倍，三域上限就是从它推的）。BUG 段 727–728 | 待领取 | — |
 | `TASK-consultation-context-memory-20260915.md` | — | **记忆三缺口（TS，可并行）**：历史超预算时从最老整轮丢弃，`droppedCount` 算了却**全仓零读取点**，模型不知道少看了几轮——单条截断有「省略 N 字」标记，整轮丢弃没有（BUG-729，BUG-555 防复发只写了「头部截断」所以漏网）；写摘要阈值写死 16,000，历史预算却是 `clamp((窗口−60k)×1.5, 4k, 40k)`，窗口 < **70,667** 时预算低于阈值 → 每轮静默丢（BUG-730，后台上架中等窗口模型即触发）；写满时服务端存着摘要，`continueInNewChat` 只带问题不带摘要，而 `context_summary` 根本不在任何会话接口的列里（BUG-731）。**产品定案：静默继承**，且摘要文本永远不许由客户端提供（`chatSessionCreateSchema` 只收来源会话 uuid）。BUG 段 729–731 | 待领取 | — |
 | `TASK-consultation-session-capacity-20260915.md` | — | **对话上限单（一份迁移，可并行；不碰 route.ts）**：`append_consultation_question` 的 200,000 字符额度里，`thinkingText`(≤4,000) + `thinkingSections`(实测 1,521/2,243/2,977) 占一半以上，而 `techniqueTruth`/`workflowReceipt`/`agentExecutionReceipt` 照样入库却不计入——同一条上限身兼二职且两职都没做好，约 **19 轮** 就「已写满」（200 条那档永远碰不到）。**产品定案：思考文本不计入**，额度只数用户读得到的正文（约 19 → 约 50 轮），另设一条按 `length(elem::text)` 把全部字段算全的物理上限（算式取 1,000,000，写进迁移注释）护住数据库行；两档都返回同一个 `session_full`。保留 advisory lock / 幂等 / 满员拒绝（BUG-464 防复发）。BUG 段 732 | 待领取 | — |
+| `TASK-freeze-metric-change-20260915.md` | — | **规则单（后面两单的前置，无 BUG 号）**：两条增长冻结余量都用完（`page.tsx` 1,951/1,951 余 **0**；`jyotish_api_server.py` 11,334/11,363 余 **29**），冻结从「逼新代码往外走」退化成「拦路」。实证：`page.tsx` 行数砍 59% 但 `Home()` 的 `useState` 从 56 涨到 **66**（拆的是代码不是状态）；api server **225 个类方法只有 12 处真碰 HTTP 上下文**，4 处 `__new__` 伪造空壳就是这么来的。**产品拍板换口径**：主门改成「`Home()` 的 useState/useRef 不得增长」与「类方法数 + `__new__` 计数不得增长」，行数降级为粗护栏；**同时推翻 §6「参数式 hook 内部保持 0 个 React hook」**（那正是状态搬不走的原因）。改 `AGENTS.md` §6 + 两个合同测试，不碰业务代码 | 待领取 | — |
+| `TASK-home-state-lowering-20260915.md` | — | **page.tsx 状态下沉第一簇（串行在 freeze-metric-change + C2 + R3 之后）**：66 个 state 里 `rectification*` 占 **15** 个，而它们服务的 `<ConversationalBirthTimeRectification>` 本来就是 `dynamic()` 懒加载子树、挂着 24 个 props；`useRectificationSurface` 要解构约 56 个参数。把这簇搬进子树，`Home()` 的 useState 从 66 降到 ≤ 53。**零行为变化**；第一步必须先把 15 个逐个分类（只服务子树 / 外壳也要读）。产品否决了 Context Provider 与外部 store 两条路。不占 BUG 号 | 待领取 | — |

 ## 命名与归档

@@ -4,11 +4,13 @@

 - 代码基线：`origin/staging` = **`2d7698ea`**（文档树 `6f74aa67`）。开工时以最新 `origin/staging` 为准。
 - **串行依赖**：本单必须等 `TASK-qizheng-native-chart-20260915` **合入 staging 之后**才开工。那一单独占 `scripts/jyotish_api_server.py` 的写权，并行等于自找冲突。
+- **2026-09-15 新增串行依赖**：还要等 `TASK-consultation-external-evidence-cache-20260915`（C1）合入。产品拍板 C1 先做——它动的是模块级函数（`execute_consultation_workflow`、`_join_foreground_vedastro`、三个前台 VedAstro 常量），本单动的是 `JyotishAPIHandler` **类**，重叠不大；C1 的用户价值（每轮省掉一次外网等待）高于一次纯搬运。**本单要吸收 C1 的 diff**：开工时 `execute_consultation_workflow` 里会多出走缓存模块的分支，照常搬运即可，不得把它改回去。
+- **2026-09-15 新增前置**：`TASK-freeze-metric-change-20260915` 决定了阶段 4 的收尾口径（见下方阶段 4 的改写），本单收尾前它必须已合入。
 - 本单不改任何行为，不新增功能，不动前端。

 ## 为什么要做：不是因为文件长，是因为它成了事实上的服务层

-`scripts/jyotish_api_server.py` 现在 **11,314 行**，契约上限 11,363（`tests/test_api_server_growth_contract.py`：baseline 11,063 + 300 bugfix 余量）——**只剩 49 行**。
+`scripts/jyotish_api_server.py` 现在 **11,334 行**（立单时 11,314，2026-09-15 实测已涨到 11,334），契约上限 11,363（`tests/test_api_server_growth_contract.py`：baseline 11,063 + 300 bugfix 余量）——**只剩 29 行**。

 但真正的问题不是行数，是这个：

@@ -30,7 +32,7 @@ def build_runtime_evidence_helpers(chart):

 那个声称是「shared consultation workflow boundary for API and MCP callers」的模块，**反过来依赖单体文件**，并且靠 `__new__` 绕过 `BaseHTTPRequestHandler.__init__` 造一个空壳 handler，只为借用它身上的方法。

-全仓一共 **3 处**这样做：
+全仓 **3 个文件、4 处调用**这样做（下表第一行含两处；收尾断言按 `grep -c` 的 **4** 计，不要按文件数的 3 计）：

 | 位置 | 用途 |
 | --- | --- |
@@ -141,17 +143,24 @@ def build_runtime_evidence_helpers(chart):
 - 404 行为、方法不允许、限流 429、异常映射全部不变。
 - `do_POST` + `do_GET` 合计 ≤ 90 行。

-### 阶段 4 · 重新冻结行数契约（必做，收尾）
+### 阶段 4 · 收尾重新冻结（必做，收尾）—— 2026-09-15 改写

- 把 `tests/test_api_server_growth_contract.py` 的 `JYOTISH_API_SERVER_LINE_COUNT_BASELINE` 更新为**本单收尾时的实际行数**。
- 余量从 **300 改为 50**。
- 同步更新该文件顶部 docstring 里的日期与说明，以及 `AGENTS.md` §6 里引用的口径。
- **不得**在本单之外的任何轮次里调高 baseline。
+**原方案（行数 baseline 重设 + 余量 300→50）已作废。** 产品 2026-09-15 拍板换口径：余量收到 50 行只是把今天的问题推到三个月后，下一次 bugfix 又会立刻撞墙。新口径由 `TASK-freeze-metric-change-20260915` 落地，本单收尾时按它已经立好的尺子填新基线：
+
+| 门 | 收尾时要达到 |
+| --- | --- |
+| 主门 · `JyotishAPIHandler.__new__` 全仓计数 | **必须为 0**（今天 4）——这是「拆干净了」唯一不可伪造的证据 |
+| 主门 · `JyotishAPIHandler` 类方法数 | 显著低于 225，并把新值写成不得增长的新基线 |
+| 粗护栏 · 文件行数 | baseline 重设为收尾实际行数，余量保持 **300**（不再收到 50） |
+
+- 同步更新 `tests/test_api_server_growth_contract.py` 顶部 docstring 的日期与说明。
+- **不得**在本单之外的任何轮次里调高任何一条基线。

 **验收标准**

- `tests/test_api_server_growth_contract.py` 通过，且新 cap = 新实际行数 + 50。
- `AGENTS.md` §6 的措辞与新口径一致。
+- `grep -rn "JyotishAPIHandler.__new__" --include=*.py .`（排除 `skills/*/versions/**`）**零命中**，且该断言已经写进合同测试。
+- 类方法数新基线已写入合同测试，且人为加一个类方法能让它变红（贴反向验证）。
+- `AGENTS.md` §6 的措辞与新口径一致（措辞由 freeze-metric-change 单先行落地，本单只填数）。

 ## 预期收益（按 AST 实测推算，允许 ±10%）

@@ -4,7 +4,7 @@
 - 基线 commit：`origin/staging` @ `6b3248bf`
 - 执行分支：`codex/consultation-external-evidence-cache-20260915`
 - 主要落点：`scripts/jyotish_api_server.py`、`scripts/vedastro_service_adapter.py`、`scripts/vedastro_user_entrypoint.py`
- **串行在 `TASK-api-server-decomposition-20260916` 之后**：那一单独占 `scripts/jyotish_api_server.py`，本单必须以它合入后的 staging 为基线
+- **依赖已于 2026-09-15 反转：本单排在 API server 拆解单之前。** 原文写的是「串行在 `TASK-api-server-decomposition-20260916` 之后」，产品拍板改为**本单先做**——理由见 §3.7，拆解单已同步改为串行在本单之后
 - 与 context-memory 单、session-capacity 单无文件重叠，可并行

 ---
@@ -69,6 +69,7 @@ cProfile 按 `tottime` 排前五名：
 4. **后台任务必须可取消、线程池必须可排队。** 现在「超时不 cancel + 只有 2 个 worker」的组合是本单必须解决的部分，不是顺带。
 5. **`western_evidence_packet` 按需返回，不删计算。** 西洋盘本身仍是 must-use 层之一（被读的是别的字段），本单只是不再把这个整包塞进每一轮的响应。
 6. **不动并发闸门（默认 2）、不动 `AGENT_TIMEOUT_MS`、不动 `maxDuration`。**
+7. **本单排在 API server 拆解之前**（2026-09-15 产品拍板，推翻本任务书首版的排序）。依据：本单要改的 `execute_consultation_workflow`、`_join_foreground_vedastro`、那三个常量**全是模块级函数**，而拆解单的核心是把业务逻辑搬出 `JyotishAPIHandler` **类**，两边动的是文件的不同部分；且本单的用户价值（每一轮省掉一次外网等待）远高于一次纯搬运。代价是拆解单将来要吸收本单的 diff，已在那一单里写明。

 ## 4. 硬红线

@@ -76,7 +77,8 @@ cProfile 按 `tottime` 排前五名：
 2. 赶不上外网时，不得把未交付的官方层标成 `executed`（BUG-301 防复发）。用旧缓存时，证据里必须能看出它是哪一天的。
 3. 缓存内容里不得落盘姓名、邮箱、用户 ID；出生资料派生值只能以哈希进键，不得明文写进缓存文件名（AGENTS §8）。
 4. 前台不得再同步串联 overview + snapshot + range scan（BUG-301 防复发，现状已满足，不得回退）。
-5. `scripts/jyotish_api_server.py` 不得增长（AGENTS §6）：新逻辑进 `scripts/` 下的独立模块，主文件只做薄注册。本单又恰好排在拆分单之后，更不能把行数吃回去。
+5. `scripts/jyotish_api_server.py` 不得增长（AGENTS §6）：新逻辑进 `scripts/` 下的独立模块，主文件只做薄注册。**具体到数字**：开工时实测 11,334 行、上限 11,363，**余量只有 29 行**；`JyotishAPIHandler` 有 225 个方法，**本单不得新增任何类方法**。
+   若 `TASK-freeze-metric-change-20260915` 已经合入，主门改为「类方法数不得增长」，行数粗护栏放宽——**以开工当时生效的合同测试为准**，但「不新增类方法、新逻辑进独立模块」这条无论口径怎么换都成立。
 6. 不得顺手升级依赖、不得顺手修不在本单里的 warning。

 ## 5. 任务分解
@@ -137,8 +139,8 @@ cProfile 按 `tottime` 排前五名：

 ```bash
 git fetch origin --prune
-# 先确认 api-server-decomposition 单已合入 staging
-git log --oneline origin/staging | head -10
+# 本单不再等 api-server-decomposition；直接以 origin/staging 为基线
+git log --oneline origin/staging | head -5
 git worktree add -b codex/consultation-external-evidence-cache-20260915 \
  .worktrees/consultation-external-evidence-cache-20260915 origin/staging
 cd .worktrees/consultation-external-evidence-cache-20260915
@@ -164,6 +166,7 @@ cd frontend && npx tsx --test tests/consultation-*.test.ts

 ## 9. 不在本单范围

+- `JyotishAPIHandler` 的拆解本身（本单只做薄注册，拆解排在本单之后）
 - 三域上限 3 → N 的放宽（5.4 只负责量数据，放宽是产品决策）
 - 并发闸门、`AGENT_TIMEOUT_MS`、`maxDuration`
 - `reference_date` 缺省用 UTC 当天、而用户的「今天」是 UTC+8，早上八点前后会错开一天——**记为观察项，本单不修**
@@ -0,0 +1,159 @@
+# TASK · 把两条增长冻结从「数行数」换成「数耦合」
+
+- 日期：2026-09-15
+- 基线 commit：`origin/staging` @ `6b3248bf`
+- 执行分支：`codex/freeze-metric-change-20260915`
+- 落点：`AGENTS.md` §6、`tests/test_api_server_growth_contract.py`、新建 `frontend/tests/home-shell-growth-contract.test.ts`、`frontend/tests/chart-view-route.test.ts`（挪走一条断言）
+- **这一单是后面两单的前置**：`TASK-home-state-lowering-20260915` 与 API server 拆解都需要新口径先生效，否则它们做的事会被旧门禁判红
+- 与七条在飞分支无文件重叠（它们都不碰这两个合同测试，也都声明「`page.tsx` 一行不许动」）
+
+---
+
+## 1. 为什么要换
+
+两条冻结的余量都用完了：
+
+| 文件 | 当前 | 上限 | 余量 |
+| --- | ---: | ---: | ---: |
+| `frontend/src/app/page.tsx` | 1,951 行 | 1,951 | **0** |
+| `scripts/jyotish_api_server.py` | 11,334 行 | 11,363 | **29** |
+
+冻结当初的用意是逼新代码往 hooks / lib / 独立模块里走，第一阶段确实起了作用（`page.tsx` 从 4,766 砍到 1,951）。但顶到线之后它的作用反转：**任何一轮正常改动只要需要在这两个文件里加几行接线就会被打红**，这一轮于是被迫去做一件与本次目标无关的搬运。上一轮的 `TASK-rectification-p0-fix-20260915` 就是这么来的——BUG-705 的十来行接线让 1,951 变 1,964，逻辑本身早就在 lib 里了，超的只是接线。
+
+而行数从来不是维护成本的来源。两个文件各有一个能直接表达耦合的数字：
+
+**`page.tsx`**
+
+| 指标 | BUG-249 当时 | 今天 |
+| --- | ---: | ---: |
+| 文件行数 | 4,766 | 1,951 |
+| `useState` | 56 | **66** |
+| `useEffect` | 18 | 22 |
+| `useRef` | — | 41 |
+| `useCallback` / `useMemo` | 0 / 0 | 0 / 0 |
+
+**行数砍掉 59%，状态反而从 56 涨到 66。** 抽出去的 hook 是参数式的（§6 现有那句「参数式 hook 内部保持 0 个 React hook」），`useSessionManagement(params)` 开头要解构约 40 个参数——代码搬走了，状态所有权一个都没搬。
+
+**`scripts/jyotish_api_server.py`**
+
+| 项 | 数量 |
+| --- | ---: |
+| `JyotishAPIHandler` 方法 | **225**（8,219 行，占全文件 72%） |
+| 模块级函数 | 102（2,981 行） |
+| `do_POST` / `do_GET` 路径分支 | 78（`do_POST` 单个方法 263 行） |
+| `self.headers` / `self.wfile` / `self.rfile` / `self.path` 全文件出现次数 | **12** |
+| `JyotishAPIHandler.__new__` 伪造点 | **4** |
+
+**225 个方法，只有 12 处真的碰到 HTTP 上下文。** 其余是披着 `self` 外衣的纯函数，这正是那 4 处 `__new__` 后门的成因。
+
+## 2. 根因
+
+冻结盯的是「文件有多大」，而维护成本来自「谁依赖谁」。行数是耦合的影子：影子被按住了，本体照长不误——`page.tsx` 的状态数、api server 的类方法数在冻结期内都是**增长**的。
+
+## 3. 决策记录
+
+产品 2026-09-15 拍板：**两条冻结的口径都要换**，并明确以下三点。
+
+1. **主门换成耦合指标，行数降级为粗护栏。** 不是取消行数限制，而是把它 rebaseline 到有余量的位置，让它只拦住「整块新功能塞进来」这种明显情况；真正的门是下面两组数。
+2. **推翻 `AGENTS.md` §6 现有的「参数式 hook 内部保持 0 个 React hook 的既定模式」。** 这条正是状态搬不走的原因：它要求抽出去的 hook 不持有 React 状态，于是状态只能留在 `Home()`。产品明确授权改掉它——**新口径下，抽出去的 hook 与子组件应当持有自己的状态**。执行方不得以「AGENTS 有这条」为由拒改；本节就是那条红线的推翻记录。
+3. **`__new__` 计数这一轮只要求「不得增长」，不要求为 0。** 现在是 4 处，收到 0 是 API server 拆解单的验收标准，不是本单的。本单只负责把尺子立起来。
+
+## 4. 硬红线
+
+1. **本单不改任何业务代码。** 只改 `AGENTS.md` §6、两个合同测试，以及把一条断言从它现在寄居的文件挪到专用文件。`page.tsx` 与 `jyotish_api_server.py` 一行不许动。
+2. **不得放宽既有的其它冻结条款。** §6 第三条（不得再手写第二个聊天输入框 / 第二套滚动跟随 / 第二套加载动画）原样保留。
+3. 行数 rebaseline 的新基线必须取**开工当时的实测值**，并在测试注释里写明取值日期与 `wc -l` 的结果，不得抄本任务书里的数字（七条在飞分支合并后这些数会变）。
+4. 新的耦合指标基线同理：`useState` / `useRef` / 类方法数 / `__new__` 计数都以开工当时实测为准，只许降不许升。
+5. 不得顺手升级依赖、不得顺手修不在本单里的 warning。
+
+## 5. 任务分解
+
+### 5.1 `page.tsx`：新建专用合同测试
+
+现在这条断言寄居在 `frontend/tests/chart-view-route.test.ts` 的 `page.tsx does not grow to host the chart page` 里（`assert.ok((pageSource.match(/\n/g) ?? []).length <= 1951)`）——它和星盘页没有关系，只是当时顺手放在那儿。新建 `frontend/tests/home-shell-growth-contract.test.ts`，把增长约束集中过去：
+
+| 门 | 断言 | 今天的值 |
+| --- | --- | ---: |
+| 主门 | `Home()` 里的 `useState` 数不得增长 | 66 |
+| 主门 | `Home()` 里的 `useRef` 数不得增长（防止把 state 改写成 ref 绕过上面那条） | 41 |
+| 粗护栏 | 文件行数 ≤ 实测基线 + 150 | 1,951 |
+
+`chart-view-route.test.ts` 里保留与星盘页真正相关的那半条（`assert.doesNotMatch(pageSource, /chart-page|ChartPageView|\/api\/chart-view/)`），行数断言删除并注明搬到了哪里。
+
+- 验收：新测试在当前代码上绿；人为在 `page.tsx` 加一个 `useState` 后必须红（执行方在进度记录里贴出这次反向验证，证明尺子会动，不是恒为真）。
+- 验收：计数方式要能区分 `useState(` 与 `useState<Type>(`（今天 66 这个数就是按 `\buseState[<(]` 数出来的；只按 `useState(` 数会漏掉一半）。
+- 验收：`npx tsx --test tests/chart-view-route.test.ts` 仍绿，且该文件不再包含行数断言。
+
+### 5.2 `jyotish_api_server.py`：改 `tests/test_api_server_growth_contract.py`
+
+现在是 `JYOTISH_API_SERVER_LINE_COUNT_BASELINE = 11063` + 300。改成：
+
+| 门 | 断言 | 今天的值 |
+| --- | --- | ---: |
+| 主门 | `JyotishAPIHandler` 的方法数不得增长 | 225 |
+| 主门 | 全仓 `JyotishAPIHandler.__new__` 出现次数不得增长 | 4 |
+| 粗护栏 | 文件行数 ≤ 实测基线 + 300 | 11,334 |
+
+方法数用缩进匹配（`^    (?:async )?def \w+`）即可，和本任务书 §1 那张表同一种数法。`__new__` 计数扫 `scripts/` 与 `tests/`，把命中文件列进断言失败信息，方便下次一眼看到是谁又开了后门。
+
+- 验收：新断言在当前代码上绿；人为加一个类方法后必须红（同样贴反向验证）。
+- 验收：该文件现有的另外三条断言（`AGENTS.md` 里必须出现 `must not grow` / `thinly registered` / 该测试必须在 `CORE_PYTEST_TARGETS` 与快速门里）一条不改仍绿。
+- 验收：`.venv/bin/python -m pytest tests/test_api_server_growth_contract.py` 通过。
+
+### 5.3 改 `AGENTS.md` §6
+
+两条改写，逐字说明新口径：
+
+- 第一条（api server）：把「冻结时行数 + 300 行 bugfix 余量」换成「**类方法数不得增长、`__new__` 伪造点不得增长**，行数是粗护栏」；保留「新端点进独立模块、主文件只做薄注册」这句话——新口径正是在奖励它。
+- 第二条（`page.tsx`）：把「不得再增长」换成「**`Home()` 的 `useState` / `useRef` 数不得增长**」；**删掉「参数式 hook 内部保持 0 个 React hook 的既定模式」**，改成「抽出去的 hook 与子组件应当持有自己的状态；`page.tsx` 只做装配」。
+
+同时在 §6 里点明这次换口径的理由一句话（行数是耦合的影子），免得下一轮有人以为是放水。
+
+- 验收：`tests/test_api_server_growth_contract.py` 里那条「`AGENTS.md` 必须包含 must not grow / thinly registered」的断言仍绿（措辞改写时不要把这两个短语弄没了）。
+- 验收：`frontend/AGENTS.md` 若有重复表述，同轮对齐。
+
+### 5.4 记录
+
+本单不产生 Bug 记录（改的是规则，不是缺陷），也不进 `CHANGELOG.md`（无用户可感知变化）。进度记录里必须写清楚：四组基线的实测值、取值日期、以及两次反向验证的结果。
+
+## 6. 让步顺序
+
+1. 5.2（api server 口径）最先做——它直接决定 C1 那一单还要不要为 29 行余量拧巴。
+2. 5.1 次之。
+3. 5.3 必须和前两条同轮（规则和门禁不许分家，否则下一轮有人按旧 AGENTS 拒改）。
+4. 5.4 不得砍。
+
+## 7. 开工前置命令
+
+```bash
+git fetch origin --prune
+git worktree add -b codex/freeze-metric-change-20260915 \
+  .worktrees/freeze-metric-change-20260915 origin/staging
+cd .worktrees/freeze-metric-change-20260915
+git status -sb | head -1
+# 取当时实测基线，不要抄任务书里的数
+wc -l scripts/jyotish_api_server.py frontend/src/app/page.tsx
+grep -cE '^    (async )?def ' scripts/jyotish_api_server.py
+grep -rc 'JyotishAPIHandler.__new__' scripts/ tests/ | grep -v ':0'
+grep -cE '\buseState[<(]' frontend/src/app/page.tsx
+grep -cE '\buseRef[<(]' frontend/src/app/page.tsx
+```
+
+验收命令：
+
+```bash
+.venv/bin/python -m pytest tests/test_api_server_growth_contract.py
+.venv/bin/python scripts/run_quality_gate.py --profile quick
+cd frontend && npx tsx --test tests/home-shell-growth-contract.test.ts tests/chart-view-route.test.ts
+npx tsx --test tests/*.test.ts     # 与基线逐条比对失败清单
+```
+
+## 8. BUG 编号起点
+
+本单不占 BUG 号。基线 `6b3248bf` 上最大号 **BUG-720**，721–732 已被两轮审计七单预占。
+
+## 9. 不在本单范围
+
+- 真的去搬状态或搬方法（见 `TASK-home-state-lowering-20260915.md` 与 API server 拆解单）
+- `__new__` 收到 0（拆解单的验收标准）
+- §6 第三条的三个「不得再手写第二套」条款
@@ -0,0 +1,159 @@
+# TASK · 把校正面的 15 个状态从首页搬下去（page.tsx 状态下沉 · 第一簇）
+
+- 日期：2026-09-15
+- 基线 commit：`origin/staging` @ `6b3248bf`（开工时以最新 `origin/staging` 为准，见 §7）
+- 执行分支：`codex/home-state-lowering-20260915`
+- 落点：`frontend/src/app/page.tsx`、`frontend/src/hooks/use-rectification-surface.ts`、`frontend/src/components/conversational-birth-time-rectification.tsx`（或新建的容器组件）
+- **串行依赖（三条，缺一不可）**：
+  1. `TASK-freeze-metric-change-20260915` —— 本单要让抽出去的 hook 持有 React 状态，那正是现行 `AGENTS.md §6` 禁止的；必须等新口径生效
+  2. `TASK-consultation-context-memory-20260915`（C2）—— 它在改 `use-session-management.ts` / `use-consultation-run.ts`，与本单同一片状态层
+  3. `TASK-rectification-settled-render-split-20260915`（R3）—— 它在改 `rectification-agentic-chat.tsx`，与本单同一片子树
+- 规模：一簇状态换个住处。**零行为变化、零文案变化。**
+
+---
+
+## 1. 为什么是这一簇
+
+`page.tsx` 现在 1,951 行，行数上限 1,951，**余量 0**。但行数不是病根：
+
+| 指标 | BUG-249 当时 | 今天 |
+| --- | ---: | ---: |
+| 文件行数 | 4,766 | 1,951 |
+| `Home()` 的 `useState` | 56 | **66** |
+| `useEffect` | 18 | 22 |
+| `useRef` | — | 41 |
+| `useCallback` / `useMemo` | 0 / 0 | 0 / 0 |
+
+**行数砍掉 59%，状态反而从 56 涨到 66。** 前几轮拆的是代码不是状态：抽出去的 hook 是参数式的，`useSessionManagement(params)` 开头要解构约 40 个参数，`useRectificationSurface(params)` 约 56 个——状态所有权一个都没搬，每搬一次还要新增一批传参。
+
+66 个 state 按归属分群：
+
+| 群 | 个数 |
+| --- | ---: |
+| **`rectification*`** | **15** |
+| `session*` | 10 |
+| `profile*` | 6 |
+| `synastry*` | 4 |
+| `account*` | 4 |
+| 其余分散 | 27 |
+
+最大的一簇服务的是一个**已经是 `dynamic()` 懒加载的子树**：`<ConversationalBirthTimeRectification>` 挂着 **24 个 props**，而喂它们的 15 个 state 全住在 `Home()` 里。边界最清楚、收益最大，所以第一簇搬它。
+
+那 15 个是：
+
+```
+rectificationSessionId          rectificationShouldStartOpening
+rectificationCaseId             rectificationTurns
+rectificationHeaderSlot         rectificationSnapshot
+rectificationPendingQuestion    rectificationOpeningSessionId
+rectificationLoading            rectificationEntrySummary
+rectificationMutationPending    rectificationEntrySummarySettled
+rectificationError
+rectificationErrorSessionId
+rectificationReadonly
+```
+
+## 2. 根因
+
+`AGENTS.md §6` 现行那句「参数式 hook 内部保持 0 个 React hook 的既定模式」把状态钉死在 `Home()` 里；同一节的行数冻结又不许 `page.tsx` 增长。两条合起来等于「不许再加状态」，而每一轮新功能都要加。`TASK-freeze-metric-change-20260915` 已经拿到产品授权推翻前半句，本单是第一个吃到新口径的轮次。
+
+## 3. 决策记录
+
+产品 2026-09-15 拍板：
+
+1. **`page.tsx` 走「状态下沉」这条路**，不引外部 store、不铺全局 Context Provider。理由：不引新依赖、可以一簇一簇增量做，每搬一簇 `page.tsx` 就真降一截。
+2. **第一簇搬校正面的 15 个。** 后续 `session*` / `profile*` / `synastry*` 各自另开单，本单不碰。
+3. **抽出去的 hook 与子组件从此持有自己的状态**（推翻 §6 旧红线，措辞由 freeze-metric-change 单落地）。执行方不得以「AGENTS 说参数式 hook 里不能有 React hook」为由拒改。
+4. **零行为变化。** 本单不修任何已知交互缺陷，发现了写进进度记录。
+
+## 4. 硬红线
+
+1. **不是 15 个都能搬。** 有几个外壳自己要读（例如 `rectificationSessionId` / `rectificationCaseId` 参与决定显示哪个界面、侧栏会话列表也要知道）。**第一步必须逐个分类**：「只服务子树 → 搬下去」「外壳也要读 → 留在外壳，但收敛成一个对象，不再是散装的多个 `useState`」。分类表写进进度记录，不许含糊。
+2. **零行为变化**是唯一成败判据：进入校正面、退出、刷新、从首页卡片打开、打开历史校正、开场自动触发、只读态、报错态、换模型、采用后回首页——逐条与改前一致。
+3. `next build` 后 `/` 仍须 `○ Static`；首屏 JS gzip 变化在 ±2 % 内（上次实测 584,413 B）。
+4. 测试总数不得低于开工时 `origin/staging` 的实测；改任何既有断言必须写「原值 / 新值 / 原因」三栏（AGENTS §7.3）。
+5. 不得新写第二个聊天输入框、第二套滚动跟随、第二套加载动画（§6 第三条原样有效）。
+6. 不得顺手升级依赖、不得顺手修不在本单里的 warning。
+7. **不得改数据库、不得改任何 API 路由。** 本单只动前端状态的住处。
+
+## 5. 任务分解
+
+### 5.1 先分类，再动手
+
+把 15 个逐个归类并写进进度记录：
+
+| 类别 | 处置 |
+| --- | --- |
+| 只服务校正子树 | 搬进子树（`useRectificationSurface` 变成真 hook，或由容器组件持有） |
+| 外壳也要读 | 留在外壳，但合并成**一个**状态对象，散装 `useState` 数下降 |
+
+- 验收：分类表在进度记录里，15 个一个不漏，每个写明依据（谁在读它）。
+
+### 5.2 `useRectificationSurface` 变成真 hook
+
+现在它要解构约 56 个参数。改成自己 `useState` / `useEffect` 持有第一类状态，对外只暴露子树真正需要的接口；`page.tsx` 侧的传参随之消失。
+
+- 验收：`useRectificationSurface` 的参数个数显著下降，新值写进进度记录（改前约 56）。
+- 验收：`<ConversationalBirthTimeRectification>` 的 props 个数下降，新值写进进度记录（改前 24）。
+
+### 5.3 `Home()` 的状态计数必须真降
+
+- 验收：`Home()` 的 `useState` 数从 **66** 降到 **≤ 53**（搬走至少 13 个；允许留 2 个在外壳，多留必须逐个说明理由）。
+- 验收：`useRef` 数不得上升（改前 41）——不许把 state 改写成 ref 来凑数字。
+- 验收：`frontend/tests/home-shell-growth-contract.test.ts`（由 freeze-metric-change 单建立）在本单收尾时更新为新基线，并贴一次反向验证。
+
+### 5.4 行为等价证明
+
+- 验收：改动前后各跑一次全量前端套件，失败清单逐条一致（无 Docker 时数据库套件照常红）。
+- 验收：`npx tsx --test tests/rectification-*.test.ts` 全绿，断言零改动——如果必须改，按 §4.4 写三栏说明。
+- 验收：`docs/testing/` 下留一份真人走查清单，覆盖 §4.2 那十条路径（本仓没有浏览器与登录态，这一项只能人工）。
+
+### 5.5 记录
+
+本单不产生 Bug 记录（不是缺陷，是结构改造），不进 `CHANGELOG.md`（无用户可感知变化）。若过程中确实改了任何可见样式，必须同提交更新 `frontend/DESIGN.md`（AGENTS §7.5）。
+
+## 6. 让步顺序
+
+1. 5.1（分类）**不得砍**——没有分类表就动手，一定会把外壳要读的状态搬下去然后再搬回来。
+2. 5.2 + 5.3 是主体。
+3. 5.3 的目标值可以让步（比如只搬到 ≤ 56），但让步幅度和原因必须写进进度记录，**不得静默降低**。
+4. 5.4 不得砍。
+5. 5.5 不得砍。
+
+## 7. 开工前置命令
+
+```bash
+git fetch origin --prune
+# 三条串行依赖必须都已合入 staging，逐个确认
+git log --oneline origin/staging | head -20
+git worktree add -b codex/home-state-lowering-20260915 \
+  .worktrees/home-state-lowering-20260915 origin/staging
+cd .worktrees/home-state-lowering-20260915/frontend
+git status -sb | head -1
+npm ci
+# 取当时实测基线，不要抄本任务书里的数字（七条在飞分支合并后会变）
+grep -cE '\buseState[<(]' src/app/page.tsx
+grep -cE '\buseRef[<(]' src/app/page.tsx
+grep -oE 'const \[rectification[A-Za-z]+' src/app/page.tsx | wc -l
+```
+
+验收命令：
+
+```bash
+./node_modules/.bin/tsc --noEmit
+npm run lint                       # 0 error
+npx tsx --test tests/rectification-*.test.ts tests/home-shell-growth-contract.test.ts
+npx tsx --test tests/*.test.ts     # 与基线逐条比对失败清单
+npm run build                      # `/` 仍须 ○ Static，首屏 gzip ±2%
+```
+
+## 8. BUG 编号起点
+
+本单不占 BUG 号。基线 `6b3248bf` 上最大号 **BUG-720**，721–732 已被两轮审计七单预占。
+
+## 9. 不在本单范围
+
+- `session*` / `profile*` / `synastry*` / `account*` 四簇（各自另开单）
+- Context Provider 或外部 store（§3.1 已否决这一轮走这两条路）
+- 校正面自身的任何交互缺陷（本单零行为变化）
+- API server 拆解（另一条线）
@@ -0,0 +1,32 @@
+# 真机清单 · 校正长会话流式时已结算消息是否还卡（2026-09-15）
+
+代码级合同在 `frontend/tests/rectification-settled-render-split.test.ts`、`chat-markdown-split.test.ts`。本仓没有浏览器环境，「长会话流式时是否还卡」只能由产品在真实环境确认。下面这些必须用真机或已登录的 staging 做，自动化替代不了。
+
+地址：`https://staging.jyotisha.chat`。截图不要带真实姓名、出生资料或会话内容。
+
+## A. 长会话流式期间历史是否还卡
+
+1. 登录后打开一个**已有二十轮以上**的生时校正会话（采集 + 探针都走过、气泡很多的那种）。
+2. 发一条会触发**长回答**的消息（例如请它解释当前范围为什么收到这里、对照了哪些分盘）。
+3. 流式开始后不要滚走，盯着屏幕。
+4. **看：** 正在写的那一条在动；上面已经写完的历史气泡**不应**跟着闪、整页掉帧、或像被整表重绘。滚动条位置保持贴底（若你本来就在底部）。
+5. 流式尚未结束时，用手向上滚一点历史。**看：** 跟随解除，「跳到最新」出现；历史气泡仍不闪。点「跳到最新」回到底部，跟随恢复。
+6. 回答写完。**看：** 刚写完的那一条没有淡出再淡入；时间线从展开收到「已完成 N 步」时，下面正文不整段跳一下。
+
+## B. 题目、选择卡、交付卡仍在原位
+
+同一条长会话里再走一轮带题的回答（选择题或口述采集）。
+
+1. **看：** 题干仍嵌在同一条助手气泡里，不跑到输入框上方，也没有第二套输入框。
+2. 选择题：选项可点；点完进入下一轮；「先这样，先看当前范围」仍在卡内。
+3. 口述采集：只有输入框，没有「没有 / 记不清」芯片。
+4. 若已到交付：区间卡仍跟在该条助手消息下面；点「更像这个」时三列卡不整张消失。
+5. 复制 / 赞 / 踩 / 重新生成（只允许最近一条）与改前一致。
+
+## C. 375px
+
+视口宽度 375px 再走一遍 A.2–A.4。历史气泡在窄屏下也不应在流式时整列闪。
+
+## 结论
+
+> 待填。测完写日期 + 设备 + 浏览器 + 逐条正常/有问题。测不了就写「未测」，不要写成通过。
@@ -30,6 +30,7 @@ import { isProductEnabled } from "@/lib/product-access";
 import { resolveSessionLanguageModel } from "@/lib/model-catalog";
 import { jsonForSupabaseSetupFailure } from "@/lib/api/service-unavailable";
 import { createAdminSupabaseClient } from "@/lib/supabase/admin";
+import { withRectificationRequestCache } from "@/lib/rectification-agentic/v9/request-cache";
 import { createServerSupabaseClient } from "@/lib/supabase/server";
 import { defaultMessageOrigin, isRectificationMessageOrigin } from "@/lib/rectification-agentic/v9/message-origin";
 import { previousInferenceFromReceipt } from "@/lib/rectification-agentic/v9/inference-adapter";
@@ -150,7 +151,7 @@ export async function POST(request: Request) {
  let accounting;
  try {
    supabase = await createServerSupabaseClient();
-    accounting = createAdminSupabaseClient();
+    accounting = withRectificationRequestCache(createAdminSupabaseClient());
  } catch (error) {
    return jsonForSupabaseSetupFailure(error, "POST /api/rectification/agent");
  }
@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import { z } from "zod";
 import { jsonForSupabaseSetupFailure } from "@/lib/api/service-unavailable";
 import { createAdminSupabaseClient } from "@/lib/supabase/admin";
+import { withRectificationRequestCache } from "@/lib/rectification-agentic/v9/request-cache";
 import { isProductEnabled } from "@/lib/product-access";
 import { createServerSupabaseClient } from "@/lib/supabase/server";
 import { RectificationToolServiceError } from "@/lib/rectification-agentic/v9/tool-service";
@@ -59,7 +60,7 @@ export async function POST(request: Request, context: RouteContext) {
  let accounting;
  try {
    supabase = await createServerSupabaseClient();
-    accounting = createAdminSupabaseClient();
+    accounting = withRectificationRequestCache(createAdminSupabaseClient());
  } catch (error) {
    return jsonForSupabaseSetupFailure(error, "POST /api/rectification/cases/[caseId]/candidates/accept");
  }
@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import { z } from "zod";
 import { jsonForSupabaseSetupFailure } from "@/lib/api/service-unavailable";
 import { createAdminSupabaseClient } from "@/lib/supabase/admin";
+import { withRectificationRequestCache } from "@/lib/rectification-agentic/v9/request-cache";
 import { createServerSupabaseClient } from "@/lib/supabase/server";
 import {
  loadV9CaseDossier,
@@ -32,7 +33,7 @@ export async function POST(request: Request, context: RouteContext) {
  let accounting;
  try {
    supabase = await createServerSupabaseClient();
-    accounting = createAdminSupabaseClient();
+    accounting = withRectificationRequestCache(createAdminSupabaseClient());
  } catch (error) {
    return jsonForSupabaseSetupFailure(error, "POST /api/rectification/cases/[caseId]/repair-exit");
  }
@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import { z } from "zod";
 import { jsonForSupabaseSetupFailure } from "@/lib/api/service-unavailable";
 import { createAdminSupabaseClient } from "@/lib/supabase/admin";
+import { withRectificationRequestCache } from "@/lib/rectification-agentic/v9/request-cache";
 import { createServerSupabaseClient } from "@/lib/supabase/server";
 import {
  loadV9CaseDossier,
@@ -29,7 +30,7 @@ export async function GET(request: Request, context: RouteContext) {
  let accounting;
  try {
    supabase = await createServerSupabaseClient();
-    accounting = createAdminSupabaseClient();
+    accounting = withRectificationRequestCache(createAdminSupabaseClient());
  } catch (error) {
    return jsonForSupabaseSetupFailure(error, "GET /api/rectification/cases/[caseId]");
  }
@@ -9,6 +9,7 @@ import { resolveExactSkillPackage } from "@/lib/skill-package-registry";
 import { resolveSessionLanguageModel } from "@/lib/model-catalog";
 import { jsonForSupabaseSetupFailure } from "@/lib/api/service-unavailable";
 import { createAdminSupabaseClient } from "@/lib/supabase/admin";
+import { withRectificationRequestCache } from "@/lib/rectification-agentic/v9/request-cache";
 import { createServerSupabaseClient } from "@/lib/supabase/server";
 import { getRectificationV9RegenerationAgent } from "@/mastra/agentic-rectification";
 import { logRectificationDeliveryTurn } from "@/lib/rectification-agentic/v9/delivery-turn-guard";
@@ -64,7 +65,7 @@ export async function POST(request: Request, context: RouteContext) {
  let accounting;
  try {
    supabase = await createServerSupabaseClient();
-    accounting = createAdminSupabaseClient();
+    accounting = withRectificationRequestCache(createAdminSupabaseClient());
  } catch (error) {
    return jsonForSupabaseSetupFailure(error, "POST /api/rectification/cases/[caseId]/turns/[turnId]/regenerate");
  }
@@ -53,19 +53,37 @@ function renderProse(text: string, renderMarkdown: MarkdownRenderer | undefined)
    ));
 }

+const settledMarkdownNodes = new WeakMap<MarkdownRenderer, Map<string, ReactNode>>();
+
+function rememberedProse(text: string, renderMarkdown: MarkdownRenderer | undefined): ReactNode {
+  if (!text) return null;
+  if (!renderMarkdown) return renderProse(text, undefined);
+  let byText = settledMarkdownNodes.get(renderMarkdown);
+  if (!byText) {
+    byText = new Map();
+    settledMarkdownNodes.set(renderMarkdown, byText);
+  }
+  const cached = byText.get(text);
+  if (cached !== undefined) return cached;
+  const node = renderMarkdown(text);
+  byText.set(text, node);
+  return node;
+}
+
 /**
- * The completed part of a streaming answer. `memo` keeps React from calling the
- * markdown parser again while `text` is unchanged, so a frame that only grew
- * the tail costs one small parse instead of one over the whole answer.
+ * Settled prose and the completed prefix of a streaming answer. `memo` plus a
+ * content-keyed parse cache keep React from calling the markdown parser again
+ * while `text` is unchanged, so a parent re-render (or a frame that only grew
+ * the tail) does not parse the whole answer.
 */
-const StableMarkdownPrefix = memo(function StableMarkdownPrefix({
+export const StableMarkdownPrefix = memo(function StableMarkdownPrefix({
  text,
  renderMarkdown,
 }: Readonly<{
  text: string;
  renderMarkdown: MarkdownRenderer | undefined;
 }>) {
-  return <>{renderProse(text, renderMarkdown)}</>;
+  return <>{rememberedProse(text, renderMarkdown)}</>;
 });

 export function StreamingMarkdown({
@@ -104,7 +122,9 @@ export function ChatMessageContent({
  const reportBody = !streaming && report
    ? (
      <>
-        <div className="message-markdown">{renderProse(report, renderMarkdown)}</div>
+        <div className="message-markdown">
+          <StableMarkdownPrefix text={report} renderMarkdown={renderMarkdown} />
+        </div>
        {foldedAudit}
      </>
    )
@@ -116,7 +136,7 @@ export function ChatMessageContent({
        <div className="message-markdown">
          {streaming
            ? <StreamingMarkdown text={spoken} renderMarkdown={renderMarkdown} />
-            : renderProse(spoken, renderMarkdown)}
+            : <StableMarkdownPrefix text={spoken} renderMarkdown={renderMarkdown} />}
        </div>
      ) : null}
      {report
@@ -5,7 +5,7 @@ import { prefetchOnIdle } from "@/components/chat-chunk-prefetch";
 import { ChatMessageContent } from "@/components/chat-message-content";
 import { ConsultationRunTimeline } from "@/components/consultation-run-timeline";
 import type { ChatMessageView } from "@/lib/chat-message-view";
-import { useEffect, useLayoutEffect, useRef, type ReactNode } from "react";
+import { memo, useEffect, useLayoutEffect, useRef, type ReactNode } from "react";

 type GsapCore = typeof import("gsap")["gsap"];

@@ -35,7 +35,7 @@ export function AgentAvatar() {
  return <span className="agent-avatar" aria-hidden="true" />;
 }

-export function ChatMessageRow({
+export const ChatMessageRow = memo(function ChatMessageRow({
  message,
  showActivity = message.state !== "settled",
  vargaSentence,
@@ -170,4 +170,4 @@ export function ChatMessageRow({
      </div>
    </article>
  );
-}
+});
@@ -5,7 +5,7 @@ import { useQueuedMessage } from "@/hooks/use-queued-message";
 import { appendQueuedText, queuedDraftSettleAction } from "@/lib/queued-draft";
 import { createPortal } from "react-dom";
 import { parseAgentReply } from "@/lib/agent-reply";
-import { nextActivityView, type AgentActivityView, type ChatMessage, type ChatMessageView } from "@/lib/chat-message-view";
+import { nextActivityView, type AgentActivityView, type ChatMessage } from "@/lib/chat-message-view";
 import { createStreamFrameBuffer } from "@/lib/stream-frame-buffer";
 import {
  completeActivityTrace,
@@ -44,7 +44,6 @@ import {
  diffRectificationBoard,
  RECTIFICATION_BOARD_SPLIT_MIN_PX,
 } from "@/lib/rectification-board-model";
-import { rectificationTimelineRows } from "@/lib/rectification-timeline-adapter";
 import {
  rectificationAdoptingLabel,
  RECTIFICATION_EMPTY_ACTION_LABEL,
@@ -59,7 +58,6 @@ import {
  RECTIFICATION_QUESTION_UNAVAILABLE_COPY,
  RECTIFICATION_COLLECT_WAITING_PLACEHOLDER,
  RECTIFICATION_DELIVERED_COPY,
-  RECTIFICATION_STOPPED_NOTICE,
  isAbortError,
  rectificationConversationState,
  rectificationInitialLiveLabel,
@@ -81,7 +79,6 @@ import {
  buildRectificationTimeline,
  type RectificationTimelineStage,
 } from "@/lib/rectification-timeline-scale";
-import { vargaSentenceFromMethods } from "@/lib/rectification-varga-sentence";
 import {
  isPublicRectificationActivity,
  isPublicRectificationMethod,
@@ -99,19 +96,20 @@ import {
 } from "@/lib/rectification-agentic/v9/choice-action";
 import { postAdoptVerifyDoneCopy } from "@/lib/rectification-agentic/user-copy";
 import { isRectificationCaseStatus, isResumableStatus, type RectificationCaseStatus } from "@/lib/rectification-agentic/v9/case-status";
-import { CHOICE_MODE, CHOICE_SKIP_QUESTION_LABEL, CHOICE_SKIP_QUESTION_MESSAGE, CHOICE_STOP_LABEL, CHOICE_STOP_MESSAGE, isPersistedFocusId, parseRectificationChoiceCard, type ChoiceKey, type RectificationChoiceCard as ChoiceCardModel } from "@/lib/rectification-agentic/v9/choice-card";
+import { isPersistedFocusId, parseRectificationChoiceCard, type ChoiceKey, type RectificationChoiceCard as ChoiceCardModel } from "@/lib/rectification-agentic/v9/choice-card";
 import type { PublicLanguageModel } from "@/lib/public-models";
 import { useConversationScrollAnchor } from "@/hooks/use-conversation-scroll-anchor";
 import { useVisibilityAwarePoll } from "@/hooks/use-visibility-aware-poll";
 import { CharacterRemaining } from "./character-remaining";
 import { ChatComposer } from "./chat-composer";
-import { ChatMessageRow } from "./chat-message-row";
 import { ConsultationTimelineLiveRow } from "./consultation-run-timeline";
 import { JumpToLatestButton } from "./jump-to-latest-button";
+import { toggleChatMessageFeedback } from "./chat-message-actions";
 import {
-  ChatMessageActions,
-  toggleChatMessageFeedback,
-} from "./chat-message-actions";
+  RectificationMessageEntry,
+  type RectificationMessageActions,
+  type RenderMessage,
+} from "./rectification-message-entry";
 import { ModelSelector } from "./model-selector";
 import { RectificationBoard, RectificationBoardPeek } from "./rectification-board";
 import { RectificationChoiceCard } from "./rectification-choice-card";
@@ -124,7 +122,6 @@ import {
  questionIsAnswered,
  resolveSelectionCardMessageKey,
  type SelectionCardLock,
-  type TurnQuestion,
 } from "@/lib/rectification-agentic/v9/turn-question";
 import { Button } from "@/components/ui/button";
 import {
@@ -239,17 +236,6 @@ type RectificationAgenticChatProps = Readonly<{
  headerSlot: HTMLElement | null;
 }>;

-type RenderMessage = ChatMessageView & {
-  renderKey: string;
-  completedReceipt?: CompletedActivityReceiptView;
-  failed?: boolean;
-  stopped?: boolean;
-  turnId?: string;
-  activityTrace?: readonly AgentActivityTraceItem[];
-  question?: TurnQuestion;
-  candidateOffer?: Readonly<{ resultId: string }>;
-};
-
 function markQuestionAnswered(
  current: RenderMessage[],
  focusId: string,
@@ -273,37 +259,6 @@ function snapshotTurns(payload: { turns?: unknown } | null | undefined): readonl
  return Array.isArray(payload?.turns) ? payload.turns : [];
 }

-function choiceCardFromQuestion(
-  question: TurnQuestion,
-  live: ChoiceCardModel | null,
-): ChoiceCardModel | null {
-  if (live && live.focus_id === question.focus_id && live.options.length === 4) {
-    return { ...live, prompt: question.prompt };
-  }
-  if (!question.options || question.options.length !== 4) return null;
-  return {
-    question_id: question.question_id,
-    method_id: "",
-    prompt: question.prompt,
-    why: "",
-    varga: null,
-    choice_mode: CHOICE_MODE,
-    options: question.options.map((option) => ({
-      key: option.key,
-      label: option.label,
-      answer_class: "unsure",
-      role: "primary",
-    })),
-    stop_label: question.kind === "reverse_verify" ? CHOICE_SKIP_QUESTION_LABEL : CHOICE_STOP_LABEL,
-    stop_message: question.kind === "reverse_verify" ? CHOICE_SKIP_QUESTION_MESSAGE : CHOICE_STOP_MESSAGE,
-    scoring: question.kind !== "reverse_verify",
-    probe_id: question.probe_id,
-    case_revision: null,
-    focus_id: question.focus_id,
-    ...(live?.skip_this_probe ? { skip_this_probe: true } : {}),
-  };
-}
-
 function completedReceiptFromPersisted(receipt: PersistedTurn["receipt"]): CompletedActivityReceiptView {
  if (!receipt) return { steps: [], methods: [] };
  if (Array.isArray(receipt.tool_activities)) {
@@ -478,6 +433,13 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
  const [copiedMessageKey, setCopiedMessageKey] = useState<string | null>(null);
  const [regeneratingMessageKey, setRegeneratingMessageKey] = useState<string | null>(null);
  const [choiceNonce, setChoiceNonce] = useState(0);
+  const messageActionsRef = useRef<RectificationMessageActions>({
+    submitChoice() {},
+    submitStop() {},
+    copyMessage() {},
+    regenerateMessage() {},
+    onFeedback() {},
+  });
  const conversation = useRef<HTMLElement>(null);
  const workspace = useRef<HTMLDivElement>(null);
  const composer = useRef<HTMLTextAreaElement>(null);
@@ -1649,6 +1611,21 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
    void submitStructuredChoice(STOP_ACTION, "stop");
  }

+  useEffect(() => {
+    messageActionsRef.current = {
+      submitChoice,
+      submitStop,
+      copyMessage,
+      regenerateMessage,
+      onFeedback(renderKey, requested) {
+        setFeedback((current) => ({
+          ...current,
+          [renderKey]: toggleRectificationFeedback(current[renderKey], requested),
+        }));
+      },
+    };
+  });
+
  const boardPeek = compactBoard && !boardOpen ? (
    <RectificationBoardPeek
      result={candidateResult}
@@ -1689,118 +1666,31 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
            </div>
          )}
          {messages.map((message) => {
-            const showActions = message.role === "assistant"
-              && message.state === "settled"
-              && !message.failed
-              && Boolean(message.text);
            const regenerating = regeneratingMessageKey === message.renderKey;
            const canRegenerate = message.renderKey === latestRegeneratableKey
              && !busy
              && !readonly
              && regeneratingMessageKey === null;
-            // Both surfaces render the same step timeline: the tool trace and receipt
-            // are projected onto ConsultationRunTimeline rows. A regenerating reply shows
-            // the queued row until real events fill it in, never a staged label.
-            const displayedMessage: RenderMessage = regenerating
-              ? {
-                ...message,
-                text: "",
-                thinkingText: undefined,
-                state: "thinking" as const,
-                activity: undefined,
-                activityTrace: emptyActivityTrace(),
-                completedReceipt: undefined,
-                timeline: [],
-              }
-              : {
-                ...message,
-                timeline: rectificationTimelineRows({
-                  trace: message.activityTrace,
-                  receipt: message.completedReceipt,
-                  activity: message.activity,
-                  settled: message.state === "settled",
-                }),
-              };
-            const vargaSentence = !message.failed
-              ? vargaSentenceFromMethods(message.completedReceipt?.methods)
-              : null;
-            const question = regenerating ? undefined : message.question;
-            const liveQuestion = Boolean(
-              question
-              && currentQuestion?.focus_id === question.focus_id
-              && !questionIsAnswered(question)
-              && !busy
-              && !readonly
-              && regeneratingMessageKey === null
-              && (
-                question.kind === "collect_spoken"
-                || (
-                  choiceCard
-                  && choiceCard.focus_id === question.focus_id
-                  && (question.kind === "choice" || question.kind === "reverse_verify")
-                )
-              ),
-            );
-            const unansweredDeadChoice = Boolean(
-              question
-              && !questionIsAnswered(question)
-              && !liveQuestion
-              && (question.kind === "choice" || question.kind === "reverse_verify")
-            );
-            const embeddedCard = question && !unansweredDeadChoice
-              ? choiceCardFromQuestion(question, liveQuestion ? choiceCard : null)
-              : null;
-            const afterAnswer = question && displayedMessage.state === "settled"
-              ? (
-                <div className="rectification-message-question">
-                  <p className="rectification-message-question__prompt">{question.prompt}</p>
-                  {embeddedCard && (
-                    <RectificationChoiceCard
-                      key={`${embeddedCard.question_id}:${question.answer_option ?? choiceNonce}:${question.status}`}
-                      variant="embedded"
-                      card={embeddedCard}
-                      pending={busy && liveQuestion}
-                      disabled={!liveQuestion}
-                      selectedKey={question.answer_option ?? ""}
-                      onSelect={submitChoice}
-                      onStop={submitStop}
-                    />
-                  )}
-                  {question.status === "skipped" && (
-                    <p className="rectification-question-skipped" role="status">
-                      {savedTime ? `已跳过（已采用 ${savedTime}）` : "已跳过"}
-                    </p>
-                  )}
-                </div>
-              )
-              : undefined;
            return (
              <div
                key={message.renderKey}
                className="rectification-message-wrap rectification-message-entry"
              >
-                {(!message.failed || Boolean(displayedMessage.text) || regenerating) && (
-                  <ChatMessageRow
-                    message={displayedMessage}
-                    showActivity={displayedMessage.state !== "settled"}
-                    vargaSentence={vargaSentence}
-                    afterAnswer={afterAnswer}
-                    stoppedNotice={message.stopped ? RECTIFICATION_STOPPED_NOTICE : undefined}
-                  />
-                )}
-                {showActions && !regenerating && (
-                  <ChatMessageActions
-                    feedback={feedback[message.renderKey]}
-                    copied={copiedMessageKey === message.renderKey}
-                    canRegenerate={canRegenerate}
-                    onFeedback={(requested) => setFeedback((current) => ({
-                      ...current,
-                      [message.renderKey]: toggleRectificationFeedback(current[message.renderKey], requested),
-                    }))}
-                    onCopy={() => void copyMessage(message)}
-                    onRegenerate={() => void regenerateMessage(message)}
-                  />
-                )}
+                <RectificationMessageEntry
+                  message={message}
+                  busy={busy}
+                  readonly={readonly}
+                  regenerating={regenerating}
+                  canRegenerate={canRegenerate}
+                  currentQuestionFocusId={currentQuestion?.focus_id ?? null}
+                  interactive={!busy && !readonly && regeneratingMessageKey === null}
+                  liveChoiceCard={choiceCard}
+                  choiceNonce={choiceNonce}
+                  savedTime={savedTime}
+                  copied={copiedMessageKey === message.renderKey}
+                  feedback={feedback[message.renderKey]}
+                  actionsRef={messageActionsRef}
+                />
                {showSelectionCards && candidateResult && message.renderKey === selectionCardMessageKey && (
                  <>
                    <RectificationRangeDelivery
@@ -0,0 +1,259 @@
+"use client";
+
+import { memo, type MutableRefObject } from "react";
+
+import {
+  ChatMessageActions,
+  type ChatMessageFeedback,
+} from "@/components/chat-message-actions";
+import { ChatMessageRow } from "@/components/chat-message-row";
+import { RectificationChoiceCard } from "@/components/rectification-choice-card";
+import { emptyActivityTrace, type AgentActivityTraceItem } from "@/lib/agent-activity-trace";
+import type { ChatMessageView } from "@/lib/chat-message-view";
+import {
+  noteSettledRowRender,
+  noteStreamingRowRender,
+  noteUnsplitListRender,
+} from "@/lib/home-streaming-render-probe";
+import type { CompletedActivityReceiptView } from "@/lib/rectification-activity-receipt";
+import {
+  CHOICE_MODE,
+  CHOICE_SKIP_QUESTION_LABEL,
+  CHOICE_SKIP_QUESTION_MESSAGE,
+  CHOICE_STOP_LABEL,
+  CHOICE_STOP_MESSAGE,
+  type ChoiceKey,
+  type RectificationChoiceCard as ChoiceCardModel,
+} from "@/lib/rectification-agentic/v9/choice-card";
+import {
+  questionIsAnswered,
+  type TurnQuestion,
+} from "@/lib/rectification-agentic/v9/turn-question";
+import { RECTIFICATION_STOPPED_NOTICE } from "@/lib/rectification-surface-state";
+import { rectificationTimelineRows } from "@/lib/rectification-timeline-adapter";
+import { vargaSentenceFromMethods } from "@/lib/rectification-varga-sentence";
+
+export type RenderMessage = ChatMessageView & {
+  renderKey: string;
+  completedReceipt?: CompletedActivityReceiptView;
+  failed?: boolean;
+  stopped?: boolean;
+  turnId?: string;
+  activityTrace?: readonly AgentActivityTraceItem[];
+  question?: TurnQuestion;
+  candidateOffer?: Readonly<{ resultId: string }>;
+};
+
+export type RectificationMessageActions = Readonly<{
+  submitChoice: (key: ChoiceKey) => void;
+  submitStop: () => void;
+  copyMessage: (message: RenderMessage) => void;
+  regenerateMessage: (message: RenderMessage) => void;
+  onFeedback: (renderKey: string, requested: ChatMessageFeedback) => void;
+}>;
+
+export type RectificationMessageEntryProps = Readonly<{
+  message: RenderMessage;
+  busy: boolean;
+  readonly: boolean;
+  regenerating: boolean;
+  canRegenerate: boolean;
+  currentQuestionFocusId: string | null;
+  interactive: boolean;
+  liveChoiceCard: ChoiceCardModel | null;
+  choiceNonce: number;
+  savedTime: string | null;
+  copied: boolean;
+  feedback: ChatMessageFeedback | undefined;
+  actionsRef: MutableRefObject<RectificationMessageActions>;
+}>;
+
+export function choiceCardFromQuestion(
+  question: TurnQuestion,
+  live: ChoiceCardModel | null,
+): ChoiceCardModel | null {
+  if (live && live.focus_id === question.focus_id && live.options.length === 4) {
+    return { ...live, prompt: question.prompt };
+  }
+  if (!question.options || question.options.length !== 4) return null;
+  return {
+    question_id: question.question_id,
+    method_id: "",
+    prompt: question.prompt,
+    why: "",
+    varga: null,
+    choice_mode: CHOICE_MODE,
+    options: question.options.map((option) => ({
+      key: option.key,
+      label: option.label,
+      answer_class: "unsure",
+      role: "primary",
+    })),
+    stop_label: question.kind === "reverse_verify" ? CHOICE_SKIP_QUESTION_LABEL : CHOICE_STOP_LABEL,
+    stop_message: question.kind === "reverse_verify" ? CHOICE_SKIP_QUESTION_MESSAGE : CHOICE_STOP_MESSAGE,
+    scoring: question.kind !== "reverse_verify",
+    probe_id: question.probe_id,
+    case_revision: null,
+    focus_id: question.focus_id,
+    ...(live?.skip_this_probe ? { skip_this_probe: true } : {}),
+  };
+}
+
+function RectificationMessageEntryView({
+  message,
+  busy,
+  regenerating,
+  canRegenerate,
+  currentQuestionFocusId,
+  interactive,
+  liveChoiceCard,
+  choiceNonce,
+  savedTime,
+  copied,
+  feedback,
+  actionsRef,
+}: RectificationMessageEntryProps) {
+  const showActions = message.role === "assistant"
+    && message.state === "settled"
+    && !message.failed
+    && Boolean(message.text);
+  const displayedMessage: RenderMessage = regenerating
+    ? {
+      ...message,
+      text: "",
+      thinkingText: undefined,
+      state: "thinking" as const,
+      activity: undefined,
+      activityTrace: emptyActivityTrace(),
+      completedReceipt: undefined,
+      timeline: [],
+    }
+    : {
+      ...message,
+      timeline: rectificationTimelineRows({
+        trace: message.activityTrace,
+        receipt: message.completedReceipt,
+        activity: message.activity,
+        settled: message.state === "settled",
+      }),
+    };
+  const vargaSentence = !message.failed
+    ? vargaSentenceFromMethods(message.completedReceipt?.methods)
+    : null;
+  const question = regenerating ? undefined : message.question;
+  const liveQuestion = Boolean(
+    question
+    && currentQuestionFocusId === question.focus_id
+    && !questionIsAnswered(question)
+    && interactive
+    && (
+      question.kind === "collect_spoken"
+      || (
+        liveChoiceCard
+        && liveChoiceCard.focus_id === question.focus_id
+        && (question.kind === "choice" || question.kind === "reverse_verify")
+      )
+    ),
+  );
+  const unansweredDeadChoice = Boolean(
+    question
+    && !questionIsAnswered(question)
+    && !liveQuestion
+    && (question.kind === "choice" || question.kind === "reverse_verify")
+  );
+  const embeddedCard = question && !unansweredDeadChoice
+    ? choiceCardFromQuestion(question, liveQuestion ? liveChoiceCard : null)
+    : null;
+  const afterAnswer = question && displayedMessage.state === "settled"
+    ? (
+      <div className="rectification-message-question">
+        <p className="rectification-message-question__prompt">{question.prompt}</p>
+        {embeddedCard && (
+          <RectificationChoiceCard
+            key={`${embeddedCard.question_id}:${question.answer_option ?? choiceNonce}:${question.status}`}
+            variant="embedded"
+            card={embeddedCard}
+            pending={busy && liveQuestion}
+            disabled={!liveQuestion}
+            selectedKey={question.answer_option ?? ""}
+            onSelect={(key) => actionsRef.current.submitChoice(key)}
+            onStop={() => actionsRef.current.submitStop()}
+          />
+        )}
+        {question.status === "skipped" && (
+          <p className="rectification-question-skipped" role="status">
+            {savedTime ? `已跳过（已采用 ${savedTime}）` : "已跳过"}
+          </p>
+        )}
+      </div>
+    )
+    : undefined;
+
+  return (
+    <>
+      {(!message.failed || Boolean(displayedMessage.text) || regenerating) && (
+        <ChatMessageRow
+          message={displayedMessage}
+          showActivity={displayedMessage.state !== "settled"}
+          vargaSentence={vargaSentence}
+          afterAnswer={afterAnswer}
+          stoppedNotice={message.stopped ? RECTIFICATION_STOPPED_NOTICE : undefined}
+        />
+      )}
+      {showActions && !regenerating && (
+        <ChatMessageActions
+          feedback={feedback}
+          copied={copied}
+          canRegenerate={canRegenerate}
+          onFeedback={(requested) => actionsRef.current.onFeedback(message.renderKey, requested)}
+          onCopy={() => void actionsRef.current.copyMessage(message)}
+          onRegenerate={() => void actionsRef.current.regenerateMessage(message)}
+        />
+      )}
+    </>
+  );
+}
+
+export const RectificationMessageEntry = memo(function RectificationMessageEntry(
+  props: RectificationMessageEntryProps,
+) {
+  if (props.regenerating || props.message.state !== "settled") noteStreamingRowRender();
+  else noteSettledRowRender();
+  return <RectificationMessageEntryView {...props} />;
+});
+
+export function UnsplitRectificationMessageList({
+  messages,
+  latestRegeneratableKey,
+  copiedMessageKey,
+  feedbackByKey,
+  regeneratingMessageKey,
+  ...shared
+}: Omit<RectificationMessageEntryProps, "message" | "regenerating" | "canRegenerate" | "copied" | "feedback"> & {
+  messages: readonly RenderMessage[];
+  latestRegeneratableKey?: string;
+  copiedMessageKey: string | null;
+  feedbackByKey: Readonly<Record<string, ChatMessageFeedback | undefined>>;
+  regeneratingMessageKey: string | null;
+}) {
+  noteUnsplitListRender();
+  return (
+    <>
+      {messages.map((message) => {
+        noteSettledRowRender();
+        if (message.state !== "settled") noteStreamingRowRender();
+        return (
+          <RectificationMessageEntryView
+            key={message.renderKey}
+            {...shared}
+            message={message}
+            regenerating={regeneratingMessageKey === message.renderKey}
+            canRegenerate={message.renderKey === latestRegeneratableKey && shared.interactive}
+            copied={copiedMessageKey === message.renderKey}
+            feedback={feedbackByKey[message.renderKey]}
+          />
+        );
+      })}
+    </>
+  );
+}
@@ -0,0 +1,76 @@
+/**
+ * Request-scoped cache for Case read projections.
+ *
+ * `get_agentic_rectification_case_dossier` and
+ * `get_agentic_rectification_case_compute` are unchanged for the life of a
+ * request until this client performs any other RPC or table access. Call sites
+ * keep calling `loadV9CaseDossier` as before; the wrapper sits on the client
+ * object so direct `accounting.rpc(...)` paths are covered too.
+ *
+ * The cache is a closure over a Map created by each `withRectificationRequestCache`
+ * call. It is not stored on `globalThis` or at module scope.
+ *
+ * Other properties are forwarded through a Proxy so `.from(table).update(...)`
+ * (used via `as never` in a few call sites) still works, and accessing them
+ * invalidates the same way a non-projection RPC does.
+ */
+import type { RectificationRpcClient } from "./tool-service";
+
+export const RECTIFICATION_CACHED_PROJECTION_RPCS = [
+  "get_agentic_rectification_case_dossier",
+  "get_agentic_rectification_case_compute",
+] as const;
+
+type CachedProjectionRpc = (typeof RECTIFICATION_CACHED_PROJECTION_RPCS)[number];
+
+const cachedProjectionRpcSet = new Set<string>(RECTIFICATION_CACHED_PROJECTION_RPCS);
+
+function isCachedProjectionRpc(fn: string): fn is CachedProjectionRpc {
+  return cachedProjectionRpcSet.has(fn);
+}
+
+function projectionCacheKey(fn: string, args: Record<string, unknown>): string | null {
+  const userId = args.p_user_id;
+  const caseId = args.p_case_id;
+  if (typeof userId !== "string" || typeof caseId !== "string" || !userId || !caseId) {
+    return null;
+  }
+  return `${fn}\0${userId}\0${caseId}`;
+}
+
+type RpcResult = Awaited<ReturnType<RectificationRpcClient["rpc"]>>;
+
+export function withRectificationRequestCache<T extends RectificationRpcClient>(accounting: T): T {
+  const cache = new Map<string, PromiseLike<RpcResult>>();
+  const originalRpc = accounting.rpc.bind(accounting);
+
+  function invalidate(): void {
+    cache.clear();
+  }
+
+  function cachedRpc(fn: string, args: Record<string, unknown>): PromiseLike<RpcResult> {
+    if (!isCachedProjectionRpc(fn)) {
+      invalidate();
+      return originalRpc(fn, args);
+    }
+    const key = projectionCacheKey(fn, args);
+    if (!key) return originalRpc(fn, args);
+    const hit = cache.get(key);
+    if (hit) return hit;
+    const pending = originalRpc(fn, args);
+    cache.set(key, pending);
+    return pending;
+  }
+
+  return new Proxy(accounting, {
+    get(target, property) {
+      if (property === "rpc") return cachedRpc;
+      invalidate();
+      const value = Reflect.get(target, property);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    },
+  }) as T;
+}
@@ -175,7 +175,11 @@ test("question stem ownership stays on set-focus spokenPrompt, not a slot or a s
  assert.doesNotMatch(exit, /assistantMessage\.(?:includes|match|search)/);
  assert.doesNotMatch(exit, /question\.prompt\.(?:includes|match|search)/);
  assert.doesNotMatch(chat, /rectification-question-slot/);
-  assert.match(chat, /afterAnswer/);
+  // 原值: 容器源码含 afterAnswer。
+  // 新值: afterAnswer 在行组件；题干类名仍在对话面。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /afterAnswer/);
  assert.match(chat, /rectification-message-question/);
 });

@@ -31,7 +31,10 @@ test("ChatMessageContent splits spoken from report and only folds when a report
 });

 test("the folded technique audit moves inside the report fold when a report exists", () => {
-  assert.match(contentSource, /<div className="message-markdown">\{renderProse\(report, renderMarkdown\)\}<\/div>/);
+  // 原值: `{renderProse(report, renderMarkdown)}` 每次重渲全量 parse。
+  // 新值: 报告层走 `StableMarkdownPrefix`。
+  // 原因: BUG-725 结算态 Markdown 按文本记忆化。
+  assert.match(contentSource, /<div className="message-markdown">\s*<StableMarkdownPrefix text=\{report\} renderMarkdown=\{renderMarkdown\} \/>/);
  assert.match(contentSource, /\{foldedAudit\}/);
  assert.match(contentSource, /const reportBody = !streaming && report/);
  assert.match(contentSource, /AnswerDetailDisclosure headings=\{layers\.headings\} streaming=\{streaming\}/);
@@ -57,15 +57,16 @@ test("the pre-markdown fallback renders prose but never raw markdown", () => {
  // 原因: 口语层与报告层共用 renderProse，plainParagraphs 只在它内部调用一次。
  assert.match(contentSource, /\(plainParagraphs\(text\) \?\? \[\]\)\.map/);

-  // 两层必须都走 renderProse，不得一层 markdown 一层裸文本。
-  // 口语层若改成 {spoken} / renderMarkdown(spoken)、报告层仍走 renderProse（或反过来），
-  // 下面的精确计数会从 2 掉到 1。不得改成 >= 1。
-  assert.match(contentSource, /renderProse\(spoken,\s*renderMarkdown\)/);
-  assert.match(contentSource, /renderProse\(report,\s*renderMarkdown\)/);
+  // 原值: 口语层与报告层都直接 `renderProse(spoken/report, renderMarkdown)`，计数为 2。
+  // 新值: 结算两层都走 `StableMarkdownPrefix`；流式尾块仍走 `renderProse(split.tail)`。
+  // 原因: BUG-725 结算态按文本记忆化。计数仍锁死为 2，不得放宽成 >= 1。
+  assert.match(contentSource, /<StableMarkdownPrefix text=\{spoken\} renderMarkdown=\{renderMarkdown\} \/>/);
+  assert.match(contentSource, /<StableMarkdownPrefix text=\{report\} renderMarkdown=\{renderMarkdown\} \/>/);
  assert.equal(
-    contentSource.match(/renderProse\((?:spoken|report),\s*renderMarkdown\)/g)?.length,
+    contentSource.match(/<StableMarkdownPrefix text=\{(?:spoken|report)\} renderMarkdown=\{renderMarkdown\} \/>/g)?.length,
    2,
  );
+  assert.match(contentSource, /renderProse\(split\.tail, renderMarkdown\)/);
  assert.doesNotMatch(contentSource, /\{renderMarkdown\((?:spoken|report)\)\}/);
  assert.doesNotMatch(contentSource, />\{(?:spoken|report)\}<\/div>/);
 });
@@ -100,7 +100,11 @@ test("rectification abort settles as stopped, not a failed alert", () => {
  assert.match(rectification, /stopped: true/);
  assert.match(rectification, /failed: false,\s*stopped: true/);
  assert.doesNotMatch(rectification, /if \(raw\.trim\(\)\) setError\(RECTIFICATION_STOPPED_NOTICE\)/);
-  assert.match(rectification, /stoppedNotice=\{message\.stopped \? RECTIFICATION_STOPPED_NOTICE : undefined\}/);
+  // 原值: 停止提示 prop 写在 rectification-agentic-chat.tsx。
+  // 新值: 同一表达式在行组件内。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /stoppedNotice=\{message\.stopped \? RECTIFICATION_STOPPED_NOTICE : undefined\}/);
  assert.match(messageRow, /stoppedNotice/);
  assert.match(messageRow, /className="message-stopped-notice"/);
  assert.equal(RECTIFICATION_STOPPED_NOTICE, "已停止，已生成的内容保留；本次不会扣点。");
@@ -4,7 +4,7 @@ import test from "node:test";
 import { createElement } from "react";
 import { renderToString } from "react-dom/server";

-import { StreamingMarkdown } from "../src/components/chat-message-content.tsx";
+import { StableMarkdownPrefix, StreamingMarkdown } from "../src/components/chat-message-content.tsx";
 import { splitStableMarkdown } from "../src/lib/chat-markdown-split.ts";

 const contentSource = readFileSync(new URL("../src/components/chat-message-content.tsx", import.meta.url), "utf8");
@@ -68,9 +68,22 @@ test("the streaming renderer parses the prefix and the tail as two separate docu
  assert.match(contentSource, /const StableMarkdownPrefix = memo\(function StableMarkdownPrefix/);
  assert.match(contentSource, /splitStableMarkdown\(text\)/);
  assert.match(contentSource, /streaming\s*\?\s*<StreamingMarkdown/);
-  // 原值: `: renderMarkdown ? renderMarkdown(spoken)` 只给口语层走 markdown。
-  // 新值: 口语层与报告层都走 `renderProse`。
-  // 原因: 两层可见性后，折叠内外共用同一套解析，避免两套 fallback。
-  assert.match(contentSource, /: renderProse\(spoken, renderMarkdown\)/);
+  // 原值: `: renderProse(spoken, renderMarkdown)` 结算口语层每次重渲都全量 parse。
+  // 新值: 结算口语层走 `StableMarkdownPrefix`（按文本记忆 + 解析缓存）。
+  // 原因: BUG-725 流式帧不得重跑已结算 Markdown。
+  assert.match(contentSource, /: <StableMarkdownPrefix text=\{spoken\} renderMarkdown=\{renderMarkdown\} \/>/);
  assert.match(messageRowSource, /streaming=\{message\.state !== "settled"\}/);
 });
+
+test("settled markdown parses the same text only once across consecutive renders", () => {
+  const calls: string[] = [];
+  const renderMarkdown = (text: string) => {
+    calls.push(text);
+    return createElement("p", null, text);
+  };
+  const text = "已结算的一段回答，对照了 D9 和 D10。";
+  renderToString(createElement(StableMarkdownPrefix, { text, renderMarkdown }));
+  renderToString(createElement(StableMarkdownPrefix, { text, renderMarkdown }));
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls, [text]);
+});
@@ -189,7 +189,15 @@ test("ordinary consultation replies reuse the shared Agent action bar", () => {
  assert.doesNotMatch(rectificationChat, /event\.type === "thinking\.delta"/);
  assert.match(rectificationChat, /startActivityTraceStep/);
  assert.match(rectificationChat, /completeActivityTraceStep/);
-  assert.match(rectificationChat, /<ChatMessageActions/);
+  // 原值: 校正面容器源码含 `<ChatMessageActions`。
+  // 新值: 动作条随行组件抽出，容器仍 import 行组件。
+  // 原因: BUG-725。
+  const rectificationEntry = readFileSync(
+    new URL("../src/components/rectification-message-entry.tsx", import.meta.url),
+    "utf8",
+  );
+  assert.match(rectificationEntry, /<ChatMessageActions/);
+  assert.match(rectificationChat, /<RectificationMessageEntry/);
  assert.match(globalStyles, /\.message-actions \{/);
  assert.doesNotMatch(globalStyles, /\.rectification-message-actions \{/);
 });
@@ -410,7 +410,11 @@ test("chat owns adopt cards on the offering message and drops the list-end hando
  // 原因: BUG-595 决策 3
  assert.doesNotMatch(chat, /rectification-adopt-status/);
  assert.doesNotMatch(chat, /用这个时间看盘/);
-  assert.match(chat, /CHOICE_STOP_LABEL/);
+  // 原值: 容器源码含 CHOICE_STOP_LABEL、已跳过（已采用）、scoring: question.kind。
+  // 新值: 这些 token 随 choiceCardFromQuestion / afterAnswer 进了行组件。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /CHOICE_STOP_LABEL/);
  // 原值: 口述采集输入框上方必须有与点选卡同款停止按钮
  // 新值: 停止只留选择题卡与生成中「停止回答」
  // 原因: BUG-595 决策 2
@@ -420,11 +424,11 @@ test("chat owns adopt cards on the offering message and drops the list-end hando
    readFileSync(new URL("../src/components/rectification-choice-card.tsx", import.meta.url), "utf8"),
    /stop_label !== CHOICE_STOP_LABEL/,
  );
-  assert.match(chat, /已跳过（已采用/);
+  assert.match(messageEntry, /已跳过（已采用/);
  assert.match(chat, /rectificationLiveProgressLabel/);
  assert.doesNotMatch(chat, /rectification-consult-handoff/);
  assert.match(chat, /kind === "reverse_verify"/);
-  assert.match(chat, /scoring: question\.kind !== "reverse_verify"/);
+  assert.match(messageEntry, /scoring: question\.kind !== "reverse_verify"/);
 });

 test("choice cards use 这题跳过 for reverse_verify and 先这样 for collect", () => {
@@ -12,6 +12,10 @@ const chat = readFileSync(
  new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url),
  "utf8",
 );
+const messageEntry = readFileSync(
+  new URL("../src/components/rectification-message-entry.tsx", import.meta.url),
+  "utf8",
+);
 const activityStatus = readFileSync(
  new URL("../src/components/agent-activity-status.tsx", import.meta.url),
  "utf8",
@@ -352,10 +356,13 @@ test("rectification keeps receipts for the varga sentence and shows live tool pr
  assert.match(activityHelper, /filter\(isPublicRectificationTool\)/);
  assert.match(activityHelper, /receipt\.methods/);
  assert.match(activityHelper, /filter\(isPublicRectificationMethod\)/);
-  assert.match(chat, /completedReceipt\?: CompletedActivityReceiptView/);
-  assert.match(chat, /showActivity=\{displayedMessage\.state !== "settled"\}/);
-  assert.match(chat, /vargaSentenceFromMethods/);
-  assert.match(chat, /vargaSentence=\{vargaSentence\}/);
+  // 原值: 上述 token 都在 rectification-agentic-chat.tsx 的 messages.map 内。
+  // 新值: RenderMessage / 时间轴 / varga 句随行组件抽出。
+  // 原因: BUG-725 已结算行记忆化，派生不得留在容器每帧计算。
+  assert.match(messageEntry, /completedReceipt\?: CompletedActivityReceiptView/);
+  assert.match(messageEntry, /showActivity=\{displayedMessage\.state !== "settled"\}/);
+  assert.match(messageEntry, /vargaSentenceFromMethods/);
+  assert.match(messageEntry, /vargaSentence=\{vargaSentence\}/);
  assert.match(chat, /activityTraceFromReceipt/);
  assert.match(activityStatus, /vargaSentence/);
  assert.match(activityStatus, /VargaTraceStep/);
@@ -375,9 +382,14 @@ test("rectification keeps receipts for the varga sentence and shows live tool pr
    chat.indexOf("{messages.map((message) => {"),
    chat.indexOf("{savedTime &&"),
  );
-  const replyIndex = messageRender.indexOf("<ChatMessageRow");
+  // 原值: `<ChatMessageRow` 写在容器 messages.map 里。
+  // 新值: 行渲染在 `rectification-message-entry.tsx`，容器 map 只挂行组件。
+  // 原因: BUG-725 抽出 memo 行。
+  const replyIndex = messageEntry.indexOf("<ChatMessageRow");
  assert.ok(replyIndex >= 0);
+  assert.match(messageRender, /<RectificationMessageEntry/);
  assert.doesNotMatch(messageRender, /<RectificationHouseTableView/);
+  assert.doesNotMatch(messageEntry, /<RectificationHouseTableView/);
  // Former locks on `completed-activity-receipt.tsx` (`<details>`, never open, the "本轮完成 · N 个
  // 步骤" summary): that was a second collapsed block under every settled rectification reply.
  // Its methods now sit as source chips on the shared timeline's calculate row (BUG-476).
@@ -397,7 +409,10 @@ test("rectification keeps receipts for the varga sentence and shows live tool pr
  assert.match(chat, /completeActivityTraceStep/);
  // Former lock: `activityStatus` contained `activityTrace` — the rectification-only trace panel.
  // The trace is now projected onto the shared timeline rows (BUG-476); the panel is a fallback.
-  assert.match(chat, /rectificationTimelineRows/);
+  // 原值: chat 源码直接调用 rectificationTimelineRows。
+  // 新值: 调用点在行组件内。
+  // 原因: BUG-725 容器不再每帧派生时间轴行。
+  assert.match(messageEntry, /rectificationTimelineRows/);
  assert.doesNotMatch(activityStatus, /activityTrace/);
  assert.match(activityStatus, /className="message-thinking"/);
  assert.match(activityStatus, />思考</);
@@ -409,7 +424,10 @@ test("completed Agent replies restore feedback, copy and safe in-place regenerat
  for (const label of ["赞", "踩", "复制回答", "重新生成回答"]) {
    assert.match(messageActions, new RegExp(`aria-label="${label}"`));
  }
-  assert.match(chat, /<ChatMessageActions/);
+  // 原值: `<ChatMessageActions` 写在容器 messages.map 里。
+  // 新值: 动作条随行组件抽出；容器仍切换 feedback。
+  // 原因: BUG-725 动作回调走 actionsRef，组件本身仍要渲染动作条。
+  assert.match(messageEntry, /<ChatMessageActions/);
  assert.match(chat, /toggleRectificationFeedback/);
  assert.match(chat, /navigator\.clipboard\.writeText\(copyTextForMessage\(message\.text, message\.question\)\)/);
  assert.match(chat, /\/turns\/\$\{encodeURIComponent\(message\.turnId\)\}\/regenerate/);
@@ -419,11 +437,12 @@ test("completed Agent replies restore feedback, copy and safe in-place regenerat
    chat.indexOf("{messages.map((message) => {"),
    chat.indexOf("{savedTime &&"),
  );
-  const replyIndex = messageRender.indexOf("<ChatMessageRow");
-  const actionsIndex = messageRender.indexOf("<ChatMessageActions");
+  const replyIndex = messageEntry.indexOf("<ChatMessageRow");
+  const actionsIndex = messageEntry.indexOf("<ChatMessageActions");
  assert.ok(replyIndex >= 0 && actionsIndex >= 0);
  assert.ok(replyIndex < actionsIndex);
  assert.doesNotMatch(messageRender, /<CompletedActivityReceipt/);
+  assert.doesNotMatch(messageEntry, /<CompletedActivityReceipt/);

  assert.doesNotMatch(chat, /send\("message",\s*(?:oldText|previousText)/);
  assert.doesNotMatch(regenerateRoute, /consultation-billing|reserveConsultation|billing\./);
@@ -486,7 +505,10 @@ test("the natal house table is a live board beside the chat, not a message", ()
    board.indexOf("className=\"rectification-snapshot\""),
    board.indexOf("{scoringMinutes.length > 0 || displayMinutes.length > 0"),
  );
-  const rowIndex = messageLoop.indexOf("<ChatMessageRow");
+  // 原值: `<ChatMessageRow` 在容器 map 循环里。
+  // 新值: 循环渲染 `RectificationMessageEntry`，ChatMessageRow 在行组件内。
+  // 原因: BUG-725。
+  const rowIndex = messageLoop.indexOf("<RectificationMessageEntry");
  const snapshotIndex = snapshot.indexOf("className=\"rectification-snapshot\"");
  const houseIndex = snapshot.indexOf("<RectificationHouseTableView");
  assert.ok(rowIndex >= 0);
@@ -582,12 +604,18 @@ test("rectification composer can stop a live agent run", () => {
  // 新值：isAbortError(caught)
  // 原因：选择题与采用路径共用同一中止判定（BUG-552）
  assert.match(chat, /isAbortError\(caught\)/);
-  assert.match(chat, /showActivity=\{displayedMessage\.state !== "settled"\}/);
+  // 原值: 容器 map 写 `showActivity={displayedMessage.state !== "settled"}`。
+  // 新值: 同一表达式在行组件内。
+  // 原因: BUG-725。
+  assert.match(messageEntry, /showActivity=\{displayedMessage\.state !== "settled"\}/);
 });

 test("aborting a live run marks the bubble stopped without an alert", () => {
  assert.match(chat, /failed: false,\s*stopped: true/);
-  assert.match(chat, /stoppedNotice=\{message\.stopped \? RECTIFICATION_STOPPED_NOTICE : undefined\}/);
+  // 原值: 停止提示 prop 写在容器 map 的 ChatMessageRow 上。
+  // 新值: 同一表达式在行组件内。
+  // 原因: BUG-725。
+  assert.match(messageEntry, /stoppedNotice=\{message\.stopped \? RECTIFICATION_STOPPED_NOTICE : undefined\}/);
  assert.doesNotMatch(chat, /role="alert"[\s\S]{0,80}RECTIFICATION_STOPPED_NOTICE/);
  const choiceFetch = chat.slice(chat.indexOf("const submitStructuredChoice"), chat.indexOf("const acceptCandidate"));
  assert.match(choiceFetch, /runAbort\.current = abortController/);
@@ -609,9 +637,13 @@ test("time-selection cards use server adoption state and stay mutually exclusive
    chat.indexOf("{messages.map((message) => {"),
    chat.indexOf("{savedTime &&"),
  );
-  const actionsIndex = messageLoop.indexOf("<ChatMessageActions");
+  // 原值: ChatMessageActions 与 RangeDelivery 都在容器 map 里，且 actions 在卡之前。
+  // 新值: 动作条在行组件内；交付卡仍在容器 map、排在行组件之后。
+  // 原因: BUG-725 行组件抽出，交付卡不属于逐消息 Markdown 边界。
+  const entryIndex = messageLoop.indexOf("<RectificationMessageEntry");
  const cardsIndex = messageLoop.indexOf("<RectificationRangeDelivery");
-  assert.ok(actionsIndex >= 0 && cardsIndex > actionsIndex);
+  assert.ok(entryIndex >= 0 && cardsIndex > entryIndex);
+  assert.match(messageEntry, /<ChatMessageActions/);
  // 旧：showSelectionCards 只看 selectionAllowed && canAdopt && !showLiveChoiceCard && !busy，
  // 锚在 latestSettledAssistant。采集题没有 A–D 卡，所以 collect_evidence 会出采用卡；
  // 采用后 busy 把卡藏掉，新消息又把卡带走。
@@ -644,11 +676,18 @@ test("time-selection cards use server adoption state and stay mutually exclusive
  // 新值: 还要有 candidateResult 才渲染行选卡
  // 原因: BUG-595 决策 1
  assert.match(messageLoop, /showSelectionCards && candidateResult && message\.renderKey === selectionCardMessageKey/);
+  // 原值: 嵌入卡 token（RectificationChoiceCard / variant / choiceNonce / answer_option）在容器 map。
+  // 新值: 嵌入卡在行组件；容器 map 仍有 persisted 题卡的 RectificationChoiceCard。
+  // 原因: BUG-725。
+  assert.match(messageEntry, /<RectificationChoiceCard/);
+  assert.match(messageEntry, /variant="embedded"/);
+  assert.match(messageEntry, /choiceNonce/);
+  assert.match(messageEntry, /question\.answer_option/);
  assert.match(messageLoop, /<RectificationChoiceCard/);
  assert.match(messageLoop, /variant="embedded"/);
  assert.match(messageLoop, /choiceNonce/);
-  assert.match(messageLoop, /question\.answer_option/);
  assert.doesNotMatch(messageLoop, /rectification-question-slot/);
+  assert.doesNotMatch(messageEntry, /rectification-question-slot/);
  assert.doesNotMatch(choiceCardComponent, /setSelectedKey\(""\)/);
  assert.match(choiceCardComponent, /selectedKey/);
  assert.match(choiceCardComponent, /is-answered/);
@@ -664,8 +703,12 @@ test("time-selection cards use server adoption state and stay mutually exclusive
  assert.doesNotMatch(chat, /send\("message", choiceCard\?\.stop_message/);
  assert.doesNotMatch(chat, /choiceCardUserMessage/);
  assert.match(caseProjection, /choice_card: choiceCardFromCaseDossier/);
-  assert.match(chat, /choiceCard\s+&& choiceCard\.focus_id === question\.focus_id/);
-  assert.match(chat, /disabled=\{!liveQuestion\}/);
+  // 原值: 容器 map 用 `choiceCard && choiceCard.focus_id === question.focus_id` 和 `disabled={!liveQuestion}`。
+  // 新值: 行组件用 liveChoiceCard / liveQuestion；容器的 live 卡判定仍比对 latestLiveQuestion。
+  // 原因: BUG-725。
+  assert.match(messageEntry, /liveChoiceCard\s+&& liveChoiceCard\.focus_id === question\.focus_id/);
+  assert.match(messageEntry, /disabled=\{!liveQuestion\}/);
+  assert.match(chat, /choiceCard\s+&& choiceCard\.focus_id === latestLiveQuestion\.focus_id/);
  assert.match(caseProjection, /current_question: projectCurrentQuestion/);
  assert.match(caseProjection, /overlayPublicDecision/);
  assert.match(caseProjection, /const fields = publicDecisionFields\(decision\)/);
@@ -107,6 +107,10 @@ test("composer wrap no longer hosts 先这样 or the adopt status bar", () => {
  assert.doesNotMatch(wrap, /rectification-collect-stop/);
  assert.doesNotMatch(wrap, /rectification-composer-meta/);
  assert.doesNotMatch(wrap, /rectification-adopt-status/);
-  assert.match(chat, /CHOICE_STOP_LABEL/);
+  // 原值: 容器源码含 CHOICE_STOP_LABEL（嵌入卡 stop 文案）。
+  // 新值: 常量在行组件的 choiceCardFromQuestion 里；composer-wrap 仍不得托管。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /CHOICE_STOP_LABEL/);
  assert.match(chat, /postAdoptVerifyDoneCopy/);
 });
@@ -636,7 +636,11 @@ test("collect spoken stop stays on choice cards; range line is status only", ()
  );
  const wrap = chat.slice(chat.indexOf("className=\"composer-wrap\""), chat.indexOf("className=\"composer-footer\""));
  assert.doesNotMatch(wrap, /rectification-collect-stop/);
-  assert.match(chat, /CHOICE_STOP_LABEL/);
+  // 原值: 容器源码含 CHOICE_STOP_LABEL。
+  // 新值: 常量在行组件；容器仍有 submitStop，composer-wrap 仍不得托管。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /CHOICE_STOP_LABEL/);
  assert.match(chat, /kind === "collect_spoken"/);
  assert.match(chat, /function submitStop/);
  assert.match(chat, /RectificationReadonlyRange/);
@@ -135,9 +135,13 @@ test("copy text is body, blank line, stem, then option lines", () => {

 test("one assistant article owns the stem and options; the slot class is gone", () => {
  assert.match(row, /afterAnswer/);
-  assert.match(chat, /afterAnswer=\{afterAnswer\}/);
+  // 原值: 容器源码含 `afterAnswer={afterAnswer}`。
+  // 新值: 行组件内部构造 afterAnswer；题干类名与 embedded 变体仍在对话面。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /afterAnswer=\{afterAnswer\}/);
  assert.match(chat, /rectification-message-question/);
-  assert.match(chat, /variant="embedded"/);
+  assert.match(messageEntry, /variant="embedded"/);
  assert.match(chat, /function markQuestionAnswered/);
  assert.match(chat, /"typed"/);
  assert.doesNotMatch(chat, /rectification-question-slot/);
@@ -0,0 +1,185 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+import { withRectificationRequestCache } from "../src/lib/rectification-agentic/v9/request-cache.ts";
+import { loadV9CaseDossier } from "../src/lib/rectification-agentic/v9/tool-service.ts";
+import { runV9AgentTurn } from "../src/lib/rectification-agentic/v9/agent-run.ts";
+import { RECTIFICATION_SKILL_NAME } from "../src/lib/rectification-agentic/v9/case-status.ts";
+import {
+  CASE_COMPUTE_RPC,
+  CASE_DOSSIER_RPC,
+  CASE_ID,
+  SESSION_ID,
+  TURN_ID,
+  USER_ID,
+  countCachedProjectionRpcs,
+  dossierFixture,
+  fakeAccounting,
+  receiptHandlers,
+} from "./rectification-v9-test-support.ts";
+
+/** Measured after wrapping: route-style prefetch + one evidence turn. */
+const CACHED_AGENT_TURN_DOSSIER_BUDGET = 4;
+
+const WRAPPED_ADMIN_CLIENT = /accounting = withRectificationRequestCache\(createAdminSupabaseClient\(\)\)/;
+const BARE_ADMIN_CLIENT = /accounting = createAdminSupabaseClient\(\)/;
+
+const CACHED_ROUTES = [
+  "../src/app/api/rectification/agent/route.ts",
+  "../src/app/api/rectification/cases/[caseId]/turns/[turnId]/regenerate/route.ts",
+  "../src/app/api/rectification/cases/[caseId]/route.ts",
+  "../src/app/api/rectification/cases/[caseId]/repair-exit/route.ts",
+  "../src/app/api/rectification/cases/[caseId]/candidates/accept/route.ts",
+] as const;
+
+function projectionArgs(caseId = CASE_ID) {
+  return { p_user_id: USER_ID, p_case_id: caseId };
+}
+
+function delayedClient(innerCalls: string[], delayMs = 20) {
+  return {
+    rpc(fn: string, args: Record<string, unknown>) {
+      void args;
+      innerCalls.push(fn);
+      return new Promise<{ data: unknown; error: null }>((resolve) => {
+        setTimeout(() => resolve({ data: { ok: fn }, error: null }), delayMs);
+      });
+    },
+  };
+}
+
+test("repeated case_dossier reads of the same user and case hit the in-flight cache once", async () => {
+  const accounting = fakeAccounting({
+    [CASE_DOSSIER_RPC]: () => dossierFixture(),
+  }, { requestCache: true });
+  const first = await loadV9CaseDossier(accounting.client, USER_ID, CASE_ID);
+  const second = await loadV9CaseDossier(accounting.client, USER_ID, CASE_ID);
+  assert.equal(first.case.caseId, CASE_ID);
+  assert.equal(second.case.caseId, CASE_ID);
+  assert.deepEqual(countCachedProjectionRpcs(accounting.calls), { dossier: 1, compute: 0 });
+});
+
+test("a non-projection rpc invalidates so the next dossier read hits the backing client", async () => {
+  const accounting = fakeAccounting({
+    [CASE_DOSSIER_RPC]: () => dossierFixture(),
+    append_agentic_rectification_turn: () => ({ turn_id: TURN_ID }),
+  }, { requestCache: true });
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs());
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs());
+  await accounting.client.rpc("append_agentic_rectification_turn", projectionArgs());
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs());
+  assert.equal(countCachedProjectionRpcs(accounting.calls).dossier, 2);
+});
+
+test("two caseIds do not share a cached projection", async () => {
+  const otherCaseId = "99999999-9999-4999-8999-999999999999";
+  const accounting = fakeAccounting({
+    [CASE_DOSSIER_RPC]: () => dossierFixture(),
+  }, { requestCache: true });
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs(CASE_ID));
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs(otherCaseId));
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs(CASE_ID));
+  assert.equal(
+    accounting.calls.filter((call) => call.fn === CASE_DOSSIER_RPC).length,
+    2,
+  );
+});
+
+test("concurrent duplicate reads share one backing rpc", async () => {
+  const innerCalls: string[] = [];
+  const wrapped = withRectificationRequestCache(delayedClient(innerCalls));
+  const args = projectionArgs();
+  const [first, second] = await Promise.all([
+    wrapped.rpc(CASE_DOSSIER_RPC, args),
+    wrapped.rpc(CASE_DOSSIER_RPC, args),
+  ]);
+  assert.deepEqual(first, { data: { ok: CASE_DOSSIER_RPC }, error: null });
+  assert.deepEqual(second, { data: { ok: CASE_DOSSIER_RPC }, error: null });
+  assert.deepEqual(innerCalls, [CASE_DOSSIER_RPC]);
+});
+
+test("dossier and compute projections cache independently", async () => {
+  const accounting = fakeAccounting({
+    [CASE_DOSSIER_RPC]: () => dossierFixture(),
+    [CASE_COMPUTE_RPC]: () => ({ case_id: CASE_ID }),
+  }, { requestCache: true });
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs());
+  await accounting.client.rpc(CASE_COMPUTE_RPC, projectionArgs());
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs());
+  await accounting.client.rpc(CASE_COMPUTE_RPC, projectionArgs());
+  assert.deepEqual(countCachedProjectionRpcs(accounting.calls), { dossier: 1, compute: 1 });
+});
+
+test(".from passthrough invalidates the projection cache", async () => {
+  const accounting = fakeAccounting({
+    [CASE_DOSSIER_RPC]: () => dossierFixture(),
+  }, { requestCache: true });
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs());
+  await accounting.client.from("profiles").update({ birth_time_source: "approximate" }).eq("id", USER_ID);
+  await accounting.client.rpc(CASE_DOSSIER_RPC, projectionArgs());
+  assert.equal(countCachedProjectionRpcs(accounting.calls).dossier, 2);
+  assert.equal(accounting.profilePatches.length, 1);
+});
+
+test("rectification routes wrap createAdminSupabaseClient once and never use the bare client", () => {
+  for (const relative of CACHED_ROUTES) {
+    const source = readFileSync(new URL(relative, import.meta.url), "utf8");
+    const wraps = source.match(new RegExp(WRAPPED_ADMIN_CLIENT.source, "g")) ?? [];
+    assert.equal(wraps.length, 1, relative);
+    assert.equal(BARE_ADMIN_CLIENT.test(source), false, relative);
+  }
+});
+
+test("a cached evidence turn stays within the measured case_dossier budget", async () => {
+  const handlers = {
+    ...receiptHandlers,
+    [CASE_DOSSIER_RPC]: () => dossierFixture(),
+    append_agentic_rectification_turn: () => ({ turn_id: TURN_ID }),
+    finalize_agentic_rectification_turn: () => ({ turn_id: TURN_ID, status: "completed", idempotent: false }),
+  };
+  const unwrapped = fakeAccounting(handlers);
+  const wrapped = fakeAccounting(handlers, { requestCache: true });
+  const stream = {
+    stream: async () => ({
+      fullStream: (async function* () {
+        yield { type: "start" };
+        yield { type: "tool-call", payload: { toolName: "skill", args: { name: RECTIFICATION_SKILL_NAME } } };
+        yield { type: "tool-result", payload: { toolName: "skill" } };
+        yield { type: "tool-call", payload: { toolName: "rectification-read-case", args: { caseId: CASE_ID } } };
+        yield { type: "tool-result", payload: { toolName: "rectification-read-case" } };
+        yield { type: "text-delta", payload: { text: "记下了。" } };
+        yield { type: "finish" };
+      })(),
+      totalUsage: Promise.resolve({ inputTokens: 10, outputTokens: 20 }),
+    }),
+    getSkill: async () => ({ name: RECTIFICATION_SKILL_NAME, instructions: "skill" }),
+  };
+  const base = {
+    userId: USER_ID,
+    caseId: CASE_ID,
+    sessionId: SESSION_ID,
+    requestId: "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee",
+    action: "evidence" as const,
+    message: "2016年9月离开家去北京工作",
+    modelName: "gpt-4o-mini",
+    billing: {
+      reserve: async () => ({ success: true, status: 200 }),
+      complete: async () => true,
+      release: async () => true,
+    },
+    emit: () => {},
+    buildAgent: async () => stream as never,
+  };
+  await loadV9CaseDossier(unwrapped.client, USER_ID, CASE_ID);
+  await runV9AgentTurn({ ...base, accounting: unwrapped.client });
+  await loadV9CaseDossier(wrapped.client, USER_ID, CASE_ID);
+  await runV9AgentTurn({ ...base, accounting: wrapped.client });
+  const before = countCachedProjectionRpcs(unwrapped.calls);
+  const after = countCachedProjectionRpcs(wrapped.calls);
+  assert.ok(after.dossier < before.dossier);
+  assert.ok(
+    after.dossier <= CACHED_AGENT_TURN_DOSSIER_BUDGET,
+    `cached dossier rpc ${after.dossier} exceeded budget ${CACHED_AGENT_TURN_DOSSIER_BUDGET} (uncached ${before.dossier})`,
+  );
+});
@@ -0,0 +1,160 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { createElement, createRef } from "react";
+import { renderToString } from "react-dom/server";
+import test from "node:test";
+
+import type { ChatMessageFeedback } from "../src/components/chat-message-actions.tsx";
+import {
+  RectificationMessageEntry,
+  UnsplitRectificationMessageList,
+  type RectificationMessageActions,
+  type RectificationMessageEntryProps,
+  type RenderMessage,
+} from "../src/components/rectification-message-entry.tsx";
+import {
+  disableHomeStreamingRenderProbe,
+  enableHomeStreamingRenderProbe,
+  homeStreamingRenderProbeSnapshot,
+  resetHomeStreamingRenderProbe,
+} from "../src/lib/home-streaming-render-probe.ts";
+
+const chatSource = readFileSync(
+  new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url),
+  "utf8",
+);
+const entrySource = readFileSync(
+  new URL("../src/components/rectification-message-entry.tsx", import.meta.url),
+  "utf8",
+);
+const rowSource = readFileSync(
+  new URL("../src/components/chat-message-row.tsx", import.meta.url),
+  "utf8",
+);
+
+function settled(role: "user" | "assistant", text: string, key: string): RenderMessage {
+  return {
+    role,
+    text,
+    renderKey: key,
+    state: "settled",
+  };
+}
+
+function liveAssistant(text: string): RenderMessage {
+  return {
+    role: "assistant",
+    text,
+    renderKey: "live-assistant",
+    state: "streaming",
+  };
+}
+
+function emptyActions(): RectificationMessageEntryProps["actionsRef"] {
+  const actionsRef = createRef<RectificationMessageActions>() as RectificationMessageEntryProps["actionsRef"];
+  actionsRef.current = {
+    submitChoice() {},
+    submitStop() {},
+    copyMessage() {},
+    regenerateMessage() {},
+    onFeedback() {},
+  };
+  return actionsRef;
+}
+
+function sharedProps(): Omit<
+  RectificationMessageEntryProps,
+  "message" | "regenerating" | "canRegenerate" | "copied" | "feedback"
+> {
+  return {
+    busy: true,
+    readonly: false,
+    currentQuestionFocusId: null,
+    interactive: false,
+    liveChoiceCard: null,
+    choiceNonce: 0,
+    savedTime: null,
+    actionsRef: emptyActions(),
+  };
+}
+
+function entryProps(
+  message: RenderMessage,
+  extras: Partial<Pick<RectificationMessageEntryProps, "regenerating" | "canRegenerate" | "copied" | "feedback">> = {},
+): RectificationMessageEntryProps {
+  return {
+    ...sharedProps(),
+    message,
+    regenerating: extras.regenerating ?? false,
+    canRegenerate: extras.canRegenerate ?? false,
+    copied: extras.copied ?? false,
+    feedback: extras.feedback,
+  };
+}
+
+test("the chat container no longer derives per-row timeline, varga, or choice cards", () => {
+  assert.doesNotMatch(chatSource, /rectificationTimelineRows\s*\(/);
+  assert.doesNotMatch(chatSource, /vargaSentenceFromMethods\s*\(/);
+  assert.doesNotMatch(chatSource, /choiceCardFromQuestion\s*\(/);
+  assert.match(entrySource, /rectificationTimelineRows\s*\(/);
+  assert.match(entrySource, /vargaSentenceFromMethods\s*\(/);
+  assert.match(entrySource, /choiceCardFromQuestion\s*\(/);
+});
+
+test("the extracted row is memoised and takes no function props except actionsRef", () => {
+  assert.match(entrySource, /export const RectificationMessageEntry = memo\(function RectificationMessageEntry/);
+  const propsBlock = entrySource.slice(
+    entrySource.indexOf("export type RectificationMessageEntryProps"),
+    entrySource.indexOf("export function choiceCardFromQuestion"),
+  );
+  assert.match(propsBlock, /actionsRef: MutableRefObject<RectificationMessageActions>/);
+  assert.doesNotMatch(propsBlock, /=>/);
+  assert.doesNotMatch(propsBlock, /on[A-Z]\w+\?:/);
+  assert.match(rowSource, /export const ChatMessageRow = memo\(function ChatMessageRow/);
+});
+
+test("the split architecture renders settled rectification rows once while streaming tokens", () => {
+  const history: RenderMessage[] = [
+    settled("user", "第一件经历", "u1"),
+    settled("assistant", "记下了第一件。", "a1"),
+    settled("user", "第二件经历", "u2"),
+    settled("assistant", "记下了第二件。", "a2"),
+  ];
+  const tokens = ["甲", "甲乙", "甲乙丙", "甲乙丙丁", "甲乙丙丁戊"];
+  const shared = sharedProps();
+  const feedbackByKey: Readonly<Record<string, ChatMessageFeedback | undefined>> = {};
+
+  resetHomeStreamingRenderProbe();
+  enableHomeStreamingRenderProbe();
+  for (const message of history) {
+    renderToString(createElement(RectificationMessageEntry, entryProps(message)));
+  }
+  for (const streamingText of tokens) {
+    renderToString(createElement(RectificationMessageEntry, entryProps(liveAssistant(streamingText))));
+  }
+  const split = homeStreamingRenderProbeSnapshot();
+  disableHomeStreamingRenderProbe();
+
+  resetHomeStreamingRenderProbe();
+  enableHomeStreamingRenderProbe();
+  for (const streamingText of tokens) {
+    renderToString(createElement(UnsplitRectificationMessageList, {
+      ...shared,
+      messages: [...history, liveAssistant(streamingText)],
+      latestRegeneratableKey: "a2",
+      copiedMessageKey: null,
+      feedbackByKey,
+      regeneratingMessageKey: null,
+    }));
+  }
+  const unsplit = homeStreamingRenderProbeSnapshot();
+  disableHomeStreamingRenderProbe();
+
+  assert.equal(split.settledRowRenders, history.length);
+  assert.ok(split.streamingRowRenders <= tokens.length);
+  assert.ok(split.streamingRowRenders >= 1);
+  assert.equal(unsplit.unsplitListRenders, tokens.length);
+  // Unsplit counts every row on every frame, including the live one.
+  assert.equal(unsplit.settledRowRenders, (history.length + 1) * tokens.length);
+  assert.ok(unsplit.settledRowRenders > split.settledRowRenders);
+});
@@ -126,9 +126,13 @@ test("cases current_question remains the submit contract, not a visual slot", ()
  assert.doesNotMatch(wrap, /rectification-collect-reply/);
  assert.doesNotMatch(wrap, /send\("message", "没有"\)/);
  assert.doesNotMatch(wrap, /rectification-step-state/);
-  const afterAnswer = chat.slice(
-    chat.indexOf("const afterAnswer = question"),
-    chat.indexOf("key={message.renderKey}"),
+  // 原值: 切片容器 map 里的 `const afterAnswer = question`。
+  // 新值: afterAnswer 在行组件内构造。
+  // 原因: BUG-725。
+  const messageEntryForReplies = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  const afterAnswer = messageEntryForReplies.slice(
+    messageEntryForReplies.indexOf("const afterAnswer = question"),
+    messageEntryForReplies.indexOf("return ("),
  );
  assert.doesNotMatch(afterAnswer, /CollectSpokenReplies/);
  assert.doesNotMatch(afterAnswer, /shouldShowCollectSpokenReplies/);
@@ -155,7 +159,11 @@ test("collect_spoken stem lives on turn.question inside the same assistant artic
  assert.match(chat, /const collectSpokenPrompt =/);
  assert.match(chat, /parseTurnQuestion\(turn\.question\)/);
  assert.match(chat, /function markQuestionAnswered/);
-  assert.match(chat, /afterAnswer=\{afterAnswer\}/);
+  // 原值: 容器把 afterAnswer 作为 ChatMessageRow prop。
+  // 新值: 行组件内部构造 afterAnswer 再传给 ChatMessageRow。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /afterAnswer=\{afterAnswer\}/);
  assert.match(chat, /rectification-message-question/);
  assert.match(row, /afterAnswer/);
  assert.doesNotMatch(chat, /composeCollectSpokenAssistantText/);
@@ -212,18 +220,26 @@ test("missing current_question is explicit only for resumable cases", () => {

 test("choice options render inside the same assistant message, not a sibling slot", () => {
  const chat = readFileSync(new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url), "utf8");
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
  const render = chat.slice(
    chat.indexOf("{messages.map((message) => {") ,
    chat.indexOf("{savedTime &&"),
  );
  assert.match(chat, /showLiveChoiceCard/);
+  // 原值: 嵌入卡、afterAnswer、onSelect={submitChoice} 都在容器 map 里。
+  // 新值: 嵌入卡与 afterAnswer 在行组件内，经 actionsRef 提交；容器的 persisted 题卡仍直接绑 submitChoice。
+  // 原因: BUG-725 已结算行记忆化，回调不得当 props。
+  assert.match(messageEntry, /<RectificationChoiceCard/);
+  assert.match(messageEntry, /afterAnswer/);
+  assert.match(messageEntry, /actionsRef\.current\.submitChoice/);
+  assert.match(messageEntry, /actionsRef\.current\.submitStop/);
  assert.match(render, /<RectificationChoiceCard/);
  assert.match(render, /onSelect=\{submitChoice\}/);
  assert.match(render, /onStop=\{submitStop\}/);
-  assert.match(render, /afterAnswer/);
  assert.doesNotMatch(render, /rectification-question-slot/);
  assert.doesNotMatch(render, /liveSpoken/);
  assert.doesNotMatch(render, /showLiveSpokenCollect/);
+  assert.doesNotMatch(messageEntry, /rectification-question-slot/);
 });

 test("openQuestionFromPersistedFocus returns collect_spoken without making collect choice-ready", () => {
@@ -6,6 +6,7 @@ import { homeSurface as page } from "./home-surface.ts";

 const read = (relativePath: string) => readFileSync(new URL(relativePath, import.meta.url), "utf8");
 const chat = read("../src/components/rectification-agentic-chat.tsx");
+const messageEntry = read("../src/components/rectification-message-entry.tsx");
 const hook = read("../src/hooks/use-rectification-surface.ts");
 const sessions = read("../src/hooks/use-session-management.ts");
 const bootstrap = read("../src/lib/home-bootstrap.ts");
@@ -126,7 +127,10 @@ test("stopping keeps what streamed and says so; a 402 explains itself before lea
  // 新值：气泡 stopped + 灰字 RECTIFICATION_STOPPED_NOTICE，error-message 只留给真正失败
  // 原因：停止是用户动作，不能穿报错衣服（BUG-552）
  assert.match(chat, /failed: false,\s*stopped: true/);
-  assert.match(chat, /stoppedNotice=\{message\.stopped \? RECTIFICATION_STOPPED_NOTICE : undefined\}/);
+  // 原值: 停止提示 prop 写在容器 map 的 ChatMessageRow 上。
+  // 新值: 同一表达式在行组件内。
+  // 原因: BUG-725。
+  assert.match(messageEntry, /stoppedNotice=\{message\.stopped \? RECTIFICATION_STOPPED_NOTICE : undefined\}/);
  assert.doesNotMatch(chat, /if \(raw\.trim\(\)\) setError\(RECTIFICATION_STOPPED_NOTICE\)/);
  assert.match(chat, /inputDisabled=\{readonly\}/);
  assert.match(chat, /setError\(RECTIFICATION_INSUFFICIENT_CREDITS_NOTICE\);[\s\S]*onOpenBilling\?\.\(\{ source: "rectification" \}\);/);
@@ -174,5 +174,9 @@ test("a choice question without a GET card is the repair path, not collect waiti
  assert.match(chat, /interviewChoiceCardUnavailable/);
  assert.match(chat, /questionSource === "unavailable" \|\| deadChoice/);
  assert.match(chat, /\/api\/rectification\/cases\/\$\{encodeURIComponent\(caseId\)\}\/repair-exit/);
-  assert.match(chat, /unansweredDeadChoice/);
+  // 原值: 容器 map 内有 `unansweredDeadChoice`。
+  // 新值: 同一判定在行组件内。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /unansweredDeadChoice/);
 });
@@ -17,6 +17,7 @@ import { PUBLIC_RECTIFICATION_METHODS } from "../src/lib/rectification-agentic/v

 const read = (path: string) => readFileSync(new URL(`../${path}`, import.meta.url), "utf8");
 const chatSource = read("src/components/rectification-agentic-chat.tsx");
+const entrySource = read("src/components/rectification-message-entry.tsx");
 const rowSource = read("src/components/chat-message-row.tsx");
 const activitySource = read("src/components/agent-activity-status.tsx");
 const packageJson = read("package.json");
@@ -156,8 +157,12 @@ test("after attempt.reset the timeline is empty, and a settled reply without a r
 });

 test("both chat surfaces render one timeline, one live marker, and no second receipt block", () => {
-  assert.match(chatSource, /rectificationTimelineRows\(\{/);
-  assert.match(chatSource, /timeline: rectificationTimelineRows/);
+  // 原值: 容器源码直接 `timeline: rectificationTimelineRows(...)`。
+  // 新值: 同一调用在行组件内；容器不得再每帧派生。
+  // 原因: BUG-725 已结算行记忆化。
+  assert.match(entrySource, /rectificationTimelineRows\(\{/);
+  assert.match(entrySource, /timeline: rectificationTimelineRows/);
+  assert.doesNotMatch(chatSource, /rectificationTimelineRows\s*\(/);
  assert.doesNotMatch(chatSource, /rectification-activity-failure|<CompletedActivityReceipt/);
  assert.doesNotMatch(chatSource, /label: "正在组织回答…",\s*\}\),\s*\}\s*:\s*message;/);
  assert.match(chatSource, /rememberLiveActivity\(RECTIFICATION_ANALYZING_LIVE_LABEL, null\)/);
@@ -1,4 +1,8 @@
 import type { RectificationRpcClient } from "../src/lib/rectification-agentic/v9/tool-service.ts";
+import { withRectificationRequestCache } from "../src/lib/rectification-agentic/v9/request-cache.ts";
+
+export const CASE_DOSSIER_RPC = "get_agentic_rectification_case_dossier";
+export const CASE_COMPUTE_RPC = "get_agentic_rectification_case_compute";

 export type FakeRpcHandler = (
  fn: string,
@@ -17,13 +21,81 @@ export type FakeAccounting = {
  };
 };

+export type FakeAccountingOptions = {
+  fallback?: FakeRpcHandler;
+  /**
+   * Default off. When true, wrap `client` with the request-scoped projection
+   * cache. Also enabled by RECTIFICATION_REQUEST_CACHE=1 for before/after counts.
+   */
+  requestCache?: boolean;
+  /**
+   * Default off. When true, this instance is included in takeFakeAccountingRpcCounts().
+   * Also enabled by RECTIFICATION_RPC_COUNT=1.
+   */
+  countRpc?: boolean;
+};
+
+export type CachedProjectionRpcCounts = {
+  dossier: number;
+  compute: number;
+};
+
+export type FakeAccountingRpcCountSummary = {
+  scenes: number;
+  dossier: number;
+  compute: number;
+  dossierMean: number;
+  computeMean: number;
+};
+
+const countedAccounting: FakeAccounting[] = [];
+let rpcCountEnabled = process.env.RECTIFICATION_RPC_COUNT === "1";
+
+export function countCachedProjectionRpcs(
+  calls: Array<{ fn: string }>,
+): CachedProjectionRpcCounts {
+  let dossier = 0;
+  let compute = 0;
+  for (const call of calls) {
+    if (call.fn === CASE_DOSSIER_RPC) dossier += 1;
+    else if (call.fn === CASE_COMPUTE_RPC) compute += 1;
+  }
+  return { dossier, compute };
+}
+
+export function enableFakeAccountingRpcCount(enabled = true): void {
+  rpcCountEnabled = enabled;
+  if (!enabled) countedAccounting.length = 0;
+}
+
+export function takeFakeAccountingRpcCounts(): FakeAccountingRpcCountSummary {
+  const scenes = countedAccounting
+    .map((item) => countCachedProjectionRpcs(item.calls))
+    .filter((row) => row.dossier > 0 || row.compute > 0);
+  const dossier = scenes.reduce((sum, row) => sum + row.dossier, 0);
+  const compute = scenes.reduce((sum, row) => sum + row.compute, 0);
+  return {
+    scenes: scenes.length,
+    dossier,
+    compute,
+    dossierMean: scenes.length === 0 ? 0 : dossier / scenes.length,
+    computeMean: scenes.length === 0 ? 0 : compute / scenes.length,
+  };
+}
+
+if (process.env.RECTIFICATION_RPC_COUNT === "1") {
+  process.on("beforeExit", () => {
+    process.stderr.write(`RECTIFICATION_RPC_COUNT ${JSON.stringify(takeFakeAccountingRpcCounts())}\n`);
+  });
+}
+
 export function fakeAccounting(
  handlers: Partial<Record<string, FakeRpcHandler>>,
-  options: { fallback?: FakeRpcHandler } = {},
+  options: FakeAccountingOptions = {},
 ): FakeAccounting {
  const calls: Array<{ fn: string; args: Record<string, unknown> }> = [];
  const profilePatches: Array<Record<string, unknown>> = [];
-  const client: FakeAccounting["client"] = {
+  const rawClient: FakeAccounting["client"] = {
    rpc(fn, args) {
      calls.push({ fn, args });
      const handler = handlers[fn] ?? options.fallback;
@@ -57,7 +129,12 @@ export function fakeAccounting(
      };
    },
  };
-  return { calls, profilePatches, client };
+  const requestCache = options.requestCache === true
+    || process.env.RECTIFICATION_REQUEST_CACHE === "1";
+  const client = requestCache ? withRectificationRequestCache(rawClient) : rawClient;
+  const accounting: FakeAccounting = { calls, profilePatches, client };
+  if (options.countRpc === true || rpcCountEnabled) countedAccounting.push(accounting);
+  return accounting;
 }

 export const CASE_ID = "11111111-1111-4111-8111-111111111111";
@@ -349,6 +349,11 @@ test("embedded choice cards hide the duplicate legend; standalone cards keep the
  assert.match(card, /<legend className="sr-only">\{props\.card\.prompt\}<\/legend>/);
  assert.match(card, /variant === "embedded"/);
  assert.match(chat, /rectification-message-question__prompt/);
+  // 原值: 容器源码含 variant="embedded"（消息内嵌卡）。
+  // 新值: 消息内嵌卡在行组件；容器 persisted 题卡仍是 embedded。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /variant="embedded"/);
  assert.match(chat, /variant="embedded"/);
  // 原值: className="rectification-choice-why"（引擎作题简报）
  // 新值: className="rectification-choice-why-user"（折叠「为什么问这题」）
@@ -423,7 +423,11 @@ test("agent instructions do not assert that the next question is already on scre
  assert.doesNotMatch(agent, /自然过渡到界面上的下一步/);
  assert.match(chat, /await loadCaseSnapshot\(\)/);
  assert.match(chat, /mergeTurnQuestions/);
-  assert.match(chat, /afterAnswer=\{afterAnswer\}/);
+  // 原值: 容器源码含 `afterAnswer={afterAnswer}`。
+  // 新值: 行组件内部构造 afterAnswer。
+  // 原因: BUG-725。
+  const messageEntry = readFileSync(new URL("../src/components/rectification-message-entry.tsx", import.meta.url), "utf8");
+  assert.match(messageEntry, /afterAnswer=\{afterAnswer\}/);
  assert.doesNotMatch(chat, /isLatestMessage/);
 });