fix(chart): keep the ascendant nakshatra the page already renders

The chart API rebuilt the ascendant without nakshatra, lord, and pada, so those cells stayed blank. Cache schema is now 7. Centered column headers line up with their cells, and the current dasha card keeps its tint without the left accent.

pytest 34 passed. tsc 0 errors. lint 0 errors and 123 existing warnings.

Co-Authored-By: Grok (agent loop)
Co-authored-by: Cursor <cursoragent@cursor.com>

CHANGELOG.md

@@ -1,12 +1,8 @@
 # 印度占星 Skill 更新日志
 
-## 2026-10-15 — 合盘更快（待合入 staging）
+## 2026-10-15 — 星盘页上升行补上星宿，表头对齐（待合入 staging）
 
-- 合盘排两张盘时关掉用不上的外部概览，两张盘一起排。个人报告在没装参照引擎时不再为注定失败的回放反复起进程。轻重任务要不要分开限流，这一单只给了模拟表，还没改规则。
-
-## 2026-10-15 — 旧版校正评分轮询不再中途报错（待合入 staging）
-
-- 旧版生时校正在查询评分进度时，会因为多读了一步数据库结果而直接失败。现在按数据库实际返回的那一行读取。其他查询行为不变。Skill 版本不变（BUG-1351）。
+- 本命盘和月亮盘的上升行现在有星宿、宿主和 pada。状态写「不适用」，不再是空横杠。分盘等表里居中的那几列，表头也居中。当前大运不再画左侧那条线，浅色底还在。已经打开过的星盘会重新计算。Skill 版本不变（BUG-1352、BUG-1353）。
 
 ## 2026-10-14 — 生产可以在测试环境后面只多了文档时照常发布（待合入 staging）
 

docs/BUG_HISTORY.md

@@ -16174,6 +16174,7 @@
 - 根因：`compute_chart_data` 给九曜按 `nak_span` 算了 `nakshatra / nakshatra_pada / nakshatra_lord`，`result["ascendant"]` 漏了；前端按「引擎不给就不推」留空。
 - 修复：抽 `_nakshatra_fields(sidereal_lon)`，九曜、计都、上升共用；`/api/chart` 缓存 `cache_schema_version` 4 → 5（缓存 TTL 900 s，改版本只影响查找键；指纹 / 绑定只用出生资料，不受影响）。前端只改注释。
 - 验证：`tests/test_report_chart_blank_columns.py`（边界 0°、13°20′ 两侧、360°；golden 盘上升 Uttara Phalguni 1 足、九曜与 golden 逐星一致）；`frontend/tests/chart-varga-table.test.tsx` 上升行断言；旧缓存无字段仍渲染「—」。golden `chart-view-golden.json` 用 `_nakshatra_fields` 重录（命令写在 `sourceCommand`）。
+- 2026-10-15 更正：上面的验证只打到引擎 `compute_chart_data`，前端 golden 的星宿三项是事后补上去的，没有经过 `/api/chart` 重建上升的那一层。接口仍把三项丢掉，星盘页继续显示「—」。见 BUG-1352。
 - 防复发：同一个量（星宿）只有一个计算函数，新增盘点直接复用。
 - 相关记录：BUG-1076（D1 表逐字节基线：本次放开上升三格，见进度记录三栏）。
 - 复发自：无
@@ -17990,36 +17991,6 @@
 - 复发自：无。
 - 修复版本：分支 `codex/api-disk-cache-retention-20261013`，尚未合入 staging。
 
-## BUG-1333 | 合盘排盘漏关外部概览，而且两张盘排队算
-
-- 状态：fixed-pending-verify
-- 首次发现 / 最近更新：2026-10-13 / 2026-10-15
-- 来源：issue #64。任务书 `docs/tasks/TASK-api-chart-subprocess-gate-20261013.md` T1、T3、T4。
-- 现象：合盘每次要排两张盘，都没关掉用不上的外部概览。每张盘多起两个后台进程，而且两张盘一张一张排。名额占满时，日志里看不出是谁占着。
-- 触发条件：打开合盘。排盘接口本身默认仍走完整链，给报告和外部调用留着。
-- 根因：合盘这条路由没跟上「只读盘面就关掉外部概览」的约定，也没有合同测试拦住。名额按路径一刀切，不带 skip 的排盘默认不占名额。
-- 修复：合盘两次排盘都带上关闭外部概览，两张盘同时排；婚恋分支的两张分盘也同时排。前端里凡是发给排盘接口的请求体，都要带这个开关，由源码合同守着。另加一个默认关闭的开关：打开后，不带 skip 的同步排盘才占一个重计算名额。名额占满时记一行日志，只写被拒的路径和当前占用者的路径、已占秒数，不写请求正文。
-- 验证：`frontend/tests/synastry-chart-skip.test.ts`、`frontend/tests/chart-request-skip-contract.test.ts`、`tests/test_api_chart_subprocess_gate.py`、`tests/test_api_heavy_compute_gate.py`。合盘耗时见 `docs/testing/api-chart-subprocess-gate-ab-20261013.md`。`tests/test_supabase_user_data_contract.py` 锁住合盘路由向 `/api/chart` 请求本人和对方两张盘，且两次都带 `skip_vedastro_main_entry_overview: true`。
-- 防复发：源码合同要求 `frontend/src/app/api` 和 `frontend/src/lib` 里发往 `/api/chart` 的请求体带 `skip_vedastro_main_entry_overview: true`。Python 合同按路由原文锁住这两次调用和这个开关。`/api/chart` 仍不在重计算路径名单里。
-- 相关记录：BUG-161、BUG-715、BUG-717、BUG-1302。
-- 复发自：无。
-- 修复版本：分支 `codex/api-chart-subprocess-gate-20261013`。编号是任务书预留的空号，夹在 BUG-1332 和 BUG-1335 之间。
-
-## BUG-1334 | 个人报告在没有参照引擎时仍为每次报告启动子进程
-
-- 状态：fixed-pending-verify
-- 首次发现 / 最近更新：2026-10-13 / 2026-10-15
-- 来源：issue #64。任务书 T2。
-- 现象：每份个人报告会起大约 10 个后台进程。其中参照引擎没装时，年度回放注定失败，但仍要付启动开销。另一段静态校验和用户的盘无关，每份报告都重跑。
-- 触发条件：生成个人长报告，且这台机器没有安装 PyJHora。装了参照引擎的开发机上，隔离用的子进程仍然要留着。
-- 根因：子进程是为了把参照引擎隔离开，这是对的；父进程却没有先问「这台机器根本没装」。静态校验文件被挂在每份报告上，没有按文件变化复用。
-- 修复：父进程先看一次能不能导入参照引擎，不能就不起子进程，返回和「子进程在没装时」相同的结果。解释器查找和静态校验各在进程内记一次；校验文件变了会重算。不缓存任何出生资料。装了参照引擎时仍走子进程。
-- 验证：`tests/test_api_chart_subprocess_gate.py` 对照 `tests/fixtures/api-chart-subprocess-gate/`。生产上的收益大约是每份报告 0.5 到 0.9 秒、少掉那几个注定失败的进程，不是排查时在装了参照引擎的机器上看到的 5 秒。本机没有 PyJHora，实测见 `docs/testing/api-chart-subprocess-gate-ab-20261013.md`。
-- 防复发：无参照引擎时测试断言不会调用 `subprocess.run`，返回值与固定样本一致。
-- 相关记录：BUG-721、BUG-1265、BUG-1333。
-- 复发自：无。
-- 修复版本：分支 `codex/api-chart-subprocess-gate-20261013`。
-
 ## BUG-1335 | 个人长报告的中文出稿和溯源哈希重复劳动
 
 - 状态：investigating
@@ -34271,6 +34242,7 @@
 - 根因：`compute_chart_data` 给九曜按 `nak_span` 算了 `nakshatra / nakshatra_pada / nakshatra_lord`，`result["ascendant"]` 漏了；前端按「引擎不给就不推」留空。
 - 修复：抽 `_nakshatra_fields(sidereal_lon)`，九曜、计都、上升共用；`/api/chart` 缓存 `cache_schema_version` 4 → 5（缓存 TTL 900 s，改版本只影响查找键；指纹 / 绑定只用出生资料，不受影响）。前端只改注释。
 - 验证：`tests/test_report_chart_blank_columns.py`（边界 0°、13°20′ 两侧、360°；golden 盘上升 Uttara Phalguni 1 足、九曜与 golden 逐星一致）；`frontend/tests/chart-varga-table.test.tsx` 上升行断言；旧缓存无字段仍渲染「—」。golden `chart-view-golden.json` 用 `_nakshatra_fields` 重录（命令写在 `sourceCommand`）。
+- 2026-10-15 更正：上面的验证只打到引擎 `compute_chart_data`，前端 golden 的星宿三项是事后补上去的，没有经过 `/api/chart` 重建上升的那一层。接口仍把三项丢掉，星盘页继续显示「—」。见 BUG-1352。
 - 防复发：同一个量（星宿）只有一个计算函数，新增盘点直接复用。
 - 相关记录：BUG-1076（D1 表逐字节基线：本次放开上升三格，见进度记录三栏）。
 - 复发自：无
@@ -36072,36 +36044,6 @@
 - 复发自：无。
 - 修复版本：分支 `codex/api-disk-cache-retention-20261013`，尚未合入 staging。
 
-## BUG-1333 | 合盘排盘漏关外部概览，而且两张盘排队算
-
-- 状态：fixed-pending-verify
-- 首次发现 / 最近更新：2026-10-13 / 2026-10-15
-- 来源：issue #64。任务书 `docs/tasks/TASK-api-chart-subprocess-gate-20261013.md` T1、T3、T4。
-- 现象：合盘每次要排两张盘，都没关掉用不上的外部概览。每张盘多起两个后台进程，而且两张盘一张一张排。名额占满时，日志里看不出是谁占着。
-- 触发条件：打开合盘。排盘接口本身默认仍走完整链，给报告和外部调用留着。
-- 根因：合盘这条路由没跟上「只读盘面就关掉外部概览」的约定，也没有合同测试拦住。名额按路径一刀切，不带 skip 的排盘默认不占名额。
-- 修复：合盘两次排盘都带上关闭外部概览，两张盘同时排；婚恋分支的两张分盘也同时排。前端里凡是发给排盘接口的请求体，都要带这个开关，由源码合同守着。另加一个默认关闭的开关：打开后，不带 skip 的同步排盘才占一个重计算名额。名额占满时记一行日志，只写被拒的路径和当前占用者的路径、已占秒数，不写请求正文。
-- 验证：`frontend/tests/synastry-chart-skip.test.ts`、`frontend/tests/chart-request-skip-contract.test.ts`、`tests/test_api_chart_subprocess_gate.py`、`tests/test_api_heavy_compute_gate.py`。合盘耗时见 `docs/testing/api-chart-subprocess-gate-ab-20261013.md`。`tests/test_supabase_user_data_contract.py` 锁住合盘路由向 `/api/chart` 请求本人和对方两张盘，且两次都带 `skip_vedastro_main_entry_overview: true`。
-- 防复发：源码合同要求 `frontend/src/app/api` 和 `frontend/src/lib` 里发往 `/api/chart` 的请求体带 `skip_vedastro_main_entry_overview: true`。Python 合同按路由原文锁住这两次调用和这个开关。`/api/chart` 仍不在重计算路径名单里。
-- 相关记录：BUG-161、BUG-715、BUG-717、BUG-1302。
-- 复发自：无。
-- 修复版本：分支 `codex/api-chart-subprocess-gate-20261013`。编号是任务书预留的空号，夹在 BUG-1332 和 BUG-1335 之间。
-
-## BUG-1334 | 个人报告在没有参照引擎时仍为每次报告启动子进程
-
-- 状态：fixed-pending-verify
-- 首次发现 / 最近更新：2026-10-13 / 2026-10-15
-- 来源：issue #64。任务书 T2。
-- 现象：每份个人报告会起大约 10 个后台进程。其中参照引擎没装时，年度回放注定失败，但仍要付启动开销。另一段静态校验和用户的盘无关，每份报告都重跑。
-- 触发条件：生成个人长报告，且这台机器没有安装 PyJHora。装了参照引擎的开发机上，隔离用的子进程仍然要留着。
-- 根因：子进程是为了把参照引擎隔离开，这是对的；父进程却没有先问「这台机器根本没装」。静态校验文件被挂在每份报告上，没有按文件变化复用。
-- 修复：父进程先看一次能不能导入参照引擎，不能就不起子进程，返回和「子进程在没装时」相同的结果。解释器查找和静态校验各在进程内记一次；校验文件变了会重算。不缓存任何出生资料。装了参照引擎时仍走子进程。
-- 验证：`tests/test_api_chart_subprocess_gate.py` 对照 `tests/fixtures/api-chart-subprocess-gate/`。生产上的收益大约是每份报告 0.5 到 0.9 秒、少掉那几个注定失败的进程，不是排查时在装了参照引擎的机器上看到的 5 秒。本机没有 PyJHora，实测见 `docs/testing/api-chart-subprocess-gate-ab-20261013.md`。
-- 防复发：无参照引擎时测试断言不会调用 `subprocess.run`，返回值与固定样本一致。
-- 相关记录：BUG-721、BUG-1265、BUG-1333。
-- 复发自：无。
-- 修复版本：分支 `codex/api-chart-subprocess-gate-20261013`。
-
 ## BUG-1335 | 个人长报告的中文出稿和溯源哈希重复劳动
 
 - 状态：investigating
@@ -36192,19 +36134,35 @@
 - 复发自：无。
 - 修复版本：分支 `codex/release-path-production-20261014`。编号接在 BUG-1349 之后。
 
-## BUG-1351 | 自托管下旧版校正评分轮询 rpc 结果多读一步，必抛 TypeError
+## BUG-1352 | 星盘页上升行的星宿三项被排盘接口丢掉
 
 - 状态：resolved
-- 首次发现：2026-10-13
+- 首次发现：2026-10-03
 - 最近更新：2026-10-15
-- 影响面：旧版生时校正（legacy-guided-v1）的评分轮询，`POST /api/birth-time-journey` 且类型为 `poll_scoring`
-- 用户现象：这类存量校正在查看评分进度时直接失败，页面拿不到「已领取 / 处理中 / 已完成」。
-- 触发条件：自托管数据库（当前 staging 与生产都是这条路径）上，对 `claim_birth_time_scoring_job` 的返回值再调用 `.single()`。该函数返回的是表格里的一行，本地适配层把整表收成数组，没有 `.single`。
-- 根因：数据访问层被标成完整的 Supabase 客户端，编译器看不出适配层没有 `.single`。原有测试用内存仓库，没有走过真实适配层。
-- 修复：去掉 `.single()`。返回值如果是数组就取第一行，如果已是单行对象就直接用，再做原来的字段校验。Supabase 回滚分支不带 `.single()` 时同样返回数组，行为一致。
-- 验证：修复前两条单元测试都抛出 `supabase.rpc(...).single is not a function`。修复后这两条通过。另有一条真实迁移测试：函数返回值是数组，认领结果为已领取，且不抛错。`tsc --noEmit` 0 错。
-- 防复发：适配层 `implements` 自己的 `DataClient`。新增调用如果用了适配层没有的方法，编译直接失败。评分认领有数据库级用例。
-- 相关记录：BUG-124、BUG-130、BUG-576、BUG-926
+- 影响面：星盘页本命盘和月亮盘的上升行（星宿、宿主、pada）
+- 用户现象：这两行的星宿、宿主、pada、状态都是「—」，像没算出来。九曜那几行是有的。
+- 触发条件：打开星盘页的本命盘或月亮盘。上升经度其实已经算好。
+- 根因：引擎给上升写了星宿三项，排盘接口在重组结果时只留了星座和度数，把这三项丢了。月亮盘用的是同一份上升。上次修复只测了引擎，前端样例又是事后补上这三项的，所以接口这一层一直没被发现。
+- 修复：接口重组上升时原样带上这三项；引擎没给时按同一套星宿算法补上。排盘缓存版本 6 改为 7，避免继续用没有这三项的旧结果。
+- 验证：虚构盘（1990-06-15 12:00 北京）走排盘处理函数，上升和 `modules.chart.ascendant` 的三项与星宿算法一致，为 Uttara Phalguni、1、Sun。本命表和月亮盘表都渲染出这三项。
+- 防复发：回归测试必须经过排盘处理函数，不能只测引擎，也不能手工往样例里补字段。
+- 相关记录：BUG-1201、BUG-1314
+- 复发自：BUG-1201（修复没有打通接口层）
+- 修复版本：分支 `codex/chart-ascendant-row-20261015`。任务书写明 BUG-1351 已被另一单占用，本单从 BUG-1352 起。
+
+## BUG-1353 | 星盘表居中列的表头靠左，当前大运卡片左边多一条线
+
+- 状态：resolved
+- 首次发现：2026-10-15
+- 最近更新：2026-10-15
+- 影响面：星盘页行星表的表头，以及大运列表里当前这一段
+- 用户现象：分盘「庙旺」的表头靠左、格子里的字居中，对不齐。当前大运卡片左边有一条竖线。
+- 触发条件：打开星盘页的分盘表或大运列表。
+- 根因：居中只加在内容格子上，表头没有。八列表的写法是冻结的，不能改标记。大运当前段用内阴影画了左侧强调线，设计说明里没写，也没有测试盯着。
+- 修复：表头与内容一起居中。本命和月亮盘的八列表不改标记，用列选择器把速度、宿主、pada 的表头居中，宫位仍靠左。分盘的庙旺和同位、行运的速度、Bhava 的换宫，表头加上与内容相同的居中标记。当前大运去掉左侧那条线，浅底和细边框留着。
+- 验证：样式合同锁定八列表对应表头居中、宫位列仍靠左，以及当前大运规则里没有 box-shadow。分盘、行运、Bhava 的渲染测试锁定表头带居中标记。
+- 防复发：上述样式合同和渲染测试。
+- 相关记录：BUG-1076、BUG-1352
 - 复发自：无
