test(freeze): 增长冻结改盯耦合，行数降为粗护栏

Home() useState/useRef 与 JyotishAPIHandler 类方法/__new__ 不得增长。行数改为开工实测基线加余量。产品授权删除参数式 hook 零 React hook 规则。
test(rectification): prove memoization in-process; tolerate golden float drift (BUG-733)
2026-09-16 08:02:43 +08:00 · 2026-09-16 07:56:56 +08:00 · 2026-09-16 07:41:41 +08:00 · 2026-09-16 07:41:41 +08:00 · 2026-09-15 23:39:30 +00:00 · 2026-09-16 07:38:36 +08:00
43 changed files with 2936 additions and 132 deletions
@@ -92,8 +92,10 @@

 ## 6. 代码增长冻结

- `scripts/jyotish_api_server.py` must not grow. New endpoints and features go in dedicated modules under `scripts/` and are thinly registered from the main file. Do not add new handler bodies, workflows, or feature branches to this file. The cap is enforced by `tests/test_api_server_growth_contract.py`（冻结时行数 + 300 行 bugfix 余量）。
- `frontend/src/app/page.tsx` 已从 4,766 行拆到 2,000 行以下，**不得再增长**：新逻辑进 `frontend/src/hooks/`、`frontend/src/lib/` 或组件；参数式 hook 内部保持 0 个 React hook 的既定模式。
+行数是耦合的影子：盯行数时，`Home()` 的状态数和 `JyotishAPIHandler` 的类方法数仍在涨。主门换成耦合指标，行数只作粗护栏。
+
+- `scripts/jyotish_api_server.py` must not grow. New endpoints and features go in dedicated modules under `scripts/` and are thinly registered from the main file. Do not add new handler bodies, workflows, or feature branches to this file. The live gate is `tests/test_api_server_growth_contract.py`：**类方法数不得增长、`JyotishAPIHandler.__new__` 伪造点不得增长**；行数是粗护栏（开工实测基线 + 300）。
+- `frontend/src/app/page.tsx`：`Home()` 的 `useState` / `useRef` 数不得增长。新逻辑进 `frontend/src/hooks/`、`frontend/src/lib/` 或组件；抽出去的 hook 与子组件应当持有自己的状态，`page.tsx` 只做装配。行数是粗护栏（开工实测基线 + 150），由 `frontend/tests/home-shell-growth-contract.test.ts` 执行。
 - 不得再手写第二个聊天输入框（一律 `ChatComposer`，自有草稿走 `value`）、第二套滚动跟随（一律 `useConversationScrollAnchor` + `JumpToLatestButton`）、第二套加载动画（揭幕后不得出现 spinner / 骨架 / "正在加载"，流式生成中除外）。

 ## 7. 前端红线
@@ -1,5 +1,10 @@
 # BLOCKED

+## 对话额度拆分（2026-09-16，分支 `codex/consultation-session-capacity-20260915`，BUG-732）
+
+- **无 Docker：** 本机 `docker` 不在 PATH。`npm run test:db` 与 `npm run db:migrate:check`（需要 `SCHEMA_DATABASE_URL` 连 Postgres）未跑。`frontend/tests/database-consultation-session-capacity.test.ts` 在无 Docker 时 skip，**不得写成通过**。替代证据是 SQL 静态合同：额度求和表达式不含 `thinkingText` / `thinkingSections`，物理上限为 `length(elem::text)`，算式写在迁移注释里。
+- **详情接口体积（5.3，已量，不改接口）：** 用三域本命夹具（每轮正文 4,000 汉字 + 思考 4,000 汉字 + 实测 `thinkingSections` + 典型三个 receipt）构造 `GET /api/sessions/[id]` 的 `{ session }` JSON。19 轮 UTF-8 **562,240 B（0.536 MiB）**；50 轮 **1,479,034 B（1.411 MiB）**，约为 2.63 倍。1.4 MiB 在 2 vCPU 上打开长会话会偏沉，分页 / 按需加载历史不在本单（任务书 §9）。PostgreSQL `length()` 按字节计，汉字正文 4,000 字 ≈ 12,000 字节，线上按字节撞 200,000 额度会早于「50 轮汉字」；50 轮数字是任务书字符口径对照。
+
 ## 只读页验收修复：镜像与浏览器（2026-09-16，分支 `codex/readonly-pages-fix-20260916`）

 - **无 Docker：** 无法验证 API 镜像里 `COPY vendor` 与容器内 `node --version`。不得写成通过。
@@ -1,5 +1,17 @@
 # 印度占星 Skill 更新日志

+## 2026-09-16 — 这段对话写满之前，思考过程不再占用额度
+
+普通咨询里，模型内部的思考过程不再算进「这段对话已写满」的额度。额度仍按你看得到的正文计算，能问的轮次大约从十几轮提到约五十轮。写满时还是请开一个新对话，提示不变。Skill 版本不变。
+
+## 2026-09-16 — 对话写满后开新对话会静默带上之前的摘要
+
+普通咨询写满、点「开新对话」之后，服务端会把上一场的会话摘要拷进新对话，界面上看不出差别。进不了窗口的更早几轮，模型会看到省略说明，不再当成没发生过。Skill 版本不变。
+
+## 2026-09-16 — 同一天再问同一张盘，不再重复等外部证据
+
+普通聊天同一张盘、同一天里再问，外部证据直接用已经取到的，不再每轮等外网。隔了一天会先用最多七天内的旧证据马上回答，后台再刷新；「深入看今日」仍然只要当天的。西洋盘整包不再塞进每一轮的回答里，压缩后的西洋层还在。Skill 版本不变。
+
 ## 2026-09-16 — 校正时系统没接上会直说，记下经历后没重算也会说明

 生时校正里，如果这边没判断出你在答哪一问，会请你把刚才那句再发一次，而不是说你没说清。记下经历后如果这次没能重新比较候选，会告诉你经历已经记下、稍后再比，不会假装范围已经在收。Skill 版本不变。
@@ -11285,7 +11285,6 @@
 - 相关记录：BUG-473、BUG-249、BUG-250、BUG-260、BUG-617
 - 复发自：BUG-473（影响面含本文件，但两条防复发只约束正在流的那一行）
 - 修复版本：待发布
-
 ## BUG-726 | 一轮校正把同一份 Case 档案从数据库取多次

 - 状态：resolved
@@ -11301,3 +11300,115 @@
 - 相关记录：BUG-176
 - 复发自：无
 - 修复版本：待发布
