@gavinc-cn/touchstone-dsh 0.1.1 → 0.3.0

package/lifecycle.py

@@ -20,8 +20,14 @@ Python 后端是 dsh 宿主进程 spawn 的子进程。宿主退出/崩溃/被 `
      父还活着（例如 stdin 不是管道、或管道被无关方关闭）只记日志不自杀。
 
 2. **同库单实例** `SingleInstance`
-   - `<db>.lock` 排它锁（`platcompat.lock_fd`）+ `<db>.pid` 记录
-     `{pid, ppid, repo_dir, parent_watch, started_at}`。
+   - `<db>.lock` 上**两道锁**：`flock` 排它（`platcompat.lock_fd`）+ 同一文件上的
+     **SQLite 排它锁**（`locking_mode=EXCLUSIVE` + 一次写事务，持锁到进程结束）；
+     再写 `<db>.pid` 记录 `{pid, ppid, repo_dir, parent_watch, started_at}`。
+     - 为什么要两道（2026-10-11，Node 后端 M1）：flock 只有 Python 侧有（Node 无
+       stdlib flock），Node 版改用 SQLite 自身的排它锁，两种锁**互不相干**
+       ⇒ 只靠 flock 挡不住 Node 版实例（实测：Node 持锁时 Python 的 flock 照样
+       成功）。两边都取 SQLite 锁后，同语言与跨语言互斥都成立，且 `kill -9` 后
+       由内核/文件锁自动释放，无需清理残留。
    - 锁被占时：读 pid 记录——若记录进程**由父死感知托管**（`parent_watch=true`）
      且其父已死 ⇒ 判定为**存量孤儿**（升级前的强杀残留），SIGTERM 后重试拿锁；
      否则视为真·另一实例，明确报错退出（防双写同库）。
@@ -39,6 +45,7 @@ Python 后端是 dsh 宿主进程 spawn 的子进程。宿主退出/崩溃/被 `
 import json
 import os
 import signal
+import sqlite3
 import sys
 import threading
 import time
@@ -225,6 +232,8 @@ class SingleInstance:
         self.reason = ""
         self.reaped_pid = 0
         self._fd = None
+        # SQLite 排它锁的连接（第二道闸，M1）；持锁期间常驻，release 时关闭
+        self._lock_conn = None
 
     # ---------- 记录读写 ----------
 
@@ -259,17 +268,21 @@ class SingleInstance:
 
     @staticmethod
     def _looks_like_server(pid):
-        """粗校验 pid 是否是 touchstone 的 server.py（防 PID 复用误杀）。
+        """粗校验 pid 是否是 touchstone 的后端（防 PID 复用误杀）。
 