-- 修复版本：分支 `codex/data-layer-types-20261013`。任务书预留 BUG-1343；开工时本文件最大号已是 BUG-1350，1343 没有条目。按「从当前最大号往后」编为 BUG-1351。
+- 修复版本：分支 `codex/chart-ascendant-row-20261015`。
 

docs/tasks/PROGRESS-api-chart-subprocess-gate-20261013.md

@@ -1,90 +0,0 @@
-# PROGRESS · 合盘排盘与报告多余子进程（2026-10-15）
-
-- 分支：`codex/api-chart-subprocess-gate-20261013`
-- 实际基线：`origin/staging` `9274491681f6fcacbc87e3797441d2c5221de874`（任务书写的 `77057a819` 更早）
-- `scripts/jyotish_api_server.py`：开工 10944 行，做完 10940 行
-- BUG-1333、BUG-1334。`docs/BUG_HISTORY.md` 后半是同一份历史的副本，两处都补上了。
-
-## 做了什么
-
-1. 合盘两次排盘都带 `skip_vedastro_main_entry_overview: true`，不改 `synastryBirthPayload`。两张盘和婚恋分支的两张九分盘都改成同时发出。任一失败仍走原来的 `catch`。
-2. 前端 `app/api` 和 `lib` 里发往 `/api/chart` 的请求体必须带这个开关。白名单是空的。
-3. 父进程先看一次能不能导入 PyJHora。不能就不起年度回放和 Tajika 的子进程，返回和「子进程在没装时」相同的结果。样本在 `tests/fixtures/api-chart-subprocess-gate/`，来自本机真实子进程（当时 `find_spec("jhora")` 为 `None`）。装了之后仍走子进程。
-4. 解释器查找（含「没找到」）和静态 oracle 校验在进程内各记一次。校验按文件路径、mtime、大小作键。不缓存出生资料。
-5. 开关 `JYOTISH_GATE_CHART_OVERVIEW` 默认关。只有把它设为 `1` 时，不带 skip、也不是异步排队的 `/api/chart` 才占一个重计算名额。`/api/chart` 没有加进 `HEAVY_COMPUTE_PATHS`。预热咨询不占名额的判断挪进了闸门模块。
-6. 名额占满时打一行日志：被拒路径、当前占用者路径、已占秒数。不写请求正文。
-
-## 自测
-
-| 检查 | 命令 | 结果 |
-| --- | --- | --- |
-| 闸门、增长护栏、本单新测试 | `.venv\Scripts\python.exe -m pytest tests/test_api_chart_subprocess_gate.py tests/test_api_heavy_compute_gate.py tests/test_api_server_growth_contract.py -q` | 21 passed，退出码 0 |
-| 报告三份既有测试 | 同上解释器 `-m pytest tests/test_report_reader_main.py tests/test_report_longform_parity.py tests/test_report_density_facts.py -q` | 27 passed，退出码 0 |
-| 前端本单与相关单文件 | 在 `frontend` 下 `node node_modules/tsx/dist/cli.mjs --test tests/synastry-chart-skip.test.ts tests/chart-request-skip-contract.test.ts tests/chart-view-route.test.ts tests/ephemeris-route.test.ts` | 22 pass，0 fail |
-| 类型检查 | `frontend\node_modules\.bin\tsc --noEmit -p frontend` | 退出码 0 |
-| lint | 在 `frontend` 下 `npm run lint` | 退出码 0，0 error，123 条原有 warning |
-| A/B | `.venv\Scripts\python.exe scripts\research\api_chart_subprocess_ab.py` | 退出码 0。数字见下 |
-
-`grep` 这三个名字在 `tests/` 里只命中本单新测试：`annual_pyjhora_replay`、`_oracle_progress_snapshot`、`_resolve_external_pyjhora_python`。
-
-## A/B 数字
-
-合盘：串行不带 skip 中位 8.0596 秒、2 次 `subprocess.run`；并发带 skip 中位 0.0166 秒、0 次。盘面摘要逐字节一致。耗时约为对照的 0.2%。
-
-报告：强制仍起子进程中位 16.5322 秒、7 次；短路后 15.3235 秒、1 次。去掉易变字段后逐字节一致。少掉的 6 次是年度回放和 Tajika。
-
-名额模拟（种子 64，一分钟，未改规则）：
-
-| 方案 | 咨询被拒 | 报告被拒 | 校正被拒 | 最高并发 | 碰到不得加池的那条 |
-| --- | --- | --- | --- | --- | --- |
-| O1 现状 | 40% | 0% | 17% | 2 | 否 |
-| O2 咨询单独小池 | 0% | 0% | 17% | 3 | 是 |
-| O3 咨询最多再等 1.5 秒 | 30% | 0% | 33% | 2 | 否 |
-| O4 重任务最多占 1 个 | 0% | 0% | 67% | 2 | 否 |
-
-全文在 `docs/testing/api-chart-subprocess-gate-ab-20261013.md`。
-
-## 改既有断言
-
-无。原值 / 新值 / 原因：没有改旧断言。
-
-## 偏离
-
-- `/api/health` 没有加 `heavy_compute` 字段。状态函数 `heavy_compute_status()` 在闸门模块里，接到健康检查会让主文件变长。任务书允许砍掉这一项。
-- 星盘名额开关默认关。打开会让不带 skip 的外部调用可能拿到 429，任务书要求先有 A/B 再提议，本单不打开。
-- O2、O3、O4 没有实现。
-- 报告对照不是 staging 源码另导入，而是本分支把「已安装」强制打开。静态校验缓存两边都在，所以耗时差只反映那 6 个子进程。
-- 合盘子进程是 2 → 0，不是任务书举例的 4 → 0。这台机器两张盘合计只数到 2 次 `subprocess.run`。
-- 没有「装了 PyJHora」的计时。父进程强制当成已安装时，子进程仍会因为没装而失败，这一组用来代表「不短路就要付启动开销」。
-
-## 环境缺口
-
-- 本机 `.venv`：`sys.executable` 是工作树的 `python.exe`；`shutil.which("python3")` 是 Windows 应用商店占位；`python3.14` 没有；`find_spec("jhora")` 是 `None`。
-- Docker 在，没有本地 `jyotisha-api` 镜像，镜像里的解释器路径没有核实。
-- 生产装了 VedAstro、并且开了外网时，不带 skip 的排盘真实耗时本机测不到。
-- 名额被占满后连带拒绝的真实频率，要等日志上了 staging 再看。
-
-## 需拍板
-
-轻重任务要不要分开限流，本单不改。模拟里，让咨询少被拒，校正就会多被拒；给咨询单独开池会让同时在跑的个数超过 2。要改规则需要另立一单。
-
-## 默认值
-
-- `JYOTISH_GATE_CHART_OVERVIEW` 默认关。
-- 合盘 skip 和报告短路没有开关。
-
-## 2026-10-15 打回修复
-
-合盘路由的合同跟上了新写法：仍锁本人和对方各请求一次排盘，并锁住关闭外部概览。对照脚本默认写到系统临时目录，只有带 `--out` 才写指定文件，不再覆盖已入库的记录。业务代码没改。名额配额仍不实现。没有新 bug 编号，补在 BUG-1333 的两处副本上。
-
-| 检查 | 命令 | 结果 |
-| --- | --- | --- |
-| 用户数据合同 | `.venv\Scripts\python.exe -m pytest tests/test_supabase_user_data_contract.py -q` | 8 passed，退出码 0 |
-| 脚本默认路径 | 调用 `resolve_record_path` | 默认不在仓库内，也不是已入库的 json；`--out` 指向传入路径 |
-| 源码文本检索 | `tests` 与 `frontend/tests` 里的合盘路由、`postPython("/api/chart"`、`postPython("/api/varga_full"` | 只有这一条合同在断言旧写法，已改。其它命中是在读路由文件，没有断言旧的两次调用。分盘前缀仍匹配，没改 |
-| 类型检查 | 在 `frontend` 下 `node_modules\.bin\tsc --noEmit -p .` | 退出码 0 |
-| lint | 在 `frontend` 下 `npm run lint` | 退出码 0，0 error，123 条原有 warning |
-
-原值：`postPython("/api/chart", selfPayload)` 与 `postPython("/api/chart", partnerPayload)`。新值：两次调用都展开对应 payload，并带 `skip_vedastro_main_entry_overview: true`。原因：合盘改为同时排两张盘并关掉用不上的外部概览，合同要锁住这两次请求和这个开关，不放宽。
-
-偏离：先合并了 `origin/staging` `1de3cc307be9134a3b8d1d606c738c1468414118`。相对打回 SHA `336286e4`，`frontend/src` 里多出来的是数据访问层那一单，不是这次修复改的。技能目录下的同名脚本没改，它的输出根不是仓库的 `docs/testing`。

docs/tasks/PROGRESS-chart-ascendant-row-20261015.md

@@ -0,0 +1,33 @@
+# PROGRESS · 星盘页上升行（issue #53 第二轮）
+
+- 分支：`codex/chart-ascendant-row-20261015`
+- 基线：`origin/staging` `2b7112a6010acbcc0fec809b6b27e2375293dd5c`
+- 编号：本文件最大号是 BUG-1350。任务书说 BUG-1351 已被 #65 的分支占用，本单用 BUG-1352（上升星宿被接口丢掉，复发自 BUG-1201）和 BUG-1353（表头错位与大运左边线）。
+
+## 做了什么
+
+- `/api/chart` 重组上升时带上 `nakshatra`、`nakshatra_pada`、`nakshatra_lord`。引擎已经有就原样带上；没有才按同一套星宿算法补。`cache_schema_version` 6 → 7。
+- 上升行状态从「—」改为「不适用」。本命、月亮盘共用这一行。
+- 八列表的标记没改。速度、宿主、pada 的表头用列选择器居中，宫位仍靠左。分盘的庙旺 / 同位、行运的速度、Bhava 的换宫，表头加上与内容相同的居中标记。
+- 当前大运去掉 `box-shadow`，浅底和细边框还在。
+
+## 样例
+
+`chart-view-golden.json` 里上升的三项本来就是 Uttara Phalguni、1、Sun，和这次接口真实返回一致，数值没有手改。`sourceCommand` 不再写「用 `_nakshatra_fields` 事后补上」，改为写明来自 `_compute_chart_sync`。
+
+## 断言改动
+
+| 位置 | 原值 | 新值 | 原因 |
+| --- | --- | --- | --- |
+| `chart-varga-table.test.tsx` 上升行状态格 | `<td>—</td>` | `<td>不适用</td>` | 产品把横杠看成没数据 |
+| `test_api_scratch_retention.py` 缓存版本 | `6` | `7` | 旧缓存没有星宿三项，必须换键 |
+| 基线 html | 仍是改前的整张表 | 不改文件 | 测试用替换得到新表，原值留在基线里 |
+
+## 自测
+
+- `pytest tests/test_api_chart_ascendant_nakshatra.py tests/test_report_chart_blank_columns.py tests/test_api_server_growth_contract.py tests/test_api_scratch_retention.py -q`：34 通过，退出码 0。没有新增 `JyotishAPIHandler.__new__`。
+- 前端：`chart-varga-table`、`chart-moon-transit`、`chart-bhava`、`chart-page-mobile-width-20260929`、`runtime-sources-no-test-imports`。月亮盘那条第一次用整页去配「上升」，配到了图上的标记；改成只看月亮盘表格后通过。
+- `tsc --noEmit -p .`：0 个错误，退出码 0。
+- `npm run lint`：0 个错误、123 条原有警告，退出码 0。
+- `chart-page-view` 与 `chart-page-hook`：46 通过，退出码 0。
+- 真机清单沿用任务书里已有的 `docs/testing/chart-ascendant-row-20261015.md`。

docs/tasks/PROGRESS-data-layer-types-20261013.md

@@ -1,92 +0,0 @@
-# PROGRESS · 数据访问层 DataClient 类型（第一阶段）
-
-- 分支：`codex/data-layer-types-20261013`
-- 基线：`origin/staging` `9274491681f6fcacbc87e3797441d2c5221de874`
-- 前置：`origin/codex/node-runtime-resources-20261013` 已是 `origin/staging` 的祖先（`merge-base --is-ancestor` 退出码 0）。`local-postgres-client-core.ts` 只加了 `import type` 和两处 `implements`。
-- `frontend/src/lib/rectification-agentic/session.ts` 已不在，本单没有改它。
-- 编号：任务书预留 BUG-1343。开工时 `docs/BUG_HISTORY.md` 最大号是 BUG-1350，1343 没有条目。按台账规则从最大号往后，记为 **BUG-1351**。
-
-## T1 · 编译器暴露的 2 条
-
-`DataClient` 换上之后、缺陷尚未修时，`tsc --noEmit` 退出码 2，恰好 2 条：
-
-```
-src/app/api/chart-profiles/route.ts(59,40): error TS7006: Parameter 'row' implicitly has an 'any' type.
-src/lib/birth-time-scoring-job-store.ts(103,10): error TS2339: Property 'single' does not exist on type 'Promise<Readonly<{ data: any; error: Readonly<{ message: string; code?: string | undefined; }> | null; count?: number | null | undefined; }>>'.
-```
-
-`grep`：`as unknown as SupabaseClient` 在 `frontend/src` 无结果。`@supabase/supabase-js` 只剩 `admin-client-core.ts` 的 `createClient` 回滚分支。
-
-## T2 · 缺陷修复红转绿
-
-修复前，`claimScoringJob` 对返回数组的假 `rpc` 调用 `.single()`：
-
-- `claimScoringJob reads the first row when rpc returns an array`：失败，`TypeError: supabase.rpc(...).single is not a function`
-- `claimScoringJob also accepts the single-object rpc shape`：同样失败
-
-去掉 `.single()` 并兼容数组与单对象之后，这两条通过。真实迁移用例 `claim_birth_time_scoring_job returns an array and claimScoringJob accepts it` 通过：`data` 是数组，第一行 `claim_state` 为 `claimed`，store 返回 `{ kind: "claimed", algorithmVersion }`。第一次启动测试库时迁移进程只留下笼统的 `database migration failed`（脚本会把非预期异常收成这一句），容器未到 Healthy。同一条用例在容器 Healthy 后重跑通过。
-
-`chart-profiles/route.ts` 的 `row` 标为 `unknown`。
-
-修完后 `tsc --noEmit` 退出码 0。`npm run lint` 退出码 0，0 error，123 warning（与改动前的存量警告数量一致，本单没有新增 warning）。
-
-## T3 · 转译差分
-
-类型层改动用 esbuild 0.28.1、`--format=esm`、`--tsconfig=frontend/tsconfig.json`，旧文件与新文件都按这份 tsconfig 转译。除 T2 的两个文件和新建的 `data-client.ts` 外，全部 `SAME`：
-
-- `src/lib/birth-time-journey-case-loader.ts`
-- `src/lib/birth-time-journey-store.ts`
-- `src/lib/birth-time-journey-turn-persistence.ts`
-- `src/lib/db/local-postgres-client-core.ts`
-- `src/lib/rectification-agentic/v9/case-service.ts`
-- `src/lib/rectification-agentic/v9/product-domain.ts`
-- `src/lib/rectification-agentic/v9/tool-service.ts`（只改了一句注释；转译后注释被去掉，产物相同）
-- `src/lib/rectification-in-chat-server.ts`
-- `src/lib/supabase/admin-client-core.ts`
-- `src/lib/supabase/server.ts`
-- `src/mastra/rectification-v9-tools.ts`
-
-任务书把旧文件写到系统临时目录再转译。esbuild 0.28.1 会沿文件所在目录寻找 `tsconfig.json`。临时目录找不到本仓库的 `tsconfig.json`（`target` 为 ES2017），类字段的转译结果会和仓库内文件不一致，即使源码只有类型或注释差别也会报 DIFF。两边都带上同一份 `--tsconfig` 后为 SAME。这不是运行时变化。
-
-## T4 · 把 data 收成 unknown 的错误清单
-
-临时把 `UntypedData` 改成 `unknown` 后 `tsc --noEmit` 退出码 2，共 93 条、12 个文件。随后已改回 `any`。
-
-| 条数 | 文件 |
-| ---: | --- |
-| 24 | `src/app/api/account/route.ts` |
-| 17 | `src/app/api/consult/route.ts`（其中 1 条是 `DataClient` 不能赋给 `GuardedTitleClient`，`consult/route.ts` 约 1055 行） |
-| 16 | `src/app/api/consult/status/route.ts` |
-| 12 | `src/app/api/payment/epay/status/route.ts` |
-| 7 | `src/lib/epay/availability.ts` |
-| 5 | `src/lib/rectification-agentic/v9/product-domain.ts` |
-| 4 | `src/app/api/sessions/route.ts` |
-| 3 | `src/lib/rectification-agentic/v9/agent-route-request.ts` |
-| 2 | `src/app/api/chart-profiles/[id]/route.ts` |
-| 1 | `src/app/api/account/avatar/route.ts` |
-| 1 | `src/app/api/chart-profiles/route.ts` |
-| 1 | `src/app/api/sessions/[id]/route.ts` |
-
-和任务书写作时的 122 条相比，`consult/route.ts` 少了 10 条，`chart-profiles/route.ts` 少了 1 条（本单已把 `row` 标成 `unknown`）。没有单独再出现一条 `session-title-guard.ts` 的错误，`GuardedTitleClient` 那条记在 `consult/route.ts` 里。这些留给第二阶段，本单没有改那些业务文件。
-
-## test:db
-
-`npm run test:db`（`tsx --test --test-concurrency=1 tests/database-*.test.ts`）约 19 分钟，退出码 1。汇总：85 条，通过 72，失败 13，取消 0，跳过 0。
-
-失败的 13 条与 `tools/agent-loop/windows-known-failures.txt` 逐条一致，没有多出来的失败：
-
-- staging backups are encrypted, atomic, private, and retain the newest three
-- rejects destructive backup directory aliases and symlink components before mutation
-- rejects unsafe writable backup parents before creating the target
-- rejects a direct canonical sticky shared backup directory before chmod
-- creates every absent backup path component privately despite a permissive caller umask
-- same-second backups publish once without overwriting the completed archive
-- find enumeration failures preserve existing backups and do not report completion
-- refuses full disks and removes a failed-pipeline partial file
-- database env validator accepts punctuated literal required secrets
-- database env validator enforces an explicit staging owner uid without printing values
-- database env validator accepts a private valid file without printing values
-- personal report job migration is atomic, lease-bound, recoverable, and owner read-only
-- personal report sections enforce owner-read RLS and service-owned durable transitions
-
-本单新增的 3 条（两条假客户端、一条真实迁移认领）都在通过的 72 条里。

