dsh-activity-pane 0.7.0 → 0.9.0

package/scripts/check.mjs

@@ -19,10 +19,10 @@ import {
 	cardSignature,
 	cleanPreview,
 	clampPaneWidth,
+	chatLatestAssistantSettled,
 	pagedHistoryEvents,
 	delegationActive,
 	progressAnchor,
-	detailLoadPlan,
 	conversationWorkItems,
 	conversationTimelineFromHistory,
 	foldWorkGroups,
@@ -30,7 +30,6 @@ import {
 	foldedHistoryTimeline,
 	historyInstructionAnchor,
 	openTurnStartFromEvents,
-	openTurnStartMissing,
 	escapeCssString,
 	firstPhysicalLine,
 	fmtAbsoluteDateTime,
@@ -54,12 +53,17 @@ import {
 	movedToRecentIds,
 	movedToActiveIds,
 	modelMetadata,
-	needsHistorySnapshot,
+	modelFromHistoryEvents,
+	reasoningEffortFromHistoryEvents,
+	catalogModelEntries,
 	lastTurnEndFromEvents,
 	lastTurnEndFromTimings,
-	lastTurnDurationFromEvents,
-	lastTurnDurationFromTimings,
+	lastTurnBusyFromEvents,
 	lastTurnDuration,
+	applyTurnEventToStats,
+	reconcileTurnStats,
+	normalizeBusyMs,
+	totalBusyDisplayMs,
 	pendingText,
 	progressHalfLifeSec,
 	progressOf,
@@ -204,6 +208,14 @@ unbindCard();
 assert.equal(cardListeners.size, 0, "card 卸载移除 click/keydown 监听");
 
 // ---- R-01-005/AC-01 回归：移动端切换会话后抑制原生 composer 自动聚焦（不弹软键盘） ----
+// 宿主 DOM 契约（dsh-client-ui-conversation ComposerContentEditable）：composer 输入面是
+// Lexical contenteditable div，显式标记 data-composer-input。旧 textarea[data-phase] 在宿主
+// DOM 上零命中会使抑制整体退化为空操作（软键盘回归根因），故钉住选择器防再漂移。
+assert.equal(
+	COMPOSER_SELECTOR,
+	"[data-composer-input]",
+	"composer 选择器须锚定宿主 contenteditable div 的显式标记 data-composer-input",
+);
 const composerEl = {
 	focused: true,
 	matches: (selector) => selector === COMPOSER_SELECTOR,
@@ -330,76 +342,113 @@ assert.deepEqual(
 	buildEntries(subagentUnderFork, [], {}, null, null, ["source"]).map((entry) => entry.id),
 	["fork", "nested-subagent"],
 	"归档 fork 来源不影响独立 fork 及其真实子代理子树");
-// models/history 加载决策行为链：首读 → 在途不重发 → 失败置空后可见期内不热重试 → 离开可见清理后重回可重试
-const loadDetail = {};
+// ---- R-01-012/AC-17、AC-18 子代理模型溯源：history 尾扫最近一条携带 source.model 的 assistant/message ----
+const subModelEvents = [
+	{ event: { type: "turn/start", seq: 1, data: { turn: 1 } } },
+	{ event: { type: "assistant/message", seq: 2, data: { turn: 1, step: 1, message: { role: "assistant", source: { kind: "model", provider: "deepseek", model: "model-a" } } } } },
+	{ event: { type: "tool/call", seq: 3, data: { turn: 1, step: 1, callId: "c1", name: "bash", arguments: "{}" } } },
+	{ event: { type: "assistant/message", seq: 4, data: { turn: 1, step: 2, message: { role: "assistant", source: { kind: "model", provider: "deepseek", model: "model-b" } } } } },
+];
 assert.deepEqual(
-	detailLoadPlan({ detail: loadDetail }),
-	{ subagent: false, model: true, history: false },
-	"冷会话首次决策发起 models 读取",
-);
-assert.equal(
-	detailLoadPlan({ detail: loadDetail, modelInflight: true }).model,
-	false,
-	"读取在途时不重复发起",
+	modelFromHistoryEvents(subModelEvents),
+	{ model: "model-b", reasoning: "" },
+	"子代理模型溯源取最近一条携带 source.model 的 assistant/message（R-01-012/AC-17）",
 );
-loadDetail.model = { model: "", reasoning: "" };
-assert.equal(detailLoadPlan({ detail: loadDetail }).model, false, "失败置空后可见期内不热重试");
-assert.equal(detailLoadPlan({ detail: {} }).model, true, "离开可见清理后重回可见允许重试");
 assert.deepEqual(
-	detailLoadPlan({ detail: {}, isSubagent: true }),
-	{ subagent: true, model: false, history: false },
-	"子代理不发起 models 读取",
+	modelFromHistoryEvents([{ type: "assistant/message", seq: 9, data: { message: { source: { provider: "p", model: "bare" } } } }]),
+	{ model: "bare", reasoning: "" },
+	"裸事件形态与 {event} 包装同样兼容（R-01-012/AC-17）",
 );
+assert.equal(modelFromHistoryEvents([]), null, "空事件流无溯源，保持空白（R-01-012/AC-18）");
 assert.equal(
-	detailLoadPlan({ detail: {}, historyNeeded: true }).history,
-	true,
-	"无快照冷会话决策发起 history 读取",
+	modelFromHistoryEvents([{ event: { type: "user/message", seq: 1, data: { message: { content: [] } } } }]),
+	null,
+	"无 assistant/message 时不得以其它事件冒充模型（R-01-012/AC-18）",
 );
 assert.equal(
-	detailLoadPlan({ detail: {}, historyNeeded: true, snapshotReady: true }).history,
-	false,
-	"原生快照已就绪且窗口数据齐全时不发 history 读取",
+	modelFromHistoryEvents([{ event: { type: "assistant/message", seq: 2, data: { message: { source: { provider: "p" } } } } }]),
+	null,
+	"source.model 缺失时不得冒充（R-01-012/AC-18）",
 );
-// R-01-013/AC-03、AC-04：最近卡窗口快照缺用户或 agent 预览时补读一次 history。
 assert.equal(
-	detailLoadPlan({ detail: { history: [{ event: { seq: 1 } }] }, snapshotReady: true, previewFallbackNeeded: true }).history,
-	true,
-	"最近卡预览不完整时即使已有早到 history 也重新补读一次",
+	modelFromHistoryEvents([null, { event: undefined }, { event: { type: "assistant/message", seq: 3, data: { turn: 1, step: 1, message: { role: "assistant", source: { provider: "p", model: "ok" } } } } }]).model,
+	"ok",
+	"畸形条目跳过不抛错，命中项照常提取（R-01-012/AC-17）",
 );
+
+// ---- R-01-012/AC-17 子代理模型读取触发信号：快照最新助手节点已定案即触发 ----
+const settledAssistantSnapshot = {
+	chat: {
+		order: ["k1", "k2", "k3", "k4"],
+		nodes: new Map([
+			["k1", { kind: "user", data: { content: [] } }],
+			["k2", { kind: "assistant-step", data: { status: "settled", turn: 1, step: 1, blocks: [] } }],
+			["k3", { kind: "tool-call", data: { status: "settled" } }],
+			["k4", { kind: "tool-call", data: { status: "running" } }],
+		]),
+	},
+};
+assert.equal(chatLatestAssistantSettled(settledAssistantSnapshot), true, "最新助手节点已定案即触发模型读取（R-01-012/AC-17）");
 assert.equal(
-	detailLoadPlan({ detail: { history: [], previewFallbackLoaded: true }, snapshotReady: true, previewFallbackNeeded: true }).history,
+	chatLatestAssistantSettled({
+		chat: {
+			order: ["k1", "k2"],
+			nodes: new Map([
+				["k1", { kind: "user", data: { content: [] } }],
+				["k2", { kind: "assistant-step", data: { status: "running", turn: 1, step: 2, blocks: [] } }],
+			]),
+		},
+	}),
 	false,
-	"最近卡预览 fallback 已尝试后可见期内不热重试",
+	"最新助手节点仍在流式（未定案）时不触发，避免早读扑空（R-01-012/AC-18）",
 );
-// R-01-009/AC-12：等待卡转入 awaiting 后，即使旧 history 已加载也必须补读最新边界。
-assert.equal(
-	detailLoadPlan({ detail: { history: [{ event: { seq: 1 } }] }, snapshotReady: true, durationFallbackNeeded: true }).history,
-	true,
-	"等待卡耗时 fallback 在已有旧 history 时仍发起一次最新 history 读取",
+assert.equal(chatLatestAssistantSettled(null), false, "无快照不触发（R-01-012/AC-18）");
+assert.equal(chatLatestAssistantSettled({ chat: { order: [], nodes: new Map() } }), false, "空窗口不触发（R-01-012/AC-18）");
+
+// ---- R-01-012/AC-17 目录分组解析显示名与 effort：provider 模型 id → {name, reasoning} 索引 ----
+assert.deepEqual(
+	catalogModelEntries([
+		{ id: "g1", models: [{ id: "glm-5.3-flash-512k", name: "(6000D) GLM-5.3-Flash 512K", reasoning: "high" }, { id: "m2", name: "模型乙" }] },
+		{ id: "g2", models: [{ id: "m3", name: "模型丙", reasoning: "low" }] },
+	]),
+	{ "glm-5.3-flash-512k": { name: "(6000D) GLM-5.3-Flash 512K", reasoning: "high" }, m2: { name: "模型乙", reasoning: "" }, m3: { name: "模型丙", reasoning: "low" } },
+	"多分组展平为 id→{name, reasoning} 索引（R-01-012/AC-17）",
 );
+assert.deepEqual(
+	catalogModelEntries([null, {}, { models: null }, { models: [null, {}, { id: "", name: "x" }, { id: "ok", name: "" }, { id: "good", name: "好", reasoning: "medium" }] }]),
+	{ good: { name: "好", reasoning: "medium" } },
+	"畸形分组与畸形条目跳过，不抛错（R-01-012/AC-18）",
+);
+assert.deepEqual(catalogModelEntries(null), {}, "目录缺失返回空索引，调用方回退显示原始溯源 id（R-01-012/AC-18）");
+
+// ---- R-01-012/AC-17 reasoning effort 提取：history 尾扫最新一条 request/header 配置 ----
+const headerEvent = (config) => ({ event: { type: "request/header", seq: 1, data: { header: { config } } } });
 assert.equal(
-	detailLoadPlan({ detail: { history: [], durationFallbackLoaded: true }, snapshotReady: true, durationFallbackNeeded: true }).history,
-	false,
-	"等待卡耗时 fallback 已尝试后可见期内不重复读取",
+	reasoningEffortFromHistoryEvents([
+		{ event: { type: "user/message", seq: 0, data: {} } },
+		headerEvent({ provider: "p", model: "m", reasoningEffort: "low" }),
+		{ event: { type: "assistant/message", seq: 2, data: { message: { source: { provider: "p", model: "ok" } } } } },
+	]),
+	"low",
+	"请求头事件的 config.reasoningEffort 提取（R-01-012/AC-17）",
 );
-// R-01-009/AC-06、R-01-012/AC-12 冷窗口兜底：快照就绪但窗口缺锚点数据（开放回合起点/用户行在窗口外）时补读 history
 assert.equal(
-	detailLoadPlan({ detail: {}, snapshotReady: true, windowComplete: false }).history,
-	true,
-	"快照就绪但窗口缺锚点数据时发起 history 补读",
+	reasoningEffortFromHistoryEvents([headerEvent({ provider: "p", model: "m", reasoningEffort: "low" }), headerEvent({ provider: "p", model: "m", reasoningEffort: "high" })]),
+	"high",
+	"多条请求头取最新纪元（R-01-012/AC-17）",
 );
 assert.equal(
-	detailLoadPlan({ detail: {}, snapshotReady: true, windowComplete: true }).history,
-	false,
-	"快照窗口锚点数据齐全时不发 history 读取",
+	reasoningEffortFromHistoryEvents([headerEvent({ provider: "p", model: "m", reasoningEffort: "low" }), headerEvent({ provider: "p", model: "m" })]),
+	null,
+	"最新请求头未声明 effort 即停，不回扫已废弃纪元（R-01-012/AC-18）",
 );
+assert.equal(reasoningEffortFromHistoryEvents([]), null, "空事件流无 effort（R-01-012/AC-18）");
 assert.equal(
-	detailLoadPlan({ detail: { history: [] }, snapshotReady: true, windowComplete: false }).history,
-	false,
-	"窗口补读失败置空后可见期内不热重试",
+	reasoningEffortFromHistoryEvents([null, { event: undefined }, { event: { type: "request/header", seq: 3, data: {} } }]),
+	null,
+	"畸形条目与缺失 header 跳过不抛错（R-01-012/AC-18）",
 );
 
-// ---- R-01-012/AC-16 模型选择切换经目录订阅推送更新，一次性读取仅作初值 ----
 // 目录 store 快照形状（{current, groups, routable, status, ...}）与 RPC value 同形兼容，经同一归一。
 assert.deepEqual(
 	modelMetadata({
@@ -1044,6 +1093,322 @@ assert.equal(fmtElapsedMs(3_599_500), "1h0m0s", "秒数四舍五入进位到小
 assert.equal(fmtElapsedMs(NaN), "", "NaN 时长归一为空");
 assert.equal(fmtElapsedMs(Infinity), "", "Infinity 时长归一为空");
 assert.equal(fmtElapsedMs(-1), "", "负时长归一为空");
+// ---- R-01-020 会话累计运行时长：事件流配对记账与显示合成 ----
+// R-01-020/AC-02：全部结束原因均计入，回合间空闲不计入。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "turn/end", seq: 2, time: 3_000 }, // completed：+2s
+		{ type: "turn/start", seq: 3, time: 10_000 },
+		{ type: "turn/end", seq: 4, time: 10_500, data: { reason: { kind: "aborted" } } }, // 中断：+0.5s
+		{ type: "turn/start", seq: 5, time: 20_000 },
+		{ type: "turn/end", seq: 6, time: 21_000, data: { reason: { kind: "error" } } }, // 错误：+1s
+	];
+	let stats = { busyMs: null, openTurnStart: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.busyMs, 3_500, "R-01-020/AC-02 全部结束原因计入、空闲不计入");
+	assert.equal(stats.openTurnStart, null, "R-01-020/AC-02 全部回合闭合后无开放起点");
+}
+// R-01-020/AC-02：起点缺失或逆序的回合跳过累加，不制造负值。
+{
+	let stats = { busyMs: null, openTurnStart: null };
+	stats = applyTurnEventToStats(stats, { type: "turn/end", seq: 1, time: 5_000 });
+	assert.equal(stats.busyMs, null, "R-01-020/AC-02 孤儿 turn/end 不累加");
+	stats = applyTurnEventToStats(stats, { type: "turn/start", seq: 2, time: 8_000 });
+	stats = applyTurnEventToStats(stats, { type: "turn/end", seq: 3, time: 7_000 });
+	assert.equal(stats.busyMs, null, "R-01-020/AC-02 时间逆序回合跳过");
+	assert.equal(stats.openTurnStart, null, "R-01-020/AC-02 逆序回合仍清空起点");
+}
+// R-01-020/AC-04：水位幂等——转移函数为纯累加，重复事件必须由调用侧 seq ≤ watermark
+// 检查跳过（host.mjs 实时登记与回填写入前均做该检查）；同批事件重复应用会翻倍。
+{
+	const replay = [
+		{ type: "turn/start", seq: 7, time: 1_000 },
+		{ type: "turn/end", seq: 8, time: 2_000 },
+	];
+	let stats = { busyMs: null, openTurnStart: null };
+	for (const event of replay) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.busyMs, 1_000, "R-01-020/AC-04 单次应用配对累计");
+	// 模拟调用侧水位：seq ≤ watermark 的事件跳过，重复推送不重复计数。
+	for (const event of replay) {
+		if (event.seq <= 8) continue;
+		stats = applyTurnEventToStats(stats, event);
+	}
+	assert.equal(stats.busyMs, 1_000, "R-01-020/AC-04 水位检查下重复推送不重复计数");
+}
+// R-01-020/AC-01
+// R-01-020/AC-03：开放回合实时增量与起点不可得降级。
+assert.equal(totalBusyDisplayMs({ busyMs: 3_500, openTurnStart: 30_000, now: 32_000 }), 5_500, "累计加开放回合实时已耗时");
+assert.equal(totalBusyDisplayMs({ busyMs: 3_500, openTurnStart: null, now: 32_000 }), 3_500, "起点不可得只显示已完成累计");
+assert.equal(totalBusyDisplayMs({ busyMs: null, openTurnStart: 30_000, now: 31_000 }), 1_000, "首回合进行中显示实时增量");
+// R-01-020/AC-06：无任何有效计时数据返回 null（调用方不显示，不以 0 冒充）。
+assert.equal(totalBusyDisplayMs({ busyMs: null, openTurnStart: null, now: 32_000 }), null, "无数据显示 null");
+assert.equal(totalBusyDisplayMs({ busyMs: null, openTurnStart: null, now: null }), null, "now 缺失且无累计为 null");
+assert.equal(totalBusyDisplayMs({ busyMs: 0, openTurnStart: null, now: null }), 0, "显式 0 累计仍是有效数据");
+// R-01-020/AC-06：记账字段归一——null/undefined 直通为 null，不得被 Number(null)===0
+// 误归一为 0（否则开放回合合成出 now−0 的天文数字）。
+assert.equal(normalizeBusyMs(null), null, "busyMs null 归一为 null");
+assert.equal(normalizeBusyMs(undefined), null, "busyMs undefined 归一为 null");
+assert.equal(normalizeBusyMs(null), null, "openTurnStart null 归一为 null");
+assert.equal(normalizeBusyMs(0), 0, "显式 0 仍是有效数字");
+assert.equal(normalizeBusyMs("123"), 123, "数字字符串可归一");
+assert.equal(normalizeBusyMs("abc"), null, "非数字字符串归一为 null");
+assert.equal(normalizeBusyMs(Number.NaN), null, "NaN 归一为 null");
+// R-01-020/AC-05：存量回合经全量事件重放补齐（与实时登记同一转移函数）。
+{
+	const backfillEvents = [
+		{ type: "turn/start", seq: 1, time: 100 },
+		{ type: "turn/end", seq: 2, time: 600 },
+		{ type: "turn/start", seq: 3, time: 900 },
+	];
+	let stats = { busyMs: null, openTurnStart: null };
+	for (const event of backfillEvents) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.busyMs, 500, "R-01-020/AC-05 存量回合重放补齐累计");
+	assert.equal(stats.openTurnStart, 900, "R-01-020/AC-05 重放恢复开放回合起点");
+	// 水位缺口增量（宿主 ensureTurnStatsFresh 已有记录路径）：从已有记账出发，
+	// 仅应用 seq > watermark 的事件，补停机缺口且不重复计数（R-01-020/AC-04、AC-05）。
+	const gapEvents = [
+		{ type: "turn/start", seq: 1, time: 100 },
+		{ type: "turn/end", seq: 2, time: 600 },
+		{ type: "turn/start", seq: 3, time: 900 },
+		{ type: "turn/end", seq: 4, time: 1_400 },
+	];
+	const gapState = { busyMs: 500, openTurnStart: null };
+	const watermark = 2;
+	let gapResult = gapState;
+	for (const event of gapEvents) {
+		if (event.seq <= watermark) continue;
+		gapResult = applyTurnEventToStats(gapResult, event);
+	}
+	assert.equal(gapResult.busyMs, 1_000, "R-01-020/AC-05 增量重放补齐水位缺口回合");
+	assert.equal(gapResult.openTurnStart, null, "R-01-020/AC-05 增量重放后无开放回合");
+}
+// ---- R-01-020/AC-07：回合内阻塞等待配对记账与停表 ----
+// 审批等待：approval/asked–decided 配对，回合结算扣除等待区间。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "approval/asked", seq: 2, time: 2_000, data: { id: "a1", toolName: "bash" } },
+		{ type: "approval/decided", seq: 3, time: 5_000, data: { id: "a1", outcome: "allowed-once" } },
+		{ type: "turn/end", seq: 4, time: 6_000, data: { reason: { kind: "completed" } } },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.busyMs, 2_000, "R-01-020/AC-07 回合结算扣除审批等待 3s");
+	assert.equal(stats.openWaitStart, null, "R-01-020/AC-07 回合结束后无未配对等待");
+	assert.equal(stats.waitedMs, null, "R-01-020/AC-07 回合结束后等待累计清零");
+}
+// 提问等待：ask_user_question 的 tool/call–tool/result 配对。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "tool/call", seq: 2, time: 2_000, data: { callId: "c1", name: "ask_user_question" } },
+		{ type: "tool/result", seq: 3, time: 7_000, data: { message: { source: { kind: "tool", callId: "c1" } } } },
+		{ type: "turn/end", seq: 4, time: 8_000, data: { reason: { kind: "completed" } } },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.busyMs, 2_000, "R-01-020/AC-07 回合结算扣除提问等待 5s");
+}
+// 非提问工具调用不开等待；kind 不一致的结算事件忽略。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "tool/call", seq: 2, time: 2_000, data: { callId: "c2", name: "bash" } },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.openWaitStart, null, "R-01-020/AC-07 非提问工具调用不开等待");
+	const mismatch = [
+		{ type: "tool/call", seq: 3, time: 2_000, data: { callId: "c3", name: "ask_user_question" } },
+		{ type: "approval/decided", seq: 4, time: 3_000, data: { id: "a9", outcome: "allowed-once" } },
+	];
+	for (const event of mismatch) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.openWaitStart, 2_000, "R-01-020/AC-07 kind 不一致的结算事件不关闭提问等待");
+	assert.equal(stats.openWaitKind, "question", "R-01-020/AC-07 提问等待保持开启");
+	const settle = [{ type: "tool/result", seq: 5, time: 4_000, data: { message: { source: { kind: "tool", callId: "c3" } } } }];
+	for (const event of settle) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.waitedMs, 2_000, "R-01-020/AC-07 提问等待按配对边界结算");
+}
+// callId/id 不匹配的结算事件忽略，等待保持开启直至配对边界（DESIGN：同 callId 结算）。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "tool/call", seq: 2, time: 2_000, data: { callId: "c1", name: "ask_user_question" } },
+		{ type: "tool/result", seq: 3, time: 3_000, data: { message: { source: { kind: "tool", callId: "cX" } } } },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.openWaitStart, 2_000, "R-01-020/AC-07 callId 不匹配的 tool/result 不关闭提问等待");
+	assert.equal(stats.openWaitId, "c1", "R-01-020/AC-07 等待记录配对 callId");
+	const settle = [{ type: "tool/result", seq: 4, time: 4_000, data: { message: { source: { kind: "tool", callId: "c1" } } } }];
+	for (const event of settle) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.waitedMs, 2_000, "R-01-020/AC-07 同 callId 的 result 结算等待");
+}
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "approval/asked", seq: 2, time: 2_000, data: { id: "a1", toolName: "bash" } },
+		{ type: "approval/decided", seq: 3, time: 3_000, data: { id: "aX", outcome: "allowed-once" } },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.openWaitStart, 2_000, "R-01-020/AC-07 id 不匹配的 approval/decided 不关闭审批等待");
+	const settle = [{ type: "approval/decided", seq: 4, time: 5_000, data: { id: "a1", outcome: "rejected" } }];
+	for (const event of settle) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.waitedMs, 3_000, "R-01-020/AC-07 同 id 的 decided 结算审批等待");
+}
+// 等待串行不嵌套：未配对等待期间的新等待边界忽略。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "approval/asked", seq: 2, time: 2_000, data: { id: "a1", toolName: "bash" } },
+		{ type: "approval/asked", seq: 3, time: 2_500, data: { id: "a2", toolName: "write" } },
+		{ type: "approval/decided", seq: 4, time: 4_000, data: { id: "a1", outcome: "rejected" } },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.waitedMs, 2_000, "R-01-020/AC-07 串行等待自首个边界起算、不重复计时");
+}
+// turn/end 强制结算未配对等待：等待尾部不落到运行时长里。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "approval/asked", seq: 2, time: 2_000, data: { id: "a1", toolName: "bash" } },
+		{ type: "turn/end", seq: 3, time: 10_000, data: { reason: { kind: "aborted" } } },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.busyMs, 1_000, "R-01-020/AC-07 回合结束强制结算未配对等待");
+	assert.equal(stats.openTurnStart, null, "R-01-020/AC-07 强制结算后回合闭合");
+}
+// 换回合重置等待累计。
+{
+	const events = [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "tool/call", seq: 2, time: 2_000, data: { callId: "c1", name: "ask_user_question" } },
+		{ type: "tool/result", seq: 3, time: 3_000, data: { message: { source: { kind: "tool", callId: "c1" } } } },
+		{ type: "turn/end", seq: 4, time: 3_500, data: { reason: { kind: "completed" } } },
+		{ type: "turn/start", seq: 5, time: 9_000 },
+	];
+	let stats = { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null };
+	for (const event of events) stats = applyTurnEventToStats(stats, event);
+	assert.equal(stats.busyMs, 1_500, "R-01-020/AC-07 首回合结算扣除提问等待");
+	assert.equal(stats.waitedMs, null, "R-01-020/AC-07 新回合重置等待累计");
+}
+// 显示合成（AC-07）：等待期间冻结——now 推进而显示值不变。
+{
+	const state = { busyMs: 1_000, openTurnStart: 5_000, waitedMs: 2_000, openWaitStart: 9_000 };
+	const frozen = totalBusyDisplayMs({ ...state, now: 10_000 });
+	assert.equal(frozen, 3_000, "R-01-020/AC-07 等待开始时刻的运行时长被冻结显示");
+	assert.equal(totalBusyDisplayMs({ ...state, now: 20_000 }), frozen, "R-01-020/AC-07 等待期间显示值不随 now 增长");
+}
+// 显示合成（AC-07）：等待结算与回合结算处显示值连续，恢复运行后续走。
+{
+	// 回合 1000 起，等待 2000–4000（waitedMs=2000）；now=5000 时显示 2000。
+	const running = { busyMs: 1_000, openTurnStart: 1_000, waitedMs: 2_000, openWaitStart: null };
+	assert.equal(totalBusyDisplayMs({ ...running, now: 5_000 }), 3_000, "R-01-020/AC-07 等待结束后从冻结值继续累计");
+	// turn/end t=6000 结算 busyMs = 1000 + (6000 − 1000 − 2000) = 4000；结算前一刻显示 4000。
+	assert.equal(totalBusyDisplayMs({ ...running, now: 6_000 }), 4_000, "R-01-020/AC-07 回合结算前一刻显示值与结算后一致");
+	assert.equal(totalBusyDisplayMs({ busyMs: 4_000, openTurnStart: null, waitedMs: null, openWaitStart: null, now: 6_000 }), 4_000, "R-01-020/AC-07 回合结算后显示 busyMs 无跳变");
+}
+// ---- R-01-020/AC-04、AC-05：reconcileTurnStats 统一收敛 ----
+// 无记录：全量重放。
+{
+	const next = reconcileTurnStats(null, [
+		{ type: "turn/start", seq: 1, time: 1_000 },
+		{ type: "turn/end", seq: 2, time: 3_000 },
+	]);
+	assert.equal(next.busyMs, 2_000, "R-01-020/AC-05 无记录全量重放补齐累计");
+	assert.equal(next.watermarkSeq, 2, "R-01-020/AC-05 全量重放推进水位");
+}
+// 水位超前于日志最大 seq（seq 空间被重编，如 dsh 0.1.5 V3 迁移）：全量重放自愈，
+// 卡死的开放回合被清除、总耗时不再无限增长（原缺陷回归）。
+{
+	const next = reconcileTurnStats(
+		{ busyMs: 100, openTurnStart: 5_000, openWaitStart: null, openWaitKind: null, waitedMs: null, watermarkSeq: 208_536 },
+		[
+			{ type: "turn/start", seq: 1, time: 1_000 },
+			{ type: "turn/end", seq: 2, time: 3_000 },
+		],
+	);
+	assert.equal(next.busyMs, 2_000, "R-01-020/AC-04 水位超前时全量重放重算累计");
+	assert.equal(next.openTurnStart, null, "R-01-020/AC-04 水位超前时卡死的开放回合被清除");
+	assert.equal(next.watermarkSeq, 2, "R-01-020/AC-04 自愈后水位回归当前 seq 空间");
+}
+// 正常增量：只应用 seq > watermark 的事件，不重复计数。
+{
+	const next = reconcileTurnStats(
+		{ busyMs: 500, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null, watermarkSeq: 2 },
+		[
+			{ type: "turn/start", seq: 1, time: 100 },
+			{ type: "turn/end", seq: 2, time: 600 },
+			{ type: "turn/start", seq: 3, time: 900 },
+			{ type: "turn/end", seq: 4, time: 1_400 },
+		],
+	);
+	assert.equal(next.busyMs, 1_000, "R-01-020/AC-05 增量收敛只补水位缺口");
+	assert.equal(next.watermarkSeq, 4, "R-01-020/AC-05 增量收敛推进水位");
+}
+// 启动扫描：closeOpenTurn 把残留开放回合按日志最后事件时刻强制结算，尾部等待不计数。
+{
+	const next = reconcileTurnStats(
+		{ busyMs: 100, openTurnStart: 5_000, openWaitStart: null, openWaitKind: null, waitedMs: null, watermarkSeq: 1 },
+		[
+			{ type: "turn/start", seq: 1, time: 5_000 },
+			{ type: "tool/call", seq: 2, time: 6_000, data: { callId: "c1", name: "ask_user_question" } },
+			{ type: "tool/result", seq: 3, time: 7_000, data: { message: { source: { kind: "tool", callId: "c1" } } } },
+		],
+		{ closeOpenTurn: true },
+	);
+	assert.equal(next.busyMs, 1_100, "R-01-020/AC-04 启动扫描按日志末事件时刻结算残留开放回合");
+	assert.equal(next.openTurnStart, null, "R-01-020/AC-04 启动扫描后无残留开放回合");
+	assert.equal(next.waitedMs, null, "R-01-020/AC-04 启动扫描后等待累计清零");
+}
+// 重编检测（R-01-020/AC-04）：水位推进处记录 watermarkTime；增量重放同步更新。
+{
+	const next = reconcileTurnStats(
+		{ busyMs: 500, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null, watermarkSeq: 2, watermarkTime: 600 },
+		[
+			{ type: "turn/start", seq: 3, time: 10_000 },
+			{ type: "turn/end", seq: 4, time: 11_000 },
+		],
+	);
+	assert.equal(next.busyMs, 1_500, "R-01-020/AC-04 增量重放补齐缺口回合");
+	assert.equal(next.watermarkTime, 11_000, "R-01-020/AC-04 水位推进处记录最后应用边界事件的时刻");
+}
+// 部分重叠的 seq 空间重编（水位 ≤ 日志最大 seq，既有水位超前检测不可达）：forceFresh
+// 丢弃旧空间记账、从空状态全量重放，实时登记的重编检测据此自愈；存量记录（无
+// watermarkTime）同走该路径。
+{
+	const forced = reconcileTurnStats(
+		{ busyMs: 100, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null, watermarkSeq: 2, watermarkTime: 600 },
+		[
+			{ type: "turn/start", seq: 1, time: 10_000 },
+			{ type: "turn/end", seq: 2, time: 11_000 },
+			{ type: "turn/start", seq: 3, time: 11_500 },
+			{ type: "turn/end", seq: 4, time: 12_000 },
+		],
+		{ forceFresh: true },
+	);
+	assert.equal(forced.busyMs, 1_500, "R-01-020/AC-04 强制全量重放按新 seq 空间重算累计");
+	assert.equal(forced.watermarkSeq, 4, "R-01-020/AC-04 强制全量重放后水位落在新空间");
+	assert.equal(forced.watermarkTime, 12_000, "R-01-020/AC-04 强制全量重放后水位时刻为最后边界事件");
+}
+{
+	const legacy = reconcileTurnStats(
+		{ busyMs: 100, openTurnStart: null, openWaitStart: null, openWaitKind: null, waitedMs: null, watermarkSeq: 2 },
+		[
+			{ type: "turn/start", seq: 1, time: 10_000 },
+			{ type: "turn/end", seq: 2, time: 11_000 },
+			{ type: "tool/call", seq: 3, time: 11_500, data: { callId: "c1", name: "bash" } },
+		],
+		{ forceFresh: true },
+	);
+	assert.equal(legacy.busyMs, 1_000, "R-01-020/AC-04 存量记录（无 watermarkTime）强制重放后按新空间重算");
+	assert.equal(legacy.watermarkSeq, 3, "R-01-020/AC-04 存量记录重放后水位覆盖全部事件（含无效果事件）");
+	assert.equal(legacy.watermarkTime, 11_500, "R-01-020/AC-04 存量记录重放后补上水位时刻");
+}
 // R-01-013/AC-05：历史卡同时显示本地绝对日期时间与相对年龄，异常输入不制造虚假时间。
 const relativeMinute = 60_000;
 const relativeHour = 60 * relativeMinute;
