dsh-dock 0.19.0 → 0.21.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/features/tokenlog/view.jsx

@@ -1413,11 +1413,16 @@ export function TokenLogChip(props) {
 	const gone = isTokenlogRouteGone();
 	// chip 文案用紧凑人民币金额（2 位小数），避免撑爆输入卡工具行；
 	// 完整金额在 title 悬浮提示里。
-	const label = gone
+	// 手机上输入区工具行很窄：主文案（图标 + token 数）单独一段；费用放进 .dockchip-x，
+	// 窄屏由 CSS 隐藏，避免整条被截成「⛁ 2…」。完整信息仍在 title 悬浮提示里。
+	const hasData = !!t && !gone && !(snap.err && !t);
+	const labelIcon = hasData ? "⛁ " : "";
+	const labelMain = gone
 		? "用量·未启用"
 		: snap.err && !t
 		? (snap.err.includes("重启") || snap.err.includes("启用") ? "用量·未启用" : "用量·失败")
-		: (t ? "⛁ " + fmtCompact(t.totalTokens) + (t.cost > 0 ? " · " + fmtCostCny(t.cost, snap.rate) : "") : "⛁ …");
+		: (t ? fmtCompact(t.totalTokens) : "…");
+	const labelExtra = hasData && t.cost > 0 ? " · " + fmtCostCny(t.cost, snap.rate) : "";
 	const title = gone
 		? routeGoneMessage() + "\n（可在功能坞里启用「用量记录」）"
 		: t
@@ -1428,7 +1433,7 @@ export function TokenLogChip(props) {
 		<button type="button" className={"dockchip" + (snap.err && !t && !gone ? " err" : "")} title={title} aria-label="会话用量"
 			onClick={() => openPanel("tokenlog", { sessionId: sid, navAt: Date.now() })}>
 			<span className="dockchip-dot" style={{ background: gone ? "var(--dsw-alias-label-tertiary,#8b95ab)" : "var(--dk-warn)" }} />
-			<span>{label}</span>
+			{labelIcon ? <span className="dockchip-ic">{labelIcon}</span> : null}<span>{labelMain}</span>{labelExtra ? <span className="dockchip-x">{labelExtra}</span> : null}
 		</button>
 	);
 }

package/index.js

@@ -18,8 +18,8 @@
 //   - tts         语音朗读：把会话回复读出来（浏览器 TTS；宿主半部只管配置 + 共享任务追踪）
 //   - modelconfig 模型设置：模型目录的输入模态与思考强度（写回官方配置）
 //   - providerconfig 模型提供商：Provider 增删改 + API Key + 拉取上游模型列表
-//   - mobile      手机适配：窄屏排版/Tab 栏/抽屉/遮罩/键盘（宿主经 tapIndex 注入 index.html）
 //   - mobile-relay 远程访问：账号密码登录的远程入口（网关 + 账号 + 浏览模式目录选择器）
+//   - mobile      手机适配：手机/窄屏体验优化（客户端运行时注入，关闭后零残留；宿主半部只留开关占位）
 import { DockConfig, sendJson, readBody, rejectUntrustedRequest, migrateNotifyConfig, migrateModelsFeatureId, migrateImportedFeatures, migrateImportedSections, bindDockConfig, readDockRoot, mutateDockSection } from './src/host-core.js'
 import { injectWelcomeAck } from './src/welcome-ack.js'
 import { feature as fModels } from './features/modelconfig/host.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-dock",
-  "version": "0.19.0",
+  "version": "0.21.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-mobile-host.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

@@ -33,7 +33,7 @@ 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.19.0";
+const DOCK_VERSION = "0.21.0";
 
 // ---- 内置功能注册表：新功能 = features/<id>/ 加模块 + 这里 import 一行 ----
 const BUILTIN_FEATURES = [fTokenlog, fModelconfig, fProviderConfig, fHeartbeat, fTheme, fBalance, fAnimation, fNotify, fRunState, fTts, fGames, fMobileRelay, fMobile];
