diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2a67b86d..b4fdce80 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # 印度占星 Skill 更新日志
 
+## 2026-10-12 — 校正还没打开时，卡片不说已经开始（待验收）
+
+- 明确要求做校正时，对话里的卡片在真正打开并绑定之前仍是普通提议，按钮是「开始核对出生时间」。打开失败可以再点，不会写成「已经开始」。Skill 版本不变。未推送，未部署。
+
 ## 2026-10-12 — 对话里明说要校正就直接进入（待验收）
 
 - 用户这一轮明确要求做生时校正时，直接打开校正，不先写解读、不用点卡。推得不准时的提议仍走卡片。做不了会用一句话说明，不再沉默。普通对话不承诺收窄出生时间，申报时段不写大运、子运的起止年月日。
diff --git a/docs/BUG_HISTORY.md b/docs/BUG_HISTORY.md
index fcab1509..8f8fe456 100644
--- a/docs/BUG_HISTORY.md
+++ b/docs/BUG_HISTORY.md
@@ -17538,7 +17538,7 @@
 
 ## BUG-1306 | 对话里明说「帮我做生时纠正」进不了校正：模型不出提议卡，反而在普通对话里自己「收窄出生时间」
 
-- 状态：fixed-pending-verify（已部署 staging；T0 无主机日志、T5 无模型凭据，真机清单 `docs/testing/rectification-explicit-entry-20261012.md` 未走前不标 resolved）
+- 状态：fixed-pending-verify（直达已部署 staging；F3 跟进随 10-12 批次合入 staging；T0 无主机日志、T5 无模型凭据，真机清单 `docs/testing/rectification-explicit-entry-20261012.md` 未走前不标 resolved）
 - 首次发现 / 最近更新：2026-10-11 / 2026-10-12
 - 来源：产品在 staging（`de4cfeb8`）新对话第一句输入「请你帮我进行生时纠正」，回复截图转述。
 - 现象：回复显示「已完成 3 步」，正文说「收窄出生时间这件事能做」，要用户报有年月的经历，「对得上，区间就能往里收」；全文没有提到提议卡，界面上也没有卡片。正文还按「代表分钟」写出大运 / 子运起止年月。
