@gavinc-cn/touchstone-dsh 0.1.0 → 0.2.0

package/board.py

@@ -283,11 +283,14 @@ def set_parent(project_id, card_id, parent_id):
     return None
 
 
-def move_card(project, card_id, target, block_text="", before_id=None):
+def move_card(project, card_id, target, block_text="", before_id=None,
+              merge_ack=False):
     """移列总入口（服务端仲裁）。返回 (card_dict, None) 或 (None, err_dict)。
 
-    err_dict 两种：{"error": "..."}（硬错误，列未变——含进 doing 起会话失败回滚原列）；
-    {"blocked": "parent-not-done"}（父任务拦截，列未变，前端弹确认）。
+    err_dict 三种：{"error": "..."}（硬错误，列未变——含进 doing 起会话失败回滚原列）；
+    {"blocked": "parent-not-done"}（父任务拦截，列未变，前端弹确认）；
+    {"merge_pending": {...}}（独立 worktree 卡进「已完成」且有提交没回流主分支，
+    列未变，前端弹「是否交给 agent 合并」，2026-10-07 批次）。
     queue 拦截不算错误：卡片落「正在开发」列排队占位（block_kind='queue'）入统一队列，正常返回。
     规则：doing 不可直接拖回 todo；离开 todo 清定时；doing→doing 同列拖放走
     手势映射（v2c T1，裁决 R10——before_id 不再丢弃、不再直接返回，force/停止/
@@ -307,6 +310,10 @@ def move_card(project, card_id, target, block_text="", before_id=None):
     即整体放弃本次移列并 400 报错，见 `_archive_card_sessions`）。
     2026-10-07 起本路径落列一律 `mark_unread=False`：拖列/按钮移列都是用户本人
     在看板上发起的操作，不是「用户没看见的状态更新」，不该由平台反过来提醒用户。
+    独立 worktree 卡进「已完成」的额外闸（2026-10-07 批次）：卡在独立工作树里开发
+    ⇒ 改动在 `ts/card-<id>` 分支上、主分支一无所知；`merge_ack=False`（默认）时先
+    查有没有待合并提交，有则返回 `{"merge_pending": ...}` **不动列**，由用户决定
+    「交给 agent 合并」还是「仅通过」（后者由前端带 `merge_ack=true` 再来一次）。
     """
     card = db.get_board_card(card_id)
     if card is None:
@@ -322,6 +329,13 @@ def move_card(project, card_id, target, block_text="", before_id=None):
         return _doing_gesture(project, card, before_id)
     if src == "doing" and target == "todo":
         return None, {"error": "doing 不可直接拖回 todo"}
+    # 待合并提交闸（2026-10-07 批次）：独立 worktree 卡进「已完成」前先问一句——
+    # 放在归档同步**之前**，因为这条分支要「列不动」地返回（先归档再问会把
+    # 会话归档了却没过卡，留下不一致状态）。
+    if target == "done" and src != "done" and not merge_ack:
+        pend = merge_pending(project, card)
+        if pend:
+            return None, {"merge_pending": pend}
     # 归档同步（2026-10-05）：进/出「已完成」先做归档面，失败即整体放弃本次移列
     # （硬失败 400 报前端，卡片列不变）。**归档先行**的理由：先落列再归档的话，
     # 失败回滚要连「已停会话/已出队/已改排序」一起退，代价与风险都大；先行失败
@@ -787,6 +801,34 @@ def _session_card_map(cards):
     return bound
 
 
