dsh-activity-pane 0.7.0 → 0.9.0

package/src/client.mjs

@@ -1,18 +1,23 @@
 // dsh-activity-pane 浏览器运行时。
 //
-// 挂载策略：把窗格作为 AppFrame 中 `conversation` 槽座的前置兄弟列插入
-// （`#root [data-slot="conversation"] || .parentElement` 即 flex 行），让外壳的
-// 让步链挤压中间栏；窄屏（<=767px）转为固定抽屉 + 浮动开关按钮。
+// 挂载策略：把窗格作为 AppFrame 中 keyed `main` 槽容器的前置兄弟列插入
+// （`#root [data-slot="main"] || .parentElement` 即中列 flex，dsh 0.1.5 起原
+// `conversation` Slot 迁移为 `main` 的 `conversation` key），让外壳的让步链
+// 挤压中间栏；窄屏（<=767px）转为固定抽屉 + 浮动开关按钮。
 //
-// 数据来源：DSH 原生 `sessions` / `workspaces` 客户端服务（推送式快照）+ native
-// `sessions.history` / `sessions.models` 冷会话读取 + 运行中会话的原生订阅
-//（binding().session）+ 可选 `modelDirectories` 目录 store 订阅（模型选择实时更新，
-// 缺失时回落一次性读取），不依赖任何第三方插件数据路由，也不做状态轮询。
+// 数据来源：DSH 原生 `sessions` / `workspaces` 客户端服务（推送式快照）+ `remote`
+// 服务的部署级模型目录（session/modelCatalog）与会话日志分页（session/page，
+// Session 格式 V3——dsh 0.1.5 起快照不再携带会话内容、connection.api 门面移除）+
+// 运行中会话的原生订阅（binding().session，运行状态面）+ 可选 `modelDirectories`
+// 目录 store 订阅（模型选择实时更新），不依赖任何第三方插件数据路由，也不做状态轮询。
 
 const name = "dsh-activity-pane";
-const inject = ["connection", "sessions", "workspaces"];
+// remote.session：dsh 0.1.5 起会话 RPC（目录/日志分页）经 api-remotes 的点分命名空间
+// 注入（cordis 代理对未注入属性直接抛错，父服务声明不代表子命名空间可用；仅声明
+// 子命名空间即可解析，无需再注入父面）。
+const inject = ["sessions", "workspaces", "uiSession", "remote.session"];
 
-const CONVERSATION_SELECTOR = "#root [data-slot=\"conversation\"]";
+const CONVERSATION_SELECTOR = "#root [data-slot=\"main\"]";
 const PANE_ATTR = "data-dsh-activity-pane";
 const PANE_CLASS = "dap-pane";
 const LIST_CLASS = "dap-list";
@@ -24,7 +29,7 @@ const INSTANCE_KEY = "__dshActivityPaneCleanup";
 const WIDTH_STORAGE_KEY = "dsh-activity-pane:width";
 const COLLAPSED_WIDTH = 34;
 /** 宿主侧完成确认 API 前缀（C-030）：acks 快照 / SSE 推送 / ack 写回，同源受信。 */
-const ACK_API_BASE = "/dsh-activity-pane/api";
+const PANE_API_BASE = "/dsh-activity-pane/api";
 // 缩进槽宽：与连接线 CSS 几何耦合（left:-8px = INDENT_PX/2 缩进槽中线，
 // top:-6px/bottom:-2px 对应 .dap-list 的 gap:6px），改任一数值须三处同步；
 // scripts/check.mjs 有钉住断言。
