@gavinc-cn/touchstone-dsh 0.1.1 → 0.3.0

package/board.py

@@ -96,6 +96,30 @@ def card_workspace(project, card):
     return wt or project["project_dir"]
 
 
+def card_ts_ms(ts_str):
+    """库内时间串（`YYYY-MM-DD HH:MM:SS`，db.now_str 口径=**服务器本地时间**）→ 毫秒 epoch。
+
+    卡面「最后更新时间」（2026-10-10 批次）的下发形态：库里存的是无时区标记的本地
+    时间串（本容器=UTC，Windows 原生运行=+8），前端若直接 `new Date(串)` 会按浏览器
+    本地时区解析 ⇒ 在 UTC 服务器 + 北京浏览器下整整差 8 小时。故一律在服务端换算成
+    epoch（与前端既有的 `scheduled_at`/`last_error_at` 同口径），前端只管按浏览器
+    时区渲染。
+
+    解释口径必须与写入口径互逆：`db.now_str` 用 `time.strftime`（本地时间），此处用
+    `time.mktime`（同按本地时区反解）——Linux(UTC)/Windows(+8) 下都自洽，见
+    tests/test_board_card_time.py 的 TZ 钉子用例。
+
+    坏值/空值返回 None（前端不渲染该小字），绝不抛异常打穿读板路径；不用 0 兜底
+    （0 会被前端当 1970 年渲染）。
+    """
+    if not ts_str:
+        return None
+    try:
+        return int(time.mktime(time.strptime(ts_str, "%Y-%m-%d %H:%M:%S"))) * 1000
+    except (TypeError, ValueError, OverflowError, OSError):
+        return None
+
+
 def card_json(row, running=False, busy=False, msg_queued=False, queue_state=None):
     """卡片 Row -> 前端 dict。running=平台在管运行；busy=会话级运行
     （平台运行或外部 busy——用户在 dsh GUI 直跑的同步卡会话，前端徽标
@@ -112,7 +136,11 @@ def card_json(row, running=False, busy=False, msg_queued=False, queue_state=None
     （queue_state_of 判定序最高级即 answer 在场 ⟺ answer_pending，免二次点查）。
     worktree（2026-10-06 批次）：独立 worktree 卡的落点绝对路径，空串=普通卡
     （前端据此渲染 🌿 徽标与详情行；只写不改口径见 plan D3）——经 `_card_opt`
-    读取，兼容无该列的老库。"""
+    读取，兼容无该列的老库。
+    updated_at_ts（2026-10-10 批次）：`updated_at` 的毫秒 epoch 形态（`card_ts_ms`
+    换算，服务器本地时间解释），供卡面渲染「最后更新时间」的相对时间/本地绝对时间；
+    语义务必与 `updated_at` 一致=**卡片行最后被改写的时刻**（agent 在会话里干活不刷
+    它，会话活动时间是另一回事）。坏值/空值 ⇒ None，前端不渲染该小字。"""
     if queue_state is None:
         answer = is_answer_pending(row["id"])
         queue_state = queue_state_of(row, running, busy, msg_queued, answer=answer)
@@ -130,6 +158,7 @@ def card_json(row, running=False, busy=False, msg_queued=False, queue_state=None
             "last_error": row["last_error"], "last_error_at": row["last_error_at"],
             "worktree": _card_opt(row, "worktree"),
             "created_at": row["created_at"], "updated_at": row["updated_at"],
+            "updated_at_ts": card_ts_ms(row["updated_at"]),
             # 状态有更新·用户未打开（2026-10-07 批次）：卡面打「有更新」标记的依据，
             # 置位/清除全在 db 层派生维护，读侧只透传布尔值。
             "unread": bool(_card_opt(row, "unread") or 0),
@@ -2009,10 +2038,13 @@ def start_card(project, card, extra=""):
     return _start_web(project, card, family, extra)
 
 
-def deliver_comment(project, card, comment_row, inject=False, raw=False):
-    """评论投递主会话（默认包装【看板评论】前缀；raw=True 直发原文——会话
-    详情页发送路径专用，用户本就在会话中对话，无需任务上下文包装；卡片评论
-    区「投递」维持前缀以区分消息来源。两条路径都照旧落评论记录 sent_text）。
+def deliver_comment(project, card, comment_row, inject=False):
+    """评论投递主会话（恒发评论原文，不包任何前缀——2026-10-10 去前缀）。
+
+    2026-09-06 起会话详情页路径 `raw=True` 直发原文、卡片评论区「投递」仍包
+    「【看板评论】任务「标题」: 」前缀以区分消息来源；2026-10-10 用户裁定**所有
+    投递路径一律原文**（前缀在会话里是噪音）——前缀构造与 `raw` 开关一并删除，
+    `sent_text` 照旧落实际发送文本（= 评论原文，评论记录仍可追溯）。
 
     2026-09-10（统一队列消息单元）：不再立即投递——登记会话消息单元进 runner
     统一队列，项目忙（同项目有任务/卡片会话在跑）时按入队顺序等待，项目空闲才
@@ -2023,10 +2055,7 @@ def deliver_comment(project, card, comment_row, inject=False, raw=False):
     """
     family = _web_family(project)
     sid = card["session_id"]
-    if raw:
-        wrapped = comment_row["text"]
-    else:
-        wrapped = f"【看板评论】任务「{card['title']}」: {comment_row['text']}"
+    text = comment_row["text"]
     # 进队前的前置校验：拦住必然失败的投递（无会话 / 退场族无投递通道）
     if family is None:
         raise RuntimeError(agents.RETIRED_MSG)
@@ -2035,12 +2064,12 @@ def deliver_comment(project, card, comment_row, inject=False, raw=False):
     inst = runner.INSTANCE
     if inst is None:
         # 无统一队列（单测/独立脚本）：保持既有立即投递行为
-        _deliver_now(project, card, comment_row, wrapped, inject)
+        _deliver_now(project, card, comment_row, text, inject)
         return None
     # 排队中的消息可「立即注入」（见 chat.inject_now）：family/model/
     # comment_id 提交时定格进等待项 meta（chat_msgs 零加列，P3 裁决 R1），执行时
     # 由 chat 侧按行＋快照重建 _deliver_unit/_deliver_now