+def _subagent_session(sid, origin=None):
+    """该会话是否 dsh **子代理会话**（占用豁免判据，2026-10-07）。
+
+    子代理是主会话的实现细节：它不构成项目外部占用（不建 ext 行、也不触发补投影）——
+    否则「一次派 8 个子代理」＝项目被占满、排队单元永不补位（实障：卡 870 排队
+    5 小时，成因即两条子代理会话的 ext 行）。
+
+    `origin` 显式传入时用调用方手上的值（`_ext_candidates` 已在快照行里）；
+    未传/为空＝未知（旧插件未上报）→ 回落 `sessparse.is_subagent` 的会话头读口
+    （磁盘，按 stamp 缓存）。两处都判不了＝False（按主会话处理：占用判定宁可多等，
+    不可误放行，与「断连=未知」同向）。
+    """
+    val = origin
+    if val is None:
+        try:
+            val = (dshevents.get(sid) or {}).get("origin") or ""
+        except Exception:
+            val = ""
+    if str(val or "") == "subagent":
+        return True
+    if str(val or ""):
+        return False                     # 明确上报了别的 origin（主会话）
+    try:
+        return sessparse.is_subagent("dsh", sid)
+    except Exception:
+        return False
+
+
 def _ext_candidates(project, cards):
     """项目活跃会话集合 → 占位目标/探测不明卡集（探测对象改造核，R15）。
 
@@ -833,6 +875,10 @@ def _ext_candidates(project, cards):
         sid = str(r.get("session_id") or "")
         if not sid or r.get("status") != "running":
             continue                         # 空闲/未知不构成占用
+        # 子代理会话不是外部占用（2026-10-07）：既不建行，也不进 unbound 触发投影
+        # （它本就不该有卡；旧插件未上报 origin 时回落会话头判定，见 _subagent_session）
+        if _subagent_session(sid, r.get("origin")):
+            continue
         # 只认本项目工作目录下的会话：dsh 会话池是宿主全局的，跨项目的在跑
         # 会话不能算到本项目头上（ext 行按项目工作目录归属）
         if os.path.abspath(str(r.get("cwd") or "")) != pdir:
@@ -903,7 +949,67 @@ def _recover_ext_rows(queued=()):
     return changed
 
 
-def _enter_doing(project, card, extra="", force=False, worktree=False):
+def refresh_ext_rows(reason="外部条目周期对账"):
+    """按项目活跃 ext 行的实况对账刷新（周期自检 / 启动补跑共用入口）。
+
+    对「有活跃 ext 行的项目」逐个跑 `_ext_refresh`（快照口径：中枢在线时以对齐过的
+    注册表为准——不在场即收口；未连接时返回 None＝保行，绝不把未知当空闲）。有行
+    变化即唤醒补位（前缀成员变化，时机③），无变化不空唤醒。返回是否有行变化。
+
+    与 `_recover_ext_rows` 的分工（2026-10-07 实障修复）：那个是**重启恢复**专用
+    （刷新面=有行项目 ∪ 有排队卡项目），执行点在 server 启动序里 `dshevents.start()`
+    之前 ⇒ 探测必然不可用、一律保行；本函数是**运行期兜底与启动补跑**——调和器的
+    逐卡探测（`_iw_once`）修好「在线但会话不在池」的口径后已能自动收口，本入口
+    覆盖「调和器未跑到/被 hold 语义挡住」的漏网行，也用于中枢首连后的启动补跑。
+
+    项目已删（行残留）走 `_finish_all_ext` 防御收口（同 recover 口径）。"""
+    changed = False
+    for pid in {row["project_id"] for row in waitq.active_ext_items()}:
+        proj = db.get_project(pid)
+        if proj is None:
+            if _finish_all_ext(pid, reason):
+                changed = True
+            continue
+        if _ext_refresh(proj):
+            changed = True
+    if changed and runner.INSTANCE is not None:
+        runner.INSTANCE.notify_busy_change()   # 前缀成员变化：唤醒排队单元重新挑选
+    return changed
+
+
+# 启动补跑等中枢首连的上限（秒）：dsh 宿主同机，正常对齐是毫秒级；给足抖动余量
+EXT_RECOVER_WAIT_SECONDS = 30.0
+
+
+def start_ext_recover_after_connect(timeout=EXT_RECOVER_WAIT_SECONDS):
+    """启动补跑线程：等中枢首连就绪后跑一次 ext 行对账（2026-10-07 实障修复）。
+
+    `board.recover()` 尾部的 `_recover_ext_rows` 执行在 server 启动序里
+    `dshevents.start()` **之前**（顺序硬约束不变）⇒ 那时探测必然「不可用」、按
+    「宁可多等」一律保行——上一进程留下的僵尸 ext 行（会话早已结束、行仍
+    running）会继续占位，**重启也救不回来**（实障：卡 870 排队 5 小时、项目 119
+    积 10 条僵尸行堵死调度）。本函数由 server 在 `dshevents.start()` 之后调用：
+    后台线程等首连（上限 timeout，不阻塞启动与端口绑定），就绪即跑一次
+    `refresh_ext_rows`（快照口径收口僵尸行 + 唤醒补位）。
+
+    未配置驱动（独立形态）/超时未就绪：直接结束——行保原样，等调和器与自检
+    线程接手（它们的收口口径同样不把未知当空闲）。返回线程对象供测试 join。
+    """
+    def _run():
+        try:
+            if not dshevents.wait_connected(timeout):
+                return                          # 未就绪：保行，交给运行期兜底
+            refresh_ext_rows("启动补跑")
+        except Exception as e:                  # noqa: BLE001 — 守护线程不 crash
+            print(f"[board] 启动补跑 ext 行对账异常: {e}", flush=True)
+
+    th = threading.Thread(target=_run, daemon=True, name="board-ext-recover")
+    th.start()
+    return th
+
+
+def _enter_doing(project, card, extra="", force=False, worktree=False,
+                 queue_worktree=False):
     """进 doing 统一入口（start 端点 / 拖入 doing / 定时开工共用）。
 
     force=true：跳过父依赖与排队直接起会话（用户自担风险），reason 标签按实参分
