dsh-activity-pane 0.8.0 → 0.9.0

package/.dsh-plugin/client.js

@@ -1985,58 +1985,30 @@ function durationTime(value) {
 	return Number.isFinite(time) ? time : null;
 }
 
-/** 从 history 提取最近完整回合的结束时刻与固定耗时；两者始终来自同一回合。 */
-function lastTurnDurationCandidateFromEvents(events) {
-	const starts = new Map();
+/**
+ * 从 history 重放回合/等待边界事件，提取最近一个已结束回合的运行过程耗时（busy 口径：
+ * 起止差值扣除回合内阻塞等待，与 R-01-020 累计口径一致，恒不大于该回合墙钟时长）。
+ * 回合起止不完整、时间逆序或回合运行段不为正时忽略该回合；无可得回合返回 null。
+ */
+function lastTurnBusyFromEvents(events) {
+	let state = emptyTurnStats();
 	let latest = null;
 	for (const entry of Array.isArray(events) ? events : []) {
-		const event = eventOf(entry);
-		const turn = Number(event?.data?.turn);
-		const time = durationTime(event?.time);
-		if (!Number.isFinite(turn) || time === null) continue;
-		if (event.type === "turn/start") {
-			starts.set(turn, time);
-			continue;
-		}
-		if (event.type !== "turn/end") continue;
-		const start = starts.get(turn);
-		if (start === undefined || time < start) continue;
-		if (latest === null || time > latest.end) latest = { end: time, duration: time - start };
-	}
-	return latest;
-}
-
-/** 从 turnTimings 提取最近完整回合的结束时刻与固定耗时；两者始终来自同一回合。 */
-function lastTurnDurationCandidateFromTimings(turnTimings) {
-	if (!(turnTimings instanceof Map)) return null;
-	let latest = null;
-	for (const timing of turnTimings.values()) {
-		const start = durationTime(timing?.startTime);
-		const end = durationTime(timing?.endTime);
-		if (start === null || end === null || end < start) continue;
-		if (latest === null || end > latest.end) latest = { end, duration: end - start };
+		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;
-}
-
-/** 从 history 提取最近完整回合的固定耗时；回合起止不完整或逆序时忽略该回合。 */
-function lastTurnDurationFromEvents(events) {
-	return lastTurnDurationCandidateFromEvents(events)?.duration ?? null;
+	return latest?.duration ?? null;
 }
 
-/** 从 turnTimings 提取最近完整回合的固定耗时；全部回合未结束或无效时返回 null。 */
-function lastTurnDurationFromTimings(turnTimings) {
-	return lastTurnDurationCandidateFromTimings(turnTimings)?.duration ?? null;
-}
-
-/** 在快照与 history 中按最近结束时刻选择同一最新完整回合的固定耗时。 */
-function lastTurnDuration({ turnTimings = null, history = [] } = {}) {
-	const candidates = [lastTurnDurationCandidateFromTimings(turnTimings), lastTurnDurationCandidateFromEvents(history)].filter(Boolean);
-	let latest = null;
-	for (const candidate of candidates) {
-		if (latest === null || candidate.end > latest.end) latest = candidate;
-	}
-	return latest?.duration ?? null;
+/** 最近完整回合的固定耗时（busy 口径）：从 history 事件重放派生。 */
+function lastTurnDuration({ history = [] } = {}) {
+	return lastTurnBusyFromEvents(history);
 }
 
 /** ask_user_question 工具名：提问/计划审查等待的开启边界（tool/call）与配对结算（tool/result）。 */
@@ -2052,7 +2024,7 @@ function isBusyBoundaryEvent(type) {
 
 /** 空记账状态（无任何有效计时）。 */
 function emptyTurnStats() {
-	return { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null };
+	return { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null, watermarkTime: null };
 }
 
 /** 从任意来源拷贝记账状态：缺失字段归一为 null（旧记录/部分记录兼容）。 */
@@ -2064,10 +2036,14 @@ function turnStatsFrom(state) {
 		openWaitKind: state?.openWaitKind ?? null,
 		openWaitId: state?.openWaitId ?? null,
 		waitedMs: state?.waitedMs ?? null,
+		watermarkTime: state?.watermarkTime ?? null,
 	};
 }
 
-/** 记账状态逐字段相等（不含 watermarkSeq——宿主侧无效果事件跳过落盘的判定）。 */
+/**
+ * 记账状态逐字段相等（不含 watermarkSeq——它不是状态字段，由宿主侧随写入一并落盘；
+ * watermarkTime 为水位处已覆盖事件的时刻，参与相等判定以让补写该字段的收敛写入生效）。
+ */
 function turnStatsEqual(a, b) {
 	return (
 		a === b ||
@@ -2076,7 +2052,8 @@ function turnStatsEqual(a, b) {
 			(a?.openWaitStart ?? null) === (b?.openWaitStart ?? null) &&
 			(a?.openWaitKind ?? null) === (b?.openWaitKind ?? null) &&
 			(a?.openWaitId ?? null) === (b?.openWaitId ?? null) &&
-			(a?.waitedMs ?? null) === (b?.waitedMs ?? null))
+			(a?.waitedMs ?? null) === (b?.waitedMs ?? null) &&
+			(a?.watermarkTime ?? null) === (b?.watermarkTime ?? null))
 	);
 }
 
@@ -2198,15 +2175,18 @@ function totalBusyDisplayMs({ busyMs = null, openTurnStart = null, waitedMs = nu
 
 /**
  * 回合统计记账的统一收敛（R-01-020/AC-04、AC-05）：对全会话事件列表重放出下一份
- * 记账，宿主侧懒回填与启动扫描共用。路径选择——无记录、持久化水位非法、或水位
- * 超前于日志最大 seq（事件 seq 空间被重编，如 dsh 0.1.5 V3 迁移）时从空状态全量
- * 重放（超前水位会把后续全部实时事件封死在守卫之外，openTurnStart 永不清空、总
- * 耗时无限增长）；否则从持久化记账出发仅增量应用 `seq > watermarkSeq` 的事件。
+ * 记账，宿主侧懒回填与启动扫描共用。路径选择——无记录、强制重放、持久化水位非法、
+ * 或水位超前于日志最大 seq（事件 seq 空间被重编，如 dsh 0.1.5 V3 迁移）时从空状态
+ * 全量重放（超前水位会把后续全部实时事件封死在守卫之外，openTurnStart 永不清空、
+ * 总耗时无限增长）；否则从持久化记账出发仅增量应用 `seq > watermarkSeq` 的事件。
+ * 水位推进处同步记录 `watermarkTime`（水位处已覆盖事件的时刻，与实时登记按效果事件
+ * 写入的口径互为保守——检测只要求该值不超过真实边界事件时刻）——宿主实时登记据此
+ * 识别 seq 空间重编（低 seq 事件携带比水位更新的时刻，增量口径已失效）。
  * `closeOpenTurn`（宿主启动扫描）：重放后仍存在的开放回合按日志最后事件时刻强制
  * 结算关闭——宿主重启后不存在仍在运行的回合，残留起点只会令总耗时无限增长；尾部
  * 未配对等待一并按同刻结算（不落到运行时长里）。
  */
-function reconcileTurnStats(current, records, { closeOpenTurn = false } = {}) {
+function reconcileTurnStats(current, records, { closeOpenTurn = false, forceFresh = false } = {}) {
 	const list = Array.isArray(records) ? records : [];
 	let maxSeq = null;
 	let lastTime = null;
@@ -2216,23 +2196,32 @@ function reconcileTurnStats(current, records, { closeOpenTurn = false } = {}) {
 		const time = durationTime(eventOf(record)?.time);
 		if (time !== null && (lastTime === null || time > lastTime)) lastTime = time;
 	}
-	const fresh = !isRecord(current) || !Number.isFinite(current.watermarkSeq) || (maxSeq !== null && Number(current.watermarkSeq) > maxSeq);
+	const fresh = forceFresh || !isRecord(current) || !Number.isFinite(current.watermarkSeq) || (maxSeq !== null && Number(current.watermarkSeq) > maxSeq);
 	let state = emptyTurnStats();
 	let watermarkSeq = null;
+	let watermarkTime = null;
+	// 水位推进：seq 更大即前推水位；事件时刻有效才更新 watermarkTime（无效不前推）。
+	const advance = (record) => {
+		const seq = Number(record?.seq);
+		if (!Number.isFinite(seq) || (watermarkSeq !== null && seq <= watermarkSeq)) return;
+		watermarkSeq = seq;
+		const time = durationTime(eventOf(record)?.time);
+		if (time !== null) watermarkTime = time;
+	};
 	if (fresh) {
 		for (const record of list) {
 			state = applyTurnEventToStats(state, record);
-			const seq = Number(record?.seq);
-			if (Number.isFinite(seq) && (watermarkSeq === null || seq > watermarkSeq)) watermarkSeq = seq;
+			advance(record);
 		}
 	} else {
 		state = turnStatsFrom(current);
+		watermarkTime = state.watermarkTime;
 		watermarkSeq = Number(current.watermarkSeq);
 		for (const record of list) {
 			const seq = Number(record?.seq);
 			if (!Number.isFinite(seq) || seq <= watermarkSeq) continue;
 			state = applyTurnEventToStats(state, record);
-			watermarkSeq = seq;
+			advance(record);
 		}
 	}
 	if (closeOpenTurn && state.openTurnStart !== null) {
@@ -2245,7 +2234,7 @@ function reconcileTurnStats(current, records, { closeOpenTurn = false } = {}) {
 		state.openWaitId = null;
 		state.waitedMs = null;
 	}
-	return { ...state, watermarkSeq };
+	return { ...state, watermarkSeq, watermarkTime };
 }
 
 /**
@@ -3035,9 +3024,11 @@ const CSS = `
   box-shadow: none;
   animation: none;
 }
+/* 会话卡标题（活动卡、子代理卡与最近卡共用 .dap-title）统一常规字重，不加粗
+   （R-01-013/AC-09 及东家 2026-09-11 视觉反馈）；无按卡类的字重覆盖。 */
 [data-dsh-activity-pane] .dap-title {
   flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis;
-  white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 700;
+  white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 400;
 }
 /* 标题行最右侧的累计运行时长（R-01-020/AC-01）：固定占位不参与标题挤压，
    标题过长时以自身省略号让位；色调弱于标题，不与状态点抢视觉。 */
@@ -3046,10 +3037,6 @@ const CSS = `
   color: #8a94a3; white-space: nowrap;
 }
 [data-dsh-activity-pane] .dap-total-time[hidden] { display: none; }
-/* 最近历史卡标题降为常规字重：历史区不抢占视觉强调（R-01-013/AC-09）。 */
-[data-dsh-activity-pane] .dap-card[data-kind="recent"] .dap-title {
-  font-weight: 400;
-}
 /* 等待卡末行首行「类型胶囊」（R-01-002/AC-01、AC-02、AC-09、AC-13，C-043）：圆底类型
    图标 + 类型文字，色相随等待类别（--dap-wait-color）——阻塞金/完成绿/错误红；
    胶囊为行内元素不自占满宽，随文字内容收缩。 */
@@ -5055,13 +5042,14 @@ function apply(ctx) {
 		}
 	}
 
-	/** 最近回合耗时 memo（等待卡与暂停子代理卡共用，R-01-009/AC-12、AC-15）：快照/历史引用不变即命中缓存。 */
-	function memoTurnDuration(detail, detailSnapshot) {
+	/** 最近回合耗时 memo（等待卡与暂停子代理卡共用，R-01-009/AC-12、AC-15）：history 引用
+	 *  不变即命中缓存。busy 口径（起止差值扣除回合内阻塞等待），与标题行总耗时同口径，
+	 *  保证恒不大于累计值（R-01-020）。 */
+	function memoTurnDuration(detail) {
 		const history = detail.history ?? null;
-		if (detail.memoTurnDurationSnapshotOf !== detailSnapshot || detail.memoTurnDurationHistoryOf !== history) {
-			detail.memoTurnDurationSnapshotOf = detailSnapshot;
+		if (detail.memoTurnDurationHistoryOf !== history) {
 			detail.memoTurnDurationHistoryOf = history;
-			detail.memoTurnDuration = lastTurnDuration({ turnTimings: detailSnapshot?.turnTimings, history });
+			detail.memoTurnDuration = lastTurnDuration({ history });
 		}
 		return detail.memoTurnDuration ?? null;
 	}
@@ -5966,7 +5954,7 @@ function apply(ctx) {
 				}
 			}
 			if (entry.kind === "awaiting" && detail) {
-				entry.elapsedMs = memoTurnDuration(detail, detailSnapshot);
+				entry.elapsedMs = memoTurnDuration(detail);
 			}
 			if (detail?.model) {
 				entry.model = detail.model.model;
@@ -6038,7 +6026,7 @@ function apply(ctx) {
 					// 非运行（暂停等待）：冻结最后已知统计与最近回合耗时，progress 置空隐藏
 					// 进度条（R-01-009/AC-15）；刷新/无留存时回退当前列表投影。
 					Object.assign(entry, mergeRuntimeStats(detail?.lastRuntimeStats, projectionStats));
-					entry.elapsedMs = detail ? memoTurnDuration(detail, detailSnapshot) : null;
+					entry.elapsedMs = detail ? memoTurnDuration(detail) : null;
 					entry.progress = null;
 				}
 			}
@@ -6061,13 +6049,13 @@ function apply(ctx) {
 		recentTotal = recentCandidates.length;
 		const recent = recentCandidates.slice(0, recentVisibleCount);
 		recentHasMore = recent.length < recentTotal;
-		// 最近卡统计复用运行卡的列表投影口径；耗时从保留快照或已读 history 取最近完整回合，
-		// 缺边界时仅为当前可见历史卡安排一次既有 history 补读（R-01-013/AC-12）。
+		// 最近卡统计复用运行卡的列表投影口径；耗时从已读 history 取最近完整回合的运行
+		// 过程时长（busy 口径，与标题行总耗时一致，R-01-013/AC-12），缺边界时仅为当前
+		// 可见历史卡安排一次既有 history 补读。
 		const recentDurationFallbackIds = new Set();
 		for (const entry of recent) {
 			const detail = sessionDetailsById.get(entry.id);
-			const detailSnapshot = livenessById.get(entry.id)?.snapshot ?? detail?.snapshot ?? null;
-			const elapsedMs = lastTurnDuration({ turnTimings: detailSnapshot?.turnTimings, history: detail?.history });
+			const elapsedMs = lastTurnDuration({ history: detail?.history ?? null });
 			// 累计运行时长（R-01-020/AC-01）：最近历史卡同为标题行右侧显示；历史卡无开放回合。
 			applyTotalBusy(entry, now);
 			const stats = statsFromProjection(snapshot?.byId?.[entry.id]?.projectionValues, elapsedMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-activity-pane",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "packageManager": "pnpm@11.5.0",
   "engines": {
     "node": ">=20"

package/scripts/acceptance.mjs

@@ -139,8 +139,8 @@ const steps = [
 	"找一个发指令后 agent 运行了较久才结束的会话，待其落入最近历史区后，确认卡片第五行同时显示本地绝对日期时间（跨年份带年份）与相对活动时间，且绝对时间对应最后回复结束时刻（而非发指令时刻）；历史区仍按该时刻从新到旧排序。刷新页面（冷会话）后确认时间先按宿主列表时间显示、数据到达后精化为回复结束时刻，相对时间会按分钟级推进。",
 	// R-01-013/AC-12 最近历史卡保留最近回合统计
 	"让一个已有完整回合的会话结束并经「移入历史」进入最近历史区，确认助手预览行之后、活动时间之前的倒数第二行仍显示最后回合的「tok/s · 缓存 · 输入 · 输出」可用统计，耗时固定在该行最右侧；缺失字段不造假且全部为空时不留空行。刷新页面后确认可从 native 列表投影与回合边界恢复。",
-	// R-01-013/AC-09 最近卡标题常规字重
-	"确认最近历史卡的会话标题为常规字重（不加粗），与活动卡的加粗标题形成明显区分。",
+	// R-01-013/AC-09 会话卡标题统一常规字重
+	"确认活动卡与最近历史卡的会话标题均为常规字重（不加粗）。",
 	// R-01-013/AC-10 最近卡整体淡化
 	"确认最近历史卡整体比活动卡明显更淡（不透明度更低），悬停时仍有高亮反馈。",
 	// R-01-013/AC-11 最近卡轮廓可辨

package/scripts/check.mjs

@@ -58,8 +58,7 @@ import {
 	catalogModelEntries,
 	lastTurnEndFromEvents,
 	lastTurnEndFromTimings,
-	lastTurnDurationFromEvents,
-	lastTurnDurationFromTimings,
+	lastTurnBusyFromEvents,
 	lastTurnDuration,
 	applyTurnEventToStats,
 	reconcileTurnStats,
@@ -1366,6 +1365,50 @@ assert.equal(normalizeBusyMs(Number.NaN), null, "NaN 归一为 null");
 	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;
@@ -2824,67 +2867,64 @@ assert.equal(
 	2500,
 	"turnTimings 取最大 endTime，忽略未结束回合",
 );
-// ---- R-01-009/AC-12 等待卡保留最近完整回合耗时 ----
+// ---- R-01-009/AC-12 等待卡保留最近完整回合耗时（busy 口径，R-01-020 语义） ----
 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 不生成等待耗时");
-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 } } },
@@ -2892,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: {
@@ -3836,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
 // 最近历史卡整体不透明度低于活动卡，弱化历史区视觉强调。

package/src/client.mjs

@@ -437,9 +437,11 @@ const CSS = `
   box-shadow: none;
   animation: none;
 }
+/* 会话卡标题（活动卡、子代理卡与最近卡共用 .dap-title）统一常规字重，不加粗
+   （R-01-013/AC-09 及东家 2026-09-11 视觉反馈）；无按卡类的字重覆盖。 */
 [data-dsh-activity-pane] .dap-title {
   flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis;
-  white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 700;
+  white-space: nowrap; font-size: 12px; line-height: 16px; font-weight: 400;
 }
 /* 标题行最右侧的累计运行时长（R-01-020/AC-01）：固定占位不参与标题挤压，
    标题过长时以自身省略号让位；色调弱于标题，不与状态点抢视觉。 */
@@ -448,10 +450,6 @@ const CSS = `
   color: #8a94a3; white-space: nowrap;
 }
 [data-dsh-activity-pane] .dap-total-time[hidden] { display: none; }
-/* 最近历史卡标题降为常规字重：历史区不抢占视觉强调（R-01-013/AC-09）。 */
-[data-dsh-activity-pane] .dap-card[data-kind="recent"] .dap-title {
-  font-weight: 400;
-}
 /* 等待卡末行首行「类型胶囊」（R-01-002/AC-01、AC-02、AC-09、AC-13，C-043）：圆底类型
    图标 + 类型文字，色相随等待类别（--dap-wait-color）——阻塞金/完成绿/错误红；
    胶囊为行内元素不自占满宽，随文字内容收缩。 */
@@ -2457,13 +2455,14 @@ function apply(ctx) {
 		}
 	}
 
-	/** 最近回合耗时 memo（等待卡与暂停子代理卡共用，R-01-009/AC-12、AC-15）：快照/历史引用不变即命中缓存。 */
-	function memoTurnDuration(detail, detailSnapshot) {
+	/** 最近回合耗时 memo（等待卡与暂停子代理卡共用，R-01-009/AC-12、AC-15）：history 引用
+	 *  不变即命中缓存。busy 口径（起止差值扣除回合内阻塞等待），与标题行总耗时同口径，
+	 *  保证恒不大于累计值（R-01-020）。 */
+	function memoTurnDuration(detail) {
 		const history = detail.history ?? null;
-		if (detail.memoTurnDurationSnapshotOf !== detailSnapshot || detail.memoTurnDurationHistoryOf !== history) {
-			detail.memoTurnDurationSnapshotOf = detailSnapshot;
+		if (detail.memoTurnDurationHistoryOf !== history) {
 			detail.memoTurnDurationHistoryOf = history;
-			detail.memoTurnDuration = lastTurnDuration({ turnTimings: detailSnapshot?.turnTimings, history });
+			detail.memoTurnDuration = lastTurnDuration({ history });
 		}
 		return detail.memoTurnDuration ?? null;
 	}
@@ -3368,7 +3367,7 @@ function apply(ctx) {
 				}
 			}
 			if (entry.kind === "awaiting" && detail) {
-				entry.elapsedMs = memoTurnDuration(detail, detailSnapshot);
+				entry.elapsedMs = memoTurnDuration(detail);
 			}
 			if (detail?.model) {
 				entry.model = detail.model.model;
@@ -3440,7 +3439,7 @@ function apply(ctx) {
 					// 非运行（暂停等待）：冻结最后已知统计与最近回合耗时，progress 置空隐藏
 					// 进度条（R-01-009/AC-15）；刷新/无留存时回退当前列表投影。
 					Object.assign(entry, mergeRuntimeStats(detail?.lastRuntimeStats, projectionStats));
-					entry.elapsedMs = detail ? memoTurnDuration(detail, detailSnapshot) : null;
+					entry.elapsedMs = detail ? memoTurnDuration(detail) : null;
 					entry.progress = null;
 				}
 			}
@@ -3463,13 +3462,13 @@ function apply(ctx) {
 		recentTotal = recentCandidates.length;
 		const recent = recentCandidates.slice(0, recentVisibleCount);
 		recentHasMore = recent.length < recentTotal;
-		// 最近卡统计复用运行卡的列表投影口径；耗时从保留快照或已读 history 取最近完整回合，
-		// 缺边界时仅为当前可见历史卡安排一次既有 history 补读（R-01-013/AC-12）。
+		// 最近卡统计复用运行卡的列表投影口径；耗时从已读 history 取最近完整回合的运行
+		// 过程时长（busy 口径，与标题行总耗时一致，R-01-013/AC-12），缺边界时仅为当前
+		// 可见历史卡安排一次既有 history 补读。
 		const recentDurationFallbackIds = new Set();
 		for (const entry of recent) {
 			const detail = sessionDetailsById.get(entry.id);
-			const detailSnapshot = livenessById.get(entry.id)?.snapshot ?? detail?.snapshot ?? null;
-			const elapsedMs = lastTurnDuration({ turnTimings: detailSnapshot?.turnTimings, history: detail?.history });
+			const elapsedMs = lastTurnDuration({ history: detail?.history ?? null });
 			// 累计运行时长（R-01-020/AC-01）：最近历史卡同为标题行右侧显示；历史卡无开放回合。
 			applyTotalBusy(entry, now);
 			const stats = statsFromProjection(snapshot?.byId?.[entry.id]?.projectionValues, elapsedMs);

package/src/core.mjs

@@ -1979,58 +1979,30 @@ function durationTime(value) {
 	return Number.isFinite(time) ? time : null;
 }
 
-/** 从 history 提取最近完整回合的结束时刻与固定耗时；两者始终来自同一回合。 */
-function lastTurnDurationCandidateFromEvents(events) {
-	const starts = new Map();
+/**
+ * 从 history 重放回合/等待边界事件，提取最近一个已结束回合的运行过程耗时（busy 口径：
+ * 起止差值扣除回合内阻塞等待，与 R-01-020 累计口径一致，恒不大于该回合墙钟时长）。
+ * 回合起止不完整、时间逆序或回合运行段不为正时忽略该回合；无可得回合返回 null。
+ */
+export function lastTurnBusyFromEvents(events) {
+	let state = emptyTurnStats();
 	let latest = null;
 	for (const entry of Array.isArray(events) ? events : []) {
-		const event = eventOf(entry);
-		const turn = Number(event?.data?.turn);
-		const time = durationTime(event?.time);
-		if (!Number.isFinite(turn) || time === null) continue;
-		if (event.type === "turn/start") {
-			starts.set(turn, time);
-			continue;
-		}
-		if (event.type !== "turn/end") continue;
-		const start = starts.get(turn);
-		if (start === undefined || time < start) continue;
-		if (latest === null || time > latest.end) latest = { end: time, duration: time - start };
+		const time = durationTime(eventOf(entry)?.time);
+		const prev = state;
+		state = applyTurnEventToStats(state, entry);
+		if (prev.openTurnStart === null || state.openTurnStart !== null) continue;
+		// 能走到回合闭合的必为时刻有效的 turn/end（applyTurnEventToStats 对无效时刻无效果）。
+		const activeMs = (state.busyMs ?? 0) - (prev.busyMs ?? 0);
+		if (activeMs <= 0) continue;
+		latest = { end: time, duration: activeMs };
 	}
-	return latest;
-}
-
-/** 从 turnTimings 提取最近完整回合的结束时刻与固定耗时；两者始终来自同一回合。 */
-function lastTurnDurationCandidateFromTimings(turnTimings) {
-	if (!(turnTimings instanceof Map)) return null;
-	let latest = null;
-	for (const timing of turnTimings.values()) {
-		const start = durationTime(timing?.startTime);
-		const end = durationTime(timing?.endTime);
-		if (start === null || end === null || end < start) continue;
-		if (latest === null || end > latest.end) latest = { end, duration: end - start };
-	}
-	return latest;
-}
-
-/** 从 history 提取最近完整回合的固定耗时；回合起止不完整或逆序时忽略该回合。 */
-export function lastTurnDurationFromEvents(events) {
-	return lastTurnDurationCandidateFromEvents(events)?.duration ?? null;
-}
-
-/** 从 turnTimings 提取最近完整回合的固定耗时；全部回合未结束或无效时返回 null。 */
-export function lastTurnDurationFromTimings(turnTimings) {
-	return lastTurnDurationCandidateFromTimings(turnTimings)?.duration ?? null;
+	return latest?.duration ?? null;
 }
 
-/** 在快照与 history 中按最近结束时刻选择同一最新完整回合的固定耗时。 */
-export function lastTurnDuration({ turnTimings = null, history = [] } = {}) {
-	const candidates = [lastTurnDurationCandidateFromTimings(turnTimings), lastTurnDurationCandidateFromEvents(history)].filter(Boolean);
-	let latest = null;
-	for (const candidate of candidates) {
-		if (latest === null || candidate.end > latest.end) latest = candidate;
-	}
-	return latest?.duration ?? null;
+/** 最近完整回合的固定耗时（busy 口径）：从 history 事件重放派生。 */
+export function lastTurnDuration({ history = [] } = {}) {
+	return lastTurnBusyFromEvents(history);
 }
 
 /** ask_user_question 工具名：提问/计划审查等待的开启边界（tool/call）与配对结算（tool/result）。 */
@@ -2046,7 +2018,7 @@ export function isBusyBoundaryEvent(type) {
 
 /** 空记账状态（无任何有效计时）。 */
 export function emptyTurnStats() {
-	return { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null };
+	return { busyMs: null, openTurnStart: null, openWaitStart: null, openWaitKind: null, openWaitId: null, waitedMs: null, watermarkTime: null };
 }
 
 /** 从任意来源拷贝记账状态：缺失字段归一为 null（旧记录/部分记录兼容）。 */
@@ -2058,10 +2030,14 @@ export function turnStatsFrom(state) {
 		openWaitKind: state?.openWaitKind ?? null,
 		openWaitId: state?.openWaitId ?? null,
 		waitedMs: state?.waitedMs ?? null,
+		watermarkTime: state?.watermarkTime ?? null,
 	};
 }
 
-/** 记账状态逐字段相等（不含 watermarkSeq——宿主侧无效果事件跳过落盘的判定）。 */
+/**
+ * 记账状态逐字段相等（不含 watermarkSeq——它不是状态字段，由宿主侧随写入一并落盘；
+ * watermarkTime 为水位处已覆盖事件的时刻，参与相等判定以让补写该字段的收敛写入生效）。
+ */
 export function turnStatsEqual(a, b) {
 	return (
 		a === b ||
@@ -2070,7 +2046,8 @@ export function turnStatsEqual(a, b) {
 			(a?.openWaitStart ?? null) === (b?.openWaitStart ?? null) &&
 			(a?.openWaitKind ?? null) === (b?.openWaitKind ?? null) &&
 			(a?.openWaitId ?? null) === (b?.openWaitId ?? null) &&
-			(a?.waitedMs ?? null) === (b?.waitedMs ?? null))
+			(a?.waitedMs ?? null) === (b?.waitedMs ?? null) &&
+			(a?.watermarkTime ?? null) === (b?.watermarkTime ?? null))
 	);
 }
 
@@ -2192,15 +2169,18 @@ export function totalBusyDisplayMs({ busyMs = null, openTurnStart = null, waited
 
 /**
  * 回合统计记账的统一收敛（R-01-020/AC-04、AC-05）：对全会话事件列表重放出下一份
- * 记账，宿主侧懒回填与启动扫描共用。路径选择——无记录、持久化水位非法、或水位
- * 超前于日志最大 seq（事件 seq 空间被重编，如 dsh 0.1.5 V3 迁移）时从空状态全量
- * 重放（超前水位会把后续全部实时事件封死在守卫之外，openTurnStart 永不清空、总
- * 耗时无限增长）；否则从持久化记账出发仅增量应用 `seq > watermarkSeq` 的事件。
+ * 记账，宿主侧懒回填与启动扫描共用。路径选择——无记录、强制重放、持久化水位非法、
+ * 或水位超前于日志最大 seq（事件 seq 空间被重编，如 dsh 0.1.5 V3 迁移）时从空状态
+ * 全量重放（超前水位会把后续全部实时事件封死在守卫之外，openTurnStart 永不清空、
+ * 总耗时无限增长）；否则从持久化记账出发仅增量应用 `seq > watermarkSeq` 的事件。
+ * 水位推进处同步记录 `watermarkTime`（水位处已覆盖事件的时刻，与实时登记按效果事件
+ * 写入的口径互为保守——检测只要求该值不超过真实边界事件时刻）——宿主实时登记据此
+ * 识别 seq 空间重编（低 seq 事件携带比水位更新的时刻，增量口径已失效）。
  * `closeOpenTurn`（宿主启动扫描）：重放后仍存在的开放回合按日志最后事件时刻强制
  * 结算关闭——宿主重启后不存在仍在运行的回合，残留起点只会令总耗时无限增长；尾部
  * 未配对等待一并按同刻结算（不落到运行时长里）。
  */
-export function reconcileTurnStats(current, records, { closeOpenTurn = false } = {}) {
+export function reconcileTurnStats(current, records, { closeOpenTurn = false, forceFresh = false } = {}) {
 	const list = Array.isArray(records) ? records : [];
 	let maxSeq = null;
 	let lastTime = null;
@@ -2210,23 +2190,32 @@ export function reconcileTurnStats(current, records, { closeOpenTurn = false } =
 		const time = durationTime(eventOf(record)?.time);
 		if (time !== null && (lastTime === null || time > lastTime)) lastTime = time;
 	}
-	const fresh = !isRecord(current) || !Number.isFinite(current.watermarkSeq) || (maxSeq !== null && Number(current.watermarkSeq) > maxSeq);
+	const fresh = forceFresh || !isRecord(current) || !Number.isFinite(current.watermarkSeq) || (maxSeq !== null && Number(current.watermarkSeq) > maxSeq);
 	let state = emptyTurnStats();
 	let watermarkSeq = null;
+	let watermarkTime = null;
+	// 水位推进：seq 更大即前推水位；事件时刻有效才更新 watermarkTime（无效不前推）。
+	const advance = (record) => {
+		const seq = Number(record?.seq);
+		if (!Number.isFinite(seq) || (watermarkSeq !== null && seq <= watermarkSeq)) return;
+		watermarkSeq = seq;
+		const time = durationTime(eventOf(record)?.time);
+		if (time !== null) watermarkTime = time;
+	};
 	if (fresh) {
 		for (const record of list) {
 			state = applyTurnEventToStats(state, record);
-			const seq = Number(record?.seq);
-			if (Number.isFinite(seq) && (watermarkSeq === null || seq > watermarkSeq)) watermarkSeq = seq;
+			advance(record);
 		}
 	} else {
 		state = turnStatsFrom(current);
+		watermarkTime = state.watermarkTime;
 		watermarkSeq = Number(current.watermarkSeq);
 		for (const record of list) {
 			const seq = Number(record?.seq);
 			if (!Number.isFinite(seq) || seq <= watermarkSeq) continue;
 			state = applyTurnEventToStats(state, record);
-			watermarkSeq = seq;
+			advance(record);
 		}
 	}
 	if (closeOpenTurn && state.openTurnStart !== null) {
@@ -2239,7 +2228,7 @@ export function reconcileTurnStats(current, records, { closeOpenTurn = false } =
 		state.openWaitId = null;
 		state.waitedMs = null;
 	}
-	return { ...state, watermarkSeq };
+	return { ...state, watermarkSeq, watermarkTime };
 }
 
 /**

package/src/host.mjs

@@ -59,7 +59,9 @@ const domainSpec = defineDomain({
  *  openTurnStart 当前开放回合起点（无开放回合为 null）、openWaitStart/openWaitKind 当前
  *  未配对等待区间（回合内阻塞等待：approval/question）、waitedMs 本回合已配对等待时长
  *  累计、watermarkSeq 实时登记已覆盖的最大事件 seq（回填与实时登记以水位衔接，seq ≤
- *  watermark 的事件不重复应用）。全部字段可选/可空。 */
+ *  watermark 的事件不重复应用）、watermarkTime 水位处事件的时刻（实时登记据此识别 seq
+ *  空间重编：低 seq 事件携带比水位更新的时刻，增量口径失效，须全量重放）。全部字段
+ *  可选/可空。 */
 const turnStatRecord = z.object({
 	busyMs: z.number().nullable().optional(),
 	openTurnStart: z.number().nullable().optional(),
@@ -68,6 +70,7 @@ const turnStatRecord = z.object({
 	openWaitId: z.string().nullable().optional(),
 	waitedMs: z.number().nullable().optional(),
 	watermarkSeq: z.number().nullable().optional(),
+	watermarkTime: z.number().nullable().optional(),
 })
 
 /** 独立 domain：dsh-storage-domain 无迁移机制（version 不同在 open 时拒绝），新增表落新 domain，
@@ -122,8 +125,13 @@ export function apply(ctx) {
 		resolveDomain()
 		// 启动扫描（R-01-020/AC-04）：宿主重启后不存在仍在运行的回合——残留开放回合的
 		// 记账按日志最后事件时刻强制结算关闭，否则总耗时按 now − openTurnStart 无限增长。
+		// 无 watermarkTime 的存量记录（本字段引入前写入）强制全量重放复核一次——无论重编
+		// 后日志 seq 是否已超越旧水位（部分重叠重编）都能收敛，重写后带上该字段、不再
+		// 重复扫描；此后重编由实时登记的重编检测承接。
 		for (const [id, record] of turnStats.entries()) {
-			if (record?.openTurnStart != null) ensureTurnStatsFresh(id, { closeOpenTurn: true })
+			const closeOpenTurn = record?.openTurnStart != null
+			const legacy = record?.watermarkTime == null
+			if (closeOpenTurn || legacy) ensureTurnStatsFresh(id, { closeOpenTurn, forceFresh: legacy })
 		}
 	})
 
@@ -159,10 +167,17 @@ export function apply(ctx) {
 	 *  reconcileTurnStats 收敛——无记录、水位非法或水位超前于日志最大 seq（事件 seq 空间
 	 *  被重编，如 dsh 0.1.5 V3 迁移）的会话自空状态全量重放；已有记录会话仅增量应用
 	 *  seq > watermarkSeq 的事件（宿主离线期间经其它入口发生的回合），以水位衔接保证
-	 *  不重复、不遗漏。closeOpenTurn（启动扫描）：重放后仍开放的回合按日志最后事件
-	 *  时刻强制结算。读取失败保留已有记账，随下次请求重试；会话不存在/已删除时静默跳过。 */
-	function ensureTurnStatsFresh(id, { closeOpenTurn = false } = {}) {
-		if (backfills.has(id)) return backfills.get(id)
+	 *  不重复、不遗漏。forceFresh：调用侧已证实水位口径失效（实时登记识别出 seq 空间
+	 *  重编，或存量记录尚未携带 watermarkTime）时丢弃已有记账、强制从空状态全量重放；
+	 *  在途回填不得吞掉该选项——命中时在其完成后补一次强制重放。closeOpenTurn（启动
+	 *  扫描）：重放后仍开放的回合按日志最后事件时刻强制结算。读取失败保留已有记账，
+	 * 随下次请求重试；会话不存在/已删除时静默跳过。 */
+	function ensureTurnStatsFresh(id, { closeOpenTurn = false, forceFresh = false } = {}) {
+		if (backfills.has(id)) {
+			const inflight = backfills.get(id)
+			if (!forceFresh) return inflight
+			return inflight.then(() => ensureTurnStatsFresh(id, { closeOpenTurn, forceFresh: true }))
+		}
 		const promise = new Promise((resolve) => {
 			ctx.inject(['sessionQuery'], (sessionQuery) => {
 				resolve(sessionQuery)
@@ -170,13 +185,16 @@ export function apply(ctx) {
 		}).then(async (sessionQuery) => {
 			try {
 				await domainReady
-				const current = turnStats.get(id) ?? null
+				const current = forceFresh ? null : turnStats.get(id) ?? null
 				const records = await sessionQuery.listEvents(id)
 				const next = reconcileTurnStats(current, Array.isArray(records) ? records : [], { closeOpenTurn })
 				const changed =
-					current === null || next.watermarkSeq !== (current.watermarkSeq ?? null) || !turnStatsEqual(next, current)
+					forceFresh ||
+					current === null ||
+					next.watermarkSeq !== (current.watermarkSeq ?? null) ||
+					!turnStatsEqual(next, current)
 				if (changed) {
-					await turnStats.put(id, { ...turnStatsFrom(next), watermarkSeq: next.watermarkSeq })
+					await turnStats.put(id, { ...turnStatsFrom(next), watermarkSeq: next.watermarkSeq, watermarkTime: next.watermarkTime })
 					broadcastBusy()
 				}
 			} catch (error) {
@@ -265,15 +283,31 @@ export function apply(ctx) {
 				const inflight = backfills.get(id)
 				if (inflight) await inflight
 			}
-			const current = turnStats.get(id)
-			if (Number.isFinite(current?.watermarkSeq) && seq <= current.watermarkSeq) return
+			let current = turnStats.get(id)
+			if (Number.isFinite(current?.watermarkSeq) && seq <= current.watermarkSeq) {
+				// 重编检测（R-01-020/AC-04）：稳定 seq 空间内低水位事件的时刻不可能比水位处
+				// 事件更新；时刻反而更新说明事件 seq 空间被重编（如 dsh 0.1.5 V3 迁移），
+				// 持久化水位已失效，增量口径不再封死后续事件。无 watermarkTime 的存量记录
+				//（本字段引入前写入，其水位未经重编检测校验）同样不可信——两者统一丢弃旧
+				// 记账强制全量重放自愈；重放若仍覆盖不到本事件（日志写入滞后），落回下方
+				// 正常增量路径应用。
+				const time = Number(event.time)
+				if (!Number.isFinite(time)) return
+				if (Number.isFinite(current.watermarkTime) && time <= current.watermarkTime) return
+				await ensureTurnStatsFresh(id, { forceFresh: true })
+				current = turnStats.get(id)
+				if (Number.isFinite(current?.watermarkSeq) && seq <= current.watermarkSeq) return
+			}
 			const next = applyTurnEventToStats(turnStatsFrom(current), event)
 			if (turnStatsEqual(next, current)) {
 				// 无效果事件（非提问工具调用、未配对的结算事件等）：不落盘不广播，
 				// 水位不前移——重放路径对同类事件同样不改变记账状态，口径一致。
 				return
 			}
-			await turnStats.put(id, { ...turnStatsFrom(next), watermarkSeq: seq })
+			const time = Number(event.time)
+			// 与 reconcile 同口径：时刻无效时保留既有 watermarkTime 不前推（能走到此处的
+			// 必为有效果事件、时刻有效，null 分支仅作防御）。
+			await turnStats.put(id, { ...turnStatsFrom(next), watermarkSeq: seq, watermarkTime: Number.isFinite(time) ? time : turnStatsFrom(current).watermarkTime ?? null })
 			broadcastBusy()
 		} catch (error) {
 			ctx.logger?.warn?.(`dsh-activity-pane: 回合统计登记失败（${id}）: ${String(error)}`)