-    return chat.submit(project["id"], sid, wrapped,
+    return chat.submit(project["id"], sid, text,
                        card_id=card["id"], comment_id=comment_row["id"],
                        inject=inject,
                        family=runner.agent_family(project["agent_path"] or ""),
@@ -2048,19 +2077,19 @@ def deliver_comment(project, card, comment_row, inject=False, raw=False):
                              or (project["model"] or "").strip())
 
 
-def _deliver_unit(project, card, comment_row, wrapped, inject):
+def _deliver_unit(project, card, comment_row, text, inject):
     """统一队列消息单元执行体：投递评论并等该会话结束（执行期间持有项目占用）。
 
-    返回即释放占用：dsh 等 busy 出现再回落（与任务 turn 同款判定，见
-    chat.wait_web_busy）；返回 chat.STATE_YIELDED = turn 挂起等作答、已让位
-    （chat.run_unit 据此落终态）。尾部 proc 分支为 CLI 时代的防御残留
-    （单族化后 _RUNS 条目恒为 dsh，proc=None）。
+    返回即释放占用：dsh 会话的等轮次走 `chat.wait_turn` 分流口（外部会话订阅全局
+    状态流、平台自持会话走既有按会话 SSE，规则见该函数）；返回
+    chat.STATE_YIELDED = turn 挂起等作答、已让位（chat.run_unit 据此落终态）。
+    尾部 proc 分支为 CLI 时代的防御残留（单族化后 _RUNS 条目恒为 dsh，proc=None）。
     """
-    _deliver_now(project, card, comment_row, wrapped, inject)
+    _deliver_now(project, card, comment_row, text, inject)
     family = _web_family(project)
     if family is not None:
-        return chat.wait_web_busy(project["project_dir"], card["session_id"],
-                                  family)
+        return chat.wait_turn(project["project_dir"], card["session_id"],
+                              family)
     with _runs_lock:
         rec = _RUNS.get(card["id"])
     proc = rec.get("proc") if rec is not None else None
@@ -2068,25 +2097,79 @@ def _deliver_unit(project, card, comment_row, wrapped, inject):
         proc.wait()
 
 
-def _deliver_now(project, card, comment_row, wrapped, inject=False):
-    """评论真正送达（立即路径与统一队列消息单元执行体共用；wrapped 为最终文本）。
+# 卡片会话已不在宿主时的投递文案（用户可见）：不暴露「驱动池 / sid」这类内部
+# 链路词，只给「发生了什么 + 怎么办」。sync 卡与「接不回」两种情形共用一句
+# ——两者对用户的可执行动作相同（点「开始」重新拉起会话）。
+LOST_SESSION_MSG = ("会话已结束（宿主无活动 agent），消息未送达："
+                    "请点「开始」重新拉起会话后再发送")
+
+
+def _ensure_card_session(project, card, sid):
+    """投递前确保宿主仍持有该卡会话（宿主已失去 ⇒ 按 resume 接回）；返回可否投递。
+
+    报障现场（卡 934，2026-10-10）：插件热重载把宿主里所有会话 dispose 掉之后，
+    卡片 `session_id` 仍在库、卡照旧在列，用户发评论 / 点「立即注入」时驱动回
+    404「会话不在驱动池中」——前端只能把这条内部文案原样 toast 出来。
+
+    判定阶梯（与调和器「会话确已结束」同源，见 `chat.host_session_lost`）：
+      ① 宿主仍有该会话（注册表命中 / 中枢未对齐＝未知）⇒ 放行，**零请求**，
+         既有路径一个字节不变；
+      ② 确已失去 ∧ 平台自建卡（`origin` 非 `sync`）⇒ `chat.revive_host_session`
+         按 `_start_web` 的续接语义 resume 回池（同一张卡、同一个 sid、同一上下文）；
+      ③ 确已失去 ∧ sync 卡（`origin='sync'`＝用户在 dsh GUI 直跑的会话）⇒ **不接回**：
+         C 批设计「只投递不接管」，平台不擅自把用户的会话收养进自己的池，直接报
+         明确文案（用户点「开始」＝显式收养，那是既有路径）。
+    接不回（会话文件缺失 / 驱动不可达）同样返回 False，由调用方报同一句文案。
+    cwd 取 `card_workspace`（worktree 卡的会话必须接回它的工作树）。
+    """
+    if not chat.host_session_lost(sid):
+        return True                        # 会话在场/未知：不动作（零请求）
+    cid = _card_opt(card, "id")
+    row = db.get_board_card(cid) if cid else None
+    origin = str(_card_opt(row if row is not None else card, "origin") or "")
+    if origin == "sync":
+        return False                       # 外部会话卡：不接管（见上 ③）
+    return chat.revive_host_session(sid, cwd=card_workspace(project, row or card),
+                                    task=f"card-{cid}")
+
+
+def _deliver_now(project, card, comment_row, text, inject=False):
+    """评论真正送达（立即路径与统一队列消息单元执行体共用；text 即评论原文）。
 
     单族化后只有 dsh_plugin：followup 忙时排进 agent inbox（等同服务端排队
     语义，不拒绝）；inject=True 走 steer，注入当前 turn 的最近 step 边界
     （steer 失败不致命，评论仍在 inbox/队列）。退场族无投递通道，直接报错。
+    送达前两道人造兜底（顺序固定，都在 `_web_send` 之前）：
+      ① **会话存活**（2026-10-10，修卡 934）：宿主被插件热重载/重启清过之后，
+         卡会话可能已不存在——`_ensure_card_session` 先接回再投递，接不回则报
+         `LOST_SESSION_MSG`（可执行指引），不再把驱动 404 原文案抛给用户；
+      ② 重声明看管（C 批终审 I2，2026-10-10）：本函数是评论**推送腿**的唯一出口，
+         `_watch_prune` 的撤销判据只看活跃 `m:` 行（不看推送腿本身）。真实入口＝平台
+         重启后 `_rebuild_run → _deliver_unit → _deliver_now` 直投：`_WATCHED` 随进程
+         清空、驱动侧 `watched` 也可能随插件重载清空 ⇒ 不补声明就撞驱动「未看管」404、
+         `m:` 行落 error。与 `_answer_deliver` 同源同判据（`_watch_before_delivery`
+         内部只对 `owned:false` 的池外会话声明，命中缓存零请求；池内/未知路径一个
+         字节不变）。
     """
     family = _web_family(project)
     sid = card["session_id"]
     if family is not None:
         try:
+            # 会话存活兜底（见上 ①）：卡会话已被宿主丢掉时先 resume 接回再投递
+            if not _ensure_card_session(project, card, sid):
+                raise RuntimeError(LOST_SESSION_MSG)
+            # 送达前重声明看管（C 批终审 I2）：外部会话的看管可能已被 `_watch_prune`
+            # 撤掉（平台重启后记账为空、驱动侧重载后 watched 为空），漏声明则下面
+            # 这条驱动调用撞「未看管」404（见上）
+            _watch_before_delivery(sid)
             # dsh 的「立即注入」= steer（注入当前 turn 的最近 step 边界）；
             # 普通投递 = followup（忙时排进 inbox，等同服务端排队）；
             # 统一走 _web_send（单族投递唯一出口，测试打桩面也在此）
-            _web_send(family, project, sid, wrapped, inject=bool(inject))
+            _web_send(family, project, sid, text, inject=bool(inject))
         except dshdriver.DshDriverError as e:
             raise RuntimeError(f"评论投递失败: {e}")
         db.update_board_comment(comment_row["id"], sent=1, session_id=sid,
-                                sent_text=wrapped)
+                                sent_text=text)
         return
     # 退场族无投递通道（单族化）：明确报错，不落已删除的 CLI 起子进程路径
     raise RuntimeError(agents.RETIRED_MSG)
@@ -2212,6 +2295,15 @@ def compact_session(project, card, sid):
     命令），触发即返回——压缩在 dsh 进程内异步进行（要过一次模型），失败落
     宿主日志（原 kimi CLI 子进程压缩与两族 web REST 压缩已随族退场）。
 
+    **池外两跳（2026-10-10 修「卡片 945 无法 compact」）**：宿主侧插件重载/dsh web
+    重启后，平台自建的卡会话在驱动里只剩**观察**（`/live` 的 `owned:false`，宿主里
+    仍活着）——旧实现只认驱动池，compact 必 404「会话不在驱动池中」，前端原样 toast。
+    这里按 `rename_card_session` 同款两跳：首跳 404（=池外）⇒ `_ensure_watch(sid)` 补
+    看管声明（幂等、**只声明不接管**）后重试一次；驱动侧 `/compact` 的池外回落分支按
+    「看管 + 宿主有活 agent」放行（node 半同批实现）。为什么不能「先接管再压缩」：
+    外部会话的 agent 已在宿主 store 注册，`/session` resume 必撞
+    `agent "…" is already registered` ⇒ 500（C 批 T1 实测）。
+
     sid 必须属于该卡片（sessions 清单或主 session_id），不支持的族抛
     RuntimeError（server 转 400）。
     """
@@ -2225,10 +2317,25 @@ def compact_session(project, card, sid):
     # 路线 A P3（2026-10-03）：走驱动 `/compact`（插件侧执行宿主 `/compact`
     # 命令；`ctx.compaction` 服务在插件 ctx 不可注入，命令路径是 P0 探针的结论）。
     # 触发即返回——压缩在 dsh 进程内异步进行（要过一次模型），失败落宿主日志。
-    try:
-        dshdriver.compact(sid)
-    except dshdriver.DshDriverError as e:
-        raise RuntimeError(f"compact 失败: {e}")
+    last = ""
+    for attempt in (1, 2):
+        try:
+            dshdriver.compact(sid)
+            return
+        except dshdriver.DshDriverError as e:
+            last = str(e)
+            pool_miss = getattr(e, "code", None) == 404
+            # 只在首跳 404（池外）补一次看管声明；**force=True** 跳过平台侧陈旧记账
+            # （驱动侧重载会清空 `watched` 表，`_WATCHED` 却仍写着「声明过」）。
+            # 已看管但宿主无活 agent 的 404 重试同样失败，代价只是一次请求，换来判定
+            # 不依赖文案匹配；且第二跳的文案更准确（「会话已结束（宿主无活动 agent）」
+            # 取代含糊的「不在驱动池中」）。
+            if attempt == 1 and pool_miss and _ensure_watch(sid, force=True):
+                print(f"[board] 卡片 compact：池外会话补看管声明后重试 sid={sid}",
+                      flush=True)
+                continue
+            break
+    raise RuntimeError(f"compact 失败: {last}")
 
 
 def fork_compact_session(project, card, sid):
@@ -2691,10 +2798,86 @@ def _reconcile_starting_rows():
               f"（claimed_at={claimed}）", flush=True)
 
 