@@ -941,6 +1047,10 @@ def _enter_doing(project, card, extra="", force=False, worktree=False):
     已带 worktree 标记时**本条起跑路径整体转交 `_enter_doing_worktree`**——那条路
     不写 `wait_items` 行（不占项目运行位、不阻塞同项目其他单元），语义与失败收口
     见该函数 docstring；本函数其余分支保持原样（排队/force 直起一字未动）。
+
+    例外（2026-10-07 批次）：`queue_worktree=True` 时**不转交**，worktree 卡照常走
+    统一队列。唯一调用方是 `handoff_worktree_merge`（把合并任务交给 agent）——合并
+    要动主仓库工作区，必须与项目内其他单元串行，免排队语义在这里有害。
     """
     if _web_family(project) is None:
         # 退场族防呆（见 docstring）：不建行、不入队、不动列——直接明确报错
@@ -957,7 +1067,9 @@ def _enter_doing(project, card, extra="", force=False, worktree=False):
     # 「在新 worktree 中开始」（worktree=True），或该卡此前已被标记为 worktree 卡
     # （card.worktree 非空 ⇒ 打回续改/重试/再进开发列自动复用同一工作树）——
     # 一律交给 `_enter_doing_worktree`：起跑但不入统一队列（不写 wait_items 行）。
-    if worktree or (_card_opt(card, "worktree") or "").strip():
+    # queue_worktree=True（合并回交，2026-10-07）是唯一例外：走下面的排队路径，
+    # 合并要动主仓库工作区，必须与项目内其他单元串行。
+    if not queue_worktree and (worktree or (_card_opt(card, "worktree") or "").strip()):
         return _enter_doing_worktree(project, card, extra, force=force,
                                      want=bool(worktree))
     if card["column_key"] == "doing" \
@@ -1085,12 +1197,14 @@ def _enter_doing(project, card, extra="", force=False, worktree=False):
     return card_json(db.get_board_card(card["id"])), None
 
 
-def start_into_doing(project, card, extra="", force=False, worktree=False):
+def start_into_doing(project, card, extra="", force=False, worktree=False,
+                     queue_worktree=False):
     """start 端点专用：语义全部由 _enter_doing 承载（保留函数名，server 调用点不动）。
 
     worktree=True = 用户在下拉里选「🌿 在新 worktree 中开始」（2026-10-06 批次）。
+    queue_worktree=True = worktree 卡也走统一队列（合并回交，2026-10-07 批次）。
     """
-    return _enter_doing(project, card, extra, force, worktree)
+    return _enter_doing(project, card, extra, force, worktree, queue_worktree)
 
 
 # ---------- 独立 worktree 卡起跑（2026-10-06 批次） ----------
@@ -1214,26 +1328,30 @@ def _enter_doing_worktree(project, card, extra="", force=False, want=False):
 def worktree_preview(project, card):
     """卡片「在新 worktree 中开始」入口的预览（server 端点用，**不落盘**）：
 
-    返回 {supported, reason, path, branch, exists}——supported=False 时 reason 是
-    给用户看的中文原因（项目不是 git 仓库 / 卡片已有主会话，D10）；前端据此把
+    返回 {supported, reason, path, branch, exists, merge}——supported=False 时 reason
+    是给用户看的中文原因（项目不是 git 仓库 / 卡片已有主会话，D10）；前端据此把
     菜单项置灰并显示原因，避免用户点了必然失败的入口。