docs/tasks/README.md

@@ -213,7 +213,7 @@
 | --- | --- | --- | --- | --- |
 | `TASK-rectification-step0-entry-20261013.md` | — | **明说要校正时第一步就能打开（agent 循环 issue #54，BUG-1306 复发）**：第 0 步只放排盘工具、规则正向句埋在禁止句里、「纠正」撞词，模型没带 explicitRequest 调工具（BUG-1317）。产品选 B：第 0 步放出校正工具 + 规则重排；推翻 BUG-923 第 0 步限制，保险用现有 runtime-contract-retry。执行方 Grok | 待领取 | `codex/rectification-step0-entry-20261013` |
 | `TASK-report-focus-card-20261013.md` | — | **报告开篇「重点」做成摘要卡（agent 循环 issue #55）**：10-08 加的开篇重点从未设计——三重「重点」、标题无样式、MD/AD/PD 行话、数据句堆砌（BUG-1316）。产品选 A 摘要卡 + 名字与日期 + 保留提醒句；引擎出 `jyotish-focus` 围栏，前端一个组件渲染。执行方 Grok | 待领取 | `codex/report-focus-card-20261013` |
-| `TASK-chart-ascendant-row-20261015.md` | — | **星盘页上升行无星宿 / 表头错位 / 大运卡左边线（issue #53 第二轮）**：`/api/chart` 重建上升时丢了星宿三字段，BUG-1201 从未打通（golden 取自引擎内部）；状态改「不适用」（推翻 DESIGN 原口径）；居中列表头没居中；当前大运 inset 左线去掉。执行方 Grok | 待领取 | `codex/chart-ascendant-row-20261015` |
+| `TASK-chart-ascendant-row-20261015.md` | `PROGRESS-chart-ascendant-row-20261015.md` | **星盘页上升行无星宿 / 表头错位 / 大运卡左边线（issue #53 第二轮）**：`/api/chart` 重建上升时丢了星宿三字段（BUG-1352，复发自 BUG-1201）；状态改「不适用」；居中列表头对齐；当前大运去掉左边线（BUG-1353） | 待验收 | `codex/chart-ascendant-row-20261015` |
 | `TASK-report-translation-gaps-20261013.md` | — | **个人报告中英混杂、正文图盘空白、上升行、同位列（agent 循环 issue #53）**：中文完整数据版靠短词替换英文，正文残留 218 处英文词与 14 处中英粘连，卫生检查只有黑名单（BUG-1312）；完整数据版图盘节只有空标题、无围栏，BUG-1203 的回归（BUG-1313）；报告本命表无上升行（BUG-1314）；D9 同位列「—」读如没数据，改「是/否」（BUG-1315）。分盘核对段随 T1 自动消失。执行方 Grok | 待领取 | `codex/report-translation-gaps-20261013` |
 | `TASK-report-translation-gaps-fix-20261013.md` | — | **#53 第 1 次打回**：`a295afa4` 实现四项都验过，但分支未基于最新 staging，且全量 pytest 新增 1 条失败（报告 Jaimini 星位名改成「灵魂星（AK）」后 `test_chara_karaka_8_bphs_order` 未跟改）。要求 rebase + 按三栏改测试，不改 `KARAKA_CN` | 待领取 | `codex/report-translation-gaps-20261013` |
 | `TASK-report-full-data-edition-20261007.md` | `PROGRESS-report-full-data-edition-20261007.md` | **报告改为完整数据版、删除阅读版**：网站阅读版中文 7.6 万字符 vs 上游 `pl9_ai_density` 97 万；移植原始数据附录 / 清理器 / 时间补充，中英文；我方报告口径（BUG-1199～1229）全部保持；旧报告仍可打开；排在 sync6 之后 | 已验收（Claude 补修 BUG-1282 后合入 staging） | `codex/report-full-data-edition-20261007`（未推 staging） |
@@ -483,8 +483,8 @@
 | `TASK-consult-prep-parallel-fix-20261014.md` | `PROGRESS-consult-prep-parallel-20261013.md` | **#62 第 1 次打回**：两条源码文本检查改认新位置，对照脚本挪进测试目录 | 待验收 | `codex/consult-prep-parallel-20261013` |
 | `TASK-frontend-dead-code-20261013.md` | `PROGRESS-frontend-dead-code-20261013.md` | 前端死代码 17 文件与无调用方接口删除，含未登录重计算接口（BUG-1342） | 待验收 | `codex/frontend-dead-code-20261013` |
 | `TASK-frontend-dead-code-fix-20261014.md` | `PROGRESS-frontend-dead-code-20261013.md` | **#63 第 1 次打回**：类名白名单去掉已删组件留下的条目 | 待验收 | `codex/frontend-dead-code-20261013` |
-| `TASK-api-chart-subprocess-gate-20261013.md` | `PROGRESS-api-chart-subprocess-gate-20261013.md` | 合盘不带 skip 串行排盘、报告无效子进程、名额轻重混用（只模拟）（BUG-1333～1334，A/B） | 第 1 次打回，见修复单 | `codex/api-chart-subprocess-gate-20261013` |
-| `TASK-api-chart-subprocess-gate-fix-20261015.md` | `PROGRESS-api-chart-subprocess-gate-20261013.md` | **#64 第 1 次打回**：`336286e4` 内容通过（合盘 1.19→0.015 s、正文逐字节一致）；Python 合同按源码检查合盘路由旧写法未跟改；A/B 脚本默认覆盖入库记录 | 待验收 | `codex/api-chart-subprocess-gate-20261013` |
+| `TASK-api-chart-subprocess-gate-20261013.md` | — | 合盘不带 skip 串行排盘、报告无效子进程、名额轻重混用（只模拟）（BUG-1333～1334，A/B） | 待领取（排队：api-disk-cache-retention + report-reference-perf） | `codex/api-chart-subprocess-gate-20261013` |
+| `TASK-api-chart-subprocess-gate-fix-20261015.md` | — | **#64 第 1 次打回**：`336286e4` 内容通过（合盘 1.19→0.015 s、正文逐字节一致）；Python 合同按源码检查合盘路由旧写法未跟改；A/B 脚本默认覆盖入库记录 | 待领取 | `codex/api-chart-subprocess-gate-20261013` |
 | `TASK-answer-effort-ab-20261013.md` | — | 答题步推理强度开关 + A/B（需模型 key） | 待领取（排队：consult-prep-parallel） | `codex/answer-effort-ab-20261013` |
 | `TASK-answer-effort-ab-fix-20261015.md` | — | **#65 第 1 次打回**：`ab7f66be` 开关逻辑通过（默认请求体不变）；研究脚本从 `frontend/tests` 读文件（BUG-1140） | 待领取 | `codex/answer-effort-ab-20261013` |
 | `TASK-consult-route-split-20261013.md` | — | consult POST 拆分第一阶段：开流前加载 + 计费结算 | 待领取（排队：consult-prep-parallel、answer-effort-ab） | `codex/consult-route-split-20261013` |
@@ -492,5 +492,5 @@
 | `TASK-python-hygiene-20261013.md` | — | 免费层排队开关报反、静默吞异常、功能吉凶兜底合一、测试专用脚本归位（BUG-1340） | 待领取（排队：pl9-render-split） | `codex/python-hygiene-20261013` |
 | `TASK-dasha-unify-20261013.md` | — | /api/dasha 改走引擎同一套实现、删占位注册表、Ashtottari 出生余额（BUG-1341、1344） | 待领取（排队：python-hygiene） | `codex/dasha-unify-20261013` |
 | `TASK-api-server-service-extract-20261013.md` | — | API 单体第一阶段：拆出不带 HTTP 的计算类，生产伪造 handler 归零 | 待领取（排队：dasha-unify） | `codex/api-server-service-extract-20261013` |
-| `TASK-data-layer-types-20261013.md` | `PROGRESS-data-layer-types-20261013.md` | 数据访问层改用自己的 DataClient 类型第一阶段（BUG-1351；任务书预留的 1343 已被更大编号越过） | 待验收 | `codex/data-layer-types-20261013` |
+| `TASK-data-layer-types-20261013.md` | — | 数据访问层改用自己的 DataClient 类型第一阶段（BUG-1343） | 待领取（排队：node-runtime-resources） | `codex/data-layer-types-20261013` |
 | `TASK-contracts-helpers-dedupe-20261013.md` | — | 前后端契约与小工具去重第一阶段 | 待领取（排队：frontend-dead-code、consult-route-split） | `codex/contracts-helpers-dedupe-20261013` |

docs/testing/api-chart-subprocess-gate-ab-20261013.json

@@ -1,53 +0,0 @@
-{
-  "charts": {
-    "serial_seconds_median": 8.0596,
-    "concurrent_skip_seconds_median": 0.0166,
-    "serial_subprocesses_median": 2,
-    "concurrent_skip_subprocesses_median": 0,
-    "summary_bytes_match": true
-  },
-  "report_forced_subprocess": {
-    "seconds_median": 16.5322,
-    "subprocesses_median": 7
-  },
-  "report_short_circuit": {
-    "seconds_median": 15.3235,
-    "subprocesses_median": 1
-  },
-  "report_bytes_match": true,
-  "schemes": [
-    {
-      "scheme": "O1",
-      "consult_429": "0.40",
-      "report_429": "0.00",
-      "score_429": "0.17",
-      "peak": 2,
-      "touches_bug_717": false
-    },
-    {
-      "scheme": "O2",
-      "consult_429": "0.00",
-      "report_429": "0.00",
-      "score_429": "0.17",
-      "peak": 3,
-      "touches_bug_717": true
-    },
-    {
-      "scheme": "O3",
-      "consult_429": "0.30",
-      "report_429": "0.00",
-      "score_429": "0.33",
-      "peak": 2,
-      "touches_bug_717": false
-    },
-    {
-      "scheme": "O4",
-      "consult_429": "0.00",
-      "report_429": "0.00",
-      "score_429": "0.67",
-      "peak": 2,
-      "touches_bug_717": false
-    }
-  ],
-  "jhora_installed": false
-}

docs/testing/api-chart-subprocess-gate-ab-20261013.md

@@ -1,40 +0,0 @@
-# 合盘排盘与报告子进程 A/B（2026-10-15）
-
-Windows 本机，工作树 `.venv` 的 `python.exe`。`importlib.util.find_spec("jhora")` 是 `None`。`python3` 指向 Windows 应用商店占位程序，`python3.14` 不存在。Docker 守护进程在，本机没有 `jyotisha-api` 镜像，所以没有进镜像再探一次。本机没有 VedAstro SDK，外网关闭（`VEDASTRO_ENABLE_NETWORK=0`）。没有「真 SDK」一组。
-
-脚本：`scripts/research/api_chart_subprocess_ab.py`。每组 3 次，取中位数。盘是任务书里的虚构盘（1990-01-01 12:00 与 1992-01-02 12:00，新德里）。星盘缓存 TTL 设为 0。易变字段在比对前丢掉：`generated_at`、`created_at`、`timestamp`、`elapsed_seconds`、`elapsed_ms`、`duration_ms`、`request_id`。原始数字在同目录 `api-chart-subprocess-gate-ab-20261013.json`。
-
-对照不是另一次 `git show` 出 staging 再导入。星盘对照是本分支的 `_compute_chart_sync`：不带 skip、两张盘串行。报告对照是本分支把「参照引擎已安装」强制打开，从而仍会起子进程；静态校验缓存和解释器查找缓存两边都开着。所以报告耗时差只含那 6 个注定失败的回放进程，不含静态校验少跑的那一次。静态校验「连调两次只跑一次」由单测覆盖。
-
-## 合盘两张盘
-
-| | 中位耗时 | 中位 `subprocess.run` 次数 | 盘面摘要 |
-| --- | --- | --- | --- |
-| 对照：不带 skip，串行 | 8.0596 秒 | 2 | — |
-| 本单：带 skip，并发 | 0.0166 秒 | 0 | 与对照逐字节一致 |
-
-0.0166 / 8.0596 ≈ 0.2%，低于「不超过对照 10%」的线。子进程从 2 降到 0。任务书写的「4 → 0」是按每张盘 2 个子进程、两张合计 4 个来估的。这台机器上两张盘合计只数到 2 次 `subprocess.run`。不带 skip 的 8 秒里，大部分是没装 SDK 时子进程空等，不是盘面计算本身。
-
-## 个人长报告（完整数据版，中英，带事实表）
-
-| | 中位耗时 | 中位 `subprocess.run` 次数 | 中英正文与事实表 |
-| --- | --- | --- | --- |
-| 对照：强制仍起回放子进程 | 16.5322 秒 | 7 | — |
-| 本单：没装参照引擎就不起 | 15.3235 秒 | 1 | 去掉易变字段后逐字节一致 |
-
-少 6 次，对应年度回放 3 次和 Tajika 3 次。剩下的 1 次两边都有，短路没有把它去掉。子进程数 1，低于「模拟生产不超过 3」的线。耗时 15.32 秒，不比对照的 16.53 秒差。本机没装 PyJHora，没有再跑「装了参照引擎」的一组；那种环境仍必须走子进程，单测用桩覆盖。
-
-生产上的收益仍按任务书：大约每份报告 0.5 到 0.9 秒，不是装了参照引擎的机器上看到的约 5 秒。
-
-## 名额方案模拟（没改规则）
-
-固定一分钟：2 份报告（每次 13 秒）、20 次咨询（每次 0.2 秒）、6 次校正打分（每次 8 秒）。随机种子 64。并发上限按现状 2。O2、O3、O4 只在脚本里模拟。
-
-| 方案 | 咨询被拒 | 报告被拒 | 校正被拒 | 同时在跑的最高个数 | 是否碰到「不得加池、不得提高并发」 |
-| --- | --- | --- | --- | --- | --- |
-| O1 现状 | 40% | 0% | 17% | 2 | 否 |
-| O2 咨询单独小池 | 0% | 0% | 17% | 3 | 是，本单不实现 |
-| O3 咨询最多再等 1.5 秒 | 30% | 0% | 33% | 2 | 否，本单不实现 |
-| O4 重任务最多占 1 个名额 | 0% | 0% | 67% | 2 | 否，本单不实现 |
-
-这是一分钟的草图，不是 staging 上的真实频率。咨询少被拒的时候，校正会多被拒（O3、O4）。O2 咨询不再被拒，但同时在跑的个数到了 3，越过了现在的上限。

frontend/DESIGN.md

@@ -1178,7 +1178,7 @@ D40 / D45 / D60 的表格上方，出生时间不是「已校正」时多一句
 | pada | 1–4，居中 |
 | 状态 | 尊贵 / 庙旺等，原样保留，只是挪到最后一列 |
 
-第一行是上升。星宿 / 宿主 / pada 用引擎按上升经度算出的值，和九曜同一个算法（2026-10-03，BUG-1201；之前引擎漏算，这三格一直是「—」）；旧缓存里没有这三项时仍写「—」，页面不自己推算。上升没有尊贵，状态格写「—」。数字列 `tabular-nums`，符号列与宿主列居中。
+第一行是上升。星宿 / 宿主 / pada 用引擎按上升经度算出的值，和九曜同一个算法（2026-10-03，BUG-1201；之前引擎漏算，这三格一直是「—」）；旧缓存里没有这三项时仍写「—」，页面不自己推算。上升没有尊贵，状态格写「不适用」（2026-10-15，与分盘表、报告同一口径；不再写「—」）。数字列 `tabular-nums`，符号列与宿主列居中。
 
 本轮不新增第二层页签：参照里「宫位 / 大运 / 星力 / 瑜伽」等页签的内容后续另立单。
 
@@ -1192,7 +1192,7 @@ D40 / D45 / D60 的表格上方，出生时间不是「已校正」时多一句
 | Bhava | 行星 · 黄道经度 · 星座宫 · Bhava 宫 · 换宫；另一张「宫 · 宫头 · 起点（sandhi）」12 行 | Sripati。换宫的行用 `--color-selected` 浅底。拿不到真实 MC 时这一栏走失败句，不画等宫（BUG-1077） |
 | 行运 | 行星 · 今天的位置 · 速度 · 落本命 · 本命同星 | 表头写计算时刻「行运 · YYYY-MM-DD 12:00（时区）」，上方一句「以本命上升为第 1 宫，放的是这一天中午的行星位置。岁差和交点与本命相同。」 |
 
-说明句 + 表格包在 `.chart-page-varga-table-block` 里，作为一个 grid 项在 ≥1024 时跨两列。宫位表头与对应数据格统一左对齐、相同 padding；包括本命/月亮、分盘、Bhava、行运。宿主、pada、速度、换宫等原本居中列不随之变化。本命/月亮八列 markup 冻结，通过限定八列表头的第四列 CSS 修正宫位，不能全局覆盖 `chart-page-planet-mid`。
+说明句 + 表格包在 `.chart-page-varga-table-block` 里，作为一个 grid 项在 ≥1024 时跨两列。宫位表头与对应数据格统一左对齐、相同 padding；包括本命/月亮、分盘、Bhava、行运。宿主、pada、速度、换宫等原本居中列不随之变化：表头与内容同为居中。本命/月亮八列 markup 冻结，速度、宿主、pada 的表头用列选择器居中，不改 markup，也不把宫位那一列居中。分盘的庙旺 / 同位、行运的速度、Bhava 的换宫，表头带 `chart-page-planet-mid`。不能全局覆盖 `chart-page-planet-mid` 去改宫位列。
 
 ### 三套坐标系
 