@@ -17551,11 +17551,12 @@
 - 推断（未证实）：正文主动承诺能收窄，不像收到「不要提校正」的拒绝，更像模型没有调用提议工具；无模型凭据、无 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`：不承诺收窄出生时间，不在对话里收集经历做校正。申报时段指令补「大运、子运只说在哪一段附近，不写起止年月日」。不改校正引擎、打分、闸门和数据库。
+- 跟进（F3，2026-10-12）：结算不再把记录写成 `opened`。直达通过仍记同结构提议，状态保持 `offered`，只在要自动开案时带 `autoOpen: true`（省略该字段的旧记录照常解析）。卡片在开案并绑定来源之前是普通提议：价格句和「开始核对出生时间」，不说「已经开始」。浏览器仍按 `rectificationDirectOpen` 自动开案，成功路径不用点。只有 `bindOfferToCase` 在开案成功、来源绑定后把状态改成 `opened`。打开失败不把本地记录改成 `opened`，卡片可再点。不新增第四种状态。`complete_consultation_free` 与五句用户文案未改。
 - 验证：`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`。
+- 防复发：`frontend/tests/rectification-explicit-entry-20261012.test.ts` 锁住直达、同一轮不重复开案、无 caseId 的 opened 绑定与找回、四种拒绝说明、两条路径不重试、普通咨询仍重试一次、规则只定义一处、申报时段「在哪一段附近」、结算调用 `complete_consultation_free`。F3 另锁：结算记录是 `offered` 且 `autoOpen: true`、卡片在绑定前不说「已经开始」、绑定后才说已经开始、打开失败仍是 `offered`、旧的 `offered` / `opened` / `returned` 照常解析且 `returned` 不出卡。用户可见句长度 ≤20。真机清单 `docs/testing/rectification-explicit-entry-20261012.md`。
 - 相关记录：BUG-1247、BUG-1248（入口改为提议卡）、BUG-976/977（禁正则判意图）。
 - 复发自：无。
-- 修复版本：staging `b8bdc003`（实现 `6a799582` 变基到 `9f1e8257`，代码逐字节相同；2026-10-12 Claude 验收通过、产品要求合入；部署核对：health gitCommit=b8bdc003、`requiredMigrationsPresent` true，`/login` 200，未登录 `/api/account` 401）。跟进项 F3（打开失败卡片仍说已开始）见 `TASK-rectification-1012-batch-fix-20261012`。
+- 修复版本：staging `b8bdc003`（实现 `6a799582` 变基到 `9f1e8257`，代码逐字节相同；2026-10-12 Claude 验收通过、产品要求合入；部署核对：health gitCommit=b8bdc003、`requiredMigrationsPresent` true，`/login` 200，未登录 `/api/account` 401）。跟进项 F3（打开失败卡片仍说已开始）见 `TASK-rectification-1012-batch-fix-20261012`。 F3 跟进（`51a77721`）随 10-12 批次合入 staging，部署核对见 BUG-1307。
 - 决策日志（2026-10-12，产品）：选 A——用户明确要求做生时校正时直接进入校正，不先写解读、不用点卡；意图由模型判断，禁正则 / 关键词。**推翻 BUG-1248 两处**：①明确要求的这一轮不再「只出卡、点卡才进」；②`product_disabled`、`pricing_unavailable`「正文不要提校正」改为必须一句话说明做不了，不得静默。普通对话模型不得承诺收窄出生时间、不得在对话里收集经历假装校正；申报时段下不得写大运 / 子运精确起止。服务端本人 / 开关 / 进行中 case / 价格判定不变。同日另立 BUG-1307（最近分界开场）、BUG-1308（父母静态题研究）。
 
 ## BUG-1307 | 生时校正开场不说记录时间离最近分界多近，首轮选题面向整个窗口，用户觉得步骤多、目的不明
diff --git a/docs/tasks/PROGRESS-rectification-offer-opened-state-20261012.md b/docs/tasks/PROGRESS-rectification-offer-opened-state-20261012.md
new file mode 100644
index 00000000..d88c6201
--- /dev/null
+++ b/docs/tasks/PROGRESS-rectification-offer-opened-state-20261012.md
@@ -0,0 +1,32 @@
+# PROGRESS · 校正提议在开案成功后才标已开始（BUG-1306 F3，2026-10-12）
+
+分支 `codex/rectification-offer-opened-state-20261012`，基线 `b8bdc003`（`origin/staging`）。未 push，未部署。状态保持 fixed-pending-verify，不是 resolved。
+
+## 结论
+
+明确要求做校正时，结算记下的提议仍是普通提议：状态 `offered`，并带 `autoOpen: true`。卡片写价格和题数，按钮是「开始核对出生时间」，不说「已经开始」。浏览器仍按 `rectificationDirectOpen` 自动开案。只有开案成功、`bindOfferToCase` 绑定来源之后，状态才变成 `opened`，卡片才说「已经开始」。打开失败时记录保持 `offered`，卡片可以再点。没有第四种状态。已存的 `offered` / `opened` / `returned` 照常解析。`complete_consultation_free` 和五句用户文案没改。
+
+## 实现
+
+`finishExplicitRectificationRequest` 不再把结算记录写成 `opened`。`autoOpen` 是可选字段，只在为真时写入；旧记录省略它也能解析。刷新走 `parseRectificationOfferRecord`，不会丢掉这个字段。`persistOpenedDirectOffer` 仍把这条还没打开的记录挂到免费回复上。客户端新开仍调用 `openRectificationFromChat`，接着做仍调用 `openRectificationSession`。开案函数失败时返回空，调用处不把本地记录改成 `opened`。成功仍由原来的绑定路径改状态。
+
+## 既有断言
+
+| 原值 | 新值 | 原因 |
+| --- | --- | --- |
+| `rectification-explicit-entry-20261012.test.ts`「explicit pass…」两处 `deepEqual` 期望 `offer("opened")` | `offer("offered", { autoOpen: true })` | F3：结算保持 offered，用 autoOpen 表示这一轮要自动开案；开案绑定后才是 opened |
+| 同文件「explicitRequest bypasses…」`rectificationOffer.status` 期望 `"opened"` | `"offered"`，且 `autoOpen === true` | 同上。直达入口 `kind: "new"` 不变 |
+| 同文件直达流「run.completed」`rectificationOffer.status` 期望 `"opened"` | `"offered"`，且 `autoOpen === true`；`rectificationDirectOpen.mode` 仍是 `"new"` | 完成事件转发的是结算记录，不能再预写 opened |
+| 同文件两处流式夹具把 `state.rectificationOffer` 设成 `offer("opened")` | `offer("offered", { autoOpen: true })` | 夹具要模拟现在的结算记录，否则事件仍像开案前就已经 opened |
+
+`rectification-in-chat-20261007.test.ts` 里原来的期望值没有改。普通提议仍是没有 `autoOpen` 的 `offered`。无 caseId 的旧 `opened` 记录仍能绑定。
+
+## 验证
+
+| 命令 | 结果 |
+| --- | --- |
+| `npx tsx --test tests/rectification-explicit-entry-20261012.test.ts` | 16 通过，0 失败，cancelled 0 |
+| `npx tsx --test tests/rectification-in-chat-20261007.test.ts` | 15 通过，0 失败，cancelled 0 |
+| `npx tsc --noEmit`（frontend） | 0 错 |
+
+没有跑 `next build`（Turbopack 拒绝 `node_modules` junction）。没有跑全量 `npm test`。没有 `npm install`，没有删 junction。`Home()` 没有改，`page.tsx` 没有改。
diff --git a/docs/tasks/README.md b/docs/tasks/README.md
index a158e7bf..33129382 100644
--- a/docs/tasks/README.md
+++ b/docs/tasks/README.md
@@ -127,7 +127,7 @@
 | `TASK-rectification-explicit-entry-20261012.md` | `PROGRESS-rectification-explicit-entry-20261012.md` | **明说要校正就直接进入（BUG-1306）**：模型判断意图（禁正则），服务端判定后直接开案并绑定来源对话；首轮排盘合同对此轮豁免；拒绝必须一句话说明（推翻 BUG-1248 静默两条）；普通对话不得假装校正、申报时段不写子运起止。**先做** | 已部署 staging `b8bdc003`，真机欠 | — |
 | `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、预登记、乱序与正对照，过门才立实现单；纯研究可并行 | 待领取 | — |
