dsh-activity-pane 0.7.0 → 0.9.0

package/.dsh-plugin/client.js

@@ -441,6 +441,23 @@ function chatNodeAt(nodes, key) {
 	}
 }
 
+/** 子代理模型读取的触发信号（R-01-012/AC-17）：快照最新一个助手节点已定案
+ *  （status === "settled"，即其 assistant/message 事件已落宿主日志，尾页读取必命中）
+ *  时为 true。只检查最新一个助手节点——它随流式推送翻转为 settled 的那一刻即产生
+ *  触发，尾扫即停、近 O(1)，完全挂在既有订阅推送上（R-02-004）；工具密集期 4 行折叠窗口
+ *  可能不含助手行，故不看折叠时间线而直接读快照。流式未定案/中断/无快照为 false。 */
+function chatLatestAssistantSettled(snapshot) {
+	const chat = snapshot?.chat;
+	const order = Array.isArray(chat?.order) ? chat.order : [];
+	const nodes = chat?.nodes;
+	for (let i = order.length - 1; i >= 0; i -= 1) {
+		const node = chatNodeAt(nodes, order[i]);
+		if (!isRecord(node) || node.visibility === "hidden" || node.kind !== "assistant-step") continue;
+		return isRecord(node.data) && node.data.status === "settled";
+	}
+	return false;
+}
+
 /** 尾部反向收集原始工作项（不含 live 合并），取够 want 个可转换项或耗尽 order 即停。
  *  continueToUser：取够后以廉价结构检查（isUserChatNode：非 hidden 的 user/steering 且含非空文本块）继续前走至最近一个未收集的用户节点（含
  *  steering），命中才转换并入队首——供指令锚行派生（R-01-012/AC-12），不为找锚做全序转换。 */
@@ -819,12 +836,54 @@ function foldedConversationTimeline(snapshot, limit = 4, cwd = "", descendantAct
 	return [];
 }
 