+def _heal_queue_placeholders():
+    """排队占位缺等待项行自愈（30s 全量对账节拍；2026-10-10 实障卡 936）。
+
+    背景：卡片停在「正在开发」+`block_kind='queue'`（前端「排队中」徽标的**唯一**
+    来源，见 `queue_state_of`），但 wait_items 里没有对应的活跃 c: 行。调度权威是
+    行——`runner._pick_locked` 只遍历等待项行，行不在场 ⇒ 补位器永远拾不到该卡，
+    卡片永久僵在排队态（除用户重按「开始」的幂等补建或服务重启 `board.recover`
+    尾段补建外**无任何自愈出口**），项目看着空闲而队列不动。本函数把 `recover`
+    尾段那条「占位卡缺等待项行就补建」的对账规则**周期化**：逐张排队占位卡核对，
+    行缺失即经 `runner.submit_card` 补建（幂等：行仍在则 `enqueue_card` 复用既有
+    行、位次不动；补建落等待区末尾，与 recover 同几何——原排队位次已不可考）。
+
+    跳过四类（都不是「行丢了」，补行反而有害）：
+    - 已答待送达（活跃 a: 行在场）：等待单元是 answer 行，本就不建 c: 行
+      （`_queue_answer_unit` 单写口径），补 c: 行会让未送达答案与新一轮起跑打架；
+    - 独立 worktree 卡：起跑不入队、不落行（spec §47），`block_kind='queue'`
+      对它是残留投影，补行等于把它塞回统一队列；
+    - 平台在管（`_has_active_run`）：会话在跑、运行行缺失归收尾/调和器兜底，
+      此处补行会与在跑会话并发起第二轮；
+    - **会话实况在跑**（卡有 sid 且 `dshevents` 注册表报 `running`）：占位卡也可能是
+      「会话被外部直跑/重启后行丢失」形态（恢复运行的行未重建），补行会让补位器起跑
+      同一会话再投一轮 prompt——行缺失交调和器/收尾路径处理，本函数只补「确实没人在
+      跑」的卡（单族化后状态读口零请求、本地注册表；断连/未知不在此列，照常补建）。
+
+    检测到的异常形态各落一行诊断（`[board] 排队占位缺等待项行（占位在、行不在）…`）；
+    异常逐卡吞（补建失败也只留一行诊断），不影响其他卡；返回本次补建条数。
+    `runner` 单例缺位（调试退化）时只报告不自愈——日志仍如实留痕。"""
+    inst = runner.INSTANCE
+    try:
+        queued = db.list_queued_board_cards()
+    except Exception as e:                                  # noqa: BLE001
+        print(f"[board] 排队占位自愈扫描失败: {e}", flush=True)
+        return 0
+    healed = 0
+    for card in queued:
+        try:
+            cid = int(card["id"])
+        except (TypeError, ValueError):
+            continue                                        # 脏 id：理论项，跳过
+        try:
+            if (_card_opt(card, "worktree") or "").strip():
+                continue                                    # worktree 卡不入队（§47）
+            if waitq.get_active(waitq.KIND_CARD, cid) is not None:
+                continue                                    # 行在场：正常排队，不动
+            if waitq.get_active(waitq.KIND_ANSWER, cid) is not None:
+                continue                                    # 已答待送达：单元是答案行
+            if _has_active_run(cid):
+                continue                                    # 会话在跑：行归收尾路径
+            sid = (card["session_id"] or "").strip()
+            if sid:
+                try:
+                    st = dshevents.get(sid) or {}
+                except Exception:                           # noqa: BLE001 — 读口异常按未知
+                    st = {}
+                if st.get("status") == "running":
+                    continue                                # 实况在跑：补行会重复投递
+            # 占位在、行不在：`enqueue_card` 单事务红线（行+占位原子）声称此形态
+            # 「从结构上消失」，出现即异常——先落一行异常报告，再补建
+            print(f"[board] 排队占位缺等待项行（占位在、行不在）：c:{cid}"
+                  f"（项目 {card['project_id']}）", flush=True)
+            if inst is None:
+                continue                                    # runner 缺位：只报告
+            inst.submit_card(cid)
+            healed += 1
+        except Exception as e:                              # noqa: BLE001
+            print(f"[board] 排队占位补建失败：c:{cid}: {e}", flush=True)
+    return healed
+
+
 def _watch_once():
     """一轮巡视：结束会话收尾（_watch_runs_once）+ 定时到点开工（被门禁拦则
-    清定时记错误；起会话失败则把卡置回 todo，避免僵在 doing 无进程）。"""
+    清定时记错误；起会话失败则把卡置回 todo，避免僵在 doing 无进程）+
+    排队占位缺行自愈（`_heal_queue_placeholders`，实障卡 936）。"""
     _watch_runs_once()
+    # 排队占位缺行自愈（30s 节拍）：占位在、行不在 ⇒ 补位器永远拾不到，卡片
+    # 僵在「排队中」而项目看着空闲。补建规则与 recover 尾段同源（幂等）。
+    try:
+        _heal_queue_placeholders()
+    except Exception:                                       # noqa: BLE001
+        pass                                    # 巡视不因自愈失败中断（下一拍再来）
     # 定时扫描：todo 列到点卡片经统一入口进 doing（整库扫描，量小；一律入队
     # （v2b T2 起 parallel 直起废除），门禁语义与手动开始一致）
     now_ms = int(time.time() * 1000)
@@ -2763,9 +2946,20 @@ def _recover_web_card(proj, card):
     `_recover_ext_rows` 按项目活跃会话集合重新对账（实况在→ext 行保持 running
     入前缀、占位不丢），空闲时由调和器列映射回 review（≤5s，与收养路径同归）。
     收养行为（建 _RUNS 条目）会把不可控会话伪装成平台
-    在管单元——ext 行被 `_platform_holds` 抑制。"""
+    在管单元——ext 行被 `_platform_holds` 抑制。
+
+    就绪闸（2026-10-08 批次 C，bug_report/20261008_1935）：本函数在启动序里必然
+    早于 `dshevents.start()`（server.py 里 board.recover 先于 dshevents.start），
+    此刻读任何会话都是「未知」；插件热重载后还会叠加「驱动实例重建、/live 空」
+    ——旧口径把「未知」当「空闲」，于是**正在运行的卡**被搬去待审核，且此后
+    调和器读不到该会话、自愈无门（实测卡 915）。现在：有 sid 而中枢不可信
+    （`dshevents.aligned()` 为 False）⇒ **不搬列**（也不建 _RUNS），保留原列等
+    中枢对齐后由调和器按实况归位（`_iw_once`：在场按忙/闲、缺席按「已结束」，
+    列写的时机从「未知时」挪到「已知时」）。"""
     family = _web_family(proj)
     sid = (card["session_id"] or "").strip()
+    if sid and not dshevents.aligned():
+        return                       # 未知 ≠ 空闲：不搬列，交调和器在可信后收口
     busy = False
     if sid:
         try:
@@ -3251,8 +3445,11 @@ def _archive_unarchive_edge(card):
 # 最后活动，近似语义为「刚开始不久」）
 SYNC_BUSY_MTIME_S = 120
 
-# sync 卡标题/描述口径（2026-10-07）：标题与描述都取「主会话第一次用户提问」——
-# 首行进标题、其余进描述（与手工建卡的 QuickAdd「首行=标题、其余行=描述」同约定）。
+# sync 卡标题/描述口径（2026-10-10 改）：标题 = DSH **当前**会话标题（末枚
+# `session/title` 事件，与 dsh GUI 侧栏 last-wins 一致——DSH 侧 LLM 自动标题 /
+# 用户改名后，同步节拍跟着改卡标题）、描述 = 主会话第一次用户提问**全文**。
+# 旧口径（2026-10-07~10-10：「首问首行进标题、其余行进描述」）已退场，存量卡由
+# `_sync_card_follow` 在首个同步拍回填（详见 board spec §48）。
 SYNC_TITLE_MAX = 200   # 标题上限（沿用建卡既有截断：insert_board_card 调用处 [:200]）
 SYNC_DESC_MAX = 2000   # 描述上限（防一次长提问把看板负载撑大）
 
@@ -3261,13 +3458,24 @@ SYNC_DESC_MAX = 2000   # 描述上限（防一次长提问把看板负载撑大
 # 不被反复软删（进程重启后重建空集，重跑一轮幂等）。
 _SYNC_SUBAGENT_SWEPT = set()
 
+# 已跑过「存量误建卡软删收口」的项目 id（`sync_sessions` 尾巴，2026-10-09）：
+# 历史版本建出的两类卡——**平台自己持有会话的卡**（B 类：任务 / 飞书会话被当成
+# 外部会话重复投影）与**空会话占位卡**（A 类：会话一个字都还没有就投影出
+# `session-xxxx`）——新版一律不再产生，存量按同款「每项目一轮 + 软删可还原」
+# 口径收口（理由与边界见 `sync_sessions` 尾巴注释）。
+_SYNC_MISBUILT_SWEPT = set()
+
 
 def _split_first_prompt(text):
-    """首问原文 → (标题, 描述)：首行=标题、其余行=描述。
+    """首问原文 → (首行, 其余行)：仅服务**回落标题**与**旧口径描述识别**。
 
-    - 首行超 SYNC_TITLE_MAX 的溢出部分并入描述开头（截断不丢内容）；
-    - 描述超 SYNC_DESC_MAX 截断并补省略号；
+    - 首行超 SYNC_TITLE_MAX 的溢出部分并入其余行开头（截断不丢内容）；
+    - 其余行超 SYNC_DESC_MAX 截断并补省略号；
     - 原文为空 → ('', '')（调用方自行兜底标题）。
+
+    新口径下卡标题取 DSH 当前标题、描述取首问全文，本函数不再直接产生卡面字段；
+    保留是因为两处仍要「旧口径形态」的字符串：无标题事件时以首问首行回落成标题
+    （`_sync_card_fields`），以及判定卡描述是否仍是旧口径自动写入（`_sync_card_follow`）。
     """
     text = (text or "").strip()
     if not text:
@@ -3284,42 +3492,146 @@ def _split_first_prompt(text):
     return first, rest
 
 
+def _full_first_prompt(text):
+    """首问原文 → 卡描述：首问**全文**（去首尾空白；超 SYNC_DESC_MAX 截断补省略号）。
+
+    与 `_split_first_prompt` 的「其余行」不同——不再丢掉首行（标题已由 DSH 会话
+    标题承担，描述要的是完整提问）。
+    """
+    raw = (text or "").strip()
+    if not raw:
+        return ""
+    return raw[:SYNC_DESC_MAX] + "…" if len(raw) > SYNC_DESC_MAX else raw
+
+
+def _is_empty_session(item):
+    """空会话判定（A 类闸，2026-10-09）：会话已存在但**还没有任何内容**。
+
+    「有内容」= 有首问（`first_prompt`）或有会话标题事件（`title`）——两者都空
+    的会话就是用户刚在 dsh 侧建出来、一句话还没说的空壳。历史版本会给它建一张
+    `session-xxxx` 占位卡（等首问落盘再补齐标题），对用户表现为「看板上凭空
+    冒出一张没标题的卡」；新口径改为**不投影**，等首问/标题落盘后的下一个
+    30s 节拍再建卡（届时标题口径直接正确，不再需要兜底与补齐两步）。
+
+    item 缺失（会话已不在本次枚举里，如存储被删）返回 False——那种情况交既有
+    「存储被删→done」规则处理，本闸不表态。
+    """
+    if not item:
+        return False
+    return not str(item.get("first_prompt") or "").strip() \
+        and not str(item.get("title") or "").strip()
+
+
+def _is_placeholder_card(card, sids):
+    """卡面是否仍是「自动写入的占位形态」——存量收口的**前置硬闸**（2026-10-09 二版）。
+
+    占位形态 = 标题为空，或等于主会话 sid 短码（`sid[:12]`，即 `_sync_card_fields`
+    的兜底名、`_sync_card_follow` 认的自动写入形态之一）。建卡时首问未落盘才会
+    长这样；一旦有首问/任务提示词写进来，标题就成了真实内容。
+
+    为什么要有这道闸：存量收口的另两条判据（会话枚举是否为空 / sid 是否在
+    tasks·飞书登记里）都依赖**易变的一次性输入**——首版上线真机首跑就因这种输入
+    异常误删 13 张有真实标题的卡（918、697、709 等，事后复算判据全不成立）。
+    卡面标题是卡自身的证据，不随会话解析成败摇摆；**真实标题的卡一律不自动收口**
+    （宁漏不误删，漏下的交用户自己删）。
+    """
+    title = (card["title"] or "").strip()
+    if not title:
+        return True
+    # 标题 == 某个绑定会话的 sid 短码（`sids` 是集合，故用 any 而非取首元素）
+    return any(title == str(s or "").strip()[:12] for s in sids if s)
+
+
+def _platform_owned_sids(project_id):
+    """本项目「平台自己持有会话位」的 sid 集合（B 类闸，2026-10-09）。
+
+    sync 卡的定位是**外部直跑会话**（用户在 dsh GUI 里直接跑、平台只是把它
+    投影到看板）。平台自己建/持有的会话在平台侧已有入口，再投影一张卡就是
+    重复，故建卡前剔除。两个来源：
+
+      - `tasks.session_id`：任务主会话（任务详情 / 日志里已有入口）；
+      - `feishu_bindings.cur_sid`：飞书通用对话当前绑定的会话（飞书侧有入口）。
+
+    看板卡自己的会话不用列——`sync_sessions` 的 bound 映射（卡片 sessions 并集）
+    已经覆盖。站点会话窗发过消息的会话（`chat_msgs`）**不纳入**：那些会话常常
+    正是 dsh GUI 建出来的外部会话（用户从会话窗投一句话而已），纳入会让它们
+    永远建不出卡（含「建卡 30s 窗口内先投了消息」的竞态）。
+
+    一次查库、单轮复用；表缺失/结构演进按空集（归因失败绝不影响建卡）。
+    """
+    sids = set()
+    try:
+        with db.connect() as conn:
+            for sql, args in (
+                ("SELECT session_id AS sid FROM tasks"
+                 " WHERE project_id=? AND session_id<>''", (project_id,)),
+                ("SELECT cur_sid AS sid FROM feishu_bindings"
+                 " WHERE cur_project_id=? AND cur_sid<>''", (project_id,)),
+            ):
+                try:
+                    sids.update(str(r["sid"]) for r in conn.execute(sql, args))
+                except Exception:
+                    continue     # 单表不可用只丢该项，不影响另一项与建卡
+    except Exception:
+        return set()
+    return {s for s in sids if s}
+
+
 def _sync_card_fields(item, sid):
