dsh-activity-pane 0.13.0 → 0.15.0

package/.dsh-plugin/client.js

@@ -18,6 +18,8 @@ window.__ModuleLoader__.load({
 //
 // 展示规则：
 //   主会话（非有效子代理行）：running || completed || pendingInteraction 都显示；
+//   存活在跑后台任务（jobsBySession 中 status ∈ {running, stopping}，R-01-023）的主会话
+//   同样按运行态显示并抑制完成/错误提醒；
 //   子代理（origin === 'subagent' 且 parentId 有效）：仅 running || pendingInteraction 时显示（结束后即消失）；
 //   pendingInteraction 总是优先视为"等待用户行动"（即使在 running 中）。
 
@@ -150,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);
 }
@@ -1561,8 +1572,12 @@ function mainTitle(byId, id) {
  * stateAt（进入当前等待行动状态的时刻，R-01-002/AC-14）：仅 awaiting 条目携带，与排序键
  * 共用 enterStateAt 单点口径——pending 取 waitingStarts，完成/错误提醒取 completions.lastTurnEnd；
  * 显示侧不回落宿主列表时间——排序键缺失时的回落仅用于排序，显示以 null（不显示）承载。
+ * jobsBySession（R-01-023）：快照携带的 `jobsBySession` 任务视图映射——存在在跑后台任务
+ * （status ∈ {running, stopping}）的主会话获得第三种自身活动来源：保留在活动区归入运行组、
+ * 完成提醒与错误提醒被抑制（AC-01、AC-02）；条目携带 liveJobs（startedAt 升序）供渲染层
+ * 标注数量与构建任务行（R-01-023）。子代理行不派生 liveJobs（后台任务当前仅主会话呈现）。
  */
-function buildEntries(snapshot, workspaceItems, detailsById = {}, completions = null, delegatingIds = null, archivedIds = [], waitingStarts = null) {
+function buildEntries(snapshot, workspaceItems, detailsById = {}, completions = null, delegatingIds = null, archivedIds = [], waitingStarts = null, jobsBySession = null) {
 	const byId = isRecord(snapshot) && isRecord(snapshot.byId) ? snapshot.byId : {};
 	const ids = Array.isArray(snapshot?.ids) ? snapshot.ids : [];
 	const current = snapshot?.current ?? null;
@@ -1603,16 +1618,20 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 		const running = row.running === true;
 		const pending = row.pendingInteraction !== undefined;
 		const isSub = hasParent;
+		// 在跑后台任务（R-01-023）：主会话的第三种自身活动来源——liveJobs 非空期间
+		// 完成/错误提醒被抑制（AC-02）、会话保持运行态呈现（AC-01）。
+		const liveJobs = isSub ? [] : liveJobsOf(jobsBySession, id);
+		const hasLive = liveJobs.length > 0;
 		// 完成确认（R-01-002/AC-03、AC-05、R-01-010/AC-06）：未确认的完成提醒按自身活动计入。
-		const done = completionReminder(row, completionFor(id, completions), isSub);
+		const done = !hasLive && completionReminder(row, completionFor(id, completions), isSub);
 		// 错误提醒（R-01-002/AC-13，C-043）：最近回合以错误结束的按自身活动计入。
-		const err = errorReminder(row, completionFor(id, completions), isSub);
+		const err = !hasLive && errorReminder(row, completionFor(id, completions), isSub);
 		// 子代理完成且没有活动后代时消失；主会话完成后保留为"等待打开"；母会话在委托周期保持运行呈现（R-01-003/AC-05）。
-		const selfActive = isOwnActiveRow(row, byId);
+		const selfActive = isOwnActiveRow(row, byId) || hasLive;
 		const descendantActive = descendantIds.has(String(id));
 		const delegating = descendantActive || (delegatingIds instanceof Set && delegatingIds.has(String(id)));
 		const show = selfActive || delegating || done || err;
-		meta.set(id, { row, running, pending, isSub, show, done, err, descendantActive, delegating, depth: 0 });
+		meta.set(id, { row, running, pending, isSub, show, done, err, descendantActive, delegating, hasLive, liveJobs, depth: 0 });
 	}
 
 	// 主会话分两组排序（R-01-001/AC-07，键口径契约详见上方 JSDoc）：运行中主会话置顶、
@@ -1620,7 +1639,8 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 	// 两组相同时间均回落宿主列表出现顺序，工作区顺序不参与排序。
 	const isRunningEntry = (id) => {
 		const m = meta.get(id);
-		return m !== undefined && !m.pending && (m.running || m.delegating);
+		// 在跑后台任务视同运行组（R-01-023/AC-01）：排序键沿用宿主列表时间。
+		return m !== undefined && !m.pending && (m.running || m.delegating || m.hasLive);
 	};
 	const waitingStartTime = (id) => {
 		if (!(waitingStarts instanceof Map)) return null;
@@ -1691,7 +1711,7 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 					? "subagent"
 					: m.pending
 						? "awaiting"
-						: m.running || m.delegating
+						: m.running || m.delegating || m.hasLive
 							? "running"
 							: "awaiting",
 				descendantActive: m.descendantActive,
@@ -1725,9 +1745,40 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 						: doneWait
 							? ROUND_DONE_NOTE
 							: undefined,
+				// 在跑后台任务（R-01-023/AC-01）：仅 liveJobs 非空时携带（startedAt 升序），
+				// 渲染层据此在标题行标注数量；任务本体以下一线条目呈现（kind: "job"）。
+				liveJobs: m.hasLive ? m.liveJobs : undefined,
+				selfRunning: m.row.running === true,
 				stateAt,
 				questionPreview: m.pending && m.row.pendingInteraction === "question" ? (questionPreview ?? null) : undefined,
 			});
+			// 后台任务子条目（R-01-023）：与子代理同形的缩进子卡，跟随母会话在其全部
+			// 子代理之前（即母亲条目的直接后继）；结束即随 liveJobs 清空而消失（R-01-023/AC-03）。
+			// 复合 id 在去重视野（entries/visited/cardsById）中唯一，且携 jobs 前缀与子代理
+			// 会话 id 空间天然隔离；层级连接线与子代理同规则参与 trackRuns（R-01-003/AC-04），
+			// 仍不参与徽标计数（kind 过滤，R-01-023/AC-04）。
+			if (m.hasLive && !m.isSub) {
+				for (const job of m.liveJobs) {
+					entries.push({
+						id: `job:${id}:${job.id}`,
+						parentId: id,
+						depth: depth + 1,
+						kind: "job",
+						title: job.label,
+						jobKind: job.kind,
+						workspaceTitle: "",
+						workspaceKey: "",
+						model: "",
+						reasoning: "",
+						timeline: [],
+						userPreview: "",
+						agentPreview: "",
+						isCurrent: false,
+						jobStatus: job.status,
+						jobStartedAt: job.startedAt,
+					});
+				}
+			}
 		}
 		for (const child of childIds.get(id) ?? []) visit(child, depth + 1);
 	};