+
+## BUG-727 | 普通聊天每轮每域同步等外网，超时不取消导致线程池饱和
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`POST /api/consultation_workflow` 前台路径、`execute_consultation_workflow`、`vedastro_gateway`、前台 VedAstro 线程池
+- 用户现象：普通聊天每发一条、每个问题域都要等外网；本地排盘只占约 3%。超时后技法表 VedAstro 云状态仍是 blocked，之后每一轮继续白等约 1.5 秒。
+- 触发条件：网页咨询 `defer_optional_external_evidence: true`；同一张盘一天内多轮提问；前台线程池默认 2 个 worker。
+- 根因：外网证据本就按「盘 + UTC 日期」组织，却没有按这个键缓存，每轮重新 TLS 握手打 `api.vedastro.org`。`_join_foreground_vedastro` 超时返回 `official_blocked` 但不 `cancel()` 后台任务，任务继续跑满预算；join 1.5 s、budget 8 s、workers 2 三个数不在同一处约束，平均每 4 秒一轮就把池子占死。
+- 修复：新增独立模块 `scripts/vedastro_snapshot_cache.py`（目录与 key 函数都与 `_api_chart_cache` 分开）。同日命中直接用、零等待、不 submit；1–7 天前先用旧的并后台刷新；`entrypoint=daily_starlanguage` 只接受当天。超时必须 `future.cancel()`；join / budget / workers 成组声明，且 `budget ≤ 2 × join`。本单不是推翻 BUG-301：前台仍取官方层，只是用缓存去掉重复等待。
+- 验证：`tests/test_vedastro_snapshot_cache.py`（同日第二次零网关调用、跨日 stale+刷新不等待、daily_starlanguage 不吃昨天、缓存目录≠chart 缓存、N+1 等待不超过 join、三常数同块且 budget 比例、超时取消排队任务）；既有前台赶上/超时降级回归。
+- 防复发：前台外部证据必须有「盘 + 日期」级缓存；任何有界等待都必须同时取消它等待的后台任务。
+- 相关记录：BUG-161、BUG-301、BUG-718
+- 复发自：无（BUG-301 是故意把 VedAstro 放回前台，本单用缓存同时满足 161 与 301）
+- 修复版本：待发布
+
+## BUG-728 | `western_evidence_packet` 无人读却每轮每域传约 122 KB
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`POST /api/consultation_workflow` 响应体、`consumer_context.western_spectrum`
+- 用户现象：一轮咨询响应约 52 万字符，其中西洋证据整包约 122 KB；前端解析后丢掉。三个域就是约 366 KB 无效 JSON。
+- 触发条件：普通聊天每个问题域调用 `/api/consultation_workflow`。
+- 根因：西洋盘计算是 must-use 层，但整包被无条件放进前台响应。`frontend/src` 零读取点；被读的是 `consumer_context.western_spectrum` 压缩投影。
+- 修复：默认不把 `western_evidence_packet` 放进咨询工作流响应，计算与 `western_spectrum` 仍保留。MCP、高严谨、显式 `include_western_evidence_packet` / `western_oracle_payload` 仍返回整包。`consultationWorkflowResponseSchema` 为 `.passthrough()`，去掉该键仍能解析。
+- 验证：`tests/test_vedastro_snapshot_cache.py` 默认省略、显式请求保留、oracle payload 仍返回；`frontend/tests/consultation-workflow-contract.test.ts` 无该键仍 `safeParse` 成功。
+- 防复发：工作流响应新增大字段前必须有读取点；没有读取点的字段不得进入前台响应。
+- 相关记录：BUG-727
+- 复发自：无
+- 修复版本：待发布
+
+## BUG-729 | 咨询历史丢掉整轮时模型看不见任何痕迹
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`consultationHistoryWindow`、`consultationUserTurnContent`、`POST /api/consult`
+- 用户现象：历史超过模型预算后，追问「刚才你说的那个时间」时模型当成从没说过。单条超长会写「省略 N 字」，整轮被丢掉时什么都不留。
+- 触发条件：普通咨询多轮之后，尾巴字符数超过当前模型的历史预算，窗口从最旧整条丢弃。
+- 根因：`droppedCount` 算出来了，`route.ts` 只取 `.tail`。BUG-555 的防复发只写了「不得再按固定 12 条 × 头部截断静默砍结论」，整轮丢弃不在字面里，所以没拦住。
+- 修复：`droppedCount > 0` 时在摘要槽追加与 `omissionMarker` 同风格的说明。有摘要时写「更早的 N 轮问答已并入上面的会话摘要」；没有摘要时诚实写结论尚未并入。`droppedCount === 0` 不加这句话。
+- 验证：超预算历史的模型可见文本含丢弃说明且轮数等于 `droppedCount`；零丢弃不加这句话；源码合同断言 `route.ts` 读取 `historyWindow.droppedCount`。
+- 防复发：咨询历史任何形式的丢弃（截断单条、丢整轮）都必须在模型可见文本里留痕。
+- 相关记录：BUG-555
+- 复发自：BUG-555（防复发只覆盖头部截断）
+- 修复版本：待发布
+
+## BUG-730 | 写摘要的阈值写死 16,000，追不上按窗口算出的历史预算
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`historyBudgetChars`、`consultationHistoryCheckpointChars`、`shouldCheckpoint`、`checkpointSessionContextSummary`
+- 用户现象：后台上架中等上下文窗口的模型后，每轮静默丢掉最老的几轮问答，摘要却还没开始写。
+- 触发条件：模型 `context_window` 低于约 70,667（例如 64k / 32k）。历史预算已经小于写死的 16,000 字阈值。
+- 根因：`shouldCheckpoint` 用常量 16,000，`consultationHistoryWindow` 用 `historyBudgetChars()`。两个数各写各的，没有「阈值必须低于预算」的断言。
+- 修复：阈值改为预算的 0.4（默认 128k 窗口仍是 16,000）。运行时断言阈值 < 预算。检查点把会话模型的 `contextWindow` 传进去。
+- 验证：表驱动覆盖 200k / 128k / 64k / 32k / null，逐条 `checkpoint < budget`；128k 仍为 16,000。
+- 防复发：触发摘要的阈值必须由历史预算派生，并由一条断言钉死「阈值 < 预算」在所有合法上下文窗口下成立。
+- 相关记录：BUG-555
+- 复发自：BUG-555（检查点阈值与窗口预算未绑在一起）
+- 修复版本：待发布
+
+## BUG-731 | 对话写满后开新对话不继承服务端已有的会话摘要
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`chatSessionCreateSchema`、`POST /api/sessions`、`continueInNewChat`、`startNewChat`
+- 用户现象：这段对话已写满、点「开新对话」之后，模型对刚才的结论一无所知，用户被要求从零开始。
+- 触发条件：`append_consultation_question` 返回 `session_full`，客户端走「开新对话」。
+- 根因：新会话是空的。`context_summary` 不在列表 GET 列里，创建合同也不接收它。即便前端想带，也没有合法入口。
+- 修复：创建合同增加可选 `continued_from_session_id`（保持 `.strict()`，不加 `context_summary`）。服务端按当前用户读源会话摘要，读到才写入新行；读不到、不属于该用户、或为空都静默跳过，仍返回 201。写满出口把当前会话 id 带进创建请求。界面不加「接着上次聊」之类提示。
+- 验证：带来源 id 时新行摘要等于源会话；源会话属于别人时新行无摘要且 201；源码合同断言创建 schema 没有 `context_summary` 字段；写满后「开新对话」没有新增提示文案。
+- 防复发：会话满员后的「开新对话」出口必须由服务端继承 `context_summary`；摘要文本任何时候都不得由客户端提供。不得把 `messages` 加回列表 GET。
+- 相关记录：BUG-464、BUG-555
+- 复发自：无
+- 修复版本：待发布
+
+## BUG-732 | 对话额度把思考文本算进去，十几轮就「已写满」
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`append_consultation_question`、`POST /api/consult` 的 `session_full`、咨询会话详情 `GET /api/sessions/[id]`
+- 用户现象：普通咨询问大约十几轮就提示「这段对话已写满，开个新对话继续吧」。200 条消息那档永远碰不到。
+- 触发条件：继续往同一段咨询会话里发问；助手消息带有 `thinkingText` / `thinkingSections`。
+- 根因：BUG-464 立下的 200,000 字符上限身兼二职却两职都没做好。求和把用户读不到的 `thinkingText`、`thinkingSections` 算进去，却不算同样入库的 `techniqueTruth` / `workflowReceipt` / `agentExecutionReceipt`。这不是回归，是那条上限从一开始就混用了「对话有多长」和「这一行有多大」。
+- 修复：新迁移 `CREATE OR REPLACE` 该函数。对话额度仍是 200,000，只累加 `elem->>'text'`。另加物理上限 `sum(length(elem::text))`，算式 50 轮 ×（正文约 4,000 + 思考 4,000 + 分节 3,000 + 三个 receipt 约 3,000）≈ 700,000，取 1,000,000。两档都返回既有 `session_full`。签名、返回列、error_code、advisory lock、`request_id` 幂等、200 条上限、单条 16,000 字校验均未改。
+- 验证：`frontend/tests/consultation-session-capacity.test.ts` 锁定额度求和不含 `thinkingText` / `thinkingSections`、物理上限算式、签名与 `session_full`。`frontend/tests/database-consultation-session-capacity.test.ts` 用真实 Postgres 覆盖思考不占额度、短正文+大 receipt 撞物理上限、额度边界不先撞物理上限；本机无 Docker，该文件 skip，不得写成通过。既有幂等 / 满员用例未改。
+- 防复发：会话上限必须分成两条各司其职的口径：面向用户的对话额度只数用户读得到的正文；面向存储的物理上限必须把整条消息 JSON 算全。新增会存进 `messages` 的字段时，必须明确它进哪一条，不得默认落进对话额度。
+- 相关记录：BUG-464
+- 复发自：无
+- 修复版本：待发布
+
+## BUG-733 | 校正记忆化 golden 对全精度浮点做整体 `==`，跨机门禁靠运气绿
+
+- 状态：resolved
+- 首次发现：2026-09-15
+- 最近更新：2026-09-16
+- 影响面：`tests/test_rectification_engine_memoization.py`、`tests/golden/rectification_engine_memoization_v1.json`（文件未改）
+- 用户现象：用户看不见。门禁 glob `tests/test_rectification_*.py` 在 `CORE_PYTEST_TARGETS` 里，换一台机器或基础镜像会因 `score` / `margin_percent` 尾数差 1.0e-4～1.1e-3 而红，CI 绿只是碰巧和生成 golden 的那台舍入一致。
+- 触发条件：`test_score_candidates_matches_baseline_golden` 把 live payload 与 golden 做整体 `==`。
+- 根因：golden 存了全精度浮点并整体相等。这是 BUG-712 的同一形状。BUG-712 的防复发只落在 `ephemeris_events` 那一处（量化到 6 位再比），没有仓库级守卫，BUG-721 新写的 rectification golden 重蹈覆辙。
+- 修复：只改测试，不动 `scripts/`。主证据改成同进程差分：同一批 static contexts，A 带四层缓存、B 把 `ashtakavarga_result` / `shadbala_result` / `vimshottari_timeline` / `narayana_periods` 置 `None`，`compute_event_candidate_rows` 输出严格相等。golden 改成分档比较：离散字段严格相等；浮点用实测最大漂移 1.1e-3 推出的容差（绝对 2e-3 与相对 5e-4 取更宽者）。禁止调用 `write_golden()` 更新那份 JSON。
+- 验证：同进程 A/B 逐字相等，且 B 的 `calc_shadbala` 次数显著高于 A（本机 6 vs 0）。反向：把某一层缓存换成全零 shadbala 对象后不再相等。golden 分档比较通过；把 golden 浮点改 1e-2 必须红；把离散字段 `time` 改掉必须红。`pytest tests/test_rectification_engine_memoization.py` 与 `pytest tests/test_rectification_*.py` 0 failed。golden JSON `git diff` 无改动。
+- 防复发：任何 golden 比较都不得对浮点做整体 `==`；浮点必须量化或带容差，容差数值要有实测依据并写在注释里；能在同进程内做差分证明的命题，不得用跨机 golden 代替。
+- 相关记录：BUG-712、BUG-721
+- 复发自：BUG-712
+- 修复版本：待发布
@@ -0,0 +1,60 @@
+# PROGRESS · 普通聊天的三条记忆缺口（2026-09-16）
+
+工作树：`.worktrees/consultation-context-memory-20260915`  
+分支：`codex/consultation-context-memory-20260915`  
+任务书基线：`origin/staging` @ `6b3248bf`；开工时本 worktree 在 `11893c7f`（任务书已合入 staging）。  
+本机 Windows。Skill **未 bump**。未改 `frontend/src/app/page.tsx`、数据库、依赖。
+
+开工核对：`docs/BUG_HISTORY.md` 最大号 **BUG-720**。校正四单预占 721–726、external-evidence-cache 预占 727/728，本单使用预占 **BUG-729 / 730 / 731**，无冲突。
+
+## 任务状态
+
+| 任务 | 状态 | BUG |
+| --- | --- | --- |
+| 5.2 写摘要阈值跟着预算走 | 完成 | BUG-730 |
+| 5.1 丢整轮必须留痕 | 完成 | BUG-729 |
+| 5.3 写满时静默继承摘要 | 完成 | BUG-731 |
+| 5.4 Bug 历史 | 完成 | 729/730/731 |
+
+## 实现要点
+
+- **BUG-730**：删除写死的 `CONSULTATION_HISTORY_TAIL_MAX_CHARS = 16_000`。新函数 `consultationHistoryCheckpointChars(window)` = `floor(historyBudgetChars(window) × 0.4)`，并运行时断言阈值 < 预算。128k 仍是 16,000。`shouldCheckpoint` / `checkpointSessionContextSummary` 吃 `contextWindow`；consult 把会话模型窗口传进去。
+- **BUG-729**：`droppedCount > 0` 时在 `consultationUserTurnContent` 的摘要槽追加与 `omissionMarker` 同风格的说明。有摘要：「更早的 N 轮问答已并入上面的会话摘要」；无摘要：「更早的 N 轮问答未能进入本轮上下文，结论尚未并入会话摘要」。`droppedCount === 0` 不加。`route.ts` 四条用户回合都读 `historyWindow.droppedCount`。
+- **BUG-731**：`chatSessionCreateSchema` 增加可选 `continued_from_session_id`（保持 `.strict()`，**不加** `context_summary`）。`POST /api/sessions` 按当前用户读源会话摘要，读到才写入新行；读不到 / 别人的 / 空都静默跳过，仍 201。`continueInNewChat` 把当前会话 id 传给 `startNewChat`。界面无新文案。
+
+未改摘要机制本身（800 汉字、15 秒 ref 计时器、乐观并发、结算后异步）。未用 `AbortSignal.timeout()` 替换摘要超时。未把 `messages` 加回列表 GET。未动数据库。
+
+## 既有断言改动
+
+| 文件 | 原值 | 新值 | 原因 |
+| --- | --- | --- | --- |
+| `session-context-summary.test.ts` | `CONSULTATION_HISTORY_TAIL_MAX_CHARS === 16_000`；`shouldCheckpoint` 只测 15_999 / 16_001 | `consultationHistoryCheckpointChars(128_000) === 16_000`；另测 64k 阈值 2_400 | BUG-730：阈值由预算派生，128k 行为与改前一致 |
+| `chat-session-write.test.ts` 源码合同 | `const { id, updated_at: _ignoredClientClock, ...values } = parsed.data` | 另拆 `continued_from_session_id`，不随 values 插入 | 该字段不是表列 |
+| `chat-session-url.test.ts` / `composer-isolation-contract.test.ts` | 切片起点 `async function startNewChat()` | `async function startNewChat(` | 可带来源会话 id |
+| `consultation-context-cache-contract.test.ts` | 检查点不传窗口 | 传 `sessionContextWindow`；历史文件不得再出现字面量 `16_000` | BUG-730 |
+
+128k 检查点阈值：**原值 16,000 / 新值 16,000 / 原因** 比例 0.4 × 预算 40,000。未弱化其它既有断言。
+
+## 测试
+
+| 命令 | 结果 |
+| --- | --- |
+| `./node_modules/.bin/tsc --noEmit` | **0 错** |
+| `npm run lint` | **0 error**（119 条既有 warning；本单未新增 error） |
+| 本单相关 `npx tsx --test`（history / summary / cache contract / chat-session-write / authority / url / composer-isolation / consultation-context） | **69 pass / 0 fail** |
+| `npx tsx --test tests/consultation*.test.ts tests/chat-session-*.test.ts tests/session-*.test.ts` | 264 项 / 252 pass / **12 fail**：3 个文件级失败 + 9 条 methodology，全是 Windows `SkillPackageRegistryError`（EPERM symlink），与本单文件无关 |
+| `npm test`（`tests/*.test.ts tests/*.test.tsx`） | `# tests 3110 / # pass 3023 / # fail 73 / # skipped 14`。失败清单不含本单文件。对照近期同机 `PROGRESS-chart-page-blocking-open-20260915.md` 的 fail **73**，**零新增失败** |
+| `page.tsx` | 未改 |
+| `npm run build` | compile + TypeScript 过；Collecting page data 死在既有 `SkillPackageRegistryError`（EPERM symlink `/api/daily-starlanguage`），与本单无关。未能从本机构建表确认 `/` 的 `○ Static` 与首屏 gzip。源码：`page.tsx` 无 `force-dynamic`；既有合同「home stays a client-read query on a static route」本单相关套件已绿 |
+
+## 环境缺口
+
+- 本机 Windows 无开发者模式 symlink：`skill-package-registry` 建 live runtime alias 报 EPERM。因此 `next build` 收集页面数据失败；若干 consult/methodology/skill-binding 测试整文件红。Linux CI / staging 不受影响。
+- 无 Docker：`tests/database-*.test.ts` 照常红，与基线同类。
+- 无登录态、无 Chrome：写满后「开新对话」的静默继承未做浏览器走查。界面无新文案，源码合同已锁「开新对话」按钮与禁止「接着上次聊」类句子。
+
+## 收尾限制
+
+- 摘要失败仍只 `console.warn("session context summary failed")`，不打印摘要正文。
+- 侧栏「新建对话」不带 `continued_from_session_id`，只有写满出口的「开新对话」会静默继承。
+- 源会话属于别人或没有摘要时新行 `context_summary` 为空，接口仍 201。
@@ -0,0 +1,93 @@
+# PROGRESS · 普通聊天外网证据缓存（2026-09-15 / 2026-09-16）
+
+工作树：`.worktrees/consultation-external-evidence-cache-20260915`
+分支：`codex/consultation-external-evidence-cache-20260915`
+任务书基线：`origin/staging` @ `6b3248bf`（任务书写）
+开工时远端：`origin/staging` @ `11893c7f973573da78d6dbb48db89cde8b373ecc`
+预占 BUG：**727 / 728**（基线最大号 720；721–726 为同日其它单预占，未冲突）
+交付 commit：`d49bd9cd`
+
+## 串行基线偏离（产品授权）
+
+`TASK-api-server-decomposition-20260916` **未合入** staging。任务书要求以拆分后的 `scripts/jyotish_api_server.py` 为基线；产品负责人要求本单现在就做。因此：
+
+- **没有增长** `scripts/jyotish_api_server.py`。新逻辑在 `scripts/vedastro_snapshot_cache.py`、`scripts/vedastro_foreground.py`；主文件只做薄导入、把 submit/join 换成 `start_foreground_vedastro` / `finish_foreground_vedastro`、按需挂 `western_evidence_packet`。
+- 冻结合同：`wc -l` 口径开工 **11334** 行，交付 **11291** 行（少 43）；上限 11063+300=**11363**。
+
+未改 context-memory 的前端会话文件，未改 session-capacity 的 SQL 迁移。
+
+## 任务对照
+
+| 任务 | 状态 | BUG |
+| --- | --- | --- |
+| 5.1 盘 + UTC 日期缓存 | 完成 | BUG-727 |
+| 5.2 超时 cancel + join/budget/workers 成组，`budget ≤ 2×join` | 完成 | BUG-727 |
+| 5.3 `western_evidence_packet` 按需返回 | 完成 | BUG-728 |
+| 5.4 staging 单域耗时清单 | 完成（环境缺口：无 staging 登录） | — |
+| 5.5 BUG-727 / 728 | 完成 | — |
+
+## 实现要点
+
+- 缓存键：`sha256(年月日时分秒 + lat + lon + tz + ayanamsa + node + UTC reference_date)`，文件名只有哈希。目录 `scratch/local/vedastro_snapshot_cache`，与 `_api_chart_cache` 分开。
+- 同日命中：直接用，不 submit。1–7 天：先用旧的（网关包上标 `snapshot_reference_date`），后台刷新只写缓存。`entrypoint=daily_starlanguage` 只接受当天。未命中才走 1.5 s join。
+- 只缓存 `official_verified` 且带 raw 的包；超时/blocked 不落盘，避免把未交付层标成 executed（BUG-301）。
+- `_join_foreground_vedastro` 超时 `cancel_event.set()` + `future.cancel()`。budget 默认改为 `2×join`（1.5 s → 3 s），不再默认跑满 8 s。
+- 非前台路径（报告/高严谨）仍同步跑网关、不受 join 上限，成功后同样写缓存。
+- 前台响应默认去掉 `western_evidence_packet`，仍算、仍投影 `consumer_context.western_spectrum`。MCP / 高严谨 / `include_western_evidence_packet` / `western_oracle_payload` 仍返回整包。
+- 前端 `runConsultationWorkflow` 把 `entrypoint` 传给 Python，供 daily 入口拒绝隔日缓存。
+
+## `western_evidence_packet` 检索
+
+| 位置 | 处理 |
+| --- | --- |
+| `frontend/src` | **零命中**，按「无人读」从咨询响应去掉 |
+| `scripts/jyotish_api_server.py` | 仍计算；默认不进响应 |
+| `scripts/vedastro_foreground.py` | `should_include_western_evidence_packet` |
+| `scripts/western_evidence_packet.py` / `western_chart_engine.py` / `western_oracle_adapter.py` | 保留计算 |
+| `scripts/unified_consultation_orchestrator.py` | 仍传入做审计日志 |
+| `scripts/cross_system_arbitrator.py` | 保留 |
+| `mcp_server.py` | 保留；`surface=skill_mcp` 仍返回整包 |
+| `tests/` | oracle / MCP / 按需返回的断言保留 |
+
+## 响应体积
+
+| | 字符 |
+| --- | ---: |
+| 任务书基线（career 同参第二轮） | 523 k，其中 `western_evidence_packet` 122 k |
+| 本机改后（stub 工作流，默认响应） | 该键不存在 |
+| 显式 `include_western_evidence_packet` | 键在，体积 ≥ 默认响应 |
+
+未在 staging 重测 523 k 真包（无登录）。按基线，每域少约 122 k 字符。
+
+## 测试
+
+本机无 `G:\Ferti\Jyotisha\.venv`，用 `C:\Users\74082\anaconda3\python.exe`（3.11.7）。任务书写的是 Python 3.13 + swisseph。
+
+| 命令 | 结果 |
+| --- | --- |
+| `pytest tests/test_vedastro_snapshot_cache.py` | **10 passed** |
+| 上项 + 前台赶上/超时/oracle/growth | **18 passed** |
+| `pytest tests/test_consultation_consumer_context.py tests/test_vedastro_runtime_ops.py tests/test_vedastro_snapshot_cache.py tests/test_api_server_growth_contract.py tests/test_consultation_workflow_domains.py` | **pass**（1 skip：本机未装 vedastro pin） |
+| `pytest tests/test_api_server_security.py` + 上列相关 | **169 passed / 6 failed / 1 skipped**。6 条失败在 **HEAD 无本单改动时同样失败**（thematic `relationship_strict_evidence` / `月度主状态`；`shadbala` advanced：`timezone inference dependency unavailable`）。不是本单引入。 |
+| `frontend`：`consultation-workflow-contract` + `consultation-spectrum-parity` | **13 passed / 0 failed** |
+| `scripts/run_quality_gate.py --profile quick` | **compile 通过**（含新模块）。停在 `interpretation_source_inventory_gate.py`：`ModuleNotFoundError: No module named 'mcp'`（Anaconda 无 FastMCP）。未改依赖。 |
+
+## 开工预检
+
+`python scripts/pre_work_check.py --remote-timeout 8 --command-timeout 45`：**fail**。`remote_visibility=verified`，fragment/external engine 扫描通过；`tests/test_preflight_fragment_scan.py` 在本机找不到 `.workbuddy/skills/jyotish-vedic-astrology`（Windows 工作树无该镜像）。属 ERR-007 同类环境，未新开台账。不得把 `.workbuddy` 当运行主仓。
+
+## 5.4 staging 耗时
+
+清单：`docs/testing/consultation-external-evidence-cache-20260915.md`。无 staging 登录，**环境缺口**。改前数字用任务书本机表（career 928/865 ms）。改后 staging 两轮 `consultationToolDurationMs` 待产品回填。本单不改三域上限 3。
+
+## 观察项（本单不修）
+
+`reference_date` 缺省 UTC 当天，与 UTC+8「今天」早上八点前后会错开一天。
+
+## 既有断言改动
+
+| 文件 | 原值 | 新值 | 原因 |
+| --- | --- | --- | --- |
+| 咨询工作流默认响应 | 总有 `western_evidence_packet` | 默认无该键 | BUG-728 无读取点 |
+| `_foreground_vedastro_budget_seconds` 默认 | 8 s（2–12） | `min(env, 2×join)`，join 默认 1.5 → budget 3 | 5.2 让步：预算不超过 join 两倍 |
+| `tests/conftest.py` | 无缓存隔离 | autouse 把 snapshot cache 指到 tmp | 避免测试互相命中磁盘缓存 |
@@ -0,0 +1,63 @@
+# PROGRESS · 对话上限一半被思考文本吃掉（2026-09-15）
+
+工作树：`.worktrees/consultation-session-capacity-20260915`  
+分支：`codex/consultation-session-capacity-20260915`  
+任务书基线：`6b3248bf`；开工时 `origin/staging` = **`11893c7f`**。  
+修复提交：`11829cf7`。  
+本机 Windows。无 Docker。
+
+未改 `frontend/src/app/api/consult/route.ts`、`page.tsx`、Skill。未 bump Skill。BUG 号核对：该 SHA 最大号仍是 **BUG-720**，本单用预占 **BUG-732**，无冲突。
+
+| 任务 | 状态 | 说明 |
+| --- | --- | --- |
+| 5.1 对话额度只数 `text` | 完成（运行时 DB 为环境缺口） | 新迁移 `20260916010000_consultation_session_capacity.sql` `CREATE OR REPLACE`；`v_chars` 只 `sum(length(elem->>'text'))` |
+| 5.2 物理上限 `length(elem::text)` | 完成（同上） | 算式见下；两档都返回 `session_full` |
+| 5.3 详情接口体积 | 完成（夹具量过） | 见下表；1.41 MiB 写入 `BLOCKED.md` 观察，本单不改接口 |
+| 5.4 BUG-732 | 完成 | 关联 BUG-464；不是回归 |
+
+## 实现要点
+
+- 只新增一份迁移。函数签名、返回列、`error_code` 取值、advisory lock、`request_id` 幂等、200 条上限、`char_length(v_text) > 16000` 均未改。
+- 物理上限算术（迁移注释原文）：50 rounds × (~4,000 body + ~4,000 thinkingText + ~3,000 thinkingSections + ~3,000 receipts) ≈ 700,000。Headroom → 1,000,000。
+- 实测 receipt（典型三域本命：12 行技法审计 + workflow + agentExecutionReceipt）JSON **1,738 字符 / 1,950 字节**，小于任务书 3,000，**不调高** 1,000,000。
+- 实测 `thinkingSections` JSON 字符：1 域 1,246、2 域 1,968、3 域 2,702（任务书 1,521 / 2,243 / 2,977，同量级，计划文案有漂移）。
+- 未删、未截断任何已存字段。
+
+## 详情 JSON 体积（5.3）
+
+夹具：每轮用户提问 100 汉字 + 助手正文 4,000 汉字 + 思考 4,000 汉字 + 三域 `natalConsultationThinkingPlan` + 上面那份典型 receipt。`GET /api/sessions/[id]` 的 `{ session }`（`sessionSelect` 含 `messages`）。
+
+| 口径 | 轮次 | UTF-8 字节 | MiB |
+| --- | ---: | ---: | ---: |
+| 改前（旧合并额度大约卡住的地方） | 19 | 562,240 | 0.536 |
+| 改后（任务书字符口径约 50 轮） | 50 | 1,479,034 | 1.411 |
+
+50 / 19 ≈ **2.63**。1.411 MiB 在 2 vCPU 上打开长会话会偏沉，观察项进 `BLOCKED.md`；分页不在本单。
+
+PostgreSQL `length()` 按字节，与 BUG-464 相同。4,000 汉字正文 ≈ 12,000 字节，按字节撞 200,000 会早于「50 轮汉字」。上表 50 轮是任务书字符口径对照，不是汉字会话在线上能存到的轮数。物理上限 1,000,000 字节在这组夹具上仍晚于对话额度触发。
+
+## 既有断言改动
+
+| 文件 | 原值 | 新值 | 原因 |
+| --- | --- | --- | --- |
+| `database-local-business.test.ts` 迁移已应用列表 | 最末 `20260915010000_rectification_touch_chat_session.sql` | 另加 `20260916010000_consultation_session_capacity.sql` 及「不得复制进 db/migrations」 | 新迁移必须被 runner 应用到 |
+
+未改幂等 / advisory lock / `session_missing` / 200 条满员三条既有用例。未改 `chat-session-authority.test.ts`（仍读 20260901010000 原文件，原文件未改）。
+
+## 测试
+
+| 命令 | 结果 |
+| --- | --- |
+| `./node_modules/.bin/tsc --noEmit` | 0 错 |
+| `npx tsx --test tests/consultation-session-capacity.test.ts` | 6 pass / 0 fail |
+| `npx tsx --test tests/consultation-*.test.ts tests/chat-session-*.test.ts` | 220 tests / 208 pass / **12 fail**：全部是 Windows `SKILL.md` symlink `EPERM`（`consultation-agentic-runtime`、`consultation-birth-time-mode`、`consultation-workflow-request` 整文件，以及 methodology 读 live skill 的 9 条）。与本单无关，既有环境缺口。本单 6 条与 `chat-session-*` 全绿 |
+| `npx eslint`（本单三个测试文件 `--max-warnings 0`） | 0 error / 0 warning |
+| `npm run lint` | **0 error** / 119 warning（既有，未动） |
+| `npm run db:migrate:check` | **blocked**：`SCHEMA_DATABASE_URL is required` |
+| `npm run test:db` | **blocked**：39 tests / 7 pass / 27 fail / 5 skip。失败均为 `spawnSync docker ENOENT` 或 Windows symlink EPERM。本单 `database-consultation-session-capacity` **skip**（`docker unavailable on this host`），不得写成通过 |
+| 全量 `npx tsx --test tests/*.test.ts` | 3089 tests / 3001 pass / 73 fail / 15 skip。失败为无 Docker `ENOENT`、Windows `SKILL.md` symlink `EPERM`、以及 `G:\\G:\\` 路径加倍，与既有环境缺口同类。本单 6 条静态合同在该套件里通过；DB 用例 skip |
+
+## 收尾限制
+
+- 运行时 Postgres 合同本机未跑。有 Docker 的验收机必须跑 `npm run test:db`。
+- 详情接口未分页。50 轮夹具 1.41 MiB，见 `BLOCKED.md`。
@@ -0,0 +1,94 @@
+# PROGRESS · 增长冻结改盯耦合（2026-09-16）
+
+工作树：`.worktrees/freeze-metric-change-20260915`  
+分支：`codex/freeze-metric-change-20260915`  
+任务书基线写 `6b3248bf`；开工时 `origin/staging` = **`51a65d92`**（含 BUG-732）。  
+本机 Windows。无 Docker。本单不占 BUG 号，不改 `CHANGELOG.md` / `BUG_HISTORY.md` / `docs/tasks/README.md`。  
+`page.tsx` 与 `scripts/jyotish_api_server.py` **一行未动**（反向验证后已 `git checkout` 还原）。
+
+## 开工实测基线（2026-09-16，`51a65d92`）
+
+禁止抄任务书 1951 / 66 / 41 / 11334 / 225。下列数字全部本机现测。
+
+| 组 | 指标 | 数法 | 实测 | 新门 |
+| --- | --- | --- | ---: | --- |
+| 1 | `frontend/src/app/page.tsx` 行数 | `Path.read_bytes().count(b"\n")`，与 `(source.match(/\n/g) ?? []).length` 相同 | **1951** | 粗护栏 ≤ 1951 + 150 = 2101 |
+| 2a | `Home()` `useState` | `\buseState[<(]`（含 `useState<Type>(`） | **66** | 主门，不得增长 |
+| 2b | `Home()` `useRef` | `\buseRef[<(]` | **41** | 主门，不得增长 |
+| 3 | `scripts/jyotish_api_server.py` 行数 | `Path.read_bytes().count(b"\n")` | **11291** | 粗护栏 ≤ 11291 + 300 = 11591 |
+| 4a | 四空格 `def`（任务书同一种数法） | `^    (?:async )?def \w+` 扫全文件 | **225** | 主门，不得增长 |
+| 4b | `JyotishAPIHandler.__new__` | `scripts/` + `tests/` 的 `*.py`，排除合同测试自身 | **33** | 主门，不得增长 |
+
+说明：
+
+- 任务书表格写 api 行数 11,334；本机 `51a65d92` 实测 **11291**（未抄）。
+- 任务书表格写 `__new__` = 4：那是 **scripts/ 生产伪造点**（`consultation_workflow_service.py` ×2、`capture_report_blocked_repairs_golden.py` ×1、`local_accuracy_report.py` ×1）。任务书要求扫 `scripts/` 与 `tests/`，实测合计 **33**（scripts 4 + tests 29）。主门按扫描范围合计冻结，只许降不许升。失败信息会列出命中文件。
+- 全文件四空格 `def` = 225，其中 `JyotishAPIHandler` 类体 222、类前嵌套 3。冻结用任务书指定的全文件数法。
+- 只按 `useState(` 会计到 26，漏掉泛型调用；合同用 `\buseState[<(]`。
+
+`frontend/AGENTS.md` 只有 Next.js 版本提示，没有 §6 重复表述，本单未改。
+
+## 做了什么
+
+1. `tests/test_api_server_growth_contract.py`：主门改成类方法数 + `__new__` 计数；行数 rebaseline 为 11291 + 300。`must not grow` / `thinly registered` / `CORE_PYTEST_TARGETS` 三条原样仍绿。
+2. 新建 `frontend/tests/home-shell-growth-contract.test.ts`：`Home()` `useState` / `useRef` 不得增长，行数粗护栏 1951 + 150。
+3. `frontend/tests/chart-view-route.test.ts`：删除行数断言，保留 `doesNotMatch(pageSource, /chart-page|ChartPageView|\/api\/chart-view/)`，注明搬到 home-shell 合同。
+4. `AGENTS.md` §6：主门改耦合指标；删掉「参数式 hook 内部保持 0 个 React hook」；第三条三个「不得再手写第二套」原样保留；仍含 `must not grow` 与 `thinly registered`。
+
+## 既有断言改动
+
+| 文件 | 原值 | 新值 | 原因 |
+| --- | --- | --- | --- |
+| `chart-view-route.test.ts` `page.tsx does not grow to host the chart page` | `(pageSource.match(/\n/g) ?? []).length <= 1951` 且 `doesNotMatch(...)` | 测试改名为 `page.tsx does not host the chart page`，只留 `doesNotMatch` | 行数冻结与星盘页无关，搬到专用合同 |
+| `test_api_server_growth_contract.py` 行数 baseline | 11063（2026-09-02）+ 300 | **11291**（2026-09-16 实测）+ 300 | 任务书要求开工实测 rebaseline，不得抄旧数 |
+
+## 反向验证
+
+### 1. `page.tsx` 人为加一个 `useState`
+
+在 `Home()` 里插入 `const [_growthContractProbe, _setGrowthContractProbe] = useState(false);`，然后：
+
+```
+npx tsx --test tests/home-shell-growth-contract.test.ts
+not ok 1 - Home() useState count must not grow
+error: 'Home() has 67 useState calls; cap is 66. ...'
+# tests 3 / pass 2 / fail 1
+```
+
+`useRef` 与行数粗护栏仍绿。随后 `git checkout -- frontend/src/app/page.tsx`，文件回到 `51a65d92`。
+
+### 2. `jyotish_api_server.py` 人为加一个类方法
+
+在 `JyotishAPIHandler` 里插入 `def _growth_contract_probe(self): return None`，然后：
+
+```
+pytest tests/test_api_server_growth_contract.py
+FAILED test_jyotish_api_handler_method_count_must_not_grow
+AssertionError: ... has 226 four-space def methods; cap is 225.
+1 failed, 4 passed
+```
+
+行数粗护栏、`__new__`、AGENTS 措辞、`CORE_PYTEST_TARGETS` 仍绿——尺子动的是耦合门。随后 `git checkout -- scripts/jyotish_api_server.py`。
+
+## 测试
+
+本 worktree 的 `.venv` 是已跟踪的指针文件（内容 `/workspace/Jyotisha/.venv`），Windows 上不能当目录用，未覆盖。合同测试用本机 `C:\Users\74082\anaconda3\python.exe`（pytest 9.1.1）。
+
+| 命令 | 结果 |
+| --- | --- |
+| `python -m pytest tests/test_api_server_growth_contract.py -v` | **5 passed**（含原 `must not grow` / `thinly registered` / `CORE_PYTEST_TARGETS` 三条） |
+| `npx tsx --test tests/home-shell-growth-contract.test.ts tests/chart-view-route.test.ts` | **16 pass / 0 fail**（home-shell 3 + chart-view 13；chart-view 无行数断言） |
+| `./node_modules/.bin/tsc --noEmit` | 0 错 |
+| `npm run lint` | **0 error** / 119 warning（既有，未动） |
+| `npx tsx --test tests/*.test.ts` | 3196 tests / 3112 pass / **69 fail** / 15 skip。本单 3 条 + `page.tsx does not host the chart page` 均 `ok`。失败为无 Docker、Windows `SKILL.md` symlink `EPERM`、bash 部署脚本，与近期同机清单同类 |
+| `run_quality_gate.py --profile quick --skip-frontend-runtime` | **blocked**：`interpretation_source_inventory_gate.py` → `ModuleNotFoundError: No module named 'mcp'`。停在 pytest 之前，不是本单合同红。未写成通过 |
+
+同 SHA 近期进度 `PROGRESS-consultation-session-capacity-20260915.md` 记 `tests/*.test.ts` 为 3089 / 3001 / **73** fail。本机这次 3196 / 3112 / **69** fail（PowerShell glob 与计数差一截，fail 未增加）。本单新增 3 条全绿，不把 69 写成通过。
+
+未跑 `next build`：无 UI 改动；质量门在 Python 预检就停了。
+
+## 未做（属范围外）
+
+- 真的搬 `Home()` 状态或拆 `JyotishAPIHandler`（后续两单）
+- `__new__` 收到 0
+- 推 `origin HEAD:staging`
@@ -0,0 +1,64 @@
+# PROGRESS · 等价 golden 跨机不稳（2026-09-15 / 执行 2026-09-16）
+
+- 执行分支：`codex/rectification-engine-memoization-fix-20260915`
+- 工作树：`.worktrees/rectification-engine-memoization-fix-20260915`
+- 任务书：`docs/tasks/TASK-rectification-engine-memoization-fix-20260915.md`
+- 开工 `HEAD` = `origin/staging` = `51a65d92`（用户核对时是 `7227b1ed`，其后合入了 BUG-732）
+- BUG：`BUG-733`（复发自 BUG-712；落库时最大号 732）
+
+## 开工前置
+
+| 项 | 结果 |
+| --- | --- |
+| `git status -sb` 第一行 | `## codex/rectification-engine-memoization-fix-20260915...origin/staging` |
+| `HEAD` | `51a65d92` |
+| BUG_HISTORY | 最大号 **BUG-732**。本单预占 **BUG-733**。读完 BUG-712 / BUG-721 |
+| 本机 Python | 主仓 `.venv` 是 25 字节指针文件。本 worktree 用 Anaconda 3.11.7 `--system-site-packages` 建真实 venv，复用 `swisseph 20230604`，未升级依赖 |
+| 先复现 golden | `test_score_candidates_matches_baseline_golden` **本机绿**。live 与 golden 逐字相同：`score` 8.6274 / 8.6227 / 8.1701，`margin_percent` 5.3006。验收机上的 1.1e-3 漂移在这台 Windows / Anaconda 3.11.7 上复现不出来——golden 就是同类机器生成的。仍按任务书改比较方式，不调用 `write_golden()` |
+
+未改 `docs/tasks/README.md` 状态列。未推 staging。未改任何 `scripts/` 实现。未改 `tests/golden/rectification_engine_memoization_v1.json`。
+
+## 做了什么
+
+| 条 | 做法 |
+| --- | --- |
+| 5.1 | 新增 `test_cached_static_context_matches_uncached_fallback`：同一请求、同一进程，A=带四层缓存的 static contexts，B=四键置 `None`。`compute_event_candidate_rows` 输出 `==`。调用计数：A 的 `calc_shadbala` = 0，B = 6（3 候选 × 2 事件）。反向：`test_poisoned_static_cache_diverges_from_live_rows` 把第一候选的 `shadbala_result` 换成全零对象，分数从 12.5125 变成 12.6125，断言不再相等 |
+| 5.2 | `test_score_candidates_matches_baseline_golden` 改成分档比较。整数 / 布尔 / 字符串 / 列表身份严格相等；浮点容差 `max(2e-3, 5e-4 * \|expected\|)`，注释写明来自实测最大漂移 1.1e-3。反向：`score += 1e-2` 红；`time = "99:99"` 红 |
+| 5.3 | 未调用 `write_golden()`。`git diff` 里该 JSON 无改动 |
+| 5.4 | 六份检查结论见下表。同类问题只记录不修 |
+| 5.5 | `docs/BUG_HISTORY.md` 新增 BUG-733，复发自 BUG-712。证据是 5.1 同进程差分 + 两次反向验证，不是「现在绿了」 |
+
+## 5.4 `tests/golden/` 检查
+
+| 文件 | 全精度浮点整体 `==` | 在哪个测试里比 | 怎么比 |
+| --- | --- | --- | --- |
+| `consultation_contract_keypaths_v1.json` | 无 | `tests/test_consultation_contract_golden.py` | 只存 keypath 与 JSON 类型（`kind=keypath_types_only`）。值不入库。live 是 keypath 超集 + 类型相同 |
+| `ephemeris_events_raman_20260915_90d.json` | 无（BUG-712 已改） | `tests/test_ephemeris_events.py` | `longitude` / `speed_longitude` 量化到 6 位再 `==`；`kind` / `date` / `body` / 星座字段严格相等。文件里仍存全精度，但测试不再整体 `==` |
+| `golden_cases.json` | 无 | `tests/test_cli_smoke.py::test_full_reading_golden_cases_cover_user_ready_output` → `tests/run_golden_cases.py` | 路径非空、模块计数、整数不变量 `ashtakavarga_sav_total == 337`、日期覆盖。不是把整份引擎浮点输出整体 `==` |
+| `qizheng_stem_branch_19900409.json` | 无（比较已量化） | `tests/test_qizheng_chart_engine.py` | 离散字段（宫、宿、ketuMode）严格相等；`siderealLon` / `mansionDegree` 用 `round(..., 2)`。**文件本身仍存全精度浮点**（如 `177.94225865978694`）。若有人新写 `assert result == golden` 会变成 BUG-712 同类。本单只记录不修 |
+| `rectification_engine_memoization_v1.json` | **本单之前有** | `tests/test_rectification_engine_memoization.py::test_score_candidates_matches_baseline_golden` | 改前：`candidate_scores` 与 `decision_receipt` 整体 `==`。改后：离散严格、浮点容差。文件未重建 |
+| `upstream_sync2/` | 无整体浮点 `==` | 见分项 | `relationship_einstein.json`：`test_upstream_sync2_goldens.py` 只比键与类型。`consultation_marriage_evidence_snapshot.json`：shape。`consultation_marriage_1990_fictional.json`：`test_relationship_event_class_evidence.py` 比离散 Dasha 字符串。`pl9_time_system_table.baseline.md`：`test_full_reading_conditional_dashas.py` 比对 markdown 表行文本（前 5 行 `==`），不是 JSON 浮点。`pl9_time_system_table.md` 与 `pl9_export_timing.json`（含 `seconds: 8.647`）**没有任何测试读取** |
+
+同类观察（不修）：qizheng golden 文件仍存全精度；ephemeris golden 文件仍存全精度（测试已量化）；`upstream_sync2/pl9_export_timing.json` 是无引用的浮点秒数。
+
+## 测试
+
+| 套件 | 结果 |
+| --- | --- |
+| `tests/test_rectification_engine_memoization.py` | **14 passed**（原 10 + 新增 4） |
+| `tests/test_rectification_*.py` | **186 passed, 0 failed**（14.42s） |
+
+命令使用 `.\.venv\Scripts\python.exe`（任务书写的 `.venv/bin/python` 在 Windows 不存在）。
+
+未改任何既有断言的期望值。新增 4 条：同进程差分、缓存毒化反向、浮点 1e-2 反向、离散字段反向。原 golden 断言从整体 `==` 改成分档，不是放宽离散字段。未跑 `run_quality_gate.py --profile quick`：该 profile 在 pytest 之后会跑 `npm test`，本机 Windows 缺 `tsx` PATH（与 BUG-721 进度记录同一缺口），本单未改前端。
+
+## CHANGELOG
+
+未改。纯测试比较方式，用户可见打分不变。
+
+## 偏离
+
+- 任务书写 `.venv/bin/python`，本机换成 `.\.venv\Scripts\python.exe`。
+- 本机未能复现验收机上的 golden 红灯（舍入与生成机一致）。仍改比较方式，并保留验收机测到的 1.1e-3 作为容差依据。
+- 未 `git push origin HEAD:staging`。
+- 5.4 按让步只检查并记录，未加仓库级自动扫描守卫。
@@ -238,11 +238,12 @@
 | `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；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-consultation-external-evidence-cache-20260915.md` | `PROGRESS-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 | 待验收 | `codex/consultation-external-evidence-cache-20260915` |
+| `TASK-consultation-context-memory-20260915.md` | `PROGRESS-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 | 待验收 | `codex/consultation-context-memory-20260915` |
+| `TASK-consultation-session-capacity-20260915.md` | `PROGRESS-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 | 待验收 | `codex/consultation-session-capacity-20260915`（BUG-732）；`test:db` 环境缺口 |
 | `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 号 | 待领取 | — |
