dsh-activity-pane 0.14.0 → 0.15.0

package/.dsh-plugin/client.js

@@ -152,6 +152,15 @@ function nextDensity(value) {
 	return DENSITY_ORDER[(index + 1) % DENSITY_ORDER.length];
 }
 
+/**
+ * 档位资源纪律谓词（R-01-025/AC-01）：紧凑呈现档下主会话日志窗口不建立或保持。
+ * 子代理日志窗口承载标题行可见的模型上下文（R-01-012/AC-17），恒不裁剪；
+ * 输入档位经 normalizeDensity 归一，非法值视作中间档即不裁剪（R-01-025/AC-01）。
+ */
+function logWindowSuppressed(densityLevel, isSubagent) {
+	return normalizeDensity(densityLevel) === "compact" && isSubagent !== true;
+}
+
 function isRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -1566,7 +1575,7 @@ function mainTitle(byId, id) {
  * jobsBySession（R-01-023）：快照携带的 `jobsBySession` 任务视图映射——存在在跑后台任务
  * （status ∈ {running, stopping}）的主会话获得第三种自身活动来源：保留在活动区归入运行组、
  * 完成提醒与错误提醒被抑制（AC-01、AC-02）；条目携带 liveJobs（startedAt 升序）供渲染层
- * 标注数量与构建任务行（R-01-024）。子代理行不派生 liveJobs（后台任务当前仅主会话呈现）。
+ * 标注数量与构建任务行（R-01-023）。子代理行不派生 liveJobs（后台任务当前仅主会话呈现）。
  */
 function buildEntries(snapshot, workspaceItems, detailsById = {}, completions = null, delegatingIds = null, archivedIds = [], waitingStarts = null, jobsBySession = null) {
 	const byId = isRecord(snapshot) && isRecord(snapshot.byId) ? snapshot.byId : {};
@@ -1743,7 +1752,7 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 				stateAt,
 				questionPreview: m.pending && m.row.pendingInteraction === "question" ? (questionPreview ?? null) : undefined,
 			});
-			// 后台任务子条目（R-01-024）：与子代理同形的缩进子卡，跟随母会话在其全部
+			// 后台任务子条目（R-01-023）：与子代理同形的缩进子卡，跟随母会话在其全部
 			// 子代理之前（即母亲条目的直接后继）；结束即随 liveJobs 清空而消失（R-01-023/AC-03）。
 			// 复合 id 在去重视野（entries/visited/cardsById）中唯一，且携 jobs 前缀与子代理
 			// 会话 id 空间天然隔离；层级连接线与子代理同规则参与 trackRuns（R-01-003/AC-04），
@@ -1765,7 +1774,6 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 						userPreview: "",
 						agentPreview: "",
 						isCurrent: false,
-						jobId: job.id,
 						jobStatus: job.status,
 						jobStartedAt: job.startedAt,
 					});
@@ -2003,11 +2011,7 @@ function entryErrorNote(completion) {
 	return typeof message === "string" && message !== "" ? message : ERROR_NOTE_FALLBACK;
 }
 
-// ---- 后台任务（R-01-023、R-01-024）：在跑活性归一与 job_output 读取回放 ----
-
-/** 后台任务输出回放的字符上限（R-01-024/AC-04）：模型每次 job_output 读取的
- *  已定案文本拼接后超出即截断并置 truncated；与单条错误信息截断同量级考虑。 */
-const JOB_OUTPUT_MAX_CHARS = 20000;
+// ---- 后台任务（R-01-023）：在跑活性归一 ----
 
 /** 在跑后台任务的活性状态全集（R-01-023）：stopping 视同在跑——停止请求已发出但
  *  任务尚未结束，呈现与提醒抑制口径与 running 一致。 */
@@ -2053,99 +2057,6 @@ function jobKindLabel(kind) {
 	return JOB_KIND_LABELS[kind] ?? kind;
 }
 