@@ -1137,8 +1502,6 @@ const bodyLabelItems = conversationWorkItems({
 	chat: { order: ["bd"], nodes: { get: (key) => ({ key, kind: "assistant-step", data: { status: "settled", turn: 1, step: 0, blocks: [{ kind: "text", text: "纯正文" }] } }) } },
 });
 assert.equal(bodyLabelItems[0].label, "助手", "正文工作项 label 为中文「助手」（R-01-012/AC-09）");
-assert.equal(needsHistorySnapshot({ chat: { order: [] } }), true, "空 chat snapshot 需要 history fallback");
-assert.equal(needsHistorySnapshot({ chat: { order: ["item"] } }), false, "已 hydrate 的 chat snapshot 优先使用 order");
 const models = modelMetadata({
 	current: { provider: "p", model: "m", reasoningEffort: "high" },
 	groups: [{ id: "p", models: [{ id: "m", name: "Model M", reasoning: { efforts: [{ id: "high", name: "High" }] } }] }],
@@ -1473,6 +1836,46 @@ assert.equal(coldInterrupted[0].status, "stopped", "interrupted 结果落定 sto
 const coldOrphan = conversationTimelineFromHistory([hToolResult(1, "hc9")], 10);
 assert.equal(coldOrphan.length, 1, "call 在窗口外的孤儿 result 仍成行（信息不丢失）");
 assert.equal(coldOrphan[0].status, "done", "孤儿 result 落定 done，不造 running 行");
+// ---- V3 log 路径行为证据（T-123 dsh 0.1.5 适配）：0.1.5 无独立 context 事件，非用户 source 的
+// user/message 即宿主 ContextMessageNode；流式期间 eventSource 以 transient assistant/live-chunk
+// 条目携带增量，须累积为 running live 行（否则运行卡无 running 圆点，R-01-009/AC-09 呈现缺失）----
+const hContext = (seq, source, text = "上下文正文") => ({ event: { type: "user/message", seq, data: { source, content: [{ type: "text", text }] } } });
+const ctxInject = conversationTimelineFromHistory([
+	hUser(1, "指令"),
+	hContext(2, { kind: "plugin", plugin: "dsh-activity-pane" }),
+	hAgent(3, "回复"),
+], 10);
+assert.equal(ctxInject[1].kind, "context", "非用户 source 的 user/message 映射为上下文行（镜像宿主 ContextMessageNode）");
+assert.equal(ctxInject[1].label, "上下文注入", "注入角色标题为上下文注入");
+assert.equal(ctxInject[1].summary, "dsh-activity-pane", "插件 source 摘要取 plugin 名（镜像原生 provenance.label）");
+const ctxRecall = conversationTimelineFromHistory([
+	hContext(1, { kind: "session-reference", references: [{ label: "会话甲" }, { label: "会话乙" }, { label: "会话甲" }] }),
+], 10);
+assert.equal(ctxRecall[0].label, "跨会话召回", "session-reference source 映射为召回角色");
+assert.equal(ctxRecall[0].summary, "会话甲, 会话乙", "召回摘要取引用标题去重逗号拼接（镜像原生 collect/joined）");
+const hLiveChunk = (seq, attemptId, text, type = "text-delta") => ({
+	type: "transient",
+	event: { type: "assistant/live-chunk", seq, time: 0, data: { attemptId, turn: 1, step: 0, chunk: { type, text } } },
+});
+const streaming = conversationTimelineFromHistory([hUser(1, "流式指令"), hLiveChunk(1.9, "a1", "正在"), hLiveChunk(1.95, "a1", "流式输出")], 10);
+assert.equal(streaming.length, 2, "流式期间用户行与 live 行并存");
+assert.equal(streaming[1].kind, "assistant", "live-chunk 累积为 assistant 行");
+assert.equal(streaming[1].status, "running", "流式 live 行为 running（运行卡 running 圆点来源）");
+assert.equal(streaming[1].live, true, "live 行携带 live 标记");
+assert.equal(streaming[1].text, "正在流式输出", "text-delta 按到达序累积为流式正文");
+const streamingReasoning = conversationTimelineFromHistory([hLiveChunk(1.8, "a2", "思考中", "reasoning-delta")], 10);
+assert.equal(streamingReasoning[0].status, "running", "reasoning-delta 同样呈现 running 行");
+assert.equal(streamingReasoning[0].detail, "思考中", "reasoning-delta 累积进 detail");
+assert.equal(streamingReasoning[0].text, "", "reasoning-delta 不混入正文");
+const settledStream = foldedHistoryTimeline([hUser(1, "流式指令"), hAgent(2, "最终回复")], 10);
+assert.ok(settledStream.every((row) => row.status !== "running"), "回合落定后 transient 条目出窗，无 running 残留");
+// 阻塞等待呈现（settleIdle）：折叠前落定残留 running 行，组标题/状态由已定案成员派生
+// （快照路径 settleWhenIdle 前置语义对齐，R-01-009/AC-09「仅执行中行闪烁」）。
+const blockedAskRunning = foldedHistoryTimeline([hUser(1, "指令"), hToolCall(2, "ha")], 10);
+assert.equal(blockedAskRunning.at(-1).label, "正在运行", "未落定呈现保留「正在运行」组标题");
+const blockedAskSettled = foldedHistoryTimeline([hUser(1, "指令"), hToolCall(2, "ha")], 10, "", true);
+assert.equal(blockedAskSettled.at(-1).status, "done", "阻塞等待呈现下折叠前落定残留 running 行");
+assert.equal(blockedAskSettled.at(-1).label, "运行了命令", "落定后组标题由已定案成员派生（非「正在运行」）");
 // historyInstructionAnchor：尾扫最近一条非空文本真实用户消息（R-01-012/AC-12 快照窗口外兜底）
 assert.equal(historyInstructionAnchor([hUser(1, "旧指令"), hAgent(2, "回复"), hUser(3, "新指令")])?.text, "新指令", "锚行取最近一条用户消息");
 assert.equal(historyInstructionAnchor([hUser(1, "  "), hAgent(2, "回复")]), null, "空文本用户消息不作锚");
@@ -1674,6 +2077,16 @@ assert.deepEqual(
 	{ outputTokens: 0, inputTokens: 0, cacheHitPct: 0, rateTokS: 8 },
 	"统计合并保留有效的零值，仅对缺失字段回退（R-01-009/AC-13）",
 );
+// R-01-009/AC-15 暂停子代理卡的冻结口径与等待卡共用同一合并语义：
+// 当前投影缺失的字段保留暂停前最后已知值，均缺失时回退当前投影，不伪造 0。
+assert.deepEqual(
+	mergeRuntimeStats(
+		{ outputTokens: 512, inputTokens: 900, cacheHitPct: 62, rateTokS: 32 },
+		{ outputTokens: null, inputTokens: 1, cacheHitPct: null, rateTokS: 5 },
+	),
+	{ outputTokens: 512, inputTokens: 900, cacheHitPct: 62, rateTokS: 32 },
+	"暂停子代理卡冻结暂停前最后已知统计，缺失字段才回退当前投影（R-01-009/AC-15）",
+);
 assert.deepEqual(
 	usageSummary({ uncachedInputTokens: 100, cacheReadTokens: 700, cacheWriteTokens: 200 }),
 	{ inputTokens: 1_000, cacheHitPct: 70 },
@@ -1798,33 +2211,6 @@ assert.equal(
 assert.equal(openTurnStartFromEvents([turnStartEv(1, 1, Number.NaN)]), null, "turn/start 时刻非法时无可用起点");
 assert.equal(openTurnStartFromEvents([]), null, "空事件无开放回合起点");
 assert.equal(openTurnStartFromEvents(null), null, "非数组输入归一 null");
-// 补读触发口径（R-01-009/AC-06）：仅「运行中 + 轮内订阅已建立 + 快照无开放回合起点」算缺口
-assert.equal(
-	openTurnStartMissing({ snapshotReady: true, running: true, hasLiveness: true, liveStartTime: null }),
-	true,
-	"运行中且快照无开放回合起点判定为缺口（超长回合冷窗口）",
-);
-assert.equal(
-	openTurnStartMissing({ snapshotReady: true, running: true, hasLiveness: true, liveStartTime: 1000 }),
-	false,
-	"窗口内含开放回合起点时不是缺口",
-);
-assert.equal(
-	openTurnStartMissing({ snapshotReady: true, running: false, hasLiveness: false, liveStartTime: null }),
-	false,
-	"等待/空闲会话（非运行、无 liveness 记录）不算缺口、不触发补读",
-);
-assert.equal(
-	openTurnStartMissing({ snapshotReady: true, running: true, hasLiveness: false, liveStartTime: null }),
-	false,
-	"轮内订阅尚未建立时不算缺口（下一帧建立后再判定）",
-);
-assert.equal(
-	openTurnStartMissing({ snapshotReady: false, running: true, hasLiveness: true, liveStartTime: null }),
-	false,
-	"快照未就绪走 historyNeeded 原路径，不算窗口缺口",
-);
-
 // ---- R-01-009/AC-07 工作项时间线的状态与主会话窗口语义摘要（无行级耗时，C-012）----
 const statusTimeline = conversationWorkItems({
 	chat: {
@@ -2481,67 +2867,64 @@ assert.equal(
 	2500,
 	"turnTimings 取最大 endTime，忽略未结束回合",
 );
-// ---- R-01-009/AC-12 等待卡保留最近完整回合耗时 ----
-assert.equal(
-	lastTurnDurationFromTimings(new Map([
-		[1, { startTime: 100, endTime: 900 }],
-		[2, { startTime: 1000 }],
-		[3, { startTime: 2000, endTime: 2500 }],
-	])),
-	500,
-	"turnTimings 取最近已结束回合的起止差值，不取更早回合或开放回合",
-);
-assert.equal(
-	lastTurnDurationFromTimings(new Map([[1, { startTime: 900, endTime: 100 }]])),
-	null,
-	"起点晚于终点时不生成虚假回合耗时",
-);
-assert.equal(lastTurnDurationFromTimings(new Map([[1, { startTime: 100 }]])), null, "无 endTime 不生成等待耗时");
+// ---- R-01-009/AC-12 等待卡保留最近完整回合耗时（busy 口径，R-01-020 语义） ----
 assert.equal(
-	lastTurnDurationFromEvents([
+	lastTurnBusyFromEvents([
 		{ event: { type: "turn/start", time: 100, data: { turn: 1 } } },
 		{ event: { type: "turn/end", time: 900, data: { turn: 1 } } },
 		{ event: { type: "turn/start", time: 1000, data: { turn: 2 } } },
 		{ event: { type: "turn/end", time: 2500, data: { turn: 2 } } },
 	]),
 	1500,
-	"history 按同一 turn 配对并取最近已结束回合的耗时",
+	"history 取最近已结束回合的起止差值",
 );
 assert.equal(
-	lastTurnDurationFromEvents([
-		{ event: { type: "turn/start", time: 900, data: { turn: 1 } } },
-		{ event: { type: "turn/end", time: 100, data: { turn: 1 } } },
+	lastTurnBusyFromEvents([
+		{ event: { type: "turn/start", time: 1000, data: { turn: 1 } } },
+		{ event: { type: "tool/call", time: 2000, data: { callId: "c1", name: "ask_user_question" } } },
+		{ event: { type: "tool/result", time: 7000, data: { message: { source: { kind: "tool", callId: "c1" } } } } },
+		{ event: { type: "turn/end", time: 8000, data: { turn: 1 } } },
 	]),
-	null,
-	"history 起止逆序时不生成虚假回合耗时",
+	2000,
+	"最近回合耗时扣除回合内提问等待（busy 口径，与总耗时一致）",
 );
 assert.equal(
-	lastTurnDurationFromEvents([
-		{ event: { type: "turn/start", time: null, data: { turn: 1 } } },
-		{ event: { type: "turn/end", time: 100, data: { turn: 1 } } },
+	lastTurnBusyFromEvents([
+		{ event: { type: "turn/start", time: 1000, data: { turn: 1 } } },
+		{ event: { type: "approval/asked", time: 2000, data: { id: "a1" } } },
+		{ event: { type: "approval/decided", time: 6000, data: { id: "a1" } } },
+		{ event: { type: "turn/end", time: 7000, data: { turn: 1 } } },
+	]),
+	2000,
+	"最近回合耗时扣除回合内审批等待",
+);
+assert.equal(
+	lastTurnBusyFromEvents([
+		{ event: { type: "turn/start", time: 1000, data: { turn: 1 } } },
+		{ event: { type: "turn/end", time: 900, data: { turn: 1 } } },
 	]),
 	null,
-	"history 起点缺失时不把 null 当作时间零点",
+	"起止逆序时不生成虚假回合耗时",
 );
 assert.equal(
-	lastTurnDurationFromTimings(new Map([[1, { startTime: Number.NaN, endTime: 100 }]])),
+	lastTurnBusyFromEvents([
+		{ event: { type: "turn/start", time: null, data: { turn: 1 } } },
+		{ event: { type: "turn/end", time: 100, data: { turn: 1 } } },
+	]),
 	null,
-	"turnTimings 起点非有限时不生成等待耗时",
+	"起点缺失时不把 null 当作时间零点",
 );
 assert.equal(
-	lastTurnDuration({
-		turnTimings: new Map([
-			[1, { startTime: 100, endTime: 900 }],
-			[2, { endTime: 2500 }],
-		]),
-		history: [],
-	}),
-	800,
-	"turnTimings 最新孤立 end 不得与更早完整回合错配",
+	lastTurnBusyFromEvents([
+		{ event: { type: "turn/start", time: 1000, data: { turn: 1 } } },
+		{ event: { type: "tool/call", time: 2000, data: { callId: "c1", name: "ask_user_question" } } },
+		{ event: { type: "turn/end", time: 5000, data: { turn: 1 } } },
+	]),
+	1000,
+	"turn/end 强制结算未配对等待：等待尾部不计入最近回合耗时",
 );
 assert.equal(
 	lastTurnDuration({
-		turnTimings: new Map(),
 		history: [
 			{ event: { type: "turn/start", time: 100, data: { turn: 1 } } },
 			{ event: { type: "turn/end", time: 900, data: { turn: 1 } } },
@@ -2549,24 +2932,10 @@ assert.equal(
 		],
 	}),
 	800,
-	"history 最新孤立 end 不得与更早完整回合错配",
-);
-assert.equal(
-	lastTurnDuration({
-		turnTimings: new Map([[1, { startTime: 100, endTime: 900 }]]),
-		history: [
-			{ event: { type: "turn/start", time: 1000, data: { turn: 2 } } },
-			{ event: { type: "turn/end", time: 1300, data: { turn: 2 } } },
-		],
-	}),
-	300,
-	"多来源时按最近结束时刻选择同一最新回合耗时",
-);
-assert.equal(
-	lastTurnDuration({ turnTimings: new Map([[1, { startTime: 100, endTime: 900 }]]), history: [] }),
-	800,
-	"无 history 时从 turnTimings 提取回合耗时",
+	"最新孤立 end 不得与更早完整回合错配",
 );
+assert.equal(lastTurnDuration({ history: [] }), null, "空 history 无回合耗时");
+assert.equal(lastTurnDuration({ history: null }), null, "history 缺失回退 null");
 const refineSnap = {
 	ids: ["sTurn", "sPrompt", "sNone"],
 	byId: {
@@ -2918,9 +3287,9 @@ assert.deepEqual(
 );
 
 // ---- R-01-014/AC-05 补充数据失败降级为空字段并可重试 ----
-// （行为链详见 R-01-012/AC-01 的 detailLoadPlan 锚点：失败置空 → 可见期内不热重试 →
-//  离开可见清理 → 重回可见允许重试。）
-assert.equal(detailLoadPlan({ detail: { model: { model: "", reasoning: "" } } }).model, false, "失败置空即降级为空字段");
+// （dsh 0.1.5 起 per-session models RPC 移除，模型提取随日志读取统一进行：失败置空
+//  语义由 R-01-012/AC-18 的空白归一单测与本文件日志读取门禁锚点共同
+//  承载——失败不置标记、下一可见期允许重试。）
 
 // ---- R-01-015/AC-02 拖拽宽度夹取 ｜ R-01-015/AC-04 持久化恢复归一 ----
 assert.equal(clampPaneWidth(280), 280, "范围内宽度原样保留");
@@ -3076,8 +3445,8 @@ assert.ok(
 assert.ok(!bundle.includes("dshcf") && !bundle.includes("autoCollapseActive"), "无 dsh-auto-collapse 探测残留（R-01-017、C-017）");
 assert.ok(!bundle.includes("nativeWorkItemRow") && !bundle.includes("cloneNativeIcon") && !bundle.includes("nativeIconsByTraceKey"), "原生行匹配/图标克隆机器无残留（C-017）");
 assert.ok(!bundle.includes("mergeTraceStatus") && !bundle.includes("allowNativePresentation"), "行状态直接采用核心派生值，无合并/切换层（C-017）");
-assert.ok(bundle.includes("api.history"), "冷会话使用 native history 一次性补齐");
-assert.ok(bundle.includes("api.models"), "模型/reasoning 使用 native models 数据");
+assert.ok(bundle.includes(".page("), "冷会话使用 remote 日志分页一次性补齐（Session V3）");
+assert.ok(bundle.includes(".modelCatalog("), "模型/reasoning 使用部署级 modelCatalog 数据");
 assert.ok(bundle.includes("dap-token-stats"), "token 统计 DOM 位于进度条之后");
 assert.ok(
 	bundle.includes('makeEl("span", "dap-token-main")') && bundle.includes('makeEl("span", "dap-token-time")'),
@@ -3086,7 +3455,7 @@ assert.ok(
 assert.ok(bundle.includes("function renderTokenStats"), "运行卡统计行继续复用既有渲染逻辑（R-01-009/AC-05）");
 // R-01-009/AC-13 等待卡保留进入等待前最后已知的 token 统计
 assert.ok(
-	bundle.includes('return [head, row, makeEl("div", "dap-trace"), statsRow, foot];'),
+	bundle.includes('return [head, row, makeEl("div", "dap-trace"), makeStatsRow(), foot];'),
 	"等待卡骨架在时间线后保留统计行（R-01-009/AC-13）",
 );
 assert.ok(
@@ -3112,7 +3481,7 @@ assert.ok(!bundle.includes("≈"), "速率不再携带约等于符号（R-01-009
 assert.ok(bundle.includes("dap-history-line"), "历史卡包含用户/agent 两条消息预览行");
 // R-01-013/AC-12 最近历史卡保留最近回合统计
 assert.ok(
-	bundle.includes('return [head, row, userLine, agentLine, statsRow, makeEl("div", "dap-note")];'),
+	bundle.includes('return [head, row, userLine, agentLine, makeStatsRow(), makeEl("div", "dap-note")];'),
 	"历史卡统计行位于助手预览后、活动时间前",
 );
 assert.ok(bundle.includes("statsFromProjection"), "历史卡统计复用列表投影派生函数（R-01-013/AC-12）");
@@ -3183,7 +3552,7 @@ assert.ok(bundle.includes("function activeSessionIds(byId = {})"), "活动子代
 // ---- R-01-016/AC-01 等待卡保留最近工作项时间线 ----
 assert.ok(
 	bundle.includes("awaitHead.append(capsule);") &&
-		bundle.includes('return [head, row, makeEl("div", "dap-trace"), statsRow, foot];'),
+		bundle.includes('return [head, row, makeEl("div", "dap-trace"), makeStatsRow(), foot];'),
 	"awaiting 骨架在标题行与统计行、末行两段（胶囊+正文）之间含时间线，固定耗时由统计行承载（R-01-016/AC-01、R-01-009/AC-12，C-043）",
 );
 // ---- R-01-002/AC-10 完成提醒卡「移入历史」按钮 ----
@@ -3197,7 +3566,7 @@ assert.ok(
 	"按钮点击/键盘激活写回 ack 且阻断卡片跳转（R-01-002/AC-10）",
 );
 assert.ok(bundle.includes('confirm.hidden = entry.waitClass !== "done"'), "仅完成提醒卡显示「移入历史」按钮，阻塞等待卡不显示（R-01-002/AC-10）");
-assert.ok(bundle.includes("new window.EventSource(`${ACK_API_BASE}/acks/stream`)"), "完成确认状态经 SSE 通道订阅（R-01-002/AC-11、AC-12）");
+assert.ok(bundle.includes("new window.EventSource(`${PANE_API_BASE}/acks/stream`)"), "完成确认状态经 SSE 通道订阅（R-01-002/AC-11、AC-12）");
 // R-01-002/AC-12 缺陷回归：移动 PWA 后台恢复后 ack 通道必须自愈（EventSource CLOSED/半开
 // 不再自动重连），否则完成等待中的会话被误判入历史区直至整页重载。
 assert.ok(
@@ -3212,7 +3581,7 @@ assert.ok(
 	bundle.includes('document.removeEventListener("visibilitychange", onVisibilityResume)') && bundle.includes('window.removeEventListener("pageshow", onPageShow)'),
 	"卸载时移除 ack 通道自愈监听（R-01-002/AC-12）",
 );
-assert.ok(bundle.includes("fetch(`${ACK_API_BASE}/ack`"), "确认写回经宿主侧 ack 路由（R-01-002/AC-10、AC-11）");
+assert.ok(bundle.includes("fetch(`${PANE_API_BASE}/ack`"), "确认写回经宿主侧 ack 路由（R-01-002/AC-10、AC-11）");
 assert.ok(
 	!bundle.includes("updateCompletedHolds") && !bundle.includes("heldCompletedIds") && !bundle.includes("prevActiveMainIds"),
 	"响应保持易失记账全套移除（C-030）",
@@ -3225,12 +3594,12 @@ assert.ok(
 assert.equal(
 	bundle.split('makeEl("span", "dap-pct")').length - 1,
 	1,
-	"百分比文本元素全 bundle 仅运行卡骨架一处创建（R-01-009/AC-06）",
+	"百分比文本元素经 makeProgressRow 共享骨架单点创建（R-01-009/AC-06、AC-14）",
 );
 assert.equal(
 	bundle.split('querySelector(".dap-pct")').length - 1,
 	1,
-	"百分比文本写入全 bundle 仅运行卡渲染分支一处（R-01-009/AC-06）",
+	"百分比文本写入经 renderProgressRow 单点承载（R-01-009/AC-06、AC-14）",
 );
 // ---- R-01-016/AC-04 时间线数据在途时显示加载指示、返回就地填充 ----
 assert.ok(
@@ -3278,8 +3647,24 @@ assert.ok(!bundle.includes('"Think"') && !bundle.includes('"Assistant"'), "bundl
 assert.ok(bundle.includes('"思考"') && bundle.includes('"助手"'), "bundle 含中文「思考」「助手」标签（R-01-012/AC-09、AC-10）");
 assert.ok(bundle.includes("session.subscribe"), "运行卡通过 native session subscribe 接收实时推送");
 assert.ok(
-	clientSource.includes('const inject = ["connection", "sessions", "workspaces"];'),
-	"sessions/workspaces 通过 client inject 注入，不依赖服务发现定时器",
+	clientSource.includes('const inject = ["sessions", "workspaces", "uiSession", "remote.session"];'),
+	"sessions/workspaces/uiSession/remote.session 通过 client inject 注入，不依赖服务发现定时器",
+);
+assert.ok(
+	bundle.includes("uiSession?.pendingInteractions") && bundle.includes("pendingInteraction: interaction.kind"),
+	"0.1.5 等待行动经 uiSession.pendingInteractions 快照回填行副本（sessions 行不再承载 pendingInteraction）",
+);
+assert.ok(
+	bundle.includes("historyDeepReadDone = true") && bundle.includes("historyDeepReadDone !== true"),
+	"日志深翻每可见期至多一次：完成即置位（失败同样置位不热重试），重入可见由详情记账清理放行重试（R-01-014/AC-05）",
+);
+assert.ok(
+	clientSource.includes("deepReadNeeded && !historyLoads.has(id)"),
+	"深翻在途守卫：同一会话深翻在途不重复入队，防 page RPC 风暴与加载指示在途性高频抖动（R-01-014/AC-05）",
+);
+assert.ok(
+	clientSource.includes('!detail.log && detail.snapshot?.openState !== "open"'),
+	"open 仅在日志窗口缺席时发起：已水合会话不逐帧重发 open，防在途翻转驱动加载指示抖动",
 );
 assert.ok(!bundle.includes("serviceTimer"), "服务发现不得保留后台定时器");
 assert.ok(!bundle.includes("frameProbeTimer"), "宿主 frame 发现不得保留后台定时器");
@@ -3311,24 +3696,33 @@ assert.ok(bundle.includes("loadingPreviews"), "预览字段级加载指示并入
 assert.ok(bundle.includes("renderTraceLoading"), "时间线区数据在途时显示加载行");
 assert.ok(clientSource.includes('e2eParams.get("dap-e2e-model-delay")'), "detail 渐进 E2E 接缝由显式 URL fragment 启用");
 assert.ok(clientSource.includes("Math.min(requestedModelDelay, 1_000)"), "detail 渐进 E2E 延迟上限为 1 秒");
-assert.ok(clientSource.includes("if (!subagent && e2eModelDelayMs === 0) subscribeModelDirectory(id, detail);"), "fixture 模式仅绕开 model directory 抢先初值");
-assert.ok(clientSource.includes("delayedModelCall(() => api.models({ sessionId: id }))"), "detail fixture 延迟正式 models RPC，不伪造 model response");
+assert.ok(
+	clientSource.includes("if (!subagent) {") &&
+		clientSource.includes("subscribeModelDirectory(id, detail);") &&
+		clientSource.includes("loadDirectoryOnce(id);"),
+	"仅主会话建立 model directory 订阅与一次性 load（子代理目录不可用不订阅）",
+);
+assert.ok(
+	clientSource.includes('delayedModelCall(() => (typeof directory.load === "function" ? directory.load() : null))'),
+	"detail fixture 延迟目录一次性 load，不伪造 model response",
+);
 assert.ok(clientSource.includes("Promise.resolve().then(call)"), "detail fixture 保留 models RPC 同步异常的 Promise catch 降级语义");
 assert.ok(clientSource.includes("e2eModelDelayWaiters.clear()"), "卸载时取消并结清 detail fixture 延迟，不残留 timer/promise");
 assert.ok(bundle.includes("promise.then(queueSync, queueSync)"), "补充数据逐个完成即重绘（先就绪先显示）");
 assert.ok(bundle.includes("LOAD_CONCURRENCY"), "冷数据读取经并发池限制慢网挤占");
 assert.ok(bundle.includes("session.open"), "运行卡通过 native session open hydrate 非当前会话");
 assert.ok(bundle.includes("sessionOpenLoads"), "session.open 请求与 cold history fallback 不重复");
-// R-01-012/AC-16 模型目录订阅：store 推送更新、只订阅不 load、随可见性/卸载清理
+// R-01-012/AC-16 模型目录订阅：store 推送更新、随可见性/卸载清理；dsh 0.1.5 起目录
+// store 惰性加载，订阅后补一次一次性 load（C-024 的 generation 竞争以最新操作胜出）
 assert.ok(bundle.includes('ctx.get("modelDirectories")'), "模型实时选择来自原生 modelDirectories 服务（可选软依赖）");
 assert.ok(bundle.includes("directory.store.subscribe"), "订阅目录 store 推送模型选择变更");
-assert.ok(!bundle.includes("directory.load("), "不调用目录 load()，不与 select() 竞争 generation（C-024）");
+assert.ok(bundle.includes("directory.load"), "目录 store 一次性 load：0.1.5 惰性加载下不 load 不产出当前选择");
 assert.ok(bundle.includes("pruneSubscriptions(modelDirectorySubs, visibleIds)"), "模型目录订阅随可见性先 unsubscribe 再除名");
 assert.ok(bundle.includes("pruneSubscriptions(modelDirectorySubs, new Set())"), "卸载时模型目录订阅整体退订归零");
 assert.ok(bundle.includes("detail.modelLive"), "目录订阅已产值时晚到的一次性 RPC 不回写旧值");
 assert.ok(!bundle.includes("events.mux"), "不常驻全局 mux，当前会话使用原生 session subscribe");
 assert.ok(
-	bundle.includes('return [head, row, makeEl("div", "dap-trace"), progressRow, statsRow];'),
+	bundle.includes('return [head, row, makeEl("div", "dap-trace"), progressRow, makeStatsRow()];'),
 	"running 卡 token 统计骨架位于进度条骨架之后",
 );
 assert.ok(
@@ -3353,12 +3747,21 @@ assert.ok(
 	!bundle.includes("ctx.get(\"dsh-answer-pet\")"),
 	"不得以服务方式依赖第三方宠物插件",
 );
-// R-02-004/AC-02（演进，C-030）：完成确认写回是唯一 HTTP 请求——自家宿主侧路由、
-// 用户操作触发的一次性 POST，非状态轮询；轮内状态仍只来自原生订阅推送与 SSE 推送。
-// fetch 唯一性由下条断言钉住：轮询需要重复请求，唯一 fetch 即排除轮询形态。
+// R-02-004/AC-02（演进，C-030、C-074）：HTTP 请求仅两处——完成确认写回（用户操作触发的
+// 一次性 POST）与累计运行时长懒回填触发（每会话至多一次的一次性 GET，随可见会话触发），
+// 均非状态轮询；轮内状态与回合统计仍只来自原生订阅推送与 SSE 推送。
+// fetch/EventSource 数量由下两条断言钉住：轮询需要重复请求，受限的调用面即排除轮询形态。
+assert.ok(
+	(bundle.match(/fetch\(/g) ?? []).length === 2
+		&& bundle.includes("fetch(`${PANE_API_BASE}/ack`")
+		&& bundle.includes("fetch(`${PANE_API_BASE}/busy?ids="),
+	"HTTP 请求仅完成确认写回与 busy 懒回填触发两处，指向宿主侧自家路由（R-01-002/AC-10、R-01-020、C-030、C-074）",
+);
 assert.ok(
-	(bundle.match(/fetch\(/g) ?? []).length === 1 && bundle.includes("fetch(`${ACK_API_BASE}/ack`"),
-	"唯一的 fetch 调用是完成确认写回，指向宿主侧自家路由（R-01-002/AC-10、C-030）",
+	(bundle.match(/new window\.EventSource\(/g) ?? []).length === 2
+		&& bundle.includes("${PANE_API_BASE}/acks/stream")
+		&& bundle.includes("${PANE_API_BASE}/busy/stream"),
+	"SSE 订阅仅 acks 与 busy 两条通道，均连接即收全量快照（C-030、C-074）",
 );
 
 // ---- R-02-003/AC-02 卸载时清理注入元素、样式与监听 ----
@@ -3459,9 +3862,9 @@ assert.ok(bundle.includes("dataset.traceKey"), "同一流程节点复用 DOM，
 assert.ok(!bundle.includes(".dap-trace-item[data-status=\"running\"]::before {\n    animation: none !important;"), "降低动效设置不关闭运行点脉冲");
 
 // R-01-013/AC-09
-// 最近历史卡标题降为常规字重（不加粗），活动卡标题保持加粗。
-assert.ok(bundle.includes('[data-kind="recent"] .dap-title {\n  font-weight: 400;'), "最近历史卡标题使用常规字重（不加粗）");
-assert.ok(bundle.includes("white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 700;"), "活动卡标题保持加粗 700");
+// 全部会话卡标题（活动卡、子代理卡、最近卡）统一常规字重（不加粗），无按卡类覆盖。
+assert.ok(bundle.includes("white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 400;"), "会话卡标题使用常规字重（不加粗）");
+assert.ok(!bundle.includes('[data-kind="recent"] .dap-title {'), "最近卡标题不再有独立字重覆盖（与活动卡共用常规字重）");
 
 // R-01-013/AC-10
 // 最近历史卡整体不透明度低于活动卡，弱化历史区视觉强调。
@@ -3872,6 +4275,63 @@ assert.ok(
 	"等待当前卡重声明蓝色描边与光晕（组合选择器压过等待态橙色）",
 );
 
+// ---- R-01-012/AC-17～AC-18、R-01-009/AC-14～AC-15 子代理卡模型/进度/统计契约 ----
+// 子代理模型经既有 history 溯源提取（models RPC 对子代理被宿主 agent-busy 拒绝）。
+assert.ok(bundle.includes("modelFromHistoryEvents") && bundle.includes("chatLatestAssistantSettled"), "子代理模型溯源提取与触发信号进入 bundle（R-01-012/AC-17）");
+assert.ok(
+	clientSource.includes("if (planSubagentModelRead) {") && clientSource.includes("detail.modelReadDone = true;"),
+	"history 读取落地时为子代理提取模型溯源并记账每次可见期单次尝试（R-01-012/AC-17）",
+);
+assert.ok(
+	clientSource.includes("chatLatestAssistantSettled(detailSnapshot)"),
+	"模型读取时机锚定已定案助手行或非运行状态（R-01-012/AC-17）",
+);
+assert.ok(
+	clientSource.includes("entry.kind === \"subagent\" && historyLoads.has(entry.id)"),
+	"子代理溯源读取在途时模型区显示加载指示（R-01-014/AC-02、R-01-012/AC-17）",
+);
+// 溯源 id → 显示名：目录分组经主会话既有两条到达路径就地收割，渲染时对子代理条目解析。
+assert.ok(
+	clientSource.includes("const catalogEntries = Object.create(null);"),
+	"目录条目索引为无原型对象，模型 id 恰为继承键名时不得穿透回退（R-01-012/AC-17）",
+);
+assert.ok(
+	clientSource.includes("harvestCatalog(snap.groups);") &&
+		clientSource.includes("harvestCatalog(value.groups);"),
+	"目录分组在 store 订阅与一次性 modelCatalog 两条到达路径就地收割（R-01-012/AC-17）",
+);
+assert.ok(
+	clientSource.includes("detail.model.reasoning = reasoningEffortFromHistoryEvents(events) ?? \"\";"),
+	"子代理 history 落地时折叠最新请求头 effort（R-01-012/AC-17）",
+);
+assert.ok(
+	clientSource.includes("if (catalogEntry?.name) entry.model = catalogEntry.name;") &&
+		clientSource.includes("if (!entry.reasoning && catalogEntry?.reasoning) entry.reasoning = catalogEntry.reasoning;"),
+	"渲染时子代理溯源 id 经目录解析为显示名与 effort 回退，未覆盖保留原始（R-01-012/AC-17、AC-18）",
+);
+// 运行中子代理卡与主会话运行卡同构：进度行 + 统计行进骨架，渲染按同一锚点与曲线。
+assert.ok(
+	clientSource.includes("return [row, makeEl(\"div\", \"dap-subtrace\"), progressRow, makeStatsRow()];") &&
+		clientSource.includes("row.append(makeEl(\"span\", \"dap-dot\"), makeEl(\"span\", \"dap-title\"), model, makeEl(\"span\", \"dap-total-time\"));"),
+	"子代理卡骨架：模型名入标题行右侧，进度行与统计行承载（R-01-009/AC-14、R-01-012/AC-17）",
+);
+assert.ok(
+	clientSource.includes("progressOf({ elapsedMs, halfLifeSec: progressHalfLifeSec({ rateTokS: projectionStats.rateTokS }) })"),
+	"运行中子代理卡按与运行卡相同的锚点口径现算进度（R-01-009/AC-14）",
+);
+assert.ok(
+	clientSource.includes("entry.kind === \"subagent\" && runLikeIds.has(entry.id)"),
+	"运行卡时钟条件纳入运行中子代理卡（R-01-009/AC-14）",
+);
+// 非运行子代理卡：进度条整行隐藏、统计与最近回合耗时冻结。
+assert.ok(
+	clientSource.includes("} else if (!progressRow.hidden) {") && clientSource.includes("progressRow.hidden = true;"),
+	"锚点空闲时子代理卡进度行整行隐藏（R-01-009/AC-15）",
+);
+assert.ok(
+	clientSource.includes("entry.progress = null;") && bundle.includes("[data-dsh-activity-pane] .dap-progress[hidden] { display: none; }"),
+	"非运行子代理卡冻结统计并隐藏进度行（R-01-009/AC-15）",
+);
 
 // ---- R-01-002/AC-10～AC-12 宿主侧完成确认契约（C-030）----
 // R-01-002/AC-12 刷新/重连恢复：状态由宿主侧持久化承载，不依赖客户端在线观测。
@@ -3887,6 +4347,14 @@ assert.ok(hostSource.includes("const API_PATH = '/dsh-activity-pane/api'") && ho
 assert.ok(hostSource.includes("'/acks/stream'") && hostSource.includes("text/event-stream"), "SSE 推送通道（AC-11、AC-12）");
 assert.ok(hostSource.includes("'/ack'") && hostSource.includes("ackedAt: Date.now()"), "ack 写回路由（AC-10～AC-12）");
 assert.ok(hostSource.includes("streamClients") && hostSource.includes("for (const res of streamClients)"), "SSE 连接集合随卸载全数关闭");
+assert.ok(
+	hostSource.includes("ctx.connection?.requestRejection?.(req)") && hostSource.includes("res.end('unauthorized')"),
+	"自定义 webServer 路由经 connection.requestRejection 鉴权门（A1-08：不继承宿主鉴权，acks/busy 读写通道不得裸奔）",
+);
+assert.ok(
+	bundle.includes("} else if (nextSeat !== seat) {") && bundle.includes("流式观察者换绑到新节点"),
+	"宿主原地替换槽容器时流式观察者换绑到新节点，不留已分离旧节点（借鉴 -mig 并行实现）",
+);
 
 
 // ---- E2E runner 浏览器生命周期契约（C-046、C-047，T-085）----