+| `TASK-rectification-engine-memoization-fix-20260915.md` | — | **验收修复单（只改测试，一行实现不许动）**：BUG-721 的实现**等价性成立**（我在改前 `6b3248bf` / 改后 `e4788dfc` 同机跑同一 payload，`candidate_scores` 逐字相同），9 条计数断言全过；但等价 golden 在本机复现不出来——4 处浮点尾数差（score 1.0e-4 ×2、`margin_percent` 1.1e-3 ×2）。**复发自 BUG-712**（「不得对全精度浮点做整体 `==`」，那一单只落在 ephemeris 一处）。而 `tests/test_rectification_*.py` 在 `CORE_PYTEST_TARGETS` 里，**staging 门禁靠机器舍入碰巧一致才是绿的**。修法：主证据换成**同进程差分**（把 static context 的四个缓存键置 `None` 即可回退旧路径，A/B 严格相等），golden 降为离散字段严格相等 + 浮点带容差（容差按实测 1.1e-3 推）；**禁止重建 golden 来「修」**。另含六份 golden 的仓库级排查。BUG-733 | 待领取 | — |

 ## 命名与归档

@@ -0,0 +1,162 @@
+# TASK · 验收修复单：等价 golden 跨机不稳，门禁靠运气绿
+
+- 日期：2026-09-15
+- 基线 commit：`origin/staging` @ `e4788dfc`（实现落在 `53a37ce9`）
+- 执行分支：`codex/rectification-engine-memoization-fix-20260915`
+- 来源：Claude 对 `TASK-rectification-engine-memoization-20260915`（BUG-721）的验收
+- 落点：`tests/test_rectification_engine_memoization.py`、必要时 `tests/golden/`、`docs/BUG_HISTORY.md`
+- 规模：只改测试。**一行实现代码都不许动。**
+
+---
+
+## 1. 验收结论摘要
+
+BUG-721 的**实现是对的，等价性成立**，我独立复核过。门禁实测（基线 `11893c7f` → 头 `e4788dfc`，含 R1/R2/R3 三个提交）：
+
+| 项 | 结果 |
+| --- | --- |
+| `tsc --noEmit` | 0 错 |
+| `npm run lint` | **0 error** / 119 warning（全部既有） |
+| 全量前端套件 | 基线 3291（fail 31）→ 头 3304（fail 31），**失败清单逐条一致** |
+| `next build` | exit 0；`/` 仍 `○ Static` |
+| 首屏 JS gzip-9 | 基线 130,872 B → 头 130,872 B，**0.00%**（两侧同一种量法） |
+| `tests/test_rectification_*.py` | **1 failed, 181 passed** |
+
+唯一那条失败就是本单要修的：`test_score_candidates_matches_baseline_golden`。
+
+**它不是实现改坏了。** 我在改前（`6b3248bf`，与 golden 自称的 `a8d29d1b` 代码相同）和改后（`e4788dfc`）两个工作树上跑同一份 payload：
+
+| | 12:00 | 12:01 | 12:02 |
+| --- | ---: | ---: | ---: |
+| 本机 **改前** | 8.6273 | 8.6226 | 8.1701 |
+| 本机 **改后** | 8.6273 | 8.6226 | 8.1701 |
+
+**改前改后逐字相同。** 本单的其余 9 条断言（shadbala / ashtakavarga / vimshottari / narayana 各等于候选分钟数；过境盘等于去重后事件日期数；探针默认 1 次、refresh 时 2 次）全部通过。
+
+## 2. 事故实证
+
+失败来自 golden 文件与**任何一台机器**的实际输出对不上：
+
+| 字段 | 本机（改前＝改后） | `tests/golden/rectification_engine_memoization_v1.json` | 差 |
+| --- | ---: | ---: | ---: |
+| `candidate_scores[0].score` | 8.6273 | 8.6274 | 1.0e-4 |
+| `candidate_scores[1].score` | 8.6226 | 8.6227 | 1.0e-4 |
+| `decision_receipt.margin_percent` | 5.2995 | 5.3006 | 1.1e-3 |
+| `decision_receipt.gates.diagnostic_quality.margin_percent` | 5.2995 | 5.3006 | 1.1e-3 |
+
+一共 4 处，全是浮点尾数。`candidate_scores[*].score` 本身已经被引擎 `round(..., 4)` 过，差值正好是那一位的 1 ulp——也就是求和顺序/libm 舍入的跨机差异，不是算法差异。
+
+**后果是实打实的**：`tests/test_rectification_*.py` 这个 glob 在 `scripts/run_quality_gate.py` 的 `CORE_PYTEST_TARGETS` 里（注释原文：「Auto staging gate is `--profile quick`…so a stale window_scan assertion in this glob stayed red on origin/staging until listed here」）。也就是说 **staging 自动门禁会跑这条断言**。今天它在 CI 上绿，只是因为那台机器的舍入和执行方的机器一致；换一台机器、换一个基础镜像、换一次 libm 版本就会红。**这条门禁现在是靠运气绿的。**
+
+## 3. 根因
+
+golden 存了全精度浮点并做整体 `==`。这正是 **BUG-712** 的形状，那条记录的防复发一字不差地写着：
+
+> 不得对全精度浮点做整体 `==`。测试不得写 golden。
+
+BUG-712 修的是 `ephemeris_events` 的 golden（`longitude` / `speed_longitude` 量化到 6 位再比，非浮点字段保持严格相等）。那一单的范围写死在星历端点上，新写的这份 rectification golden 是同样的写法，没被扫到。
+
+更深一层：**golden 本来就不是证明「记忆化没改结果」的合适工具。** golden 证明的是「今天的输出等于某台机器某一天的输出」，中间夹了一个与被测命题无关的变量（机器）。被测命题其实可以在**同一个进程里**证明——见 §5.1。
+
+## 4. 决策记录
+
+产品 2026-09-15 授权本单：
+
+1. **不回滚 BUG-721 的实现。** 等价性已由改前/改后同机对比独立证实，实现留在 staging 上。
+2. **本单只改测试。** 一行 `scripts/` 下的实现代码都不许动——不得为了让断言通过去改业务代码（这是产品的既定偏好）。
+3. **不得用「重新生成 golden」来修。** 在本机重跑一次 `write_golden()` 能让测试变绿，但那只是把不稳定性换个方向藏起来，下一台机器照样红。**这条是硬红线，见 §5.3。**
+4. **防复发升级为仓库级。** BUG-712 的那句话从单点措施提升成对所有 golden 生效的规则，并配一条能自动发现违例的守卫。
+
+## 5. 任务分解
+
+### 5.1 把主证据换成同进程差分（首要，也是本单真正的价值）
+
+实现已经把四层不变量放进 static context 的具名键（`ashtakavarga_result` / `shadbala_result` / `vimshottari_timeline` / `narayana_periods`），而每个消费点都有 `if result is None:` 的回退分支。**这意味着记忆化可以在同一个进程里关掉**：把 context 里那四个键置 `None`，消费点就会退回逐次计算的老路径。
+
+新增一条断言：同一份请求、同一个进程，
+- A：正常的 static contexts（带四层缓存）
+- B：把那四个键全部置 `None` 的同一批 contexts（回退到逐次计算）
+
+断言 `compute_event_candidate_rows` 在 A / B 下的输出**严格逐字相等**。
+
+这条证明不经过任何跨机变量，是比 golden 强得多的等价证据。
+
+- 验收：新断言通过；人为把某一层的缓存值替换成错误对象后必须红（贴反向验证，证明这条断言不是恒为真）。
+- 验收：A / B 两条路径确实走了不同分支（用调用计数确认 B 的 `calc_shadbala` 次数显著高于 A），否则等于什么都没测。
+
+### 5.2 golden 断言改成分档比较
+
+保留 golden（它仍有价值：能发现跨版本的大幅漂移），但改比较方式：
+
+| 字段类别 | 比较方式 |
+| --- | --- |
+| 离散字段（`time`、`supporting_event_ids`、`conflicting_event_ids`、各 gate 布尔、`overall_confidence`、`representative_time`、排序） | **严格相等** |
+| 浮点字段 | 容差比较 |
+
+容差必须由实测漂移推出来，不得拍脑袋：本次实测最大漂移 **1.1e-3**（`margin_percent`）。取一个有余量但仍能发现真回归的值（建议绝对 2e-3 与相对 5e-4 取更宽者），并把「这个数怎么来的」写进测试注释。
+
+- 验收：把 golden 里任意一个浮点改动 1e-2，断言必须红（贴反向验证）。
+- 验收：把 golden 里任意一个离散字段改掉，断言必须红。
+- 验收：`.venv/bin/python -m pytest tests/test_rectification_*.py` 在本机 **0 failed**。
+
+### 5.3 不得重建 golden
+
+`write_golden()` 这个辅助函数留着没问题，但**本单不得调用它更新那份 golden 文件**。若执行方认为必须重建，要在进度记录里写明理由并说明为什么不是在掩盖跨机不稳——默认答案是「不重建」。
+
+- 验收：`git diff` 里 `tests/golden/rectification_engine_memoization_v1.json` **无改动**（若有改动，按上一条给出理由）。
+
+### 5.4 仓库级防复发守卫
+
+`tests/golden/` 下现在共 6 份：`consultation_contract_keypaths_v1.json`、`ephemeris_events_raman_20260915_90d.json`、`golden_cases.json`、`qizheng_stem_branch_19900409.json`、`rectification_engine_memoization_v1.json`、`upstream_sync2/`。
+
+- 逐份检查有没有「全精度浮点 + 整体 `==`」的比较方式，结果列进进度记录（每份写明：有/无、在哪个测试里比的、怎么比的）。
+- 发现同类问题的，本单**只记录不修**（各自另开单），除非改动小到一眼可见。
+
+- 验收：六份的检查结论在进度记录里，一份不漏。
+
+### 5.5 Bug 历史
+
+同一变更内写进 `docs/BUG_HISTORY.md`，预占 **BUG-733**（721–732 已被两轮审计的七单占用，避让）。必须写明：
+
+- **复发自 BUG-712**，并说明为什么没拦住：BUG-712 的防复发只落在 `ephemeris_events` 那一处，没有仓库级守卫，新写的 golden 重蹈覆辙。
+- 状态可写 `resolved`，但**证据必须是 §5.1 的同进程差分 + §5.2 的两次反向验证**，不能只写「现在绿了」。
+- 防复发升级为：**任何 golden 比较都不得对浮点做整体 `==`；浮点必须量化或带容差，容差数值要有实测依据并写在注释里；能在同进程内做差分证明的命题，不得用跨机 golden 代替。**
+
+## 6. 让步顺序
+
+1. 5.1 **不得砍**——它才是这一单的意义；没有它，5.2 只是把红灯调成绿灯。
+2. 5.2 必须做。
+3. 5.4 可以只做「检查并记录」，修留到后续单。
+4. 5.3、5.5 不得砍。
+
+## 7. 开工前置命令
+
+```bash
+git fetch origin --prune
+git worktree add -b codex/rectification-engine-memoization-fix-20260915 \
+  .worktrees/rectification-engine-memoization-fix-20260915 origin/staging
+cd .worktrees/rectification-engine-memoization-fix-20260915
+git status -sb | head -1
+# 先复现：这一条应当是红的
+.venv/bin/python -m pytest tests/test_rectification_engine_memoization.py -q
+```
+
+开工前必读：`docs/BUG_HISTORY.md` 的 **BUG-712**（同形态前例与它的修法）与 **BUG-721**（本单要保护的那次改动）。
+
+验收命令：
+
+```bash
+.venv/bin/python -m pytest tests/test_rectification_engine_memoization.py
+.venv/bin/python -m pytest tests/test_rectification_*.py          # 门禁 glob，须 0 failed
+.venv/bin/python scripts/run_quality_gate.py --profile quick
+```
+
+## 8. BUG 编号起点
+
+基线 `e4788dfc` 上 `docs/BUG_HISTORY.md` 最大号为 **BUG-725**。721–732 已被两轮审计七单预占（726–732 尚未落库），本单避让，预占 **BUG-733**。开工时核对实际最大号。
+
+## 9. 不在本单范围
+
+- BUG-721 的实现（已验收等价，不动）
+- 其余五份 golden 的修复（5.4 只检查并记录）
+- `CORE_PYTEST_TARGETS` 的构成（`tests/test_rectification_*.py` 这条 glob 保留，本单是让它变得可靠，不是把它摘掉）
@@ -0,0 +1,41 @@
+# 真人核对 · staging 单域咨询耗时（外网证据缓存，2026-09-15）
+
+执行环境无 staging 登录态。下列条目留给有真实账号的人在 staging 走查。本单自动化不替代这些。
+
+目的：同一张盘、同一个问题域连发两轮，记录 `consultationToolDurationMs`。第一轮冷（可能等外网），第二轮应命中「盘 + UTC 日期」缓存，接近本地计算。
+
+代码注释里的域上限 3 是按「staging 实测三域共 62.9 秒」反推的，即一域约 21 秒。本机同样调用只要约 0.5 秒。**本单不改三域上限**；若单域已显著低于 21 秒，把数字写进进度记录，放宽另开单。
+
+## 准备
+
+1. 打开 `https://staging.jyotisha.chat/login` 并登录（用自己的受控账号）。
+2. 确认 `https://staging.jyotisha.chat/api/health` 的 `deployment.gitCommit` 等于含本单代码的那次 staging 提交。
+3. 选一张**当天还没问过**的盘（或等 UTC 零点后再测），避免误用旧缓存。不要把出生资料贴回对话。
+
+## 冷启动（第一轮）
+
+4. 新建对话，只问一个域（例如事业）。不要点「深入看今日」。
+5. 等回答出来。记下：
+   - 主观等待 `____` 秒
+   - 若浏览器/服务端日志能看到 `consultationToolDurationMs`：`____` ms
+   - 技法表「VedAstro 云状态」是 executed 还是 blocked：`____`
+
+## 同日第二轮（应 0 等待）
+
+6. 同一条对话里，用同一张盘再问同一域（换一句问法即可）。
+7. 记下：
+   - 主观等待 `____` 秒
+   - `consultationToolDurationMs`：`____` ms
+   - VedAstro 云状态：`____`
+8. 第二轮应明显短于第一轮，且不应再出现「空等约 1.5 秒再 blocked」。
+
+## 跨日（可选，UTC 过零点后）
+
+9. 第二天用同一张盘再问同一域。第一句应马上有回答（用昨天的证据），证据里能看出是哪一天的快照；下一轮才换成当天。
+10. 点「深入看今日」时，不得沿用昨天的快照；没有当天的就走原来的 1.5 秒有界等待。
+
+## 回填后怎么处理
+
+把 5、7 的两组数字交给验收方，写进 `docs/tasks/PROGRESS-consultation-external-evidence-cache-20260915.md`。若单域已稳定低于 21 秒，结论写成「三域上限可以放宽到 N」的依据，**不要在本单改上限**。
+
+**在这份清单回填之前，任何人不得声称「staging 单域耗时已验证」。**
@@ -330,6 +330,7 @@ export async function POST(request: Request) {
      { status: 503 },
    );
  }
+  const sessionContextWindow = sessionModel.contextWindow;

  if (parsed.data.entrypoint === "birth_time_rectification") {
    return NextResponse.json(
@@ -353,7 +354,7 @@ export async function POST(request: Request) {
  // Client `history` stays in the request schema for old bundles and is not read.
  const contextSummary = parseSessionContextSummary(chatSession.context_summary);
  const historyWindow = consultationHistoryWindow(chatSession.messages, contextSummary, {
-    contextWindow: sessionModel.contextWindow,
+    contextWindow: sessionContextWindow,
  });
  const storedHistory = historyWindow.tail;
  const userControlledPrompt = [
@@ -596,6 +597,7 @@ export async function POST(request: Request) {
      await checkpointSessionContextSummary({
        messages: sessionRow.messages,
        summary: sessionRow.context_summary,
+        contextWindow: sessionContextWindow,
        generateText: (prompt, signal) => generateSessionContextSummaryText(summaryModel, prompt, signal),
        update: async (summary, seenUpdatedAt) => {
          let query = supabase.from("chat_sessions")
@@ -875,6 +877,7 @@ export async function POST(request: Request) {
            instruction: modeInstruction,
            extra: generalDailyContextPrompt(generalDailyContext),
            summaryText: historyWindow.summaryText,
+            droppedCount: historyWindow.droppedCount,
            question: resolvedQuestion.modelQuestion,
          }),
        },
@@ -1271,6 +1274,7 @@ export async function POST(request: Request) {
          instruction: generalNoMinuteInstruction(Boolean(generalDailyContext)),
          extra: generalDailyContextPrompt(generalDailyContext),
          summaryText: historyWindow.summaryText,
+          droppedCount: historyWindow.droppedCount,
          question: resolvedQuestion.modelQuestion,
        }),
      },
@@ -1355,6 +1359,7 @@ export async function POST(request: Request) {
          name,
          instruction: "先用 3–6 句口语直接回答下面的问题，不要加标题；形状为一句结论、2–3 条短要点（每条完整句子、不超过 30 字）、一句下一步，总量不超过 400 字；然后再按 skill Level 2 骨架写：原始结构、六步宫位、Yoga 表、时机、综合、文末技法审计表，最后才是现代生活。骨架不可省略。星盘事实只使用系统里已经注入的计算结果，不要复述内部字段、JSON 或再跑一遍咨询流程。",
          summaryText: historyWindow.summaryText,
+          droppedCount: historyWindow.droppedCount,
          question: resolvedQuestion.modelQuestion,
        }),
      },
@@ -1379,6 +1384,7 @@ export async function POST(request: Request) {
            name,
            instruction: "先用 3–6 句口语直接回答下面的问题，不要加标题；形状为一句结论、2–3 条短要点（每条完整句子、不超过 30 字）、一句下一步，总量不超过 400 字；然后再按 skill Level 2 骨架写：原始结构、六步宫位、Yoga 表、时机、综合、文末技法审计表，最后才是现代生活。骨架不可省略。星盘事实只使用系统里已经注入的计算结果，不要复述内部字段、JSON 或再跑一遍咨询流程。",
            summaryText: historyWindow.summaryText,
+            droppedCount: historyWindow.droppedCount,
            question: resolvedQuestion.modelQuestion,
          }),
        },
@@ -1,6 +1,12 @@
 import { NextResponse } from "next/server";
-import { chatSessionCreateSchema, ChatSessionBodyTooLargeError, readChatSessionJson } from "@/lib/chat-session-write-contract";
+import {
+  chatSessionCreateInsertRow,
+  chatSessionCreateSchema,
+  ChatSessionBodyTooLargeError,
+  readChatSessionJson,
+} from "@/lib/chat-session-write-contract";
 import { consumeUserRequestRateLimit } from "@/lib/request-rate-limit";