+    `merge`（2026-10-07 批次）= 待合并提交判定（`merge_pending`，None=无待合并）：
+    已经是 worktree 卡的卡片走本端点时前端据它决定「通过」要不要弹合并框。
     """
     branch = worktree.branch_for(card["id"])
+    pend = merge_pending(project, card)
     if (_card_opt(card, "worktree") or "").strip():
         # 已是 worktree 卡：续跑自动复用，无需再选（前端一般不再显示该入口）
         return {"supported": False, "reason": "该卡片已在独立 worktree 中运行",
                 "path": _card_opt(card, "worktree"), "branch": branch,
-                "exists": os.path.isdir(_card_opt(card, "worktree"))}
+                "exists": os.path.isdir(_card_opt(card, "worktree")),
+                "merge": pend}
     if (card["session_id"] or "").strip():
         return {"supported": False,
                 "reason": "该卡片已有主会话，不能切换到独立 worktree（请新建卡片）",
-                "path": "", "branch": branch, "exists": False}
+                "path": "", "branch": branch, "exists": False, "merge": pend}
     pv = worktree.preview(project, card["id"])
     if not pv["ok"]:
         return {"supported": False, "reason": pv["error"], "path": "",
-                "branch": branch, "exists": False}
+                "branch": branch, "exists": False, "merge": pend}
     return {"supported": True, "reason": "", "path": pv["path"],
-            "branch": pv["branch"], "exists": pv["exists"]}
+            "branch": pv["branch"], "exists": pv["exists"], "merge": pend}
 
 
 def cleanup_card_worktree(project, card):
@@ -1253,6 +1371,105 @@ def cleanup_card_worktree(project, card):
     return True, ""
 
 
+# ---------- worktree 改动回流主分支（「通过」时的待合并闸，2026-10-07 批次） ----------
+#
+# 需求（用户 2026-10-07）：独立 worktree 卡的改动在 `ts/card-<id>` 分支上，主分支
+# 一无所知；点「通过」时应当先看有没有待合并提交——没有就直接完成，有就把合并
+# 交给 agent（冲突只有 agent 能解），**平台自己不执行任何 git 合并命令**。
+#
+# 分工与边界：
+# - 平台（本模块）：判定 `ahead`（见 `merge_pending`）+ 生成指令 + 把卡片连同指令
+#   送回统一队列（`handoff_worktree_merge`）；不碰分支、不替用户决定合并结果。
+# - agent：在卡片会话里执行同步主分支、解冲突、回流合并（指令原文
+#   `build_merge_instruction`），干完这轮会话结束 ⇒ 卡片按既有流程自动回待审核；
+#   用户再点「通过」时 `ahead` 已为 0，直接进「已完成」。
+# - worktree 卡平时**免排队**（不占项目运行位，plan D1）；但合并要动主仓库工作区，
+#   必须与项目内其他单元串行 ⇒ 这条路径显式走统一队列（`queue_worktree=True`），
+#   卡片在开发列显示「排队中」，轮到才起会话。
+
+# 合并任务指令的段落标记：投给卡片会话的指令以它开头，`build_start_prompt` 据此
+# 走专用提示词（不套打回意见的「【修改意见】…请按修改意见继续完善」壳——那会让
+# agent 以为要改代码，而不是合并分支）。生产者=`build_merge_instruction`。
+MERGE_TASK_MARK = "【合并任务】"
+
+
+def merge_pending(project, card):
+    """「通过」前的待合并提交判定（只服务独立 worktree 卡）。返回 dict 或 None。
+
+    None = 无需询问（非 worktree 卡 / 工作树读不到 / 没有待合并提交）——三种情形
+    都按普通卡直接完成（用户 2026-10-07 约定：没有可合并的 commit 就直接进已完成；
+    工作树被用户删掉等读不到的情形拦下来只会卡住「通过」，故一并放行）。
+    有值 = 前端弹「是否交给 agent 合并」（列不动），字段：
+    {branch, target, ahead, behind, dirty, dirty_count, path}。
+    """
+    if not (_card_opt(card, "worktree") or "").strip():
+        return None
+    st = worktree.merge_status(project, card)
+    if not st["ok"] or st["ahead"] <= 0:
+        return None
+    return {"branch": st["branch"], "target": st["target"],
+            "ahead": st["ahead"], "behind": st["behind"],
+            "dirty": st["dirty"], "dirty_count": st["dirty_count"],
+            "path": st["path"]}
+
+
+def build_merge_instruction(project, card, st):
+    """生成交给 agent 的合并指令（原文即 prompt，见 `MERGE_TASK_MARK`）。
+
+    指令把两个路径都写死（工作树 / 主仓库）——agent 的 cwd 是工作树，回流的
+    `git -C <主仓库> merge` 是跨目录操作，不写清楚它会去猜（plan D7 的教训）。
+    合并口径按用户 2026-10-07 约定：**先同步主分支最新代码，再回流；尽量 ff，
+    不能 ff 才普通 merge**；冲突由 agent 解，解不了必须 abort 回退，不留半合并态。
+    """
+    main = (project["project_dir"] or "").strip()
+    branch, target, path = st["branch"], st["target"], st["path"]
+    dirty = int(st.get("dirty_count") or 0)
+    head = [f"{MERGE_TASK_MARK}把卡片 #{card['id']} 的独立 worktree 改动合并回主分支。",
+            f"工作树：{path}（分支 {branch}，你的会话工作目录）",
+            f"主仓库：{main}（主分支 {target}）",
+            f"待合并提交：{st['ahead']} 个"]
+    if dirty:
+        head.append(f"工作树当前有 {dirty} 处未提交改动，第一步先提交它们。")
+    steps = [
+        "步骤：",
+        f"1. 提交工作树里的未提交改动（有的话），提交信息带上卡片号 #{card['id']}。",
+        f"2. 同步主分支最新代码：若项目有远端，先在主仓库执行"
+        f" `git -C {main} fetch`（无远端会失败，忽略即可）；然后在工作树执行"
+        f" `git -C {path} merge {target}`（主分支已合入过就跳过）。"
+        f"冲突在工作树内解决，并跑相关测试确认。",
+        f"3. 回流合并：在主仓库执行 `git -C {main} merge --ff-only {branch}`"
+        f"（能快进就快进，主分支保持线性）；若因主分支又前进而无法快进，"
+        f"改用 `git -C {main} merge {branch}` 生成合并提交，冲突自己解决。",
+        f"4. 不要 push，不要 rebase/重置主分支，不要改动与本卡无关的文件。",
+        f"5. 结束后用一两句话报告：合并是否成功、目标分支名、合并后的 HEAD 短 sha；"
+        f"失败就说明卡在哪一步。",
+        f"若第 2/3 步冲突无法解决：`git -C {path} merge --abort`（工作树侧）或"
+        f" `git -C {main} merge --abort`（主仓库侧）回退，"
+        f"绝不留半合并状态，并在报告里说明卡在哪里。",
+    ]
+    return "\n".join(head + [""] + steps)[:PROMPT_MAX]
+
+
+def handoff_worktree_merge(project, card):
+    """把「合并 worktree 改动回主分支」交给卡片会话（回统一队列排队）。
+
+    返回 (card_dict, None) 或 (None, err_dict)。平台**只投递不执行**：判定有
+    待合并提交后，把 `build_merge_instruction` 的指令当打回意见送进统一队列
+    （`queue_worktree=True` 让 worktree 卡走排队路径而不是免排队直起）——轮到该卡
+    时才起会话，agent 干完这轮卡片自动回待审核，用户再点「通过」即完成。
+    前置校验：无待合并提交 / 无主会话（没会话就没上下文可投递）直接报错。
+    """
+    if not (card["session_id"] or "").strip():
+        return None, {"error": "该卡片尚无主会话，无法交给 agent 合并"}
+    st = worktree.merge_status(project, card)
+    if not st["ok"]:
+        return None, {"error": f"无法判定待合并提交：{st['error']}"}
+    if st["ahead"] <= 0:
+        return None, {"error": "该卡片没有待合并的提交（可直接通过）"}
+    instruction = build_merge_instruction(project, card, st)
+    return start_into_doing(project, card, instruction, queue_worktree=True)
+
+
 def dequeue_start(project, card):
     """runner 拾到排队卡片后的起跑（队列已保证项目串行位）。
 