@@ -164,6 +164,12 @@ const SHELL_CSS = [
 	".dockm-name{display:flex;align-items:center;gap:8px;font-weight:600;font-size:15px;}",
 	".dockm-desc{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.6;}",
 	".dockm-view{display:flex;flex-direction:column;gap:8px;border-top:1px solid var(--dsw-alias-border-l1);padding-top:10px;}",
+	".dockm-page{box-sizing:border-box;height:100%;overflow:auto;padding:20px 24px 32px;}",
+	".dockm-page-head{display:flex;align-items:flex-start;gap:10px;margin-bottom:16px;}",
+	".dockm-page-icon{flex:none;display:flex;align-items:center;justify-content:center;width:34px;height:34px;border-radius:10px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);}",
+	".dockm-page-titles{min-width:0;}",
+	".dockm-page-title{font-size:17px;font-weight:600;color:var(--dsw-alias-label-primary);line-height:1.3;}",
+	".dockm-page-sub{font-size:12px;color:var(--dsw-alias-label-tertiary);margin-top:2px;}",
 	".dockm-note{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.6;border-top:1px solid var(--dsw-alias-border-l1);padding-top:10px;}",
 	".dockm-err{color:var(--dsw-alias-state-error-primary);}",
 	".dockm-foot{margin-top:auto;display:flex;align-items:center;gap:8px;color:var(--dsw-alias-label-tertiary);font-size:11px;border-top:1px solid var(--dsw-alias-border-l1);padding-top:10px;flex-wrap:wrap;}",
@@ -195,7 +201,11 @@ const SHELL_CSS = [
 ".dockm-foot-swlabel.on{color:var(--dsw-alias-state-success-primary);}",
 	// 窄屏：功能坞是一级工作台而不是被压扁的桌面弹窗。全屏承接安全区，导航改横向，
 	// 禁用桌面拖拽/缩放，所有导航和关闭动作保持至少 44px 的可点击面积。
-	"@media (max-width:680px){.dockm-backdrop{align-items:stretch;justify-content:stretch;background:var(--dsw-alias-bg-layer-2);backdrop-filter:none}.dockm-dialog,.dockm-dialog.dockm-max{position:fixed!important;left:0!important;top:0!important;right:auto!important;bottom:auto!important;width:100dvw!important;height:100dvh!important;min-height:100dvh;border:0;border-radius:0;box-shadow:none}.dockm-dialog.dockm-min .dockm-body{display:flex}.dockm-head{min-height:60px;box-sizing:border-box;padding:calc(env(safe-area-inset-top) + 8px) 12px 8px;cursor:default;touch-action:manipulation}.dockm-sub,.dockm-win,.dockm-resize{display:none}.dockm-title{font-size:16px}.dockm-close{width:44px;height:44px;font-size:17px}.dockm-body{flex-direction:column;min-height:0}.dockm-nav{box-sizing:border-box;width:auto;max-width:100%;min-height:56px;flex-direction:row;gap:6px;padding:6px 10px;overflow-x:auto;overflow-y:hidden;border-right:0;border-bottom:1px solid var(--dsw-alias-border-l1);scrollbar-width:none;overscroll-behavior-x:contain}.dockm-nav::-webkit-scrollbar{display:none}.dockm-nav-item{flex:none;min-height:44px;padding:0 12px;font-size:13px;touch-action:manipulation}.dockm-nav-item .dockm-badge{display:none}.dockm-content{padding:16px max(16px,env(safe-area-inset-right)) calc(20px + env(safe-area-inset-bottom)) max(16px,env(safe-area-inset-left));gap:14px;overscroll-behavior:contain}.dockm-content-head{gap:5px}.dockm-name{font-size:16px}.dockm-desc{font-size:13px;line-height:1.55}.dockm-foot{padding-top:12px;font-size:11px}.dockm-foot-sw{width:100%;margin-left:0;justify-content:space-between}.dock-sw{width:44px;height:26px}.dock-sw::after{top:3px;left:3px;width:18px;height:18px}.dock-sw.on::after{transform:translateX(18px)}.dockh-grid{grid-template-columns:1fr;gap:10px}.dockh-card{padding:12px}.dockh-desc{font-size:13px}.dockh-go{font-size:12px}}",
+	"@media (max-width:680px){.dockm-backdrop{align-items:stretch;justify-content:stretch;background:var(--dsw-alias-bg-layer-2);backdrop-filter:none}.dockm-dialog,.dockm-dialog.dockm-max{position:fixed!important;left:0!important;top:0!important;right:auto!important;bottom:auto!important;width:100dvw!important;height:100dvh!important;min-height:100dvh;border:0;border-radius:0;box-shadow:none}.dockm-dialog.dockm-min .dockm-body{display:flex}.dockm-head{min-height:60px;box-sizing:border-box;padding:calc(env(safe-area-inset-top) + 8px) 12px 8px;cursor:default;touch-action:manipulation}.dockm-sub,.dockm-win,.dockm-resize{display:none}.dockm-title{font-size:16px}.dockm-close{width:44px;height:44px;font-size:17px}.dockm-body{flex-direction:column;min-height:0}.dockm-nav{box-sizing:border-box;width:auto;max-width:100%;min-height:56px;flex-direction:row;gap:6px;padding:6px 10px;overflow-x:auto;overflow-y:hidden;border-right:0;border-bottom:1px solid var(--dsw-alias-border-l1);scrollbar-width:none;overscroll-behavior-x:contain}.dockm-nav::-webkit-scrollbar{display:none}.dockm-nav-item{flex:none;min-height:44px;padding:0 12px;font-size:13px;touch-action:manipulation}.dockm-nav-item .dockm-badge{display:none}.dockm-content{padding:16px max(16px,env(safe-area-inset-right)) calc(20px + env(safe-area-inset-bottom)) max(16px,env(safe-area-inset-left));gap:14px;overscroll-behavior:contain}.dockm-content-head{gap:5px}.dockm-name{font-size:16px}.dockm-desc{font-size:13px;line-height:1.55}.dockm-foot{padding-top:12px;font-size:11px}.dockm-foot-sw{width:100%;margin-left:0;justify-content:space-between}.dock-sw{width:44px;height:26px}.dock-sw::after{top:3px;left:3px;width:18px;height:18px}.dock-sw.on::after{transform:translateX(18px)}.dockh-grid{grid-template-columns:minmax(0,1fr);gap:10px;min-width:0}.dockh-card{padding:12px;box-sizing:border-box;min-width:0}.dockh-desc{font-size:13px}.dockh-go{font-size:12px}}",
+	/* 手机端：功能坞弹层挂在 .overlayLayer(z20) 内，会被 z71 的侧栏抽屉盖住（只剩右侧一条）。\n	   把 overlayLayer 在窄屏抬到抽屉之上，面板才能全屏覆盖——且不依赖【手机适配】模块是否启用。 */
+	"@media (max-width:767px){[class*=\"overlayLayer\"]{z-index:100 !important}}",
+	/* 手机：输入卡里的「轮/步/token/缓存」状态条移到输入框上方，压成一行不溢出；空会话时把输入卡贴底 */
+	"@media (max-width:767px){[class*=\"scrollBody\"]>[class*=\"composerSeat\"]{margin-top:auto!important;padding-bottom:0!important}[class*=\"composerSeat\"] [class*=\"_dock\"]{order:-1!important;width:100%!important;max-width:100%!important;box-sizing:border-box!important;padding:0 2px 6px!important;gap:6px!important;font-size:10px!important;overflow:hidden!important}[class*=\"composerSeat\"] [class*=\"_dock\"]>*{min-width:0}}",
 	"@media (prefers-reduced-motion:reduce){.dockm-backdrop,.dockm-dialog{animation:none}.dockm-nav-item,.dockm-close,.dockm-win,.dock-sw{transition:none}}",
 	".dockh-desc{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.5;}",
 	".dockh-stat{color:var(--dsw-alias-label-tertiary);font-size:12px;border-top:1px solid var(--dsw-alias-border-l1);padding-top:6px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}",
@@ -221,7 +231,9 @@ const SHELL_CSS = [
 	".dockchip > span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0;}",
 	".dockchip:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary);}",
 	".dockchip .dockchip-dot{width:6px;height:6px;border-radius:50%;flex:none;}",
-	".dockchip.err{color:var(--dsw-alias-state-error-primary);}"
+	".dockchip.err{color:var(--dsw-alias-state-error-primary);}",
+	/* 手机：输入区工具行很窄，给 chips 稍多宽度，并隐藏费用等次要后缀（.dockchip-x），避免被截成「⛁ 2…／余…」 */
+	"@media (max-width:767px){.dockchip-row{max-width:min(216px,40cqw)}.dockchip-x{display:none}.dockchip{font-size:10px!important;padding:1px 2px!important;gap:3px!important}.dockchip .dockchip-dot{width:4px;height:4px}.dockchip-ic{display:none}.dockchip-pre{display:none}}"
 ].join("\n");
 
 let dockCssTag = null;
@@ -617,6 +629,19 @@ function DockPanel(props) {
 		}));
 }
 