-/** 从 tool-result 消息提取纯文本：tool-result 内容块内的 text 片段按换行拼接；
- *  非数组内容或无文本块返回 undefined（错误结果是否纳入由调用方按 isError 判定）。 */
-function jobResultText(message) {
-	if (!Array.isArray(message.content)) return undefined;
-	const parts = [];
-	for (const block of message.content) {
-		if (!isRecord(block) || block.type !== "tool-result") continue;
-		if (!Array.isArray(block.content)) continue;
-		for (const item of block.content) {
-			if (isRecord(item) && item.type === "text" && typeof item.text === "string") parts.push(item.text);
-		}
-	}
-	return parts.length > 0 ? parts.join("\n") : undefined;
-}
-
-/** tool-result 是否为错误结果（内层 tool-result 块的 isError 标志）。 */
-function jobResultIsError(message) {
-	if (!Array.isArray(message.content)) return false;
-	return message.content.some((block) => isRecord(block) && block.type === "tool-result" && block.isError === true);
-}
-
-/**
- * 从事件记录列表提取 job_output 读写轨迹（R-01-024）：`tool/call` 名为 `job_output`
- * 的行经 `arguments.job_id`（JSON 字符串或已解析对象）登记 callId → jobId 映射，
- * `tool/result` 行按 `message.source.callId` 配对并携带模型收到的定案文本与错误标志。
- * 兼容包装记录 `{ seq, event }` 与平面事件两种形状（seq 取事件或记录顶层）；seq 非法的
- * 事件跳过。返回按 seq 升序的去重轨迹数组（同 seq 后到者胜——实时镜像与日志重放合并
- * 时的自然口径）。
- */
-function jobOutputTraces(records) {
-	const bySeq = new Map();
-	for (const record of Array.isArray(records) ? records : []) {
-		const event = eventOf(record);
-		if (!isRecord(event) || (event.type !== "tool/call" && event.type !== "tool/result")) continue;
-		const seq = Number(event.seq ?? (isRecord(record) ? record.seq : undefined));
-		if (!Number.isFinite(seq)) continue;
-		const data = isRecord(event.data) ? event.data : {};
-		if (event.type === "tool/call") {
-			if (data.name !== "job_output" || typeof data.callId !== "string") continue;
-			let jobId = null;
-			if (typeof data.arguments === "string") {
-				try {
-					const parsed = JSON.parse(data.arguments);
-					if (isRecord(parsed) && typeof parsed.job_id === "string") jobId = parsed.job_id;
-				} catch {
-					// 参数不可解析：不构成有效的 job_output 调用轨迹。
-				}
-			} else if (isRecord(data.arguments) && typeof data.arguments.job_id === "string") {
-				jobId = data.arguments.job_id;
-			}
-			if (jobId === null) continue;
-			bySeq.set(seq, { seq, kind: "call", callId: data.callId, jobId });
-		} else {
-			const message = isRecord(data.message) ? data.message : null;
-			const callId = typeof message?.source?.callId === "string" ? message.source.callId : null;
-			if (callId === null) continue;
-			bySeq.set(seq, { seq, kind: "result", callId, text: jobResultText(message), isError: jobResultIsError(message) });
-		}
-	}
-	return [...bySeq.values()].sort((a, b) => a.seq - b.seq);
-}
-
-/**
- * 从轨迹回放指定后台任务的模型已读输出（R-01-024/AC-01）：按 seq 序配对 call → result，
- * 拼接归属 jobId 的全部读取文本；剔除错误结果与 `(no new output)` 占位（模型视角的
- * 「无新内容」对人无展示价值）。返回 `{ text, truncated, read }`——read = 存在已配对
- * 读取（无配对时 text 为空，客户端以「尚未被读取」承接，R-01-024/AC-02）；超出
- * limit 按字符截断并置 truncated（R-01-024/AC-04）。同 seq 轨迹去重（后到者胜），
- * 供日志重放与实时镜像两源合并。jobId 非法返回未读取空结果。
- */
-function jobOutputFromTraces(traces, jobId, limit = JOB_OUTPUT_MAX_CHARS) {
-	if (typeof jobId !== "string" || jobId === "") return { text: "", truncated: false, read: false };
-	const bySeq = new Map();
-	for (const trace of Array.isArray(traces) ? traces : []) {
-		if (isRecord(trace) && Number.isFinite(Number(trace?.seq))) bySeq.set(Number(trace.seq), trace);
-	}
-	const jobOf = new Map();
-	const parts = [];
-	let read = false;
-	for (const trace of [...bySeq.values()].sort((a, b) => a.seq - b.seq)) {
-		if (trace?.kind === "call") {
-			if (typeof trace.jobId === "string") jobOf.set(trace.callId, trace.jobId);
-		} else if (jobOf.get(trace.callId) === jobId) {
-			read = true;
-			if (trace.isError !== true && typeof trace.text === "string" && !trace.text.startsWith("(no new output)")) {
-				parts.push(trace.text);
-			}
-		}
-	}
-	const text = parts.join("\n");
-	return { text: text.length > limit ? text.slice(0, limit) : text, truncated: text.length > limit, read };
-}
-
 /**
  * 活动区→历史区迁移检测（R-01-010/AC-07）：上一帧活动区 id 在本帧离开活动区且出现于
  * 历史区即判定为一次迁移；彻底消失（归档、不再被会话服务列出）不判定。prevActiveIds 为上一帧
@@ -3566,12 +3477,17 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
 }
 [data-dsh-activity-pane] .dap-jobs-chip[hidden] { display: none; }
 /* 后台任务子卡（R-01-023/AC-05、AC-07）：与子代理卡同构的两行卡面，底色在子代理卡
-   底色上轻染任务状态点同族的蓝以相互可辨；状态点色随任务状态翻转。 */
+   底色上轻染任务状态点同族的蓝以相互可辨；状态点色随任务状态翻转。
+   子卡为纯展示（R-01-023/AC-08）：默认光标，悬停不提供可点反馈。 */
 [data-dsh-activity-pane] .dap-card[data-kind="job"] {
   padding: 6px 10px;
   border-radius: 12px;
   background: color-mix(in srgb, #65a0ff 8%, rgba(25, 27, 32, 0.95));
-  cursor: pointer;
+  cursor: default;
+}
+[data-dsh-activity-pane] .dap-card[data-kind="job"]:hover {
+  border-color: rgba(255, 255, 255, 0.13);
+  filter: none;
 }
 /* 任务卡行 1（R-01-023/AC-05）：状态点 + 工具名称 + 右缘随时钟时长；工具名不可得时
    文本段隐藏，仅保留状态点与时长。 */
@@ -3599,23 +3515,6 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
   flex: 1 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
   font-family: var(--dsh-font-mono, monospace); font-size: 11px; line-height: 15px;
 }