@@ -1367,7 +1584,12 @@ def build_start_prompt(project, card, extra="", sid=""):
     resume）传其 sid，否则传空串——无可续会话自动回落全量，避免给无上下文的
     新会话发「继续」。
     卡上标题/描述即便有编辑一并忽略（用户约定：有会话只发「继续」）。
+    合并回交指令（extra 以 MERGE_TASK_MARK 开头，2026-10-07 批次）：**原文直发**，
+    不套「【修改意见】…请按修改意见继续完善」壳——那是打回改代码的语义，合并
+    任务要的是执行 git 步骤，混在一起会让 agent 跑偏。
     """
+    if extra.startswith(MERGE_TASK_MARK):
+        return extra[:PROMPT_MAX]
     if sid:
         return build_continue_prompt(extra)
     return build_task_prompt(project, card, extra)
@@ -1787,10 +2009,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
     统一队列，项目忙（同项目有任务/卡片会话在跑）时按入队顺序等待，项目空闲才
@@ -1801,10 +2026,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)
@@ -1813,12 +2035,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 ""),
@@ -1826,19 +2048,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
@@ -1846,25 +2068,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)
@@ -1990,6 +2266,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）。
     """
@@ -2003,10 +2288,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):
@@ -2469,10 +2769,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)
@@ -2541,9 +2917,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:
@@ -3029,18 +3416,37 @@ 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   # 描述上限（防一次长提问把看板负载撑大）
 
+# 已跑过「存量子代理卡软删收口」的项目 id（`sync_sessions` 尾巴，2026-10-07）。
+# 枚举侧过滤后不会再产生子代理卡，故每项目一轮足够；也保证用户从回收站还原后
+# 不被反复软删（进程重启后重建空集，重跑一轮幂等）。
+_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:
@@ -3057,42 +3463,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
 