+// ---- 功能坞主面板页（sidebar.panellist 一级入口 → main 面板） ----
+// 作为侧栏面板入口注册后，DSH 自带的入口自定义（Pin/更多）即可让用户把它固定在侧栏顶部
+// （“放到上面”），或取消固定收进侧栏「更多」菜单（“放到更多里”）。
+function DockPage() {
+	return react.createElement("div", { className: "dockm-page" },
+		react.createElement("div", { className: "dockm-page-head" },
+			react.createElement("span", { className: "dockm-page-icon" }, react.createElement(DockIcon, { size: 20 })),
+			react.createElement("div", { className: "dockm-page-titles" },
+				react.createElement("div", { className: "dockm-page-title" }, "功能坞"),
+				react.createElement("div", { className: "dockm-page-sub" }, "所有小功能集中在这里管理。侧栏图标可在「更多」菜单里 Pin 到顶部，或取消固定收进更多。"))),
+		react.createElement("div", { className: "dockm-page-body" }, react.createElement(DockPanel, { params: null })));
+}
+
 // ---- 会话输入区工具行 chips：已启用功能的随身小控件（模型选择器左侧） ----
 // 功能模块在 feature 描述符上挂可选 Chip 组件（props: { ctx, session, sessionId, input, feature }），
 // 启用即在 conversation.input.left 渲染；点击通常经 openPanel(...) 打开功能坞定位到对应功能页。
