dsh-activity-pane 0.14.0 → 0.16.0

package/.dsh-plugin/client.js

@@ -7,13 +7,16 @@ window.__ModuleLoader__.load({
 // dsh-activity-pane 核心纯函数：把 DSH 原生 sessions/workspaces 客户端服务
 // 快照映射成窗格里的"活动会话条目"。这一层不触碰 DOM，可单测。
 //
-// 数据源约定（来自 @deepseek-ai/dsh-client-runtime 的 sessions.list 快照）：
+// 数据源约定（来自 @deepseek-ai/dsh-api-session-controller 0.2.0 的 sessions.list 快照）：
 //   ids: SessionId[]                     —— 宿主列表顺序（祖先在前的 lineage 顺序）
-//   byId[id]: { id, displayTitle, title?, cwd?, parentId?, origin?, running, completed?,
-//              pendingInteraction?: 'approval'|'plan-review'|'question', blank, ... }
-//   current: SessionId | undefined
-//   subagentsByParent: { [parentId]: { entries: [{ id, label, ... }] } }
-//   jobsBySession: { [sessionId]: JobView[] }
+//   byId[id]: { id, displayTitle, title?, cwd?, parentId?, origin?, running,
+//              retainedBy: { [source]: count }, blank, updatedAt, ... }
+//   current                              —— 0.2.0 起不再携带：以行上 retainedBy.mainView > 0
+//                                           推导（宿主外壳 DocumentTitle / UiSession
+//                                           .publishMain / isMain 同款口径，currentIdOf）
+//   projectionsBySession[id]: { values: { subagentCatalog?: SubagentCatalogEntry[] },
+//                                state: 'idle'|'loading'|'ready'|'error' }
+//   jobsBySession: { [sessionId]: JobView[] }（来自 jobs 服务 state.rows，watchRows 订阅）
 // 以及 workspaces.list 的 items: [{ title, path, sessionIds }]。
 //
 // 展示规则：
@@ -152,6 +155,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);
 }
@@ -1517,12 +1529,42 @@ function instructionTime(row) {
 	return Number.isFinite(time) ? time : -1;
 }
 