+/** user/message 非用户 source 的 provenance 投影（对齐宿主 dsh-client-ui-chat
+ *  contextProvenance）：recall = 跨会话召回，其余为注入；label 取各 source 形态的
+ *  稳定标识，未知 kind 直接以 kind 呈现。 */
+function contextProvenanceOf(source) {
+	if (!isRecord(source)) return { role: "inject", label: null };
+	const kind = typeof source.kind === "string" ? source.kind : null;
+	if (kind === null) return { role: "inject", label: null };
+	if (kind === "session-reference") return { role: "recall", label: joinedSourceLabels(source.references, "label") ?? kind };
+	if (kind === "agent-instructions") return { role: "inject", label: joinedSourceLabels(source.changes, "path") ?? kind };
+	if (kind === "plugin") return { role: "inject", label: typeof source.plugin === "string" ? source.plugin : kind };
+	if (kind === "skill-invocation") return { role: "inject", label: typeof source.name === "string" ? source.name : kind };
+	return { role: "inject", label: kind };
+}
+
+/** source 数组成员的字段去重收集（首见顺序），逗号拼接为单行标签。 */
+function joinedSourceLabels(list, field) {
+	if (!Array.isArray(list)) return null;
+	const seen = [];
+	for (const entry of list) {
+		const value = isRecord(entry) && typeof entry[field] === "string" ? entry[field] : null;
+		if (value !== null && !seen.includes(value)) seen.push(value);
+	}
+	return seen.length > 0 ? seen.join(", ") : null;
+}
+
 function timelineItemFromEvent(entry, cwd = "") {
 	const event = isRecord(entry?.event) ? entry.event : entry;
 	const data = isRecord(event?.data) ? event.data : {};
 	if (!event || typeof event.type !== "string") return null;
-	if (event.type === "user/message" && data.source?.kind === "user") {
-		return { id: `user:${event.seq}`, kind: "user", icon: "user", label: "用户", text: contentText(data.content), detail: null, status: "done" };
+	if (event.type === "user/message") {
+		if (data.source?.kind === "user") {
+			return { id: `user:${event.seq}`, kind: "user", icon: "user", label: "用户", text: contentText(data.content), detail: null, status: "done" };
+		}
+		// V3 log 路径的注入上下文行：非用户 source 的 user/message 即宿主 ContextMessageNode
+		// （0.1.5 无独立 context 事件），镜像原生 ContextInjectionRow 的角色文案。
+		const text = contentText(data.content);
+		if (text === "") return null;
+		const provenance = contextProvenanceOf(data.source);
+		return {
+			id: `context:${event.seq}`,
+			kind: "context",
+			icon: "context",
+			label: provenance.role === "recall" ? "跨会话召回" : "上下文注入",
+			text,
+			summary: provenance.label ?? "",
+			detail: null,
+			status: "done",
+		};
 	}
 	if (event.type === "assistant/message") {
 		const text = contentText(data.message?.content);
@@ -866,20 +925,15 @@ function historyToolResultRoot(data, resultView, callInfo = null) {
 	};
 }
 
-/** 判断 session window 是否尚未 hydrate，需用 native history 补齐。 */
-function needsHistorySnapshot(snapshot) {
-	return !snapshot || !Array.isArray(snapshot.chat?.order) || snapshot.chat.order.length === 0;
-}
-
 /** 冷会话 history 回溯深翻：自尾页起按 beforeSeq 向前翻页，直至命中最近一条用户消息
- *  （messagePreviews 的 userPreview 非空，R-01-013/AC-03）、或翻尽
- *  （hasMore=false/无更多事件/业务错误 null）；requireOpenTurnStart 为 true 时
- *  （运行会话开放回合起点兜底，R-01-009/AC-06）命中用户消息后开放回合起点未命中
- *  仍继续深翻直至起点命中或翻尽。maxPages 仅作显式护栏（默认 Infinity 即不设页数
- *  上限——用户消息必然存在于会话最早段，翻尽必终止，无需预置页数界）。fetchPage
- *  (beforeSeq) 注入实际读取（返回 `{events, hasMore}` 或 null），便于纯函数单测；
- *  中途异常保留已得事件并以 error 返回。返回 `{ events, error }`（events 按时间
- *  正序，新页在后）。 */
+ * （messagePreviews 的 userPreview 非空，R-01-013/AC-03）、或翻尽
+ * （hasMore=false/无更多事件/业务错误 null）；requireOpenTurnStart 为 true 时
+ * （运行会话开放回合起点兜底，R-01-009/AC-06）命中用户消息后开放回合起点未命中
+ * 仍继续深翻直至起点命中或翻尽。maxPages 仅作显式护栏（默认 Infinity 即不设页数
+ * 上限——用户消息必然存在于会话最早段，翻尽必终止，无需预置页数界）。fetchPage
+ * (beforeSeq) 注入实际读取（返回 `{events, hasMore}` 或 null），便于纯函数单测；
+ * 中途异常保留已得事件并以 error 返回。返回 `{ events, error }`（events 按时间
+ * 正序，新页在后）。 */
 async function pagedHistoryEvents({ fetchPage, maxPages = Infinity, requireOpenTurnStart = false }) {
 	const allEvents = [];
 	let beforeSeq;
@@ -908,17 +962,45 @@ async function pagedHistoryEvents({ fetchPage, maxPages = Infinity, requireOpenT
 	return { events: allEvents, error };
 }
 
-/** 冷会话 history 的扁平工作项映射：供没有 ChatSnapshot 的活动/历史会话折叠分组使用。
- *  native `sessions.history` 响应只含 `{events, hasMore, projections?}`（in-flight
- *  partial 以 chunk 事件携带，不做逐 chunk 折叠），故只从事件流取尾部工作项。
+/** V3 log 窗口的扁平工作项映射：供没有 ChatSnapshot 的活动/历史会话折叠分组使用。
+ *  eventSource 快照含 type === "transient" 的 `assistant/live-chunk` 条目（agent-stream
+ *  增量帧，seq 为插值小数，仅存在于流式期间）：按 attemptId 原位累积为单个 running
+ *  assistant 行（对齐快照路径 mergeLiveItems 的 partial 行语义）；回合落定后 transient
+ *  条目随 attempt 出窗，durable assistant/message 自然接管。tool-call-delta 不折叠——
+ *  tool/call 以 durable 事件落定后经既有 call/result 配对路径呈现。
  *  tool/result 落定同 callId 的 call 项（原位替换，name/arguments/callView 由 call 事件补齐）：
  *  history 是冻结过去，call 事件单独留存会成为永久 running 幽灵行（R-01-016/AC-01）。 */
 function conversationTimelineFromHistory(history, limit = 4, cwd = "") {
 	const items = [];
 	const inflightCalls = new Map(); // callId → { index, data, callView }：等待结果落定的 tool/call 事件
+	const liveAttempts = new Map(); // attemptId → { index, text, reasoning }：流式期间累积的 live 行
 	for (const entry of Array.isArray(history) ? history : []) {
 		const event = eventOf(entry);
 		const data = isRecord(event?.data) ? event.data : {};
+		if (event?.type === "assistant/live-chunk") {
+			const attemptId = typeof data.attemptId === "string" ? data.attemptId : "";
+			const text = typeof data.chunk?.text === "string" ? data.chunk.text : "";
+			if (attemptId === "" || text === "" || !isRecord(data.chunk)) continue;
+			const attempt = liveAttempts.get(attemptId) ?? (() => {
+				const created = { index: items.length, text: "", reasoning: "" };
+				liveAttempts.set(attemptId, created);
+				items.push({ id: `live:${attemptId}`, kind: "assistant", icon: "assistant", text: "", detail: null, status: "running", live: true });
+				return created;
+			})();
+			if (data.chunk.type === "reasoning-delta") attempt.reasoning += text;
+			else if (data.chunk.type === "text-delta") attempt.text += text;
+			else continue;
+			items[attempt.index] = {
+				...items[attempt.index],
+				text: attempt.text,
+				detail: attempt.reasoning || null,
+				// 镜像原生 ReasoningRow：流式思考显示尾部最新行，避免与已定案首行摘要漂移。
+				summary: attempt.reasoning ? latestLineOf(attempt.reasoning) : attempt.text,
+				status: "running",
+				live: true,
+			};
+			continue;
+		}
 		if (event?.type === "tool/result") {
 			const callId = toolResultCallId(data);
 			const pending = callId !== undefined ? inflightCalls.get(callId) : undefined;
@@ -948,12 +1030,15 @@ function conversationTimelineFromHistory(history, limit = 4, cwd = "") {
 
 /** 冷 history 折叠分组时间线（R-01-017、R-01-012/AC-12～AC-15）：页内全部事件映射折叠后
  *  套用与快照路径同一窗口/锚行选择（selectTimelineRows），最近用户消息滚动触顶后停留为
- *  首行锚行。 */
-function foldedHistoryTimeline(history, limit = 4, cwd = "") {
+ *  首行锚行。settleIdle：阻塞等待呈现（pendingText 存在）下折叠前把残留 running 行落定，
+ *  组标题/状态由已定案成员派生（「运行了命令」而非「正在运行」蓝闪），与快照路径的
+ *  settleWhenIdle 前置语义一致。 */
+function foldedHistoryTimeline(history, limit = 4, cwd = "", settleIdle = false) {
 	const max = Math.max(0, limit);
 	if (max === 0) return [];
 	const items = conversationTimelineFromHistory(history, Number.MAX_SAFE_INTEGER, cwd);
-	return selectTimelineRows(foldWorkGroups(items, Number.MAX_SAFE_INTEGER), max);
+	const settled = settleIdle ? settleWhenIdle(items, true) : items;
+	return selectTimelineRows(foldWorkGroups(settled, Number.MAX_SAFE_INTEGER), max);
 }
 
 /** history 指令锚行提取（R-01-012/AC-12 快照窗口外兜底）：尾部反向取最近一条非空文本的
@@ -971,14 +1056,6 @@ function historyInstructionAnchor(history) {
 }
 
 
-/** 开放回合起点缺口判定（R-01-009/AC-06 冷窗口兜底触发口径）：快照就绪、宿主判定运行中、
- *  轮内订阅已建立，但快照 turnTimings 无开放回合起点（liveStartTime 为 null）——超长回合
- *  的 turn/start 在尾页窗口之外。等待/空闲会话（非运行或无 liveness 记录）不算缺口，
- *  不触发 history 补读。 */
-function openTurnStartMissing({ snapshotReady = false, running = false, hasLiveness = false, liveStartTime = null } = {}) {
-	return snapshotReady === true && running === true && hasLiveness === true && liveStartTime == null;
-}
-
 /** 开放回合起点兜底提取（R-01-009/AC-06）：history 事件尾部反向扫描，最近一条边界事件
  *  为 turn/start 即存在开放回合、返回其时刻；为 turn/end 则无开放回合返回 null。
  *  minTurn：快照已知的最晚回合号——history 开放回合落后于此（拉取后已切换新回合）时
@@ -1051,6 +1128,64 @@ function modelMetadata(models) {
 	};
 }
 
+/** 子代理模型溯源（R-01-012/AC-17）：从 history 事件流尾扫最近一条携带模型溯源的
+ *  `assistant/message` 事件，取 `message.source.model`。返回值 reasoning 恒为空串，
+ *  effort 由调用方以 `reasoningEffortFromHistoryEvents` 同页折叠；无命中（空事件、
+ *  无助手消息或溯源缺失）返回 null，调用方保持模型区空白、不以 preset 或母会话
+ *  模型冒充（R-01-012/AC-18）。 */
+function modelFromHistoryEvents(history) {
+	const entries = Array.isArray(history) ? history : [];
+	for (let i = entries.length - 1; i >= 0; i -= 1) {
+		const event = eventOf(entries[i]);
+		if (event?.type !== "assistant/message") continue;
+		const source = isRecord(event.data?.message?.source) ? event.data.message.source : null;
+		if (source !== null && typeof source.model === "string" && source.model !== "") {
+			return { model: source.model, reasoning: "" };
+		}
+	}
+	return null;
+}
+
+/** 子代理 reasoning effort（R-01-012/AC-17）：history 尾扫最新一条 `request/header`
+ *  事件，取 `config.reasoningEffort`——宿主的会话选择即从该折叠读取。命中最新请求头
+ *  即停：更早请求头属已废弃纪元，即使声明过 effort 也不再回扫。最新请求头未声明
+ *  effort 或页内无请求头（超长子会话的 header 在日志开头、可能落在尾页窗口之外）
+ *  返回 null，调用方回落目录条目 `reasoning` 后保持空值（R-01-012/AC-18）。 */
+function reasoningEffortFromHistoryEvents(history) {
+	const entries = Array.isArray(history) ? history : [];
+	for (let i = entries.length - 1; i >= 0; i -= 1) {
+		const event = eventOf(entries[i]);
+		if (event?.type !== "request/header") continue;
+		const config = isRecord(event.data?.header?.config) ? event.data.header.config : null;
+		if (config !== null && typeof config.reasoningEffort === "string" && config.reasoningEffort !== "") {
+			return config.reasoningEffort;
+		}
+		return null;
+	}
+	return null;
+}
+
+/** 模型目录分组的 modelId → {name, reasoning} 索引（R-01-012/AC-17）：溯源
+ *  `source.model` 是 provider 侧 id，显示名需经目录分组解析；同一部署的目录分组在
+ *  主/子会话间共享，条目 `reasoning` 是请求头 effort 不可得时的回退来源。畸形条目
+ *  跳过；目录缺失返回空索引，调用方回退显示原始溯源 id（R-01-012/AC-18）。 */
+function catalogModelEntries(groups) {
+	const entries = {};
+	for (const group of Array.isArray(groups) ? groups : []) {
+		if (!isRecord(group)) continue;
+		for (const model of Array.isArray(group.models) ? group.models : []) {
+			if (!isRecord(model)) continue;
+			if (typeof model.id === "string" && model.id !== "" && typeof model.name === "string" && model.name !== "") {
+				entries[model.id] = {
+					name: model.name,
+					reasoning: typeof model.reasoning === "string" && model.reasoning !== "" ? model.reasoning : "",
+				};
+			}
+		}
+	}
+	return entries;
+}
+
 /** 只提供卡片底部所需的原始统计字段，不拼接当前动作文案。 */
 function runtimeStats({ elapsedMs = null, outputTokens = null, rateTokS = null } = {}) {
 	return {
@@ -1193,36 +1328,6 @@ function escapeCssString(value) {
 		.replace(/\0/g, "�");
 }
 
-/** 冷会话补充数据读取决策（单次渲染内是否发起 models/history 读取）。
- *  失败路径会写入空 model/history 使决策转为「不读」（可见期内不热重试）；
- *  详情与记账随可见性清理（pruneInvisibleEntries）一起移除后，决策自然恢复为「读取」。
- *  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、R-01-013/AC-12）。 */
-function detailLoadPlan({
-	detail = {},
-	isSubagent = false,
-	snapshotReady = false,
-	historyNeeded = false,
-	previewFallbackNeeded = false,
-	durationFallbackNeeded = false,
-	windowComplete = true,
-	modelInflight = false,
-	historyInflight = false,
-} = {}) {
-	return {
-		subagent: isSubagent === true,
-		model: !isSubagent && !detail.model && !modelInflight,
-		history:
-			!historyInflight &&
-			((durationFallbackNeeded && detail.durationFallbackLoaded !== true) ||
-				(previewFallbackNeeded && detail.previewFallbackLoaded !== true) ||
-				(!detail.history && ((!snapshotReady && historyNeeded) || (snapshotReady === true && windowComplete === false)))),
-	};
-}
-
 /** 打开重试链是否应取消：目标已成为当前会话（已到达），或用户已激活其它卡片（被新意图取代）。 */
 function shouldCancelOpenRetry({ targetId, currentId = null, activatedId = null } = {}) {
 	if (targetId === undefined || targetId === null) return true;
@@ -1693,6 +1798,8 @@ function cardSignature(entries) {
 			entry.loadingTimeline ?? null,
 			entry.loadingPreviews ?? null,
 			entry.tokenStats ?? [entry.outputTokens ?? null, entry.inputTokens ?? null, entry.cacheHitPct ?? null, entry.rateTokS ?? null, entry.elapsedMs ?? null],
+			// 累计运行时长参与签名（R-01-020）：回填/SSE 推送与逐秒推进都要驱动重绘。
+			entry.totalBusyMs ?? null,
 		]),
 	);
 }
@@ -1878,58 +1985,256 @@ 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;
+	return latest?.duration ?? null;
 }
 
-/** 从 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 };
+/** 最近完整回合的固定耗时（busy 口径）：从 history 事件重放派生。 */
+function lastTurnDuration({ history = [] } = {}) {
+	return lastTurnBusyFromEvents(history);
+}
+
+/** ask_user_question 工具名：提问/计划审查等待的开启边界（tool/call）与配对结算（tool/result）。 */
+const QUESTION_TOOL_NAME = "ask_user_question";
+
+/** 回合/等待边界事件类型全集：busy 记账只消费这些事件，其余事件对记账无效果。 */
+const BOUNDARY_EVENT_TYPES = new Set(["turn/start", "turn/end", "approval/asked", "approval/decided", "tool/call", "tool/result"]);
+
+/** 边界事件判定（宿主实时登记入口与记账转移共用，新增边界只改 BOUNDARY_EVENT_TYPES 一处）。 */
+function isBusyBoundaryEvent(type) {
+	return BOUNDARY_EVENT_TYPES.has(type);
+}
+
+/** 空记账状态（无任何有效计时）。 */
+function emptyTurnStats() {
+	return { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null, watermarkTime: null };
+}
+
+/** 从任意来源拷贝记账状态：缺失字段归一为 null（旧记录/部分记录兼容）。 */
+function turnStatsFrom(state) {
+	return {
+		busyMs: state?.busyMs ?? null,
+		openTurnStart: state?.openTurnStart ?? null,
+		openWaitStart: state?.openWaitStart ?? null,
+		openWaitKind: state?.openWaitKind ?? null,
+		openWaitId: state?.openWaitId ?? null,
+		waitedMs: state?.waitedMs ?? null,
+		watermarkTime: state?.watermarkTime ?? null,
+	};
+}
+
+/**
+ * 记账状态逐字段相等（不含 watermarkSeq——它不是状态字段，由宿主侧随写入一并落盘；
+ * watermarkTime 为水位处已覆盖事件的时刻，参与相等判定以让补写该字段的收敛写入生效）。
+ */
+function turnStatsEqual(a, b) {
+	return (
+		a === b ||
+		((a?.busyMs ?? null) === (b?.busyMs ?? null) &&
+			(a?.openTurnStart ?? null) === (b?.openTurnStart ?? null) &&
+			(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?.watermarkTime ?? null) === (b?.watermarkTime ?? null))
+	);
+}
+
+/** 结算当前未配对等待区间：时刻有效则累加 waitedMs，随后清空等待态。 */
+function settleOpenWait(next, time) {
+	if (next.openWaitStart !== null && time >= next.openWaitStart) {
+		next.waitedMs = (next.waitedMs ?? 0) + (time - next.openWaitStart);
+	}
+	next.openWaitStart = null;
+	next.openWaitKind = null;
+	next.openWaitId = null;
+}
+
+/** 强制关闭开放回合（turn/end 与启动扫描共用）：先按时刻结算未配对等待（等待尾部不
+ *  计入运行时长），再把 `time − openTurnStart − waitedMs` 的运行部分累加进 busyMs，
+ *  最后清空回合态；时间逆序时跳过累加、仅清空。 */
+function settleTurnClose(next, time) {
+	if (next.openWaitStart !== null) settleOpenWait(next, time);
+	if (next.openTurnStart !== null && time >= next.openTurnStart) {
+		const activeMs = time - next.openTurnStart - (next.waitedMs ?? 0);
+		if (activeMs > 0) next.busyMs = (next.busyMs ?? 0) + activeMs;
 	}
-	return latest;
+	next.openTurnStart = null;
+	next.waitedMs = null;
 }
 
-/** 从 history 提取最近完整回合的固定耗时；回合起止不完整或逆序时忽略该回合。 */
-function lastTurnDurationFromEvents(events) {
-	return lastTurnDurationCandidateFromEvents(events)?.duration ?? null;
+/**
+ * 会话回合统计记账的单步转移（R-01-020）：对单个回合/等待边界事件应用后返回新状态。
+ * 状态 `{ busyMs, openTurnStart, openWaitStart, openWaitKind, openWaitId, waitedMs }`——
+ * busyMs 为运行过程时长的累计（null 表示尚无任何有效回合计时），openTurnStart 为当前
+ * 开放回合起点，openWaitStart/openWaitKind/openWaitId 为当前未配对等待区间（回合内
+ * 阻塞等待：'approval' 审批 / 'question' 提问，id 为审批 id 或提问 callId），waitedMs
+ * 为本回合内已配对等待时长的累计；completed/blocked/max-tokens/aborted/error 全部结束
+ * 原因均计入，回合间空闲与回合内等待不计入。等待边界：`approval/asked` 与
+ * `ask_user_question` 的 `tool/call` 开启（记录 id/callId），`approval/decided` 与同
+ * id/callId 的 `tool/result` 结算（id 不匹配的结算事件忽略）；等待串行不嵌套（已有
+ * 未配对等待时新边界忽略），`turn/end` 先按事件时刻强制结算未配对等待再以
+ * `time − openTurnStart − waitedMs` 结算回合。start 覆盖式登记（串行回合下最后一个
+ * start 为当前回合），end 配对最近 start；起点缺失或时间逆序的回合跳过累加、仅清空
+ * 状态。event 兼容 history 条目包装与裸事件（eventOf 解包），宿主实时登记与回填共用
+ * 同一转移，保证口径一致（R-01-020/AC-02）。
+ */
+function applyTurnEventToStats(state, entry) {
+	const event = eventOf(entry);
+	const time = durationTime(event?.time);
+	const type = event?.type;
+	if (time === null || !isBusyBoundaryEvent(type)) return state;
+	const next = turnStatsFrom(state);
+	if (type === "turn/start") {
+		next.openTurnStart = time;
+		next.openWaitStart = null;
+		next.openWaitKind = null;
+		next.openWaitId = null;
+		next.waitedMs = null;
+		return next;
+	}
+	if (type === "turn/end") {
+		settleTurnClose(next, time);
+		return next;
+	}
+	if (type === "approval/asked") {
+		if (next.openTurnStart === null || next.openWaitStart !== null) return state;
+		next.openWaitStart = time;
+		next.openWaitKind = "approval";
+		next.openWaitId = typeof event?.data?.id === "string" ? event.data.id : null;
+		return next;
+	}
+	if (type === "approval/decided") {
+		if (next.openWaitStart === null || next.openWaitKind !== "approval") return state;
+		if (next.openWaitId !== null && event?.data?.id !== next.openWaitId) return state;
+		settleOpenWait(next, time);
+		return next;
+	}
+	if (type === "tool/call") {
+		if (event?.data?.name !== QUESTION_TOOL_NAME) return state;
+		if (next.openTurnStart === null || next.openWaitStart !== null) return state;
+		next.openWaitStart = time;
+		next.openWaitKind = "question";
+		next.openWaitId = typeof event?.data?.callId === "string" ? event.data.callId : null;
+		return next;
+	}
+	// tool/result：仅结算开启中的提问等待，且 callId 与开启边界一致——其余 result 对
+	// 记账无效果（等待串行，同 callId 的下一个 result 即配对边界）。
+	if (next.openWaitStart === null || next.openWaitKind !== "question") return state;
+	const resultCallId = event?.data?.message?.source?.callId;
+	if (next.openWaitId !== null && resultCallId !== next.openWaitId) return state;
+	settleOpenWait(next, time);
+	return next;
 }
 
-/** 从 turnTimings 提取最近完整回合的固定耗时；全部回合未结束或无效时返回 null。 */
-function lastTurnDurationFromTimings(turnTimings) {
-	return lastTurnDurationCandidateFromTimings(turnTimings)?.duration ?? null;
+/**
+ * busy 记账字段归一：null/undefined 直通为 null（「无数据」语义），仅真实有限数字
+ * 保留。必须先判空再走 Number()——Number(null) === 0 会把「无开放回合」误归一为
+ * epoch 0，令合成值膨胀为 now−0（R-01-020/AC-06 回归）。
+ */
+function normalizeBusyMs(value) {
+	if (value === null || value === undefined) return null;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : 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;
+/**
+ * 标题行累计运行时长的显示合成（R-01-020/AC-01、AC-03、AC-06、AC-07）：已完成回合
+ * 累计加开放回合的实时已耗时（扣除回合内已配对等待与进行中的未配对等待）；两者皆
+ * 不可得时返回 null（调用方不显示，不以 0 冒充）。now 缺失或无效时不推进实时增量，
+ * 只返回已完成累计。等待期间 `(now − openTurnStart)` 与 `(now − openWaitStart)` 两项
+ * 随 now 同步增长相互抵消，显示值自冻结；等待结算时 waitedMs 接管同一增量，恢复
+ * 运行后从冻结值继续，回合结算处连续无跳变。
+ */
+function totalBusyDisplayMs({ busyMs = null, openTurnStart = null, waitedMs = null, openWaitStart = null, now = null } = {}) {
+	let total = typeof busyMs === "number" && Number.isFinite(busyMs) && busyMs >= 0 ? busyMs : null;
+	if (openTurnStart !== null && Number.isFinite(openTurnStart) && Number.isFinite(now) && now > openTurnStart) {
+		const waited = typeof waitedMs === "number" && Number.isFinite(waitedMs) && waitedMs >= 0 ? waitedMs : 0;
+		const waitingNow = openWaitStart !== null && Number.isFinite(openWaitStart) && now > openWaitStart ? now - openWaitStart : 0;
+		total = (total ?? 0) + Math.max(0, now - openTurnStart - waited - waitingNow);
 	}
-	return latest?.duration ?? null;
+	return total;
+}
+
+/**
+ * 回合统计记账的统一收敛（R-01-020/AC-04、AC-05）：对全会话事件列表重放出下一份
+ * 记账，宿主侧懒回填与启动扫描共用。路径选择——无记录、强制重放、持久化水位非法、
+ * 或水位超前于日志最大 seq（事件 seq 空间被重编，如 dsh 0.1.5 V3 迁移）时从空状态
+ * 全量重放（超前水位会把后续全部实时事件封死在守卫之外，openTurnStart 永不清空、
+ * 总耗时无限增长）；否则从持久化记账出发仅增量应用 `seq > watermarkSeq` 的事件。
+ * 水位推进处同步记录 `watermarkTime`（水位处已覆盖事件的时刻，与实时登记按效果事件
+ * 写入的口径互为保守——检测只要求该值不超过真实边界事件时刻）——宿主实时登记据此
+ * 识别 seq 空间重编（低 seq 事件携带比水位更新的时刻，增量口径已失效）。
+ * `closeOpenTurn`（宿主启动扫描）：重放后仍存在的开放回合按日志最后事件时刻强制
+ * 结算关闭——宿主重启后不存在仍在运行的回合，残留起点只会令总耗时无限增长；尾部
+ * 未配对等待一并按同刻结算（不落到运行时长里）。
+ */
+function reconcileTurnStats(current, records, { closeOpenTurn = false, forceFresh = false } = {}) {
+	const list = Array.isArray(records) ? records : [];
+	let maxSeq = null;
+	let lastTime = null;
+	for (const record of list) {
+		const seq = Number(record?.seq);
+		if (Number.isFinite(seq) && (maxSeq === null || seq > maxSeq)) maxSeq = seq;
+		const time = durationTime(eventOf(record)?.time);
+		if (time !== null && (lastTime === null || time > lastTime)) lastTime = time;
+	}
+	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);
+			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);
+			advance(record);
+		}
+	}
+	if (closeOpenTurn && state.openTurnStart !== null) {
+		// 启动扫描：宿主重启后不存在仍在运行的回合——按日志最后事件时刻强制结算关闭；
+		// 日志不可得（空/缺失）时仅清除回合态，不制造虚假运行时长。
+		if (lastTime !== null) settleTurnClose(state, lastTime);
+		state.openTurnStart = null;
+		state.openWaitStart = null;
+		state.openWaitKind = null;
+		state.openWaitId = null;
+		state.waitedMs = null;
+	}
+	return { ...state, watermarkSeq, watermarkTime };
 }
 
 /**
@@ -2236,8 +2541,9 @@ function scrollCardIntoView(scroll, card, behavior = "smooth") {
 	return Number(scroll.scrollTop) !== currentTop;
 }
 
-/** 原生会话输入框（dsh-client-ui-conversation composer 的 textarea）。 */
-const COMPOSER_SELECTOR = "textarea[data-phase]";
+/** 原生会话输入框：dsh-client-ui-conversation 的 composer 输入面（Lexical contenteditable div，
+ * 宿主以 data-composer-input 显式标记；宿主 0.1.5 重写前为 textarea[data-phase]）。 */
+const COMPOSER_SELECTOR = "[data-composer-input]";
 
 /**
  * 抑制切换会话后原生 composer 的自动聚焦（R-01-005/AC-01 移动端回归）。
@@ -2281,19 +2587,24 @@ function bindBackdropDismiss(backdrop, dismiss) {
 
 // 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";
@@ -2305,7 +2616,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 有钉住断言。
@@ -2713,14 +3024,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）——阻塞金/完成绿/错误红；
    胶囊为行内元素不自占满宽，随文字内容收缩。 */
@@ -2846,6 +3162,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;
@@ -3316,8 +3633,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;
@@ -3390,12 +3709,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 = [];
@@ -3562,7 +3893,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 {
@@ -3592,7 +3923,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 }),
@@ -3606,8 +3937,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 脉冲，
@@ -3632,16 +4092,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();
 		};
@@ -3649,17 +4110,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) ?? {};
@@ -3667,80 +4159,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);
@@ -3748,7 +4215,7 @@ function apply(ctx) {
 				historyPromises.push(promise);
 			}
 		}
-		const pending = modelPromises.concat(historyPromises);
+		const pending = historyPromises;
 		if (pending.length > 0) {
 			// 逐个完成即重绘（先就绪先显示，不等待全部，R-01-014/AC-03）；
 			// 并立即重绘一次让加载指示在数据返回前出现。
@@ -3757,15 +4224,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 {
@@ -3776,6 +4343,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();
 	}
@@ -4031,6 +4606,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");
@@ -4038,15 +4630,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");
@@ -4061,14 +4660,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）：首行「类型胶囊」（圆底类型
 			// 图标 + 类型文字），其下为正文行——阻塞/错误的说明文字，完成提醒的
 			// 「继续对话，或移入历史」+ 行尾「移入历史」按钮。
@@ -4079,24 +4675,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 }) {
@@ -4445,6 +5031,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");
@@ -4559,6 +5168,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 热装兼容）：旧版「正文行 + 行尾类型徽标」骨架升级为
@@ -4597,16 +5215,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;
 		}
@@ -4614,6 +5225,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;
 		}
 
@@ -4701,6 +5323,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 {
@@ -5223,6 +5849,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");
@@ -5242,24 +5881,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;
@@ -5271,7 +5928,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 ?? [];
 			}
@@ -5293,18 +5954,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 写入。
@@ -5313,7 +5975,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));
@@ -5334,7 +5998,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);
@@ -5350,6 +6015,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；均无则不提供，
@@ -5369,13 +6049,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 ? {
@@ -5410,9 +6092,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 空帧不得误清（进度重置）；陈旧条目靠
@@ -5420,6 +6120,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 });
 
@@ -5708,7 +6409,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 });
@@ -5731,8 +6441,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);
@@ -5748,11 +6467,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);
@@ -5769,6 +6496,7 @@ function apply(ctx) {
 		livenessById.clear();
 		// 卸载即全量退订：空可见集合驱动 pruneSubscriptions 先 unsubscribe 再除名。
 		pruneSubscriptions(modelDirectorySubs, new Set());
+		pruneSubscriptions(logSourceSubs, new Set());
 		progressAnchorById.clear();
 		sessionOpenLoads.clear();
 		loadQueue.length = 0;