@gavinc-cn/touchstone-dsh 0.1.0 → 0.2.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@gavinc-cn/touchstone-dsh",
-  "version": "0.1.0",
-  "description": "Touchstone 自动化测试平台的 dsh 插件（自包含）: Node 薄壳托管 Python 后端 + /touchstone 前缀反代 + 进程内 agent 驱动, 浏览器半经 exports[\"./client\"] 提供侧栏入口与全屏面板; 包内附完整平台源码与预构建插件前端",
+  "version": "0.2.0",
+  "description": "AI-agent-driven automated testing platform for DeepSeek Harness (dsh): Markdown case library, bug reports, per-project serial queue, development board and built-in load testing.",
   "license": "MIT",
+  "author": "Touchstone contributors",
   "type": "module",
   "main": "./dsh-plugin/lib/index.js",
   "exports": {
@@ -72,5 +73,9 @@
     "testing",
     "automation",
     "agent"
-  ]
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
 }

package/requirements.txt

@@ -4,6 +4,7 @@ zstandard>=0.25.0
 # 飞书开放平台 REST（M2 入站：回复/补丁/bot 信息；tenant_access_token 自管，2h-5min 刷新）
 requests>=2.31
 # 飞书 ws 长连接（M2 入站事件 im.message.receive_v1；仅承担长连接，REST 走 requests）
-lark-oapi>=1.3.0
+# ≥1.5.5：M5 配置自动化用 lark_oapi.register_app 做「扫码一键建应用」（低版本无此入口）
+lark-oapi>=1.5.5
 # Windows 原生运行：进程树终止/PID 探活/端口归属（platcompat Windows 分支懒加载，Linux 运行时不导入）
 psutil>=5.9.0

package/runner.py

