dsh-activity-pane 0.8.0 → 0.10.0

package/.dsh-plugin/client.js

@@ -130,6 +130,26 @@ function clampPaneWidth(raw) {
 	return Math.min(PANE_WIDTH_MAX, Math.max(PANE_WIDTH_MIN, Math.round(value)));
 }
 
+/**
+ * 把任意输入（localStorage 字符串等）归一为合法卡片显示档位：
+ * 仅 'full'/'medium'/'compact' 为合法档位，其余（含缺失/非法值）回退默认中间档（R-01-021/AC-06）。
+ */
+function normalizeDensity(raw) {
+	return raw === "compact" || raw === "medium" || raw === "full" ? raw : "medium";
+}
+
+/** 显示档位的循环次序：完整 → 中间 → 紧凑 → 完整（R-01-021/AC-01）。 */
+const DENSITY_ORDER = ["full", "medium", "compact"];
+
+/**
+ * 返回循环切换后的下一显示档位：完整 → 中间 → 紧凑 → 完整；
+ * 输入先经 normalizeDensity 归一，非法值视作中间档（R-01-021/AC-01）。
+ */
+function nextDensity(value) {
+	const index = DENSITY_ORDER.indexOf(normalizeDensity(value));
+	return DENSITY_ORDER[(index + 1) % DENSITY_ORDER.length];
+}
+
 function isRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -1293,25 +1313,25 @@ function awaitBadgeStats(entries) {
 
 /** 数量标识呈现态（R-01-014/AC-06）：列表在途（loading）时不冒充计数——归一为
  *  loading 呈现（加载指示 + 加载中 aria 文案，不等待、不脉冲）；否则归一为 count
- *  呈现（n/m 文本 + 计数 aria 文案）。awaiting 表达「存在等待行动」——底色经
+ *  呈现（n/m 文本 + 计数 aria 文案 + 悬停 tips 文案）。分子为正在运行的主会话数
+ *  （running = total − waiting）——随会话逐一完成递减至 0，与等待行动数互补
+ *  （R-01-001/AC-04、AC-05）；awaiting 表达「存在等待行动」——底色经
  *  awaitBadgeTone（错误 > 阻塞 > 完成，红/金/绿）与脉冲门控同一信号：任一等待行动
  *  （阻塞等待、完成提醒或错误提醒）即脉冲（R-01-002/AC-06，C-037、C-043）。
  *  blocked 入参只用于 aria 文案的计数说明，不再驱动门控。错误轴不算在途，维持计数呈现。 */
 function countBadgeState(listState, waiting, total, blocked = 0) {
-	if (listState === "loading") return { mode: "loading", text: "", ariaText: "活动会话计数加载中", awaiting: false };
+	if (listState === "loading") return { mode: "loading", text: "", ariaText: "活动会话计数加载中", tip: "", awaiting: false };
 	const awaiting = waiting > 0;
 	const hasBlocked = blocked > 0;
 	const doneCount = waiting - (hasBlocked ? blocked : 0);
+	const running = total - waiting;
 	return {
 		mode: "count",
-		text: `${waiting}/${total}`,
-		ariaText: hasBlocked
-			? doneCount > 0
-				? `${total} 个活动会话，${blocked} 个等待你答复，${doneCount} 个已完成`
-				: `${total} 个活动会话，${blocked} 个等待你答复`
-			: awaiting
-				? `${total} 个活动会话，${waiting} 个已完成`
-				: `${total} 个活动会话`,
+		text: `${running}/${total}`,
+		ariaText: `${total} 个活动会话，${running} 个正在运行`
+			+ (hasBlocked ? `，${blocked} 个等待你答复` : "")
+			+ (doneCount > 0 ? `，${doneCount} 个已完成` : ""),
+		tip: `运行中的会话 ${running} / 总活动会话 ${total}`,
 		awaiting,
 	};
 }
@@ -1386,16 +1406,11 @@ function workspaceInfoForSession(sessionId, workspaceItems, byId = {}) {
 }
 
 /**
- * 工作区徽标基色色相（R-01-003/AC-08、AC-09）：以工作区身份为唯一输入的纯函数——
- * djb2 哈希经雪崩终混（异或右移 + 乘法，把高位熵折入低位，消除 djb2 低位分布
- * 聚集；每步 >>> 0 保持无符号，异或结果可能带符号位）后在避开红色警戒区的
- * 色相弧 [30°,320°] 上均匀取色（30 + hash % 291），输出 [30,320] 整数。
- * 同一身份恒得同一基色色相，与工作区列表顺序、会话状态及持久化存储无关，页面
- * 刷新后不变；空身份返回 null。
+ * 身份字符串 → 32 位无符号哈希：djb2 经雪崩终混（见 C-029 决策记录）。
+ * 异或右移 + 乘法把高位熵折入低位，消除 djb2 低位分布聚集；每步 >>> 0 保持
+ * 无符号，异或结果可能带符号位。
  */
-function workspaceHue(key) {
-	const text = cleanText(key);
-	if (!text) return null;
+function identityHash(text) {
 	let hash = 5381;
 	for (let i = 0; i < text.length; i += 1)
 		hash = ((hash << 5) + hash + text.charCodeAt(i)) >>> 0;
@@ -1405,8 +1420,24 @@ function workspaceHue(key) {
 	// 乘法的乘积（最大约 5×10^18）超出 double 精确整数上限 2^53，低 32 位
 	// 会丢失精度。
 	hash = Math.imul(hash, 0x45d9f3b) >>> 0;
-	hash = (hash ^ (hash >>> 16)) >>> 0;
-	return 30 + (hash % 291);
+	return (hash ^ (hash >>> 16)) >>> 0;
+}
+
+// 避红基色色相弧 [30°,320°] 的起点与取值数（30 + hash % 291）；背景变体
+// 以同一弧宽的商派生，共享常量避免两处口径漂移（R-01-003/AC-09、C-077）。
+const WORKSPACE_HUE_ARC_START = 30;
+const WORKSPACE_HUE_ARC_SIZE = 291;
+
+/**
+ * 工作区徽标基色色相（R-01-003/AC-08、AC-09）：以工作区身份为唯一输入的纯函数，
+ * 在避开红色警戒区的色相弧 [30°,320°] 上均匀取色，输出 [30,320] 整数；哈希
+ * 机制见 {@link identityHash}。同一身份恒得同一基色色相，与工作区列表顺序、
+ * 会话状态及持久化存储无关，页面刷新后不变；空身份返回 null。
+ */
+function workspaceHue(key) {
+	const text = cleanText(key);
+	if (!text) return null;
+	return WORKSPACE_HUE_ARC_START + (identityHash(text) % WORKSPACE_HUE_ARC_SIZE);
 }
 
 const WORKSPACE_COLOR_SLOTS = Object.freeze([
@@ -1442,90 +1473,46 @@ const WORKSPACE_BACKGROUND_SLOTS = Object.freeze([
 	},
 ].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);
+/** 环形色相距离（度，0–180）。 */
+function hueDistance(a, b) {
+	const d = Math.abs(a - b) % 360;
+	return Math.min(d, 360 - d);
 }
 
 /**
- * 同屏工作区复合颜色槽位消解（R-01-003/AC-08、AC-12）：前七个身份沿原七色
- * OKLCH 主槽位分配，主槽位占满后再使用五个受控明度/色相补充槽位；每个前景槽位
- * 内优先使用未用的三个背景变体；超过三十六个复合身份后按槽位使用次数均衡复用。
+ * 同屏工作区复合颜色槽位消解（R-01-003/AC-08、AC-12）：逐身份纯映射——每个
+ * 身份独立地以其 32 位雪崩哈希派生前景与背景槽位，身份之间互不影响，创建、
+ * 移除或变更其它工作区不改变既有工作区的颜色（C-077）；前景取基色色相在 12 个
+ * 前景槽位中环形距离最近者（平局取低槽位），背景变体取 floor(hash / 弧宽) % 3。
+ * 均匀哈希使不同身份的前景碰撞概率保持在约 1/12、复合碰撞约 1/36 的最小水平。
  */
 function resolveWorkspaceColors(keys) {
 	const identities = [...new Set((Array.isArray(keys) ? keys : []).map(cleanText).filter(Boolean))].sort();
-	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 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],
-			);
+		const hash = identityHash(identity);
+		const baseHue = WORKSPACE_HUE_ARC_START + (hash % WORKSPACE_HUE_ARC_SIZE);
+		let foregroundSlot = 0;
+		let nearest = hueDistance(baseHue, WORKSPACE_COLOR_SLOTS[0].hue);
+		for (let slot = 1; slot < WORKSPACE_COLOR_SLOTS.length; slot += 1) {
+			const distance = hueDistance(baseHue, WORKSPACE_COLOR_SLOTS[slot].hue);
+			if (distance < nearest) {
+				nearest = distance;
+				foregroundSlot = slot;
+			}
 		}
-		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],
+			background: WORKSPACE_BACKGROUND_SLOTS[Math.floor(hash / WORKSPACE_HUE_ARC_SIZE) % WORKSPACE_BACKGROUND_SLOTS.length],
 		});
 	}
 	return resolved;
 }
 