@@ -3100,11 +3610,20 @@ def _sync_card_follow(card, item, sid):
 def sync_sessions(project):
     """自动同步项目 agent 会话到看板。返回新建卡 id 列表。
 
-    新建卡（origin='sync'）：标题/描述=主会话第一次用户提问（首行→标题、其余→
-    描述；首问未落盘时回落会话标题、再回落 sid 短码，落盘后由本函数补齐），绑定
-    主会话，busy→doing / 空闲→review；存量 sync 卡：首问补齐标题/描述（用户改过
-    名的不动）+ dsh 族列映射移交调和器（事件驱动），此处仅归档→done（人工拖到
-    todo/blocked/done 后不再自动搬）；会话存储被删的 sync 卡自动进 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 卡不占 runner 项目占用（外部会话平台控制不了，防堵死统一队列）。
     """
     if not settings_of(project["id"]).get("sync_sessions", True):
@@ -3124,6 +3643,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"]
@@ -3132,9 +3653,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 判定，直接落「已完成」
@@ -3156,13 +3684,68 @@ def sync_sessions(project):
                 want = "done" if archived else None
                 if want and c["column_key"] != want:
                     db.update_board_card(c["id"], column_key=want)
+    # —— 存量子代理卡收口（2026-10-07 实障修复）——
+    # 新口径下 `sessparse.list_sessions` 已过滤子代理会话（不再建新卡），但历史版本按
+    # 子代理会话建出的卡还留在板面上（实测全机 72 张、70 张永留「待审核」——子代理
+    # 不会被归档、存储也不会被删，归档同步与下面「存储被删→done」两条规则都够不着）。
+    # 这里**软删进回收站**（可还原；不删会话文件、不动会话与依赖）。两条边界：
+    #   ① 只认 origin='sync' 自动卡——用户自建卡即便绑了子代理会话也是用户的东西，不碰；
+    #   ② 每项目只跑一轮——A 之后不会再产生这类卡，一轮足够；用户从回收站**还原**后
+    #      同一进程内不会被反复软删（尊重显式操作），进程重启后重跑一轮（幂等）。
+    if project["id"] not in _SYNC_SUBAGENT_SWEPT:
+        dropped = 0
+        for c in cards:
+            sids = set(_card_sids(c))
+            if c["origin"] != "sync" or not sids or _has_active_run(c["id"]):
+                continue
+            if any(sessparse.is_subagent(family, s) for s in sids):
+                db.trash_board_card(c["id"])
+                dropped += 1
+        _SYNC_SUBAGENT_SWEPT.add(project["id"])
+        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"]):
             continue
-        sids = set(json.loads(c["sessions"] or "[]"))
-        if c["session_id"]:
-            sids.add(c["session_id"])
+        sids = set(_card_sids(c))
         if sids and not any(sessparse.session_exists(family, s) for s in sids):
             db.update_board_card(c["id"], column_key="done")
     return created
@@ -3188,6 +3771,42 @@ def _has_active_run(card_id):
         return card_id in _RUNS
 
 
+def _wt_in_flight(card_id):
+    """worktree 直起窗口在场判定（`_WT_STARTING`，见 `_enter_doing_worktree`）。
+
+    worktree 卡不落 c: 行（「不进统一队列」语义），起跑窗口只能靠这个进程内
+    登记集表征：`_wt_start_begin` 在入口登记、`finally` 在 `start_card`（内部
+    登记 `_RUNS`）之后才 `_wt_start_end` 释放 ⇒ 在场区间恰好覆盖起跑窗口。"""
+    with _WT_STARTING_LOCK:
+        return card_id in _WT_STARTING
+
+
+def _starting_window(card_id, starting_ids=None):
+    """卡片是否处于「起跑窗口」：占位保护已解除，但会话尚未证实起跑。
+
+    窗口的成因（2026-10-07 卡 902/903 实障）：`dequeue_start` / `_enter_doing_worktree`
+    先落 `doing` + 清 `block_kind='queue'` 占位，**之后**才起会话；而 `_RUNS`
+    在 `_start_web` 末尾（create_session → 会话默认值 → turn 基线 → `dsh_send`
+    全跑完）才登记。这段 1～2 秒里 dsh 侧读到的 busy=False 是「turn 还没开始」，
+    不是「会话已结束」——调和器若据此按忙/闲搬列，正在起跑的卡会被搬去
+    「待审核」（用户约定：运行中的卡都在「正在开发」列），且随后 `has_run`
+    早退不再自愈，卡片整轮滞留错列。
+
+    三条起跑路径各自的窗口表征：
+      - 统一队列路径（含 force 落表行）：c: 行 `state=starting`（拾取 →
+        `card_started` 置 running）；
+      - worktree 直起路径（无 c: 行）：`_WT_STARTING` 在场（见 `_wt_in_flight`）；
+      - 已登记在管条目（`_RUNS`）＝已证实起跑，**一律不算窗口**——正常忙/闲
+        映射（含「送达恢复」那种 running 行而无在管条目的形态：会话结束要能
+        落回待审核，这条口径不能被本判据吞掉）。
+    `starting_ids` 为调用方的批量读口预取值（`waitq.starting_card_ids()`，
+    调和器一轮一次），缺省自行单查（`_iw_apply` 写前复核用）。"""
+    if _has_active_run(card_id):
+        return False
+    ids = waitq.starting_card_ids() if starting_ids is None else starting_ids
+    return card_id in ids or _wt_in_flight(card_id)
+
+
 def run_pid(card_id):
     """在管卡会话子进程 pid（无运行条目/web 族无 proc → None；R11④ 进程存活
     裁活的写入侧数据源，落行 evidence.pid）。"""
