dsh-compact-relay 0.4.0 → 0.4.2

package/lib/client.js

@@ -724,6 +724,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 '—';
@@ -742,6 +961,59 @@ window.__ModuleLoader__.load({
       );
     };
 
+    /**
+     * 0.4.1：原生自动压缩线「配置阈值 vs 实际触发线」。
+     * DSH 按 token 预算触发：min(窗口×配置阈值, 窗口−输出预留−余量)，
+     * 所以实际触发点常比配置比例更早（deepseek-flash 配置 80%、实际 67.85%）。
+     * autoEnabled=false 时 effective/percentText 为空（未开启），但 actualText 仍给出
+     * 「开启后实际会触发多少」，供关闭态文案使用。
+     * @param {object|null} native readState 下发的 native 字段
+     * @returns {{configured:number|null,configuredText:string|null,actual:number|null,actualText:string,effective:number|null,percentText:string,differs:boolean,autoOff:boolean,why:string}}
+     */
+    const nativeLineInfo = (native) => {
+      const num = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : null);
+      const ratioOf = (value) => {
+        const n = num(value);
+        return n !== null && n > 0 && n < 1 ? n : null;
+      };
+      const src = native === null || native === undefined ? null : native;
+      const configured = ratioOf(src === null ? null : src.thresholdRatio);
+      const actual = ratioOf(src === null ? null : src.ratio);
+      const autoOff = src !== null && src.autoEnabled === false;
+      const effective = autoOff ? null : actual !== null ? actual : configured;
+      const pctText = (value) => {
+        const p = value * 100;
+        return Math.abs(p - Math.round(p)) < 0.05 ? String(Math.round(p)) : p.toFixed(1);
+      };
+      const configuredText = configured === null ? null : pctText(configured);
+      const actualText = actual === null ? '' : pctText(actual);
+      const percentText = effective === null ? '' : pctText(effective);
+      const differs = configured !== null && effective !== null && Math.abs(effective - configured) >= 0.005;
+      let why = '';
+      if (differs) {
+        const overridden = src.overridden === true;
+        const windowTokens = num(src.contextWindow);
+        const reserved = num(src.reservedCompletionTokens);
+        const headroom = num(src.headroomTokens);
+        // 只有「预算分支确实更小」时，才能把差异归因为输出预留/余量。
+        const budgetTokens = windowTokens !== null ? windowTokens - (reserved ?? 0) - (headroom ?? 0) : null;
+        const budgetBinding = budgetTokens !== null && configured !== null && budgetTokens < windowTokens * configured;
+        const parts = [];
+        if (reserved !== null && reserved > 0) parts.push(`模型输出要预留 ${fmt(reserved)}`);
+        if (headroom !== null && headroom > 0) parts.push(`DSH 自己还要留 ${fmt(headroom)} 余量`);
+        if (overridden) {
+          why = `这个模型单独配了阈值（按路由覆盖），实际触发是 ${actualText}%（全局配置 ${configuredText}%）。`;
+        } else if (budgetBinding && parts.length > 0) {
+          why = `配置阈值 ${configuredText}% 只是理论上限；${parts.join('、')}，所以实际打到 ${percentText}% 就会自动压。`;
+        } else if (actual !== null && configured !== null && actual > configured) {
+          why = `这个路由的输出预留更小，实际触发晚于配置阈值 ${configuredText}%（实际 ${actualText}%）。`;
+        } else {
+          why = `实际触发 ${actualText}% 与配置阈值 ${configuredText}% 不同，按宿主 token 预算算的。`;
+        }
+      }
+      return { configured, configuredText, actual, actualText, effective, percentText, differs, autoOff, why };
+    };
+
     const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
     /**
@@ -1033,6 +1305,11 @@ window.__ModuleLoader__.load({
                     typeof data.native.headroomTokens === 'number' && Number.isFinite(data.native.headroomTokens)
                       ? data.native.headroomTokens
                       : null,
+                  // 0.4.1：悬停卡解释「为什么实际触发比配置阈值早」要用到输出预留。
+                  reservedCompletionTokens:
+                    typeof data.native.reservedCompletionTokens === 'number' && Number.isFinite(data.native.reservedCompletionTokens)
+                      ? data.native.reservedCompletionTokens
+                      : null,
                   overridden: data.native.overridden === true,
                   route:
                     data.native.route && typeof data.native.route === 'object' && typeof data.native.route.model === 'string'
@@ -1249,6 +1526,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 反馈）。
@@ -1316,6 +1609,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：按消息在历史里的相对位置）。这是「保护内容」的信号，
@@ -1430,6 +1756,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;
@@ -1764,11 +2113,12 @@ window.__ModuleLoader__.load({
               state.native.route !== null ? `，${state.native.route.provider}/${state.native.route.model}` : ''
             }${state.native.overridden ? '，按路由覆盖' : ''}）`
           : '';
+      const nativeInfo = nativeLineInfo(state.native);
       const nativeLineText =
         nativeEffective !== null
           ? `原生自动压缩线 ${(nativeEffective * 100).toFixed(1)}%${nativeDetail}${
-              ratio > nativeEffective ? '（已越过：整环红色闪烁）' : ''
-            }`
+              nativeInfo.differs ? `；${nativeInfo.why}` : ''
+            }${ratio > nativeEffective ? '（已越过：整环红色闪烁）' : ''}`
           : 'DSH 原生自动压缩已关闭';
       const pressureKnown = pressureValue !== null;
       const title =
@@ -1778,6 +2128,7 @@ window.__ModuleLoader__.load({
         `，已压缩 ${state.summaries} 次｜${adviceText}` +
         (compressHintText !== '' ? `｜${compressHintText}` : '') +
         (nativeLineText !== '' ? `｜${nativeLineText}` : '') +
+        (handoffWarnText !== '' ? `｜${handoffWarnText}` : '') +
         (pins.count > 0 ? `｜已锁定 ${pins.count} 条` : '') +
         (effectiveBusy ? '｜处理中…' : '');
 
@@ -1837,6 +2188,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;
 
@@ -1859,6 +2214,8 @@ window.__ModuleLoader__.load({
         }),
         // 0.3.1：DSH 原生自动压缩线（刻度/危险区）。
         ...nativeNodes,
+        // 0.4.2：交接线已晚的警示标记（交接刻度旁的小短线 + 小点，不改分段逻辑）。
+        ...handoffWarnNodes,
         // 0.3.1：锁定消息在环上的块（品红，按历史位置）。
         ...pinBlocks,
       );
@@ -2074,6 +2431,8 @@ window.__ModuleLoader__.load({
                     onClick: () => {
                       void startHandoffPreview();
                     },
+                    // 0.4.2（P1）：交接线晚于原生压缩时，菜单项旁直接标出来（只告警，仍可点）。
+                    ...(handoffLate ? { note: handoffWarnText, title: handoffGuardInfo.message } : {}),
                   }
                 : { disabled: true, note: '会话刚打开，请稍候' },
             ),
@@ -2926,6 +3285,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 };
@@ -3011,6 +3407,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);
@@ -3044,22 +3455,53 @@ window.__ModuleLoader__.load({
         [],
       );
 
+      /** 0.4.1：设置接口只给「配置阈值」，实际触发线要从 state 接口补（同一套 readState 数据）。 */
+      const nativeLineExtra = useRef(null);
+      const mergeNative = useCallback((view) => {
+        if (view === null || view === undefined) return null;
+        const extra = nativeLineExtra.current;
+        return extra === null ? view : { ...view, ...extra };
+      }, []);
+
       /** 把服务端返回的 view 落到表单：同时更新「已保存」快照和设置文件错误。 */
       const applyLoaded = useCallback((data) => {
         setForm(data.config);
         setSavedSnapshot(JSON.stringify(data.config));
+        // 服务端回来的配置是新的权威值：丢掉输入草稿，输入框重新按表单派生（加载/保存成功都走这里）。
+        setPercentDrafts({});
         setSettingsError(data.settingsError ?? null);
-        setNative(data.native && typeof data.native === 'object' ? data.native : null);
+        setNative(mergeNative(data.native && typeof data.native === 'object' ? data.native : null));
         if (typeof data.version === 'string') setVersion(data.version);
         if (typeof data.path === 'string') setSettingsPath(data.path);
         setLedger(data.ledger !== null && typeof data.ledger === 'object' ? data.ledger : null);
-      }, []);
+      }, [mergeNative]);
 
       const load = useCallback(async () => {
         try {
-          const res = await fetch('/api/compact-relay-settings', { cache: 'no-store' });
-          const data = await res.json().catch(() => ({}));
-          if (!res.ok || data.ok === false) throw new Error(data && data.message ? String(data.message) : '读取设置失败');
+          const [settingsRes, stateRes] = await Promise.all([
+            fetch('/api/compact-relay-settings', { cache: 'no-store' }),
+            fetch('/api/compact-relay-state', { cache: 'no-store' }).catch(() => null),
+          ]);
+          const data = await settingsRes.json().catch(() => ({}));
+          if (!settingsRes.ok || data.ok === false) throw new Error(data && data.message ? String(data.message) : '读取设置失败');
+          // 0.4.1：补上实际触发线相关字段（配置接口没有这些，只有 state 接口有）。
+          let extra = null;
+          if (stateRes !== null && stateRes.ok) {
+            const stateData = await stateRes.json().catch(() => ({}));
+            const sn = stateData !== null && stateData.native !== null && typeof stateData.native === 'object' ? stateData.native : null;
+            if (sn !== null) {
+              extra = {
+                ratio: typeof sn.ratio === 'number' ? sn.ratio : null,
+                thresholdTokens: typeof sn.thresholdTokens === 'number' ? sn.thresholdTokens : null,
+                contextWindow: typeof sn.contextWindow === 'number' ? sn.contextWindow : null,
+                reservedCompletionTokens: typeof sn.reservedCompletionTokens === 'number' ? sn.reservedCompletionTokens : null,
+                headroomTokens: typeof sn.headroomTokens === 'number' ? sn.headroomTokens : null,
+                overridden: sn.overridden === true,
+                route: sn.route !== null && typeof sn.route === 'object' ? sn.route : null,
+              };
+            }
+          }
+          nativeLineExtra.current = extra;
           applyLoaded(data);
           setStatus(null);
         } catch (error) {
@@ -3074,32 +3516,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 () => {
@@ -3124,6 +3656,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) => {
@@ -3238,7 +3783,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 = (() => {
@@ -3250,7 +3794,45 @@ window.__ModuleLoader__.load({
       })();
 
       const autoOnNative = native !== null && native.autoEnabled !== false;
-      const nativePercent = native !== null && typeof native.thresholdRatio === 'number' ? Math.round(native.thresholdRatio * 100) : 80;
+      // 0.4.1：配置阈值（thresholdRatio）只是理论上限；实际触发线由宿主按 token 预算算。
+      const nativeInfo = nativeLineInfo(native);
+      const nativePercent = nativeInfo.configured !== null ? Math.round(nativeInfo.configured * 100) : 80;
+      // 原生压缩已关闭时 effective/percentText 为空：回落到「开启后实际会触发多少」，再回落配置阈值。
+      const nativeActualText = nativeInfo.percentText !== '' ? nativeInfo.percentText : nativeInfo.actualText !== '' ? nativeInfo.actualText : nativeInfo.configuredText !== null ? nativeInfo.configuredText : String(nativePercent);
+      /**
+       * 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）。
@@ -3279,7 +3861,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',
@@ -3300,8 +3882,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 }, '% 窗口'),
             ),
@@ -3310,10 +3903,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）`),
@@ -3323,25 +3926,125 @@ window.__ModuleLoader__.load({
             '交接提醒线',
             '到这条线内圆亮红点，菜单建议「交接新会话」。',
             '调高 → 更晚换会话、单会话更久；调低 → 更早换会话、单会话更短。必须大于压缩线。',
-            h('div', { style: { display: 'flex', alignItems: 'center', gap: 8 } },
-              h('input', {
-                type: 'number',
-                min: 5,
-                max: native !== null && native.autoEnabled !== false ? Math.max(5, Math.round(native.thresholdRatio * 100) - 1) : 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 ? Math.max(0.05, native.thresholdRatio - 0.01) : 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(
@@ -3387,10 +4090,10 @@ window.__ModuleLoader__.load({
             native === null
               ? '正在读取 DSH 配置…'
               : autoOnNative
-                ? `当前开启：容量到 ${nativePercent}% 时，DSH 会自己把历史压成摘要（不读本插件的锁定）。`
+                ? `当前开启：容量到 ${nativeActualText}% 时，DSH 会自己把历史压成摘要（不读本插件的锁定）。`
                 : '当前已关闭：DSH 不再自动压历史，只有你主动压缩/交接才会动历史。',
             autoOnNative
-              ? `开启时：容量到 ${nativePercent}% DSH 会自己压历史（不读锁定）；关闭后：只在你主动压缩/交接时才动历史。`
+              ? `开启时：容量到 ${nativeActualText}% DSH 会自己压历史（不读锁定）；关闭后：只在你主动压缩/交接时才动历史。${nativeInfo.differs ? `（${nativeInfo.why}）` : ''}`
               : '开启后：DSH 会在容量到原生阈值时自动压历史，可能压掉锁定的消息；本插件的提醒照常。',
             h(
               'div',
@@ -3437,7 +4140,13 @@ window.__ModuleLoader__.load({
                 }),
               ),
               h('span', { style: { fontSize: 12, fontWeight: 600, minWidth: 44 } }, native === null ? '读取中…' : nativeBusy ? '处理中…' : autoOnNative ? '已开启' : '已关闭'),
-              h('span', { style: settingsHintStyle }, native !== null ? `原生阈值 ${nativePercent}%` : ''),
+              h('span', { style: settingsHintStyle }, native !== null
+                ? (nativeInfo.autoOff
+                  ? (nativeInfo.actualText !== ''
+                    ? `原生阈值 配置 ${nativeInfo.configuredText ?? nativePercent}%（已关闭；开启后实际触发 ${nativeInfo.actualText}%）`
+                    : `原生阈值 配置 ${nativeInfo.configuredText ?? nativePercent}%（已关闭）`)
+                  : (nativeInfo.differs ? `原生阈值 配置 ${nativeInfo.configuredText}%（实际触发 ${nativeInfo.percentText}%）` : `原生阈值 ${nativeActualText}%`))
+                : ''),
               nativeStatus === null
                 ? null
                 : h(
@@ -3474,9 +4183,9 @@ window.__ModuleLoader__.load({
                   { style: { ...settingsHintStyle, marginBottom: 8 } },
                   confirmNative === 'disable'
                     ? `操作内容：在 DSH profile 的 cordis.patch.yml 里把 compaction-basic 的 auto 改为 false（写前备份原文件，可回滚）。` +
-                      `改变：DSH 不再在容量到 ${nativePercent}% 时自动压缩历史；锁定的消息不会被压掉；本插件的提醒和手动压缩照常。需要重启 DSH 生效。`
+                      `改变：DSH 不再在容量到 ${nativeActualText}% 时自动压缩历史；锁定的消息不会被压掉；本插件的提醒和手动压缩照常。需要重启 DSH 生效。`
                     : `操作内容：在 DSH profile 的 cordis.patch.yml 里把 compaction-basic 的 auto 改回 true（写前备份，可回滚）。` +
-                      `改变：DSH 重新在容量到 ${nativePercent}% 时自动压历史，可能压掉锁定的消息。需要重启 DSH 生效。`,
+                      `改变：DSH 重新在容量到 ${nativeActualText}% 时自动压历史，可能压掉锁定的消息。需要重启 DSH 生效。`,
                 ),
                 h(
                   'div',
@@ -3583,12 +4292,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(
@@ -3664,13 +4367,15 @@ window.__ModuleLoader__.load({
               { ratio: compactRatio + 0.08, hint: null, title: '进入压缩区', text: '琥珀：建议压缩旧会话' },
               { ratio: handoffRatio + 0.15, hint: null, title: '越过交接线', text: '红：建议交接新会话' },
             ];
-            if (native !== null && native.autoEnabled !== false) {
+            if (native !== null && native.autoEnabled !== false && nativeInfo.effective !== null) {
               legend.push({
-                ratio: native.thresholdRatio + 0.06,
+                ratio: Math.min(0.95, nativeInfo.effective + 0.06),
                 hint: null,
-                nativeAt: native.thresholdRatio,
+                nativeAt: nativeInfo.effective,
                 title: '原生自动压缩线',
-                text: `${Math.round(native.thresholdRatio * 100)}%：DSH 会自己压历史（越过整环红色闪烁）`,
+                text: nativeInfo.differs
+                  ? `实际 ${nativeInfo.percentText}%：DSH 会自己压历史（配置阈值 ${nativeInfo.configuredText}%，越过整环红色闪烁）`
+                  : `${nativeInfo.percentText}%：DSH 会自己压历史（越过整环红色闪烁）`,
               });
             }
             return h(
@@ -3789,16 +4494,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）。
         // 只有用户点了「生成并预览」/「打开问题报告页」才会出现；关掉后本次会话不再显示首次说明卡。