-/** 子代理的展示标题：优先目录 label，其次 displayTitle，兜底 "子任务"。 */
-function subagentTitle(parentId, id, byId, subagentsByParent = {}) {
-	const entries = subagentsByParent[parentId]?.entries;
-	const entry = Array.isArray(entries)
-		? entries.find((candidate) => String(candidate?.id) === String(id))
-		: undefined;
+/**
+ * 当前会话 id 推导（dsh 0.2.0 起 sessions.list 不再携带 current）：取行上
+ * `retainedBy.mainView` 引用计数 > 0 的首行。与宿主外壳同款口径——client-ui-layout
+ * DocumentTitle、client-ui-session publishMain/isMain 均以该判定取当前会话。
+ * 快照非记录、行缺 retainedBy 或计数非有限数字均按未命中处理，不抛错。
+ */
+function currentIdOf(list) {
+	const byId = isRecord(list) && isRecord(list.byId) ? list.byId : {};
+	for (const row of Object.values(byId)) {
+		if (!isRecord(row) || !isRecord(row.retainedBy)) continue;
+		const count = Number(row.retainedBy.mainView);
+		if (Number.isFinite(count) && count > 0) return typeof row?.id === "string" ? row.id : null;
+	}
+	return null;
+}
+
+/**
+ * 母会话子代理目录条目读取（dsh 0.2.0 起 subagentsByParent 移除）：取列表快照
+ * `projectionsBySession[parentId].values.subagentCatalog`（SubagentCatalogEntry[]
+ * —— `{ id, createdAt, mode: 'one-shot'|'continuable'|'unknown', label? }`）。
+ * 投影未加载（无该键、state 非就绪或 values 缺键）按目录不可得返回 undefined，
+ * 调用方经 sessions.refreshProjections(parentId) 拉取后重试。
+ */
+function subagentCatalogOf(projectionsBySession, parentId) {
+	if (!isRecord(projectionsBySession)) return undefined;
+	const snapshot = projectionsBySession[String(parentId)];
+	const entries = isRecord(snapshot) ? snapshot.values?.subagentCatalog : undefined;
+	return Array.isArray(entries) ? entries : undefined;
+}
+
+/** 子代理的展示标题：优先目录 label，其次 displayTitle，兜底 "子任务"。
+ *  第 4 参为 0.2.0 的列表快照 `projectionsBySession`（旧 subagentsByParent 移除）。 */
+function subagentTitle(parentId, id, byId, projectionsBySession = {}) {
+	const entry = subagentCatalogOf(projectionsBySession, parentId)?.find(
+		(candidate) => String(candidate?.id) === String(id),
+	);
 	const label = cleanText(entry?.label);
 	if (label) return label;
 	const display = cleanText(byId[id]?.displayTitle);
@@ -1566,14 +1608,14 @@ 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 : {};
 	const ids = Array.isArray(snapshot?.ids) ? snapshot.ids : [];
-	const current = snapshot?.current ?? null;
-	const subagentsByParent = isRecord(snapshot?.subagentsByParent)
-		? snapshot.subagentsByParent
+	const current = currentIdOf(snapshot);
+	const projectionsBySession = isRecord(snapshot?.projectionsBySession)
+		? snapshot.projectionsBySession
 		: {};
 	const archived = archivedIds instanceof Set
 		? new Set([...archivedIds].map((id) => String(id)))
@@ -1707,7 +1749,7 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 							: "awaiting",
 				descendantActive: m.descendantActive,
 				title: m.isSub
-					? subagentTitle(parentId, id, byId, subagentsByParent)
+					? subagentTitle(parentId, id, byId, projectionsBySession)
 					: mainTitle(byId, id),
 				workspaceTitle: workspace.title,
 				workspaceKey: workspace.key,
@@ -1743,7 +1785,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 +1807,6 @@ function buildEntries(snapshot, workspaceItems, detailsById = {}, completions =
 						userPreview: "",
 						agentPreview: "",
 						isCurrent: false,
-						jobId: job.id,
 						jobStatus: job.status,
 						jobStartedAt: job.startedAt,
 					});
@@ -2003,11 +2044,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 +2090,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 为上一帧
@@ -2496,7 +2440,7 @@ function createSessionEventSerializer() {
 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;
+	const current = currentIdOf(snapshot);
 	const items = Array.isArray(workspaceItems) ? workspaceItems : [];
 	const activeIds = activeSessionIds(byId);
 	const archived = archivedIds instanceof Set ? archivedIds : new Set(archivedIds ?? []);
@@ -2743,13 +2687,16 @@ function shouldDismissDrawerOnActivation({ targetId, currentId, mobile, drawerOp
 }
 
 /**
- * 调用 DSH 原生会话导航；由调用方决定失败后的 refresh/retry 策略。
- * 不读取 sessions.list，避免用另一份可能已过期的快照拦截跳转。
+ * 调用 DSH 原生会话导航（dsh 0.2.0，T-159）：经 uiWorkspace.openSession 发起
+ * 「选中会话并显示其 Conversation」的导航动作（内部以 source "mainView" retain
+ * 并驱动外壳 selection；替代 0.2.0 已删除的 sessions.open）。发起为 void 且可被
+ * 后续导航取代，是否到达由调用方的 currentId 重试链判定；target 亦接受子代理
+ * 持久父地址（SessionTarget）。服务缺失返回 false，由调用方决定重试策略。
  */
-function openSession(sessions, sessionId) {
-	if (typeof sessions?.open !== "function") return false;
+function openSession(uiWorkspace, target) {
+	if (typeof uiWorkspace?.openSession !== "function") return false;
 	try {
-		sessions.open(sessionId);
+		uiWorkspace.openSession(target);
 		return true;
 	} catch {
 		return false;
@@ -2846,15 +2793,26 @@ function bindBackdropDismiss(backdrop, dismiss) {
 //
 // 数据来源：DSH 原生 `sessions` / `workspaces` 客户端服务（推送式快照）+ `remote`
 // 服务的部署级模型目录（session/modelCatalog）与会话日志分页（session/page，
-// Session 格式 V3——dsh 0.1.5 起快照不再携带会话内容、connection.api 门面移除）+
-// 运行中会话的原生订阅（binding().session，运行状态面）+ 可选 `modelDirectories`
-// 目录 store 订阅（模型选择实时更新），不依赖任何第三方插件数据路由，也不做状态轮询。
+// Session 格式 V3——快照不再携带会话内容、connection.api 门面移除）+ `jobs` 服务的
+// 会话任务 roster（watchRows/state.rows，0.2.0 起 jobsBySession 自列表快照移除）+
+// `uiSession.sessionStatus` 统一状态面（running/pendingInteraction/completionUnread，
+// 0.2.0 取代 pendingInteractions）+ 运行中会话的原生订阅（retain 引用的 binding，
+// 运行状态面与 eventSource 日志窗口）+ 可选 `modelDirectories` 目录 store 订阅
+// （模型选择实时更新），不依赖任何第三方插件数据路由，也不做状态轮询。
+//
+// 会话代际生命周期（dsh 0.2.0，T-170）：`binding()` 只借用已保留代际，插件经
+// `sessions.retain(target, { source: "dsh-activity-pane" })` 显式持有可见卡片的
+// 会话引用（子代理以 `sessions.subagentAddress()` 解析的持久父地址为 target），
+// `reference.ready` 落定后接线 binding.eventSource 日志窗口与 session 运行态订阅；
+// 引用随可见性 prune、紧凑档拆窗、服务代际更替与卸载释放。
 
 const name = "dsh-activity-pane";
-// remote.session：dsh 0.1.5 起会话 RPC（目录/日志分页）经 api-remotes 的点分命名空间
-// 注入（cordis 代理对未注入属性直接抛错，父服务声明不代表子命名空间可用；仅声明
-// 子命名空间即可解析，无需再注入父面）。
-const inject = ["sessions", "workspaces", "uiSession", "remote.session"];
+// remote.session：会话 RPC（目录/日志分页）经 api-remotes 的点分命名空间注入
+// （cordis 代理对未注入属性直接抛错，父服务声明不代表子命名空间可用；仅声明
+// 子命名空间即可解析，无需再注入父面）。jobs/uiWorkspace：0.2.0 起后台任务
+// roster 与会话导航分别由 jobs 服务（dsh-api-job-controller client 半面）与
+// uiWorkspace.openSession（dsh-client-ui-workspace）承载。
+const inject = ["sessions", "workspaces", "uiSession", "remote.session", "jobs", "uiWorkspace"];
 
 const CONVERSATION_SELECTOR = "#root [data-slot=\"main\"]";
 const PANE_ATTR = "data-dsh-activity-pane";
@@ -2977,8 +2935,10 @@ const CSS = `
   -webkit-overflow-scrolling: touch;
   padding: 0 0 10px;
   /* Keep the native scrollbar just left of the edge handle, as in the host
-     sidebar; stable keeps the list geometry unchanged when overflow appears. */
-  margin-right: var(--dsh-scrollbar-width, 8px);
+     sidebar; stable keeps the list geometry unchanged when overflow appears.
+     max() 下限 = 调宽手柄宽度（6px）：dsh 0.2.0 起宿主 scrollbar-width token
+     收窄到 5px，裸 token 会让手柄压住滚动条命中区（T-170）。 */
+  margin-right: max(var(--dsh-scrollbar-width, 8px), 6px);
   scrollbar-gutter: stable;
 }
 /* 滚动条在滚动或鼠标进入窗格时显示（R-01-004/AC-03，与外壳侧栏一致）：thumb 默认透明，
@@ -3566,24 +3526,39 @@ 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;
 }
-/* 任务卡行 1（R-01-023/AC-05）：状态点 + 工具名称 + 右缘随时钟时长；工具名不可得时
-   文本段隐藏，仅保留状态点与时长。 */
+[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、AC-09）：状态点 + 工具名称 + 右缘随时钟时长；工具名不可得时
+   文本段隐藏，仅保留状态点与时长。状态点活性脉冲（AC-09）：与运行中主会话卡标题状态点
+   同源同节奏（dap-pulse 1.2s），光晕与着色同色相——运行中任务蓝、停止中琥珀。 */
 [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%;
+}
+[data-dsh-activity-pane] .dap-job-dot[data-status="running"] {
   background: #65a0ff;
+  box-shadow: 0 0 6px rgba(101, 160, 255, 0.8);
+}
+[data-dsh-activity-pane] .dap-job-dot[data-status="stopping"] { background: #f5a524; box-shadow: 0 0 6px rgba(245, 165, 36, 0.8); }
+/* 活性门控（AC-09）：着色、光晕与脉冲只作用于 running/stopping 两个在跑状态，AC 条件由
+   CSS 显式表达，不依赖「liveJobs 只收 running/stopping」的跨层隐式前提（双轴复审修复）。 */
+[data-dsh-activity-pane] .dap-job-dot[data-status="running"],
+[data-dsh-activity-pane] .dap-job-dot[data-status="stopping"] {
+  animation: dap-pulse 1.2s ease-in-out infinite;
 }
-[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;
@@ -3599,23 +3574,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;
@@ -3822,26 +3780,67 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
 .dap-toggle .dap-toggle-count .dap-spinner {
   vertical-align: middle;
 }
-/* 移动端浮动开关按钮：仅在窄屏显示（桌面隐藏）。固定于会话头部左上角、
-   原生左边栏切换按钮（28px @ left:8px; top:12px）右侧（R-01-008/AC-04）。 */
+/* 移动端「活动」开关按钮：仅在窄屏显示（桌面隐藏）。呈紧凑形态（仅计数徽标，
+   无图标与文字标签，T-162）——面板图标被东家误读为边栏按钮，撤销）。常态嵌入
+   宿主头部的标题行行首作为布局子项参与排布（R-01-008/AC-04，T-163；视觉上位于
+   左边栏切换按钮右侧，其余头部控件被真实后挤）；标题行不可得且宿主侧栏展开按钮
+   在屏时落位 hero 形态贴靠该按钮右侧（T-167）。落位由 placeToggle 驱动
+   （data-embedded / data-hero 属性承载）；未落位的开关不进入 DOM（不可嵌即不
+   渲染，C-093）。本基规则不再携带 fixed 定位与高层级 z-index：按钮处于 flex
+   容器时其 z-index 即使 static 也生效（CSS Flexbox 规范），高层级声明曾使嵌入
+   态整体逃逸宿主抽屉之上（T-167 根因）。按钮本体无外层胶囊壳：不携带底色、
+   描边与投影（T-168，东家指示只留内部涂色的计数胶囊），可见形态即
+   .dap-toggle-count 徽标本体；border:none 与 background:none 显式压掉 UA
+   默认按钮壳——appearance:none 不摘除 UA 声明的边框与底色，WebKit 探针实测
+   漏出 2px 灰壳；外层命中盒最小 44×38px，内层计数徽标最小 36×24px，
+    计数文字 12px、水平 padding 8px（R-01-008/AC-07、C-095）。
+   width:max-content + appearance:none + max-width:64px 显式钉宽并钳硬上限；
+   两位计数时外层命中盒保持至少 44px 宽，较长计数沿既有上限处理。 */
 .dap-toggle {
-  position: fixed; top: 12px; left: 44px; z-index: 2147482991;
   display: none;
-  align-items: center; gap: 6px;
-  min-height: 30px; padding: 0 11px;
-  border: 1px solid color-mix(in srgb, currentColor 18%, transparent);
-  border-radius: 999px;
-  background: rgba(24, 28, 38, 0.94);
-  color: currentColor;
+  align-items: center; gap: 5px;
+  min-width: 44px; height: 38px; min-height: 38px; padding: 0;
+  appearance: none; white-space: nowrap; width: max-content; max-width: 64px;
+  box-sizing: border-box;
+  border: none; background: none;
   font-size: 12px; font-weight: 600;
   cursor: pointer;
-  box-shadow: 0 6px 16px rgba(0,0,0,.34);
+}
+/* 嵌入态：回归文档流参与标题行排布；flex:none + width:max-content +
+   max-width:64px 在此重复声明是特异度保险——宿主样式表的 (0,1,1) 级后代规则
+   可压过 0-1-0 的基规则，嵌入态处于宿主子树内必须自带 (0,2,0) 钉宽；min-width
+   44px、height 38px 与宿主移动控件对齐；右缘 8px 与标题簇分隔。z-index:1 为层级归位
+   （T-167）：flex 子项的 z-index 即使 static 也生效，置 1 使按钮略高于行内
+   兄弟、仍远低于宿主任何覆盖层（移动壳层抽屉 1300 / 遮罩 1250 / 菜单 1100），
+   抽屉滑入即被正常遮挡；同时免疫宿主 header 内 absolute 装饰的意外覆盖。 */
+.dap-toggle[data-embedded] {
+  position: static;
+  margin-right: 8px;
+  flex: none;
+  width: max-content; max-width: 64px; min-width: 44px;
+  height: 38px; min-height: 38px;
+  z-index: 1;
+}
+/* hero 形态（T-167）：标题行不可得（宿主 data-phase="hero"，英雄页/空白会话）
+   时贴靠宿主侧栏展开按钮（dsh-web-mobile ⊡，data-mobile-nav="fab"/"toggle"）
+   右侧 8px 并垂直居中，几何由 placeToggle 内联钉死（T-164 策略），此处承载
+   position 缺省。z-index:1060 等同页面内容层：低于壳层遮罩（1250）、宿主抽屉
+   （1300）与宿主菜单（1100，抽屉打开期间壳层把宿主浮层抬至 1400 同样盖住它），
+   抽屉滑入即被逐步遮挡；数值耦合 dsh-web-mobile 层契约，壳层改版会漂移，记录
+   为边界（同 T-165 判据耦合）。 */
+.dap-toggle[data-hero] {
+  position: absolute;
+  z-index: 1060;
 }
 .dap-toggle .dap-toggle-count {
-  min-width: 16px; text-align: center; border-radius: 999px;
+  display: inline-flex; align-items: center; justify-content: center;
+  box-sizing: border-box; min-width: 36px; max-width: 64px; height: 24px;
+  line-height: 24px; text-align: center; border-radius: 999px;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
   background: color-mix(in srgb, currentColor 16%, transparent);
-  padding: 0 5px; font-size: 10px; font-weight: 700;
+  padding: 0 8px; font-size: 12px; font-weight: 700;
 }
+/* 徽标等待态：执行色底 + 呼吸动画（有待执行行动时点亮）。 */
 .dap-toggle[data-awaiting] .dap-toggle-count {
   background: rgba(46, 42, 26, 0.97);
   animation: dap-await-pulse 1.2s ease-in-out infinite;
@@ -3904,12 +3903,18 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
      body，不落本规则，浮动开关徽标脉冲（R-01-002/AC-06、AC-07）照常。 */
   [data-dsh-activity-pane]:not([data-open="true"]) { content-visibility: hidden; }
   .dap-backdrop[data-drawer-open] { display: block; }
-  .dap-toggle { display: flex; }
-  .dap-toggle[data-drawer-open] { display: none; }
+  /* 开关显隐改为落位属性驱动（T-167）：嵌入态/hero 态各自 display:flex，
+     未落位（不在 DOM）自然不显示；fixed 兜底形态已去除。 */
+  .dap-toggle[data-embedded] { display: flex; }
+  .dap-toggle[data-hero] { display: flex; }
+  /* 插件抽屉打开时开关留位隐藏：visibility 不可见且不可命中（满足 AC-05 隐藏），
+     标题行不因开合重排（T-160 闸口决策）；pointer-events 同步摘除，不可见盒
+     不拦截宿主抽屉点击；hero 态 absolute 脱流，留位语义等价。 */
+  .dap-toggle[data-drawer-open] { display: flex; visibility: hidden; pointer-events: none; }
 }
 /* 浅色主题适配：外壳以 body 上 data-ds-dark-theme 属性标记深色（缺省即浅色），
    并在两个作用域下翻转整套 --dsw-alias-* 变量。本块只覆盖上文暗色专用的硬编码
-   颜色（卡片底色/描边/阴影、时间线文字与轨道、进度轨道、浮动开关），深色主题下
+   颜色（卡片底色/描边/阴影、时间线文字与轨道、进度轨道），深色主题下
    全部规则保持原值；状态色（绿/蓝/橙/红）与 currentColor 派生色两主题通用，不覆盖。
    ::before 状态圆点不覆盖：基色本就被各 data-status 规则接管，覆盖反而会以更高
    优先级压掉运行/完成/错误状态色。 */
@@ -3925,10 +3930,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);
@@ -3997,9 +4007,6 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-trace-item[data-ico
 body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-track {
   background: var(--dsw-alias-interactive-bg-hover, rgba(0, 0, 0, 0.08));
 }
-body:not([data-ds-dark-theme]) .dap-toggle {
-  background: var(--dsw-alias-button-floating-fill, rgba(255, 255, 255, 0.94));
-}
 /* 「回到顶部」与标题行档位按钮及左侧仓库入口的浅色覆盖：不透明层-2 底色与外壳描边别名
    （R-01-018/AC-05、R-01-021/AC-05、R-01-022/AC-01）；仓库入口无描边（T-139），只并入底色组。 */
 body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-top,
@@ -4125,9 +4132,11 @@ function apply(ctx) {
 	let sessions = null;
 	let workspaces = null;
 	let uiSession = null;
+	let jobs = null;
 	let sessionUnsubscribe = null;
 	let workspaceUnsubscribe = null;
 	let pendingUnsubscribe = null;
+	let jobsUnsubscribe = null;
 	let clockTimer = null;
 	let recentTimeTimer = null;
 	let syncScheduled = false;
@@ -4173,8 +4182,13 @@ function apply(ctx) {
 	 *  重挂载后保留（R-01-021/AC-06）。 */
 	let densityLevel = readStoredDensity();
 	/** 待执行的锚定补偿：档位切换时登记当前选中卡片顶部的视口相对位置，本轮渲染
-	 *  提交后量测该卡新位置并补偿 scrollTop（R-01-021/AC-01）。 */
+	 *  提交后量测该卡新位置并补偿 scrollTop（R-01-021/AC-01）。
+	 *  dsh 0.2.0（T-170 审核）：切回更高档位时窗口经 retain→ready 异步重建，时间线
+	 *  内容分多帧长回——补偿在沉降窗内逐帧执行，位置稳定或超窗即撤（单帧补偿
+	 *  会漏掉后期增长，锚点漂移）。 */
 	let pendingDensityAnchor = null;
+	/** 锚定补偿沉降窗截止时刻：窗内逐帧补偿，位置稳定提前撤，超窗强制撤。 */
+	let densityAnchorDeadline = 0;
 	/** 用户最近一次激活的卡片 id；打开重试链被更新的激活意图取代即取消。 */
 	let lastActivatedId = null;
 	/** 最近一次已处理的当前卡片；同一卡片的运行时重绘不反复打断用户手动滚动。 */
@@ -4228,7 +4242,6 @@ function apply(ctx) {
 	let catalogGroups = [];
 	/** 部署级 modelCatalog 一次性读取的在途 Promise：成功即缓存、失败允许重试。 */
 	let catalogPromise = null;
-	/** native session.open() requests in flight; avoid duplicate cold history reads. */
 	/** 冷数据读取并发池：队列顺序即优先级（调用方已排序），逐个完成逐个重绘。 */
 	const loadQueue = [];
 	let loadInflight = 0;
@@ -4249,29 +4262,146 @@ function apply(ctx) {
 		pumpDetailLoads();
 		return promise;
 	}
-	const sessionOpenLoads = new Map();
-	/** 子代理目录按需拉取记账（T-151）：parentId → 已触发；失败不热重试（行为有界）。 */
-	const subagentCatalogRequests = new Set();
+	/** 插件持有的会话引用登记（dsh 0.2.0 retain 生命周期，T-170）：String(id) →
+	 *  { reference, session, eventSource, pending }。retain 以独立
+	 *  source `dsh-activity-pane` 持有可见卡片的会话代际（binding 只借用已保留代际，
+	 *  旧打开/释放调用已移出会话面）；释放点 = 可见性 prune / 紧凑档拆窗 /
+	 *  服务代际更替 / 卸载。 */
+	const sessionRefs = new Map();
+	/** 插件 retain source：与宿主 mainView/workspaceOperation 并列的独立消费方标识。 */
+	const PLUGIN_RETAIN_SOURCE = "dsh-activity-pane";
+	/** jobs 服务按会话 roster 订阅（dsh 0.2.0 起 jobsBySession 移除，R-01-023）：
+	 *  String(id) → stop()；对列表内全会话订 roster，随列表 prune。 */
+	const jobWatchById = new Map();
+	/** 母会话投影按需拉取记账（T-151 后继）：parentId 在途记账，完成即除名允许重试。 */
+	const projectionRefreshes = new Set();
 
 	const style = document.createElement("style");
 	style.id = STYLE_ID;
 	style.textContent = CSS;
 	document.head.appendChild(style);
 
-	// 移动端浮动开关按钮（桌面隐藏见 CSS）。
+	// 移动端浮动开关按钮（桌面隐藏见 CSS）：紧凑形骨架——仅计数徽标，无图标与
+	// 文字标签（R-01-008/AC-04，T-162；面板图标被东家误读为边栏按钮，撤销）；
+	// 可访问名称由 aria-label 承担。不预挂 DOM：开关仅在 placeToggle 落位时进入
+	// 文档，未落位即不渲染（C-093，fail-visible——嵌入失败表现为按钮消失）。
 	const toggle = document.createElement("button");
 	toggle.className = "dap-toggle";
 	toggle.type = "button";
 	toggle.setAttribute("aria-label", "切换活动会话窗格");
-	toggle.innerHTML =
-		"<span>活动</span><span class=\"dap-toggle-count\"></span>";
-	document.body.appendChild(toggle);
+	toggle.innerHTML = "<span class=\"dap-toggle-count\"></span>";
 
 	// 移动端抽屉透明遮罩：仅窄屏且抽屉打开时显示，点击收起抽屉（R-01-008/AC-03）。
 	const backdrop = document.createElement("div");
 	backdrop.className = "dap-backdrop";
 	document.body.appendChild(backdrop);
 
+	// 移动端「活动」开关落位守卫（T-163/T-167/T-171，R-01-008/AC-04）：常态嵌入宿主
+	// 头部参与布局——东家指示（左边栏弹出按钮的右侧，其余控件被真实后挤）。0.2.0 起
+	// 头部结构代差：header.firstElementChild 只是左侧窄条 headerLeading；无壳层开关
+	// 占座时仍嵌该行行首；移动壳层开关（data-mobile-nav="toggle"）占座时改嵌会话头
+	// 标题行行首（座位右缘）。hero 页头部被壳层隐藏时几何感知回落 hero 形态。
+	// 插入点取行内首个内容簇（标题 crumb 导航所在顶层簇）之前，无簇时行首 prepend；
+	// 幂等：已是行首元素时不动 DOM；宿主重渲染丢弃嵌入节点后由下一轮渲染守卫重插
+	// （头部在 seat 子树内，conversationObserver 的 subtree 监听会经 queueSync
+	// 唤醒本守卫）。
+	// 标题行不可得（宿主 data-phase="hero"：英雄页/空白会话；或会话视图未挂载
+	// 窗口期）时落位 hero 形态：贴靠宿主侧栏展开按钮（dsh-web-mobile ⊡，语义属性
+	// data-mobile-nav="toggle"/"fab"，互斥、任一时刻至多一个在屏）右侧 8px 并垂直
+	// 居中，absolute 挂宿主 frame（[data-shell-overlay] 的 parentElement，与壳层
+	// findFrame 同源，东家确认；hero 页无布局流容器可嵌，C-093）。两落位均不可得时
+	// 摘除开关不渲染——静默浮层降级已去除（T-167，fail-visible）。
+	// 在屏判据阈值：元素 x 超过 -10px 视为在屏内（移动壳层屏外收起抽屉 x 约 -300）
+	const ON_SCREEN_X = -10;
+	function placeToggle() {
+		const seat = document.querySelector(CONVERSATION_SELECTOR);
+		const header = seat !== null ? (seat.querySelector("header") ?? null) : null;
+		const row = header !== null ? (header.firstElementChild ?? null) : null;
+		// 几何感知（T-171）：0.2.0 起 hero 页 header.firstElementChild 存在（左侧窄条
+		// headerLeading），但移动壳层对 headerBlank/headerHidden 头部整条 display:none
+		// ——行存在不等于行可见，嵌入其中会被连带隐藏（0.2.0 移动空白页入口消失根因）。
+		// 可见性判据取 header 包围盒：headerLeading 自身可为 0 宽（未嵌入时槽内容被壳
+		// 层隐藏，列宽塌缩），header 可见即行可嵌。宽高归零即回落 hero 形态贴靠 ⊡。
+		const headerRect = header !== null ? header.getBoundingClientRect() : null;
+		const headerVisible = headerRect !== null && headerRect.width > 0 && headerRect.height > 0;
+		if (row !== null && headerVisible) {
+			// 壳层左座检测（T-171）：移动壳层在头部左缘 absolute 挂自己的目录开关
+			// （data-mobile-nav="toggle"，实测 [8,6,28,28]），嵌入 headerLeading 行首
+			// 会与之同位叠置（0.2.0 active 页双开关冲突根因）。检出在屏壳层开关时改嵌
+			// 会话头标题行（conversation.session.header 槽渲染的 titleRow，壳层以
+			// padding-left:32 让出座位）行首——开关落座位右缘，标题被真实后挤；
+			// 标题行不可得时维持 headerLeading 旧落位（叠置边界记录 T-171）。
+			const shellToggle = [...header.querySelectorAll('button[data-mobile-nav="toggle"]')].find((el) => {
+				const rect = el.getBoundingClientRect();
+				return rect.width > 0 && rect.x > ON_SCREEN_X;
+			});
+			let target = row;
+			if (shellToggle !== undefined) {
+				const titleRow = header.querySelector('[data-slot="conversation.session.header"]')?.firstElementChild ?? null;
+				if (titleRow !== null) target = titleRow;
+			}
+			// 插入点取行内首个内容簇（标题簇）之前：行首即视觉上位于左侧边栏切换按钮
+			// 的右侧，其余头部控件被真实后挤（相对顺序契约，不断言行首）。簇内含 crumb
+			// 导航即认定标题簇（nav 必在 head 子树内，顶层簇即 head 本身）。
+			const head = target.firstElementChild;
+			const cluster = head !== null && (head.tagName === "NAV" || head.querySelector("nav") !== null)
+				? head
+				: null;
+			const settled = toggle.parentElement === target && toggle.hasAttribute("data-embedded") &&
+				(cluster !== null ? toggle.nextSibling === cluster : target.firstElementChild === toggle);
+			if (settled) return;
+			if (cluster !== null) target.insertBefore(toggle, cluster);
+			else target.prepend(toggle);
+			toggle.setAttribute("data-embedded", "");
+			toggle.removeAttribute("data-hero");
+			// 定位关键量内联钉死：嵌入态回归文档流不依赖样式表状态（东家真机
+			// 疑似样式与脚本状态失配，T-164）；样式表只承担外观。
+			toggle.style.position = "static";
+			toggle.style.top = "";
+			toggle.style.left = "";
+			return;
+		}
+		// hero 形态：锚定宿主侧栏展开按钮（⊡）右侧。toggle/fab 属性值互斥（会话头
+		// toggle 挂 header.actions 槽、hero 页 header 为空壳不渲染槽内容），统一
+		// 寻址取首个在屏者；抽屉打开期间壳层在 drawerOpen 翻转的同一 reconciler 遍
+		// 内移除 ⊡（overlay-backdrop-fab ensure），锚不可测走保留分支——开关已被
+		// 抽屉与遮罩在层级上盖住，保留原位即「一直在抽屉后面被挡住」（T-168）。
+		let fabEl = null;
+		for (const fab of document.querySelectorAll('button[data-mobile-nav="toggle"], button[data-mobile-nav="fab"]')) {
+			const rect = fab.getBoundingClientRect();
+			if (rect.width > 0 && rect.x > ON_SCREEN_X) {
+				fabEl = fab;
+				break;
+			}
+		}
+		const frame = document.querySelector("[data-shell-overlay]")?.parentElement ?? null;
+		if (fabEl === null || frame === null) {
+			// 锚或挂载点不可得：已落位开关保留原位几何——宿主抽屉打开窗口内壳层移除
+			// ⊡，开关由抽屉（1300）与遮罩（1250）遮挡，摘除会在关抽屉后经复检凭空
+			// 重现（T-168 东家否决）；随失效行/旧 frame detach 的开关不可见，由下一
+			// 次成功落位回收。未落位开关不在此进入文档（不渲染，C-093）；壳层结构
+			// 缺失（frame 不可得）时仍摘除已挂载开关。宿主改版致锚长期缺失时开关
+			// 残留于最后有效位置，记录为边界（T-168 验证矩阵）。
+			if (frame === null && toggle.parentElement !== null) toggle.remove();
+			return;
+		}
+		if (toggle.parentElement !== frame) frame.appendChild(toggle);
+		toggle.removeAttribute("data-embedded");
+		toggle.setAttribute("data-hero", "");
+		// 定位关键量内联钉死（T-164 策略）：absolute 几何不依赖样式表状态；
+		// 38 为样式表 height 缺省，量测失败时保底。
+		// 几何取锚的布局坐标（offsetLeft/Top/Width/Height）而非视口 rect（T-172）：
+		// 两者同为 frame 直系子项、offsetParent 同为 frame，布局坐标即 frame 内
+		// absolute 坐标本身；视口 rect 含 frame 自身位移（iOS rubber-band/滚动期
+		// 合成层位移），烘进 frame 内坐标等于把该位移重复计入一次——位移期间每次
+		// 重落位都让开关相对 ⊡ 多漂一份位移（实测 40px 位移重落位后总位移 80px），
+		// 且离散重落位呈顿挫。布局坐标不受祖先 transform 影响，重落位幂等稳定。
+		const toggleHeight = toggle.offsetHeight || 38;
+		toggle.style.position = "absolute";
+		toggle.style.top = `${Math.round(fabEl.offsetTop + (fabEl.offsetHeight - toggleHeight) / 2)}px`;
+		toggle.style.left = `${Math.round(fabEl.offsetLeft + fabEl.offsetWidth + 8)}px`;
+	}
+
 	// 桌面判定与"真实参与布局"：中间列切为行方向，窗格固定宽、会话根弹性填充
 	// 剩余宽度（flex:1 + min-width:0），让会话内容（标题/tabs/滚动区/输入框）
 	// 被真实挤到窗格右侧，且聊天列在增宽的会话带内自动居中。
@@ -4414,12 +4544,10 @@ function apply(ctx) {
 		}
 	}
 
-	/** 回到前台（含 bfcache 还原）时 ack 与任务输出通道自愈：重建 SSE（jobs 无全量快照，
-	 *  重连后由下一次轨迹通知或重新选中收敛；选中输出随卡片渲染帧刷新）。 */
+	/** 回到前台（含 bfcache 还原）时 ack 通道自愈：重建 SSE（连接即发全量，状态必然收敛）。 */
 	function resumePushChannels() {
 		if (!disposed) {
 			connectAcksStream();
-			connectJobsStream();
 		}
 	}
 	const onVisibilityResume = () => {
@@ -4432,51 +4560,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) {
@@ -4634,34 +4717,37 @@ 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;
+	/** 母会话子代理目录条目查找（T-151 单源；T-170 改读 0.2.0 投影）：open 地址与
+	 *  深翻分页地址共用同一取法，防条目形状或键名演化时两处漂移。 */
+	function subagentCatalogEntry(projectionsBySession, parentId, id) {
+		const entries = subagentCatalogOf(projectionsBySession, parentId);
+		return entries?.find((candidate) => String(candidate?.id) === String(id));
 	}
 
 	/** 会话日志分页地址（R-01-012）：主会话 `{kind:"session", sessionId}`；子代理
-	 *  `{kind:"subagent", parentSessionId, childSessionId, mode}`——母会话 id 兼容
-	 *  `parentSessionId` / `parentId` 两种条目键名。mode 必须与子代理描述符一致，
-	 *  不一致被宿主以 subagent/unauthorized 拒绝（T-151）：优先取母会话目录条目的
-	 *  mode，目录条目缺失（未加载、在途空窗或无该子条目）时回退行 `continuable`
-	 *  启发（读取失败由 pagedHistoryEvents 以 null 收敛为空白详情，R-01-013）。 */
-	function sessionPageAddress(id, byId, subagentsByParent = null) {
+	 *  `{kind:"subagent", parentSessionId, childSessionId, mode}`。mode 必须与子代理
+	 *  描述符一致，不一致被宿主以 subagent/unauthorized 拒绝（T-151）：优先取母会话
+	 *  目录条目的 mode；目录条目缺失（未加载、在途空窗或无该子条目）时以 `unknown`
+	 *  兜底——0.2.0 SessionAddress 新增该合法值（旧行 `continuable` 字段已随 0.2.0
+	 *  行形状移除，启发不再可靠；读取失败仍由 pagedHistoryEvents 以 null 收敛为空白
+	 *  详情，R-01-013）。 */
+	/** 子代理行的母会话 id（T-170 审核发现 7）：0.2.0 行形状 parentSessionId，
+	 *  兼容旧 parentId 键，单点解析避免三处漂移。 */
+	function parentSessionIdOf(row) {
+		return row?.parentSessionId ?? row?.parentId;
+	}
+
+	function sessionPageAddress(id, byId, projectionsBySession = null) {
 		const row = byId[id] ?? {};
 		if (row?.origin === "subagent") {
-			const parentId = row.parentSessionId ?? row.parentId;
+			const parentId = parentSessionIdOf(row);
 			if (parentId !== undefined && parentId !== null) {
-				const entry = subagentCatalogEntry(subagentsByParent, String(parentId), id);
+				const entry = subagentCatalogEntry(projectionsBySession, String(parentId), id);
 				return {
 					kind: "subagent",
 					parentSessionId: String(parentId),
 					childSessionId: String(id),
-					mode: typeof entry?.mode === "string" && entry.mode !== ""
-						? entry.mode
-						: row.continuable === true ? "continuable" : "one-shot",
+					mode: typeof entry?.mode === "string" && entry.mode !== "" ? entry.mode : "unknown",
 				};
 			}
 		}
@@ -4770,7 +4856,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 +4878,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;
@@ -4798,11 +4891,29 @@ function apply(ctx) {
 			if (deepReadNeeded && !historyLoads.has(id)) {
 				detail.previewFallbackLoaded = true;
 				detail.durationFallbackLoaded = true;
-				const address = sessionPageAddress(id, byId, listSnap?.subagentsByParent ?? null);
+				// 子代理目录未加载时先拉母会话投影再重试（T-170 审核）：0.2.0 起
+				// 子代理分页地址的 mode 取自 projectionsBySession 目录，缺目录时
+				// 以 mode:"unknown" 贸然翻页可能被宿主拒绝、首读收敛为空白；
+				// 与 retain 路径同款单发拉取（ensureParentProjections），下一轮
+				// 渲染目录就位后按真实 mode 重试。
+				const rowById = byId[id] ?? {};
+				if (rowById?.origin === "subagent") {
+					const rowParentId = parentSessionIdOf(rowById);
+					if (rowParentId != null && subagentCatalogOf(listSnap?.projectionsBySession ?? null, String(rowParentId)) === undefined) {
+						ensureParentProjections(String(rowParentId));
+						queueSync();
+						continue;
+					}
+				}
+				const address = sessionPageAddress(id, byId, listSnap?.projectionsBySession ?? 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 }),
 								);
@@ -4810,6 +4921,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 +4946,52 @@ 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 重订阅 + retain 重新水合）就绪，
+	 *  不新增恢复机制。 */
+	function enforceDensityDataDiscipline() {
+		if (densityLevel !== "compact") return;
+		const listSnap = getSnapshot(sessions, "list");
+		const currentId = currentIdOf(listSnap);
+		if (currentId == null) return;
+		for (const [id, unsubscribe] of [...logSourceSubs]) {
+			if (!logWindowSuppressedFor(id, listSnap?.byId ?? {})) continue;
+			if (String(id) === String(currentId)) continue;
+			try {
+				unsubscribe?.();
+			} catch {
+				/* 监听器已失效：除名即可 */
+			}
+			logSourceSubs.delete(id);
+			const detail = sessionDetailsById.get(id) ?? null;
+			if (detail !== null) detail.log = null;
+			// dsh 0.2.0 retain 生命周期（T-170）：拆窗即释放插件引用——旧
+			// sessions.binding(id).session.dispose() 随 open/dispose 移出会话面而删除。
+			releaseSessionRef(id);
+		}
+		// 无窗口引用的兜底释放（T-170 审核）：引用可先于窗口存在（轮内状态订阅
+		// 借用、切档在途），被抑制且非当前会话的残留引用一并释放，不留常驻
+		// retain（R-01-025/AC-01）。
+		for (const id of [...sessionRefs.keys()]) {
+			if (logSourceSubs.has(id)) continue;
+			if (!logWindowSuppressedFor(id, listSnap?.byId ?? {})) continue;
+			if (String(id) === String(currentId)) continue;
+			releaseSessionRef(id);
+		}
+	}
+
 	/** 日志页落地后的详情派生（R-01-012、R-01-017）：时间线折叠、消息预览与子代理模型上下文。
 	 *  子代理沿用溯源链（assistant/message source.model + 请求头 effort，T-122）；主会话模型
 	 *  不经日志提取（目录链订阅 + 一次性 load 承载，见 installServiceSubscriptions 注）。
@@ -4855,28 +5016,149 @@ function apply(ctx) {
 		// 当前选择），不可得时保持空白，不以日志历史取值或部署默认冒充（R-01-012/AC-18）。
 	}
 
-	/** 绑定会话并水合事件源（dsh 0.1.5 起会话内容经 eventSource 流式下发：打开即收
-	 *  完整日志窗口 + 实时尾，原生 Conversation 同源）。冷会话补一次 open()，日志窗口
-	 *  快照引用变化即重派生详情（时间线/预览/模型），窗口由宿主按消息对齐分页。 */
+	/** 会话引用获取（dsh 0.2.0 retain 生命周期，T-170）：为可见卡片以独立 source
+	 *  持有会话代际。子代理行先经 sessions.subagentAddress 解析持久父地址（旧
+	 *  会话面地址安装路径随重构删除）；地址不可得时先拉取母会话投影
+	 *  并返回 null 下轮重试。reference.ready 落定后接线 binding.eventSource 与
+	 *  session 面（ObservableSnapshot 半面）。返回 { session, eventSource } 或
+	 *  null（在途/不可得——调用方下轮渲染重试）。 */
+	function liveSessionFace(id) {
+		const key = String(id);
+		const existing = sessionRefs.get(key);
+		if (existing !== undefined) return existing.pending ? null : existing;
+		const listSnap = getSnapshot(sessions, "list");
+		const byId = listSnap?.byId ?? {};
+		let target = id;
+		if (isSubagentRow(byId[id], byId)) {
+			const parentId = String(parentSessionIdOf(byId[id]));
+			let address = null;
+			try {
+				address = sessions?.subagentAddress?.(String(id)) ?? null;
+			} catch {
+				address = null;
+			}
+			if (address === null || address === undefined) {
+				ensureParentProjections(parentId);
+				return null;
+			}
+			target = address;
+		}
+		let reference = null;
+		try {
+			reference = sessions?.retain?.(target, { source: PLUGIN_RETAIN_SOURCE }) ?? null;
+		} catch {
+			reference = null;
+		}
+		if (reference === null) return null;
+		const record = { reference, session: null, eventSource: null, pending: true };
+		sessionRefs.set(key, record);
+		Promise.resolve(reference.ready)
+			.then(() => {
+				if (disposed) {
+					try {
+						reference.release();
+					} catch {
+						/* 已卸载：引用兜底释放 */
+					}
+					return;
+				}
+				let binding = null;
+				try {
+					binding = reference.binding ?? null;
+				} catch {
+					binding = null; // 代际已终结：下次渲染重新 retain
+				}
+				if (binding !== null) {
+					record.session = binding.session ?? null;
+					record.eventSource = binding.eventSource ?? null;
+				}
+				record.pending = false;
+				queueSync();
+			})
+			.catch(() => {
+				record.pending = false;
+				if (!disposed) queueSync();
+			});
+		return null;
+	}
+
+	/** 只借用已接线会话面，不发起 retain（T-170 审核发现 1）：运行状态订阅的
+	 *  面必须来自既有引用（日志窗口或外壳主视图 retain 的会话）。无引用时返回
+	 *  null，调用方降级到统一状态面（sessionStatus）与 busy 记账，不得为
+	 *  轮内状态订阅单独水合紧凑档非当前主会话（R-01-025/AC-01）。 */
+	function peekSessionFace(id) {
+		const record = sessionRefs.get(String(id));
+		if (record === undefined || record.pending) return null;
+		const session = record.session;
+		const eventSource = record.eventSource;
+		if ((session === null || session === undefined) && (eventSource === null || eventSource === undefined)) return null;
+		return record;
+	}
+
+	/** 释放一个会话引用：release retain 引用（dsh 0.2.0），断流由宿主随引用计数收敛。 */
+	function releaseSessionRef(id) {
+		const key = String(id);
+		const record = sessionRefs.get(key);
+		if (record === undefined) return;
+		sessionRefs.delete(key);
+		try {
+			record.reference?.release?.();
+		} catch {
+			/* 引用已释放 */
+		}
+	}
+
+	/** 母会话投影按需拉取（T-170）：0.2.0 起子代理目录随列表快照的
+	 *  projectionsBySession 下发，未加载时经 refreshProjections 拉取后重试。 */
+	function ensureParentProjections(parentId) {
+		if (typeof sessions?.refreshProjections !== "function") return;
+		const key = String(parentId);
+		if (projectionRefreshes.has(key)) return;
+		projectionRefreshes.add(key);
+		try {
+			Promise.resolve(sessions.refreshProjections(key))
+				.catch(() => {})
+				.finally(() => {
+					projectionRefreshes.delete(key);
+					if (!disposed) queueSync();
+				});
+		} catch {
+			projectionRefreshes.delete(key);
+		}
+	}
+
+	// 绑定会话并水合事件源（dsh 0.2.0 retain 生命周期，T-170）：retain 的 ready
+	// 承载共享初始历史打开（旧显式会话打开调用随 open 移出会话面而删除），
+	// binding.eventSource 打开即收完整日志窗口 + 实时尾（原生 Conversation 同源）。
+	// 日志窗口快照引用变化即重派生详情（时间线/预览/模型），窗口由宿主按消息对齐分页。
 	function captureSessionLog(id, { cwd } = {}) {
+		// 档位资源纪律（R-01-025/AC-01）：紧凑档主会话不建立或保持会话日志窗口——
+		// 不订阅事件流、不发起水合、不读窗口快照。判定必须先于 liveSessionFace：
+		// dsh 0.2.0 起 retain.ready 承载共享初始历史打开，先 retain 后判档会让
+		// 紧凑档非当前主会话被水合（T-170 审核发现 1）。判定在函数入口用时重读，
+		// 切档在途的回调与重试不落地新窗口。子代理日志窗口承载标题行可见的
+		// 模型上下文（R-01-012/AC-17），恒不裁剪（单点判定见 logWindowSuppressedFor）。
+		if (logWindowSuppressedFor(id)) return;
 		const detail = sessionDetailsById.get(id) ?? {};
 		sessionDetailsById.set(id, detail);
-		let session = null;
-		try {
-			session = sessions?.binding?.(id)?.session ?? null;
-		} catch {
-			session = null;
+		const live = liveSessionFace(id);
+		if (live === null) return; // retain 在途/子代理地址未就绪：下轮渲染重试
+		const session = live.session;
+		const eventSource = live.eventSource;
+		if ((session === null || session === undefined) && (eventSource === null || eventSource === undefined)) {
+			// 代际已终结（binding 访问失败）：释放登记，下轮渲染重新 retain。
+			releaseSessionRef(id);
+			return;
 		}
-		if (session === null) return;
 		// 日志窗口无效化订阅（事件驱动，不构成轮询，R-02-004）：等待/历史卡无会话状态
 		// 订阅（syncLiveness 只订阅运行中），窗口推进（回合收尾、流式尾）必须经此回调
 		// 重读快照并重绘；否则窗口更新只能靠渲染期重读兜底——渲染一旦静默（一次性
 		// load 修复后），完成提醒耗时等窗口派生数据将永久停摆。随可见性 prune。
-		if (typeof session.eventSource?.subscribe === "function" && !logSourceSubs.has(id)) {
+		if (typeof eventSource?.subscribe === "function" && !logSourceSubs.has(id)) {
 			try {
 				logSourceSubs.set(
 					id,
-					session.eventSource.subscribe(() => {
+					eventSource.subscribe(() => {
 						if (disposed) return;
 						const listSnap = getSnapshot(sessions, "list");
 						captureSessionLog(id, { cwd: listSnap?.byId?.[id]?.cwd ?? "" });
@@ -4887,24 +5169,7 @@ function apply(ctx) {
 				// 订阅不可用：回退渲染期重读。
 			}
 		}
-		try {
-			// 日志窗口缺席才发起 open：非订阅会话（等待/历史卡）无快照推送，openState 永远
-			// 不可知，只以 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(() => {
-					if (sessionOpenLoads.get(id) === opening) sessionOpenLoads.delete(id);
-					queueSync();
-				});
-			}
-		} catch {
-			// open 不可用：保持当前窗口。
-		}
-		const log = session.eventSource?.getSnapshot?.() ?? null;
+		const log = eventSource?.getSnapshot?.() ?? null;
 		if (log === detail.log) return;
 		detail.log = log;
 		// 流式派生合并（T-127）：事件到达只更新引用并标脏，applyLogEvents 的 O(日志窗口)
@@ -4933,53 +5198,6 @@ 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()` 无参数读取；成功即缓存不再
 	 *  重发，失败留待下轮详情读取重试。 */
@@ -4996,18 +5214,43 @@ function apply(ctx) {
 			});
 	}
 
+	/** 释放全部会话引用并停流 jobs roster 订阅（T-170 审核发现 5）：服务代际更替
+	 *  与卸载两个释放点共用同一形状，抽单点避免漂移。 */
+	function releaseAllSessionRefs() {
+		for (const id of [...sessionRefs.keys()]) releaseSessionRef(id);
+	}
+
+	function stopAllJobWatches() {
+		for (const [, stop] of jobWatchById) {
+			try {
+				stop?.();
+			} catch {
+				/* 流已随旧代际关闭或已卸载 */
+			}
+		}
+		jobWatchById.clear();
+	}
+
 	function installServiceSubscriptions() {
 		const nextSessions = ctx.get("sessions");
 		const nextWorkspaces = ctx.get("workspaces");
 		const nextUiSession = ctx.get("uiSession");
-		if (nextSessions === sessions && nextWorkspaces === workspaces && nextUiSession === uiSession) return;
+		const nextJobs = ctx.get("jobs");
+		if (nextSessions === sessions && nextWorkspaces === workspaces && nextUiSession === uiSession && nextJobs === jobs) return;
+
+		// 服务代际更替：旧代际上登记的 retain 引用与 jobs roster 订阅一并释放——
+		// 引用的 binding 在代际终结后访问即失败（dsh 0.2.0 retain 语义）。
+		releaseAllSessionRefs();
+		stopAllJobWatches();
 
 		sessionUnsubscribe?.();
 		workspaceUnsubscribe?.();
 		pendingUnsubscribe?.();
+		jobsUnsubscribe?.();
 		sessions = nextSessions ?? null;
 		workspaces = nextWorkspaces ?? null;
 		uiSession = nextUiSession ?? null;
+		jobs = nextJobs ?? null;
 		try {
 			sessionUnsubscribe = sessions?.list?.subscribe?.(queueSync) ?? null;
 		} catch {
@@ -5019,13 +5262,20 @@ function apply(ctx) {
 			workspaceUnsubscribe = null;
 		}
 		try {
-			// 0.1.5 起 sessions 行不再承载 pendingInteraction：待确认/待审查/待回复改由
-			// uiSession.pendingInteractions（Map<sessionId, interaction>）独立承载，
+			// dsh 0.2.0（T-170）：统一会话状态面 sessionStatus 取代 pendingInteractions
+			// （Map<sessionId, {running, pendingInteraction, completionUnread}>），
 			// 订阅其快照变化驱动等待卡重算（R-01-002/AC-03）。
-			pendingUnsubscribe = uiSession?.pendingInteractions?.subscribe?.(queueSync) ?? null;
+			pendingUnsubscribe = uiSession?.sessionStatus?.subscribe?.(queueSync) ?? null;
 		} catch {
 			pendingUnsubscribe = null;
 		}
+		try {
+			// dsh 0.2.0（T-170）：后台任务 roster 经 jobs 服务的 state 快照推送
+			// （rows: Record<sessionId, JobView[]>），订阅驱动在跑任务卡重算（R-01-023）。
+			jobsUnsubscribe = jobs?.state?.subscribe?.(queueSync) ?? null;
+		} catch {
+			jobsUnsubscribe = null;
+		}
 
 		queueSync();
 	}
@@ -5040,6 +5290,41 @@ function apply(ctx) {
 		toggle.toggleAttribute("data-drawer-open", open);
 		queueSync();
 	}
+	// 帧状态观察（T-167/T-171）：键盘（Escape）与滑动手势关抽屉不派发 pointer 事件；
+	// 壳层抽屉状态机本体是 frame 的 data-sidebar-collapsed 属性，观察其翻转是
+	// 关抽屉后 ⊡ 重挂、hero 落位重锚的必然唤醒点——回调仅在状态翻转与 frame
+	// 直系子节点变动（锚/开关挂载摘除，T-171）时发生，无轮询成本。按元素记挂：
+	// frame 就绪前延迟挂载，外壳重挂载出新 frame 时换挂。
+	// 开关在锚缺失期间保留原位（T-168），翻转即检与 400ms 复检均为同值重写或
+	// 重锚，无显隐突变；宿主抽屉隐藏检测（T-165）随层级归位失去必要性，整体
+	// 摘除（T-168）。
+	let frameObserver = null;
+	let observedFrame = null;
+	function armFrameObserver() {
+		if (disposed) return;
+		const frame = document.querySelector("[data-shell-overlay]")?.parentElement;
+		if (frame == null) return;
+		if (frameObserver !== null && observedFrame === frame) return;
+		frameObserver?.disconnect();
+		frameObserver = new MutationObserver(() => {
+			if (disposed) return;
+			// 翻转即检 + 400ms 复检：壳层重挂 ⊡ 晚于属性翻转（reconcile 异步），
+			// 仅翻转即检会扑空且再无唤醒点；开关未摘除，复检为重锚同值。
+			placeToggle();
+			setTimeout(() => {
+				if (disposed) return;
+				placeToggle();
+			}, 400);
+		});
+		// childList（T-171）：锚（⊡/壳层开关）与开关自身的挂载摘除都是 frame 直接
+		// 子节点变动——锚在静默页面上出现（壳层延迟挂 ⊡、e2e 注入）没有任何其它
+		// 唤醒点（seat 突变、抽屉翻转、订阅均不发生），落位会悬到下一个任意时钟。
+		// 观察直系子节点变动即检，落位从事件驱动变为确定；回调幂等无反馈环。
+		frameObserver.observe(frame, { attributes: true, attributeFilter: ["data-sidebar-collapsed"], childList: true });
+		observedFrame = frame;
+	}
+	armFrameObserver();
+	placeToggle();
 	function notifyLayoutChange() {
 		try {
 			window.dispatchEvent(new Event("resize"));
@@ -5177,11 +5462,15 @@ 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 重建；
-			// 锚定补偿在本轮渲染提交后执行，此时量测才含新行高
+			// 锚定补偿在渲染提交后逐帧执行至沉降窗结束，此时量测才含新行高
 			//（R-01-021/AC-01、AC-08）。
 			pendingDensityAnchor = currentCard && anchorTop !== null ? anchorTop : null;
+			densityAnchorDeadline = Date.now() + 1500;
 			queueSync();
 		};
 		// 档位按钮位于标题行右侧的工具区（标题区折叠控件的兄弟节点），激活天然不会
@@ -5215,6 +5504,10 @@ function apply(ctx) {
 
 	// ---- 窗格容器（conversation 槽座的前置兄弟列；外壳重挂载后重插） ----
 	function ensurePane() {
+		// 开关落位守卫先于窗格守卫：头部行存在与否独立于窗格挂载态（T-160）。
+		placeToggle();
+		// 帧观察器在 frame 就绪后补挂（外壳重挂载后 frame 为新元素，须重挂）。
+		armFrameObserver();
 		const seat = document.querySelector(CONVERSATION_SELECTOR);
 		if (seat === null || seat.parentElement === null) return null;
 		// [data-slot="conversation"] 的父级是 AppFrame 的中间列（flex column）。
@@ -5404,8 +5697,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 +6191,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 +6202,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 +6217,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 +6239,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 +6359,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 +6370,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 +6384,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 +6398,7 @@ function apply(ctx) {
 					progressRow.hidden = true;
 				}
 			}
-			renderTokenStats(el, entry);
+			if (densityLevel === "full") renderTokenStats(el, entry);
 			return;
 		}
 
@@ -6198,14 +6419,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 变化会重建骨架）。
@@ -6245,65 +6470,65 @@ function apply(ctx) {
 	}
 
 	// ---- 轮内状态订阅生命周期（R-01-009、R-02-004） ----
+	// dsh 0.2.0（T-170 审核发现 1）：状态订阅只借用既有引用的会话面——日志窗口
+	// 豁免（高档位/当前/子代理）与外壳主视图已 retain 的会话免费获得；紧凑档
+	// 非当前主会话不 retain（retain.ready 即共享初始历史打开，等价水合，
+	// R-01-025/AC-01），其运行呈现降级到统一状态面 sessionStatus（running，
+	// 宿主级单订阅已随 installServiceSubscriptions 建立）与 busy 记账
+	// openTurnStart（回合起点，供运行卡时钟）。
 	function syncLiveness(runningIds, clockWanted) {
 		for (const id of runningIds) {
-			if (livenessById.has(id)) continue;
-			let session = null;
-			try {
-				session = sessions?.binding?.(id)?.session ?? null;
-			} catch {
-				session = null;
-			}
-			if (session === null) continue; // 下次渲染再试
-			let unsubscribe = null;
-			try {
-				unsubscribe = session.subscribe(() => {
-					if (disposed) return;
-					const snapshot = getSessionSnapshot(session);
-					const live = livenessFromSnapshot(snapshot);
-					livenessById.set(id, { unsubscribe, liveness: live, snapshot });
+			const existing = livenessById.get(id);
+			const face = peekSessionFace(id);
+			// 幂等调和：已订阅的记录不动；降级记录（无订阅无快照）在引用出现时
+			// 升级为会话订阅，引用缺席时保持降级。
+			if (existing !== undefined && ((existing.unsubscribe ?? null) !== null || existing.snapshot !== null || face === null)) continue;
+			if (face !== null) {
+				const session = face.session;
+				let unsubscribe = null;
+				if (session !== null && session !== undefined) {
+					try {
+						unsubscribe = session.subscribe(() => {
+							if (disposed) return;
+							const snapshot = getSessionSnapshot(session);
+							const live = livenessFromSnapshot(snapshot);
+							livenessById.set(id, { unsubscribe, liveness: live, snapshot });
+							const detail = sessionDetailsById.get(id) ?? {};
+							detail.snapshot = snapshot;
+							sessionDetailsById.set(id, detail);
+							// dsh 0.1.5 起快照不再携带会话内容：时间线经 eventSource 日志窗口
+							// 就地重派生（R-01-009）。
+							const listSnap = getSnapshot(sessions, "list");
+							captureSessionLog(id, { cwd: listSnap?.byId?.[id]?.cwd ?? "" });
+							queueSync();
+						});
+					} catch {
+						unsubscribe = null; // 订阅不可用：降级到统一状态面路径
+					}
+				}
+				const snapshot = face.session ? getSessionSnapshot(face.session) : null;
+				if (snapshot !== null) {
+					livenessById.set(id, {
+						unsubscribe,
+						liveness: livenessFromSnapshot(snapshot),
+						snapshot,
+					});
 					const detail = sessionDetailsById.get(id) ?? {};
 					detail.snapshot = snapshot;
 					sessionDetailsById.set(id, detail);
-					// dsh 0.1.5 起快照不再携带会话内容：时间线经 eventSource 日志窗口
-					// 就地重派生（R-01-009）。
-					const listSnap = getSnapshot(sessions, "list");
-					captureSessionLog(id, { cwd: listSnap?.byId?.[id]?.cwd ?? "" });
-					queueSync();
+				} else {
+					livenessById.set(id, { unsubscribe: null, liveness: { startTime: null }, snapshot: null });
+				}
+			} else {
+				// 无引用（紧凑档非当前主会话）：不 retain、不订阅。运行起点由消费点
+				// 逐帧从 busy 记账现取（hostStartTime 回退链既有路径），起点不落记录
+				// 冻结；快照派生退回 history 补读路径（既有 fallback）。
+				livenessById.set(id, {
+					unsubscribe: null,
+					liveness: { startTime: null },
+					snapshot: null,
 				});
-			} catch {
-				continue; // 订阅失败：本次跳过，下次渲染重试
 			}
-			// 子代理事件流仅接受持久父地址：open 前先安装（T-151），否则宿主拒绝、窗口永不水合。
-			ensureSubagentAddress(id, session);
-			let opening = null;
-			try {
-				opening = session.open?.();
-			} catch {
-				opening = null;
-			}
-			if (opening && typeof opening.then === "function") {
-				const tracked = Promise.resolve(opening).then(
-					() => {
-						sessionOpenLoads.delete(id);
-						queueSync();
-					},
-					() => {
-						sessionOpenLoads.delete(id);
-						queueSync();
-					},
-				);
-				sessionOpenLoads.set(id, tracked);
-			}
-			const snapshot = getSessionSnapshot(session);
-			livenessById.set(id, {
-				unsubscribe,
-				liveness: livenessFromSnapshot(snapshot),
-				snapshot,
-			});
-			const detail = sessionDetailsById.get(id) ?? {};
-			detail.snapshot = snapshot;
-			sessionDetailsById.set(id, detail);
 		}
 		for (const [id, rec] of livenessById) {
 			if (runningIds.has(id)) continue;
@@ -6331,6 +6556,33 @@ function apply(ctx) {
 		}
 	}
 
+	/** jobs roster 订阅同步（R-01-023，T-170）：dsh 0.2.0 起任务 roster 经 jobs 服务
+	 *  按会话 watchRows 拉取（引用计数共享流），不再随列表快照推送。对列表全会话
+	 *  建立订阅（与旧 jobsBySession 全量推送同覆盖），离开列表即停流；幂等，每帧
+	 *  重入只处理差集。服务缺失时整轮跳过。 */
+	function syncJobsWatches(listSnapshot) {
+		if (typeof jobs?.watchRows !== "function") return;
+		const ids = Array.isArray(listSnapshot?.ids) ? listSnapshot.ids : [];
+		const wanted = new Set(ids.map((id) => String(id)));
+		for (const [key, stop] of [...jobWatchById]) {
+			if (wanted.has(key)) continue;
+			jobWatchById.delete(key);
+			try {
+				stop?.();
+			} catch {
+				/* 流已断 */
+			}
+		}
+		for (const id of wanted) {
+			if (jobWatchById.has(id)) continue;
+			try {
+				jobWatchById.set(id, jobs.watchRows(id));
+			} catch {
+				/* 单会话订流失败：下帧重试 */
+			}
+		}
+	}
+
 	function getSessionSnapshot(session) {
 		try {
 			return session?.getSnapshot?.() ?? null;
@@ -6499,14 +6751,12 @@ 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;
-				}
-				if (typeof sessions?.open !== "function") 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 ctx.get("uiWorkspace")?.openSession !== "function") return;
 				lastActivatedId = sessionId;
 				// 新激活意图取代一切旧重试链，避免过期链条稍后把当前会话拽回旧目标；
 				// 收起抽屉的分支同样是最新意图，必须先取消挂起链条再 return。
@@ -6516,7 +6766,7 @@ function apply(ctx) {
 				if (
 					shouldDismissDrawerOnActivation({
 						targetId: sessionId,
-						currentId: getSnapshot(sessions, "list")?.current ?? null,
+						currentId: currentIdOf(getSnapshot(sessions, "list")),
 						mobile: window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT})`).matches,
 						drawerOpen:
 							document.querySelector(`[${PANE_ATTR}]`)?.getAttribute("data-open") === "true",
@@ -6534,8 +6784,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;
 		}
@@ -6806,16 +7062,18 @@ function apply(ctx) {
 			}
 		}
 		const listState = listLoadState(snapshot);
-		// 0.1.5 sessions 行不再承载 pendingInteraction：从 uiSession.pendingInteractions
-		// 快照（Map<sessionId, interaction>，kind ∈ approval/plan-review/question）回填到
-		// 行副本上，等待卡分类（awaiting/blocked/提问中）保持既有单一口径（R-01-002/AC-03）。
-		const pendingSnapshot = uiSession?.pendingInteractions?.getSnapshot?.() ?? null;
-		if (pendingSnapshot instanceof Map && pendingSnapshot.size > 0 && snapshot?.byId) {
+		// dsh 0.2.0（T-170）：统一会话状态面 sessionStatus（Map<sessionId,
+		// {running, pendingInteraction, completionUnread}>）取代 pendingInteractions：
+		// 从状态快照把 pendingInteraction.kind 回填到行副本上，等待卡分类
+		// （awaiting/blocked/提问中）保持既有单一口径（R-01-002/AC-03）。
+		const statusSnapshot = uiSession?.sessionStatus?.getSnapshot?.() ?? null;
+		if (statusSnapshot instanceof Map && statusSnapshot.size > 0 && snapshot?.byId) {
 			const byId = { ...snapshot.byId };
-			for (const [id, interaction] of pendingSnapshot) {
+			for (const [id, status] of statusSnapshot) {
 				const row = byId[id];
-				if (!isRecord(row) || typeof interaction?.kind !== "string") continue;
-				byId[id] = { ...row, pendingInteraction: interaction.kind };
+				const kind = status?.pendingInteraction?.kind;
+				if (!isRecord(row) || typeof kind !== "string") continue;
+				byId[id] = { ...row, pendingInteraction: kind };
 			}
 			snapshot = { ...snapshot, byId };
 		}
@@ -6837,9 +7095,12 @@ function apply(ctx) {
 		for (const [id, record] of busyById) {
 			if (typeof record?.openWaitStart === "number") waitingStarts.set(String(id), record.openWaitStart);
 		}
-		// 在跑后台任务（R-01-023）：jobsBySession 快照注入 buildEntries/buildRecent——
-		// liveJobs 非空的主会话保留活动区、归运行组并抑制完成/错误提醒。
-		const jobsBySession = isRecord(snapshot) && isRecord(snapshot.jobsBySession) ? snapshot.jobsBySession : null;
+		// 在跑后台任务（R-01-023，T-170）：dsh 0.2.0 起 jobsBySession 自列表快照移除，
+		// 改由 jobs 服务的 state.rows（Record<sessionId, JobView[]>）注入
+		// buildEntries/buildRecent——liveJobs 非空的主会话保留活动区、归运行组并抑制
+		// 完成/错误提醒；roster 订阅经 syncJobsWatches 对列表全会话建立。
+		syncJobsWatches(snapshot);
+		const jobsBySession = jobs?.state?.getSnapshot?.()?.rows ?? null;
 		const active = buildEntries(snapshot, workspaceItems, sessionDetailsById, completeAcksById, delegatingIds, archivedSessionIds, waitingStarts, jobsBySession);
 		// 轮内订阅仅对"运行中"会话建立（主会话 + 运行中的子代理），保持在运行中的订阅
 		// 数量 == 运行中会话数量（R-02-004/AC-01）；暂停等待的子代理只显示标题。
@@ -6947,7 +7208,7 @@ function apply(ctx) {
 			entry.loadingModel = !detail?.model && (modelLoads.has(entry.id) || (entry.kind === "subagent" && historyLoads.has(entry.id)));
 			entry.loadingTimeline =
 				entry.timeline.length === 0 &&
-				(historyLoads.has(entry.id) || sessionOpenLoads.has(entry.id) || (runLikeIds.has(entry.id) && !liveRecord));
+				(historyLoads.has(entry.id) || sessionRefs.get(String(entry.id))?.pending === true || (runLikeIds.has(entry.id) && !liveRecord));
 			// token/速率取自 sessions.list 条目的投影（tokenUsage/sessionStats），
 			// 复用既有列表订阅，无新增轮询（R-01-009/AC-05、R-02-004/AC-02）。
 			const projection = snapshot?.byId?.[entry.id]?.projectionValues;
@@ -7076,7 +7337,12 @@ function apply(ctx) {
 			if (chatLatestAssistantSettled(detailSnapshot)) subagentModelReadIds.add(entry.id);
 		}
 		const detailIds = [...active, ...recent].map((entry) => entry.id);
-		detailIds.sort((a, b) => Number(String(b) === String(snapshot?.current)) - Number(String(a) === String(snapshot?.current)));
+		const currentId = currentIdOf(snapshot);
+		detailIds.sort((a, b) => Number(String(b) === String(currentId)) - Number(String(a) === String(currentId)));
+		// 档位资源纪律（R-01-025/AC-01）：渲染期持续执法——进入紧凑档即拆主会话窗口；
+		// 拆窗时被豁免的当前会话在切走后的下一轮渲染照常释放。幂等：主会话拆窗后
+		// 不在 logSourceSubs，重复执法为无操作。
+		enforceDensityDataDiscipline();
 		loadNativeDetails({ ids: detailIds, previewFallbackIds, durationFallbackIds, subagentModelReadIds });
 		// 累计运行时长懒回填（R-01-020/AC-05）：对可见主会话触发宿主侧存量回合补齐；
 		// 宿主侧每会话单飞，重复触发由宿主合并；完成后经 busy SSE 广播推送。
@@ -7085,12 +7351,17 @@ function apply(ctx) {
 		// 详情与 loads 记账同生命周期：离开可见集合即放行，重回可见时允许重拉/重试。
 		// 锚点记账不随可见性 prune：瞬时 loading 空帧不得误清（进度重置）；陈旧条目靠
 		// 耗尽宽限与 turnStart 不匹配自校正，仅在 dispose 时整体清除。
-		pruneInvisibleEntries([sessionDetailsById, modelLoads, historyLoads, sessionOpenLoads], visibleIds);
+		pruneInvisibleEntries([sessionDetailsById, modelLoads, historyLoads], visibleIds);
 		// 模型目录订阅同生命周期：不可见即先 unsubscribe 再除名，监听器不残留（R-01-012/AC-16）。
 		pruneSubscriptions(modelDirectorySubs, visibleIds);
 		pruneSubscriptions(logSourceSubs, visibleIds);
+		// 会话引用同生命周期（T-170）：离开可见集合即 release retain 引用——retain 的
+		// 共享代际与流随引用计数收敛，对应旧 dispose 语义。
+		for (const refId of [...sessionRefs.keys()]) {
+			if (!visibleIds.has(refId)) releaseSessionRef(refId);
+		}
 		// 重试链目标已成为当前会话（他途到达）即取消，避免过期链条拽回会话。
-		cancelStaleOpenRetries({ currentId: snapshot?.current ?? null, activatedId: lastActivatedId });
+		cancelStaleOpenRetries({ currentId, activatedId: lastActivatedId });
 
 		const visibleEntries = [...active, ...recent];
 		const pulseSurface = desktopQuery.matches
@@ -7188,7 +7459,7 @@ function apply(ctx) {
 		}
 		runMoveGhosts(movePlans);
 		if (shiftRects !== null) runShiftAnimations(shiftRects);
-		ensureCurrentCardVisible(pane.querySelector(".dap-scroll"), snapshot?.current ?? null);
+		ensureCurrentCardVisible(pane.querySelector(".dap-scroll"), currentIdOf(snapshot));
 		if (focusAfterMigrationId !== null) cardsById.get(focusAfterMigrationId)?.el.focus();
 		// 区域已有条目但列表仍在途时，在区头部显示行内加载指示（R-01-014/AC-01）。
 		const headerEl = pane.querySelector(".dap-titlebar");
@@ -7261,7 +7532,10 @@ function apply(ctx) {
 		}
 		// 锚定补偿（R-01-021/AC-01）：档位切换的渲染落地后量测当前选中卡的新位置并
 		// 补偿 scrollTop，使当前卡顶部回到切换前相对视口的位置；补偿量超滚动边界时
-		// 由浏览器钳制（以当前卡不滚出可视范围为准）。
+		// 由浏览器钳制（以当前卡不滚出可视范围为准）。沉降窗内逐帧补偿：dsh 0.2.0
+		// 起切回高档位的窗口经 retain→ready 异步重建，时间线内容分多帧长回，单帧
+		// 补偿会漏掉后期增长（T-170 审核修复回归）；位置稳定（残差 ≤1px）或超窗
+		// （1500ms）即撤，避免与用户手动滚动长期对抗。
 		if (pendingDensityAnchor !== null) {
 			const scrollEl = pane.querySelector(".dap-scroll");
 			// 补偿按当前 DOM 的 data-current 卡实时定位：跨区迁移等渲染可能重建卡片
@@ -7270,13 +7544,21 @@ function apply(ctx) {
 			if (scrollEl !== null && currentCard !== null) {
 				const viewportTop = scrollEl.getBoundingClientRect().top;
 				const shiftedTop = currentCard.getBoundingClientRect().top - viewportTop;
+				// 仅按沉降窗超时撤除（T-170）：窗口重建分多帧长回且成簇到达，帧间
+				// 空隙的「稳定帧」不可作为撤除依据——提前撤除会让后续突增失偿。
 				scrollEl.scrollTop += shiftedTop - pendingDensityAnchor;
+				if (Date.now() > densityAnchorDeadline) {
+					pendingDensityAnchor = null;
+					densityAnchorDeadline = 0;
+				}
+			} else {
+				pendingDensityAnchor = null;
+				densityAnchorDeadline = 0;
 			}
-			pendingDensityAnchor = null;
 		}
 	}
 
-	// ---- 打开会话（让 sessions.open 自己校验列表，失败时 refresh + 重试） ----
+	// ---- 打开会话（dsh 0.2.0 经 uiWorkspace.openSession 导航，currentId 驱动重试链） ----
 	const MAX_OPEN_ATTEMPTS = 60;
 	function cardElFor(sessionId) {
 		return document.querySelector(`[${PANE_ATTR}] [data-session-id="${escapeCssString(sessionId)}"]`);
@@ -7319,31 +7601,44 @@ function apply(ctx) {
 				}, 500);
 			});
 	}
+	// dsh 0.2.0 导航目标（T-170）：子代理行以持久父地址寻址（T-151 语义后继——宿主
+	// 仍按地址校验子代理会话路由）；地址不可得（母会话投影未拉取）时以裸 id 发起，
+	// 重试链在投影到达后自然命中。
+	function openTargetFor(sessionId) {
+		const listSnap = getSnapshot(sessions, "list");
+		const byId = listSnap?.byId ?? {};
+		if (!isSubagentRow(byId[sessionId], byId)) return sessionId;
+		try {
+			return sessions?.subagentAddress?.(String(sessionId)) ?? sessionId;
+		} catch {
+			return sessionId;
+		}
+	}
 	function attemptOpen(sessionId, attempt) {
-		// 过期链条（目标已到达 / 已被新激活意图取代）不再发起 open，防止拽回会话。
-		if (
-			shouldCancelOpenRetry({
-				targetId: sessionId,
-				currentId: getSnapshot(sessions, "list")?.current ?? null,
-				activatedId: lastActivatedId,
-			})
-		) {
+		// 过期链条（目标已到达 / 已被新激活意图取代）不再发起 open，防止拽回会话；
+		// 到达（currentId 命中本目标）即视为导航成功并收链。
+		const currentId = currentIdOf(getSnapshot(sessions, "list"));
+		if (shouldCancelOpenRetry({ targetId: sessionId, currentId, activatedId: lastActivatedId })) {
 			cancelOpenRetry(sessionId);
 			return;
 		}
 		const el = cardElFor(sessionId);
 		if (el !== null) el.setAttribute("data-opening", "");
 
-		if (openSession(sessions, sessionId)) {
-			// 移动视口下抑制原生 composer 在 sessionId 变化后的自动聚焦，
-			// 避免切换会话弹出软键盘（桌面保持原生自动聚焦）。
-			if (!desktopQuery.matches) suppressComposerAutofocus(document);
-			// 到达新目标后取消全部剩余链条：任何旧链成功都会把会话从新目标拽走。
-			cancelStaleOpenRetries({ activatedId: sessionId });
-			cancelOpenRetry(sessionId);
-			el?.removeAttribute("data-opening");
-			return;
-		}
+		// dsh 0.2.0（T-170）：导航经 uiWorkspace.openSession（内部以 source "mainView"
+		// retain 并驱动外壳 selection，替代已删除的 sessions.open）。发起不等于到达：
+		// 到达判定交给 currentId 驱动的取消链（同步循环每帧 cancelStaleOpenRetries
+		// 与本重试链共用 shouldCancelOpenRetry），data-opening 随取消/到达摘除；
+		// 未到达则 500ms 后重发导航（MAX_OPEN_ATTEMPTS 封顶）。
+		// 移动端抑制（R-01-005/AC-01）：宿主 composer 聚焦 effect 与 selection 同一
+		// 提交周期发生，抑制必须在发起导航时即武装（blur + 捕获期 focusin 拦截窗），
+		// 不能等到达判定——0.1.5 的「成功后抑制」时序在 0.2.0 会晚于宿主聚焦。
+		// 窗宽分档（T-170 审核发现 5）：首发沿用 1200ms 全窗；重试只武装 60ms
+		// 窄窗——失败的尝试不触发 selection 变更、宿主不聚焦，宽窗只会在失败链
+		// 期间连续吞掉用户聚焦；窄窗仍覆盖成功尝试的同一提交周期聚焦 effect。
+		const suppressFocus = !desktopQuery.matches;
+		openSession(ctx.get("uiWorkspace"), openTargetFor(sessionId));
+		if (suppressFocus) suppressComposerAutofocus(document, setTimeout, attempt === 0 ? 1200 : 60);
 		if (attempt < MAX_OPEN_ATTEMPTS) scheduleOpenRetry(sessionId, attempt + 1);
 		else cancelOpenRetry(sessionId);
 	}
@@ -7459,13 +7754,14 @@ function apply(ctx) {
 
 	const cleanup = () => {
 		disposed = true;
+		frameObserver?.disconnect();
+		frameObserver = null;
+		observedFrame = null;
 		sessionUnsubscribe?.();
 		workspaceUnsubscribe?.();
 		pendingUnsubscribe?.();
 		acksSource?.close();
 		acksSource = null;
-		jobsSource?.close();
-		jobsSource = null;
 		busySource?.close();
 		busySource = null;
 		document.removeEventListener("visibilitychange", onBusyVisibilityResume);
@@ -7500,8 +7796,12 @@ function apply(ctx) {
 		// 卸载即全量退订：空可见集合驱动 pruneSubscriptions 先 unsubscribe 再除名。
 		pruneSubscriptions(modelDirectorySubs, new Set());
 		pruneSubscriptions(logSourceSubs, new Set());
+		// 会话引用与 jobs roster 订阅随卸载全量释放（dsh 0.2.0 retain/流语义，T-170）。
+		releaseAllSessionRefs();
+		stopAllJobWatches();
+		jobsUnsubscribe?.();
+		jobsUnsubscribe = null;
 		progressAnchorById.clear();
-		sessionOpenLoads.clear();
 		loadQueue.length = 0;
 		loadInflight = 0;
 		for (const rec of cardsById.values()) rec.unbind?.();