-    """sync 卡**新建**时的 (标题, 描述)。
+    """sync 卡平台自动写入形态的 (标题, 描述) 目标值。
+
+    标题 = **DSH 当前会话标题**（`item["title"]` = 末枚 `session/title` 事件，与
+    dsh GUI 侧栏一致；无标题事件时回落首问首行、再回落 sid 短码）；描述 = 首问
+    **全文**。建卡与 `_sync_card_follow` 补齐共用同一口径（幂等）。
 
-    优先「主会话第一次用户提问」（首行→标题、其余→描述）；会话还没收到提问时
-    回落会话标题事件、再回落 sid 短码——建卡后首问一旦落盘，由
-    `_sync_card_follow` 在同步节拍里补齐（会话目录先建、提问后到的真实竞态，
-    见 board spec「sync 会话归类」）。
+    本函数只被**已通过空会话闸**的调用方调用——首问/标题两者皆空的会话根本不建卡
+    （见 `_is_empty_session`）；建卡后 DSH 侧标题自动更新（LLM 标题、用户改名）与
+    首问落盘，都由 `_sync_card_follow` 在下一个同步节拍里跟上。
     """
-    title, desc = _split_first_prompt(item.get("first_prompt") or "")
+    title = (item.get("title") or "").strip()
     if not title:
-        title = ((item.get("title") or "") or sid[:12])[:SYNC_TITLE_MAX]
-    return title, desc
+        title = _split_first_prompt(item.get("first_prompt") or "")[0]
+    if not title:
+        title = sid[:12]
+    return title[:SYNC_TITLE_MAX], _full_first_prompt(item.get("first_prompt") or "")
+
+
+def _auto_title_forms(item, sid):
+    """平台**可能自动写入过**的卡标题集合（判「卡面标题是否仍属自动写入形态」）。
+
+    含：空、sid 短码、DSH 当前标题、**全部历史标题事件**、旧口径写入的首问首行。
+    历史标题事件一项是为「建卡时只有兜底标题、LLM 标题后到」的窗口准备的——那时
+    平台写进卡面的兜底标题已不是当前标题，只存在于会话的标题事件历史里；用户手工
+    改过的标题不在此集合 ⇒ 整卡不再自动覆盖（尊重用户在卡面的改名）。
+    """
+    forms = {"", sid[:12]}
+    forms.add(((item.get("title") or ""))[:SYNC_TITLE_MAX])
+    forms.update(str(t or "")[:SYNC_TITLE_MAX] for t in (item.get("titles") or []))
+    forms.add(_split_first_prompt(item.get("first_prompt") or "")[0])
+    return forms
 
 
 def _sync_card_follow(card, item, sid):
-    """存量 sync 卡按首问补齐的字段 dict（无变化返回 {}，调用方直接 update）。
+    """存量 sync 卡按「DSH 当前标题 + 首问全文」补齐的字段 dict（无变化返回 {}）。
 
-    只认「主会话」：遍历到的会话不是卡的主会话（多会话并集里的子会话）时不动，
-    对齐需求「主会话的第一次用户提问」。
-    只在卡仍由平台自动写入时动：标题为空 / 等于 sid 短码 / 等于旧口径写入的会话
-    标题事件文本 —— 用户在卡面行内改过标题（title 三者都不等）就整张卡不再自动
-    覆盖；描述只在卡描述为空时填，用户写过的描述不覆盖。
+    只认「主会话」：遍历到的会话不是卡的主会话（多会话并集里的子会话）时不动。
+    只在卡仍由平台自动写入时动（卡标题 ∈ `_auto_title_forms`：空 / sid 短码 / 任一枚
+    会话标题事件 / 旧口径的首问首行）——用户在卡面行内改过标题就整张卡不再自动覆盖
+    （描述也不动）。描述仅在为空、或仍是**旧口径自动写入**（首问除首行）时改成首问
+    全文；用户写过的描述不覆盖。
     """
     if (card["session_id"] or sid) != sid:
         return {}
-    title, desc = _split_first_prompt(item.get("first_prompt") or "")
-    if not title:
-        return {}
     cur_title = (card["title"] or "").strip()
-    auto_titles = {"", sid[:12], ((item.get("title") or "") or "")[:SYNC_TITLE_MAX]}
-    if cur_title not in auto_titles:
+    if cur_title not in _auto_title_forms(item, sid):
         return {}
+    title, desc = _sync_card_fields(item, sid)
     out = {}
     if cur_title != title:
         out["title"] = title
-    if desc and not (card["description"] or "").strip():
+    cur_desc = (card["description"] or "").strip()
+    legacy_desc = _split_first_prompt(item.get("first_prompt") or "")[1]
+    if desc and cur_desc != desc and cur_desc in ("", legacy_desc):
         out["description"] = desc
     return out
 
@@ -3327,12 +3639,20 @@ def _sync_card_follow(card, item, sid):
 def sync_sessions(project):
     """自动同步项目 agent 会话到看板。返回新建卡 id 列表。
 
-    新建卡（origin='sync'）：标题/描述=主会话第一次用户提问（首行→标题、其余→
-    描述；首问未落盘时回落会话标题、再回落 sid 短码，落盘后由本函数补齐），绑定
-    主会话，busy→doing / 空闲→review；存量 sync 卡：首问补齐标题/描述（用户改过
-    名的不动）+ dsh 族列映射移交调和器（事件驱动），此处仅归档→done（人工拖到
+    **建卡闸（2026-10-09 两处收窄，用户诉求「看板别再莫名冒卡」）**：
+    - A 类 空会话不投影：会话已存在但一句话都还没有（首问/标题皆空）时不建卡，
+      等首问或标题落盘后的下一个节拍再建（见 `_is_empty_session`）；
+    - B 类 平台自持会话不重复投影：`tasks.session_id` / `feishu_bindings.cur_sid`
+      的会话平台侧已有入口，不再当成"外部直跑会话"投影成卡（见
+      `_platform_owned_sids`）。
+
+    新建卡（origin='sync'）：标题 = DSH 当前会话标题（无标题事件时回落首问首行、
+    再回落 sid 短码）、描述 = 首问全文，绑定主会话，busy→doing / 空闲→review；
+    存量 sync 卡：按 DSH 当前标题 + 首问全文补齐（DSH 侧标题自动更新/改名后跟着改；
+    用户改过名的不动）+ dsh 族列映射移交调和器（事件驱动），此处仅归档→done（人工拖到
     todo/blocked/done 后不再自动搬）；会话存储被删的 sync 卡自动进 done；绑子代理
-    会话的存量 sync 卡收口进回收站（每项目一轮，见函数尾注释）。
+    会话的存量 sync 卡收口进回收站（每项目一轮）；上述两类误建卡的存量也按同款
+    口径收口（每项目一轮，见函数尾注释）。
     sync 卡不占 runner 项目占用（外部会话平台控制不了，防堵死统一队列）。
     """
     if not settings_of(project["id"]).get("sync_sessions", True):
@@ -3352,6 +3672,8 @@ def sync_sessions(project):
             bound[s] = c
         if c["session_id"]:
             bound[c["session_id"]] = c
+    # B 类闸的 sid 集合（每轮一次查库，见 `_platform_owned_sids`）
+    owned = _platform_owned_sids(project["id"])
     created = []
     for it in items:
         sid = it["sid"]
@@ -3360,9 +3682,16 @@ def sync_sessions(project):
         # busy 按需判定（2026-09-27）：只有新卡分支消费 busy；存量 sync 卡只用
         # archived（列映射归调和器），不再为每个会话无条件探测。
         busy = False
-        if c is None:
+        if c is None and not _is_empty_session(it) and sid not in owned:
             busy = _sync_session_busy(project, raw_family, sid, it["mtime"])
         if c is None:
+            # A 类闸：空会话不投影（建卡竞态由"等首问"取代旧的"先落 sid 短码
+            # 兜底再补齐"——用户在板上看到的将只会有内容的会话）
+            if _is_empty_session(it):
+                continue
+            # B 类闸：平台自持会话（任务/飞书）已有入口，不重复投影成卡
+            if sid in owned:
+                continue
             title, desc = _sync_card_fields(it, sid)
             cid = db.insert_board_card(project["id"], title, desc)
             # 归档会话：不参与 busy 判定，直接落「已完成」
@@ -3405,6 +3734,42 @@ def sync_sessions(project):
         if dropped:
             print(f"[board-sync] 子代理会话卡收口: 软删 {dropped} 张"
                   f"（项目 {project['id']}，见 spec/queue/排队与占用.md）")
+    # —— 存量误建卡收口（2026-10-09；二版：「卡面占位形态」为前置硬闸）——
+    # A/B 两闸只挡新建，历史版本已经建出的两类卡还留在板面上（实测：任务会话卡
+    # 12 张、空会话占位卡 10 张，跨 4 个项目）。这里**软删进回收站**（可还原；
+    # 不删会话文件、不动会话与依赖、不碰任务的任何记录）。判据与新建闸同源：
+    #   ① B 类：卡绑的 sid 是平台自持会话（tasks/飞书）——重复投影，收回；
+    #   ② A 类：卡绑的会话**全部**是空会话（首问/标题皆空）——没有任何内容可看；
+    #      任一 sid 不在本轮枚举里（存储被删等）即不判空，交「存储被删→done」规则。
+    # **首版实障（2026-10-09 当天）**：上述两条都依赖「易变的一次性输入」（会话
+    # 枚举的解析结果 / tasks·飞书登记），真机首跑即在三个项目误删 13 张**有真实
+    # 标题**的卡（918「现在TS作为DSH的插件…」、697/709 等；事后在库副本上复算，
+    # 它们连判据中间值都不成立 ⇒ 属判据输入的一次性异常）。故补**前置硬闸**
+    # `_is_placeholder_card`：只收口「卡面标题仍是自动写入占位形态（空 / 主会话
+    # sid 短码）」的卡——卡面标题是卡自身的证据，不随会话解析成败摇摆；真实标题
+    # （用户提问首行 / 任务提示词首行）一律不自动收口。代价＝标题已补齐的误建卡
+    # （任务会话卡）会漏删，交用户自行处理（**宁漏不误删**）。
+    # 三条边界与子代理卡收口一致：只认 origin='sync' 自动卡（用户自建卡一字节
+    # 不动）、平台在管的运行中卡跳过（`_has_active_run`）、每项目只跑一轮
+    # （用户从回收站还原后同一进程内不再被反复软删；重启后重跑一轮，幂等）。
+    if project["id"] not in _SYNC_MISBUILT_SWEPT:
+        by_sid = {it["sid"]: it for it in items}
+        dropped = 0
+        for c in cards:
+            if c["origin"] != "sync" or _has_active_run(c["id"]):
+                continue
+            sids = set(_card_sids(c))
+            if not sids or not _is_placeholder_card(c, sids):
+                continue          # 卡面已有真实标题 ⇒ 非自动占位卡，绝不自动收口
+            if any(s in owned for s in sids) or \
+                    all(_is_empty_session(by_sid.get(s)) for s in sids):
+                db.trash_board_card(c["id"])
+                dropped += 1
+        _SYNC_MISBUILT_SWEPT.add(project["id"])
+        if dropped:
+            print(f"[board-sync] 误建卡收口: 软删 {dropped} 张"
+                  f"（项目 {project['id']}：平台自持会话卡 / 空会话占位卡，"
+                  f"见 board spec §48）")
     # 存储被删 → done（list 只回 50 条，不能用「不在列表」判定删除，必须逐卡查存在性）
     for c in cards:
         if c["origin"] != "sync" or c["column_key"] == "done" or _has_active_run(c["id"]):
@@ -3481,6 +3846,27 @@ def run_pid(card_id):
     return None
 
 
+def _orphan_hold(card_id):
+    """本卡是否持有「无平台在管条目背书」的活跃 `c:` 行（**孤儿运行行**，缺陷 B 判据）。
+
+    生产上唯一的产生面＝作答/立即送达**送达成功**时 `runner.card_started` 补回的
+    「送达恢复」/「立即送达」行：那行由平台建，而目标会话是外部/接管会话（平台的
+    `_RUNS` 里没有它）⇒ 行没有「在管条目」背书，收口只能靠调和器按实况判定
+    （`_starting_window` 的 docstring 早已写明这类形态要能「落回待审核」）。
+
+    为什么必须与 `has_run` 分开判（缺陷 B，T9b 真机 6 轮 5 轮命中）：调和状态机把
+    `live_msg`（本卡有排队/执行中的 `m:` 行）算作「在跑」，而**孤儿行本身就在运行
+    前缀里**——serial 项目里它把本卡自己的排队消息永久挡在队外
+    （`runner._prefix_window_blocked`），状态机又因为那条消息「排队中」判本卡「在跑」
+    ⇒ 互等：行不收口、消息永远排不到、该卡与项目后续投递全被挡住（周期自检只打
+    `[waitq-selfcheck] 行状态不明（仅告警）`）。故孤儿行只认**实况 busy**。
+
+    池内卡走不到这个形态：同一「送达恢复」动作发生在池内卡上时 `_RUNS` 条目在场
+    （`has_run=True`），状态机在 `has_run` 分支早退、行由巡视线程 `_finish_run` 在
+    会话空闲时收口（见 `_reconcile_action_for` 的不干预规则）。"""
+    return _card_unit_active(card_id) and not _has_active_run(card_id)
+
+
 # ---------- 交互等待检测（InteractionWatcher，方案 A） ----------
 # 单族化后等待态只有 dsh 一个来源：`dshevents` 注册表的 interaction 字段——
 # 提问来自 `user-questions/request` waterfall、审批来自 `approval/asked`
@@ -3542,6 +3928,12 @@ def _iw_interaction(family, proj, sid, busy_hint=None):
             return None
         busy = st.get("status") == "running"
         mark = st.get("interaction") or {}