-| `TASK-rectification-1012-batch-fix-20261012.md` | — | **10-12 三单验收修复**：entry `6a799582` 通过（合入待产品）；boundary `b285011a` 未通过——F1 开场与段汇总岁差写死 Raman（BUG-1307 / 新 BUG-1309）、F2 本命上升换段不说；F3 打开失败卡片仍说已开始（BUG-1306 跟进）；F4 研究报告补编码问题与暂停结论（BUG-1308） | 待领取 | — |
+| `TASK-rectification-1012-batch-fix-20261012.md` | `PROGRESS-rectification-offer-opened-state-20261012.md` | **10-12 三单验收修复**：entry `6a799582` 通过（合入待产品）；boundary `b285011a` 未通过——F1 开场与段汇总岁差写死 Raman（BUG-1307 / 新 BUG-1309）、F2 本命上升换段不说；F3 提议在开案成功后才标 opened（BUG-1306 跟进，本分支待验收）；F4 研究报告补编码问题与暂停结论（BUG-1308） | F3 待验收（`codex/rectification-offer-opened-state-20261012`）；F1/F2/F4 仍待领取 | — |
 
 ### 聊天主链路与首页
 
diff --git a/frontend/DESIGN.md b/frontend/DESIGN.md
index 23398c9f..7f0d8cfd 100644
--- a/frontend/DESIGN.md
+++ b/frontend/DESIGN.md
@@ -11,7 +11,7 @@
 
 不新增等待动画；打开校正沿用既有一次揭幕。
 
-**明确要求则直接打开（2026-10-12，BUG-1306）**：用户这一轮明说要做校正时，不再先出卡再点。回答只留一句过渡，界面沿用既有一次揭幕直接打开校正面。没有新的按钮、输入框、等待动画或 Home 状态。推得不准时的主动提议仍用 `.rectification-offer-card`。做不了时只显示一句话，不静默，也不在对话里假装校正。
+**明确要求则直接打开（2026-10-12，BUG-1306）**：用户这一轮明说要做校正时，不再先出卡再点。回答只留一句过渡，界面沿用既有一次揭幕直接打开校正面。没有新的按钮、输入框、等待动画或 Home 状态。推得不准时的主动提议仍用 `.rectification-offer-card`。做不了时只显示一句话，不静默，也不在对话里假装校正。开案还没成功时，同一张提议卡仍是普通提议（不说「已经开始」，按钮仍是「开始核对出生时间」）。开案成功并绑定来源后才换成已开始的文案。打开失败时按钮仍可点。
 
 ## 用量页分段计时（2026-10-05，在途）
 
diff --git a/frontend/docs/VOICE.md b/frontend/docs/VOICE.md
index 3b7963e6..03788155 100644
--- a/frontend/docs/VOICE.md
+++ b/frontend/docs/VOICE.md
@@ -26,10 +26,10 @@ Jyotisha 的可见文案是产品的一部分。正确性红线（真实性、
 ## 生时校正从对话进入（2026-10-07，BUG-1247～1251；2026-10-12，BUG-1306）
 
 - **何时提议**：用户说推得不准时先分清读法问题和时间问题。只是不认同某个解释，按纠正规则认下、改读，不提校正。不承诺能收窄出生时间，不在对话里收集经历做校正。说出过去的具体事情和盘对不上、说出生时间是估的或记不准、但没有明确要做校正，才调用提议工具。同一次对话提议过、用户没接，不再主动提；用户自己再要求时传 `userAsked=true`。规则只定义在 `consultation-thinking-plan.ts` 的 `RECTIFICATION_OFFER_RULE`。不用关键词判断。