@@ -1737,10 +1788,10 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 	return entries;
 }
 /**
- * 把活动条目压成母会话轨道运行（R-01-003/AC-04）：每个拥有可见直属子代理的
- * 母会话一条，记录全部可见直属子代理 id（有序，末位即末级）与子级深度，供
- * 渲染层测量后绘制整条连续轨道与接入横线。条目按 preorder 排列，同一直属
- * 子代理组天然连续。直属性按「条目深度 = 母会话条目深度 + 1」判定（与条目
+ * 把活动条目压成母会话轨道运行（R-01-003/AC-04）：每个拥有可见直属子代理或后台
+ * 任务子卡的母会话一条，记录全部可见直属子级 id（有序，末位即末级）与子级深度，
+ * 供渲染层测量后绘制整条连续轨道与接入横线。条目按 preorder 排列，同一直属
+ * 子级组天然连续。直属性按「条目深度 = 母会话条目深度 + 1」判定（与条目
  * 顺序无关）；无 id、无母会话条目或非直属的条目一律跳过。
  */
 function trackRuns(entries) {
@@ -1752,7 +1803,8 @@ function trackRuns(entries) {
 	const runs = new Map();
 	for (const entry of list) {
 		if (entry?.id == null || entry?.parentId == null || (entry.depth ?? 0) < 1) continue;
-		if (entry.kind !== "subagent") continue;
+		// 子代理与后台任务子卡一视同仁（R-01-003/AC-04）：两类直属子级同规则上轨。
+		if (entry.kind !== "subagent" && entry.kind !== "job") continue;
 		const pid = String(entry.parentId);
 		const parentDepth = depthById.get(pid);
 		if (parentDepth === undefined || entry.depth !== parentDepth + 1) continue;
@@ -1830,6 +1882,13 @@ function cardSignature(entries) {
 			entry.tokenStats ?? [entry.outputTokens ?? null, entry.inputTokens ?? null, entry.cacheHitPct ?? null, entry.rateTokS ?? null, entry.elapsedMs ?? null],
 			// 累计运行时长参与签名（R-01-020）：回填/SSE 推送与逐秒推进都要驱动重绘。
 			entry.totalBusyMs ?? null,
+			// 在跑后台任务（R-01-023）：任务视图随快照推送帧刷新，进入/退出在跑态驱动重绘；
+			// job 子卡状态翻转与秒桶（渲染期注入的任务行时长推进）同入签名。
+			entry.liveJobs ?? null,
+			entry.jobStatus ?? null,
+			// jobKind 不入签名（R-01-023/AC-05）：同一 jobId 的工具类型由发起方定死恒定，
+			// 签名分量永不变化；任务视图整体（liveJobs，含 kind）已随推送帧入签名。
+			entry.jobsAgeSec ?? null,
 		]),
 	);
 }
