dsh-activity-pane 0.3.0 → 0.6.0

package/.dsh-plugin/client.js

@@ -9,7 +9,7 @@ window.__ModuleLoader__.load({
 //
 // 数据源约定（来自 @deepseek-ai/dsh-client-runtime 的 sessions.list 快照）：
 //   ids: SessionId[]                     —— 宿主列表顺序（祖先在前的 lineage 顺序）
-//   byId[id]: { id, displayTitle, title?, cwd?, parentId?, running, completed?,
+//   byId[id]: { id, displayTitle, title?, cwd?, parentId?, origin?, running, completed?,
 //              pendingInteraction?: 'approval'|'plan-review'|'question', blank, ... }
 //   current: SessionId | undefined
 //   subagentsByParent: { [parentId]: { entries: [{ id, label, ... }] } }
@@ -17,8 +17,8 @@ window.__ModuleLoader__.load({
 // 以及 workspaces.list 的 items: [{ title, path, sessionIds }]。
 //
 // 展示规则：
-//   主会话（无有效 parentId）：running || completed || pendingInteraction 都显示；
-//   子代理：仅 running || pendingInteraction 时显示（结束后即消失）；
+//   主会话（非有效子代理行）：running || completed || pendingInteraction 都显示；
+//   子代理（origin === 'subagent' 且 parentId 有效）：仅 running || pendingInteraction 时显示（结束后即消失）；
 //   pendingInteraction 总是优先视为"等待用户行动"（即使在 running 中）。
 
 const PENDING_LABELS = {
@@ -1073,6 +1073,31 @@ function usageSummary({ uncachedInputTokens = null, cacheReadTokens = null, cach
 	return { inputTokens, cacheHitPct };
 }
 
+/** 从 sessions.list 的投影统一归一卡片统计：运行卡与最近卡共享同一口径。 */
+function statsFromProjection(projection = null, elapsedMs = null) {
+	const usage = isRecord(projection?.tokenUsage) ? projection.tokenUsage : {};
+	const sessionStats = isRecord(projection?.sessionStats) ? projection.sessionStats : {};
+	const rateTokS = Number.isFinite(sessionStats.decodeMs) && sessionStats.decodeMs > 0
+		? sessionStats.decodeTokens / (sessionStats.decodeMs / 1000)
+		: null;
+	return {
+		...runtimeStats({ elapsedMs, outputTokens: usage.outputTokens, rateTokS }),
+		...usageSummary(usage),
+	};
+}
+
+/** 统计字段按字段合并：当前值有效时优先，否则回退到上一份已知值；不合并 elapsedMs。 */
+function mergeRuntimeStats(current = null, fallback = null) {
+	const currentStats = isRecord(current) ? current : {};
+	const fallbackStats = isRecord(fallback) ? fallback : {};
+	return {
+		outputTokens: currentStats.outputTokens ?? fallbackStats.outputTokens ?? null,
+		inputTokens: currentStats.inputTokens ?? fallbackStats.inputTokens ?? null,
+		cacheHitPct: currentStats.cacheHitPct ?? fallbackStats.cacheHitPct ?? null,
+		rateTokS: currentStats.rateTokS ?? fallbackStats.rateTokS ?? null,
+	};
+}
+
 /** 需要用户行动的种类的展示文案。 */
 function pendingText(kind) {
 	return PENDING_LABELS[kind] ?? PENDING_UNKNOWN_LABEL;
@@ -1174,8 +1199,8 @@ function escapeCssString(value) {
  *  windowComplete（R-01-009/AC-06、R-01-012/AC-12 冷窗口兜底）：快照已就绪但窗口缺
  *  锚点数据（开放回合起点或可锚用户行在窗口外）时为 false——此时仍发起一次 history
  *  补读，供进度锚点与指令锚行兜底。previewFallbackNeeded 表示最近卡的快照预览
- *  不完整，同样补读一次 history（R-01-013/AC-03、AC-04）；durationFallbackNeeded 表示等待卡
- *  需要在已加载的旧 history 之后再取一次最新回合边界（R-01-009/AC-12）。 */
+ *  不完整，同样补读一次 history（R-01-013/AC-03、AC-04）；durationFallbackNeeded 表示等待卡或最近卡
+ *  需要在已加载的旧 history 之后再取一次最新回合边界（R-01-009/AC-12、R-01-013/AC-12）。 */
 function detailLoadPlan({
 	detail = {},
 	isSubagent = false,
@@ -1256,11 +1281,11 @@ function workspaceInfoForSession(sessionId, workspaceItems, byId = {}) {
 }
 
 /**
- * 工作区徽标色相（R-01-003/AC-08、AC-09）：以工作区身份为唯一输入的纯函数——
+ * 工作区徽标基色色相（R-01-003/AC-08、AC-09）：以工作区身份为唯一输入的纯函数——
  * djb2 哈希经雪崩终混（异或右移 + 乘法，把高位熵折入低位，消除 djb2 低位分布
  * 聚集；每步 >>> 0 保持无符号，异或结果可能带符号位）后在避开红色警戒区的
  * 色相弧 [30°,320°] 上均匀取色（30 + hash % 291），输出 [30,320] 整数。
- * 同一身份恒得同一色相，与工作区列表顺序、会话状态及持久化存储无关，页面
+ * 同一身份恒得同一基色色相，与工作区列表顺序、会话状态及持久化存储无关，页面
  * 刷新后不变；空身份返回 null。
  */
 function workspaceHue(key) {
@@ -1279,34 +1304,99 @@ function workspaceHue(key) {
 	return 30 + (hash % 291);
 }
 
-const WORKSPACE_HUE_ANCHORS = [55, 100, 145, 190, 235, 280, 325];
+const WORKSPACE_COLOR_SLOTS = Object.freeze([
+	{ slot: 0, hue: 55, darkL: 0.78, darkC: 0.16, lightL: 0.48, lightC: 0.15 },
+	{ slot: 1, hue: 100, darkL: 0.78, darkC: 0.16, lightL: 0.48, lightC: 0.15 },
+	{ slot: 2, hue: 145, darkL: 0.78, darkC: 0.16, lightL: 0.48, lightC: 0.15 },
+	{ slot: 3, hue: 190, darkL: 0.78, darkC: 0.16, lightL: 0.48, lightC: 0.15 },
+	{ slot: 4, hue: 235, darkL: 0.78, darkC: 0.16, lightL: 0.48, lightC: 0.15 },
+	{ slot: 5, hue: 280, darkL: 0.78, darkC: 0.16, lightL: 0.48, lightC: 0.15 },
+	{ slot: 6, hue: 325, darkL: 0.78, darkC: 0.16, lightL: 0.48, lightC: 0.15 },
+	{ slot: 7, hue: 77, darkL: 0.64, darkC: 0.15, lightL: 0.36, lightC: 0.15 },
+	{ slot: 8, hue: 122, darkL: 0.64, darkC: 0.15, lightL: 0.36, lightC: 0.15 },
+	{ slot: 9, hue: 167, darkL: 0.64, darkC: 0.15, lightL: 0.36, lightC: 0.15 },
+	{ slot: 10, hue: 257, darkL: 0.64, darkC: 0.15, lightL: 0.36, lightC: 0.15 },
+	{ slot: 11, hue: 302, darkL: 0.64, darkC: 0.15, lightL: 0.36, lightC: 0.15 },
+].map(Object.freeze));
+
+const WORKSPACE_BACKGROUND_SLOTS = Object.freeze([
+	{
+		slot: 0,
+		dark: Object.freeze({ l: 0.30, c: 0.05, mix: "26%", borderMix: "46%" }),
+		light: Object.freeze({ l: 0.92, c: 0.05, mix: "20%", borderMix: "34%" }),
+	},
+	{
+		slot: 1,
+		dark: Object.freeze({ l: 0.38, c: 0.06, mix: "31%", borderMix: "52%" }),
+		light: Object.freeze({ l: 0.84, c: 0.06, mix: "27%", borderMix: "42%" }),
+	},
+	{
+		slot: 2,
+		dark: Object.freeze({ l: 0.46, c: 0.07, mix: "36%", borderMix: "58%" }),
+		light: Object.freeze({ l: 0.76, c: 0.07, mix: "34%", borderMix: "50%" }),
+	},
+].map(Object.freeze));
+
+const WORKSPACE_PRIMARY_SLOT_COUNT = 7;
+const WORKSPACE_SECONDARY_SLOT_COUNT = WORKSPACE_COLOR_SLOTS.length - WORKSPACE_PRIMARY_SLOT_COUNT;
+
+function workspaceSlotProbe(start, count, step) {
+	return Array.from({ length: count }, (_, offset) => (start + offset * step) % count);
+}
 
 /**
- * 同屏工作区色相消解（R-01-003/AC-08、AC-12）：身份去重排序后，以稳定基色
- * 确定七个 OKLCH 感知锚点的起始槽；撞槽时按步进 3 跨色区探测。超过七个
- * 工作区后选择当前使用次数最少的槽，使复用均衡且确定。
+ * 同屏工作区复合颜色槽位消解（R-01-003/AC-08、AC-12）：前七个身份沿原七色
+ * OKLCH 主槽位分配，主槽位占满后再使用五个受控明度/色相补充槽位；每个前景槽位
+ * 内优先使用未用的三个背景变体；超过三十六个复合身份后按槽位使用次数均衡复用。
  */
-function resolveWorkspaceHues(keys) {
+function resolveWorkspaceColors(keys) {
 	const identities = [...new Set((Array.isArray(keys) ? keys : []).map(cleanText).filter(Boolean))].sort();
-	const uses = WORKSPACE_HUE_ANCHORS.map(() => 0);
+	const uses = WORKSPACE_COLOR_SLOTS.map(() => 0);
+	const backgroundUses = WORKSPACE_COLOR_SLOTS.map(() => WORKSPACE_BACKGROUND_SLOTS.map(() => 0));
 	const resolved = new Map();
 	for (const identity of identities) {
-		const start = (workspaceHue(identity) - 30) % WORKSPACE_HUE_ANCHORS.length;
-		let chosen = start;
-		for (let offset = 0; offset < WORKSPACE_HUE_ANCHORS.length; offset += 1) {
-			const candidate = (start + offset * 3) % WORKSPACE_HUE_ANCHORS.length;
-			if (uses[candidate] < uses[chosen]) chosen = candidate;
-			if (uses[candidate] === 0) {
-				chosen = candidate;
-				break;
-			}
+		const baseHue = workspaceHue(identity);
+		const primaryOrder = workspaceSlotProbe(
+			(baseHue - 30) % WORKSPACE_PRIMARY_SLOT_COUNT,
+			WORKSPACE_PRIMARY_SLOT_COUNT,
+			3,
+		);
+		const secondaryOrder = workspaceSlotProbe(
+			(baseHue - 30) % WORKSPACE_SECONDARY_SLOT_COUNT,
+			WORKSPACE_SECONDARY_SLOT_COUNT,
+			2,
+		).map((index) => WORKSPACE_PRIMARY_SLOT_COUNT + index);
+		const order = [...primaryOrder, ...secondaryOrder];
+		const backgroundOrder = workspaceSlotProbe(
+			(baseHue - 30) % WORKSPACE_BACKGROUND_SLOTS.length,
+			WORKSPACE_BACKGROUND_SLOTS.length,
+			2,
+		);
+		const availableForegroundOrder = order.filter((index) => backgroundOrder.some((backgroundSlot) => backgroundUses[index][backgroundSlot] === 0));
+		const foregroundOrder = availableForegroundOrder.length > 0 ? availableForegroundOrder : order;
+		let foregroundSlot = foregroundOrder.find((index) => uses[index] === 0);
+		if (foregroundSlot === undefined) {
+			foregroundSlot = foregroundOrder.reduce(
+				(best, index) => (uses[index] < uses[best] ? index : best),
+				foregroundOrder[0],
+			);
 		}
-		uses[chosen] += 1;
-		resolved.set(identity, WORKSPACE_HUE_ANCHORS[chosen]);
+		uses[foregroundSlot] += 1;
+		const backgroundUsesForForeground = backgroundUses[foregroundSlot];
+		const backgroundSlot = backgroundOrder.reduce(
+			(best, index) => (backgroundUsesForForeground[index] < backgroundUsesForForeground[best] ? index : best),
+			backgroundOrder[0],
+		);
+		backgroundUsesForForeground[backgroundSlot] += 1;
+		resolved.set(identity, {
+			foreground: WORKSPACE_COLOR_SLOTS[foregroundSlot],
+			background: WORKSPACE_BACKGROUND_SLOTS[backgroundSlot],
+		});
 	}
 	return resolved;
 }
 
+
 /** 主会话按左侧工作区顺序排序的权重；不在任何 workspace 的排在最后保持 lineage 顺序。 */
 function workspaceRank(workspaceItems) {
 	const wsIndex = new Map();
@@ -1361,6 +1451,7 @@ function mainTitle(byId, id) {
  *   - 主会话 running（且无 pending）或处于委托周期（含后代耗尽空窗）→ 'running'
  *   - 主会话 pendingInteraction / completed / errorReminder → 'awaiting'（等待用户行动）
  *   - 子代理 running / pending 或存在活动后代 → 'subagent'，自身与后代均不活动则不显示
+ *   - 普通 fork 虽有 parentId，但 origin 缺失，仍按独立主会话处理
  * completions（完成确认与错误提醒，R-01-002/AC-05、AC-13、R-01-010/AC-06）：Map id →
  * { lastTurnEnd, lastTurnEndKind, lastTurnEndError, ackedAt }，由渲染层从宿主侧 ack 状态
  * 通道注入；其中完成提醒成立（completionReminder）或错误提醒成立（errorReminder）的
@@ -1368,21 +1459,38 @@ function mainTitle(byId, id) {
  * 记账派生）：集合内会话视同处于委托周期——后代耗尽至 settle 处理回合启动的
  * 空窗内仍保持运行呈现、完成/错误提醒不生效；条目的 descendantActive 字段
  * 始终为当帧原始后代活性（供进度锚点记账判定耗尽），不受 delegatingIds 影响。
+ * archivedIds（工作区服务的注册表全局归档集合）：归档会话及其有效子代理子树不产出活动条目，
+ * 普通 fork 仅因共享来源 parentId 不受影响；避免会话服务仍保留旧行或完成提醒时在窗格中滞留。
  */
-function buildEntries(snapshot, workspaceItems, detailsById = {}, completions = null, delegatingIds = null) {
+function buildEntries(snapshot, workspaceItems, detailsById = {}, completions = null, delegatingIds = null, archivedIds = []) {
 	const byId = isRecord(snapshot) && isRecord(snapshot.byId) ? snapshot.byId : {};
 	const ids = Array.isArray(snapshot?.ids) ? snapshot.ids : [];
 	const current = snapshot?.current ?? null;
 	const subagentsByParent = isRecord(snapshot?.subagentsByParent)
 		? snapshot.subagentsByParent
 		: {};
+	const archived = archivedIds instanceof Set
+		? new Set([...archivedIds].map((id) => String(id)))
+		: new Set((archivedIds ?? []).map((id) => String(id)));
+	const isArchived = (id) => {
+		const seen = new Set();
+		let currentId = id;
+		while (currentId !== undefined && currentId !== null) {
+			const key = String(currentId);
+			if (archived.has(key) || seen.has(key)) return archived.has(key);
+			seen.add(key);
+			currentId = subagentParentId(byId[key], byId);
+		}
+		return false;
+	};
 	const rank = workspaceRank(workspaceItems ?? []);
-	const descendantIds = descendantActiveIds(byId);
+	const descendantIds = descendantActiveIds(byId, isArchived);
 	// 第一遍：层级关系 + 显示判定（show = 自身活动 || 委托周期 || 完成提醒，单点实现避免漂移）。
 	const rootIds = [];
 	const childIds = new Map();
 	const meta = new Map();
 	for (const id of ids) {
+		if (isArchived(id)) continue;
 		const row = byId[id];
 		if (!isRecord(row)) continue;
 		const hasParent = isSubagentRow(row, byId);
@@ -1600,10 +1708,15 @@ function listLoadState(snapshot) {
 	return "ready";
 }
 
-/** 会话行是否为某主会话的直属子代理。 */
+/** 会话行是否为某主会话的直属子代理：需同时满足 origin 与有效父会话。 */
 function isSubagentRow(row, byId = {}) {
 	const id = row?.parentId;
-	return id !== undefined && id !== null && isRecord(byId[id]);
+	return row?.origin === "subagent" && id !== undefined && id !== null && isRecord(byId[id]);
+}
+
+/** 取实际子代理的直属母会话 id；普通 fork 的 parentId 只是来源关系，不参与子代理树。 */
+function subagentParentId(row, byId = {}) {
+	return isSubagentRow(row, byId) ? row.parentId : undefined;
 }
 
 /** 会话行是否满足自身状态的活动判定，不含后代活动继承。
@@ -1617,31 +1730,32 @@ function isOwnActiveRow(row, byId = {}) {
 	return running || pending;
 }
 
-/** 沿自身活动会话的有效 parentId 链上溯收集会话 id：includeSelf 含活动会话自身，
+/** 沿实际子代理关系的有效 parentId 链上溯收集会话 id：includeSelf 含活动会话自身，
  *  否则只收祖先（存在活动后代的母会话）。活动区与历史区显示判定的单点实现。 */
-function lineageActiveIds(byId, includeSelf) {
+function lineageActiveIds(byId, includeSelf, isExcluded = null) {
 	const ids = new Set();
 	for (const [id, row] of Object.entries(byId)) {
-		if (!isOwnActiveRow(row, byId)) continue;
+		if (isExcluded?.(id) || !isOwnActiveRow(row, byId)) continue;
 		const seen = new Set();
-		let currentId = includeSelf ? id : row?.parentId;
+		let currentId = includeSelf ? id : subagentParentId(row, byId);
 		while (currentId !== undefined && currentId !== null && isRecord(byId[currentId]) && !seen.has(String(currentId))) {
+			if (isExcluded?.(currentId)) break;
 			seen.add(String(currentId));
 			ids.add(String(currentId));
-			currentId = byId[currentId]?.parentId;
+			currentId = subagentParentId(byId[currentId], byId);
 		}
 	}
 	return ids;
 }
 
-/** 沿活动会话的有效 parentId 链补齐活动祖先（含活动会话自身），供历史区显示判定。 */
+/** 沿实际子代理关系补齐活动祖先（含活动会话自身），供历史区显示判定。 */
 function activeSessionIds(byId = {}) {
 	return lineageActiveIds(byId, true);
 }
 
 /** 「存在活动后代」的母会话集合（不含活动会话自身），供 buildEntries 判定委托周期（R-01-003/AC-05）。 */
-function descendantActiveIds(byId = {}) {
-	return lineageActiveIds(byId, false);
+function descendantActiveIds(byId = {}, isExcluded = null) {
+	return lineageActiveIds(byId, false, isExcluded);
 }
 
 /** 判断活动条目是否需要建立轮内状态订阅：以宿主 running 为准、与呈现 kind 解耦——
@@ -2083,6 +2197,43 @@ function openSession(sessions, sessionId) {
 	}
 }
 
+/**
+ * 以最小必要距离把卡片滚入窗格滚动视口；不会居中，也不会滚动外层页面。
+ * 默认使用原生 smooth scroll，调用方可传 auto 适配降低动效偏好；缺少 scrollTo 或 options 不受支持时回退为同步滚动
+ * （R-01-006/AC-02）。
+ */
+function scrollCardIntoView(scroll, card, behavior = "smooth") {
+	if (typeof scroll?.getBoundingClientRect !== "function" || typeof card?.getBoundingClientRect !== "function")
+		return false;
+	const viewport = scroll.getBoundingClientRect();
+	const rect = card.getBoundingClientRect();
+	const delta = rect.top < viewport.top
+		? rect.top - viewport.top
+		: rect.bottom > viewport.bottom
+			? rect.bottom - viewport.bottom
+			: 0;
+	if (delta === 0) return false;
+	const currentTop = Number(scroll.scrollTop);
+	if (!Number.isFinite(currentTop)) return false;
+	const scrollHeight = Number(scroll.scrollHeight);
+	const clientHeight = Number(scroll.clientHeight);
+	const maxTop = Number.isFinite(scrollHeight) && Number.isFinite(clientHeight)
+		? Math.max(0, scrollHeight - clientHeight)
+		: Infinity;
+	const nextTop = Math.min(maxTop, Math.max(0, currentTop + delta));
+	if (!Number.isFinite(nextTop) || nextTop === currentTop) return false;
+	if (typeof scroll.scrollTo === "function") {
+		try {
+			scroll.scrollTo({ top: nextTop, behavior });
+			if (behavior !== "auto" || Number(scroll.scrollTop) !== currentTop) return true;
+		} catch (error) {
+			if (!(error instanceof TypeError)) throw error;
+		}
+	}
+	scroll.scrollTop = nextTop;
+	return Number(scroll.scrollTop) !== currentTop;
+}
+
 /** 原生会话输入框（dsh-client-ui-conversation composer 的 textarea）。 */
 const COMPOSER_SELECTOR = "textarea[data-phase]";
 
@@ -2595,23 +2746,41 @@ const CSS = `
 /* 复审修复（C-040、C-043）：状态点光晕三类同强度、仅换色相——阻塞金、完成绿与错误红光晕一致。 */
 /* 工作区徽标「图标+文本」双段：文件夹图标与左边栏工作区条目同源（R-01-003/AC-06）；
    名称字号不低于 10.5px（AC-07），行高保持 14px 以维持胶囊与卡片高度。
-   着色（AC-08～AC-11）：核心映射提供 OKLCH hue；深色主题文字取高明度中高彩度，
-   浅色主题文字取低明度中高彩度。文字直接使用调色板色，底色与描边在 OKLCH
-   空间按透明度混合；前景与背景始终同色相、明度对比拉开。 */
+   着色（AC-08～AC-12）：核心映射提供 12 个前景身份槽与每槽 3 个背景变体；
+   深色/浅色主题分别使用前景与背景槽位的 L/C 参数，文字使用前景调色板色，
+   底色使用独立背景源色、描边使用前景调色板色，分别在 OKLCH 空间按变体混合强度呈现；前景与背景保持同色相族。 */
 [data-dsh-activity-pane] .dap-workspace {
   width: fit-content; max-width: 100%; display: flex; align-items: center; gap: 3px;
   overflow: hidden;
   font-size: 10.5px; line-height: 14px;
-  --dap-workspace-color: oklch(0.78 0.16 var(--dap-workspace-hue, 235));
+  --dap-workspace-color: oklch(
+     var(--dap-workspace-dark-l, 0.78)
+     var(--dap-workspace-dark-c, 0.16)
+     var(--dap-workspace-hue, 235)
+   );
+  --dap-workspace-background-color: oklch(
+     var(--dap-workspace-bg-dark-l, 0.38)
+     var(--dap-workspace-bg-dark-c, 0.06)
+     var(--dap-workspace-hue, 235)
+   );
   color: var(--dap-workspace-color);
-  background: color-mix(in oklch, var(--dap-workspace-color) 14%, transparent);
-  border: 1px solid color-mix(in oklch, var(--dap-workspace-color) 34%, transparent);
+  background: color-mix(in oklch, var(--dap-workspace-background-color) var(--dap-workspace-bg-dark-mix, 31%), transparent);
+  border: 1px solid color-mix(in oklch, var(--dap-workspace-color) var(--dap-workspace-bg-dark-border-mix, 52%), transparent);
   border-radius: 999px; padding: 0 7px;
 }
 body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
-  --dap-workspace-color: oklch(0.48 0.15 var(--dap-workspace-hue, 235));
-  background: color-mix(in oklch, var(--dap-workspace-color) 10%, transparent);
-  border-color: color-mix(in oklch, var(--dap-workspace-color) 28%, transparent);
+  --dap-workspace-color: oklch(
+     var(--dap-workspace-light-l, 0.48)
+     var(--dap-workspace-light-c, 0.15)
+     var(--dap-workspace-hue, 235)
+   );
+  --dap-workspace-background-color: oklch(
+     var(--dap-workspace-bg-light-l, 0.84)
+     var(--dap-workspace-bg-light-c, 0.06)
+     var(--dap-workspace-hue, 235)
+   );
+  background: color-mix(in oklch, var(--dap-workspace-background-color) var(--dap-workspace-bg-light-mix, 27%), transparent);
+  border-color: color-mix(in oklch, var(--dap-workspace-color) var(--dap-workspace-bg-light-border-mix, 42%), transparent);
 }
 [data-dsh-activity-pane] .dap-workspace-icon { flex: none; display: inline-flex; }
 [data-dsh-activity-pane] .dap-workspace-icon svg { display: block; }
@@ -2649,14 +2818,10 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
   display: flex; flex-direction: column; align-items: flex-start; gap: 4px;
   min-width: 0; margin: 2px 0 0;
 }
-/* 等待类型胶囊与上一轮耗时同行：时长沿用运行统计行的右缘位置，不参与等待脉冲。 */
+/* 等待类型胶囊独立同行：耗时回到统计行最右侧，不参与等待脉冲。 */
 [data-dsh-activity-pane] .dap-await-head {
   display: flex; align-items: center; gap: 8px; align-self: stretch; min-width: 0;
 }
-[data-dsh-activity-pane] .dap-await-head .dap-token-time {
-  margin-left: auto; flex: none; font-size: 10px; line-height: 14px;
-  color: #8f9aaa; font-variant-numeric: tabular-nums;
-}
 [data-dsh-activity-pane] .dap-note-row {
   display: flex; align-items: center; gap: 6px; min-width: 0; align-self: stretch;
 }
@@ -2675,7 +2840,7 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
   color: color-mix(in srgb, currentColor 82%, transparent);
   background: color-mix(in srgb, currentColor 14%, transparent);
 }
-/* 运行卡富化（对齐 answer-pet 卡片；MIT 参考，见 README）。 */
+/* 运行卡与最近卡统计（对齐 answer-pet 卡片；MIT 参考，见 README）。 */
 [data-dsh-activity-pane] .dap-progress {
   display: flex; align-items: center; gap: 7px; min-width: 0;
 }
@@ -3158,16 +3323,18 @@ function apply(ctx) {
 	/** 等待条目 id/类别队列签名：变化时统一重启数量胶囊与等待卡末行动画对相（R-01-002/AC-07、AC-08）。 */
 	let pulseSignature = "";
 	// E2E-only deterministic seams（T-089/T-090）：显式 URL fragment 最多把本页首次列表 ready 呈现
-	// 或正式 models RPC 延后 1s；默认路径为 0，不伪造服务响应、快照或生产时序。
+	// 或正式 models RPC 延后 1s；列表延迟从首个窗格 render 开始计时，避免宿主启动耗时
+	// 把 pending 观察窗口提前消耗；默认路径为 0，不伪造服务响应、快照或生产时序。
 	const e2eParams = new URLSearchParams(window.location.hash.slice(1));
 	const requestedListDelay = Number(e2eParams.get("dap-e2e-list-delay"));
-	const e2eListReadyAt = Number.isFinite(requestedListDelay) && requestedListDelay > 0
-		? Date.now() + Math.min(requestedListDelay, 1_000)
+	const e2eListDelayMs = Number.isFinite(requestedListDelay) && requestedListDelay > 0
+		? Math.min(requestedListDelay, 1_000)
 		: 0;
 	const requestedModelDelay = Number(e2eParams.get("dap-e2e-model-delay"));
 	const e2eModelDelayMs = Number.isFinite(requestedModelDelay) && requestedModelDelay > 0
 		? Math.min(requestedModelDelay, 1_000)
 		: 0;
+	let e2eListReadyAt = 0;
 	let e2eListReleaseTimer = null;
 	const e2eModelDelayWaiters = new Map();
 	function delayedModelCall(call) {
@@ -3188,6 +3355,9 @@ function apply(ctx) {
 	let paneWidth = readStoredPaneWidth();
 	/** 用户最近一次激活的卡片 id；打开重试链被更新的激活意图取代即取消。 */
 	let lastActivatedId = null;
+	/** 最近一次已处理的当前卡片；同一卡片的运行时重绘不反复打断用户手动滚动。 */
+	let autoScrolledCurrentId = null;
+	let autoScrolledCurrentCard = null;
 	/** 完成确认状态（R-01-002/AC-03、AC-10～AC-12）：id → { lastTurnEnd, ackedAt }，
 	 *  来自宿主侧 ack 通道（SSE 全量快照），随每次推送整体替换。 */
 	const completeAcksById = new Map();
@@ -3214,7 +3384,7 @@ function apply(ctx) {
 	const livenessById = new Map();
 	/** 委托周期进度锚点记账：id → progressAnchor 状态（R-01-009/AC-06）。 */
 	const progressAnchorById = new Map();
-	/** 订阅停止后保留最近快照，供 awaiting/recent 卡继续显示上下文。 */
+	/** 订阅停止后保留最近快照与最后已知运行统计，供 awaiting/recent 卡继续显示上下文。 */
 	const sessionDetailsById = new Map();
 	/** 会话跳转的单一重试链；避免重复点击叠加 refresh/timer。 */
 	const openRetryStates = new Map();
@@ -3889,7 +4059,10 @@ function apply(ctx) {
 			const agentLabel = makeEl("span", "dap-history-label");
 			agentLabel.textContent = "助手";
 			agentLine.append(agentIcon, agentLabel, makeEl("span", "dap-history-separator"), makeEl("span", "dap-history-text"));
-			return [head, row, userLine, agentLine, makeEl("div", "dap-note")];
+			const statsRow = makeEl("div", "dap-token-stats");
+			statsRow.append(makeEl("span", "dap-token-main"), makeEl("span", "dap-token-time"));
+			statsRow.hidden = true;
+			return [head, row, userLine, agentLine, statsRow, makeEl("div", "dap-note")];
 		}
 		if (kind === "awaiting") {
 			const row = makeEl("div", "dap-row");
@@ -3903,10 +4076,13 @@ function apply(ctx) {
 			const noteRow = makeEl("div", "dap-note-row");
 			noteRow.append(makeEl("div", "dap-note"), makeConfirmButton());
 			const awaitHead = makeEl("div", "dap-await-head");
-			awaitHead.append(capsule, makeEl("span", "dap-token-time"));
+			awaitHead.append(capsule);
+			const statsRow = makeEl("div", "dap-token-stats");
+			statsRow.append(makeEl("span", "dap-token-main"), makeEl("span", "dap-token-time"));
+			statsRow.hidden = true;
 			const foot = makeEl("div", "dap-foot");
 			foot.append(awaitHead, noteRow);
-			return [head, row, makeEl("div", "dap-trace"), foot];
+			return [head, row, makeEl("div", "dap-trace"), statsRow, foot];
 		}
 		const row = makeEl("div", "dap-row");
 		row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"));
@@ -4267,14 +4443,19 @@ function apply(ctx) {
 		}
 	}
 
-	/** 统计行渲染：运行卡写入速率、token 与耗时，旧骨架缺节点时就地补齐。 */
+	/** 统计行渲染：运行卡、等待卡与最近卡写入速率、token 与耗时，旧骨架缺节点时就地补齐。 */
 	function renderTokenStats(el, entry) {
 		let stats = el.querySelector(".dap-token-stats");
 		if (stats === null) {
 			stats = makeEl("div", "dap-token-stats");
 			stats.append(makeEl("span", "dap-token-main"), makeEl("span", "dap-token-time"));
 			stats.hidden = true;
-			el.append(stats);
+			const foot = entry.kind === "awaiting" ? el.querySelector(".dap-foot") : null;
+			if (foot !== null) el.insertBefore(stats, foot);
+			else el.append(stats);
+		} else if (entry.kind === "awaiting") {
+			const foot = el.querySelector(".dap-foot");
+			if (foot !== null && stats.nextElementSibling !== foot) el.insertBefore(stats, foot);
 		}
 		let mainTextEl = stats.querySelector(".dap-token-main");
 		let timeEl = stats.querySelector(".dap-token-time");
@@ -4296,25 +4477,9 @@ function apply(ctx) {
 		if (stats.hidden !== statsHidden) stats.hidden = statsHidden;
 	}
 
-	/** 等待卡耗时写入：与等待类型胶囊同一行靠右，旧骨架缺该行时就地补齐。 */
-	function renderAwaitingDuration(el, entry) {
-		const foot = el.querySelector(".dap-foot");
-		if (foot === null) return;
-		let head = foot.querySelector(".dap-await-head");
-		if (head === null) {
-			const capsule = foot.querySelector(".dap-capsule");
-			if (capsule === null) return;
-			head = makeEl("div", "dap-await-head");
-			capsule.replaceWith(head);
-			head.append(capsule);
-		}
-		let time = head.querySelector(".dap-token-time");
-		if (time === null) {
-			time = makeEl("span", "dap-token-time");
-			head.append(time);
-		}
-		const text = Number.isFinite(entry.elapsedMs) && entry.elapsedMs >= 0 ? fmtElapsedMs(entry.elapsedMs) : "";
-		if (time.textContent !== text) time.textContent = text;
+	/** 旧热装等待骨架清理：耗时已迁回统计行，去掉胶囊同行残留的时长节点。 */
+	function removeAwaitingHeadDuration(el) {
+		el.querySelector(".dap-await-head .dap-token-time")?.remove();
 	}
 
 	/** 时间线区加载指示：数据在途且尚无工作项时显示活动图标行（R-01-014/AC-02）。 */
@@ -4341,22 +4506,40 @@ function apply(ctx) {
 		renderTrace(container, entry.timeline, { lastOnly });
 	}
 
-	function renderCardInto(el, entry, hueByWorkspace) {
+	function renderCardInto(el, entry, colorByWorkspace) {
 		const workspaceLabel = el.querySelector(".dap-workspace");
 		if (workspaceLabel !== null) {
 			const workspaceText = workspaceLabel.querySelector(".dap-workspace-text");
-			if (entry.workspaceTitle !== "") {
+			const color = colorByWorkspace.get(entry.workspaceKey);
+			const foreground = color?.foreground;
+			const background = color?.background;
+			const colorVariables = {
+				"--dap-workspace-hue": foreground?.hue,
+				"--dap-workspace-dark-l": foreground?.darkL,
+				"--dap-workspace-dark-c": foreground?.darkC,
+				"--dap-workspace-light-l": foreground?.lightL,
+				"--dap-workspace-light-c": foreground?.lightC,
+				"--dap-workspace-bg-dark-l": background?.dark?.l,
+				"--dap-workspace-bg-dark-c": background?.dark?.c,
+				"--dap-workspace-bg-dark-mix": background?.dark?.mix,
+				"--dap-workspace-bg-dark-border-mix": background?.dark?.borderMix,
+				"--dap-workspace-bg-light-l": background?.light?.l,
+				"--dap-workspace-bg-light-c": background?.light?.c,
+				"--dap-workspace-bg-light-mix": background?.light?.mix,
+				"--dap-workspace-bg-light-border-mix": background?.light?.borderMix,
+			};
+			if (entry.workspaceTitle !== "" && foreground !== undefined && background !== undefined) {
 				if (workspaceText !== null) restoreTextField(workspaceText, entry.workspaceTitle);
-				const hue = hueByWorkspace.get(entry.workspaceKey) ?? workspaceHue(entry.workspaceKey);
-				const hueText = hue === null ? "" : String(hue);
-				if (workspaceLabel.style.getPropertyValue("--dap-workspace-hue") !== hueText) {
-					if (hue === null) workspaceLabel.style.removeProperty("--dap-workspace-hue");
-					else workspaceLabel.style.setProperty("--dap-workspace-hue", hueText);
+				for (const [property, value] of Object.entries(colorVariables)) {
+					const next = value === undefined ? "" : String(value);
+					if (workspaceLabel.style.getPropertyValue(property) === next) continue;
+					if (next === "") workspaceLabel.style.removeProperty(property);
+					else workspaceLabel.style.setProperty(property, next);
 				}
 				workspaceLabel.removeAttribute("hidden");
 			} else {
 				if (workspaceText !== null) restoreTextField(workspaceText, "");
-				workspaceLabel.style.removeProperty("--dap-workspace-hue");
+				for (const property of Object.keys(colorVariables)) workspaceLabel.style.removeProperty(property);
 				workspaceLabel.setAttribute("hidden", "");
 			}
 		}
@@ -4449,12 +4632,14 @@ function apply(ctx) {
 					restoreTextField(text, previews[i]);
 				}
 			}
+			renderTokenStats(el, entry);
 		}
 
 		if (entry.kind === "awaiting") {
 			const traceContainer = el.querySelector(".dap-trace");
 			if (traceContainer !== null) renderTimelineArea(traceContainer, entry);
-			renderAwaitingDuration(el, entry);
+			removeAwaitingHeadDuration(el);
+			renderTokenStats(el, entry);
 			const confirm = el.querySelector(".dap-confirm");
 			if (confirm !== null) {
 				// 激活锚点：只在结构重建时绑一次（卡片按 id 复用，kind 变化会重建骨架）。
@@ -4733,7 +4918,7 @@ function apply(ctx) {
 
 	/** 渲染某一张卡片进指定列表容器（活动/历史通用）。index 是条目在卡片序列中的
 	 * 序号，offset 是容器内首个卡片前的非卡片子节点数（活动区有轨道层、历史区有段头）。 */
-	function renderCardIntoList(list, entry, reuseMap, index, offset, hueByWorkspace) {
+	function renderCardIntoList(list, entry, reuseMap, index, offset, colorByWorkspace) {
 		let rec = reuseMap.get(entry.id);
 		if (rec === undefined) {
 			const el = document.createElement("div");
@@ -4790,7 +4975,7 @@ function apply(ctx) {
 				recentTimeText ? "，" + recentTimeText : ""
 			}`,
 		);
-		renderCardInto(rec.el, entry, hueByWorkspace);
+		renderCardInto(rec.el, entry, colorByWorkspace);
 		// 只有顺序/归属真正变化时才移动 DOM：每次渲染无条件 appendChild 会把所有
 		// 卡片瞬时移除再插回——按下/抬起之间经过的移动让浏览器取消 click；焦点卡
 		// 被瞬时断开而失焦；悬停卡的 :hover 也随之丢失且不再补发。会话活跃期间
@@ -4800,6 +4985,37 @@ function apply(ctx) {
 		return true;
 	}
 
+	/** 原生侧栏切换当前会话后，只把已呈现且未完整可见的当前卡片滚入窗格；降低动效偏好时不平滑。 */
+	function ensureCurrentCardVisible(scroll, currentId) {
+		const id = currentId === null || currentId === undefined ? null : String(currentId);
+		if (id === null || id === "") {
+			autoScrolledCurrentId = null;
+			autoScrolledCurrentCard = null;
+			return;
+		}
+		// 当前会话卡片只有在活动列表中才参与自动定位；完成确认后同一 current
+		// 会话会进入历史区，不能因仍带 data-current 把窗格滚到历史卡片。
+		const card = scroll?.querySelector?.(`.${LIST_CLASS} .${CARD_CLASS}[data-current]`) ?? null;
+		if (
+			card === null ||
+			card.dataset.sessionId !== id ||
+			scroll.clientHeight <= 0 ||
+			card.getBoundingClientRect().height <= 0
+		)
+			return;
+		if (autoScrolledCurrentId === id && autoScrolledCurrentCard === card) return;
+		if (scrollCardIntoView(scroll, card, prefersReducedMotion() ? "auto" : "smooth")) {
+			autoScrolledCurrentId = id;
+			autoScrolledCurrentCard = card;
+			return;
+		}
+		const viewport = scroll.getBoundingClientRect();
+		const rect = card.getBoundingClientRect();
+		if (rect.height <= viewport.height && (rect.top < viewport.top || rect.bottom > viewport.bottom)) return;
+		autoScrolledCurrentId = id;
+		autoScrolledCurrentCard = card;
+	}
+
 	function pruneCards(reuseMap, alive) {
 		for (const [id, rec] of reuseMap) {
 			if (alive.has(id)) continue;
@@ -4983,6 +5199,8 @@ function apply(ctx) {
 			recentTotal = 0;
 			recentHasMore = false;
 			recentAppendQueued = false;
+			autoScrolledCurrentId = null;
+			autoScrolledCurrentCard = null;
 			// 旧窗格已脱离文档：其在飞平移的 transitionend 不再触发，逐元素取消避免残留。
 			for (const el of [...shiftCleanups.keys()]) cancelShift(el);
 		}
@@ -4991,6 +5209,7 @@ function apply(ctx) {
 		const recentSection = pane.querySelector(`.${RECENT_CLASS}`);
 		if (activeList === null || recentSection === null) return;
 
+		if (e2eListReadyAt === 0 && e2eListDelayMs > 0) e2eListReadyAt = Date.now() + e2eListDelayMs;
 		let snapshot = getSnapshot(sessions, "list");
 		if (e2eListReadyAt > Date.now() && snapshot?.phase !== "error") {
 			snapshot = { phase: "pending" };
@@ -5015,7 +5234,7 @@ function apply(ctx) {
 		for (const [id, state] of progressAnchorById) {
 			if (delegationActive(state, now)) delegatingIds.add(id);
 		}
-		const active = buildEntries(snapshot, workspaceItems, sessionDetailsById, completeAcksById, delegatingIds);
+		const active = buildEntries(snapshot, workspaceItems, sessionDetailsById, completeAcksById, delegatingIds, archivedSessionIds);
 		// 轮内订阅仅对"运行中"会话建立（主会话 + 运行中的子代理），保持在运行中的订阅
 		// 数量 == 运行中会话数量（R-02-004/AC-01）；暂停等待的子代理只显示标题。
 		const runLikeIds = new Set(
@@ -5099,11 +5318,11 @@ function apply(ctx) {
 			// token/速率取自 sessions.list 条目的投影（tokenUsage/sessionStats），
 			// 复用既有列表订阅，无新增轮询（R-01-009/AC-05、R-02-004/AC-02）。
 			const projection = snapshot?.byId?.[entry.id]?.projectionValues;
-			const stats = projection?.sessionStats;
-			const rateTokS =
-				stats && Number.isFinite(stats.decodeMs) && stats.decodeMs > 0
-					? stats.decodeTokens / (stats.decodeMs / 1000)
-					: null;
+			const projectionStats = statsFromProjection(projection);
+			if (entry.kind === "awaiting") {
+				// 等待期间冻结运行停止前的最后已知统计；刷新/无留存时回退当前列表投影。
+				Object.assign(entry, mergeRuntimeStats(detail?.lastRuntimeStats, projectionStats));
+			}
 			// 委托周期锚点（R-01-009/AC-06）：全部活动条目逐帧记账——锚点不因呈现翻转
 			// （委托期与 awaiting 互转）或瞬时不可见而丢失，仅 dispose 时整体清除；周期内
 			// 进度连续（含 settle 处理回合），周期外由宿主回合起点驱动（新回合归零）。
@@ -5119,13 +5338,15 @@ function apply(ctx) {
 			progressAnchorById.set(entry.id, anchor);
 			if (entry.kind === "running") {
 				const elapsedMs = Number.isFinite(anchor.anchor) ? Math.max(0, now - anchor.anchor) : null;
-				const outputTokens = projection?.tokenUsage?.outputTokens ?? null;
-				Object.assign(entry, runtimeStats({ elapsedMs, outputTokens, rateTokS }));
-				Object.assign(entry, usageSummary(projection?.tokenUsage ?? {}));
+				Object.assign(entry, projectionStats, { elapsedMs });
+				if (detail) {
+					// 列表投影短暂缺字段时，不覆盖此前已知的有效统计。
+					detail.lastRuntimeStats = mergeRuntimeStats(projectionStats, detail.lastRuntimeStats);
+				}
 				// 回合进度：纯时间驱动 y = t/(t+k)，半衰期每帧按最新实测速率现算，固定
 				// k 下单调性由函数本身保证；k 变化时允许进度随速率回落而回退（委托周期
 				// 连续、周期外回合切换归零，R-01-009/AC-06，C-014、C-044）。
-				entry.progress = progressOf({ elapsedMs: elapsedMs ?? 0, halfLifeSec: progressHalfLifeSec({ rateTokS }) });
+				entry.progress = progressOf({ elapsedMs: elapsedMs ?? 0, halfLifeSec: progressHalfLifeSec({ rateTokS: projectionStats.rateTokS }) });
 			}
 		}
 		// 历史区时间精化（R-01-010/AC-08、AC-09）：从保留快照的 turnTimings 与已拉取的
@@ -5146,6 +5367,23 @@ function apply(ctx) {
 		recentTotal = recentCandidates.length;
 		const recent = recentCandidates.slice(0, recentVisibleCount);
 		recentHasMore = recent.length < recentTotal;
+		// 最近卡统计复用运行卡的列表投影口径；耗时从保留快照或已读 history 取最近完整回合，
+		// 缺边界时仅为当前可见历史卡安排一次既有 history 补读（R-01-013/AC-12）。
+		const recentDurationFallbackIds = new Set();
+		for (const entry of recent) {
+			const detail = sessionDetailsById.get(entry.id);
+			const detailSnapshot = livenessById.get(entry.id)?.snapshot ?? detail?.snapshot ?? null;
+			const elapsedMs = lastTurnDuration({ turnTimings: detailSnapshot?.turnTimings, history: detail?.history });
+			const stats = statsFromProjection(snapshot?.byId?.[entry.id]?.projectionValues, elapsedMs);
+			const retained = detail?.lastRuntimeStats;
+			Object.assign(entry, stats, retained ? {
+				outputTokens: retained.outputTokens ?? stats.outputTokens,
+				inputTokens: retained.inputTokens ?? stats.inputTokens,
+				cacheHitPct: retained.cacheHitPct ?? stats.cacheHitPct,
+				rateTokS: retained.rateTokS ?? stats.rateTokS,
+			} : null);
+			if (elapsedMs === null) recentDurationFallbackIds.add(entry.id);
+		}
 		syncRecentTimeClock(recent.length > 0);
 		// 预览只对当前显示的 recent 卡计算（活动卡不显示预览）；快照/历史引用不变时命中缓存。
 		// 完成瞬间的窗口快照可能先有用户消息、后到 agent reply；缺任一预览时补读一次 history。
@@ -5166,7 +5404,10 @@ function apply(ctx) {
 			entry.loadingPreviews = (!entry.userPreview || !entry.agentPreview) && historyLoads.has(entry.id);
 		}
 		// 补充数据读取优先级：当前会话最优先，活动区先于当前已显示历史页（区内按显示顺序）。
-		const durationFallbackIds = new Set(active.filter((entry) => entry.kind === "awaiting").map((entry) => entry.id));
+		const durationFallbackIds = new Set([
+			...active.filter((entry) => entry.kind === "awaiting").map((entry) => entry.id),
+			...recentDurationFallbackIds,
+		]);
 		const detailIds = [...active, ...recent].map((entry) => entry.id);
 		detailIds.sort((a, b) => Number(String(b) === String(snapshot?.current)) - Number(String(a) === String(snapshot?.current)));
 		loadNativeDetails(detailIds, previewFallbackIds, durationFallbackIds);
@@ -5191,12 +5432,32 @@ function apply(ctx) {
 		const recentTimeSignature = recent.map((entry) => fmtRecentTime(entry.activityAt));
 		const sig = JSON.stringify([listState, cardSignature(visibleEntries), pulseSurface, recentTimeSignature]);
 		if (sig === lastSig) return;
-		const hueByWorkspace = resolveWorkspaceHues(visibleEntries.map((entry) => entry.workspaceKey));
+		const colorByWorkspace = resolveWorkspaceColors(visibleEntries.map((entry) => entry.workspaceKey));
 		// 跨区迁移（双向，R-01-010/AC-07）：DOM 写入前量取旧卡矩形并克隆 ghost。
 		const migrations = [
 			...movedToRecentIds(prevRenderedActiveIds, active, recent).map((id) => ({ id, from: cardsById, to: recentCardsById })),
 			...movedToActiveIds(prevRenderedRecentIds, active, recent).map((id) => ({ id, from: recentCardsById, to: cardsById })),
 		];
+		// 活动卡带焦点迁入历史时，把键盘焦点交给其上一个仍在活动区的卡片；
+		// 若迁移卡已在活动区首位，则退到下一张，避免焦点落到历史区或 body。
+		let focusAfterMigrationId = null;
+		const focusedElement = document.activeElement;
+		const activeIds = new Set(active.map((entry) => String(entry.id)));
+		for (const { id, from } of migrations) {
+			if (from !== cardsById) continue;
+			const source = from.get(id)?.el;
+			if (source === undefined || !source.contains(focusedElement)) continue;
+			const activeCards = [...activeList.querySelectorAll(`.${CARD_CLASS}`)];
+			const sourceIndex = activeCards.indexOf(source);
+			if (sourceIndex < 0) continue;
+			const target = activeCards
+				.slice(0, sourceIndex)
+				.reverse()
+				.find((card) => activeIds.has(String(card.dataset.sessionId)))
+				?? activeCards.slice(sourceIndex + 1).find((card) => activeIds.has(String(card.dataset.sessionId)));
+			focusAfterMigrationId = target?.dataset.sessionId ?? null;
+			break;
+		}
 		const movePlans = prepareMoveGhosts(migrations);
 		// 迁移帧内位置受影响的其它卡片与历史区段头：DOM 写入前量取当前视觉矩形
 		// （R-01-010/AC-10）；reduced-motion 下 movePlans 为空，FLIP 量取整体跳过。
@@ -5210,7 +5471,7 @@ function apply(ctx) {
 		const aliveActive = new Set();
 		for (const [index, entry] of active.entries()) {
 			try {
-				renderCardIntoList(activeList, entry, cardsById, index, 1, hueByWorkspace);
+				renderCardIntoList(activeList, entry, cardsById, index, 1, colorByWorkspace);
 			} catch (error) {
 				renderOk = false;
 				logCardRenderError(entry.id, error);
@@ -5227,7 +5488,7 @@ function apply(ctx) {
 		// 历史区容器首个子节点是段头（.dap-recent-head），卡片从 offset 1 开始。
 		for (const [index, entry] of recent.entries()) {
 			try {
-				renderCardIntoList(recentSection, entry, recentCardsById, index, 1, hueByWorkspace);
+				renderCardIntoList(recentSection, entry, recentCardsById, index, 1, colorByWorkspace);
 			} catch (error) {
 				renderOk = false;
 				logCardRenderError(entry.id, error);
@@ -5246,6 +5507,8 @@ function apply(ctx) {
 		}
 		runMoveGhosts(movePlans);
 		if (shiftRects !== null) runShiftAnimations(shiftRects);
+		ensureCurrentCardVisible(pane.querySelector(".dap-scroll"), snapshot?.current ?? null);
+		if (focusAfterMigrationId !== null) cardsById.get(focusAfterMigrationId)?.el.focus();
 		// 区域已有条目但列表仍在途时，在区头部显示行内加载指示（R-01-014/AC-01）。
 		const headerEl = pane.querySelector(".dap-header");
 		const recentHeadEl = recentSection?.querySelector(".dap-recent-head") ?? null;