dsh-compact-relay 0.4.1 → 0.5.0

package/lib/client.js

@@ -2,6 +2,7 @@
  * dsh-compact-relay —— 浏览器半（DSH client bundle）。
  *
  * 职责：输入框左侧指示灯 / 悬停卡 / 菜单 / 压缩确认卡 / 交接单面板 / toast，
+ *       输入框上方接力条（0.5.0：已接力自 … + 下拉菜单），
  *       以及 /handoff 命令卡（命令成功后自动切到新会话）。
  * 数据：GET /api/compact-relay-state、SSE /api/compact-relay-stream；
  * 动作：POST /api/compact-relay-action；交接单：GET /api/compact-relay-handoffs。
@@ -724,6 +725,225 @@ window.__ModuleLoader__.load({
         })
         .filter((node) => node !== null);
     }
+    /**
+     * 交接线保命判定 —— 纯函数，零依赖（0.4.2）。
+     *
+     * 背景（0.4.1 遗留的三个洞，见 docs/0.4.2-implementation-plan.md）：
+     * 1. 交接提醒线仍是配置值（默认 60%），换到实际触发线更低的模型（如 55%）时，
+     *    DSH 会先自己压历史，dcr 的交接提醒来不及；
+     * 2. 服务端保存校验只看配置阈值（80%），手改设置文件能设到 70%；
+     * 3. 旧值不跟随当前模型，除设置页一行 warning 外没有其它可见提示。
+     *
+     * 0.4.2 规则（范围定稿）：
+     *   交接提醒线 ≤ 实际触发线 − 5pp（HANDOFF_MARGIN_PP），向下取整到整数百分位。
+     *   - 实际触发线来自 state.native.ratio（按当前路由模型实时算，见 core/native-line.js）；
+     *   - 实际线算不出时：运行时不告警、不阻断；服务端保存退回配置阈值防呆（0.4.1 行为）；
+     *   - DSH 原生自动压缩关闭时不存在「被抢先压缩」的截止线，不判定；
+     *   - 只告警 / 拒绝，绝不静默改写用户配置。
+     *
+     * 本模块只做判定与文案，不做 IO：服务端 `lib/actions/settings.js` 直接 import，
+     * 客户端由 `scripts/build-client.mjs` 的 `/* @inline core/handoff-guard.js *\/`
+     * 内联进 `lib/client.js`（同一份判定，避免 UI 与后台两套口径）。
+     */
+
+    /** 交接线相对实际触发线至少留 5 个百分点（1M 窗口 ≈ 50K tokens 缓冲）。 */
+    const HANDOFF_MARGIN_PP = 5;
+
+    /** 实际线算不出、退回配置阈值防呆时的余量（0.4.1 口径：最高 = 配置阈值 −1pp）。 */
+    const FALLBACK_MARGIN_PP = 1;
+
+    /** cap 的绝对上限（避免算出 96%+ 这种没有意义的上限）。 */
+    const HANDOFF_LIMIT_DEFAULT = 0.95;
+
+    const EPS = 1e-9;
+
+    /**
+     * 合法窗口比例：必须是 0<r<1 的有限数。
+     * @param {unknown} value
+     * @returns {number|null}
+     */
+    function ratioOf(value) {
+      return typeof value === 'number' && Number.isFinite(value) && value > 0 && value < 1 ? value : null;
+    }
+
+    /**
+     * 比例 → 百分数数字（一位小数，整数不带小数）：0.678 → 67.8，0.62 → 62。
+     * @param {number|null} ratio
+     * @returns {number|null}
+     */
+    function percentOf(ratio) {
+      if (ratio === null) return null;
+      const percent = ratio * 100;
+      return Math.abs(percent - Math.round(percent)) < 0.05 ? Math.round(percent) : Number(percent.toFixed(1));
+    }
+
+    /**
+     * 比例 → 百分数文本（用于文案）：0.678 → '67.8'，0.62 → '62'。
+     * @param {number|null} ratio
+     * @returns {string}
+     */
+    function percentText(ratio) {
+      if (ratio === null) return '';
+      const percent = ratio * 100;
+      return Math.abs(percent - Math.round(percent)) < 0.05 ? String(Math.round(percent)) : percent.toFixed(1);
+    }
+
+    /**
+     * 只算交接线上限：参考线 − marginPp，向下取整到整数百分位，再夹到 limit。
+     *
+     * 浮点安全：`0.62 − 0.05` 在二进制里可能是 0.5700000000000001 / 0.5699999999999999，
+     * 直接 floor 会把 57 变成 56，所以加 EPS 再 floor。
+     *
+     * @param {number|null} referenceRatio 参考线（实际触发线或配置阈值），非法时返回 null
+     * @param {{marginPp?:number, limit?:number}} [options]
+     * @returns {number|null} 例如 0.62；参考线太小（减完 ≤0）时返回 null
+     */
+    function handoffCapOf(referenceRatio, { marginPp = HANDOFF_MARGIN_PP, limit = HANDOFF_LIMIT_DEFAULT } = {}) {
+      const reference = ratioOf(referenceRatio);
+      if (reference === null) return null;
+      const margin = (Number.isFinite(marginPp) ? marginPp : HANDOFF_MARGIN_PP) / 100;
+      const max = Number.isFinite(limit) && limit > 0 && limit < 1 ? limit : HANDOFF_LIMIT_DEFAULT;
+      // 向下取整到整数百分位（例如 62.8 → 0.62），不是四舍五入。
+      const cap = Math.floor((reference - margin) * 100 + EPS) / 100;
+      if (!(cap > 0)) return null;
+      return Math.min(cap, max);
+    }
+
+    /** 「重算目标 ≤ 压缩线」时的补充提示（保持「交接线 > 压缩线」现有约束）。 */
+    function compactConflictText(capPercent, compactRatio) {
+      return `按实际线重算目标 ${capPercent}% 不高于压缩线 ${percentText(compactRatio)}%，请先把压缩线降到 ${capPercent}% 以下。`;
+    }
+
+    /**
+     * 判定「当前交接线是否会在 DSH 原生压缩之后」。
+     *
+     * @param {object} [input]
+     * @param {number|null} [input.actualRatio] 当前模型实际触发线（state.native.ratio）；算不出/关闭时 null
+     * @param {number|null} [input.configuredRatio] 配置阈值（native.thresholdRatio），兜底用
+     * @param {number|null} [input.handoffRatio] 当前交接提醒线（thresholds.handoffRatio）
+     * @param {number|null} [input.compactRatio] 压缩提醒线（thresholds.compactRatio），判重算冲突
+     * @param {boolean} [input.autoEnabled] DSH 原生自动压缩是否开启（false → 不判定，交接线无截止线）
+     * @param {number} [input.limit] cap 绝对上限，默认 0.95
+     * @param {'none'|'configured'} [input.fallback]
+     *   'none'（运行时默认）：实际线算不出就不判定（不告警、不阻断）；
+     *   'configured'（服务端保存默认）：实际线算不出时按配置阈值 −1pp 防呆（0.4.1 行为）。
+     * @returns {{
+     *   source:'actual'|'configured'|null,
+     *   actualRatio:number|null, actualPercent:number|null,
+     *   configuredRatio:number|null, configuredPercent:number|null,
+     *   handoffRatio:number|null, handoffPercent:number|null,
+     *   compactRatio:number|null, compactPercent:number|null,
+     *   cap:number|null, capPercent:number|null,
+     *   ok:boolean, severity:'ok'|'warn'|'late'|'unknown',
+     *   reason:'ok'|'late'|'margin'|'fallback'|'no-reference'|'invalid-handoff'|'no-cap',
+     *   message:string, target:number|null, compactConflict:boolean
+     * }}
+     */
+    function handoffGuard({
+      actualRatio = null,
+      configuredRatio = null,
+      handoffRatio = null,
+      compactRatio = null,
+      autoEnabled = true,
+      limit = HANDOFF_LIMIT_DEFAULT,
+      fallback = 'none',
+    } = {}) {
+      const actual = ratioOf(actualRatio);
+      const configured = ratioOf(configuredRatio);
+      const handoff = ratioOf(handoffRatio);
+      const compact = ratioOf(compactRatio);
+      const neutral = {
+        source: null,
+        actualRatio: actual,
+        actualPercent: percentOf(actual),
+        configuredRatio: configured,
+        configuredPercent: percentOf(configured),
+        handoffRatio: handoff,
+        handoffPercent: percentOf(handoff),
+        compactRatio: compact,
+        compactPercent: percentOf(compact),
+        cap: null,
+        capPercent: null,
+        ok: true,
+        severity: 'unknown',
+        reason: 'no-reference',
+        message: '',
+        target: null,
+        compactConflict: false,
+      };
+      // 原生自动压缩关着：DSH 不会自己压，不存在「提醒来不及」的截止线。
+      if (autoEnabled === false) return neutral;
+
+      /** 带 cap 的结果骨架（cap 已是整数百分位，×100 即整数）。 */
+      const withCap = (source, cap) => {
+        const capPercent = cap === null ? null : Math.round(cap * 100);
+        return {
+          ...neutral,
+          source,
+          cap,
+          capPercent,
+          target: source === 'actual' ? cap : null,
+          compactConflict: cap !== null && compact !== null && cap <= compact + EPS,
+        };
+      };
+
+      // 1) 实际触发线可用：唯一口径（−5pp），不再叠加「配置阈值 −1pp」。
+      if (actual !== null) {
+        const cap = handoffCapOf(actual, { limit });
+        if (cap === null) return { ...withCap('actual', null), reason: 'no-cap' };
+        const base = withCap('actual', cap);
+        if (handoff === null) return { ...base, reason: 'invalid-handoff' };
+        const conflict = base.compactConflict ? compactConflictText(base.capPercent, compact) : '';
+        // 等于实际触发线也算「晚」：DSH 会在同一位置自己压历史，提醒来不及。
+        if (handoff > actual - EPS) {
+          return {
+            ...base,
+            ok: false,
+            severity: 'late',
+            reason: 'late',
+            message:
+              `交接线已晚：当前模型实际触发 ${percentText(actual)}%，交接线 ${percentText(handoff)}% 会在原生压缩之后` +
+              `（DSH 会先压历史）；最高可设 ${base.capPercent}%。${conflict}`,
+          };
+        }
+        if (handoff > cap + EPS) {
+          return {
+            ...base,
+            ok: false,
+            severity: 'warn',
+            reason: 'margin',
+            message:
+              `交接线偏晚：当前模型实际触发 ${percentText(actual)}%，交接线 ${percentText(handoff)}% ` +
+              `距原生压缩不足 ${HANDOFF_MARGIN_PP} 个百分点；最高可设 ${base.capPercent}%。${conflict}`,
+          };
+        }
+        return { ...base, ok: true, severity: 'ok', reason: 'ok' };
+      }
+
+      // 2) 实际线算不出 + 服务端保存：退回配置阈值防呆（0.4.1 行为，兼容旧客户端）。
+      if (fallback === 'configured' && configured !== null) {
+        const cap = handoffCapOf(configured, { marginPp: FALLBACK_MARGIN_PP, limit });
+        if (cap === null) return { ...withCap('configured', null), reason: 'no-cap' };
+        const base = withCap('configured', cap);
+        if (handoff === null) return { ...base, reason: 'invalid-handoff' };
+        if (handoff > cap + EPS) {
+          return {
+            ...base,
+            ok: false,
+            severity: 'warn',
+            reason: 'fallback',
+            message:
+              `「交接提醒线」必须低于 DSH 原生自动压缩线（配置阈值 ${percentText(configured)}%），` +
+              `否则原生压缩会先动手；最高只能设到 ${base.capPercent}%。` +
+              '想设更高请先在设置里关闭「DSH 原生自动压缩」。',
+          };
+        }
+        return { ...base, ok: true, severity: 'ok', reason: 'ok' };
+      }
+
+      // 3) 运行时且算不出：不告警、不阻断。
+      return neutral;
+    }
 
     const fmt = (n) => {
       if (n == null) return '—';
@@ -1307,6 +1527,22 @@ window.__ModuleLoader__.load({
       // 0.3.1：模型判断的「这里适合压缩」位置 → 断点1（优先于阈值）；失效的 hint 由 host 过滤。
       const hintRatio = state.compressHint && typeof state.compressHint.ratio === 'number' ? state.compressHint.ratio : null;
       const ring = ringSegments(ratio, compactRatio, handoffRatio, hintRatio);
+      /**
+       * 0.4.2（P0-1）：交接线是否已晚 —— 硬上限 = 实际触发线 −5pp（与后台 save() 同一份判定）。
+       * 只在宿主算出实际触发线（native.ratio）且原生自动压缩开启时判定；
+       * 算不出时按范围定稿「不告警、不阻断」。
+       */
+      const handoffGuardInfo = handoffGuard({
+        actualRatio: state.native === null ? null : state.native.ratio,
+        configuredRatio: state.native === null ? null : state.native.thresholdRatio,
+        handoffRatio,
+        compactRatio,
+        autoEnabled: state.native === null ? true : state.native.autoEnabled !== false,
+      });
+      const handoffLate = handoffGuardInfo.source === 'actual' && handoffGuardInfo.ok === false;
+      const handoffWarnText = handoffLate
+        ? `⚠ 交接线已晚：实际触发 ${handoffGuardInfo.actualPercent}%，交接线 ${handoffGuardInfo.handoffPercent}% 会在原生压缩之后（最高 ${handoffGuardInfo.capPercent}%）`
+        : '';
       // DSH 原生自动压缩线（报警最高阈值）：开着时在环上画一个「径向刻度」（不是沿环的弧），
       // 用紫色 + 主题底色描边——刻意不用五级配色里的颜色，保证在任何分段颜色上都看得清。
       // 越过原生线后：整环红色闪烁（作者 2026-10-20 反馈）。
@@ -1374,6 +1610,39 @@ window.__ModuleLoader__.load({
           }),
         );
       }
+      // 0.4.2（P1）：交接线已晚时，在环上「交接刻度」旁加一个小警示（径向短线 + 小点）。
+      // 只加节点，不改环的分段/断点逻辑（范围定稿：A/B/C 画法不并进 0.4.2）。
+      const handoffWarnNodes = [];
+      if (handoffLate) {
+        const tick = nativeTickAt(handoffRatio); // 复用同一套径向几何，位置换成交接线
+        const warnAngle = handoffRatio * Math.PI * 2 - Math.PI / 2;
+        handoffWarnNodes.push(
+          h('line', {
+            key: 'handoff-warn-casing',
+            ...tick,
+            stroke: theme.dark ? '#26262c' : '#ffffff',
+            strokeWidth: 4.4,
+            strokeLinecap: 'round',
+            opacity: 0.92,
+          }),
+          h('line', {
+            key: 'handoff-warn',
+            ...tick,
+            stroke: palette.handoff,
+            strokeWidth: 2.2,
+            strokeLinecap: 'round',
+            'data-cr-handoff-warn': '1',
+          }),
+          h('circle', {
+            key: 'handoff-warn-dot',
+            cx: Number((10 + 9.4 * Math.cos(warnAngle)).toFixed(3)),
+            cy: Number((10 + 9.4 * Math.sin(warnAngle)).toFixed(3)),
+            r: 1.05,
+            fill: palette.handoff,
+            'data-cr-handoff-warn-dot': '1',
+          }),
+        );
+      }
       // 平时给中心一点可见的灰点；交接时红点（外环已分段，红点强调该交接）。
       const dotColor = adviseHandoff ? palette.handoff : palette.idle;
       // 锁定消息在环上的块（方案 A：按消息在历史里的相对位置）。这是「保护内容」的信号，
@@ -1488,6 +1757,29 @@ window.__ModuleLoader__.load({
         return () => window.removeEventListener('compact-relay:replay-onboarding', onReplay);
       }, [playOnboarding]);
 
+      // 0.4.2（P1）：换模型后首次发现「交接线已晚」弹一次提示（同路由不重复打扰）。
+      // 只在「观察到路由变化」（localStorage 记着上一次的 provider/model）时弹；
+      // 首次见到某路由不弹（不是换模型导致的），设置页有常驻提示兜底。
+      useEffect(() => {
+        if (state.native === null || state.native.route === null) return;
+        const key = `${state.native.route.provider || ''}/${state.native.route.model}`;
+        let previous = null;
+        try {
+          previous = window.localStorage.getItem('dsh.compact-relay.route.v1');
+        } catch {
+          previous = null; // 隐私模式：不记、不弹，避免反复打扰
+          return;
+        }
+        if (previous === key) return;
+        try {
+          window.localStorage.setItem('dsh.compact-relay.route.v1', key);
+        } catch {
+          /* ignore */
+        }
+        if (previous === null || previous === '' || !handoffLate) return;
+        showToast(`已切换到 ${state.native.route.model}：${handoffWarnText.replace('⚠ ', '')}。可在「设置 → 压缩接力」一键重算。`, 10000);
+      }, [state.native, handoffLate, handoffWarnText, showToast]);
+
       // 引导光晕：默认 4 次呼吸后自动停（手动重播时按传入时长）。
       useEffect(() => {
         if (!onboarding) return undefined;
@@ -1837,6 +2129,7 @@ window.__ModuleLoader__.load({
         `，已压缩 ${state.summaries} 次｜${adviceText}` +
         (compressHintText !== '' ? `｜${compressHintText}` : '') +
         (nativeLineText !== '' ? `｜${nativeLineText}` : '') +
+        (handoffWarnText !== '' ? `｜${handoffWarnText}` : '') +
         (pins.count > 0 ? `｜已锁定 ${pins.count} 条` : '') +
         (effectiveBusy ? '｜处理中…' : '');
 
@@ -1896,6 +2189,10 @@ window.__ModuleLoader__.load({
                 { style: { color: theme.subText } },
                 `已压缩 ${state.summaries} 次 · ${adviceText}${compressHintText !== '' ? ` · ${compressHintText}` : ''}${nativeLineText !== '' ? ` · ${nativeLineText}` : ''}${pins.count > 0 ? ` · 已锁定 ${pins.count} 条` : ''}${effectiveBusy ? ' · 处理中…' : ''}`,
               ),
+              // 0.4.2：交接线晚于原生压缩时，悬停卡里给一行显式警示（只告警，不改设置）。
+              handoffWarnText !== ''
+                ? h('div', { 'data-cr-handoff-warn-text': '1', style: { marginTop: 2, color: palette.handoff } }, handoffWarnText)
+                : null,
             )
           : null;
 
@@ -1918,6 +2215,8 @@ window.__ModuleLoader__.load({
         }),
         // 0.3.1：DSH 原生自动压缩线（刻度/危险区）。
         ...nativeNodes,
+        // 0.4.2：交接线已晚的警示标记（交接刻度旁的小短线 + 小点，不改分段逻辑）。
+        ...handoffWarnNodes,
         // 0.3.1：锁定消息在环上的块（品红，按历史位置）。
         ...pinBlocks,
       );
@@ -2133,6 +2432,8 @@ window.__ModuleLoader__.load({
                     onClick: () => {
                       void startHandoffPreview();
                     },
+                    // 0.4.2（P1）：交接线晚于原生压缩时，菜单项旁直接标出来（只告警，仍可点）。
+                    ...(handoffLate ? { note: handoffWarnText, title: handoffGuardInfo.message } : {}),
                   }
                 : { disabled: true, note: '会话刚打开，请稍候' },
             ),
@@ -2841,114 +3142,878 @@ window.__ModuleLoader__.load({
       );
     }
 
-    /** 交接结果的一行式展示（放在聊天流里的 /handoff 命令卡）。 */
-    function handoffRow(text, tone, action) {
+    /* ---------------- 0.5.0 接力条（v1）：输入框上方一行「已接力自 …」 ---------------- */
+
+    /**
+     * 0.5.0 接力条 v1 —— 只做「一行摘要 + 向上弹出的下拉菜单」。
+     *
+     * 位置：`conversation.input.dock`（list / session scope；宿主文档原文
+     *       “Full-width entries above the composer card”，即输入卡上方通栏）。
+     * 显示：`readState.chain` 非 null，且这条记录是**本会话的入站记录**
+     *       （childId === sessionId）。出站记录（本会话交接给了下一代）不显示
+     *       「已接力自」；老宿主/没有 chain 字段时组件返回 null，不占高度。
+     * 数据：GET `/api/compact-relay-state?sessionId=…`。会话刚打开、宿主还没装日志
+     *       时短重试几次（拿到本会话的 sessionId 后就停，不做常驻轮询/SSE）。
+     *       子会话的 relay record 不带 path（F3 只写链号），缺 path 时再只读一次父
+     *       会话状态，用父记录里的 path 打开交接单（childId/ordinal 校验）。
+     * 交互：点击这一行 → fixed 定位、向上弹出的菜单（不被输入区裁切）：
+     *       查看交接单 / 回到原会话 / 路线图（即将上线，占位禁用）。
+     */
+
+    /**
+     * readState.chain → 接力条可用的最小结构；无效时返回 null（不猜、不补默认值）。
+     *
+     * 只接受 ordinal 为正整数的链；baseTitle/parentId/path 缺了就保持 null，
+     * 由 UI 决定禁用或回落文案。老宿主的响应里没有 chain 字段 → null → 不渲染。
+     *
+     * @param {object|null|undefined} data `/api/compact-relay-state` 的响应
+     * @param {string|undefined} sessionId 当前会话 id（dock 的 session scope 参数）
+     * @returns {{ordinal:number, baseTitle:string|null, parentId:string|null, childId:string|null, scheme:'handoff-n'|'history-n'|null, path:string|null}|null}
+     */
+    function relayBarChainOf(data, sessionId) {
+      const chain = relayChainProjectionOf(data);
+      if (chain === null) return null;
+      // 出站记录（本会话把接力棒交给下一代）：它不是「已接力自」，v1 不显示。
+      // childId 缺失时（旧链路记录形态）不据此隐藏，遵守「chain 非 null 就显示」。
+      if (chain.childId !== null && typeof sessionId === 'string' && sessionId.length > 0 && chain.childId !== sessionId) return null;
+      return chain;
+    }
+
+    /**
+     * 只做字段投影，不做「是不是本会话入站记录」的判断。
+     *
+     * 单独拆出来是给「父记录补 path」用：父会话里的同一条记录是出站的
+     * （childId=本会话），用 relayBarChainOf 会被入站判断过滤掉，但它的 path
+     * 恰恰是子会话要打开的那份交接单。
+     *
+     * @param {object|null|undefined} data `/api/compact-relay-state` 的响应
+     * @returns {{ordinal:number, baseTitle:string|null, parentId:string|null, childId:string|null, scheme:'handoff-n'|'history-n'|null, path:string|null}|null}
+     */
+    function relayChainProjectionOf(data) {
+      if (data === null || typeof data !== 'object' || data.ok === false) return null;
+      const chain = data.chain;
+      if (chain === null || typeof chain !== 'object') return null;
+      if (!Number.isInteger(chain.ordinal) || chain.ordinal <= 0) return null;
+      const text = (value) => (typeof value === 'string' && value.length > 0 ? value : null);
+      return {
+        ordinal: chain.ordinal,
+        baseTitle: text(chain.baseTitle),
+        parentId: text(chain.parentId),
+        childId: text(chain.childId),
+        scheme: chain.scheme === 'handoff-n' || chain.scheme === 'history-n' ? chain.scheme : null,
+        path: text(chain.path),
+      };
+    }
+
+    /**
+     * 0.5.0：旧会话是否已被交接流程自动归档。
+     *
+     * 宿主 `readState` 在链有父会话时下发 `parentArchived`（boolean；服务不可用为 null）。
+     * 老宿主没有这个字段 → null（客户端按「可尝试恢复」处理，恢复调用本身幂等）。
+     * @param {object|null|undefined} data `/api/compact-relay-state` 的响应
+     * @returns {boolean|null}
+     */
+    function relayBarParentArchivedOf(data) {
+      if (data === null || typeof data !== 'object' || data.ok === false) return null;
+      return typeof data.parentArchived === 'boolean' ? data.parentArchived : null;
+    }
+
+    /**
+     * 接力条摘要：新链「历史 N：原名」，旧链「交接第 N 次：原名」。
+     * @param {object} chain relayBarChainOf 的结果
+     * @returns {string}
+     */
+    function relayBarLabelOf(chain) {
+      const baseTitle = chain.baseTitle === null ? '会话' : chain.baseTitle;
+      return chain.scheme === 'history-n' ? `历史 ${chain.ordinal}：${baseTitle}` : `交接第 ${chain.ordinal} 次：${baseTitle}`;
+    }
+
+    /**
+     * 交接单绝对路径 → `/api/compact-relay-handoffs?file=` 只接受的 handoff-*.md 文件名。
+     * 服务端只认文件名（不是全路径），这里取 basename 并做同一形态校验；不合法 → null。
+     * @param {string|null} path
+     * @returns {string|null}
+     */
+    function relayBarDocNameOf(path) {
+      if (typeof path !== 'string' || path.length === 0) return null;
+      const name = path.split(/[\\/]/).pop();
+      return typeof name === 'string' && /^handoff-[0-9A-Za-z][0-9A-Za-z.\-_]*\.md$/.test(name) ? name : null;
+    }
+
+    /** 接力条菜单里的一行（和指示灯菜单同一套视觉，但更轻）。 */
+    function relayBarItem(label, sub, key, action, meta = {}) {
+      const disabled = meta.disabled === true;
       return h(
-        'div',
+        'button',
         {
+          type: 'button',
+          key,
+          role: 'menuitem',
+          'data-cr-relay-action': key,
+          disabled,
+          title: meta.title ?? (disabled ? sub : undefined),
+          onClick: () => {
+            if (disabled || typeof action !== 'function') return;
+            action();
+          },
           style: {
             display: 'flex',
             alignItems: 'center',
-            gap: 8,
-            padding: '4px 2px',
-            fontSize: 12,
-            color: tone === 'error' ? COLORS.error : COLORS.subText,
+            gap: 10,
+            width: '100%',
+            minHeight: 32,
+            padding: '5px 10px',
+            border: 'none',
+            borderRadius: 8,
+            background: 'transparent',
+            textAlign: 'left',
+            cursor: disabled ? 'default' : 'pointer',
+            color: 'var(--dsw-alias-label-primary, inherit)',
+            opacity: disabled ? 0.55 : 1,
+            font: 'inherit',
+          },
+          onMouseEnter: (event) => {
+            if (!disabled) event.currentTarget.style.background = 'var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,0.10))';
+          },
+          onMouseLeave: (event) => {
+            event.currentTarget.style.background = 'transparent';
           },
         },
-        h('span', { style: { flex: 1, minWidth: 0 } }, text),
-        action
-          ? h(
-              'button',
-              {
-                type: 'button',
-                onClick: action,
-                style: {
-                  flex: 'none',
-                  border: 'none',
-                  borderRadius: 6,
-                  padding: '2px 8px',
-                  background: COLORS.hover,
-                  color: 'inherit',
-                  fontSize: 11,
-                  cursor: 'pointer',
-                },
-              },
-              '重试打开',
-            )
-          : null,
+        h(
+          'span',
+          { style: { display: 'flex', flexDirection: 'column', gap: 1, flex: 1, minWidth: 0 } },
+          h('span', { style: { fontSize: 12, fontWeight: 500 } }, label),
+          sub !== null
+            ? h(
+                'span',
+                { style: { fontSize: 10, lineHeight: '14px', color: 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.9))' } },
+                sub,
+              )
+            : null,
+        ),
+        h(
+          'span',
+          { style: { flex: 'none', fontSize: 11, color: 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.9))', whiteSpace: 'nowrap' } },
+          meta.right ?? (disabled ? '' : '›'),
+        ),
       );
     }
 
     /**
-     * /handoff 命令卡：命令成功后自动切到新会话。
-     * 这个槽把命令的通用卡片替换成我们的卡片（只有 /handoff 这一个 key）。
+     * 接力条本体（`conversation.input.dock`，输入卡上方一行）。
+     *
+     * @param {object} props ctx.slots.register 注入的 props
+     * @param {string} [props.sessionId] 当前会话 id（session scope）
+     * @param {(sessionId:string)=>unknown} [props.openSession] 切到某个会话（ctx.uiWorkspace.openSession）
+     * @param {(sessionId:string)=>Promise<unknown>|undefined} [props.unarchiveSession] 恢复归档会话
+     *   （ctx.uiWorkspace.unarchiveSession；老宿主没有 → 走本插件 HTTP recover 兜底）
      */
-    function HandoffCard({ node, waitAndOpen }) {
-      const outcome = node !== null && typeof node === 'object' ? node.outcome : undefined;
-      const outcomeText = outcome !== null && typeof outcome === 'object' && typeof outcome.text === 'string' ? outcome.text : '';
-      // A5：优先用命令结果里的结构化 childId；旧宿主没带字段时再从文本 #child= 兜底。
-      const childId =
-        outcome !== null && typeof outcome === 'object' && typeof outcome.childId === 'string' && outcome.childId.length > 0
-          ? outcome.childId
-          : extractChildId(outcomeText);
-      // P2-C1：区分 opening / opened / failed；刷新后只有 localStorage='1' 才算已打开，
-      // 'opening'（上次没走完）要重新尝试，不能直接渲染成功态。
-      const [status, setStatus] = useState(() => {
-        if (outcome === undefined) return 'running';
-        if (outcome !== null && outcome.kind === 'error') return 'error';
-        if (childId === null) return 'done';
-        return wasOpened(childId) ? 'done' : 'opening';
-      });
-      const [detail, setDetail] = useState(null);
+    function CompactRelayBar(props) {
+      const sessionId = props === null || props === undefined ? undefined : props.sessionId;
+      const openSession = props === null || props === undefined ? undefined : props.openSession;
+      const unarchiveSession = props === null || props === undefined ? undefined : props.unarchiveSession;
+      const hasSession = typeof sessionId === 'string' && sessionId.length > 0;
+      const [chain, setChain] = useState(null);
+      // null = 宿主没给归档状态（老宿主）；true/false = readState.parentArchived。
+      const [parentArchived, setParentArchived] = useState(null);
+      const [open, setOpen] = useState(false);
+      const [doc, setDoc] = useState(null);
+      const [notice, setNotice] = useState(null);
+      const [anchor, setAnchor] = useState(null);
+      const theme = useAutoTheme();
+      const rootRef = useRef(null);
+      const triggerRef = useRef(null);
+      const menuRef = useRef(null);
+      const docRequestRef = useRef(0);
+      const docAbortRef = useRef(null);
 
-      const openChild = useCallback(() => {
-        if (childId === null) return;
-        setStatus('opening');
-        setDetail(null);
-        waitAndOpen(childId).then(
-          () => {
-            markOpened(childId, '1');
-            setStatus('done');
-          },
-          (error) => {
-            clearOpened(childId);
-            setStatus('failed');
-            setDetail(String(error && error.message ? error.message : error));
-          },
-        );
-      }, [childId, waitAndOpen]);
+      /** 取消未完成的交接单读取；同时让晚到的响应失效（requestId 对不上）。 */
+      const abortDoc = useCallback(() => {
+        docRequestRef.current += 1;
+        if (docAbortRef.current !== null) {
+          try {
+            docAbortRef.current.abort();
+          } catch {
+            /* ignore */
+          }
+          docAbortRef.current = null;
+        }
+      }, []);
 
+      const closeMenu = useCallback(() => {
+        abortDoc();
+        setOpen(false);
+        setDoc(null);
+        setNotice(null);
+      }, [abortDoc]);
+
+      // 从交接单详情回到菜单列表：取消读取，避免「返回后又被晚到的响应撑开」。
+      const backToMenu = useCallback(() => {
+        abortDoc();
+        setDoc(null);
+      }, [abortDoc]);
+
+      // 读链状态。会话刚打开时宿主可能还没把日志装进内存（readState.sessionId 为
+      // null），这时要重试几次；一旦宿主确认「就是这个会话且没有 chain」就停，
+      // 普通会话不会无限打接口。fetch 失败/老宿主没有 chain → setChain(null) → 不渲染。
       useEffect(() => {
-        if (outcome === undefined || outcome === null || outcome.kind !== 'success' || childId === null) return;
-        if (wasOpened(childId)) {
-          setStatus('done');
-          return;
+        // 换会话/没有会话时先清掉上一条链（dock 组件可能被复用而不是重挂）。
+        setChain(null);
+        setParentArchived(null);
+        setOpen(false);
+        setDoc(null);
+        setNotice(null);
+        if (!hasSession) return undefined;
+        let dead = false;
+        let timer = 0;
+        let attempts = 0;
+        const url = `/api/compact-relay-state?sessionId=${encodeURIComponent(sessionId)}`;
+        const schedule = () => {
+          if (dead) return;
+          attempts += 1;
+          if (attempts > 12) return;
+          timer = setTimeout(() => {
+            void load();
+          }, Math.min(500 * attempts, 3000));
+        };
+        async function loadParentPath(localChain) {
+          try {
+            const res = await fetch(`/api/compact-relay-state?sessionId=${encodeURIComponent(localChain.parentId)}`, {
+              cache: 'no-store',
+            });
+            if (dead || !res.ok) return;
+            const parentData = await res.json().catch(() => null);
+            if (dead) return;
+            const parentChain = relayChainProjectionOf(parentData);
+            if (
+              parentChain === null ||
+              parentChain.childId !== sessionId ||
+              parentChain.ordinal !== localChain.ordinal ||
+              parentChain.path === null
+            ) {
+              return;
+            }
+            setChain((previous) => (previous === null ? previous : { ...previous, path: parentChain.path }));
+          } catch {
+            /* 父会话读不到（未加载/已归档）：保持「暂无交接单」，不影响接力条本身 */
+          }
         }
-        markOpened(childId, 'opening');
-        let alive = true;
-        waitAndOpen(childId).then(
-          () => {
-            markOpened(childId, '1');
-            if (alive) setStatus('done');
-          },
-          (error) => {
-            clearOpened(childId);
-            if (!alive) return;
-            setStatus('failed');
-            setDetail(String(error && error.message ? error.message : error));
-          },
-        );
+        async function load() {
+          try {
+            const res = await fetch(url, { cache: 'no-store' });
+            if (dead) return;
+            if (!res.ok) {
+              // 4xx（鉴权/端点不存在）等下去也不会变；5xx/网络抖动才重试。
+              if (res.status >= 400 && res.status < 500) return;
+              schedule();
+              return;
+            }
+            const data = await res.json().catch(() => null);
+            if (dead) return;
+            if (data !== null && typeof data === 'object' && data.ok === false) return;
+            const parsed = relayBarChainOf(data, sessionId);
+            if (parsed !== null) {
+              setChain(parsed);
+              setParentArchived(relayBarParentArchivedOf(data));
+              // F3 的子会话记录不带 path（交接单路径只写在父记录里）：向父会话读回
+              // 同一条链，childId 指回本会话且链号一致时才采用它的 path。只读、失败
+              // 就保持「暂无交接单」；不碰宿主逻辑，也不改交接流程。
+              if (parsed.path === null && parsed.parentId !== null) void loadParentPath(parsed);
+              return;
+            }
+            // sessionId 对不上/为 null → 宿主还没加载本会话，继续等；对得上 → 确定没有链。
+            const loaded =
+              data !== null && typeof data === 'object' && typeof data.sessionId === 'string' && data.sessionId === sessionId;
+            if (loaded) {
+              setChain(null);
+              setParentArchived(null);
+            } else schedule();
+          } catch {
+            /* 宿主不在/网络失败：保持「没有链」—— 不显示，不占高度；稍后再试 */
+            schedule();
+          }
+        }
+        void load();
         return () => {
-          alive = false;
+          dead = true;
+          if (timer !== 0) clearTimeout(timer);
         };
-      }, [childId, outcome, waitAndOpen]);
+      }, [hasSession, sessionId]);
 
-      if (status === 'running') return handoffRow('正在交接：压缩旧会话 → 生成交接单 → 打开新会话…');
-      if (status === 'error') return handoffRow(outcomeText || '交接失败（详见日志）', 'error');
-      if (childId === null) return handoffRow(outcomeText || '交接完成');
-      if (status === 'failed') {
-        return handoffRow(`新会话已建好（${childId}），自动切换失败：${detail || '未知原因'}`, 'error', openChild);
-      }
+      // 菜单打开时按这一行的真实位置重算锚点（滚动/缩放不漂）。
+      useEffect(() => {
+        if (!open) return undefined;
+        const update = () => {
+          const root = rootRef.current;
+          const el = root === null || root === undefined ? null : root.firstElementChild;
+          if (el === null || el === undefined || typeof el.getBoundingClientRect !== 'function') return;
+          const rect = el.getBoundingClientRect();
+          setAnchor({
+            left: Math.round(rect.left),
+            right: Math.round(rect.right),
+            top: Math.round(rect.top),
+            bottom: Math.round(rect.bottom),
+          });
+        };
+        update();
+        window.addEventListener('scroll', update, true);
+        window.addEventListener('resize', update);
+        return () => {
+          window.removeEventListener('scroll', update, true);
+          window.removeEventListener('resize', update);
+        };
+      }, [open]);
+
+      // 点外面 / Esc 关闭菜单与交接单查看。
+      useEffect(() => {
+        if (!open) return undefined;
+        const inside = (target) => {
+          const root = rootRef.current;
+          const menu = menuRef.current;
+          return (root !== null && root !== undefined && root.contains(target)) || (menu !== null && menu !== undefined && menu.contains(target));
+        };
+        const onDown = (event) => {
+          if (inside(event.target)) return;
+          closeMenu();
+        };
+        const onKey = (event) => {
+          if (event.key !== 'Escape') return;
+          closeMenu();
+          const trigger = triggerRef.current;
+          if (trigger !== null && trigger !== undefined && typeof trigger.focus === 'function') {
+            window.setTimeout(() => trigger.focus(), 0);
+          }
+        };
+        document.addEventListener('mousedown', onDown);
+        document.addEventListener('keydown', onKey);
+        return () => {
+          document.removeEventListener('mousedown', onDown);
+          document.removeEventListener('keydown', onKey);
+        };
+      }, [open, closeMenu]);
+
+      // 打开后把焦点送进第一个可操作项（键盘用户不用再 Tab 找）。
+      useEffect(() => {
+        if (!open || doc !== null) return;
+        const menu = menuRef.current;
+        if (menu === null || menu === undefined || typeof menu.querySelector !== 'function') return;
+        const first = menu.querySelector('button:not(:disabled)');
+        if (first !== null && first !== undefined && typeof first.focus === 'function') first.focus();
+      }, [open, doc]);
+
+      const toggleMenu = useCallback((event) => {
+        const current = event === null || event === undefined ? null : event.currentTarget;
+        if (current !== null && current !== undefined && typeof current.getBoundingClientRect === 'function') {
+          const rect = current.getBoundingClientRect();
+          setAnchor({
+            left: Math.round(rect.left),
+            right: Math.round(rect.right),
+            top: Math.round(rect.top),
+            bottom: Math.round(rect.bottom),
+          });
+        }
+        abortDoc();
+        setNotice(null);
+        setDoc(null);
+        setOpen((value) => !value);
+      }, [abortDoc]);
+
+      const loadDoc = useCallback(async (name) => {
+        if (typeof name !== 'string' || name.length === 0) return;
+        if (docAbortRef.current !== null) {
+          try {
+            docAbortRef.current.abort();
+          } catch {
+            /* ignore */
+          }
+        }
+        const controller = typeof AbortController === 'function' ? new AbortController() : null;
+        docAbortRef.current = controller;
+        const requestId = ++docRequestRef.current;
+        setDoc({ loading: true, name });
+        setNotice(null);
+        try {
+          const res = await fetch(`/api/compact-relay-handoffs?file=${encodeURIComponent(name)}`, {
+            cache: 'no-store',
+            ...(controller === null ? {} : { signal: controller.signal }),
+          });
+          const data = await res.json().catch(() => ({}));
+          if (requestId !== docRequestRef.current) return;
+          if (!res.ok || data.ok === false) throw new Error(data && data.message ? String(data.message) : '读取失败');
+          setDoc({
+            loading: false,
+            name,
+            content: typeof data.content === 'string' ? data.content : '',
+            path: typeof data.path === 'string' ? data.path : null,
+          });
+        } catch (error) {
+          if (requestId !== docRequestRef.current || (error && error.name === 'AbortError')) return;
+          setDoc({
+            loading: false,
+            name,
+            error: '读取失败：' + (error && error.message ? error.message : '未知错误'),
+          });
+        } finally {
+          if (requestId === docRequestRef.current) docAbortRef.current = null;
+        }
+      }, []);
+
+      /** 直接切到父会话（不碰归档状态）；成功发起返回 true。 */
+      const openParentNow = useCallback(() => {
+        if (chain === null || chain.parentId === null) return false;
+        if (typeof openSession !== 'function') {
+          setNotice('这个宿主不支持切换会话，无法自动打开原会话。');
+          return false;
+        }
+        try {
+          const result = openSession(chain.parentId);
+          if (result !== null && result !== undefined && typeof result.then === 'function') {
+            result.catch((error) => {
+              setNotice('打不开原会话：' + (error && error.message ? error.message : '未知错误'));
+              setOpen(true);
+            });
+          }
+          return true;
+        } catch (error) {
+          setNotice('打不开原会话：' + (error && error.message ? error.message : '未知错误'));
+          return false;
+        }
+      }, [chain, openSession]);
+
+      /**
+       * 0.5.0：恢复归档的父会话并切过去。
+       *
+       * 优先用宿主 Client 侧的 `ctx.uiWorkspace.unarchiveSession`（与侧栏「取消归档」
+       * 同一条接缝，会同步更新本地归档集合）；老宿主没有时走本插件 HTTP
+       * `action:'recover'`（服务端 workspaceRegistry.unarchiveSession），成功后同样尝试切换。
+       * 恢复本身幂等：父会话没归档时宿主 no-op，仍然可以直接打开。
+       */
+      const restoreParent = useCallback(() => {
+        setNotice(null);
+        if (chain === null || chain.parentId === null) return undefined;
+        const target = chain.parentId;
+        return (async () => {
+          try {
+            if (typeof unarchiveSession === 'function') {
+              await unarchiveSession(target);
+            } else {
+              const res = await fetch('/api/compact-relay-action', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                cache: 'no-store',
+                body: JSON.stringify({ action: 'recover', sessionId: target }),
+              });
+              const data = await res.json().catch(() => null);
+              if (!res.ok || data === null || data.ok === false) {
+                throw new Error(data !== null && typeof data.message === 'string' ? data.message : '恢复接口不可用');
+              }
+            }
+            setParentArchived(false);
+            if (typeof openSession !== 'function') {
+              setNotice('旧会话已恢复，但这个宿主不支持自动切换；请从侧栏打开。');
+              setOpen(true);
+              return;
+            }
+            const result = openSession(target);
+            if (result !== null && result !== undefined && typeof result.then === 'function') {
+              result.catch((error) => {
+                setNotice('已恢复旧会话，但自动切换失败：' + (error && error.message ? error.message : '未知错误'));
+                setOpen(true);
+              });
+            }
+            setOpen(false);
+            setDoc(null);
+          } catch (error) {
+            setNotice('恢复旧会话失败：' + (error && error.message ? error.message : '未知错误'));
+            setOpen(true);
+          }
+        })();
+      }, [chain, openSession, unarchiveSession]);
+
+      const goParent = useCallback(() => {
+        setNotice(null);
+        if (chain === null || chain.parentId === null) return;
+        // 已归档 → 先恢复再打开（否则宿主会拒绝打开归档会话）。
+        if (parentArchived === true) {
+          void restoreParent();
+          return;
+        }
+        if (openParentNow()) {
+          setOpen(false);
+          setDoc(null);
+        }
+      }, [chain, openParentNow, parentArchived, restoreParent]);
+
+      // 无链 → 什么都不渲染（不占 composerStack 的高度）。
+      if (chain === null) return null;
+
+      const label = relayBarLabelOf(chain);
+      const docName = relayBarDocNameOf(chain.path);
+      const hasParent = chain.parentId !== null;
+      // 归档状态已知且未归档 → 不需要恢复入口；true（已归档）或 null（老宿主不知道）
+      // 都显示——恢复调用幂等，宁可多一个入口，也不让用户的旧会话找不回来。
+      const showRestore = hasParent && parentArchived !== false;
+      const vw = typeof window === 'undefined' ? 1280 : window.innerWidth;
+      const vh = typeof window === 'undefined' ? 900 : window.innerHeight;
+      const menuWidth = Math.min(doc === null ? 272 : 420, Math.max(240, vw - 16));
+      const estimatedHeight = doc === null ? 168 : 360;
+      const anchorTop = anchor === null ? vh - 96 : anchor.top;
+      const anchorBottom = anchor === null ? vh - 40 : anchor.bottom;
+      const openUp = anchorTop >= Math.min(estimatedHeight, vh - 16) + 12;
+      const left = Math.max(8, Math.min(anchor === null ? 8 : anchor.left, Math.max(8, vw - menuWidth - 8)));
+      const position = openUp
+        ? { left, bottom: Math.max(8, vh - anchorTop + 6) }
+        : { left, top: Math.min(Math.max(8, anchorBottom + 6), Math.max(8, vh - Math.min(estimatedHeight, vh - 16) - 8)) };
+
+      const docPanel =
+        doc === null
+          ? null
+          : h(
+              'div',
+              { role: 'dialog', 'aria-label': '交接单', 'data-cr-relay-doc': '1', style: { display: 'flex', flexDirection: 'column', minHeight: 0 } },
+              h(
+                'div',
+                {
+                  style: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: 8,
+                    padding: '7px 10px',
+                    borderBottom: `1px solid ${theme.panelBorder}`,
+                    fontSize: 12,
+                    fontWeight: 600,
+                  },
+                },
+                h('span', { style: { flex: 1, minWidth: 0 } }, '交接单'),
+                h(
+                  'button',
+                  {
+                    type: 'button',
+                    'data-cr-relay-doc-back': '1',
+                    onClick: backToMenu,
+                    style: { border: `1px solid ${theme.panelBorder}`, borderRadius: 6, padding: '2px 8px', fontSize: 11, cursor: 'pointer', background: 'transparent', color: theme.panelFg },
+                  },
+                  '← 返回',
+                ),
+                h(
+                  'button',
+                  {
+                    type: 'button',
+                    'data-cr-relay-doc-close': '1',
+                    onClick: closeMenu,
+                    style: { border: `1px solid ${theme.panelBorder}`, borderRadius: 6, padding: '2px 8px', fontSize: 11, cursor: 'pointer', background: 'transparent', color: theme.panelFg },
+                  },
+                  '关闭',
+                ),
+              ),
+              doc.loading === true
+                ? h('div', { style: { padding: '10px 12px', fontSize: 11, color: theme.subText } }, '读取中…')
+                : doc.error !== undefined && doc.error !== null
+                  ? h('div', { style: { padding: '10px 12px', fontSize: 11, color: COLORS.error } }, String(doc.error))
+                  : h(
+                      'div',
+                      { style: { overflowY: 'auto', overflowX: 'hidden', padding: '8px 12px', fontSize: 11, lineHeight: '16px', maxHeight: 'min(52vh, 320px)', wordBreak: 'break-word' } },
+                      renderMarkdownLite(doc.content ?? ''),
+                    ),
+            );
+
+      const menu =
+        open === true
+          ? h(
+              'div',
+              {
+                ref: menuRef,
+                role: 'menu',
+                'aria-label': '接力菜单',
+                'data-cr-relay-menu': '1',
+                style: {
+                  position: 'fixed',
+                  ...position,
+                  width: menuWidth,
+                  maxWidth: 'calc(100vw - 16px)',
+                  maxHeight: 'min(65vh, 460px)',
+                  display: 'flex',
+                  flexDirection: 'column',
+                  overflow: 'hidden',
+                  padding: doc === null ? 5 : 0,
+                  borderRadius: 12,
+                  ...panelChrome(theme),
+                  color: theme.panelFg,
+                  // 顶层：高于指示灯菜单/确认卡（39–44），避免被输入区或其它浮层盖住。
+                  zIndex: 60,
+                },
+              },
+              notice !== null
+                ? h(
+                    'div',
+                    { 'data-cr-relay-notice': '1', style: { padding: '7px 10px', fontSize: 11, lineHeight: '15px', color: 'var(--dsw-alias-state-error-primary, #D92D20)' } },
+                    notice,
+                  )
+                : null,
+              docPanel ??
+                h(
+                  'div',
+                  { style: { display: 'flex', flexDirection: 'column' } },
+                  relayBarItem('查看交接单', docName === null ? '这一链没有记录交接单路径' : '打开本次交接的九段交接单', 'doc', () => {
+                    void loadDoc(docName);
+                  }, {
+                    disabled: docName === null,
+                    // 需求文案：无 path 时明确提示「暂无交接单」。
+                    right: docName === null ? '暂无交接单' : '›',
+                    title: docName === null ? '暂无交接单：这条接力记录里没有交接单路径（旧记录，或父会话已不在）' : '打开交接单',
+                  }),
+                  relayBarItem('回到原会话', hasParent ? '切到上一个会话，继续看那边历史' : '这条记录没有父会话 id', 'parent', goParent, {
+                    disabled: !hasParent,
+                    right: hasParent ? '›' : '不可用',
+                    title: hasParent ? `打开原会话 ${chain.parentId}` : undefined,
+                  }),
+                  showRestore
+                    ? relayBarItem(
+                        '恢复旧会话',
+                        parentArchived === true
+                          ? '旧会话已归档：恢复后切回上一代'
+                          : '宿主没提供归档状态；恢复调用是幂等的，仍可直接尝试',
+                        'unarchive',
+                        () => {
+                          void restoreParent();
+                        },
+                        {
+                          right: parentArchived === true ? '已归档' : '恢复',
+                          title: `从归档中恢复旧会话 ${chain.parentId}`,
+                        },
+                      )
+                    : null,
+                  relayBarItem('路线图（即将上线）', '跨会话时间线，0.6 之后', 'roadmap', null, {
+                    disabled: true,
+                    right: '即将上线',
+                  }),
+                ),
+            )
+          : null;
+
+      return h(
+        'div',
+        {
+          ref: rootRef,
+          'data-cr-relay-root': '1',
+          style: {
+            boxSizing: 'border-box',
+            flex: 'none',
+            // 与宿主 TodoPanel（同一 dock 槽）一致：两侧留出 composer 的边距，
+            // 宽度跟着输入卡走，避免通栏压到侧栏。
+            width: 'calc(100% - var(--dsh-composer-side-clearance, 16px) * 2 - var(--dsh-composer-dock-inset, 8px) * 4)',
+            maxWidth: 'calc(var(--dsh-composer-card-max-width, 920px) - var(--dsh-composer-dock-inset, 8px) * 4)',
+            margin: '0 auto',
+          },
+        },
+        // 卡片外观放在内层：backdrop-filter 会给 fixed 子元素造 containing block，
+        // 菜单必须留在这一层之外，才能相对视口定位（不被输入区裁切）。
+        h(
+          'div',
+          {
+            'data-cr-relay-card': '1',
+            style: {
+              borderRadius: 'var(--dsw-radius-lg, 12px)',
+              border: '1px solid var(--dsw-alias-border-l1, rgba(127,127,127,0.24))',
+              // 底色/字体全部走 DSH 主题 token：切深浅色不需要重挂组件；老宿主用 theme 兜底。
+              background: `var(--dsw-specific-menu, ${theme.panelBg})`,
+              backdropFilter: 'var(--dsw-menu-backdrop-filter, none)',
+              WebkitBackdropFilter: 'var(--dsw-menu-backdrop-filter, none)',
+              boxShadow: 'var(--dsw-elevation-panel, 0 1px 2px rgba(0,0,0,0.06))',
+              color: 'var(--dsw-alias-label-primary, inherit)',
+              overflow: 'hidden',
+            },
+          },
+          h(
+            'button',
+            {
+              type: 'button',
+              ref: triggerRef,
+              'data-cr-relay-bar': '1',
+              'data-cr-relay-ordinal': String(chain.ordinal),
+              'data-cr-relay-scheme': chain.scheme ?? '',
+              'data-cr-relay-parent': chain.parentId ?? '',
+              'data-cr-relay-path': chain.path ?? '',
+              // 空串 = 宿主没给归档状态（老宿主），'true'/'false' = readState.parentArchived。
+              'data-cr-relay-parent-archived': parentArchived === null ? '' : String(parentArchived),
+              'aria-haspopup': 'menu',
+              'aria-expanded': open,
+              'aria-label': `已接力自 ${label}，打开接力菜单`,
+              onClick: toggleMenu,
+              style: {
+                display: 'flex',
+                alignItems: 'center',
+                gap: 8,
+                width: '100%',
+                minHeight: 30,
+                padding: '3px 10px',
+                border: 'none',
+                borderRadius: 'inherit',
+                background: 'transparent',
+                color: 'inherit',
+                font: 'inherit',
+                textAlign: 'left',
+                cursor: 'pointer',
+              },
+              onMouseEnter: (event) => {
+                event.currentTarget.style.background = 'var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,0.10))';
+              },
+              onMouseLeave: (event) => {
+                event.currentTarget.style.background = 'transparent';
+              },
+            },
+            h(
+              'span',
+              { style: { flex: 'none', fontSize: 12, lineHeight: '20px', color: 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.9))' } },
+              // 末尾留一个空格：flex gap 负责视觉间距，文本内容（读屏/可访问性树）也要读得通。
+              '已接力自 ',
+            ),
+            h(
+              'span',
+              {
+                style: {
+                  flex: 1,
+                  minWidth: 0,
+                  fontSize: 13,
+                  fontWeight: 500,
+                  lineHeight: '20px',
+                  color: 'var(--dsw-alias-label-primary, inherit)',
+                  overflow: 'hidden',
+                  textOverflow: 'ellipsis',
+                  whiteSpace: 'nowrap',
+                },
+              },
+              label,
+            ),
+            h(
+              'span',
+              {
+                'aria-hidden': true,
+                style: {
+                  flex: 'none',
+                  fontSize: 10,
+                  lineHeight: 1,
+                  color: 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.9))',
+                  transform: open ? 'rotate(180deg)' : 'none',
+                  transition: 'transform 120ms ease',
+                },
+              },
+              '▾',
+            ),
+          ),
+        ),
+        menu,
+      );
+    }
+
+    /** 交接结果的一行式展示（放在聊天流里的 /handoff 命令卡）。 */
+    function handoffRow(text, tone, action) {
+      return h(
+        'div',
+        {
+          style: {
+            display: 'flex',
+            alignItems: 'center',
+            gap: 8,
+            padding: '4px 2px',
+            fontSize: 12,
+            color: tone === 'error' ? COLORS.error : COLORS.subText,
+          },
+        },
+        h('span', { style: { flex: 1, minWidth: 0 } }, text),
+        action
+          ? h(
+              'button',
+              {
+                type: 'button',
+                onClick: action,
+                style: {
+                  flex: 'none',
+                  border: 'none',
+                  borderRadius: 6,
+                  padding: '2px 8px',
+                  background: COLORS.hover,
+                  color: 'inherit',
+                  fontSize: 11,
+                  cursor: 'pointer',
+                },
+              },
+              '重试打开',
+            )
+          : null,
+      );
+    }
+
+    /**
+     * /handoff 命令卡：命令成功后自动切到新会话。
+     * 这个槽把命令的通用卡片替换成我们的卡片（只有 /handoff 这一个 key）。
+     */
+    function HandoffCard({ node, waitAndOpen }) {
+      const outcome = node !== null && typeof node === 'object' ? node.outcome : undefined;
+      const outcomeText = outcome !== null && typeof outcome === 'object' && typeof outcome.text === 'string' ? outcome.text : '';
+      // A5：优先用命令结果里的结构化 childId；旧宿主没带字段时再从文本 #child= 兜底。
+      const childId =
+        outcome !== null && typeof outcome === 'object' && typeof outcome.childId === 'string' && outcome.childId.length > 0
+          ? outcome.childId
+          : extractChildId(outcomeText);
+      // P2-C1：区分 opening / opened / failed；刷新后只有 localStorage='1' 才算已打开，
+      // 'opening'（上次没走完）要重新尝试，不能直接渲染成功态。
+      const [status, setStatus] = useState(() => {
+        if (outcome === undefined) return 'running';
+        if (outcome !== null && outcome.kind === 'error') return 'error';
+        if (childId === null) return 'done';
+        return wasOpened(childId) ? 'done' : 'opening';
+      });
+      const [detail, setDetail] = useState(null);
+
+      const openChild = useCallback(() => {
+        if (childId === null) return;
+        setStatus('opening');
+        setDetail(null);
+        waitAndOpen(childId).then(
+          () => {
+            markOpened(childId, '1');
+            setStatus('done');
+          },
+          (error) => {
+            clearOpened(childId);
+            setStatus('failed');
+            setDetail(String(error && error.message ? error.message : error));
+          },
+        );
+      }, [childId, waitAndOpen]);
+
+      useEffect(() => {
+        if (outcome === undefined || outcome === null || outcome.kind !== 'success' || childId === null) return;
+        if (wasOpened(childId)) {
+          setStatus('done');
+          return;
+        }
+        markOpened(childId, 'opening');
+        let alive = true;
+        waitAndOpen(childId).then(
+          () => {
+            markOpened(childId, '1');
+            if (alive) setStatus('done');
+          },
+          (error) => {
+            clearOpened(childId);
+            if (!alive) return;
+            setStatus('failed');
+            setDetail(String(error && error.message ? error.message : error));
+          },
+        );
+        return () => {
+          alive = false;
+        };
+      }, [childId, outcome, waitAndOpen]);
+
+      if (status === 'running') return handoffRow('正在交接：压缩旧会话 → 生成交接单 → 打开新会话…');
+      if (status === 'error') return handoffRow(outcomeText || '交接失败（详见日志）', 'error');
+      if (childId === null) return handoffRow(outcomeText || '交接完成');
+      if (status === 'failed') {
+        return handoffRow(`新会话已建好（${childId}），自动切换失败：${detail || '未知原因'}`, 'error', openChild);
+      }
       if (status === 'opening') return handoffRow(`交接完成，正在打开新会话（${childId}）…`);
       return handoffRow('交接完成：已切到新会话（点指示灯 → 查看交接单 可回看或复制）。');
     }
@@ -2985,6 +4050,43 @@ window.__ModuleLoader__.load({
       cursor: 'pointer',
     };
 
+    /** 百分比上限徽标：「最高 62%」——让上限一眼可见，但不用它夹紧输入。 */
+    const percentCapChipStyle = {
+      display: 'inline-flex',
+      alignItems: 'center',
+      height: 20,
+      padding: '0 8px',
+      borderRadius: 999,
+      border: '1px solid var(--dsw-alias-border-l2, rgba(127,127,127,0.28))',
+      background: 'var(--dsw-alias-bg-layer-2, rgba(127,127,127,0.08))',
+      color: 'var(--dsw-alias-label-secondary, rgba(127,127,127,0.95))',
+      fontSize: 11,
+      lineHeight: '20px',
+      whiteSpace: 'nowrap',
+    };
+
+    /**
+     * 行内提示块（告警 / 失败）：淡色底 + 同色描边，深浅主题都靠 DSH 状态 token 自适应。
+     * 红色只用在真正的失败上，且用 7% 透明底而不是整块红，避免刺眼。
+     * @param {'warning'|'error'} kind
+     */
+    function alertBoxStyle(kind) {
+      const warning = kind === 'warning';
+      return {
+        display: 'flex',
+        flexDirection: 'column',
+        gap: 2,
+        padding: '8px 10px',
+        borderRadius: 8,
+        border: `1px solid ${warning ? 'var(--dsw-alias-state-warning-primary, #d97706)' : 'var(--dsw-alias-state-error-primary, #D92D20)'}`,
+        background: warning ? 'rgba(217, 119, 6, 0.08)' : 'rgba(217, 45, 32, 0.07)',
+        color: warning ? 'var(--dsw-alias-state-warning-primary, #b45309)' : 'var(--dsw-alias-state-error-primary, #D92D20)',
+        fontSize: 12,
+        lineHeight: '17px',
+        fontWeight: 600,
+      };
+    }
+
     /** 不可变地设置对象里的某个路径。 */
     function setIn(object, path, value) {
       if (path.length === 1) return { ...object, [path[0]]: value };
@@ -3070,6 +4172,21 @@ window.__ModuleLoader__.load({
       /** 0.4 P1-3：轻账本累计数字（独立账本文件算出来的；null = 没有数据/读不到，显示引导文案）。 */
       const [ledger, setLedger] = useState(null);
       const [confirmNative, setConfirmNative] = useState(null); // null | 'disable' | 'enable'
+      /** 0.4.2：按实际线重算交接线（先二次确认，{ratio,percent}）。 */
+      const [confirmRecalc, setConfirmRecalc] = useState(null);
+      /**
+       * 0.4.2 修复（真机 bug「输入 80 他直接改成 99」）：百分比输入框的**本地草稿**。
+       *
+       * 根因：输入框的 value 以前是派生值 `Math.round(ratio*100)`（受控、无草稿），
+       * 每次按键都经过 `Math.min(0.99, …)` 夹紧再四舍五入回写。于是「60 后面按 8」这种
+       * 中间态（608）会被夹成 0.99 → 显示 99，用户输入被静默吃掉，保存再报错。
+       *
+       * 现在：按键只记草稿（用户输入什么就显示什么，除非非数字），表单同步原样写入
+       * `value/100`（不夹紧）；失焦/加载/保存成功时丢弃草稿，回到表单的派生值。
+       * 超限一律留给服务端拒绝（guard.message 给目标值），不在客户端改写。
+       * @type {[Record<string,string>, Function]}
+       */
+      const [percentDrafts, setPercentDrafts] = useState({});
       const [nativeBusy, setNativeBusy] = useState(false);
       /** UI-003：结果提示就地显示在开关旁（以前只写页面底部，用户看不到）。 */
       const [nativeStatus, setNativeStatus] = useState(null);
@@ -3115,6 +4232,8 @@ window.__ModuleLoader__.load({
       const applyLoaded = useCallback((data) => {
         setForm(data.config);
         setSavedSnapshot(JSON.stringify(data.config));
+        // 服务端回来的配置是新的权威值：丢掉输入草稿，输入框重新按表单派生（加载/保存成功都走这里）。
+        setPercentDrafts({});
         setSettingsError(data.settingsError ?? null);
         setNative(mergeNative(data.native && typeof data.native === 'object' ? data.native : null));
         if (typeof data.version === 'string') setVersion(data.version);
@@ -3162,32 +4281,122 @@ window.__ModuleLoader__.load({
       const patch = (path, value) => {
         setForm((prev) => (prev === null ? prev : setIn(prev, path, value)));
         setConfirmReset(false);
+        setConfirmRecalc(null);
+        // 0.4.2 修复：一改值就清掉上一次的保存结果/失败提示，避免旧错误一直挂着像没生效。
+        setStatus(null);
+      };
+
+      /* ---------------- 百分比输入：草稿优先，绝不静默改写 ---------------- */
+
+      /**
+       * 输入框显示值：有草稿就用草稿（用户打什么显示什么），否则按表单比例派生整数百分位。
+       * @param {'minRatio'|'compactRatio'|'handoffRatio'} key
+       * @param {number} ratio
+       * @returns {string}
+       */
+      const percentText = (key, ratio) => {
+        const draft = percentDrafts[key];
+        return typeof draft === 'string' ? draft : String(Math.round(ratio * 100));
+      };
+
+      /**
+       * 百分比输入变化：先记草稿，再把「用户输入的数字 / 100」原样写进表单。
+       * - 空串 = 用户正在删旧值准备重打：只留草稿，不动表单（以前空串会被夹成 5%，用户根本打不出新值）；
+       * - 非数字（type=number 下浏览器给空串或字母被吞）：只显示，不动表单；
+       * - 其余：不夹紧、不四舍五入，超限交给保存时服务端拒绝并给目标值。
+       * @param {'minRatio'|'compactRatio'|'handoffRatio'} key
+       * @param {string} text
+       */
+      const changePercent = (key, text) => {
+        const raw = typeof text === 'string' ? text : '';
+        setPercentDrafts((prev) => ({ ...prev, [key]: raw }));
+        if (raw.trim() === '') {
+          setStatus(null);
+          setConfirmReset(false);
+          setConfirmRecalc(null);
+          return;
+        }
+        const value = Number(raw);
+        if (!Number.isFinite(value)) return;
+        patch(['thresholds', key], value / 100);
+      };
+
+      /** 丢弃某个草稿，显示回到表单派生值（失焦时用；不会改表单）。 */
+      const restorePercentDraft = (key) => {
+        setPercentDrafts((prev) => {
+          if (!(key in prev)) return prev;
+          const next = { ...prev };
+          delete next[key];
+          return next;
+        });
+      };
+
+      /**
+       * 聚焦/点击即全选：阈值框只有 2–3 位数，点进去直接打字就是「替换」，
+       * 不会出现「60 后面接着打 80 变成 6080」这种叠加（真机上「输入 80 变成 99」的一半原因）。
+       *
+       * 为什么还要 setTimeout(0) 再选一次：点进输入框时，浏览器会在 focus 事件之后
+       * 才把光标落到鼠标位置（把刚做的选区冲掉）。下一轮事件循环再选一次 = 打字一定是替换。
+       */
+      const selectOnFocus = (event) => {
+        const el = event === null || event === undefined ? null : event.target;
+        if (el === null || el === undefined || typeof el.select !== 'function') return;
+        try {
+          el.select();
+        } catch {
+          /* 个别浏览器不允许对 number 输入做选区：忽略，不影响输入 */
+        }
+        setTimeout(() => {
+          try {
+            if (el.ownerDocument !== null && el.ownerDocument !== undefined && el.ownerDocument.activeElement === el) el.select();
+          } catch {
+            /* 元素已卸载：忽略 */
+          }
+        }, 0);
       };
 
       /** 表单与已保存快照不一致 → 有未保存修改。 */
       const dirty = form !== null && savedSnapshot !== null && JSON.stringify(form) !== savedSnapshot;
 
-      const save = useCallback(async () => {
+      /**
+       * 保存设置。0.4.2：body 带上 `nativeRatio`（当前模型实际触发线），
+       * 服务端据此按「实际线 −5pp」同口径校验交接线；算不出/原生关闭时不带（服务端兜底）。
+       * @param {object} [override] 「按实际线重算」用：一次性覆盖表单（不依赖 setState 的异步生效）
+       */
+      const save = useCallback(async (override) => {
         if (form === null || saving) return;
+        const payload = override !== undefined && override !== null ? override : form;
         setSaving(true);
         setStatus(null);
         setConfirmReset(false);
         try {
+          const info = nativeLineInfo(native);
+          const nativeRatio = native !== null && native.autoEnabled !== false && info.actual !== null ? info.actual : null;
           const res = await fetch('/api/compact-relay-settings', {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(form),
+            body: JSON.stringify(nativeRatio === null ? payload : { ...payload, nativeRatio }),
           });
           const data = await res.json().catch(() => ({}));
-          if (!res.ok || data.ok === false) throw new Error(data && data.message ? String(data.message) : '保存失败');
+          if (!res.ok || data.ok === false) {
+            // 0.4.2 修复：服务端会带 field（交接线校验失败时是 thresholds.handoffRatio），
+            // 带出来才能在交接线行内就地标红，而不是只在页面底部写一行。
+            const failure = new Error(data && data.message ? String(data.message) : '保存失败');
+            if (data !== null && typeof data === 'object' && typeof data.field === 'string') failure.field = data.field;
+            throw failure;
+          }
           applyLoaded(data);
           setStatus({ text: '已保存（立即生效，不需要重启）' });
         } catch (error) {
-          setStatus({ error: true, text: `保存失败：${error && error.message ? error.message : '未知错误'}` });
+          setStatus({
+            error: true,
+            text: `保存失败：${error && error.message ? error.message : '未知错误'}`,
+            field: error !== null && typeof error === 'object' && typeof error.field === 'string' ? error.field : null,
+          });
         } finally {
           setSaving(false);
         }
-      }, [form, saving, applyLoaded]);
+      }, [form, saving, applyLoaded, native]);
 
       /** 恢复默认 = 删除用户设置文件；先二次确认，避免误点丢掉配色。 */
       const reset = useCallback(async () => {
@@ -3212,6 +4421,19 @@ window.__ModuleLoader__.load({
         }
       }, [saving, applyLoaded]);
 
+      /**
+       * 0.4.2：「按实际线重算」——目标 = 实际触发线 −5pp（整数百分位，guard 已算好）。
+       * 二次确认后一次性保存（不走 patch + save 的异步状态，避免发出旧表单）。
+       */
+      const applyRecalc = useCallback(async () => {
+        if (form === null || confirmRecalc === null || saving) return;
+        const next = setIn(form, ['thresholds', 'handoffRatio'], confirmRecalc.ratio);
+        setConfirmRecalc(null);
+        // 目标值是 guard 算出来的权威值：丢掉输入草稿，避免输入框还显示用户手打的旧数字。
+        setPercentDrafts({});
+        await save(next);
+      }, [form, confirmRecalc, saving, save]);
+
       /** 0.3.1：关闭/恢复 DSH 原生自动压缩（写 profile 配置，备份后重启生效）。 */
       const applyNative = useCallback(
         async (enabled) => {
@@ -3326,7 +4548,6 @@ window.__ModuleLoader__.load({
 
       const percent = (ratio) => Math.round(ratio * 100);
       const compactPercent = percent(form.thresholds.compactRatio);
-      const handoffPercent = percent(form.thresholds.handoffRatio);
       const count = (value) => (Number.isFinite(value) ? value : 0);
       // 0.4 P1-3：轻账本一行累计数字（只读；数据来自宿主账本，与账本文件同源）。
       const ledgerLine = (() => {
@@ -3341,13 +4562,42 @@ window.__ModuleLoader__.load({
       // 0.4.1：配置阈值（thresholdRatio）只是理论上限；实际触发线由宿主按 token 预算算。
       const nativeInfo = nativeLineInfo(native);
       const nativePercent = nativeInfo.configured !== null ? Math.round(nativeInfo.configured * 100) : 80;
-      const nativeCapRatio = nativeInfo.effective !== null ? nativeInfo.effective : nativeInfo.configured !== null ? nativeInfo.configured : 0.8;
-      // 交接线可设上限：按实际触发线向下取整，输入框 max 与 onChange 用同一个数。
-      const nativeCapPercent = Math.max(5, Math.floor(nativeCapRatio * 100 - 1));
       // 原生压缩已关闭时 effective/percentText 为空：回落到「开启后实际会触发多少」，再回落配置阈值。
       const nativeActualText = nativeInfo.percentText !== '' ? nativeInfo.percentText : nativeInfo.actualText !== '' ? nativeInfo.actualText : nativeInfo.configuredText !== null ? nativeInfo.configuredText : String(nativePercent);
-      const handoffOverNative = nativeInfo.effective !== null && form !== null && typeof form.thresholds === 'object' && typeof form.thresholds.handoffRatio === 'number' && form.thresholds.handoffRatio > nativeInfo.effective + 1e-9;
-      const handoffNativeWarning = handoffOverNative ? `当前交接线 ${Math.round(form.thresholds.handoffRatio * 100)}% 高于原生实际触发线 ${nativeInfo.percentText}%：DSH 会先自己压历史，这条提醒可能来不及。建议调到 ${nativeInfo.percentText}% 以下（改完立即生效）。` : '';
+      /**
+       * 0.4.2（P0-1/P1）：交接线硬上限 = 实际触发线 −5pp（整数百分位），与后台 save() 同一份判定。
+       * 实际线算不出时退回配置阈值 −1pp 兜底（与 0.4.1 一致，仅限制输入上限，不告警）。
+       * 注意：这里读 nativeInfo.actual（真实触发线），不能用 effective（autoOff/算不出时它会回落配置阈值）。
+       */
+      const handoffGuardInfo = handoffGuard({
+        actualRatio: nativeInfo.actual,
+        configuredRatio: nativeInfo.configured,
+        handoffRatio: form.thresholds.handoffRatio,
+        compactRatio: form.thresholds.compactRatio,
+        autoEnabled: autoOnNative,
+        fallback: 'configured',
+      });
+      const handoffCapPercent = handoffGuardInfo.capPercent;
+      const handoffLate = handoffGuardInfo.source === 'actual' && handoffGuardInfo.ok === false;
+      const handoffCapHint =
+        handoffGuardInfo.source === 'actual'
+          ? `当前模型实际触发 ${nativeInfo.actualText}%，最高可设 ${handoffCapPercent}%（实际触发线 −5pp）。`
+          : autoOnNative && handoffCapPercent !== null
+            ? `实际触发线未知（会话未就绪或算不出），暂按配置阈值最高 ${handoffCapPercent}%。`
+            : '';
+      /**
+       * 0.4.2 修复（真机反馈）：交接线被服务端拒绝时，错误文案就地显示在交接线行内。
+       * 文案沿用 guard.message（含实际线与目标值），去掉「保存失败：」前缀避免重复。
+       */
+      const handoffSaveError =
+        status !== null && status.error && status.field === 'thresholds.handoffRatio'
+          ? String(status.text).replace(/^保存失败：/, '')
+          : null;
+      // 重算目标 ≤ 压缩线时（保持「交接线 > 压缩线」现有约束）点按钮直接拒绝并提示先降压缩线。
+      const handoffRecalcConflict =
+        handoffGuardInfo.compactConflict && handoffCapPercent !== null
+          ? `按实际线重算目标 ${handoffCapPercent}% 不高于压缩线 ${compactPercent}%，请先把压缩线降到 ${handoffCapPercent}% 以下。`
+          : '';
       const previewLight = paletteForScheme(form.colors, 'light');
       const previewDark = paletteForScheme(form.colors, 'dark');
       // 0.4 P0-2：诊断预览弹层复用指示灯那套浮层材质（15-shared.panelChrome）。
@@ -3376,7 +4626,7 @@ window.__ModuleLoader__.load({
 
       return h(
         'div',
-        { style: { display: 'flex', flexDirection: 'column', maxWidth: 680, padding: '4px 0 20px' } },
+        { style: { display: 'flex', flexDirection: 'column', maxWidth: 680, padding: '4px 0 8px' } },
         h('div', { style: { fontSize: 14, fontWeight: 600, marginBottom: 4 } }, '压缩接力'),
         h(
           'p',
@@ -3397,8 +4647,19 @@ window.__ModuleLoader__.load({
               'div',
               { style: { display: 'flex', alignItems: 'center', gap: 8 } },
               h('input', {
-                type: 'number', min: 1, max: 60, step: 1, value: Math.round(form.thresholds.minRatio * 100), 'aria-label': '最小压缩线（百分比）', style: { ...settingsInputStyle, width: 90 },
-                onChange: (event) => patch(['thresholds', 'minRatio'], Math.min(0.6, Math.max(0.01, Number(event.target.value) / 100))),
+                type: 'number',
+                inputMode: 'numeric',
+                min: 1,
+                max: 60,
+                step: 1,
+                value: percentText('minRatio', form.thresholds.minRatio),
+                'aria-label': '最小压缩线（百分比）',
+                style: { ...settingsInputStyle, width: 90, textAlign: 'right', fontVariantNumeric: 'tabular-nums' },
+                onFocus: selectOnFocus,
+                onClick: selectOnFocus,
+                // 0.4.2 修复：不再按键就夹紧/四舍五入（以前清空会立刻变 5%），草稿优先，越界交服务端拒绝。
+                onChange: (event) => changePercent('minRatio', event.target.value),
+                onBlur: () => restorePercentDraft('minRatio'),
               }),
               h('span', { style: settingsHintStyle }, '% 窗口'),
             ),
@@ -3407,10 +4668,20 @@ window.__ModuleLoader__.load({
             '压缩提醒线',
             '指示灯到这条线开始变琥珀色，菜单也会建议「压缩旧会话」。',
             '调高 → 更晚提醒、压得更少但上下文更长；调低 → 更早提醒、压得更勤。',
-            h('div', { style: { display: 'flex', alignItems: 'center', gap: 8 } },
+            h('div', { style: { display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' } },
               h('input', {
-                type: 'number', min: 5, max: 95, step: 1, value: compactPercent, 'aria-label': '压缩提醒线（百分比）', style: { ...settingsInputStyle, width: 90 },
-                onChange: (event) => patch(['thresholds', 'compactRatio'], Math.min(0.95, Math.max(0.05, Number(event.target.value) / 100))),
+                type: 'number',
+                inputMode: 'numeric',
+                min: 5,
+                max: 95,
+                step: 1,
+                value: percentText('compactRatio', form.thresholds.compactRatio),
+                'aria-label': '压缩提醒线（百分比）',
+                style: { ...settingsInputStyle, width: 90, textAlign: 'right', fontVariantNumeric: 'tabular-nums' },
+                onFocus: selectOnFocus,
+                onClick: selectOnFocus,
+                onChange: (event) => changePercent('compactRatio', event.target.value),
+                onBlur: () => restorePercentDraft('compactRatio'),
               }),
               h('span', { style: settingsHintStyle }, '% 窗口'),
               h('span', { style: settingsHintStyle }, `（1M 窗口 ≈ ${Math.round(1000000 * form.thresholds.compactRatio / 1000)}K）`),
@@ -3419,26 +4690,126 @@ window.__ModuleLoader__.load({
           settingsRow(
             '交接提醒线',
             '到这条线内圆亮红点，菜单建议「交接新会话」。',
-            `调高 → 更晚换会话、单会话更久；调低 → 更早换会话、单会话更短。必须大于压缩线。${handoffNativeWarning}`,
-            h('div', { style: { display: 'flex', alignItems: 'center', gap: 8 } },
-              h('input', {
-                type: 'number',
-                min: 5,
-                max: native !== null && native.autoEnabled !== false ? nativeCapPercent : 99,
-                step: 1,
-                value: handoffPercent,
-                'aria-label': '交接提醒线（百分比）',
-                style: { ...settingsInputStyle, width: 90 },
-                onChange: (event) => {
-                  const raw = Math.max(0.05, Number(event.target.value) / 100);
-                  const cap = native !== null && native.autoEnabled !== false ? nativeCapPercent / 100 : 0.99;
-                  patch(['thresholds', 'handoffRatio'], Math.min(cap, raw));
-                },
-              }),
-              h('span', { style: settingsHintStyle }, '% 窗口'),
-              h('span', { style: settingsHintStyle }, `（1M 窗口 ≈ ${Math.round(1000000 * form.thresholds.handoffRatio / 1000)}K）`),
+            '调高 → 更晚换会话、单会话更久；调低 → 更早换会话、单会话更短。必须大于压缩线。',
+            h(
+              'div',
+              { 'data-cr-handoff-field': '1', style: { display: 'flex', flexDirection: 'column', gap: 8 } },
+              // 控制行：输入框 + 单位 + 上限徽标（上限只做提示，不用来夹紧输入）
+              h(
+                'div',
+                { style: { display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' } },
+                h('input', {
+                  type: 'number',
+                  inputMode: 'numeric',
+                  min: 5,
+                  // 0.4.2 修复：max 用真实上限（如 62），只作浏览器提示；不再靠代码夹紧改写用户输入。
+                  max: handoffCapPercent !== null ? handoffCapPercent : 100,
+                  step: 1,
+                  value: percentText('handoffRatio', form.thresholds.handoffRatio),
+                  'aria-label': '交接提醒线（百分比）',
+                  'aria-describedby': 'cr-handoff-cap-hint',
+                  style: { ...settingsInputStyle, width: 90, textAlign: 'right', fontVariantNumeric: 'tabular-nums' },
+                  onFocus: selectOnFocus,
+                  onClick: selectOnFocus,
+                  // 0.4.2 修复（真机 bug「输入 80 变成 99」）：输入原样保留，不夹紧/不取整/不替用户改。
+                  onChange: (event) => changePercent('handoffRatio', event.target.value),
+                  onBlur: () => restorePercentDraft('handoffRatio'),
+                }),
+                h('span', { style: settingsHintStyle }, '% 窗口'),
+                handoffCapPercent === null
+                  ? null
+                  : h('span', {
+                      'data-cr-handoff-cap-chip': '1',
+                      title: `超过 ${handoffCapPercent}% 保存会被拒绝（会告诉你目标值）；这里不会自动改写你的输入。`,
+                      style: percentCapChipStyle,
+                    }, `最高 ${handoffCapPercent}%`),
+              ),
+              // 体量估算单独一行：和上限、告警挤在同一排会显得拥挤。
+              h('div', { style: settingsHintStyle }, `（1M 窗口 ≈ ${Math.round(1000000 * form.thresholds.handoffRatio / 1000)}K）`),
+              handoffCapHint === '' ? null : h('div', { 'data-cr-handoff-cap': '1', id: 'cr-handoff-cap-hint', style: settingsHintStyle }, handoffCapHint),
+              // 超限告警：保存前就可见（amber），保存被拒后由红色失败块接棒（两者不同时出现）。
+              handoffLate && handoffSaveError === null
+                ? h('div', { 'data-cr-handoff-late': '1', role: 'status', style: alertBoxStyle('warning') }, `⚠ ${handoffGuardInfo.message}`)
+                : null,
+              // 保存失败（服务端 guard.message）：就地在交接线行内显示，滚动到页面任何位置都不用回头找。
+              handoffSaveError === null
+                ? null
+                : h('div', { 'data-cr-handoff-error': '1', role: 'alert', style: alertBoxStyle('error') }, handoffSaveError),
+              // 违规时给「按实际线重算」：目标 = 实际触发线 −5pp（整数百分位），保存前二次确认。
+              // 0.4.2 修复：从 11px 灰色小字里挪到独立动作行（右对齐），和告警同属一块可视区，不再跟单位/估算挤在一排。
+              handoffLate && handoffCapPercent !== null
+                ? h(
+                    'div',
+                    { style: { display: 'flex', justifyContent: 'flex-end' } },
+                    h('button', {
+                      type: 'button',
+                      'data-cr-recalc': '1',
+                      disabled: saving,
+                      title: `按当前模型实际触发线 ${nativeInfo.actualText}% 重算：最高可设 ${handoffCapPercent}%`,
+                      style: { ...settingsButtonStyle, height: 28, fontSize: 12, padding: '0 12px', whiteSpace: 'nowrap', cursor: saving ? 'wait' : 'pointer' },
+                      onClick: () => {
+                        if (handoffRecalcConflict !== '') {
+                          setConfirmRecalc(null);
+                          setStatus({ error: true, text: handoffRecalcConflict, field: 'thresholds.handoffRatio' });
+                          return;
+                        }
+                        setStatus(null);
+                        setConfirmRecalc({ ratio: handoffGuardInfo.target, percent: handoffCapPercent });
+                      },
+                    }, `按实际线重算（${handoffCapPercent}%）`),
+                  )
+                : null,
             ),
           ),
+          confirmRecalc === null
+            ? null
+            : h(
+                'div',
+                {
+                  'data-cr-recalc-confirm': '1',
+                  style: {
+                    margin: '0 0 14px',
+                    padding: '10px 12px',
+                    borderRadius: 8,
+                    border: '1px solid var(--dsw-alias-state-warning-primary, #d97706)',
+                    background: 'var(--dsw-alias-bg-layer-2, rgba(127,127,127,0.06))',
+                  },
+                },
+                h('div', { style: { fontSize: 12, fontWeight: 600, marginBottom: 4 } }, `确认把「交接提醒线」改为 ${confirmRecalc.percent}%？`),
+                h(
+                  'div',
+                  { style: { ...settingsHintStyle, marginBottom: 8 } },
+                  `当前模型实际触发 ${nativeInfo.actualText}%，按「实际线 −5pp」向下取整到 ${confirmRecalc.percent}%；` +
+                    '点「确认重算」会立即保存生效（不改压缩线、不动其它设置）。',
+                ),
+                h(
+                  'div',
+                  { style: { display: 'flex', gap: 8 } },
+                  h(
+                    'button',
+                    {
+                      type: 'button',
+                      disabled: saving,
+                      'data-cr-recalc-ok': '1',
+                      style: { padding: '4px 12px', borderRadius: 6, border: '1px solid #d97706', background: '#d97706', color: '#fff', cursor: saving ? 'wait' : 'pointer', fontSize: 12 },
+                      onClick: () => {
+                        void applyRecalc();
+                      },
+                    },
+                    saving ? '保存中…' : '确认重算',
+                  ),
+                  h(
+                    'button',
+                    {
+                      type: 'button',
+                      disabled: saving,
+                      style: { padding: '4px 12px', borderRadius: 6, border: '1px solid var(--dsw-alias-border-secondary, rgba(127,127,127,0.35))', background: 'transparent', color: 'var(--dsw-alias-label-primary, inherit)', cursor: 'pointer', fontSize: 12 },
+                      onClick: () => setConfirmRecalc(null),
+                    },
+                    '取消',
+                  ),
+                ),
+              ),
         ),
         sectionHeading('压缩行为'),
         h(
@@ -3686,12 +5057,6 @@ window.__ModuleLoader__.load({
             '换成更醒目的反差色 → 锁定位置一眼可见；换成接近默认色 → 更安静（但可能看不清标记）。',
             colorField(form.colors.base.pin, (value) => patch(['colors', 'base', 'pin'], value), '锁定颜色'),
           ),
-          h('div', { style: { display: 'flex', alignItems: 'center', gap: 10, marginTop: 16, flexWrap: 'wrap' } },
-            h('button', { type: 'button', style: { ...settingsButtonStyle, background: 'var(--dsw-alias-button-primary, #2563eb)', color: '#fff', border: 'none' }, disabled: saving, onClick: () => void save() }, saving ? '保存中…' : dirty ? '保存修改' : '保存'),
-            dirty ? h('span', { style: { fontSize: 11, color: 'var(--dsw-alias-state-warning-primary, #b45309)' } }, '有未保存的修改') : null,
-            status !== null ? h('span', { style: { fontSize: 11, color: status.error ? 'var(--dsw-alias-state-error-primary, #d92d20)' : 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.9))' } }, status.text) : null,
-            h('span', { style: settingsHintStyle }, '改完点这里保存；恢复默认在页面最底部。'),
-          ),
         ),
         sectionHeading('帮助'),
         h(
@@ -3894,16 +5259,130 @@ window.__ModuleLoader__.load({
           h('p', { style: settingsHintStyle }, '联系方式：cfanzx@136.com（合作、安全问题，以及不便公开讨论的事项）。'),
           h('p', { style: settingsHintStyle }, 'npm 包页面：https://www.npmjs.com/package/dsh-compact-relay'),
           h('p', { style: settingsHintStyle }, '致谢：DeepSeek Harness；设置栏实现参考了 dsh-plugin-memory；也谢谢帮忙测试的朋友们。'),
-          h('div', { style: { display: 'flex', alignItems: 'center', gap: 10, marginTop: 20, paddingTop: 14, borderTop: '1px dashed var(--dsw-alias-border-l2, rgba(127,127,127,0.25))', flexWrap: 'wrap' } },
-            h('span', { style: { fontSize: 12, fontWeight: 600, color: 'var(--dsw-alias-state-error-primary, #d92d20)' } }, '危险操作'),
-            confirmReset
-              ? h('span', { style: { display: 'inline-flex', alignItems: 'center', gap: 6 } },
-                  h('span', { style: { fontSize: 11, color: 'var(--dsw-alias-state-error-primary, #d92d20)' } }, '确定恢复默认？（会删除你的设置文件）'),
-                  h('button', { type: 'button', style: settingsButtonStyle, disabled: saving, onClick: () => void reset() }, '确定恢复'),
-                  h('button', { type: 'button', style: settingsButtonStyle, disabled: saving, onClick: () => setConfirmReset(false) }, '取消'),
-                )
-              : h('button', { type: 'button', style: settingsButtonStyle, disabled: saving, onClick: () => setConfirmReset(true) }, '恢复默认'),
+          h(
+            'p',
+            { style: { ...settingsHintStyle, marginTop: 20, paddingTop: 14, borderTop: '1px dashed var(--dsw-alias-border-l2, rgba(127,127,127,0.25))' } },
+            '危险操作：恢复默认会删除你的设置文件。入口在页面底部常驻的保存工具条里，点一次后还需要再确认一次（不会误删）。',
+          ),
+        ),
+        /**
+         * 0.4.2 修复（真机反馈「保存按键太靠下了」）：设置页很长，保存/恢复默认改成
+         * 粘性底部工具条 —— 页面滚到哪都固定在视口底部，不用滚到页尾才能点保存。
+         *
+         * 为什么用 sticky 而不是 fixed：它是流内元素，天然只占页面末尾那一格，
+         * 不会盖住最后一块内容；滚动中固定在底部时给宿主弹层留出 12px 内边距 +
+         * 安全区 padding，避免贴边/遮挡。
+         *
+         * 0.4.2 视觉打磨：按钮组靠左、状态靠右（marginLeft:auto 对齐，不再错位），
+         * 状态做成淡色小胶囊（失败红 / 成功绿 / 无状态时占位提示，行高不跳）；
+         * 底色/投影用现有 DSH token + theme.dark 兜底，深色浅色都不糊。
+         */
+        h(
+          'div',
+          {
+            'data-cr-savebar': '1',
+            style: {
+              position: 'sticky',
+              bottom: 0,
+              zIndex: 20,
+              marginTop: 20,
+              marginLeft: -8,
+              marginRight: -8,
+              padding: '8px 10px calc(8px + env(safe-area-inset-bottom, 0px))',
+              borderTop: '1px solid var(--dsw-alias-border-l2, rgba(127,127,127,0.22))',
+              background: `var(--dsw-alias-bg-layer-1, ${theme.dark ? 'rgba(32,33,36,0.94)' : 'rgba(255,255,255,0.94)'})`,
+              backdropFilter: 'var(--dsw-menu-backdrop-filter, blur(10px))',
+              WebkitBackdropFilter: 'var(--dsw-menu-backdrop-filter, blur(10px))',
+              boxShadow: theme.dark ? '0 -6px 18px rgba(0,0,0,0.42)' : '0 -6px 18px rgba(0,0,0,0.08)',
+              display: 'flex',
+              flexDirection: 'column',
+              gap: 6,
+            },
+          },
+          h(
+            'div',
+            { style: { display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' } },
+            h(
+              'button',
+              {
+                type: 'button',
+                'data-cr-save': '1',
+                disabled: saving,
+                style: {
+                  ...settingsButtonStyle,
+                  height: 30,
+                  padding: '0 16px',
+                  fontWeight: 600,
+                  background: 'var(--dsw-alias-button-primary, #2563eb)',
+                  color: '#fff',
+                  border: 'none',
+                  cursor: saving ? 'wait' : 'pointer',
+                  boxShadow: '0 1px 2px rgba(0,0,0,0.12)',
+                },
+                onClick: () => void save(),
+              },
+              saving ? '保存中…' : dirty ? '保存修改' : '保存',
+            ),
+            h(
+              'button',
+              {
+                type: 'button',
+                'data-cr-reset': '1',
+                disabled: saving,
+                style: { ...settingsButtonStyle, height: 30, cursor: saving ? 'wait' : 'pointer' },
+                onClick: () => setConfirmReset(true),
+              },
+              '恢复默认',
+            ),
+            dirty
+              ? h('span', { 'data-cr-dirty': '1', style: { fontSize: 11, fontWeight: 600, color: 'var(--dsw-alias-state-warning-primary, #b45309)' } }, '有未保存的修改')
+              : h('span', { 'data-cr-dirty': '0', style: { fontSize: 11, color: 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.9))' } }, '已是最新'),
+            // 没有状态时右侧放提示占位：按钮行高度稳定，不会因为状态出现/消失而跳。
+            status === null
+              ? h('span', { style: { ...settingsHintStyle, marginLeft: 'auto', textAlign: 'right' } }, '改完随时点「保存」，不用滚到页尾。')
+              : null,
           ),
+          // 状态单独一行（失败文案可能两行）：淡色胶囊 + 状态色文字，条内也看得清，且不把按钮挤歪。
+          status === null
+            ? null
+            : h(
+                'div',
+                {
+                  'data-cr-save-status': status.error ? 'error' : 'ok',
+                  role: status.error ? 'alert' : 'status',
+                  style: {
+                    padding: '4px 8px',
+                    borderRadius: 6,
+                    background: status.error ? 'rgba(217, 45, 32, 0.10)' : 'rgba(21, 128, 61, 0.10)',
+                    color: status.error
+                      ? 'var(--dsw-alias-state-error-primary, #D92D20)'
+                      : 'var(--dsw-alias-state-success-primary, #15803D)',
+                    fontSize: 11,
+                    lineHeight: '16px',
+                    fontWeight: status.error ? 600 : 500,
+                  },
+                },
+                status.text,
+              ),
+          confirmReset
+            ? h(
+                'div',
+                {
+                  'data-cr-reset-confirm': '1',
+                  style: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: 8,
+                    flexWrap: 'wrap',
+                    paddingTop: 6,
+                    borderTop: '1px dashed var(--dsw-alias-border-l2, rgba(127,127,127,0.2))',
+                  },
+                },
+                h('span', { style: { fontSize: 12, fontWeight: 600, color: 'var(--dsw-alias-state-error-primary, #d92d20)' } }, '确定恢复默认？（会删除你的设置文件）'),
+                h('button', { type: 'button', style: settingsButtonStyle, disabled: saving, onClick: () => void reset() }, '确定恢复'),
+                h('button', { type: 'button', style: settingsButtonStyle, disabled: saving, onClick: () => setConfirmReset(false) }, '取消'),
+              )
+            : null,
         ),
         // 0.4 P0-2：诊断信息预览弹层（只读等宽文本 + 复制 Markdown/JSON）。
         // 只有用户点了「生成并预览」/「打开问题报告页」才会出现；关掉后本次会话不再显示首次说明卡。
@@ -4113,6 +5592,30 @@ window.__ModuleLoader__.load({
         ),
       );
 
+      // 0.5.0 接力条 v1：输入卡上方通栏一行「已接力自 …」+ 向上弹出的下拉菜单。
+      // 组件内部再判断 chain：无链/老宿主没有 chain 字段 → 返回 null，不占高度。
+      ctx.slots.inject('conversation.input.dock', () =>
+        ctx.slots.register(
+          {
+            name: 'conversation.input.dock',
+            id: 'compact-relay',
+            // 宿主 TodoPanel 是 0、queue 是 20；接力条夹在中间（输入卡正上方）。
+            order: 10,
+            inject: (sessionId) => ({
+              sessionId,
+              openSession: (targetSessionId) => ctx.uiWorkspace.openSession(targetSessionId),
+              // 0.5.0：恢复归档旧会话（与侧栏「取消归档」同一条 Client 接缝）。
+              // 老宿主没有这个方法时传 undefined，组件会退回 HTTP recover。
+              unarchiveSession:
+                typeof ctx.uiWorkspace?.unarchiveSession === 'function'
+                  ? (targetSessionId) => ctx.uiWorkspace.unarchiveSession(targetSessionId)
+                  : undefined,
+            }),
+          },
+          CompactRelayBar,
+        ),
+      );
+
       // /handoff 命令卡：成功后自动切换（key 必须等于命令名）。
       ctx.slots.inject('conversation.chat.commandview', () =>
         ctx.slots.register(