@@ -1952,6 +2011,52 @@ function entryErrorNote(completion) {
 	return typeof message === "string" && message !== "" ? message : ERROR_NOTE_FALLBACK;
 }
 
+// ---- 后台任务（R-01-023）：在跑活性归一 ----
+
+/** 在跑后台任务的活性状态全集（R-01-023）：stopping 视同在跑——停止请求已发出但
+ *  任务尚未结束，呈现与提醒抑制口径与 running 一致。 */
+const LIVE_JOB_STATUSES = new Set(["running", "stopping"]);
+
+/**
+ * 归一会话的在跑后台任务列表（R-01-023/AC-01）：取快照 `jobsBySession[id]` 中
+ * status ∈ {running, stopping} 的任务视图，按 startedAt 升序（最早在前）。
+ * jobsBySession 缺失、非记录、条目非记录或字段非法均按无任务/剔除处理，不抛错。
+ * 返回 `{ id, kind, label, status, startedAt }` 的新数组（不泄漏宿主对象引用；
+ * `kind` 为任务发起工具的类型原文，供任务卡工具名行消费，R-01-023/AC-05）。
+ */
+function liveJobsOf(jobsBySession, id) {
+	if (!isRecord(jobsBySession)) return [];
+	const list = jobsBySession[String(id)];
+	if (!Array.isArray(list)) return [];
+	const live = [];
+	for (const job of list) {
+		if (!isRecord(job)) continue;
+		if (!LIVE_JOB_STATUSES.has(job.status)) continue;
+		live.push({
+			id: typeof job.id === "string" ? job.id : "",
+			kind: typeof job.kind === "string" ? job.kind : "",
+			// label 纯空白视为任务内容不可得（R-01-023/AC-06 的数据源头）：不渲染空白行，
+			// 不以占位文本补位；非空白保留原文（不额外 trim，显示层忠实原文）。
+			label: typeof job.label === "string" && job.label.trim() !== "" ? job.label : "",
+			status: job.status,
+			startedAt: Number.isFinite(Number(job.startedAt)) ? Number(job.startedAt) : 0,
+		});
+	}
+	live.sort((a, b) => a.startedAt - b.startedAt);
+	return live;
+}
+
+/** 后台任务工具名的友好显示映射（R-01-023/AC-05）：bash→Bash、pwsh→PowerShell、
+ *  subagent→子代理；未知 kind 原样显示，非字符串或空串视为不可得（返回空串）。
+ *  与 client 渲染层 JOB_STATUS_LABELS（状态词文案）分层：本表居 core 因核心与
+ *  渲染两层共用且需 Node 单测钉住映射，状态词仅渲染层消费。 */
+const JOB_KIND_LABELS = { bash: "Bash", pwsh: "PowerShell", subagent: "子代理" };
+
+function jobKindLabel(kind) {
+	if (typeof kind !== "string" || kind === "") return "";
+	return JOB_KIND_LABELS[kind] ?? kind;
+}
+
 /**
  * 活动区→历史区迁移检测（R-01-010/AC-07）：上一帧活动区 id 在本帧离开活动区且出现于
  * 历史区即判定为一次迁移；彻底消失（归档、不再被会话服务列出）不判定。prevActiveIds 为上一帧
@@ -2299,7 +2404,7 @@ function createSessionEventSerializer() {
  * 也不入历史区。历史区不再按时间窗口或条数截断；turnEnds（id → 已知回合结束时刻）驱动
  * activityAt 精化（R-01-010、R-01-019）。
  */