@@ -432,14 +437,19 @@ 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-013/AC-09）。 */
-[data-dsh-activity-pane] .dap-card[data-kind="recent"] .dap-title {
-  font-weight: 400;
+/* 标题行最右侧的累计运行时长（R-01-020/AC-01）：固定占位不参与标题挤压，
+   标题过长时以自身省略号让位；色调弱于标题，不与状态点抢视觉。 */
+[data-dsh-activity-pane] .dap-total-time {
+  flex: none; margin-left: auto; font-size: 12px; line-height: 16px;
+  color: #8a94a3; white-space: nowrap;
 }
+[data-dsh-activity-pane] .dap-total-time[hidden] { display: none; }
 /* 等待卡末行首行「类型胶囊」（R-01-002/AC-01、AC-02、AC-09、AC-13，C-043）：圆底类型
    图标 + 类型文字，色相随等待类别（--dap-wait-color）——阻塞金/完成绿/错误红；
    胶囊为行内元素不自占满宽，随文字内容收缩。 */
@@ -565,6 +575,7 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
 [data-dsh-activity-pane] .dap-progress {
   display: flex; align-items: center; gap: 7px; min-width: 0;
 }
+[data-dsh-activity-pane] .dap-progress[hidden] { display: none; }
 [data-dsh-activity-pane] .dap-progress .dap-track { flex: 1 1 auto; min-width: 0; }
 [data-dsh-activity-pane] .dap-pct {
   flex: none; width: 5ch; font-size: 12px; line-height: 15px; font-weight: 700; text-align: right;
@@ -1035,8 +1046,10 @@ function apply(ctx) {
 	let disposed = false;
 	let sessions = null;
 	let workspaces = null;
+	let uiSession = null;
 	let sessionUnsubscribe = null;
 	let workspaceUnsubscribe = null;
+	let pendingUnsubscribe = null;
 	let clockTimer = null;
 	let recentTimeTimer = null;
 	let syncScheduled = false;
@@ -1109,12 +1122,24 @@ function apply(ctx) {
 	const sessionDetailsById = new Map();
 	/** 会话跳转的单一重试链；避免重复点击叠加 refresh/timer。 */
 	const openRetryStates = new Map();
-	/** native cold-session model/history reads, one promise per session and no polling. */
+	/** 主会话目录一次性 load 的在途记账：id → promise（字段级加载指示消费）。 */
 	const modelLoads = new Map();
+	/** native cold-session log reads, one promise per session and no polling. */
 	const historyLoads = new Map();
 	/** 模型目录订阅（R-01-012/AC-16）：id → unsubscribe；模型选择切换经原生
 	 *  modelDirectories store 推送即时到达，随可见性清理/卸载先 unsubscribe 再除名。 */
 	const modelDirectorySubs = new Map();
+	const logSourceSubs = new Map();
+	/** 模型目录分组的 modelId → {name, reasoning} 索引（R-01-012/AC-17）：同一部署的
+	 *  目录分组在主/子会话间共享，经主会话的目录订阅与一次性 models RPC 就地收割，
+	 *  渲染时解析显示名与 effort 回退。无原型对象：模型 id 可能恰为 "constructor" 等
+	 *  继承键名，不得穿透回退。 */
+	const catalogEntries = Object.create(null);
+	/** 部署级目录分组（dsh 0.1.5 起模型上下文的显示名/effort 解析来源）：由
+	 *  remote.sessions.modelCatalog 与 modelDirectories 订阅推送共同收割。 */
+	let catalogGroups = [];
+	/** 部署级 modelCatalog 一次性读取的在途 Promise：成功即缓存、失败允许重试。 */
+	let catalogPromise = null;
 	/** native session.open() requests in flight; avoid duplicate cold history reads. */
 	/** 冷数据读取并发池：队列顺序即优先级（调用方已排序），逐个完成逐个重绘。 */
 	const loadQueue = [];
@@ -1281,7 +1306,7 @@ function apply(ctx) {
 		acksSource = null;
 		if (disposed || typeof window.EventSource !== "function") return;
 		try {
-			const source = new window.EventSource(`${ACK_API_BASE}/acks/stream`);
+			const source = new window.EventSource(`${PANE_API_BASE}/acks/stream`);
 			source.addEventListener("state", (event) => applyAcksState(event.data ?? ""));
 			acksSource = source;
 		} catch {
@@ -1311,7 +1336,7 @@ function apply(ctx) {
 		completeAcksById.set(id, { ...prev, lastTurnEnd: prev?.lastTurnEnd ?? null, ackedAt: Date.now() });
 		queueSync();
 		try {
-			const response = await fetch(`${ACK_API_BASE}/ack`, {
+			const response = await fetch(`${PANE_API_BASE}/ack`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify({ sessionId: id }),
@@ -1325,8 +1350,137 @@ function apply(ctx) {
 		}
 	}
 
-	function apiValue(response) {
-		return response?.result?.ok === true ? response.result.value : null;
+	// ---- 累计运行时长通道（R-01-020，C-074） ----
+	// SSE 订阅宿主侧回合统计：连接即收全量快照（刷新/重连恢复），此后每次变更（回合
+	// 边界、回填完成）推送新全量。无 EventSource 环境静默降级为不显示累计时长。
+	// 可见会话的懒回填经 GET /busy?ids= 触发（fire-and-forget），完成后经同一 SSE 广播。
+	const busyById = new Map(); // sessionId -> { busyMs, openTurnStart }
+	const busyRequestedIds = new Set(); // 已触发过回填的会话 id（宿主侧单飞，本地防重复请求）
+	const busyRetryAtById = new Map(); // sessionId -> 回填失败后的最早重试时刻（30s 退避，不逼近轮询）
+	let busySource = null;
+	let busyFetchInflight = false;
+
+	/** SSE 全量快照应用：接受已解析对象或原始 JSON 文本；解析失败静默丢弃。 */
+	function applyBusyState(input) {
+		if (disposed) return;
+		let state = typeof input === "object" ? input : null;
+		if (state === null) {
+			try {
+				state = JSON.parse(input);
+			} catch {
+				state = null;
+			}
+		}
+		if (state === null || typeof state !== "object") return;
+		busyById.clear();
+		for (const [id, record] of Object.entries(state)) {
+			busyById.set(String(id), {
+				busyMs: normalizeBusyMs(record?.busyMs),
+				openTurnStart: normalizeBusyMs(record?.openTurnStart),
+				waitedMs: normalizeBusyMs(record?.waitedMs),
+				openWaitStart: normalizeBusyMs(record?.openWaitStart),
+			});
+		}
+		queueSync();
+	}
+
+	/** 累计运行时长注入（R-01-020/AC-01、AC-03、AC-07）：已完成回合累计 + 开放回合实时
+	 *  已耗时（扣除等待区间）；渲染期按 now 合成，阻塞等待期间公式自冻结；子代理条目
+	 *  不注入（entry.totalBusyMs 保持 undefined → 节点隐藏）。 */
+	function applyTotalBusy(entry, now) {
+		const busyRecord = busyById.get(entry.id);
+		entry.totalBusyMs = totalBusyDisplayMs({
+			busyMs: busyRecord?.busyMs ?? null,
+			openTurnStart: busyRecord?.openTurnStart ?? null,
+			waitedMs: busyRecord?.waitedMs ?? null,
+			openWaitStart: busyRecord?.openWaitStart ?? null,
+			now,
+		});
+	}
+
+	/** 触发可见主会话的懒回填：只对未请求过的 id 发一次 GET；在途时跳过（SSE 广播兜底）。 */
+	function requestBusyBackfill(ids) {
+		if (disposed || typeof fetch !== "function") return;
+		const pending = ids.filter((id) => !busyRequestedIds.has(id) && !busyById.has(id) && Date.now() >= (busyRetryAtById.get(id) ?? 0));
+		if (pending.length === 0 || busyFetchInflight) return;
+		for (const id of pending) busyRequestedIds.add(id);
+		busyFetchInflight = true;
+		fetch(`${PANE_API_BASE}/busy?ids=${encodeURIComponent(pending.join(","))}`)
+			.then((response) => (response.ok ? response.json() : null))
+			.then((state) => {
+				if (state !== null && typeof state === "object") applyBusyState(state);
+			})
+			.catch(() => {
+				// 回填触发失败：30s 退避后允许重试，不逐帧逼近轮询形态。
+				const retryAt = Date.now() + 30_000;
+				for (const id of pending) {
+					busyRequestedIds.delete(id);
+					busyRetryAtById.set(id, retryAt);
+				}
+			})
+			.finally(() => {
+				busyFetchInflight = false;
+			});
+	}
+
+	/** （重）建 SSE 连接：先关闭旧连接再新建；连接即收宿主侧全量快照。 */
+	function connectBusyStream() {
+		try {
+			busySource?.close();
+		} catch {}
+		busySource = null;
+		if (disposed || typeof window.EventSource !== "function") return;
+		try {
+			const source = new window.EventSource(`${PANE_API_BASE}/busy/stream`);
+			source.addEventListener("state", (event) => applyBusyState(event.data ?? ""));
+			busySource = source;
+		} catch {
+			busySource = null;
+		}
+	}
+	// 回到前台（含 bfcache 还原）时 busy 通道自愈：重建 SSE，借连接全量快照收敛；
+	// 具名 handler 使 cleanup 能移除监听（与 acks 通道同模式，R-02-003）。
+	const onBusyVisibilityResume = () => {
+		if (document.visibilityState === "visible" && !disposed) connectBusyStream();
+	};
+	const onBusyPageShow = (event) => {
+		if (event?.persisted === true && !disposed) connectBusyStream();
+	};
+	document.addEventListener("visibilitychange", onBusyVisibilityResume);
+	window.addEventListener("pageshow", onBusyPageShow);
+	connectBusyStream();
+
+	function remoteValue(response) {
+		if (response?.ok === true) return response.value;
+		throw response?.error ?? new Error("remote request failed");
+	}
+
+	/** 会话日志分页地址（R-01-012）：主会话 `{kind:"session", sessionId}`；子代理
+	 *  `{kind:"subagent", parentSessionId, childSessionId, mode}`——母会话 id 兼容
+	 *  `parentSessionId` / `parentId` 两种条目键名，mode 无条目标注时按一次性子代理
+	 *  处理、读取失败由 pagedHistoryEvents 以 null 收敛为空白详情（R-01-013）。 */
+	function sessionPageAddress(id, byId) {
+		const row = byId[id] ?? {};
+		if (row?.origin === "subagent") {
+			const parentId = row.parentSessionId ?? row.parentId;
+			if (parentId !== undefined && parentId !== null) {
+				return {
+					kind: "subagent",
+					parentSessionId: String(parentId),
+					childSessionId: String(id),
+					mode: row.continuable === true ? "continuable" : "one-shot",
+				};
+			}
+		}
+		return { kind: "session", sessionId: String(id) };
+	}
+
+	/** 部署级目录分组收割（R-01-012/AC-01）：modelCatalog RPC 与 modelDirectories
+	 *  目录订阅推送共享同一部署目录，后到覆盖（分组集合一致）；展平索引进
+	 *  `catalogEntries` 供子代理溯源 id 解析显示名。空分组不覆盖既有缓存。 */
+	function harvestCatalog(groups) {
+		if (Array.isArray(groups) && groups.length > 0) catalogGroups = groups;
+		Object.assign(catalogEntries, catalogModelEntries(groups));
 	}
 
 	/** 同帧重启等待提醒动画：数量胶囊保持亮度呼吸，卡片末行保持 opacity 脉冲，
@@ -1351,16 +1505,17 @@ function apply(ctx) {
 		try {
 			directory = ctx.get("modelDirectories")?.directoryFor?.(id) ?? null;
 		} catch {
-			directory = null; // 会话无 scope：回落一次性读取
+			directory = null; // 会话无 scope：回落日志提取
 		}
 		if (directory === null) return;
 		const syncFromDirectory = () => {
 			if (disposed) return;
 			const snap = directory.store?.getSnapshot?.();
 			if (!snap?.current) return; // 目录未就绪：不覆写既有取值
+			harvestCatalog(snap.groups);
 			detail.models = { current: snap.current, groups: snap.groups ?? [] };
 			detail.model = modelMetadata(detail.models);
-			// 订阅已产值标记：晚到的一次性 RPC 快照不得回写切换前的旧值。
+			// 订阅已产值标记：晚到的一次性快照不得回写切换前的旧值。
 			detail.modelLive = true;
 			queueSync();
 		};
@@ -1368,17 +1523,48 @@ function apply(ctx) {
 		try {
 			unsubscribe = directory.store.subscribe(syncFromDirectory);
 		} catch {
-			return; // 订阅失败：保持一次性读取结果
+			return; // 订阅失败：保持日志提取结果
 		}
 		modelDirectorySubs.set(id, unsubscribe);
-		syncFromDirectory(); // 目录已被主窗口加载时立即同步，该会话免发一次性 RPC
+		syncFromDirectory(); // 目录已被主窗口加载时立即同步，该会话免发一次性读取
+	}
+
+	/** 目录 store 一次性 load（dsh 0.1.5 起惰性加载：不 load 不产出当前选择，原生模型
+	 *  选择器同样先 load）。load 与 select() 的 generation 竞争以「最新操作胜出」，用户
+	 *  切换后到仍胜出。e2e 接缝（dap-e2e-model-delay）延迟 load 发起，使模型上下文
+	 *  严格晚于时间线呈现，渐进渲染可观察（R-01-014/AC-03）。 */
+	function loadDirectoryOnce(id) {
+		if (disposed || !modelDirectorySubs.has(id) || modelLoads.has(id)) return;
+		let directory = null;
+		try {
+			directory = ctx.get("modelDirectories")?.directoryFor?.(id) ?? null;
+		} catch {
+			directory = null;
+		}
+		if (directory === null) return;
+		try {
+			const loadPromise = delayedModelCall(() => (typeof directory.load === "function" ? directory.load() : null));
+			if (loadPromise && typeof loadPromise.finally === "function") {
+				modelLoads.set(id, loadPromise);
+				// 守卫只在失败时释放（放行下一次渲染重试）；成功后保持到可见性 prune，
+				// 兑现一次性 load 语义。若 settle 即释放，目录 store 的每次广播
+				// （syncInputs 无条件以新引用 set）都会再驱动 render → load → 广播，
+				// 形成 rAF 速率反馈环——空闲期 60fps 满载，手机端表现为持续发烫。
+				loadPromise.catch(() => {
+					if (modelLoads.get(id) === loadPromise) modelLoads.delete(id);
+				});
+			}
+			loadPromise?.catch(() => {});
+		} catch {
+			// load 不可用：保持订阅，等待主窗口加载后的推送。
+		}
 	}
 
-	function loadNativeDetails(ids, previewFallbackIds = new Set(), durationFallbackIds = new Set()) {
-		const api = ctx.get("connection")?.api?.sessions;
-		if (!api) return;
+	function loadNativeDetails({ ids, previewFallbackIds = new Set(), durationFallbackIds = new Set(), subagentModelReadIds = new Set() }) {
+		const sessionRemote = ctx.get("remote.session") ?? null;
+		if (!sessionRemote) return;
+		ensureCatalogGroups(sessionRemote);
 		const byId = getSnapshot(sessions, "list")?.byId ?? {};
-		const modelPromises = [];
 		const historyPromises = [];
 		for (const id of ids) {
 			const detail = sessionDetailsById.get(id) ?? {};
@@ -1386,80 +1572,55 @@ function apply(ctx) {
 			if (liveSnapshot) detail.snapshot = liveSnapshot;
 			sessionDetailsById.set(id, detail);
 			const subagent = isSubagentRow(byId[id], byId);
-			// 主会话先试模型目录订阅：store 已有当前选择时同步填充（随后 plan.model 为假、免发 RPC）；
-			// 子代理的目录不可用（宿主以 agent-busy 拒绝其模型 RPC），不建立订阅。
-			if (!subagent && e2eModelDelayMs === 0) subscribeModelDirectory(id, detail);
-			const snapshotReady = detail.snapshot?.openState === "open";
-			// 冷窗口兜底（R-01-009/AC-06、R-01-012/AC-12）：快照就绪但窗口缺开放回合起点
-			// （超长回合的 turn/start 在尾页窗口之外；等待/空闲会话不算缺口）或缺可锚
-			// 用户行时，补读一次 history。
-			const turnStartMissing = openTurnStartMissing({
-				snapshotReady,
-				running: byId[id]?.running === true,
-				hasLiveness: livenessById.has(id),
-				liveStartTime: livenessById.get(id)?.liveness?.startTime ?? null,
-			});
-			const windowComplete = snapshotReady !== true || (!turnStartMissing && detail.snapshotHasAnchorableUserRow === true);
-			const durationFallbackNeeded = durationFallbackIds.has(id) && detail.durationFallbackLoaded !== true;
-			const plan = detailLoadPlan({
-				detail,
-				isSubagent: subagent,
-				snapshotReady,
-				historyNeeded: needsHistorySnapshot(detail.snapshot),
-				previewFallbackNeeded: previewFallbackIds.has(id),
-				durationFallbackNeeded,
-				windowComplete,
-				modelInflight: modelLoads.has(id),
-				historyInflight: historyLoads.has(id) || sessionOpenLoads.has(id),
-			});
-			if (plan.subagent) {
-				// 子代理的 models 读取必被宿主以 agent-busy 拒绝：直接留空，不发注定失败的 RPC。
-				detail.model ??= { model: "", reasoning: "" };
-			} else if (plan.model && typeof api.models === "function") {
-				const promise = enqueueDetailLoad(() => delayedModelCall(() => api.models({ sessionId: id }))
-					.then((response) => {
-						const value = apiValue(response);
-						if (!value) {
-							if (!detail.modelLive) detail.model = { model: "", reasoning: "" };
-							return;
-						}
-						// 目录订阅已产出更新的当前选择时，晚到的 RPC 快照不得回写旧值（R-01-012/AC-16）。
-						if (detail.modelLive) return;
-						detail.models = value;
-						detail.model = modelMetadata(value);
-					})
-					.catch((error) => {
-						if (!detail.modelLive) detail.model = { model: "", reasoning: "" };
-						detail.modelError = error instanceof Error ? error.message : String(error);
-					}));
-				modelLoads.set(id, promise);
-				// settle 即移除记账：在途判定驱动加载指示，残留会让空字段永久误报加载。
-				promise.finally(() => {
-					if (modelLoads.get(id) === promise) modelLoads.delete(id);
-				});
-				modelPromises.push(promise);
+			// 主会话建立模型目录订阅：dsh 0.1.5 起目录 store 惰性加载（不 load 不产出当前
+			// 选择），订阅与一次性 load 一并触发；子代理的目录不可用（宿主以 agent-busy
+			// 拒绝其模型 RPC），不建立订阅。e2e 接缝把订阅与 load 整体延后，使模型上下文
+			// 严格晚于时间线呈现（R-01-014/AC-03 渐进语义可观察）。
+			if (!subagent) {
+				if (e2eModelDelayMs === 0) {
+					subscribeModelDirectory(id, detail);
+					loadDirectoryOnce(id);
+				} else {
+					delayedModelCall(() => {
+						subscribeModelDirectory(id, detail);
+						loadDirectoryOnce(id);
+						return null;
+					});
+				}
 			}
-			if (plan.history && typeof api.history === "function") {
-				if (durationFallbackNeeded) detail.durationFallbackLoaded = true;
-				if (previewFallbackIds.has(id)) detail.previewFallbackLoaded = true;
+			captureSessionLog(id, { subagent, cwd: byId[id]?.cwd ?? "" });
+			// 长会话深读兜底（R-01-013/AC-03）：最近卡预览/子代理溯源不在尾页日志窗口内
+			// 且宿主标记 hasMore 时，按 beforeSeq 向前回溯翻页（默认无页数上限）。
+			const windowEntries = Array.isArray(detail.log?.entries) ? detail.log.entries : [];
+			const lastSeq = Number(windowEntries.at(-1)?.event?.seq);
+			const deepReadNeeded =
+				(previewFallbackIds.has(id) || durationFallbackIds.has(id) || (subagent && subagentModelReadIds.has(id))) &&
+				detail.log?.hasMore === true &&
+				Number.isFinite(lastSeq) &&
+				detail.historyDeepReadDone !== true;
+			// 在途守卫：深翻未在途才入队。渲染逐帧发生而 deepReadNeeded 在深翻完成前恒真，
+			// 无守卫时每帧重复入队新 job，队列以 LOAD_CONCURRENCY 并发放大发——同一会话的
+			// page RPC 风暴，且 historyLoads 的 set/delete 随 job 翻转驱动加载指示高频闪烁。
+			if (deepReadNeeded && !historyLoads.has(id)) {
+				detail.previewFallbackLoaded = true;
+				detail.durationFallbackLoaded = true;
+				const address = sessionPageAddress(id, byId);
 				const promise = enqueueDetailLoad(() => Promise.resolve()
 					.then(async () => {
-						// 单池任务内串行回溯深翻（默认无页数上限）：向前翻到命中最近一条
-						// 用户消息或翻尽为止——超长会话的最后用户消息可能在尾页窗口之外，
-						// 固定页数上限会让历史卡用户预览永久缺失（R-01-013/AC-03 回溯承诺）。
-						// 运行会话缺窗口内回合起点时要求深翻至命中开放回合 turn/start
-						// （R-01-009/AC-06 冷窗口兜底）。
 						const { events, error } = await pagedHistoryEvents({
-							fetchPage: async (beforeSeq) => apiValue(await api.history({ sessionId: id, beforeSeq, maxMessages: 50 })),
-							requireOpenTurnStart: turnStartMissing,
+							fetchPage: async (beforeSeq) => {
+								const value = remoteValue(
+									await sessionRemote.page({ address, throughSeq: lastSeq, beforeSeq, maxMessages: 50 }),
+								);
+								if (!value) return null;
+								return { events: Array.isArray(value.records) ? value.records : [], hasMore: value.hasMore === true };
+							},
 						});
 						if (error) detail.historyError = error instanceof Error ? error.message : String(error);
 						detail.history = events;
-						// R-01-017：冷路径同样折叠分组（取全量页内事件再折成最多 4 组，
-						// 含指令锚行窗口选择，R-01-012/AC-12～AC-15）。
-						detail.timeline = foldedHistoryTimeline(events, 4, byId[id]?.cwd ?? "");
-						detail.previews = messagePreviews({ history: events });
-					}))
+						detail.historyDeepReadDone = true;
+						applyLogEvents(id, detail, events, { subagent, cwd: byId[id]?.cwd ?? "", planSubagentModelRead: subagent });
+					}));
 				historyLoads.set(id, promise);
 				promise.finally(() => {
 					if (historyLoads.get(id) === promise) historyLoads.delete(id);
@@ -1467,7 +1628,7 @@ function apply(ctx) {
 				historyPromises.push(promise);
 			}
 		}
-		const pending = modelPromises.concat(historyPromises);
+		const pending = historyPromises;
 		if (pending.length > 0) {
 			// 逐个完成即重绘（先就绪先显示，不等待全部，R-01-014/AC-03）；
 			// 并立即重绘一次让加载指示在数据返回前出现。
@@ -1476,15 +1637,115 @@ function apply(ctx) {
 		}
 	}
 
+	/** 日志页落地后的详情派生（R-01-012、R-01-017）：时间线折叠、消息预览与子代理模型上下文。
+	 *  子代理沿用溯源链（assistant/message source.model + 请求头 effort，T-122）；主会话模型
+	 *  不经日志提取（目录链订阅 + 一次性 load 承载，见 installServiceSubscriptions 注）。
+	 *  无请求头/无溯源时保持空白，不以部署默认或其它会话取值冒充（R-01-012/AC-18）。 */
+	function applyLogEvents(id, detail, events, { subagent, cwd = "", planSubagentModelRead = false }) {
+		detail.history = events;
+		detail.timeline = foldedHistoryTimeline(events, 4, cwd);
+		detail.previews = messagePreviews({ history: events });
+		if (subagent) {
+			if (planSubagentModelRead) {
+				detail.modelReadDone = true;
+				if (!detail.model) detail.model = modelFromHistoryEvents(events);
+			} else if (!detail.model) {
+				detail.model = modelFromHistoryEvents(events);
+			}
+			if (detail.model && !detail.model.reasoning) {
+				detail.model.reasoning = reasoningEffortFromHistoryEvents(events) ?? "";
+			}
+			return;
+		}
+		// 主会话模型上下文不经日志提取：以 modelDirectories 目录订阅为准（实时推送
+		// 当前选择），不可得时保持空白，不以日志历史取值或部署默认冒充（R-01-012/AC-18）。
+	}
+
+	/** 绑定会话并水合事件源（dsh 0.1.5 起会话内容经 eventSource 流式下发：打开即收
+	 *  完整日志窗口 + 实时尾，原生 Conversation 同源）。冷会话补一次 open()，日志窗口
+	 *  快照引用变化即重派生详情（时间线/预览/模型），窗口由宿主按消息对齐分页。 */
+	function captureSessionLog(id, { subagent, cwd }) {
+		const detail = sessionDetailsById.get(id) ?? {};
+		sessionDetailsById.set(id, detail);
+		let session = null;
+		try {
+			session = sessions?.binding?.(id)?.session ?? null;
+		} catch {
+			session = null;
+		}
+		if (session === null) return;
+		// 日志窗口无效化订阅（事件驱动，不构成轮询，R-02-004）：等待/历史卡无会话状态
+		// 订阅（syncLiveness 只订阅运行中），窗口推进（回合收尾、流式尾）必须经此回调
+		// 重读快照并重绘；否则窗口更新只能靠渲染期重读兜底——渲染一旦静默（一次性
+		// load 修复后），完成提醒耗时等窗口派生数据将永久停摆。随可见性 prune。
+		if (typeof session.eventSource?.subscribe === "function" && !logSourceSubs.has(id)) {
+			try {
+				logSourceSubs.set(
+					id,
+					session.eventSource.subscribe(() => {
+						if (disposed) return;
+						const listSnap = getSnapshot(sessions, "list");
+						captureSessionLog(id, {
+							subagent: isSubagentRow(listSnap?.byId?.[id], listSnap ?? {}),
+							cwd: listSnap?.byId?.[id]?.cwd ?? "",
+						});
+						queueSync();
+					}),
+				);
+			} catch {
+				// 订阅不可用：回退渲染期重读。
+			}
+		}
+		try {
+			// 日志窗口缺席才发起 open：非订阅会话（等待/历史卡）无快照推送，openState 永远
+			// 不可知，只以 openState 把关会对已水合会话逐帧重发 open，settle→delete→重发
+			// 的在途翻转同样驱动加载指示抖动（docsim 卡闪烁根因之一）。
+			if (!detail.log && detail.snapshot?.openState !== "open" && !sessionOpenLoads.has(id) && typeof session.open === "function") {
+				const opening = Promise.resolve(session.open()).catch(() => {});
+				sessionOpenLoads.set(id, opening);
+				opening.finally(() => {
+					if (sessionOpenLoads.get(id) === opening) sessionOpenLoads.delete(id);
+					queueSync();
+				});
+			}
+		} catch {
+			// open 不可用：保持当前窗口。
+		}
+		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 });
+	}
+
+	/** 部署级模型目录一次性读取（R-01-012/AC-01）：dsh 0.1.5 起 per-session models
+	 *  RPC 移除，目录经 `remote.session.modelCatalog()` 无参数读取；成功即缓存不再
+	 *  重发，失败留待下轮详情读取重试。 */
+	function ensureCatalogGroups(sessionRemote) {
+		if (catalogGroups.length > 0 || catalogPromise !== null) return;
+		catalogPromise = Promise.resolve()
+			.then(() => remoteValue(sessionRemote.modelCatalog()))
+			.then((value) => {
+				if (value && Array.isArray(value.groups)) harvestCatalog(value.groups);
+			})
+			.catch(() => {})
+			.finally(() => {
+				catalogPromise = null;
+			});
+	}
+
 	function installServiceSubscriptions() {
 		const nextSessions = ctx.get("sessions");
 		const nextWorkspaces = ctx.get("workspaces");
-		if (nextSessions === sessions && nextWorkspaces === workspaces) return;
+		const nextUiSession = ctx.get("uiSession");
+		if (nextSessions === sessions && nextWorkspaces === workspaces && nextUiSession === uiSession) return;
 
 		sessionUnsubscribe?.();
 		workspaceUnsubscribe?.();
+		pendingUnsubscribe?.();
 		sessions = nextSessions ?? null;
 		workspaces = nextWorkspaces ?? null;
+		uiSession = nextUiSession ?? null;
 		try {
 			sessionUnsubscribe = sessions?.list?.subscribe?.(queueSync) ?? null;
 		} catch {
@@ -1495,6 +1756,14 @@ function apply(ctx) {
 		} catch {
 			workspaceUnsubscribe = null;
 		}
+		try {
+			// 0.1.5 起 sessions 行不再承载 pendingInteraction：待确认/待审查/待回复改由
+			// uiSession.pendingInteractions（Map<sessionId, interaction>）独立承载，
+			// 订阅其快照变化驱动等待卡重算（R-01-002/AC-03）。
+			pendingUnsubscribe = uiSession?.pendingInteractions?.subscribe?.(queueSync) ?? null;
+		} catch {
+			pendingUnsubscribe = null;
+		}
 
 		queueSync();
 	}
@@ -1750,6 +2019,23 @@ function apply(ctx) {
 		foot.append(capsule, noteRow);
 	}
 
+	/** 进度行骨架（运行卡与子代理卡共用，R-01-009/AC-06、AC-14）：可伸缩轨道 + 固定宽百分比。 */
+	function makeProgressRow() {
+		const track = makeEl("div", "dap-track");
+		track.append(makeEl("div", "dap-fill"));
+		const progressRow = makeEl("div", "dap-progress");
+		progressRow.append(track, makeEl("span", "dap-pct"));
+		return progressRow;
+	}
+
+	/** 统计行骨架：左列 token/速率/命中率（超长省略号截断），时长固定最右（R-01-009/AC-05）。 */
+	function makeStatsRow() {
+		const statsRow = makeEl("div", "dap-token-stats");
+		statsRow.append(makeEl("span", "dap-token-main"), makeEl("span", "dap-token-time"));
+		statsRow.hidden = true;
+		return statsRow;
+	}
+
 	/** 静态骨架卡片；动态文本一律走 textContent，规避 HTML 注入。 */
 	function cardChildren(kind) {
 		const head = makeEl("div", "dap-card-head");
@@ -1757,15 +2043,22 @@ function apply(ctx) {
 		const workspaceIcon = makeEl("span", "dap-workspace-icon");
 		workspaceIcon.append(createWorkspaceFolderIcon());
 		workspace.append(workspaceIcon, makeEl("span", "dap-workspace-text"));
-		head.append(workspace, makeEl("div", "dap-model"));
+		const model = makeEl("div", "dap-model");
+		head.append(workspace, model);
 		if (kind === "subagent") {
 			const row = makeEl("div", "dap-row");
-			row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"));
-			return [head, row, makeEl("div", "dap-subtrace")];
+			// 模型名与标题同行右对齐（东家反馈）：子代理卡无工作区徽标与累计时长，
+			// 标题行右侧即模型位；空值时区域隐藏不占位（R-01-012/AC-17、AC-18）。
+			row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"), model, makeEl("span", "dap-total-time"));
+			// 运行中子代理卡与主会话运行卡同构的进度行与统计行（R-01-009/AC-14）；
+			// 非运行时进度行隐藏、统计行冻结（R-01-009/AC-15）。
+			const progressRow = makeProgressRow();
+			progressRow.hidden = true;
+			return [row, makeEl("div", "dap-subtrace"), progressRow, makeStatsRow()];
 		}
 		if (kind === "recent") {
 			const row = makeEl("div", "dap-row");
-			row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"));
+			row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"), makeEl("span", "dap-total-time"));
 			const userLine = makeEl("div", "dap-history-line");
 			userLine.dataset.role = "user";
 			const userIcon = makeEl("span", "dap-history-icon");
@@ -1780,14 +2073,11 @@ function apply(ctx) {
 			const agentLabel = makeEl("span", "dap-history-label");
 			agentLabel.textContent = "助手";
 			agentLine.append(agentIcon, agentLabel, makeEl("span", "dap-history-separator"), makeEl("span", "dap-history-text"));
-			const statsRow = makeEl("div", "dap-token-stats");
-			statsRow.append(makeEl("span", "dap-token-main"), makeEl("span", "dap-token-time"));
-			statsRow.hidden = true;
-			return [head, row, userLine, agentLine, statsRow, makeEl("div", "dap-note")];
+			return [head, row, userLine, agentLine, makeStatsRow(), makeEl("div", "dap-note")];
 		}
 		if (kind === "awaiting") {
 			const row = makeEl("div", "dap-row");
-			row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"));
+			row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"), makeEl("span", "dap-total-time"));
 			// 等待三类末行结构（R-01-002/AC-08、AC-09，C-043）：首行「类型胶囊」（圆底类型
 			// 图标 + 类型文字），其下为正文行——阻塞/错误的说明文字，完成提醒的
 			// 「继续对话，或移入历史」+ 行尾「移入历史」按钮。
@@ -1798,24 +2088,14 @@ function apply(ctx) {
 			noteRow.append(makeEl("div", "dap-note"), makeConfirmButton());
 			const awaitHead = makeEl("div", "dap-await-head");
 			awaitHead.append(capsule);
-			const statsRow = makeEl("div", "dap-token-stats");
-			statsRow.append(makeEl("span", "dap-token-main"), makeEl("span", "dap-token-time"));
-			statsRow.hidden = true;
 			const foot = makeEl("div", "dap-foot");
 			foot.append(awaitHead, noteRow);
-			return [head, row, makeEl("div", "dap-trace"), statsRow, foot];
+			return [head, row, makeEl("div", "dap-trace"), makeStatsRow(), foot];
 		}
 		const row = makeEl("div", "dap-row");
-		row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"));
-		const track = makeEl("div", "dap-track");
-		track.append(makeEl("div", "dap-fill"));
-		const progressRow = makeEl("div", "dap-progress");
-		progressRow.append(track, makeEl("span", "dap-pct"));
-		// 统计行双段结构：左列 token/速率/命中率（超长省略号截断），时长固定最右（R-01-009/AC-05）。
-		const statsRow = makeEl("div", "dap-token-stats");
-		statsRow.append(makeEl("span", "dap-token-main"), makeEl("span", "dap-token-time"));
-		statsRow.hidden = true;
-		return [head, row, makeEl("div", "dap-trace"), progressRow, statsRow];
+		row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"), makeEl("span", "dap-total-time"));
+		const progressRow = makeProgressRow();
+		return [head, row, makeEl("div", "dap-trace"), progressRow, makeStatsRow()];
 	}
 
 	function createInlineIcon({ viewBox, width = 12, height = 12, parts }) {
@@ -2164,6 +2444,29 @@ function apply(ctx) {
 		}
 	}
 
+	/** 进度行写入（运行卡与子代理卡共用，R-01-009/AC-06、AC-14）：百分比与填充宽度，未变化跳过 DOM 写。 */
+	function renderProgressRow(el, progress) {
+		const pct = el.querySelector(".dap-pct");
+		if (pct !== null) pct.textContent = `${Math.round(progress ?? 0)}%`;
+		const fill = el.querySelector(".dap-fill");
+		if (fill !== null) {
+			const width = `${Math.min(100, Math.max(0, progress ?? 0))}%`;
+			if (fill.style.width !== width) fill.style.width = width;
+		}
+	}
+
+	/** 最近回合耗时 memo（等待卡与暂停子代理卡共用，R-01-009/AC-12、AC-15）：history 引用
+	 *  不变即命中缓存。busy 口径（起止差值扣除回合内阻塞等待），与标题行总耗时同口径，
+	 *  保证恒不大于累计值（R-01-020）。 */
+	function memoTurnDuration(detail) {
+		const history = detail.history ?? null;
+		if (detail.memoTurnDurationHistoryOf !== history) {
+			detail.memoTurnDurationHistoryOf = history;
+			detail.memoTurnDuration = lastTurnDuration({ history });
+		}
+		return detail.memoTurnDuration ?? null;
+	}
+
 	/** 统计行渲染：运行卡、等待卡与最近卡写入速率、token 与耗时，旧骨架缺节点时就地补齐。 */
 	function renderTokenStats(el, entry) {
 		let stats = el.querySelector(".dap-token-stats");
@@ -2278,6 +2581,15 @@ function apply(ctx) {
 		const title = el.querySelector(".dap-title");
 		if (title !== null && title.textContent !== entry.title)
 			title.textContent = entry.title;
+		// 标题行最右侧的累计运行时长（R-01-020/AC-01、AC-06）：有数据才显示，
+		// 无数据（含子代理卡）隐藏节点，不以 0 冒充。
+		const totalTime = el.querySelector(".dap-total-time");
+		if (totalTime !== null) {
+			const totalText = Number.isFinite(entry.totalBusyMs) && entry.totalBusyMs >= 0 ? fmtElapsedMs(entry.totalBusyMs) : "";
+			if (totalTime.textContent !== totalText) totalTime.textContent = totalText;
+			const totalHidden = totalText === "";
+			if (totalTime.hidden !== totalHidden) totalTime.hidden = totalHidden;
+		}
 
 		const capsule = el.querySelector(".dap-capsule");
 		// 陈旧骨架就地迁移（C-043 热装兼容）：旧版「正文行 + 行尾类型徽标」骨架升级为
@@ -2316,16 +2628,9 @@ function apply(ctx) {
 		}
 
 		if (entry.kind === "running") {
-			const pct = el.querySelector(".dap-pct");
-			if (pct !== null)
-				pct.textContent = `${Math.round(entry.progress ?? 0)}%`;
+			renderProgressRow(el, entry.progress);
 			const traceContainer = el.querySelector(".dap-trace");
 			if (traceContainer !== null) renderTimelineArea(traceContainer, entry);
-			const fill = el.querySelector(".dap-fill");
-			if (fill !== null) {
-				const width = `${Math.min(100, Math.max(0, entry.progress ?? 0))}%`;
-				if (fill.style.width !== width) fill.style.width = width;
-			}
 			renderTokenStats(el, entry);
 			return;
 		}
@@ -2333,6 +2638,17 @@ function apply(ctx) {
 		if (entry.kind === "subagent") {
 			const traceContainer = el.querySelector(".dap-subtrace");
 			if (traceContainer !== null) renderTimelineArea(traceContainer, entry, { lastOnly: true });
+			// 运行中呈现与运行卡同构的进度行；锚点空闲（暂停等待）时整行隐藏（R-01-009/AC-15）。
+			const progressRow = el.querySelector(".dap-progress");
+			if (progressRow !== null) {
+				if (Number.isFinite(entry.progress)) {
+					renderProgressRow(el, entry.progress);
+					if (progressRow.hidden) progressRow.hidden = false;
+				} else if (!progressRow.hidden) {
+					progressRow.hidden = true;
+				}
+			}
+			renderTokenStats(el, entry);
 			return;
 		}
 
@@ -2420,6 +2736,10 @@ function apply(ctx) {
 					const detail = sessionDetailsById.get(id) ?? {};
 					detail.snapshot = snapshot;
 					sessionDetailsById.set(id, detail);
+					// 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 ?? "" });
 					queueSync();
 				});
 			} catch {
@@ -2942,6 +3262,19 @@ function apply(ctx) {
 			}
 		}
 		const listState = listLoadState(snapshot);
+		// 0.1.5 sessions 行不再承载 pendingInteraction：从 uiSession.pendingInteractions
+		// 快照（Map<sessionId, interaction>，kind ∈ approval/plan-review/question）回填到
+		// 行副本上，等待卡分类（awaiting/blocked/提问中）保持既有单一口径（R-01-002/AC-03）。
+		const pendingSnapshot = uiSession?.pendingInteractions?.getSnapshot?.() ?? null;
+		if (pendingSnapshot instanceof Map && pendingSnapshot.size > 0 && snapshot?.byId) {
+			const byId = { ...snapshot.byId };
+			for (const [id, interaction] of pendingSnapshot) {
+				const row = byId[id];
+				if (!isRecord(row) || typeof interaction?.kind !== "string") continue;
+				byId[id] = { ...row, pendingInteraction: interaction.kind };
+			}
+			snapshot = { ...snapshot, byId };
+		}
 		// 只消费上一轮追加请求；列表短暂 pending 时保留已展开页，ready 后继续从同一前缀呈现。
 		recentAppendQueued = false;
 		const workspaceSnapshot = getSnapshot(workspaces, "list");
@@ -2961,24 +3294,42 @@ function apply(ctx) {
 		const runLikeIds = new Set(
 			active.filter((entry) => shouldSubscribeToSession(entry, snapshot?.byId ?? {})).map((entry) => entry.id),
 		);
-		syncLiveness(runLikeIds, active.some((entry) => entry.kind === "running"));
+		// 运行卡时钟：运行中子代理卡同样承载逐秒推进的进度与时长（R-01-009/AC-14）。
+		syncLiveness(
+			runLikeIds,
+			active.some((entry) => entry.kind === "running" || (entry.kind === "subagent" && runLikeIds.has(entry.id))),
+		);
 		for (const entry of active) {
 			const liveRecord = livenessById.get(entry.id);
 			const live = liveRecord?.liveness ?? null;
 			const detail = sessionDetailsById.get(entry.id);
 			if (entry.kind === "running" && detail) detail.durationFallbackLoaded = false;
+			// 累计运行时长（R-01-020/AC-01、AC-03）：主会话条目注入显示值——渲染期合成，
+			// 含开放回合的实时已耗时并随时钟逐秒推进；子代理卡片不显示。
+			if (entry.kind !== "subagent") applyTotalBusy(entry, now);
 			const detailSnapshot = liveRecord?.snapshot ?? detail?.snapshot ?? null;
 			if (detail && detail.memoHistoryAnchorOf !== (detail.history ?? null)) {
 				detail.memoHistoryAnchorOf = detail.history ?? null;
 				detail.memoHistoryAnchor = historyInstructionAnchor(detail.history);
 			}
+			// 等待/暂停呈现（pendingText 存在）且自身快照为冻结值时，残留 running 行全部落定；
+			// 存在活动后代时保留尾部提升的「agent 工作中」呈现（R-01-009/AC-10 委托周期语义）。
+			const entryIdle = (entry.pendingText ?? null) !== null && entry.descendantActive !== true;
+			const entryCwd = snapshot?.byId?.[entry.id]?.cwd ?? "";
+			// log 派生 memo：history 引用 / idle / cwd 变化才重算。落定在折叠前生效
+			// （foldedHistoryTimeline 的 settleIdle），组标题由已定案成员派生——阻塞等待卡
+			// 呈现「运行了命令」+「等待回答」摘要，而非「正在运行」蓝闪（R-01-009/AC-09）。
+			const historyRef = detail?.history ?? null;
+			const logReady = Array.isArray(historyRef) && historyRef.length > 0;
+			if (detail && logReady && (detail.memoLogTimelineOf !== historyRef || detail.memoLogTimelineIdle !== entryIdle || detail.memoLogTimelineCwd !== entryCwd)) {
+				detail.memoLogTimelineOf = historyRef;
+				detail.memoLogTimelineIdle = entryIdle;
+				detail.memoLogTimelineCwd = entryCwd;
+				detail.memoLogTimeline = foldedHistoryTimeline(historyRef, 4, entryCwd, entryIdle);
+			}
 			if (detail && detailSnapshot) {
 				// 按快照引用 memo：引用不变（时钟 tick、无关推送）时命中缓存，
 				// 长会话不再每次渲染全序扫描。
-				const entryCwd = snapshot?.byId?.[entry.id]?.cwd ?? "";
-				// 等待/暂停呈现（pendingText 存在）且自身快照为冻结值时，残留 running 行全部落定；
-				// 存在活动后代时保留尾部提升的「agent 工作中」呈现（R-01-009/AC-10 委托周期语义）。
-				const entryIdle = (entry.pendingText ?? null) !== null && entry.descendantActive !== true;
 				if (detail.memoTimelineOf !== detailSnapshot || detail.memoTimelineCwd !== entryCwd || detail.memoTimelineDescendantActive !== (entry.descendantActive === true) || detail.memoTimelineIdle !== entryIdle || detail.memoTimelineAnchor !== (detail.memoHistoryAnchor ?? null)) {
 					detail.memoTimelineOf = detailSnapshot;
 					detail.memoTimelineCwd = entryCwd;
@@ -2990,7 +3341,11 @@ function apply(ctx) {
 					// 出现在输出（窗口行或锚行），反之需 history 补读。
 					detail.snapshotHasAnchorableUserRow = detail.memoTimeline.some(isAnchorableUserRow);
 				}
-				entry.timeline = detail.memoTimeline.length > 0 ? detail.memoTimeline : detail.timeline ?? [];
+				// V3 快照不再承载 chat/partial：活动时间线以 log 派生（eventSource 窗口，含
+				// live-chunk 流式行）为主源；快照派生仅在 log 未就绪时兜底（锚行回退）。
+				entry.timeline = logReady ? detail.memoLogTimeline : detail.memoTimeline ?? [];
+			} else if (logReady) {
+				entry.timeline = detail.memoLogTimeline;
 			} else {
 				entry.timeline = detail?.timeline ?? entry.timeline ?? [];
 			}
@@ -3012,18 +3367,19 @@ function apply(ctx) {
 				}
 			}
 			if (entry.kind === "awaiting" && detail) {
-				const history = detail.history ?? null;
-				if (detail.memoTurnDurationSnapshotOf !== detailSnapshot || detail.memoTurnDurationHistoryOf !== history) {
-					detail.memoTurnDurationSnapshotOf = detailSnapshot;
-					detail.memoTurnDurationHistoryOf = history;
-					detail.memoTurnDuration = lastTurnDuration({ turnTimings: detailSnapshot?.turnTimings, history });
-				}
-				entry.elapsedMs = detail.memoTurnDuration ?? null;
+				entry.elapsedMs = memoTurnDuration(detail);
 			}
 			if (detail?.model) {
 				entry.model = detail.model.model;
 				entry.reasoning = detail.model.reasoning;
 			}
+			// 子代理溯源得到的是 provider 模型 id：经目录分组解析为显示名，effort 缺失时
+			// 以同一目录条目回退（R-01-012/AC-17）；目录未覆盖该 id 时保留原始回退（AC-18）。
+			if (entry.kind === "subagent" && detail?.model) {
+				const catalogEntry = catalogEntries[detail.model.model];
+				if (catalogEntry?.name) entry.model = catalogEntry.name;
+				if (!entry.reasoning && catalogEntry?.reasoning) entry.reasoning = catalogEntry.reasoning;
+			}
 			// 待回复卡列表补全（C-040、C-064）：buildEntries 运行时快照时间线可能仍为空，
 			// 而上面的 memo 才在本帧算出结构化提问预览；等待卡静止后常无下一帧，因此在此
 			// 立即补入 questionPreview，由 cardSignature 驱动本帧 DOM 写入。
@@ -3032,7 +3388,9 @@ function apply(ctx) {
 				if (question !== null) entry.questionPreview = question;
 			}
 			// 字段级加载指示（R-01-014/AC-02）：补充数据在途时卡片对应位置显示活动图标。
-			entry.loadingModel = !detail?.model && modelLoads.has(entry.id);
+			// 主会话模型经目录 store 一次性 load 到达（modelLoads 记账），子代理模型经
+			// 日志读取提取（R-01-012/AC-17）。
+			entry.loadingModel = !detail?.model && (modelLoads.has(entry.id) || (entry.kind === "subagent" && historyLoads.has(entry.id)));
 			entry.loadingTimeline =
 				entry.timeline.length === 0 &&
 				(historyLoads.has(entry.id) || sessionOpenLoads.has(entry.id) || (runLikeIds.has(entry.id) && !liveRecord));
@@ -3053,7 +3411,8 @@ function apply(ctx) {
 			// 之外）时，取 history 深翻提取的开放回合起点。
 			const anchor = progressAnchor(progressAnchorById.get(entry.id) ?? null, {
 				descendantActive: entry.descendantActive === true,
-				hostStartTime: live?.startTime ?? detail?.memoOpenTurnStart ?? null,
+				// dsh 0.1.5 起快照不再携带 turnTimings：开放回合起点由宿主侧 busy 记账兜底。
+				hostStartTime: live?.startTime ?? busyById.get(entry.id)?.openTurnStart ?? detail?.memoOpenTurnStart ?? null,
 				now,
 			});
 			progressAnchorById.set(entry.id, anchor);
@@ -3069,6 +3428,21 @@ function apply(ctx) {
 				// 连续、周期外回合切换归零，R-01-009/AC-06，C-014、C-044）。
 				entry.progress = progressOf({ elapsedMs: elapsedMs ?? 0, halfLifeSec: progressHalfLifeSec({ rateTokS: projectionStats.rateTokS }) });
 			}
+			if (entry.kind === "subagent") {
+				// 运行中子代理卡与主会话运行卡同口径：同一锚点状态机与进度曲线（R-01-009/AC-14）。
+				const elapsedMs = Number.isFinite(anchor.anchor) ? Math.max(0, now - anchor.anchor) : null;
+				if (elapsedMs !== null) {
+					Object.assign(entry, projectionStats, { elapsedMs });
+					if (detail) detail.lastRuntimeStats = mergeRuntimeStats(projectionStats, detail.lastRuntimeStats);
+					entry.progress = progressOf({ elapsedMs, halfLifeSec: progressHalfLifeSec({ rateTokS: projectionStats.rateTokS }) });
+				} else {
+					// 非运行（暂停等待）：冻结最后已知统计与最近回合耗时，progress 置空隐藏
+					// 进度条（R-01-009/AC-15）；刷新/无留存时回退当前列表投影。
+					Object.assign(entry, mergeRuntimeStats(detail?.lastRuntimeStats, projectionStats));
+					entry.elapsedMs = detail ? memoTurnDuration(detail) : null;
+					entry.progress = null;
+				}
+			}
 		}
 		// 历史区时间精化（R-01-010/AC-08、AC-09）：从保留快照的 turnTimings 与已拉取的
 		// history 同批事件提取最后回合结束时刻（取两者较新者），按引用 memo；均无则不提供，
@@ -3088,13 +3462,15 @@ 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);
 			const retained = detail?.lastRuntimeStats;
 			Object.assign(entry, stats, retained ? {
@@ -3129,9 +3505,27 @@ function apply(ctx) {
 			...active.filter((entry) => entry.kind === "awaiting").map((entry) => entry.id),
 			...recentDurationFallbackIds,
 		]);
+		// 子代理模型溯源读取时机（R-01-012/AC-17）：运行中看快照最新助手节点是否已
+		// 定案（事件已落宿主日志，尾页读取必命中；工具密集期 4 行折叠窗口可能不含
+		// 助手行，故直接读快照而非折叠时间线）；不在运行中则整段日志已冻结，直接读取。
+		// 开局只有流式 partial 时不读，避免早读扑空。
+		const subagentModelReadIds = new Set();
+		for (const entry of active) {
+			if (entry.kind !== "subagent") continue;
+			if (!runLikeIds.has(entry.id)) {
+				subagentModelReadIds.add(entry.id);
+				continue;
+			}
+			const detail = sessionDetailsById.get(entry.id);
+			const detailSnapshot = livenessById.get(entry.id)?.snapshot ?? detail?.snapshot ?? null;
+			if (chatLatestAssistantSettled(detailSnapshot)) subagentModelReadIds.add(entry.id);
+		}
 		const detailIds = [...active, ...recent].map((entry) => entry.id);
 		detailIds.sort((a, b) => Number(String(b) === String(snapshot?.current)) - Number(String(a) === String(snapshot?.current)));
-		loadNativeDetails(detailIds, previewFallbackIds, durationFallbackIds);
+		loadNativeDetails({ ids: detailIds, previewFallbackIds, durationFallbackIds, subagentModelReadIds });
+		// 累计运行时长懒回填（R-01-020/AC-05）：对可见主会话触发宿主侧存量回合补齐；
+		// 宿主侧每会话单飞，重复触发由宿主合并；完成后经 busy SSE 广播推送。
+		requestBusyBackfill([...active, ...recent].filter((entry) => entry.kind !== "subagent").map((entry) => entry.id));
 		const visibleIds = new Set([...active, ...recent].map((entry) => entry.id));
 		// 详情与 loads 记账同生命周期：离开可见集合即放行，重回可见时允许重拉/重试。
 		// 锚点记账不随可见性 prune：瞬时 loading 空帧不得误清（进度重置）；陈旧条目靠
@@ -3139,6 +3533,7 @@ function apply(ctx) {
 		pruneInvisibleEntries([sessionDetailsById, modelLoads, historyLoads, sessionOpenLoads], visibleIds);
 		// 模型目录订阅同生命周期：不可见即先 unsubscribe 再除名，监听器不残留（R-01-012/AC-16）。
 		pruneSubscriptions(modelDirectorySubs, visibleIds);
+		pruneSubscriptions(logSourceSubs, visibleIds);
 		// 重试链目标已成为当前会话（他途到达）即取消，避免过期链条拽回会话。
 		cancelStaleOpenRetries({ currentId: snapshot?.current ?? null, activatedId: lastActivatedId });
 
@@ -3427,7 +3822,16 @@ function apply(ctx) {
 		// 只观察 center 的直接子节点，捕获 seat/pane 重挂载，不观察 pane 子树。
 		centerObserver = new MutationObserver(() => {
 			const nextSeat = document.querySelector(CONVERSATION_SELECTOR);
-			if (nextSeat?.parentElement !== center) installFrameObserver();
+			if (nextSeat?.parentElement !== center) {
+				installFrameObserver();
+			} else if (nextSeat !== seat) {
+				// 中间列未换但槽容器被宿主原地替换：流式观察者换绑到新节点，
+				// 不整层重装（旧节点已脱离 DOM，留着会让流式 childList 更新丢失）。
+				conversationObserver?.disconnect();
+				conversationObserver = new MutationObserver(queueSync);
+				conversationObserver.observe(nextSeat, { childList: true, subtree: true });
+				observedSeat = nextSeat;
+			}
 			queueSync();
 		});
 		centerObserver.observe(center, { childList: true });
@@ -3450,8 +3854,17 @@ function apply(ctx) {
 
 	// ---- 交互：移动端抽屉开关、弹窗收起、桌面折叠 ----
 	function onToggleClick() {
-		const pane = document.querySelector(`[${PANE_ATTR}]`);
-		const open = pane?.getAttribute("data-open") !== "true";
+		let pane = document.querySelector(`[${PANE_ATTR}]`);
+		if (pane === null) {
+			// 宿主视图替换窗口期/绑定失败时窗格可能缺失：先补绑再开合，开关不得静默无响应
+			// （真机宿主重渲染节奏与桌面不同，此窗口期在触屏上更易被命中，R-01-008/AC-01）。
+			pane = ensurePane();
+			if (pane === null) {
+				console.warn("[dsh-activity-pane] 窗格挂载点不存在（main 槽容器未就绪），已忽略本次开关点击");
+				return;
+			}
+		}
+		const open = pane.getAttribute("data-open") !== "true";
 		togglePane(open);
 	}
 	toggle.addEventListener("click", onToggleClick);
@@ -3467,11 +3880,19 @@ function apply(ctx) {
 		disposed = true;
 		sessionUnsubscribe?.();
 		workspaceUnsubscribe?.();
+		pendingUnsubscribe?.();
 		acksSource?.close();
 		acksSource = null;
+		busySource?.close();
+		busySource = null;
+		document.removeEventListener("visibilitychange", onBusyVisibilityResume);
+		window.removeEventListener("pageshow", onBusyPageShow);
 		document.removeEventListener("visibilitychange", onVisibilityResume);
 		window.removeEventListener("pageshow", onPageShow);
 		completeAcksById.clear();
+		busyById.clear();
+		busyRequestedIds.clear();
+		busyRetryAtById.clear();
 		if (clockTimer !== null) clearInterval(clockTimer);
 		if (recentTimeTimer !== null) clearInterval(recentTimeTimer);
 		if (e2eListReleaseTimer !== null) clearTimeout(e2eListReleaseTimer);
@@ -3488,6 +3909,7 @@ function apply(ctx) {
 		livenessById.clear();
 		// 卸载即全量退订：空可见集合驱动 pruneSubscriptions 先 unsubscribe 再除名。
 		pruneSubscriptions(modelDirectorySubs, new Set());
+		pruneSubscriptions(logSourceSubs, new Set());
 		progressAnchorById.clear();
 		sessionOpenLoads.clear();
 		loadQueue.length = 0;