@gavinc-cn/touchstone-dsh 0.3.0 → 0.4.0

package/backend/lib/board.js

@@ -2630,7 +2630,7 @@ export function buildTaskPrompt(project, card, extra = '') {
   const desc = String(card.description || '').trim();
   const body = [title, desc].filter((seg) => seg).join('\n\n') || '（无）';
   const workspace = cardWorkspace(project, card);
-  let p = `【任务描述】${body}\n【工作目录】${workspace}`;
+  let p = `${TASK_PROMPT_TAG}${body}\n【工作目录】${workspace}`;
   const wt = String(cardOpt(card, 'worktree') || '').trim();
   if (wt) {
     p += `\n（本任务运行在独立 git worktree 中：分支 ${branchFor(card.id)}，`
@@ -3125,6 +3125,15 @@ function requireCardSession(card, sid) {
  * 的卡会话在驱动里只剩观察 ⇒ 首跳 404 时经 `ensureWatch` 钩子（`force=true`）补看管声明后
  * 重试一次。未接线（M5-3）⇒ 不补声明、直接按失败抛（与 Python「声明失败」同一分支）。
  *
+ * **会话存活前置（2026-10-17 修卡 907「TS 侧 /compact 对已结束会话必失败」）**：上面那条
+ * 「池外回落」只对宿主里**仍活着**的会话成立；对宿主里根本没有活 agent 的会话（dsh web
+ * 重启、插件重载、久未接续的旧卡），驱动 `/compact` 必 404「会话已结束（宿主无活动 agent）」
+ * ——补看管声明也救不回来。而 dsh GUI 自己的 `/compact` 对冷会话是按需 resume 再执行命令
+ * （`dsh-api-session-controller.resolve` → `agents.resume`），故这里与投递腿 `deliverNow`
+ * 同款：先 `ensureCardSession` 接回（判据/边界同它——中枢未对齐按「未知」不动、sync 卡不
+ * 收养、回滚阀 `TS_HOST_SESSION_REVIVE=0` 时不动，均为零请求），再走下面的两跳。接不回
+ * **不在此收口**：照旧走两跳，由驱动 404 文案兜底（与修复前完全一致）。
+ *
  * `sid` 必须属于该卡片；不支持的族抛 `Error`（server 转 400）。**async**。
  * @returns {Promise<void>}
  */
@@ -3132,6 +3141,8 @@ export async function compactSession(project, card, sid, options = {}) {
   requireCardSession(card, sid);
   const family = agentFamily(project.agent_path || '');
   if (family !== 'dsh_plugin') throw new Error(RETIRED_MSG);
+  // 会话存活前置：宿主已失去该会话 ⇒ 先按 resume 语义接回，再压缩（与投递同款）
+  await ensureCardSession(project, card, sid, options);
   let last = '';
   for (const attempt of [1, 2]) {
     try {
@@ -3910,6 +3921,12 @@ export const SYNC_BUSY_MTIME_S = 120;
 export const SYNC_TITLE_MAX = 200;
 /** sync 卡描述上限（Python `SYNC_DESC_MAX`） */
 export const SYNC_DESC_MAX = 2000;
+/**
+ * 平台任务提示词的段标（Python `TASK_PROMPT_TAG`）：`buildTaskPrompt` 的首段。
+ * 除拼提示词外还用作**判据**——会话首问以它开头 ⇒ 这个会话是平台按某张卡片的内容拼
+ * 提示词启动的（2026-10-16 起这类卡的标题/描述也跟随 DSH，见 `isPlatformTaskSession`）。
+ */
+export const TASK_PROMPT_TAG = '【任务描述】';
 
 /** 已跑过「存量子代理卡软删收口」的项目 id（Python `_SYNC_SUBAGENT_SWEPT`，每项目一轮） */
 const SYNC_SUBAGENT_SWEPT = new Set();
@@ -4092,24 +4109,67 @@ export function autoTitleForms(item, sid) {
 export const _auto_title_forms = autoTitleForms;
 
 /**
- * 存量 sync 卡按「DSH 当前标题 + 首问全文」补齐的字段 dict（Python `_sync_card_follow`；
+ * 卡面字段是否仍是「平台按卡片内容拼进首问」的**原文形态**（Python `_in_first_prompt`；
+ * 判自动写入用）。
+ *
+ * 平台起会话时把卡片标题/描述原样拼进首问（`buildTaskPrompt`：标题并入【任务描述】段、
+ * 与描述空行分隔）⇒ 卡面字段只要没被用户改过，就必然能在首问原文里原样找到；用户后来
+ * 改写过的文本通常不在（⇒ 不覆盖，尊重用户编辑）。空/纯空白一律 false（空标题由
+ * `autoTitleForms` 那一档负责）。
+ * @param {string} text
+ * @param {object} item
+ * @returns {boolean}
+ */
+export function inFirstPrompt(text, item) {
+  const t = String(text === null || text === undefined ? '' : text).trim();
+  return Boolean(t) && String(item.first_prompt || '').includes(t);
+}
+
+/** `_in_first_prompt` 的 Python 名别名。 */
+export const _in_first_prompt = inFirstPrompt;
+
+/**
+ * 该会话是否「平台按某张卡片的内容拼提示词启动的」（Python `_is_platform_task_session`；
+ * 判据 = 首问以段标开头）。
+ *
+ * 卡片启动腿（`enterDoing` → `buildTaskPrompt`）拼的首问以 `TASK_PROMPT_TAG` 开头；
+ * 用户在 dsh GUI 里直跑的会话首问是用户原文、续跑腿是「继续」，都不会命中。用于把正向
+ * 同步（DSH 标题/首问 → 卡面）从 sync 卡扩到**平台从看板启动过会话的卡**（2026-10-16
+ * 用户诉求：卡面标题/正文与 DSH 保持一致；见 spec/board §48）。
+ * @param {object} item
+ * @returns {boolean}
+ */
+export function isPlatformTaskSession(item) {
+  return String(item.first_prompt || '').replace(/^\s+/, '').startsWith(TASK_PROMPT_TAG);
+}
+
+/** `_is_platform_task_session` 的 Python 名别名。 */
+export const _is_platform_task_session = isPlatformTaskSession;
+
+/**
+ * 卡面按「DSH 当前标题 + 首问全文」补齐的字段 dict（Python `_sync_card_follow`；
  * 无变化返回 `{}`）。
  *
  * 只认「主会话」：遍历到的会话不是卡的主会话（多会话并集里的子会话）时不动。
- * 只在卡仍由平台自动写入时动——用户在卡面行内改过标题就整张卡不再自动覆盖（描述也不动）；
- * 描述仅在为空、或仍是**旧口径自动写入**（首问除首行）时改成首问全文。
+ * 只在卡仍由平台自动写入时动——卡标题 ∈ `autoTitleForms`（空 / sid 短码 / 任一枚会话
+ * 标题事件 / 旧口径的首问首行）**或**仍是平台拼进首问的原文（`inFirstPrompt`，
+ * 2026-10-16 增：服务「平台从看板启动过会话的卡」——它的标题是用户在卡里敲的原文，
+ * 不在任何标题事件里）；用户在卡面行内改过标题就整张卡不再自动覆盖（描述也不动）。
+ * 描述仅在为空、仍是**旧口径自动写入**（首问除首行）、或仍是平台拼进首问的原文时改成
+ * 首问全文；用户写过的描述不覆盖。
  * @returns {object}
  */
 export function syncCardFollow(card, item, sid) {
   if (String(card.session_id || sid) !== String(sid)) return {};
   const curTitle = String(card.title || '').trim();
-  if (!autoTitleForms(item, sid).has(curTitle)) return {};
+  if (!autoTitleForms(item, sid).has(curTitle) && !inFirstPrompt(curTitle, item)) return {};
   const [title, desc] = syncCardFields(item, sid);
   const out = {};
   if (curTitle !== title) out.title = title;
   const curDesc = String(card.description || '').trim();
   const legacyDesc = splitFirstPrompt(item.first_prompt || '')[1];
-  if (desc && curDesc !== desc && (curDesc === '' || curDesc === legacyDesc)) {
+  if (desc && curDesc !== desc
+      && (curDesc === '' || curDesc === legacyDesc || inFirstPrompt(curDesc, item))) {
     out.description = desc;
   }
   return out;
@@ -4126,6 +4186,10 @@ export const _sync_card_follow = syncCardFollow;
  * busy→doing / 空闲→review；存量 sync 卡按同口径补齐 + 归档→done；会话存储被删的 sync 卡
  * 自动进 done；绑子代理会话的存量 sync 卡收口进回收站（每项目一轮）；两类误建卡的存量也按
  * 同款口径收口（每项目一轮）。sync 卡不占 runner 项目占用（外部会话平台控制不了）。
+ * **平台从看板启动过会话的卡**（用户建卡 → 开始/回车启动，首问 = 平台拼的任务提示词，
+ * 见 `isPlatformTaskSession`）同样按上面同一口径补齐卡面——但**列语义不动**：归档/取消
+ * 归档的列映射与各类存量收口仍只服务 `origin='sync'` 卡（用户自己的卡，平台只同步
+ * 标题/描述，不替用户搬列、不软删）。用户改过卡名 ⇒ 整卡不动（含描述）。
  *
  * **async**：本函数自身不打驱动，但 `setCardPlaceholder`→无；`webBusy` 走 `dshevents` 内存读。
  * 除 `subagentSession`（注入缝）外全同步——保持 `async` 只为「调用方统一 await」的形态一致。
@@ -4164,11 +4228,14 @@ export async function syncSessions(project, options = {}) {
         { session_id: sid, sessions: pyJsonDumps([sid]), column_key: col, origin: 'sync' },
         options);
       created.push(cid);
-    } else if (c.origin === 'sync') {
-      // 首问补齐（2026-10-07）：标题/描述仍是平台自动写入形态时按首问覆盖
+    } else if (c.origin === 'sync' || isPlatformTaskSession(it)) {
+      // 卡面补齐（2026-10-07 起服务 sync 卡；2026-10-16 起扩到「平台从看板启动过会话的卡」，
+      // 见 `syncCardFollow`）：标题/描述仍是平台自动写入形态时按 DSH 当前标题 + 首问全文
+      // 覆盖（用户改过名整卡不动）
       const fields = syncCardFollow(c, it, sid);
       if (Object.keys(fields).length) dbmod.updateBoardCard(c.id, true, fields, options);
-      if ((c.column_key === 'doing' || c.column_key === 'review')
+      if (c.origin === 'sync'
+          && (c.column_key === 'doing' || c.column_key === 'review')
           && !hasActiveRun(c.id)) {
         // dsh 的 busy/空闲 列映射已移交调和器；此处保留归档→done（archived 来源=
         // list_sessions 的宿主归档集文件读，与调和器读驱动帧是两条独立通道）
@@ -5070,8 +5137,14 @@ export function startInteractionWatcher() {
     }, delay).unref?.();
   };
   try {
-    dshMod.subscribe(() => kick());
-  } catch { /* 订阅面不可用（未连接）：兜底拍照常 */ }
+    eventSubscribe(() => kick());
+  } catch (e) {
+    // 留痕（2026-10-16 实障）：这里原本写的是 `dshMod.subscribe(...)`——`dshMod` 是
+    // `./dshdriver.js`（无该导出），TypeError 被空 catch 吞掉 ⇒ 事件面从没接上，调和器
+    // 退化成只有 `IW_SAFETY_SECONDS` 兜底拍（生产实测：待审核卡追问后 ~60s 才进开发列）。
+    // 事件面若真的不可用，必须能定位（不再是静默降级）。
+    console.log(`[board] 调和器事件订阅失败（退化为 ${IW_SAFETY_SECONDS}s 兜底轮询）: ${errText(e)}`);
+  }
   IW_TIMER = setInterval(() => {
     IW_LAST = nowSec();
     void iwTick();                     // 兜底对账（60s）；事件面未接时的唯一驱动

package/backend/lib/chat.js

@@ -1171,6 +1171,43 @@ export function cancelQueued({ sid = null, cardId = null } = {}, options = {}) {
   return count;
 }
 
+/**
+ * 取消排队中的消息**并回带原文**（`mode=cancel_queue` 端点的实现；用户点「取消排队」）。
+ *
+ * 与 `cancelQueued` 的差别只有「回带」：后者是停止入口共用的计数壳。用户显式取消排队时，
+ * 前端要把消息原文放回输入框，而 `msgsOfSid` 下发给前端的展示文本被截到 120 字——
+ * 回填必须由服务端给**全量原文**，否则长消息被静默截断。
+ *
+ * 逐行只在 `cancel()` 真命中（`chat_msgs` 的 queued→cancelled 原子守卫是仲裁点，R12）
+ * 时才收进结果：与 worker claim 竞态下已被抢走执行的消息既不会被取消、也不会回带，
+ * 前端不会把仍在执行的消息错放回输入框。返回按入队顺序（`msgRows` 的 created_at,id）。
+ *
+ * `filter.msgId` 非空 ⇒ 只取消该条（归属校验由端点层做，本函数只管状态）。
+ *
+ * @param {{sid?: string|null, cardId?: number|string|null, msgId?: string|null}} [filter]
+ * @param {{db?: object, dbPath?: string, env?: NodeJS.ProcessEnv}} [options]
+ * @returns {{cancelled: number, msgs: Array<{id: string, text: string}>}}
+ */
+export function cancelQueuedDetail({ sid = null, cardId = null, msgId = null } = {}, options = {}) {
+  if (!sid && !cardId && !msgId) return { cancelled: 0, msgs: [] };
+  let rows;
+  if (msgId) {
+    const one = waitq.msgGet(msgId, options);
+    if (one === null || one.state !== STATE_QUEUED) return { cancelled: 0, msgs: [] };
+    rows = [one];
+  } else {
+    rows = waitq.msgRows({ sid, cardId, states: [STATE_QUEUED] }, options);
+  }
+  const msgs = [];
+  for (const row of rows) {
+    // 先取原文再取消：取消是终态迁移，但仍按「命中才回带」的次序写，读一次即用一次
+    const text = row.message === null || row.message === undefined ? '' : String(row.message);
+    if (!cancel(row.id, options)) continue;
+    msgs.push({ id: row.id, text });
+  }
+  return { cancelled: msgs.length, msgs };
+}
+
 // --------------------------------------------------------------------------
 // 立即注入（chat.py:452-493）
 // --------------------------------------------------------------------------

package/backend/lib/feishu.js

@@ -1684,6 +1684,8 @@ function requireCfgDict(cfg) {
  */
 export async function saveUserConfig(userId, body, options = {}) {
   const cfg = requireCfgDict(userConfig(userId, options));
+  // M11：换应用前后的凭据快照（自动「确认切换」卡片用旧应用凭据发，见函数尾）
+  const oldCfg = { app_id: cfg.app_id || '', app_secret: cfg.app_secret || '' };
   // 推送总控（2026-10-10）：与旧 `enabled` 是两个独立开关，缺省=不改（不在 body 里就不动）
   if (Object.hasOwn(body, 'push_enabled')) cfg.push_enabled = pyTruthy(body.push_enabled) ? 1 : 0;
   if (Object.hasOwn(body, 'enabled')) cfg.enabled = pyTruthy(body.enabled) ? 1 : 0;
@@ -1693,6 +1695,12 @@ export async function saveUserConfig(userId, body, options = {}) {
   setFeishuUserCfg(userId, cfg, options);
   const started = startInboundFor(userId, options);
   const verify = appConfig(userId, options) ? await verifyCredentials(userId, options) : null;
+  // M11：手工换应用（非扫码路径）同样发「确认切换」卡片——旧连接还活着时用旧应用通道
+  // 通知用户点确认。后台发（不阻塞保存响应）；条件在 maybeSendSwitchCard 里复核，
+  // 凭据没变/线程没跑时是零请求空转；自动卡片故障绝不反噬保存主流程。
+  if (Object.hasOwn(body, 'app_id') || Object.hasOwn(body, 'app_secret')) {
+    void maybeSendSwitchCard(userId, oldCfg, options).catch(() => {});
+  }
   return { inbound_started: Boolean(started), verify };
 }
 
@@ -1733,6 +1741,7 @@ export function startInboundAll(options = {}) {
 // 本节新增的依赖（ESM import 声明提升，等价于置顶；放末尾以严守「只追加」的写作用域）
 import { setFeishuBinding, setFeishuUserCfg } from './db.js';
 import { inboundStatus, userConfig } from './feishu_cfg.js';
-import { startInboundAll as inboundStartAll, startInboundFor as inboundStartFor } from './feishu_inbound.js';
+import { startInboundAll as inboundStartAll, maybeSendSwitchCard,
+  startInboundFor as inboundStartFor } from './feishu_inbound.js';
 import * as feishuConv from './feishu_conv.js';
 import { verifyCredentials } from './feishu_provision.js';

package/backend/lib/feishu_cfg.js

@@ -50,6 +50,12 @@ export const FEISHU_DEFAULT_EVENTS = Object.freeze(['blocked_interaction', 'task
 
 /** 入站线程注册表（`user_id` → 线程形对象；对齐 `feishu._WS_THREADS`，见文件头 M7.5 接缝） */
 const INBOUND_THREADS = new Map();
+/**
+ * `user_id` → **拉起该线程时**用的 app_id（对齐 `feishu._WS_APP_ID`，M10 2026-10-17）。
+ * 为什么需要：lark SDK 无干净停止 ⇒ 换凭据后旧连接仍在跑、只有重启站点才换；
+ * doctor 靠它判「线程绑的应用 ≠ 配置里的应用」，否则那一项会一直假绿。
+ */
+const INBOUND_APP_IDS = new Map();
 
 /**
  * Python 真值口径（`""`/`0`/`None`/`False`/空容器为假）。
@@ -193,7 +199,8 @@ export function hookOf(projectId, options = {}) {
  * `configured` = 应用凭据齐全（`appConfig` 非 null）；`thread` = 注册表里的线程还活着。
  *
  * `thread: true` 只代表线程还在 `client.start()` 内（SDK 内置重连），连接失败细节看 server.log。
- * **当前恒为 false**——注册方是 M7.5（见文件头接缝），这不是占位假值而是今天的正确状态。
+ * **形状是 `GET /api/me/feishu-cfg` 响应的子对象 ⇒ 只许这两键**（「线程绑的哪个应用」
+ * 不放进这里，见 `inboundThreadAppId`；加键会改对外契约，node 的形状判据当场会红）。
  * @param {number} userId
  * @param {{db?: object, dbPath?: string, env?: NodeJS.ProcessEnv}} [options]
  * @returns {{configured: boolean, thread: boolean}}
@@ -207,14 +214,28 @@ export function inboundStatus(userId, options = {}) {
   };
 }
 
+/**
+ * **拉起入站线程时**用的 app_id（对齐 `feishu.inbound_thread_app_id`，M10 2026-10-17）：
+ * 换凭据后旧连接仍在跑、只有重启站点才换 ⇒ doctor 靠它判「线程绑的应用 ≠ 配置里的应用」
+ * 的假绿。空串 = 本进程没为该用户拉过线程 ⇒ 调用方不许据此告警。
+ * 刻意**不并进 `inboundStatus`**：那是 `GET /api/me/feishu-cfg` 的响应子对象。
+ * @param {number} userId
+ * @returns {string}
+ */
+export function inboundThreadAppId(userId) {
+  return INBOUND_APP_IDS.get(userId) || '';
+}
+
 /**
  * 【M7.5 接缝】登记某用户的入站线程（对齐 `feishu._WS_THREADS[user_id] = t`，feishu.py:1643）。
  * 值的契约：`{ isAlive(): boolean }`（与 `threading.Thread` 同形）。幂等覆盖，不校验重复。
  * @param {number} userId
  * @param {{isAlive: () => boolean}} thread
+ * @param {string} [appId] 拉起该线程时用的 app_id（对齐 `feishu._WS_APP_ID[user_id]`）
  */
-export function setInboundThread(userId, thread) {
+export function setInboundThread(userId, thread, appId = '') {
   INBOUND_THREADS.set(userId, thread);
+  INBOUND_APP_IDS.set(userId, appId || '');
 }
 
 /**
@@ -225,4 +246,17 @@ export function setInboundThread(userId, thread) {
  */
 export function clearInboundThread(userId) {
   INBOUND_THREADS.delete(userId);
+  INBOUND_APP_IDS.delete(userId);
+}
+
+/**
+ * 【M11 接缝】取某用户当前登记的入站 runner（**内部用**：M11 起要在进程内停连接，
+ * `isAlive()` 不够——得拿到 runner 背后的 ws 客户端，见 `feishu_inbound.js:stopInboundFor`）。
+ * Python 侧没有对应函数：那边直接读模块级 `_WS_THREADS`/`_WS_CLIENTS` 两个字典。
+ * **不并进 `inboundStatus`**（那是 `GET /api/me/feishu-cfg` 的响应子对象，形状只许两键）。
+ * @param {number} userId
+ * @returns {{isAlive: () => boolean}|null}
+ */
+export function inboundRunner(userId) {
+  return INBOUND_THREADS.get(userId) || null;
 }