dsh-mini-remote 0.2.0 → 0.2.1

package/lib/page.html

@@ -44,6 +44,12 @@
     --run: #a9c8e8;
     --shimmer: #eaf4ff;   /* 跑着的行那道扫光的亮色（照 PC 的 label-shimmer，2026-10-04） */
     --err: #d4614f;
+    /* 「等你在手机上动手」那一类状态（待审批 / 计划待审 / 待回答）。
+       和 --ok/--run/--err 同一档：**状态点的语义色**，占的是一个小点/一截短字，
+       不算强调色，不参与"一屏最多两处暖金"那条规矩。
+       照 PC 侧栏的说法，那一类用的是共享的 warning 橙点——我们这边补一个对应的令牌，
+       PC 上的原话是「待处理交互的优先级高于共享 ongoing loading」。 */
+    --warn: #e0904a;
     --r: 2px;
     --sh-1: 0 1px 2px rgba(0, 0, 0, .28);
     --sh-2: 0 2px 6px rgba(0, 0, 0, .34);
@@ -76,6 +82,7 @@
     --run: #3b6fc4;
     --shimmer: #7ea6e6;   /* 浅色下的扫光要比 --run 亮、又不能白到看不见 */
     --err: #c0392b;
+    --warn: #b56a17;      /* 白底上的警示橙：比深色那档压深，才读得清 */
     --sh-1: 0 1px 2px rgba(28, 60, 110, .07);
     --sh-2: 0 2px 8px rgba(28, 60, 110, .12);
     --glass: rgba(255, 255, 255, .74);
@@ -880,6 +887,108 @@
     flex: 0 0 auto; width: 6px; height: 6px; border-radius: 50%;
     background: var(--run);
   }
+  /* ---------- 会话条目上的执行动作（2026-10-09） ----------
+     电脑端是"悬停时行尾冒出按钮"，手机没有悬停——所以这里改成**常驻**一个小入口（⋯）。
+     选常驻不选长按：长按是看不见的隐藏手势，还和系统的选字/链接预览打架；
+     而这份列表里一半条目没名字，最需要的恰恰是一个看得见的入口。
+     动作本身不弹菜单，在那一行下面**行内展开**（照「新建文件夹」「模式清单」已有的先例）。 */
+  /* 一行会话 = 一个"打开它"的按钮 + 一个常驻的 ⋯。
+     两者是**兄弟**而不是父子：塞进去就成了"按钮里套按钮"（无效结构），
+     点 ⋯ 也会先把会话打开。所以多包一层，让它们并排。 */
+  .sess-line { display: flex; align-items: center; }
+  .sess-line .sess { flex: 1 1 auto; min-width: 0; padding-right: 4px; }
+  .s-more {
+    flex: 0 0 auto; width: 26px; height: 26px; padding: 0; margin-right: 8px;
+    display: flex; align-items: center; justify-content: center;
+    background: none; border: none; color: var(--muted);
+    font: inherit; font-size: 15px; line-height: 1; cursor: pointer;
+    border-radius: var(--r);
+  }
+  .s-more:active { background: var(--line); color: var(--fg); }
+  .sess.acting, .sess.renaming { background: var(--panel-2); }
+  /* 待处理那一类（待审批 / 计划待审 / 待回答）：占的是行尾更新时间的位置——
+     和电脑端同一条规矩（"以待批准、计划待审或待回答替换尾部更新时间"）。 */
+  .sess .s-flag.pending { color: var(--warn); }
+  .sess .s-dot.pending { background: var(--warn); }
+  /* 已归档：整行置灰，并在行尾标出来。**不去掉这一行**——用户要看的是"它还在，
+     只是收起来了"，凭空消失只会让人以为会话被删了（官方：会话可以归档但绝不会被删除）。 */
+  .sess.archived { color: var(--muted); }
+  .sess .s-flag { flex: 0 0 auto; font-size: 11.5px; color: var(--muted); white-space: nowrap; }
+
+  .sess-acts { display: flex; flex-wrap: wrap; gap: 6px; padding: 0 14px 9px 30px; }
+  .sess-acts button {
+    flex: 1 1 auto; min-width: 0; padding: 8px 10px; font: inherit; font-size: 13px;
+    background: var(--panel-2); border: 1px solid var(--line);
+    border-radius: var(--r); color: var(--fg); cursor: pointer;
+  }
+  .sess-acts button:active { background: var(--line); }
+  .sess-acts button.danger { color: var(--err); }
+  /* 动作条下面的一句说明（目前只有「分叉会话」那一项用得上）。
+     **只在动作条展开时才出现**，所以它不占常驻的地方；字号比按钮小一档、用灰色——
+     它是解释，不是又一个能点的东西，所以不做成按钮的样子。 */
+  .sess-acts-hint { padding: 0 14px 9px 30px; margin-top: -3px; font-size: 12px; line-height: 1.6; color: var(--muted); }
+
+  /* 改名字那一行。形状照抄下面的「新建文件夹」：同样是内联输入，不用 window.prompt
+     （prompt 在微信这类内嵌浏览器里会被直接屏蔽，点了什么都不发生、也没提示）。 */
+  .sess-rename { display: flex; gap: 6px; padding: 0 14px 9px 30px; align-items: center; }
+  .sess-rename input {
+    flex: 1 1 auto; min-width: 0; padding: 9px 10px; font: inherit; font-size: 14px;
+    background: var(--panel-2); border: 1px solid var(--line);
+    border-radius: var(--r); color: var(--fg);
+  }
+  .sess-rename button {
+    flex: 0 0 auto; padding: 9px 12px; font: inherit; font-size: 13px; cursor: pointer;
+    background: var(--panel-2); border: 1px solid var(--line);
+    border-radius: var(--r); color: var(--fg);
+  }
+  .sess-rename button:active { background: var(--line); }
+
+  /* 「展开其余 N 个 / 收起」。官方口径：默认只显示 5 条空闲会话，每点一次多 5 条。
+     它是一个动作，所以用强调**字色**（--ice），不是强调底色——底那一档一屏只有一个。 */
+  .sess-more {
+    display: block; width: 100%; padding: 10px 14px 10px 30px;
+    background: none; border: none; color: var(--ice);
+    font: inherit; font-size: 13px; text-align: left; cursor: pointer;
+  }
+  .sess-more:active { background: var(--panel-2); }
+
+  /* 抽屉顶部的「显示已归档」。默认关——官方的默认项就是"隐藏已归档"。
+     关着的时候是一句普通灰字，开着的时候用 --ice 亮起来，一眼看得出当前在哪一档。 */
+  .nav-filter {
+    display: flex; align-items: center; gap: 6px; width: 100%;
+    padding: 9px 14px; background: none; border: none; border-bottom: 1px solid var(--line);
+    color: var(--muted); font: inherit; font-size: 13px; text-align: left; cursor: pointer;
+  }
+  .nav-filter.on { color: var(--ice); }
+  .nav-filter:active { background: var(--panel-2); }
+
+  /* 归档确认（"停止并归档此会话？"）。**这一处是真弹的**——官方原话是
+     "仍有工作在跑的 Session 是唯一会先询问的情形……侧栏随即打开『停止并归档』对话框"，
+     而这件事会停掉正在跑的工作，不能做成一行不显眼的文字。 */
+  #navConfirm {
+    position: fixed; inset: 0; z-index: 120; display: none;
+    background: var(--scrim); padding: 24px 18px calc(24px + env(safe-area-inset-bottom));
+    align-items: center; justify-content: center;
+  }
+  #navConfirm.on { display: flex; }
+  #navConfirm .nc-panel {
+    width: 100%; max-width: 340px; max-height: 100%; overflow-y: auto;
+    background: var(--pop); border: 1px solid var(--line); border-radius: var(--r);
+    box-shadow: var(--sh-2); padding: 16px;
+  }
+  #navConfirm h3 { margin: 0 0 10px; font-size: 15.5px; font-weight: 650; }
+  #navConfirm p { margin: 0 0 10px; font-size: 13.5px; line-height: 1.7; color: var(--muted); }
+  #navConfirm ul { margin: 0 0 14px; padding-left: 18px; font-size: 13.5px; line-height: 1.8; }
+  #navConfirm li b { font-weight: 650; }
+  #navConfirm .nc-foot { display: flex; gap: 8px; }
+  #navConfirm .nc-foot button {
+    flex: 1 1 0; padding: 11px; font: inherit; font-size: 14px; cursor: pointer;
+    background: var(--panel-2); border: 1px solid var(--line);
+    border-radius: var(--r); color: var(--fg);
+  }
+  #navConfirm .nc-foot button:active { background: var(--line); }
+  #navConfirm .nc-foot button.danger { color: var(--err); border-color: var(--err); }
+  #navConfirm .nc-foot button[disabled] { color: var(--muted); cursor: default; }
   /* 「新建会话」那一行。跟会话条目同宽、同缩进，但用强调色——
      它不是一个会话，是一个动作。长得跟会话一样会让人以为点进去就是那条会话。 */
   .ws-new {
@@ -1271,6 +1380,35 @@
     background: var(--bg-top);
   }
   .mv-title { flex: 1 1 auto; font-size: 14px; color: var(--fg); }