@@ -1214,7 +1214,7 @@ D40 / D45 / D60 的表格上方，出生时间不是「已校正」时多一句
 
 时间条只画时长大于 0 的段，宽度按时长。当前段用主文字色内描边，一条竖线标 `asOf`。两端是 `YYYY.MM`。0 年段不进这条轴。段色轮换现有的浅底 token（`--color-action-soft`、`--color-success-muted`、`--color-canvas-strong`、`--color-danger-muted`、`--color-selected`、`--color-canvas-muted`），不新造一套色。
 
-列表用原生 `<details>` / `<summary>`。只有当前段带 `open`。子运一行是「名称 · YYYY.MM – YYYY.MM」，日期 `tabular-nums` 靠右，当前子运用主文字色。`summary` 与子运行高 44px。未展开的子运列表用 `details:not([open]) > ul { display: none }` 收起。0 年段不是 `<details>`，文字用 `--color-ink-tertiary`，只写「0 年」和「本段时长为 0，不展开」。
+列表用原生 `<details>` / `<summary>`。只有当前段带 `open`。子运一行是「名称 · YYYY.MM – YYYY.MM」，日期 `tabular-nums` 靠右，当前子运用主文字色。`summary` 与子运行高 44px。未展开的子运列表用 `details:not([open]) > ul { display: none }` 收起。0 年段不是 `<details>`，文字用 `--color-ink-tertiary`，只写「0 年」和「本段时长为 0，不展开」。当前大运用浅底和细边框标出，不画左侧强调线。
 
 ### 西洋盘 Tab（2026-09-25）
 

frontend/src/app/api/chart-profiles/route.ts

@@ -56,7 +56,7 @@ export async function GET() {
       .order("updated_at", { ascending: false });
 
     if (error) throw error;
-    const profiles = (data ?? []).map((row: unknown) => toClientProfile(row as Record<string, unknown>));
+    const profiles = (data ?? []).map((row) => toClientProfile(row as Record<string, unknown>));
     return NextResponse.json({
       profiles,
       limit: MAX_SAVED_SUBJECTS,

frontend/src/app/api/synastry/route.ts

@@ -183,10 +183,8 @@ export async function POST(request: Request) {
       synastryBirthPayload(globalBirthProfileFromAccountRow(selfResolved.row)),
       synastryBirthPayload(globalBirthProfileFromAccountRow(partnerResolved.row)),
     ]);
-    const [selfChart, partnerChart] = await Promise.all([
-      postPython("/api/chart", { ...selfPayload, skip_vedastro_main_entry_overview: true }),
-      postPython("/api/chart", { ...partnerPayload, skip_vedastro_main_entry_overview: true }),
-    ]);
+    const selfChart = await postPython("/api/chart", selfPayload);
+    const partnerChart = await postPython("/api/chart", partnerPayload);
     const relationshipType = parsed.data.relationshipType === "business" || parsed.data.relationshipType === "family" || parsed.data.relationshipType === "general"
       ? parsed.data.relationshipType
       : "romance";
@@ -212,20 +210,18 @@ export async function POST(request: Request) {
         message: "该关系类型尚无可验证的专用合盘计算合同；已保留问题草稿。",
       });
     }
