fix(consult): open rectification when the user asks directly (BUG-1306)

BLOCKED.md

@@ -1,5 +1,11 @@
 # BLOCKED
 
+## TASK-rectification-explicit-entry-20261012：T0 日志、T5 模型（BUG-1306，2026-10-12）
+
+- **T0**：本 worktree 没有 staging 主机，读不到 web 容器 `docker logs`，也没有数据库。无法核对 10-11 那一轮是否调用了 `offer-birth-time-rectification`。不阻塞实现。产品可照做的查法写在 `docs/tasks/PROGRESS-rectification-explicit-entry-20261012.md`，只看工具名、status，以及该会话 messages 里有没有 `rectificationOffer`。
+- **T5**：供应商 API key 在管理端数据库里加密保存，环境只留 `MODEL_PROVIDER_CONFIG_ENCRYPTION_KEY`。本机没有可用数据库，不能解密，也不调用模型。八个场景写成 `docs/testing/rectification-explicit-entry-20261012.md`。
+- **`next build`**：默认 Turbopack 拒绝 worktree 的 `frontend/node_modules` junction（指向文件系统根之外）。`npm run build -- --webpack` 编译与 TypeScript 已过，收集 page data 时 Windows 不能为 Skill 建符号链接（EPERM）。没有路由表，`/` 是否仍 Static、首屏 gzip 未测。没有 `npm install`，没有删 junction，没有改 next 配置。
+
 ## TASK-astrologer-rulings-batch5：Rath 双主星 p.43、名人生平回测、`next build`、真机（2026-10-04）
 
 - **Rath 双主星按 p.43 (a)–(e)（任务书 T1，BUG-1227）**：照裁定实现后原书软件表双主星 8/10 → 9/10，但 Table 17 大运年数 12/12 → 10/12（天蝎 10 → 1、水瓶 8 → 1），低于验收底线，按红线 2 停下、未落地。原书标准盘 Table 17 / Chart 3 / p.43 (e) 例与同书 Table 23 软件判定互相冲突，需产品与占星师二选一（见进度记录 T1 节）。替代证据：试算脚本与三种读法对照表。

CHANGELOG.md

@@ -1,5 +1,9 @@
 # 印度占星 Skill 更新日志
 
+## 2026-10-12 — 对话里明说要校正就直接进入（待验收）
+
+- 用户这一轮明确要求做生时校正时，直接打开校正，不先写解读、不用点卡。推得不准时的提议仍走卡片。做不了会用一句话说明，不再沉默。普通对话不承诺收窄出生时间，申报时段不写大运、子运的起止年月日。
+
 ## 2026-10-09 — 事业判断表旁边注明不按星性写方向（已合入 staging；回测仍有 1 次，记为已知残余）
 
 - 事业判断表里，自然代表星、Jaimini 代表星、大运主星和宫主这几行旁边加了一句：只看力量与受冲，不按这颗星的本性写职业类型、做事方式或方向。其他领域不加。行和取值没有改。系统提示没有改。

docs/BUG_HISTORY.md

@@ -17538,8 +17538,8 @@
 
 ## BUG-1306 | 对话里明说「帮我做生时纠正」进不了校正：模型不出提议卡，反而在普通对话里自己「收窄出生时间」
 
-- 状态：open（根因已定，修复单 `docs/tasks/TASK-rectification-explicit-entry-20261012.md` 待领取；T0 取证未完成）
-- 首次发现 / 最近更新：2026-10-11 / 2026-10-11
+- 状态：fixed-pending-verify（实现在 `codex/rectification-explicit-entry-20261012`，未 push；T0 无主机日志，T5 无模型凭据）
+- 首次发现 / 最近更新：2026-10-11 / 2026-10-12
 - 来源：产品在 staging（`de4cfeb8`）新对话第一句输入「请你帮我进行生时纠正」，回复截图转述。
 - 现象：回复显示「已完成 3 步」，正文说「收窄出生时间这件事能做」，要用户报有年月的经历，「对得上，区间就能往里收」；全文没有提到提议卡，界面上也没有卡片。正文还按「代表分钟」写出大运 / 子运起止年月。
 - 触发条件：申报出生时段的本人档案；首轮；用户明确要求做校正。
@@ -17549,10 +17549,13 @@
   3. BUG-1248 上线前的模型实测只覆盖「不认同解释 / 过去的事对不上 + 时间是估的 / 家人 / 已提议又被拒」四种说法，没有「首轮直接点名要校正」。
   4. 服务端拒绝原因中 `product_disabled`、`pricing_unavailable` 要求正文「不要提校正」，用户看到的是没有回应。
 - 推断（未证实）：正文主动承诺能收窄，不像收到「不要提校正」的拒绝，更像模型没有调用提议工具；无模型凭据、无 staging 运行日志，暂未取证。另：用户若照做在普通对话里报经历，这些经历不会进入校正引擎计分，正文「区间就能往里收」是做不到的承诺；按代表分钟写大运起止，与申报时段指令「精确应期一律不可用」不符。
-- 待做：取该轮观测记录确认是否调用了工具及服务端结果（任务书 T0；观测只打到 web 容器控制台，需 staging 主机日志）。
+- 待做：取该轮观测记录确认是否调用了工具及服务端结果（任务书 T0；观测只打到 web 容器控制台，需 staging 主机日志）。本轮没有主机和数据库，查法见进度记录，不阻塞修复。
+- 修复：不新建工具。`offer-birth-time-rectification` 增加 `explicitRequest`。这一轮明确要校正由模型填写；`userAsked` 仍是「提议过之后用户自己再要求才出卡」。服务端判定仍是 `decideRectificationOffer`（本人、开关、无进行中 case、有价）。通过则记下与提议卡同结构、状态直接为 `opened`、尚无 caseId 的记录，`run.completed` 带 `rectificationDirectOpen`，浏览器调用已有的 `openRectificationFromChat`。同一轮已有直达或已有提议时不再开第二次。`bindOfferToCase` 也会绑定这种还没有 caseId 的 `opened` 记录，刷新后按 caseId 找回。进行中的 case 不新开：查到 `agentic_rectification_cases.session_id` 就打开那次，查不到就说可以在历史对话里接着做。`product_disabled` 与 `pricing_unavailable` 对用户是同一句「出生时间核对这会儿还做不了。」家人仍是「给家人校正暂时还不支持」。四种拒绝说明都不再写「不要提校正」。没有明确要求时的拒绝仍走原来的排盘回答。直达和明确拒绝把首轮合同视为就绪，不跑「运行合同不完整」重试、不跑空答重试、不跑 Pass4，已流出的正文换成那一句。这一轮结算走 `complete_consultation_free`，不走 `complete_consultation_response`；新开时再把提议补到会话消息上，不改请求行。规则仍只定义在 `RECTIFICATION_OFFER_RULE`：不承诺收窄出生时间，不在对话里收集经历做校正。申报时段指令补「大运、子运只说在哪一段附近，不写起止年月日」。不改校正引擎、打分、闸门和数据库。
+- 验证：`npx tsc --noEmit` 0 错。`npm run lint` 0 error（125 条既有 warning）。定向 `rectification-explicit-entry-20261012` 与 `rectification-in-chat-20261007` 26 通过。合同套件 236 条里 235 通过；唯一失败是 Skill 符号链接 EPERM。`CI=1 npm test` 4922 条，通过 4780，失败 101，cancelled 0；失败在本轮没改的文件（无 Docker、符号链接、WSL、路径拼接、junction 下的依赖解析）。telemetry 合同按直达结算改了一条断言，改完 4 条通过。默认 `next build` 因 worktree `node_modules` junction 被 Turbopack 拒绝；`npm run build -- --webpack` 编译与 TypeScript 已过，收集 page data 时 Skill 符号链接 EPERM，没有路由表，`/` Static 与首屏 gzip 未测。T5 未跑模型。
+- 防复发：`frontend/tests/rectification-explicit-entry-20261012.test.ts` 锁住直达、同一轮不重复开案、无 caseId 的 opened 绑定与找回、四种拒绝说明、两条路径不重试、普通咨询仍重试一次、规则只定义一处、申报时段「在哪一段附近」、结算调用 `complete_consultation_free`。用户可见句长度 ≤20。真机清单 `docs/testing/rectification-explicit-entry-20261012.md`。
 - 相关记录：BUG-1247、BUG-1248（入口改为提议卡）、BUG-976/977（禁正则判意图）。
 - 复发自：无。
-- 修复版本：未修复。
+- 修复版本：本分支提交，未 push，未部署。
 - 决策日志（2026-10-12，产品）：选 A——用户明确要求做生时校正时直接进入校正，不先写解读、不用点卡；意图由模型判断，禁正则 / 关键词。**推翻 BUG-1248 两处**：①明确要求的这一轮不再「只出卡、点卡才进」；②`product_disabled`、`pricing_unavailable`「正文不要提校正」改为必须一句话说明做不了，不得静默。普通对话模型不得承诺收窄出生时间、不得在对话里收集经历假装校正；申报时段下不得写大运 / 子运精确起止。服务端本人 / 开关 / 进行中 case / 价格判定不变。同日另立 BUG-1307（最近分界开场）、BUG-1308（父母静态题研究）。
 
 ## BUG-1307 | 生时校正开场不说记录时间离最近分界多近，首轮选题面向整个窗口，用户觉得步骤多、目的不明

docs/tasks/PROGRESS-rectification-explicit-entry-20261012.md