@@ -3198,6 +3817,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`
@@ -3236,7 +3876,9 @@ def _iw_interaction(family, proj, sid, busy_hint=None):
     交互卡片（选项+描述+自定义输入 / 批准-拒绝）。
     options 逐项 = `_dsh_option` 归一后的 `{id, label, description}`（2026-10-04
     起带选项描述，修 #791）；qid 取自插件的提问标识（认领中的提问非空 ⇒
-    answerable=True ⇒ 会话窗渲染单选/多选框 + 「提交」）。
+    answerable=True ⇒ 会话窗渲染单选/多选框 + 「提交」）。2026-10-06 修 #837 起
+    dsh Web GUI 同时弹同一个提问框（插件的原生作答通道）：两侧都能答、先答者胜，
+    GUI 先答时平台迟到作答拿 accepted=false（上层按 40405 收口）。
     异常/无 sid 返回 None（该轮跳过，不误移不报错）。
     单族化后只有 dsh_plugin：读 `dshevents` 注册表（busy 来自 agent/status
     事件，挂起来自 `user-questions/request` waterfall 与 `approval/asked`
@@ -3257,6 +3899,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,
@@ -3308,6 +3956,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": ""},
@@ -3320,7 +4248,8 @@ _RECONCILE_FIELDS = {
 
 
 def _reconcile_action_for(family, card, r, has_run=False, live_msg=False,
-                          stop_recent=False, archived=None):
+                          stop_recent=False, archived=None, starting=False,
+                          orphan_hold=False):
     """调和状态机（纯函数，单测覆盖）：按会话实况 r（pending/busy）、归档态
     archived 与当前卡状态得出动作，action ∈
     {'block'（进阻塞+interaction）,
@@ -3334,13 +4263,26 @@ 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 拥有（防与轮收尾抢写）。
+    todo/done 终态不动；平台在管运行（has_run=True）的卡只做交互 block/recover、
+    busy/空闲流转归 _finish_run 拥有（防与轮收尾抢写）——**唯一例外**是卡片在
+    「待审核」而会话确实在跑（起跑窗口误判的遗留形态）→ 归位 doing，见
+    `starting` 段与 2026-10-07 批次说明。
+    `starting`（起跑窗口，判据见 `_starting_window`）：占位已清、会话尚未证实
+    起跑——此窗口内 busy=False 是「turn 还没开始」而非「已结束」，**不做忙/闲
+    列映射**，只防御性放行 block（2026-10-07 修卡 902/903：此前正在起跑的
+    doing 卡被误判空闲搬去「待审核」，`_RUNS` 登记后早退不再自愈，卡片整轮
+    滞留错列——用户约定：运行中的卡都在「正在开发」列）。
     queue 排队占位卡只放行 block（2026-09-10 修复）：占位不等于会话已停——
     运行中卡交互阻塞解除后落 doing/queue 排队等串行位（_recover_to_doing），
     dsh 会话照跑、稍后仍可能再提问；此前 queue 卡被一律跳过，这类提问
@@ -3371,7 +4313,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                      # 等待用户回答：维持阻塞态
@@ -3380,6 +4324,12 @@ def _reconcile_action_for(family, card, r, has_run=False, live_msg=False,
         return "to_doing" if running else None
     if card["block_kind"] == "queue":
         return "block" if pending else None
+    if starting:
+        # 起跑窗口（`_starting_window`）：占位已清、会话尚未证实起跑——此时的
+        # busy=False 是「turn 还没开始」而非「已结束」，**不做忙/闲列映射**
+        # （否则 doing 卡被判空闲搬去待审核；2026-10-07 卡 902/903 实障）。
+        # 窗口内提问不可能出现（prompt 还没下发），仅作防御性放行。
+        return "block" if pending else None
     if pending:
         if card["column_key"] == "blocked" and card["block_kind"] == "interaction":
             return None                      # 已在交互阻塞，等待作答
@@ -3395,6 +4345,13 @@ def _reconcile_action_for(family, card, r, has_run=False, live_msg=False,
     if card["column_key"] == "blocked" and not card["block_kind"]:
         return "to_doing" if (running or has_run) else "to_review"
     if has_run:
+        # 在管运行：列流转归 _finish_run（防与轮收尾抢写）。唯一例外——卡片在
+        # 「待审核」而会话确实在跑：只可能来自起跑窗口内的误判（本批次修复前的
+        # 遗留形态：窗口内被搬去待审核、`_RUNS` 登记后早退不再自愈），按用户
+        # 约定「运行中的卡都在正在开发列」归位。stop_recent 宽限内不搬：刚被
+        # 平台停过会话（停止/拖离开发列）的卡，busy 可能是 abort 生效前的残留。
+        if card["column_key"] == "review" and running and not stop_recent:
+            return "to_doing"
         return None                          # 在管运行：列流转归 _finish_run
     if card["column_key"] == "doing":
         return None if running else "to_review"
@@ -3405,7 +4362,8 @@ def _reconcile_action_for(family, card, r, has_run=False, live_msg=False,
 
 def _iw_apply(family, card, action, r):
     """执行调和动作（read-verify-write）。写库前用 get_board_card 重读当前行，
-    并重评 has_run/live_msg/stop_recent、重跑状态机：仅当动作仍成立才写库；
+    并重评 has_run/live_msg/stop_recent/起跑窗口（`_starting_window`）、重跑状态机：
+    仅当动作仍成立才写库；
     否则跳过——保护用户手动拖卡/其他写者不被调和窗口内的旧判定覆盖
     （事件快照到落库之间卡状态可能已变/已删；live_msg 实时重取
     ——消息单元刚结束/被取消时状态机结论可能翻转为不动；stop_recent 实时
@@ -3423,9 +4381,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 "")) != action:
+                             dshevents.archived(cur["session_id"] or ""),
+                             _starting_window(cur["id"]),
+                             orphan) != action:
         return                    # 状态已变：跳过，不写库
     if action == "to_done":
         # dsh 侧归档 → 卡片进「已完成」（2026-10-05 反向规则）：走容器迁移原语收口
@@ -3548,11 +4510,15 @@ 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)
     ext_changed = False
     seen_sids = set()      # 本轮在场的归档判定 sid（_ARCH_SEEN 有界清理用）
+    # 起跑窗口批量读口（一轮一次；逐卡点查会成 N+1，见 `_starting_window`）
+    starting_ids = waitq.starting_card_ids()
     for proj in db.list_projects_all():
         if proj["archived"]:
             continue
@@ -3592,15 +4558,44 @@ 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:
-                    if not _platform_holds(card["id"]):
+                    # 实况读不到：两种语义必须分开（2026-10-07 实障修复，卡 870）——
+                    # ① 中枢**断连**＝真未知：保行（宁多等不可误放行，原口径）；
+                    # ② 中枢**在线**而注册表无此 sid ＝ 该会话已不在 dsh 会话池
+                    #    （`session/disposed` 摘条目，或重连对齐时被 `/live` 快照
+                    #    覆盖掉）⇒ 外部会话已结束：不 hold，交本轮
+                    #    `_ext_stale_finish` 按「不在目标集」收口。
+                    # 旧口径把两者混为一谈，一律 hold 保行——子代理会话留下的 ext
+                    # 行因此永久占位（项目常驻「有外部会话在跑」⇒ 永不补位，实障
+                    # 里卡 870 排队 5 小时、项目 119 积 10 条僵尸行）。
+                    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）不算占用（豁免面②：挂起即出队，不建行）；平台
                 # 持有者（活跃 c: 行/在管条目）自占前缀位，不建行（防 ext:/c: 双计）。
                 if r.get("busy") and not r.get("pending") \
-                        and not _platform_holds(card["id"]):
+                        and not _platform_holds(card["id"]) \
+                        and not _subagent_session(sid, r.get("origin")):
                     ext_busy[card["id"]] = sid
                 if _has_active_run(card["id"]):
                     # 平台在管运行卡：行心跳 + 证据（v3c：证据迁行，直调；
@@ -3613,9 +4608,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)
+                                               _stop_recent(card["id"]), arch,
+                                               _starting_window(card["id"],
+                                                                starting_ids),
+                                               orphan)
                 if action:
                     _iw_apply(fam, card, action, r)
             except Exception:
@@ -3646,6 +4648,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):
@@ -3821,10 +4829,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:
@@ -4036,7 +5051,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": ...}, ...]（前端逐题收集；
@@ -4115,7 +5132,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):
@@ -4124,6 +5141,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）；
             # 驱动调用失败（网络/序列化/提问已失效等）均须落到前端
@@ -4144,7 +5166,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 ""
@@ -4172,12 +5195,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