dsh-dock 0.18.0 → 0.20.0

package/features/runstate/host.js

@@ -15,13 +15,11 @@ import { acquireTaskTracker } from '../../src/task-track.js'
 export const feature = {
   id: 'runstate',
   name: '运行状态',
-  description: '任务运行状态一览：进行中任务（阶段 / 耗时 / 回合 / Token / 等待确认）与最近完成',
+  description: '任务运行状态一览：进行中任务（阶段 / 耗时 / 回合 / Token / 等人介入）与最近完成',
   defaultEnabled: false,
   setup(ctx) {
     const disposers = []
     const dispose = () => {
-      // 撤掉「本宿主注册了 runstate 路由」旗标（见下方注册处的说明）
-      try { if (typeof window !== 'undefined' && window.__dshDockRunstate) delete window.__dshDockRunstate } catch { /* ignore */ }
       while (disposers.length > 0) {
         const fn = disposers.pop()
         try { if (typeof fn === 'function') fn() } catch { /* 停用清理失败不阻断 */ }
@@ -35,14 +33,6 @@ export const feature = {
 
     // ===== RPC 路由 =====
     disposers.push(ctx.inject(['webServer'], (wsCtx) => {
-      // 路由注册成功后打旗标：【手机适配】的汉堡角标据此决定要不要轮询 status。
-      // 没有它的话，功能停用时角标会先打一次必然失败的请求 → 控制台一条 405/404，
-      // 与【用量记录】chip 当年同一个毛病（见 features/tokenlog/view.jsx 的 routeGone 闩锁）。
-      // 旗标与 __dshDockMobileDrawer / __dshDockWelcomeAck 同风格：宿主侧唯一事实，客户端只读。
-      wsCtx.effect(() => {
-        if (typeof window !== 'undefined') window.__dshDockRunstate = true
-        return () => { try { if (typeof window !== 'undefined' && window.__dshDockRunstate) delete window.__dshDockRunstate } catch { /* ignore */ } }
-      })
       wsCtx.effect(() => wsCtx.webServer.register({
         kind: 'prefix',
         path: '/dsh-dock/runstate',

package/features/runstate/view.jsx

@@ -1,8 +1,8 @@
 // dsh-dock · 功能模块【运行状态】· 客户端视图
 //
 // 两部分：
-//  1. View     —— 功能坞面板页：进行中任务（阶段 / 耗时 / 回合 / 工具 / Token / 等待确认）与最近完成一览；
-//  2. HomeStat —— 首页总揽概要（N 个任务进行中 / 等待确认 / 空闲 · 最近完成…）。
+//  1. View     —— 功能坞面板页：进行中任务（阶段 / 耗时 / 回合 / 工具 / Token / 等人介入）与最近完成一览；
+//  2. HomeStat —— 首页总揽概要（N 个任务进行中 / 等人介入 / 空闲 · 最近完成…）。
 //
 // 只读页面：数据全部来自宿主侧会话级任务追踪（src/task-track.js，与【任务动画】【任务通知】
 // 共用同一份实例），本模块不写任何配置——动效在 features/animation/、结束与确认提醒在
@@ -10,6 +10,7 @@
 //
 // Host 通信：fetch('dsh-dock/runstate/status')（见 features/runstate/host.js）。
 import { useState, useEffect } from "react";
+import { waitingCountOf, taskWaiting, taskApprovals, taskQuestions } from "../../src/shared.js";
 
 // ---------- Host RPC 桥接 ----------
 function rpcCall(method, args) {
@@ -108,22 +109,33 @@ function useRunState() {
 	return snap;
 }
 
-// 等待确认的审批项总数（标题、横幅与首页概要共用；任何分支之外都能引用）
+// 等人介入的项总数（审批项 + 待回答的提问；标题、横幅与首页概要共用）
+// 口径统一走 src/shared.js 的 waitingCountOf——别在这里另写一份，
+// 漏掉提问就会重演「明明在等用户答、界面却报卡住」那类误报。
 function waitingOf(active) {
-	return (active || []).reduce((n, t) => n + (Array.isArray(t.approvals) ? t.approvals.length : 0), 0);
+	return waitingCountOf(active);
 }
 
 // ---------- 任务卡 ----------
 function TaskCard(props) {
 	const t = props.t;
 	const info = endInfo(t.endReason);
-	const waiting = !props.done && Array.isArray(t.approvals) && t.approvals.length > 0;
+	const waiting = !props.done && taskWaiting(t);
+	// 等批准与等回答是不同的动作：标签与明细分开写，用户一眼知道该去点"批准"还是"选答案"
+	const approvals = taskApprovals(t);
+	const questions = taskQuestions(t);
+	const waitLabel = approvals.length > 0
+		? "等待确认"
+		: (questions.length > 0 ? "等待回答" : "");
+	const waitDetail = approvals.length > 0
+		? approvals.map((a) => (a && a.toolName ? a.toolName : "未知工具") + (a && a.reason ? "：" + truncate(a.reason, 80) : "")).join("；")
+		: questions.map((q) => (q && q.header ? q.header : "提问") + (q && q.question ? "：" + truncate(q.question, 80) : "")).join("；");
 	return (
 		<div className="dkrs-task">
 			<div className="dkrs-task-head">
 				<span className="dkrs-task-title" title={t.title}>{t.title || "(无标题)"}</span>
 				{props.done ? <span className={"dkrs-tag " + info.cls}>{info.label}</span>
-					: waiting ? <span className="dkrs-tag warn">等待确认</span>
+					: waiting ? <span className="dkrs-tag warn">{waitLabel}</span>
 						: <span className="dkrs-tag on">{phaseLabel(t.phase)}</span>}
 			</div>
 			<div className="dkrs-task-meta">
@@ -133,10 +145,8 @@ function TaskCard(props) {
 				{t.totalTokens ? <span>{"↧" + fmtCompact(t.inputTokens) + " ↥" + fmtCompact(t.outputTokens)}</span> : null}
 				{props.done && t.endTime ? <span>{fmtTime(t.endTime)}</span> : null}
 			</div>
-			{waiting ? (
-				<div className="dkrs-task-wait">
-					{t.approvals.map((a, i) => (a && a.toolName ? a.toolName : "未知工具") + (a && a.reason ? "：" + truncate(a.reason, 80) : "")).join("；")}
-				</div>
+			{waiting && waitDetail ? (
+				<div className="dkrs-task-wait">{waitDetail}</div>
 			) : null}
 			{props.done && t.errorMessage ? <div className="dkrs-task-err">{truncate(t.errorMessage, 120)}</div> : null}
 		</div>
@@ -150,6 +160,13 @@ function RunStateView() {
 	const active = st && st.active ? st.active : [];
 	const recent = st && st.recent ? st.recent.slice(0, 10) : [];
 	const waitingCount = waitingOf(active);
+	// 等待的性质要分开说：等批准是"要不要执行"，等回答是"选哪个答案"，用户要做的动作不同。
+	// 两类同时存在时并列点名，别用一句含糊的「等待确认」把提问也吞进去。
+	const waitApprovals = (active || []).reduce((n, t) => n + taskApprovals(t).length, 0);
+	const waitQuestions = (active || []).reduce((n, t) => n + taskQuestions(t).length, 0);
+	const waitBannerHint = waitApprovals > 0 && waitQuestions > 0
+		? waitApprovals + " 项等批准、" + waitQuestions + " 项等你回答"
+		: waitApprovals > 0 ? "任务停在需要你批准的步骤上" : "任务在等你回答问题";
 	// 面板打开期间自动刷新：有任务 2s（阶段/耗时/待确认跟得上），空闲 8s，出错 15s。
 	// 本模块没有常驻浮层，所以关掉面板即停止轮询。
 	useEffect(() => {
@@ -167,7 +184,7 @@ function RunStateView() {
 
 	const sub = snap.error ? "状态拉取失败：" + snap.error
 		: !st ? (snap.loading ? "正在拉取任务状态…" : "等待任务状态")
-			: waitingCount > 0 ? waitingCount + " 项等待确认 · " + active.length + " 个任务进行中"
+			: waitingCount > 0 ? waitingCount + " 项等你介入 · " + active.length + " 个任务进行中"
 				: active.length > 0 ? active.length + " 个任务进行中"
 					: recent.length > 0 ? "空闲 · 显示最近完成" : "空闲 · 暂无任务记录";
 
@@ -182,7 +199,7 @@ function RunStateView() {
 					</button>
 				</div>
 				{waitingCount > 0 ? (
-					<div className="dkrs-waitbanner">✋ {waitingCount} 项等待确认：任务停在需要你批准的步骤上，请在会话里处理后继续。</div>
+					<div className="dkrs-waitbanner">✋ {waitingCount} 项等你介入：{waitBannerHint}，请在会话里处理后继续。</div>
 				) : null}
 				{active.length > 0 ? (
 					<div className="dkrs-tasks">{active.map((t) => <TaskCard key={t.sessionId} t={t} />)}</div>
@@ -217,7 +234,7 @@ function RunStateStat(props) {
 	if (!st) return <span>等待任务状态…</span>;
 	const active = st.active || [];
 	const waiting = waitingOf(active);
-	if (waiting > 0) return <span className="dkrs-warn">✋ {waiting} 项等待确认 · {active.length} 个任务进行中</span>;
+	if (waiting > 0) return <span className="dkrs-warn">✋ {waiting} 项等你介入 · {active.length} 个任务进行中</span>;
 	if (active.length > 0) {
 		return <span>{active.length + " 个任务进行中 · " + fmtDur(Math.max(...active.map((x) => x.elapsed || 0)))}</span>;
 	}
@@ -238,7 +255,7 @@ const css = [
 	".dkrs-sec-sub{font-size:11px;color:var(--dsw-alias-label-tertiary);flex:1;min-width:120px;}",
 	".dkrs-refresh{cursor:pointer;flex:none;color:var(--dsw-alias-label-primary);background:transparent;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:2px 10px;font-family:inherit;font-size:12px;}",
 	".dkrs-refresh:hover{background:var(--dsw-alias-interactive-bg-hover);}",
-	// 等待确认横幅：琥珀描边，常驻在列表上方（任务卡各自也带「等待确认」标签）
+	// 等人介入横幅：琥珀描边，常驻在列表上方（任务卡各自也带「等待确认」/「等待回答」标签）
 	".dkrs-waitbanner{border:1px solid color-mix(in srgb,var(--dk-warn) 45%,transparent);background:color-mix(in srgb,var(--dk-warn) 10%,transparent);color:var(--dk-warn);border-radius:8px;padding:6px 10px;font-size:12px;line-height:1.6;}",
 	".dkrs-done-title{font-size:12px;font-weight:600;color:var(--dsw-alias-label-secondary);}",
 	// 任务列表
@@ -262,7 +279,7 @@ export const feature = {
 	name: "运行状态",
 	order: 150,
 	accent: "#38bdf8",
-	description: "任务运行状态一览：进行中任务的阶段 / 耗时 / Token / 等待确认与最近完成记录（只读）",
+	description: "任务运行状态一览：进行中任务的阶段 / 耗时 / Token / 等人介入（等批准 / 等回答）与最近完成记录（只读）",
 	css,
 	View: RunStateView,
 	HomeStat: RunStateStat,

package/index.js

@@ -18,7 +18,6 @@
 //   - tts         语音朗读：把会话回复读出来（浏览器 TTS；宿主半部只管配置 + 共享任务追踪）
 //   - modelconfig 模型设置：模型目录的输入模态与思考强度（写回官方配置）
 //   - providerconfig 模型提供商：Provider 增删改 + API Key + 拉取上游模型列表
-//   - mobile      手机适配：窄屏排版/Tab 栏/抽屉/遮罩/键盘（宿主经 tapIndex 注入 index.html）
 //   - mobile-relay 远程访问：账号密码登录的远程入口（网关 + 账号 + 浏览模式目录选择器）
 import { DockConfig, sendJson, readBody, rejectUntrustedRequest, migrateNotifyConfig, migrateModelsFeatureId, migrateImportedFeatures, migrateImportedSections, bindDockConfig, readDockRoot, mutateDockSection } from './src/host-core.js'
 import { injectWelcomeAck } from './src/welcome-ack.js'
@@ -32,7 +31,6 @@ import { feature as fNotify } from './features/notify/host.js'
 import { feature as fRunState } from './features/runstate/host.js'
 import { feature as fTts } from './features/tts/host.js'
 import { feature as fMobileRelay } from './features/mobile-relay/host.js'
-import { feature as fMobile } from './features/mobile/host.js'
 
 export const name = 'dsh-dock'
 
@@ -76,7 +74,6 @@ export function apply(ctx, config) {
     fRunState,
     fTts,
     fMobileRelay,
-    fMobile,
   ]
 
   // 绑定 Config 镜像（替代已移除的 settings.get）；volatile 字段热更时重绑。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-dock",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "DeepSeek Harness 功能坞插件（dsh-dock）：模块化功能中枢——每个功能一个 features/ 模块（可单独提取成包发布，又可经 dockBridge 装回面板）。含用量记录（LLM 调用记账/费用统计，支持各模型自定义单价、多段分时价与周末/节假日谷价）、模型设置、图片理解代理、模型余额、任务动画（19 种运行动画 + 桌面伙伴 3D 场景）、任务通知（完成/异常/需确认通知、提示音、语音播报可选音色、系统通知、钉钉/飞书推送）、运行状态（进行中任务与最近完成一览）、语音朗读（浏览器 TTS 读回复：回合下方喇叭按钮 + 自动朗读）；侧栏入口 + 可拖拽弹窗（最大化/最小化/缩放）。",
   "type": "module",
   "main": "index.js",
@@ -43,7 +43,7 @@
   "scripts": {
     "build:client": "node scripts/build-client.mjs",
     "test:client": "node scripts/test-client-views.mjs",
-    "test:host": "node scripts/test-task-host.mjs && node scripts/test-tokenlog-host.mjs && node scripts/test-balance-host.mjs && node scripts/test-route-trust-host.mjs && node scripts/test-tts-host.mjs && node scripts/test-legacy-import.mjs && node scripts/test-mobile-host.mjs && node scripts/test-mobile-relay-host.mjs && node scripts/test-mobile-relay.mjs && node scripts/test-welcome-ack.mjs",
+    "test:host": "node scripts/test-task-host.mjs && node scripts/test-tokenlog-host.mjs && node scripts/test-balance-host.mjs && node scripts/test-route-trust-host.mjs && node scripts/test-tts-host.mjs && node scripts/test-legacy-import.mjs && node scripts/test-mobile-relay-host.mjs && node scripts/test-mobile-relay.mjs && node scripts/test-welcome-ack.mjs",
     "dev:client": "node scripts/watch-client.mjs",
     "dev:link": "node scripts/dev-link-deps.mjs"
   },

package/src/client.jsx

@@ -30,13 +30,12 @@ import { feature as fRunState } from "../features/runstate/view.jsx";
 import { feature as fTts } from "../features/tts/view.jsx";
 import { feature as fGames } from "../features/games/view.jsx";
 import { feature as fMobileRelay } from "../features/mobile-relay/view.jsx";
-import { feature as fMobile } from "../features/mobile/view.js";
 
 const name = "dsh-dock";
-const DOCK_VERSION = "0.18.0";
+const DOCK_VERSION = "0.20.0";
 
 // ---- 内置功能注册表：新功能 = features/<id>/ 加模块 + 这里 import 一行 ----
-const BUILTIN_FEATURES = [fTokenlog, fModelconfig, fProviderConfig, fHeartbeat, fTheme, fBalance, fAnimation, fNotify, fRunState, fTts, fGames, fMobileRelay, fMobile];
+const BUILTIN_FEATURES = [fTokenlog, fModelconfig, fProviderConfig, fHeartbeat, fTheme, fBalance, fAnimation, fNotify, fRunState, fTts, fGames, fMobileRelay];
 // 规划占位（路线图）：接入后移除并建 features/<id>/ 模块
 const PLANNED_FEATURES = [];
 const PLANNED_NOTES = {};

package/src/host-core.js

@@ -101,6 +101,15 @@ export const DockConfig = z.object({
     notifyOnError: z.boolean().default(true),
     // 工具等待用户确认/批准时提醒（dsh 会话流 approval/asked → decided）
     notifyOnConfirm: z.boolean().default(true),
+    // 卡住提醒卡片：编程阶段长时间无活动时弹一张（与 voiceOnStuck 同口径，但开关独立）
+    notifyOnStuck: z.boolean().default(true),
+    // 页内卡片总开关：关闭后右侧所有通知卡片一律不再弹出（含已挂着的）。
+    // 只管卡片——语音播报、提示音、系统通知、钉钉/飞书推送各有独立开关，不受它影响。
+    notifyCards: z.boolean().default(true),
+    // 卡片口径三挡（右侧卡片正文写多少）：brief = 任务与耗时/谁卡住；medium = 加模型、
+    // 起止时间、停滞时长；detailed = 全部（回合步骤、Token、摘要或错误、最后动作）。
+    // 默认 detailed ＝历史内容——未设置时卡片不缩水。
+    cardMode: z.string().default('detailed'),
     // 通知停留毫秒数（0 = 常驻直到手动关闭）
     notifyStayMs: z.number().default(8000),
     // 浏览器系统通知（页面后台时推送）
@@ -116,9 +125,11 @@ export const DockConfig = z.object({
     feishuEnabled: z.boolean().default(false),
     feishuWebhook: z.string().default(''),
     // ===== 语音播报（浏览器 speechSynthesis；与【语音朗读】同一套声音但相互独立开关） =====
-    // 总开关：关闭时下面所有播报都不发声（默认关，避免升级后突然说话吓人）。
+    // 服务端总开关（跨浏览器/跨设备）：关闭时所有浏览器都不播报（默认关，避免升级后突然说话吓人）。
+    // 客户端另有按浏览器保存的「本机播报」开关（localStorage，不进本配置）；两者都开才播报。
     voiceNotify: z.boolean().default(false),
-    // 播报口径：brief = 一句话（「任务完成」）；detailed = 带标题/耗时/回合/工具/错误原因。
+    // 播报口径三挡：brief = 一句话；medium = 点名任务 + 原因/耗时/停滞时长；
+    // detailed = 带标题/耗时/回合统计/工具名/最后动作。
     voiceMode: z.string().default('brief'),
     // 四个播报时刻，各自独立开关（开总开关后按这里筛选）：
     voiceOnComplete: z.boolean().default(true),   // 任务正常完成
@@ -259,6 +270,7 @@ export async function mutateDockSection(ctx, path, value, expectedRevision) {
 /** 通知配置字段清单（schema、迁移、客户端默认值三处共用同一份键名）。 */
 export const NOTIFY_FIELDS = [
   'notifyOnComplete', 'notifyOnError', 'notifyOnConfirm', 'notifyStayMs',
+  'notifyOnStuck', 'notifyCards', 'cardMode',
   'systemNotify', 'soundNotify', 'soundEffect',
   'dingtalkEnabled', 'dingtalkWebhook', 'feishuEnabled', 'feishuWebhook',
   // 语音播报（新增段字段；旧 animation 段里不存在，迁移循环自然不会搬它们）

package/src/shared.js

@@ -193,3 +193,89 @@ export function subscribePanel(fn) {
 	navListeners.add(fn);
 	return () => { navListeners.delete(fn); };
 }
+
+// ---- 等人介入（等待确认 / 等待回答）的统一口径 ----
+// 宿主快照里有两类「任务停在原地等人」：
+//   approvals —— 工具等待批准（approval/asked → approval/decided）；
+//   questions —— 提问等待回答（tool/call ask_user_question → tool/result）。
+// 两者语义相同（不动手就不会继续），但来源与文案不同。历史教训（2026-11-01 用户反馈）：
+// 只有 approvals 被当成「等人」，提问挂起期间会话零事件，18 秒后被卡住判定误报成
+// 「主任务卡住了」——界面在报卡住，实际是等人选答案。凡「是否在等人」的判断都走
+// 这里的统一口径，别各处各写一份（漏一处就又是一次误报）。
+/** 任务等待批准的审批项（缺字段时给空数组，老宿主快照没有该字段）。 */
+export function taskApprovals(task) {
+	return task && Array.isArray(task.approvals) ? task.approvals : [];
+}
+/** 任务等待回答的提问（缺字段时给空数组，老宿主快照没有该字段）。 */
+export function taskQuestions(task) {
+	return task && Array.isArray(task.questions) ? task.questions : [];
+}
+/** 任务是否停在原地等人（等批准或等回答）。 */
+export function taskWaiting(task) {
+	return taskApprovals(task).length > 0 || taskQuestions(task).length > 0;
+}
+/** 等人介入的项数（审批项 + 提问数），标题、横幅与角标共用。 */
+export function waitingCountOf(active) {
+	return (active || []).reduce((n, t) => n + taskApprovals(t).length + taskQuestions(t).length, 0);
+}
+
+// ---- 「还在动」与「真的停了」的统一口径 ----
+// 卡住判定误报过两次，毛病是同一个：只看「最后一个事件的时间」，把「会话在忙但事件
+// 暂时没落地」当成停滞。
+//   · 2026-11-01：提问挂起等用户答（零事件）→ 误报「主任务卡住了」（由 taskWaiting 兜住）。
+//   · 2026-11-02：压缩上下文 / 等模型回包（零事件）→ 25 分钟里误报 18 次，最长 96.7 秒，
+//     全部落在 compaction/start → compaction/end 之间（实测会话，工具调用最长只有 7.5 秒）。
+// 所以「还在动」要看三类信号，并且只在这里定义一次（notify 的卡住判定与 animation 的
+// 卡住姿态都走这里，别各处各写一份）：
+//   1) 最近活动时间 = max(lastActivityAt, lastMotionAt, phaseAt)：流式输出（assistant/chunk）
+//      只刷 lastMotionAt，漏掉它就会把正在刷字的会话当停滞；
+//   2) 有在飞的工具调用（pendingTool）：长命令（构建 / 全量测试）期间没有事件，但确实在跑；
+//   3) 正在压缩上下文（compacting）：compaction 全程同样零事件。
+// 后两类给一个上限（TASK_BUSY_MS）：真挂死（工具永不返回 / 压缩永不结束）仍要能报出来，
+// 不能因为「有在飞的调用」就永远不报。
+/** 卡住阈值：编程阶段多久没动静算停滞（宿主可用 stuckMs 覆盖）。 */
+export const TASK_STALL_MS = 18000;
+/** 「在飞」信号的有效上限：超过这个时长仍无任何事件，就按真停滞处理。 */
+export const TASK_BUSY_MS = 180000;
+
+function numOf(v) {
+	const n = Number(v);
+	return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+/** 任务最近一次「有动静」的时间：取活动时间、流式动作时间、阶段切换时间三者最大值。 */
+export function taskActivityAt(task) {
+	if (!task) return 0;
+	return Math.max(numOf(task.lastActivityAt), numOf(task.lastMotionAt), numOf(task.phaseAt));
+}
+
+/** 任务是否「正在忙」（有在飞的工具调用 / 正在压缩上下文），与耗时无关的那部分信号。 */
+export function taskBusy(task, now, capMs) {
+	if (!task) return false;
+	const at = typeof now === "number" ? now : Date.now();
+	const cap = typeof capMs === "number" && capMs > 0 ? capMs : TASK_BUSY_MS;
+	if (task.compacting === true) {
+		const since = numOf(task.compactStartedAt);
+		if (!since || at - since < cap) return true;
+	}
+	if (typeof task.pendingTool === "string" && task.pendingTool) {
+		const since = numOf(task.toolStartedAt);
+		if (!since || at - since < cap) return true;
+	}
+	return false;
+}
+
+/**
+ * 卡住判定：返回已停滞时长（毫秒），不算卡住时返回 0。
+ * 等人介入、有在飞调用、正在压缩上下文一律返回 0（那都不是卡住）。
+ */
+export function taskStalled(task, now, thresholdMs) {
+	if (!task || taskWaiting(task) || taskBusy(task, now)) return 0;
+	const at = typeof now === "number" ? now : Date.now();
+	const limit = typeof thresholdMs === "number" && thresholdMs > 0 ? thresholdMs : TASK_STALL_MS;
+	const lastAct = taskActivityAt(task);
+	if (!lastAct) return 0;
+	const stalled = at - lastAct;
+	return stalled >= limit ? stalled : 0;
+}
+

package/src/task-track.js

@@ -72,6 +72,29 @@ function createTracker(ctx) {
 		return 'code'
 	}
 
+	/**
+	 * ask_user_question 的调用参数 → 快照里够用的提问摘要。
+	 * 解析失败不报错：参数拿不到就当「有一问在等人答」，标题留空由客户端兜底
+	 * （宁可少说一句，也不要因为解析异常把整条任务追踪打断）。
+	 * @param {unknown} rawArguments 工具调用的 arguments（JSON 字符串）
+	 * @param {number} askedAt 提问时间（事件时间，不用本地钟）
+	 * @returns {{header: string, question: string, count: number, askedAt: number}}
+	 */
+	function describeQuestion(rawArguments, askedAt) {
+		const summary = { header: '', question: '', count: 1, askedAt }
+		try {
+			const parsed = typeof rawArguments === 'string' ? JSON.parse(rawArguments) : rawArguments
+			const list = parsed && Array.isArray(parsed.questions) ? parsed.questions : []
+			if (list.length > 0) summary.count = list.length
+			const first = list[0]
+			if (first && typeof first === 'object') {
+				if (typeof first.header === 'string') summary.header = truncate(first.header, 60)
+				if (typeof first.question === 'string') summary.question = truncate(first.question, 200)
+			}
+		} catch { /* 参数不是合法 JSON：留空摘要，提问本身照样算「等人答」 */ }
+		return summary
+	}
+
 	// 会话标题：官方标题服务，取不到回退首条用户输入（firstPrompt）
 	async function getSessionTitle(sessionId, sessionQuery) {
 		try {
@@ -88,6 +111,32 @@ function createTracker(ctx) {
 		return ''
 	}
 
+	/**
+	 * 会话标题 + 主/子任务归属：优先 readTitleSnapshot（一次观测同时拿到标题与会话头），
+	 * 会话头里的 origin === 'subagent' / delegationDepth 是权威的子任务标记（见 dsh-session
+	 * SessionHeader），fallback 路径只拿标题、按主任务处理。取不到头不报错——播报退化为
+	 * 不带归属的旧口径，功能不受影响（测试桩只需实现 readTitle/readSession 也能跑）。
+	 * @returns {Promise<{ title: string, header: object|null }>}
+	 */
+	async function readSessionFacts(sessionId, sessionQuery) {
+		const facts = { title: '', header: null }
+		if (!sessionQuery) return facts
+		try {
+			if (typeof sessionQuery.readTitleSnapshot === 'function') {
+				const obs = await sessionQuery.readTitleSnapshot(sessionId)
+				if (obs) {
+					const t = obs.title
+					if (typeof t === 'string') facts.title = t
+					else if (t && typeof t.title === 'string') facts.title = t.title
+					if (obs.session && typeof obs.session === 'object') facts.header = obs.session
+					if (facts.title || facts.header) return facts
+				}
+			}
+		} catch { /* 换下一种读法 */ }
+		facts.title = await getSessionTitle(sessionId, sessionQuery)
+		return facts
+	}
+
 	function addActiveSession(sid, sessionQuery, extra = {}) {
 		if (activeSessions.has(sid)) return activeSessions.get(sid)
 		// 不在终端打「任务开始」日志：开始/结束状态界面（运行状态页）已实时可见
@@ -108,8 +157,28 @@ function createTracker(ctx) {
 			errorMessage: '',
 			lastText: '',
 			firstPrompt: '',
+			// 主/子任务归属 + 最近一次调用的工具：卡住播报与卡住卡要说清「哪里卡住、最后在干什么」
+			//（isSubtask 由会话头 origin/delegationDepth 异步判定，判定前按主任务处理）
+			isSubtask: false,
+			parentSessionId: '',
+			lastToolName: '',
 			// 工具等待用户确认（dsh 会话流 approval/asked）：浏览器侧据此弹"需确认"通知
 			approvals: new Map(), // approvalId -> { toolName, reason, askedAt }
+			// 用户提问等待回答（dsh 会话流 tool/call ask_user_question → tool/result）：
+			// 与 approvals 同属「等人介入」。不记它的后果是实测过的（2026-11-01 用户反馈：
+			// 会话在等用户选答案，界面却报「主任务卡住了」）——提问期间会话天然零事件，
+			// 18 秒安静被卡住判定当成停滞。提问是**等回答**，不是卡住。
+			questions: new Map(), // callId -> { header, question, count, askedAt }
+			// 在飞的工具调用（tool/call → tool/result）：长命令（构建/全量测试）期间会话零事件，
+			// 但任务确实在跑。客户端靠它区分「正在跑长命令」与「真卡住」。
+			pendingTool: '',
+			toolStartedAt: 0,
+			// 上下文压缩（compaction/start → compaction/end）：压缩全程同样零事件，
+			// 实测 2026-11-02 的 25 分钟会话里 25 次长停顿有 18 次落在压缩窗口内
+			// （最长 96.7 秒），全被卡住判定误报。压缩是**正在干活**，不是卡住。
+			compacting: false,
+			compactStartedAt: 0,
+			compactId: '',
 			phase: 'think',
 			phaseAt: Date.now(),
 			lastActivityAt: Date.now(),
@@ -120,10 +189,17 @@ function createTracker(ctx) {
 			...extra,
 		}
 		activeSessions.set(sid, record)
-		getSessionTitle(sid, sessionQuery).then((title) => {
+		readSessionFacts(sid, sessionQuery).then((facts) => {
 			const s = activeSessions.get(sid)
-			if (s) s.title = title
-		})
+			if (!s) return
+			if (facts.title) s.title = facts.title
+			const h = facts.header
+			if (h) {
+				s.isSubtask = h.origin === 'subagent'
+					|| (typeof h.delegationDepth === 'number' && h.delegationDepth > 0)
+				s.parentSessionId = typeof h.parentSession === 'string' && h.parentSession ? h.parentSession : ''
+			}
+		}).catch(() => { /* 标题/归属读失败：title 走 firstPrompt 兜底，归属按主任务 */ })
 		return record
 	}
 
@@ -229,9 +305,52 @@ function createTracker(ctx) {
 			s.toolCalls++
 			s.phase = phaseOfToolName(event.data && event.data.name)
 			s.phaseAt = now
+			// 记下最后调用的工具名：卡住播报/卡住卡要回答「最后在干什么」
+			const called = event.data && typeof event.data.name === 'string' ? event.data.name : ''
+			if (called) s.lastToolName = called
+			// 记下在飞调用：长命令跑起来后到结果落地之间没有事件，靠它别误报卡住
+			s.pendingTool = called || 'tool'
+			s.toolStartedAt = now
+			// ask_user_question 是**阻塞式等人回答**：调用发出后到用户提交答案之间，会话
+			// 一条事件都不会有（实测 2026-11-01：提问挂起 66 秒，其间零事件）。把它记成
+			// 「等人介入」的一种，卡住判定才不会把这段安静误判成停滞。
+			if (called === 'ask_user_question') {
+				const callId = typeof event.data.callId === 'string' ? event.data.callId : ''
+				if (callId) s.questions.set(callId, describeQuestion(event.data.arguments, now))
+			}
 			// 工具启动是稀疏事件，给一个更明显的短促动作，检索/写文件也不会显得停住。
 			s.motionTicks += s.phase === 'search' ? 7 : 9
 			s.lastMotionAt = now
+		} else if (event.type === 'tool/result') {
+			// 提问的回答（或超时/取消）落地 → 提问结束，恢复普通追踪。
+			// 时间字段用事件时间，保证「答完那一刻」就是新的活动起点。
+			const msg = event.data && event.data.message
+			const callId = msg && typeof msg.toolCallId === 'string' ? msg.toolCallId : ''
+			if (callId) s.questions.delete(callId)
+			// 调用落地 → 不再有在飞的调用（同一时刻只会有一个工具在跑）
+			s.pendingTool = ''
+			s.toolStartedAt = 0
+		} else if (event.type === 'compaction/start' && event.data) {
+			// 压缩上下文开始：期间会话零事件，但这是**正在干活**。记成在忙，别按停滞算。
+			s.compacting = true
+			s.compactStartedAt = now
+			s.compactId = typeof event.data.compactionId === 'string' ? event.data.compactionId : ''
+			s.lastActivityAt = now
+		} else if (event.type === 'compaction/summary' && event.data) {
+			// 压缩出摘要：仍在压缩中（llmStreamCall 表示还在等模型），只刷活动时间
+			s.lastActivityAt = now
+		} else if (event.type === 'compaction/end' && event.data) {
+			// 压缩收尾：解除在忙状态；compactionId 不一致说明是另一个窗口的迟到事件，不误清
+			const endId = typeof event.data.compactionId === 'string' ? event.data.compactionId : ''
+			if (!endId || !s.compactId || endId === s.compactId) {
+				s.compacting = false
+				s.compactStartedAt = 0
+				s.compactId = ''
+			}
+			s.lastActivityAt = now
+		} else if (event.type === 'compaction/prune' && event.data) {
+			// 修剪历史（不产摘要的轻量压缩）：也算在忙，但很快结束，只刷活动时间
+			s.lastActivityAt = now
 		} else if (event.type === 'user/message') {
 			if (!s.firstPrompt && event.data && event.data.content) {
 				const text = extractText(event.data.content)
@@ -329,7 +448,20 @@ function createTracker(ctx) {
 					lastActivityAt: s.lastActivityAt,
 					motionTicks: s.motionTicks,
 					lastMotionAt: s.lastMotionAt,
+					// 「在忙」信号：有在飞的工具调用 / 正在压缩上下文。卡住判定据此豁免
+					//（客户端口径见 src/shared.js 的 taskBusy / taskStalled）
+					pendingTool: s.pendingTool || '',
+					toolStartedAt: s.toolStartedAt || 0,
+					compacting: !!s.compacting,
+					compactStartedAt: s.compactStartedAt || 0,
+					// 卡住播报/卡住卡专用：主/子归属（会话头判定）与最后调用的工具
+					isSubtask: !!s.isSubtask,
+					parentSessionId: s.parentSessionId || '',
+					lastToolName: s.lastToolName || '',
 					approvals: [...s.approvals.entries()].map(([id, v]) => ({ id, ...v })),
+					// 等人回答的提问（ask_user_question 挂起中）：与 approvals 同属「等人介入」，
+					// 客户端据此显示「等待回答」而不是「卡住」。
+					questions: [...s.questions.entries()].map(([id, v]) => ({ id, ...v })),
 				})
 			}
 			return { now: at, active, recent: completedSessions.slice(0, 20) }