+
+  /* ---------- 顶部那条横条的「收 / 放」（2026-10-15 用户要求） ----------
+     平时**完全看不见**：整条收进一个 0 高的壳里。**用「收起来」而不是「透明」**——
+     透明还占着 61px 的地方，官方界面就长不高、屏幕上留一道空当；收起来的话框自己
+     长上来填满（高度是过渡的，不跳）。
+
+     桌面：鼠标贴到屏幕顶部才滑出来，移开就滑走。
+     **顶上那条 16px 的感应带不能省**：鼠标一落到框里那份文档上，事件就进了那份文档，
+     外层页一个都收不到——不盖这一条，最顶上就没有任何东西能「碰到」。
+     它透明、只有 16px，压在官方界面最上面那道空白上：实测宽屏（1440/1024）下 0~21px
+     里没有任何可点的东西（官方自己的按钮最低也从第 22px 起，右上角那个「打开右侧边栏」
+     在第 28px）；**窄到 800px 时最早的可点元素从第 18px 起**（左上那颗图标按钮），所以
+     带的高度停在 16px——两边各留 2~6px 余量，谁也不挡。
+
+     **只在「主输入设备是有悬停能力的精细指针」时才收起来**（上面那个媒体查询管的就是
+     这件事）：触摸优先的设备上它匹配不上，横条保持**常驻**——触摸没有「悬停」这回事，
+     藏起来就会变成摸不到的东西。它是唯一回手机页的出口，这一条不能赌。 */
+  #mirrorHot { display: none; }
+  .mv-hot { flex: 0 0 auto; overflow: hidden; }
+  @media (hover: hover) and (pointer: fine) {
+    #mirrorHot {
+      display: block; position: absolute; left: 0; right: 0; top: 0;
+      height: 16px; z-index: 2;
+    }
+    /* 100px 是留给 `max-height` 过渡的余量：横条实测 61px，留够就不会被削。
+       收起那一侧同理——`max-height` 掉到 61px 以下才真的开始收。 */
+    .mv-hot { max-height: 0; transition: max-height .25s ease; }
+    #mirrorView.bar-on .mv-hot { max-height: 100px; }
+  }
   #mirrorFrame {
     flex: 1 1 auto; width: 100%; border: 0; background: var(--bg);
     /* 底部让开手势条（2026-10-07 从「被镜像的那份页面」搬回来的）。
@@ -1329,6 +1467,16 @@
     color: var(--on-act); font-size: 16px; font-weight: 600;
   }
   #gate .err { color: var(--err); font-size: 13px; min-height: 18px; }
+  /* 被撤销的那台设备要看到的一句话。**默认不出现**，只有服务端说"这枚凭据的名册记录
+     已经被删掉了"那一次才露（见 lib/server.js 里那一条判据，以及 lib/page.js 里那个
+     注入给页面的开关）。
+     这句注释里**不许写出那个占位符本身**：服务端是拿字符串替换注入的，而 replace 只
+     换第一处——注释里写一遍，真正该被换掉的那一行就永远换不掉了（2026-10-16 真踩过）。
+     下面那句 `[hidden]` 也不能省：这个文件里 `.sheet .version[hidden]`、
+     `#mirrorView[hidden]` 都是同一件事——作者样式表里的 display 会压住浏览器默认的
+     [hidden]，少一句就变成"一句本来不该出现的话一直挂在屏幕上"。 */
+  #gate p.revoked[hidden] { display: none; }
+  #gate p.revoked { color: var(--err); }
 
   #toast {
     position: fixed; left: 50%; bottom: 84px; transform: translateX(-50%) translateY(8px);
@@ -1338,6 +1486,17 @@
     transition: opacity .2s, transform .2s; z-index: 200; max-width: 86vw; text-align: center;
   }
   #toast.show { opacity: 1; transform: translateX(-50%) translateY(0); }
+  /* 带「撤销」那一版的提示：只有它需要点得动，所以只有它开 pointer-events。
+     普通提示还是原来那样——纯字、点不中，不给用户一个按了没反应的假按钮。 */
+  #toast.with-act {
+    pointer-events: auto; display: flex; align-items: center; gap: 12px; text-align: left;
+  }
+  #toast .toast-act {
+    flex: 0 0 auto; padding: 4px 8px; background: none; border: none;
+    color: var(--ice); font: inherit; font-size: 13.5px; font-weight: 650;
+    cursor: pointer; border-radius: var(--r);
+  }
+  #toast .toast-act:active { background: var(--panel-2); }
 
   /* ——— 回答电脑提问的卡片 ———
      整屏遮住聊天区：手机上一次只专心答一题，答完自动消失。
@@ -1739,6 +1898,21 @@
   </aside>
 </div>
 
+<!-- 归档确认。**独立于抽屉之外**：抽屉能被关掉，而这一问必须挡住整屏——
+     它要停下来的是正在电脑上跑的工作，不该因为用户顺手关了抽屉就悄悄消失。
+     里面的内容（会停掉哪几族工作）由 renderNavConfirm 现填。 -->
+<div id="navConfirm" role="dialog" aria-modal="true" aria-labelledby="navConfirmTitle">
+  <div class="nc-panel">
+    <h3 id="navConfirmTitle">停止并归档此会话？</h3>
+    <p id="navConfirmDesc"></p>
+    <ul id="navConfirmList"></ul>
+    <div class="nc-foot">
+      <button type="button" data-nc-cancel="1">取消</button>
+      <button type="button" class="danger" data-nc-ok="1">停止并归档</button>
+    </div>
+  </div>
+</div>
+
 <div id="settings">
   <div class="sheet">
     <!-- 页眉。整屏之后「点外面关掉」没了，所以这里必须有一个一直看得见的关闭口
@@ -1922,7 +2096,7 @@
     </div>
 
     <div class="foot">
-      <button class="btn" id="btnForget">清除 token</button>
+      <button class="btn" id="btnForget">重新输入令牌</button>
       <button class="btn primary" id="btnClose">完成</button>
     </div>
 
@@ -1950,9 +2124,15 @@
   另外整行都能点（不只右边那个按钮）——按钮只有 54×40，手指容易点偏。
 -->
 <div id="mirrorView" hidden>
-  <div class="mv-bar">
-    <span class="mv-title">电脑端界面</span>
-    <button class="btn" id="mirrorClose" type="button">返回</button>
+  <!-- 顶部感应带：桌面上「鼠标贴到屏幕顶部」那一下由它接住。手机上它是 display:none，
+       那时横条本来就常驻——为什么必须有它、为什么手机不吃这一套，见样式表那段说明。 -->
+  <div id="mirrorHot"></div>
+  <!-- 横条外面这层壳是「收 / 放」用的：收起时压成 0 高，官方界面自己长上来填满。 -->
+  <div class="mv-hot" id="mirrorBar">
+    <div class="mv-bar">
+      <span class="mv-title">电脑端界面</span>
+      <button class="btn" id="mirrorClose" type="button">返回</button>
+    </div>
   </div>
   <!-- 地址是点开那一刻才设的：没点之前一个字节都不加载。 -->
   <iframe id="mirrorFrame" title="电脑端界面"></iframe>
@@ -2026,6 +2206,7 @@
 
 <div id="gate">
   <h1>需要访问令牌</h1>
+  <p class="revoked" id="gateRevoked" hidden>这台设备的授权已被移除，请重新扫码。</p>
   <p>在电脑上打开 DSH 的「设置 → 手机遥控」，用手机重新扫一次二维码就能进来。
      或者把那一页上的链接整条复制到浏览器地址栏打开。</p>
   <input id="gateInput" type="text" placeholder="粘贴 token" autocomplete="off"
@@ -2042,6 +2223,9 @@
 
   var DEFAULT_MODE = '__DEFAULT_MODE__';
   var NEEDS_TOKEN = __NEEDS_TOKEN__;
+  // 这台设备是**被撤销了**（名册里那条记录被删掉），还是从来没进过门？
+  // 由服务端判（它才知道凭据兑不兑得出来），页面只负责把那句话说给用户听。
+  var DEVICE_REVOKED = __DEVICE_REVOKED__;
   // 构建指纹，由服务端注入。拼在立绘地址后面，换了图浏览器就不会一直用缓存那张。
   var BUILD = '__BUILD__';
   // 单个文件的大小上限（字节），由服务端注入。页面里不写第二份——两处各写一个数，
@@ -2051,7 +2235,14 @@
   // ---------------- 状态 ----------------
   var params = new URLSearchParams(location.search);
   var state = {
-    token: params.get('token') || localStorage.getItem('dshMiniToken') || '',
+    /**
+     * 进没进门——**由服务端说了算**（2026-10-16 第二步）。
+     *
+     * 服务端只在「没放行」的那一次渲染门禁页（needsToken=true）；放行时永远是 false。
+     * 这是页面之后唯一需要的身份信息：真正的凭据是一枚 HttpOnly 的设备 cookie，
+     * 页面看不见、也不该管它——浏览器自己会给同源的每一趟请求带上。
+     */
+    entered: !NEEDS_TOKEN,
     mode: localStorage.getItem('dshMiniMode') || DEFAULT_MODE || 'minimal',
     // 外观：'dark' | 'light' | 'auto'。默认深色——不给老用户换掉现在的样子；
     // 要浅色或跟着系统走，去设置页「外观」点一下。
@@ -2124,11 +2315,14 @@
      */
     pendingCommand: null
   };