-function buildRecent(snapshot, workspaceItems, now, detailsById = {}, archivedIds = [], completions = null, delegatingIds = null, turnEnds = null) {
+function buildRecent(snapshot, workspaceItems, now, detailsById = {}, archivedIds = [], completions = null, delegatingIds = null, turnEnds = null, jobsBySession = null) {
 	const byId = isRecord(snapshot) && isRecord(snapshot.byId) ? snapshot.byId : {};
 	const ids = Array.isArray(snapshot?.ids) ? snapshot.ids : [];
 	const current = snapshot?.current ?? null;
@@ -2317,6 +2422,8 @@ function buildRecent(snapshot, workspaceItems, now, detailsById = {}, archivedId
 		if (completionReminder(row, completionFor(id, completions), false)) continue; // 完成确认中，留在活动区
 		if (errorReminder(row, completionFor(id, completions), false)) continue; // 错误提醒中，留在活动区
 		if (delegatingIds instanceof Set && delegatingIds.has(String(id))) continue; // 委托周期中（含耗尽空窗），留在活动区
+		// 在跑后台任务（R-01-023/AC-01、AC-03）：留在活动区，不落入最近历史。
+		if (liveJobsOf(jobsBySession, id).length > 0) continue;
 		if (isActiveRow(row, byId, activeIds)) continue;
 		const updatedAt = Number(row.updatedAt);
 		if (!Number.isFinite(updatedAt)) continue;
@@ -2919,7 +3026,8 @@ const CSS = `
     .dap-token-stats,
     .dap-foot,
     .dap-history-line,
-    .dap-note
+    .dap-note,
+    .dap-job-content
   ) {
   display: none;
 }
@@ -3077,7 +3185,7 @@ const CSS = `
   gap: 4px;
   cursor: pointer;
 }
-/* 子代理层级连接线（R-01-003/AC-04）：竖轨与横线全部由轨道层整体绘制——
+/* 子代理与后台任务子卡层级连接线（R-01-003/AC-04）：竖轨与横线全部由轨道层整体绘制——
    syncTracks 测量各卡片浮点矩形，trackBoxes 统一取整到 CSS 像素后写入：
    每个母会话一条连续竖轨 .dap-conn-track（母会话底缘 → 末级子卡中心，
    含收口行），每个子卡一条横线 .dap-conn-stub（竖轨右缘 → 子卡左缘）。
@@ -3361,6 +3469,52 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
 }
 [data-dsh-activity-pane] .dap-token-time { flex: none; }
 [data-dsh-activity-pane] .dap-token-stats[hidden] { display: none; }
+/* 后台任务数量注（R-01-023/AC-01）：母卡标题行内「后台 ×N」小注，弱化色调不抢标题。 */
+[data-dsh-activity-pane] .dap-jobs-chip {
+  flex: none; font-size: 10px; line-height: 15px;
+  color: color-mix(in srgb, currentColor 55%, transparent);
+  font-variant-numeric: tabular-nums;
+}
+[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: 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）：状态点 + 工具名称 + 右缘随时钟时长；工具名不可得时
+   文本段隐藏，仅保留状态点与时长。 */
+[data-dsh-activity-pane] .dap-card[data-kind="job"] .dap-job-kind {
+  flex: 1 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  font-size: 11px; line-height: 15px;
+}
+[data-dsh-activity-pane] .dap-job-dot {
+  flex: none; width: 6px; height: 6px; border-radius: 50%;
+  background: #65a0ff;
+}
+[data-dsh-activity-pane] .dap-job-dot[data-status="stopping"] { background: #f5a524; }
+[data-dsh-activity-pane] .dap-job-elapsed {
+  flex: none; margin-left: auto; font-size: 10px; line-height: 15px;
+  color: color-mix(in srgb, currentColor 55%, transparent); font-variant-numeric: tabular-nums;
+}
+/* 任务内容行（R-01-023/AC-05、AC-06）：mono 原文单行省略，原生 tooltip 承载完整原文；
+   内容不可得时整行 hidden（[hidden] 显式覆盖 display:flex），紧凑档经密度规则隐藏。 */
+[data-dsh-activity-pane] .dap-job-content {
+  display: flex; align-items: baseline; min-width: 0;
+  margin-top: 1px;
+}
+[data-dsh-activity-pane] .dap-job-content[hidden] { display: none; }
+[data-dsh-activity-pane] .dap-card[data-kind="job"] .dap-job-label {
+  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;
+}
 [data-dsh-activity-pane] .dap-history-line {
   display: flex; align-items: center; gap: 4px; height: 15px;
   min-width: 0; overflow: hidden; white-space: nowrap;
@@ -3670,6 +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-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);
@@ -3991,6 +4154,8 @@ function apply(ctx) {
 		return promise;
 	}
 	const sessionOpenLoads = new Map();
+	/** 子代理目录按需拉取记账（T-151）：parentId → 已触发；失败不热重试（行为有界）。 */
+	const subagentCatalogRequests = new Set();
 
 	const style = document.createElement("style");
 	style.id = STYLE_ID;
@@ -4153,15 +4318,17 @@ function apply(ctx) {
 		}
 	}
 
-	/** 回到前台（含 bfcache 还原）时 ack 通道自愈：重建 SSE，借连接全量快照收敛。 */
-	function resumeAcksChannel() {
-		if (!disposed) connectAcksStream();
+	/** 回到前台（含 bfcache 还原）时 ack 通道自愈：重建 SSE（连接即发全量，状态必然收敛）。 */
+	function resumePushChannels() {
+		if (!disposed) {
+			connectAcksStream();
+		}
 	}
 	const onVisibilityResume = () => {
-		if (document.visibilityState === "visible") resumeAcksChannel();
+		if (document.visibilityState === "visible") resumePushChannels();
 	};
 	const onPageShow = (event) => {
-		if (event?.persisted === true) resumeAcksChannel();
+		if (event?.persisted === true) resumePushChannels();
 	};
 	document.addEventListener("visibilitychange", onVisibilityResume);
 	window.addEventListener("pageshow", onPageShow);
@@ -4324,20 +4491,34 @@ function apply(ctx) {
 		throw response?.error ?? new Error("remote request failed");
 	}
 
+	/** 母会话子代理目录条目查找（T-151 单源）：open 地址与深翻分页地址共用同一取法，
+	 *  防条目形状或键名演化时两处漂移。 */
+	function subagentCatalogEntry(subagentsByParent, parentId, id) {
+		const entries = subagentsByParent?.[String(parentId)]?.entries;
+		return Array.isArray(entries)
+			? entries.find((candidate) => String(candidate?.id) === String(id))
+			: undefined;
+	}
+
 	/** 会话日志分页地址（R-01-012）：主会话 `{kind:"session", sessionId}`；子代理
 	 *  `{kind:"subagent", parentSessionId, childSessionId, mode}`——母会话 id 兼容
-	 *  `parentSessionId` / `parentId` 两种条目键名，mode 无条目标注时按一次性子代理
-	 *  处理、读取失败由 pagedHistoryEvents 以 null 收敛为空白详情（R-01-013）。 */
-	function sessionPageAddress(id, byId) {
+	 *  `parentSessionId` / `parentId` 两种条目键名。mode 必须与子代理描述符一致，
+	 *  不一致被宿主以 subagent/unauthorized 拒绝（T-151）：优先取母会话目录条目的
+	 *  mode，目录条目缺失（未加载、在途空窗或无该子条目）时回退行 `continuable`
+	 *  启发（读取失败由 pagedHistoryEvents 以 null 收敛为空白详情，R-01-013）。 */
+	function sessionPageAddress(id, byId, subagentsByParent = null) {
 		const row = byId[id] ?? {};
 		if (row?.origin === "subagent") {
 			const parentId = row.parentSessionId ?? row.parentId;
 			if (parentId !== undefined && parentId !== null) {
+				const entry = subagentCatalogEntry(subagentsByParent, String(parentId), id);
 				return {
 					kind: "subagent",
 					parentSessionId: String(parentId),
 					childSessionId: String(id),
-					mode: row.continuable === true ? "continuable" : "one-shot",
+					mode: typeof entry?.mode === "string" && entry.mode !== ""
+						? entry.mode
+						: row.continuable === true ? "continuable" : "one-shot",
 				};
 			}
 		}
@@ -4433,7 +4614,8 @@ function apply(ctx) {
 		const sessionRemote = ctx.get("remote.session") ?? null;
 		if (!sessionRemote) return;
 		ensureCatalogGroups(sessionRemote);
-		const byId = getSnapshot(sessions, "list")?.byId ?? {};
+		const listSnap = getSnapshot(sessions, "list");
+		const byId = listSnap?.byId ?? {};
 		const historyPromises = [];
 		for (const id of ids) {
 			const detail = sessionDetailsById.get(id) ?? {};
@@ -4445,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);
@@ -4464,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;
@@ -4473,11 +4662,15 @@ function apply(ctx) {
 			if (deepReadNeeded && !historyLoads.has(id)) {
 				detail.previewFallbackLoaded = true;
 				detail.durationFallbackLoaded = true;
-				const address = sessionPageAddress(id, byId);
+				const address = sessionPageAddress(id, byId, listSnap?.subagentsByParent ?? null);
 				const promise = enqueueDetailLoad(() => Promise.resolve()
 					.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 }),
 								);
@@ -4485,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;
@@ -4506,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 注）。
@@ -4543,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 只订阅运行中），窗口推进（回合收尾、流式尾）必须经此回调
 		// 重读快照并重绘；否则窗口更新只能靠渲染期重读兜底——渲染一旦静默（一次性
@@ -4567,6 +4807,8 @@ function apply(ctx) {
 			// 不可知，只以 openState 把关会对已水合会话逐帧重发 open，settle→delete→重发
 			// 的在途翻转同样驱动加载指示抖动（docsim 卡闪烁根因之一）。
 			if (!detail.log && detail.snapshot?.openState !== "open" && !sessionOpenLoads.has(id) && typeof session.open === "function") {
+				// 子代理事件流仅接受持久父地址：open 前先安装（T-151），否则宿主拒绝、窗口永不水合。
+				ensureSubagentAddress(id, session);
 				const opening = Promise.resolve(session.open()).catch(() => {});
 				sessionOpenLoads.set(id, opening);
 				opening.finally(() => {
@@ -4606,6 +4848,53 @@ function apply(ctx) {
 		queueSync();
 	}
 
+	/** 触发母会话子代理目录单发读取（T-151）：目录条目是地址 mode 的唯一可靠来源，
+	 *  未加载时先拉取，目录随下一轮快照到达；每次拉取经原生 sessions.refreshSubagents
+	 *  走既有 remote 通道，单父会话单飞、不重试，不构成轮询（R-02-004）。 */
+	function requestSubagentCatalog(parentId) {
+		if (typeof sessions?.refreshSubagents !== "function") return;
+		if (subagentCatalogRequests.has(parentId)) return;
+		subagentCatalogRequests.add(parentId);
+		try {
+			Promise.resolve(sessions?.refreshSubagents?.(parentId))
+				.catch(() => {})
+				.finally(() => {
+					if (!disposed) queueSync();
+				});
+		} catch {
+			subagentCatalogRequests.delete(parentId);
+		}
+	}
+
+	/** 子代理会话事件流打开前置（T-151 缺陷修复）：dsh 0.1.5 起宿主按地址校验会话事件
+	 *  流路由——子代理会话仅接受持久父地址，且地址 mode 必须与其描述符一致（不一致被
+	 *  subagent/unauthorized 拒绝），持久地址仅经原生导航留存。mode 唯一可靠来源是母
+	 *  会话的子代理目录条目：在册即经 configureSubagent 安装（与原生 selectSubagent
+	 *  同构，但不切换当前会话）；目录未加载时先单发拉取并跳过本轮安装，避免装入必被
+	 *  拒绝的错误 mode 地址；目录拉取失败沿用既有空白详情路径（深翻以 null 收敛），
+	 *  不阻断其余卡片。非子代理行或会话对象缺 configureSubagent 时为无操作。 */
+	function ensureSubagentAddress(id, session) {
+		const listSnap = getSnapshot(sessions, "list");
+		const byId = listSnap?.byId ?? {};
+		if (!isSubagentRow(byId[id], byId)) return;
+		if (typeof session?.configureSubagent !== "function") return;
+		const parentId = String(byId[id].parentSessionId ?? byId[id].parentId);
+		const catalog = isRecord(listSnap?.subagentsByParent) ? listSnap.subagentsByParent[parentId] : null;
+		const entry = subagentCatalogEntry(listSnap?.subagentsByParent ?? null, parentId, id);
+		if (!isRecord(entry) || typeof entry.mode !== "string" || entry.mode === "") {
+			requestSubagentCatalog(parentId);
+			return;
+		}
+		try {
+			session.configureSubagent(
+				{ kind: "subagent", parentSessionId: parentId, childSessionId: String(id), mode: entry.mode },
+				typeof catalog?.parentAvailable === "boolean" ? catalog.parentAvailable : undefined,
+			);
+		} catch {
+			// 安装失败沿用既有空白详情路径，不阻断其余卡片。
+		}
+	}
+
 	/** 部署级模型目录一次性读取（R-01-012/AC-01）：dsh 0.1.5 起 per-session models
 	 *  RPC 移除，目录经 `remote.session.modelCatalog()` 无参数读取；成功即缓存不再
 	 *  重发，失败留待下轮详情读取重试。 */
@@ -4803,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 重建；
 			// 锚定补偿在本轮渲染提交后执行，此时量测才含新行高
@@ -5029,8 +5321,17 @@ function apply(ctx) {
 			foot.append(awaitHead, noteRow);
 			return [head, row, makeEl("div", "dap-trace"), makeStatsRow(), foot];
 		}
+		if (kind === "job") {
+			// 后台任务子卡（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");
+			content.append(makeEl("span", "dap-job-label"));
+			return [row, content];
+		}
 		const row = makeEl("div", "dap-row");
-		row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"), makeEl("span", "dap-total-time"));
+		row.append(makeEl("span", "dap-dot"), makeEl("span", "dap-title"), makeEl("span", "dap-jobs-chip"), makeEl("span", "dap-total-time"));
 		const progressRow = makeProgressRow();
 		return [head, row, makeEl("div", "dap-trace"), progressRow, makeStatsRow()];
 	}
@@ -5511,6 +5812,60 @@ function apply(ctx) {
 		renderTrace(container, entry.timeline, { lastOnly });
 	}
 
+	/** 后台任务状态的两字中文短语（R-01-023 呈现）：与原生 ui-jobs 状态词同口径。 */
+	const JOB_STATUS_LABELS = { running: "运行中", stopping: "停止中", completed: "已完成", killed: "已终止", failed: "失败" };
+
+	/** 后台任务数量注（R-01-023/AC-01）：母卡标题行内 `后台 ×N` 小注；任务本体以 job
+	 *  子卡呈现（R-01-023），本注仅承载数量语义。无 liveJobs 时隐藏节点。 */
+	function renderJobsChip(el, entry) {
+		const chip = el.querySelector(".dap-jobs-chip");
+		if (chip === null) return;
+		const count = Array.isArray(entry.liveJobs) ? entry.liveJobs.length : 0;
+		const text = count > 0 ? `后台 ×${count}` : "";
+		if (chip.textContent !== text) chip.textContent = text;
+		const hidden = count === 0;
+		if (chip.hidden !== hidden) chip.hidden = hidden;
+	}
+
+	/** 后台任务子卡渲染（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;
+		// 工具名称（R-01-023/AC-05）：核心友好映射；不可得时隐藏文本段，仅保留状态点与时长。
+		const kindEl = el.querySelector(".dap-job-kind");
+		if (kindEl !== null) {
+			const kindText = jobKindLabel(entry.jobKind);
+			if (kindEl.textContent !== kindText) kindEl.textContent = kindText;
+			const kindHidden = kindText === "";
+			if (kindEl.hidden !== kindHidden) kindEl.hidden = kindHidden;
+		}
+		// 任务内容行（R-01-023/AC-05、AC-06）：mono 原文单行省略，完整原文以原生 tooltip
+		// 显示（tooltip 归内容行）；内容不可得时整行隐藏，不补空白或占位。
+		const contentRow = el.querySelector(".dap-job-content");
+		const labelText = String(entry.title ?? "");
+		if (contentRow !== null) {
+			const contentHidden = labelText === "";
+			if (contentRow.hidden !== contentHidden) contentRow.hidden = contentHidden;
+			if (!contentHidden) {
+				const label = contentRow.querySelector(".dap-job-label");
+				if (label !== null) {
+					if (label.textContent !== labelText) label.textContent = labelText;
+					if (label.title !== labelText) label.title = labelText;
+				}
+			}
+		}
+		const elapsed = el.querySelector(".dap-job-elapsed");
+		if (elapsed !== null) {
+			const elapsedText =
+				Number.isFinite(entry.jobStartedAt) && entry.jobStartedAt > 0
+					? fmtElapsedMs(Math.max(0, Date.now() - entry.jobStartedAt))
+					: "";
+			if (elapsed.textContent !== elapsedText) elapsed.textContent = elapsedText;
+		}
+	}
+
 	function renderCardInto(el, entry, colorByWorkspace) {
 		const workspaceLabel = el.querySelector(".dap-workspace");
 		if (workspaceLabel !== null) {
@@ -5624,19 +5979,43 @@ function apply(ctx) {
 		}
 
 		if (entry.kind === "running") {
-			renderProgressRow(el, entry.progress);
+			// 仅在跑后台任务（R-01-023/AC-01）：呈现冻结——隐藏进度行（进度/条纹为回合运行
+			// 语义，不冒充回合执行），时间线保留最后已知状态；任务本体以 job 子卡呈现。
+			const jobsOnly = Array.isArray(entry.liveJobs) && entry.liveJobs.length > 0 && entry.selfRunning !== true;
+			renderJobsChip(el, entry);
+			const progressRow = el.querySelector(".dap-progress");
+			// 档位资源纪律（R-01-025/AC-05）：进度行在中间/紧凑档被 CSS 隐藏，不写入；
+			// 切回完整档后随档位签名重渲染恢复。
+			if (progressRow !== null && densityLevel === "full") {
+				if (jobsOnly) {
+					if (!progressRow.hidden) progressRow.hidden = true;
+				} else {
+					renderProgressRow(el, entry.progress);
+					if (progressRow.hidden) progressRow.hidden = false;
+				}
+			}
 			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;
+		}
+
+		if (entry.kind === "job") {
+			renderJobCardInto(el, entry);
 			return;
 		}
 
 		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;
@@ -5644,7 +6023,7 @@ function apply(ctx) {
 					progressRow.hidden = true;
 				}
 			}
-			renderTokenStats(el, entry);
+			if (densityLevel === "full") renderTokenStats(el, entry);
 			return;
 		}
 
@@ -5665,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 变化会重建骨架）。
@@ -5741,10 +6124,20 @@ function apply(ctx) {
 			} catch {
 				continue; // 订阅失败：本次跳过，下次渲染重试
 			}
-			try {
-				opening = session.open?.();
-			} catch {
-				opening = null;
+			// 子代理事件流仅接受持久父地址：open 前先安装（T-151），否则宿主拒绝、窗口永不水合。
+			ensureSubagentAddress(id, session);
+			// 档位资源纪律（R-01-025/AC-01）：紧凑档主会话不发起 open 水合——轮内状态
+			// 订阅（本函数职责，R-02-004）保留，liveness 记账与正常路径共用下方代码，
+			// 日志窗口水合在切回更高档位后经渲染期重试重建。子代理模型上下文依赖其
+			// 窗口，不裁剪（单点判定见 logWindowSuppressedFor）。
+			const livenessSuppressed = logWindowSuppressedFor(id);
+			let opening = null;
+			if (!livenessSuppressed) {
+				try {
+					opening = session.open?.();
+				} catch {
+					opening = null;
+				}
 			}
 			if (opening && typeof opening.then === "function") {
 				const tracked = Promise.resolve(opening).then(
@@ -5963,7 +6356,11 @@ function apply(ctx) {
 		if (rec === undefined) {
 			const el = document.createElement("div");
 			el.className = CARD_CLASS;
-			const unbind = bindCardActivation(el, (sessionId) => {
+			// 后台任务子卡为纯展示（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;
 				// 新激活意图取代一切旧重试链，避免过期链条稍后把当前会话拽回旧目标；
@@ -5992,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;
 		}
@@ -6007,10 +6410,13 @@ function apply(ctx) {
 			rec.el.setAttribute("data-wait", entry.waitClass);
 		else rec.el.removeAttribute("data-wait");
 		const recentTimeText = entry.kind === "recent" ? fmtRecentTime(entry.activityAt) : "";
+		const jobStatusText = entry.kind === "job" ? JOB_STATUS_LABELS[entry.jobStatus] ?? "" : "";
+		const jobKindText = entry.kind === "job" ? jobKindLabel(entry.jobKind) : "";
 		rec.el.setAttribute(
 			"aria-label",
-			`${entry.workspaceTitle ? entry.workspaceTitle + " - " : ""}${entry.title}${
-				entry.pendingText ? "，" + entry.pendingText : ""
+			`${entry.workspaceTitle ? entry.workspaceTitle + " - " : ""}${jobKindText ? jobKindText + "，" : ""}${entry.title}${
+				jobStatusText ? "，" + jobStatusText : ""
+			}${entry.pendingText ? "，" + entry.pendingText : ""
 			}${(entry.waitClass === "done" || entry.waitClass === "error") && entry.noteText ? "，" + entry.noteText : ""}${
 				recentTimeText ? "，" + recentTimeText : ""
 			}`,
@@ -6292,7 +6698,10 @@ function apply(ctx) {
 		for (const [id, record] of busyById) {
 			if (typeof record?.openWaitStart === "number") waitingStarts.set(String(id), record.openWaitStart);
 		}
-		const active = buildEntries(snapshot, workspaceItems, sessionDetailsById, completeAcksById, delegatingIds, archivedSessionIds, waitingStarts);
+		// 在跑后台任务（R-01-023）：jobsBySession 快照注入 buildEntries/buildRecent——
+		// liveJobs 非空的主会话保留活动区、归运行组并抑制完成/错误提醒。
+		const jobsBySession = isRecord(snapshot) && isRecord(snapshot.jobsBySession) ? snapshot.jobsBySession : null;
+		const active = buildEntries(snapshot, workspaceItems, sessionDetailsById, completeAcksById, delegatingIds, archivedSessionIds, waitingStarts, jobsBySession);
 		// 轮内订阅仅对"运行中"会话建立（主会话 + 运行中的子代理），保持在运行中的订阅
 		// 数量 == 运行中会话数量（R-02-004/AC-01）；暂停等待的子代理只显示标题。
 		const runLikeIds = new Set(
@@ -6301,7 +6710,7 @@ function apply(ctx) {
 		// 运行卡时钟：运行中子代理卡同样承载逐秒推进的进度与时长（R-01-009/AC-14）。
 		syncLiveness(
 			runLikeIds,
-			active.some((entry) => entry.kind === "running" || (entry.kind === "subagent" && runLikeIds.has(entry.id))),
+			active.some((entry) => entry.kind === "running" || entry.kind === "job" || (entry.kind === "subagent" && runLikeIds.has(entry.id))),
 		);
 		for (const entry of active) {
 			const liveRecord = livenessById.get(entry.id);
@@ -6464,7 +6873,7 @@ function apply(ctx) {
 			}
 			if (detail.memoTurnEnd != null) turnEnds[id] = detail.memoTurnEnd;
 		}
-		const recentCandidates = buildRecent(snapshot, workspaceItems, now, sessionDetailsById, archivedSessionIds, completeAcksById, delegatingIds, turnEnds);
+		const recentCandidates = buildRecent(snapshot, workspaceItems, now, sessionDetailsById, archivedSessionIds, completeAcksById, delegatingIds, turnEnds, jobsBySession);
 		recentTotal = recentCandidates.length;
 		const recent = recentCandidates.slice(0, recentVisibleCount);
 		recentHasMore = recent.length < recentTotal;
@@ -6529,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 广播推送。
@@ -6556,6 +6969,13 @@ function apply(ctx) {
 		const awaitAgeSignature = active
 			.filter((entry) => entry.kind === "awaiting")
 			.map((entry) => entry.awaitAge ?? "");
+		// job 子卡的任务行时长随 1 秒时钟推进（R-01-023/AC-01）：秒桶注入渲染签名，
+		// 与运行卡 totalBusyMs 的逐秒重绘同节奏，不新增时钟。
+		for (const entry of visibleEntries) {
+			if (entry.kind === "job") {
+				entry.jobsAgeSec = Math.floor(Date.now() / 1000);
+			}
+		}
 		const sig = JSON.stringify([listState, cardSignature(visibleEntries), pulseSurface, recentTimeSignature, awaitAgeSignature, densityLevel]);
 		if (sig === lastSig) return;
 		const colorByWorkspace = resolveWorkspaceColors(visibleEntries.map((entry) => entry.workspaceKey));