@@ -2462,6 +2462,17 @@ def start_unit_selfcheck(interval=SELFCHECK_INTERVAL, min_age=SELFCHECK_MIN_AGE,
                     # 等下个外部事件会让排队单元无谓停滞一个周期以上）
                     with inst._cond:
                         inst._cond.notify_all()
+                # 外部条目（ext 行）周期对账（2026-10-07 僵尸占用修复的兜底入口）：
+                # 调和器逐卡探测已修好「中枢在线、会话已不在 dsh 池」的口径
+                # （见 `board._iw_once`）；本拍覆盖「调和器线程未跑到 / 被保守
+                # hold 语义挡住」的漏网行——否则僵尸 ext 行永久占位、项目永不
+                # 补位（实障：卡 870 排队 5 小时）。中枢未连接时 `_ext_refresh`
+                # 收敛为 None＝保行（绝不把未知当空闲）；行有变化时唤醒补位，
+                # 异常只打一行、不打断自检线程。
+                try:
+                    board.refresh_ext_rows("外部条目周期对账")
+                except Exception as e:      # noqa: BLE001 — 同兜底口径
+                    print(f"[waitq-selfcheck] 外部条目对账异常: {e}", flush=True)
                 n = waitq.prune_finished()      # 周期尾部：终态等待项回收（R14）
                 if n:
                     print(f"[waitq-selfcheck] 终态等待项回收 {n} 条", flush=True)

package/server.py

@@ -17,6 +17,7 @@ runner.py（任务轮次执行）、prompts.py（轮次 prompt）。
 
 import base64
 import collections
+import faulthandler
 import json
 import os
 import re
@@ -31,6 +32,12 @@ import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import parse_qs, quote, unquote
 
+# 原生崩溃取证（2026-10-09）：本进程 2026-10-08 21:48 在插件形态下两次被 SIGSEGV 带走
+# （薄壳只留一行 `sig=SIGSEGV`，无任何 Python 栈）。faulthandler 常开：SIGSEGV/SIGABRT 等
+# 致命中止时把**各线程的 Python 栈**打印到 stderr ⇒ 插件形态落 `<库目录>/plugin-backend.log`
+# （薄壳逐行落盘）、独立形态落 `.run/server.log`。零成本、不改变任何行为。
+faulthandler.enable()
+
 import auth
 import board
 import builtin_assets
@@ -375,6 +382,29 @@ def _board_session_running(owner_cid, proj, sid):
     return board.web_session_busy(proj, sid)
 
 
+def _session_owned(sid):
+    """会话归属（会话端点 meta.owned；C 批 T8，2026-10-10）：**三态**返回。
+
+    - `True`  = 平台自持（驱动池内会话）：平台的停止/中断本来就有效，前端照现状渲染；
+    - `False` = 外部会话（用户在 dsh GUI 里直跑/接管）：轮次由 dsh GUI 持有，平台停不了，
+                前端据此出「外部会话」提示条并把「停止」置灰；
+    - `None`  = 注册表未知（未连接 / 热重载后 /live 未对齐 / 没见过该 sid）：前端
+                **按「池内」渲染**，与现状一致——「未知 ≠ 外部」是本批统一判定阶梯，
+                绝不据不可信快照反向推断成外部会话。
+
+    判定阶梯与投递前置闸 `chat._external_preflight` 的第 ②③④ 步逐条对齐（未知放行、
+    不可信快照放行、owned 为真放行，其余才是外部）。
+
+    为什么不是 `bool(...)`：外部会话上报的也是 `owned:false`，与「注册表未知」的兜底
+    值撞车——布尔下发会让断连/未对齐窗口里的池内会话被误判成外部（误出提示条，还误
+    停用「停止」/「取消排队」）。故未知一律下发 `None`，把「未知 ≠ 外部」落进线上格式。
+    """
+    st = dshevents.get(sid)
+    if st is None or not dshevents.aligned():
+        return None
+    return bool(st.get("owned"))
+
+
 def _session_permission_mode(state):
     """会话级权限档（会话窗「权限」控件的数据源，2026-10-04 修恒置灰）。
 
@@ -453,6 +483,7 @@ PUBLIC_PAGES = {"/login"}
 
 # 「首次登录强制改密」白名单：must_change_pw=1 的账号只放行这三个端点，其余 API 一律 403
 # （2026-10-02：未设 TS_ADMIN_PASSWORD 时种子口令改为随机生成，登录后必须先改密）
+# 2026-10-08 增例外：dsh 插件形态的免登信任头路径**整体跳过**此门（见 _must_change_pw_blocked）
 MUST_CHANGE_PW_ALLOW = ("/api/auth/me", "/api/auth/change_password", "/api/auth/logout")
 
 # 压测指标 SSE 首次连接的回放行数上限（2026-09-19 压测面板重构批次）：
@@ -1031,6 +1062,16 @@ class Handler(BaseHTTPRequestHandler):
         if path == "/api/me/feishu/slash-commands":
             self._api_me_feishu_slash_set(body)
             return
+        if path == "/api/me/feishu/provision":
+            self._api_me_feishu_provision_set(body)
+            return
+        if path == "/api/me/feishu/doctor":
+            self._api_me_feishu_doctor(body)
+            return
+        if path == "/api/me/feishu-hook/apply":
+            # 项目推送绑定批量应用（设置页「同时应用到我的全部项目」，2026-10-10）
+            self._api_me_feishu_hook_apply(body)
+            return
         m = re.match(r"^/api/admin/users/(\d+)$", path)
         if m:
             self._api_admin_update_user(int(m.group(1)), body)
@@ -1086,6 +1127,11 @@ class Handler(BaseHTTPRequestHandler):
         if m:
             self._api_board_card_action(int(m.group(1)), int(m.group(2)), m.group(3), body)
             return
+        # worktree 改动回流：把合并任务交给卡片会话（回统一队列排队，2026-10-07 批次）
+        m = re.match(r"^/api/projects/(\d+)/board/cards/(\d+)/worktree/merge$", path)
+        if m:
+            self._api_board_card_worktree_merge(int(m.group(1)), int(m.group(2)))
+            return
         # 卡片「已查看」（2026-10-07 批次）：前端打开卡片详情时调用，清「有更新」标记
         m = re.match(r"^/api/projects/(\d+)/board/cards/(\d+)/viewed$", path)
         if m:
@@ -1271,6 +1317,8 @@ class Handler(BaseHTTPRequestHandler):
             self._api_me_feishu_outbox()
         elif path == "/api/me/feishu/slash-commands":
             self._api_me_feishu_slash_get()
+        elif path == "/api/me/feishu/provision":
+            self._api_me_feishu_provision_get()
         elif path == "/api/admin/users":
             self._api_admin_list_users()
         elif path == "/api/admin/rag":
@@ -1526,11 +1574,18 @@ class Handler(BaseHTTPRequestHandler):
         self.wfile.write(body)
 
     def _api_change_password(self):
+        """改密。插件形态（免登信任头）下**不校验原口令**（2026-10-08）。
+
+        为什么：插件形态首装的随机一次性口令只印在启动横幅里（薄壳曾整段丢弃），
+        存量库的旧口令用户也可能不知道——要求原口令等于把面板锁死。信任头本就等价
+        admin 全权（_current_user），这里放行不新增任何权限面。
+        """
         user = self._current_user()
         data = self._read_json() or {}
         old_pw = _pw_str(data.get("old_password"))
         new_pw = _pw_str(data.get("new_password"))
-        if not auth.verify_password(old_pw, user["pass_hash"], user["salt"]):
+        if not self._trusted_admin_request() and \
+                not auth.verify_password(old_pw, user["pass_hash"], user["salt"]):
             self._respond(400, '{"error":"原密码错误"}'.encode("utf-8"),
                           "application/json; charset=utf-8")
             return
@@ -1678,11 +1733,17 @@ class Handler(BaseHTTPRequestHandler):
 
     def _api_me_feishu_cfg_get(self):
         """当前用户飞书配置读取（所有用户可访问，各看各的）：
-        webhook 打码、secret 只回布尔 + 本人入站长连接状态。"""
+        webhook 打码、secret 只回布尔 + 本人入站长连接状态。
+
+        `push_enabled` = 推送总控（2026-10-10 新增，默认 true）——与旧 `enabled`
+        （只管「未单独设置的项目按默认事件推送」那条回落腿 + 入站连接）是两个开关，
+        前端把两者分别渲染并各自加文案说明。"""
         user = self._current_user()
         cfg = feishu.user_config(user["id"])
         self._respond(200, json.dumps({
             "enabled": bool(cfg.get("enabled", True)),
+            # 缺键按开回显，与 feishu.notify_events 的判定口径一致（存量配置零迁移）
+            "push_enabled": bool(cfg.get("push_enabled", True)),
             "default_webhook": self._mask_webhook(cfg.get("default_webhook", "")),
             "has_default_secret": bool(cfg.get("default_secret")),
             "base_url": cfg.get("base_url", ""),
@@ -1694,24 +1755,56 @@ class Handler(BaseHTTPRequestHandler):
         }, ensure_ascii=False).encode("utf-8"), "application/json; charset=utf-8")
 
     def _api_me_feishu_cfg_set(self, body):
-        """当前用户飞书配置更新：字段缺省=不改，显式空串=清除
-        （前端对未编辑的 secret/webhook 输入框不下发该键，防误清）。
-        应用凭据齐全时尝试拉起本用户入站长连接：首次配置免重启即时生效；
-        已在运行的（变更凭据）为幂等 no-op，需重启站点重建。inbound_started 供前端提示。"""
+        """当前用户飞书配置更新（业务在 feishu.save_user_config：字段缺省=不改、
+        显式空串=清除；凭据齐全时拉起入站长连接并**即时快检**）。
+        响应 = 既有字段 + verify（快检结果；凭据不全时 null）——前端据此即时提示对错。"""
         user = self._current_user()
-        cfg = feishu.user_config(user["id"])
-        if "enabled" in body:
-            cfg["enabled"] = 1 if body["enabled"] else 0
-        for key in ("default_webhook", "default_secret", "base_url",
-                    "app_id", "app_secret"):
-            if key in body:
-                cfg[key] = str(body[key] or "").strip()
-        db.set_feishu_user_cfg(user["id"], cfg)
-        started = feishu.start_inbound_for(user["id"])
+        out = feishu.save_user_config(user["id"], body)
         self._respond(200, json.dumps(
-            {"ok": True, "inbound_started": bool(started)},
+            {"ok": True, **out},
             ensure_ascii=False).encode("utf-8"), "application/json; charset=utf-8")
 
+    def _api_me_feishu_provision_get(self):
+        """扫码建应用流程现状（设置页轮询口，只读）：能力/总闸/状态/确认链接/步骤。"""
+        user = self._current_user()
+        self._respond(200, json.dumps(feishu.provision_status(user["id"]),
+                                      ensure_ascii=False).encode("utf-8"),
+                      "application/json; charset=utf-8")
+
+    def _api_me_feishu_provision_set(self, body):
+        """扫码建应用四动作（全部返回 200 + 摘要，页面据此渲染引导；非法 action 400）：
+        start=发起（force 覆盖已有应用）/ cancel=取消 / apply=补齐机器人能力+权限+
+        长连接订阅+事件+回调 / publish=提交发布（版本号缺省自动递增）。"""
+        user = self._current_user()
+        action = str(body.get("action") or "")
+        uid = user["id"]
+        if action == "start":
+            out = feishu.provision_start(uid, force=bool(body.get("force")))
+        elif action == "cancel":
+            out = feishu.provision_cancel(uid)
+        elif action == "apply":
+            out = feishu.provision_apply(uid)
+        elif action == "publish":
+            out = feishu.provision_publish(uid,
+                                           version=str(body.get("version") or "") or None,
+                                           remark=str(body.get("remark") or ""),
+                                           changelog=str(body.get("changelog") or ""))
+        else:
+            self._respond(400, json.dumps(
+                {"error": "action 仅支持 start / cancel / apply / publish"},
+                ensure_ascii=False).encode("utf-8"),
+                "application/json; charset=utf-8")
+            return
+        self._respond(200, json.dumps(out, ensure_ascii=False).encode("utf-8"),
+                      "application/json; charset=utf-8")
+
+    def _api_me_feishu_doctor(self, body):
+        """配置自检（八项）：只读为主；send_probe=true 时额外发一条测试消息（60s 频控）。"""
+        user = self._current_user()
+        out = feishu.doctor(user["id"], send_probe=bool(body.get("send_probe")))
+        self._respond(200, json.dumps(out, ensure_ascii=False).encode("utf-8"),
+                      "application/json; charset=utf-8")
+
     def _api_me_feishu_outbox(self):
         """当前用户的最近投递记录（target 打码——URL 本身含 token 即凭据）。"""
         user = self._current_user()
@@ -1965,6 +2058,58 @@ class Handler(BaseHTTPRequestHandler):
                            ",".join(cur_events), 1 if cur_enabled else 0)
         self._respond(200, b'{"ok":true}', "application/json; charset=utf-8")
 
