dsh-activity-pane 0.3.0 → 0.6.0

package/scripts/check.mjs

@@ -66,12 +66,16 @@ import {
 	pruneInvisibleEntries,
 	pruneSubscriptions,
 	runtimeStats,
+	statsFromProjection,
+	mergeRuntimeStats,
 	shouldCancelOpenRetry,
 	subagentTitle,
 	summarizeToolArguments,
 	usageSummary,
 	workspaceHue,
-	resolveWorkspaceHues,
+	WORKSPACE_COLOR_SLOTS,
+	WORKSPACE_BACKGROUND_SLOTS,
+	resolveWorkspaceColors,
 	workspaceInfoForSession,
 } from "../src/core.mjs";
 import {
@@ -79,6 +83,7 @@ import {
 	bindBackdropDismiss,
 	bindCardActivation,
 	openSession,
+	scrollCardIntoView,
 	shouldDismissDrawerOnActivation,
 	suppressComposerAutofocus,
 } from "../src/navigation.mjs";
@@ -112,6 +117,56 @@ assert.equal(
 	"sessions.open 失败时交给调用方进入 refresh/retry",
 );
 
+// ---- R-01-006/AC-02 当前卡片最小滚动：只调整越界方向，不居中 ----
+const viewport = { top: 10, bottom: 110 };
+const makeScrollBox = (scrollTop, smooth = true) => {
+	const scroll = {
+		scrollTop,
+		scrollHeight: 300,
+		clientHeight: 100,
+		getBoundingClientRect: () => viewport,
+	};
+	if (smooth) {
+		scroll.scrollCalls = [];
+		scroll.scrollTo = ({ top, behavior }) => {
+			scroll.scrollCalls.push({ top, behavior });
+			scroll.scrollTop = top;
+		};
+	}
+	return scroll;
+};
+const makeCardBox = (top, bottom) => ({
+	getBoundingClientRect: () => ({ top, bottom }),
+});
+const belowScroll = makeScrollBox(0);
+assert.equal(scrollCardIntoView(belowScroll, makeCardBox(120, 160)), true, "卡片底部越界时执行向下定位");
+assert.equal(belowScroll.scrollTop, 50, "向下只滚动卡片底部超出的最小距离");
+assert.deepEqual(belowScroll.scrollCalls, [{ top: 50, behavior: "smooth" }], "向下定位使用快速平滑滚动");
+const reducedMotionScroll = makeScrollBox(0);
+assert.equal(scrollCardIntoView(reducedMotionScroll, makeCardBox(120, 160), "auto"), true, "降低动效偏好时仍执行定位");
+assert.deepEqual(reducedMotionScroll.scrollCalls, [{ top: 50, behavior: "auto" }], "降低动效偏好时跳过平滑过渡");
+const fallbackScroll = makeScrollBox(0, false);
+assert.equal(scrollCardIntoView(fallbackScroll, makeCardBox(120, 160)), true, "缺少 scrollTo 时保留直接滚动 fallback");
+assert.equal(fallbackScroll.scrollTop, 50, "scrollTo fallback 仍使用最小滚动距离");
+const throwingScroll = makeScrollBox(0);
+throwingScroll.scrollTo = () => { throw new TypeError("unsupported options"); };
+assert.equal(scrollCardIntoView(throwingScroll, makeCardBox(120, 160)), true, "scrollTo options 不受支持时回退为直接滚动");
+assert.equal(throwingScroll.scrollTop, 50, "scrollTo fallback 仍完成最小滚动");
+const unexpectedScroll = makeScrollBox(0);
+unexpectedScroll.scrollTo = () => { throw new Error("unexpected failure"); };
+assert.throws(() => scrollCardIntoView(unexpectedScroll, makeCardBox(120, 160)), /unexpected failure/, "非预期滚动异常继续暴露");
+const aboveScroll = makeScrollBox(100);
+assert.equal(scrollCardIntoView(aboveScroll, makeCardBox(-20, 20)), true, "卡片顶部越界时执行向上定位");
+assert.equal(aboveScroll.scrollTop, 70, "向上只滚动卡片顶部超出的最小距离");
+const visibleScroll = makeScrollBox(42);
+assert.equal(scrollCardIntoView(visibleScroll, makeCardBox(20, 90)), false, "卡片完整可见时不滚动");
+assert.equal(visibleScroll.scrollTop, 42, "卡片完整可见时保持原滚动位置");
+const topBoundaryScroll = makeScrollBox(0);
+assert.equal(scrollCardIntoView(topBoundaryScroll, makeCardBox(-20, 20)), false, "顶部边界不能继续向上滚动");
+const bottomBoundaryScroll = makeScrollBox(200);
+assert.equal(scrollCardIntoView(bottomBoundaryScroll, makeCardBox(120, 160)), false, "底部边界不能继续向下滚动");
+assert.equal(scrollCardIntoView(null, makeCardBox(0, 1)), false, "缺少滚动容器时静默跳过");
+
 // ---- R-01-005/AC-01、R-02-003/AC-01 card 自身 click/键盘监听与卸载 ----
 const cardListeners = new Map();
 const card = {
@@ -219,7 +274,62 @@ assert.equal(escapeCssString("a\fb"), "a\\c b", "换页按 CSS 字符串码位
 assert.equal(escapeCssString("a\0b"), "a�b", "NUL 归一为替换字符");
 // R-01-012/AC-01
 assert.equal(isSubagentRow({ parentId: "ghost" }, {}), false, "父级不在列表时按主会话处理（仍允许 models 读取）");
-assert.equal(isSubagentRow({ parentId: "p" }, { p: { id: "p" } }), true, "直属子代理判定命中时跳过 models 读取");
+assert.equal(isSubagentRow({ parentId: "p" }, { p: { id: "p" } }), false, "普通 fork 的 parentId 不足以判定为子代理");
+assert.equal(isSubagentRow({ parentId: "p", origin: "subagent" }, { p: { id: "p" } }), true, "origin 为 subagent 且父级有效时命中子代理判定");
+assert.equal(isSubagentRow({ origin: "subagent" }, { p: { id: "p" } }), false, "缺少有效 parentId 时不判定为子代理");
+// R-01-003/AC-01、R-01-010/AC-01：普通 fork 虽有 parentId，仍按独立主会话处理。
+const forkWorkspace = [{ title: "Fork 工作区", path: "/srv/fork", sessionIds: ["fork-root", "fork-child"] }];
+const forkActivity = {
+	ids: ["fork-root", "fork-child"],
+	byId: {
+		"fork-root": { id: "fork-root", displayTitle: "来源会话", running: false, completed: false, updatedAt: 1_000 },
+		"fork-child": { id: "fork-child", displayTitle: "分支会话", running: true, completed: false, parentId: "fork-root" },
+	},
+	current: null,
+};
+assert.equal(isSubagentRow(forkActivity.byId["fork-child"], forkActivity.byId), false, "普通 fork 的 parentId 不改变主会话身份");
+assert.deepEqual([...activeSessionIds(forkActivity.byId)], ["fork-child"], "活动 fork 不把来源会话算作活动后代母会话");
+assert.deepEqual(
+	buildEntries(forkActivity, forkWorkspace).map((entry) => [entry.id, entry.kind, entry.depth, entry.parentId, entry.workspaceTitle]),
+	[["fork-child", "running", 0, null, "Fork 工作区"]],
+	"活动 fork 保持独立主会话条目与工作区身份");
+const forkRecent = {
+	...forkActivity,
+	byId: {
+		"fork-root": { ...forkActivity.byId["fork-root"], updatedAt: 1_000 },
+		"fork-child": { ...forkActivity.byId["fork-child"], running: false, updatedAt: 1_500 },
+	},
+};
+assert.deepEqual(
+	buildRecent(forkRecent, forkWorkspace, 2_000).map((entry) => [entry.id, entry.workspaceTitle]),
+	[["fork-child", "Fork 工作区"], ["fork-root", "Fork 工作区"]],
+	"结束 fork 可进入最近历史且保留工作区身份");
+const trueSubagentActivity = {
+	...forkActivity,
+	byId: { ...forkActivity.byId, "fork-child": { ...forkActivity.byId["fork-child"], origin: "subagent" } },
+};
+assert.deepEqual(
+	buildEntries(trueSubagentActivity, forkWorkspace).map((entry) => [entry.id, entry.kind, entry.depth, entry.parentId]),
+	[["fork-root", "running", 0, null], ["fork-child", "subagent", 1, "fork-root"]],
+	"origin 为 subagent 的真实子代理仍保持嵌套与母会话委托呈现");
+const subagentUnderFork = {
+	ids: ["source", "fork", "nested-subagent"],
+	byId: {
+		source: { id: "source", displayTitle: "来源会话", running: false },
+		fork: { id: "fork", displayTitle: "独立分支", parentId: "source", running: false },
+		"nested-subagent": { id: "nested-subagent", displayTitle: "分支中的子代理", parentId: "fork", origin: "subagent", running: true },
+	},
+	current: null,
+};
+assert.deepEqual([...activeSessionIds(subagentUnderFork.byId)].sort(), ["fork", "nested-subagent"], "分支下真实子代理的活动祖先不越过独立 fork 来源");
+assert.deepEqual(
+	buildEntries(subagentUnderFork, [{ title: "Fork 工作区", path: "/srv/fork", sessionIds: ["source", "fork", "nested-subagent"] }]).map((entry) => [entry.id, entry.kind, entry.depth, entry.parentId]),
+	[["fork", "running", 0, null], ["nested-subagent", "subagent", 1, "fork"]],
+	"分支下真实子代理只嵌套到 fork，不把来源会话变成母会话");
+assert.deepEqual(
+	buildEntries(subagentUnderFork, [], {}, null, null, ["source"]).map((entry) => entry.id),
+	["fork", "nested-subagent"],
+	"归档 fork 来源不影响独立 fork 及其真实子代理子树");
 // models/history 加载决策行为链：首读 → 在途不重发 → 失败置空后可见期内不热重试 → 离开可见清理后重回可重试
 const loadDetail = {};
 assert.deepEqual(
@@ -528,56 +638,86 @@ const hueSpread = new Set();
 for (let i = 0; i < 50; i += 1) hueSpread.add(workspaceHue(`/home/user/proj/ws-${i}`));
 assert.ok(hueSpread.size >= 40, `50 个长前缀身份分散到 ${hueSpread.size} 个不同色相（≥40，R-01-003/AC-09）`);
 
-// ---- R-01-003/AC-12 OKLCH 七色感知锚点 + 步进 3 跨色区槽位消解 ----
-const workspaceHueAnchors = [55, 100, 145, 190, 235, 280, 325];
+// ---- R-01-003/AC-12 OKLCH 十二前景槽、三档背景变体、主题距离与复合容量 ----
+const workspacePrimaryHues = [55, 100, 145, 190, 235, 280, 325];
+const workspacePaletteHues = WORKSPACE_COLOR_SLOTS.map((slot) => slot.hue);
 const realWorkspaceCluster = [
 	"/home/cailei/ops",
 	"/home/cailei/proj/docsim",
 	"/home/cailei/proj/dsh-activity-pane",
 	"/home/cailei/proj/dsh-control-center",
 ];
-const resolvedCluster = resolveWorkspaceHues(realWorkspaceCluster);
+const resolvedCluster = resolveWorkspaceColors(realWorkspaceCluster);
 assert.deepEqual(
-	[...resolvedCluster.entries()],
+	[...resolvedCluster.entries()].map(([key, color]) => [key, color.foreground.hue]),
 	[
 		["/home/cailei/ops", 280],
 		["/home/cailei/proj/docsim", 55],
 		["/home/cailei/proj/dsh-activity-pane", 190],
 		["/home/cailei/proj/dsh-control-center", 100],
 	],
-	"真实撞槽子集以 +3 探测确定性拆分到蓝紫/橙/青/黄绿明显色区（R-01-003/AC-12）",
-);
-assert.deepEqual(
-	[...resolveWorkspaceHues([...realWorkspaceCluster].reverse(), "", "  ", realWorkspaceCluster[0]).entries()],
-	[...resolvedCluster.entries()],
-	"输入顺序、重复项与空白身份不影响消解映射（R-01-003/AC-08、AC-12）",
-);
-assert.deepEqual([...resolveWorkspaceHues(null).entries()], [], "无身份集合返回空映射（R-01-003/AC-12）");
-const sevenHues = [...resolveWorkspaceHues(Array.from({ length: 7 }, (_, index) => `/home/user/proj/seven-${index}`)).values()];
-assert.deepEqual([...sevenHues].sort((a, b) => a - b), workspaceHueAnchors, "七个工作区恰占满七个避红 OKLCH 感知锚点（R-01-003/AC-12）");
-const oklabHueDistance = (hueA, hueB, chroma) => {
-	const a = hueA * Math.PI / 180;
-	const b = hueB * Math.PI / 180;
-	return Math.hypot(chroma * Math.cos(a) - chroma * Math.cos(b), chroma * Math.sin(a) - chroma * Math.sin(b));
+	"真实撞槽子集保持 +3 探测拆分到蓝紫/橙/青/黄绿明显色区（R-01-003/AC-12）",
+);
+assert.deepEqual(
+	[...resolveWorkspaceColors([...realWorkspaceCluster].reverse(), "", "  ", realWorkspaceCluster[0]).entries()].map(([key, color]) => [key, color.foreground.slot, color.background.slot]),
+	[...resolvedCluster.entries()].map(([key, color]) => [key, color.foreground.slot, color.background.slot]),
+	"输入顺序、重复项与空白身份不影响前景/背景复合槽位映射（R-01-003/AC-08、AC-12）",
+);
+assert.deepEqual([...resolveWorkspaceColors(null).entries()], [], "无身份集合返回空映射（R-01-003/AC-12）");
+const sevenColors = [...resolveWorkspaceColors(Array.from({ length: 7 }, (_, index) => `/home/user/proj/seven-${index}`)).values()];
+assert.deepEqual([...sevenColors].map((color) => color.foreground.hue).sort((a, b) => a - b), workspacePrimaryHues, "七个工作区仍恰占满七个主色相槽位（R-01-003/AC-12）");
+assert.ok([...sevenColors].every((color) => color.foreground.slot < workspacePrimaryHues.length), "七个工作区不提前使用补充槽位（R-01-003/AC-12）");
+const oklabPoint = (color, theme) => {
+	const hue = color.hue * Math.PI / 180;
+	const lightness = theme === "dark" ? color.darkL : color.lightL;
+	const chroma = theme === "dark" ? color.darkC : color.lightC;
+	return [lightness, chroma * Math.cos(hue), chroma * Math.sin(hue)];
 };
-for (let i = 0; i < sevenHues.length; i += 1)
-	for (let j = i + 1; j < sevenHues.length; j += 1) {
-		assert.ok(oklabHueDistance(sevenHues[i], sevenHues[j], 0.16) >= 0.11, "深色主题七锚点任意两色 OKLab 距离至少 0.11（R-01-003/AC-12）");
-		assert.ok(oklabHueDistance(sevenHues[i], sevenHues[j], 0.15) >= 0.11, "浅色主题七锚点任意两色 OKLab 距离至少 0.11（R-01-003/AC-12）");
-	}
-const crowdedHues = resolveWorkspaceHues(Array.from({ length: 20 }, (_, index) => `/home/user/proj/crowded-${index}`));
-assert.equal(crowdedHues.size, 20, "超容量集合仍为每个身份返回色相并有限终止（R-01-003/AC-12）");
-assert.ok([...crowdedHues.values()].every((hue) => workspaceHueAnchors.includes(hue)), "超容量时仍只使用七个避红 OKLCH 感知锚点（R-01-003/AC-12）");
-const anchorUses = workspaceHueAnchors.map((anchor) => [...crowdedHues.values()].filter((hue) => hue === anchor).length);
-assert.ok(Math.max(...anchorUses) - Math.min(...anchorUses) <= 1, "超容量时七锚点复用计数差不超过 1（R-01-003/AC-12）");
+const oklabDistance = (colorA, colorB, theme) => {
+	const a = oklabPoint(colorA, theme);
+	const b = oklabPoint(colorB, theme);
+	return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+};
+const twelveColors = [...resolveWorkspaceColors(Array.from({ length: 12 }, (_, index) => `/home/user/proj/twelve-${index}`)).values()];
+assert.deepEqual(
+	[...twelveColors].map((color) => color.foreground.slot).sort((a, b) => a - b),
+	Array.from({ length: 12 }, (_, index) => index),
+	"十二个工作区恰好使用十二个唯一前景颜色槽位（R-01-003/AC-12）",
+);
+assert.equal(new Set(workspacePaletteHues).size, workspacePaletteHues.length, "十二槽 hue 不重复（R-01-003/AC-12）");
+assert.ok(workspacePaletteHues.every((hue) => hue > 30 && hue < 330), "十二槽 hue 均避开红色警戒环段（R-01-003/AC-09、AC-12）");
+assert.deepEqual(
+	WORKSPACE_BACKGROUND_SLOTS.map((slot) => slot.slot),
+	[0, 1, 2],
+	"每个前景槽位提供三个背景变体槽（R-01-003/AC-12）",
+);
+assert.equal(new Set(WORKSPACE_BACKGROUND_SLOTS.map((slot) => slot.dark.l)).size, 3, "深色背景变体具有三档独立明度（R-01-003/AC-10、AC-11）");
+assert.equal(new Set(WORKSPACE_BACKGROUND_SLOTS.map((slot) => slot.light.l)).size, 3, "浅色背景变体具有三档独立明度（R-01-003/AC-10、AC-11）");
+for (const theme of ["dark", "light"])
+	for (let i = 0; i < twelveColors.length; i += 1)
+		for (let j = i + 1; j < twelveColors.length; j += 1)
+			assert.ok(oklabDistance(twelveColors[i].foreground, twelveColors[j].foreground, theme) >= 0.11, `${theme} 主题十二槽任意两前景色 OKLab 距离至少 0.11（R-01-003/AC-12）`);
+const thirtySixColors = [...resolveWorkspaceColors(Array.from({ length: 36 }, (_, index) => `/home/user/proj/thirty-six-${index}`)).values()];
+const pairKeys = thirtySixColors.map((color) => `${color.foreground.slot}/${color.background.slot}`);
+assert.equal(new Set(pairKeys).size, 36, "三十六个工作区恰好使用三十六个唯一前景/背景复合槽位（R-01-003/AC-12）");
+for (const foregroundSlot of WORKSPACE_COLOR_SLOTS.map((slot) => slot.slot)) {
+	const backgrounds = thirtySixColors.filter((color) => color.foreground.slot === foregroundSlot).map((color) => color.background.slot);
+	assert.deepEqual(backgrounds.sort((a, b) => a - b), [0, 1, 2], `前景槽 ${foregroundSlot} 先使用三个背景变体（R-01-003/AC-12）`);
+}
+const crowdedColors = resolveWorkspaceColors(Array.from({ length: 40 }, (_, index) => `/home/user/proj/crowded-${index}`));
+assert.equal(crowdedColors.size, 40, "超容量集合仍为每个身份返回复合颜色槽位并有限终止（R-01-003/AC-12）");
+assert.ok([...crowdedColors.values()].every((color) => color.foreground.slot >= 0 && color.foreground.slot < WORKSPACE_COLOR_SLOTS.length), "超容量时仍只使用十二个前景颜色槽位（R-01-003/AC-12）");
+assert.ok([...crowdedColors.values()].every((color) => color.background.slot >= 0 && color.background.slot < WORKSPACE_BACKGROUND_SLOTS.length), "超容量时仍只使用三个背景变体槽位（R-01-003/AC-12）");
+const pairUses = [...new Set([...crowdedColors.values()].map((color) => `${color.foreground.slot}/${color.background.slot}`))].map((pair) => [...crowdedColors.values()].filter((color) => `${color.foreground.slot}/${color.background.slot}` === pair).length);
+assert.ok(Math.max(...pairUses) - Math.min(...pairUses) <= 1, "超容量时三十六个复合槽位复用计数差不超过 1（R-01-003/AC-12）");
 
 // ---- R-01-001/AC-01 活动卡片逐条显示 ｜ R-01-003/AC-01 子代理嵌套 ｜ R-01-003/AC-02 子代理结束即消失 ｜ R-01-006/AC-01 当前会话 ----
 const snapshot = {
 	ids: ["sA", "sA-c1", "sA-c2", "sB", "sX"],
 	byId: {
 		sA: { id: "sA", displayTitle: "主A", running: true, completed: false },
-		"sA-c1": { id: "sA-c1", displayTitle: "子1", running: true, parentId: "sA" },
-		"sA-c2": { id: "sA-c2", displayTitle: "子2", running: false, completed: true, parentId: "sA" },
+		"sA-c1": { id: "sA-c1", displayTitle: "子1", running: true, parentId: "sA", origin: "subagent" },
+		"sA-c2": { id: "sA-c2", displayTitle: "子2", running: false, completed: true, parentId: "sA", origin: "subagent" },
 		sB: { id: "sB", displayTitle: "主B", running: false, completed: true },
 		sX: { id: "sX", displayTitle: "主X", running: false, completed: false },
 	},
@@ -683,8 +823,8 @@ const inheritedActivity = {
 	ids: ["root", "parent", "child"],
 	byId: {
 		root: { id: "root", displayTitle: "根母会话", running: false, completed: false, updatedAt: 1900 },
-		parent: { id: "parent", displayTitle: "中间母会话", running: false, completed: false, parentId: "root", updatedAt: 1900 },
-		child: { id: "child", displayTitle: "活动子会话", running: true, parentId: "parent" },
+		parent: { id: "parent", displayTitle: "中间母会话", running: false, completed: false, parentId: "root", origin: "subagent", updatedAt: 1900 },
+		child: { id: "child", displayTitle: "活动子会话", running: true, parentId: "parent", origin: "subagent" },
 	},
 	current: null,
 };
@@ -714,7 +854,7 @@ const delegCompleted = {
 	ids: ["root", "child"],
 	byId: {
 		root: { id: "root", displayTitle: "母会话", running: false, updatedAt: 1900 },
-		child: { id: "child", displayTitle: "活动子会话", running: true, parentId: "root" },
+		child: { id: "child", displayTitle: "活动子会话", running: true, parentId: "root", origin: "subagent" },
 	},
 	current: null,
 };
@@ -1502,6 +1642,33 @@ assert.deepEqual(
 	{ elapsedMs: 47_000, outputTokens: 0, rateTokS: null },
 	"零速率归一为空，token 统计仍可放在进度条下方",
 );
+assert.deepEqual(
+	statsFromProjection(
+		{
+			tokenUsage: { uncachedInputTokens: 100, cacheReadTokens: 20, cacheWriteTokens: 10, outputTokens: 144 },
+			sessionStats: { decodeTokens: 144, decodeMs: 3_000 },
+		},
+		47_000,
+	),
+	{ elapsedMs: 47_000, outputTokens: 144, rateTokS: 48, inputTokens: 130, cacheHitPct: 15 },
+	"最近卡复用列表投影派生 tok/s、缓存、输入/输出与固定耗时（R-01-013/AC-12）",
+);
+assert.deepEqual(
+	mergeRuntimeStats(
+		{ outputTokens: null, inputTokens: 24, cacheHitPct: null, rateTokS: null },
+		{ outputTokens: 96, inputTokens: 12, cacheHitPct: 40, rateTokS: 8 },
+	),
+	{ outputTokens: 96, inputTokens: 24, cacheHitPct: 40, rateTokS: 8 },
+	"等待/运行统计按字段回退，缺失投影不覆盖最后已知有效值（R-01-009/AC-13）",
+);
+assert.deepEqual(
+	mergeRuntimeStats(
+		{ outputTokens: 0, inputTokens: 0, cacheHitPct: 0, rateTokS: null },
+		{ outputTokens: 96, inputTokens: 12, cacheHitPct: 40, rateTokS: 8 },
+	),
+	{ outputTokens: 0, inputTokens: 0, cacheHitPct: 0, rateTokS: 8 },
+	"统计合并保留有效的零值，仅对缺失字段回退（R-01-009/AC-13）",
+);
 assert.deepEqual(
 	usageSummary({ uncachedInputTokens: 100, cacheReadTokens: 700, cacheWriteTokens: 200 }),
 	{ inputTokens: 1_000, cacheHitPct: 70 },
@@ -2445,7 +2612,7 @@ assert.equal(completionReminder(holdBase, { lastTurnEnd: 1000, ackedAt: 1000 },
 assert.equal(completionReminder(holdBase, { lastTurnEnd: 1000, ackedAt: 2000 }, false), false, "ackedAt 晚于 lastTurnEnd 不成立");
 assert.equal(completionReminder(holdBase, null, false), false, "无完成登记不成立（升级不回溯补发提醒）");
 assert.equal(completionReminder(holdBase, { lastTurnEnd: 0, ackedAt: null }, false), false, "lastTurnEnd 非法不作数");
-assert.equal(completionReminder({ id: "m-c1", parentId: "m", displayTitle: "子S" }, { lastTurnEnd: 1000, ackedAt: null }, true), false, "子代理不产生完成提醒");
+assert.equal(completionReminder({ id: "m-c1", parentId: "m", origin: "subagent", displayTitle: "子S" }, { lastTurnEnd: 1000, ackedAt: null }, true), false, "子代理不产生完成提醒");
 // 打开/切换当前会话不解除（AC-05）：完成提醒成立与 current 无关。
 // R-01-002/AC-05 打开或切换当前会话不解除完成提醒：判定与 current 无关（C-030）。
 const holdSnap = { ids: ["sB"], byId: { sB: holdBase }, current: "sA" };
@@ -2483,7 +2650,7 @@ assert.deepEqual(
 // 新回合隐式更替：lastTurnEnd 前移后旧确认游标不再覆盖新回合（仍未确认则对新回合成立）。
 assert.equal(completionReminder(holdBase, { lastTurnEnd: 2000, ackedAt: 1500 }, false), true, "新回合完成后提醒针对新回合重新成立");
 // 委托周期抑制：后代活动期间完成提醒不生效（呈现不依赖宿主 completed）。
-const delegDoneMix = { ids: ["root", "root-c1"], byId: { root: holdBase, "root-c1": { id: "root-c1", displayTitle: "子S", parentId: "root", running: true } }, current: null };
+const delegDoneMix = { ids: ["root", "root-c1"], byId: { root: holdBase, "root-c1": { id: "root-c1", displayTitle: "子S", parentId: "root", origin: "subagent", running: true } }, current: null };
 assert.deepEqual(
 	buildEntries(delegDoneMix, [], {}, acks(1000), new Set(["root"])).map((e) => [e.id, e.pendingText ?? null]),
 	[["root", null], ["root-c1", null]],
@@ -2505,7 +2672,7 @@ assert.equal(errorReminder({ id: "sB", displayTitle: "旧B" }, { lastTurnEndKind
 assert.equal(errorReminder({ id: "sB", displayTitle: "旧B" }, { lastTurnEndKind: "completed" }, false), false, "正常回合不成立");
 assert.equal(errorReminder({ id: "sB", displayTitle: "旧B" }, { lastTurnEndKind: "error", ackedAt: 99999 }, false), true, "错误提醒不消费 ack 游标（ackedAt 不影响成立）");
 assert.equal(errorReminder({ id: "sB", displayTitle: "旧B" }, null, false), false, "无登记不成立（升级不回溯补发错误提醒）");
-assert.equal(errorReminder({ id: "m-c1", parentId: "m", displayTitle: "子S" }, { lastTurnEndKind: "error" }, true), false, "子代理不产生错误提醒");
+assert.equal(errorReminder({ id: "m-c1", parentId: "m", origin: "subagent", displayTitle: "子S" }, { lastTurnEndKind: "error" }, true), false, "子代理不产生错误提醒");
 const errEntries = buildEntries(holdSnap, [], {}, errAcks("error", "The engine is currently overloaded, please try again later"));
 assert.deepEqual(
 	errEntries.map((e) => [e.id, e.kind, e.pendingText ?? null, e.waitClass, e.noteText]),
@@ -2557,7 +2724,7 @@ assert.deepEqual(
 const clearedErrAcked = buildEntries(holdSnap, [], {}, errAcks("completed", null, 2000));
 assert.deepEqual(clearedErrAcked.map((e) => [e.id, e.kind]), [], "新回合正常结束且已确认后完全退出活动区（错误提醒无确认按钮语义）");
 // 委托周期抑制：后代活动期间错误提醒不生效。
-const delegErrMix = { ids: ["root", "root-c1"], byId: { root: holdBase, "root-c1": { id: "root-c1", displayTitle: "子S", parentId: "root", running: true } }, current: null };
+const delegErrMix = { ids: ["root", "root-c1"], byId: { root: holdBase, "root-c1": { id: "root-c1", displayTitle: "子S", parentId: "root", origin: "subagent", running: true } }, current: null };
 const delegErrAcks = new Map([["root", { lastTurnEnd: 1000, lastTurnEndKind: "error", lastTurnEndError: "boom", ackedAt: null }]]);
 assert.deepEqual(
 	buildEntries(delegErrMix, [], {}, delegErrAcks, new Set(["root"])).map((e) => e.id),
@@ -2599,7 +2766,7 @@ const recentSubSnap = {
 	ids: ["m", "m-c1"],
 	byId: {
 		m: { id: "m", displayTitle: "主M", running: false, completed: false, updatedAt: NOW - 1_000 },
-		"m-c1": { id: "m-c1", displayTitle: "子S", running: false, completed: false, parentId: "m", updatedAt: NOW - 500 },
+		"m-c1": { id: "m-c1", displayTitle: "子S", running: false, completed: false, parentId: "m", origin: "subagent", updatedAt: NOW - 500 },
 	},
 	current: null,
 };
@@ -2648,6 +2815,67 @@ assert.deepEqual(
 	"归档集同样接受 Set 形态",
 );
 
+// R-01-010/AC-01：归档集合同时驱动活动区过滤；未确认完成提醒也不得在归档后滞留。
+const activeArchivedSnap = {
+	ids: ["sKeep", "sGone"],
+	byId: {
+		sKeep: { id: "sKeep", displayTitle: "保留K", running: true },
+		sGone: { id: "sGone", displayTitle: "归档G", running: false },
+	},
+	current: null,
+};
+assert.deepEqual(
+	buildEntries(activeArchivedSnap, [], {}, new Map([["sGone", { lastTurnEnd: NOW, ackedAt: null }]]), null, ["sGone"]).map((e) => e.id),
+	["sKeep"],
+	"归档会话从活动区消失，不因未确认完成提醒继续滞留",
+);
+const archivedStatusSnap = {
+	ids: ["sRunning", "sDone", "sError", "sDelegating"],
+	byId: {
+		sRunning: { id: "sRunning", displayTitle: "运行中归档", running: true },
+		sDone: { id: "sDone", displayTitle: "完成归档", running: false },
+		sError: { id: "sError", displayTitle: "错误归档", running: false },
+		sDelegating: { id: "sDelegating", displayTitle: "委托归档", running: false },
+	},
+	current: null,
+};
+assert.deepEqual(
+	buildEntries(
+		archivedStatusSnap,
+		[],
+		{},
+		new Map([
+			["sDone", { lastTurnEnd: NOW, ackedAt: null }],
+			["sError", { lastTurnEnd: NOW, lastTurnEndKind: "error", lastTurnEndError: "boom", ackedAt: null }],
+		]),
+		new Set(["sDelegating"]),
+		new Set(["sRunning", "sDone", "sError", "sDelegating"]),
+	).map((e) => e.id),
+	[],
+	"Set 归档集合同时过滤运行、完成提醒、错误提醒与委托周期中的会话",
+);
+const archivedLineageSnap = {
+	ids: ["root", "root-child", "root-grandchild", "keep-root", "keep-child"],
+	byId: {
+		root: { id: "root", displayTitle: "归档母会话", running: false },
+		"root-child": { id: "root-child", displayTitle: "归档子代理", parentId: "root", origin: "subagent", running: true },
+		"root-grandchild": { id: "root-grandchild", displayTitle: "归档孙代理", parentId: "root-child", origin: "subagent", running: true },
+		"keep-root": { id: "keep-root", displayTitle: "保留母会话", running: false },
+		"keep-child": { id: "keep-child", displayTitle: "被归档子代理", parentId: "keep-root", origin: "subagent", running: true },
+	},
+	current: null,
+};
+assert.deepEqual(
+	buildEntries(archivedLineageSnap, [], {}, null, null, ["root"]).map((e) => e.id),
+	["keep-root", "keep-child"],
+	"归档母会话时其子会话与更深层后代均不产出活动条目",
+);
+assert.deepEqual(
+	buildEntries(archivedLineageSnap, [], {}, null, null, ["keep-child"]).map((e) => e.id),
+	["root", "root-child", "root-grandchild"],
+	"归档子会话后不因残留后代活动把未归档母会话留在活动区",
+);
+
 // ---- R-01-014/AC-01 列表在途显示加载指示而非空态 ----
 assert.equal(listLoadState(null), "loading", "快照缺失视为列表在途");
 assert.equal(listLoadState({ phase: "pending" }), "loading", "phase 为 pending 视为列表在途");
@@ -2781,6 +3009,16 @@ assert.ok(
 	clientSource.includes("const sig = JSON.stringify([listState, cardSignature(visibleEntries), pulseSurface, recentTimeSignature]);"),
 	"列表 phase 与历史时间文案必须参与结构化渲染签名，空列表不得冻结在加载/失败状态（T-087）",
 );
+assert.ok(
+	clientSource.includes("scroll?.querySelector?.(`.${LIST_CLASS} .${CARD_CLASS}[data-current]`)") &&
+		!clientSource.includes("scroll?.querySelector?.(`.${CARD_CLASS}[data-current]`)"),
+	"当前卡片自动滚动仅定位活动列表，完成卡迁入历史后不追随历史区（R-01-006/AC-02）",
+);
+assert.ok(
+	clientSource.includes("source.contains(focusedElement)") &&
+		clientSource.includes("cardsById.get(focusAfterMigrationId)?.el.focus()"),
+	"活动卡迁移时将已有键盘焦点交给仍在活动区的相邻卡片（R-01-005/AC-01）",
+);
 // R-01-013/AC-02 回归：卡片标题必须随快照更新——单卡渲染异常不得冻结其余卡片
 // （此前渲染签名先于卡片循环提交且无异常隔离，故障卡及其后全部卡片永久滞留旧标题，
 //  历史卡因此停在首条消息形态的 fallback 标题，与左侧栏脱节）。
@@ -2815,13 +3053,13 @@ assert.ok(
 	bundle.includes("list.insertBefore(rec.el, ref)"),
 	"卡片仅在顺序/归属变化时移动 DOM（insertBefore 位置守卫）",
 );
-// ---- R-01-009/AC-02、R-01-009/AC-05、R-01-012/AC-01..04、R-01-013/AC-01..06 ----
+// ---- R-01-009/AC-02、R-01-009/AC-05、R-01-012/AC-01..04、R-01-013/AC-01..06、AC-12 ----
 assert.ok(bundle.includes("foldedConversationTimeline"), "活动卡时间线由折叠分组唯一来源派生（R-01-012、R-01-017）");
 assert.ok(!bundle.includes("dap-trace-time"), "工作项时间线不渲染行级耗时元素，对齐主会话窗口（R-01-009/AC-07、C-012）");
 assert.ok(!bundle.includes("PROGRESS_THINK_BASE") && !bundle.includes("progressFloor"), "回合进度纯时间驱动，无思考基线/单调下限残留（R-01-009/AC-06、C-014）");
 assert.ok(bundle.includes("progressHalfLifeSec"), "bundle 含半衰期速率校准函数（R-01-009/AC-06、C-025、C-044）");
 assert.ok(
-	bundle.includes("halfLifeSec: progressHalfLifeSec({ rateTokS })"),
+	bundle.includes("halfLifeSec: progressHalfLifeSec({ rateTokS: projectionStats.rateTokS })"),
 	"进度赋值每帧按最新实测速率现算半衰期（R-01-009/AC-06、C-044）",
 );
 assert.ok(
@@ -2841,9 +3079,18 @@ assert.ok(
 	"统计行双段结构：左列文本 + 右置时长（R-01-009/AC-05）",
 );
 assert.ok(bundle.includes("function renderTokenStats"), "运行卡统计行继续复用既有渲染逻辑（R-01-009/AC-05）");
+// R-01-009/AC-13 等待卡保留进入等待前最后已知的 token 统计
+assert.ok(
+	bundle.includes('return [head, row, makeEl("div", "dap-trace"), statsRow, foot];'),
+	"等待卡骨架在时间线后保留统计行（R-01-009/AC-13）",
+);
 assert.ok(
-	bundle.includes("function renderAwaitingDuration") && bundle.includes("dap-await-head"),
-	"等待卡耗时与等待类型胶囊共用同行右置渲染（R-01-009/AC-12）",
+	bundle.includes("renderTokenStats(el, entry);") && bundle.includes("removeAwaitingHeadDuration(el);"),
+	"等待卡复用统计行并清理胶囊同行的旧耗时节点（R-01-009/AC-12、AC-13）",
+);
+assert.ok(
+	bundle.includes("function removeAwaitingHeadDuration") && bundle.includes("awaitHead.append(capsule);"),
+	"等待类型胶囊独立成行，固定耗时回到统计行（R-01-009/AC-12）",
 );
 assert.ok(bundle.includes("lastTurnDuration({"), "等待卡耗时由最近完整回合边界派生（R-01-009/AC-12）");
 assert.ok(bundle.includes("`输入 ${fmtTokens("), "统计行含输入/输出中文短标签（R-01-009/AC-05）");
@@ -2858,6 +3105,14 @@ assert.ok(
 );
 assert.ok(!bundle.includes("≈"), "速率不再携带约等于符号（R-01-009/AC-05）");
 assert.ok(bundle.includes("dap-history-line"), "历史卡包含用户/agent 两条消息预览行");
+// R-01-013/AC-12 最近历史卡保留最近回合统计
+assert.ok(
+	bundle.includes('return [head, row, userLine, agentLine, statsRow, makeEl("div", "dap-note")];'),
+	"历史卡统计行位于助手预览后、活动时间前",
+);
+assert.ok(bundle.includes("statsFromProjection"), "历史卡统计复用列表投影派生函数（R-01-013/AC-12）");
+assert.ok(bundle.includes("lastRuntimeStats"), "会话结束时保留最后已知运行统计（R-01-013/AC-12）");
+assert.ok(bundle.includes("recentDurationFallbackIds"), "历史卡缺回合边界时复用 history 补读（R-01-013/AC-12）");
 // R-01-003/AC-04
 assert.ok(bundle.includes("parentId: m.isSub ? String(parentId) : null"), "活动卡条目保留直属母会话 id");
 assert.ok(bundle.includes("function trackRuns(entries)"), "母会话轨道拓扑由纯函数 trackRuns 一次求出");
@@ -2915,16 +3170,16 @@ assert.ok(
 assert.ok(
 	clientSource.includes("const INDENT_PX = 16;") &&
 		bundle.includes("Math.round(parent.left + indentPx / 2 + 1)") &&
-		bundle.includes("renderCardIntoList(activeList, entry, cardsById, index, 1, hueByWorkspace)"),
+		bundle.includes("renderCardIntoList(activeList, entry, cardsById, index, 1, colorByWorkspace)"),
 	"几何耦合钉住：INDENT_PX=16、轨道 left 由母会话卡片左缘测量推导（+半槽+1px border，取整后与横线起笔相接）与活动区卡片 offset=1（轨道层为首子节点），改任一必须同步",
 );
 // R-01-003/AC-05
 assert.ok(bundle.includes("function activeSessionIds(byId = {})"), "活动子代理沿 parentId 链补齐活动祖先");
 // ---- R-01-016/AC-01 等待卡保留最近工作项时间线 ----
 assert.ok(
-	bundle.includes('awaitHead.append(capsule, makeEl("span", "dap-token-time"))') &&
-		bundle.includes('return [head, row, makeEl("div", "dap-trace"), foot];'),
-	"awaiting 骨架在标题行与末行两段（胶囊+正文）之间含时间线，并将耗时放在胶囊同行右侧（R-01-016/AC-01、R-01-009/AC-12，C-043）",
+	bundle.includes("awaitHead.append(capsule);") &&
+		bundle.includes('return [head, row, makeEl("div", "dap-trace"), statsRow, foot];'),
+	"awaiting 骨架在标题行与统计行、末行两段（胶囊+正文）之间含时间线，固定耗时由统计行承载（R-01-016/AC-01、R-01-009/AC-12，C-043）",
 );
 // ---- R-01-002/AC-10 完成提醒卡「移入历史」按钮 ----
 assert.ok(
@@ -3397,20 +3652,27 @@ assert.ok(bundle.includes('workspace.append(workspaceIcon, makeEl("span", "dap-w
 assert.ok(bundle.includes("if (workspaceText !== null) restoreTextField(workspaceText, entry.workspaceTitle)"), "热装旧骨架无文本段时容空跳过，不中断渲染（R-01-003/AC-06 健壮性）");
 
 // R-01-003/AC-08、AC-09、AC-10、AC-11、AC-12
-// 工作区徽标按身份派生基色、经同屏跨色区槽位消解后着色：渲染层写入 --dap-workspace-hue，
-// CSS 以 OKLCH 调色板色直接呈现文字，底色/描边在 OKLCH 空间同色相混合；胶囊几何与字号不变。
-assert.ok(bundle.includes("resolveWorkspaceHues(visibleEntries.map((entry) => entry.workspaceKey))"), "渲染层按同帧可见身份集合消解色相（R-01-003/AC-12）");
-assert.ok(bundle.includes("hueByWorkspace.get(entry.workspaceKey)"), "每张卡使用集合消解后的工作区色相（R-01-003/AC-08、AC-12）");
-assert.ok(bundle.includes('style.setProperty("--dap-workspace-hue"'), "渲染层把消解后色相写入徽标 --dap-workspace-hue（R-01-003/AC-08、AC-12）");
-assert.ok(bundle.includes('style.removeProperty("--dap-workspace-hue")'), "徽标隐藏时移除色相变量，不留陈旧着色（R-01-003/AC-08）");
-assert.ok(bundle.includes("--dap-workspace-color: oklch(0.78 0.16 var(--dap-workspace-hue, 235))"), "深色主题文字使用 OKLCH 高明度中高彩度调色板色（R-01-003/AC-11）");
+// 工作区徽标按身份派生基色、经同屏前景/背景复合槽位消解后着色：渲染层写入
+// 前景 hue/L/C 与背景变体主题参数，CSS 以 OKLCH 前景色呈现文字、独立背景源色混合底色/描边；胶囊几何与字号不变。
+assert.ok(bundle.includes("resolveWorkspaceColors(visibleEntries.map((entry) => entry.workspaceKey))"), "渲染层按同帧可见身份集合消解十二槽颜色（R-01-003/AC-12）");
+assert.ok(bundle.includes("colorByWorkspace.get(entry.workspaceKey)"), "每张卡使用集合消解后的工作区颜色槽位（R-01-003/AC-08、AC-12）");
+assert.ok(bundle.includes('entry.workspaceTitle !== "" && foreground !== undefined && background !== undefined'), "缺少工作区身份或背景变体时隐藏徽标而不使用默认颜色（R-01-003/AC-08）");
+assert.ok(bundle.includes("style.setProperty(property, next)"), "渲染层把槽位颜色变量写入徽标（R-01-003/AC-08、AC-12）");
+assert.ok(bundle.includes('"--dap-workspace-dark-l": foreground?.darkL'), "渲染层把前景深色主题 L 写入徽标（R-01-003/AC-10、AC-11）");
+assert.ok(bundle.includes('"--dap-workspace-light-l": foreground?.lightL'), "渲染层把前景浅色主题 L 写入徽标（R-01-003/AC-10、AC-11）");
+assert.ok(bundle.includes('"--dap-workspace-bg-dark-l": background?.dark?.l'), "渲染层把背景变体深色主题 L 写入徽标（R-01-003/AC-10、AC-11）");
+assert.ok(bundle.includes('"--dap-workspace-bg-light-l": background?.light?.l'), "渲染层把背景变体浅色主题 L 写入徽标（R-01-003/AC-10、AC-11）");
+assert.ok(bundle.includes("for (const property of Object.keys(colorVariables)) workspaceLabel.style.removeProperty(property)"), "徽标隐藏时移除全部前景/背景颜色变量，不留陈旧着色（R-01-003/AC-08）");
+assert.ok(bundle.includes("var(--dap-workspace-dark-l, 0.78)"), "深色主题使用槽位 OKLCH 明度变量（R-01-003/AC-11）");
+assert.ok(bundle.includes("var(--dap-workspace-dark-c, 0.16)"), "深色主题使用槽位 OKLCH 彩度变量（R-01-003/AC-11）");
 assert.ok(bundle.includes("color: var(--dap-workspace-color)"), "徽标文字直接使用调色板色、不混 currentColor（R-01-003/AC-11）");
-assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-color) 14%, transparent)"), "深色主题底色在 OKLCH 空间同色相铺底（R-01-003/AC-11）");
-assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-color) 34%, transparent)"), "深色主题描边在 OKLCH 空间同色相混合（R-01-003/AC-11）");
+assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-background-color) var(--dap-workspace-bg-dark-mix, 31%), transparent)"), "深色主题底色使用加强的独立背景变体混合（R-01-003/AC-10、AC-11）");
+assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-color) var(--dap-workspace-bg-dark-border-mix, 52%), transparent)"), "深色主题描边使用高对比前景色混合（R-01-003/AC-10、AC-11）");
 assert.ok(bundle.includes("body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {"), "浅色主题单独校准徽标配色（R-01-003/AC-10、AC-11）");
-assert.ok(bundle.includes("--dap-workspace-color: oklch(0.48 0.15 var(--dap-workspace-hue, 235))"), "浅色主题文字使用 OKLCH 低明度中高彩度调色板色（R-01-003/AC-11）");
-assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-color) 10%, transparent)"), "浅色主题底色更轻（R-01-003/AC-11）");
-assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-color) 28%, transparent)"), "浅色主题描边（R-01-003/AC-11）");
+assert.ok(bundle.includes("var(--dap-workspace-light-l, 0.48)"), "浅色主题使用槽位 OKLCH 明度变量（R-01-003/AC-11）");
+assert.ok(bundle.includes("var(--dap-workspace-light-c, 0.15)"), "浅色主题使用槽位 OKLCH 彩度变量（R-01-003/AC-11）");
+assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-background-color) var(--dap-workspace-bg-light-mix, 27%), transparent)"), "浅色主题底色使用加强的独立背景变体混合（R-01-003/AC-10、AC-11）");
+assert.ok(bundle.includes("color-mix(in oklch, var(--dap-workspace-color) var(--dap-workspace-bg-light-border-mix, 42%), transparent)"), "浅色主题描边使用高对比前景色混合（R-01-003/AC-10、AC-11）");
 assert.ok(!bundle.includes("color-mix(in srgb, var(--dap-workspace-color) 92%, currentColor)"), "工作区文字不得再以 currentColor 冲淡调色板色（R-01-003/AC-11）");
 
 // R-01-010/AC-01、R-01-010/AC-05