+        两版后端的命令行都要认：Python 是 `server.py`，Node 是 `backend/server.js`
+        （2026-10-11 M1 起 Node 版也走同一套 `.pid` 记录与孤儿收口）。
         读不到命令行时返回 True（宁可不杀——见 acquire 的调用点：仅在
         「pid 记录声明 parent_watch 且其父已死」时才走到这里）。
         """
         try:
             if sys.platform.startswith("linux"):
                 with open(f"/proc/{int(pid)}/cmdline", "rb") as f:
-                    return b"server.py" in f.read()
+                    cmdline = f.read()
+                return b"server.py" in cmdline or b"server.js" in cmdline
             import psutil
-            return any("server.py" in str(a) for a in psutil.Process(int(pid)).cmdline())
+            argv = [str(a) for a in psutil.Process(int(pid)).cmdline()]
+            return any("server.py" in a or "server.js" in a for a in argv)
         except Exception:                        # noqa: BLE001
             return True
 
@@ -308,12 +321,93 @@ class SingleInstance:
 
     # ---------- 加锁 ----------
 
+    def _acquire_sqlite_lock(self):
+        """第二道闸：同一锁文件上的 SQLite 排它锁（M1，2026-10-11）。
+
+        Node 版没有 stdlib `flock`，改用 SQLite 自身的排它锁：在 `<db>.lock` 上
+        `PRAGMA locking_mode=EXCLUSIVE` + 一次写事务，锁持有到进程/连接结束
+        （`kill -9` 由内核释放，无残留文件要清理）。两种锁机制**互不相干**，所以
+        两边都要取这一道，跨语言互斥才成立（实测：Node 持锁时 Python 的 flock
+        照样能拿到）。
+
+        返回 `(状态, 文案)`：
+          - `("ok", "")`      拿到（连接挂在 `self._lock_conn`）
+          - `("busy", "")`    被占用（调用方报「另一实例」并退出）
+          - `("unusable", 文案)` 锁文件本身不可用（损坏/是目录/打不开）——
+            **不再降级放行**（2026-10-11 评审 P1）：降级等于互斥无声消失，
+            实测「先起 Python 再起 Node」双方都能就绪 ⇒ 同库双写。
+        """
+        try:
+            conn = sqlite3.connect(self.lock_path, timeout=0)
+        except sqlite3.Error as e:
+            return "unusable", self._unusable_reason(e)
+        try:
+            conn.execute("PRAGMA busy_timeout=0")
+            conn.execute("PRAGMA locking_mode=EXCLUSIVE")
+            # 必须真写一次：EXCLUSIVE 模式在首个写事务时取锁并一直持有
+            conn.execute("CREATE TABLE IF NOT EXISTS lock_holder ("
+                         " id INTEGER PRIMARY KEY CHECK (id = 1),"
+                         " pid INTEGER NOT NULL, started_at INTEGER NOT NULL)")
+            conn.execute("INSERT OR REPLACE INTO lock_holder(id, pid, started_at)"
+                         " VALUES(1, ?, ?)", (os.getpid(), int(time.time())))
+            conn.commit()
+        except sqlite3.Error as e:
+            try:
+                conn.close()
+            except sqlite3.Error:
+                pass
+            if "locked" in str(e) or "busy" in str(e):
+                return "busy", ""
+            return "unusable", self._unusable_reason(e)
+        self._lock_conn = conn
+        return "ok", ""
+
+    def _unusable_reason(self, error):
+        """锁文件不可用的报错文案（与 Node `lock.js:unusableLockReason` 同义）。"""
+        return (f"单实例锁文件不可用：{self.lock_path}（库 {self.db_file}）。原因：{error}。"
+                f"该文件应为 SQLite 库或 0 字节空文件；内容损坏/被换成目录时无法建立互斥，"
+                f"继续启动会与另一版后端同库双写（任务重复执行、队列行被抢）。"
+                f"修复：确认没有实例在跑之后把它移走再启动"
+                f"（mv {self.lock_path} {self.lock_path}.broken）；"
+                f"或显式 --allow-shared-db 自担双写风险。")
+
+    def _release_sqlite_lock(self):
+        """释放 SQLite 排它锁（幂等）。"""
+        conn, self._lock_conn = self._lock_conn, None
+        if conn is None:
+            return
+        try:
+            conn.close()
+        except sqlite3.Error:
+            pass
+
+    def _try_take_locks(self):
+        """两道锁的状态：`("ok"|"busy"|"unusable", 文案)`。
+
+        flock 拿到但 SQLite 被占/不可用时**回退 flock**：留着不放会挡住下一个 Python
+        实例去走「孤儿收口 → 重试」的路径（它只看到 flock 被占），把可恢复的孤儿变成死锁。
+        """
+        if not platcompat.lock_fd(self._fd, blocking=False):
+            return "busy", ""
+        state, detail = self._acquire_sqlite_lock()
+        if state == "ok":
+            return "ok", ""
+        try:
+            platcompat.unlock_fd(self._fd)
+        except OSError:
+            pass
+        return state, detail
+
     def acquire(self):
-        """拿同库单实例锁。True=拿到（已写 pid 记录）；False=被真·另一实例占用。
+        """拿同库单实例锁。True=拿到（已写 pid 记录）；False=不能独占（`reason` 说明原因）。
 
         非阻塞试锁 + 存量孤儿收口：拿到即写记录返回；拿不到先读 pid 记录——
         若记录进程由父死感知托管且其父已死，判为存量孤儿，SIGTERM 后在
         `stale_wait` 内重试；否则立即返回 False 并给出可执行的报错文案。
+
+        **不再有「降级为无锁运行」分支**（2026-10-11 评审 P1）：锁文件打不开/损坏时
+        返回 False（调用方 exit 3）并给修复步骤——静默降级会让互斥无声消失、同库双写，
+        那比「启动被拒」严重得多。
         """
         os.makedirs(os.path.dirname(self.lock_path), exist_ok=True)
         if self.allow_shared:
@@ -322,15 +416,18 @@ class SingleInstance:
         try:
             fd = os.open(self.lock_path, os.O_RDWR | os.O_CREAT, 0o644)
         except OSError as e:
-            self.log(f"[lifecycle] 锁文件打开失败（降级为无锁运行）: {e}")
-            return True
+            self.reason = self._unusable_reason(e)
+            return False
         self._fd = fd
-        deadline = time.time() + max(self.stale_wait, 0.5) + 1.0
         reaped = False
         while True:
-            if platcompat.lock_fd(fd, blocking=False):
+            state, detail = self._try_take_locks()
+            if state == "ok":
                 self._write_record(os.getpid())
                 return True
+            if state == "unusable":
+                self.reason = detail
+                return False
             rec = self._read_record()
             if rec and not reaped and self._reap_stale(rec):
                 reaped = True                   # 孤儿已收口：其锁随进程退出释放，再试
@@ -343,9 +440,14 @@ class SingleInstance:
                     f"（TOUCHSTONE_DB / 插件 extraEnv.TOUCHSTONE_DB），"
                     f"或显式 --allow-shared-db 自担双写风险。")
             else:
-                self.reason = (f"锁文件被占用且无归属记录：{self.lock_path}"
-                               f"（库 {self.db_file}）。若确认无实例在跑，"
-                               f"删除该锁文件后重试。")
+                # 无归属记录时**不要**教用户删锁文件：删掉后新实例会在新 inode 上取锁，
+                # 与仍在运行的占用者双写（flock 与 SQLite 锁同理）。给安全的两个出口。
+                self.reason = (
+                    f"锁文件被占用且无归属记录：{self.lock_path}"
+                    f"（库 {self.db_file}）。占用者可能是另一版后端的异常窗口"
+                    f"（Node 版取锁后、写 .pid 前被杀）或残留的第三方进程；"
+                    f"如需并行请用独立库（TOUCHSTONE_DB / 插件 extraEnv.TOUCHSTONE_DB），"
+                    f"或显式 --allow-shared-db 自担双写风险。")
             return False
         # 不可达：while True 内所有分支都 return（保静态检查可读性）
 
@@ -354,6 +456,7 @@ class SingleInstance:
         rec = self._read_record()
         if rec and int(rec.get("pid") or 0) == os.getpid():
             self._remove_record()
+        self._release_sqlite_lock()
         if self._fd is not None:
             platcompat.unlock_fd(self._fd)
             try:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gavinc-cn/touchstone-dsh",
-  "version": "0.1.1",
+  "version": "0.3.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",
@@ -27,6 +27,10 @@
   "files": [
     "*.py",
     "requirements.txt",
+    "backend/server.js",
+    "backend/lib",
+    "backend/routes",
+    "backend/schema",
     "builtin_prompts",
     "extensions",
     "dsh-plugin/cordis.patch.yml",
@@ -55,6 +59,7 @@
   },
   "scripts": {
     "build:client": "node dsh-plugin/scripts/build.mjs",
+    "test:backend": "node --test \"backend/test/**/*.test.mjs\"",
     "prepack": "node dsh-plugin/scripts/prepack-check.mjs"
   },
   "repository": {

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/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)
@@ -1276,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":
@@ -1531,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
@@ -1683,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", ""),
@@ -1699,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()
@@ -1970,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):
@@ -2812,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):
@@ -3162,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:
@@ -3333,13 +3495,19 @@ class Handler(BaseHTTPRequestHandler):
             # 与「立即送达」按钮（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 {}
@@ -4809,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 "",
@@ -5029,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