-/* 子卡输出区（R-01-024/AC-01）：展开时追加于卡内底部，终端风回放。 */
-[data-dsh-activity-pane] .dap-jobout {
-  min-width: 0; max-height: 160px; overflow: auto;
-  margin: 4px 0 0;
-  background: color-mix(in srgb, currentColor 7%, transparent);
-  border-radius: 6px; padding: 4px 6px;
-}
-[data-dsh-activity-pane] .dap-jobout-pre {
-  margin: 0; white-space: pre-wrap; word-break: break-word;
-  font-family: var(--dsh-font-mono, monospace); font-size: 10px; line-height: 14px;
-  color: color-mix(in srgb, currentColor 78%, transparent);
-}
-[data-dsh-activity-pane] .dap-jobout-hint {
-  font-size: 10px; line-height: 14px;
-  color: color-mix(in srgb, currentColor 55%, transparent);
-}
-[data-dsh-activity-pane] .dap-jobout-hint:empty { display: none; }
 [data-dsh-activity-pane] .dap-history-line {
   display: flex; align-items: center; gap: 4px; height: 15px;
   min-width: 0; overflow: hidden; white-space: nowrap;
@@ -3925,10 +3824,15 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-card:hover {
 body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-card[data-kind="subagent"] {
   background: var(--dsw-specific-sidebar-fill, rgb(249, 250, 251));
 }
-/* 后台任务子卡浅色主题与子代理卡同源（R-01-024）：淡侧栏填充底，轻染同族蓝与子代理卡区分（R-01-023/AC-07）。 */
+/* 后台任务子卡浅色主题与子代理卡同源（R-01-023）：淡侧栏填充底，轻染同族蓝与子代理卡区分（R-01-023/AC-07）。 */
 body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-card[data-kind="job"] {
   background: color-mix(in srgb, #65a0ff 8%, var(--dsw-specific-sidebar-fill, rgb(249, 250, 251)));
 }
+/* 纯展示子卡（R-01-023/AC-08）：浅色主题同样不提供悬停反馈（回归基态描边）。 */
+body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-card[data-kind="job"]:hover {
+  border-color: var(--dsw-alias-border-l2, rgba(0, 0, 0, 0.1));
+  filter: none;
+}
 body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-card[data-kind="recent"] {
   /* 暗于活动卡的 --dsw-alias-bg-layer-2 纯白、深于窗格底色（R-01-013/AC-10、AC-11）。 */
   background: rgb(243, 244, 246);
@@ -4414,12 +4318,10 @@ function apply(ctx) {
 		}
 	}
 
-	/** 回到前台（含 bfcache 还原）时 ack 与任务输出通道自愈：重建 SSE（jobs 无全量快照，
-	 *  重连后由下一次轨迹通知或重新选中收敛；选中输出随卡片渲染帧刷新）。 */
+	/** 回到前台（含 bfcache 还原）时 ack 通道自愈：重建 SSE（连接即发全量，状态必然收敛）。 */
 	function resumePushChannels() {
 		if (!disposed) {
 			connectAcksStream();
-			connectJobsStream();
 		}
 	}
 	const onVisibilityResume = () => {
@@ -4432,51 +4334,6 @@ function apply(ctx) {
 	window.addEventListener("pageshow", onPageShow);
 	connectAcksStream();
 
-	// ---- 后台任务输出通道（R-01-024） ----
-	// SSE 订阅宿主侧 job_output 轨迹通知：连接即发空快照（轨迹不入库、无全量快照语义），
-	// 此后每个新轨迹广播 { sessionId, jobId }；客户端仅对「已选中该任务」的可见卡片
-	// 回读输出（R-01-024/AC-03）。无 EventSource 环境静默降级为选中时不自动刷新，
-	// 不引入轮询。
-	let jobsSource = null;
-
-	/** 轨迹通知应用：命中已展开该任务的 job 子卡即置脏并回读一次；其余通知忽略。 */
-	function applyJobTraceNotice(raw) {
-		if (disposed) return;
-		let notice = null;
-		try {
-			notice = JSON.parse(raw);
-		} catch {
-			notice = null;
-		}
-		const sessionId = typeof notice?.sessionId === "string" ? notice.sessionId : null;
-		const jobId = typeof notice?.jobId === "string" ? notice.jobId : null;
-		if (sessionId === null || jobId === null) return;
-		for (const [, card] of cardsById) {
-			const el = card?.el;
-			if (el?.dataset?.kind !== "job" || el.dataset.jobOwner !== sessionId || el.dataset.jobId !== jobId) continue;
-			// 脏标记 + 回读钩子：仅展开中的输出区需要拉取新轨迹（R-01-024/AC-03）。
-			el.__jobOutDirty = true;
-			el.__jobOutReload?.();
-		}
-	}
-
-	/** （重）建 jobs SSE 连接：与 acks 通道同模式的断连自愈口径。 */
-	function connectJobsStream() {
-		try {
-			jobsSource?.close();
-		} catch {}
-		jobsSource = null;
-		if (disposed || typeof window.EventSource !== "function") return;
-		try {
-			const source = new window.EventSource(`${PANE_API_BASE}/jobs/stream`);
-			source.addEventListener("state", (event) => applyJobTraceNotice(event.data ?? ""));
-			jobsSource = source;
-		} catch {
-			jobsSource = null;
-		}
-	}
-	connectJobsStream();
-
 	/** 确认写回（R-01-002/AC-10～AC-12）：乐观更新本地游标（签名驱动即时解除），
 	 *  再 POST 宿主侧持久化并广播；写回失败回滚本地游标（提醒恢复），不吞异常。 */
 	async function ackCompletion(sessionId) {
@@ -4770,7 +4627,10 @@ function apply(ctx) {
 			// 选择），订阅与一次性 load 一并触发；子代理的目录不可用（宿主以 agent-busy
 			// 拒绝其模型 RPC），不建立订阅。e2e 接缝把订阅与 load 整体延后，使模型上下文
 			// 严格晚于时间线呈现（R-01-014/AC-03 渐进语义可观察）。
-			if (!subagent) {
+			// 档位资源纪律（R-01-025/AC-06）：紧凑档主会话的模型区域在头部行内、整体
+			// 隐藏——模型上下文无可见消费者，不订阅不 load；切回更高档位后经既有
+			// 一次性读取语义补齐。logWindowSuppressed 单点判定。
+			if (!subagent && !logWindowSuppressedFor(id, byId)) {
 				if (e2eModelDelayMs === 0) {
 					subscribeModelDirectory(id, detail);
 					loadDirectoryOnce(id);
@@ -4789,6 +4649,10 @@ function apply(ctx) {
 			const lastSeq = Number(windowEntries.at(-1)?.event?.seq);
 			const deepReadNeeded =
 				(previewFallbackIds.has(id) || durationFallbackIds.has(id) || (subagent && subagentModelReadIds.has(id))) &&
+				// 档位资源纪律（R-01-025/AC-03）：紧凑档主会话不发起日志分页深翻——
+				// 预览行与最近回合耗时在该档位均不可见，最近历史排序以既有可用时刻
+				// 承载（R-01-010/AC-09 档位限定）；子代理模型溯源读取不受影响。
+				(subagent || !logWindowSuppressed(densityLevel, subagent)) &&
 				detail.log?.hasMore === true &&
 				Number.isFinite(lastSeq) &&
 				detail.historyDeepReadDone !== true;
@@ -4803,6 +4667,10 @@ function apply(ctx) {
 					.then(async () => {
 						const { events, error } = await pagedHistoryEvents({
 							fetchPage: async (beforeSeq) => {
+								// 档位资源纪律（R-01-025/AC-03）：分页响应点用时重读档位——
+								// 切入紧凑档后，在途深翻不再发起下一页；中止时已取页不落地、
+								// 保持既有详情，切回后重新入队重取。子代理模型溯源读取不受影响。
+								if (logWindowSuppressed(densityLevel, subagent)) return null;
 								const value = remoteValue(
 									await sessionRemote.page({ address, throughSeq: lastSeq, beforeSeq, maxMessages: 50 }),
 								);
@@ -4810,6 +4678,10 @@ function apply(ctx) {
 								return { events: Array.isArray(value.records) ? value.records : [], hasMore: value.hasMore === true };
 							},
 						});
+						// 切档中止的在途深翻不落地、不标记完成——historyDeepReadDone 无复位
+						// 路径，中止即置位会让切回高档位后的预览/耗时补齐永久失效；中止时
+						// 保持既有详情不变，切回后经 deepReadNeeded 重新入队（R-01-025/AC-01）。
+						if (logWindowSuppressed(densityLevel, subagent)) return;
 						if (error) detail.historyError = error instanceof Error ? error.message : String(error);
 						detail.history = events;
 						detail.historyDeepReadDone = true;
@@ -4831,6 +4703,44 @@ function apply(ctx) {
 		}
 	}
 
+	/** 档位资源纪律单点判定（R-01-025）：档位谓词与子代理判定的唯一组合。
+	 *  byId 缺省时读当帧列表快照；调用方已持有快照时传入以免重复读取。 */
+	function logWindowSuppressedFor(id, byId = getSnapshot(sessions, "list")?.byId ?? {}) {
+		return logWindowSuppressed(densityLevel, isSubagentRow(byId[id], byId));
+	}
+
+	/** 档位资源纪律拆窗（R-01-025/AC-01）：对非当前主会话的日志窗口订阅先
+	 *  unsubscribe 再除名并清除窗口引用，并 dispose 会话运行时的 live 源
+	 *  （openState 归 cold，底层 session/follow 流终止）——订阅回调移除不终止
+	 *  共享传输流，dispose 才真正停带宽。当前会话的窗口由外壳会话视图持有，
+	 *  不 dispose、不拆订阅（由本函数在渲染期持续执法：其切走后的下一轮渲染
+	 *  照常释放）；当前会话不可判定（列表快照未就绪）时整轮跳过，不误释放。
+	 *  子代理日志窗口承载标题行可见的模型上下文，保留。切回更高档位时经既有
+	 *  渐进路径（captureSessionLog 重订阅 + session.open 重新水合）就绪，
+	 *  不新增恢复机制。 */
+	function enforceDensityDataDiscipline() {
+		if (densityLevel !== "compact") return;
+		const listSnap = getSnapshot(sessions, "list");
+		if (listSnap?.current == null) return;
+		for (const [id, unsubscribe] of [...logSourceSubs]) {
+			if (!logWindowSuppressedFor(id, listSnap?.byId ?? {})) continue;
+			if (String(id) === String(listSnap.current)) continue;
+			try {
+				unsubscribe?.();
+			} catch {
+				/* 监听器已失效：除名即可 */
+			}
+			logSourceSubs.delete(id);
+			const detail = sessionDetailsById.get(id) ?? null;
+			if (detail !== null) detail.log = null;
+			try {
+				sessions?.binding?.(id)?.session?.dispose?.();
+			} catch {
+				/* dispose 不可用：订阅已断即达成本档位纪律的可用部分 */
+			}
+		}
+	}
+
 	/** 日志页落地后的详情派生（R-01-012、R-01-017）：时间线折叠、消息预览与子代理模型上下文。
 	 *  子代理沿用溯源链（assistant/message source.model + 请求头 effort，T-122）；主会话模型
 	 *  不经日志提取（目录链订阅 + 一次性 load 承载，见 installServiceSubscriptions 注）。
@@ -4868,6 +4778,11 @@ function apply(ctx) {
 			session = null;
 		}
 		if (session === null) return;
+		// 档位资源纪律（R-01-025/AC-01）：紧凑档主会话不建立或保持会话日志窗口——
+		// 不订阅事件流、不发起 open 水合、不读窗口快照。判定在函数入口用时重读，
+		// 切档在途的回调与重试不落地新窗口。子代理日志窗口承载标题行可见的
+		// 模型上下文（R-01-012/AC-17），恒不裁剪（单点判定见 logWindowSuppressedFor）。
+		if (logWindowSuppressedFor(id)) return;
 		// 日志窗口无效化订阅（事件驱动，不构成轮询，R-02-004）：等待/历史卡无会话状态
 		// 订阅（syncLiveness 只订阅运行中），窗口推进（回合收尾、流式尾）必须经此回调
 		// 重读快照并重绘；否则窗口更新只能靠渲染期重读兜底——渲染一旦静默（一次性
@@ -5177,6 +5092,9 @@ function apply(ctx) {
 			const anchorTop = currentCard ? currentCard.getBoundingClientRect().top - viewportTop : null;
 			densityLevel = nextDensity(densityLevel);
 			writeStoredDensity(densityLevel);
+			// 档位资源纪律（R-01-025/AC-01）：进入紧凑档即拆主会话日志窗口订阅；
+			// captureSessionLog 入口门控阻止在途回调重建。
+			enforceDensityDataDiscipline();
 			applyDensity();
 			// 档位已纳入渲染签名：触发一轮同步让时间线按新档位以 lastOnly 重建；
 			// 锚定补偿在本轮渲染提交后执行，此时量测才含新行高
@@ -5404,8 +5322,8 @@ function apply(ctx) {
 			return [head, row, makeEl("div", "dap-trace"), makeStatsRow(), foot];
 		}
 		if (kind === "job") {
-			// 后台任务子卡（R-01-023/AC-05、R-01-024）：行 1 = 状态点 + 工具名称 + 随时钟
-			// 时长；行 2 = 任务内容原文（mono 省略 + tooltip）；输出区在展开时追加。
+			// 后台任务子卡（R-01-023/AC-05）：行 1 = 状态点 + 工具名称 + 随时钟时长；
+			// 行 2 = 任务内容原文（mono 省略 + tooltip）。
 			const row = makeEl("div", "dap-row");
 			row.append(makeEl("span", "dap-job-dot"), makeEl("span", "dap-job-kind"), makeEl("span", "dap-job-elapsed"));
 			const content = makeEl("div", "dap-job-content");
@@ -5898,7 +5816,7 @@ function apply(ctx) {
 	const JOB_STATUS_LABELS = { running: "运行中", stopping: "停止中", completed: "已完成", killed: "已终止", failed: "失败" };
 
 	/** 后台任务数量注（R-01-023/AC-01）：母卡标题行内 `后台 ×N` 小注；任务本体以 job
-	 *  子卡呈现（R-01-024），本注仅承载数量语义。无 liveJobs 时隐藏节点。 */
+	 *  子卡呈现（R-01-023），本注仅承载数量语义。无 liveJobs 时隐藏节点。 */
 	function renderJobsChip(el, entry) {
 		const chip = el.querySelector(".dap-jobs-chip");
 		if (chip === null) return;
@@ -5909,84 +5827,9 @@ function apply(ctx) {
 		if (chip.hidden !== hidden) chip.hidden = hidden;
 	}
 
-	/** 后台任务子卡的输出展开/收起（R-01-024/AC-01）：激活 job 卡即在卡内展开输出区，
-	 *  再次激活收起；同一母会话下至多展开一张（点击新卡先收兄弟，稳定性与共享坞等价）。 */
-	function toggleJobExpanded(el) {
-		if (el.hasAttribute("data-expanded")) {
-			el.removeAttribute("data-expanded");
-			el.querySelector(".dap-jobout")?.remove();
-			delete el.dataset.loadedFor;
-			el.__jobOutReload = null;
-			return;
-		}
-		const ownerId = el.dataset.jobOwner ?? "";
-		for (const [, card] of cardsById) {
-			const other = card?.el;
-			if (other === el || other?.dataset?.kind !== "job" || other.dataset.jobOwner !== ownerId) continue;
-			other.removeAttribute("data-expanded");
-			other.querySelector(".dap-jobout")?.remove();
-			delete other.dataset.loadedFor;
-			other.__jobOutReload = null;
-		}
-		el.setAttribute("data-expanded", "");
-		// 展开视为显式回读请求：置脏令 renderJobOutput 必发一次（含重复点选的重试语义）。
-		el.__jobOutDirty = true;
-		renderJobOutput(el);
-	}
-
-	/** 输出区装载/刷新（R-01-024/AC-01～AC-04）：按卡上归属与任务 id 回读一次模型已读
-	 *  输出——未被读取显示「尚未被读取」（AC-02），超限截断提示（AC-04），失败诚实降级。
-	 *  回读仅在展开、选中切换（=重新展开）或轨迹通知置脏时发出（R-01-024/AC-03）：
-	 *  loadedFor 未变且未置脏时渲染帧直达 return，不构成周期性拉取（R-02-004）。
-	 *  token 使迟到的响应失效（快速切换不串内容）。 */
-	function renderJobOutput(el) {
-		if (!el.hasAttribute("data-expanded")) return;
-		const sessionId = el.dataset.jobOwner ?? null;
-		const jobId = el.dataset.jobId ?? null;
-		if (sessionId === null || sessionId === "" || jobId === null || jobId === "") return;
-		let out = el.querySelector(".dap-jobout");
-		if (out === null) {
-			out = makeEl("div", "dap-jobout");
-			out.append(makeEl("pre", "dap-jobout-pre"), makeEl("div", "dap-jobout-hint"));
-			el.append(out);
-		}
-		const loadedFor = el.dataset.loadedFor;
-		const key = `${sessionId}/${jobId}`;
-		if (loadedFor === key && el.__jobOutDirty !== true) return;
-		el.dataset.loadedFor = key;
-		el.__jobOutDirty = false;
-		const pre = out.querySelector(".dap-jobout-pre");
-		const hint = out.querySelector(".dap-jobout-hint");
-		const token = `${sessionId} ${jobId} ${Date.now()}`;
-		el.__jobOutToken = token;
-		// jobs SSE 轨迹通知按此钩子触发回读（R-01-024/AC-03）；随卡片重建自然失效。
-		el.__jobOutReload = () => renderJobOutput(el);
-		pre.textContent = "";
-		hint.textContent = "读取中…";
-		fetch(`${PANE_API_BASE}/jobs-output?sessionId=${encodeURIComponent(sessionId)}&jobId=${encodeURIComponent(jobId)}`)
-			.then((response) => (response.ok ? response.json() : null))
-			.then((payload) => {
-				if (el.__jobOutToken !== token || disposed) return;
-				if (payload === null || typeof payload !== "object") {
-					hint.textContent = "输出读取失败";
-					return;
-				}
-				pre.textContent = typeof payload.text === "string" ? payload.text : "";
-				hint.textContent =
-					payload.read === false
-						? "尚未被读取"
-						: payload.truncated === true
-							? "输出过长，已截断"
-							: "";
-			})
-			.catch(() => {
-				if (el.__jobOutToken === token && !disposed) hint.textContent = "输出读取失败";
-			});
-	}
-
-	/** 后台任务子卡渲染（R-01-023/AC-01、R-01-024/AC-01）：状态点着色、标题与随时钟
-	 *  推进的已运行时长；展开态下装载/刷新输出区。任务消失由条目派生侧收卡（随
-	 *  liveJobs 清空整个条目消失），此处只呈现当帧状态。 */
+	/** 后台任务子卡渲染（R-01-023/AC-01、AC-05）：状态点着色、标题与随时钟推进的
+	 *  已运行时长。任务消失由条目派生侧收卡（随 liveJobs 清空整个条目消失），
+	 *  此处只呈现当帧状态。 */
 	function renderJobCardInto(el, entry) {
 		const dot = el.querySelector(".dap-job-dot");
 		if (dot !== null && dot.dataset.status !== entry.jobStatus) dot.dataset.status = entry.jobStatus;
@@ -5999,8 +5842,7 @@ function apply(ctx) {
 			if (kindEl.hidden !== kindHidden) kindEl.hidden = kindHidden;
 		}
 		// 任务内容行（R-01-023/AC-05、AC-06）：mono 原文单行省略，完整原文以原生 tooltip
-		// 显示（沿用 R-01-024 呈现细化语义，tooltip 归内容行）；内容不可得时整行隐藏，
-		// 不补空白或占位。
+		// 显示（tooltip 归内容行）；内容不可得时整行隐藏，不补空白或占位。
 		const contentRow = el.querySelector(".dap-job-content");
 		const labelText = String(entry.title ?? "");
 		if (contentRow !== null) {
@@ -6022,9 +5864,6 @@ function apply(ctx) {
 					: "";
 			if (elapsed.textContent !== elapsedText) elapsed.textContent = elapsedText;
 		}
-		if (el.dataset.jobOwner !== String(entry.parentId)) el.dataset.jobOwner = String(entry.parentId);
-		if (el.dataset.jobId !== String(entry.jobId)) el.dataset.jobId = String(entry.jobId);
-		renderJobOutput(el);
 	}
 
 	function renderCardInto(el, entry, colorByWorkspace) {
@@ -6145,7 +5984,9 @@ function apply(ctx) {
 			const jobsOnly = Array.isArray(entry.liveJobs) && entry.liveJobs.length > 0 && entry.selfRunning !== true;
 			renderJobsChip(el, entry);
 			const progressRow = el.querySelector(".dap-progress");
-			if (progressRow !== null) {
+			// 档位资源纪律（R-01-025/AC-05）：进度行在中间/紧凑档被 CSS 隐藏，不写入；
+			// 切回完整档后随档位签名重渲染恢复。
+			if (progressRow !== null && densityLevel === "full") {
 				if (jobsOnly) {
 					if (!progressRow.hidden) progressRow.hidden = true;
 				} else {
@@ -6154,8 +5995,10 @@ function apply(ctx) {
 				}
 			}
 			const traceContainer = el.querySelector(".dap-trace");
-			if (traceContainer !== null) renderTimelineArea(traceContainer, entry, { lastOnly: densityLevel === "medium" });
-			renderTokenStats(el, entry);
+			// 档位资源纪律（R-01-025/AC-05）：紧凑档不构建被隐藏的时间线内容；
+			// 中间档 lastOnly 单行语义不变（R-01-021/AC-08）。切回后随档位签名重渲染恢复。
+			if (traceContainer !== null && densityLevel !== "compact") renderTimelineArea(traceContainer, entry, { lastOnly: densityLevel === "medium" });
+			if (densityLevel === "full") renderTokenStats(el, entry);
 			return;
 		}
 
@@ -6166,10 +6009,13 @@ function apply(ctx) {
 
 		if (entry.kind === "subagent") {
 			const traceContainer = el.querySelector(".dap-subtrace");
-			if (traceContainer !== null) renderTimelineArea(traceContainer, entry, { lastOnly: true });
+			// 档位资源纪律（R-01-025/AC-05）：紧凑档不构建被隐藏的子卡时间线内容；
+			// 标题行内联模型上下文（R-01-012/AC-17）不受影响。
+			if (traceContainer !== null && densityLevel !== "compact") renderTimelineArea(traceContainer, entry, { lastOnly: true });
 			// 运行中呈现与运行卡同构的进度行；锚点空闲（暂停等待）时整行隐藏（R-01-009/AC-15）。
 			const progressRow = el.querySelector(".dap-progress");
-			if (progressRow !== null) {
+			// 档位资源纪律（R-01-025/AC-05）：进度行与统计行在中间/紧凑档不写入。
+			if (progressRow !== null && densityLevel === "full") {
 				if (Number.isFinite(entry.progress)) {
 					renderProgressRow(el, entry.progress);
 					if (progressRow.hidden) progressRow.hidden = false;
@@ -6177,7 +6023,7 @@ function apply(ctx) {
 					progressRow.hidden = true;
 				}
 			}
-			renderTokenStats(el, entry);
+			if (densityLevel === "full") renderTokenStats(el, entry);
 			return;
 		}
 
@@ -6198,14 +6044,18 @@ function apply(ctx) {
 					restoreTextField(text, previews[i]);
 				}
 			}
-			renderTokenStats(el, entry);
+			// 档位资源纪律（R-01-025/AC-05）：最近卡统计行在中间/紧凑档不写入。
+			if (densityLevel === "full") renderTokenStats(el, entry);
 		}
 
 		if (entry.kind === "awaiting") {
 			const traceContainer = el.querySelector(".dap-trace");
-			if (traceContainer !== null) renderTimelineArea(traceContainer, entry, { lastOnly: densityLevel === "medium" });
+			// 档位资源纪律（R-01-025/AC-05）：紧凑档不构建被隐藏的时间线内容；
+			// 中间档 lastOnly 单行语义不变（R-01-021/AC-08）。
+			if (traceContainer !== null && densityLevel !== "compact") renderTimelineArea(traceContainer, entry, { lastOnly: densityLevel === "medium" });
 			removeAwaitingHeadDuration(el);
-			renderTokenStats(el, entry);
+			// 档位资源纪律（R-01-025/AC-05）：等待卡统计行在中间/紧凑档不写入。
+			if (densityLevel === "full") renderTokenStats(el, entry);
 			const confirm = el.querySelector(".dap-confirm");
 			if (confirm !== null) {
 				// 激活锚点：只在结构重建时绑一次（卡片按 id 复用，kind 变化会重建骨架）。
@@ -6276,11 +6126,18 @@ function apply(ctx) {
 			}
 			// 子代理事件流仅接受持久父地址：open 前先安装（T-151），否则宿主拒绝、窗口永不水合。
 			ensureSubagentAddress(id, session);
+			// 档位资源纪律（R-01-025/AC-01）：紧凑档主会话不发起 open 水合——轮内状态
+			// 订阅（本函数职责，R-02-004）保留，liveness 记账与正常路径共用下方代码，
+			// 日志窗口水合在切回更高档位后经渲染期重试重建。子代理模型上下文依赖其
+			// 窗口，不裁剪（单点判定见 logWindowSuppressedFor）。
+			const livenessSuppressed = logWindowSuppressedFor(id);
 			let opening = null;
-			try {
-				opening = session.open?.();
-			} catch {
-				opening = null;
+			if (!livenessSuppressed) {
+				try {
+					opening = session.open?.();
+				} catch {
+					opening = null;
+				}
 			}
 			if (opening && typeof opening.then === "function") {
 				const tracked = Promise.resolve(opening).then(
@@ -6499,13 +6356,11 @@ function apply(ctx) {
 		if (rec === undefined) {
 			const el = document.createElement("div");
 			el.className = CARD_CLASS;
-			const unbind = bindCardActivation(el, (sessionId) => {
-				// 后台任务子卡（R-01-024/AC-01）：激活即切换卡内输出展开，不发起会话跳转
-				//（job 复合 id 非会话 id，无可打开目标）。
-				if (el.dataset.kind === "job") {
-					toggleJobExpanded(el);
-					return;
-				}
+			// 后台任务子卡为纯展示（R-01-023/AC-08）：不绑激活监听，job 复合 id 亦非会话
+			// id，不存在可跳转目标。job 复合 id 与会话 id 空间隔离（`job:` 前缀），reuseMap
+			// 按条目 id 复用，同一 card 元素不会跨 kind 复用——创建时按 entry.kind 一次性
+			// 决定是否绑激活是安全的；若 id 规则变化须同步复核此处。
+			const unbind = entry.kind === "job" ? null : bindCardActivation(el, (sessionId) => {
 				if (typeof sessions?.open !== "function") return;
 				lastActivatedId = sessionId;
 				// 新激活意图取代一切旧重试链，避免过期链条稍后把当前会话拽回旧目标；
@@ -6534,8 +6389,14 @@ function apply(ctx) {
 			rec.el.dataset.kind = entry.kind;
 			rec.el.dataset.sessionId = entry.id;
 			rec.el.dataset.depth = String(entry.depth ?? 0);
-			rec.el.setAttribute("role", "button");
-			rec.el.tabIndex = 0;
+			// 纯展示子卡（R-01-023/AC-08）不进入按钮语义与 tab 序。
+			if (entry.kind === "job") {
+				rec.el.removeAttribute("role");
+				rec.el.removeAttribute("tabindex");
+			} else {
+				rec.el.setAttribute("role", "button");
+				rec.el.tabIndex = 0;
+			}
 			rec.el.replaceChildren(...cardChildren(entry.kind));
 			rec.kind = entry.kind;
 		}
@@ -7077,6 +6938,10 @@ function apply(ctx) {
 		}
 		const detailIds = [...active, ...recent].map((entry) => entry.id);
 		detailIds.sort((a, b) => Number(String(b) === String(snapshot?.current)) - Number(String(a) === String(snapshot?.current)));
+		// 档位资源纪律（R-01-025/AC-01）：渲染期持续执法——进入紧凑档即拆主会话窗口；
+		// 拆窗时被豁免的当前会话在切走后的下一轮渲染照常释放。幂等：主会话拆窗后
+		// 不在 logSourceSubs，重复执法为无操作。
+		enforceDensityDataDiscipline();
 		loadNativeDetails({ ids: detailIds, previewFallbackIds, durationFallbackIds, subagentModelReadIds });
 		// 累计运行时长懒回填（R-01-020/AC-05）：对可见主会话触发宿主侧存量回合补齐；
 		// 宿主侧每会话单飞，重复触发由宿主合并；完成后经 busy SSE 广播推送。
@@ -7464,8 +7329,6 @@ function apply(ctx) {
 		pendingUnsubscribe?.();
 		acksSource?.close();
 		acksSource = null;
-		jobsSource?.close();
-		jobsSource = null;
 		busySource?.close();
 		busySource = null;
 		document.removeEventListener("visibilitychange", onBusyVisibilityResume);