@@ -0,0 +1,54 @@
+# PROGRESS · 明说要校正就直接进入（BUG-1306，2026-10-12）
+
+分支 `codex/rectification-explicit-entry-20261012`，基线 `e6baff95`。未 push，未部署。
+
+## 结论
+
+用户这一轮明确要求做生时校正时，直接打开校正：不先写解读，不用点卡。是否明确要求由模型填写 `explicitRequest`，不用关键词。推得不准时的主动提议仍走卡片。做不了时用一句话说明。普通对话的规则写明不承诺收窄出生时间，也不在对话里收集经历做校正。申报时段的大运、子运只说在哪一段附近。
+
+## 实现
+
+沿用现有工具 `offer-birth-time-rectification`，不新建工具。服务端判定仍是 `decideRectificationOffer`。通过后记录状态为 `opened`、还没有 caseId 的提议，浏览器调用已有的 `openRectificationFromChat`。已有进行中的 case 不新开，查到会话就接着打开。结算走 `complete_consultation_free`，新开时再把提议补到会话消息上，不改 `consultation_requests`。`Home()` 没有新增 `useState` / `useRef`。
+
+## T0 给产品的查法
+
+本 worktree 没有 staging 主机，读不到 web 容器日志，也没有数据库。不阻塞实现。
+
+只查该时段 web 容器日志里的 `[agent-observability]`：
+
+1. `toolCalls` 里有没有 `offer-birth-time-rectification`。
+2. 该次调用的 status（有没有放行、有没有 `offered`）。
+3. 该会话的 `messages` 里有没有 `rectificationOffer` 这个字段。
+
+不要打开回答正文，不要查看出生资料。
+
+## T5
+
+环境里没有可用模型凭据。`MODEL_PROVIDER_CONFIG_ENCRYPTION_KEY` 与常见供应商 key、数据库连接变量都不在本机环境里（只看了是否存在，没有读取值）。供应商 key 在管理端数据库里加密保存，本机没有数据库，不能解密，也没有调用模型。八个场景写在 `docs/testing/rectification-explicit-entry-20261012.md`。
+
+## 既有断言
+
+| 原值 | 新值 | 原因 |
+| --- | --- | --- |
+| `rectification-in-chat-20261007.test.ts` 的断言原文没有改。 | 无。 | 测试辅助函数 `offerTool()` 补了钩子新必填字段 `sourceSessionId` 与 `loadResumableSessionId`，否则类型检查过不了。期望值没有改。 |
+| `consult-evidence-card-telemetry-20260927.test.ts`：本命片段匹配 `answerForTelemetry = output` 之后紧接着能看到 `return settleRun(() => completeResponse(`。 | 非直达仍是 `if (!state.rectificationDirectEntry) answerForTelemetry = output`，本命 `onComplete` 调用 `settleAnswer`；`settleAnswer` 在没有直达时 `return settleRun(() => completeResponse(`。 | BUG-1306：直达轮不把模型正文当回答，结算改走 `complete_consultation_free`。普通本命轮仍记 telemetry，仍走 `completeResponse`。 |
+
+## 验证
+
+| 命令 | 结果 |
+| --- | --- |
+| `npx tsc --noEmit`（frontend） | 0 错 |
+| `npm run lint` | 0 error，125 条 warning，都是既有未使用变量和 hook 依赖，没有新增 error |
+| `rectification-explicit-entry-20261012` + `rectification-in-chat-20261007` | 26 通过，0 失败 |
+| 合同套件（agentic runtime、stream recovery、birth accuracy、workflow contract、home shell、smalltalk、composer、entrypoint、rectification entry） | 236 条，235 通过。唯一失败：`consultation-agentic-runtime.test.ts`「personal Agent exposes the Jyotish Skill and named server tool」。Windows 建 Skill 符号链接 EPERM。该测试与 `skill-package-registry.ts`、`skill-binding.ts` 本轮没改 |
+| `Home()` useState / useRef | 增长合同通过，没有新增 |
+| `CI=1 npm test` | 4922 条，通过 4780，失败 101，cancelled 0。失败都在本轮没改的文件：无 Docker、Windows 不能建符号链接、WSL 不可用、路径被拼成 `G:\G:\`、`node_modules` junction 下 tailwind-merge / sonner 解析失败、迁移相对路径、临时目录 EBUSY。唯一由本轮源码形状引起的是 telemetry 那条，断言已按上表改过，该文件再跑 4 条通过。`consult-single-pass-answer-20260927.test.ts` 在 import 时因 Skill 符号链接 EPERM 整文件退出，路由断言没跑到 |
+| `next build` | 默认 Turbopack 失败：`node_modules` junction 指向文件系统根之外。`npm run build -- --webpack` 编译成功（7.8 分钟），TypeScript 通过（4.1 分钟）。收集 page data 时 Skill 符号链接 EPERM（`/api/consult`、`/api/reports`、`/api/rectification/agent`、`/api/birth-time-guide`）。没有路由表，因此没有证明 `/` 仍是 Static，也没有首屏 gzip。没有 `npm install`，没有删 junction，没有改 next 配置。 |
+
+## 环境缺口
+
+- T0：无 staging `docker logs`，无数据库。
+- T5：无模型凭据，未调用模型。
+- 定向套件里的 Skill 符号链接 EPERM 是本机 Windows 限制。
+- `frontend/node_modules` 是指向主仓的 junction。没有 `npm install`，没有删 junction。
+- `next build`：Turbopack 拒绝该 junction；webpack 编译与类型检查已过，收集 page data 时不能建 Skill 符号链接。`/` Static 与首屏 gzip 未测。

docs/tasks/README.md

@@ -124,7 +124,7 @@
 | `TASK-rectification-mobile-timeline-readout-20260917.md` | `PROGRESS-rectification-mobile-timeline-readout-20260917.md` | 手机截图：时间轴读数第四项被裁成「已…」（nowrap + inset 内边距，BUG-918）；「跳到最新」浮层压住选项 C（BUG-919）。灰卡与「再说一件」矛盾归修复单 BUG-915/917 | 已验收 | `e8e98bbd`（合入时重放为本分支提交，BUG-918/919）。时间轴相关 71 条 + 全量同上；手机上隐藏「已对照 N 件」符合 DESIGN §10；桌面是否也移除待产品拍板。真机清单 `docs/testing/rectification-mobile-timeline-readout-20260917.md` |
 | `TASK-mobile-viewport-scroll-lock-20260917.md` | `PROGRESS-mobile-viewport-scroll-lock-20260917.md` | iPhone 上键盘收起 / 刷新后整页上移、顶栏点不到（BUG-920）：iOS 不支持 `interactive-widget`，键盘弹出时 Safari 滚动 window，`html/body overflow: hidden` 让用户拉不回来，reload 又还原 `scrollY`；代码里无任何 window 级复位。补 `ViewportScrollLock`（`scrollRestoration=manual` + `visualViewport` 复位）。与今天两单无关，既有缺陷。**T3 顶栏积分块「有点扁」（BUG-921）**：两枚芯片 44px 塞在 46px 顶栏里、字号/内边距/圆角各一套、积分块强制 64px 最小宽度；统一尺寸并把手机顶栏放到 52px | 已合入（无独立验收记录） | `1b508d5e`（BUG-920/921 resolved；已部署 staging，run 2715）；真机待核 |
 | `TASK-rectification-session-composer-guard-20260917.md` | `PROGRESS-rectification-session-composer-guard-20260917.md` | 校正会话激活但校正面未开（刷新揭幕超时 / 打开失败不重试 / 删除与 popstate 回退落到列表第一条）时露出可用的普通输入框，问题发到 `/api/consult` 回 404「咨询会话不存在」；`send()` 无会话类型守卫；服务端无独立错误码。关联 BUG-505。BUG 段 924 起 | 已验收 | `6d81062b`（Claude 验收：T1–T5 全通过；409 `session_not_consultation` 在扣点前、不扣点；回退路径多修了归档一条；page.tsx 1830→1830。残留 P3：列表只剩校正会话时 `activeSession` 为空，输入框可用但发送静默无效 → BUG-935 在 fix 单）；真机三条欠 |
-| `TASK-rectification-explicit-entry-20261012.md` | — | **明说要校正就直接进入（BUG-1306）**：模型判断意图（禁正则），服务端判定后直接开案并绑定来源对话；首轮排盘合同对此轮豁免；拒绝必须一句话说明（推翻 BUG-1248 静默两条）；普通对话不得假装校正、申报时段不写子运起止。**先做** | 待领取 | — |
+| `TASK-rectification-explicit-entry-20261012.md` | `PROGRESS-rectification-explicit-entry-20261012.md` | **明说要校正就直接进入（BUG-1306）**：模型判断意图（禁正则），服务端判定后直接开案并绑定来源对话；首轮排盘合同对此轮豁免；拒绝必须一句话说明（推翻 BUG-1248 静默两条）；普通对话不得假装校正、申报时段不写子运起止。**先做** | 待验收 | — |
 | `TASK-rectification-nearest-boundary-opening-20261012.md` | — | **最近分界开场（BUG-1307）**：开场说记录时间离最近分盘换段点多近、两侧哪些层不同，近分界时首轮只问该分界；不改打分 / 闸门 / 4 件 3 域，77 例回放不降；改 page.tsx / 校正开场组件的部分须在 BUG-1306 合入后 | 待领取 | — |
 | `TASK-rectification-d12-parent-probes-research-20261012.md` | — | **父母静态是非题（D12）研究（BUG-1308）**：公开案例 ≥60、预登记、乱序与正对照，过门才立实现单；纯研究可并行 | 待领取 | — |
 

docs/testing/rectification-explicit-entry-20261012.md

@@ -0,0 +1,16 @@
+# 真机清单 · 明说要校正就直接进入（2026-10-12）
+
+对应 BUG-1306，任务书 `docs/tasks/TASK-rectification-explicit-entry-20261012.md` 的 T5。在 staging 上用自己的账号走。deepseek-v4-flash 一遍，产品默认模型再一遍。每个场景至少两次。回答原文和出生资料不记进仓库。本人档案除第 6 步外都用本人。申报时段用第 8 步；其余有分钟的档案即可。
+
+| 步 | 怎么做 | 通过标准 |
+| --- | --- | --- |
+| 1 | 新对话第一句：「请你帮我进行生时纠正」 | 直接打开校正。这一轮不写解读，不用点卡。过渡只有一句 |
+| 2 | 另开三条新对话，分别说「帮我校正出生时间」「想核对一下出生时间准不准」「我出生时间是估的，帮我对一下」 | 三次都直接打开，不先出卡 |
+| 3 | 新对话先问一件普通的事，答完后再说「请帮我做生时校正」 | 这一轮直接打开，不把刚才的解读再写一遍 |
+| 4 | 新对话问事业，答完后说「你说我事业不顺，我觉得挺顺的」 | 认下、改读。不进入校正，下面没有提议卡 |
+| 5 | 接着说一件过去的事和盘对不上，并说出生时间是估的，但不要说「帮我校正」 | 回答下面出现提议卡。不直接打开校正 |
+| 6 | 换到一个家人档案，第一句就说「请帮我校正出生时间」 | 一句「给家人校正暂时还不支持」。不打开校正 |
+| 7 | 在校正开关关闭，或价格暂时不可用时，本人说「请帮我做生时校正」 | 一句「出生时间核对这会儿还做不了。」不沉默，不写价格，不写内部原因。构造不了这一步就在进度里标环境缺口，不要改开关去试 |
+| 8 | 申报出生时段的本人档案，问一件普通的事，不要提校正 | 正文不写大运、子运的起止年月日，也不承诺能收窄出生时间 |
+
+做不了的两句和家人那句以界面上的原句为准。点数：直接进入的那一轮不按解读扣咨询点；校正本身仍按原来的开案扣费。

frontend/DESIGN.md

@@ -11,6 +11,8 @@
 
 不新增等待动画；打开校正沿用既有一次揭幕。
 
+**明确要求则直接打开（2026-10-12，BUG-1306）**：用户这一轮明说要做校正时，不再先出卡再点。回答只留一句过渡，界面沿用既有一次揭幕直接打开校正面。没有新的按钮、输入框、等待动画或 Home 状态。推得不准时的主动提议仍用 `.rectification-offer-card`。做不了时只显示一句话，不静默，也不在对话里假装校正。
+
 ## 用量页分段计时（2026-10-05，在途）
 
 `/admin/usage` 在原表格上多一列「分段」。格子里四行：分类耗时、第 0 步、第 1 步、第 1 步开始到第一个正文字符。每步带推理、输出、输入、缓存输入 token。供应商没返回的数显示「—」。不新开页面，不改表，数字来自 `usage_ledger.metadata` 里已有的 JSON。没有新的等待动画或输入框。

frontend/docs/VOICE.md

@@ -23,10 +23,12 @@ Jyotisha 的可见文案是产品的一部分。正确性红线（真实性、
 
 首页开场语下面可以有一行今日趋势（今日星语卡片的 trend，每日生成）；还没生成时写「今天的星语还没写出来。」，没有出生分钟时不写。入口按钮下面平时不写字，只在用户需要动手时写一句：有没做完的校正写「上次那次校正还没完成，可以在历史对话里接着做。」；当前人物不是本人写「生时校正暂时只支持本人。」。不再写「不确定出生时间时，用记得住的经历一步步缩小范围」「上次已经校正完，可以拿最新资料再来一次」，也不要用「·」把两句不相干的提示拼成一行。
 
-## 生时校正从对话进入（2026-10-07，BUG-1247～1251）
+## 生时校正从对话进入（2026-10-07，BUG-1247～1251；2026-10-12，BUG-1306）
 
-- **何时提议**：用户说推得不准时先分清读法问题和时间问题。只是不认同某个解释，按纠正规则认下、改读，不提校正；说出过去的具体事情和盘对不上、说出生时间是估的或记不准、或明确想核对出生时间，agent 才调用提议工具。同一次对话提议过、用户没接，不再主动提；规则只定义在 `consultation-thinking-plan.ts` 的 `RECTIFICATION_OFFER_RULE`。不用关键词判断。
-- **正文怎么提**：一句，放在最后一段（例：「如果想确认出生时间准不准，可以用下面的卡片，答几道过去经历的题核对一下。」），不写价格和题数——卡片上写。给家人档案时说「给家人校正暂时还不支持」，不出卡。
+- **何时提议**：用户说推得不准时先分清读法问题和时间问题。只是不认同某个解释，按纠正规则认下、改读，不提校正。不承诺能收窄出生时间，不在对话里收集经历做校正。说出过去的具体事情和盘对不上、说出生时间是估的或记不准、但没有明确要做校正，才调用提议工具。同一次对话提议过、用户没接，不再主动提；用户自己再要求时传 `userAsked=true`。规则只定义在 `consultation-thinking-plan.ts` 的 `RECTIFICATION_OFFER_RULE`。不用关键词判断。
+- **明确要求则直接进入**：用户这一轮明确要做校正，由模型判断，不用关键词。服务端放行后直接打开校正：不先写解读，不用点卡。过渡只有一句「好，我们开始核对出生时间。」已经有一次没做完的，直接接着做那一次，不新开。
+- **做不了必须说一句**：开关关着，或暂时没有价格，都说「出生时间核对这会儿还做不了。」不写内部原因，不写价格，不得沉默。家人档案说「给家人校正暂时还不支持」，不开案。有进行中的校正但这次打不开原来的会话，说「可在历史对话里接着做。」
+- **正文怎么提**（没有明确要求、只是时间可能不准）：一句，放在最后一段（例：「如果想确认出生时间准不准，可以用下面的卡片，答几道过去经历的题核对一下。」），不写价格和题数——卡片上写。
 - **卡片**：「可以用几道过去经历的题，核对一下你的出生时间。大约 N 题，会用掉 M 点；开始答第一题时才扣。」按钮「开始核对出生时间」；已开始「出生时间核对已经开始。」/「继续核对出生时间」。点数来自 `feature_pricing`，不写死。
 - **回来**：分隔线「出生时间改为 HH:MM（生时校正）」/「出生时间没有改」；之前的回答上方「按校正前的时间」；按钮「按新时间重新看：「原问题」」。校正面按钮「回到刚才的对话」。不再说「新建对话」。
 

frontend/src/app/(app)/page.tsx

@@ -735,7 +735,7 @@ export default function Home() {
     startNewChat,
     continueInNewChat,
     refreshAccount,
-    openAccountDialog, openRectificationSession,
+    openAccountDialog, openRectificationSession, openRectificationFromChat,
     onboardingPaywallShown, setOnboardingPaywallOpen,
   });
   const jumpToLatestVisible = !rectificationSurfaceOpen

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

@@ -15,7 +15,8 @@ import { recordModerationEvent } from "@/lib/moderation/log";
 import { consultationDomainSchema } from "@/lib/consultation-domain-registry";
 import { parseAgentReply } from "@/lib/agent-reply";
 import { revisitQuestionForOffer, sessionHasRectificationOffer } from "@/lib/rectification-in-chat";
-import { decideRectificationOffer } from "@/lib/rectification-in-chat-server";
+import { decideRectificationOffer, persistOpenedDirectOffer } from "@/lib/rectification-in-chat-server";
+import { getRectificationEntrySummary } from "@/lib/rectification-agentic/v9/case-service";
 import { createConsultationReplyMetadata } from "@/lib/consultation-reply-metadata";
 import {
   ConsultationPlanValidationError,
@@ -244,7 +245,7 @@ function generalNoMinuteInstruction(hasPublicDaily: boolean) {
 }
 
 function declaredWindowInstruction() {
-  return "当前是声明出生窗口咨询，没有单一出生分钟。如需个人结构结论，必须调用 run-jyotish-window-consultation。探针时刻不是出生时间，不得把 00:00、时段中点、中午或任一探针写成出生分钟。只能根据稳定层作方向性回答；上升或宫位若在窗口内变化，列出可能星座，不得写成「你的上升是 X」。精确应期一律不可用。这只是粗看。" + RECTIFICATION_OFFER_RULE;
+  return "当前是声明出生窗口咨询，没有单一出生分钟。如需个人结构结论，必须调用 run-jyotish-window-consultation。探针时刻不是出生时间，不得把 00:00、时段中点、中午或任一探针写成出生分钟。只能根据稳定层作方向性回答；上升或宫位若在窗口内变化，列出可能星座，不得写成「你的上升是 X」。精确应期一律不可用。大运、子运只说「在哪一段附近」，不写起止年月日。这只是粗看。" + RECTIFICATION_OFFER_RULE;
 }
 
 function usesPublicDailyGeneralAgent(
@@ -902,6 +903,55 @@ export async function POST(request: Request) {
     }
   }
 
+  // Explicit rectification (BUG-1306): one short sentence, same free settlement
+  // as smalltalk, so a turn with no reading does not spend a consultation credit.
+  // The RPC message is only role/text/responseKind. A new case's offer is patched
+  // onto the session message afterwards and is not written back onto the request.
+  async function completeDirectRectificationTurn(
+    usage: Promise<{ inputTokens?: number; outputTokens?: number }>,
+  ): Promise<AgentSettlementResult> {
+    const entry = latencyState?.rectificationDirectEntry;
+    const offer = latencyState?.rectificationOffer;
+    if (!entry) throw new Error("direct_entry_missing");
+    try {
+      const actualUsage = await usagePayload(usage);
+      const responseMessage = { role: "assistant" as const, text: entry.sentence, responseKind: "smalltalk" as const };
+      const completion = await retryDetachedSettlement(async () => {
+        const { data, error } = await accounting.rpc("complete_consultation_free", {
+          p_user_id: userId,
+          p_request_id: requestId,
+          p_session_id: sessionId,
+          p_response_message: responseMessage,
+          p_actual_usage: actualUsage,
+        });
+        const parsedCompletion = consultationCompletionSchema.safeParse(first(data ?? []));
+        if (error || !parsedCompletion.success) {
+          throw new CreditRpcError(error?.message || "invalid_free_completion");
+        }
+        if (!parsedCompletion.data.success && parsedCompletion.data.error_code !== "request_cancelled") {
+          throw new CreditRpcError(parsedCompletion.data.error_code || "free_completion_rejected");
+        }
+        if (parsedCompletion.data.success && entry.kind === "new" && offer) {
+          await persistOpenedDirectOffer({
+            client: supabase,
+            userId,
+            sessionId,
+            sentence: entry.sentence,
+            offer,
+          });
+        }
+        return parsedCompletion.data;
+      });
+      if (!completion.success && completion.error_code !== "request_cancelled") {
+        throw new CreditRpcError(completion.error_code || "free_completion_rejected");
+      }
+      return "completed";
+    } catch (error) {
+      await cancel();
+      throw error;
+    }
+  }
+
   let settlement: Promise<AgentSettlementResult> | null = null;
   function settleResult(action: () => Promise<AgentSettlementResult>) {
     settlement ??= action();
@@ -966,6 +1016,21 @@ export async function POST(request: Request) {
       }),
       alreadyOffered: sessionHasRectificationOffer(chatSession?.messages),
       revisitQuestion: revisitQuestionForOffer(chatSession?.messages, visibleQuestion, requestId),
+      sourceSessionId: sessionId,
+      loadResumableSessionId: async () => {
+        const summary = await getRectificationEntrySummary(accounting, userId);
+        const caseId = summary.latestResumable?.caseId;
+        if (!caseId) return null;
+        const { data, error } = await accounting
+          .from("agentic_rectification_cases")
+          .select("session_id")
+          .eq("user_id", userId)
+          .eq("id", caseId)
+          .maybeSingle();
+        if (error || !data) return null;
+        const resumableSessionId = (data as { session_id?: unknown }).session_id;
+        return typeof resumableSessionId === "string" && resumableSessionId ? resumableSessionId : null;
+      },
     };
     const hooks = createConsultationRuntimeHooks(state);
     const usages: Promise<Usage>[] = [];
@@ -1203,6 +1268,28 @@ export async function POST(request: Request) {
         }
         : { route: "pending", status: "blocked", preciseTiming: "blocked", missingLayers: [] };
 
+    const settleAnswer = (
+      output: string,
+      agentExecutionReceipt: AgentExecutionReceipt,
+      techniqueTruth: string,
+      workflow: WorkflowReceipt,
+      thinkingText?: string,
+      thinkingSections?: PublicThinkingSection[],
+    ) => {
+      if (state.rectificationDirectEntry) {
+        return settleRun(() => completeDirectRectificationTurn(mergeUsage(usages)), undefined);
+      }
+      return settleRun(() => completeResponse(
+        output,
+        mergeUsage(usages),
+        techniqueTruth,
+        workflow,
+        agentExecutionReceipt,
+        thinkingText,
+        thinkingSections,
+      ), undefined);
+    };
+
     if (usesPublicDailyGeneralAgent(consultationMode, generalDailyContext)) {
       state.workflowReceipt = workflowReceipt;
       const agent = getGeneralJyotishAgent(selectedModel);
@@ -1260,15 +1347,14 @@ export async function POST(request: Request) {
         headers: { "x-jyotish-birth-time-mode": consultationMode },
         onFirstActivity: markFirstActivity,
         onFirstOutput: markFirstText,
-        onComplete: (output, agentExecutionReceipt, thinkingText, thinkingSections) => settleRun(() => completeResponse(
+        onComplete: (output, agentExecutionReceipt, thinkingText, thinkingSections) => settleAnswer(
           output,
-          mergeUsage(usages),
+          agentExecutionReceipt,
           generalDailyContext ? "public-panchanga-only" : "not-applicable",
           workflowReceipt,
-          agentExecutionReceipt,
           thinkingText,
           thinkingSections,
-        ), undefined),
+        ),
         onError: (error) => settleRun(
           cancel,
           toAgentObservabilityErrorCode(error),
@@ -1393,15 +1479,14 @@ export async function POST(request: Request) {
         headers: { "x-jyotish-birth-time-mode": consultationMode },
         onFirstActivity: markFirstActivity,
         onFirstOutput: markFirstText,
-        onComplete: (output, agentExecutionReceipt, thinkingText, thinkingSections) => settleRun(() => completeResponse(
+        onComplete: (output, agentExecutionReceipt, thinkingText, thinkingSections) => settleAnswer(
           output,
-          mergeUsage(usages),
+          agentExecutionReceipt,
           state.techniqueTruth ?? "declared-window",
           state.workflowReceipt ?? workflowReceipt,
-          agentExecutionReceipt,
           thinkingText,
           thinkingSections,
-        ), undefined),
+        ),
         onError: (error) => settleRun(
           cancel,
           toAgentObservabilityErrorCode(error),
@@ -1506,16 +1591,15 @@ export async function POST(request: Request) {
       onFirstActivity: markFirstActivity,
       onFirstOutput: markFirstText,
       onComplete: (output, agentExecutionReceipt, thinkingText, thinkingSections) => {
-        answerForTelemetry = output;
-        return settleRun(() => completeResponse(
+        if (!state.rectificationDirectEntry) answerForTelemetry = output;
+        return settleAnswer(
           output,
-          mergeUsage(usages),
+          agentExecutionReceipt,
           state.techniqueTruth ?? "unknown",
           state.workflowReceipt ?? workflowReceipt,
-          agentExecutionReceipt,
           thinkingText,
           thinkingSections,
-        ), undefined);
+        );
       },
       onError: (error) => settleRun(
         cancel,

frontend/src/hooks/use-consultation-run.ts

@@ -155,6 +155,8 @@ export type ConsultationRunParams = {
   onboardingPaywallShown?: MutableRefObject<boolean>;
   setOnboardingPaywallOpen?: (open: boolean) => void;
   openRectificationSession: (exactSessionId: string) => Promise<void> | void;
+  /** Direct entry from this consultation (BUG-1306). Same opener as the offer card. */
+  openRectificationFromChat: (sourceSessionId: string) => Promise<void> | void;
 };
 
 export function useConsultationRun(params: ConsultationRunParams) {
@@ -215,6 +217,7 @@ export function useConsultationRun(params: ConsultationRunParams) {
     onboardingPaywallShown,
     setOnboardingPaywallOpen,
     openRectificationSession,
+    openRectificationFromChat,
   } = params;
   // First refusal for credits on this page → redeem paywall; later ones → billing (P4, BUG-1080).
   const openRedeemPaywallOnce = () => tryOpenRedeemPaywall({
@@ -874,6 +877,7 @@ export function useConsultationRun(params: ConsultationRunParams) {
       };
       let agentExecutionReceipt: AgentExecutionReceipt | undefined;
       let rectificationOffer: RectificationOfferRecord | undefined;
+      let rectificationDirectOpen: Extract<ConsultationAgentPublicEvent, { type: "run.completed" }>["rectificationDirectOpen"];
       let runCompleted = false;
       let truncatedFailure: Extract<ConsultationAgentPublicEvent, { type: "run.failed" }> | undefined;
       const reader = response.body.getReader();
@@ -953,6 +957,7 @@ export function useConsultationRun(params: ConsultationRunParams) {
           if (event.type === "run.completed") {
             runCompleted = true;
             rectificationOffer = event.rectificationOffer;
+            rectificationDirectOpen = event.rectificationDirectOpen;
             if (event.responseKind === "smalltalk") {
               responseKind = "smalltalk";
             } else if (event.receipt) {
@@ -1054,7 +1059,10 @@ export function useConsultationRun(params: ConsultationRunParams) {
         messages: [...userSession.messages, {
           role: "assistant",
           text: reply.text,
-          ...(responseKind === "smalltalk" ? { responseKind } : {
+          ...(responseKind === "smalltalk" ? {
+            responseKind,
+            ...(rectificationOffer ? { rectificationOffer } : {}),
+          } : {
             ...(streamedThinking.trim() ? { thinkingText: streamedThinking.trim().slice(0, 4000) } : {}),
             ...(thinkingSections.length ? { thinkingSections } : {}),
             techniqueTruth,
@@ -1066,6 +1074,11 @@ export function useConsultationRun(params: ConsultationRunParams) {
         updatedAt: timestamp(),
       };
       updateSession(sessionId, () => completedSession);
+      if (rectificationDirectOpen?.mode === "resume" && rectificationDirectOpen.resumeSessionId) {
+        void openRectificationSession(rectificationDirectOpen.resumeSessionId);
+      } else if (rectificationDirectOpen?.mode === "new") {
+        void openRectificationFromChat(rectificationDirectOpen.sourceSessionId);
+      }
       try {
         await persistSession(completedSession);
       } catch (error) {

frontend/src/lib/consultation-agent-events.ts

@@ -139,12 +139,21 @@ const sessionTitleSchema = z.object({
   type: z.literal("session.title"),
   title: z.string().trim().min(1).max(48),
 }).strict();
+/** Browser opens rectification from this turn without a card click (BUG-1306). */
+const rectificationDirectOpenSchema = z.object({
+  sourceSessionId: z.string().uuid(),
+  mode: z.enum(["new", "resume"]),
+  resumeSessionId: z.string().uuid().optional(),
+}).strict();
+
 const runCompletedSchema = z.object({
   type: z.literal("run.completed"),
   receipt: agentExecutionReceiptSchema.optional(),
   responseKind: z.literal("smalltalk").optional(),
   /** The answer offered birth-time rectification (BUG-1248); the card hangs under it. */
   rectificationOffer: rectificationOfferRecordSchema.optional(),
+  /** Present for a direct open or resume. A refusal is smalltalk and omits this. */
+  rectificationDirectOpen: rectificationDirectOpenSchema.optional(),
 }).strict();
 // A failure is the case the receipt is most needed for, so it carries the same
 // allowlisted receipt a completed run does. It stays optional because the

frontend/src/lib/consultation-thinking-plan.ts

@@ -455,11 +455,11 @@ export function natalAnswerShapeInstruction(): string {
 }
 
 /**
- * C2 (TASK-rectification-in-chat-step1-20261006, BUG-1248): when "推得不准"
- * may be the birth time, the agent offers rectification through the offer
- * tool; it is never decided from keywords. Defined here once.
+ * C2 (BUG-1248) plus direct entry when this turn explicitly asks (BUG-1306).
+ * Never decided from keywords. Defined here once; the offer tool names the
+ * same parameters and does not restate this rule.
  */
-export const RECTIFICATION_OFFER_RULE = "出生时间核对：用户说你推得不准时，先分清是读法问题还是时间问题。只是不认同某个解释，按纠正规则认下、改读，不提校正。用户说出过去某件具体的事和盘对不上、说自己的出生时间是估的或记不准、或明确想核对出生时间，才在写回答之前调用 offer-birth-time-rectification，再按工具结果在正文里用一句话提一下（不写价格和题数，卡片上有）。同一次对话提议过、用户没接，就不再主动提；用户自己再要求时调用并传 userAsked=true。工具说不能提供时（比如问的是家人），照工具说明用一句话说清楚。";
+export const RECTIFICATION_OFFER_RULE = "出生时间核对：用户说你推得不准时，先分清是读法问题还是时间问题。只是不认同某个解释，按纠正规则认下、改读，不提校正。不承诺能收窄出生时间，不在对话里收集经历做校正。用户这一轮明确要做校正，就在写回答之前调用 offer-birth-time-rectification 并传 explicitRequest=true；工具通过后只写那一句过渡，不写解读。用户说出过去某件具体的事和盘对不上、说自己的出生时间是估的或记不准、但没有明确要做校正，才在写回答之前调用 offer-birth-time-rectification，再按工具结果在正文里用一句话提一下（不写价格和题数，卡片上有）。同一次对话提议过、用户没接，就不再主动提；用户自己再要求时调用并传 userAsked=true。工具说不能提供时（比如问的是家人），照工具说明用一句话说清楚。";
 
 /** D4 / BUG-1166: the user corrects an earlier reading; acknowledge it, never defend the reading. */
 export const FOLLOW_UP_CORRECTION_RULE = "用户纠正了前面的判断（比如说父亲其实不常在身边）：先认下这件事，再只说盘上真正对得上的那几条、原来哪句读偏了；盘本身分不出的，直说「盘本身分不出这一点」，不把普通配置说成必然；不为原判断辩护。";

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

@@ -7,11 +7,13 @@ import { getRectificationEntrySummary } from "@/lib/rectification-agentic/v9/cas
 import { loadV9CaseDossier } from "@/lib/rectification-agentic/v9/tool-service";
 import {
   appendRectificationReturn,
+  attachOpenedOfferToFreeMessage,
   bindOfferToCase,
   decideRectificationOfferWith,
   offerForCase,
   sourceFromSessionRows,
   type RectificationOfferDecision,
+  type RectificationOfferRecord,
   type RectificationReturnRecord,
   type RectificationSource,
 } from "@/lib/rectification-in-chat";
@@ -61,6 +63,35 @@ async function writeMessages(client: SupabaseClient, userId: string, sessionId:
   return !error;
 }
 
+/**
+ * After a free direct-entry reply is appended, hang the opened offer on that
+ * message. Idempotent: an offer already on the message (including one a later
+ * bind gave a case id) is left as it is. Does not touch consultation_requests.
+ */
+export async function persistOpenedDirectOffer(input: {
+  client: SupabaseClient;
+  userId: string;
+  sessionId: string;
+  sentence: string;
+  offer: RectificationOfferRecord;
+}): Promise<void> {
+  const { data, error } = await input.client
+    .from("chat_sessions")
+    .select("messages")
+    .eq("id", input.sessionId)
+    .eq("user_id", input.userId)
+    .maybeSingle();
+  if (error || !data) throw new Error("direct_offer_session_unreadable");
+  const attached = attachOpenedOfferToFreeMessage((data as { messages?: unknown }).messages, {
+    sentence: input.sentence,
+    offer: input.offer,
+  });
+  if (attached === "present") return;
+  if (attached === "missing") throw new Error("direct_offer_message_missing");
+  const wrote = await writeMessages(input.client, input.userId, input.sessionId, attached);
+  if (!wrote) throw new Error("direct_offer_write_failed");
+}
+
 /** C4: after a case opens from a consultation, bind the offer card to it. Best effort. */
 export async function bindRectificationSource(input: {
   client: SupabaseClient;

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

@@ -70,6 +70,18 @@ export const RECTIFICATION_OFFER_OPENED_COPY = "出生时间核对已经开始
 export const RECTIFICATION_RETURN_BUTTON_LABEL = "回到刚才的对话";
 export const RECTIFICATION_BEFORE_CHANGE_LABEL = "按校正前的时间";
 
+/**
+ * User-visible sentences for a turn that enters rectification directly
+ * (BUG-1306). `complete_consultation_free` rejects text longer than 20
+ * characters, so these stay short. Same sentence for "not open" and "no price":
+ * the user does not see the internal reason.
+ */
+export const RECTIFICATION_DIRECT_NEW_COPY = "好，我们开始核对出生时间。";
+export const RECTIFICATION_DIRECT_RESUME_COPY = "核对还没做完，我们接着做。";
+export const RECTIFICATION_DIRECT_UNAVAILABLE_COPY = "出生时间核对这会儿还做不了。";
+export const RECTIFICATION_DIRECT_NOT_SELF_COPY = "给家人校正暂时还不支持";
+export const RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY = "可在历史对话里接着做。";
+
 export function rectificationReturnDividerText(record: Pick<RectificationReturnRecord, "adopted" | "clock">): string {
   return record.adopted && record.clock
     ? `出生时间改为 ${record.clock}（生时校正）`
@@ -136,7 +148,10 @@ export function bindOfferToCase(
   }
   for (let index = stored.length - 1; index >= 0; index -= 1) {
     const offer = parseRectificationOfferRecord(stored[index]!.rectificationOffer);
-    if (!offer || offer.status !== "offered") continue;
+    if (!offer || offer.caseId) continue;
+    // A direct open records `opened` before the case id exists (BUG-1306).
+    // An offer already bound to another case is left alone.
+    if (offer.status !== "offered" && offer.status !== "opened") continue;
     const next = [...stored];
     next[index] = {
       ...stored[index],
@@ -147,6 +162,29 @@ export function bindOfferToCase(
   return null;
 }
 
+/**
+ * After `complete_consultation_free` appends the one-sentence reply, hang the
+ * opened offer on that message so a reload can still find the source. Returns
+ * the next array, "present" when that message already has an offer (do not
+ * overwrite a later case id), or "missing" when the free reply is not there yet.
+ */
+export function attachOpenedOfferToFreeMessage(
+  messages: unknown,
+  input: { sentence: string; offer: RectificationOfferRecord },
+): StoredMessage[] | "present" | "missing" {
+  const stored = asMessages(messages);
+  if (!stored) return "missing";
+  for (let index = stored.length - 1; index >= 0; index -= 1) {
+    const message = stored[index]!;
+    if (message.role !== "assistant" || message.text !== input.sentence || message.responseKind !== "smalltalk") continue;
+    if (parseRectificationOfferRecord(message.rectificationOffer)) return "present";
+    const next = [...stored];
+    next[index] = { ...message, rectificationOffer: input.offer };
+    return next;
+  }
+  return "missing";
+}
+
 /** The offer bound to this case, if this session holds one. */
 export function offerForCase(messages: unknown, caseId: string): RectificationOfferRecord | null {
   for (const message of asMessages(messages) ?? []) {

frontend/src/lib/stream-agent-response.ts

@@ -313,7 +313,8 @@ export async function collectAgentPublicEvents(stream: ChunkStream | Iterable<Ch
     }
   }
   flushPlan();
-  events.push({
+  const directCompleted = options.state ? rectificationDirectRunCompleted(options.state) : null;
+  events.push(directCompleted ?? {
     type: "run.completed",
     receipt: agentExecutionReceiptSchema.parse(options.receipt()),
     ...(options.state?.rectificationOffer ? { rectificationOffer: options.state.rectificationOffer } : {}),
@@ -387,10 +388,32 @@ type StreamAgentResponseOptions = EventOptions & {
 // the single-calculation boundary. Gating on total attempts would make any
 // transient failure permanently unrecoverable.
 function contractReady(options: StreamAgentResponseOptions) {
+  // An explicit rectification turn does not need a chart calculation (BUG-1306).
+  if (options.state.rectificationDirectEntry) return true;
   return options.state.jyotishSkillBound
     && (!options.requireTool || (options.state.consultationToolCompleted && options.state.consultationToolSuccessCount === 1));
 }
 
+/** Smalltalk completion for a direct rectification turn. No receipt: the schema forbids both. */
+function rectificationDirectRunCompleted(state: ConsultationRuntimeState): ConsultationAgentPublicEvent | null {
+  const entry = state.rectificationDirectEntry;
+  if (!entry) return null;
+  return consultationAgentPublicEventSchema.parse({
+    type: "run.completed",
+    responseKind: "smalltalk",
+    ...(entry.kind === "new" && state.rectificationOffer ? { rectificationOffer: state.rectificationOffer } : {}),
+    ...(entry.kind === "new" || entry.kind === "resume"
+      ? {
+          rectificationDirectOpen: {
+            sourceSessionId: entry.sourceSessionId,
+            mode: entry.kind,
+            ...(entry.resumeSessionId ? { resumeSessionId: entry.resumeSessionId } : {}),
+          },
+        }
+      : {}),
+  });
+}
+
 function isSkillBindingAbortError(error: unknown) {
   if (!(error instanceof Error)) return false;
   if (error.message === SKILL_BINDING_FAILED) return true;
@@ -654,6 +677,8 @@ export function streamAgentResponse(options: StreamAgentResponseOptions) {
       stepCalledTool = false;
     };
     const outputText = async (text: string) => {
+      // Direct entry ends on the server sentence. Further model text is not the answer.
+      if (options.state.rectificationDirectEntry) return;
       // Text the model writes before the contract is ready is not the answer: it
       // is the model narrating its own in-progress or failed tool calls. Holding
       // it meant a later successful call released that narration as the entire
@@ -1058,6 +1083,23 @@ export function streamAgentResponse(options: StreamAgentResponseOptions) {
               throw new Error("runtime_contract_incomplete");
             }
           }
+          const directCompleted = rectificationDirectRunCompleted(options.state);
+          if (directCompleted) {
+            const sentence = options.state.rectificationDirectEntry?.sentence ?? "";
+            fullOutput = sentence;
+            send(controller, { type: "answer.delta", text: sentence, replace: true });
+            emitted = true;
+            recordAnswerTelemetry();
+            settling = true;
+            const receipt = agentExecutionReceiptSchema.parse(options.receipt());
+            await options.onComplete?.(sentence, receipt, undefined, undefined);
+            settled = true;
+            settling = false;
+            await sideEvent;
+            send(controller, directCompleted);
+            if (!disconnected) controller.close();
+            return;
+          }
           if (!deliveredDegraded) {
             // The loop's own final step wrote the answer with the calculation
             // in its context (BUG-1053); there is no second, blind compose.

frontend/src/mastra/consultation-tools.ts

@@ -1,4 +1,9 @@
 import {
+  RECTIFICATION_DIRECT_NEW_COPY,
+  RECTIFICATION_DIRECT_NOT_SELF_COPY,
+  RECTIFICATION_DIRECT_RESUME_COPY,
+  RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY,
+  RECTIFICATION_DIRECT_UNAVAILABLE_COPY,
   RECTIFICATION_OFFER_TOOL_ID,
   type RectificationOfferDecision,
   type RectificationOfferRecord,
@@ -276,6 +281,18 @@ export type ConsultationRuntimeState = {
   jyotishSkillBound: boolean;
   /** Set when this turn's answer offered birth-time rectification (BUG-1248); persisted with the answer. */
   rectificationOffer?: RectificationOfferRecord;
+  /**
+   * Set when this turn explicitly asked to rectify (BUG-1306). The stream
+   * replaces the answer with `sentence` and does not charge a reading.
+   * `new` opens a case; `resume` opens the one already in progress; `refused`
+   * only says why it cannot.
+   */
+  rectificationDirectEntry?: {
+    kind: "new" | "resume" | "refused";
+    sentence: string;
+    sourceSessionId: string;
+    resumeSessionId?: string;
+  };
   skillReferenceReadCount: number;
   methodologySectionCount: number;
   consultationToolStarted: boolean;
@@ -457,6 +474,13 @@ export type RectificationOfferHook = Readonly<{
   decide: () => Promise<RectificationOfferDecision>;
   alreadyOffered: boolean;
   revisitQuestion: string;
+  /** This consultation. Direct entry opens from it (BUG-1306). */
+  sourceSessionId: string;
+  /**
+   * Called only for an explicit request while a case is already in progress.
+   * The rectification session to resume, or null when it cannot be read.
+   */
+  loadResumableSessionId: () => Promise<string | null>;
   now?: () => Date;
 }>;
 
@@ -1039,40 +1063,120 @@ const evidenceLookupInputSchema = z.object({
 }).strict();
 
 const RECTIFICATION_OFFER_REFUSAL_NOTES: Readonly<Record<Exclude<RectificationOfferDecision, { ok: true }>["reason"], string>> = {
-  not_self: "问的不是用户本人的盘，生时校正暂时只支持本人。正文用一句话照实说明（例：「给家人校正暂时还不支持」），不出卡。",
-  product_disabled: "生时校正暂时没有开放。正文不要提校正。",
+  not_self: `问的不是用户本人的盘，生时校正暂时只支持本人。正文用这一句说明：「${RECTIFICATION_DIRECT_NOT_SELF_COPY}」，不出卡。`,
+  product_disabled: `出生时间核对这会儿做不了。正文必须用这一句说明：「${RECTIFICATION_DIRECT_UNAVAILABLE_COPY}」，不写内部原因。`,
   case_in_progress: "用户已经有一次没做完的生时校正。正文用一句话告诉他可以在历史对话里接着做。",
-  pricing_unavailable: "生时校正这会儿提供不了。正文不要提校正。",
+  pricing_unavailable: `出生时间核对这会儿做不了。正文必须用这一句说明：「${RECTIFICATION_DIRECT_UNAVAILABLE_COPY}」，不写价格。`,
 };
 
+function offerRecord(
+  hook: RectificationOfferHook,
+  decision: Extract<RectificationOfferDecision, { ok: true }>,
+  status: RectificationOfferRecord["status"],
+): RectificationOfferRecord {
+  return {
+    status,
+    creditCost: decision.creditCost,
+    questionEstimate: decision.questionEstimate,
+    sourceQuestion: hook.revisitQuestion,
+    offeredAt: (hook.now?.() ?? new Date()).toISOString(),
+  };
+}
+
 /**
- * The offer card tool (C3, BUG-1248). It only records the offer for this turn;
- * the server decides whether a card may be shown and the card itself carries
- * the question count and price. Never calculates, never opens a case.
+ * Explicit request (BUG-1306): the server already decided. A pass records an
+ * opened offer with no case id yet and tells the stream to open. A case
+ * already in progress resumes that case. Anything else is one sentence.
+ */
+async function finishExplicitRectificationRequest(
+  state: ConsultationRuntimeState,
+  hook: RectificationOfferHook,
+  decision: RectificationOfferDecision,
+) {
+  if (decision.ok) {
+    state.rectificationOffer = offerRecord(hook, decision, "opened");
+    state.rectificationDirectEntry = {
+      kind: "new",
+      sentence: RECTIFICATION_DIRECT_NEW_COPY,
+      sourceSessionId: hook.sourceSessionId,
+    };
+    return {
+      offered: true as const,
+      directEntry: "new" as const,
+      note: `只写这一句过渡，不写解读：「${RECTIFICATION_DIRECT_NEW_COPY}」`,
+    };
+  }
+  if (decision.reason === "case_in_progress") {
+    let resumeSessionId: string | null = null;
+    try {
+      resumeSessionId = await hook.loadResumableSessionId();
+    } catch {
+      resumeSessionId = null;
+    }
+    if (resumeSessionId) {
+      state.rectificationDirectEntry = {
+        kind: "resume",
+        sentence: RECTIFICATION_DIRECT_RESUME_COPY,
+        sourceSessionId: hook.sourceSessionId,
+        resumeSessionId,
+      };
+      return {
+        offered: false as const,
+        reason: decision.reason,
+        directEntry: "resume" as const,
+        note: `只写这一句，不写解读：「${RECTIFICATION_DIRECT_RESUME_COPY}」`,
+      };
+    }
+    state.rectificationDirectEntry = {
+      kind: "refused",
+      sentence: RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY,
+      sourceSessionId: hook.sourceSessionId,
+    };
+    return { offered: false as const, reason: decision.reason, note: RECTIFICATION_OFFER_REFUSAL_NOTES.case_in_progress };
+  }
+  const sentence = decision.reason === "not_self"
+    ? RECTIFICATION_DIRECT_NOT_SELF_COPY
+    : RECTIFICATION_DIRECT_UNAVAILABLE_COPY;
+  state.rectificationDirectEntry = {
+    kind: "refused",
+    sentence,
+    sourceSessionId: hook.sourceSessionId,
+  };
+  return { offered: false as const, reason: decision.reason, note: RECTIFICATION_OFFER_REFUSAL_NOTES[decision.reason] };
+}
+
+/**
+ * The offer card tool (C3, BUG-1248; direct entry BUG-1306). The server decides
+ * whether a card may be shown or this turn opens rectification. Never calculates.
+ * The rule text lives only in RECTIFICATION_OFFER_RULE.
  */
 function createRectificationOfferTool(ctx: Readonly<{ state: ConsultationRuntimeState; rectificationOffer?: RectificationOfferHook }>) {
   return createTool({
     id: RECTIFICATION_OFFER_TOOL_ID,
-    description: "Offer birth-time rectification under this answer. Call it before writing the answer, only when the user says a concrete past event does not fit the chart, says the birth time is an estimate or unsure, or asks to check the birth time; never for a disagreement with an interpretation. Pass userAsked=true only when the user asked for it in this turn. The result says whether a card will be shown and what to say in one sentence.",
-    inputSchema: z.object({ userAsked: z.boolean().optional() }).strict(),
+    description: "Offer birth-time rectification under this answer, or open it when explicitRequest is true. Call before writing the answer. Pass explicitRequest=true only when the user explicitly asks to do rectification this turn; then write only the one transition sentence in the result and no reading. Pass userAsked=true only when the user asks again after an earlier offer in this conversation. Never call it for a disagreement with an interpretation. Do not promise to narrow the birth time or collect life events here. The result says whether a card will be shown and what one sentence to write.",
+    inputSchema: z.object({
+      userAsked: z.boolean().optional(),
+      explicitRequest: z.boolean().optional(),
+    }).strict(),
     execute: async (input) => {
       const hook = ctx.rectificationOffer;
       if (!hook) return { offered: false as const, reason: "unavailable", note: RECTIFICATION_OFFER_REFUSAL_NOTES.product_disabled };
-      if (ctx.state.rectificationOffer) {
-        return { offered: true as const, note: "提议卡已经在了。正文用一句话提一下就好，不写价格和题数。" };
+      if (input.explicitRequest === true && ctx.state.rectificationDirectEntry) {
+        return { offered: false as const, note: "已经在打开。不要再写解读。" };
       }
-      if (hook.alreadyOffered && input.userAsked !== true) {
+      if (ctx.state.rectificationDirectEntry || ctx.state.rectificationOffer) {
+        if (ctx.state.rectificationOffer) {
+          return { offered: true as const, note: "提议卡已经在了。正文用一句话提一下就好，不写价格和题数。" };
+        }
+        return { offered: false as const, note: "已经在打开。不要再写解读。" };
+      }
+      if (hook.alreadyOffered && input.userAsked !== true && input.explicitRequest !== true) {
         return { offered: false as const, reason: "already_offered_in_session", note: "这次对话里已经提议过一次，用户没接。不再主动提校正，正常回答。" };
       }
       const decision = await hook.decide();
+      if (input.explicitRequest === true) return finishExplicitRectificationRequest(ctx.state, hook, decision);
       if (!decision.ok) return { offered: false as const, reason: decision.reason, note: RECTIFICATION_OFFER_REFUSAL_NOTES[decision.reason] };
-      ctx.state.rectificationOffer = {
-        status: "offered",
-        creditCost: decision.creditCost,
-        questionEstimate: decision.questionEstimate,
-        sourceQuestion: hook.revisitQuestion,
-        offeredAt: (hook.now?.() ?? new Date()).toISOString(),
-      };
+      ctx.state.rectificationOffer = offerRecord(hook, decision, "offered");
       return { offered: true as const, note: "你的回答下面会出现一张提议卡，写着大约几题、几点。正文最后一段必须有一句提到它（例：「如果想确认出生时间准不准，可以用下面的卡片，答几道过去经历的题核对一下。」），不写价格和题数，不催。" };
     },
   });

frontend/tests/consult-evidence-card-telemetry-20260927.test.ts

@@ -87,7 +87,13 @@ test("the consult route logs the record once per natal turn, without session or
   assert.match(block, /agentVersion: "consultation-evidence-card-v2"/);
   assert.doesNotMatch(block, /sessionId|userId/);
   const natal = route.slice(route.indexOf("const agent = getJyotishAgent(selectedModel, agentContext);"));
-  assert.match(natal, /answerForTelemetry = output;[\s\S]*return settleRun\(\(\) => completeResponse\(/);
+  // 原值: /answerForTelemetry = output;[\s\S]*return settleRun\(\(\) => completeResponse\(/
+  // 新值: 非直达仍把 output 记入 answerForTelemetry，并经 settleAnswer 调用 completeResponse
+  // 原因: BUG-1306 直达轮不把模型正文当回答，结算改走 complete_consultation_free
+  assert.match(natal, /if \(!state\.rectificationDirectEntry\) answerForTelemetry = output;/);
+  assert.match(natal, /return settleAnswer\(/);
+  const settle = route.slice(route.indexOf("const settleAnswer ="), route.indexOf("if (usesPublicDailyGeneralAgent"));
+  assert.match(settle, /return settleRun\(\(\) => completeResponse\(/);
   // Only a finished answer counts citations; a failed run logs the card size with no citations.
   assert.doesNotMatch(natal, /onError: \(error, _emitted, output\)/);
 });

frontend/tests/rectification-explicit-entry-20261012.test.ts

@@ -0,0 +1,589 @@
+// BUG-1306: an explicit request opens rectification directly. Fictional data only.
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import { consultationAgentPublicEventSchema, createNdjsonParser, type AgentExecutionReceipt, type ConsultationAgentPublicEvent } from "../src/lib/consultation-agent-events.ts";
+import { RECTIFICATION_OFFER_RULE } from "../src/lib/consultation-thinking-plan.ts";
+import {
+  RECTIFICATION_DIRECT_NEW_COPY,
+  RECTIFICATION_DIRECT_NOT_SELF_COPY,
+  RECTIFICATION_DIRECT_RESUME_COPY,
+  RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY,
+  RECTIFICATION_DIRECT_UNAVAILABLE_COPY,
+  RECTIFICATION_OFFER_TOOL_ID,
+  attachOpenedOfferToFreeMessage,
+  bindOfferToCase,
+  offerForCase,
+  sourceFromSessionRows,
+  type RectificationOfferRecord,
+} from "../src/lib/rectification-in-chat.ts";
+import { CONTRACT_DEGRADED_NOTE, streamAgentResponse } from "../src/lib/stream-agent-response.ts";
+import type { Pass4Mode } from "../src/lib/timing-output-guard.ts";
+import {
+  consultationStepBudgetReceipt,
+  createConsultationRuntimeState,
+  createConsultationTools,
+  publicConsultationRuntimeSteps,
+} from "../src/mastra/consultation-tools.ts";
+
+const CASE_ID = "11111111-1111-4111-8111-111111111111";
+const OTHER_CASE = "55555555-5555-4555-8555-555555555555";
+const RECT_SESSION = "22222222-2222-4222-8222-222222222222";
+const SOURCE_SESSION = "33333333-3333-4333-8333-333333333333";
+const RESUME_SESSION = "44444444-4444-4444-8444-444444444444";
+const REQUEST_ID = "66666666-6666-4666-8666-666666666666";
+
+const DIRECT_SENTENCES = [
+  RECTIFICATION_DIRECT_NEW_COPY,
+  RECTIFICATION_DIRECT_RESUME_COPY,
+  RECTIFICATION_DIRECT_UNAVAILABLE_COPY,
+  RECTIFICATION_DIRECT_NOT_SELF_COPY,
+  RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY,
+] as const;
+
+const STOP_FINISH = { type: "finish", payload: { stepResult: { reason: "stop" }, output: { usage: {}, steps: [{}] } } };
+
+type OfferDecision =
+  | { ok: true; creditCost: number; questionEstimate: number }
+  | { ok: false; reason: "not_self" | "product_disabled" | "case_in_progress" | "pricing_unavailable" };
+
+function offer(status: RectificationOfferRecord["status"] = "offered", extra: Partial<RectificationOfferRecord> = {}): RectificationOfferRecord {
+  return {
+    status,
+    creditCost: 3,
+    questionEstimate: 8,
+    sourceQuestion: "我和伴侣还能走下去吗",
+    offeredAt: "2026-10-07T00:00:00.000Z",
+    ...extra,
+  };
+}
+
+function offerTool(options: {
+  alreadyOffered?: boolean;
+  decide?: () => Promise<OfferDecision>;
+  loadResumableSessionId?: () => Promise<string | null>;
+} = {}) {
+  const state = createConsultationRuntimeState();
+  let decisions = 0;
+  let loads = 0;
+  const tools = createConsultationTools({
+    userId: "user-fictional",
+    sessionId: SOURCE_SESSION,
+    requestId: REQUEST_ID,
+    consultationMode: "verified_chart",
+    serverChart: {} as never,
+    state,
+    rectificationOffer: {
+      decide: async () => {
+        decisions += 1;
+        return options.decide ? options.decide() : { ok: true, creditCost: 3, questionEstimate: 8 };
+      },
+      alreadyOffered: options.alreadyOffered ?? false,
+      revisitQuestion: "我和伴侣还能走下去吗",
+      sourceSessionId: SOURCE_SESSION,
+      loadResumableSessionId: async () => {
+        loads += 1;
+        return options.loadResumableSessionId ? options.loadResumableSessionId() : null;
+      },
+      now: () => new Date("2026-10-07T00:00:00.000Z"),
+    },
+  }) as Record<string, { execute: (input: unknown, context?: unknown) => Promise<Record<string, unknown>> }>;
+  return { state, decisions: () => decisions, loads: () => loads, tool: tools[RECTIFICATION_OFFER_TOOL_ID]! };
+}
+
+function src(relative: string) {
+  return readFileSync(new URL(relative, import.meta.url), "utf8");
+}
+
+function walkSources(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === "node_modules") continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walkSources(full));
+    else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) out.push(full);
+  }
+  return out;
+}
+
+test("direct-entry sentences stay within the free-completion length", () => {
+  assert.deepEqual(DIRECT_SENTENCES.map((sentence) => Array.from(sentence).length), [13, 13, 14, 11, 11]);
+  for (const sentence of DIRECT_SENTENCES) assert.ok(Array.from(sentence).length <= 20);
+  assert.equal(RECTIFICATION_DIRECT_NEW_COPY, "好，我们开始核对出生时间。");
+  assert.equal(RECTIFICATION_DIRECT_RESUME_COPY, "核对还没做完，我们接着做。");
+  assert.equal(RECTIFICATION_DIRECT_UNAVAILABLE_COPY, "出生时间核对这会儿还做不了。");
+  assert.equal(RECTIFICATION_DIRECT_NOT_SELF_COPY, "给家人校正暂时还不支持");
+  assert.equal(RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY, "可在历史对话里接着做。");
+});
+
+test("an opened offer with no case id binds, and a reload can find that case", () => {
+  const opened = [{
+    role: "assistant",
+    text: RECTIFICATION_DIRECT_NEW_COPY,
+    responseKind: "smalltalk",
+    rectificationOffer: offer("opened"),
+  }];
+  assert.equal(sourceFromSessionRows([{ id: SOURCE_SESSION, messages: opened }], CASE_ID), null);
+  const bound = bindOfferToCase(opened, { caseId: CASE_ID, rectificationSessionId: RECT_SESSION });
+  assert.ok(bound);
+  assert.equal((bound![0]!.rectificationOffer as RectificationOfferRecord).status, "opened");
+  assert.equal((bound![0]!.rectificationOffer as RectificationOfferRecord).caseId, CASE_ID);
+  assert.equal((bound![0]!.rectificationOffer as RectificationOfferRecord).rectificationSessionId, RECT_SESSION);
+  assert.equal(bindOfferToCase(bound, { caseId: CASE_ID, rectificationSessionId: RECT_SESSION }), null);
+  assert.ok(offerForCase(bound, CASE_ID));
+  assert.deepEqual(sourceFromSessionRows([{ id: SOURCE_SESSION, messages: bound }], CASE_ID), {
+    sessionId: SOURCE_SESSION,
+    question: "我和伴侣还能走下去吗",
+    returned: null,
+  });
+});
+
+test("binding leaves another case's opened record alone and still binds a later card", () => {
+  const messages = [
+    { role: "assistant", text: "旧卡", rectificationOffer: offer("opened", { caseId: OTHER_CASE, rectificationSessionId: RECT_SESSION }) },
+    { role: "assistant", text: RECTIFICATION_DIRECT_NEW_COPY, responseKind: "smalltalk", rectificationOffer: offer("opened") },
+  ];
+  assert.equal(bindOfferToCase(
+    [{ role: "assistant", rectificationOffer: offer("opened", { caseId: OTHER_CASE, rectificationSessionId: RECT_SESSION }) }],
+    { caseId: CASE_ID, rectificationSessionId: RECT_SESSION },
+  ), null);
+  const bound = bindOfferToCase(messages, { caseId: CASE_ID, rectificationSessionId: RECT_SESSION });
+  assert.ok(bound);
+  assert.equal((bound![0]!.rectificationOffer as RectificationOfferRecord).caseId, OTHER_CASE);
+  assert.equal((bound![1]!.rectificationOffer as RectificationOfferRecord).caseId, CASE_ID);
+  assert.equal((bound![1]!.rectificationOffer as RectificationOfferRecord).status, "opened");
+});
+
+test("the free reply can carry the opened offer once, without clobbering a case id", () => {
+  const sentence = RECTIFICATION_DIRECT_NEW_COPY;
+  const card = offer("opened");
+  assert.equal(attachOpenedOfferToFreeMessage([], { sentence, offer: card }), "missing");
+  assert.equal(attachOpenedOfferToFreeMessage(
+    [{ role: "assistant", text: sentence, responseKind: "consultation" }],
+    { sentence, offer: card },
+  ), "missing");
+  const attached = attachOpenedOfferToFreeMessage(
+    [{ role: "user", text: "请帮我核对出生时间" }, { role: "assistant", text: sentence, responseKind: "smalltalk" }],
+    { sentence, offer: card },
+  );
+  assert.ok(Array.isArray(attached));
+  assert.deepEqual(attached[1]!.rectificationOffer, card);
+  assert.equal(attachOpenedOfferToFreeMessage(attached, { sentence, offer: card }), "present");
+  const withCase = attachOpenedOfferToFreeMessage(
+    [{ role: "assistant", text: sentence, responseKind: "smalltalk", rectificationOffer: offer("opened", { caseId: CASE_ID, rectificationSessionId: RECT_SESSION }) }],
+    { sentence, offer: card },
+  );
+  assert.equal(withCase, "present");
+});
+
+test("explicit pass opens once, records an opened offer, and does not open again", async () => {
+  const fresh = offerTool();
+  const result = await fresh.tool.execute({ explicitRequest: true, userAsked: true });
+  assert.equal(result.offered, true);
+  assert.equal(result.directEntry, "new");
+  assert.match(String(result.note), /好，我们开始核对出生时间/);
+  assert.deepEqual(fresh.state.rectificationOffer, offer("opened"));
+  assert.equal(fresh.state.rectificationOffer?.caseId, undefined);
+  assert.deepEqual(fresh.state.rectificationDirectEntry, {
+    kind: "new",
+    sentence: RECTIFICATION_DIRECT_NEW_COPY,
+    sourceSessionId: SOURCE_SESSION,
+  });
+  assert.equal(fresh.loads(), 0);
+  assert.equal(fresh.decisions(), 1);
+  const again = await fresh.tool.execute({ explicitRequest: true });
+  assert.equal(again.offered, false);
+  assert.match(String(again.note), /已经在打开/);
+  assert.match(String(again.note), /不要再写解读/);
+  assert.equal(fresh.decisions(), 1);
+  assert.deepEqual(fresh.state.rectificationOffer, offer("opened"));
+});
+
+test("explicitRequest bypasses an earlier offer, and userAsked alone still only shows a card", async () => {
+  const direct = offerTool({ alreadyOffered: true });
+  const opened = await direct.tool.execute({ explicitRequest: true });
+  assert.equal(opened.directEntry, "new");
+  assert.equal(direct.state.rectificationOffer?.status, "opened");
+  assert.equal(direct.state.rectificationDirectEntry?.kind, "new");
+
+  const card = offerTool({ alreadyOffered: true });
+  const asked = await card.tool.execute({ userAsked: true });
+  assert.equal(asked.offered, true);
+  assert.equal(card.state.rectificationOffer?.status, "offered");
+  assert.equal(card.state.rectificationDirectEntry, undefined);
+
+  const held = offerTool();
+  await held.tool.execute({});
+  const second = await held.tool.execute({ explicitRequest: true });
+  assert.match(String(second.note), /提议卡已经在了/);
+  assert.equal(held.state.rectificationDirectEntry, undefined);
+  assert.equal(held.state.rectificationOffer?.status, "offered");
+  assert.equal(held.decisions(), 1);
+});
+
+test("an in-progress case resumes that session, or says to continue in history", async () => {
+  const resume = offerTool({
+    decide: async () => ({ ok: false, reason: "case_in_progress" }),
+    loadResumableSessionId: async () => RESUME_SESSION,
+  });
+  const resumed = await resume.tool.execute({ explicitRequest: true });
+  assert.equal(resumed.offered, false);
+  assert.equal(resumed.directEntry, "resume");
+  assert.equal(resume.state.rectificationOffer, undefined);
+  assert.deepEqual(resume.state.rectificationDirectEntry, {
+    kind: "resume",
+    sentence: RECTIFICATION_DIRECT_RESUME_COPY,
+    sourceSessionId: SOURCE_SESSION,
+    resumeSessionId: RESUME_SESSION,
+  });
+  assert.equal(resume.loads(), 1);
+
+  const missing = offerTool({ decide: async () => ({ ok: false, reason: "case_in_progress" }) });
+  const refused = await missing.tool.execute({ explicitRequest: true });
+  assert.equal(refused.directEntry, undefined);
+  assert.equal(missing.state.rectificationDirectEntry?.kind, "refused");
+  assert.equal(missing.state.rectificationDirectEntry?.sentence, RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY);
+  assert.equal(missing.state.rectificationOffer, undefined);
+  assert.match(String(refused.note), /历史对话/);
+  assert.doesNotMatch(String(refused.note), /不要提校正/);
+
+  const thrown = offerTool({
+    decide: async () => ({ ok: false, reason: "case_in_progress" }),
+    loadResumableSessionId: async () => { throw new Error("db down"); },
+  });
+  const fallback = await thrown.tool.execute({ explicitRequest: true });
+  assert.equal(thrown.state.rectificationDirectEntry?.kind, "refused");
+  assert.equal(thrown.state.rectificationDirectEntry?.sentence, RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY);
+  assert.match(String(fallback.note), /历史对话/);
+
+  const quiet = offerTool({ decide: async () => ({ ok: false, reason: "case_in_progress" }) });
+  const ordinary = await quiet.tool.execute({});
+  assert.equal(quiet.loads(), 0);
+  assert.equal(quiet.state.rectificationDirectEntry, undefined);
+  assert.match(String(ordinary.note), /历史对话/);
+  assert.doesNotMatch(String(ordinary.note), /不要提校正/);
+});
+
+test("explicit refusals are one sentence, and none of the four notes says to hide rectification", async () => {
+  const unavailable = offerTool({ decide: async () => ({ ok: false, reason: "product_disabled" }) });
+  const disabled = await unavailable.tool.execute({ explicitRequest: true });
+  assert.equal(unavailable.state.rectificationDirectEntry?.kind, "refused");
+  assert.equal(unavailable.state.rectificationDirectEntry?.sentence, RECTIFICATION_DIRECT_UNAVAILABLE_COPY);
+  assert.equal(unavailable.state.rectificationOffer, undefined);
+  assert.match(String(disabled.note), /出生时间核对这会儿还做不了/);
+  assert.match(String(disabled.note), /不写内部原因/);
+  assert.doesNotMatch(String(disabled.note), /不要提校正/);
+
+  const unpriced = offerTool({ decide: async () => ({ ok: false, reason: "pricing_unavailable" }) });
+  const priced = await unpriced.tool.execute({ explicitRequest: true });
+  assert.equal(unpriced.state.rectificationDirectEntry?.sentence, RECTIFICATION_DIRECT_UNAVAILABLE_COPY);
+  assert.match(String(priced.note), /出生时间核对这会儿还做不了/);
+  assert.match(String(priced.note), /不写价格/);
+  assert.doesNotMatch(String(priced.note), /不要提校正/);
+
+  const family = offerTool({ decide: async () => ({ ok: false, reason: "not_self" }) });
+  const other = await family.tool.execute({ explicitRequest: true });
+  assert.equal(family.state.rectificationDirectEntry?.sentence, RECTIFICATION_DIRECT_NOT_SELF_COPY);
+  assert.match(String(other.note), /给家人校正暂时还不支持/);
+  assert.doesNotMatch(String(other.note), /不要提校正/);
+
+  const plainFamily = offerTool({ decide: async () => ({ ok: false, reason: "not_self" }) });
+  const plain = await plainFamily.tool.execute({});
+  assert.equal(plainFamily.state.rectificationDirectEntry, undefined);
+  assert.doesNotMatch(String(plain.note), /不要提校正/);
+  const plainPrice = offerTool({ decide: async () => ({ ok: false, reason: "pricing_unavailable" }) });
+  assert.doesNotMatch(String((await plainPrice.tool.execute({})).note), /不要提校正/);
+  const plainOff = offerTool({ decide: async () => ({ ok: false, reason: "product_disabled" }) });
+  assert.doesNotMatch(String((await plainOff.tool.execute({})).note), /不要提校正/);
+  assert.equal(plainPrice.state.rectificationDirectEntry, undefined);
+  assert.equal(plainOff.state.rectificationDirectEntry, undefined);
+});
+
+function receipt(state: ReturnType<typeof createConsultationRuntimeState>): AgentExecutionReceipt {
+  return {
+    runId: "run-direct",
+    runtime: "mastra-agentic",
+    skill: {
+      name: "jyotish-vedic-astrology",
+      loaded: state.jyotishSkillBound,
+      referenceReads: state.skillReferenceReadCount,
+      methodologySections: state.methodologySectionCount,
+    },
+    steps: publicConsultationRuntimeSteps(state),
+    stepBudget: consultationStepBudgetReceipt(state),
+    workflow: { route: "career", status: "ready", preciseTiming: "blocked", missingLayers: [] },
+  };
+}
+
+function visibleAnswer(events: readonly ConsultationAgentPublicEvent[]) {
+  let text = "";
+  for (const event of events) {
+    if (event.type !== "answer.delta") continue;
+    text = event.replace ? event.text : text + event.text;
+  }
+  return text;
+}
+
+async function readStream(response: Response) {
+  const events: ConsultationAgentPublicEvent[] = [];
+  const parser = createNdjsonParser((event) => events.push(event));
+  parser.finish(await response.text());
+  return events;
+}
+
+test("natal and window direct entry or explicit refusal skips the runtime-contract retry", async () => {
+  const modes: Pass4Mode[] = ["verified_chart", "declared_birth_window"];
+  const kinds = ["new", "resume", "refused"] as const;
+  for (const pass4Mode of modes) {
+    for (const kind of kinds) {
+      const state = createConsultationRuntimeState();
+      const sentence = kind === "new"
+        ? RECTIFICATION_DIRECT_NEW_COPY
+        : kind === "resume"
+          ? RECTIFICATION_DIRECT_RESUME_COPY
+          : RECTIFICATION_DIRECT_UNAVAILABLE_COPY;
+      let contractRetries = 0;
+      let answerRetries = 0;
+      let warmupRan = false;
+      let completedOutput = "";
+      const response = streamAgentResponse({
+        runId: "run-direct",
+        requestId: REQUEST_ID,
+        state,
+        requireTool: true,
+        pass4Mode,
+        stepScopedAnswer: true,
+        toolStatus: () => "ready",
+        receipt: () => receipt(state),
+        ...(pass4Mode === "declared_birth_window"
+          ? {
+            warmup: async (send: (event: ConsultationAgentPublicEvent) => void) => {
+              warmupRan = true;
+              send({ type: "activity", phase: "chart-calculation", label: "窗口预热" });
+            },
+          }
+          : {}),
+        stream: (async function* () {
+          yield { type: "text-delta", payload: { text: "我先看看盘。" } };
+          yield { type: "tool-call", payload: { toolCallId: "offer-1", toolName: "offer-birth-time-rectification" } };
+          state.rectificationDirectEntry = {
+            kind,
+            sentence,
+            sourceSessionId: SOURCE_SESSION,
+            ...(kind === "resume" ? { resumeSessionId: RESUME_SESSION } : {}),
+          };
+          if (kind === "new") state.rectificationOffer = offer("opened");
+          yield { type: "text-delta", payload: { text: "然后写一段解读。" } };
+          yield STOP_FINISH;
+        })(),
+        retry: async () => {
+          contractRetries += 1;
+          return (async function* () { yield STOP_FINISH; })();
+        },
+        retryForAnswer: async () => {
+          answerRetries += 1;
+          return (async function* () { yield STOP_FINISH; })();
+        },
+        onComplete: (output) => { completedOutput = output; },
+      });
+      const events = await readStream(response);
+      assert.equal(contractRetries, 0, `${pass4Mode} ${kind} retried the contract`);
+      assert.equal(answerRetries, 0, `${pass4Mode} ${kind} retried the answer`);
+      assert.equal(state.consultationToolCompleted, false);
+      assert.equal(visibleAnswer(events), sentence);
+      assert.equal(visibleAnswer(events).includes("我先看看盘"), false);
+      assert.equal(visibleAnswer(events).includes("然后写一段解读"), false);
+      assert.equal(visibleAnswer(events).includes(CONTRACT_DEGRADED_NOTE), false);
+      assert.equal(completedOutput, sentence);
+      if (pass4Mode === "declared_birth_window") assert.equal(warmupRan, true);
+      const completed = events.filter((event) => event.type === "run.completed");
+      assert.equal(completed.length, 1);
+      const done = completed[0]!;
+      assert.equal(done.type === "run.completed" && done.responseKind, "smalltalk");
+      assert.equal(done.type === "run.completed" && done.receipt, undefined);
+      if (kind === "new") {
+        assert.equal(done.type === "run.completed" && done.rectificationOffer?.status, "opened");
+        assert.equal(done.type === "run.completed" && done.rectificationOffer?.caseId, undefined);
+        assert.deepEqual(done.type === "run.completed" ? done.rectificationDirectOpen : undefined, {
+          sourceSessionId: SOURCE_SESSION,
+          mode: "new",
+        });
+      } else if (kind === "resume") {
+        assert.equal(done.type === "run.completed" && done.rectificationOffer, undefined);
+        assert.deepEqual(done.type === "run.completed" ? done.rectificationDirectOpen : undefined, {
+          sourceSessionId: SOURCE_SESSION,
+          mode: "resume",
+          resumeSessionId: RESUME_SESSION,
+        });
+      } else {
+        assert.equal(done.type === "run.completed" && done.rectificationDirectOpen, undefined);
+        assert.equal(done.type === "run.completed" && done.rectificationOffer, undefined);
+      }
+      assert.equal(events.some((event) => event.type === "activity" && event.label === "正在补齐方法与计算步骤"), false);
+    }
+  }
+});
+
+test("a reading that already streamed is replaced by the direct-entry sentence", async () => {
+  for (const pass4Mode of ["verified_chart", "declared_birth_window"] as const) {
+    const state = createConsultationRuntimeState();
+    state.consultationToolCompleted = true;
+    state.consultationToolSuccessCount = 1;
+    let contractRetries = 0;
+    const response = streamAgentResponse({
+      runId: "run-direct",
+      requestId: REQUEST_ID,
+      state,
+      requireTool: true,
+      pass4Mode,
+      stepScopedAnswer: true,
+      toolStatus: () => "ready",
+      receipt: () => receipt(state),
+      stream: (async function* () {
+        yield { type: "text-delta", payload: { text: "事业方向的判断如下。" } };
+        yield { type: "step-finish", payload: { stepResult: { reason: "stop" } } };
+        state.rectificationDirectEntry = {
+          kind: "new",
+          sentence: RECTIFICATION_DIRECT_NEW_COPY,
+          sourceSessionId: SOURCE_SESSION,
+        };
+        state.rectificationOffer = offer("opened");
+        yield STOP_FINISH;
+      })(),
+      retry: async () => {
+        contractRetries += 1;
+        return (async function* () { yield STOP_FINISH; })();
+      },
+    });
+    const events = await readStream(response);
+    assert.equal(contractRetries, 0);
+    assert.equal(events.some((event) => event.type === "answer.delta" && event.text.includes("事业方向的判断如下")), true);
+    assert.equal(events.some((event) => event.type === "answer.delta" && event.replace === true && event.text === RECTIFICATION_DIRECT_NEW_COPY), true);
+    assert.equal(visibleAnswer(events), RECTIFICATION_DIRECT_NEW_COPY);
+  }
+});
+
+test("an ordinary consultation still retries once when the calculation never finished", async () => {
+  const state = createConsultationRuntimeState();
+  let contractRetries = 0;
+  let answerRetries = 0;
+  const response = streamAgentResponse({
+    runId: "run-direct",
+    requestId: REQUEST_ID,
+    state,
+    requireTool: true,
+    pass4Mode: "verified_chart",
+    stepScopedAnswer: true,
+    toolStatus: () => "ready",
+    receipt: () => receipt(state),
+    stream: (async function* () {
+      yield { type: "text-delta", payload: { text: "还没排盘。" } };
+      yield STOP_FINISH;
+    })(),
+    retry: async () => {
+      contractRetries += 1;
+      state.consultationToolCompleted = true;
+      state.consultationToolSuccessCount = 1;
+      return (async function* () {
+        yield { type: "text-delta", payload: { text: "事业方向可以看。" } };
+        yield STOP_FINISH;
+      })();
+    },
+    retryForAnswer: async () => {
+      answerRetries += 1;
+      return (async function* () { yield STOP_FINISH; })();
+    },
+  });
+  const events = await readStream(response);
+  assert.equal(contractRetries, 1);
+  assert.equal(answerRetries, 0);
+  assert.equal(visibleAnswer(events), "事业方向可以看。");
+  assert.equal(visibleAnswer(events).includes(CONTRACT_DEGRADED_NOTE), false);
+  assert.equal(visibleAnswer(events).includes("还没排盘"), false);
+  const done = events.find((event) => event.type === "run.completed");
+  assert.equal(done?.type === "run.completed" && done.receipt !== undefined, true);
+  assert.equal(done?.type === "run.completed" && done.responseKind, undefined);
+  assert.equal(events.some((event) => event.type === "activity" && event.label === "正在补齐方法与计算步骤"), true);
+});
+
+test("the offer rule is defined once, and direct entry settles with the free completion", () => {
+  const definitions = walkSources(fileURLToPath(new URL("../src/", import.meta.url))).filter((file) => (
+    readFileSync(file, "utf8").includes("export const RECTIFICATION_OFFER_RULE")
+  ));
+  assert.equal(definitions.length, 1);
+  assert.match(definitions[0]!, /consultation-thinking-plan\.ts$/);
+  assert.match(RECTIFICATION_OFFER_RULE, /不承诺能收窄出生时间/);
+  assert.match(RECTIFICATION_OFFER_RULE, /不在对话里收集经历做校正/);
+  assert.match(RECTIFICATION_OFFER_RULE, /explicitRequest=true/);
+  assert.match(RECTIFICATION_OFFER_RULE, /只写那一句过渡，不写解读/);
+  assert.match(RECTIFICATION_OFFER_RULE, /只是不认同某个解释，按纠正规则认下、改读，不提校正/);
+  assert.match(RECTIFICATION_OFFER_RULE, /userAsked=true/);
+
+  const tools = src("../src/mastra/consultation-tools.ts");
+  assert.doesNotMatch(tools, /不承诺能收窄出生时间/);
+  assert.doesNotMatch(tools, /不要提校正/);
+  assert.match(tools, /explicitRequest/);
+  assert.match(tools, /userAsked/);
+
+  const route = src("../src/app/api/consult/route.ts");
+  assert.match(route, /大运、子运只说「在哪一段附近」，不写起止年月日/);
+  assert.match(route, /这只是粗看。" \+ RECTIFICATION_OFFER_RULE;/);
+  assert.doesNotMatch(route, /请你帮我进行生时纠正/);
+  const direct = route.slice(
+    route.indexOf("async function completeDirectRectificationTurn"),
+    route.indexOf("let settlement:"),
+  );
+  assert.match(direct, /complete_consultation_free/);
+  assert.match(direct, /responseKind: "smalltalk"/);
+  assert.match(direct, /persistOpenedDirectOffer/);
+  assert.doesNotMatch(direct, /complete_consultation_response/);
+  assert.doesNotMatch(direct, /consultation_requests/);
+  const windowBlock = route.slice(
+    route.indexOf("if (shouldRunDeclaredWindowWorkflow(consultationMode))"),
+    route.indexOf("if (!prepared.serverChart)"),
+  );
+  const natalBlock = route.slice(
+    route.indexOf("if (!prepared.serverChart)"),
+    route.indexOf("const history = storedHistory;"),
+  );
+  assert.match(windowBlock, /settleAnswer/);
+  assert.match(natalBlock, /settleAnswer/);
+  assert.match(windowBlock, /warmup:/);
+  assert.match(windowBlock, /precomputeWindowConsultation/);
+  assert.match(windowBlock, /运行合同不完整/);
+  assert.match(natalBlock, /运行合同不完整/);
+  assert.match(route, /getRectificationEntrySummary\(accounting, userId\)/);
+  assert.match(route, /\.from\("agentic_rectification_cases"\)/);
+  assert.match(route, /\.select\("session_id"\)/);
+
+  const stream = src("../src/lib/stream-agent-response.ts");
+  assert.match(stream, /if \(options\.state\.rectificationDirectEntry\) return true;/);
+  assert.match(stream, /rectificationDirectRunCompleted\(options\.state\)/);
+  assert.doesNotMatch(stream, /请你帮我进行生时纠正/);
+
+  const hook = src("../src/hooks/use-consultation-run.ts");
+  assert.match(hook, /openRectificationFromChat\(rectificationDirectOpen\.sourceSessionId\)/);
+  assert.match(hook, /openRectificationSession\(rectificationDirectOpen\.resumeSessionId\)/);
+  assert.equal(hook.match(/openRectificationFromChat\(rectificationDirectOpen\.sourceSessionId\)/g)?.length, 1);
+  assert.match(hook, /responseKind === "smalltalk" \? \{[\s\S]*?rectificationOffer/);
+
+  const page = src("../src/app/(app)/page.tsx");
+  assert.match(page, /openAccountDialog, openRectificationSession, openRectificationFromChat,/);
+  assert.doesNotMatch(page, /请你帮我进行生时纠正/);
+
+  const server = src("../src/lib/rectification-in-chat-server.ts");
+  assert.match(server, /return sourceFromSessionRows/);
+  assert.match(server, /attachOpenedOfferToFreeMessage/);
+  const persist = server.slice(server.indexOf("export async function persistOpenedDirectOffer"), server.indexOf("export async function bindRectificationSource"));
+  assert.doesNotMatch(persist, /consultation_requests/);
+
+  consultationAgentPublicEventSchema.parse({
+    type: "run.completed",
+    responseKind: "smalltalk",
+    rectificationOffer: offer("opened"),
+    rectificationDirectOpen: { sourceSessionId: SOURCE_SESSION, mode: "new" },
+  });
+});

frontend/tests/rectification-in-chat-20261007.test.ts

@@ -128,6 +128,8 @@ function offerTool(options: { alreadyOffered?: boolean; decide?: () => Promise<{
       decide: options.decide ?? (async () => ({ ok: true, creditCost: 3, questionEstimate: 8 })),
       alreadyOffered: options.alreadyOffered ?? false,
       revisitQuestion: "我和伴侣还能走下去吗",
+      sourceSessionId: SOURCE_SESSION,
+      loadResumableSessionId: async () => null,
       now: () => new Date("2026-10-07T00:00:00.000Z"),
     },
   }) as Record<string, { execute: (input: unknown, context?: unknown) => Promise<Record<string, unknown>> }>;