-    const [selfD9, partnerD9] = await Promise.all([
-      postPython("/api/varga_full", {
-        ...selfPayload,
-        planets: selfChart.planets,
-        ascendant: selfChart.ascendant,
-        divisions: ["D9"],
-      }),
-      postPython("/api/varga_full", {
-        ...partnerPayload,
-        planets: partnerChart.planets,
-        ascendant: partnerChart.ascendant,
-        divisions: ["D9"],
-      }),
-    ]);
+    const selfD9 = await postPython("/api/varga_full", {
+      ...selfPayload,
+      planets: selfChart.planets,
+      ascendant: selfChart.ascendant,
+      divisions: ["D9"],
+    });
+    const partnerD9 = await postPython("/api/varga_full", {
+      ...partnerPayload,
+      planets: partnerChart.planets,
+      ascendant: partnerChart.ascendant,
+      divisions: ["D9"],
+    });
     const synastry = await postPython("/api/synastry", {
       male_moon: moonLongitude(selfChart),
       female_moon: moonLongitude(partnerChart),

frontend/src/app/globals.css

@@ -5655,11 +5655,18 @@ input:not([type="radio"]):not([type="checkbox"]):not([class^="ant-"]):not([class
 .chart-page-planet-glyph.is-node,
 .ephemeris-transit-glyph.is-node { color: var(--color-planet-node); }
 .chart-page-planet-glyph.is-ascendant { color: var(--color-planet-ascendant); font-weight: 700; }
+.chart-page-planet-table th.chart-page-planet-mid,
 .chart-page-planet-table td.chart-page-planet-mid { text-align: center; }
-/* The natal/Moon eight-column markup stays frozen; only its house column changes. */
+/* The natal/Moon eight-column markup stays frozen; only its house column changes.
+   Speed, nakshatra lord and pada stay centered, including their headers. */
 .chart-page-planet-table:has(> thead > tr > th:nth-child(8)) > tbody > tr > td:nth-child(4) {
   text-align: left;
 }
+.chart-page-planet-table:has(> thead > tr > th:nth-child(8)) > thead > tr > th:nth-child(3),
+.chart-page-planet-table:has(> thead > tr > th:nth-child(8)) > thead > tr > th:nth-child(6),
+.chart-page-planet-table:has(> thead > tr > th:nth-child(8)) > thead > tr > th:nth-child(7) {
+  text-align: center;
+}
 /* Figures line up column-wise instead of drifting with glyph width. */
 .chart-page-planet-num { font-variant-numeric: tabular-nums; }
 .chart-page-boundary {
@@ -5774,7 +5781,6 @@ input:not([type="radio"]):not([type="checkbox"]):not([class^="ant-"]):not([class
 .chart-page-dasha-period.is-current {
   background: var(--color-selected);
   border-color: var(--color-border-strong);
-  box-shadow: inset 2px 0 0 var(--color-focus);
 }
 .chart-page-dasha-period.is-zero { color: var(--color-ink-tertiary); }
 .chart-page-dasha-period.is-zero span { margin-left: auto; }

frontend/src/components/chart-page/chart-vedic-tab.tsx

@@ -79,7 +79,7 @@ function PlanetRow({ row }: { row: ChartViewPlanetRow }) {
 
 /**
  * The ascendant is a chart point: nakshatra, lord and pada come from the
- * engine (BUG-1201); it has no dignity, so the status cell stays empty.
+ * engine (BUG-1201); it has no dignity, so the status cell says 不适用.
  * `house` is 1 except on the Moon chart, which counts from the Moon.
  */
 function AscendantRow({ row, house = row.house }: { row: ChartViewAscendantRow; house?: number }) {
@@ -96,7 +96,7 @@ function AscendantRow({ row, house = row.house }: { row: ChartViewAscendantRow;
         {row.nakshatraLord ? <BodyGlyph name={row.nakshatraLord} /> : "—"}
       </td>
       <td className="chart-page-planet-mid chart-page-planet-num">{row.pada ?? "—"}</td>
-      <td>—</td>
+      <td>不适用</td>
     </tr>
   );
 }
@@ -192,8 +192,8 @@ export function VargaTable({ varga }: { varga: ChartViewVarga }) {
             <th scope="col">分盘星座</th>
             <th scope="col">宫位</th>
             <th scope="col">本命星座</th>
-            {columns.supportsDignity && <th scope="col">庙旺</th>}
-            {columns.supportsVargottama && <th scope="col">同位</th>}
+            {columns.supportsDignity && <th scope="col" className="chart-page-planet-mid">庙旺</th>}
+            {columns.supportsVargottama && <th scope="col" className="chart-page-planet-mid">同位</th>}
           </tr>
         </thead>
         <tbody>
@@ -219,7 +219,7 @@ function TransitTable({ transit }: { transit: ChartViewTransitOk }) {
           <tr>
             <th scope="col">行星</th>
             <th scope="col">今天的位置</th>
-            <th scope="col">速度</th>
+            <th scope="col" className="chart-page-planet-mid">速度</th>
             <th scope="col">落本命</th>
             <th scope="col">本命同星</th>
           </tr>
@@ -257,7 +257,7 @@ function BhavaTables({ bhava }: { bhava: ChartViewBhavaOk }) {
               <th scope="col">黄道经度</th>
               <th scope="col">星座宫</th>
               <th scope="col">Bhava 宫</th>
-              <th scope="col">换宫</th>
+              <th scope="col" className="chart-page-planet-mid">换宫</th>
             </tr>
           </thead>
           <tbody>

frontend/src/lib/birth-time-journey-case-loader.ts

@@ -1,4 +1,4 @@
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import { z } from "zod";
 import {
   parseRectificationQuestionnaire,
@@ -34,7 +34,7 @@ export type JourneyLoadClient = {
   from(table: string): { select(columns: string): JourneyLoadQuery };
 };
 
-export function createJourneyLoadClient(supabase: DataClient): JourneyLoadClient {
+export function createJourneyLoadClient(supabase: SupabaseClient): JourneyLoadClient {
   return {
     from(table) {
       return {

frontend/src/lib/birth-time-journey-store.ts

@@ -1,6 +1,6 @@
 import "server-only";
 
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import type {
   BirthTimeJourneyStore,
 } from "./birth-time-journey-service.ts";
@@ -24,7 +24,7 @@ import { createDynamicScoringJobStore } from "./birth-time-dynamic-scoring-job-s
 export { BirthTimeJourneyStoreError } from "./birth-time-journey-turn-persistence.ts";
 
 export function createSupabaseBirthTimeJourneyStore(
-  supabase: DataClient,
+  supabase: SupabaseClient,
   now: () => Date = () => new Date(),
 ): BirthTimeJourneyStore {
   const loadClient = createJourneyLoadClient(supabase);

frontend/src/lib/birth-time-journey-turn-persistence.ts

@@ -1,4 +1,4 @@
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import { z } from "zod";
 import type { JourneySnapshot } from "./birth-time-journey.ts";
 import type { LegacyStoredRectificationCase, StoredRectificationCase } from "./birth-time-journey-service.ts";
@@ -56,7 +56,7 @@ function canonicalAskedDomains(input: readonly EvidenceDomain[]): readonly Evide
 }
 
 export function createJourneyTurnPersistence(
-  supabase: DataClient,
+  supabase: SupabaseClient,
   loadCase: (userId: string, caseId: string) => Promise<StoredRectificationCase | null>,
 ) {
   return {

frontend/src/lib/birth-time-scoring-job-store.ts

@@ -1,4 +1,4 @@
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import { z } from "zod";
 import { BirthTimeScoringJobError } from "./birth-time-scoring-job.ts";
 import type {
@@ -58,7 +58,7 @@ async function requireReloaded(
 }
 
 export function createSupabaseScoringJobStore(
-  supabase: DataClient,
+  supabase: SupabaseClient,
   loadCase: (userId: string, caseId: string) => Promise<StoredRectificationCase | null>,
 ): ScoringStoreMethods {
   return {
@@ -91,17 +91,18 @@ export function createSupabaseScoringJobStore(
     },
 
     async claimScoringJob(identity) {
-      const { data, error } = await supabase.rpc("claim_birth_time_scoring_job", {
-        p_user_id: identity.userId,
-        p_case_id: identity.caseId,
-        p_job_id: identity.jobId,
-        p_evidence_fingerprint: identity.evidenceFingerprint,
-        p_algorithm_version: identity.algorithmVersion,
-        p_now: identity.now,
-      });
+      const { data, error } = await supabase
+        .rpc("claim_birth_time_scoring_job", {
+          p_user_id: identity.userId,
+          p_case_id: identity.caseId,
+          p_job_id: identity.jobId,
+          p_evidence_fingerprint: identity.evidenceFingerprint,
+          p_algorithm_version: identity.algorithmVersion,
+          p_now: identity.now,
+        })
+        .single();
       if (error) throw mapScoringRpcError(error.message, error.code);
-      const row = Array.isArray(data) ? data[0] ?? null : data;
-      const parsed = claimSchema.safeParse(row);
+      const parsed = claimSchema.safeParse(data);
       if (!parsed.success) throw new BirthTimeJourneyStoreError("load_case");
       return {
         kind: parsed.data.claim_state,

frontend/src/lib/db/data-client.ts

@@ -1,46 +0,0 @@
-export type DataQueryError = Readonly<{ message: string; code?: string }>;
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- phase 1: equals SupabaseClient<any>; phase 2 narrows per table
-type UntypedData = any;
-
-export type DataQueryResult = Readonly<{
-  data: UntypedData;
-  error: DataQueryError | null;
-  count?: number | null;
-}>;
-
-export interface DataQueryBuilder extends PromiseLike<DataQueryResult> {
-  select(columns?: string): DataQueryBuilder;
-  insert(value: Record<string, unknown> | readonly Record<string, unknown>[]): DataQueryBuilder;
-  upsert(
-    value: Record<string, unknown> | readonly Record<string, unknown>[],
-    options?: { onConflict?: string },
-  ): DataQueryBuilder;
-  update(values: Record<string, unknown>): DataQueryBuilder;
-  delete(options?: { count?: string }): DataQueryBuilder;
-  eq(column: string, value: unknown): DataQueryBuilder;
-  neq(column: string, value: unknown): DataQueryBuilder;
-  gt(column: string, value: unknown): DataQueryBuilder;
-  lte(column: string, value: unknown): DataQueryBuilder;
-  like(column: string, value: unknown): DataQueryBuilder;
-  in(column: string, value: readonly unknown[]): DataQueryBuilder;
-  is(column: string, value: unknown): DataQueryBuilder;
-  not(column: string, operator: string, value: unknown): DataQueryBuilder;
-  or(expression: string): DataQueryBuilder;
-  order(column: string, options?: { ascending?: boolean }): DataQueryBuilder;
-  limit(value: number): DataQueryBuilder;
-  abortSignal(signal: AbortSignal): DataQueryBuilder;
-  single(): Promise<DataQueryResult>;
-  maybeSingle(): Promise<DataQueryResult>;
-}
-
-export interface DataClient {
-  readonly auth: Readonly<{
-    getUser: () => Promise<{
-      data: { user: { id: string; email?: string | null } | null };
-      error: unknown;
-    }>;
-  }>;
-  from(table: string): DataQueryBuilder;
-  rpc(fn: string, args?: Readonly<Record<string, unknown>>): Promise<DataQueryResult>;
-}

frontend/src/lib/db/local-postgres-client-core.ts

@@ -1,5 +1,4 @@
 import { Pool, type PoolClient } from "pg";
-import type { DataClient, DataQueryBuilder } from "./data-client";
 
 type LocalIdentity = Readonly<{ id: string; email: string | null }> | null;
 export type LocalDatabaseRole = "authenticated" | "service_role";
@@ -458,7 +457,7 @@ export function queryValue(type: string | undefined, value: unknown): unknown {
   return value;
 }
 
-class LocalPostgresQueryBuilder implements DataQueryBuilder {
+class LocalPostgresQueryBuilder implements PromiseLike<QueryResult> {
   private selectedColumns: string[] | null = null;
   private mutation: Mutation | null = null;
   private readonly filters: Filter[] = [];
@@ -864,7 +863,7 @@ function castType(value: string): string {
   return value;
 }
 
-export class LocalPostgresDataClient implements DataClient {
+export class LocalPostgresDataClient {
   readonly auth: Readonly<{
     getUser: () => Promise<
       Readonly<{

frontend/src/lib/rectification-agentic/v9/case-service.ts

@@ -8,7 +8,7 @@
  */
 import { createHash } from "node:crypto";
 import { requestCandidateIntervals, type DatedCandidateRange } from "../core/candidate-window.ts";
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import { resolveMissingBirthTimezoneOffset } from "../../birth-profile-timezone.ts";
 import { declaredClockRange } from "../../declared-birth-window.ts";
 import {
@@ -43,7 +43,7 @@ import {
   type RectificationEntrySummary,
 } from "./open-request.ts";
 
-type AccountingClient = DataClient;
+type AccountingClient = SupabaseClient;
 
 export type V9BaselineSnapshot = Readonly<{
   birth_date: string;

frontend/src/lib/rectification-agentic/v9/product-domain.ts

@@ -1,4 +1,4 @@
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import { RectificationCaseServiceError } from "./case-service.ts";
 import type { OpenRectificationCaseRequest } from "./open-request.ts";
 
@@ -17,7 +17,7 @@ const domainsBySessionTheme: Readonly<Record<string, string>> = {
 
 /** Only an owned persisted consultation is a product-domain source. */
 export async function resolveRectificationProductDomain(
-  client: DataClient,
+  client: SupabaseClient,
   userId: string,
   request: OpenRectificationCaseRequest,
 ): Promise<string> {

frontend/src/lib/rectification-agentic/v9/tool-service.ts

@@ -44,7 +44,7 @@ import { decisionStateFingerprint } from "../core/decision-fingerprint";
 const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 /**
- * Minimal structural RPC client. DataClient satisfies this; tests can
+ * Minimal structural RPC client. SupabaseClient satisfies this; tests can
  * pass a fake with a single rpc() method.
  */
 export type RectificationRpcClient = {

frontend/src/lib/rectification-in-chat-server.ts

@@ -1,6 +1,6 @@
 import "server-only";
 
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import { resolveFeaturePricing } from "@/lib/feature-pricing";
 import { isProductEnabled } from "@/lib/product-access";
 import { getRectificationEntrySummary } from "@/lib/rectification-agentic/v9/case-service";
@@ -27,7 +27,7 @@ import {
 
 /** C3: whether the offer card may be shown, decided by the server and never by the model. */
 export async function decideRectificationOffer(input: {
-  accounting: DataClient;
+  accounting: SupabaseClient;
   userId: string;
   subjectRole: "self" | "other";
   modelId: string;
@@ -42,7 +42,7 @@ export async function decideRectificationOffer(input: {
 
 type SessionRow = { id: string; messages: unknown; session_type?: string | null };
 
-async function readConsultationSession(client: DataClient, userId: string, sessionId: string): Promise<SessionRow | null> {
+async function readConsultationSession(client: SupabaseClient, userId: string, sessionId: string): Promise<SessionRow | null> {
   const { data, error } = await client
     .from("chat_sessions")
     .select("id,messages,session_type")
@@ -54,7 +54,7 @@ async function readConsultationSession(client: DataClient, userId: string, sessi
   return (row.session_type ?? "consultation") === "consultation" ? row : null;
 }
 
-async function writeMessages(client: DataClient, userId: string, sessionId: string, messages: unknown[]): Promise<boolean> {
+async function writeMessages(client: SupabaseClient, userId: string, sessionId: string, messages: unknown[]): Promise<boolean> {
   const { error } = await client
     .from("chat_sessions")
     .update({ messages })
@@ -71,7 +71,7 @@ async function writeMessages(client: DataClient, userId: string, sessionId: stri
  * Does not touch consultation_requests.
  */
 export async function persistOpenedDirectOffer(input: {
-  client: DataClient;
+  client: SupabaseClient;
   userId: string;
   sessionId: string;
   sentence: string;
@@ -96,7 +96,7 @@ export async function persistOpenedDirectOffer(input: {
 
 /** C4: after a case opens from a consultation, bind the offer card to it. Best effort. */
 export async function bindRectificationSource(input: {
-  client: DataClient;
+  client: SupabaseClient;
   userId: string;
   sourceSessionId: string;
   caseId: string;
@@ -118,7 +118,7 @@ const SOURCE_SEARCH_LIMIT = 20;
  * from history has none.
  */
 export async function findRectificationSource(
-  client: DataClient,
+  client: SupabaseClient,
   userId: string,
   caseId: string,
 ): Promise<RectificationSource | null> {
@@ -139,8 +139,8 @@ export async function findRectificationSource(
  * never from the browser.
  */
 export async function returnToRectificationSource(input: {
-  client: DataClient;
-  accounting: DataClient;
+  client: SupabaseClient;
+  accounting: SupabaseClient;
   userId: string;
   caseId: string;
   now?: () => Date;

frontend/src/lib/supabase/admin-client-core.ts

@@ -1,12 +1,11 @@
-import { createClient } from "@supabase/supabase-js";
-import type { DataClient } from "@/lib/db/data-client";
+import { createClient, type SupabaseClient } from "@supabase/supabase-js";
 import { createLocalPostgresDataClient } from "@/lib/db/local-postgres-client-core";
 import {
   getSupabaseUrl,
   SupabaseConfigurationError,
 } from "./config";
 
-export function createAdminSupabaseClient(): DataClient {
+export function createAdminSupabaseClient() {
   if (process.env.AUTH_PROVIDER?.trim() === "self-hosted") {
     const connectionString = process.env.SERVICE_DATABASE_URL?.trim();
     if (!connectionString) {
@@ -19,7 +18,7 @@ export function createAdminSupabaseClient(): DataClient {
       connectionString,
       null,
       "service_role",
-    ) as DataClient;
+    ) as unknown as SupabaseClient;
   }
   const url = getSupabaseUrl();
   const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
@@ -27,10 +26,9 @@ export function createAdminSupabaseClient(): DataClient {
     throw new SupabaseConfigurationError(["SUPABASE_SERVICE_ROLE_KEY"]);
   }
 
-  // 回滚分支，运行时形状是超集
   return createClient(url, serviceRoleKey, {
     auth: { autoRefreshToken: false, persistSession: false },
-  }) as unknown as DataClient;
+  });
 }
 
 export function isAdminEmail(email: string | null | undefined) {

frontend/src/lib/supabase/server.ts

@@ -1,8 +1,8 @@
 import "server-only";
 
 import { createServerClient } from "@supabase/ssr";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import { cookies, headers } from "next/headers";
-import type { DataClient } from "@/lib/db/data-client";
 import { createLocalPostgresDataClient } from "@/lib/db/local-postgres-client";
 import { readDatabaseUrl } from "@/lib/db/config";
 import { getIdentityAuthServices } from "@/modules/identity/auth";
@@ -11,7 +11,7 @@ import { getSupabasePublicConfig } from "./config";
 
 export async function createServerSupabaseClient(options?: {
   readonly disableCookieCache?: boolean;
-}): Promise<DataClient> {
+}) {
   if (process.env.AUTH_PROVIDER?.trim() === "self-hosted") {
     const requestHeaders = new Headers(await headers());
     const session = await readIdentitySession(
@@ -22,12 +22,11 @@ export async function createServerSupabaseClient(options?: {
     return createLocalPostgresDataClient(
       readDatabaseUrl(process.env, "APP_DATABASE_URL"),
       session ? { id: session.user.id, email: session.user.email } : null,
-    ) as DataClient;
+    ) as unknown as SupabaseClient;
   }
   const { url, anonKey } = getSupabasePublicConfig();
   const cookieStore = await cookies();
 
-  // 回滚分支，运行时形状是超集
   return createServerClient(url, anonKey, {
     cookies: {
       getAll: () => cookieStore.getAll(),
@@ -41,5 +40,5 @@ export async function createServerSupabaseClient(options?: {
         }
       },
     },
-  }) as unknown as DataClient;
+  });
 }

frontend/src/mastra/rectification-v9-tools.ts

@@ -12,7 +12,7 @@
 import { windowIntervalsWidth } from "../lib/rectification-agentic/core/candidate-window.ts";
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
-import type { DataClient } from "@/lib/db/data-client";
+import type { SupabaseClient } from "@supabase/supabase-js";
 import type { PublicRectificationMethod } from "@/lib/rectification-agentic/v9/public-receipt";
 import {
   canonicalToolInputFingerprint,
@@ -196,7 +196,7 @@ export type RectificationV9Context = Readonly<{
   turnId: string;
   attemptId?: string;
   userMessage?: string | null;
-  accounting: DataClient;
+  accounting: SupabaseClient;
   engineBase?: string;
   decision?: RectificationDecision;
   productDelivery?: import("../lib/rectification-agentic/v9/product-delivery.ts").ProductDelivery | null;

frontend/tests/chart-bhava.test.tsx

@@ -90,6 +90,7 @@ test("Sripati rows, cusps and the drawn houses follow the engine's Bhava houses"
   assert.match(markup, /<dt>交点<\/dt>/);
   assert.doesNotMatch(markup, /Swiss Ephemeris|>引擎</);
   assert.match(markup, /<caption>Bhava · Sripati<\/caption>/);
+  assert.match(markup, /<th scope="col" class="chart-page-planet-mid">换宫<\/th>/);
   assert.match(markup, /<caption>宫头与宫界<\/caption>/);
   assert.equal((markup.match(/class="is-shifted"/g) ?? []).length, shifted.length);
   assert.equal((markup.match(/<td class="chart-page-planet-mid">是<\/td>/g) ?? []).length, shifted.length);

frontend/tests/chart-moon-transit.test.tsx

@@ -87,6 +87,12 @@ test("the Moon chart is the D1 counted from the Moon's sign, projected without a
   const markup = renderToStaticMarkup(React.createElement(ChartVedicTab, { view, vargaId: "MOON", onSelectVarga: () => {} }));
   assert.match(markup, /<caption>月亮盘 · 以月亮所在星座（[^）]+）为第 1 宫<\/caption>/);
   assert.deepEqual(ascendantMarkHouses(markup), [moon.ascendantHouse], "the lagna mark sits in the natal ascendant's house");
+  const table = markup.slice(markup.indexOf("月亮盘"));
+  const ascendantRow = table.match(/<th scope="row">[\s\S]*?上升[\s\S]*?<\/tr>/)?.[0] ?? "";
+  assert.match(ascendantRow, /<td>Uttara Phalguni<\/td>/);
+  assert.match(ascendantRow, /is-sun/);
+  assert.match(ascendantRow, />1</);
+  assert.match(ascendantRow, />不适用</);
 });
 
 test("a chart counted from the ascendant still draws the lagna mark in house 1 only", async () => {
@@ -125,7 +131,8 @@ test("the transit layer posts today's noon with the natal ayanamsa and node mode
 
   const markup = renderToStaticMarkup(React.createElement(ChartVedicTab, { view, vargaId: "TRANSIT", onSelectVarga: () => {} }));
   assert.match(markup, /<caption>行运 · 2026-09-15 12:00（Asia\/Shanghai）<\/caption>/);
-  for (const column of ["行星", "今天的位置", "速度", "落本命", "本命同星"]) assert.match(markup, new RegExp(`<th scope="col">${column}</th>`));
+  for (const column of ["行星", "今天的位置", "落本命", "本命同星"]) assert.match(markup, new RegExp(`<th scope="col">${column}</th>`));
+  assert.match(markup, /<th scope="col" class="chart-page-planet-mid">速度<\/th>/);
   assert.ok(markup.includes(CHART_VIEW_COPY.transitNote));
   assert.match(markup, /<dl class="chart-page-params-table">/);
   assert.match(markup, /<dt>岁差<\/dt>/);

frontend/tests/chart-page-mobile-width-20260929.test.ts

@@ -48,7 +48,21 @@ test("the Vedic waiting slot reserves the result legend band without changing th
 
 test("only the house column in frozen natal and Moon tables overrides centering", () => {
   assert.match(cssDeclarations(".chart-page-planet-table td.chart-page-planet-mid", globalStyles), /text-align:\s*center/);
+  assert.match(cssDeclarations(".chart-page-planet-table th.chart-page-planet-mid", globalStyles), /text-align:\s*center/);
   assert.match(cssDeclarations(".chart-page-planet-table:has(> thead > tr > th:nth-child(8)) > tbody > tr > td:nth-child(4)", globalStyles), /text-align:\s*left/);
+  for (const child of [3, 6, 7]) {
+    assert.match(
+      cssDeclarations(`.chart-page-planet-table:has(> thead > tr > th:nth-child(8)) > thead > tr > th:nth-child(${child})`, globalStyles),
+      /text-align:\s*center/,
+    );
+  }
+});
+
+test("the current dasha card keeps its tint and drops the left accent line", () => {
+  const current = cssDeclarations(".chart-page-dasha-period.is-current", globalStyles);
+  assert.match(current, /background:\s*var\(--color-selected\)/);
+  assert.match(current, /border-color:\s*var\(--color-border-strong\)/);
+  assert.doesNotMatch(current, /box-shadow/);
 });
 
 test("wide chart-page content still scrolls inside its own box instead of widening the page", () => {

frontend/tests/chart-request-skip-contract.test.ts

@@ -1,44 +0,0 @@
-import assert from "node:assert/strict";
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-
-const frontendRoot = fileURLToPath(new URL("../", import.meta.url));
-const roots = ["src/app/api", "src/lib"];
-// Empty on purpose. A call site that cannot send skip must be listed here with a reason.
-const allowlist: string[] = [];
-
-function walk(dir: string): string[] {
-  const found: string[] = [];
-  for (const name of readdirSync(dir)) {
-    const full = path.join(dir, name);
-    if (statSync(full).isDirectory()) found.push(...walk(full));
-    else if (name.endsWith(".ts") || name.endsWith(".tsx")) found.push(full);
-  }
-  return found;
-}
-
-test("python /api/chart bodies from app/api and lib send skip", () => {
-  const failures: string[] = [];
-  for (const root of roots) {
-    for (const file of walk(path.join(frontendRoot, root))) {
-      const rel = path.relative(frontendRoot, file).replaceAll("\\", "/");
-      if (allowlist.includes(rel)) continue;
-      const text = readFileSync(file, "utf8");
-      const re = /["']\/api\/chart["']/g;
-      let match: RegExpExecArray | null;
-      while ((match = re.exec(text))) {
-        const idx = match.index;
-        const before = text.slice(Math.max(0, idx - 120), idx);
-        if (!/postPython\s*\(|callEngine\s*\(|fetchEngine\s*\(|fetch\s*\(/.test(before)) continue;
-        const window = text.slice(Math.max(0, idx - 40), idx + 420);
-        const sendsSkip = window.includes("skip_vedastro_main_entry_overview: true")
-          || window.includes("transitChartBody(")
-          || (/["']\/api\/chart["']\s*,\s*payload/.test(window) && text.includes("skip_vedastro_main_entry_overview: true"));
-        if (!sendsSkip) failures.push(`${rel}:${text.slice(0, idx).split("\n").length}`);
-      }
-    }
-  }
-  assert.deepEqual(failures, []);
-});

frontend/tests/chart-varga-table.test.tsx

@@ -99,8 +99,11 @@ test("the D1 table is byte-for-byte the table the page drew before BUG-1076, asc
   // (Leo 29°23′ = Uttara Phalguni pada 1, lord Sun), where the baseline had dashes.
   const baseline = readFileSync(new URL("./fixtures/chart-d1-table-baseline.html", import.meta.url), "utf8");
   const dashes = '<td>—</td><td class="chart-page-planet-mid">—</td><td class="chart-page-planet-mid chart-page-planet-num">—</td><td>—</td>';
+  // 原值：上升行状态格 <td>—</td>
+  // 新值：<td>不适用</td>
+  // 原因：产品把「—」看成没数据。上升没有尊贵，与分盘表、报告同一口径写「不适用」。基线文件仍是改前的表。
   const filled = '<td>Uttara Phalguni</td><td class="chart-page-planet-mid"><span class="chart-page-planet-glyph is-sun">☉</span></td>'
-    + '<td class="chart-page-planet-mid chart-page-planet-num">1</td><td>—</td>';
+    + '<td class="chart-page-planet-mid chart-page-planet-num">1</td><td>不适用</td>';
   assert.equal(baseline.split(dashes).length, 2, "the baseline's ascendant row is the only all-dash row");
   assert.equal(table, baseline.replace(dashes, filled));
 });
@@ -113,6 +116,8 @@ test("the D1 ascendant row shows the engine's nakshatra, lord and pada", async (
   const ascendant = row(render(view, "D1"), "上升");
   assert.match(ascendant, /<td>Uttara Phalguni<\/td>/);
   assert.match(ascendant, /is-sun/, "Uttara Phalguni's lord is the Sun");
+  assert.match(ascendant, />1</, "pada 1");
+  assert.match(ascendant, />不适用</);
   // An older cached chart without the fields still renders, with dashes.
   const chart = structuredClone(golden.chart);
   for (const key of ["nakshatra", "nakshatra_pada", "nakshatra_lord"]) delete (chart.ascendant as Record<string, unknown>)[key];
@@ -136,6 +141,8 @@ test("divisional rows carry engine dignity and vargottama, and drop nakshatra co
   const markup = render(view, "D9");
   const header = markup.match(/<thead>([\s\S]*?)<\/thead>/)?.[1] ?? "";
   for (const column of ["行星", "分盘星座", "宫位", "本命星座", "庙旺", "同位"]) assert.match(header, new RegExp(`>${column}<`));
+  assert.match(header, /<th scope="col" class="chart-page-planet-mid">庙旺<\/th>/);
+  assert.match(header, /<th scope="col" class="chart-page-planet-mid">同位<\/th>/);
   assert.doesNotMatch(header, /星宿|宿主|pada/);
   // Same wording as the D1 status column (BUG-1202), friendship levels included.
   // 原值：同位行星单元格是「同位」，非同位是「—」

frontend/tests/database-scoring-job-claim-shape.test.ts

@@ -1,157 +0,0 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-
-import {
-  closeLocalPostgresDataPools,
-  createLocalPostgresDataClient,
-} from "../src/lib/db/local-postgres-client-core.ts";
-import type { DataClient } from "../src/lib/db/data-client.ts";
-import { birthTimeScoringAlgorithmVersion } from "../src/lib/birth-time-scoring-job.ts";
-import { createSupabaseScoringJobStore } from "../src/lib/birth-time-scoring-job-store.ts";
-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 ids = {
-  user: "e1111111-1111-4111-8111-111111111111",
-  caseId: "e2222222-2222-4222-8222-222222222222",
-  job: "e3333333-3333-4333-8333-333333333333",
-  shapeJob: "e4444444-4444-4444-8444-444444444444",
-};
-
-const fingerprint = "claim-shape-fingerprint";
-
-function sqlLiteral(value: string): string {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-
-const identity = {
-  userId: ids.user,
-  caseId: ids.caseId,
-  jobId: ids.job,
-  evidenceFingerprint: fingerprint,
-  algorithmVersion: birthTimeScoringAlgorithmVersion,
-  now: "2026-10-15T00:00:00.000Z",
-};
-
-test("claimScoringJob reads the first row when rpc returns an array", async () => {
-  const rpc = async () => ({
-    data: [{ claim_state: "claimed", algorithm_version: birthTimeScoringAlgorithmVersion }],
-    error: null,
-  });
-  const store = createSupabaseScoringJobStore({ rpc } as unknown as DataClient, async () => null);
-  const claim = await store.claimScoringJob(identity);
-  assert.deepEqual(claim, {
-    kind: "claimed",
-    algorithmVersion: birthTimeScoringAlgorithmVersion,
-  });
-});
-
-test("claimScoringJob also accepts the single-object rpc shape", async () => {
-  const rpc = async () => ({
-    data: { claim_state: "processing", algorithm_version: birthTimeScoringAlgorithmVersion },
-    error: null,
-  });
-  const store = createSupabaseScoringJobStore({ rpc } as unknown as DataClient, async () => null);
-  const claim = await store.claimScoringJob(identity);
-  assert.deepEqual(claim, {
-    kind: "processing",
-    algorithmVersion: birthTimeScoringAlgorithmVersion,
-  });
-});
-
-test("claim_birth_time_scoring_job returns an array and claimScoringJob accepts it", { skip: skipWithoutDocker }, async () => {
-  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,
-      JSON.stringify({
-        status: migration.status,
-        stderr: migration.stderr,
-        stdoutTail: String(migration.stdout).slice(-1500),
-      }),
-    );
-
-    fixture.psqlAs(
-      "identity_runtime",
-      "identity-runtime-test-password",
-      `insert into identity.users (id, name, email, email_verified, email_verified_at)
-       values (${sqlLiteral(ids.user)}, 'Claim Shape', 'claim-shape@example.com', true, now());`,
-    );
-    fixture.psql(`
-      insert into public.birth_time_rectification_cases (
-        id, user_id, status, reported_date, source
-      ) values (
-        ${sqlLiteral(ids.caseId)}, ${sqlLiteral(ids.user)}, 'rectifying', '1990-01-01', 'family_exact'
-      );
-      insert into public.birth_time_rectification_scoring_jobs (
-        id, case_id, user_id, evidence_fingerprint, algorithm_version, status, expires_at
-      ) values (
-        ${sqlLiteral(ids.job)}, ${sqlLiteral(ids.caseId)}, ${sqlLiteral(ids.user)},
-        ${sqlLiteral(fingerprint)}, ${sqlLiteral(birthTimeScoringAlgorithmVersion)},
-        'pending', '2026-10-15T01:00:00Z'
-      ), (
-        ${sqlLiteral(ids.shapeJob)}, ${sqlLiteral(ids.caseId)}, ${sqlLiteral(ids.user)},
-        ${sqlLiteral(`${fingerprint}-shape`)}, ${sqlLiteral(birthTimeScoringAlgorithmVersion)},
-        'pending', '2026-10-15T01:00:00Z'
-      );
-      update public.birth_time_rectification_cases
-      set journey_protocol = 'legacy-guided-v1',
-          turn_state = ${sqlLiteral(JSON.stringify({
-            nextAction: { kind: "score_pending", jobId: ids.shapeJob },
-          }))}::jsonb
-      where id = ${sqlLiteral(ids.caseId)};
-    `);
-
-    const client = createLocalPostgresDataClient(
-      fixture.connectionUrl("service_runtime", "service-runtime-test-password"),
-      null,
-      "service_role",
-    );
-    const direct = await client.rpc("claim_birth_time_scoring_job", {
-      p_user_id: ids.user,
-      p_case_id: ids.caseId,
-      p_job_id: ids.shapeJob,
-      p_evidence_fingerprint: `${fingerprint}-shape`,
-      p_algorithm_version: birthTimeScoringAlgorithmVersion,
-      p_now: identity.now,
-    });
-    assert.equal(direct.error, null, direct.error?.message);
-    assert.equal(Array.isArray(direct.data), true);
-    assert.equal(direct.data[0]?.claim_state, "claimed");
-
-    fixture.psql(`
-      update public.birth_time_rectification_cases
-      set turn_state = ${sqlLiteral(JSON.stringify({
-        nextAction: { kind: "score_pending", jobId: ids.job },
-      }))}::jsonb
-      where id = ${sqlLiteral(ids.caseId)};
-    `);
-    const store = createSupabaseScoringJobStore(client, async () => null);
-    const claim = await store.claimScoringJob(identity);
-    assert.deepEqual(claim, {
-      kind: "claimed",
-      algorithmVersion: birthTimeScoringAlgorithmVersion,
-    });
-  } finally {
-    await closeLocalPostgresDataPools();
-    fixture.stop();
-  }
-});

frontend/tests/fixtures/chart-view-golden.json

@@ -1,5 +1,5 @@
 {
-  "sourceCommand": "anaconda python: domain_calculation_service.compute_chart + compute_vimshottari_timeline; divisional_charts_extended.DivisionalChartsCalculator; jaimini.calc_chara_dasha_with_antardasha (pratyantar_dashas stripped; unused by the page); western_chart_engine.build_tropical_natal_chart. Fictional 1990-06-15 12:00 Beijing 39.9042N 116.4074E tz+8 Raman mean node. D40/D45/D60 appended 2026-09-28 from the same chart.planets[*].lon and ascendant.lon via DivisionalChartsCalculator._calculate_single_varga (recompute of D9/D10/D30 from those inputs equals the stored ones). 2026-10-03 (BUG-1201/1202): chart.ascendant nakshatra fields from jyotish_engine._nakshatra_fields(ascendant.lon) and varga_full.result[*].planets[*].dignity_level from scripts/varga_dignity.annotate_varga_dignity on the stored positions (the same calls /api/chart and /api/varga_full now make).",
+  "sourceCommand": "anaconda python: domain_calculation_service.compute_chart + compute_vimshottari_timeline; divisional_charts_extended.DivisionalChartsCalculator; jaimini.calc_chara_dasha_with_antardasha (pratyantar_dashas stripped; unused by the page); western_chart_engine.build_tropical_natal_chart. Fictional 1990-06-15 12:00 Beijing 39.9042N 116.4074E tz+8 Raman mean node. D40/D45/D60 appended 2026-09-28 from the same chart.planets[*].lon and ascendant.lon via DivisionalChartsCalculator._calculate_single_varga (recompute of D9/D10/D30 from those inputs equals the stored ones). 2026-10-03 (BUG-1202): varga_full.result[*].planets[*].dignity_level from scripts/varga_dignity.annotate_varga_dignity on the stored positions. 2026-10-15 (BUG-1352): chart.ascendant nakshatra, nakshatra_pada and nakshatra_lord are the fields returned by JyotishAPIHandler._compute_chart_sync for this birth (tests/test_api_chart_ascendant_nakshatra.py); they are not filled in by hand.",
   "chart": {
     "success": true,
     "birth": {

frontend/tests/synastry-chart-skip.test.ts

@@ -1,103 +0,0 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-
-const frontendRoot = fileURLToPath(new URL("../", import.meta.url));
-const partnerId = "11111111-1111-4111-8111-111111111111";
-
-function runRoute(script: string): { romance: Record<string, unknown>; business: Record<string, unknown>; maxChart: number; maxVarga: number; chartSkip: boolean } {
-  const result = spawnSync(process.execPath, [
-    "--experimental-test-module-mocks",
-    "--import",
-    "tsx",
-    "--input-type=module",
-    "--eval",
-    script,
-  ], { cwd: frontendRoot, encoding: "utf8", timeout: 20000 });
-  assert.equal(result.status, 0, result.stderr || result.stdout);
-  const line = result.stdout.trim().split("\n").at(-1) ?? "{}";
-  return JSON.parse(line);
-}
-
-test("synastry charts send skip concurrently and keep the stubbed JSON", () => {
-  const script = String.raw`
-    import { mock } from "node:test";
-    import { pathToFileURL } from "node:url";
-    const moduleUrl = (path) => pathToFileURL(process.cwd() + "/" + path).href;
-    mock.module("server-only", { namedExports: {} });
-    mock.module("@/lib/account-deletion-server", { namedExports: { refuseWhenAccountDeletionPending: async () => null } });
-    mock.module("@/lib/product-access", { namedExports: { isProductEnabled: async () => true } });
-    mock.module("@/lib/request-rate-limit", { namedExports: { consumeUserRequestRateLimit: () => ({ ok: true, retryAfterSeconds: 1 }) } });
-    mock.module("@/lib/supabase/server", { namedExports: { createServerSupabaseClient: async () => ({ auth: { getUser: async () => ({ data: { user: { id: "user-1" } }, error: null }) } }) } });
-    mock.module("@/lib/subject-birth", { namedExports: {
-      ConsultationSubjectError: class ConsultationSubjectError extends Error {},
-      loadSubjectBirth: async () => ({ chartable: true, row: { name: "fixture" } }),
-    } });
-    mock.module("@/lib/server-owned-birth-profile", { namedExports: { globalBirthProfileFromAccountRow: (row) => row } });
-    mock.module("@/lib/global-birth-payloads", { namedExports: {
-      synastryBirthPayload: async () => ({ year: 1990, month: 1, day: 1, hour: 12, minute: 0, lat: 28.6139, lon: 77.209, tz: 5.5, ayanamsa: "lahiri" }),
-    } });
-    const chartBodies = [];
-    const maxInflight = { chart: 0, varga: 0 };
-    const inflight = { chart: 0, varga: 0 };
-    const waiters = { chart: [], varga: [] };
-    globalThis.fetch = async (inputUrl, init) => {
-      const url = String(inputUrl);
-      const body = JSON.parse(String(init.body));
-      const kind = url.endsWith("/api/chart") ? "chart" : url.endsWith("/api/varga_full") ? "varga" : "other";
-      if (kind === "chart") chartBodies.push(body);
-      if (kind === "chart" || kind === "varga") {
-        inflight[kind] += 1;
-        maxInflight[kind] = Math.max(maxInflight[kind], inflight[kind]);
-        await new Promise((resolve) => {
-          waiters[kind].push(resolve);
-          if (waiters[kind].length >= 2) {
-            const pending = waiters[kind].splice(0, 2);
-            pending.forEach((fn) => fn());
-          }
-        });
-        inflight[kind] -= 1;
-      }
-      if (url.endsWith("/api/chart")) {
-        return Response.json({
-          planets: { Moon: { lon: 12.5, sign: "Aries", nakshatra: "Ashwini", nakshatra_pada: 1, nakshatra_lord: "Ketu" } },
-          ascendant: { sign: "Leo" },
-        });
-      }
-      if (url.endsWith("/api/varga_full")) {
-        const divisions = body.divisions || [];
-        if (divisions.includes("D9")) {
-          return Response.json({ source: "engine", result: { D9_Navamsa: { ascendant: { sign: "Virgo" }, planets: { Moon: { sign: "Cancer" }, Venus: { sign: "Taurus" }, Mars: { sign: "Aries" } } } } });
-        }
-        return Response.json({ source: "engine", result: {
-          D2_Hora: { planets: { Moon: { sign: "Taurus" } } },
-          D10_Dasamsa: { ascendant: { sign: "Libra" } },
-          D11_Rudramsa: { planets: { Sun: { sign: "Capricorn" } } },
-        } });
-      }
-      if (url.endsWith("/api/synastry")) return Response.json({ total_score: 18, max_score: 36 });
-      return Response.json({}, { status: 500 });
-    };
-    const { POST } = await import(moduleUrl("src/app/api/synastry/route.ts"));
-    const romanceRes = await POST(new Request("https://example.test/api/synastry", { method: "POST", body: JSON.stringify({ partnerChartProfileId: "${partnerId}", relationshipType: "romance" }) }));
-    const romance = await romanceRes.json();
-    const businessRes = await POST(new Request("https://example.test/api/synastry", { method: "POST", body: JSON.stringify({ partnerChartProfileId: "${partnerId}", relationshipType: "business" }) }));
-    const business = await businessRes.json();
-    console.log(JSON.stringify({ romance, business, maxChart: maxInflight.chart, maxVarga: maxInflight.varga, chartSkip: chartBodies.every((body) => body.skip_vedastro_main_entry_overview === true) && chartBodies.length === 4 }));
-  `;
-  const got = runRoute(script);
-  assert.equal(got.maxChart, 2);
-  assert.equal(got.maxVarga, 2);
-  assert.equal(got.chartSkip, true);
-  assert.equal(got.romance.status, "ok");
-  assert.equal(got.romance.method, "ashtakoot_plus_moon_nakshatra_d9");
-  assert.deepEqual(got.romance.selfChart, {
-    moon: { sign: "Aries", nakshatra: "Ashwini", pada: 1, lord: "Ketu", longitude: 12.5 },
-    d9: { ascendant: { sign: "Virgo" }, moon: { sign: "Cancer" }, venus: { sign: "Taurus" }, mars: { sign: "Aries" }, source: "engine" },
-  });
-  assert.equal((got.romance.relationshipReport as { scoreBand?: string }).scoreBand, "mixed");
-  assert.equal(got.business.status, "ok");
-  assert.equal(got.business.method, "d2_d10_d11_business_screening_partial");
-  assert.equal((got.business.relationshipReport as { scoreBand?: string }).scoreBand, "not_scored");
-});

scripts/annual_pyjhora_replay.py

@@ -9,7 +9,6 @@ from __future__ import annotations
 
 import contextlib
 import hashlib
-import importlib.util
 import json
 import subprocess
 import sys
@@ -23,34 +22,6 @@ from typing import Any, Callable
 
 ENGINE = "PyJHora/JHora"
 REPO_ROOT = Path(__file__).resolve().parents[1]
-_jhora_spec_cache: bool | None = None
-
-
-def reset_jhora_import_cache() -> None:
-    """Tests reset the process-local "is PyJHora installed?" answer."""
-    global _jhora_spec_cache
-    _jhora_spec_cache = None
-
-
-def _jhora_importable() -> bool:
-    global _jhora_spec_cache
-    if _jhora_spec_cache is None:
-        _jhora_spec_cache = importlib.util.find_spec("jhora") is not None
-    return _jhora_spec_cache
-
-
-def _no_jhora_tajaka_replay(settings: dict[str, Any]) -> dict[str, Any]:
-    """Same dict the child returns when ``import jhora`` raises ModuleNotFoundError."""
-    copied = dict(settings)
-    return {
-        "status": "blocked",
-        "reason": "pyjhora_ayanamsa_configuration_failed:ModuleNotFoundError",
-        "settings": copied,
-        "node_mode": {
-            "requested": copied.get("node_mode"),
-            "status": "unsupported_by_replay_adapter",
-        },
-    }
 _TAJAKA_YEAR_LORD_MODULE = "jhora.horoscope.transit.tajaka"
 _YEAR_LORD_MODULES = (
     "jhora.horoscope.dhasa.annual.mudda",
@@ -168,10 +139,6 @@ def _run_isolated_tajaka_year_lord(
         "settings": settings,
     }
     request_hash = _request_hash(request)
-    if not _jhora_importable():
-        replay = _no_jhora_tajaka_replay(settings)
-        replay["request_hash"] = request_hash
-        return replay
     command = [
         sys.executable,
         "-c",
@@ -309,10 +276,6 @@ def _run_isolated_annual_replay(
         "settings": settings,
     }
     request_hash = _request_hash(request)
-    if not _jhora_importable():
-        replay = _no_jhora_annual_replay(settings)
-        replay["request_hash"] = request_hash
-        return replay
     command = [
         sys.executable,
         "-c",
@@ -428,18 +391,6 @@ def _annual_worker_result(
     }
 
 
-def _no_jhora_annual_replay(settings: dict[str, Any]) -> dict[str, Any]:
-    """Same dict the annual child returns when ``import jhora`` raises ModuleNotFoundError."""
-    copied = dict(settings)
-    node_mode = {"requested": copied.get("node_mode"), "status": "unsupported_by_replay_adapter"}
-    reason = "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError"
-    return _annual_worker_result(
-        {key: {"status": "blocked", "reason": reason} for key in _ANNUAL_SURFACE_KEYS},
-        settings=copied,
-        node_mode=node_mode,
-    )
-
-
 def _annual_replay_blocked(reason: str, request_hash: str, settings: dict[str, Any]) -> dict[str, Any]:
     return _annual_worker_result(
         {key: {"status": "blocked", "reason": reason} for key in _ANNUAL_SURFACE_KEYS},

scripts/api_heavy_compute_gate.py

@@ -8,17 +8,13 @@ must not call this gate.
 
 from __future__ import annotations
 
-import logging
 import os
 import threading
-import time
 
 DEFAULT_CONCURRENCY = 2
 DEFAULT_RETRY_AFTER_SECONDS = 2
 ENV_CONCURRENCY = "JYOTISH_HEAVY_COMPUTE_CONCURRENCY"
 ENV_RETRY_AFTER = "JYOTISH_HEAVY_COMPUTE_RETRY_AFTER_SECONDS"
-ENV_GATE_CHART_OVERVIEW = "JYOTISH_GATE_CHART_OVERVIEW"
-_LOG = logging.getLogger("jyotish.heavy_compute")
 
 HEAVY_COMPUTE_PATHS = frozenset(
     {
@@ -50,26 +46,6 @@ HEAVY_COMPUTE_PATHS = frozenset(
 _state_lock = threading.Lock()
 _semaphore: threading.BoundedSemaphore | None = None
 _retry_after_seconds = DEFAULT_RETRY_AFTER_SECONDS
-_limit = DEFAULT_CONCURRENCY
-_holders: list[dict] = []
-_holder_seq = 0
-
-
-class _HeldSlot:
-    """One acquired heavy-compute permit, paired with the path that holds it."""
-
-    def __init__(self, semaphore: threading.BoundedSemaphore, holder_id: int) -> None:
-        self._semaphore = semaphore
-        self._holder_id = holder_id
-        self._released = False
-
-    def release(self) -> None:
-        with _state_lock:
-            if self._released:
-                return
-            self._released = True
-            _holders[:] = [item for item in _holders if item["id"] != self._holder_id]
-            self._semaphore.release()
 
 
 class HeavyComputeBusy(RuntimeError):
@@ -104,7 +80,7 @@ def reset_heavy_compute_gate(
     retry_after_seconds: int | None = None,
 ) -> None:
     """Rebuild the process-wide semaphore. Tests must call this after env changes."""
-    global _semaphore, _retry_after_seconds, _limit, _holders
+    global _semaphore, _retry_after_seconds
     resolved_limit = (
         limit
         if limit is not None
@@ -117,96 +93,31 @@ def reset_heavy_compute_gate(
     )
     with _state_lock:
         _retry_after_seconds = resolved_retry
-        _limit = resolved_limit
-        _holders = []
         _semaphore = threading.BoundedSemaphore(resolved_limit)
 
 
 def _ensure_locked() -> tuple[threading.BoundedSemaphore, int]:
-    global _semaphore, _retry_after_seconds, _limit
+    global _semaphore, _retry_after_seconds
     if _semaphore is None:
-        _limit = _parse_positive_int(os.environ.get(ENV_CONCURRENCY), DEFAULT_CONCURRENCY)
+        limit = _parse_positive_int(os.environ.get(ENV_CONCURRENCY), DEFAULT_CONCURRENCY)
         _retry_after_seconds = _parse_positive_int(
             os.environ.get(ENV_RETRY_AFTER), DEFAULT_RETRY_AFTER_SECONDS
         )
-        _semaphore = threading.BoundedSemaphore(_limit)
+        _semaphore = threading.BoundedSemaphore(limit)
     return _semaphore, _retry_after_seconds
 
 
-def _holder_view(now: float) -> list[dict]:
-    return [
-        {
-            "path": item["path"],
-            "held_seconds": round(max(now - item["started"], 0.0), 3),
-        }
-        for item in _holders
-    ]
-
-
-def _acquire_recorded(path: str) -> _HeldSlot:
-    """Take one permit and remember which path holds it. Fail fast when full."""
-    global _holder_seq
-    with _state_lock:
-        semaphore, retry_after = _ensure_locked()
-        if not semaphore.acquire(blocking=False):
-            snapshot = _holder_view(time.monotonic())
-            failed = True
-            slot = None
-        else:
-            _holder_seq += 1
-            holder_id = _holder_seq
-            _holders.append({"id": holder_id, "path": path, "started": time.monotonic()})
-            failed = False
-            snapshot = []
-            slot = _HeldSlot(semaphore, holder_id)
-    if failed:
-        _LOG.warning(
-            "heavy_compute_busy rejected_path=%s holders=%s",
-            path,
-            snapshot,
-        )
-        raise HeavyComputeBusy(retry_after)
-    assert slot is not None
-    return slot
-
-
-def acquire_heavy_compute_slot(path: str) -> _HeldSlot | None:
+def acquire_heavy_compute_slot(path: str) -> threading.BoundedSemaphore | None:
     """Acquire a slot for a gated path. Light paths return None. Fail-fast on saturation."""
     if not is_heavy_compute_path(path):
         return None
-    return _acquire_recorded(path)
-
-
-def _chart_overview_gate_enabled() -> bool:
-    return os.environ.get(ENV_GATE_CHART_OVERVIEW, "").strip() == "1"
-
-
-def acquire_heavy_compute_slot_for_request(path: str, body: dict | None) -> _HeldSlot | None:
-    """Path gate, plus the chart-overview switch and the warm-consultation exception.
-
-    ``/api/chart`` stays out of ``HEAVY_COMPUTE_PATHS``. It takes a slot only when
-    ``JYOTISH_GATE_CHART_OVERVIEW=1``, the body does not skip the VedAstro overview,
-    and the body is not an async enqueue. Default is off.
-    """
-    payload = body if isinstance(body, dict) else {}
-    if path == "/api/consultation_workflow" and payload.get("consult_card_warm_only") is True:
-        return None
-    if path == "/api/chart" and _chart_overview_gate_enabled():
-        if payload.get("async") or payload.get("enqueue"):
-            return None
-        if payload.get("skip_vedastro_main_entry_overview"):
-            return None
-        return _acquire_recorded(path)
-    return acquire_heavy_compute_slot(path)
-
-
-def heavy_compute_status() -> dict:
-    """Process-local counts only. No request body and no user identity."""
     with _state_lock:
-        _ensure_locked()
-        return {"limit": _limit, "in_use": len(_holders)}
+        semaphore, retry_after = _ensure_locked()
+    if not semaphore.acquire(blocking=False):
+        raise HeavyComputeBusy(retry_after)
+    return semaphore
 
 
-def release_heavy_compute_slot(slot: _HeldSlot | None) -> None:
+def release_heavy_compute_slot(slot: threading.BoundedSemaphore | None) -> None:
     if slot is not None:
         slot.release()

scripts/jyotish_api_server.py

@@ -122,13 +122,13 @@ except ModuleNotFoundError:  # pragma: no cover - script execution path
 try:
     from scripts.api_heavy_compute_gate import (
         HeavyComputeBusy,
-        acquire_heavy_compute_slot_for_request,
+        acquire_heavy_compute_slot,
         release_heavy_compute_slot,
     )
 except ModuleNotFoundError:  # pragma: no cover - script execution path
     from api_heavy_compute_gate import (
         HeavyComputeBusy,
-        acquire_heavy_compute_slot_for_request,
+        acquire_heavy_compute_slot,
         release_heavy_compute_slot,
     )
 
@@ -2589,12 +2589,24 @@ def _vedastro_runtime_fingerprint() -> dict:
     }
 
 
+def _chart_ascendant_nakshatra(ascendant_data: dict, lon: float) -> dict:
+    """Keep the engine's nakshatra fields when /api/chart rebuilds the ascendant."""
+    fields = {
+        key: ascendant_data[key]
+        for key in ('nakshatra', 'nakshatra_pada', 'nakshatra_lord')
+        if ascendant_data.get(key) not in (None, '')
+    }
+    if 'nakshatra' in fields:
+        return fields
+    return _load_local_module('jyotish_engine')._nakshatra_fields(lon)
+
+
 def _build_api_chart_cache_payload(body: dict) -> dict:
     import api_scratch_retention as retention
 
     today = body.get('today') or body.get('current_date')
     return {
-        'cache_schema_version': 6,
+        'cache_schema_version': 7,
         'birth': retention.normalize_chart_cache_birth(body),
         'calculation': {
             'ayanamsa': _request_ayanamsa(body),
@@ -3345,10 +3357,14 @@ class JyotishAPIHandler(BaseHTTPRequestHandler, VedastroEvidenceMixin, SynastryM
         try:
             self._enforce_request_security(require_json=True)
             body = self._read_json_body()
-            # Warm chart-save must not take a slot (BUG-1302). Chart overview
-            # gating is off unless JYOTISH_GATE_CHART_OVERVIEW=1. Both live in
-            # the gate module so this file only keeps the call.
-            compute_slot = acquire_heavy_compute_slot_for_request(path, body)
+            # Chart-save warm builds today's packet on the same route. It must
+            # not take a heavy-compute slot: the cap is 2, and a question asked
+            # right after save would otherwise come back 429.
+            warm_only = (
+                path == '/api/consultation_workflow'
+                and body.get('consult_card_warm_only') is True
+            )
+            compute_slot = None if warm_only else acquire_heavy_compute_slot(path)
             if path == '/api/location/resolve':
                 city = str(body.get('city') or '').strip()
                 city_aliases = {'beijing': '北京', 'shanghai': '上海', 'guangzhou': '广州', 'shenzhen': '深圳'}
@@ -6659,6 +6675,7 @@ class JyotishAPIHandler(BaseHTTPRequestHandler, VedastroEvidenceMixin, SynastryM
                     'degree': round(asc_lon % 30, 2),
                     'degree_in_sign': round(asc_lon % 30, 2),
                     'lon': round(asc_lon, 4),
+                    **_chart_ascendant_nakshatra(ascendant_data, asc_lon),
                 },
                 'planets': planets_data, 'houses': houses, 'shadbala': shadbala_summary,
                 'dasha': {

scripts/jyotish_engine.py

@@ -10762,25 +10762,7 @@ def _planet_snapshot(planets, planet_name):
     }
 
 
-_oracle_progress_cache: dict = {}
-
-
-def reset_oracle_progress_snapshot_cache():
-    """Tests clear the static-file validation cache."""
-    _oracle_progress_cache.clear()
-
-
-def _oracle_progress_cache_key(oracle_file):
-    try:
-        stat = oracle_file.stat()
-    except OSError:
-        return None
-    mtime = getattr(stat, 'st_mtime_ns', stat.st_mtime)
-    return (str(oracle_file.resolve()), mtime, stat.st_size)
-
-
 def _oracle_progress_snapshot():
-    cache_key = None
     try:
         import json
         import subprocess
@@ -10790,9 +10772,6 @@ def _oracle_progress_snapshot():
 
         root = Path(__file__).resolve().parents[1]
         oracle_file = root / 'references' / 'oracle' / 'dasha_shadbala_oracle_cases.json'
-        cache_key = _oracle_progress_cache_key(oracle_file)
-        if cache_key is not None and cache_key in _oracle_progress_cache:
-            return _oracle_progress_cache[cache_key]
         with tempfile.TemporaryDirectory() as temp_dir:
             queue_path = Path(temp_dir) / 'oracle-queue.json'
             queue = subprocess.run(
@@ -10818,7 +10797,7 @@ def _oracle_progress_snapshot():
                 raise RuntimeError(validation.stderr.strip() or validation.stdout.strip())
             report = json.loads(validation.stdout)
         summary = report.get('summary', {})
-        result = {
+        return {
             'scope': 'external_oracle_evidence_validation',
             'collection_queue': 'external_oracle_collection_queue',
             'total_packets': summary.get('total_packets', 0),
@@ -10830,7 +10809,7 @@ def _oracle_progress_snapshot():
             'boundary': report.get('boundary', 'Dasha/Shadbala absolute values are not externally calibrated until enough packets pass validation.'),
         }
     except Exception as exc:
-        result = {
+        return {
             'scope': 'external_oracle_evidence_validation',
             'collection_queue': 'external_oracle_collection_queue',
             'total_packets': 0,
@@ -10841,9 +10820,6 @@ def _oracle_progress_snapshot():
             'promotion_rule': 'external_verified requires source_artifact, filled target values, and non-local-engine external evidence.',
             'boundary': f'Oracle progress unavailable: {exc}',
         }
-    if cache_key is not None:
-        _oracle_progress_cache[cache_key] = result
-    return result
 
 
 # Combustion orbs of the full reading (Step 5 shadbala block). The Moon, Rahu

scripts/research/api_chart_subprocess_ab.py

@@ -1,291 +0,0 @@
-"""A/B for issue #64. A is this branch with the PyJHora short-circuit forced off
-(the staging control flow: always spawn). B is the short-circuit on.
-
-Chart skip/concurrency is measured on the real chart call. The gate schemes
-O2/O3/O4 are simulated only and are not implemented.
-
-Volatile fields dropped before the report byte compare:
-generated_at, created_at, timestamp, elapsed_seconds, elapsed_ms, duration_ms, request_id.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import random
-import statistics
-import subprocess
-import sys
-import tempfile
-import threading
-import time
-from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[2]
-sys.path.insert(0, str(ROOT))
-sys.path.insert(0, str(ROOT / "scripts"))
-
-os.environ.setdefault("JYOTISH_API_CHART_CACHE_TTL_SECONDS", "0")
-os.environ.setdefault("VEDASTRO_ENABLE_NETWORK", "0")
-os.environ.setdefault("JYOTISH_GATE_CHART_OVERVIEW", "0")
-
-import annual_pyjhora_replay as replay  # noqa: E402
-import tajika as tajika_top  # noqa: E402
-from scripts.jyotish_api_server import JyotishAPIHandler  # noqa: E402
-from scripts.jyotish_engine import reset_oracle_progress_snapshot_cache  # noqa: E402
-from scripts.professional_report_reference import build_professional_report_reference  # noqa: E402
-from scripts.tajika import reset_external_pyjhora_python_cache  # noqa: E402
-
-BIRTH = {
-    "year": 1990,
-    "month": 1,
-    "day": 1,
-    "hour": 12,
-    "minute": 0,
-    "second": 0,
-    "lat": 28.6139,
-    "lon": 77.2090,
-    "tz": 5.5,
-    "ayanamsa": "lahiri",
-    "node_mode": "true",
-}
-PARTNER = {**BIRTH, "year": 1992, "day": 2}
-VOLATILE = {"generated_at", "created_at", "timestamp", "elapsed_seconds", "elapsed_ms", "duration_ms", "request_id"}
-
-
-class _Counter:
-    def __init__(self) -> None:
-        self.n = 0
-        self._real = subprocess.run
-        self._lock = threading.Lock()
-
-    def install(self) -> None:
-        def _run(*args, **kwargs):
-            with self._lock:
-                self.n += 1
-            return self._real(*args, **kwargs)
-
-        subprocess.run = _run  # type: ignore[assignment]
-        for module in list(sys.modules.values()):
-            bound = getattr(module, "subprocess", None)
-            if getattr(bound, "run", None) is self._real:
-                bound.run = _run  # type: ignore[union-attr]
-
-    def reset(self) -> None:
-        with self._lock:
-            self.n = 0
-
-
-def _median(values: list[float]) -> float:
-    return statistics.median(values) if values else 0.0
-
-
-def _strip(value):
-    if isinstance(value, dict):
-        return {key: _strip(item) for key, item in value.items() if key not in VOLATILE}
-    if isinstance(value, list):
-        return [_strip(item) for item in value]
-    return value
-
-
-def _canon(value) -> str:
-    return json.dumps(_strip(value), sort_keys=True, ensure_ascii=True, default=str)
-
-
-def _chart_summary(chart: dict) -> dict:
-    planets = chart.get("planets") if isinstance(chart, dict) else None
-    moon = planets.get("Moon") if isinstance(planets, dict) else None
-    lon = None
-    if isinstance(moon, dict):
-        lon = moon.get("lon", moon.get("longitude"))
-    return {
-        "ascendant": chart.get("ascendant") if isinstance(chart, dict) else None,
-        "planets": planets,
-        "moon_longitude": lon,
-    }
-
-
-def _one_chart(body: dict) -> tuple[float, dict]:
-    started = time.perf_counter()
-    chart = object.__new__(JyotishAPIHandler)._compute_chart_sync(body)
-    return time.perf_counter() - started, chart
-
-
-def _measure_charts(counter: _Counter) -> dict:
-    serial_times = []
-    concurrent_times = []
-    serial_subs = []
-    concurrent_subs = []
-    same = True
-    for _ in range(3):
-        counter.reset()
-        started = time.perf_counter()
-        _, self_a = _one_chart(BIRTH)
-        _, partner_a = _one_chart(PARTNER)
-        serial_times.append(time.perf_counter() - started)
-        serial_subs.append(counter.n)
-        counter.reset()
-        started = time.perf_counter()
-        with ThreadPoolExecutor(max_workers=2) as pool:
-            self_b = pool.submit(_one_chart, {**BIRTH, "skip_vedastro_main_entry_overview": True})
-            partner_b = pool.submit(_one_chart, {**PARTNER, "skip_vedastro_main_entry_overview": True})
-            _, self_chart = self_b.result()
-            _, partner_chart = partner_b.result()
-        concurrent_times.append(time.perf_counter() - started)
-        concurrent_subs.append(counter.n)
-        same = same and _canon(_chart_summary(self_a)) == _canon(_chart_summary(self_chart))
-        same = same and _canon(_chart_summary(partner_a)) == _canon(_chart_summary(partner_chart))
-    return {
-        "serial_seconds_median": round(_median(serial_times), 4),
-        "concurrent_skip_seconds_median": round(_median(concurrent_times), 4),
-        "serial_subprocesses_median": _median(serial_subs),
-        "concurrent_skip_subprocesses_median": _median(concurrent_subs),
-        "summary_bytes_match": same,
-    }
-
-
-def _measure_report(counter: _Counter, *, spawn: bool) -> dict:
-    times = []
-    subs = []
-    payload = None
-    body = {**BIRTH, "format": "markdown", "edition": "full_data", "languages": ["zh", "en"], "include_fact_tables": True}
-    for _ in range(3):
-        replay.reset_jhora_import_cache()
-        if spawn:
-            replay._jhora_spec_cache = True
-        reset_oracle_progress_snapshot_cache()
-        reset_external_pyjhora_python_cache()
-        tajika_top.reset_external_pyjhora_python_cache()
-        counter.reset()
-        started = time.perf_counter()
-        payload = build_professional_report_reference(
-            object.__new__(JyotishAPIHandler),
-            body,
-        )
-        times.append(time.perf_counter() - started)
-        subs.append(counter.n)
-    return {
-        "seconds_median": round(_median(times), 4),
-        "subprocesses_median": _median(subs),
-        "payload": payload,
-    }
-
-
-def _simulate() -> list[dict]:
-    """One fixed minute. O2 adds a second pool and is the only scheme that touches BUG-717."""
-    rng = random.Random(64)
-    arrivals = [("report", index * 30.0, 13.0) for index in range(2)]
-    arrivals += [("consult", rng.random() * 60.0, 0.2) for _ in range(20)]
-    arrivals += [("score", rng.random() * 60.0, 8.0) for _ in range(6)]
-    arrivals.sort(key=lambda item: item[1])
-
-    def run(mode: str) -> dict:
-        heavy: list[tuple[float, str]] = []
-        light: list[float] = []
-        rejected = {"consult": 0, "report": 0, "score": 0}
-        accepted = {"consult": 0, "report": 0, "score": 0}
-        peak = 0
-
-        def occupy(at: float) -> tuple[int, int]:
-            running = [item for item in heavy if item[0] > at]
-            lights = [item for item in light if item > at]
-            return len(running), len(lights)
-
-        for kind, arrival, duration in arrivals:
-            heavy_n, light_n = occupy(arrival)
-            heavy = [item for item in heavy if item[0] > arrival]
-            light = [item for item in light if item > arrival]
-            placed = False
-            stamp = arrival
-            if mode == "O2" and kind == "consult":
-                if light_n < 2:
-                    light.append(arrival + duration)
-                    placed = True
-            elif mode == "O3" and kind == "consult":
-                start = arrival
-                while start <= arrival + 1.5:
-                    heavy_n, _light_n = occupy(start)
-                    if heavy_n < 2:
-                        heavy.append((start + duration, kind))
-                        placed = True
-                        stamp = start
-                        break
-                    nxt = min(item[0] for item in heavy)
-                    if nxt > arrival + 1.5:
-                        break
-                    start = nxt
-            elif mode == "O4" and kind != "consult":
-                heavy_jobs = sum(1 for _end, slot in heavy if slot != "consult")
-                if heavy_jobs < 1 and heavy_n < 2:
-                    heavy.append((arrival + duration, kind))
-                    placed = True
-            else:
-                if heavy_n < 2:
-                    heavy.append((arrival + duration, kind))
-                    placed = True
-            if placed:
-                accepted[kind] += 1
-            else:
-                rejected[kind] += 1
-            running, lights = occupy(stamp)
-            peak = max(peak, running + lights)
-
-        def rate(kind: str) -> str:
-            total = accepted[kind] + rejected[kind]
-            return "0" if total == 0 else f"{rejected[kind] / total:.2f}"
-
-        return {
-            "scheme": mode,
-            "consult_429": rate("consult"),
-            "report_429": rate("report"),
-            "score_429": rate("score"),
-            "peak": peak,
-            "touches_bug_717": mode == "O2",
-        }
-
-    return [run(mode) for mode in ("O1", "O2", "O3", "O4")]
-
-
-def resolve_record_path(explicit: str | None) -> Path:
-    """Write the A/B JSON only where asked. The committed note stays untouched."""
-    if explicit:
-        return Path(explicit)
-    directory = Path(tempfile.mkdtemp(prefix="api-chart-subprocess-ab-"))
-    return directory / "api-chart-subprocess-gate-ab-20261013.json"
-
-
-def main(argv: list[str] | None = None) -> None:
-    parser = argparse.ArgumentParser(description="A/B for issue #64 chart subprocess gate")
-    parser.add_argument(
-        "--out",
-        default=None,
-        help="Write the JSON record to this path. Omit to use a fresh temp directory, not the committed docs/testing file.",
-    )
-    args = parser.parse_args(argv)
-    counter = _Counter()
-    counter.install()
-    charts = _measure_charts(counter)
-    forced = _measure_report(counter, spawn=True)
-    native = _measure_report(counter, spawn=False)
-    report_match = _canon(forced["payload"]) == _canon(native["payload"])
-    schemes = _simulate()
-    out = {
-        "charts": charts,
-        "report_forced_subprocess": {key: value for key, value in forced.items() if key != "payload"},
-        "report_short_circuit": {key: value for key, value in native.items() if key != "payload"},
-        "report_bytes_match": report_match,
-        "schemes": schemes,
-        "jhora_installed": False,
-    }
-    text = json.dumps(out, ensure_ascii=False, indent=2)
-    dest = resolve_record_path(args.out)
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    dest.write_text(text + "\n", encoding="utf-8")
-    print(dest, file=sys.stderr)
-    print(text)
-
-
-if __name__ == "__main__":
-    main()

scripts/tajika.py

@@ -1501,28 +1501,7 @@ print(json.dumps({str(k): float(v) for k, v in dict(scores).items()}))
         return None
 
 
-_external_pyjhora_python_cached = False
-_external_pyjhora_python_value: Optional[str] = None
-
-
-def reset_external_pyjhora_python_cache() -> None:
-    """Tests and a fresh process both start with no remembered interpreter."""
-    global _external_pyjhora_python_cached, _external_pyjhora_python_value
-    _external_pyjhora_python_cached = False
-    _external_pyjhora_python_value = None
-
-
 def _resolve_external_pyjhora_python() -> Optional[str]:
-    """Remember the lookup, including "not installed", for this process."""
-    global _external_pyjhora_python_cached, _external_pyjhora_python_value
-    if _external_pyjhora_python_cached:
-        return _external_pyjhora_python_value
-    _external_pyjhora_python_value = _lookup_external_pyjhora_python()
-    _external_pyjhora_python_cached = True
-    return _external_pyjhora_python_value
-
-
-def _lookup_external_pyjhora_python() -> Optional[str]:
     candidates = [
         os.environ.get('JYOTISH_PYJHORA_PYTHON'),
         shutil.which('python3.14'),

tests/fixtures/api-chart-subprocess-gate/README.txt

@@ -1,6 +0,0 @@
-Generated 2026-10-15 by calling the isolated workers with PyJHora absent
-(importlib.util.find_spec("jhora") is None on the Windows venv):
-
-  .venv\Scripts\python -c "import json; from scripts.annual_pyjhora_replay import _isolated_tajaka_worker, _isolated_annual_worker; req={'birth_julian_day':2447893.0,'place':{'name':'Delhi','latitude':28.6139,'longitude':77.209,'timezone':5.5,'elevation':0},'age':30,'settings':{'ayanamsa':'LAHIRI','node_mode':'mean'}}; print(json.dumps(_isolated_tajaka_worker(req), sort_keys=True)); print(json.dumps(_isolated_annual_worker(req), sort_keys=True, default=str))"
-
-The parent adds request_hash after this body. The short-circuit must match this body.

tests/fixtures/api-chart-subprocess-gate/annual-no-jhora.json

@@ -1,41 +0,0 @@
-{
-  "annual_chart_snapshot": {
-    "reason": "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError",
-    "status": "blocked"
-  },
-  "annual_chart_speed_snapshot": {
-    "reason": "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError",
-    "status": "blocked"
-  },
-  "effective_ayanamsa": null,
-  "evidence_scope": "pyjhora_behavior_only",
-  "mudda_dasha": {
-    "reason": "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError",
-    "status": "blocked"
-  },
-  "node_mode": {
-    "requested": "mean",
-    "status": "unsupported_by_replay_adapter"
-  },
-  "parity_status": "not_multiengine_parity",
-  "patyayini_dasha": {
-    "reason": "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError",
-    "status": "blocked"
-  },
-  "sahams": {
-    "reason": "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError",
-    "status": "blocked"
-  },
-  "settings": {
-    "ayanamsa": "LAHIRI",
-    "node_mode": "mean"
-  },
-  "solar_return_boundary": {
-    "reason": "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError",
-    "status": "blocked"
-  },
-  "tajika_yogas": {
-    "reason": "pyjhora_annual_adapter_setup_failed:ModuleNotFoundError",
-    "status": "blocked"
-  }
-}

tests/fixtures/api-chart-subprocess-gate/tajaka-no-jhora.json

@@ -1,12 +0,0 @@
-{
-  "node_mode": {
-    "requested": "mean",
-    "status": "unsupported_by_replay_adapter"
-  },
-  "reason": "pyjhora_ayanamsa_configuration_failed:ModuleNotFoundError",
-  "settings": {
-    "ayanamsa": "LAHIRI",
-    "node_mode": "mean"
-  },
-  "status": "blocked"
-}

tests/test_api_chart_ascendant_nakshatra.py

@@ -0,0 +1,56 @@
+"""The chart API must keep the ascendant nakshatra the engine already computed."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPTS = ROOT / "scripts"
+TESTS = ROOT / "tests"
+for path in (SCRIPTS, TESTS):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+import jyotish_api_server  # noqa: E402
+from test_api_server_security import _handler  # noqa: E402
+
+BEIJING = {
+    "year": 1990,
+    "month": 6,
+    "day": 15,
+    "hour": 12,
+    "minute": 0,
+    "second": 0,
+    "lat": 39.9042,
+    "lon": 116.4074,
+    "tz": 8,
+    "ayanamsa": "raman",
+    "node_mode": "mean",
+    "transit_date": "2026-10-15",
+    "skip_vedastro_main_entry_overview": True,
+}
+
+
+def test_api_chart_keeps_ascendant_nakshatra_from_the_engine(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("JYOTISH_API_CHART_CACHE_TTL_SECONDS", "0")
+    monkeypatch.setenv("VEDASTRO_ENABLE_NETWORK", "0")
+    monkeypatch.setattr(
+        jyotish_api_server,
+        "_attach_vedastro_main_entry_overview",
+        lambda result, _birth: result,
+    )
+    engine = jyotish_api_server._load_local_module("jyotish_engine")
+    result = _handler()._compute_chart_sync(BEIJING)
+    lon = result["ascendant"]["lon"]
+    expected = engine._nakshatra_fields(lon)
+
+    for packet in (result["ascendant"], result["modules"]["chart"]["ascendant"]):
+        assert packet["nakshatra"] == expected["nakshatra"]
+        assert packet["nakshatra_pada"] == expected["nakshatra_pada"]
+        assert packet["nakshatra_lord"] == expected["nakshatra_lord"]
+    assert result["ascendant"]["nakshatra"] == "Uttara Phalguni"
+    assert result["ascendant"]["nakshatra_pada"] == 1
+    assert result["ascendant"]["nakshatra_lord"] == "Sun"

tests/test_api_chart_subprocess_gate.py

@@ -1,197 +0,0 @@
-"""Issue #64: skip useless report subprocesses and observe the heavy-compute gate."""
-
-from __future__ import annotations
-
-import json
-import logging
-from pathlib import Path
-
-import pytest
-
-from scripts import api_heavy_compute_gate as gate
-from scripts.annual_pyjhora_replay import (
-    _run_isolated_annual_replay,
-    _run_isolated_tajaka_year_lord,
-    reset_jhora_import_cache,
-)
-from scripts.jyotish_engine import (
-    _oracle_progress_snapshot,
-    reset_oracle_progress_snapshot_cache,
-)
-from scripts.tajika import (
-    _resolve_external_pyjhora_python,
-    reset_external_pyjhora_python_cache,
-)
-
-ROOT = Path(__file__).resolve().parents[1]
-FIXTURES = ROOT / "tests" / "fixtures" / "api-chart-subprocess-gate"
-
-
-class _Place:
-    name = "Delhi"
-    latitude = 28.6139
-    longitude = 77.209
-    timezone = 5.5
-    elevation = 0
-
-
-_PROFILE = {"ayanamsa": "LAHIRI", "node_mode": "mean"}
-
-
-def _without_hash(payload: dict) -> dict:
-    body = dict(payload)
-    body.pop("request_hash", None)
-    return body
-
-
-def test_no_jhora_tajaka_skips_subprocess_and_matches_golden(monkeypatch) -> None:
-    reset_jhora_import_cache()
-    monkeypatch.setattr("scripts.annual_pyjhora_replay._jhora_importable", lambda: False)
-
-    def _forbid_subprocess(*_args, **_kwargs):
-        raise AssertionError("subprocess.run must not run when jhora cannot be imported")
-
-    monkeypatch.setattr("scripts.annual_pyjhora_replay.subprocess.run", _forbid_subprocess)
-    result = _run_isolated_tajaka_year_lord(_PROFILE, 2447893.0, _Place(), 30)
-    golden = json.loads((FIXTURES / "tajaka-no-jhora.json").read_text(encoding="utf-8"))
-    assert result["request_hash"]
-    assert _without_hash(result) == golden
-
-
-def test_no_jhora_annual_skips_subprocess_and_matches_golden(monkeypatch) -> None:
-    reset_jhora_import_cache()
-    monkeypatch.setattr("scripts.annual_pyjhora_replay._jhora_importable", lambda: False)
-
-    def _forbid_subprocess(*_args, **_kwargs):
-        raise AssertionError("subprocess.run must not run when jhora cannot be imported")
-
-    monkeypatch.setattr("scripts.annual_pyjhora_replay.subprocess.run", _forbid_subprocess)
-    result = _run_isolated_annual_replay(_PROFILE, 2447893.0, _Place(), 30)
-    golden = json.loads((FIXTURES / "annual-no-jhora.json").read_text(encoding="utf-8"))
-    assert result["request_hash"]
-    assert _without_hash(result) == golden
-
-
-def test_jhora_available_still_uses_subprocess(monkeypatch) -> None:
-    reset_jhora_import_cache()
-    monkeypatch.setattr("scripts.annual_pyjhora_replay._jhora_importable", lambda: True)
-    calls = {"n": 0}
-
-    class _Completed:
-        returncode = 0
-        stdout = json.dumps({"status": "partial_verified", "settings": {}})
-
-    def _fake_run(*_args, **_kwargs):
-        calls["n"] += 1
-        return _Completed()
-
-    monkeypatch.setattr("scripts.annual_pyjhora_replay.subprocess.run", _fake_run)
-    tajaka = _run_isolated_tajaka_year_lord(_PROFILE, 2447893.0, _Place(), 30)
-    annual = _run_isolated_annual_replay(_PROFILE, 2447893.0, _Place(), 30)
-    assert calls["n"] == 2
-    assert tajaka["request_hash"]
-    assert annual["request_hash"]
-
-
-def test_pyjhora_interpreter_lookup_is_cached(monkeypatch) -> None:
-    reset_external_pyjhora_python_cache()
-    calls = {"n": 0}
-
-    def _missing():
-        calls["n"] += 1
-        return None
-
-    monkeypatch.setattr("scripts.tajika._lookup_external_pyjhora_python", _missing)
-    assert _resolve_external_pyjhora_python() is None
-    assert _resolve_external_pyjhora_python() is None
-    assert calls["n"] == 1
-
-
-def test_oracle_progress_snapshot_reuses_until_the_file_changes(monkeypatch) -> None:
-    reset_oracle_progress_snapshot_cache()
-    calls = {"n": 0}
-    real_run = __import__("subprocess").run
-
-    def _counting_run(*args, **kwargs):
-        calls["n"] += 1
-        return real_run(*args, **kwargs)
-
-    monkeypatch.setattr("subprocess.run", _counting_run)
-    first = _oracle_progress_snapshot()
-    after_first = calls["n"]
-    assert after_first >= 1
-    second = _oracle_progress_snapshot()
-    assert calls["n"] == after_first
-    assert second == first
-
-    oracle = ROOT / "references" / "oracle" / "dasha_shadbala_oracle_cases.json"
-    stat = oracle.stat()
-    later = stat.st_mtime + 5
-    try:
-        oracle.touch()
-        import os
-        os.utime(oracle, (later, later))
-        third = _oracle_progress_snapshot()
-        assert calls["n"] > after_first
-        assert third["scope"] == first["scope"]
-    finally:
-        os_utime = __import__("os").utime
-        os_utime(oracle, (stat.st_atime, stat.st_mtime))
-        reset_oracle_progress_snapshot_cache()
-
-
-def test_chart_overview_gate_is_off_by_default(monkeypatch) -> None:
-    monkeypatch.delenv(gate.ENV_GATE_CHART_OVERVIEW, raising=False)
-    gate.reset_heavy_compute_gate(limit=1)
-    held = gate.acquire_heavy_compute_slot("/api/high_rigor_workflow")
-    assert held is not None
-    assert gate.acquire_heavy_compute_slot_for_request("/api/chart", {"year": 1990}) is None
-    gate.release_heavy_compute_slot(held)
-    assert gate.heavy_compute_status()["in_use"] == 0
-    gate.reset_heavy_compute_gate()
-
-
-def test_chart_overview_gate_only_sync_unskipped_requests(monkeypatch) -> None:
-    monkeypatch.setenv(gate.ENV_GATE_CHART_OVERVIEW, "1")
-    gate.reset_heavy_compute_gate(limit=1)
-    body = {"year": 1990, "lat": 28.6, "lon": 77.2}
-    slot = gate.acquire_heavy_compute_slot_for_request("/api/chart", body)
-    assert slot is not None
-    assert gate.heavy_compute_status() == {"limit": 1, "in_use": 1}
-    with pytest.raises(gate.HeavyComputeBusy):
-        gate.acquire_heavy_compute_slot_for_request("/api/chart", {"year": 1991})
-    gate.release_heavy_compute_slot(slot)
-    assert gate.heavy_compute_status()["in_use"] == 0
-    assert gate.acquire_heavy_compute_slot_for_request(
-        "/api/chart", {"skip_vedastro_main_entry_overview": True}
-    ) is None
-    assert gate.acquire_heavy_compute_slot_for_request("/api/chart", {"async": True}) is None
-    assert gate.acquire_heavy_compute_slot_for_request("/api/chart", {"enqueue": 1}) is None
-    assert "/api/chart" not in gate.HEAVY_COMPUTE_PATHS
-    gate.reset_heavy_compute_gate()
-
-
-def test_busy_log_names_holders_and_not_the_body(caplog) -> None:
-    gate.reset_heavy_compute_gate(limit=1)
-    held = gate.acquire_heavy_compute_slot("/api/professional_report_reference")
-    assert held is not None
-    secret_body = {"birth_date": "1990-01-01", "name": "must-not-appear"}
-    with caplog.at_level(logging.WARNING, logger="jyotish.heavy_compute"):
-        with pytest.raises(gate.HeavyComputeBusy):
-            gate.acquire_heavy_compute_slot_for_request("/api/professional_report_reference", secret_body)
-    text = caplog.text
-    assert "/api/professional_report_reference" in text
-    assert "1990-01-01" not in text
-    assert "must-not-appear" not in text
-    gate.release_heavy_compute_slot(held)
-    assert gate.heavy_compute_status()["in_use"] == 0
-    gate.reset_heavy_compute_gate()
-
-
-def test_warm_consultation_still_skips_the_slot() -> None:
-    gate.reset_heavy_compute_gate(limit=1)
-    assert gate.acquire_heavy_compute_slot_for_request(
-        "/api/consultation_workflow", {"consult_card_warm_only": True}
-    ) is None
-    assert gate.heavy_compute_status()["in_use"] == 0
-    gate.reset_heavy_compute_gate()

tests/test_api_scratch_retention.py

@@ -139,7 +139,10 @@ def test_numeric_birth_spellings_share_one_chart_cache_key():
     assert _chart_key(dict(base, hour=12, tz="Asia/Kolkata")) not in keys
     skipped = _chart_key(dict(base, hour=12, skip_vedastro_main_entry_overview=True))
     assert skipped not in keys
-    assert api._build_api_chart_cache_payload(base)["cache_schema_version"] == 6
+    # 原值：cache_schema_version == 6
+    # 新值：7
+    # 原因：/api/chart 的上升补上星宿三项，旧缓存里没有这三项，必须换键。
+    assert api._build_api_chart_cache_payload(base)["cache_schema_version"] == 7
 
 
 def test_audit_artifact_default_off_and_compact_when_on(monkeypatch, tmp_path):

tests/test_supabase_user_data_contract.py

@@ -298,11 +298,8 @@ def test_synastry_route_orchestrates_python_chart_and_ashtakoot() -> None:
     route = SYNASTRY_ROUTE.read_text(encoding="utf-8")
     for token in (
         'const apiBase = process.env.JYOTISH_API_BASE ?? "http://127.0.0.1:5200"',
-        # 原值: postPython("/api/chart", selfPayload) 与 postPython("/api/chart", partnerPayload)
-        # 新值: 两次调用都展开对应 payload，并带 skip_vedastro_main_entry_overview: true
-        # 原因: 合盘改为同时排本人和对方两张盘，并关掉用不上的外部概览。断言仍锁住这两次 /api/chart，同时锁住这个开关，不放宽。
-        'postPython("/api/chart", { ...selfPayload, skip_vedastro_main_entry_overview: true })',
-        'postPython("/api/chart", { ...partnerPayload, skip_vedastro_main_entry_overview: true })',
+        'postPython("/api/chart", selfPayload)',
+        'postPython("/api/chart", partnerPayload)',
         'postPython("/api/varga_full"',
         'postPython("/api/synastry"',
         "moonLongitude(selfChart)",