-
-/** 主会话按左侧工作区顺序排序的权重；不在任何 workspace 的排在最后保持 lineage 顺序。 */
-function workspaceRank(workspaceItems) {
-	const wsIndex = new Map();
-	const posIndex = new Map();
-	for (const workspace of workspaceItems ?? []) {
-		if (!isRecord(workspace)) continue;
-		const sessionIds = Array.isArray(workspace.sessionIds)
-			? workspace.sessionIds
-			: [];
-		sessionIds.forEach((sid, p) => {
-			const key = String(sid);
-			if (!wsIndex.has(key)) {
-				wsIndex.set(key, wsIndex.size);
-				posIndex.set(key, p);
-			}
-		});
-	}
-	return (id) => {
-		const key = String(id);
-		return {
-			ws: wsIndex.get(key) ?? Number.MAX_SAFE_INTEGER,
-			pos: posIndex.get(key) ?? Number.MAX_SAFE_INTEGER,
-		};
-	};
+/** 主会话活动区排序用的最后用户指令时刻：宿主列表时间，缺失/非法视为最旧。 */
+function instructionTime(row) {
+	const time = Number(row?.updatedAt);
+	return Number.isFinite(time) ? time : -1;
 }
 
 /** 子代理的展示标题：优先目录 label，其次 displayTitle，兜底 "子任务"。 */
@@ -1588,7 +1575,6 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 		}
 		return false;
 	};
-	const rank = workspaceRank(workspaceItems ?? []);
 	const descendantIds = descendantActiveIds(byId, isArchived);
 	// 第一遍：层级关系 + 显示判定（show = 自身活动 || 委托周期 || 完成提醒，单点实现避免漂移）。
 	const rootIds = [];
@@ -1621,12 +1607,25 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 		meta.set(id, { row, running, pending, isSub, show, done, err, descendantActive, delegating, depth: 0 });
 	}
 
-	// 主会话按 workspace 顺序排序；未归入任何工作区的主会话保持在 lineage 中靠后。
+	// 主会话分两组排序（R-01-001/AC-07）：运行中主会话置顶，组内按最后一次用户指令
+	// 时间（宿主列表时间）从新到旧；等待/完成组（阻塞等待、完成提醒、错误提醒）排后，
+	// 组内按进入该状态的时刻（最近一次回合结束登记时刻，缺失回落宿主列表时间）从新到旧。
+	// 两组相同时间均回落宿主列表出现顺序。工作区顺序不参与排序，仅承载卡片徽标与名称。
+	const isRunningEntry = (id) => {
+		const m = meta.get(id);
+		return m !== undefined && !m.pending && (m.running || m.delegating);
+	};
+	const sortTime = (id) => {
+		if (isRunningEntry(id)) return instructionTime(byId[id]);
+		const record = completionFor(id, completions);
+		const end = isRecord(record) ? Number(record.lastTurnEnd) : NaN;
+		return Number.isFinite(end) ? end : instructionTime(byId[id]);
+	};
 	rootIds.sort((a, b) => {
-		const ra = rank(a);
-		const rb = rank(b);
-		if (ra.ws !== rb.ws) return ra.ws - rb.ws;
-		if (ra.pos !== rb.pos) return ra.pos - rb.pos;
+		const byGroup = Number(isRunningEntry(b)) - Number(isRunningEntry(a));
+		if (byGroup !== 0) return byGroup;
+		const byTime = sortTime(b) - sortTime(a);
+		if (byTime !== 0) return byTime;
 		return ids.indexOf(a) - ids.indexOf(b);
 	});
 
@@ -1985,58 +1984,30 @@ function durationTime(value) {
 	return Number.isFinite(time) ? time : null;
 }
 