+    def _api_me_feishu_hook_apply(self, body):
+        """项目推送绑定**批量应用**（设置页「同时应用到我的全部项目」，2026-10-10）。
+
+        把一份配置写进当前用户**本人的全部未归档项目**（归档项目不再产生推送，
+        故不纳入；跨用户项目一律不碰——多用户隔离红线）。字段语义与单项目端点
+        `_api_feishu_hook_set` 完全对齐：**缺省=不改该字段**，因此前端只在输入框
+        有内容时才带 `webhook_url`/`webhook_secret` 键 ⇒「留空 = 各项目保留原值」，
+        只统一「启用推送」与事件勾选；显式传空串=清除。`events` 走白名单校验。
+
+        返回 {ok, updated, archived_skipped, projects}：projects = 实际写入的项目名
+        （供前端回执列出「改了什么」）。
+        """
+        user = self._current_user()
+        req_events = None
+        if "events" in body:
+            req_events = body["events"]
+            if not isinstance(req_events, list) \
+                    or not set(req_events) <= set(feishu.FEISHU_EVENTS):
+                self._respond(400, '{"error":"events 含非法事件"}'.encode("utf-8"),
+                              "application/json; charset=utf-8")
+                return
+        names, skipped = [], 0
+        for proj in db.list_projects(user["id"]):
+            if proj["archived"]:
+                skipped += 1
+                continue
+            row = db.get_feishu_hook(proj["id"])
+            cur_url = (row["webhook_url"] if row is not None else "")
+            cur_secret = (row["webhook_secret"] if row is not None else "")
+            cur_enabled = (bool(row["enabled"]) if row is not None else True)
+            if row is not None:
+                cur_events = [e for e in feishu.FEISHU_EVENTS
+                              if e in (row["events"] or "")]
+            else:
+                # 无绑定行的默认事件集与设置页回显一致（卡片待审核默认关）
+                cur_events = list(feishu.FEISHU_DEFAULT_EVENTS)
+            if "webhook_url" in body:
+                cur_url = str(body["webhook_url"] or "").strip()
+            if "webhook_secret" in body:
+                cur_secret = str(body["webhook_secret"] or "").strip()
+            if req_events is not None:
+                cur_events = req_events
+            if "enabled" in body:
+                cur_enabled = bool(body["enabled"])
+            db.set_feishu_hook(proj["id"], cur_url, cur_secret,
+                               ",".join(cur_events), 1 if cur_enabled else 0)
+            names.append(proj["name"])
+        self._respond(200, json.dumps(
+            {"ok": True, "updated": len(names), "archived_skipped": skipped,
+             "projects": names}, ensure_ascii=False).encode("utf-8"),
+            "application/json; charset=utf-8")
+
     # ---------- 个人飞书绑定（M2 入站身份映射） ----------
 
     def _api_me_feishu_bindcode(self):
