dsh-activity-pane 0.15.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 }]。
 //
 // 展示规则：
@@ -1526,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);
@@ -1580,9 +1613,9 @@ function mainTitle(byId, id) {
 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)))
@@ -1716,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,
@@ -2407,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 ?? []);
@@ -2654,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;
@@ -2757,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";
@@ -2888,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 默认透明，
@@ -3489,17 +3538,27 @@ body:not([data-ds-dark-theme]) [data-dsh-activity-pane] .dap-workspace {
   border-color: rgba(255, 255, 255, 0.13);
   filter: none;
 }
-/* 任务卡行 1（R-01-023/AC-05）：状态点 + 工具名称 + 右缘随时钟时长；工具名不可得时
-   文本段隐藏，仅保留状态点与时长。 */
+/* 任务卡行 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;
@@ -3721,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;
@@ -3803,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 规则接管，覆盖反而会以更高
    优先级压掉运行/完成/错误状态色。 */
@@ -3901,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,
@@ -4029,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;
@@ -4077,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;
 	/** 最近一次已处理的当前卡片；同一卡片的运行时重绘不反复打断用户手动滚动。 */
@@ -4132,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;
@@ -4153,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/滚动区/输入框）
 	// 被真实挤到窗格右侧，且聊天列在增宽的会话带内自动居中。
@@ -4491,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",
 				};
 			}
 		}
@@ -4662,7 +4891,21 @@ 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({
@@ -4716,15 +4959,16 @@ function apply(ctx) {
 	 *  不 dispose、不拆订阅（由本函数在渲染期持续执法：其切走后的下一轮渲染
 	 *  照常释放）；当前会话不可判定（列表快照未就绪）时整轮跳过，不误释放。
 	 *  子代理日志窗口承载标题行可见的模型上下文，保留。切回更高档位时经既有
-	 *  渐进路径（captureSessionLog 重订阅 + session.open 重新水合）就绪，
+	 *  渐进路径（captureSessionLog 重订阅 + retain 重新水合）就绪，
 	 *  不新增恢复机制。 */
 	function enforceDensityDataDiscipline() {
 		if (densityLevel !== "compact") return;
 		const listSnap = getSnapshot(sessions, "list");
-		if (listSnap?.current == null) return;
+		const currentId = currentIdOf(listSnap);
+		if (currentId == null) return;
 		for (const [id, unsubscribe] of [...logSourceSubs]) {
 			if (!logWindowSuppressedFor(id, listSnap?.byId ?? {})) continue;
-			if (String(id) === String(listSnap.current)) continue;
+			if (String(id) === String(currentId)) continue;
 			try {
 				unsubscribe?.();
 			} catch {
@@ -4733,11 +4977,18 @@ function apply(ctx) {
 			logSourceSubs.delete(id);
 			const detail = sessionDetailsById.get(id) ?? null;
 			if (detail !== null) detail.log = null;
-			try {
-				sessions?.binding?.(id)?.session?.dispose?.();
-			} catch {
-				/* dispose 不可用：订阅已断即达成本档位纪律的可用部分 */
-			}
+			// 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);
 		}
 	}
 
@@ -4765,33 +5016,149 @@ function apply(ctx) {
 		// 当前选择），不可得时保持空白，不以日志历史取值或部署默认冒充（R-01-012/AC-18）。
 	}
 
-	/** 绑定会话并水合事件源（dsh 0.1.5 起会话内容经 eventSource 流式下发：打开即收
-	 *  完整日志窗口 + 实时尾，原生 Conversation 同源）。冷会话补一次 open()，日志窗口
-	 *  快照引用变化即重派生详情（时间线/预览/模型），窗口由宿主按消息对齐分页。 */
-	function captureSessionLog(id, { cwd } = {}) {
-		const detail = sessionDetailsById.get(id) ?? {};
-		sessionDetailsById.set(id, detail);
-		let session = null;
+	/** 会话引用获取（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 {
-			session = sessions?.binding?.(id)?.session ?? null;
+			record.reference?.release?.();
 		} catch {
-			session = null;
+			/* 引用已释放 */
 		}
-		if (session === null) return;
+	}
+
+	/** 母会话投影按需拉取（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）：紧凑档主会话不建立或保持会话日志窗口——
-		// 不订阅事件流、不发起 open 水合、不读窗口快照。判定在函数入口用时重读，
+		// 不订阅事件流、不发起水合、不读窗口快照。判定必须先于 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);
+		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;
+		}
 		// 日志窗口无效化订阅（事件驱动，不构成轮询，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 ?? "" });
@@ -4802,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(日志窗口)
@@ -4848,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()` 无参数读取；成功即缓存不再
 	 *  重发，失败留待下轮详情读取重试。 */
@@ -4911,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 {
@@ -4934,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();
 	}
@@ -4955,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"));
@@ -5097,9 +5467,10 @@ function apply(ctx) {
 			enforceDensityDataDiscipline();
 			applyDensity();
 			// 档位已纳入渲染签名：触发一轮同步让时间线按新档位以 lastOnly 重建；
-			// 锚定补偿在本轮渲染提交后执行，此时量测才含新行高
+			// 锚定补偿在渲染提交后逐帧执行至沉降窗结束，此时量测才含新行高
 			//（R-01-021/AC-01、AC-08）。
 			pendingDensityAnchor = currentCard && anchorTop !== null ? anchorTop : null;
+			densityAnchorDeadline = Date.now() + 1500;
 			queueSync();
 		};
 		// 档位按钮位于标题行右侧的工具区（标题区折叠控件的兄弟节点），激活天然不会
@@ -5133,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）。
@@ -6095,72 +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();
-				});
-			} catch {
-				continue; // 订阅失败：本次跳过，下次渲染重试
-			}
-			// 子代理事件流仅接受持久父地址：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;
+				} 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,
+				});
 			}
-			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;
@@ -6188,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;
@@ -6361,7 +6756,7 @@ function apply(ctx) {
 			// 按条目 id 复用，同一 card 元素不会跨 kind 复用——创建时按 entry.kind 一次性
 			// 决定是否绑激活是安全的；若 id 规则变化须同步复核此处。
 			const unbind = entry.kind === "job" ? null : bindCardActivation(el, (sessionId) => {
-				if (typeof sessions?.open !== "function") return;
+				if (typeof ctx.get("uiWorkspace")?.openSession !== "function") return;
 				lastActivatedId = sessionId;
 				// 新激活意图取代一切旧重试链，避免过期链条稍后把当前会话拽回旧目标；
 				// 收起抽屉的分支同样是最新意图，必须先取消挂起链条再 return。
@@ -6371,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",
@@ -6667,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 };
 		}
@@ -6698,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）；暂停等待的子代理只显示标题。
@@ -6808,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;
@@ -6937,7 +7337,8 @@ 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，重复执法为无操作。
@@ -6950,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
@@ -7053,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");
@@ -7126,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 卡实时定位：跨区迁移等渲染可能重建卡片
@@ -7135,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)}"]`);
@@ -7184,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);
 	}
@@ -7324,6 +7754,9 @@ function apply(ctx) {
 
 	const cleanup = () => {
 		disposed = true;
+		frameObserver?.disconnect();
+		frameObserver = null;
+		observedFrame = null;
 		sessionUnsubscribe?.();
 		workspaceUnsubscribe?.();
 		pendingUnsubscribe?.();
@@ -7363,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?.();