@@ -684,9 +709,14 @@ export function apply(ctx) {
 	const slots = ctx.get("slots");
 	if (slots === undefined) return;
 
-	slots.inject("sidebar.footer.action", () => slots.register(
-		{ name: "sidebar.footer.action", id: "dsh-dock", order: 1, label: "功能坞" },
-		(props) => react.createElement(DockEntry, props)));
+	// 侧栏一级入口（sidebar.panellist）+ 对应主面板（main）：注册成面板入口后，DSH 自带的
+	// 入口自定义可以「固定到左侧栏」= 显示在顶部图标区；取消固定 = 收进侧栏「更多」菜单。
+	slots.inject("sidebar.panellist", () => slots.register(
+		{ name: "sidebar.panellist", id: "dsh-dock", order: 30, label: "功能坞" },
+		(props) => react.createElement(DockIcon, { size: (props && props.size) || 18 })));
+	slots.inject("main", () => slots.register(
+		{ name: "main", key: "dsh-dock", label: "功能坞" },
+		() => react.createElement(DockPage, null)));
 	slots.inject("shell.overlay", () => slots.register(
 		{ name: "shell.overlay", id: "dsh-dock-panel", order: 21, label: "功能坞面板" },
 		() => react.createElement(DockModal, null)));

package/src/host-core.js

@@ -125,7 +125,8 @@ export const DockConfig = z.object({
     feishuEnabled: z.boolean().default(false),
     feishuWebhook: z.string().default(''),
     // ===== 语音播报（浏览器 speechSynthesis；与【语音朗读】同一套声音但相互独立开关） =====
-    // 总开关：关闭时下面所有播报都不发声（默认关，避免升级后突然说话吓人）。
+    // 服务端总开关（跨浏览器/跨设备）：关闭时所有浏览器都不播报（默认关，避免升级后突然说话吓人）。
+    // 客户端另有按浏览器保存的「本机播报」开关（localStorage，不进本配置）；两者都开才播报。
     voiceNotify: z.boolean().default(false),
     // 播报口径三挡：brief = 一句话；medium = 点名任务 + 原因/耗时/停滞时长；
     // detailed = 带标题/耗时/回合统计/工具名/最后动作。
@@ -141,6 +142,12 @@ export const DockConfig = z.object({
     voiceVolume: z.number().default(1),
     voiceLang: z.string().default(''),
     voiceURI: z.string().default(''),
+    // 事件 × 渠道开关矩阵：扁平键形如 card:complete / sound:error / system:confirm /
+    // voice:stuck / dingtalk:complete / feishu:error。未设置的键由客户端回退到旧的
+    // notifyOn* / voiceOn* 字段（升级不改变既有行为）。
+    eventMatrix: z.dict(z.boolean()).default({}),
+    // 群机器人消息口径三挡：brief / medium / detailed（宿主发消息时按此裁剪正文）。
+    pushMode: z.string().default('detailed'),
     // 一次性迁移标记：animation 段的旧通知配置已搬到本段（搬完置 true，避免每次启动重复写）
     migratedFromAnimation: z.boolean().default(false),
   }).default({}).volatile(),

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 {
@@ -141,6 +164,21 @@ function createTracker(ctx) {
 			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(),
@@ -270,9 +308,49 @@ function createTracker(ctx) {
 			// 记下最后调用的工具名：卡住播报/卡住卡要回答「最后在干什么」
 			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)
@@ -370,11 +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) }