-- **明确要求则直接进入**：用户这一轮明确要做校正，由模型判断，不用关键词。服务端放行后直接打开校正：不先写解读，不用点卡。过渡只有一句「好，我们开始核对出生时间。」已经有一次没做完的，直接接着做那一次，不新开。
+- **明确要求则直接进入**：用户这一轮明确要做校正，由模型判断，不用关键词。服务端放行后直接打开校正：不先写解读，不用点卡。过渡只有一句「好，我们开始核对出生时间。」已经有一次没做完的，直接接着做那一次，不新开。开案还没成功时，回答下面仍是普通提议卡，不说「已经开始」；打开失败可以再点「开始核对出生时间」。开案并绑定来源之后才改成「已经开始」。
 - **做不了必须说一句**：开关关着，或暂时没有价格，都说「出生时间核对这会儿还做不了。」不写内部原因，不写价格，不得沉默。家人档案说「给家人校正暂时还不支持」，不开案。有进行中的校正但这次打不开原来的会话，说「可在历史对话里接着做。」
 - **正文怎么提**（没有明确要求、只是时间可能不准）：一句，放在最后一段（例：「如果想确认出生时间准不准，可以用下面的卡片，答几道过去经历的题核对一下。」），不写价格和题数——卡片上写。
-- **卡片**：「可以用几道过去经历的题，核对一下你的出生时间。大约 N 题，会用掉 M 点；开始答第一题时才扣。」按钮「开始核对出生时间」；已开始「出生时间核对已经开始。」/「继续核对出生时间」。点数来自 `feature_pricing`，不写死。
+- **卡片**：「可以用几道过去经历的题，核对一下你的出生时间。大约 N 题，会用掉 M 点；开始答第一题时才扣。」按钮「开始核对出生时间」；已开始（开案并绑定来源之后，不是结算当时）「出生时间核对已经开始。」/「继续核对出生时间」。点数来自 `feature_pricing`，不写死。
 - **回来**：分隔线「出生时间改为 HH:MM（生时校正）」/「出生时间没有改」；之前的回答上方「按校正前的时间」；按钮「按新时间重新看：「原问题」」。校正面按钮「回到刚才的对话」。不再说「新建对话」。
 
 ## 生时校正服务器固定句（2026-10-07，BUG-1258）
