dsh-activity-pane 0.3.0 → 0.6.0

package/src/core.mjs

@@ -3,7 +3,7 @@
 //
 // 数据源约定（来自 @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, ... }] } }
@@ -11,8 +11,8 @@
 // 以及 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 = {
@@ -1067,6 +1067,31 @@ export function usageSummary({ uncachedInputTokens = null, cacheReadTokens = nul
 	return { inputTokens, cacheHitPct };
 }
 
+/** 从 sessions.list 的投影统一归一卡片统计：运行卡与最近卡共享同一口径。 */
+export 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。 */
+export 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,
+	};
+}
+
 /** 需要用户行动的种类的展示文案。 */
 export function pendingText(kind) {
 	return PENDING_LABELS[kind] ?? PENDING_UNKNOWN_LABEL;
@@ -1168,8 +1193,8 @@ export 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）。 */
 export function detailLoadPlan({
 	detail = {},
 	isSubagent = false,
@@ -1250,11 +1275,11 @@ export 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。
  */
 export function workspaceHue(key) {
@@ -1273,34 +1298,99 @@ export function workspaceHue(key) {
 	return 30 + (hash % 291);
 }
 
-const WORKSPACE_HUE_ANCHORS = [55, 100, 145, 190, 235, 280, 325];
+export 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));
+
+export 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 主槽位分配，主槽位占满后再使用五个受控明度/色相补充槽位；每个前景槽位
+ * 内优先使用未用的三个背景变体；超过三十六个复合身份后按槽位使用次数均衡复用。
  */
-export function resolveWorkspaceHues(keys) {
+export 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();
@@ -1355,6 +1445,7 @@ export 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）的
@@ -1362,21 +1453,38 @@ export function mainTitle(byId, id) {
  * 记账派生）：集合内会话视同处于委托周期——后代耗尽至 settle 处理回合启动的
  * 空窗内仍保持运行呈现、完成/错误提醒不生效；条目的 descendantActive 字段
  * 始终为当帧原始后代活性（供进度锚点记账判定耗尽），不受 delegatingIds 影响。
+ * archivedIds（工作区服务的注册表全局归档集合）：归档会话及其有效子代理子树不产出活动条目，
+ * 普通 fork 仅因共享来源 parentId 不受影响；避免会话服务仍保留旧行或完成提醒时在窗格中滞留。
  */
-export function buildEntries(snapshot, workspaceItems, detailsById = {}, completions = null, delegatingIds = null) {
+export 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);
@@ -1594,10 +1702,15 @@ export function listLoadState(snapshot) {
 	return "ready";
 }
 
-/** 会话行是否为某主会话的直属子代理。 */
+/** 会话行是否为某主会话的直属子代理：需同时满足 origin 与有效父会话。 */
 export 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;
 }
 
 /** 会话行是否满足自身状态的活动判定，不含后代活动继承。
@@ -1611,31 +1724,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 链补齐活动祖先（含活动会话自身），供历史区显示判定。 */
+/** 沿实际子代理关系补齐活动祖先（含活动会话自身），供历史区显示判定。 */
 export 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 解耦——

package/src/navigation.mjs

@@ -47,6 +47,43 @@ export function openSession(sessions, sessionId) {
 	}
 }
 
+/**
+ * 以最小必要距离把卡片滚入窗格滚动视口；不会居中，也不会滚动外层页面。
+ * 默认使用原生 smooth scroll，调用方可传 auto 适配降低动效偏好；缺少 scrollTo 或 options 不受支持时回退为同步滚动
+ * （R-01-006/AC-02）。
+ */
+export 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）。 */
 export const COMPOSER_SELECTOR = "textarea[data-phase]";