+        # T9 真机取证待办（2026-10-10）：外部会话（owned:false）挂起等作答期间，宿主
+        # `status` 是否为 `running` **尚未取证**——本批先按既有口径交付，判据保持不动。
+        # 若实测为 `idle`，mark 非空的挂起会被本行判成 pending=False（answerable 随之
+        # 丢失、站点上不可答），届时由控制者另派小修复把判据拆开：`mark` 为空 ⇒
+        # pending False；`mark` 非空且 `call_id` 非空 ⇒ pending True（`busy` 照实回传，
+        # 防陈旧 mark 复活卡片），并补一条对应的反例用例。
         if not busy or not mark:
             return {"pending": False, "busy": busy, "qid": None,
                     "question": None, "options": None,
@@ -3593,6 +3985,286 @@ def _iw_interaction(family, proj, sid, busy_hint=None):
         return None          # 读注册表异常：本轮跳过
 
 
+# ---------- 外部会话看管声明（C 批 T5，2026-10-10） ----------
+#
+# 背景：用户在 dsh GUI 里直跑/接管的会话（`/live` 里 `owned:false`）不在驱动池，
+# 投递必然 404。驱动侧因此加了 `POST /watch` 显式看管闸（见 dshdriver.watch_session）；
+# 平台侧把「声明范围」限定为**平台确实要投递的会话**：有卡的会话（宿主里与 Touchstone
+# 无关的会话一律不碰）**加上**宿主上报为外部态（owned:false）的任务侧会话——后者由
+# 消息前置闸与作答送达前的 `_watch_before_delivery` 按需补声明（T7 评审 2026-10-10）。
+#
+# 声明点三处，互为兜底：
+#   ① `_iw_once` 逐卡循环内（调和器扫描，覆盖常态）；
+#   ② `chat._external_preflight` 投递前置闸内（覆盖「卡刚建、扫描节拍还没跑到」的窗口）；
+#   ③ `_watch_before_delivery` 作答/审批送达前（覆盖无卡的**任务侧**外部会话）。
+# 撤销：`_watch_prune`（卡删除/换绑会话后回收，防集合无界增长）。
+# 失效：`_watch_generation_sync`（中枢重连边沿清空记账后重放，设计 §5.1）。
+# 语义：`_WATCHED` 是**进程内缓存**（「已声明过」的记账，避免每轮重复 POST）；
+# 驱动侧 `watched` 才是权威。故集合清了只会多打一次幂等的 `/watch`，不会漏声明。
+_WATCHED: set[str] = set()
+_watch_lock = threading.Lock()
+# 看管代次：上次见到的中枢连接代次（`dshevents.stats()["reconnects"]`）。
+# None = 本进程尚未对过账（首次读只记基准，不清空——启动时集合本就为空）。
+_WATCH_GEN = None
+# 扫卡节流窗口（秒，C 批终审 I3，2026-10-10）：`_iw_once` 由**每个状态帧**唤醒
+# （仅 IW_MIN_INTERVAL 限速），节拍尾部每轮都调 `_watch_prune()`；而扫卡 =
+# `list_projects_all()` 一次连接 + **每项目一次** `list_board_cards()`，只要有任何
+# 一个外部会话被看管，全量扫卡就跟着状态帧跑。节流到与调和器兜底拍
+# （`IW_SAFETY_SECONDS`=60s，见文件尾）同量级：被节流的只是「扫卡 + 撤销」，
+# **只影响回收的及时性**（多留一会儿看管是安全方向）；代次检查是正确性路径，
+# 照旧每次进入都做（见 `_watch_prune`）。
+WATCH_PRUNE_INTERVAL = 60.0
+# 上次真正扫卡的时刻（`time.monotonic()`；0.0 = 本拍该扫）。就地读写都在 `_watch_lock` 内。
+_WATCH_PRUNE_AT = 0.0
+
+
+def _watch_generation_sync():
+    """中枢重连边沿 ⇒ 清空 `_WATCHED`；返回是否发生了清空（设计 §5.1 的失效通道）。
+
+    依据：`dshevents.stats()["reconnects"]`——中枢（`dshevents.EventHub`）每次
+    「未连接 → 已连接」边沿加一，读口是**纯本地** `with self._cond`（零 HTTP 请求），
+    故每次声明前读一次也不打驱动。为什么必须清：驱动侧 `watched` 是插件进程内的
+    易失状态（`dispose()` / 插件重新 apply、宿主重载即清空），而平台记账仍写着
+    「已声明过」——不清就会一直命中陈旧缓存、不再 POST `/watch`，投递撞驱动 404 落
+    error，且卡还在时 `_watch_prune` 不撤 ⇒ 不自愈（bug_report/20261008_1935 记录的
+    宿主侧重载场景）。清空只让下一次 `_ensure_watch` 重新声明一次（幂等 POST），
+    不会漏声明。
+    """
+    global _WATCH_GEN
+    try:
+        gen = dshevents.stats().get("reconnects")
+    except Exception:                      # noqa: BLE001 — 读口异常不阻断，下轮再来
+        return False
+    if gen is None:
+        return False
+    with _watch_lock:
+        prev, _WATCH_GEN = _WATCH_GEN, gen
+        if prev is None or prev == gen:
+            return False
+        _WATCHED.clear()
+    return True
+
+
+def _ensure_watch(sid, force=False):
+    """声明「平台看管该会话」（幂等，成功才入缓存）；失败留痕返回 False，不重试。
+
+    先过**代次对账**（中枢重连 ⇒ 陈旧记账作废，见 `_watch_generation_sync`），
+    再查缓存：已在 `_WATCHED` 内直接 True（零请求）；否则
+    `dshdriver.watch_session(sid)`，驱动确认 `watched=true` 才记进缓存。任何失败
+    （旧插件无 `/watch` ⇒ 404、驱动不可达、令牌错）都只打印一行诊断并返回 False
+    ——**不重试**：调用方（`chat._external_preflight`）据此拒投并给明确文案，比反复
+    打驱动更有用；下一轮调和器扫描会自然重试一次（缓存里没有它）。
+
+    `force=True` 跳过缓存命中、**强制重发一次声明**（成功后照常入缓存）。唯一调用方是
+    `rename_card_session` 的 404 重试：那里的 404 恰恰说明「驱动侧认为没看管」，而
+    `_WATCHED` 是**平台侧进程内记账**、可能与驱动侧脱节（实测 2026-10-10：带外
+    `POST /watch {on:false}`、以及驱动在 `session/disposed` 时自清看管表，
+    都会让缓存变陈旧）——缓存命中就不能让它挡住这次重试。
+    """
+    sid = str(sid or "")
+    if not sid:
+        return False
+    _watch_generation_sync()
+    if not force:
+        with _watch_lock:
+            if sid in _WATCHED:
+                return True
+    try:
+        ok = bool(dshdriver.watch_session(sid))
+    except Exception as exc:                       # noqa: BLE001 — 失败降级为拒投
+        hint = "（插件过旧：无 /watch 端点，请重装插件并重启 dsh web）" \
+            if getattr(exc, "code", None) == dshdriver.WATCH_UNSUPPORTED else ""
+        print(f"[board] 看管声明失败 sid={sid}: {exc}{hint}", flush=True)
+        return False
+    if not ok:
+        print(f"[board] 看管声明失败 sid={sid}: 驱动未确认看管（watched=false）",
+              flush=True)
+        return False
+    with _watch_lock:
+        _WATCHED.add(sid)
+    return True
+
+
+# 卡面改名的驱动调用超时（秒）：best-effort 的同步链路，快失败比让 HTTP worker 挂满
+# 默认 120s 有用（2026-10-10 需求「TS 卡面改名 → DSH 会话名同步」）。
+RENAME_TIMEOUT = 10
+
+
+def rename_card_session(sid, title):
+    """卡面改名 → 同步改 DSH 会话标题（best-effort）。返回 `(ok, error, accepted)`。
+
+    两跳（2026-10-10 用户需求，B 档）：
+      ① `dshdriver.rename`：覆盖**池内**会话（平台建/恢复过的：任务会话、平台起过的卡、
+         会话窗发过消息被 resume 的）；
+      ② 首跳 404（池外）⇒ `_ensure_watch(sid)` 声明看管（幂等、**只声明不接管**）后
+         重试一次：覆盖用户在 dsh GUI 直跑、驱动只观察的会话——驱动侧 `/rename` 的
+         池外回落分支按「看管 + 宿主有活 agent」放行（node 半同批实现）。
+    失败**不抛**：卡面是用户的编辑，必须先生效；调用方（server 端点）把原因回给前端。
+    `accepted` = 驱动回执里宿主**接受**的标题（可能被 dsh 规范化/按字节预算截断），
+    成功时非空——调用方据此回写卡面，保证两侧逐字一致。
+    """
+    sid = str(sid or "")
+    title = str(title or "").strip()
+    if not sid or not title:
+        return False, "缺少会话或标题，未同步 DSH 会话名", ""
+    last = ""
+    for attempt in (1, 2):
+        try:
+            r = dshdriver.rename(sid, title, timeout=RENAME_TIMEOUT) or {}
+            return True, "", str(r.get("title") or title)
+        except Exception as exc:                   # noqa: BLE001 — 统一降级为原因串
+            last = str(exc)
+            pool_miss = getattr(exc, "code", None) == 404
+            # 只在「池外」这一跳补一次看管声明（已看管无活 agent 的 404 重试同样失败，
+            # 但代价只是一次请求，换来判定逻辑不依赖文案匹配）。**force=True**：这一跳的
+            # 404 正说明驱动侧认为没看管，平台侧 `_WATCHED` 缓存可能陈旧（带外撤销、
+            # 驱动在 session/disposed 时自清），不能被它挡住重发。
+            if attempt == 1 and pool_miss and _ensure_watch(sid, force=True):
+                print(f"[board] 卡面改名：池外会话补看管声明后重试 sid={sid}",
+                      flush=True)
+                continue
+            break
+    return False, last, ""
+
+
+def _watch_card_refs():
+    """看管引用集：全部卡片的 `session_id ∪ sessions`。
+
+    含归档项目（归档 ≠ 删卡，归档项目的在跑会话照旧需要投递通道）。坏 JSON 按
+    「无附加会话」防御（与卡片读侧同口径）。
+    """
+    refs = set()
+    for proj in db.list_projects_all():
+        for card in db.list_board_cards(proj["id"]):
+            sid = str(card["session_id"] or "")
+            if sid:
+                refs.add(sid)
+            try:
+                refs.update(str(s) for s in json.loads(card["sessions"] or "[]") if s)
+            except ValueError:
+                pass                               # 坏 JSON 按无附加会话（防御）
+    return refs
+
+
+def _watch_msg_inflight(sid):
+    """该 sid 是否仍有在途消息（活跃 `m:` 行）——看管撤销判据的第二条。
+
+    读口用 `chat.live_of_sid`（内部即既有 waitq 读口
+    `waitq.msg_rows(sid=…, states=("queued", "running"))`，不另写 SQL）。
+    读不到按「有在途」保守处理：宁可少撤（下轮再试），不可误撤（在途消息送达
+    撞驱动 404，正是本任务要消灭的「放行后静默失败」）。
+    """
+    try:
+        return bool(chat.live_of_sid(sid))
+    except Exception:                          # noqa: BLE001 — 读不到按「有在途」保守
+        return True
+
+
+def _watch_prune():
+    """撤掉**确无需要**的看管声明（`POST /watch {on:false}`），返回撤销条数。
+
+    判据（两条都成立才撤）：
+      ① 无卡引用——引用集 = 全部卡片的 `session_id ∪ sessions`，见 `_watch_card_refs`；
+      ② 无在途消息——该 sid 已无活跃 `m:` 行，见 `_watch_msg_inflight`。前置闸会为
+         **无卡**外部会话放行（飞书绑定会话、任务会话重载后变外部态等 `card_id/
+         task_id` 皆空的 submit 路径），此时「无卡引用」≠「无人需要看管」：还在
+         `m:` 行里排队的消息一旦被撤看管，送达时 `/prompt` 就撞驱动 404。
+
+    竞态（与前置闸的 TOCTOU）：撤销判据在**同一临界区**内复核，不信任扫描快照
+    ——① `_WATCHED` 成员资格在锁内重查（快照之后并发的前置闸可能刚重新声明入集合）；
+    ② 在途消息在锁内重查（快照之后可能刚落 `m:` 行）。撤销成功后**再复核一次**：
+    窗口内若又冒出新声明/新在途消息（`on:false` 可能压掉了并发的 `on:true`），立即
+    补偿重声明——宁可多打一次幂等 `/watch`，不可留「缓存无、驱动无」而在途消息撞
+    404。驱动 I/O 全程在锁外（锁纪律：`_watch_lock` 只保护记账集合，绝不跨网络调用）。
+    撤销失败的 sid 放回集合等下一轮重试。
+
+    节流（C 批终审 I3，2026-10-10）：本函数由 `_iw_once` **每个状态帧**调用一次，
+    而「扫卡」是 O(项目数 × 每项目卡数) 的 DB 读、`_watch_msg_inflight` 还在
+    `_watch_lock` 内做 SQLite 查询。故「扫卡 + 撤销」节流到
+    `WATCH_PRUNE_INTERVAL`(60s，与调和器兜底拍同量级)：窗口内只剩两件零成本的事
+    —— `_watch_generation_sync()`（本地代次读口）与「集合空则返回」。
+    **代次检查不参与节流**（它是正确性路径：中枢重连边沿必须立刻作废旧记账，否则
+    陈旧缓存永不自愈）；被节流影响的**只有回收的及时性**（最多晚一拍撤销看管——
+    多留一会儿看管是安全方向，且在途消息送达不受影响）。
+    开销：`_WATCHED` 为空（常态）时零 DB 访问（早于节流判定，也不会消耗窗口——
+    新声明入集合后本拍即扫）。
+    """
+    global _WATCH_PRUNE_AT
+    _watch_generation_sync()                   # 中枢重连过：陈旧记账先作废（撤销无意义）
+    with _watch_lock:
+        if not _WATCHED:
+            return 0                           # 常态：零 DB 访问（不消耗节流窗口）
+        now = time.monotonic()
+        if now - _WATCH_PRUNE_AT < WATCH_PRUNE_INTERVAL:
+            return 0                           # 本窗口已扫过：只推迟回收，不影响正确性
+        _WATCH_PRUNE_AT = now                  # 开窗（含扫描异常：下一拍再试）
+    refs = _watch_card_refs()
+    with _watch_lock:
+        candidates = sorted(_WATCHED - refs)   # 粗筛快照；最终判据见下面的锁内复核
+    n = 0
+    for sid in candidates:
+        with _watch_lock:
+            # —— 撤销前锁内复核（唯一信任点）——
+            if sid not in _WATCHED or sid in refs or _watch_msg_inflight(sid):
+                continue
+            _WATCHED.discard(sid)              # 先出缓存：并发 _ensure_watch 转为重新声明
+        try:
+            dshdriver.watch_session(sid, on=False)
+        except Exception as exc:               # noqa: BLE001 — 留痕，下轮重试
+            with _watch_lock:
+                _WATCHED.add(sid)              # 撤销失败：放回，下轮再试
+            print(f"[board] 看管撤销失败 sid={sid}: {exc}", flush=True)
+            continue
+        # —— 撤销后复核：窗口内并发落下的新声明 / 新在途消息 ⇒ 补偿重声明 ——
+        with _watch_lock:
+            redeclared = sid in _WATCHED
+            if redeclared:
+                _WATCHED.discard(sid)          # 清掉再声明：强制真发一次 POST
+        if redeclared or _watch_msg_inflight(sid):
+            _ensure_watch(sid)
+            continue
+        n += 1
+    return n
+
+
+def _watch_before_delivery(sid):
+    """送达前对**非池内**（外部）会话重新声明一次看管（C 批 T7 控制器裁定，2026-10-10）。
+
+    为什么必须补（T5 与 T4 两处评审叠加出的真实洞）：`_watch_prune` 的撤销判据是
+    「无卡引用 ∧ 无在途 `m:` 行」——**不含活跃 `a:`（作答）行**；驱动的
+    `/watch {on:false}` 也不会主动收口在途认领（要等 abort/disposed/dispose）。
+    两者叠加：答案已入队未送达、或会话正挂起等作答（用户刚点作答）时点，prune 可能
+    已把该 sid 的看管撤掉 ⇒ 送达 `/answer`·`/approval` 撞驱动「未看管」404 ⇒
+    `a:` 行落 error，正是本批要消灭的失败类。故作答/审批的**唯一送达出口**
+    （`_answer_deliver`，worker 补位与「立即送达」共用）在真正调驱动前补一次声明。
+
+    幂等且廉价：`_ensure_watch` 命中 `_WATCHED` 缓存时是**纯本地判断、零请求**，
+    只有缓存/驱动侧确已被撤（prune 撤销、中枢重连失效）才真发一次 `POST /watch`。
+
+    判据用既有读口 `dshevents.get(sid)` 的 `owned`（不新增全局状态、不猜）：
+    `owned is False` ⇒ 外部会话（需要显式看管）；`owned is True`（平台自持）与
+    `None`（注册表未知/断连——未知 ≠ 外部）一律不声明，与 `chat._external_preflight`
+    及 `_iw_once` 逐卡挂钩同一判定阶梯：池内与未知路径行为一个字节不变。
+    本函数**不改** `_watch_prune` 判据（「未看管不认领」是驱动侧红线，驱动行为正确），
+    只把「撤销窗口里到达的送达」自愈回来。
+
+    失败不阻断（`_ensure_watch` 自带留痕、不重试）：声明失败时驱动同样回 404，由
+    调用方既有的重试/放弃语义处置，错误口径与此前一致。
+
+    边界：本钩子**缩小但不关闭** `_watch_prune` 与「在途送达」之间的交错窗口——钩子
+    返回后到驱动真正收到 `/answer`·`/approval` 之间仍可能被一次并发 prune 撤掉看管；
+    该残留窗口的兜底在**送达重试**（`a:` 行的 3 次退避重试；每次重试都再走一遍本钩子
+    重新声明），不为此引入锁或全局状态。
+    """
+    sid = str(sid or "")
+    if not sid:
+        return
+    st = dshevents.get(sid)
+    if st is None or st.get("owned"):
+        return                          # 未知（断连/没见过）与平台自持：不碰
+    _ensure_watch(sid)
+
+
 _RECONCILE_FIELDS = {
     # 动作 -> 落库字段（block 的 block_text 由调用方按检测摘录补）
     "recover": {"column_key": "doing", "block_kind": None, "block_text": ""},
@@ -3605,7 +4277,8 @@ _RECONCILE_FIELDS = {
 
 
 def _reconcile_action_for(family, card, r, has_run=False, live_msg=False,
-                          stop_recent=False, archived=None, starting=False):
+                          stop_recent=False, archived=None, starting=False,
+                          orphan_hold=False):
     """调和状态机（纯函数，单测覆盖）：按会话实况 r（pending/busy）、归档态
     archived 与当前卡状态得出动作，action ∈
     {'block'（进阻塞+interaction）,
@@ -3619,10 +4292,16 @@ def _reconcile_action_for(family, card, r, has_run=False, live_msg=False,
     （None，中枢断连）一律不动作（不变量「断连=未知」）。
     映射规则（无平台在管运行时，设计 §2.4）：提问→blocked(interaction)；
     运行中→doing；空闲→review；阻塞解除按运行态回 doing/review。
-    运行判定 running = busy or live_msg（2026-09-11）：live_msg=本卡会话有
-    排队/执行中的平台消息单元（chat.live_of_sid）——消息排队尚未执行时会话
-    并不 busy，仅凭 busy 会漏判；阻塞列卡片在消息投递后即应回开发列（用户
-    约定：所有正在运行的卡片都在「正在开发」列）。
+    运行判定 running = busy or (live_msg ∧ ¬orphan_hold)（2026-09-11 立，2026-10-10
+    加孤儿行例外）：live_msg=本卡会话有排队/执行中的平台消息单元（chat.live_of_sid）
+    ——消息排队尚未执行时会话并不 busy，仅凭 busy 会漏判；阻塞列卡片在消息投递后
+    即应回开发列（用户约定：所有正在运行的卡片都在「正在开发」列）。
+    `orphan_hold`（`_orphan_hold`：本卡有活跃 `c:` 行但无 `_RUNS` 背书，生产上＝
+    作答/立即送达补回的「送达恢复」行）**只认实况 busy**：那条行本身就在运行前缀里，
+    serial 项目里它把本卡自己的排队消息挡在队外，再把 live_msg 当「在跑」就是互等
+    （缺陷 B：行不收口 ⇒ 消息永远排不到 ⇒ 行永远收不了；真机 6 轮 5 轮命中，该卡与
+    项目后续投递被永久挡住）。会话可信空闲（busy=False）时这类行必须收口让队列继续
+    ——与「送达恢复行按实况落回待审核」的既有口径（`_starting_window`）同源。
     不干预规则：退场族不动（调用方已过滤，此处兜底保纯函数安全）；
     todo/done 终态不动；平台在管运行（has_run=True）的卡只做交互 block/recover、
     busy/空闲流转归 _finish_run 拥有（防与轮收尾抢写）——**唯一例外**是卡片在
@@ -3663,7 +4342,9 @@ def _reconcile_action_for(family, card, r, has_run=False, live_msg=False,
         return None
     pending = bool(r and r.get("pending"))
     busy = bool(r and r.get("busy"))
-    running = busy or bool(live_msg)
+    # 孤儿运行行只认实况 busy（缺陷 B，见 `_orphan_hold` 与 docstring）：
+    # live_msg 不能再把它按「在跑」保住——行恰恰是那条消息起不来的原因
+    running = busy or (bool(live_msg) and not orphan_hold)
     if card["block_kind"] == "manual":
         if pending:
             return None                      # 等待用户回答：维持阻塞态
@@ -3729,10 +4410,13 @@ def _iw_apply(family, card, action, r):
         return                    # 已答待送达：调和动作一律跳过（见 docstring）
     has_run = _has_active_run(card["id"])
     live_msg = chat.live_of_sid((cur["session_id"] or "").strip())
+    # 写前复核同样重取「孤儿运行行」（缺陷 B，短路口径同 `_iw_once`）
+    orphan = bool(live_msg) and _orphan_hold(cur["id"])
     if _reconcile_action_for(family, cur, r, has_run, live_msg,
                              _stop_recent(cur["id"]),
                              dshevents.archived(cur["session_id"] or ""),
-                             _starting_window(cur["id"])) != action:
+                             _starting_window(cur["id"]),
+                             orphan) != action:
         return                    # 状态已变：跳过，不写库
     if action == "to_done":
         # dsh 侧归档 → 卡片进「已完成」（2026-10-05 反向规则）：走容器迁移原语收口
@@ -3855,6 +4539,8 @@ def _iw_once():
     异常语义：读不到实况（中枢未连接/未知）该卡本轮跳过（不搬列，防把运行中卡
     误判完成搬去待审核；取代 sync_sessions 旧「异常视为空闲」；ext 行侧保留既有
     行=保留上一轮占用，宁可多等不可误放行——逐卡 `r is None` 走 `ext_hold`）。
+    看管声明（C 批 T5）：逐卡对 `owned:false`（用户直跑的）会话调 `_ensure_watch`
+    ——声明范围=有卡会话；卡删除后的回收在节拍尾部 `_watch_prune`。
     单卡异常不外抛（不影响其他卡/项目）。节拍尾部另跑 starting 超时对账
     （_reconcile_starting_rows，v2d T3，裁决 R6）。"""
     now = int(time.time() * 1000)
@@ -3901,6 +4587,15 @@ def _iw_once():
                 if not sid:
                     continue               # 无会话（从未起跑的真排队卡等）无可探测
                 r = _iw_interaction(fam, proj, sid)
+                # —— 看管声明（C 批 T5）：外部会话（用户直跑/接管，`owned:false`）
+                # 的投递/作答通道以平台显式 `POST /watch` 为闸，声明范围=有卡会话
+                # （本循环即「有卡」的天然边界；撤销见 `_watch_prune`）。幂等：
+                # 只有新 sid 首见（或中枢重连后记账刚被清空，见
+                # `_watch_generation_sync`）才真发请求，失败留痕不重试。
+                # 读注册表判 owned（而非另发请求）；未知（get 为 None）不声明。
+                _st = dshevents.get(sid)
+                if _st is not None and not _st.get("owned"):
+                    _ensure_watch(sid)
                 if r is None:
                     # 实况读不到：两种语义必须分开（2026-10-07 实障修复，卡 870）——
                     # ① 中枢**断连**＝真未知：保行（宁多等不可误放行，原口径）；
@@ -3914,6 +4609,15 @@ def _iw_once():
                     if not dshevents.connected() and not _platform_holds(card["id"]) \
                             and not _subagent_session(sid):
                         ext_hold.add(card["id"])   # 占用未知：保留既有行（old 探针口径）
+                    elif dshevents.aligned() and not _platform_holds(card["id"]):
+                        # ③ 中枢可信（在线 ∧ 已对齐）却查不到该 sid ＝ 会话确已结束：
+                        #    补上卡列这一格（2026-10-08 批次 D，bug_report/20261008_1935）
+                        #    ——旧口径只收 ext 行、列不动，会话静默消失的 doing 卡永滞
+                        #    开发列（卡 908/909/912/913 的原症状）；对齐前一律不动，
+                        #    杜绝「热重载后注册表为空 ⇒ 把运行中的卡批量搬走」的误判。
+                        #    写前复核全在 `_iw_apply`：queue 占位 / 起跑窗口 / 平台持有 /
+                        #    已答待送达 / 归档（to_done）自动跳出（状态机重评）。
+                        _iw_apply(fam, card, "to_review", None)
                     continue               # 实况读不到：该卡本轮跳过，不搬列
                 # —— 外部条目占用候选（v2d T4）：busy 且非挂起、且平台不持有 ——
                 # 挂起（pending）不算占用（豁免面②：挂起即出队，不建行）；平台
@@ -3933,11 +4637,16 @@ def _iw_once():
                     c.update(r)            # pending/busy/qid/question/options/answerable/text
                     c["ts"] = now
                 live_msg = chat.live_of_sid(sid)   # 本卡消息在跑/排队（消息驱动的会话）
+                # 孤儿运行行（缺陷 B）只在「本卡确有排队/执行中的消息」时才影响判定
+                # （无消息时 running 只看 busy，见 `_reconcile_action_for`）⇒ 短路
+                # 掉那次行点查，平台在管卡的常规拍零额外 DB 访问。
+                orphan = bool(live_msg) and _orphan_hold(card["id"])
                 action = _reconcile_action_for(fam, card, r,
                                                _has_active_run(card["id"]), live_msg,
                                                _stop_recent(card["id"]), arch,
                                                _starting_window(card["id"],
-                                                                starting_ids))
+                                                                starting_ids),
+                                               orphan)
                 if action:
                     _iw_apply(fam, card, action, r)
             except Exception:
@@ -3968,6 +4677,12 @@ def _iw_once():
         _reconcile_starting_rows()
     except Exception:
         pass                                     # 守护线程不 crash（同 _iw_once 口径）
+    # 看管回收（C 批 T5）：卡删除/换绑会话后撤掉驱动的看管声明（`_WATCHED` 为空时
+    # 零 DB 访问；异常不影响本轮回调和的其余部分）。
+    try:
+        _watch_prune()
+    except Exception:
+        pass                                     # 同上：回收失败下轮再来
 
 
 def interaction_of_sid(sid):
@@ -4143,10 +4858,17 @@ def _answer_deliver(proj, meta):
     插件在 waterfall 里挂起），meta 带 `outcome`（`allowed-once`/`rejected`）走
     插件 `/approval`；未认领（GUI 作答）时插件返回 409 → 这里转 40005 让上层按
     「再无待决」收口。
+
+    外部（池外）会话（C 批 T7，2026-10-10）：真正调驱动前经 `_watch_before_delivery`
+    幂等补声明看管——看管可能已被 `_watch_prune` 撤掉（其撤销判据不含活跃 `a:` 行），
+    漏声明会让 `/answer`·`/approval` 撞「未看管」404、答案落 error。
     """
     if _web_family(proj) != "dsh_plugin":
         # 退场族无作答送达通道（单族化）：明确报错，不落已删除的 kimi 配送段
         raise RuntimeError(agents.RETIRED_MSG)
+    # 送达前重声明看管（C 批 T7）：外部会话的看管可能已被 `_watch_prune` 撤掉
+    # （其判据不含活跃 `a:` 行），漏声明则下面两条驱动调用撞「未看管」404（见上）
+    _watch_before_delivery(meta.get("sid"))
     if meta.get("approval_id"):
         outcome = str(meta.get("outcome") or "")
         if not outcome:
@@ -4358,7 +5080,9 @@ def answer_interaction(proj, card, qid, answers):
     看板卡路径（v2b T1，裁决 R8）**一律入队**（_queue_answer_unit：插前缀后/
     等待区最前 + doing/queue 占位，补位启动时 worker 才调驱动 `/answer` 一次
     提交送达——dsh 侧按 callId + 逐题 selected/custom 一次给全，缺项即未答）；
-    任务侧伪卡（无 id）保持直送。成功后清理 watcher 缓存（下轮调和重新检测刷新）。
+    任务侧伪卡（无 id）保持直送，但直送前经 `_watch_before_delivery` 补声明看管
+    （任务会话被宿主上报为外部态后撞「未看管」404 的修复，T7 评审 2026-10-10）。
+    成功后清理 watcher 缓存（下轮调和重新检测刷新）。
 
     answers = [{"wire": "q_0", "kind": "single|multi|other|multi_with_other",
                 "option_id"/"option_ids"/"text": ...}, ...]（前端逐题收集；
@@ -4437,7 +5161,7 @@ def answer_interaction(proj, card, qid, answers):
     # ._answer_exempt_keys_locked，R5⑥），一律插「运行中最后一个条目后面」
     # （前缀后/等待区最前），卡落 doing/queue 排队占位，补位启动时才送达。
     # 仅看板卡（有卡 id）参与；任务侧会话没有卡片列语义，保持直送
-    # （specQ §5 边界不变）。
+    # （specQ §5 边界不变；直送前经 `_watch_before_delivery` 补声明看管，见下）。
     try:
         card_id = card["id"]
     except (KeyError, IndexError, TypeError):
@@ -4446,6 +5170,11 @@ def answer_interaction(proj, card, qid, answers):
         if _web_family(proj) != "dsh_plugin":
             # 退场族无作答通道（单族化）：不落已删除的 kimi 配送段
             return f"回答失败：{agents.RETIRED_MSG}"
+        # 送达前重声明看管（T7 评审 Important，控制器裁定 2026-10-10）：任务会话
+        # 宿主重载后会被驱动以 owned:false 上报（= 池外），而本直送分支不经
+        # `_answer_deliver`；不补声明就撞「未看管」404，用户看到「回答失败：…」。
+        # 判据同 `_answer_deliver`：owned:false 才声明，池内/未知零请求。
+        _watch_before_delivery(sid)
         try:
             # 路线 A：任务侧会话直送（卡片侧走作答排队，见 _answer_deliver）；
             # 驱动调用失败（网络/序列化/提问已失效等）均须落到前端
@@ -4466,7 +5195,8 @@ def answer_approval(proj, card, approval_id, decision, scope=""):
     与 answer_interaction 同款白名单校验：approval_id 必须是缓存里的实况值
     （防伪造/旧 id 重放）；decision ∈ approved/rejected（平台两态），
     scope="session" 为「本会话内批准」——dsh 无该语义，显式拒绝（见下）。
-    看板卡路径（v2b T1）一律入队、补位启动时才送达；任务侧保持直送。
+    看板卡路径（v2b T1）一律入队、补位启动时才送达；任务侧保持直送，直送前同样经
+    `_watch_before_delivery` 补声明看管（与提问腿同源，T7 评审 2026-10-10）。
     成功后清 watcher 缓存（下轮调和重新检测刷新）。
     返回 None=成功，str=错误信息（server 转 400 JSON {error}）。"""
     sid = card["session_id"] or ""
@@ -4494,12 +5224,15 @@ def answer_approval(proj, card, approval_id, decision, scope=""):
     dsh_outcome = {"approved": "allowed-once", "rejected": "rejected"}[decision]
     # 审批作答同路入队（v2b T1，删恒直送）：与提问作答同一插入规则——补位
     # 启动时由执行体按 meta 分发 answer_approval 送达。仅看板卡（有卡 id）
-    # 参与；任务侧会话保持直送（specQ §5 边界不变）。
+    # 参与；任务侧会话保持直送（specQ §5 边界不变；直送前同样补声明看管，见下）。
     try:
         card_id = card["id"]
     except (KeyError, IndexError, TypeError):
         card_id = None
     if card_id is None:
+        # 送达前重声明看管（T7 评审 Important，控制器裁定 2026-10-10）：同上
+        # （提问腿）——任务会话池外化后，本直送分支同样需要先补声明再调 `/approval`。
+        _watch_before_delivery(sid)
         try:
             dshdriver.answer_approval(sid, approval_id, dsh_outcome)
         except Exception as e:                      # noqa: BLE001