+import { resolveInheritedContextSummary } from "@/lib/session-context-summary";
 import { isSupabaseConfigurationError } from "@/lib/supabase/config";
 import { createServerSupabaseClient } from "@/lib/supabase/server";
 import {
@@ -94,13 +100,28 @@ export async function POST(request: Request) {
    }
    const parsed = chatSessionCreateSchema.safeParse(await readChatSessionJson(request));
    if (!parsed.success) return NextResponse.json({ error: "聊天记录格式不正确" }, { status: 400 });
-    const { id, updated_at: _ignoredClientClock, ...values } = parsed.data;
-    const { error } = await supabase.from("chat_sessions").insert({
-      id,
-      user_id: user.id,
-      ...values,
-      updated_at: new Date().toISOString(),
+    const { id, updated_at: _ignoredClientClock, continued_from_session_id: continuedFromSessionId, ...values } = parsed.data;
+    const inheritedSummary = await resolveInheritedContextSummary({
+      continuedFromSessionId,
+      loadOwnedSummary: async (sourceId) => {
+        const { data } = await supabase
+          .from("chat_sessions")
+          .select("context_summary")
+          .eq("id", sourceId)
+          .eq("user_id", user.id)
+          .maybeSingle();
+        return data?.context_summary ?? null;
+      },
    });
+    const { error } = await supabase.from("chat_sessions").insert(
+      chatSessionCreateInsertRow({
+        id,
+        userId: user.id,
+        values,
+        inheritedSummary,
+        updatedAt: new Date().toISOString(),
+      }),
+    );
    if (error) return NextResponse.json({ error: "聊天记录暂时无法同步" }, { status: 500 });
    return NextResponse.json({ ok: true }, { status: 201 });
  } catch (error) {
@@ -135,7 +135,7 @@ export type ConsultationRunParams = {
  uiPreviewMode: MutableRefObject<string | null>;
  persistSession: (session: ChatSession, mode?: "create" | "update") => Promise<void>;
  updateSession: (sessionId: string, change: (session: ChatSession) => ChatSession) => void;
-  startNewChat: () => Promise<ChatSession | null>;
+  startNewChat: (options?: { continuedFromSessionId?: string }) => Promise<ChatSession | null>;
  continueInNewChat: (prompt: { question: string; theme: Theme }) => Promise<void>;
  refreshAccount: () => Promise<void>;
  openAccountDialog: (dialog: AccountDialog, options?: HTMLButtonElement | null | OpenAccountDialogOptions) => void;
@@ -139,7 +139,11 @@ export function useSessionManagement(params: SessionManagementParams) {
    setSessions((current) => current.map((session) => (session.id === sessionId ? change(session) : session)));
  }

-  async function persistSession(session: ChatSession, mode: "create" | "update" = "update") {
+  async function persistSession(
+    session: ChatSession,
+    mode: "create" | "update" = "update",
+    options?: { continuedFromSessionId?: string },
+  ) {
    if (!account) throw new Error("账户尚未加载完成");
    if (process.env.NODE_ENV === "development" && uiPreview.current) return;
    const values = mode === "create"
@@ -153,6 +157,9 @@ export function useSessionManagement(params: SessionManagementParams) {
        chart_profile_id: session.chartProfileId,
        chart_profile_name: session.chartProfileName,
        chart_profile_role: session.chartProfileRole,
+        ...(options?.continuedFromSessionId
+          ? { continued_from_session_id: options.continuedFromSessionId }
+          : {}),
      }
      : {
        title: session.title,
@@ -192,7 +199,10 @@ export function useSessionManagement(params: SessionManagementParams) {

  async function continueInNewChat(prompt: { question: string; theme: Theme }) {
    setSessionFullPrompt(null);
-    const created = await startNewChat();
+    const sourceSessionId = activeSessionId;
+    const created = await startNewChat(
+      sourceSessionId ? { continuedFromSessionId: sourceSessionId } : undefined,
+    );
    if (!created) return;
    setDraft(prompt.question);
    setDraftTheme(prompt.theme);
@@ -294,7 +304,7 @@ export function useSessionManagement(params: SessionManagementParams) {
    }
  }

-  async function startNewChat(): Promise<ChatSession | null> {
+  async function startNewChat(options?: { continuedFromSessionId?: string }): Promise<ChatSession | null> {
    if (!account || !modelCatalog || creatingSession) return null;
    const nextSession = {
      ...createSession(modelCatalog.defaultModelId),
@@ -312,7 +322,13 @@ export function useSessionManagement(params: SessionManagementParams) {
    setComposerNotice("");
    setRequestError(null);
    try {
-      await persistSession(nextSession, "create");
+      await persistSession(
+        nextSession,
+        "create",
+        options?.continuedFromSessionId
+          ? { continuedFromSessionId: options.continuedFromSessionId }
+          : undefined,
+      );
      return nextSession;
    } catch (caught) {
      setSessions((current) => current.filter((session) => session.id !== nextSession.id));
@@ -59,6 +59,7 @@ export const chatSessionCreateSchema = z.object({
  messages: z.array(chatMessageSchema).max(0),
  session_type: z.enum(["consultation", "birth_time_rectification"]),
  rectification_case_id: z.string().uuid().nullable(),
+  continued_from_session_id: z.string().uuid().optional(),
  ...chartBindingSchema,
  updated_at: z.string().datetime().optional(),
 }).strict();
@@ -148,11 +149,41 @@ export type ChatSessionCreate = Readonly<{
  messages: readonly [];
  session_type: "consultation" | "birth_time_rectification";
  rectification_case_id: string | null;
+  continued_from_session_id?: string;
  chart_profile_id?: string | null;
  chart_profile_name?: string | null;
  chart_profile_role?: "self" | "other" | null;
 }>;

+export type ChatSessionCreateInsertValues = Readonly<{
+  title: string;
+  theme: ConsultationDomain;
+  model_id: string;
+  messages: readonly unknown[];
+  session_type: "consultation" | "birth_time_rectification";
+  rectification_case_id: string | null;
+  chart_profile_id?: string | null;
+  chart_profile_name?: string | null;
+  chart_profile_role?: "self" | "other" | null;
+}>;
+
+export function chatSessionCreateInsertRow(input: {
+  id: string;
+  userId: string;
+  values: ChatSessionCreateInsertValues;
+  inheritedSummary?: unknown;
+  updatedAt: string;
+}): Record<string, unknown> {
+  const row: Record<string, unknown> = {
+    id: input.id,
+    user_id: input.userId,
+    ...input.values,
+    updated_at: input.updatedAt,
+  };
+  if (input.inheritedSummary) row.context_summary = input.inheritedSummary;
+  return row;
+}
+
 export type ChatSessionWrite = Readonly<{
  title: string;
  theme: ConsultationDomain;
@@ -1,11 +1,14 @@
 export const CONSULTATION_HISTORY_LIMIT = 12;
 export const CONSULTATION_HISTORY_MESSAGE_CHARS = 12_000;
-export const CONSULTATION_HISTORY_TAIL_MAX_CHARS = 16_000;
 export const CONSULTATION_HISTORY_SYSTEM_RESERVE_TOKENS = 60_000;
 export const CONSULTATION_HISTORY_CHAR_PER_TOKEN = 1.5;
 export const CONSULTATION_HISTORY_BUDGET_MIN_CHARS = 4_000;
 export const CONSULTATION_HISTORY_BUDGET_MAX_CHARS = 40_000;
 export const DEFAULT_MODEL_CONTEXT_WINDOW = 128_000;
+// 0.4 of the history budget. At the default 128k window the budget is 40,000,
+// so the checkpoint fires at 16,000 — the previous hard-coded threshold.
+// Smaller windows then checkpoint before the tail can exceed the budget.
+export const CONSULTATION_HISTORY_CHECKPOINT_BUDGET_RATIO = 0.4;

 export const SESSION_CONTEXT_SUMMARY_HEADING = "【会话摘要（服务端维护）】";

@@ -51,6 +54,15 @@ export function historyBudgetChars(contextWindow: number | null | undefined): nu
  );
 }

+export function consultationHistoryCheckpointChars(contextWindow: number | null | undefined): number {
+  const budget = historyBudgetChars(contextWindow);
+  const threshold = Math.floor(budget * CONSULTATION_HISTORY_CHECKPOINT_BUDGET_RATIO);
+  if (!(threshold < budget)) {
+    throw new Error("consultation history checkpoint threshold must stay below the history budget");
+  }
+  return threshold;
+}
+
 export function parseSessionContextSummary(value: unknown): SessionContextSummaryV1 | null {
  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
  const row = value as Record<string, unknown>;
@@ -74,6 +86,13 @@ export function omissionMarker(omittedChars: number): string {
  return `……（以下省略 ${omittedChars} 字，结论已并入会话摘要）`;
 }

+export function droppedRoundsMarker(droppedCount: number, hasSummary: boolean): string {
+  if (droppedCount <= 0) return "";
+  return hasSummary
+    ? `……（更早的 ${droppedCount} 轮问答已并入上面的会话摘要）`
+    : `……（更早的 ${droppedCount} 轮问答未能进入本轮上下文，结论尚未并入会话摘要）`;
+}
+
 export function clipConsultationHistoryText(text: string): string {
  if (text.length <= CONSULTATION_HISTORY_MESSAGE_CHARS) return text;
  const omitted = text.length - CONSULTATION_HISTORY_MESSAGE_CHARS;
@@ -165,16 +184,18 @@ export function consultationUserTurnContent(input: {
  instruction: string;
  extra?: string;
  summaryText?: string | null;
+  droppedCount?: number;
  question: string;
 }): string {
+  const summary = input.summaryText?.trim() ?? "";
+  const dropped = droppedRoundsMarker(input.droppedCount ?? 0, Boolean(summary));
  return [
    input.currentTime,
    input.name ? `用户称呼：${input.name}` : "",
    input.instruction,
    input.extra ?? "",
-    input.summaryText?.trim()
-      ? `${SESSION_CONTEXT_SUMMARY_HEADING}\n${input.summaryText.trim()}`
-      : "",
+    summary ? `${SESSION_CONTEXT_SUMMARY_HEADING}\n${summary}` : "",
+    dropped,
    input.question,
  ].filter(Boolean).join("\n");
 }
@@ -1,7 +1,7 @@
 import { Agent } from "@mastra/core/agent";

 import {
-  CONSULTATION_HISTORY_TAIL_MAX_CHARS,
+  consultationHistoryCheckpointChars,
  lastConsultationPair,
  parseSessionContextSummary,
  storedConsultationTurns,
@@ -98,7 +98,7 @@ export function sanitizeSessionContextSummary(raw: string): string | null {
 export function tailCharCount(
  messages: unknown,
  summary: SessionContextSummaryV1 | null,
-  options: { excludeRequestId?: string } = {},
+  options: { excludeRequestId?: string; contextWindow?: number | null } = {},
 ): number {
  const turns = storedConsultationTurns(messages, { excludeRequestId: options.excludeRequestId });
  const tail = summary
@@ -110,9 +110,10 @@ export function tailCharCount(
 export function shouldCheckpoint(
  messages: unknown,
  summary: SessionContextSummaryV1 | null,
-  options: { excludeRequestId?: string } = {},
+  options: { excludeRequestId?: string; contextWindow?: number | null } = {},
 ): boolean {
-  return tailCharCount(messages, summary, options) > CONSULTATION_HISTORY_TAIL_MAX_CHARS;
+  return tailCharCount(messages, summary, options)
+    > consultationHistoryCheckpointChars(options.contextWindow);
 }

 export function messagesForSummaryInput(
@@ -215,6 +216,19 @@ export function nextSessionContextSummary(
  };
 }

+export async function resolveInheritedContextSummary(input: {
+  continuedFromSessionId?: string | null;
+  loadOwnedSummary: (sessionId: string) => Promise<unknown>;
+}): Promise<SessionContextSummaryV1 | null> {
+  const sourceId = input.continuedFromSessionId?.trim();
+  if (!sourceId) return null;
+  try {
+    return parseSessionContextSummary(await input.loadOwnedSummary(sourceId));
+  } catch {
+    return null;
+  }
+}
+
 export async function writeSessionContextSummary(input: {
  seenUpdatedAt: string | null;
  summary: SessionContextSummaryV1;
@@ -228,13 +242,17 @@ export async function checkpointSessionContextSummary(input: {
  messages: unknown;
  summary: unknown;
  excludeRequestId?: string;
+  contextWindow?: number | null;
  now?: () => Date;
  generateText: (prompt: string, signal?: AbortSignal) => Promise<string>;
  update: (summary: SessionContextSummaryV1, seenUpdatedAt: string | null) => Promise<boolean>;
  timeoutMs?: number;
 }): Promise<"written" | "skipped" | "abandoned" | "failed"> {
  const previous = parseSessionContextSummary(input.summary);
-  if (!shouldCheckpoint(input.messages, previous, { excludeRequestId: input.excludeRequestId })) {
+  if (!shouldCheckpoint(input.messages, previous, {
+    excludeRequestId: input.excludeRequestId,
+    contextWindow: input.contextWindow,
+  })) {
    return "skipped";
  }
  try {
@@ -676,6 +676,7 @@ export function createConsultationTools(ctx: ConsultationAgentContext) {
              signal: context.abortSignal ?? ctx.abortSignal,
              plan: domainPlan,
              requestId: ctx.requestId,
+              entrypoint: ctx.entrypoint,
            });
            const guarded = applyBirthTimeModeToWorkflowContext(workflow, ctx.consultationMode, {
              birthTimeSource: ctx.serverChart.truth.birthTimeSource,
@@ -125,7 +125,13 @@ export function consultationWorkflowFailureCode(error: unknown): ConsultationWor

 export async function runConsultationWorkflow(
  input: ConsultationInput,
-  options?: { foreground?: boolean; signal?: AbortSignal; plan?: ConsultationPlan; requestId?: string },
+  options?: {
+    foreground?: boolean;
+    signal?: AbortSignal;
+    plan?: ConsultationPlan;
+    requestId?: string;
+    entrypoint?: string;
+  },
 ) {
  const { entryMode, question, theme, ...workflowInput } = input;
  const plan = options?.plan ?? createConsultationPlan({ userIntent: question, theme });
@@ -139,6 +145,7 @@ export async function runConsultationWorkflow(
      ...workflowInput,
      // Correlates this call with the API access log when a run fails.
      ...(options?.requestId ? { request_id: options.requestId } : {}),
+      ...(options?.entrypoint ? { entrypoint: options.entrypoint } : {}),
      entry_mode: entryMode,
      question: workflowRequest.question,
      question_text: workflowRequest.question,
@@ -0,0 +1,135 @@
+-- BUG-732: split append_consultation_question into two caps.
+-- Conversation quota (200,000) counts only user-visible `text`.
+-- thinkingText / thinkingSections stay stored but must not enter that sum.
+-- Physical cap counts the whole message JSON, including receipts.
+-- Arithmetic: 50 rounds × (~4,000 body + ~4,000 thinkingText + ~3,000
+-- thinkingSections + ~3,000 receipts) ≈ 700,000. Headroom → 1,000,000.
+-- Signature, return columns, error_code values, advisory lock, request_id
+-- idempotency, 200-message cap, and 16,000-char question check are unchanged
+-- (BUG-464). CREATE OR REPLACE is backward compatible with deployed callers.
+
+begin;
+
+do $migration$
+begin
+  if current_user <> 'schema_owner' then
+    raise exception 'consultation_session_capacity_requires_schema_owner'
+      using errcode = '42501';
+  end if;
+end
+$migration$;
+
+create or replace function public.append_consultation_question(
+  p_user_id uuid,
+  p_request_id text,
+  p_session_id uuid,
+  p_question_message jsonb
+)
+returns table(success boolean, error_code text)
+language plpgsql
+security definer
+set search_path = ''
+as $$
+declare
+  v_session public.chat_sessions%rowtype;
+  v_message jsonb;
+  v_text text;
+  v_request_id text;
+  v_count integer;
+  v_chars integer;
+  v_new_chars integer;
+  v_physical_chars bigint;
+  v_new_physical bigint;
+begin
+  v_request_id := btrim(coalesce(p_request_id, ''));
+  if p_user_id is null or p_session_id is null or v_request_id = '' then
+    return query select false, 'invalid_request'::text;
+    return;
+  end if;
+  if jsonb_typeof(p_question_message) <> 'object'
+    or p_question_message->>'role' <> 'user' then
+    return query select false, 'invalid_question_message'::text;
+    return;
+  end if;
+  v_text := btrim(coalesce(p_question_message->>'text', ''));
+  if v_text = '' or char_length(v_text) > 16000 then
+    return query select false, 'invalid_question_message'::text;
+    return;
+  end if;
+
+  perform pg_advisory_xact_lock(hashtextextended(p_user_id::text || ':' || v_request_id, 0));
+
+  select session.* into v_session
+  from public.chat_sessions as session
+  where session.id = p_session_id
+    and session.user_id = p_user_id
+    and session.session_type = 'consultation'
+  for update;
+
+  if not found then
+    return query select false, 'session_missing'::text;
+    return;
+  end if;
+
+  if exists (
+    select 1
+    from jsonb_array_elements(coalesce(v_session.messages, '[]'::jsonb)) as elem
+    where elem->>'requestId' = v_request_id
+  ) then
+    return query select true, null::text;
+    return;
+  end if;
+
+  v_message := p_question_message || jsonb_build_object('requestId', v_request_id);
+
+  v_count := jsonb_array_length(coalesce(v_session.messages, '[]'::jsonb));
+  select
+    coalesce(sum(length(coalesce(elem->>'text', ''))), 0),
+    coalesce(sum(length(elem::text)), 0)
+  into v_chars, v_physical_chars
+  from jsonb_array_elements(coalesce(v_session.messages, '[]'::jsonb)) as elem;
+
+  v_new_chars := length(v_text);
+  v_new_physical := length(v_message::text);
+  if v_count >= 200
+    or (v_chars + v_new_chars) > 200000
+    or (v_physical_chars + v_new_physical) > 1000000 then
+    return query select false, 'session_full'::text;
+    return;
+  end if;
+
+  update public.chat_sessions as session
+  set messages = coalesce(session.messages, '[]'::jsonb) || jsonb_build_array(v_message),
+      title = case
+        when coalesce(btrim(session.title), '') in ('', '新对话') then
+          case
+            when char_length(v_text) > 14 then left(v_text, 14) || '…'
+            else v_text
+          end
+        else session.title
+      end,
+      updated_at = clock_timestamp()
+  where session.id = p_session_id
+    and session.user_id = p_user_id
+    and session.session_type = 'consultation';
+  if not found then
+    return query select false, 'session_missing'::text;
+    return;
+  end if;
+
+  return query select true, null::text;
+end;
+$$;
+
+revoke all on function public.append_consultation_question(uuid, text, uuid, jsonb)
+  from public, anon, authenticated;
+grant execute on function public.append_consultation_question(uuid, text, uuid, jsonb)
+  to service_role;
+do $$ begin
+  if exists(select 1 from pg_roles where rolname = 'admin_runtime') then
+    grant execute on function public.append_consultation_question(uuid, text, uuid, jsonb)
+      to admin_runtime;
+  end if;
+end $$;
+
+commit;
@@ -296,8 +296,9 @@ test("the golden chart-view envelope stays inside the page contract", () => {
  assert.match(COORDINATE_BOUNDARY.qizheng, /角宿/);
 });

-test("page.tsx does not grow to host the chart page", () => {
-  assert.ok((pageSource.match(/\n/g) ?? []).length <= 1951);
+test("page.tsx does not host the chart page", () => {
+  // Line-count freeze moved to tests/home-shell-growth-contract.test.ts
+  // (Home() useState / useRef caps + coarse line-count guardrail).
  assert.doesNotMatch(pageSource, /chart-page|ChartPageView|\/api\/chart-view/);
 });

@@ -20,6 +20,10 @@ test("session list GET omits messages while detail GET returns them", () => {
    /SESSION_LIST_COLUMNS = "id,title,theme,model_id,session_type,rectification_case_id,chart_profile_id,chart_profile_name,chart_profile_role,updated_at,pinned,archived_at"/,
  );
  assert.doesNotMatch(listRoute, /select\(SESSION_LIST_COLUMNS\)[\s\S]*messages/);
+  assert.doesNotMatch(
+    listRoute,
+    /SESSION_LIST_COLUMNS = "[^"]*context_summary/,
+  );
  assert.match(itemRoute, /export async function GET/);
  assert.match(
    itemRoute,
@@ -52,6 +56,8 @@ test("consult appends the user question after reserve and returns session_full",
  assert.match(sendSource, /caught\.code === "session_full"/);
  assert.match(sendSource, /label: "开新对话"/);
  assert.match(sendSource, /continueInNewChat\(\{ question: originalQuestion, theme \}\)/);
+  assert.match(page, /continuedFromSessionId: sourceSessionId/);
+  assert.doesNotMatch(page, /接着上次|继续上次聊|继承会话摘要|从上次对话继续/);
 });

 test("PATCH compatibility accepts and ignores a legacy messages write", () => {
@@ -173,7 +173,7 @@ test("popstate to a missing session query reuses selectSession side effects for
 });

 test("creating and leaving a session keep the address bar in sync", () => {
-  const startNewChat = sourceBetween(page, "async function startNewChat()", "function selectSession(");
+  const startNewChat = sourceBetween(page, "async function startNewChat(", "function selectSession(");
  assert.match(startNewChat, /writeSessionUrl\(nextSession\.id, "push"\)/);
  assert.match(startNewChat, /window\.history\.replaceState\(null, "", previousHref\)/);

@@ -1,7 +1,14 @@
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import test from "node:test";
-import { chatSessionCreateSchema, chatSessionMetadataPatchSchema, chatSessionWriteSchema, writeChatSession, type ChatSessionWrite } from "../src/lib/chat-session-write-contract.ts";
+import {
+  chatSessionCreateInsertRow,
+  chatSessionCreateSchema,
+  chatSessionMetadataPatchSchema,
+  chatSessionWriteSchema,
+  writeChatSession,
+  type ChatSessionWrite,
+} from "../src/lib/chat-session-write-contract.ts";
 import { metadataUpdateValues } from "../src/lib/session-metadata-update.ts";
 import { homeSurface } from "./home-surface.ts";

@@ -41,6 +48,61 @@ test("create schema keeps the client-generated session id after transcript limit
  assert.equal(parsed.messages.length, 0);
 });

+test("create schema accepts continued_from_session_id and rejects client-supplied context_summary", () => {
+  const parsed = chatSessionCreateSchema.parse({
+    id: sessionId,
+    ...createValues,
+    continued_from_session_id: "22222222-2222-4222-8222-222222222222",
+  });
+  assert.equal(parsed.continued_from_session_id, "22222222-2222-4222-8222-222222222222");
+  assert.equal("context_summary" in parsed, false);
+  assert.equal("context_summary" in chatSessionCreateSchema.shape, false);
+
+  const withSummary = chatSessionCreateSchema.safeParse({
+    id: sessionId,
+    ...createValues,
+    context_summary: { version: 1, text: "injected" },
+  });
+  assert.equal(withSummary.success, false);
+
+  const badId = chatSessionCreateSchema.safeParse({
+    id: sessionId,
+    ...createValues,
+    continued_from_session_id: "not-a-uuid",
+  });
+  assert.equal(badId.success, false);
+});
+
+test("create insert copies an owned summary and omits a missing one", () => {
+  const source = {
+    version: 1 as const,
+    text: "已问过的问题\n事业时机",
+    throughRequestId: "a1",
+    throughMessageIndex: 3,
+    messageCount: 4,
+    updatedAt: "2026-09-15T00:00:00.000Z",
+  };
+  const copied = chatSessionCreateInsertRow({
+    id: sessionId,
+    userId: "owner",
+    values: createValues,
+    inheritedSummary: source,
+    updatedAt: "2026-09-16T00:00:00.000Z",
+  });
+  assert.deepEqual(copied.context_summary, source);
+  assert.equal("continued_from_session_id" in copied, false);
+
+  const skipped = chatSessionCreateInsertRow({
+    id: sessionId,
+    userId: "owner",
+    values: createValues,
+    inheritedSummary: null,
+    updatedAt: "2026-09-16T00:00:00.000Z",
+  });
+  assert.equal("context_summary" in skipped, false);
+  assert.equal(skipped.user_id, "owner");
+});
+
 test("create schema rejects a non-empty transcript", () => {
  // Former value: create accepted up to CHAT_SESSION_MAX_MESSAGES and was a
  // history-import path. Create is now only an empty session.
@@ -122,6 +184,19 @@ test("metadata patch accepts pin and archive fields without a transcript", () =>
  assert.deepEqual(chatSessionMetadataPatchSchema.parse({ archived_at: null }), { archived_at: null });
 });

+test("create write may carry continued_from_session_id and never context_summary", async () => {
+  const calls: Array<Record<string, unknown>> = [];
+  await writeChatSession(sessionId, {
+    ...createValues,
+    continued_from_session_id: "22222222-2222-4222-8222-222222222222",
+  }, "create", async (_url, init) => {
+    calls.push(JSON.parse(String(init?.body)));
+    return Response.json({ ok: true }, { status: 201 });
+  });
+  assert.equal(calls[0]?.continued_from_session_id, "22222222-2222-4222-8222-222222222222");
+  assert.equal("context_summary" in (calls[0] ?? {}), false);
+});
+
 test("chat session writes use same-origin API instead of browser-to-Supabase requests", async () => {
  const calls: Array<{ url: string; init?: RequestInit }> = [];
  await writeChatSession(sessionId, metadataPatch, "update", async (url, init) => {
@@ -205,8 +280,17 @@ test("session API owns create and update while answer UI keeps sync failures out
  assert.match(itemRoute, /readChatSessionJson/);
  assert.match(collectionRoute, /ChatSessionBodyTooLargeError/);
  assert.match(itemRoute, /ChatSessionBodyTooLargeError/);
-  // Former value: `const { id, ...values } = parsed.data` trusted the client clock.
-  assert.match(collectionRoute, /const \{ id, updated_at: _ignoredClientClock, \.\.\.values \} = parsed\.data/);
+  // Former value: `const { id, updated_at: _ignoredClientClock, ...values } = parsed.data`
+  // New value: also peel `continued_from_session_id` so it is never inserted as a column.
+  assert.match(
+    collectionRoute,
+    /const \{ id, updated_at: _ignoredClientClock, continued_from_session_id: continuedFromSessionId, \.\.\.values \} = parsed\.data/,
+  );
+  assert.match(collectionRoute, /resolveInheritedContextSummary/);
+  assert.match(collectionRoute, /chatSessionCreateInsertRow/);
+  assert.match(collectionRoute, /\.eq\("user_id", user\.id\)/);
+  assert.match(collectionRoute, /status: 201/);
+  assert.doesNotMatch(collectionRoute, /context_summary: parsed/);
  assert.match(contract, /function limitTranscriptSize<Output extends \{ messages: Array<\{ text: string; thinkingText\?: string; thinkingSections\?: unknown \}> \}>/);
  assert.match(contract, /\): z\.ZodType<Output> \{/);
  assert.match(page, /chartSnapshotForSession/);
@@ -91,7 +91,7 @@ test("every external draft writer keeps working through the page-owned setters",

  // When: each existing write path is inspected.
  const chooseSuggested = sourceBetween(pageSource, "function chooseSuggestedQuestion(", "async function startSuggestedConsultation");
-  const startNewChat = sourceBetween(pageSource, "async function startNewChat()", "function selectSession(");
+  const startNewChat = sourceBetween(pageSource, "async function startNewChat(", "function selectSession(");
  const selectSession = sourceBetween(pageSource, "function selectSession(sessionId: string)", "async function selectSessionModel");
  const saveOnboardingName = sourceBetween(pageSource, "async function saveOnboardingName()", "async function saveOnboardingBirth");
  const stopRestore = sourceBetween(pageSource, "updateSession(pending.sessionId, () => pending.previousSession);", "function completeConsultationInterface");
@@ -14,7 +14,10 @@ test("consult history uses the checkpoint tail and puts the summary after the ti
  assert.match(consultRoute, /consultationHistoryWindow\(chatSession\.messages, contextSummary/);
  assert.match(consultRoute, /SESSION_CONTEXT_SUMMARY_HEADING|consultationUserTurnContent/);
  assert.match(consultRoute, /summaryText: historyWindow\.summaryText/);
+  assert.match(consultRoute, /droppedCount: historyWindow\.droppedCount/);
  assert.match(history, /【会话摘要（服务端维护）】/);
+  assert.match(history, /droppedRoundsMarker/);
+  assert.doesNotMatch(history, /16_000|16000/);
  const helper = history.slice(history.indexOf("export function consultationUserTurnContent"));
  const timeLine = helper.indexOf("input.currentTime");
  const summaryLine = helper.indexOf("SESSION_CONTEXT_SUMMARY_HEADING");
@@ -33,9 +36,13 @@ test("consult retries once on context overflow with summary plus the last pair",
 test("consult checkpoints the session summary after a successful completion", () => {
  assert.match(consultRoute, /void checkpointConsultationContext\(\)/);
  assert.match(consultRoute, /checkpointSessionContextSummary/);
+  assert.match(consultRoute, /contextWindow: sessionContextWindow/);
  assert.match(consultRoute, /context_summary ->>updatedAt|context_summary->>updatedAt/);
  assert.match(consultRoute, /console\.warn\("session context summary failed"/);
  assert.doesNotMatch(consultRoute, /AbortSignal\.timeout\(\s*15/);
+  const summary = readFileSync(new URL("../src/lib/session-context-summary.ts", import.meta.url), "utf8");
+  assert.match(summary, /consultationHistoryCheckpointChars/);
+  assert.doesNotMatch(summary, /CONSULTATION_HISTORY_TAIL_MAX_CHARS/);
 });

 test("the context summary migration only adds one jsonb column", () => {
@@ -0,0 +1,288 @@
+import assert from "node:assert/strict";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import { natalConsultationThinkingPlan } from "../src/lib/consultation-thinking-plan.ts";
+
+const migrationsDir = new URL("../supabase/migrations/", import.meta.url);
+const originalSql = readFileSync(
+  new URL("../supabase/migrations/20260901010000_append_consultation_question.sql", import.meta.url),
+  "utf8",
+);
+const sql = readFileSync(
+  new URL("../supabase/migrations/20260916010000_consultation_session_capacity.sql", import.meta.url),
+  "utf8",
+);
+const itemRoute = readFileSync(
+  new URL("../src/app/api/sessions/[id]/route.ts", import.meta.url),
+  "utf8",
+);
+const consultRoute = readFileSync(
+  new URL("../src/app/api/consult/route.ts", import.meta.url),
+  "utf8",
+);
+
+const SESSION_SELECT =
+  "id,title,theme,model_id,messages,session_type,rectification_case_id,chart_profile_id,chart_profile_name,chart_profile_role,updated_at,pinned,archived_at";
+
+function functionBody(source: string): string {
+  const match = source.match(/as \$\$\r?\n([\s\S]*?)\r?\n\$\$;/);
+  assert.ok(match?.[1], "function body must be present");
+  return match[1];
+}
+
+function withoutLineComments(source: string): string {
+  return source.replace(/--[^\n]*/g, "");
+}
+
+function utf8Bytes(value: string): number {
+  return Buffer.byteLength(value, "utf8");
+}
+
+function typicalReceipts(domains: readonly string[]) {
+  const workflowReceipt = {
+    route: "multi-domain",
+    status: "ready",
+    preciseTiming: "allowed",
+    missingLayers: [] as string[],
+    domains,
+  };
+  const agentExecutionReceipt = {
+    runId: "run-typical",
+    runtime: "mastra-agentic" as const,
+    skill: {
+      name: "jyotish-vedic-astrology" as const,
+      loaded: true,
+      version: "1.0.0",
+      referenceReads: 2,
+      methodologySections: 4,
+    },
+    steps: [
+      { sequence: 1, kind: "skill" as const, name: "jyotish-vedic-astrology", status: "completed" as const, durationMs: 120 },
+      { sequence: 2, kind: "tool" as const, name: "run-jyotish-consultation", status: "completed" as const, durationMs: 1800 },
+    ],
+    stepBudget: { planned: 8, used: 2, remaining: 6, truncated: false },
+    workflow: workflowReceipt,
+    techniqueTruth: "verified",
+    techniqueAuditTable: [
+      { technique: "VedAstro Cloud State", status: "blocked" as const, note: "未经核验的官方云证据，置信度封顶" },
+      { technique: "Functional Benefic/Malefic", status: "executed" as const, note: "功能属性与自然属性冲突时降置信" },
+      { technique: "Formal Vargas D1–D60", status: "executed" as const, note: "20/20 传统命名分盘" },
+      { technique: "Vimshottari sub-periods", status: "executed" as const, note: "本轮已纳入证据计划" },
+      { technique: "Narayana Dasha", status: "executed" as const, note: "本轮无独立当前读数" },
+      { technique: "Yogas", status: "executed" as const, note: "成盘与落空均列出" },
+      { technique: "Ashtakavarga", status: "executed" as const, note: "本轮已纳入证据计划" },
+      { technique: "Shadbala components", status: "executed" as const, note: "本轮已纳入证据计划" },
+      { technique: "MEVG / Global Web Evidence", status: "blocked" as const, note: "本轮未闭合" },
+      { technique: "Real Case Calibration", status: "blocked" as const, note: "本轮未闭合" },
+      { technique: "Timing Precision Gate", status: "executed" as const, note: "按声明精度封顶" },
+      { technique: "Prashna chart", status: "not_applicable" as const, note: "本轮为本命咨询" },
+    ],
+  };
+  return {
+    techniqueTruth: "verified",
+    workflowReceipt,
+    agentExecutionReceipt,
+  };
+}
+
+function thinkingPlan(domains: readonly ("career" | "wealth" | "marriage")[]) {
+  return natalConsultationThinkingPlan({
+    domains,
+    requiredBlocks: [
+      "raw_structure",
+      "raman_six_step",
+      "yoga_table",
+      "timing",
+      "synthesis",
+      "technique_audit_table",
+      "modern_wrap",
+    ],
+    mustUseLayers: ["D1", "run-jyotish-consultation", "D10", "skill_read"],
+  });
+}
+
+function assistantMessage(_index: number, domains: readonly ("career" | "wealth" | "marriage")[]) {
+  const receipts = typicalReceipts(domains);
+  return {
+    role: "assistant" as const,
+    text: "正".repeat(4000),
+    thinkingText: "思".repeat(4000),
+    thinkingSections: thinkingPlan(domains),
+    ...receipts,
+  };
+}
+
+function userMessage(index: number) {
+  return {
+    role: "user" as const,
+    text: `第${String(index + 1).padStart(2, "0")}问`.padEnd(100, "问"),
+    requestId: `capacity-req-${index + 1}`,
+  };
+}
+
+function sessionDetailPayload(rounds: number, domains: readonly ("career" | "wealth" | "marriage")[]) {
+  const messages = Array.from({ length: rounds }, (_, index) => [
+    userMessage(index),
+    assistantMessage(index, domains),
+  ]).flat();
+  return {
+    session: {
+      id: "00000000-0000-4000-8000-000000000001",
+      title: "事业方向",
+      theme: "career",
+      model_id: "test-model",
+      messages,
+      session_type: "consultation",
+      rectification_case_id: null,
+      chart_profile_id: null,
+      chart_profile_name: null,
+      chart_profile_role: null,
+      updated_at: "2026-09-15T00:00:00.000Z",
+      pinned: false,
+      archived_at: null,
+    },
+  };
+}
+
+function countedText(messages: readonly { text?: string }[]): number {
+  return messages.reduce((sum, message) => sum + (message.text ?? "").length, 0);
+}
+
+function oldCountedChars(messages: readonly Record<string, unknown>[]): number {
+  return messages.reduce((sum, message) => {
+    const text = typeof message.text === "string" ? message.text.length : 0;
+    const thinking = typeof message.thinkingText === "string" ? message.thinkingText.length : 0;
+    const sections = "thinkingSections" in message
+      ? JSON.stringify(message.thinkingSections).length
+      : 0;
+    return sum + text + thinking + sections;
+  }, 0);
+}
+
+test("the capacity migration is the latest replace of append_consultation_question", () => {
+  const names = readdirSync(fileURLToPath(migrationsDir))
+    .filter((name) => name.endsWith(".sql"))
+    .sort();
+  const replaces = names.filter((name) =>
+    name.includes("append_consultation_question") || name.includes("consultation_session_capacity"),
+  );
+  assert.deepEqual(replaces.at(-1), "20260916010000_consultation_session_capacity.sql");
+  assert.equal(
+    existsSync(fileURLToPath(new URL("../db/migrations/20260916010000_consultation_session_capacity.sql", import.meta.url))),
+    false,
+    "business migration must not be copied into frontend/db/migrations (BUG-127/BUG-144)",
+  );
+});
+
+test("CREATE OR REPLACE keeps the BUG-464 signature, lock, idempotency, and error codes", () => {
+  assert.match(
+    sql,
+    /create or replace function public\.append_consultation_question\(\s*p_user_id uuid,\s*p_request_id text,\s*p_session_id uuid,\s*p_question_message jsonb\s*\)/,
+  );
+  assert.match(sql, /returns table\(success boolean, error_code text\)/);
+  const body = functionBody(sql);
+  assert.match(body, /pg_advisory_xact_lock/);
+  assert.match(body, /elem->>'requestId' = v_request_id/);
+  assert.match(body, /return query select true, null::text;/);
+  assert.match(body, /'session_missing'::text/);
+  assert.match(body, /'session_full'::text/);
+  assert.match(body, /'invalid_request'::text/);
+  assert.match(body, /'invalid_question_message'::text/);
+  assert.match(body, /char_length\(v_text\) > 16000/);
+  assert.match(body, /v_count >= 200/);
+  assert.match(body, /\(v_chars \+ v_new_chars\) > 200000/);
+  assert.match(
+    sql,
+    /revoke all on function public\.append_consultation_question\(uuid, text, uuid, jsonb\)\s+from public, anon, authenticated/,
+  );
+  assert.match(
+    sql,
+    /grant execute on function public\.append_consultation_question\(uuid, text, uuid, jsonb\)\s+to service_role/,
+  );
+  assert.doesNotMatch(body, /session_physically_full|quota_exceeded|storage_full/);
+});
+
+test("conversation quota sum counts only text; physical cap counts whole JSON", () => {
+  assert.match(originalSql, /length\(coalesce\(elem->>'thinkingText', ''\)\)/);
+  assert.match(originalSql, /elem \? 'thinkingSections'/);
+
+  const body = functionBody(sql);
+  const code = withoutLineComments(body);
+  assert.doesNotMatch(code, /thinkingText/);
+  assert.doesNotMatch(code, /thinkingSections/);
+  assert.match(code, /coalesce\(sum\(length\(coalesce\(elem->>'text', ''\)\)\), 0\)/);
+  assert.match(code, /coalesce\(sum\(length\(elem::text\)\), 0\)/);
+  assert.match(code, /\(v_physical_chars \+ v_new_physical\) > 1000000/);
+  assert.match(sql, /50 rounds × \(~4,000 body \+ ~4,000 thinkingText \+ ~3,000/);
+  assert.match(sql, /thinkingSections \+ ~3,000 receipts\) ≈ 700,000\. Headroom → 1,000,000\./);
+});
+
+test("both caps still surface as session_full; consult route is unchanged", () => {
+  const body = functionBody(sql);
+  const fullReturns = body.match(/return query select false, 'session_full'::text;/g) ?? [];
+  assert.equal(fullReturns.length, 1);
+  assert.match(consultRoute, /error_code === "session_full"/);
+  assert.match(consultRoute, /code: "session_full"/);
+  assert.doesNotMatch(consultRoute, /session_physically_full|physical_cap|storage_full/);
+  assert.match(itemRoute, new RegExp(`sessionSelect = "${SESSION_SELECT}"`));
+});
+
+test("measured thinkingSections and receipts stay inside the physical-cap arithmetic", () => {
+  const one = JSON.stringify(thinkingPlan(["career"]));
+  const two = JSON.stringify(thinkingPlan(["career", "wealth"]));
+  const three = JSON.stringify(thinkingPlan(["career", "wealth", "marriage"]));
+  assert.ok(one.length >= 1200 && one.length <= 2500, `1-domain sections JSON length ${one.length}`);
+  assert.ok(two.length >= 1800 && two.length <= 3500, `2-domain sections JSON length ${two.length}`);
+  assert.ok(three.length >= 2400 && three.length <= 4500, `3-domain sections JSON length ${three.length}`);
+
+  const receipts = typicalReceipts(["career", "wealth", "marriage"]);
+  const receiptJson = JSON.stringify({
+    techniqueTruth: receipts.techniqueTruth,
+    workflowReceipt: receipts.workflowReceipt,
+    agentExecutionReceipt: receipts.agentExecutionReceipt,
+  });
+  const receiptChars = receiptJson.length;
+  assert.ok(
+    receiptChars <= 4000,
+    `typical three-receipt JSON is ${receiptChars} chars; update the 3,000 term and 1,000,000 cap if this is a real stored shape`,
+  );
+
+  const perRound =
+    4000
+    + 4000
+    + three.length
+    + receiptChars;
+  const fiftyRoundPhysical = 50 * perRound;
+  assert.ok(
+    fiftyRoundPhysical < 1_000_000,
+    `50 × typical stored round (${perRound} chars) = ${fiftyRoundPhysical}; must stay under the physical cap`,
+  );
+});
+
+test("session-detail JSON at the old ~19-round cap versus the new ~50-round cap", () => {
+  const domains = ["career", "wealth", "marriage"] as const;
+  const oldCap = sessionDetailPayload(19, domains);
+  const newCap = sessionDetailPayload(50, domains);
+  const oldJson = JSON.stringify(oldCap);
+  const newJson = JSON.stringify(newCap);
+  const oldBytes = utf8Bytes(oldJson);
+  const newBytes = utf8Bytes(newJson);
+
+  assert.equal(oldCap.session.messages.length, 38);
+  assert.equal(newCap.session.messages.length, 100);
+  assert.ok(oldCountedChars(oldCap.session.messages) > 200_000, "19 full rounds already exceeded the old combined quota");
+  assert.ok(countedText(newCap.session.messages) >= 200_000, "50 rounds of 100+4000 visible text reach the conversation quota");
+  // Measured 2026-09-16 on this fixture: 19-round 562,240 B (0.536 MiB);
+  // 50-round 1,479,034 B (1.411 MiB); ratio 2.631.
+  assert.ok(oldBytes > 540_000 && oldBytes < 590_000, `19-round detail JSON was ${oldBytes} bytes`);
+  assert.ok(newBytes > 1_450_000 && newBytes < 1_510_000, `50-round detail JSON was ${newBytes} bytes`);
+  assert.ok(newBytes > oldBytes, "50-round detail JSON must be larger than 19-round");
+
+  const ratio = newBytes / oldBytes;
+  assert.ok(
+    ratio > 2.5 && ratio < 2.8,
+    `50/19 size ratio was ${ratio.toFixed(3)} (utf8 ${oldBytes} → ${newBytes})`,
+  );
+});
@@ -2,11 +2,14 @@ import assert from "node:assert/strict";
 import test from "node:test";

 import {
+  CONSULTATION_HISTORY_CHECKPOINT_BUDGET_RATIO,
  CONSULTATION_HISTORY_MESSAGE_CHARS,
  clipConsultationHistoryText,
+  consultationHistoryCheckpointChars,
  consultationHistoryFromStoredMessages,
  consultationHistoryWindow,
  consultationUserTurnContent,
+  droppedRoundsMarker,
  historyBudgetChars,
  isContextOverflowError,
  omissionMarker,
@@ -77,6 +80,61 @@ test("historyBudgetChars uses 64k, 32k, and null-as-128k windows", () => {
  assert.equal(historyBudgetChars(undefined), 40_000);
 });

+test("checkpoint threshold stays below the history budget for legal context windows", () => {
+  assert.equal(CONSULTATION_HISTORY_CHECKPOINT_BUDGET_RATIO, 0.4);
+  const windows = [200_000, 128_000, 64_000, 32_000, null] as const;
+  for (const window of windows) {
+    const budget = historyBudgetChars(window);
+    const threshold = consultationHistoryCheckpointChars(window);
+    assert.ok(threshold < budget, `window=${window}`);
+  }
+  // 128k keeps the previous 16,000-character checkpoint.
+  assert.equal(consultationHistoryCheckpointChars(128_000), 16_000);
+  assert.equal(consultationHistoryCheckpointChars(null), 16_000);
+  assert.equal(consultationHistoryCheckpointChars(64_000), 2_400);
+  assert.equal(consultationHistoryCheckpointChars(32_000), 1_600);
+});
+
+test("dropped whole turns leave an omission marker in the user-turn summary slot", () => {
+  const body = "x".repeat(3_000);
+  const history = consultationHistoryWindow(numberedMessages(20, () => body), null, {
+    contextWindow: 128_000,
+  });
+  assert.ok(history.droppedCount > 0);
+  const withoutSummary = consultationUserTurnContent({
+    currentTime: "当前时间：2026-09-16 12:00（中国）",
+    instruction: "先加载 Jyotish Skill",
+    summaryText: history.summaryText,
+    droppedCount: history.droppedCount,
+    question: "刚才你说的那个时间",
+  });
+  assert.match(
+    withoutSummary,
+    new RegExp(`更早的 ${history.droppedCount} 轮问答未能进入本轮上下文，结论尚未并入会话摘要`),
+  );
+  assert.equal(withoutSummary.includes(SESSION_CONTEXT_SUMMARY_HEADING), false);
+
+  const withSummary = consultationUserTurnContent({
+    currentTime: "当前时间：2026-09-16 12:00（中国）",
+    instruction: "先加载 Jyotish Skill",
+    summaryText: "先前结论",
+    droppedCount: history.droppedCount,
+    question: "刚才你说的那个时间",
+  });
+  assert.match(withSummary, new RegExp(`更早的 ${history.droppedCount} 轮问答已并入上面的会话摘要`));
+  assert.ok(withSummary.indexOf(SESSION_CONTEXT_SUMMARY_HEADING) < withSummary.indexOf("刚才你说的那个时间"));
+
+  const kept = consultationUserTurnContent({
+    currentTime: "当前时间：2026-09-16 12:00（中国）",
+    instruction: "先加载 Jyotish Skill",
+    summaryText: "先前结论",
+    droppedCount: 0,
+    question: "刚才你说的那个时间",
+  });
+  assert.equal(kept.includes("更早的"), false);
+  assert.equal(droppedRoundsMarker(0, true), "");
+});
+
 test("stored consultation history can skip the in-flight request id", () => {
  const history = consultationHistoryFromStoredMessages([
    { role: "user", text: "old", requestId: "keep" },
@@ -177,6 +177,19 @@ test("validates and emits non-sensitive workflow and execution receipts", () =>
  assert.match(route, /streamAgentResponse/);
 });

+test("consultationWorkflowResponseSchema still parses without western_evidence_packet", () => {
+  const schema = workflow.slice(
+    workflow.indexOf("export const consultationWorkflowResponseSchema"),
+    workflow.indexOf("function record("),
+  );
+  assert.match(schema, /success: z\.boolean\(\)/);
+  assert.match(schema, /chart: z\.record\(z\.unknown\(\)\)/);
+  assert.match(schema, /routing: z\.record\(z\.unknown\(\)\)/);
+  assert.match(schema, /consumer_context:/);
+  assert.match(schema, /\)\.passthrough\(\);/);
+  assert.doesNotMatch(schema, /western_evidence_packet/);
+});
+
 test("carries commercial technique truth into the model contract", () => {
  assert.match(workflow, /technique_truth/);
  assert.match(mastra, /deterministic_claims_forbidden_for/);
@@ -0,0 +1,277 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import { startPostgresFixture } from "./helpers/postgres-fixture.ts";
+
+const runnerPath = fileURLToPath(
+  new URL("../scripts/db-migrate.mjs", import.meta.url),
+);
+
+function dockerAvailable(): boolean {
+  return spawnSync("docker", ["version", "--format", "{{.Server.Version}}"], {
+    encoding: "utf8",
+    stdio: "ignore",
+  }).status === 0;
+}
+
+const skipWithoutDocker = dockerAvailable() ? false : "docker unavailable on this host";
+
+const SESSION_ID = "99999999-9999-4999-8999-999999999999";
+
+function sqlLiteral(value: string): string {
+  return value.replaceAll("'", "''");
+}
+
+function appendQuestionSql(
+  fixture: ReturnType<typeof startPostgresFixture>,
+  userId: string,
+  requestId: string,
+  textSql: string,
+  sessionId = SESSION_ID,
+): string {
+  return fixture.psql(`
+    select coalesce(success::text, 'null') || ':' || coalesce(error_code, 'null')
+    from public.append_consultation_question(
+      '${userId}'::uuid,
+      '${sqlLiteral(requestId)}',
+      '${sessionId}'::uuid,
+      jsonb_build_object('role', 'user', 'text', ${textSql})
+    );
+  `);
+}
+
+function appendQuestion(
+  fixture: ReturnType<typeof startPostgresFixture>,
+  userId: string,
+  requestId: string,
+  text: string,
+  sessionId = SESSION_ID,
+): string {
+  return appendQuestionSql(fixture, userId, requestId, `'${sqlLiteral(text)}'`, sessionId);
+}
+
+function seedSession(
+  fixture: ReturnType<typeof startPostgresFixture>,
+  userId: string,
+  messagesSql: string,
+): void {
+  fixture.psql(`
+    insert into public.chat_sessions (
+      id, user_id, title, theme, model_id, messages, session_type, updated_at
+    ) values (
+      '${SESSION_ID}', '${userId}', '新对话', 'general',
+      'test-model', ${messagesSql}, 'consultation', now()
+    )
+    on conflict (id) do update
+      set messages = excluded.messages,
+          title = excluded.title,
+          updated_at = now();
+  `);
+}
+
+test("append_consultation_question ignores thinking fields and enforces the physical JSON cap", { skip: skipWithoutDocker }, () => {
+  const fixture = startPostgresFixture();
+  const schemaUrl = fixture.connectionUrl("schema_owner", "schema-owner-test-password");
+
+  try {
+    const migration = spawnSync(process.execPath, [runnerPath], {
+      encoding: "utf8",
+      env: { ...process.env, SCHEMA_DATABASE_URL: schemaUrl },
+    });
+    assert.equal(migration.status, 0, migration.stderr);
+    assert.match(migration.stdout, /applied 20260916010000_consultation_session_capacity\.sql/);
+
+    fixture.psqlAs(
+      "identity_runtime",
+      "identity-runtime-test-password",
+      `
+        insert into identity.users (name, email, email_verified, email_verified_at)
+        values ('Capacity User', 'capacity@example.com', true, now());
+      `,
+    );
+    const userId = fixture.psql(
+      "select id from identity.users where email = 'capacity@example.com'",
+    );
+
+    assert.equal(
+      fixture.psql(`
+        select
+          has_function_privilege(
+            'service_role',
+            'public.append_consultation_question(uuid, text, uuid, jsonb)',
+            'execute'
+          ) || ':' ||
+          has_function_privilege(
+            'authenticated',
+            'public.append_consultation_question(uuid, text, uuid, jsonb)',
+            'execute'
+          ) || ':' ||
+          has_function_privilege(
+            'anon',
+            'public.append_consultation_question(uuid, text, uuid, jsonb)',
+            'execute'
+          )
+      `),
+      "true:f:f",
+    );
+
+    assert.equal(
+      appendQuestion(fixture, userId, "missing-session", "会话不存在"),
+      "false:session_missing",
+    );
+
+    seedSession(fixture, userId, "'[]'::jsonb");
+    assert.equal(appendQuestion(fixture, userId, "append-request-1", "第一问会不会丢"), "true:null");
+    assert.equal(appendQuestion(fixture, userId, "append-request-1", "不该写入的重复提问"), "true:null");
+    assert.equal(
+      fixture.psql(`select jsonb_array_length(messages) from public.chat_sessions where id = '${SESSION_ID}'`),
+      "1",
+    );
+
+    assert.equal(
+      appendQuestionSql(fixture, userId, "too-long", "repeat('x', 16001)"),
+      "false:invalid_question_message",
+    );
+
+    seedSession(fixture, userId, `
+      (
+        select coalesce(jsonb_agg(elem order by n), '[]'::jsonb)
+        from (
+          select n,
+            case when n % 2 = 1 then
+              jsonb_build_object(
+                'role', 'user',
+                'text', '短问题',
+                'requestId', 'think-seed-' || n::text
+              )
+            else
+              jsonb_build_object(
+                'role', 'assistant',
+                'text', '短回答',
+                'thinkingText', repeat('T', 4000),
+                'thinkingSections', jsonb_build_object('pad', repeat('S', 3000)),
+                'techniqueTruth', 'verified',
+                'workflowReceipt', jsonb_build_object(
+                  'route', 'career',
+                  'status', 'ready',
+                  'preciseTiming', 'allowed',
+                  'missingLayers', jsonb_build_array()
+                )
+              )
+            end as elem
+          from generate_series(1, 60) as n
+        ) as seeded
+      )
+    `);
+
+    const thinkingSums = fixture.psql(`
+      select
+        coalesce(sum(length(coalesce(elem->>'text', ''))), 0)::text
+        || ':' ||
+        coalesce(sum(
+          length(coalesce(elem->>'text', ''))
+          + length(coalesce(elem->>'thinkingText', ''))
+          + case when elem ? 'thinkingSections'
+              then length((elem->'thinkingSections')::text) else 0 end
+        ), 0)::text
+        || ':' ||
+        coalesce(sum(length(elem::text)), 0)::text
+      from public.chat_sessions,
+        jsonb_array_elements(coalesce(messages, '[]'::jsonb)) as elem
+      where id = '${SESSION_ID}'
+    `);
+    const [textOnly, oldFormula, physical] = thinkingSums.split(":").map(Number);
+    assert.ok(textOnly < 50_000, `visible text was ${textOnly}`);
+    assert.ok(oldFormula > 200_000, `old combined formula was ${oldFormula}`);
+    assert.ok(physical < 1_000_000, `physical JSON was ${physical}`);
+    assert.equal(appendQuestion(fixture, userId, "after-thinking", "思考不该占额度"), "true:null");
+    assert.equal(
+      fixture.psql(`select jsonb_array_length(messages) from public.chat_sessions where id = '${SESSION_ID}'`),
+      "61",
+    );
+
+    seedSession(fixture, userId, `
+      (
+        select coalesce(jsonb_agg(
+          jsonb_build_object('role', 'assistant', 'text', repeat('x', 19900), 'requestId', n::text)
+          order by n
+        ), '[]'::jsonb)
+        from generate_series(1, 10) as n
+      )
+    `);
+    const quotaBoundary = fixture.psql(`
+      select
+        coalesce(sum(length(coalesce(elem->>'text', ''))), 0)::text
+        || ':' ||
+        coalesce(sum(length(elem::text)), 0)::text
+      from public.chat_sessions,
+        jsonb_array_elements(coalesce(messages, '[]'::jsonb)) as elem
+      where id = '${SESSION_ID}'
+    `);
+    const [quotaText, quotaPhysical] = quotaBoundary.split(":").map(Number);
+    assert.equal(quotaText, 199_000);
+    assert.ok(quotaPhysical < 1_000_000, `quota-boundary physical JSON was ${quotaPhysical}`);
+    assert.equal(
+      appendQuestionSql(fixture, userId, "quota-full", "repeat('y', 1001)"),
+      "false:session_full",
+    );
+    assert.equal(
+      fixture.psql(`select jsonb_array_length(messages) from public.chat_sessions where id = '${SESSION_ID}'`),
+      "10",
+    );
+
+    seedSession(fixture, userId, `
+      jsonb_build_array(
+        jsonb_build_object(
+          'role', 'assistant',
+          'text', '短',
+          'techniqueTruth', 'verified',
+          'workflowReceipt', jsonb_build_object('route', 'career', 'status', 'ready', 'preciseTiming', 'allowed', 'missingLayers', jsonb_build_array()),
+          'agentExecutionReceipt', jsonb_build_object('pad', repeat('R', 1000001))
+        )
+      )
+    `);
+    const physicalOnly = fixture.psql(`
+      select
+        coalesce(sum(length(coalesce(elem->>'text', ''))), 0)::text
+        || ':' ||
+        coalesce(sum(length(elem::text)), 0)::text
+      from public.chat_sessions,
+        jsonb_array_elements(coalesce(messages, '[]'::jsonb)) as elem
+      where id = '${SESSION_ID}'
+    `);
+    const [shortText, hugePhysical] = physicalOnly.split(":").map(Number);
+    assert.ok(shortText < 100, `short body was ${shortText}`);
+    assert.ok(hugePhysical > 1_000_000, `receipt pad physical JSON was ${hugePhysical}`);
+    assert.equal(
+      appendQuestion(fixture, userId, "physical-full", "正文很短但行已经胀了"),
+      "false:session_full",
+    );
+    assert.equal(
+      fixture.psql(`select jsonb_array_length(messages) from public.chat_sessions where id = '${SESSION_ID}'`),
+      "1",
+    );
+
+    seedSession(fixture, userId, `
+      (
+        select coalesce(jsonb_agg(
+          jsonb_build_object('role', 'user', 'text', 'x', 'requestId', n::text)
+          order by n
+        ), '[]'::jsonb)
+        from generate_series(1, 200) as n
+      )
+    `);
+    assert.equal(
+      appendQuestion(fixture, userId, "count-full", "满了就不能再写"),
+      "false:session_full",
+    );
+    assert.equal(
+      fixture.psql(`select jsonb_array_length(messages) from public.chat_sessions where id = '${SESSION_ID}'`),
+      "200",
+    );
+  } finally {
+    fixture.stop();
+  }
+});
@@ -94,6 +94,7 @@ test("local PostgreSQL applies the reviewed business schema and serves authentic
    assert.match(migration.stdout, /applied 20260901020000_chat_session_pin_archive\.sql/);
    assert.match(migration.stdout, /applied 20260905010000_personal_report_longform_appendices\.sql/);
    assert.match(migration.stdout, /applied 20260915010000_rectification_touch_chat_session\.sql/);
+    assert.match(migration.stdout, /applied 20260916010000_consultation_session_capacity\.sql/);
    assert.equal(
      existsSync(fileURLToPath(new URL("../db/migrations/20260901020000_chat_session_pin_archive.sql", import.meta.url))),
      false,
@@ -104,6 +105,11 @@ test("local PostgreSQL applies the reviewed business schema and serves authentic
      false,
      "business migration must not be copied into frontend/db/migrations (BUG-127/BUG-144)",
    );
+    assert.equal(
+      existsSync(fileURLToPath(new URL("../db/migrations/20260916010000_consultation_session_capacity.sql", import.meta.url))),
+      false,
+      "business migration must not be copied into frontend/db/migrations (BUG-127/BUG-144)",
+    );
    fixture.psql(pinArchiveMigration);
    assert.equal(
      fixture.psql(`
@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+const pageSource = readFileSync(new URL("../src/app/page.tsx", import.meta.url), "utf8");
+
+// Measured 2026-09-16 on origin/staging @ 51a65d92.
+// Line count: (pageSource.match(/\n/g) ?? []).length, same as `wc -l` = 1951.
+// Hook counts use \buseState[<(] / \buseRef[<(] so `useState<Type>(` is not missed.
+// Former line-count assertion lived in tests/chart-view-route.test.ts
+// (`page.tsx does not grow to host the chart page`).
+const PAGE_LINE_COUNT_BASELINE = 1951;
+const PAGE_LINE_COUNT_CAP = PAGE_LINE_COUNT_BASELINE + 150;
+const HOME_USE_STATE_CAP = 66;
+const HOME_USE_REF_CAP = 41;
+
+const USE_STATE_RE = /\buseState[<(]/g;
+const USE_REF_RE = /\buseRef[<(]/g;
+
+function homeSource(source: string): string {
+  const marker = "export default function Home(";
+  const start = source.indexOf(marker);
+  assert.notEqual(start, -1, "page.tsx must export default function Home(");
+  return source.slice(start);
+}
+
+function countMatches(source: string, pattern: RegExp): number {
+  return source.match(new RegExp(pattern.source, "g"))?.length ?? 0;
+}
+
+test("Home() useState count must not grow", () => {
+  const n = countMatches(homeSource(pageSource), USE_STATE_RE);
+  assert.ok(
+    n <= HOME_USE_STATE_CAP,
+    `Home() has ${n} useState calls; cap is ${HOME_USE_STATE_CAP}. Extracted hooks and child components should own their own state.`,
+  );
+});
+
+test("Home() useRef count must not grow", () => {
+  const n = countMatches(homeSource(pageSource), USE_REF_RE);
+  assert.ok(
+    n <= HOME_USE_REF_CAP,
+    `Home() has ${n} useRef calls; cap is ${HOME_USE_REF_CAP}. Do not rewrite state as refs to dodge the useState freeze.`,
+  );
+});
+
+test("page.tsx line count stays within the coarse guardrail", () => {
+  const n = (pageSource.match(/\n/g) ?? []).length;
+  assert.ok(
+    n <= PAGE_LINE_COUNT_CAP,
+    `page.tsx has ${n} lines; cap is ${PAGE_LINE_COUNT_CAP} (${PAGE_LINE_COUNT_BASELINE} baseline + 150).`,
+  );
+});
@@ -3,13 +3,14 @@ import { readFileSync } from "node:fs";
 import test from "node:test";

 import {
-  CONSULTATION_HISTORY_TAIL_MAX_CHARS,
+  consultationHistoryCheckpointChars,
 } from "../src/lib/consultation-session-history.ts";
 import {
  buildSummaryPrompt,
  checkpointSessionContextSummary,
  generateSessionContextSummary,
  messagesForSummaryInput,
+  resolveInheritedContextSummary,
  sanitizeSessionContextSummary,
  shouldCheckpoint,
  writeSessionContextSummary,
@@ -24,10 +25,14 @@ function overBudgetConversation() {
  ];
 }

-test("checkpoint triggers only when the tail exceeds 16_000 characters", () => {
-  assert.equal(CONSULTATION_HISTORY_TAIL_MAX_CHARS, 16_000);
+test("checkpoint triggers only when the tail exceeds the derived threshold", () => {
+  // Former value: hard-coded CONSULTATION_HISTORY_TAIL_MAX_CHARS = 16_000.
+  // 128k still checkpoints at 16_000 (0.4 × 40_000 budget).
+  assert.equal(consultationHistoryCheckpointChars(128_000), 16_000);
  assert.equal(shouldCheckpoint([{ role: "user", text: "x".repeat(15_999) }], null), false);
  assert.equal(shouldCheckpoint([{ role: "user", text: "x".repeat(16_001) }], null), true);
+  assert.equal(shouldCheckpoint([{ role: "user", text: "x".repeat(2_400) }], null, { contextWindow: 64_000 }), false);
+  assert.equal(shouldCheckpoint([{ role: "user", text: "x".repeat(2_401) }], null, { contextWindow: 64_000 }), true);
 });

 test("checkpoint prompt omits the last question-answer pair", () => {
@@ -108,6 +113,41 @@ test("writeSessionContextSummary abandons when updatedAt does not match", async
  assert.equal(result, "abandoned");
 });

+test("inherited context summary copies owned text and skips foreign or empty sources", async () => {
+  const source = {
+    version: 1 as const,
+    text: "已问过的问题\n事业时机",
+    throughRequestId: "a1",
+    throughMessageIndex: 3,
+    messageCount: 4,
+    updatedAt: "2026-09-15T00:00:00.000Z",
+  };
+  const copied = await resolveInheritedContextSummary({
+    continuedFromSessionId: "11111111-1111-4111-8111-111111111111",
+    loadOwnedSummary: async () => source,
+  });
+  assert.deepEqual(copied, source);
+
+  const foreign = await resolveInheritedContextSummary({
+    continuedFromSessionId: "22222222-2222-4222-8222-222222222222",
+    loadOwnedSummary: async () => null,
+  });
+  assert.equal(foreign, null);
+
+  const empty = await resolveInheritedContextSummary({
+    continuedFromSessionId: "11111111-1111-4111-8111-111111111111",
+    loadOwnedSummary: async () => ({ version: 1, text: "   " }),
+  });
+  assert.equal(empty, null);
+
+  const skipped = await resolveInheritedContextSummary({
+    loadOwnedSummary: async () => {
+      throw new Error("should not load");
+    },
+  });
+  assert.equal(skipped, null);
+});
+
 test("checkpoint writes a new summary when the tail is over budget", async () => {
  const result = await checkpointSessionContextSummary({
    messages: overBudgetConversation(),
@@ -52,6 +52,18 @@ try:
        MIN_SCORING_EVENTS,
    )
    from scripts.vedastro_runtime_context import temporary_timeout_seconds
+    from scripts.vedastro_foreground import (
+        _FOREGROUND_VEDASTRO_EXECUTOR,
+        _FOREGROUND_VEDASTRO_WORKERS,
+        _blocked_foreground_vedastro,
+        _foreground_vedastro_budget_seconds,
+        _foreground_vedastro_join_seconds,
+        _join_foreground_vedastro,
+        _run_foreground_vedastro_gateway,
+        finish_foreground_vedastro,
+        should_include_western_evidence_packet,
+        start_foreground_vedastro,
+    )
 except ModuleNotFoundError:  # pragma: no cover - script execution path
    from local_env import load_local_env
    from rectification_policy import (
@@ -63,6 +75,18 @@ except ModuleNotFoundError:  # pragma: no cover - script execution path
        MIN_SCORING_EVENTS,
    )
    from vedastro_runtime_context import temporary_timeout_seconds
+    from vedastro_foreground import (
+        _FOREGROUND_VEDASTRO_EXECUTOR,
+        _FOREGROUND_VEDASTRO_WORKERS,
+        _blocked_foreground_vedastro,
+        _foreground_vedastro_budget_seconds,
+        _foreground_vedastro_join_seconds,
+        _join_foreground_vedastro,
+        _run_foreground_vedastro_gateway,
+        finish_foreground_vedastro,
+        should_include_western_evidence_packet,
+        start_foreground_vedastro,
+    )
 try:
    from scripts.unified_consultation_orchestrator import FORMAL_DIVISIONS, UnifiedConsultationOrchestrator
 except ModuleNotFoundError:  # pragma: no cover - script execution path
@@ -122,11 +146,6 @@ _ASYNC_JOB_EXECUTOR = ThreadPoolExecutor(
    max_workers=_ASYNC_JOB_WORKERS,
    thread_name_prefix='jyotish-job',
 )
-_FOREGROUND_VEDASTRO_WORKERS = max(int(os.environ.get('JYOTISH_FOREGROUND_VEDASTRO_WORKERS', '2')), 1)
-_FOREGROUND_VEDASTRO_EXECUTOR = ThreadPoolExecutor(
-    max_workers=_FOREGROUND_VEDASTRO_WORKERS,
-    thread_name_prefix='jyotish-vedastro-fg',
-)
 _ASYNC_JOB_CAPACITY = threading.BoundedSemaphore(_ASYNC_JOB_WORKERS + _ASYNC_JOB_QUEUE_SIZE)
 _RATE_LIMIT_LOCK = threading.Lock()
 _RATE_LIMIT_BUCKETS: dict[str, tuple[float, int]] = {}
@@ -442,6 +461,8 @@ def _evaluate_vedastro_minute_sensitive_pair(request, times: list[str]) -> dict:
        try:
            reports.append(future.result(timeout=remaining))
        except FuturesTimeoutError:
+            for pending in futures:
+                pending.cancel()
            return _unevaluated_vedastro_minute_sensitive('vedastro_minute_snapshot_timeout')
        except Exception:
            return _unevaluated_vedastro_minute_sensitive('vedastro_minute_snapshot_error')
@@ -2036,22 +2057,6 @@ _VEDASTRO_COMPACT_DENY_KEYS = {
 }


-def _foreground_vedastro_budget_seconds() -> float:
-    raw = str(os.environ.get('JYOTISH_FOREGROUND_VEDASTRO_BUDGET_SECONDS', '8')).strip()
-    try:
-        return min(max(float(raw), 2.0), 12.0)
-    except ValueError:
-        return 8.0
-
-
-def _foreground_vedastro_join_seconds() -> float:
-    raw = str(os.environ.get('JYOTISH_FOREGROUND_VEDASTRO_JOIN_SECONDS', '1.5')).strip()
-    try:
-        return min(max(float(raw), 0.0), 3.0)
-    except ValueError:
-        return 1.5
-
-
 def _vedastro_natal_signs(raw) -> dict | None:
    if not isinstance(raw, dict):
        return None
@@ -2107,45 +2112,6 @@ def _compact_vedastro_cross_check(vedastro_official: dict, vedastro_gateway: dic
    return compact


-def _blocked_foreground_vedastro(*, reason: str, error_type: str | None = None) -> dict:
-    packet = {
-        'scope': 'vedastro_gateway_run',
-        'status': 'official_blocked',
-        'official_closure_state': 'official_blocked',
-        'official_closure_reason': reason,
-    }
-    if error_type:
-        packet['error_type'] = error_type
-    return packet
-
-
-def _run_foreground_vedastro_gateway(handler, body: dict) -> dict:
-    try:
-        with temporary_timeout_seconds(_foreground_vedastro_budget_seconds()):
-            result = handler._compute_vedastro_gateway_run(body)
-    except Exception as exc:
-        return _blocked_foreground_vedastro(
-            reason='gateway_invocation_error',
-            error_type=type(exc).__name__,
-        )
-    return result if isinstance(result, dict) else _blocked_foreground_vedastro(reason='gateway_invocation_error')
-
-
-def _join_foreground_vedastro(future, *, timeout: float) -> dict:
-    if future is None:
-        return _blocked_foreground_vedastro(reason='foreground_optional_evidence_timeout')
-    try:
-        result = future.result(timeout=timeout)
-    except FuturesTimeoutError:
-        return _blocked_foreground_vedastro(reason='foreground_optional_evidence_timeout')
-    except Exception as exc:
-        return _blocked_foreground_vedastro(
-            reason='gateway_invocation_error',
-            error_type=type(exc).__name__,
-        )
-    return result if isinstance(result, dict) else _blocked_foreground_vedastro(reason='gateway_invocation_error')
-
-
 def _blocked_birth_time_sensitivity(*, error_type: str) -> dict:
    return {
        'schema': 'jyotish.report_birth_time_sensitivity.v1',
@@ -2266,7 +2232,7 @@ def execute_consultation_workflow(
            western_evidence_packet=western_evidence_packet,
            blind=bool(body.get('blind') or body.get('blind_technical_mode')),
        )
-        if western_evidence_packet:
+        if western_evidence_packet and should_include_western_evidence_packet(body, surface=surface):
            result['western_evidence_packet'] = western_evidence_packet
        if body.get('return_high_rigor_shape'):
            result['endpoint'] = 'high_rigor_workflow'
@@ -2288,13 +2254,14 @@ def execute_consultation_workflow(
    rectification = {}
    muhurta_panchanga = {}
    computed_chart = bool(chart)
-    foreground_vedastro_future = None
-    if defer_optional_external_evidence:
-        # Overlap a bounded official gateway with local compute. Main-entry
-        # overview / range scan stay skipped so foreground cannot replay BUG-161.
-        foreground_vedastro_future = _FOREGROUND_VEDASTRO_EXECUTOR.submit(
-            _run_foreground_vedastro_gateway, handler, dict(body),
-        )
+    # Overlap a bounded official gateway with local compute. Main-entry
+    # overview / range scan stay skipped so foreground cannot replay BUG-161.
+    # Same-day snapshot cache skips the submit entirely (BUG-727).
+    vedastro_session = start_foreground_vedastro(
+        handler,
+        dict(body),
+        defer_optional_external_evidence=defer_optional_external_evidence,
+    )

    for step in runtime_planner.get('sync_steps', []):
        if step == 'run_prashna':
@@ -2375,21 +2342,8 @@ def execute_consultation_workflow(
        })
        executed_steps.append('run_thematic_report')
    vedastro_gateway = rectification.get('vedastro_gateway') if isinstance(rectification, dict) else None
-    if defer_optional_external_evidence:
-        vedastro_gateway = _join_foreground_vedastro(
-            foreground_vedastro_future,
-            timeout=_foreground_vedastro_join_seconds(),
-        )
-    elif not isinstance(vedastro_gateway, dict):
-        try:
-            vedastro_gateway = handler._compute_vedastro_gateway_run(body)
-        except Exception as exc:  # Gateway evidence must not block the local chart result.
-            vedastro_gateway = {
-                'scope': 'vedastro_gateway_run',
-                'status': 'official_blocked',
-                'official_closure_reason': 'gateway_invocation_error',
-                'error_type': type(exc).__name__,
-            }
+    if defer_optional_external_evidence or not isinstance(vedastro_gateway, dict):
+        vedastro_gateway = finish_foreground_vedastro(vedastro_session)

    vedastro_official = handler._high_rigor_vedastro_official_summary(chart)
    gateway_raw = (
@@ -2524,7 +2478,6 @@ def execute_consultation_workflow(
        'interpretation_source_runtime_coverage': interpretation_source_runtime_coverage,
        'machine_evidence_packet': machine_evidence_packet,
        'consumer_context': consumer_context,
-        'western_evidence_packet': western_evidence_packet or {},
        'real_case_calibration': real_case_calibration,
        'birth_time_sensitivity': birth_time_sensitivity,
        'runtime_evidence_log': runtime_evidence_log,
@@ -2535,6 +2488,10 @@ def execute_consultation_workflow(
            'domain-relevant routes execute according to the configured sample/network limits.'
        ),
    }
+    if should_include_western_evidence_packet(body, surface=surface):
+        result['western_evidence_packet'] = western_evidence_packet or {}
+    if getattr(vedastro_session, 'meta', None):
+        result['vedastro_snapshot_cache'] = vedastro_session.meta
    if high_rigor:
        result['high_rigor_external_parity'] = {
            'status': 'pass' if external_parity_gate.get('status') == 'pass' else 'blocked',
@@ -75,6 +75,8 @@ CORE_PYTEST_TARGETS = [
    "tests/test_birth_time_journey_contract.py",
    # Freeze scripts/jyotish_api_server.py growth; new features must be modules.
    "tests/test_api_server_growth_contract.py",
+    # Foreground VedAstro snapshot cache + join cancel (BUG-727 / BUG-728).
+    "tests/test_vedastro_snapshot_cache.py",
    # Native seven-governors adapter and the three read-only chart endpoints.
    "tests/test_qizheng_chart_engine.py",
    "tests/test_qizheng_api_productization.py",
@@ -0,0 +1,250 @@
+"""Foreground VedAstro wait, cancel, and snapshot-cache coordination.
+
+Join, budget, and worker count bound the same wall clock, so they are
+declared together and must be changed together.
+
+join: how long the consultation thread waits for the official gateway
+      (default 1.5s, cap 3s).
+budget: how long a worker may keep running after it has started.
+workers: process-wide pool. Extra work queues; join still caps the wait.
+
+A timed-out join must cancel its future so queued work never starts.
+budget <= k * join (k=2) keeps leftover occupancy of an already-running
+worker from stretching later requests past the join cap. The previous
+default budget of 8s with a 1.5s join left cancelled-too-late workers
+holding the two-thread pool for the rest of the 8s.
+"""
+from __future__ import annotations
+
+import os
+import threading
+from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
+from typing import Any
+
+try:
+    from scripts.vedastro_runtime_context import temporary_timeout_seconds
+    from scripts.vedastro_snapshot_cache import (
+        annotate_stale_gateway,
+        is_cacheable_gateway,
+        lookup_snapshot,
+        official_snapshot_reference_date,
+        requires_today_snapshot,
+        store_snapshot,
+    )
+except ModuleNotFoundError:  # pragma: no cover - script execution path
+    from vedastro_runtime_context import temporary_timeout_seconds
+    from vedastro_snapshot_cache import (
+        annotate_stale_gateway,
+        is_cacheable_gateway,
+        lookup_snapshot,
+        official_snapshot_reference_date,
+        requires_today_snapshot,
+        store_snapshot,
+    )
+
+# --- join / budget / workers (one declaration block; change together) ---
+FOREGROUND_VEDASTRO_JOIN_SECONDS_DEFAULT = 1.5
+FOREGROUND_VEDASTRO_JOIN_SECONDS_MAX = 3.0
+FOREGROUND_VEDASTRO_BUDGET_JOIN_RATIO = 2.0
+FOREGROUND_VEDASTRO_WORKERS_DEFAULT = 2
+# ----------------------------------------------------------------------
+
+_FOREGROUND_VEDASTRO_WORKERS = max(
+    int(os.environ.get("JYOTISH_FOREGROUND_VEDASTRO_WORKERS", str(FOREGROUND_VEDASTRO_WORKERS_DEFAULT))),
+    1,
+)
+_FOREGROUND_VEDASTRO_EXECUTOR = ThreadPoolExecutor(
+    max_workers=_FOREGROUND_VEDASTRO_WORKERS,
+    thread_name_prefix="jyotish-vedastro-fg",
+)
+
+
+def _foreground_vedastro_join_seconds() -> float:
+    raw = str(os.environ.get("JYOTISH_FOREGROUND_VEDASTRO_JOIN_SECONDS", str(FOREGROUND_VEDASTRO_JOIN_SECONDS_DEFAULT))).strip()
+    try:
+        return min(max(float(raw), 0.0), FOREGROUND_VEDASTRO_JOIN_SECONDS_MAX)
+    except ValueError:
+        return FOREGROUND_VEDASTRO_JOIN_SECONDS_DEFAULT
+
+
+def _foreground_vedastro_budget_seconds() -> float:
+    join = _foreground_vedastro_join_seconds()
+    cap = FOREGROUND_VEDASTRO_BUDGET_JOIN_RATIO * join
+    raw = str(os.environ.get("JYOTISH_FOREGROUND_VEDASTRO_BUDGET_SECONDS", "")).strip()
+    if not raw:
+        return cap
+    try:
+        budget = float(raw)
+    except ValueError:
+        return cap
+    if budget < 0:
+        return cap
+    return min(budget, cap)
+
+
+def _blocked_foreground_vedastro(*, reason: str, error_type: str | None = None) -> dict:
+    packet = {
+        "scope": "vedastro_gateway_run",
+        "status": "official_blocked",
+        "official_closure_state": "official_blocked",
+        "official_closure_reason": reason,
+    }
+    if error_type:
+        packet["error_type"] = error_type
+    return packet
+
+
+def _run_foreground_vedastro_gateway(handler, body: dict, cancel_event: threading.Event | None = None) -> dict:
+    if cancel_event is not None and cancel_event.is_set():
+        return _blocked_foreground_vedastro(reason="foreground_optional_evidence_timeout")
+    try:
+        with temporary_timeout_seconds(_foreground_vedastro_budget_seconds()):
+            result = handler._compute_vedastro_gateway_run(body)
+    except Exception as exc:
+        return _blocked_foreground_vedastro(
+            reason="gateway_invocation_error",
+            error_type=type(exc).__name__,
+        )
+    return result if isinstance(result, dict) else _blocked_foreground_vedastro(reason="gateway_invocation_error")
+
+
+def _run_foreground_vedastro_gateway_and_store(
+    handler,
+    body: dict,
+    cancel_event: threading.Event | None = None,
+) -> dict:
+    result = _run_foreground_vedastro_gateway(handler, body, cancel_event)
+    if is_cacheable_gateway(result):
+        try:
+            store_snapshot(body, result)
+        except OSError:
+            pass
+    return result
+
+
+def _join_foreground_vedastro(future, *, timeout: float, cancel_event: threading.Event | None = None) -> dict:
+    if future is None:
+        return _blocked_foreground_vedastro(reason="foreground_optional_evidence_timeout")
+    try:
+        result = future.result(timeout=timeout)
+    except FuturesTimeoutError:
+        if cancel_event is not None:
+            cancel_event.set()
+        future.cancel()
+        return _blocked_foreground_vedastro(reason="foreground_optional_evidence_timeout")
+    except Exception as exc:
+        return _blocked_foreground_vedastro(
+            reason="gateway_invocation_error",
+            error_type=type(exc).__name__,
+        )
+    return result if isinstance(result, dict) else _blocked_foreground_vedastro(reason="gateway_invocation_error")
+
+
+def should_include_western_evidence_packet(body: dict | None, *, surface: str = "") -> bool:
+    payload = body if isinstance(body, dict) else {}
+    if payload.get("include_western_evidence_packet") or payload.get("return_western_evidence_packet"):
+        return True
+    if payload.get("return_high_rigor_shape"):
+        return True
+    if isinstance(payload.get("western_oracle_payload"), dict) or isinstance(payload.get("western_astrology_oracle"), dict):
+        return True
+    if isinstance(payload.get("western_evidence_packet"), dict):
+        return True
+    return str(surface or "") in {"skill_mcp", "professional_reading_web", "mcp"}
+
+
+class ForegroundVedastroSession:
+    def __init__(self, handler, body: dict, *, defer: bool) -> None:
+        self.handler = handler
+        self.body = dict(body)
+        self.defer = bool(defer)
+        self.cached_gateway: dict | None = None
+        self.future = None
+        self.cancel_event = threading.Event()
+        self.meta: dict[str, Any] = {}
+
+    def start(self) -> "ForegroundVedastroSession":
+        today = official_snapshot_reference_date(self.body)
+        hit = lookup_snapshot(self.body, today=today)
+        if hit is not None:
+            record = hit["record"]
+            freshness = hit["freshness"]
+            gateway = record["gateway"]
+            if freshness == "stale":
+                gateway = annotate_stale_gateway(
+                    gateway,
+                    reference_date=str(record.get("reference_date") or ""),
+                    served_on_utc_date=today,
+                )
+                refresh_body = dict(self.body)
+                refresh_body["reference_date"] = today
+                refresh_body["today"] = today
+                refresh_body["current_date"] = today
+                self.future = _FOREGROUND_VEDASTRO_EXECUTOR.submit(
+                    _run_foreground_vedastro_gateway_and_store,
+                    self.handler,
+                    refresh_body,
+                    None,
+                )
+            self.cached_gateway = gateway
+            self.meta = {
+                "freshness": freshness,
+                "reference_date": str(record.get("reference_date") or today),
+                "served_on_utc_date": today,
+                "refresh_submitted": freshness == "stale",
+            }
+            return self
+        self.meta = {
+            "freshness": "miss",
+            "reference_date": today,
+            "served_on_utc_date": today,
+            "refresh_submitted": False,
+            "require_today": requires_today_snapshot(self.body),
+        }
+        if self.defer:
+            self.future = _FOREGROUND_VEDASTRO_EXECUTOR.submit(
+                _run_foreground_vedastro_gateway_and_store,
+                self.handler,
+                dict(self.body),
+                self.cancel_event,
+            )
+        return self
+
+    def finish(self) -> dict:
+        if self.cached_gateway is not None:
+            return self.cached_gateway
+        if self.defer:
+            return _join_foreground_vedastro(
+                self.future,
+                timeout=_foreground_vedastro_join_seconds(),
+                cancel_event=self.cancel_event,
+            )
+        try:
+            result = self.handler._compute_vedastro_gateway_run(self.body)
+        except Exception as exc:
+            return _blocked_foreground_vedastro(
+                reason="gateway_invocation_error",
+                error_type=type(exc).__name__,
+            )
+        if not isinstance(result, dict):
+            return _blocked_foreground_vedastro(reason="gateway_invocation_error")
+        if is_cacheable_gateway(result):
+            try:
+                store_snapshot(self.body, result)
+            except OSError:
+                pass
+        return result
+
+
+def start_foreground_vedastro(handler, body: dict, *, defer_optional_external_evidence: bool) -> ForegroundVedastroSession:
+    return ForegroundVedastroSession(
+        handler,
+        body,
+        defer=defer_optional_external_evidence,
+    ).start()
+
+
+def finish_foreground_vedastro(session: ForegroundVedastroSession | None) -> dict:
+    if session is None:
+        return _blocked_foreground_vedastro(reason="foreground_optional_evidence_timeout")
+    return session.finish()
@@ -0,0 +1,228 @@
+"""Disk cache for foreground VedAstro gateway snapshots.
+
+Keyed by birth data + ayanamsa + node + UTC reference date. This is a
+separate store from ``_api_chart_cache`` (BUG-161): different directory
+and a different key function. Freshness is the reference date itself
+plus a 7-day stale window — there is no independent TTL environment
+variable.
+
+Filenames are sha256 hex only. Cache files must not contain names,
+emails, or user ids.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import tempfile
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+CACHE_SCHEMA = "vedastro_snapshot_cache.v1"
+MAX_STALE_DAYS = 7
+_SHA256_NAME = re.compile(r"^[0-9a-f]{64}\.json$")
+_IDENTITY_KEYS = {
+    "name",
+    "email",
+    "user_id",
+    "userid",
+    "user_email",
+    "session_id",
+    "sessionid",
+    "full_name",
+    "display_name",
+}
+
+
+def snapshot_cache_dir() -> Path:
+    raw = str(os.environ.get("JYOTISH_VEDASTRO_SNAPSHOT_CACHE_DIR") or "").strip()
+    path = Path(raw) if raw else ROOT / "scratch" / "local" / "vedastro_snapshot_cache"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def official_snapshot_reference_date(case: dict[str, Any] | None) -> str:
+    """Same date rule as ``vedastro_service_adapter._official_snapshot_reference_date``.
+
+    Duplicated so this module does not import the adapter (and its optional
+    network stack) at cache-lookup time.
+    """
+    payload = case if isinstance(case, dict) else {}
+    for key in ("reference_date", "today", "transit_date", "current_date"):
+        value = payload.get(key)
+        if not value:
+            continue
+        raw = str(value)[:10]
+        try:
+            datetime.strptime(raw, "%Y-%m-%d")
+            return raw
+        except ValueError:
+            continue
+    return datetime.utcnow().strftime("%Y-%m-%d")
+
+
+def requires_today_snapshot(body: dict[str, Any] | None) -> bool:
+    payload = body if isinstance(body, dict) else {}
+    entrypoint = str(payload.get("entrypoint") or payload.get("consult_entrypoint") or "").strip()
+    return entrypoint == "daily_starlanguage"
+
+
+def snapshot_cache_key(body: dict[str, Any] | None, *, reference_date: str) -> str:
+    payload = body if isinstance(body, dict) else {}
+    ayanamsa = (
+        payload.get("ayanamsa")
+        or payload.get("ayanamsa_name")
+        or payload.get("ayanamsa_policy")
+        or "raman"
+    )
+    node = payload.get("node_mode") or payload.get("nodeMode") or "mean"
+    material = {
+        "year": payload.get("year"),
+        "month": payload.get("month"),
+        "day": payload.get("day"),
+        "hour": payload.get("hour"),
+        "minute": payload.get("minute"),
+        "second": payload.get("second", 0),
+        "lat": payload.get("lat"),
+        "lon": payload.get("lon"),
+        "tz": payload.get("tz"),
+        "ayanamsa_policy": str(ayanamsa).strip().lower(),
+        "node_policy": str(node).strip().lower(),
+        "reference_date": str(reference_date)[:10],
+    }
+    canonical = json.dumps(material, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def snapshot_cache_path(cache_key: str) -> Path:
+    if not re.fullmatch(r"[0-9a-f]{64}", cache_key):
+        raise ValueError("vedastro snapshot cache key must be sha256 hex")
+    return snapshot_cache_dir() / f"{cache_key}.json"
+
+
+def is_cacheable_gateway(packet: Any) -> bool:
+    if not isinstance(packet, dict):
+        return False
+    state = packet.get("official_closure_state") or packet.get("status")
+    if state != "official_verified":
+        return False
+    raw = packet.get("official_raw_response") or packet.get("raw_response")
+    return bool(raw)
+
+
+def _strip_identity(value: Any) -> Any:
+    if isinstance(value, dict):
+        cleaned = {}
+        for key, item in value.items():
+            if str(key).strip().lower() in _IDENTITY_KEYS:
+                continue
+            cleaned[key] = _strip_identity(item)
+        return cleaned
+    if isinstance(value, list):
+        return [_strip_identity(item) for item in value]
+    return value
+
+
+def _load_record(cache_key: str) -> dict[str, Any] | None:
+    path = snapshot_cache_path(cache_key)
+    if not _SHA256_NAME.match(path.name) or not path.is_file():
+        return None
+    try:
+        record = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(record, dict) or record.get("schema") != CACHE_SCHEMA:
+        return None
+    gateway = record.get("gateway")
+    if not isinstance(gateway, dict):
+        return None
+    reference_date = str(record.get("reference_date") or "")[:10]
+    try:
+        datetime.strptime(reference_date, "%Y-%m-%d")
+    except ValueError:
+        return None
+    return record
+
+
+def lookup_snapshot(
+    body: dict[str, Any] | None,
+    *,
+    today: str | None = None,
+    require_today: bool | None = None,
+) -> dict[str, Any] | None:
+    payload = body if isinstance(body, dict) else {}
+    served = today or official_snapshot_reference_date(payload)
+    must_be_today = requires_today_snapshot(payload) if require_today is None else bool(require_today)
+    today_key = snapshot_cache_key(payload, reference_date=served)
+    record = _load_record(today_key)
+    if record is not None:
+        return {
+            "freshness": "fresh",
+            "record": record,
+            "served_on_utc_date": served,
+        }
+    if must_be_today:
+        return None
+    current = datetime.strptime(served, "%Y-%m-%d").date()
+    for days in range(1, MAX_STALE_DAYS + 1):
+        past = (current - timedelta(days=days)).isoformat()
+        record = _load_record(snapshot_cache_key(payload, reference_date=past))
+        if record is None:
+            continue
+        return {
+            "freshness": "stale",
+            "record": record,
+            "served_on_utc_date": served,
+        }
+    return None
+
+
+def store_snapshot(
+    body: dict[str, Any] | None,
+    gateway: dict[str, Any],
+    *,
+    reference_date: str | None = None,
+) -> dict[str, Any] | None:
+    if not is_cacheable_gateway(gateway):
+        return None
+    payload = body if isinstance(body, dict) else {}
+    stored_date = (reference_date or official_snapshot_reference_date(payload))[:10]
+    cache_key = snapshot_cache_key(payload, reference_date=stored_date)
+    record = {
+        "schema": CACHE_SCHEMA,
+        "cache_key": cache_key,
+        "reference_date": stored_date,
+        "stored_at": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "gateway": _strip_identity(gateway),
+    }
+    path = snapshot_cache_path(cache_key)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    encoded = json.dumps(record, ensure_ascii=False, sort_keys=True)
+    fd, tmp_name = tempfile.mkstemp(prefix=f"{cache_key}.", suffix=".tmp", dir=str(path.parent))
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(encoded)
+        os.replace(tmp_name, path)
+    except Exception:
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        raise
+    return record
+
+
+def annotate_stale_gateway(gateway: dict[str, Any], *, reference_date: str, served_on_utc_date: str) -> dict[str, Any]:
+    """Shallow copy that shows which day a stale snapshot is from.
+
+    Does not change ``official_closure_state`` / ``status`` — a previously
+    delivered official layer stays whatever it was (BUG-301).
+    """
+    packet = dict(gateway)
+    packet["snapshot_reference_date"] = reference_date
+    packet["snapshot_freshness"] = "stale"
+    packet["snapshot_served_on_utc_date"] = served_on_utc_date
+    return packet
@@ -5,6 +5,8 @@ from __future__ import annotations
 import sys
 from pathlib import Path

+import pytest
+
 ROOT = Path(__file__).resolve().parents[1]
 SCRIPTS = str(ROOT / "scripts")
 WORKBUDDY_SKILL_SCRIPTS = ".workbuddy/skills/jyotish-vedic-astrology/scripts"
@@ -38,6 +40,12 @@ def pytest_runtest_setup() -> None:
    ensure_project_scripts_first()


+@pytest.fixture(autouse=True)
+def _isolate_vedastro_snapshot_cache(tmp_path_factory, monkeypatch) -> None:
+    cache_dir = tmp_path_factory.mktemp("vedastro_snapshot_cache")
+    monkeypatch.setenv("JYOTISH_VEDASTRO_SNAPSHOT_CACHE_DIR", str(cache_dir))
+
+
 def pytest_collection_modifyitems(items) -> None:
    for item in items:
        if item.fspath.basename == "test_api_server_security.py" and item.name.startswith(SLOW_API_SECURITY_PREFIXES):
@@ -1,30 +1,81 @@
-"""Freeze scripts/jyotish_api_server.py growth.
+"""Freeze coupling in scripts/jyotish_api_server.py.

 New endpoints and features must live in new modules and be thinly registered
-from the main file. This cap is the live line count at freeze (11063 on
-2026-09-02, via `wc -l`) plus 300 lines of bugfix slack.
+from the main file. Line count is only a coarse guardrail; the live gates are
+JyotishAPIHandler method count and JyotishAPIHandler.__new__ forgery sites.
 """

 from __future__ import annotations

+import re
+from collections import Counter
 from pathlib import Path

 ROOT = Path(__file__).resolve().parents[1]
 API_SERVER = ROOT / "scripts" / "jyotish_api_server.py"
 AGENTS = ROOT / "AGENTS.md"

-# Live `wc -l scripts/jyotish_api_server.py` at freeze. New features must not
-# consume this budget; open a module instead.
-JYOTISH_API_SERVER_LINE_COUNT_BASELINE = 11063
+# Live `wc -l scripts/jyotish_api_server.py` equivalent:
+# Path.read_bytes().count(b"\n"), measured 2026-09-16 on origin/staging @ 51a65d92.
+# New features must not consume this budget; open a module instead.
+JYOTISH_API_SERVER_LINE_COUNT_BASELINE = 11291
 JYOTISH_API_SERVER_LINE_COUNT_CAP = JYOTISH_API_SERVER_LINE_COUNT_BASELINE + 300

+# Whole-file indent match `^    (?:async )?def \w+`, same count as
+# TASK-freeze-metric-change-20260915 §1. Measured 2026-09-16 @ 51a65d92.
+JYOTISH_API_HANDLER_METHOD_COUNT_BASELINE = 225
+
+# `JyotishAPIHandler.__new__` in scripts/ and tests/ `*.py`, excluding this file.
+# Measured 2026-09-16 @ 51a65d92: scripts/ production forgeries = 4, tests/ = 29.
+JYOTISH_API_HANDLER_NEW_COUNT_BASELINE = 33
+
+HANDLER_METHOD_RE = re.compile(r"^    (?:async )?def \w+", re.MULTILINE)
+NEW_MARKER = "JyotishAPIHandler.__new__"
+
+
+def _handler_method_count(source: str) -> int:
+    return len(HANDLER_METHOD_RE.findall(source))
+
+
+def _new_hits() -> Counter[str]:
+    hits: Counter[str] = Counter()
+    skip = Path(__file__).resolve()
+    for folder in (ROOT / "scripts", ROOT / "tests"):
+        for path in sorted(folder.rglob("*.py")):
+            if path.resolve() == skip:
+                continue
+            count = path.read_text(encoding="utf-8").count(NEW_MARKER)
+            if count:
+                hits[path.relative_to(ROOT).as_posix()] = count
+    return hits
+
+
+def test_jyotish_api_handler_method_count_must_not_grow() -> None:
+    source = API_SERVER.read_text(encoding="utf-8")
+    count = _handler_method_count(source)
+    assert count <= JYOTISH_API_HANDLER_METHOD_COUNT_BASELINE, (
+        f"{API_SERVER.as_posix()} has {count} four-space def methods; "
+        f"cap is {JYOTISH_API_HANDLER_METHOD_COUNT_BASELINE}. Move behaviour "
+        "into a dedicated module; thinly registered from this file."
+    )
+
+
+def test_jyotish_api_handler_new_count_must_not_grow() -> None:
+    hits = _new_hits()
+    total = sum(hits.values())
+    listed = ", ".join(f"{path}:{count}" for path, count in sorted(hits.items()))
+    assert total <= JYOTISH_API_HANDLER_NEW_COUNT_BASELINE, (
+        f"{NEW_MARKER} appears {total} times under scripts/ and tests/; "
+        f"cap is {JYOTISH_API_HANDLER_NEW_COUNT_BASELINE}. Hits: {listed}"
+    )
+

 def test_jyotish_api_server_must_not_grow_beyond_bugfix_slack() -> None:
    line_count = API_SERVER.read_bytes().count(b"\n")
    assert line_count <= JYOTISH_API_SERVER_LINE_COUNT_CAP, (
        f"{API_SERVER.as_posix()} has {line_count} lines; cap is "
        f"{JYOTISH_API_SERVER_LINE_COUNT_CAP} ({JYOTISH_API_SERVER_LINE_COUNT_BASELINE} "
-        "baseline + 300 bugfix slack). New endpoints and features must be new "
+        "baseline + 300 coarse guardrail). New endpoints and features must be new "
        "modules, thinly registered from this file."
    )

@@ -2,17 +2,25 @@

 Golden payload in tests/golden/rectification_engine_memoization_v1.json was
 produced from origin/staging @ a8d29d1b before any memoization landed.
+
+Do not compare that payload with a whole-structure ``==``. Cross-machine
+libm / pyswisseph rounding already drifted ``margin_percent`` by 1.1e-3
+(TASK-rectification-engine-memoization-fix-20260915). Equivalence of the
+four cached layers is proven in-process instead.
 """

 from __future__ import annotations

 import inspect
 import json
+import math
 from datetime import date, datetime
 from pathlib import Path
 from typing import Any
 from unittest.mock import patch

+import pytest
+
 from scripts.active_rectification_event_engine import (
    _candidate_datetimes,
    _controlled_transit_rules,
@@ -35,6 +43,20 @@ GOLDEN_PATH = ROOT / "tests" / "golden" / "rectification_engine_memoization_v1.j
 FROZEN_TODAY = date(2026, 9, 16)
 TIMING_KEYS = frozenset({"column_compare_ms"})
 SOURCE_COMMIT = "a8d29d1b6cc37ff865ddec6c8bccdf9aa889ee53"
+CACHE_LAYER_KEYS = (
+    "ashtakavarga_result",
+    "shadbala_result",
+    "vimshottari_timeline",
+    "narayana_periods",
+)
+# TASK-rectification-engine-memoization-fix-20260915 §2 measured max
+# cross-machine drift of 1.1e-3 on decision_receipt.margin_percent
+# (5.2995 vs golden 5.3006). Candidate scores, already rounded to 4
+# decimals, drifted by 1 ulp (1.0e-4). Tolerance is the wider of
+# abs=2e-3 and rel=5e-4 so 1.1e-3 still passes while a 1e-2 mutation
+# (the reverse test below) fails.
+GOLDEN_FLOAT_ABS = 2e-3
+GOLDEN_FLOAT_REL = 5e-4


 def public_score_request() -> dict[str, Any]:
@@ -117,11 +139,102 @@ def _count_calls(monkeypatch, owner: Any, name: str, *, from_engine: bool = Fals
    return counter


+def _is_json_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _assert_tiered_equal(actual: Any, expected: Any, *, path: str) -> None:
+    if isinstance(expected, dict):
+        assert isinstance(actual, dict), path
+        assert set(actual) == set(expected), f"{path} keys {set(actual)!r} != {set(expected)!r}"
+        for key in expected:
+            _assert_tiered_equal(actual[key], expected[key], path=f"{path}.{key}")
+        return
+    if isinstance(expected, list):
+        assert isinstance(actual, list), path
+        assert len(actual) == len(expected), f"{path} length {len(actual)} != {len(expected)}"
+        for index, (left, right) in enumerate(zip(actual, expected)):
+            _assert_tiered_equal(left, right, path=f"{path}[{index}]")
+        return
+    if isinstance(expected, int) and isinstance(actual, int) and not isinstance(expected, bool) and not isinstance(actual, bool):
+        assert actual == expected, f"{path}: {actual!r} != {expected!r}"
+        return
+    if _is_json_number(expected) or _is_json_number(actual):
+        left = float(actual)
+        right = float(expected)
+        tolerance = max(GOLDEN_FLOAT_ABS, GOLDEN_FLOAT_REL * abs(right))
+        assert math.isclose(left, right, rel_tol=0.0, abs_tol=tolerance), (
+            f"{path}: {left!r} vs {right!r} exceeds {tolerance}"
+        )
+        return
+    assert actual == expected, f"{path}: {actual!r} != {expected!r}"
+
+
+def _assert_memoization_payloads(actual: dict[str, Any], expected: dict[str, Any]) -> None:
+    _assert_tiered_equal(actual["candidate_scores"], expected["candidate_scores"], path="candidate_scores")
+    _assert_tiered_equal(actual["decision_receipt"], expected["decision_receipt"], path="decision_receipt")
+
+
+def _event_engine_request() -> dict[str, Any]:
+    """Dated events for compute_event_candidate_rows (not the v5 score payload)."""
+    return {
+        "birth_date": "1990-01-01",
+        "start_time": "12:00",
+        "end_time": "12:02",
+        "lat": 39.9,
+        "lon": 116.4,
+        "tz": 8,
+        "events": [
+            {
+                "id": "00000000-0000-4000-8000-000000000001",
+                "domain": "education",
+                "event_kind": "education_start",
+                "date": "2008-07-01",
+                "precision": "day",
+                "summary": "入学",
+            },
+            {
+                "id": "00000000-0000-4000-8000-000000000002",
+                "domain": "career",
+                "event_kind": "career_entry",
+                "date": "2012-06-15",
+                "precision": "day",
+                "summary": "入职",
+            },
+        ],
+    }
+
+
+def _contexts_with_layer_cache_cleared(contexts: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    cleared: list[dict[str, Any]] = []
+    for context in contexts:
+        clone = dict(context)
+        for key in CACHE_LAYER_KEYS:
+            clone[key] = None
+        cleared.append(clone)
+    return cleared
+
+
 def test_score_candidates_matches_baseline_golden() -> None:
    expected = json.loads(GOLDEN_PATH.read_text(encoding="utf-8"))
    actual = json.loads(json.dumps(_golden_payload(), ensure_ascii=True))
-    assert actual["candidate_scores"] == expected["candidate_scores"]
-    assert actual["decision_receipt"] == expected["decision_receipt"]
+    _assert_memoization_payloads(actual, expected)
+
+
+def test_golden_float_shift_of_1e_minus_2_fails() -> None:
+    expected = json.loads(GOLDEN_PATH.read_text(encoding="utf-8"))
+    mutated = json.loads(json.dumps(expected))
+    mutated["candidate_scores"][0]["score"] += 1e-2
+    with pytest.raises(AssertionError):
+        _assert_memoization_payloads(expected, mutated)
+
+
+def test_golden_discrete_field_mismatch_fails() -> None:
+    expected = json.loads(GOLDEN_PATH.read_text(encoding="utf-8"))
+    mutated = json.loads(json.dumps(expected))
+    mutated["candidate_scores"][0]["time"] = "99:99"
+    with pytest.raises(AssertionError):
+        _assert_memoization_payloads(expected, mutated)


 def test_shadbala_verified_fields_match_with_and_without_birth_minute() -> None:
@@ -372,3 +485,51 @@ def test_compute_event_candidate_rows_reuses_static_context_without_mutating_it(
    assert len(rows) == 2
    assert [frozenset(context) for context in contexts] == original_keys
    assert all("_transit_chart_cache" not in context for context in contexts)
+
+
+def test_cached_static_context_matches_uncached_fallback(monkeypatch) -> None:
+    request = _event_engine_request()
+    cached = [
+        build_candidate_static_context(request, candidate)
+        for candidate in _candidate_datetimes(request)
+    ]
+    assert len(cached) >= 2
+    assert len(request["events"]) >= 2
+    for context in cached:
+        for key in CACHE_LAYER_KEYS:
+            assert context.get(key) is not None
+    uncached = _contexts_with_layer_cache_cleared(cached)
+    for context in uncached:
+        for key in CACHE_LAYER_KEYS:
+            assert context[key] is None
+    calls = _count_calls(monkeypatch, event_engine.shadbala, "calc_shadbala")
+    rows_cached = compute_event_candidate_rows(request, static_contexts=cached)
+    cached_calls = calls[0]
+    rows_uncached = compute_event_candidate_rows(request, static_contexts=uncached)
+    uncached_calls = calls[0] - cached_calls
+    assert rows_cached == rows_uncached
+    assert cached_calls == 0
+    assert uncached_calls > cached_calls
+    assert uncached_calls >= len(cached) * len(request["events"])
+
+
+def test_poisoned_static_cache_diverges_from_live_rows() -> None:
+    request = _event_engine_request()
+    cached = [
+        build_candidate_static_context(request, candidate)
+        for candidate in _candidate_datetimes(request)
+    ]
+    rows_cached = compute_event_candidate_rows(request, static_contexts=cached)
+    poisoned = [dict(context) for context in cached]
+    poisoned[0]["shadbala_result"] = {
+        "planets": {
+            name: {
+                "sthana_bala": {"total": 0.0},
+                "drik_bala": 0.0,
+                "naisargika_bala": 0.0,
+            }
+            for name in ("Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn")
+        }
+    }
+    rows_poisoned = compute_event_candidate_rows(request, static_contexts=poisoned)
+    assert rows_poisoned != rows_cached
@@ -0,0 +1,350 @@
+"""BUG-727 / BUG-728: foreground VedAstro snapshot cache, cancel, and on-demand western packet."""
+from __future__ import annotations
+
+import json
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import pytest
+
+from scripts import jyotish_api_server
+from scripts import vedastro_foreground as foreground
+from scripts.jyotish_api_server import JyotishAPIHandler
+from scripts.vedastro_snapshot_cache import (
+    lookup_snapshot,
+    snapshot_cache_dir,
+    snapshot_cache_key,
+    snapshot_cache_path,
+    store_snapshot,
+)
+
+
+def _handler() -> JyotishAPIHandler:
+    return JyotishAPIHandler.__new__(JyotishAPIHandler)
+
+
+def _verified_gateway(*, request_id: str, reference_date: str) -> dict:
+    return {
+        "scope": "vedastro_gateway_run",
+        "status": "official_verified",
+        "official_closure_state": "official_verified",
+        "official_raw_response": {
+            "request_id": request_id,
+            "natal": {"sun": "Leo", "moon": "Taurus", "ascendant": "Cancer"},
+            "reference_date": reference_date,
+        },
+    }
+
+
+def _fake_chart() -> dict:
+    return {
+        "success": True,
+        "birth_info": {"date": "1997-08-08", "time": "05:00", "tz": 8},
+        "ascendant": {"lon": 92.0, "sign": "Cancer", "sign_idx": 3},
+        "planets": {},
+        "dasha": {"periods": [{"lord": "Sun", "start": "2026-01-01", "end": "2027-01-01"}]},
+        "modules": {
+            "varga_full": {"D9": {}, "D10": {}},
+            "arudha_padas": {"A10": {}, "UL": {}},
+            "narayana_dasha": {"periods": []},
+            "ashtakavarga": {"sav": []},
+            "kp_cusps": {"houses": []},
+        },
+        "special_lagnas": {"precision": "sunrise_correct"},
+    }
+
+
+def _stub_local(monkeypatch, handler: JyotishAPIHandler, gateway) -> None:
+    monkeypatch.setattr(handler, "_compute_chart", lambda body: _fake_chart())
+    monkeypatch.setattr(
+        handler,
+        "_compute_rectification_gate",
+        lambda body: {
+            "success": True,
+            "summary": {"recommended_events": [], "warned": [], "disabled": []},
+        },
+    )
+    monkeypatch.setattr(
+        handler,
+        "_compute_thematic_report",
+        lambda body: {"success": True, "endpoint": "thematic_report", "themes": {}},
+    )
+    monkeypatch.setattr(handler, "_compute_vedastro_gateway_run", gateway)
+
+
+def _body(*, reference_date: str, extra: dict | None = None) -> dict:
+    payload = {
+        "entry_mode": "direct_chart",
+        "question": "请直接排盘并重点看事业",
+        "theme": ["career"],
+        "year": 1997,
+        "month": 8,
+        "day": 8,
+        "hour": 5,
+        "minute": 0,
+        "lat": 36.420487,
+        "lon": 114.209936,
+        "tz": 8,
+        "reference_date": reference_date,
+        "today": reference_date,
+        "current_date": reference_date,
+        "western_mode": False,
+        "defer_optional_external_evidence": True,
+    }
+    if extra:
+        payload.update(extra)
+    return payload
+
+
+@pytest.fixture
+def snapshot_cache(tmp_path, monkeypatch):
+    cache_dir = tmp_path / "vedastro_snapshot_cache"
+    monkeypatch.setenv("JYOTISH_VEDASTRO_SNAPSHOT_CACHE_DIR", str(cache_dir))
+    return cache_dir
+
+
+def test_snapshot_cache_dir_is_not_api_chart_cache_dir(snapshot_cache) -> None:
+    chart_dir = jyotish_api_server._api_chart_cache_dir()
+    snap_dir = snapshot_cache_dir()
+    assert snap_dir.resolve() != chart_dir.resolve()
+    assert snap_dir.name == "vedastro_snapshot_cache"
+    assert chart_dir.name == "api_chart_cache"
+    assert snapshot_cache_key is not jyotish_api_server._api_chart_cache_key
+
+
+def test_snapshot_cache_key_differs_from_api_chart_cache_key() -> None:
+    body = _body(reference_date="2026-09-15")
+    snap_key = snapshot_cache_key(body, reference_date="2026-09-15")
+    chart_key = jyotish_api_server._api_chart_cache_key(
+        jyotish_api_server._build_api_chart_cache_payload(body)
+    )
+    assert snap_key != chart_key
+    assert len(snap_key) == 64
+    assert "1997" not in snap_key
+    assert "36.420487" not in snap_key
+    assert snapshot_cache_path(snap_key).name == f"{snap_key}.json"
+
+
+def test_cache_file_strips_identity_and_keeps_hash_filename(snapshot_cache) -> None:
+    body = _body(reference_date="2026-09-15")
+    packet = _verified_gateway(request_id="keep-me", reference_date="2026-09-15")
+    packet["name"] = "Secret Person"
+    packet["email"] = "user@example.com"
+    packet["user_id"] = "usr_123"
+    stored = store_snapshot(body, packet, reference_date="2026-09-15")
+    assert stored is not None
+    path = snapshot_cache_path(stored["cache_key"])
+    text = path.read_text(encoding="utf-8")
+    assert "Secret Person" not in text
+    assert "user@example.com" not in text
+    assert "usr_123" not in text
+    assert "keep-me" in text
+    assert path.name.endswith(".json")
+    assert "1997" not in path.name
+
+
+def test_second_same_day_consultation_skips_gateway_and_urlopen(snapshot_cache, monkeypatch) -> None:
+    handler = _handler()
+    calls = {"gateway": 0, "urlopen": 0}
+
+    def counting_gateway(body):
+        calls["gateway"] += 1
+        return _verified_gateway(request_id="same-day", reference_date=body.get("reference_date"))
+
+    def counting_urlopen(*_args, **_kwargs):
+        calls["urlopen"] += 1
+        raise AssertionError("urlopen must not run when the gateway is stubbed")
+
+    _stub_local(monkeypatch, handler, counting_gateway)
+    monkeypatch.setattr("urllib.request.urlopen", counting_urlopen)
+
+    body = _body(reference_date="2026-09-15")
+    first = handler._compute_consultation_workflow(body)
+    second = handler._compute_consultation_workflow(body)
+
+    assert calls["gateway"] == 1
+    assert calls["urlopen"] == 0
+    assert first["vedastro_gateway"] == second["vedastro_gateway"]
+    assert first["vedastro_snapshot_cache"]["freshness"] == "miss"
+    assert second["vedastro_snapshot_cache"]["freshness"] == "fresh"
+
+
+def test_next_day_serves_stale_and_refreshes_without_waiting(snapshot_cache, monkeypatch) -> None:
+    handler = _handler()
+    yesterday = "2026-09-14"
+    today = "2026-09-15"
+    store_snapshot(
+        _body(reference_date=yesterday),
+        _verified_gateway(request_id="yesterday", reference_date=yesterday),
+        reference_date=yesterday,
+    )
+    release = threading.Event()
+    calls = {"gateway": 0}
+
+    def slow_today(body):
+        calls["gateway"] += 1
+        release.wait(timeout=2.0)
+        return _verified_gateway(request_id="today", reference_date=today)
+
+    _stub_local(monkeypatch, handler, slow_today)
+    started = time.monotonic()
+    result = handler._compute_consultation_workflow(_body(reference_date=today))
+    elapsed = time.monotonic() - started
+    release.set()
+
+    assert elapsed < 1.0
+    assert result["vedastro_snapshot_cache"]["freshness"] == "stale"
+    assert result["vedastro_snapshot_cache"]["reference_date"] == yesterday
+    assert result["vedastro_gateway"]["snapshot_reference_date"] == yesterday
+    assert result["vedastro_gateway"]["official_closure_state"] == "official_verified"
+    assert result["vedastro_gateway"]["official_raw_response"]["request_id"] == "yesterday"
+    deadline = time.monotonic() + 2.0
+    while calls["gateway"] < 1 and time.monotonic() < deadline:
+        time.sleep(0.01)
+    assert calls["gateway"] >= 1
+
+
+def test_daily_starlanguage_does_not_eat_yesterday_cache(snapshot_cache, monkeypatch) -> None:
+    handler = _handler()
+    yesterday = "2026-09-14"
+    today = "2026-09-15"
+    store_snapshot(
+        _body(reference_date=yesterday),
+        _verified_gateway(request_id="yesterday", reference_date=yesterday),
+        reference_date=yesterday,
+    )
+    calls = {"gateway": 0}
+
+    def today_gateway(body):
+        calls["gateway"] += 1
+        return _verified_gateway(request_id="today-live", reference_date=today)
+
+    _stub_local(monkeypatch, handler, today_gateway)
+    result = handler._compute_consultation_workflow(
+        _body(reference_date=today, extra={"entrypoint": "daily_starlanguage"})
+    )
+
+    assert calls["gateway"] == 1
+    assert result["vedastro_snapshot_cache"]["freshness"] == "miss"
+    assert result["vedastro_gateway"]["official_raw_response"]["request_id"] == "today-live"
+    assert lookup_snapshot(
+        _body(reference_date=today, extra={"entrypoint": "daily_starlanguage"}),
+        today=today,
+    )["freshness"] == "fresh"
+
+
+def test_nth_plus_one_wait_stays_within_join_and_queued_work_is_cancelled(
+    snapshot_cache, monkeypatch
+) -> None:
+    join = 0.2
+    monkeypatch.setenv("JYOTISH_FOREGROUND_VEDASTRO_JOIN_SECONDS", str(join))
+    monkeypatch.setenv("JYOTISH_FOREGROUND_VEDASTRO_BUDGET_SECONDS", "8")
+    handler = _handler()
+    started: list[int] = []
+    lock = threading.Lock()
+    release = threading.Event()
+
+    def slow_gateway(body):
+        with lock:
+            started.append(1)
+        release.wait(timeout=8)
+        return _verified_gateway(request_id="slow", reference_date="2026-09-15")
+
+    _stub_local(monkeypatch, handler, slow_gateway)
+    workers = foreground._FOREGROUND_VEDASTRO_WORKERS
+    body = _body(reference_date="2026-09-15")
+    elapsed: list[float] = []
+
+    def run_one() -> None:
+        t0 = time.monotonic()
+        result = handler._compute_consultation_workflow(body)
+        elapsed.append(time.monotonic() - t0)
+        assert result["vedastro_gateway"]["official_closure_reason"] == "foreground_optional_evidence_timeout"
+
+    try:
+        with ThreadPoolExecutor(max_workers=workers + 3) as pool:
+            futs = [pool.submit(run_one) for _ in range(workers + 3)]
+            for fut in futs:
+                fut.result(timeout=8)
+        assert max(elapsed) <= join + 2.5
+        assert len(started) <= workers
+    finally:
+        release.set()
+
+
+def test_join_budget_workers_declared_together_and_budget_respects_ratio(monkeypatch) -> None:
+    source = Path("scripts/vedastro_foreground.py").read_text(encoding="utf-8")
+    join_idx = source.index("FOREGROUND_VEDASTRO_JOIN_SECONDS_DEFAULT")
+    ratio_idx = source.index("FOREGROUND_VEDASTRO_BUDGET_JOIN_RATIO")
+    workers_idx = source.index("FOREGROUND_VEDASTRO_WORKERS_DEFAULT")
+    span = max(join_idx, ratio_idx, workers_idx) - min(join_idx, ratio_idx, workers_idx)
+    assert span < 400
+    assert "change together" in source
+
+    monkeypatch.delenv("JYOTISH_FOREGROUND_VEDASTRO_JOIN_SECONDS", raising=False)
+    monkeypatch.delenv("JYOTISH_FOREGROUND_VEDASTRO_BUDGET_SECONDS", raising=False)
+    join = foreground._foreground_vedastro_join_seconds()
+    budget = foreground._foreground_vedastro_budget_seconds()
+    assert budget <= foreground.FOREGROUND_VEDASTRO_BUDGET_JOIN_RATIO * join + 1e-9
+
+    monkeypatch.setenv("JYOTISH_FOREGROUND_VEDASTRO_JOIN_SECONDS", "1.5")
+    monkeypatch.setenv("JYOTISH_FOREGROUND_VEDASTRO_BUDGET_SECONDS", "8")
+    assert foreground._foreground_vedastro_budget_seconds() <= 3.0 + 1e-9
+
+
+def test_default_consultation_omits_western_packet_and_schema_required_keys_remain(
+    snapshot_cache, monkeypatch
+) -> None:
+    handler = _handler()
+    _stub_local(
+        monkeypatch,
+        handler,
+        lambda body: _verified_gateway(request_id="omit-western", reference_date="2026-09-15"),
+    )
+    omitted = handler._compute_consultation_workflow(_body(reference_date="2026-09-15"))
+    included = handler._compute_consultation_workflow(
+        _body(reference_date="2026-09-15", extra={"include_western_evidence_packet": True})
+    )
+
+    assert "western_evidence_packet" not in omitted
+    assert "western_spectrum" in omitted["consumer_context"]
+    assert omitted["success"] is True
+    assert isinstance(omitted["chart"], dict)
+    assert isinstance(omitted["routing"], dict)
+    assert isinstance(omitted["consumer_context"], dict)
+    assert "western_evidence_packet" in included
+
+    workflow_ts = Path("frontend/src/mastra/consultation-workflow.ts").read_text(encoding="utf-8")
+    schema = workflow_ts.split("export const consultationWorkflowResponseSchema", 1)[1]
+    assert "success: z.boolean()" in schema
+    assert "chart: z.record(z.unknown())" in schema
+    assert "routing: z.record(z.unknown())" in schema
+    assert "consumer_context:" in schema
+    assert ").passthrough()" in schema
+
+    omitted_chars = len(json.dumps(omitted, ensure_ascii=False))
+    included_chars = len(json.dumps(included, ensure_ascii=False))
+    assert included_chars >= omitted_chars
+
+
+def test_western_oracle_payload_still_returns_packet(snapshot_cache, monkeypatch) -> None:
+    handler = _handler()
+    _stub_local(
+        monkeypatch,
+        handler,
+        lambda body: _verified_gateway(request_id="oracle", reference_date="2026-09-15"),
+    )
+    result = handler._compute_consultation_workflow(
+        _body(
+            reference_date="2026-09-15",
+            extra={
+                "western_oracle_payload": {
+                    "source_engine": "kerykeion_external_json",
+                    "natal": {"ascendant": "Virgo", "mc": "Gemini"},
+                }
+            },
+        )
+    )
+    assert result["western_evidence_packet"]["source_engine"] == "kerykeion_external_json"
Author	SHA1	Message	Date
jesse-ux	3b17c1b242	test(freeze): 增长冻结改盯耦合，行数降为粗护栏 Independent Staging Quality Gate / validate (push) Failing after 6m21s Details Independent Staging Quality Gate / publish (push) Skipped Details Home() useState/useRef 与 JyotishAPIHandler 类方法/__new__ 不得增长。行数改为开工实测基线加余量。产品授权删除参数式 hook 零 React hook 规则。	2026-09-16 08:02:43 +08:00
jesse-ux	2b7b45657b	test(rectification): prove memoization in-process; tolerate golden float drift (BUG-733) Independent Staging Quality Gate / validate (push) Canceled after 5m0s Details Independent Staging Quality Gate / publish (push) Canceled after 0s Details Replace whole-structure golden == with same-process cached vs None fallback equality, plus discrete-strict / measured-tolerance golden comparison. Do not rebuild the golden JSON.	2026-09-16 07:56:56 +08:00
jesse-ux	51a65d927f	docs(tasks): record BUG-732 implementation SHA Independent Staging Quality Gate / validate (push) Failing after 6m19s Details Independent Staging Quality Gate / publish (push) Skipped Details	2026-09-16 07:41:41 +08:00
jesse-ux	dcfc2f15af	fix(consultation): count visible text only for session quota (BUG-732) Replace append_consultation_question so the 200,000 quota sums only user-visible text, and add a 1,000,000-byte whole-JSON physical cap. Both still return session_full. Advisory lock, request_id idempotency, and the 200-message cap are unchanged.	2026-09-16 07:41:41 +08:00
Jesse_ChenandClaude Opus 5	7227b1ed8d	docs(tasks): R1 验收修复单——等价 golden 跨机不稳，门禁靠运气绿对 BUG-721（引擎记忆化）的验收：实现通过，等价性我独立复核过——改前 `6b3248bf` 与改后 `e4788dfc` 在同一台机器上跑同一 payload，candidate_scores 逐字相同（8.6273 / 8.6226 / 8.1701），9 条计数断言全过；tsc 0、lint 0 error、全量前端 3291(fail 31) → 3304(fail 31) 失败清单逐条一致、next build 绿且 / 仍 Static、首屏 gzip 0.00% 变化。唯一一条红的是 test_score_candidates_matches_baseline_golden：golden 与本机实际输出有 4 处浮点尾数差（score 1.0e-4 ×2、margin_percent 1.1e-3 ×2），改前改后都对不上，说明是 golden 存全精度浮点跨机不稳，不是实现改坏了。复发自 BUG-712。而 tests/test_rectification_*.py 在 CORE_PYTEST_TARGETS 里，staging 自动门禁会跑它——今天绿只是因为 CI 那台机器的舍入和执行方一致。修复单只改测试：主证据换成同进程差分（四个缓存键置 None 即回退旧路径， A/B 严格相等，不经过任何跨机变量），golden 降为离散字段严格相等 + 浮点带容差；禁止用重建 golden 来修；防复发升级为仓库级并排查另外五份 golden。纯文档推送，不触发门禁、不发布镜像、不部署。 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JUei7K13cYxLHE3Axe4A45	2026-09-15 23:39:30 +00:00
jesse-ux	149e1ec4c3	fix(consult): drop traces, budget checkpoints, silent summary inherit Independent Staging Quality Gate / validate (push) Canceled after 3m8s Details Independent Staging Quality Gate / publish (push) Canceled after 0s Details BUG-729: dropped history rounds leave an omission marker in the model-visible summary slot. BUG-730: checkpoint threshold is 0.4 of historyBudgetChars (128k still 16,000). BUG-731: session_full new chat copies owned context_summary on the server; clients send only continued_from_session_id.	2026-09-16 07:38:36 +08:00
jesse-ux	e61535f464	fix(consultation): 外网证据按盘+日期缓存，超时取消前台任务 Independent Staging Quality Gate / validate (push) Canceled after 2m21s Details Independent Staging Quality Gate / publish (push) Canceled after 0s Details BUG-727：同日 VedAstro 快照零等待，跨日先用旧的并后台刷新；join 超时必须 cancel，budget 不超过 2×join。BUG-728：western_evidence_packet 无读取点，默认不再进咨询响应。jyotish_api_server.py 未增长（11334→11291）。	2026-09-16 07:36:09 +08:00