-/** 从 history 提取最近完整回合的结束时刻与固定耗时；两者始终来自同一回合。 */
-function lastTurnDurationCandidateFromEvents(events) {
-	const starts = new Map();
+/**
+ * 从 history 重放回合/等待边界事件，提取最近一个已结束回合的运行过程耗时（busy 口径：
+ * 起止差值扣除回合内阻塞等待，与 R-01-020 累计口径一致，恒不大于该回合墙钟时长）。
+ * 回合起止不完整、时间逆序或回合运行段不为正时忽略该回合；无可得回合返回 null。
+ */
+function lastTurnBusyFromEvents(events) {
+	let state = emptyTurnStats();
 	let latest = null;
 	for (const entry of Array.isArray(events) ? events : []) {
-		const event = eventOf(entry);
-		const turn = Number(event?.data?.turn);
-		const time = durationTime(event?.time);
-		if (!Number.isFinite(turn) || time === null) continue;
-		if (event.type === "turn/start") {
-			starts.set(turn, time);
-			continue;
-		}
-		if (event.type !== "turn/end") continue;
-		const start = starts.get(turn);
-		if (start === undefined || time < start) continue;
-		if (latest === null || time > latest.end) latest = { end: time, duration: time - start };
+		const time = durationTime(eventOf(entry)?.time);
+		const prev = state;
+		state = applyTurnEventToStats(state, entry);
+		if (prev.openTurnStart === null || state.openTurnStart !== null) continue;
+		// 能走到回合闭合的必为时刻有效的 turn/end（applyTurnEventToStats 对无效时刻无效果）。
+		const activeMs = (state.busyMs ?? 0) - (prev.busyMs ?? 0);
+		if (activeMs <= 0) continue;
+		latest = { end: time, duration: activeMs };
 	}
-	return latest;
-}
-
-/** 从 turnTimings 提取最近完整回合的结束时刻与固定耗时；两者始终来自同一回合。 */
-function lastTurnDurationCandidateFromTimings(turnTimings) {
-	if (!(turnTimings instanceof Map)) return null;
-	let latest = null;
-	for (const timing of turnTimings.values()) {
-		const start = durationTime(timing?.startTime);
-		const end = durationTime(timing?.endTime);
-		if (start === null || end === null || end < start) continue;
-		if (latest === null || end > latest.end) latest = { end, duration: end - start };
-	}
-	return latest;
-}
-
-/** 从 history 提取最近完整回合的固定耗时；回合起止不完整或逆序时忽略该回合。 */
-function lastTurnDurationFromEvents(events) {
-	return lastTurnDurationCandidateFromEvents(events)?.duration ?? null;
-}
-
-/** 从 turnTimings 提取最近完整回合的固定耗时；全部回合未结束或无效时返回 null。 */
-function lastTurnDurationFromTimings(turnTimings) {
-	return lastTurnDurationCandidateFromTimings(turnTimings)?.duration ?? null;
+	return latest?.duration ?? null;
 }
 
-/** 在快照与 history 中按最近结束时刻选择同一最新完整回合的固定耗时。 */
-function lastTurnDuration({ turnTimings = null, history = [] } = {}) {
-	const candidates = [lastTurnDurationCandidateFromTimings(turnTimings), lastTurnDurationCandidateFromEvents(history)].filter(Boolean);
-	let latest = null;
-	for (const candidate of candidates) {
-		if (latest === null || candidate.end > latest.end) latest = candidate;
-	}
-	return latest?.duration ?? null;
+/** 最近完整回合的固定耗时（busy 口径）：从 history 事件重放派生。 */
+function lastTurnDuration({ history = [] } = {}) {
+	return lastTurnBusyFromEvents(history);
 }
 
 /** ask_user_question 工具名：提问/计划审查等待的开启边界（tool/call）与配对结算（tool/result）。 */
@@ -2052,7 +2023,7 @@ function isBusyBoundaryEvent(type) {
 
 /** 空记账状态（无任何有效计时）。 */
 function emptyTurnStats() {
-	return { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null };
+	return { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null, watermarkTime: null };
 }
 
 /** 从任意来源拷贝记账状态：缺失字段归一为 null（旧记录/部分记录兼容）。 */
@@ -2064,10 +2035,14 @@ function turnStatsFrom(state) {
 		openWaitKind: state?.openWaitKind ?? null,
 		openWaitId: state?.openWaitId ?? null,
 		waitedMs: state?.waitedMs ?? null,
+		watermarkTime: state?.watermarkTime ?? null,
 	};
 }
 
-/** 记账状态逐字段相等（不含 watermarkSeq——宿主侧无效果事件跳过落盘的判定）。 */
+/**
+ * 记账状态逐字段相等（不含 watermarkSeq——它不是状态字段，由宿主侧随写入一并落盘；
+ * watermarkTime 为水位处已覆盖事件的时刻，参与相等判定以让补写该字段的收敛写入生效）。
+ */
 function turnStatsEqual(a, b) {
 	return (
 		a === b ||
@@ -2076,7 +2051,8 @@ function turnStatsEqual(a, b) {
 			(a?.openWaitStart ?? null) === (b?.openWaitStart ?? null) &&
 			(a?.openWaitKind ?? null) === (b?.openWaitKind ?? null) &&
 			(a?.openWaitId ?? null) === (b?.openWaitId ?? null) &&
-			(a?.waitedMs ?? null) === (b?.waitedMs ?? null))
+			(a?.waitedMs ?? null) === (b?.waitedMs ?? null) &&
+			(a?.watermarkTime ?? null) === (b?.watermarkTime ?? null))
 	);
 }
 
@@ -2198,15 +2174,18 @@ function totalBusyDisplayMs({ busyMs = null, openTurnStart = null, waitedMs = nu
 
 /**
  * 回合统计记账的统一收敛（R-01-020/AC-04、AC-05）：对全会话事件列表重放出下一份
- * 记账，宿主侧懒回填与启动扫描共用。路径选择——无记录、持久化水位非法、或水位
- * 超前于日志最大 seq（事件 seq 空间被重编，如 dsh 0.1.5 V3 迁移）时从空状态全量
- * 重放（超前水位会把后续全部实时事件封死在守卫之外，openTurnStart 永不清空、总
- * 耗时无限增长）；否则从持久化记账出发仅增量应用 `seq > watermarkSeq` 的事件。
+ * 记账，宿主侧懒回填与启动扫描共用。路径选择——无记录、强制重放、持久化水位非法、
+ * 或水位超前于日志最大 seq（事件 seq 空间被重编，如 dsh 0.1.5 V3 迁移）时从空状态
+ * 全量重放（超前水位会把后续全部实时事件封死在守卫之外，openTurnStart 永不清空、
+ * 总耗时无限增长）；否则从持久化记账出发仅增量应用 `seq > watermarkSeq` 的事件。
+ * 水位推进处同步记录 `watermarkTime`（水位处已覆盖事件的时刻，与实时登记按效果事件
+ * 写入的口径互为保守——检测只要求该值不超过真实边界事件时刻）——宿主实时登记据此
+ * 识别 seq 空间重编（低 seq 事件携带比水位更新的时刻，增量口径已失效）。
  * `closeOpenTurn`（宿主启动扫描）：重放后仍存在的开放回合按日志最后事件时刻强制
  * 结算关闭——宿主重启后不存在仍在运行的回合，残留起点只会令总耗时无限增长；尾部
  * 未配对等待一并按同刻结算（不落到运行时长里）。
  */
-function reconcileTurnStats(current, records, { closeOpenTurn = false } = {}) {
+function reconcileTurnStats(current, records, { closeOpenTurn = false, forceFresh = false } = {}) {
 	const list = Array.isArray(records) ? records : [];
 	let maxSeq = null;
 	let lastTime = null;
@@ -2216,23 +2195,32 @@ function reconcileTurnStats(current, records, { closeOpenTurn = false } = {}) {
 		const time = durationTime(eventOf(record)?.time);
 		if (time !== null && (lastTime === null || time > lastTime)) lastTime = time;
 	}
-	const fresh = !isRecord(current) || !Number.isFinite(current.watermarkSeq) || (maxSeq !== null && Number(current.watermarkSeq) > maxSeq);
+	const fresh = forceFresh || !isRecord(current) || !Number.isFinite(current.watermarkSeq) || (maxSeq !== null && Number(current.watermarkSeq) > maxSeq);
 	let state = emptyTurnStats();
 	let watermarkSeq = null;
+	let watermarkTime = null;
+	// 水位推进：seq 更大即前推水位；事件时刻有效才更新 watermarkTime（无效不前推）。
+	const advance = (record) => {
+		const seq = Number(record?.seq);
+		if (!Number.isFinite(seq) || (watermarkSeq !== null && seq <= watermarkSeq)) return;
+		watermarkSeq = seq;
+		const time = durationTime(eventOf(record)?.time);
+		if (time !== null) watermarkTime = time;
+	};
 	if (fresh) {
 		for (const record of list) {
 			state = applyTurnEventToStats(state, record);
-			const seq = Number(record?.seq);
-			if (Number.isFinite(seq) && (watermarkSeq === null || seq > watermarkSeq)) watermarkSeq = seq;
+			advance(record);
 		}
 	} else {
 		state = turnStatsFrom(current);
+		watermarkTime = state.watermarkTime;
 		watermarkSeq = Number(current.watermarkSeq);
 		for (const record of list) {
 			const seq = Number(record?.seq);
 			if (!Number.isFinite(seq) || seq <= watermarkSeq) continue;
 			state = applyTurnEventToStats(state, record);
-			watermarkSeq = seq;
+			advance(record);
 		}
 	}
 	if (closeOpenTurn && state.openTurnStart !== null) {
@@ -2245,7 +2233,7 @@ function reconcileTurnStats(current, records, { closeOpenTurn = false } = {}) {
 		state.openWaitId = null;
 		state.waitedMs = null;
 	}
-	return { ...state, watermarkSeq };
+	return { ...state, watermarkSeq, watermarkTime };
 }
 
 /**
@@ -2625,6 +2613,10 @@ const STYLE_ID = "dsh-activity-pane-style";
 const INSTANCE_KEY = "__dshActivityPaneCleanup";
 /** 拖拽调宽的 localStorage 持久化键（R-01-015/AC-04）。 */
 const WIDTH_STORAGE_KEY = "dsh-activity-pane:width";
+/** 卡片紧凑显示的 localStorage 持久化键（R-01-021/AC-06）。 */
+const DENSITY_STORAGE_KEY = "dsh-activity-pane:density";
+/** 三档显示的可访问名称用中文标签，键为档位值（R-01-021/AC-01）。 */
+const DENSITY_LABELS = { full: "完整", medium: "中间", compact: "紧凑" };
 const COLLAPSED_WIDTH = 34;
 /** 宿主侧完成确认 API 前缀（C-030）：acks 快照 / SSE 推送 / ack 写回，同源受信。 */
 const PANE_API_BASE = "/dsh-activity-pane/api";
@@ -2635,6 +2627,10 @@ const INDENT_PX = 16;
 const MOBILE_BREAKPOINT = "767px";
 /** 运行卡时钟：只要存在运行中会话，就以该周期刷新时长显示。 */
 const CLOCK_MS = 1000;
+/** 渲染与流式派生的最小合并间隔：事件密集（流式输出）时把渲染/派生频率硬顶在
+ *  10Hz——事件率随宿主流式 chunk 数增长，显示粒度（秒级时长、块级时间线）无感，
+ *  而渲染与 O(日志窗口) 派生不再随刷新率（移动端 120Hz）与事件率线性放大（T-127）。 */
+const SYNC_MIN_INTERVAL_MS = 100;
 /** 历史卡相对时间刷新周期；无需每秒重绘整列。 */
 const RECENT_TIME_REFRESH_MS = 60_000;
 /** 冷数据读取并发池上限：慢网下避免几十张卡片的 models/history 一次性挤占通道。 */
@@ -2664,25 +2660,27 @@ const CSS = `
 [data-dsh-activity-pane] .dap-header {
   display: flex;
   align-items: center;
-  gap: 8px;
-  padding: 10px 12px;
   font-size: 12px;
   font-weight: 700;
   letter-spacing: 0.02em;
 }
-/* 标题行整体即收起控件，两端断点一致（R-01-011/AC-03、R-01-008/AC-02）：指针与悬停/聚焦反馈。 */
-[data-dsh-activity-pane] .dap-header { cursor: pointer; }
-[data-dsh-activity-pane] .dap-header:hover,
-[data-dsh-activity-pane] .dap-header:focus-visible {
-  background: color-mix(in srgb, currentColor 8%, transparent);
+/* 标题行拆为两部分：左侧标题区（flex:1 占满剩余宽度）整体即收起控件，悬停/聚焦
+   高亮只覆盖标题区（R-01-011/AC-03、AC-07、R-01-008/AC-02）；右侧工具区独立，
+   不参与标题区的悬停高亮与折叠激活。 */
+[data-dsh-activity-pane] .dap-titlebar {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 8px 10px 12px;
+  cursor: pointer;
 }
-[data-dsh-activity-pane] .dap-header:focus-visible { outline: none; }
-/* 方向符号：标题行的一部分而非独立按钮，两端断点一致呈现（R-01-011/AC-03、R-01-008/AC-02）。 */
-[data-dsh-activity-pane] .dap-collapse-hint {
-  margin-left: auto;
-  color: color-mix(in srgb, currentColor 45%, transparent);
-  font-size: 13px;
+[data-dsh-activity-pane] .dap-titlebar:hover,
+[data-dsh-activity-pane] .dap-titlebar:focus-visible {
+  background: color-mix(in srgb, currentColor 8%, transparent);
 }
+[data-dsh-activity-pane] .dap-titlebar:focus-visible { outline: none; }
 [data-dsh-activity-pane] .dap-count {
   flex: none;
   font-size: 10px;
@@ -2753,13 +2751,13 @@ const CSS = `
     scrollbar-color: var(--dsh-scrollbar-thumb, color-mix(in srgb, currentColor 25%, transparent)) transparent;
   }
 }
-/* 「回到顶部」悬浮图标按钮（R-01-018）：窗格内右下角圆形按钮，纯图标无文字、不透明底色；
-   默认 hidden，scrollTop 超阈值时由滚动监听揭隐。基类 display:flex 会压过 UA 的
+/* 「回到顶部」（R-01-018）悬浮图标按钮：右缘对齐、28px 圆形、不透明底色。
+   默认 hidden，scrollTop 超阈值时由滚动监听揭隐；基类 display:flex 会压过 UA 的
    [hidden] 规则，故显式补 [hidden] 隐藏。 */
 [data-dsh-activity-pane] .dap-top {
   position: absolute;
-  bottom: 12px;
   right: 12px;
+  bottom: 12px;
   z-index: 6;
   display: flex;
   align-items: center;
@@ -2778,6 +2776,109 @@ const CSS = `
 [data-dsh-activity-pane] .dap-top:focus-visible {
   background: #262932;
 }
+/* 标题行右侧工具按钮区（R-01-021/AC-05）：固定于行尾、常显档位切换按钮，未来新
+   工具按钮统一加入此区；宽度不随悬停态变化，收起方向图标的显隐不挤动本区按钮；
+   左缘 padding 12px 与标题区保持充分间隔。收起方向图标（R-01-011/AC-07）是标题区
+   的行尾提示：常态宽度为 0 不占位，鼠标悬停或键盘聚焦标题区时在标题区最右端即时
+   显现（无过渡动画），离开即隐藏。 */
+[data-dsh-activity-pane] .dap-tools {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 10px 12px;
+}
+[data-dsh-activity-pane] .dap-density {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  padding: 0;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  border-radius: 999px;
+  background: #1d1f25;
+  color: inherit;
+  cursor: pointer;
+}
+[data-dsh-activity-pane] .dap-density:hover,
+[data-dsh-activity-pane] .dap-density:focus-visible {
+  background: #262932;
+}
+/* 仓库入口无描边（T-139）：视觉强度弱于带描边的档位切换按钮，仅以不透明底色圆形呈现。 */
+[data-dsh-activity-pane] .dap-repo {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  border-radius: 999px;
+  background: #1d1f25;
+  color: inherit;
+  cursor: pointer;
+  text-decoration: none;
+}
+[data-dsh-activity-pane] .dap-repo:hover,
+[data-dsh-activity-pane] .dap-repo:focus-visible {
+  background: #262932;
+}
+[data-dsh-activity-pane] .dap-collapse-hint {
+  margin-left: auto;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 0;
+  height: 22px;
+  opacity: 0;
+  overflow: hidden;
+}
+[data-dsh-activity-pane] .dap-titlebar:hover .dap-collapse-hint,
+[data-dsh-activity-pane] .dap-titlebar:focus-visible .dap-collapse-hint {
+  width: 22px;
+  opacity: 1;
+}
+/* 卡片显示档位（R-01-021）：中间档保留标题行、工作区徽标行、等待末行与最近卡
+   消息预览行、经渲染层 lastOnly 单行渲染时间线（仅最新一行，AC-08）；完成提醒卡
+   末行在中间档收合为单行（见下方 data-wait="done" 作用域规则）；紧凑档在
+   中间档基础上再隐藏工作区徽标行、时间线末行、等待末行与消息预览行，仅保留
+   标题行（AC-02）——激活跳转逻辑不感知档位，渲染签名含显示档位分量（档位切换
+   经 queueSync 触发一轮重渲染）（R-01-021/AC-04）。 */
+[data-dsh-activity-pane][data-density="medium"] .dap-card :is(
+    .dap-progress,
+    .dap-token-stats
+  ) {
+  display: none;
+}
+[data-dsh-activity-pane][data-density="compact"] .dap-card :is(
+    .dap-card-head,
+    .dap-trace,
+    .dap-subtrace,
+    .dap-progress,
+    .dap-token-stats,
+    .dap-foot,
+    .dap-history-line,
+    .dap-note
+  ) {
+  display: none;
+}
+/* 中间档完成提醒卡末行收合为单行（R-01-021/AC-08，东家反馈）：末行两行内容
+   （「已完成」胶囊行 +「继续对话，或移入历史」与「移入历史」按钮行）冗余，收合为
+   单行——「已完成」胶囊居左、按钮 margin-left:auto 居右、正文不再显示；两段包裹层
+   以 display: contents 释放为同行 flex 项。选择器以卡片根 data-wait="done" 作用域，
+   阻塞/错误提醒卡与完整呈现档的两行结构不受影响，紧凑档仍整体隐藏末行。 */
+[data-dsh-activity-pane][data-density="medium"] .dap-card[data-kind="awaiting"][data-wait="done"] .dap-foot {
+  flex-direction: row;
+  align-items: center;
+  gap: 6px;
+}
+[data-dsh-activity-pane][data-density="medium"] .dap-card[data-kind="awaiting"][data-wait="done"] :is(.dap-await-head, .dap-note-row) {
+  display: contents;
+}
+[data-dsh-activity-pane][data-density="medium"] .dap-card[data-kind="awaiting"][data-wait="done"] .dap-note {
+  display: none;
+}
+[data-dsh-activity-pane][data-density="medium"] .dap-card[data-kind="awaiting"][data-wait="done"] .dap-confirm {
+  margin-left: auto;
+}
 [data-dsh-activity-pane] .dap-list {
   display: flex;
   flex-direction: column;
@@ -3035,9 +3136,11 @@ const CSS = `
   box-shadow: none;
   animation: none;
 }
+/* 会话卡标题（活动卡、子代理卡与最近卡共用 .dap-title）统一常规字重，不加粗
+   （R-01-013/AC-09 及东家 2026-09-11 视觉反馈）；无按卡类的字重覆盖。 */
 [data-dsh-activity-pane] .dap-title {
   flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis;
-  white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 700;
+  white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 400;
 }
 /* 标题行最右侧的累计运行时长（R-01-020/AC-01）：固定占位不参与标题挤压，
    标题过长时以自身省略号让位；色调弱于标题，不与状态点抢视觉。 */
@@ -3046,10 +3149,6 @@ const CSS = `
   color: #8a94a3; white-space: nowrap;
 }
 [data-dsh-activity-pane] .dap-total-time[hidden] { display: none; }
-/* 最近历史卡标题降为常规字重：历史区不抢占视觉强调（R-01-013/AC-09）。 */
-[data-dsh-activity-pane] .dap-card[data-kind="recent"] .dap-title {
-  font-weight: 400;
-}
 /* 等待卡末行首行「类型胶囊」（R-01-002/AC-01、AC-02、AC-09、AC-13，C-043）：圆底类型
    图标 + 类型文字，色相随等待类别（--dap-wait-color）——阻塞金/完成绿/错误红；
    胶囊为行内元素不自占满宽，随文字内容收缩。 */
@@ -3341,17 +3440,30 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
 [data-dsh-activity-pane] .dap-fill {
   position: absolute; inset: 0 auto 0 0; width: 0%;
   border-radius: 6px;
-  background: repeating-linear-gradient(90deg, #58c98f 0 10px, #3fbf86 10px 20px);
-  background-size: 200% 100%;
+  overflow: hidden;
   box-shadow: 0 0 7px rgba(88, 201, 143, 0.5);
   transition: width 0.45s cubic-bezier(0.22, 1, 0.36, 1);
   /* 进度条仅存于运行卡骨架：会话运行全程持续向右滚动条纹，作为活动标志
      （对齐 answer-pet 的 ap-stripes，R-01-009/AC-08）。 */
+  /* 条带载体 ::after 与滚动动画分离（T-128）：background-position 不可合成，
+     每帧重绘；改由伪元素 transform 平移承载滚动，fill 只保留 width 过渡与
+     裁切，滚动帧全程合成器驱动。 */
+}
+[data-dsh-activity-pane] .dap-fill::after {
+  content: "";
+  position: absolute;
+  inset: 0 auto 0 0;
+  /* 覆盖 fill 宽度 + 一次位移量：平移全程右缘不落后于 fill 右缘，无缝循环。 */
+  width: calc(100% + 40px);
+  /* 周期 20px（色带 10px）与原 background-position 实现一致——px 色标不受
+     background-size 拉伸（T-128 双轴实测）；translateX(-40px) 恰为 2 个周期，
+     无缝且速度 40px/0.8s 与原实现一致。 */
+  background: repeating-linear-gradient(90deg, #58c98f 0 10px, #3fbf86 10px 20px);
   animation: dap-stripes 0.8s linear infinite;
 }
 @keyframes dap-stripes {
-  from { background-position: 0 0; }
-  to { background-position: 40px 0; }
+  from { transform: translateX(-40px); }
+  to { transform: translateX(0); }
 }
 @media (prefers-reduced-motion: reduce) {
   /* answer-pet 保留状态脉冲/进度条纹；仅关闭宽度过渡，避免状态反馈消失。 */
@@ -3461,6 +3573,11 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
     touch-action: none;
   }
   [data-dsh-activity-pane][data-open="true"] { transform: translateX(0); }
+  /* 屏外休眠（T-127）：抽屉关闭（含初始未开，data-open 缺省视同关闭）时子树整体
+     跳过渲染——无限动画与样式失效不再产生渲染开销；布局状态保留，scrollTop 不归零
+     （区别于 display:none，T-027）；打开瞬间恢复渲染，滑入过渡不变。开关与遮罩挂
+     body，不落本规则，浮动开关徽标脉冲（R-01-002/AC-06、AC-07）照常。 */
+  [data-dsh-activity-pane]:not([data-open="true"]) { content-visibility: hidden; }
   .dap-backdrop[data-drawer-open] { display: block; }
   .dap-toggle { display: flex; }
   .dap-toggle[data-drawer-open] { display: none; }
@@ -3554,13 +3671,23 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-track {
 body:not([data-ds-dark-theme]) .dap-toggle {
   background: var(--dsw-alias-button-floating-fill, rgba(255, 255, 255, 0.94));
 }
-/* 「回到顶部」图标按钮浅色覆盖：不透明层-2 底色与外壳描边别名（R-01-018/AC-05）。 */
-body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-top {
+/* 「回到顶部」与标题行工具区档位/仓库入口按钮的浅色覆盖：不透明层-2 底色与外壳描边别名
+   （R-01-018/AC-05、R-01-021/AC-05、R-01-022/AC-01）；仓库入口无描边（T-139），只并入底色组。 */
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-top,
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-density,
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-repo {
   background: var(--dsw-alias-bg-layer-2, #ffffff);
+}
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-top,
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-density {
   border-color: var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.1));
 }
 body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-top:hover,
-body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-top:focus-visible {
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-top:focus-visible,
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-density:hover,
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-density:focus-visible,
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-repo:hover,
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-repo:focus-visible {
   background: var(--dsw-alias-bg-layer-3, #eceef1);
 }
 `;
@@ -3636,6 +3763,22 @@ function writeStoredPaneWidth(width) {
 	} catch {}
 }
 
+/** 读取持久化卡片显示档位：缺失/非法值经 normalizeDensity 归一为默认中间档；
+ *  localStorage 不可用（隐私模式）静默回退中间档（R-01-021/AC-06）。 */
+function readStoredDensity() {
+	try {
+		return normalizeDensity(window.localStorage.getItem(DENSITY_STORAGE_KEY));
+	} catch {
+		return "medium";
+	}
+}
+/** 切换时持久化卡片显示档位；localStorage 不可用时静默跳过（R-01-021/AC-06）。 */
+function writeStoredDensity(value) {
+	try {
+		window.localStorage.setItem(DENSITY_STORAGE_KEY, value);
+	} catch {}
+}
+
 function apply(ctx) {
 	const previousCleanup = document[INSTANCE_KEY] ?? globalThis[INSTANCE_KEY];
 	if (typeof previousCleanup === "function") previousCleanup();
@@ -3653,6 +3796,10 @@ function apply(ctx) {
 	let clockTimer = null;
 	let recentTimeTimer = null;
 	let syncScheduled = false;
+	/** 渲染节流状态（T-127）：lastSyncAt 取 0 保证首轮立即渲染；syncThrottleTimer 为
+	 *  节流窗口尾的在途 timer，交付或卸载时清空。 */
+	let lastSyncAt = 0;
+	let syncThrottleTimer = null;
 	let lastSig = "";
 	/** 等待条目 id/类别队列签名：变化时统一重启数量胶囊与等待卡末行动画对相（R-01-002/AC-07、AC-08）。 */
 	let pulseSignature = "";
@@ -3687,6 +3834,12 @@ function apply(ctx) {
 	let collapsed = false;
 	/** 当前桌面列宽：启动时从 localStorage 恢复，拖拽实时更新，重挂载后保留（R-01-015）。 */
 	let paneWidth = readStoredPaneWidth();
+	/** 卡片显示档位（full/medium/compact）：启动时从 localStorage 恢复，切换实时更新，
+	 *  重挂载后保留（R-01-021/AC-06）。 */
+	let densityLevel = readStoredDensity();
+	/** 待执行的锚定补偿：档位切换时登记当前选中卡片顶部的视口相对位置，本轮渲染
+	 *  提交后量测该卡新位置并补偿 scrollTop（R-01-021/AC-01）。 */
+	let pendingDensityAnchor = null;
 	/** 用户最近一次激活的卡片 id；打开重试链被更新的激活意图取代即取消。 */
 	let lastActivatedId = null;
 	/** 最近一次已处理的当前卡片；同一卡片的运行时重绘不反复打断用户手动滚动。 */
@@ -3854,13 +4007,23 @@ function apply(ctx) {
 		if (changed) notifyLayoutChange();
 	}
 
+	function deliverSync() {
+		syncScheduled = false;
+		syncThrottleTimer = null;
+		if (disposed) return;
+		lastSyncAt = Date.now();
+		render();
+	}
+
+	/** 渲染入口合帧 + 节流（T-127）：距上次渲染落点不足 SYNC_MIN_INTERVAL_MS 时，
+	 *  本轮请求合并到窗口尾由 timer 交付（在途请求只此一个）；达到间隔走原 rAF
+	 *  合帧立即渲染。空闲期无事件即无排队，不引入常驻唤醒。 */
 	function queueSync() {
 		if (disposed || syncScheduled) return;
 		syncScheduled = true;
-		schedule(() => {
-			syncScheduled = false;
-			if (!disposed) render();
-		});
+		const wait = SYNC_MIN_INTERVAL_MS - (Date.now() - lastSyncAt);
+		if (wait > 0) syncThrottleTimer = setTimeout(deliverSync, wait);
+		else schedule(deliverSync);
 	}
 
 	// ---- 完成确认通道（R-01-002/AC-10～AC-12、R-01-010/AC-06，C-030） ----
@@ -4050,6 +4213,36 @@ function apply(ctx) {
 	window.addEventListener("pageshow", onBusyPageShow);
 	connectBusyStream();
 
+	// ---- 回到前台渲染管线自愈（R-01-001/AC-03 回归修复） ----
+	// iOS 后台挂起会丢弃在途 setTimeout：queueSync 的节流窗口尾与流式派生窗口若在
+	// 挂起前排队，恢复后永不交付——syncScheduled/logDeriveTimer 永久滞留，此后一切
+	// 更新（store 订阅推送、SSE 快照、时钟 tick）都被 queueSync 早退吞掉，窗格停留
+	// 在挂起前状态（会话已完成仍显示运行中）。回前台时无条件清掉两类在途 timer 并
+	// 立即交付一轮渲染（rAF 路径挂起安全），与 acks/busy 通道回前台重建同模式。
+	function resumeRenderPipeline() {
+		if (disposed) return;
+		if (syncThrottleTimer !== null) {
+			clearTimeout(syncThrottleTimer);
+			syncThrottleTimer = null;
+		}
+		syncScheduled = false;
+		for (const detail of sessionDetailsById.values()) {
+			if (detail.logDeriveTimer && detail.logDeriveFlush) {
+				clearTimeout(detail.logDeriveTimer);
+				detail.logDeriveFlush();
+			}
+		}
+		schedule(deliverSync);
+	}
+	const onSyncVisibilityResume = () => {
+		if (document.visibilityState === "visible") resumeRenderPipeline();
+	};
+	const onSyncPageShow = (event) => {
+		if (event?.persisted === true) resumeRenderPipeline();
+	};
+	document.addEventListener("visibilitychange", onSyncVisibilityResume);
+	window.addEventListener("pageshow", onSyncPageShow);
+
 	function remoteValue(response) {
 		if (response?.ok === true) return response.value;
 		throw response?.error ?? new Error("remote request failed");
@@ -4188,7 +4381,7 @@ function apply(ctx) {
 					});
 				}
 			}
-			captureSessionLog(id, { subagent, cwd: byId[id]?.cwd ?? "" });
+			captureSessionLog(id, { cwd: byId[id]?.cwd ?? "" });
 			// 长会话深读兜底（R-01-013/AC-03）：最近卡预览/子代理溯源不在尾页日志窗口内
 			// 且宿主标记 hasMore 时，按 beforeSeq 向前回溯翻页（默认无页数上限）。
 			const windowEntries = Array.isArray(detail.log?.entries) ? detail.log.entries : [];
@@ -4264,7 +4457,7 @@ function apply(ctx) {
 	/** 绑定会话并水合事件源（dsh 0.1.5 起会话内容经 eventSource 流式下发：打开即收
 	 *  完整日志窗口 + 实时尾，原生 Conversation 同源）。冷会话补一次 open()，日志窗口
 	 *  快照引用变化即重派生详情（时间线/预览/模型），窗口由宿主按消息对齐分页。 */
-	function captureSessionLog(id, { subagent, cwd }) {
+	function captureSessionLog(id, { cwd } = {}) {
 		const detail = sessionDetailsById.get(id) ?? {};
 		sessionDetailsById.set(id, detail);
 		let session = null;
@@ -4285,10 +4478,7 @@ function apply(ctx) {
 					session.eventSource.subscribe(() => {
 						if (disposed) return;
 						const listSnap = getSnapshot(sessions, "list");
-						captureSessionLog(id, {
-							subagent: isSubagentRow(listSnap?.byId?.[id], listSnap ?? {}),
-							cwd: listSnap?.byId?.[id]?.cwd ?? "",
-						});
+						captureSessionLog(id, { cwd: listSnap?.byId?.[id]?.cwd ?? "" });
 						queueSync();
 					}),
 				);
@@ -4314,8 +4504,30 @@ function apply(ctx) {
 		const log = session.eventSource?.getSnapshot?.() ?? null;
 		if (log === detail.log) return;
 		detail.log = log;
-		const entries = Array.isArray(log?.entries) ? log.entries : [];
-		applyLogEvents(id, detail, entries, { subagent, cwd });
+		// 流式派生合并（T-127）：事件到达只更新引用并标脏，applyLogEvents 的 O(日志窗口)
+		// 全量折叠/预览/模型提取合并进 SYNC_MIN_INTERVAL_MS 窗口执行——事件率与派生成本
+		// 解耦，消化时读到的即最新窗口。subagent/cwd 在回调内经 list 快照现取（timer 在途
+		// 期间行属性可能突变，建窗入参不代表消化时刻；与 logSourceSubs 回调同模式），
+		// cwd 在快照不可得时回退建窗入参（subagent 现取即权威，无建窗回退）。
+		// 深翻路径为一次性同步调用，不经本窗口。交付体同时挂在 detail.logDeriveFlush
+		// 上：回前台自愈据此补交付被挂起丢弃的窗口（resumeRenderPipeline）。
+		if (!detail.logDeriveTimer && typeof setTimeout === "function") {
+			const flushDerive = () => {
+				detail.logDeriveTimer = null;
+				detail.logDeriveFlush = null;
+				if (disposed) return;
+				const listSnap = getSnapshot(sessions, "list");
+				const entries = Array.isArray(detail.log?.entries) ? detail.log.entries : [];
+				applyLogEvents(id, detail, entries, {
+					subagent: isSubagentRow(listSnap?.byId?.[id], listSnap?.byId ?? {}),
+					cwd: listSnap?.byId?.[id]?.cwd ?? cwd,
+				});
+				queueSync();
+			};
+			detail.logDeriveFlush = flushDerive;
+			detail.logDeriveTimer = setTimeout(flushDerive, SYNC_MIN_INTERVAL_MS);
+		}
+		queueSync();
 	}
 
 	/** 部署级模型目录一次性读取（R-01-012/AC-01）：dsh 0.1.5 起 per-session models
@@ -4393,7 +4605,7 @@ function apply(ctx) {
 		return true;
 	}
 	function bindPaneControls(pane) {
-		const header = pane.querySelector(".dap-header");
+		const header = pane.querySelector(".dap-titlebar");
 		const rail = pane.querySelector(".dap-rail");
 		const resize = pane.querySelector(".dap-resize");
 		const scroll = pane.querySelector(".dap-scroll");
@@ -4495,6 +4707,37 @@ function apply(ctx) {
 		const onTopClick = () => {
 			scroll?.scrollTo({ top: 0, behavior: prefersReducedMotion() ? "auto" : "smooth" });
 		};
+		// 显示档位循环切换（R-01-021/AC-01）：完整→中间→紧凑→完整，形态写窗格根属性
+		// 驱动纯 CSS 呈现，持久化于 localStorage（AC-06），会话状态变化不触碰已选档位（AC-07）。
+		const densityBtn = pane.querySelector(".dap-density");
+		const applyDensity = () => {
+			pane.setAttribute("data-density", densityLevel);
+			if (densityBtn !== null) {
+				const next = nextDensity(densityLevel);
+				densityBtn.setAttribute("aria-label", `切换为${DENSITY_LABELS[next]}显示`);
+				densityBtn.title = `${DENSITY_LABELS[next]}显示`;
+			}
+		};
+		const onDensityClick = () => {
+			// 滚动锚定（R-01-021/AC-01）：记录切换前当前选中卡片顶部相对滚动视口的
+			// 位置，档位翻转后把 scrollTop 补偿回该相对位置，使卡片顶部在屏幕上不动。
+			const scrollEl = scroll ?? pane.querySelector(".dap-scroll");
+			const currentCard = scrollEl?.querySelector(".dap-card[data-current]") ?? null;
+			const viewportTop = scrollEl?.getBoundingClientRect().top ?? 0;
+			const anchorTop = currentCard ? currentCard.getBoundingClientRect().top - viewportTop : null;
+			densityLevel = nextDensity(densityLevel);
+			writeStoredDensity(densityLevel);
+			applyDensity();
+			// 档位已纳入渲染签名：触发一轮同步让时间线按新档位以 lastOnly 重建；
+			// 锚定补偿在本轮渲染提交后执行，此时量测才含新行高
+			//（R-01-021/AC-01、AC-08）。
+			pendingDensityAnchor = currentCard && anchorTop !== null ? anchorTop : null;
+			queueSync();
+		};
+		// 档位按钮位于标题行右侧的工具区（标题区折叠控件的兄弟节点），激活天然不会
+		// 冒泡为标题区折叠，无需额外阻断。
+		densityBtn?.addEventListener("click", onDensityClick);
+		applyDensity();
 		header?.addEventListener("click", onHeaderActivate);
 		header?.addEventListener("keydown", onHeaderKeydown);
 		rail?.addEventListener("click", onRailClick);
@@ -4515,6 +4758,7 @@ function apply(ctx) {
 			recentMore?.removeEventListener("click", onRecentMoreClick);
 			if (scrollHideTimer !== null) clearTimeout(scrollHideTimer);
 			topBtn?.removeEventListener("click", onTopClick);
+			densityBtn?.removeEventListener("click", onDensityClick);
 			resize?.removeEventListener("pointerdown", onResizeDown);
 		};
 	}
@@ -4534,10 +4778,16 @@ function apply(ctx) {
 			pane.className = PANE_CLASS;
 			center.insertBefore(pane, seat);
 			pane.innerHTML = `
-				<div class="dap-header" role="button" tabindex="0" aria-expanded="true" aria-label="收起活动会话窗格" title="收起">
-					<span>活动会话</span>
-					<span class="dap-count" role="status" aria-live="polite"></span>
-					<span class="dap-collapse-hint" aria-hidden="true">«</span>
+				<div class="dap-header">
+					<span class="dap-titlebar" role="button" tabindex="0" aria-expanded="true" aria-label="收起活动会话窗格" title="收起">
+						<span>活动会话</span>
+						<span class="dap-count" role="status" aria-live="polite"></span>
+						<span class="dap-collapse-hint" aria-hidden="true"></span>
+					</span>
+					<span class="dap-tools">
+						<a class="dap-repo" href="https://github.com/ccll/dsh-activity-pane" target="_blank" rel="noreferrer noopener" aria-label="报告问题" title="报告问题"></a>
+						<button class="dap-density" type="button" aria-label="切换为紧凑显示" title="紧凑显示"></button>
+					</span>
 				</div>
 				<div class="dap-scroll">
 					<div class="dap-list" tabindex="-1"><div class="dap-tracks" aria-hidden="true"></div></div>
@@ -4556,6 +4806,13 @@ function apply(ctx) {
 			pane.style.setProperty("--dap-width", `${paneWidth}px`);
 			// 「回到顶部」按钮为纯图标呈现（R-01-018/AC-05）：骨架无文字，图标在创建时注入。
 			pane.querySelector(".dap-top").append(createTopIcon());
+			// 紧凑显示切换按钮常显于标题行右侧工具区（R-01-021/AC-05）；切换时以 data-density
+			// 驱动纯 CSS 呈现，骨架重建后由 bindPaneControls 的 applyDensity 恢复形态。
+			pane.querySelector(".dap-density").append(createDensityIcon());
+			// 仓库入口常显于标题行右侧工具区（R-01-022/AC-01）；图标在创建时注入。
+			pane.querySelector(".dap-repo").append(createRepoIcon());
+			// 收起方向图标为标题行悬停/聚焦的可见性提示（R-01-011/AC-07），图标在创建时注入。
+			pane.querySelector(".dap-collapse-hint").append(createCollapseIcon());
 		}
 		if (pane !== boundPane) {
 			unbindPaneControls?.();
@@ -4728,6 +4985,50 @@ function apply(ctx) {
 		});
 	}
 
+	/** 紧凑显示切换按钮的「多行收拢为单行」密度图标：上下两个指向中线的箭头夹一条
+	 *  标题行横线，与「回到顶部」的单向箭头、标题行的收起方向图标均可区分
+	 *  （canonical 图标集无现成字形，14 盒 stroke 风格与 createTopIcon 一致，R-01-021/AC-05）。 */
+	function createDensityIcon() {
+		return createInlineIcon({
+			viewBox: "0 0 14 14",
+			width: 14,
+			height: 14,
+			parts: [
+				{ attrs: { d: "m3.5 4.5 3.5-3.5 3.5 3.5", stroke: "currentColor", "stroke-width": "1.5", "stroke-linecap": "round", "stroke-linejoin": "round" } },
+				{ attrs: { d: "M3 7h8", stroke: "currentColor", "stroke-width": "1.5", "stroke-linecap": "round", "stroke-linejoin": "round" } },
+				{ attrs: { d: "m3.5 9.5 3.5 3.5 3.5-3.5", stroke: "currentColor", "stroke-width": "1.5", "stroke-linecap": "round", "stroke-linejoin": "round" } },
+			],
+		});
+	}
+
+	/** 标题行的「收起」方向图标（R-01-011/AC-07）：左侧竖杠 + 向左箭头指向竖杠，
+	 *  表达窗格收缩到左侧；随 .dap-collapse-hint 在标题行悬停/聚焦时显现。 */
+	function createCollapseIcon() {
+		return createInlineIcon({
+			viewBox: "0 0 14 14",
+			width: 14,
+			height: 14,
+			parts: [
+				{ attrs: { d: "M3 2.5v9", stroke: "currentColor", "stroke-width": "1.5", "stroke-linecap": "round", "stroke-linejoin": "round" } },
+				{ attrs: { d: "M11.5 7H5", stroke: "currentColor", "stroke-width": "1.5", "stroke-linecap": "round", "stroke-linejoin": "round" } },
+				{ attrs: { d: "M8.25 3.75 5 7l3.25 3.25", stroke: "currentColor", "stroke-width": "1.5", "stroke-linecap": "round", "stroke-linejoin": "round" } },
+			],
+		});
+	}
+
+	/** 标题行工具区的仓库入口图标（R-01-022/AC-01）：GitHub Octicon `mark-github` 字形
+	 *  （MIT 许可，Primer Octicons），与工具区既有图标同用 14px 字形盒。 */
+	function createRepoIcon() {
+		return createInlineIcon({
+			viewBox: "0 0 16 16",
+			width: 14,
+			height: 14,
+			parts: [
+				{ attrs: { d: "M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27s1.36.09 2 .27c1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.28.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.01 8.01 0 0 0 16 8c0-4.42-3.58-8-8-8z", fill: "currentColor" } },
+			],
+		});
+	}
+
 	function createUserIcon() {
 		return createInlineIcon({
 			viewBox: "0 0 16 16",
@@ -5055,13 +5356,14 @@ function apply(ctx) {
 		}
 	}
 
-	/** 最近回合耗时 memo（等待卡与暂停子代理卡共用，R-01-009/AC-12、AC-15）：快照/历史引用不变即命中缓存。 */
-	function memoTurnDuration(detail, detailSnapshot) {
+	/** 最近回合耗时 memo（等待卡与暂停子代理卡共用，R-01-009/AC-12、AC-15）：history 引用
+	 *  不变即命中缓存。busy 口径（起止差值扣除回合内阻塞等待），与标题行总耗时同口径，
+	 *  保证恒不大于累计值（R-01-020）。 */
+	function memoTurnDuration(detail) {
 		const history = detail.history ?? null;
-		if (detail.memoTurnDurationSnapshotOf !== detailSnapshot || detail.memoTurnDurationHistoryOf !== history) {
-			detail.memoTurnDurationSnapshotOf = detailSnapshot;
+		if (detail.memoTurnDurationHistoryOf !== history) {
 			detail.memoTurnDurationHistoryOf = history;
-			detail.memoTurnDuration = lastTurnDuration({ turnTimings: detailSnapshot?.turnTimings, history });
+			detail.memoTurnDuration = lastTurnDuration({ history });
 		}
 		return detail.memoTurnDuration ?? null;
 	}
@@ -5229,7 +5531,7 @@ function apply(ctx) {
 		if (entry.kind === "running") {
 			renderProgressRow(el, entry.progress);
 			const traceContainer = el.querySelector(".dap-trace");
-			if (traceContainer !== null) renderTimelineArea(traceContainer, entry);
+			if (traceContainer !== null) renderTimelineArea(traceContainer, entry, { lastOnly: densityLevel === "medium" });
 			renderTokenStats(el, entry);
 			return;
 		}
@@ -5273,7 +5575,7 @@ function apply(ctx) {
 
 		if (entry.kind === "awaiting") {
 			const traceContainer = el.querySelector(".dap-trace");
-			if (traceContainer !== null) renderTimelineArea(traceContainer, entry);
+			if (traceContainer !== null) renderTimelineArea(traceContainer, entry, { lastOnly: densityLevel === "medium" });
 			removeAwaitingHeadDuration(el);
 			renderTokenStats(el, entry);
 			const confirm = el.querySelector(".dap-confirm");
@@ -5338,7 +5640,7 @@ function apply(ctx) {
 					// dsh 0.1.5 起快照不再携带会话内容：时间线经 eventSource 日志窗口
 					// 就地重派生（R-01-009）。
 					const listSnap = getSnapshot(sessions, "list");
-					captureSessionLog(id, { subagent: isSubagentRow(listSnap?.byId?.[id], listSnap ?? {}), cwd: listSnap?.byId?.[id]?.cwd ?? "" });
+					captureSessionLog(id, { cwd: listSnap?.byId?.[id]?.cwd ?? "" });
 					queueSync();
 				});
 			} catch {
@@ -5429,15 +5731,18 @@ function apply(ctx) {
 	}
 
 	/** 数量标识内容写入（R-01-014/AC-06）：加载态显示活动指示——已是指示则不重写，
-	 *  避免每轮 replaceChildren 重启动画抖动；计数态恢复文本写入，textContent 赋值自动摘除指示。 */
+	 *  避免每轮 replaceChildren 重启动画抖动；计数态恢复文本写入，textContent 赋值自动摘除指示。
+	 *  计数态同时写入悬停 tips（R-01-001/AC-08）：说明分子/分母口径；加载态无计数可解释，摘除。 */
 	function setCountBadgeContent(el, badge) {
 		if (badge.mode === "loading") {
 			const spinner = el.firstElementChild;
 			if (!(el.childNodes.length === 1 && spinner !== null && spinner.classList.contains("dap-spinner")))
 				el.replaceChildren(makeEl("span", "dap-spinner"));
-		} else if (el.textContent !== badge.text) {
+			if (el.getAttribute("title") !== null) el.removeAttribute("title");
+		} else {
 			// 值未变不写文本节点：aria-live 下相同赋值也会触发替换与重复播报。
-			el.textContent = badge.text;
+			if (el.textContent !== badge.text) el.textContent = badge.text;
+			if (el.getAttribute("title") !== badge.tip) el.setAttribute("title", badge.tip);
 		}
 	}
 
@@ -5966,7 +6271,7 @@ function apply(ctx) {
 				}
 			}
 			if (entry.kind === "awaiting" && detail) {
-				entry.elapsedMs = memoTurnDuration(detail, detailSnapshot);
+				entry.elapsedMs = memoTurnDuration(detail);
 			}
 			if (detail?.model) {
 				entry.model = detail.model.model;
@@ -6038,7 +6343,7 @@ function apply(ctx) {
 					// 非运行（暂停等待）：冻结最后已知统计与最近回合耗时，progress 置空隐藏
 					// 进度条（R-01-009/AC-15）；刷新/无留存时回退当前列表投影。
 					Object.assign(entry, mergeRuntimeStats(detail?.lastRuntimeStats, projectionStats));
-					entry.elapsedMs = detail ? memoTurnDuration(detail, detailSnapshot) : null;
+					entry.elapsedMs = detail ? memoTurnDuration(detail) : null;
 					entry.progress = null;
 				}
 			}
@@ -6061,13 +6366,13 @@ function apply(ctx) {
 		recentTotal = recentCandidates.length;
 		const recent = recentCandidates.slice(0, recentVisibleCount);
 		recentHasMore = recent.length < recentTotal;
-		// 最近卡统计复用运行卡的列表投影口径；耗时从保留快照或已读 history 取最近完整回合，
-		// 缺边界时仅为当前可见历史卡安排一次既有 history 补读（R-01-013/AC-12）。
+		// 最近卡统计复用运行卡的列表投影口径；耗时从已读 history 取最近完整回合的运行
+		// 过程时长（busy 口径，与标题行总耗时一致，R-01-013/AC-12），缺边界时仅为当前
+		// 可见历史卡安排一次既有 history 补读。
 		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 elapsedMs = lastTurnDuration({ history: detail?.history ?? null });
 			// 累计运行时长（R-01-020/AC-01）：最近历史卡同为标题行右侧显示；历史卡无开放回合。
 			applyTotalBusy(entry, now);
 			const stats = statsFromProjection(snapshot?.byId?.[entry.id]?.projectionValues, elapsedMs);
@@ -6145,7 +6450,7 @@ function apply(ctx) {
 		// 进入渲染，以便与当前可见等待卡末行重新对相（R-01-002/AC-07）。
 		// 历史卡的相对活动时间随分钟级时钟变化，纳入签名后只在文案实际变化时重绘。
 		const recentTimeSignature = recent.map((entry) => fmtRecentTime(entry.activityAt));
-		const sig = JSON.stringify([listState, cardSignature(visibleEntries), pulseSurface, recentTimeSignature]);
+		const sig = JSON.stringify([listState, cardSignature(visibleEntries), pulseSurface, recentTimeSignature, densityLevel]);
 		if (sig === lastSig) return;
 		const colorByWorkspace = resolveWorkspaceColors(visibleEntries.map((entry) => entry.workspaceKey));
 		// 跨区迁移（双向，R-01-010/AC-07）：DOM 写入前量取旧卡矩形并克隆 ghost。
@@ -6225,7 +6530,7 @@ function apply(ctx) {
 		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 headerEl = pane.querySelector(".dap-titlebar");
 		const recentHeadEl = recentSection?.querySelector(".dap-recent-head") ?? null;
 		for (const [head, hasItems] of [[headerEl, active.length > 0], [recentHeadEl, recent.length > 0]]) {
 			if (head === null) continue;
@@ -6237,11 +6542,12 @@ function apply(ctx) {
 			}
 		}
 
-		// 计数与折叠：n/m 只统计主会话——分子为等待行动数、分母为其加运行中主会话之和
+		// 计数与折叠：n/m 只统计主会话——分子为运行中数、分母为其加等待行动主会话之和
 		// （R-01-001/AC-04、AC-05）；空态同样显示 0/0（AC-06）。列表在途时不冒充计数，
-		// 三处数量标识显示加载指示（R-01-014/AC-06）。脉冲由 data-awaiting 承载：
-		// 任一等待行动（阻塞等待、完成提醒或错误提醒）即脉冲（R-01-002/AC-06，C-037）；
-		// 底色经 data-tone 跟随等待构成——错误 > 阻塞 > 完成 优先级取红/金/绿（C-040、C-043）。
+		// 三处数量标识显示加载指示（R-01-014/AC-06）。悬停 tips 说明分子/分母口径（AC-08）。
+		// 脉冲由 data-awaiting 承载：任一等待行动（阻塞等待、完成提醒或错误提醒）即脉冲
+		// （R-01-002/AC-06，C-037）；底色经 data-tone 跟随等待构成——错误 > 阻塞 > 完成
+		// 优先级取红/金/绿（C-040、C-043）。
 		const count = pane.querySelector(".dap-count");
 		const railCount = pane.querySelector(".dap-rail-count");
 		const { waiting, blocked, total } = awaitBadgeStats(active);
@@ -6292,6 +6598,21 @@ function apply(ctx) {
 			prevRenderedActiveIds = new Set(active.map((entry) => String(entry.id)));
 			prevRenderedRecentIds = new Set(recent.map((entry) => String(entry.id)));
 		}
+		// 锚定补偿（R-01-021/AC-01）：档位切换的渲染落地后量测当前选中卡的新位置并
+		// 补偿 scrollTop，使当前卡顶部回到切换前相对视口的位置；补偿量超滚动边界时
+		// 由浏览器钳制（以当前卡不滚出可视范围为准）。
+		if (pendingDensityAnchor !== null) {
+			const scrollEl = pane.querySelector(".dap-scroll");
+			// 补偿按当前 DOM 的 data-current 卡实时定位：跨区迁移等渲染可能重建卡片
+			// 元素，不持有旧引用（量测恒为 attached 节点）。
+			const currentCard = scrollEl?.querySelector(".dap-card[data-current]") ?? null;
+			if (scrollEl !== null && currentCard !== null) {
+				const viewportTop = scrollEl.getBoundingClientRect().top;
+				const shiftedTop = currentCard.getBoundingClientRect().top - viewportTop;
+				scrollEl.scrollTop += shiftedTop - pendingDensityAnchor;
+			}
+			pendingDensityAnchor = null;
+		}
 	}
 
 	// ---- 打开会话（让 sessions.open 自己校验列表，失败时 refresh + 重试） ----
@@ -6488,12 +6809,19 @@ function apply(ctx) {
 		window.removeEventListener("pageshow", onBusyPageShow);
 		document.removeEventListener("visibilitychange", onVisibilityResume);
 		window.removeEventListener("pageshow", onPageShow);
+		document.removeEventListener("visibilitychange", onSyncVisibilityResume);
+		window.removeEventListener("pageshow", onSyncPageShow);
 		completeAcksById.clear();
 		busyById.clear();
 		busyRequestedIds.clear();
 		busyRetryAtById.clear();
 		if (clockTimer !== null) clearInterval(clockTimer);
 		if (recentTimeTimer !== null) clearInterval(recentTimeTimer);
+		if (syncThrottleTimer !== null) clearTimeout(syncThrottleTimer);
+		// 流式派生合并窗口：逐 detail 清理在途 timer（T-127）。
+		for (const detail of sessionDetailsById.values()) {
+			if (detail.logDeriveTimer) clearTimeout(detail.logDeriveTimer);
+		}
 		if (e2eListReleaseTimer !== null) clearTimeout(e2eListReleaseTimer);
 		for (const [timer, resolve] of e2eModelDelayWaiters) {
 			clearTimeout(timer);