@@ -2807,8 +2952,29 @@ class Handler(BaseHTTPRequestHandler):
             # 压缩新建后的绑定）也要归档——I2「done 卡全部绑定会话都归档」。
             # best-effort：失败只记提示 + 退避重试，不回滚绑定。
             board.archive_bound_session(db.get_board_card(card_id), newly_bound)
-        self._respond(200, json.dumps(board.card_json(db.get_board_card(card_id)),
-                                      ensure_ascii=False).encode("utf-8"),
+        rename_info = None
+        if "title" in fields and fields["title"].strip() != (card["title"] or "").strip():
+            # 卡面改名 → 同步改 DSH 会话名（2026-10-10 用户需求）：只认**改后的主会话**
+            # （同一次 PATCH 里换绑/解绑以新状态为准），best-effort——失败不改卡面，
+            # 只把原因回给前端（`session_rename.ok=false`）。
+            fresh = db.get_board_card(card_id)
+            sid = str((fresh["session_id"] if fresh else "") or "")
+            if sid:
+                ok, err, accepted = board.rename_card_session(sid, fields["title"].strip())
+                rename_info = {"ok": ok, "session_id": sid}
+                if not ok:
+                    rename_info["error"] = err
+                elif accepted and accepted != fields["title"]:
+                    # 宿主规范化/截断（`normalizeSessionTitle` 的 UTF-8 字节预算，实测
+                    # 约 80 字节）：**只如实上报，不回写卡面**——卡面是用户输入，平台不
+                    # 替用户缩短内容（2026-10-10 真机教训：回写会把长标题静默截断，
+                    # 用户原文丢失）。前端据 `accepted_title` 提示「DSH 侧标题被截断」，
+                    # 由用户自行决定是否缩短卡名。
+                    rename_info["accepted_title"] = accepted
+        payload = board.card_json(db.get_board_card(card_id))
+        if rename_info:
+            payload["session_rename"] = rename_info
+        self._respond(200, json.dumps(payload, ensure_ascii=False).encode("utf-8"),
                       "application/json; charset=utf-8")
 
     def _api_board_delete_card(self, project_id, card_id):
@@ -2904,7 +3070,8 @@ class Handler(BaseHTTPRequestHandler):
         """标记卡片已查看（POST /api/projects/<pid>/board/cards/<cid>/viewed）。
 
         2026-10-07 批次「卡片状态有更新·用户还没打开过 ⇒ 卡面打标记」的清除端：
-        前端打开卡片详情（点击卡面正文 / 详情按钮）时调用，清 `board_cards.unread`。
+        前端打开卡片详情（点击卡面正文 / 详情按钮）或点卡面操作行上任意一个按钮时调用，
+        清 `board_cards.unread`。
         幂等：本来就未读/标记已被别的标签页清掉都回 200；`changed` 说明本次是否真的
         清了标记（不清就不发看板变更信号，前端也不必重取）。归属校验走
         `_board_owned`（多用户隔离红线：越权访问他人卡片一律 404）。
@@ -2936,12 +3103,18 @@ class Handler(BaseHTTPRequestHandler):
                 before_id = int(body["before_id"]) if body.get("before_id") is not None else None
             except (TypeError, ValueError):
                 before_id = None
+            # merge_ack（2026-10-07 批次）：独立 worktree 卡进「已完成」的待合并闸。
+            # 默认 false ⇒ 有待合并提交时 move_card 回 {"merge_pending": ...} 且列不动，
+            # 前端弹「交给 agent 合并 / 仅通过」；用户选「仅通过」时前端带 true 再来一次，
+            # 后端跳过该闸（= 旧行为，分支保留）。
             card_dict, err = board.move_card(row, card_id, target,
                                              (body.get("block_text") or "")[:2000],
-                                             before_id=before_id)
+                                             before_id=before_id,
+                                             merge_ack=bool(body.get("merge_ack")))
             if err:
-                if "blocked" in err:  # 父任务拦截：前端弹确认框，不算错误
-                    self._respond(200, json.dumps(err).encode("utf-8"),
+                if "blocked" in err or "merge_pending" in err:
+                    # 父任务拦截 / 合并询问：前端弹确认框，不算错误（列未变）
+                    self._respond(200, json.dumps(err, ensure_ascii=False).encode("utf-8"),
                                   "application/json; charset=utf-8")
                     return
                 self._respond(400, json.dumps(err, ensure_ascii=False).encode("utf-8"),
@@ -3017,6 +3190,28 @@ class Handler(BaseHTTPRequestHandler):
             return
         self._respond(200, b'{"ok": true}', "application/json; charset=utf-8")
 
+    def _api_board_card_worktree_merge(self, project_id, card_id):
+        """把 worktree 改动回流主分支的合并任务交给卡片会话（2026-10-07 批次）。
+
+        `POST .../board/cards/<id>/worktree/merge`。「通过」时若判定有待合并提交
+        （move 端点回 `merge_pending`），前端弹框让用户选——这条端点即「交给 agent
+        合并」：平台只投递指令 + 把卡片送回统一队列，agent 在卡片会话里执行同步
+        主分支与合并回流（冲突由 agent 解），干完这轮卡片自动回待审核，用户再点
+        「通过」时已无待合并提交、直接进「已完成」。
+        硬错误 400（无待合并提交 / 无主会话 / 工作树读不到）；卡片运行中由
+        `board._enter_doing` 的入口预检拦下（同样 400 带中文原因）。
+        """
+        row, card = self._board_owned(project_id, card_id)
+        if row is None:
+            return
+        card_dict, err = board.handoff_worktree_merge(row, card)
+        if err:
+            self._respond(400, json.dumps(err, ensure_ascii=False).encode("utf-8"),
+                          "application/json; charset=utf-8")
+            return
+        self._respond(200, json.dumps({"card": card_dict}, ensure_ascii=False).encode("utf-8"),
+                      "application/json; charset=utf-8")
+
     def _api_board_compact(self, project_id, card_id, body):
         """卡片会话 compact（压缩上下文）。busy 拒绝（409）；族不支持 400；
         CLI 族异步触发即返回（日志落工作目录 .web/board_compact_*）。"""
@@ -3128,10 +3323,11 @@ class Handler(BaseHTTPRequestHandler):
         try:
             # inject=true 时立即注入运行中的当前轮（dsh 等 steer 能力会话生效）；
             # 项目忙（同项目有单元在跑）时登记统一队列消息单元，返回 queued=true
-            #（前端显示「排队中」，注释见 board.deliver_comment）
+            #（前端显示「排队中」，注释见 board.deliver_comment）；投递文本恒为评论
+            # 原文、不包【看板评论】前缀（2026-10-10 去前缀；旧客户端多传的 body.raw
+            # 字段静默忽略，不再透传）
             rec = board.deliver_comment(row, card, target,
-                                        inject=bool(body.get("inject")),
-                                        raw=bool(body.get("raw")))
+                                        inject=bool(body.get("inject")))
         except dshdriver.DshDriverError as e:
             # 409 = 会话运行中（deliver_comment 的忙拒绝）；其余 code 按 500
             if e.args and e.args[0] == 409:
@@ -3292,17 +3488,26 @@ class Handler(BaseHTTPRequestHandler):
             # 卡片当前所在列（会话窗标题「卡片队列」徽标，键值同看板列：todo/doing/
             # blocked/review/done；前端转列名展示，随 2s 轮询跟随卡片移列）
             data["card_column"] = owner["column_key"]
+            # 卡片是否跑在独立 worktree（2026-10-07 批次）：会话窗「通过」要按
+            # 看板同款口径弹「是否交给 agent 合并」（空串=普通卡）
+            data["card_worktree"] = str(db.row_opt(owner, "worktree") or "").strip()
             # 已作答·待送达（答案排队，2026-09-14）：前端在输入区上方渲染「待送达」行
             # 与「立即送达」按钮（POST .../cards/<cid>/answer/deliver，不等项目空闲）
             data["answer_pending"] = board.is_answer_pending(owner_cid)
             data["interaction"] = board.interaction_of_sid(sid)
+            # 会话归属三态（C 批 T8）：前端按 `owned === false` 出「外部会话」提示条并把
+            # 「停止」置灰；`None`=注册表未知按「池内」渲染（判定口径见 _session_owned）
+            data["owned"] = _session_owned(sid)
             data["family"] = family
             if family == "dsh_plugin":
-                # P6：ctx 圈数据源＝EventHub 的 usage（事件推来，零请求）。
-                # dsh 的 TokenUsage 没有窗口上限 ⇒ max 缺省 None（前端不画环）。
+                # 上下文圈（2026-10-10 修「恒为 0」）：分子/分母都随上面的
+                # `sessparse.load` 从会话存储的两个 last-wins 槽位带出来
+                # （used＝最新 usage 的 prompt 侧 token 数，max＝最新
+                # `request/context` 的 contextWindow，见 sessparse._dsh_prompt_tokens），
+                # 此处**不再**用 EventHub 的 usage 覆盖：那条只有 total 口径、且插件
+                # 后端一重启就清零；会话文件是持久的，本来就在本次请求里解析过
+                # （零额外解压，`data["ctx"]` 由 load 结果带出，窗口未知时不带该键）。
                 st = dshevents.get(sid)
-                if st and st.get("usage"):
-                    data["ctx"] = {"used": st["usage"].get("total") or 0, "max": None}
                 # 会话级模型（会话窗「模型」展示）：事件流里学到就用它，否则留空
                 # 由前端回落「项目默认模型」（既有兜底链）
                 sel = (st or {}).get("model") or {}
@@ -4772,6 +4977,14 @@ class Handler(BaseHTTPRequestHandler):
                                           ensure_ascii=False).encode("utf-8"),
                           "application/json; charset=utf-8")
             return
+        except RuntimeError as e:
+            # 投递前置闸拒投（chat.DeliveryRefused：外部会话前提不成立，C 批 T5/T8）——
+            # 消息未入队、未落行，回 400 + 闸的中文文案（口径同 _api_board_session_comment）。
+            # 必须排在 dshdriver.DshDriverError 之后：它也是 RuntimeError 子类，先命中 409/500；
+            # 裸 RuntimeError 若逃逸，do_POST 无兜底 ⇒ 用户拿到连接重置而不是要求的明确文案。
+            self._respond(400, json.dumps({"error": str(e)}, ensure_ascii=False).encode("utf-8"),
+                          "application/json; charset=utf-8")
+            return
         self._respond(200, json.dumps(
             {"ok": True, "queued": bool(rec.get("queued")),
              "msg_id": rec.get("id") or "", "state": rec.get("state") or "",
@@ -4992,20 +5205,36 @@ class Handler(BaseHTTPRequestHandler):
 
         返回 True 表示已回 403、调用方直接 return。前端据 /api/auth/me 的
         must_change_password 渲染改密门；此处是服务端兜底（防绕过前端直调 API）。
+
+        例外（2026-10-08，插件形态死锁修复）：免登信任头路径整体跳过此闸。
+        插件形态下用户拿不到随机一次性口令（薄壳曾把横幅整段丢弃），拦在这里只会
+        把面板锁死——而信任头本已等价 admin（见 _current_user），跳过不降安全等级；
+        存量库 must_change_pw=1 在插件形态亦据此不再锁死，用户进面板后可在设置页设密码。
         """
         if not user or not user["must_change_pw"]:
             return False
+        if self._trusted_admin_request():
+            return False
         if path in MUST_CHANGE_PW_ALLOW:
             return False
         self._respond(403, '{"error":"请先修改初始口令"}'.encode("utf-8"),
                       "application/json; charset=utf-8")
         return True
 
+    def _trusted_admin_request(self):
+        """本次请求是否由薄壳反代注入的免登信任头判为 admin（--trust-internal-user）。
+
+        仅回环监听 + 显式开关时才可能为真（main() 已限制）；该头等价 admin 全权，
+        故以此为据的放行（跳过强制改密门、免原口令改密）不新增任何权限面。
+        """
+        return bool(TRUST_INTERNAL_USER
+                    and self.headers.get(TRUST_USER_HEADER) == "admin")
+
     def _current_user(self):
         """按 cookie 取会话用户，无效返回 None。"""
         # dsh 插件形态免登：--trust-internal-user 时反代注入的信任头视为 admin 登录
         # （main() 已限制仅回环监听可开启）；后续 _owned_project 等隔离逻辑不变
-        if TRUST_INTERNAL_USER and self.headers.get(TRUST_USER_HEADER) == "admin":
+        if self._trusted_admin_request():
             admin = db.get_user_by_name("admin")
             if admin is not None:
                 return admin
@@ -5267,6 +5496,11 @@ def main():
     # 状态流），再起调和器——调和器改为等它的事件唤醒，不再固定 5s 轮询 dsh。
     # 独立形态（未下发驱动地址）下 start() 直接返回 False，不起线程。
     dshevents.start()
+    # 启动补跑（2026-10-07 僵尸 ext 行实障修复）：上面 board.recover() 里的 ext 行
+    # 对账执行时中枢尚未连接 ⇒ 探测「不可用」、一律保行；上一进程留下的僵尸占用行
+    # （会话已结束、行仍 running）会继续堵死该项目补位，重启也救不回来。这里等首连
+    # 就绪后补跑一次对账（后台线程，不阻塞启动与端口绑定；未就绪直接结束）。
+    board.start_ext_recover_after_connect()
     board.start_interaction_watcher()
     runner.start_unit_selfcheck()  # 等待项周期自检线程（首轮宽限+年龄豁免），替代已退场的影子比对线程
     feishu.start_notifier()  # 飞书 outbox 投递线程（未配置时空转）