diff --git a/frontend/src/components/rectification-in-chat-cards.tsx b/frontend/src/components/rectification-in-chat-cards.tsx
index 4eddd057..2522d201 100644
--- a/frontend/src/components/rectification-in-chat-cards.tsx
+++ b/frontend/src/components/rectification-in-chat-cards.tsx
@@ -26,6 +26,8 @@ export function RectificationOfferCard({
   onStart,
 }: Readonly<{ offer: RectificationOfferRecord; disabled: boolean; onStart: () => void }>) {
   if (offer.status === "returned") return null;
+  // 「已经开始」 / 继续核对 only after the case is bound. autoOpen still shows
+  // the ordinary offer and 「开始核对出生时间」 until status is opened.
   const opened = offer.status === "opened";
   return (
     <div className="rectification-offer-card" role="group" aria-label="核对出生时间">
diff --git a/frontend/src/hooks/use-consultation-run.ts b/frontend/src/hooks/use-consultation-run.ts
index 494b710c..8ed8fba7 100644
--- a/frontend/src/hooks/use-consultation-run.ts
+++ b/frontend/src/hooks/use-consultation-run.ts
@@ -156,7 +156,7 @@ export type ConsultationRunParams = {
   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;
+  openRectificationFromChat: (sourceSessionId: string) => Promise<unknown> | void;
 };
 
 export function useConsultationRun(params: ConsultationRunParams) {
@@ -1077,7 +1077,13 @@ export function useConsultationRun(params: ConsultationRunParams) {
       if (rectificationDirectOpen?.mode === "resume" && rectificationDirectOpen.resumeSessionId) {
         void openRectificationSession(rectificationDirectOpen.resumeSessionId);
       } else if (rectificationDirectOpen?.mode === "new") {
-        void openRectificationFromChat(rectificationDirectOpen.sourceSessionId);
+        // Stored offer stays offered. bindOfferToCase marks opened only after
+        // the case opens. A failed open must not mark it opened here.
+        void Promise.resolve(openRectificationFromChat(rectificationDirectOpen.sourceSessionId)).then((opened) => {
+          if (opened) return;
+        }, () => {
+          // The opener threw. Leave the stored offer offered.
+        });
       }
       try {
         await persistSession(completedSession);
diff --git a/frontend/src/hooks/use-rectification-surface.ts b/frontend/src/hooks/use-rectification-surface.ts
index cbed7c63..27ac5ccf 100644
--- a/frontend/src/hooks/use-rectification-surface.ts
+++ b/frontend/src/hooks/use-rectification-surface.ts
@@ -369,8 +369,8 @@ export function useRectificationSurface(params: RectificationSurfaceParams) {
 
   /** C4: the offer card under a consultation answer starts (or resumes) the case. */
   async function openRectificationFromChat(sourceSessionId: string) {
-    if (rectificationLimitedToSelf()) return;
-    await openRectificationCase("homepage", null, sourceSessionId);
+    if (rectificationLimitedToSelf()) return null;
+    return openRectificationCase("homepage", null, sourceSessionId);
   }
 
   async function openRectificationSession(exactSessionId: string) {
diff --git a/frontend/src/lib/rectification-in-chat-server.ts b/frontend/src/lib/rectification-in-chat-server.ts
index 98bf2dd6..4ec8d784 100644
--- a/frontend/src/lib/rectification-in-chat-server.ts
+++ b/frontend/src/lib/rectification-in-chat-server.ts
@@ -64,9 +64,11 @@ async function writeMessages(client: SupabaseClient, userId: string, sessionId:
 }
 
 /**
- * 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.
+ * After a free direct-entry reply is appended, hang the offer on that message.
+ * The record is not opened yet (`offered` + `autoOpen`); bindOfferToCase sets
+ * opened after the case actually opens. 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;
diff --git a/frontend/src/lib/rectification-in-chat.ts b/frontend/src/lib/rectification-in-chat.ts
index eda833b2..f912d4c4 100644
--- a/frontend/src/lib/rectification-in-chat.ts
+++ b/frontend/src/lib/rectification-in-chat.ts
@@ -28,6 +28,12 @@ export const rectificationOfferRecordSchema = z.object({
   offeredAt: z.string().min(1).max(40),
   caseId: z.string().uuid().optional(),
   rectificationSessionId: z.string().uuid().optional(),
+  /**
+   * Present only when this turn should open the case without a click.
+   * Writers omit it unless it is true. Older stored offers omit it too.
+   * The card stays an ordinary offer until status is opened (BUG-1306 F3).
+   */
+  autoOpen: z.boolean().optional(),
 }).strict();
 
 export type RectificationOfferRecord = z.infer<typeof rectificationOfferRecordSchema>;
@@ -149,8 +155,9 @@ export function bindOfferToCase(
   for (let index = stored.length - 1; index >= 0; index -= 1) {
     const offer = parseRectificationOfferRecord(stored[index]!.rectificationOffer);
     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.
+    // Offered cards, including a direct open that is still offered (autoOpen).
+    // An older direct-open row stored as opened before it had a case id still binds.
+    // Returned rows, and a card already bound to another case, are left alone.
     if (offer.status !== "offered" && offer.status !== "opened") continue;
     const next = [...stored];
     next[index] = {
@@ -164,7 +171,8 @@ export function bindOfferToCase(
 
 /**
  * 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
+ * offer on that message so a reload can still find the source. The record is
+ * not opened yet (still `offered`, with `autoOpen` on a direct open). 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.
  */
diff --git a/frontend/src/mastra/consultation-tools.ts b/frontend/src/mastra/consultation-tools.ts
index 7b845e13..c7f0b699 100644
--- a/frontend/src/mastra/consultation-tools.ts
+++ b/frontend/src/mastra/consultation-tools.ts
@@ -1073,6 +1073,7 @@ function offerRecord(
   hook: RectificationOfferHook,
   decision: Extract<RectificationOfferDecision, { ok: true }>,
   status: RectificationOfferRecord["status"],
+  autoOpen = false,
 ): RectificationOfferRecord {
   return {
     status,
@@ -1080,13 +1081,16 @@ function offerRecord(
     questionEstimate: decision.questionEstimate,
     sourceQuestion: hook.revisitQuestion,
     offeredAt: (hook.now?.() ?? new Date()).toISOString(),
+    // Only when true. Ordinary offers and refusals omit the key.
+    ...(autoOpen ? { autoOpen: true } : {}),
   };
 }
 
 /**
  * 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.
+ * offered card with autoOpen and tells the stream to open. Status stays
+ * offered until the case is bound. A case already in progress resumes that
+ * case. Anything else is one sentence and writes no offer.
  */
 async function finishExplicitRectificationRequest(
   state: ConsultationRuntimeState,
@@ -1094,7 +1098,7 @@ async function finishExplicitRectificationRequest(
   decision: RectificationOfferDecision,
 ) {
   if (decision.ok) {
-    state.rectificationOffer = offerRecord(hook, decision, "opened");
+    state.rectificationOffer = offerRecord(hook, decision, "offered", true);
     state.rectificationDirectEntry = {
       kind: "new",
       sentence: RECTIFICATION_DIRECT_NEW_COPY,
diff --git a/frontend/tests/rectification-explicit-entry-20261012.test.ts b/frontend/tests/rectification-explicit-entry-20261012.test.ts
index 4ba246a2..fbe10568 100644
--- a/frontend/tests/rectification-explicit-entry-20261012.test.ts
+++ b/frontend/tests/rectification-explicit-entry-20261012.test.ts
@@ -4,7 +4,10 @@ import { readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import test from "node:test";
+import { createElement } from "react";
+import { renderToString } from "react-dom/server";
 
+import { RectificationOfferCard } from "../src/components/rectification-in-chat-cards.tsx";
 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 {
@@ -13,10 +16,14 @@ import {
   RECTIFICATION_DIRECT_RESUME_COPY,
   RECTIFICATION_DIRECT_RESUME_ELSEWHERE_COPY,
   RECTIFICATION_DIRECT_UNAVAILABLE_COPY,
+  RECTIFICATION_OFFER_OPENED_COPY,
+  RECTIFICATION_OFFER_START_LABEL,
   RECTIFICATION_OFFER_TOOL_ID,
   attachOpenedOfferToFreeMessage,
   bindOfferToCase,
   offerForCase,
+  parseRectificationOfferRecord,
+  rectificationOfferCardCopy,
   sourceFromSessionRows,
   type RectificationOfferRecord,
 } from "../src/lib/rectification-in-chat.ts";
@@ -179,13 +186,15 @@ test("the free reply can carry the opened offer once, without clobbering a case
   assert.equal(withCase, "present");
 });
 
-test("explicit pass opens once, records an opened offer, and does not open again", async () => {
+test("explicit pass opens once, records an offered auto-open 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.deepEqual(fresh.state.rectificationOffer, offer("offered", { autoOpen: true }));
+  assert.equal(fresh.state.rectificationOffer?.status, "offered");
+  assert.equal(fresh.state.rectificationOffer?.autoOpen, true);
   assert.equal(fresh.state.rectificationOffer?.caseId, undefined);
   assert.deepEqual(fresh.state.rectificationDirectEntry, {
     kind: "new",
@@ -199,14 +208,15 @@ test("explicit pass opens once, records an opened offer, and does not open again
   assert.match(String(again.note), /已经在打开/);
   assert.match(String(again.note), /不要再写解读/);
   assert.equal(fresh.decisions(), 1);
-  assert.deepEqual(fresh.state.rectificationOffer, offer("opened"));
+  assert.deepEqual(fresh.state.rectificationOffer, offer("offered", { autoOpen: true }));
 });
 
 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.rectificationOffer?.status, "offered");
+  assert.equal(direct.state.rectificationOffer?.autoOpen, true);
   assert.equal(direct.state.rectificationDirectEntry?.kind, "new");
 
   const card = offerTool({ alreadyOffered: true });
@@ -375,7 +385,7 @@ test("natal and window direct entry or explicit refusal skips the runtime-contra
             sourceSessionId: SOURCE_SESSION,
             ...(kind === "resume" ? { resumeSessionId: RESUME_SESSION } : {}),
           };
-          if (kind === "new") state.rectificationOffer = offer("opened");
+          if (kind === "new") state.rectificationOffer = offer("offered", { autoOpen: true });
           yield { type: "text-delta", payload: { text: "然后写一段解读。" } };
           yield STOP_FINISH;
         })(),
@@ -405,7 +415,8 @@ test("natal and window direct entry or explicit refusal skips the runtime-contra
       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?.status, "offered");
+        assert.equal(done.type === "run.completed" && done.rectificationOffer?.autoOpen, true);
         assert.equal(done.type === "run.completed" && done.rectificationOffer?.caseId, undefined);
         assert.deepEqual(done.type === "run.completed" ? done.rectificationDirectOpen : undefined, {
           sourceSessionId: SOURCE_SESSION,
@@ -450,7 +461,7 @@ test("a reading that already streamed is replaced by the direct-entry sentence",
           sentence: RECTIFICATION_DIRECT_NEW_COPY,
           sourceSessionId: SOURCE_SESSION,
         };
-        state.rectificationOffer = offer("opened");
+        state.rectificationOffer = offer("offered", { autoOpen: true });
         yield STOP_FINISH;
       })(),
       retry: async () => {
@@ -568,6 +579,9 @@ test("the offer rule is defined once, and direct entry settles with the free com
   assert.match(hook, /openRectificationFromChat\(rectificationDirectOpen\.sourceSessionId\)/);
   assert.match(hook, /openRectificationSession\(rectificationDirectOpen\.resumeSessionId\)/);
   assert.equal(hook.match(/openRectificationFromChat\(rectificationDirectOpen\.sourceSessionId\)/g)?.length, 1);
+  const directOpen = hook.slice(hook.indexOf("rectificationDirectOpen?.mode"), hook.indexOf("await persistSession(completedSession)"));
+  assert.match(directOpen, /if \(opened\) return/);
+  assert.doesNotMatch(directOpen, /status:\s*"opened"/);
   assert.match(hook, /responseKind === "smalltalk" \? \{[\s\S]*?rectificationOffer/);
 
   const page = src("../src/app/(app)/page.tsx");
@@ -586,4 +600,85 @@ test("the offer rule is defined once, and direct entry settles with the free com
     rectificationOffer: offer("opened"),
     rectificationDirectOpen: { sourceSessionId: SOURCE_SESSION, mode: "new" },
   });
+  consultationAgentPublicEventSchema.parse({
+    type: "run.completed",
+    responseKind: "smalltalk",
+    rectificationOffer: offer("offered", { autoOpen: true }),
+    rectificationDirectOpen: { sourceSessionId: SOURCE_SESSION, mode: "new" },
+  });
+
+  const surface = src("../src/hooks/use-rectification-surface.ts");
+  const fromChat = surface.slice(surface.indexOf("async function openRectificationFromChat"), surface.indexOf("async function openRectificationSession"));
+  assert.match(fromChat, /return null/);
+  assert.match(fromChat, /return openRectificationCase\("homepage", null, sourceSessionId\)/);
+});
+
+function cardHtml(record: RectificationOfferRecord) {
+  return renderToString(createElement(RectificationOfferCard, { offer: record, disabled: false, onStart() {} }));
+}
+
+test("a direct-open offer still shows the ordinary card until the case is bound", () => {
+  const pending = offer("offered", { autoOpen: true });
+  const html = cardHtml(pending);
+  assert.match(html, /大约 8 题，会用掉 3 点/);
+  assert.match(html, new RegExp(RECTIFICATION_OFFER_START_LABEL));
+  assert.equal(html.includes(RECTIFICATION_OFFER_OPENED_COPY), false);
+  assert.equal(html.includes("继续核对出生时间"), false);
+  assert.match(html, new RegExp(rectificationOfferCardCopy(pending).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+
+  const messages = [{ role: "assistant", text: RECTIFICATION_DIRECT_NEW_COPY, responseKind: "smalltalk", rectificationOffer: pending }];
+  const bound = bindOfferToCase(messages, { caseId: CASE_ID, rectificationSessionId: RECT_SESSION });
+  const opened = bound![0]!.rectificationOffer as RectificationOfferRecord;
+  assert.equal(opened.status, "opened");
+  assert.equal(opened.autoOpen, true);
+  assert.equal(opened.caseId, CASE_ID);
+  const openedHtml = cardHtml(opened);
+  assert.match(openedHtml, new RegExp(RECTIFICATION_OFFER_OPENED_COPY));
+  assert.match(openedHtml, /继续核对出生时间/);
+  assert.equal(openedHtml.includes(RECTIFICATION_OFFER_START_LABEL), false);
+});
+
+test("a failed direct open leaves the offer offered and clickable", () => {
+  const pending = offer("offered", { autoOpen: true });
+  const messages = [{ role: "assistant", text: RECTIFICATION_DIRECT_NEW_COPY, responseKind: "smalltalk", rectificationOffer: pending }];
+  const opened = null;
+  const next = opened ? bindOfferToCase(messages, { caseId: CASE_ID, rectificationSessionId: RECT_SESSION }) : null;
+  assert.equal(next, null);
+  assert.equal((messages[0]!.rectificationOffer as RectificationOfferRecord).status, "offered");
+  assert.equal((messages[0]!.rectificationOffer as RectificationOfferRecord).autoOpen, true);
+  const html = cardHtml(pending);
+  assert.equal(html.includes(RECTIFICATION_OFFER_OPENED_COPY), false);
+  assert.match(html, new RegExp(RECTIFICATION_OFFER_START_LABEL));
+  assert.equal(html.includes("disabled=\"\""), false);
+  assert.equal(html.includes("disabled=\"disabled\""), false);
+});
+
+test("stored offers offered, opened, and returned still parse; returned hides the card", () => {
+  for (const status of ["offered", "opened", "returned"] as const) {
+    const parsed = parseRectificationOfferRecord(offer(status));
+    assert.equal(parsed?.status, status);
+    assert.equal(parsed?.autoOpen, undefined);
+    assert.equal("autoOpen" in (parsed ?? {}), false);
+  }
+  const flagged = parseRectificationOfferRecord(offer("offered", { autoOpen: true }));
+  assert.equal(flagged?.status, "offered");
+  assert.equal(flagged?.autoOpen, true);
+  assert.equal(parseRectificationOfferRecord({ ...offer("opened"), extra: true }), null);
+  assert.equal(cardHtml(offer("returned")), "");
+  assert.match(cardHtml(offer("opened")), new RegExp(RECTIFICATION_OFFER_OPENED_COPY));
+  assert.match(cardHtml(offer("offered")), new RegExp(RECTIFICATION_OFFER_START_LABEL));
+});
+
+test("the free reply stores the direct-open offer still offered, with autoOpen", () => {
+  // The record is not opened yet. The name of the attacher is historical.
+  const sentence = RECTIFICATION_DIRECT_NEW_COPY;
+  const card = offer("offered", { autoOpen: true });
+  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((attached[1]!.rectificationOffer as RectificationOfferRecord).status, "offered");
+  assert.equal(attachOpenedOfferToFreeMessage(attached, { sentence, offer: card }), "present");
 });
diff --git a/frontend/tests/rectification-in-chat-20261007.test.ts b/frontend/tests/rectification-in-chat-20261007.test.ts
index 86096026..493167a5 100644
--- a/frontend/tests/rectification-in-chat-20261007.test.ts
+++ b/frontend/tests/rectification-in-chat-20261007.test.ts
@@ -279,6 +279,53 @@ test("the open route binds the offer only for a consultation source; the source
   assert.doesNotMatch(server, /createAdminSupabaseClient/);
 });
 
+test("an auto-open offer shows the ordinary card until the case is bound, and a reload keeps autoOpen", async () => {
+  const pending = offer("offered", { autoOpen: true });
+  const waiting = [
+    { role: "user" as const, text: "请帮我核对出生时间" },
+    { role: "assistant" as const, text: "好，我们开始核对出生时间。", responseKind: "smalltalk" as const, rectificationOffer: pending },
+  ];
+  const html = renderToString(createElement(ChatTranscript, transcriptProps(waiting, [])));
+  assert.match(html, /开始核对出生时间/);
+  assert.match(html, /大约 8 题，会用掉 3 点；开始答第一题时才扣。/);
+  assert.doesNotMatch(html, /出生时间核对已经开始/);
+  assert.doesNotMatch(html, /继续核对出生时间/);
+
+  const bound = bindOfferToCase(waiting, { caseId: CASE_ID, rectificationSessionId: RECT_SESSION })!;
+  const openedHtml = renderToString(createElement(ChatTranscript, transcriptProps(bound as ChatMessage[], [])));
+  assert.match(openedHtml, /出生时间核对已经开始/);
+  assert.match(openedHtml, /继续核对出生时间/);
+  assert.equal((bound[1]!.rectificationOffer as RectificationOfferRecord).status, "opened");
+  assert.equal((bound[1]!.rectificationOffer as RectificationOfferRecord).autoOpen, true);
+
+  const failed = waiting;
+  assert.equal((failed[1]!.rectificationOffer as RectificationOfferRecord).status, "offered");
+
+  const { readSessions } = await import("../src/lib/home-cloud-sync.ts");
+  const reloaded = readSessions([{
+    id: SOURCE_SESSION,
+    title: "虚构",
+    theme: "marriage",
+    messages: [{ role: "assistant", text: "还没打开", rectificationOffer: pending }],
+  }], null);
+  assert.equal(reloaded.sessions[0]!.messages[0]!.rectificationOffer?.status, "offered");
+  assert.equal(reloaded.sessions[0]!.messages[0]!.rectificationOffer?.autoOpen, true);
+  const old = readSessions([{
+    id: SOURCE_SESSION,
+    title: "虚构",
+    theme: "marriage",
+    messages: [
+      { role: "assistant", text: "a", rectificationOffer: offer("offered") },
+      { role: "assistant", text: "b", rectificationOffer: offer("opened", { caseId: CASE_ID, rectificationSessionId: RECT_SESSION }) },
+      { role: "assistant", text: "c", rectificationOffer: offer("returned", { caseId: CASE_ID, rectificationSessionId: RECT_SESSION }) },
+    ],
+  }], null);
+  assert.deepEqual(old.sessions[0]!.messages.map((message) => message.rectificationOffer?.status), ["offered", "opened", "returned"]);
+  assert.equal(old.sessions[0]!.messages[0]!.rectificationOffer?.autoOpen, undefined);
+  const returnedHtml = renderToString(createElement(ChatTranscript, transcriptProps(old.sessions[0]!.messages.slice(2) as ChatMessage[], [])));
+  assert.doesNotMatch(returnedHtml, /rectification-offer-card/);
+});
+
 test("stored sessions keep the offer and the divider when the browser reads them back (BUG-1248/1250)", async () => {
   const { readSessions } = await import("../src/lib/home-cloud-sync.ts");
   const bound = bindOfferToCase(conversation(), { caseId: CASE_ID, rectificationSessionId: RECT_SESSION })!;