-  if (params.get('token')) {
-    localStorage.setItem('dshMiniToken', params.get('token'));
-    // 别把 token 留在地址栏里，避免被截图/分享带出去。
-    history.replaceState(null, '', location.pathname);
-  }
+  /**
+   * 地址里那一枚令牌**只是入场那一下**（2026-10-16 第二步）。
+   *
+   * 服务端在上面那一次请求里已经把它换成了设备凭据（HttpOnly cookie，浏览器自己带），
+   * 页面从此不读它、不存它、也不再往任何请求里放它。这里只做一件事：把地址栏擦干净，
+   * 免得被截图/分享带出去。
+   */
+  if (params.get('token')) history.replaceState(null, '', location.pathname);
 
   /**
    * ---------------- 执行轨迹：订阅与收帧（数据层） ----------------
@@ -2293,7 +2487,7 @@
    * 读不到就把原因写出来，不说「没有过程」。
    */
   function requestTrajectory() {
-    if (state.mode !== 'full' || !state.token) return;
+    if (state.mode !== 'full' || !state.entered) return;
     var sessionId = state.boundSessionId;
     if (!sessionId) {
       state.trajectory = [];
@@ -2327,7 +2521,7 @@
    *   重连成功与否都不用在这里补救——`open` 里那一套会再走一遍。
    */
   function syncTrajectorySubscription() {
-    if (!state.token) return;
+    if (!state.entered) return;
     var want = state.mode === 'full';
     if (!want) {
       if (subscribedClientId) {
@@ -2401,8 +2595,8 @@
     var name = src.replace(/\\/g, '/').replace(/^\.\//, '');
     if (/^lib\/art\//i.test(name)) name = name.slice(8);
     if (/^[a-z0-9-]+(\.webp)?$/i.test(name)) return artUrl(name.replace(/(\.webp)?$/i, ''));
-    return '/mini/art/?p=' + encodeURIComponent(src)
-      + '&token=' + encodeURIComponent(state.token);
+    // **不拼令牌**：这条路和别的接口一样，靠浏览器自动带上的设备 cookie 认人。
+    return '/mini/art/?p=' + encodeURIComponent(src);
   }
 
   function mdInline(raw) {
@@ -2612,14 +2806,59 @@
   function toast(msg) {
     var el = $('toast');
     el.textContent = msg;
+    // 普通提示**一定是纯字**：上一版如果带着「撤销」那颗按钮，这里要把它连同
+    // with-act 一起收掉，否则会留下一个按了没反应的按钮（它的回调早就过期了）。
+    el.classList.remove('with-act');
     el.classList.add('show');
     clearTimeout(toastTimer);
     toastTimer = setTimeout(function () { el.classList.remove('show'); }, 1800);
   }
+
+  /**
+   * 带一个动作的提示。目前只有一处用：归档成功后的「撤销」。
+   *
+   * 为什么单独一个函数、而不是给 toast 加参数：普通提示是**纯字、点不中**的
+   * （见 #toast 的 pointer-events），带动作就得反过来——两种形状差别够大，
+   * 混在一个函数里迟早会让某一条普通提示也莫名其妙能点。
+   *
+   * 停留 6 秒：短于这个数，用户看到"归档了"再去找按钮就已经没了；长于这个数，
+   * 它会一直压着输入区上方那块地方。
+   */
+  function toastAction(msg, label, onTap) {
+    var el = $('toast');
+    el.textContent = '';
+    var text = document.createElement('span');
+    text.textContent = msg;
+    el.appendChild(text);
+    var btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = 'toast-act';
+    btn.textContent = label;
+    btn.addEventListener('click', function () {
+      el.classList.remove('show');
+      el.classList.remove('with-act');
+      clearTimeout(toastTimer);
+      onTap();
+    });
+    el.appendChild(btn);
+    el.classList.add('with-act');
+    el.classList.add('show');
+    clearTimeout(toastTimer);
+    toastTimer = setTimeout(function () {
+      el.classList.remove('show');
+      // 收掉的时候把 with-act 一起收：光藏起来的话，那层透明的提示仍然接着点击。
+      setTimeout(function () { el.classList.remove('with-act'); }, 220);
+    }, 6000);
+  }
+  /**
+   * 每一趟请求带什么头。
+   *
+   * **一个凭据都不带**（2026-10-16 第二步）：进门那一下服务端已经把身份换成了设备 cookie
+   * （HttpOnly），浏览器自己会给同源的每一趟请求带上它——请求头和地址里从此不再出现令牌。
+   * 这也是「名册里删掉那条记录 = 那台设备当场什么都做不了」能成立的前提。
+   */
   function authHeaders(isJson) {
-    return isJson === false
-      ? { 'X-Mini-Token': state.token }
-      : { 'Content-Type': 'application/json', 'X-Mini-Token': state.token };
+    return isJson === false ? {} : { 'Content-Type': 'application/json' };
   }
   function api(path, options) {
     var opts = options || {};
@@ -2635,6 +2874,9 @@
           // 状态码挂在错上带出去：调用方要区分「服务端说这题已经结束了」（409）和
           // 「压根没连上」（fetch 直接抛）——靠中文字面去猜太脆。
           err.status = r.status;
+          // 整个响应体也挂上。归档那条要**读里面的 activity**（会停掉哪些工作）才能
+          // 弹确认框——只靠状态码看不出"还有工作在跑"和"工作区服务拿不到"的区别。
+          err.body = body;
           throw err;
         }
         return body;
@@ -2819,10 +3061,12 @@
     return out;
   }
 
-  /** 立绘地址。走 query 而不是靠 cookie：从门禁页手输 token 进来时是没有 cookie 的。 */
+  /**
+   * 立绘地址。**不带令牌**（2026-10-16 第二步）：进门之后浏览器手里有设备 cookie，
+   * 同源的 <img> 自己会带上它。指纹照旧——换了图浏览器不会一直用缓存那张。
+   */
   function artUrl(file) {
-    return '/mini/art/' + file + '.webp?token=' + encodeURIComponent(state.token)
-      + '&v=' + encodeURIComponent(BUILD);
+    return '/mini/art/' + file + '.webp?v=' + encodeURIComponent(BUILD);
   }
 
   /**
@@ -3674,6 +3918,33 @@
    */
   var pinnedAnswerKey = '';
 
+  /**
+   * 这一轮**助手侧内容的第一块**：从最后那条回答往回退，只跨紧挨着它的过程组
+   * 与轨迹说明（trajInterleave 把组插在**该轮第一个回答之前**，见那里的落点 a），
+   * 退不动就停在哪儿。
+   *
+   * 为什么「完整」模式要多退这一步：用户 2026-10-08 报的——单帧和聊天停在回答的开头
+   * 是对的，完整模式照做就错了。回答前面还有这一轮的执行轨迹，把回答的开头顶到屏幕
+   * 最上沿，等于把那串过程整个推到屏幕上方：他落定那一刻看到的不是这一轮的开头，
+   * 而是轨迹的尾巴接着正文。停在这一轮的头上，才是从他要读的地方读起。
+   *
+   * **用户自己发的那条指令不算**：他刚敲过，不用再读一遍；要读的是助手这一侧。
+   * 所以往回走只认过程组和那句「这份轨迹不是全部」的说明，碰到别的节点
+   * （`.bubble.user`、`.cmd`、子智能体卡片、页面上那几条说明）就停——一轮的边界
+   * 本来就在那儿。这也顺带保证了**这一轮没有过程**时原样返回那条回答：完整模式
+   * 退化成聊天模式的样子，不会跑到上一轮的轨迹上去。
+   */
+  function trajRunHead(saidEl) {
+    var node = saidEl;
+    for (;;) {
+      var prev = node.previousElementSibling;
+      if (!prev || !prev.classList) break;
+      if (!prev.classList.contains('traj-group') && !prev.classList.contains('traj-note')) break;
+      node = prev;
+    }
+    return node;
+  }
+
   /**
    * 聊天模式的滚动：**回答的开头才是要读的地方，不是末尾。**
    *
@@ -3690,7 +3961,8 @@
    *     就被拽回末尾，等于没改。
    *
    *   · **落定**（timestamp 变了）——对齐最后那条 `.said` 的开头，
-   *     让最终版从第一行开始读。
+   *     让最终版从第一行开始读。（**完整**模式再往前退到这一轮的头上，
+   *     理由见 trajRunHead：那一轮的过程组就排在回答前面。）
    *
    * 为什么要记 key、而不是「每次都对齐」：用户往下读的时候，每次重画都把他拽回
    * 开头，比不对齐还烦人。这一点和单帧模式里 scrolledReplyAt 的道理是一样的。
@@ -3719,6 +3991,9 @@
       } else if (replyEl.querySelectorAll) {
         var saids = replyEl.querySelectorAll('.said');
         target = saids.length ? saids[saids.length - 1] : null;
+        // 「完整」模式要停的是**这一轮的头上**，不是这条回答的头上（见 trajRunHead）。
+        // 「正在流」那一路不对齐这里：用户看的就是刚流出来的那段本身。
+        if (target && state.mode === 'full') target = trajRunHead(target);
       }
       pinToTop(target);
       return;
@@ -4377,6 +4652,46 @@
   var navPresets = null;   // Agent 模式清单（2026-10-04：新建会话时手机上也要能选模式）
   var navPresetsLoaded = false;
   var navPickerWs = '';    // 正在挑模式的那个工作区（清单行内展开在它的「新建会话」下）
+  // —— 会话条目的执行功能（2026-10-09）——
+  /**
+   * 「显示已归档」这枚筛选开关**摆在界面外**：用户 2026-10-09 要求——这个功能不需要，
+   * 但既然做了，先别删、隐藏起来。
+   *
+   * 所以下面这一整套**一行都没删**，只是不再画到界面上：开关的渲染（renderNav 里
+   * 那一段还在）、navShowArchived 这个状态、setShowArchived、拼请求时的 archived=1、
+   * 服务端那条筛选口径、以及相关测试。
+   *
+   * **要恢复这个开关：把这一行的 false 改成 true 就行**，别的地方一处都不用动。
+   */
+  var SHOW_ARCHIVED_FILTER = false;
+  /**
+   * 「另有 N 条已归档、M 条还是空白的新会话」这句**也不摆到界面上**：
+   * 用户 2026-10-09 要求——这句不需要显示，先不删、隐藏起来。
+   *
+   * 所以那句话的渲染、以及支撑它的两个数（hiddenArchived / hiddenBlank，服务端照旧在算、
+   * 照旧随列表一起回来）**一行都没删**，只是不再画出来。
+   * 注意闸住的**只是这半句**：同一块里前面那句「这个工作区里没有能列出来的会话。」
+   * 照旧摆着——那是"会话全被筛掉了"这个情形的兜底文字，一起藏掉的话，
+   * 工作区标题下面就是一片空白，用户会以为界面坏了。
+   *
+   * **要恢复这句话：把下面这一行的 false 改成 true 就行**，别的地方一处都不用动。
+   */
+  var SHOW_NAV_COUNT_HINT = false;
+  var navShowArchived = false; // 筛选：默认**隐藏已归档**（官方默认项就是这个）
+  var navActing = '';      // 正在行内展开动作条的那条会话 id
+  var navRenaming = '';    // 正在改名字的那条会话 id
+  var navConfirm = null;   // 归档确认：{ sessionId, title, activity }；非空就是弹着
+  var navExtra = {};       // workspaceId -> 已经点了几次「展开其余」
+  var navLimit = {};       // workspaceId -> 这次向服务端要了多少条（要更多时递增）
+
+  /**
+   * 「展开其余」一次多几条。**这个 5 是官方口径**，不是我们挑的：
+   * PC 侧栏的文档原话是「默认只显示 5 条空闲 Session……每次点击『展开其余』最多再显示五条」。
+   * 正在跑的会话不占这 5 条配额，始终显示——同一个来源。
+   */
+  var NAV_IDLE_QUOTA = 5;
+  /** 一次向服务端要多少条。要少了「展开其余」很快就没得展开；要多了标题那一步很贵。 */
+  var NAV_PAGE = 20;
 
   function openNav() {
     $('nav').classList.add('open');
@@ -4417,7 +4732,7 @@
   function prefetchWorkspaces() {
     // Agent 模式清单也是导航栏要用的、也几乎不变——顺手一起预取（见 prefetchPresets）。
     prefetchPresets();
-    if (navList || navPrefetchPromise || navView !== 'tree' || !state.token) return;
+    if (navList || navPrefetchPromise || navView !== 'tree' || !state.entered) return;
     var run = function () {
       navPrefetchPromise = api('/mini/api/workspaces').then(function (body) {
         navList = body.workspaces || [];
@@ -4441,7 +4756,7 @@
    * **不摆一个只有一项的选择题**，也不假装自己知道 DSH 有哪些模式。
    */
   function prefetchPresets() {
-    if (navPresetsLoaded || !state.token) return;
+    if (navPresetsLoaded || !state.entered) return;
     navPresetsLoaded = true;
     api('/mini/api/agent-presets').then(function (body) {
       navPresets = body && body.ok ? body : { ok: false, reason: (body && body.reason) || 'failed' };
@@ -4472,12 +4787,24 @@
     // 「新建工作区」常驻在最上面：它是这一屏的入口，不该等有了会话才出现——
     // 一个工作区都还没有的人，恰恰最需要它。
     var cta = '<button class="nav-cta" type="button" data-new-ws="1">＋ 新建工作区</button>';
+    // 「显示已归档」是**整屏一个**的口径，所以放在 CTA 下面、工作区上面：
+    // 它管的不是某一个工作区，是所有工作区里"已归档的那些要不要出现"。
+    // 默认关（官方的默认项就是"隐藏已归档"）。
+    //
+    // 整块由 SHOW_ARCHIVED_FILTER 闸住（见那个常量上的说明）：闸住时这一段一个字都不画，
+    // **但渲染代码原样留着**——恢复就是改那一个词，不用重写。
+    var filter = SHOW_ARCHIVED_FILTER
+      ? '<button class="nav-filter' + (navShowArchived ? ' on' : '')
+        + '" type="button" data-archived-toggle="1" aria-pressed="' + (navShowArchived ? 'true' : 'false')
+        + '">' + (navShowArchived ? '✓ ' : '')
+        + (navShowArchived ? '显示已归档（点一下收起来）' : '显示已归档') + '</button>'
+      : '';
     if (!list.length) {
-      $('navBody').innerHTML = cta + '<div class="placeholder">电脑上还没有可以切换的会话。<br>'
+      $('navBody').innerHTML = cta + filter + '<div class="placeholder">电脑上还没有可以切换的会话。<br>'
         + '在电脑上开一个，这里就会出现了。</div>';
       return;
     }
-    $('navBody').innerHTML = cta + list.map(function (ws) {
+    $('navBody').innerHTML = cta + filter + list.map(function (ws) {
       var open = Boolean(navExpanded[ws.id]);
       return '<div class="ws' + (open ? ' open' : '') + '" data-ws="' + escapeHtml(ws.id) + '">'
         + '<button class="ws-head" type="button">'
@@ -4493,6 +4820,76 @@
     }).join('');
   }
 
+  /** 这个工作区现在到底该摆出哪几条。**口径都在这里，一处说了算。** */
+  function navVisible(wsId, got) {
+    var ex = navExtra[wsId] || 0;
+    var quota = NAV_IDLE_QUOTA * (ex + 1);
+    var rows = [];
+    var idleShown = 0;
+    var idleTotal = 0;
+    (got.sessions || []).forEach(function (s) {
+      if (s.running === true) { rows.push(s); return; }
+      idleTotal += 1;
+      if (idleShown < quota) { rows.push(s); idleShown += 1; }
+    });
+    var remaining = Math.max(0, idleTotal - idleShown);
+    return {
+      rows: rows,
+      quota: quota,
+      // 页里还有没摆出来的，或者服务端说这个工作区还有没取回来的——两种都算"还有"
+      more: remaining > 0 || got.truncated === true,
+      remaining: remaining,
+      expandable: remaining > 0 || got.truncated === true,
+      // 按钮上那个数：官方口径是"每次最多再显示五条"，所以最多写 5。
+      step: remaining > 0 ? Math.min(NAV_IDLE_QUOTA, remaining) : NAV_IDLE_QUOTA,
+      collapsed: ex > 0 && !(remaining > 0 || got.truncated === true),
+    };
+  }
+
+  /** 一条会话在行尾该显示什么。**一行只显示一个**：尾部那块地方只够一样。 */
+  function navTail(s) {
+    if (s.pending === 'approval') return '<span class="s-flag pending">待审批</span>';
+    if (s.pending === 'plan') return '<span class="s-flag pending">计划待审</span>';
+    if (s.pending === 'question') return '<span class="s-flag pending">待回答</span>';
+    var badge = '';
+    if (s.archived) badge = '<span class="s-flag">已归档</span>';
+    else if (s.pinned) badge = '<span class="s-flag">已置顶</span>';
+    return badge + '<span class="s-meta">' + dayLabel(s.createdAt) + '</span>';
+  }
+
+  /**
+   * 动作条。**归档行不给置顶**——官方规定归档与置顶互斥（归档会把置顶一并丢掉），
+   * 摆一个按了会被拒的按钮，比不摆更糟。
+   *
+   * 顺序照电脑端的槽位号摆（2026-10-09 从 0.2.0-rc.2 的 `dsh-client-ui-workspace` 读到原文）：
+   * `sidebar.workspaces.session.menu.item` 上 pin=order 100、rename=200、**fork=300**、
+   * archive=400。手机这一条横排也是一样的先后，用户从电脑换到手机上不用重新找。
+   *
+   * 分叉这一项**归档行也留着**：官方的菜单项没有"归档就不给分叉"这条判断
+   * （只有 pin 那一个在归档行上返回 null），而且分叉出来的是一条独立的新会话。
+   */
+  function navActs(s) {
+    var id = escapeHtml(s.id);
+    var pin = s.archived
+      ? ''
+      : '<button type="button" data-act="pin" data-act-id="' + id + '" data-act-on="'
+        + (s.pinned ? '1' : '0') + '">' + (s.pinned ? '取消置顶' : '置顶会话') + '</button>';
+    var arc = s.archived
+      ? '<button type="button" data-act="unarchive" data-act-id="' + id + '">取消归档</button>'
+      : '<button type="button" class="danger" data-act="archive" data-act-id="' + id + '">归档会话</button>';
+    return '<div class="sess-acts">'
+      + pin
+      + '<button type="button" data-act="rename" data-act-id="' + id + '">重命名</button>'
+      + '<button type="button" data-act="fork" data-act-id="' + id + '">分叉会话</button>'
+      + arc
+      + '</div>'
+      // 「分叉」是个电脑词，非技术用户看不出它会干什么。这句是**极短的说明**：
+      // 只说两件事——从哪儿分（最近完成的一轮）、原会话会怎样（不动）。
+      // 不加的话，用户能猜到的只有"分叉"两个字，而按下去是**在电脑上真建一个会话**，
+      // 不是可以随便试的手势，所以这笔字值得花。
+      + '<div class="sess-acts-hint">分叉＝从最近完成的一轮复制出一个新会话，原来这条不动。</div>';
+  }
+
   function sessionsHtml(wsId) {
     // 「新建会话」永远排在最上面：不管这个工作区有几个会话、甚至一个都没有，
     // 这一行都在。放在列表末尾的话，一个 452 条会话的工作区要划到底才看得到。
@@ -4516,25 +4913,341 @@
     }
     var got = navSessions[wsId];
     if (!got) return html + '<div class="placeholder">正在读取…</div>';
-    if (!got.sessions.length) return html + '<div class="placeholder">这个工作区还没有会话。</div>';
+    if (!got.sessions.length) {
+      // 「一条都没有」和「都被筛掉了」是两件事，得分开说——不然用户会以为
+      // 自己的会话不见了（就在刚才，那还是他亲手归档的）。
+      var hid = (got.hiddenArchived || 0) + (got.hiddenBlank || 0);
+      if (hid > 0) {
+        // 后半句（那两条条数）由 SHOW_NAV_COUNT_HINT 闸住（见那个常量上的说明）：
+        // 闸住时只少这半句，**前面那句兜底照旧画**——全都不画就成了工作区标题下面
+        // 一片空白，用户只会以为界面坏了。恢复就是改那一个词。
+        var hint = SHOW_NAV_COUNT_HINT
+          ? '<br>另有 ' + (got.hiddenArchived || 0) + ' 条已归档、'
+            + (got.hiddenBlank || 0) + ' 条还是空白的新会话。'
+          : '';
+        return html + '<div class="placeholder">这个工作区里没有能列出来的会话。'
+          + hint + '</div>';
+      }
+      return html + '<div class="placeholder">这个工作区还没有会话。</div>';
+    }
     var cur = state.boundSessionId;
-    html += got.sessions.map(function (s) {
-      // 没有标题就用日期——原来退到取 id 的前 8 位当名字，而本机真有一个会话的 id
-      // 以「session-」开头，于是整列都显示成一样的「session-」，等于没有名字。
-      return '<button class="sess' + (s.id === cur ? ' cur' : '') + '" type="button"'
+    var view = navVisible(wsId, got);
+    html += view.rows.map(function (s) {
+      var cls = 'sess';
+      if (s.id === cur) cls += ' cur';
+      // 已归档的行置灰，而且**点不开**——官方原话是「已归档对话暂时无法查看，
+      // 请取消归档后查看」。留着可点会是更坏的结果：点进去是一个空会话。
+      if (s.archived) cls += ' archived';
+      if (navActing === s.id) cls += ' acting';
+      if (navRenaming === s.id) cls += ' renaming';
+      // 行首那颗点：**有等着的就显示等着的**（照 PC：「待处理交互的优先级高于
+      // 共享 ongoing loading」）；没有等着才轮到"正在跑"。
+      var dot = s.pending
+        ? '<span class="s-dot pending"></span>'
+        : (s.running ? '<span class="s-dot"></span>' : '');
+      var row = '<div class="sess-line">'
+        + '<button class="' + cls + '" type="button"'
         + ' data-sess="' + escapeHtml(s.id) + '">'
-        + (s.running ? '<span class="s-dot"></span>' : '')
+        + dot
+        // 没有标题就用日期——原来退到取 id 的前 8 位当名字，而本机真有一个会话的 id
+        // 以「session-」开头，于是整列都显示成一样的「session-」，等于没有名字。
         + '<span class="s-title">' + escapeHtml(s.title || '未命名会话') + '</span>'
-        + '<span class="s-meta">' + dayLabel(s.createdAt) + '</span>'
-        + '</button>';
+        + navTail(s)
+        + '</button>'
+        // ⋯ 是**兄弟**不是子节点：塞进那个 button 里就成了"按钮里套按钮"，
+        // 点它会同时触发"打开会话"，而且那种结构本身是无效的。
+        + '<button class="s-more" type="button" aria-label="会话操作"'
+        + ' data-more-menu="' + escapeHtml(s.id) + '">⋯</button>'
+        + '</div>';
+      if (navActing === s.id) row += navActs(s);
+      if (navRenaming === s.id) {
+        row += '<div class="sess-rename">'
+          // 预填的是**真实标题**（没有就是空的），绝不是「未命名会话」那个显示占位——
+          // 把占位当标题提交，就等于凭空把"未命名"三个字钉成一个真标题。
+          + '<input id="renameInput" type="text" value="' + escapeHtml(s.title || '')
+          + '" placeholder="给这个会话起个名字" aria-label="会话标题">'
+          + '<button type="button" data-rename-cancel="1">取消</button>'
+          + '<button type="button" data-rename-ok="1">确定</button>'
+          + '</div>';
+      }
+      return row;
     }).join('');
-    if (got.truncated) {
-      html += '<div class="nav-note">只列了最近 ' + got.sessions.length + ' 条，共 '
-        + got.total + ' 条。</div>';
+    // 「展开其余 N 个 / 收起」。**这里原来是一句死话**（「只列了最近 N 条，共 M 条」），
+    // 展不开也搜不了，用户只能去电脑上找。现在按官方口径真的展开。
+    if (view.expandable) {
+      html += '<button class="sess-more" type="button" data-more="' + escapeHtml(wsId) + '">'
+        + '展开其余 ' + view.step + ' 个</button>';
+    } else if (view.collapsed) {
+      html += '<button class="sess-more" type="button" data-less="' + escapeHtml(wsId) + '">收起</button>';
     }
     return html;
   }
 
+  /**
+   * 会话列表里的一条（拿真实数据用，比如"当前标题是什么"）。
+   * 找不到返回 null——调用方据此如实说"刷新一下再看看"，而不是凭空造一个。
+   */
+  function navSessionById(id) {
+    var keys = Object.keys(navSessions);
+    for (var i = 0; i < keys.length; i++) {
+      var got = navSessions[keys[i]];
+      var list = (got && got.sessions) || [];
+      for (var j = 0; j < list.length; j++) {
+        if (list[j].id === id) return { wsId: keys[i], row: list[j], got: got };
+      }
+    }
+    return null;
+  }
+
+  function toggleActs(id) {
+    navRenaming = '';
+    navActing = navActing === id ? '' : id;
+    renderNav();
+  }
+
+  function startRename(id) {
+    navActing = '';
+    navRenaming = id;
+    renderNav();
+    // 光标落在末尾：用户多半是想改几个字，不是想全部重打。
+    var input = $('renameInput');
+    if (input && input.focus) {
+      try { input.focus(); input.setSelectionRange(input.value.length, input.value.length); } catch (e) {}
+    }
+  }
+
+  /**
+   * 提交改名。
+   *
+   * **这一步就是"不误钉"的全部**：官方 `SessionTitleService.rename` 的原文是
+   * 「Appends a `session/title` event with the `user` source, which **pins** the title:
+   * in-flight automatic generation is superseded and later user messages schedule none」
+   * ——也就是说**传什么都会钉住**，哪怕跟当前那条自动标题一字不差。
+   * 所以"没改"就**根本不发这一趟**（用户双击进来又原样退出的情形很常见）。
+   */
+  function renameSubmit() {
+    var id = navRenaming;
+    var found = navSessionById(id);
+    if (!found) { navRenaming = ''; renderNav(); toast('这个会话不在了，刷新一下再看看'); return; }
+    var input = $('renameInput');
+    var next = input ? input.value : '';
+    var current = typeof found.row.title === 'string' ? found.row.title : '';
+    // 只比"归一化之后"的那一份（去空白）。官方那边也会 trim，比原始串会把
+    // "结尾多了一个空格"当成真改动，那正是要避开的误钉。
+    if (next.trim() === current.trim()) {
+      navRenaming = '';
+      renderNav();
+      return;
+    }
+    if (!next.trim()) { toast('标题不能为空'); return; }
+    return api('/mini/api/session/rename', {
+      method: 'POST',
+      body: JSON.stringify({ sessionId: id, title: next }),
+    }).then(function (res) {
+      navRenaming = '';
+      // 用**服务端接受的那一份**改本地这一行：官方会归一化（去控制字符、按字节截断），
+      // 界面要显示的是它认下来的那个标题，不是我们递过去的那串。
+      found.row.title = res && typeof res.title === 'string' ? res.title : next;
+      renderNav();
+      toast('已改名');
+    }).catch(function (err) { toast(err.message); });
+  }
+
+  /**
+   * 分叉会话。电脑端那个功能在手机上等价的一下：在**最后一个已完成轮次**处复制出
+   * 一个新会话，标题递增。
+   *
+   * 三件事照电脑端的原样，一件都不能走样：
+   *   · **不打开新会话**：PC 那条路上 `navigation.forkSession()` 之后就结束了，
+   *     没有任何切换动作。所以这里也**一个字都不碰 `state.boundSessionId`**。
+   *   · **成功后刷新列表**：新会话是 PC 侧栏那种"排在源会话旁边"的普通行，得重新问一次
+   *     服务端才看得见。而且必须带 `refresh=1`——服务端那份会话清册有 30 秒缓存，
+   *     不绕过的话用户会看到"按了但什么都没多出来"（刚建的会话它还答不上来）。
+   *   · **失败时说 Host 那句话**：`err.message` 就是服务端转发过来的原话
+   *     （"没有已结束的轮次"那一种带上 Host 的英文原文），这里**不加工、不换词**。
+   */
+  function forkAct(id) {
+    return api('/mini/api/session/fork', {
+      method: 'POST',
+      body: JSON.stringify({ sessionId: id }),
+    }).then(function (res) {
+      navActing = '';
+      var found = navSessionById(id);
+      refreshSessions(found ? found.wsId : '', true);
+      // 把新标题报出来：手机列表可能很长，"多了一条"这句话不如"多了一条叫什么"有用，
+      // 标题里那个 (1) 也正是"它是刚才那条分出来的"最直接的凭据。
+      toast(res && res.title ? '已分叉出「' + res.title + '」' : '已分叉出新会话');
+    }).catch(function (err) { toast(err.message); });
+  }
+
+  /** 置顶 / 取消置顶。*/
+  function pinAct(id, on) {
+    return api('/mini/api/session/pin', {
+      method: 'POST',
+      body: JSON.stringify({ sessionId: id, pinned: on }),
+    }).then(function () {
+      var found = navSessionById(id);
+      if (found) found.row.pinned = on;
+      // 置顶会改整个列表的顺序，所以这次要重新问一遍服务端（别自己在本地排——
+      // 官方的置顶顺序是"最近置顶的在前"，本地排不出那个顺序）。
+      refreshSessions(found ? found.wsId : '');
+      navActing = '';
+      toast(on ? '已置顶' : '已取消置顶');
+    }).catch(function (err) { toast(err.message); });
+  }
+
+  /**
+   * 归档 / 取消归档。
+   *
+   * `stop` 那一次往返是**官方那条两段式流程**：不带它，会话还有工作在跑时服务端会拒绝，
+   * 同时把"会停掉什么"按族带回来（见 lib/index.js 的 archiveSession）。
+   * 拿到那一份就弹确认框问过用户再来一次——**不自己猜会停掉什么**。
+   */
+  function archiveAct(id, stop) {
+    return api('/mini/api/session/archive', {
+      method: 'POST',
+      body: JSON.stringify({ sessionId: id, stop: stop === true }),
+    }).then(function () {
+      // **先把确认框收掉**，再动别的。漏了这一句的后果实测过：那一层是
+      // fixed/inset:0，z-index 120——归档成功之后它仍然盖在整屏上，
+      // 用户接下来点哪儿都是点到它（点哪儿都当成"取消"，什么都没发生）。
+      navConfirm = null;
+      renderNavConfirm();
+      navActing = '';
+      var found = navSessionById(id);
+      if (found) { found.row.archived = true; found.row.pinned = false; }
+      refreshSessions(found ? found.wsId : '');
+      toastAction('会话已归档', '撤销', function () {
+        api('/mini/api/session/unarchive', {
+          method: 'POST', body: JSON.stringify({ sessionId: id }),
+        }).then(function () {
+          var f = navSessionById(id);
+          if (f) f.row.archived = false;
+          refreshSessions(f ? f.wsId : '');
+          toast('已取消归档');
+        }).catch(function (err) { toast(err.message); });
+      });
+    }).catch(function (err) {
+      var body = err && err.body;
+      if (err && err.status === 409 && body && body.reason === 'active') {
+        var found = navSessionById(id);
+        navConfirm = {
+          sessionId: id,
+          title: (found && found.row.title) || '',
+          wsId: found ? found.wsId : '',
+          activity: Array.isArray(body.activity) ? body.activity : [],
+        };
+        renderNavConfirm();
+        return;
+      }
+      toast(err.message);
+    });
+  }
+
+  /** 取消归档。说明里那句"不恢复置顶"是官方的规矩，如实说。 */
+  function unarchiveAct(id) {
+    return api('/mini/api/session/unarchive', {
+      method: 'POST', body: JSON.stringify({ sessionId: id }),
+    }).then(function () {
+      navActing = '';
+      var found = navSessionById(id);
+      if (found) found.row.archived = false;
+      refreshSessions(found ? found.wsId : '');
+      toast('已取消归档');
+    }).catch(function (err) { toast(err.message); });
+  }
+
+  /**
+   * 官方那四族工作的中文说法。**四种一一对应，不多不少**——`kind` 是从
+   * `SessionActivityKindMap`（turn / job / subagent / schedule）来的，认不出的
+   * 如实写它的原名，不硬套一个近义词。
+   */
+  var ACTIVITY_COPY = {
+    turn: '进行中的回合',
+    job: '后台任务',
+    subagent: '运行中的子智能体',
+    schedule: '定时提醒',
+  };
+
+  function renderNavConfirm() {
+    var el = $('navConfirm');
+    if (!el) return;
+    if (!navConfirm) { el.classList.remove('on'); return; }
+    $('navConfirmDesc').textContent = '「' + (navConfirm.title || '这个会话')
+      + '」还有正在进行的工作。归档会先停止这些工作；被停止的工作不会自动继续。'
+      + '归档之后它就不在列表里了，接下来 6 秒里可以点提示上的「撤销」把它找回来；'
+      + '过了这几秒，就得到电脑端才能取消归档。';
+    var items = (navConfirm.activity || []).map(function (fam) {
+      var name = ACTIVITY_COPY[fam.kind] || fam.kind;
+      var labels = (fam.items || []).map(function (it) {
+        return escapeHtml(it.label || it.id || '（没有名字）');
+      });
+      var head = '<b>' + escapeHtml(name) + '</b>：';
+      // 一项一项列出来；带不下就如实说"共 N 项"，不假装只有这几项。
+      var detail = labels.length ? labels.join('、') : '（没有名字）';
+      var more = fam.count > labels.length ? '（共 ' + fam.count + ' 项）' : '';
+      return '<li>' + head + detail + more + '</li>';
+    }).join('');
+    $('navConfirmList').innerHTML = items || '<li>（没能问出具体是哪几项工作）</li>';
+    el.classList.add('on');
+  }
+
+  /**
+   * 重新问一遍某个工作区的会话（置顶/归档之后顺序和状态都变了）。
+   *
+   * `force` 是给**分叉**用的：会话清册在服务端有 30 秒缓存，而分叉是"多出来一条"，
+   * 缓存里根本没有它。不带 force 的那几处（置顶/归档）只要状态和顺序，缓存那份就够。
+   *
+   * **`loadWsSessions` 必须排在 `renderNav` 前面**（2026-10-09 活页面验证逮住的）：
+   * renderNav 自己会给每个展开着的工作区起一趟 `loadWsSessions(id)`（**不带 force**），
+   * 而那一趟会先把 `navWsFetching` 占住——后面这一趟带 force 的就被那道闩挡在门外，
+   * 结果新会话压根没被取回来（界面看着像"按了没反应"）。先起带 force 的这一趟，
+   * renderNav 顺手起的那一趟自然就被同一道闩挡掉了。
+   */
+  function refreshSessions(wsId, force) {
+    if (!wsId) { loadWorkspaces(true); return; }
+    delete navSessions[wsId];
+    delete navWsFetching[wsId];
+    loadWsSessions(wsId, force);
+    renderNav();
+  }
+
+  /** 「展开其余」：页里还有就只是多摆几条；页里没了就去服务端多要一批。 */
+  function expandMore(wsId) {
+    var got = navSessions[wsId];
+    var view = got ? navVisible(wsId, got) : null;
+    if (view && view.remaining > 0) {
+      navExtra[wsId] = (navExtra[wsId] || 0) + 1;
+      renderNav();
+      return;
+    }
+    // 页里已经摆完了，但服务端说这个工作区还有没取回来的：把这次要的条数翻上去。
+    navExtra[wsId] = (navExtra[wsId] || 0) + 1;
+    navLimit[wsId] = Math.min(100, (navLimit[wsId] || NAV_PAGE) + NAV_PAGE * 2);
+    delete navSessions[wsId];
+    delete navWsFetching[wsId];
+    loadWsSessions(wsId);
+  }
+
+  function collapseMore(wsId) {
+    navExtra[wsId] = 0;
+    renderNav();
+  }
+
+  // 筛选一改，所有工作区那份数据就都不作数了（服务端按筛选给的是不同的列表）。
+  // **展开次数也一起归零**：换了口径还停在"展开了 3 页"，用户会莫名其妙的。
+  function setShowArchived(on) {
+    navShowArchived = on === true;
+    navSessions = {};
+    navExtra = {};
+    navLimit = {};
+    navActing = '';
+    navRenaming = '';
+    Object.keys(navFollowTimers).forEach(function (id) { clearTimeout(navFollowTimers[id]); });
+    navFollowTimers = {};
+    renderNav();
+  }
+
   // ---------------- 新建工作区：浏览电脑目录 ----------------
   //
   // 面板里有两个「屏」：工作区树（默认）和目录浏览。用一个变量记当前在哪一屏，
@@ -4762,10 +5475,11 @@
   // navWsFetching 这道闩让同一工作区同时只有一趟在飞，别重复付读日志折标题的钱。
   // 15 秒兜底解锁是给「请求永远不回来」留的——闩本身不能变成新的卡死点，
   // 超过 15 秒就放行，让下一次渲染或点击还能再试（服务端有缓存，重发很便宜）。
-  function loadWsSessions(wsId) {
+  function loadWsSessions(wsId, force) {
     if (navSessions[wsId] || navWsFetching[wsId]) return;
     navWsFetching[wsId] = true;
     var bail = setTimeout(function () { delete navWsFetching[wsId]; }, 15000);
+    var sessionsUrl = sessionsUrlOf(wsId, force);
     /**
      * 接着问，直到服务端说「一条都不剩」。
      *
@@ -4781,7 +5495,7 @@
         delete navFollowTimers[wsId];
         // 用户收起了、或者这份数据已经被刷新换掉，就放手：别跟人抢。
         if (navSessions[wsId] !== cur || !navExpanded[wsId]) return;
-        api('/mini/api/workspaces/' + encodeURIComponent(wsId) + '/sessions')
+        api(sessionsUrlOf(wsId))
           .then(function (body) {
             if (navSessions[wsId] !== cur || !navExpanded[wsId]) return;
             navSessions[wsId] = body;
@@ -4793,7 +5507,7 @@
           });
       }, TITLE_FOLLOW_MS);
     }
-    api('/mini/api/workspaces/' + encodeURIComponent(wsId) + '/sessions')
+    api(sessionsUrl)
       .then(function (body) {
         clearTimeout(bail);
         navSessions[wsId] = body;
@@ -4810,6 +5524,23 @@
       });
   }
 
+  /**
+   * 取一个工作区会话列表的地址。三个参数都是**这次的口径**：
+   *   · `archived=1` 只在「显示已归档」打开时带——默认那一档是隐藏已归档（官方默认项）。
+   *   · `limit` 只在"要过更多"时才带，平时不带。**不带就还是原来那条地址**：
+   *     多带一个参数会让服务端每次都走一条不一样的路径，也没必要。
+   *   · `refresh=1` 只在**刚刚多出一条会话**（分叉）时才带：服务端那份清册有 30 秒缓存，
+   *     不绕过的话新会话不在里面。
+   */
+  function sessionsUrlOf(wsId, force) {
+    var url = '/mini/api/workspaces/' + encodeURIComponent(wsId) + '/sessions';
+    var parts = [];
+    if (navShowArchived) parts.push('archived=1');
+    if (navLimit[wsId]) parts.push('limit=' + navLimit[wsId]);
+    if (force) parts.push('refresh=1');
+    return parts.length ? url + '?' + parts.join('&') : url;
+  }
+
   // 防连点。建会话**不是幂等的**——点两下就在电脑上真建出两个会话来，
   // 而手机上什么都看不出来（第二个只是把列表撑长了一行）。所以这里必须自己拦。
   // 服务端那道闸门拦不住这个：两个请求都是合法的。
@@ -4887,6 +5618,33 @@
     });
   }
 
+  // 归档确认面板。**它自己带两个按钮，不走 navBody 那套委托**：
+  // 它在抽屉之外、是一整屏的浮层，混进列表的事件里只会让人以为它也是列表的一部分。
+  //
+  // 确认后**才**带 stop:true 重发——被停掉的工作不会自动继续，所以这一下必须是人按的。
+  $('navConfirm').addEventListener('click', function (e) {
+    var t = e.target;
+    if (t === $('navConfirm') || (t && t.closest && t.closest('[data-nc-cancel]'))) {
+      navConfirm = null;
+      renderNavConfirm();
+      return;
+    }
+    var ok = t && t.closest ? t.closest('[data-nc-ok]') : null;
+    if (!ok || !navConfirm) return;
+    // 按下去先禁掉：这一趟会在电脑上真停东西，连点两下没有第二件事可做。
+    ok.disabled = true;
+    archiveAct(navConfirm.sessionId, true);
+  });
+  // 改名那一行：手机键盘上是「回车」，桌面上是 Enter。不接这个键的话，
+  // 用户打完字的第一反应（回车）什么都不会发生。
+  $('navBody').addEventListener('keydown', function (e) {
+    if (e.key !== 'Enter') return;
+    var t = e.target;
+    if (!t || t.id !== 'renameInput') return;
+    e.preventDefault();
+    renameSubmit();
+  });
+
   $('btnNav').addEventListener('click', openNav);
   $('btnNavClose').addEventListener('click', closeNav);
   $('btnNavRefresh').addEventListener('click', function () { loadWorkspaces(true); });
@@ -4894,15 +5652,45 @@
 
   $('navBody').addEventListener('click', function (e) {
     var t = e.target;
+    var at = function (sel) { return t && t.closest ? t.closest(sel) : null; };
     var sess = t && t.closest ? t.closest('.sess') : null;
     if (sess) {
       // 目录浏览那一屏里的 .sess 是「进这个目录」，不是「切到这个会话」。
       // 两屏共用同一个条目样式，所以要先看当前在哪一屏。
       if (navView === 'browse') { browseTo(sess.getAttribute('data-browse-to')); return; }
+      // 已归档的**点不开**（官方原话：「已归档对话暂时无法查看，请取消归档后查看」）。
+      // 留着能点更坏：点进去是一个空会话，用户只会以为会话被清空了。
+      var bound = navSessionById(sess.getAttribute('data-sess'));
+      if (bound && bound.row.archived) {
+        toast('已归档的会话打不开，先取消归档');
+        return;
+      }
       bindSession(sess.getAttribute('data-sess'));
       return;
     }
-    var at = function (sel) { return t && t.closest ? t.closest(sel) : null; };
+
+    // —— 会话条目的执行入口（2026-10-09）。都排在下面那些之前，
+    //    因为它们都挂在会话那一行上，和「新建会话 / 展开工作区」不是一类。 ——
+    var menu = at('[data-more-menu]');
+    if (menu) { toggleActs(menu.getAttribute('data-more-menu')); return; }
+    var act = at('[data-act]');
+    if (act) {
+      var actId = act.getAttribute('data-act-id');
+      var which = act.getAttribute('data-act');
+      if (which === 'rename') startRename(actId);
+      else if (which === 'fork') forkAct(actId);
+      else if (which === 'pin') pinAct(actId, act.getAttribute('data-act-on') !== '1');
+      else if (which === 'archive') archiveAct(actId, false);
+      else if (which === 'unarchive') unarchiveAct(actId);
+      return;
+    }
+    if (at('[data-rename-cancel]')) { navRenaming = ''; renderNav(); return; }
+    if (at('[data-rename-ok]')) { renameSubmit(); return; }
+    var more = at('[data-more]');
+    if (more) { expandMore(more.getAttribute('data-more')); return; }
+    var less = at('[data-less]');
+    if (less) { collapseMore(less.getAttribute('data-less')); return; }
+    if (at('[data-archived-toggle]')) { setShowArchived(!navShowArchived); return; }
 
     var newWs = at('[data-new-ws]');
     if (newWs) { openBrowse(); return; }
@@ -4973,13 +5761,13 @@
   var es = null;
   function connect() {
     if (es) { try { es.close(); } catch (e) {} es = null; }
-    if (!state.token) { showGate(); return; }
+    if (!state.entered) { showGate(); return; }
     setStatus('', '连接中…');
     // clientId 每条连接都带（订阅的 POST 靠它认出这条流）；full=1 只在「完整」模式带，
     // 服务端见到就自动把这条连接订上轨迹——断线重连沿用同一个地址，重新订上由服务端
     // 自己完成，客户端不用再握手一次。
-    es = new EventSource('/mini/api/stream?token=' + encodeURIComponent(state.token)
-      + '&clientId=' + encodeURIComponent(clientId)
+    // **地址里不带令牌**（2026-10-16 第二步）：同源的 EventSource 会带上设备 cookie。
+    es = new EventSource('/mini/api/stream?clientId=' + encodeURIComponent(clientId)
       + (state.mode === 'full' ? '&full=1' : ''));
 
     es.addEventListener('open', function () {
@@ -5034,6 +5822,23 @@
       }
       if (navExpanded[payload.workspaceId] && navView === 'tree') renderNav();
     });
+    es.addEventListener('navigation-pending', function (e) {
+      // 谁在等人变了。**只就地换那几行的尾部标记**，不重绘整棵树——
+      // 重绘会把用户正在划的滚动位置弹回顶部（和 paintNavCurrent 同一条理由）。
+      var map;
+      try { map = JSON.parse(e.data); } catch (err) { return; }
+      if (!map || typeof map !== 'object') return;
+      var touched = false;
+      Object.keys(navSessions).forEach(function (wsId) {
+        var got = navSessions[wsId];
+        if (!got || !Array.isArray(got.sessions)) return;
+        got.sessions.forEach(function (s) {
+          var next = typeof map[s.id] === 'string' ? map[s.id] : null;
+          if (s.pending !== next) { s.pending = next; touched = true; }
+        });
+      });
+      if (touched && $('nav').classList.contains('open') && navView === 'tree') renderNav();
+    });
     es.addEventListener('subagent-metrics', function (e) {
       var payload;
       try { payload = JSON.parse(e.data); } catch (err) { return; }
@@ -6733,11 +7538,13 @@
    * 解析成 `/mini/`，在 `/mini/mirror/` 上才是 `/mini/mirror/`——差这一个字符，
    * 里面引用的脚本会全 404、界面白屏（真浏览器验出来的）。
    *
-   * 地址里带 token：框里那些请求不一定都带得上 cookie（这个框是新开的文档），
-   * 入口那一下顺手把 cookie 写上，之后就靠 cookie 认人了。
+   *
+   * **地址里不带令牌**（2026-10-16 第二步）：这个框是同源文档，设备 cookie 会自动跟着
+   * 它的每一条请求走（文档本身、静态资源、界面自己发的 `/api/*`），入口那一下不再需要
+   * 顺手写 cookie。上游收到的东西里一个字节的凭据都没有——第一步已经钉住。
    */
   function mirrorUrl() {
-    return '/mini/mirror/?token=' + encodeURIComponent(state.token || '');
+    return '/mini/mirror/';
   }
 
   /**
@@ -6766,6 +7573,9 @@
 
   function closeMirror() {
     $('mirrorView').hidden = true;
+    // 收起状态一起复位：下次进来从「看不见」开始（鼠标若正好停在顶上，
+    // 那一下 mousemove 会把它勾出来，见下面的接线）。
+    mirrorBarOff();
     // 把地址清掉：那一屏里是个完整应用（还在跑、还连着），关掉就该真停，
     // 而不是留在后台继续占内存和连接。
     $('mirrorFrame').src = 'about:blank';
@@ -6780,6 +7590,55 @@
   });
   $('mirrorClose').addEventListener('click', closeMirror);
 
+  /**
+   * 顶栏的「收 / 放」（2026-10-15 用户要的甲案：鼠标移到屏幕顶部才滑出来）。
+   *
+   * 为什么非要有那条 16px 感应带、为什么手机不走这一套：样式表里那一段说清了。
+   * 这里只说两件必须做对的事：
+   *
+   * ① **贴到顶上先停 0.18 秒再滑出**。鼠标路过顶边去点官方界面时（右上角那个
+   *    「打开右侧边栏」就在第 28px），不该把它勾出来；停这么一下就不会误触发。
+   *
+   * ② **「返回」永远可达**——它是唯一回手机页的出口，绝不能藏死：
+   *    · 鼠标碰到顶上 16px 就出来（滑出只是一次 0.18 秒的等待）；光标停在感应带上
+   *      不动也没关系：显示之后感应带还在最上面，鼠标一动就再勾一次；
+   *    · 键盘 Tab 停在「返回」上时也把它亮出来（下面 focus 那一条），
+   *      不留一个「焦点在这、按钮看不见」的坑；
+   *    · 滑出时横条**占自己的位置**、不盖在官方界面上，谁也挡不住它；
+   *    · 手机上它压根不藏（触摸没有悬停，藏了就等于摸不到）。
+   */
+  var mirrorHot = $('mirrorHot');
+  var mirrorBar = $('mirrorBar');
+  var barShowTimer = null;
+  var barHideTimer = null;
+
+  function mirrorBarOn() { $('mirrorView').classList.toggle('bar-on', true); }
+  function mirrorBarOff() { $('mirrorView').classList.toggle('bar-on', false); }
+
+  if (mirrorHot && mirrorBar && mirrorHot.addEventListener) {
+    function barScheduleShow() {
+      if (barShowTimer) return;
+      clearTimeout(barHideTimer);
+      barShowTimer = setTimeout(function () { barShowTimer = null; mirrorBarOn(); }, 180);
+    }
+    // 收的时候也先等 0.2 秒：鼠标可能是从感应带往下挪进横条里（那条就贴在它下面），
+    // 中途路过那一下不该被判成「离开了」。
+    function barScheduleHide() {
+      clearTimeout(barShowTimer);
+      barShowTimer = null;
+      clearTimeout(barHideTimer);
+      barHideTimer = setTimeout(mirrorBarOff, 200);
+    }
+    mirrorHot.addEventListener('mouseenter', barScheduleShow);
+    // 显示这一屏那一刻鼠标可能就停在顶上（那时不会再有 mouseenter）——动一下也算数。
+    mirrorHot.addEventListener('mousemove', barScheduleShow);
+    mirrorHot.addEventListener('mouseleave', barScheduleHide);
+    mirrorBar.addEventListener('mouseenter', function () { clearTimeout(barHideTimer); });
+    mirrorBar.addEventListener('mouseleave', barScheduleHide);
+  }
+  // Tab 走到「返回」上要看得见它。
+  $('mirrorClose').addEventListener('focus', mirrorBarOn);
+
   /**
    * 框里那一页自己发的「返回手机页」。
    *
@@ -6965,10 +7824,14 @@
     toast('正在重连…');
   });
 
+  /**
+   * 「重新输入令牌」：把闸门露出来，让用户再贴一枚令牌进来。
+   *
+   * **这一下不再清除任何东西**（2026-10-16 第二步）：身份已经是一枚 HttpOnly 的设备
+   * cookie，页面看不到也删不掉它——真正的「把这台设备赶出去」在电脑那边（名册里删掉
+   * 它，下一步做进设置页）。按钮原来叫「清除 token」，那个名字从这一刻起就是假的。
+   */
   $('btnForget').addEventListener('click', function () {
-    localStorage.removeItem('dshMiniToken');
-    state.token = '';
-    if (es) { try { es.close(); } catch (e) {} es = null; }
     sheet.classList.remove('open');
     showGate();
   });
@@ -6983,28 +7846,25 @@
   $('gateInput').addEventListener('keydown', function (e) {
     if (e.key === 'Enter') submitGate();
   });
+  /**
+   * 把手里这枚令牌交回**门口那一次**（和扫码进来是同一条路）。
+   *
+   * 为什么不在这里校验一次、把它留在手里：令牌留在手里就等于**撤销失效**——名册里
+   * 把这条记录删掉之后，这台设备还会拿令牌进门。所以这里只是**跳一次**：服务端在门口
+   * 认这枚令牌、换成设备 cookie（HttpOnly），页面自己一个字节都不记。
+   * 令牌不对时服务端会重新发下门禁页；下面启动那一段看地址里那枚 token 就知道要报什么。
+   */
   function submitGate() {
     var value = $('gateInput').value.trim();
     if (!value) { $('gateErr').textContent = '请先粘贴 token'; return; }
     $('gateErr').textContent = '校验中…';
-    fetch('/mini/api/state', { headers: { 'X-Mini-Token': value } })
-      .then(function (r) {
-        if (!r.ok) throw new Error('token 不正确');
-        localStorage.setItem('dshMiniToken', value);
-        state.token = value;
-        $('gate').classList.remove('open');
-        // 手输 token 进来的人也得有立绘——立绘地址是拿 state.token 拼的，
-        // 不在这里补一次，这一路进来的用户会看到空白的立绘位。
-        preloadPoses();
-        connect();
-      })
-      .catch(function () { $('gateErr').textContent = 'token 不正确，请核对后重试'; });
+    location.replace(location.pathname + '?token=' + encodeURIComponent(value));
   }
 
   // ---------------- presence 与心跳 ----------------
   document.addEventListener('visibilitychange', function () {
     var hidden = document.hidden;
-    if (state.token) {
+    if (state.entered) {
       api('/mini/api/presence', {
         method: 'POST',
         body: JSON.stringify({ state: hidden ? 'background' : 'foreground' })
@@ -7013,12 +7873,12 @@
     if (!hidden) { render(); connectIfDead(); }
   });
   setInterval(function () {
-    if (state.token) api('/mini/api/heartbeat', { method: 'POST', body: '{}' }).catch(function () {});
+    if (state.entered) api('/mini/api/heartbeat', { method: 'POST', body: '{}' }).catch(function () {});
   }, 30000);
 
   function connectIfDead() {
     // 切回前台时 EventSource 可能已经悄悄死了，探一下。
-    if (!state.token) return;
+    if (!state.entered) return;
     if (es && es.readyState === EventSource.OPEN) return;
     connect();
   }
@@ -7037,7 +7897,7 @@
    * **正在打字就先不刷**——用户没发出去的话不能被吞掉，等下一轮再说。
    */
   function watchBuild() {
-    if (!state.token) return;
+    if (!state.entered) return;
     api('/mini/api/version').then(function (r) {
       // 设置页底部那行版本。**问到才显示**——问不到就整行不出现，
       // 不拿「unknown」糊一行上去（那个字对用户没意义，还像页面坏了）。
@@ -7099,10 +7959,17 @@
   // ---------------- 启动 ----------------
   syncSeg();
   autoGrow();
-  if (NEEDS_TOKEN && !state.token) {
-    showGate();
-  } else if (!state.token) {
+  if (!state.entered) {
+    // 服务端没放行：这是一张只用来输入令牌的门禁页。
+    // 地址里那枚 token = 刚才手输（或扫码）交上来的那一枚，它没被认下来才会走到这儿——
+    // 报一句人话，并把地址栏擦掉（不把输错的令牌留在那儿）。
+    var bad = params.get('token');
+    if (bad) history.replaceState(null, '', location.pathname);
     showGate();
+    if (bad) $('gateErr').textContent = 'token 不正确，请核对后重试';
+    // 被撤销的那台设备：**说清发生了什么、下一步做什么**。不说的话，用户看到的
+    // 只是一张"要令牌"的页面——他昨天还能用，今天莫名其妙进不去了。
+    if (DEVICE_REVOKED) $('gateRevoked').hidden = false;
   } else {
     preloadPoses();
     connect();
@@ -7263,7 +8130,7 @@
       var body = { provider: provider, model: model }
       if (effort) body.reasoningEffort = effort
       busy = true
-      fetch('/mini/api/set-model?token=' + encodeURIComponent(state.token), {
+      fetch('/mini/api/set-model', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body)
@@ -7285,8 +8152,8 @@
 
     // ---- 读目录 ----------------------------------------------------------
     function load() {
-      if (!state.token) return
-      fetch('/mini/api/models?token=' + encodeURIComponent(state.token), { cache: 'no-store' })
+      if (!state.entered) return
+      fetch('/mini/api/models', { cache: 'no-store' })
         .then(function (r) { return r.ok ? r.json() : null })
         .then(function (d) {
           if (!d || !d.ok) return