dsh-remote-control 1.2.0 → 2.0.1

package/dist/bundle/index.js

@@ -4501,7 +4501,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes5, createHash: createHash3 } = __require("crypto");
+    var { randomBytes: randomBytes5, createHash: createHash4 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -5182,7 +5182,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash3("sha1").update(key + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -5551,7 +5551,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash3 } = __require("crypto");
+    var { createHash: createHash4 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -5858,7 +5858,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash3("sha1").update(key + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -7486,10 +7486,10 @@ var require_segments = __commonJS({
       const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
       const nodes = buildNodes(segs);
       const graph = buildGraph(nodes, version2);
-      const path3 = dijkstra.find_path(graph.map, "start", "end");
+      const path7 = dijkstra.find_path(graph.map, "start", "end");
       const optimizedSegs = [];
-      for (let i = 1; i < path3.length - 1; i++) {
-        optimizedSegs.push(graph.table[path3[i]].node);
+      for (let i = 1; i < path7.length - 1; i++) {
+        optimizedSegs.push(graph.table[path7[i]].node);
       }
       return exports.fromArray(mergeSegments(optimizedSegs));
     };
@@ -9925,7 +9925,7 @@ var require_utils2 = __commonJS({
 // ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/png.js
 var require_png2 = __commonJS({
   "../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/png.js"(exports) {
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var PNG = require_png().PNG;
     var Utils = require_utils2();
     exports.render = function render(qrData, options) {
@@ -9966,7 +9966,7 @@ var require_png2 = __commonJS({
       });
       png.pack();
     };
-    exports.renderToFile = function renderToFile(path3, qrData, options, cb) {
+    exports.renderToFile = function renderToFile(path7, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
@@ -9977,7 +9977,7 @@ var require_png2 = __commonJS({
         called = true;
         cb.apply(null, args);
       };
-      const stream = fs.createWriteStream(path3);
+      const stream = fs2.createWriteStream(path7);
       stream.on("error", done);
       stream.on("close", done);
       exports.renderToFileStream(stream, qrData, options);
@@ -10039,14 +10039,14 @@ var require_utf8 = __commonJS({
       }
       return output2;
     };
-    exports.renderToFile = function renderToFile(path3, qrData, options, cb) {
+    exports.renderToFile = function renderToFile(path7, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs = __require("fs");
+      const fs2 = __require("fs");
       const utf82 = exports.render(qrData, options);
-      fs.writeFile(path3, utf82, cb);
+      fs2.writeFile(path7, utf82, cb);
     };
   }
 });
@@ -10167,7 +10167,7 @@ var require_svg_tag = __commonJS({
       return str;
     }
     function qrToPath(data, size, margin) {
-      let path3 = "";
+      let path7 = "";
       let moveBy = 0;
       let newRow = false;
       let lineLength = 0;
@@ -10178,19 +10178,19 @@ var require_svg_tag = __commonJS({
         if (data[i]) {
           lineLength++;
           if (!(i > 0 && col > 0 && data[i - 1])) {
-            path3 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+            path7 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
             moveBy = 0;
             newRow = false;
           }
           if (!(col + 1 < size && data[i + 1])) {
-            path3 += svgCmd("h", lineLength);
+            path7 += svgCmd("h", lineLength);
             lineLength = 0;
           }
         } else {
           moveBy++;
         }
       }
-      return path3;
+      return path7;
     }
     exports.render = function render(qrData, options, cb) {
       const opts = Utils.getOptions(options);
@@ -10198,10 +10198,10 @@ var require_svg_tag = __commonJS({
       const data = qrData.modules.data;
       const qrcodesize = size + opts.margin * 2;
       const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + ' d="M0 0h' + qrcodesize + "v" + qrcodesize + 'H0z"/>';
-      const path3 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+      const path7 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
       const viewBox = 'viewBox="0 0 ' + qrcodesize + " " + qrcodesize + '"';
       const width = !opts.width ? "" : 'width="' + opts.width + '" height="' + opts.width + '" ';
-      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path3 + "</svg>\n";
+      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path7 + "</svg>\n";
       if (typeof cb === "function") {
         cb(null, svgTag);
       }
@@ -10215,15 +10215,15 @@ var require_svg = __commonJS({
   "../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/svg.js"(exports) {
     var svgTagRenderer = require_svg_tag();
     exports.render = svgTagRenderer.render;
-    exports.renderToFile = function renderToFile(path3, qrData, options, cb) {
+    exports.renderToFile = function renderToFile(path7, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs = __require("fs");
+      const fs2 = __require("fs");
       const svgTag = exports.render(qrData, options);
       const xmlStr = '<?xml version="1.0" encoding="utf-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">' + svgTag;
-      fs.writeFile(path3, xmlStr, cb);
+      fs2.writeFile(path7, xmlStr, cb);
     };
   }
 });
@@ -10381,8 +10381,8 @@ var require_server = __commonJS({
         cb
       };
     }
-    function getTypeFromFilename(path3) {
-      return path3.slice((path3.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
+    function getTypeFromFilename(path7) {
+      return path7.slice((path7.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
     }
     function getRendererFromType(type) {
       switch (type) {
@@ -10446,17 +10446,17 @@ var require_server = __commonJS({
       const renderer = getRendererFromType(params.opts.type);
       return render(renderer.renderToBuffer, text, params);
     };
-    exports.toFile = function toFile(path3, text, opts, cb) {
-      if (typeof path3 !== "string" || !(typeof text === "string" || typeof text === "object")) {
+    exports.toFile = function toFile(path7, text, opts, cb) {
+      if (typeof path7 !== "string" || !(typeof text === "string" || typeof text === "object")) {
         throw new Error("Invalid argument");
       }
       if (arguments.length < 3 && !canPromise()) {
         throw new Error("Too few arguments provided");
       }
       const params = checkParams(text, opts, cb);
-      const type = params.opts.type || getTypeFromFilename(path3);
+      const type = params.opts.type || getTypeFromFilename(path7);
       const renderer = getRendererFromType(type);
-      const renderToFile = renderer.renderToFile.bind(null, path3);
+      const renderToFile = renderer.renderToFile.bind(null, path7);
       return render(renderToFile, text, params);
     };
     exports.toFileStream = function toFileStream(stream, text, opts) {
@@ -10655,9 +10655,9 @@ var init_mock_kernel = __esm({
 });
 
 // src/index.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
+import path6 from "node:path";
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/crypto/bytes.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/crypto/bytes.js
 import { Buffer as Buffer2 } from "node:buffer";
 var encoder = new TextEncoder();
 var decoder = new TextDecoder("utf-8", { fatal: false });
@@ -10684,7 +10684,7 @@ function concat(parts) {
   return out;
 }
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/crypto/keys.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/crypto/keys.js
 import { createHash, randomBytes } from "node:crypto";
 var KDF_NAMESPACE = "dsh-rc/v1";
 var UNIT_SEPARATOR = 31;
@@ -10714,7 +10714,7 @@ function randomNonce() {
   return new Uint8Array(randomBytes(NONCE_BYTES));
 }
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/crypto/record.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/crypto/record.js
 var import_tweetnacl = __toESM(require_nacl_fast(), 1);
 var MAC_BYTES = 16;
 var MIN_RECORD_BYTES = NONCE_BYTES + MAC_BYTES;
@@ -10747,7 +10747,7 @@ function open(key, record2) {
   }
 }
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/identity/pairing.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/identity/pairing.js
 import { randomBytes as randomBytes2 } from "node:crypto";
 var URI_PREFIX = "dshr:";
 var TOKEN_RE = /^\d{6}$/;
@@ -11593,10 +11593,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11936,11 +11936,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -12390,16 +12390,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path3 = []) => {
+  const processError = (error63, path7 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -12438,17 +12438,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result2 = { errors: [] };
-  const processError = (error63, path3 = []) => {
+  const processError = (error63, path7 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result2.errors.push(mapper(issue2));
           continue;
@@ -12487,8 +12487,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -29590,13 +29590,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1] === void 0 ? void 0 : decodeJSONPointerSegment(path3[1]);
+  if (path7[0] === defsKey) {
+    const key = path7[1] === void 0 ? void 0 : decodeJSONPointerSegment(path7[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -30445,7 +30445,7 @@ function date4(params) {
   return _coercedDate(ZodDate, params);
 }
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/wire/frames.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/wire/frames.js
 var PAIRING_TOKEN_RE = /^\d{6}$/;
 var nonEmpty = external_exports.string().min(1);
 var pairingToken = external_exports.string().regex(PAIRING_TOKEN_RE);
@@ -30468,8 +30468,7 @@ var helloFrame = external_exports.object({
 });
 var pairBeginFrame = external_exports.object({
   t: external_exports.literal("pair-begin"),
-  pairingToken,
-  hostLabel: external_exports.string().max(128).optional()
+  pairingToken
 });
 var pairClaimFrame = external_exports.object({
   t: external_exports.literal("pair-begin-client"),
@@ -30605,7 +30604,7 @@ function parseRelayFrameText(raw) {
   }
 }
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/wire/payloads.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/wire/payloads.js
 var SESSION_STATES = [
   "idle",
   "running",
@@ -30670,6 +30669,13 @@ var evPermissionRequest = external_exports.object({
   options: external_exports.array(choiceOption).optional(),
   expiresAt: external_exports.string().optional()
 });
+var evPermissionResolved = external_exports.object({
+  t: external_exports.literal("ev.permission_resolved"),
+  requestId: nonEmpty2,
+  sessionId: nonEmpty2.optional(),
+  /** 谁收的场。手机只按"要不要收掉这张卡"读它，所以不做必填。 */
+  by: external_exports.enum(["desktop", "cancelled"]).optional()
+});
 var questionItem = external_exports.object({
   id: nonEmpty2,
   question: nonEmpty2,
@@ -30680,7 +30686,23 @@ var evQuestionRequest = external_exports.object({
   t: external_exports.literal("ev.question_request"),
   sessionId: nonEmpty2.optional(),
   requestId: nonEmpty2,
-  questions: external_exports.array(questionItem)
+  questions: external_exports.array(questionItem),
+  /**
+   * 这张提问卡什么时候作废（ISO 字符串）。
+   *
+   * 为什么审批有而提问没有过：主机侧的提问等待本来就带超时（`questionTimeoutMs`，默认 300s），
+   * 但手机上那张卡**没有任何倒计时**——用户看不见自己按的按钮什么时候失效，
+   * 而这违反伞仓 `docs/PRODUCT.md` §3 第 3 条「超时必须可见」。
+   * 与审批那条同一个形状：可选、ISO 字符串、由主机每次发问时现算。
+   */
+  expiresAt: external_exports.string().optional()
+});
+var evQuestionResolved = external_exports.object({
+  t: external_exports.literal("ev.question_resolved"),
+  requestId: nonEmpty2,
+  sessionId: nonEmpty2.optional(),
+  /** 谁收的场。手机只按"要不要收掉这张卡"读它，所以不做必填。 */
+  by: external_exports.enum(["desktop", "cancelled"]).optional()
 });
 var evRunState = external_exports.object({
   t: external_exports.literal("ev.run_state"),
@@ -30697,6 +30719,24 @@ var evKeepAwakeState = external_exports.object({
   backend: nonEmpty2,
   reason: external_exports.string().optional()
 });
+var modelOption = external_exports.object({
+  /** 机器名（回传用），例如 `deepseek-chat`。 */
+  value: nonEmpty2,
+  /** 给人看的名字；缺省时小程序自己截断 `value`。 */
+  label: external_exports.string().optional(),
+  provider: external_exports.string().optional()
+});
+var evModel = external_exports.object({
+  t: external_exports.literal("ev.model"),
+  provider: nonEmpty2.optional(),
+  model: nonEmpty2,
+  /** 主机能不能换。false 时小程序**不许**渲染成可点的下拉。 */
+  canSwitch: external_exports.boolean(),
+  /** 候选清单；`canSwitch` 为 true 时至少一项。 */
+  options: external_exports.array(modelOption).optional(),
+  /** 不能切时给手机一句人话，直接显示，不要让小程序自己编措辞。 */
+  reason: external_exports.string().optional()
+});
 var evResult = external_exports.object({
   t: external_exports.literal("ev.result"),
   cmdId: external_exports.string(),
@@ -30718,18 +30758,37 @@ var evPayload = external_exports.discriminatedUnion("t", [
   evMessageDelta,
   evToolEvent,
   evPermissionRequest,
+  evPermissionResolved,
   evQuestionRequest,
+  evQuestionResolved,
   evRunState,
   evKeepAwakeState,
+  evModel,
   evResult,
   evSessionHistory
 ]);
+var imageAttachment = external_exports.object({
+  /** 落盘用的文件名（mp 侧生成，形如 `img-<ms>-<n>.jpg`；主机侧还会再收敛一次字符集）。 */
+  name: nonEmpty2,
+  mediaType: external_exports.literal("image/jpeg"),
+  /** base64 字节，**不带** `data:` 前缀。 */
+  data: nonEmpty2,
+  /** 压缩后的像素尺寸，主机写旁车元数据用（排错时对得上）。 */
+  width: external_exports.number().int().positive().optional(),
+  height: external_exports.number().int().positive().optional()
+});
 var cmdSendPrompt = external_exports.object({
   t: external_exports.literal("cmd.send_prompt"),
   cmdId: nonEmpty2,
   /** DSH 会话 id，不是配对通道 id。 */
   sessionId: nonEmpty2,
-  text: external_exports.string()
+  text: external_exports.string(),
+  /**
+   * 随消息的图片附件。**可选**：老版本手机不带这个字段，老主机看到也不认
+   * （zod 默认 strip 未知键，而 text 照旧）——所以这是向后兼容的增补，不升协议版本。
+   * 上限 4 张：再多对"看清楚这张图"没有帮助，只是把帧撑爆。
+   */
+  images: external_exports.array(imageAttachment).max(4).optional()
 });
 var answerItem = external_exports.object({
   questionId: nonEmpty2,
@@ -30808,14 +30867,17 @@ var PAYLOAD_TYPES = {
   evMessageDelta: "ev.message_delta",
   evToolEvent: "ev.tool_event",
   evPermissionRequest: "ev.permission_request",
+  evPermissionResolved: "ev.permission_resolved",
   evQuestionRequest: "ev.question_request",
+  evQuestionResolved: "ev.question_resolved",
   evRunState: "ev.run_state",
   evKeepAwakeState: "ev.keep_awake_state",
+  evModel: "ev.model",
   evResult: "ev.result",
   evSessionHistory: "ev.session_history"
 };
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/wire/outbound.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/wire/outbound.js
 function sessionChanged(sessions, reason) {
   return { t: PAYLOAD_TYPES.evSessionChanged, sessions, ...reason === void 0 ? {} : { reason } };
 }
@@ -30828,15 +30890,31 @@ function toolEvent(args) {
 function permissionRequest(args) {
   return { t: PAYLOAD_TYPES.evPermissionRequest, ...args };
 }
+function permissionResolved(args) {
+  return { t: PAYLOAD_TYPES.evPermissionResolved, ...args };
+}
 function questionRequest(args) {
   return { t: PAYLOAD_TYPES.evQuestionRequest, ...args };
 }
+function questionResolved(args) {
+  return { t: PAYLOAD_TYPES.evQuestionResolved, ...args };
+}
 function runState(args) {
   return { t: PAYLOAD_TYPES.evRunState, ...args };
 }
 function keepAwakeState(args) {
   return { t: PAYLOAD_TYPES.evKeepAwakeState, ...args };
 }
+function model(args) {
+  const payload = { t: PAYLOAD_TYPES.evModel, model: args.model, canSwitch: args.canSwitch };
+  if (args.provider !== void 0)
+    payload.provider = args.provider;
+  if (args.canSwitch && args.options?.length)
+    payload.options = args.options;
+  if (args.reason !== void 0)
+    payload.reason = args.reason;
+  return payload;
+}
 function result(cmdId, ok, extras = {}) {
   const { message, data } = extras;
   return {
@@ -30858,7 +30936,7 @@ function sessionHistory(args) {
   };
 }
 
-// ../../node_modules/.pnpm/dsh-remote-wire@1.0.0/node_modules/dsh-remote-wire/dist/src/platform/sleep.js
+// ../../node_modules/.pnpm/dsh-remote-wire@1.3.0/node_modules/dsh-remote-wire/dist/src/platform/sleep.js
 function detectBackend(platform) {
   if (platform === "darwin")
     return "caffeinate";
@@ -30899,6 +30977,81 @@ function buildSleepCommand(platform, ownerPid, keepDisplay = false) {
 // src/core/runtime.ts
 import { randomUUID } from "node:crypto";
 
+// src/shell/uploads.ts
+import fs from "node:fs";
+import path from "node:path";
+function safeSegment(raw, fallback, maxLen = 96) {
+  const cleaned = String(raw || "").replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^[._-]+/, "").slice(0, maxLen).replace(/[._-]+$/, "");
+  return cleaned === "" ? fallback : cleaned;
+}
+function decodeBase64(data) {
+  if (!/^[A-Za-z0-9+/=\s]+$/.test(data)) return null;
+  const buf = Buffer.from(data, "base64");
+  return buf.length > 0 ? buf : null;
+}
+function looksLikeJpeg(buf) {
+  return buf.length > 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255;
+}
+function saveImageAttachments(options) {
+  const maxCount = options.maxCount ?? 4;
+  const maxBytes = options.maxBytesPerImage ?? 4 * 1024 * 1024;
+  const images = options.images || [];
+  if (images.length === 0) return { ok: true, saved: [], dir: options.dir };
+  if (images.length > maxCount) {
+    return { ok: false, message: `\u4E00\u6B21\u6700\u591A\u5E26 ${maxCount} \u5F20\u56FE\u7247\uFF0C\u6536\u5230 ${images.length} \u5F20` };
+  }
+  const decoded = [];
+  for (const [i, img] of images.entries()) {
+    if (img.mediaType !== "image/jpeg") {
+      return { ok: false, message: `\u7B2C ${i + 1} \u5F20\u4E0D\u662F jpeg\uFF08${img.mediaType || "\u7A7A"}\uFF09\uFF0C\u4E3B\u673A\u53EA\u6536 jpeg` };
+    }
+    const buf = decodeBase64(img.data);
+    if (!buf) return { ok: false, message: `\u7B2C ${i + 1} \u5F20\u7684\u89E3\u7801\u5931\u8D25\uFF08\u4E0D\u662F\u5408\u6CD5 base64\uFF09` };
+    if (buf.length > maxBytes) {
+      return {
+        ok: false,
+        message: `\u7B2C ${i + 1} \u5F20\u6709 ${Math.round(buf.length / 1024)}KB\uFF0C\u8D85\u8FC7\u5355\u5F20\u4E0A\u9650 ${Math.round(maxBytes / 1024)}KB`
+      };
+    }
+    if (!looksLikeJpeg(buf)) {
+      return { ok: false, message: `\u7B2C ${i + 1} \u5F20\u7684\u5185\u5BB9\u4E0D\u662F jpeg\uFF08\u6587\u4EF6\u5934\u5BF9\u4E0D\u4E0A\uFF09` };
+    }
+    decoded.push({ img, buf });
+  }
+  const sessionDir = path.join(options.dir, safeSegment(options.sessionId, "session"));
+  const written = [];
+  try {
+    fs.mkdirSync(sessionDir, { recursive: true });
+    for (const [i, one] of decoded.entries()) {
+      const base = safeSegment(one.img.name, `img-${i + 1}.jpg`).replace(/\.jpg$/i, "") + ".jpg";
+      let name = base;
+      let n = 1;
+      while (fs.existsSync(path.join(sessionDir, name))) {
+        name = base.replace(/\.jpg$/, `-${++n}.jpg`);
+      }
+      const file2 = path.join(sessionDir, name);
+      fs.writeFileSync(file2, one.buf, { mode: 384 });
+      written.push({ name, path: file2, bytes: one.buf.length });
+    }
+  } catch (error62) {
+    return {
+      ok: false,
+      message: `\u56FE\u7247\u843D\u76D8\u5931\u8D25\uFF1A${String(error62?.message ?? error62).slice(0, 160)}`
+    };
+  }
+  return { ok: true, saved: written, dir: sessionDir };
+}
+function appendImageNote(text, saved) {
+  if (saved.length === 0) return text;
+  const lines = saved.map((img, i) => `${i + 1}. ${img.path}`);
+  const note = `
+
+[\u56FE\u7247\u9644\u4EF6 ${saved.length} \u5F20\uFF0C\u5DF2\u5B58\u5230\u672C\u673A]
+${lines.join("\n")}`;
+  const head = String(text || "");
+  return head === "" ? note.replace(/^\n\n/, "") : head + note;
+}
+
 // src/core/window.ts
 var DEFAULT_WINDOW_OPTIONS = {
   windowMs: 120,
@@ -31069,7 +31222,11 @@ var DEFAULTS = {
   listingRefreshMs: 15e3,
   approvalTimeoutMs: 18e4,
   questionTimeoutMs: 3e5,
-  unarchiveOnPrompt: true
+  unarchiveOnPrompt: true,
+  // 图片附件：默认**不收**（uploadDir 空 = 拒收）。要放开必须在插件配置里显式
+  // 给一个目录——落盘是往用户磁盘写文件，不该由库默认值悄悄代劳。
+  uploadDir: "",
+  maxImageBytes: 4 * 1024 * 1024
 };
 var LISTING_LIMIT = 100;
 var HISTORY_LIMIT = 40;
@@ -31156,7 +31313,32 @@ var HostRuntime = class {
               return;
             }
           }
-          const sent = await this.kernel.sendPrompt(cmd.sessionId, cmd.text);
+          let text = cmd.text;
+          const images = Array.isArray(cmd.images) ? cmd.images : [];
+          if (images.length > 0) {
+            if (!this.options.uploadDir) {
+              reply(false, { message: "\u8FD9\u53F0\u4E3B\u673A\u6CA1\u914D\u56FE\u7247\u843D\u76D8\u76EE\u5F55\uFF08uploadDir\uFF09\uFF0C\u6536\u4E0D\u4E86\u56FE\u7247\u9644\u4EF6" });
+              return;
+            }
+            const saved = saveImageAttachments({
+              images,
+              dir: this.options.uploadDir,
+              sessionId: cmd.sessionId,
+              maxBytesPerImage: this.options.maxImageBytes
+            });
+            if (!saved.ok) {
+              reply(false, { message: saved.message });
+              return;
+            }
+            this.options.log?.("\u56FE\u7247\u9644\u4EF6\u843D\u76D8", {
+              sessionId: cmd.sessionId,
+              images: saved.saved.length,
+              bytes: saved.saved.reduce((sum, img) => sum + img.bytes, 0),
+              dir: saved.dir
+            });
+            text = appendImageNote(text, saved.saved);
+          }
+          const sent = await this.kernel.sendPrompt(cmd.sessionId, text);
           reply(sent.ok, sent.message ? { message: sent.message } : {});
           if (sent.ok) {
             this.sleep.markActive();
@@ -31244,6 +31426,25 @@ var HostRuntime = class {
   get stats() {
     return { ...this.outboundCount };
   }
+  /**
+   * 有几件事正挂在手机上等回答，以及**最久的那件已经等了多久**（秒）。
+   *
+   * 为什么这条要出到界面上（而不只是内部状态）：一张挂起的审批阻塞着远端一条正在跑的回合，
+   * 而回合阻塞着用户的下班时间。桌面那颗 pill 原来在"已配对 + 有东西在等"时仍然只说
+   * `已配对`——那是这整条链上唯一看得见它的地方，等于没有。判据见伞仓 docs/PRODUCT.md §3。
+   *
+   * `oldestSec` 用 `clock.now()` 而不是 `Date.now()`： FakeClock 要能演"等了 4 分钟"，
+   * 否则这条时长在测试里永远是 0，也就永远不会红。
+   */
+  get waiting() {
+    const now = this.clock.now();
+    let oldest = 0;
+    for (const item of this.pending.values()) {
+      const age = Math.max(0, Math.floor((now - item.askedAt) / 1e3));
+      if (age > oldest) oldest = age;
+    }
+    return { count: this.pending.size, oldestSec: oldest };
+  }
   countOutbound(payload, sent) {
     const key = payload.t.replace(/^ev\./, "");
     this.outboundCount[key] = (this.outboundCount[key] ?? 0) + 1;
@@ -31321,8 +31522,40 @@ var HostRuntime = class {
     }
     this.broadcast(sessionChanged(this.sessions, reason));
     this.broadcast(keepAwakeState(this.sleep.snapshot()));
+    this.broadcastModel();
     return this.sessions;
   }
+  /**
+   * 广播当前模型。
+   *
+   * 跟着 `pushSessions` 一起发而不是单独起一条：模型与防休眠都是**全局状态**，
+   * 而 `pushSessions` 已经是"状态变了就推一次"的唯一入口，另开一条推送路径
+   * 必然出现「会话更新了但模型没更新」这种半同步状态。
+   *
+   * **读不到就不发**（而不是发一个 `model: ''`）：`ev.model` 的 `model` 是必填的
+   * 非空串，硬塞空串会让手机把「不知道用什么模型」显示成「模型名为空」——
+   * 后者看起来像 bug，前者只是没显示。内核缺 `currentSelection` 时真机上是常态
+   * （见 carrier 的 modelFace 探测）。
+   */
+  broadcastModel() {
+    let selection;
+    try {
+      selection = this.kernel.modelSelection?.();
+    } catch {
+      return;
+    }
+    if (!selection?.model) return;
+    const face = this.kernel.modelOptions?.();
+    this.broadcast(
+      model({
+        model: selection.model,
+        provider: selection.provider,
+        canSwitch: Boolean(face?.canSwitch),
+        options: face?.options,
+        reason: face?.canSwitch ? void 0 : face?.reason ?? "\u4E3B\u673A\u5185\u6838\u672A\u63D0\u4F9B\u5207\u6362\u6A21\u578B\u7684\u80FD\u529B"
+      })
+    );
+  }
   refreshLoop() {
     if (this.stopped) return;
     void this.pushSessions("refresh");
@@ -31336,24 +31569,33 @@ var HostRuntime = class {
    * **没有在线对端就返回 `'decline'`**，让适配器去调平台的 `next()` 把决定权交还桌面 UI；
    * 超时同样返回 `'decline'`（我们已经把卡片发出去了，但手机迟迟没点，
    * 与其替用户决定，不如让桌面去决定）。
+   *
+   * 返回值只说明"手机这一侧算出了什么"，**不代表这张卡是手机答掉的**：
+   * 桌面与手机是同时被问的（见 `carrier-services.ts` 的 `participate`），
+   * 所以收尾时要按"有没有真的有人在手机上点过"决定要不要把卡收回去。
    */
   async onApprovalRequest(info) {
     const conversationId = this.pickConversation(info.sessionId);
-    if (!conversationId || !this.transport.hasPeer(conversationId)) return "decline";
+    if (!conversationId || !this.transport.hasClient(conversationId)) return "decline";
     const id = `ap_${randomUUID().slice(0, 8)}`;
     this.sleep.hold(id);
     const answered = await new Promise((resolve) => {
       const timer = this.clock.setTimeout(() => {
-        this.pending.delete(id);
-        resolve("decline");
+        this.settle(id, "decline", "timeout");
       }, this.options.approvalTimeoutMs);
       this.pending.set(id, {
         conversationId,
         sessionId: info.sessionId,
         resolve: (value) => resolve(value === void 0 ? "decline" : value),
-        timer
+        timer,
+        kind: "approval",
+        askedAt: this.clock.now()
       });
-      info.signal?.addEventListener("abort", () => this.settle(id, "cancelled"), { once: true });
+      info.signal?.addEventListener(
+        "abort",
+        () => this.settle(id, "cancelled", info.signal?.reason === "desktop" ? "desktop" : "withdrawn"),
+        { once: true }
+      );
       this.replyTo(
         conversationId,
         permissionRequest({
@@ -31361,7 +31603,8 @@ var HostRuntime = class {
           sessionId: info.sessionId,
           action: info.action,
           ...info.reason === void 0 ? {} : { reason: info.reason },
-          options: APPROVAL_OPTIONS
+          options: APPROVAL_OPTIONS,
+          expiresAt: new Date(Date.now() + this.options.approvalTimeoutMs).toISOString()
         })
       );
     });
@@ -31370,28 +31613,36 @@ var HostRuntime = class {
   }
   async onQuestionRequest(info) {
     const conversationId = this.pickConversation(info.sessionId);
-    if (!conversationId || !this.transport.hasPeer(conversationId)) return null;
+    if (!conversationId || !this.transport.hasClient(conversationId)) return null;
     const id = `q_${randomUUID().slice(0, 8)}`;
     this.sleep.hold(id);
     const answer = await new Promise((resolve) => {
       const timer = this.clock.setTimeout(() => {
-        this.pending.delete(id);
-        resolve(null);
+        this.settle(id, null, "timeout");
       }, this.options.questionTimeoutMs);
       this.pending.set(id, {
         conversationId,
         sessionId: info.sessionId,
         resolve: (value) => resolve(value ?? null),
         timer,
-        options: info.questions
+        options: info.questions,
+        kind: "question",
+        askedAt: this.clock.now()
       });
-      info.signal?.addEventListener("abort", () => this.settle(id, null), { once: true });
+      info.signal?.addEventListener(
+        "abort",
+        () => this.settle(id, null, info.signal?.reason === "desktop" ? "desktop" : "withdrawn"),
+        { once: true }
+      );
       this.replyTo(
         conversationId,
         questionRequest({
           requestId: id,
           sessionId: info.sessionId,
-          questions: info.questions
+          questions: info.questions,
+          // 提问这张卡以前**没有**到期时刻：主机 300 秒就判"没答上"，而手机上看不见任何倒计时，
+          // 用户不知道自己按的按钮什么时候作废（伞仓 docs/PRODUCT.md §3 第 3 条）。
+          expiresAt: new Date(Date.now() + this.options.questionTimeoutMs).toISOString()
         })
       );
     });
@@ -31423,13 +31674,47 @@ var HostRuntime = class {
     this.settle(requestId, value);
     return true;
   }
-  settle(id, value) {
+  settle(id, value, voidAs) {
     const item = this.pending.get(id);
     if (!item) return;
     this.pending.delete(id);
     this.clock.clearTimeout(item.timer);
+    if (voidAs) this.voidStaleCard(id, item, voidAs);
     item.resolve(value);
   }
+  /**
+   * 让手机上那张已经作废的卡片**当场**收掉：先按 `requestId` 发一条精确帧，
+   * 再补一帧 `ev.run_state` 兜住"手机上装的是老版小程序"这一档。
+   *
+   * 为什么要两条而不是一条：`ev.permission_resolved` / `ev.question_resolved` 是按
+   * `requestId` 收单的（一次答完不会误收别的会话、别的请求那张卡），这是**正路**——
+   * mp 1.0.1 起就认这两帧（`pages/chat/chat.js` 的 `_onPermissionResolved` /
+   * `_onQuestionResolved`）。而 `ev.run_state` 是它从第一版就认的粗粒度信号
+   * （整会话两张卡一起收），发它只为兜住 **1.0.1 以前**的安装存量——那一档小程序
+   * 的分发是一串 `if (p.t === …)`，认不出来的 `t` 静默忽略。
+   * （`pages/chat/chat.js` 的 `_onRunState` 同时清 `pendingPermission` 与 `pendingQuestion`，
+   * 并停掉那条还在走的本地倒数）。所以两条都发：新版手机收到精确帧就精收一张，
+   * 老版手机靠 `run_state` 也能当场收卡，不用等用户重新上传小程序。
+   *
+   * 内核**不会**为"审批/提问被别人答掉了"发状态跳变（这一回合自始至终是 running），
+   * 所以这一帧只能由我们补发；补的是**当前真相**而不是硬编码 `running`——
+   * 手机上那个"思考中"跟着这一帧走，发错方向会一直错到下一次真实跳变。
+   * 读不到真相时退回缓存快照，再退 `idle`：宁可少一个转圈，不能凭空多一个转圈。
+   */
+  voidStaleCard(requestId, item, reason) {
+    const by = reason === "desktop" ? "desktop" : "cancelled";
+    this.replyTo(
+      item.conversationId,
+      item.kind === "approval" ? permissionResolved({ requestId, sessionId: item.sessionId, by }) : questionResolved({ requestId, sessionId: item.sessionId, by })
+    );
+    const emit = (running) => {
+      this.broadcast(runState({ sessionId: item.sessionId, state: running ? "running" : "idle" }));
+      this.log("pending card voided", { requestId, reason, kind: item.kind, state: running ? "running" : "idle" });
+    };
+    void this.kernel.runState(item.sessionId).then((truth) => emit(truth.running)).catch(() => {
+      emit(this.sessions.some((session) => session.id === item.sessionId && session.running === true));
+    });
+  }
   /**
    * 挑一条配对通道把这轮交互发出去。
    *
@@ -31441,7 +31726,7 @@ var HostRuntime = class {
   pickConversation(_sessionId) {
     const ids = this.transport.conversationIds();
     if (ids.length === 0) return void 0;
-    return ids.find((id) => this.transport.hasPeer(id)) ?? ids[0];
+    return ids.find((id) => this.transport.hasClient(id)) ?? ids[0];
   }
   log(message, fields) {
     this.options.log?.(message, fields);
@@ -31603,6 +31888,10 @@ var DEFAULT_PRUNE_POLICY = {
   // 一天没有任何收发就认为这条通道不会再被用（手机真回来时会重新扫码，
   // 而且它会先撞上 `unknown_session` → 中文提示，而不是"永远转圈"）。
   idleTtlMs: 24 * 3600 * 1e3,
+  // 恢复出来的会话不按上面那条剪：默认给 7 天，与中继的 `DRC_CONV_IDLE_TTL_MS`
+  // （`config.ts` 的 7×24h）逐字对齐 —— 中继忘掉它的那天本来就得重扫，
+  // 主机提前剪只是把同一次重扫提前到用户还没察觉的时间点，反而更难解释。
+  restoredIdleTtlMs: 7 * 24 * 3600 * 1e3,
   maxConversations: 64
 };
 var ConversationBook = class {
@@ -31620,13 +31909,48 @@ var ConversationBook = class {
       kH2C: derivePskKey(args.psk, H2C, args.id),
       psk: args.psk,
       seqHost: 0,
-      generation: args.generation,
       createdAt: args.now,
       lastActivityAt: args.now
     };
     this.byId.set(args.id, conversation);
     return conversation;
   }
+  /**
+   * 从落盘记录恢复会话（跨进程续用，见 `shell/pair-store.ts`）。
+   *
+   * 两条刻意的选择：
+   *
+   * - **`clientIds` 一律置空**：那是"此刻谁连着"的瞬时态，进程刚起来时没有人连着主机。
+   *   填了旧值会让主机一启动就往每条会话广播，而手机端还没重连 ——
+   *   那些帧全被中继计成丢帧（`relay.ts` 的 `broadcast` 闸门当初就是为这个加的）。
+   *   手机回来发的第一帧会经 `RelayClient.onEncrypted` 把它重新登记进来。
+   * - **`restored: true`**：让剪枝对这条会话用另一条 TTL，理由见该字段的注释。
+   *
+   * 返回真正恢复出来的会话 id：**同一条 id 重复出现时后者覆盖前者**，
+   * 而一条形状不合的记录整条丢弃（宁可少一条通道，也不要一条解不开的）。
+   */
+  restore(records, now) {
+    const restored = [];
+    for (const record2 of records) {
+      const conversation = this.open({ id: record2.id, psk: record2.psk, now });
+      conversation.seqHost = record2.seqHost;
+      conversation.createdAt = record2.createdAt;
+      conversation.lastActivityAt = record2.lastActivityAt;
+      conversation.restored = true;
+      restored.push(record2.id);
+    }
+    return restored;
+  }
+  /** 导出可落盘的记录（**不含 clientIds**，理由见 `restore`）。 */
+  snapshot() {
+    return [...this.byId.values()].map((conversation) => ({
+      id: conversation.id,
+      psk: conversation.psk,
+      seqHost: conversation.seqHost,
+      createdAt: conversation.createdAt,
+      lastActivityAt: conversation.lastActivityAt
+    }));
+  }
   /** 有实际收发就记一笔活跃（剪枝只看这个时刻）。未知通道返回 false，不顺手建条目。 */
   touch(id, now) {
     const conversation = this.byId.get(id);
@@ -31640,33 +31964,43 @@ var ConversationBook = class {
   has(id) {
     return this.byId.has(id);
   }
+  /**
+   * 这条会话**现在有没有活着的客户端**。
+   *
+   * 与 `has()` 是两件事，而且必须分开：`has()` 是"我手里有这条通道的密钥"，
+   * 手机回前台时要用同一个 `convId` 回来，所以密钥**必须留着**（D3）；
+   * 但"有密钥"不等于"现在有人能收到"。
+   *
+   * 原来只有 `has()` 一个判据，于是 `hasPeer()` 答的是"有密钥"，广播就照着它发——
+   * 真机后果：手机断开之后（会话默认 7 天 TTL）主机每 15 秒仍往这条空会话发
+   * `session_changed` / `model` / `keep_awake_state` 三帧，中继每一帧计一次丢帧，
+   * 实测 45 秒涨 9、`/healthz` 的 `droppedFrames` 因此被这一路噪声主导（5737）。
+   */
+  hasClient(id) {
+    const conversation = this.byId.get(id);
+    return conversation !== void 0 && conversation.clientIds.size > 0;
+  }
   close(id) {
     return this.byId.delete(id);
   }
-  /** 中继重启（generation 变化）时把旧会话全部丢掉：它们再也解不开了。 */
-  closeBefore(generation) {
-    const dropped = [];
-    for (const [id, conversation] of [...this.byId]) {
-      if (conversation.generation < generation) {
-        this.byId.delete(id);
-        dropped.push(id);
-      }
-    }
-    return dropped;
-  }
   /**
    * 按策略剪枝，返回被剪掉的 id（调用方负责通知中继与上层，见
    * `RelayClient.pruneConversations`）。
    *
-   * 两条规则都做，因为它们是两种不同的失控：
+   * 三条规则，因为它们是三种不同的失控：
    * - 空闲超 TTL：一条通道一天没有任何收发，就不会再有人用它了；
+   * - **恢复出来的会话走另一条 TTL**（`restoredIdleTtlMs`）：见 `Conversation.restored`
+   *   与 `DEFAULT_PRUNE_POLICY.restoredIdleTtlMs` 的理由 —— 它不该按"新配对却没人用"的
+   *   标准剪掉，否则长假之后主机一启动就把唯一那条通道清了，免扫码重连白做；
    * - 超出硬上界：从**最不活跃**的开始剪。没有这条，一个每天配一次对的用户
    *   会在两周内攒下 260 条密钥，并且每次广播都对它们逐个密封一遍。
    */
   pruneStale(now, policy = DEFAULT_PRUNE_POLICY) {
     const dropped = [];
+    const restoredTtl = policy.restoredIdleTtlMs ?? policy.idleTtlMs;
     for (const [id, conversation] of [...this.byId]) {
-      if (now - conversation.lastActivityAt > policy.idleTtlMs) {
+      const ttl = conversation.restored ? restoredTtl : policy.idleTtlMs;
+      if (now - conversation.lastActivityAt > ttl) {
         this.byId.delete(id);
         dropped.push(id);
       }
@@ -31683,6 +32017,25 @@ var ConversationBook = class {
   ids() {
     return [...this.byId.keys()];
   }
+  /**
+   * 当前**真正连着**的客户端数（去重后的 clientId，不是会话数）。
+   *
+   * 为什么必须单独算：一条会话（convId）对应一次配对，而**同一部手机**在
+   * 「解除配对再重新配对」之后会开一条新会话 —— 于是 `size`（会话数）会增长，
+   * 手机却还是那一台。把 `size` 当成"有几部手机"报出去，用户解除配对后看到
+   * 数字反而变大，会以为解配没生效。
+   *
+   * 反过来也算不准：会话被剪掉了但手机还在（`pruneStale`），
+   * 所以这个数只保证"不比会话数更离谱"，不保证等于真实在线数 ——
+   * 界面上它只该当"有手机连着没有"的粗判据，不该当精确计数。
+   */
+  clientCount() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const conversation of this.byId.values()) {
+      for (const clientId of conversation.clientIds) ids.add(clientId);
+    }
+    return ids.size;
+  }
   get size() {
     return this.byId.size;
   }
@@ -31849,6 +32202,14 @@ var RelayClient = class {
   options;
   conversations = new ConversationBook();
   socket;
+  /**
+   * **主机侧连接代号**：每收到一次 `hello-ok` 就 +1。
+   *
+   * 它现在**只**喂给 `PairingWindow`（"中继的 pending-pair 表是不是清空了"），
+   * 绝不用来清会话 —— 理由见文件头。它递增本身没有权威性（中继不回代次），
+   * 所以配对窗口用它判"换码"是保守正确的：中继真重启时代次一定变了，
+   * 中继没重启时多换一张码的代价只是浪费一个 6 位码。
+   */
   generation = 0;
   attempts = 0;
   stopped = false;
@@ -31862,6 +32223,39 @@ var RelayClient = class {
   get conversationCount() {
     return this.conversations.size;
   }
+  /**
+   * 当前连着的**手机台数**（去重的 clientId）。
+   *
+   * 与 `conversationCount` 分开是因为「解除配对 → 重新配对」会开一条新会话，
+   * 手机却还是那一台：拿会话数当手机数报，用户解完配对看到数字变大，
+   * 会以为解配没生效。
+   */
+  get clientCount() {
+    return this.conversations.clientCount();
+  }
+  /** 本轮已连上的中继代号（`status.json` 与配对窗口都读它）。 */
+  get relayGeneration() {
+    return this.generation;
+  }
+  /**
+   * 恢复上次进程留下的会话（密钥来自 `pair-store`）。
+   *
+   * **恢复出来的会话里 `clientIds` 是空的**（见 `ConversationBook.restore`），所以
+   * `conversationCount > 0` 而 `clientCount === 0` 是这一阶段的正常形态：
+   * 密钥还在、手机还没回来。调用方据此知道**不能**等 `onPeerJoined` 才启动内核订阅
+   * —— 否则主机重启后手机能连上、主机却不订阅任何事件，表现与配对丢失一模一样。
+   */
+  restoreConversations(records) {
+    const restored = this.conversations.restore(records, this.options.clock.now());
+    if (restored.length > 0) {
+      this.options.log("conversations restored from disk", {
+        count: restored.length,
+        // 记一下有没有手机已经登记进来了：恢复阶段应当恒为 0。
+        clients: this.conversations.clientCount()
+      });
+    }
+    return restored;
+  }
   connect() {
     if (this.stopped) return;
     this.closeSocket();
@@ -31936,23 +32330,34 @@ var RelayClient = class {
       this.options.log("pruned stale conversations", { count: dropped.length, remaining: this.conversations.size });
     return dropped;
   }
-  /** 向一条配对会话发一条载荷；返回 false = 这条会话已经没了或没人接。 */
+  /** 向一条配对会话发一条载荷；返回 false = 这条会话已经没了，或**现在没有活着的客户端**。 */
   send(conversationId, payload) {
     const conversation = this.conversations.get(conversationId);
     if (!conversation) return false;
+    if (conversation.clientIds.size === 0) return false;
     const record2 = seal(conversation.kH2C, payload);
     conversation.lastActivityAt = this.options.clock.now();
+    this.options.onBookActivity?.();
     return this.raw({ t: "enc", sessionId: conversationId, seq: ++conversation.seqHost, ciphertext: record2.ciphertext });
   }
   broadcast(payload) {
     let sent = 0;
     for (const id of this.conversations.ids()) {
+      if (!this.conversations.hasClient(id)) continue;
       if (this.send(id, payload)) sent += 1;
     }
     return sent;
   }
-  hasPeer(conversationId) {
-    return this.conversations.has(conversationId);
+  /**
+   * 这条会话**现在**有没有能收到东西的手机。
+   *
+   * 原来这个方法叫 `hasPeer`、答的是"我手里有没有这条通道的密钥"——两者在手机上线时恰好
+   * 同真，所以错误一直藏着：手机断开后审批仍然"发得出去"（发进一条空会话），
+   * 桌面那一半要等满 180 秒才拿到决定权。名字换成 `hasClient` 是为了让下一次
+   * 想写 `conversations.has()` 的人当场看见这两个概念不是一回事。
+   */
+  hasClient(conversationId) {
+    return this.conversations.hasClient(conversationId);
   }
   conversationIds() {
     return this.conversations.ids();
@@ -31978,6 +32383,7 @@ var RelayClient = class {
     this.voided.add(conversationId);
     this.undecryptable.delete(conversationId);
     this.conversations.close(conversationId);
+    this.options.onStructuralChange?.();
     this.raw({ t: "session-leave", sessionId: conversationId });
     this.options.onConversationGone(conversationId);
   }
@@ -32000,18 +32406,24 @@ var RelayClient = class {
     switch (frame.t) {
       case "hello-ok": {
         this.generation += 1;
-        const dropped = this.conversations.closeBefore(this.generation);
-        for (const id of dropped) this.options.onConversationGone(id);
         this.emitState("online");
         this.raw({ t: "resync", sessionIds: this.conversations.ids() });
-        this.options.log("relay online", { generation: this.generation, conversations: this.conversations.size });
+        this.options.log("relay online", {
+          generation: this.generation,
+          conversations: this.conversations.size,
+          clients: this.conversations.clientCount()
+        });
         return;
       }
       case "pair-ready":
         this.options.onPairReady(frame.pairingToken, frame.ttlMs);
         return;
       case "peer-joined": {
-        if (!frame.pairingToken) return;
+        if (!frame.pairingToken) {
+          const conversation = this.conversations.get(frame.sessionId);
+          if (conversation && frame.clientId) conversation.clientIds.add(frame.clientId);
+          return;
+        }
         const slot = this.options.lookupPairingSlot(frame.pairingToken);
         if (!slot) {
           this.options.log("peer-joined without a known pairing token", { sessionId: frame.sessionId });
@@ -32020,9 +32432,10 @@ var RelayClient = class {
         this.conversations.open({
           id: frame.sessionId,
           psk: slot.psk,
-          generation: this.generation,
           now: this.options.clock.now()
         });
+        this.options.onStructuralChange?.();
+        if (frame.clientId) this.conversations.get(frame.sessionId)?.clientIds.add(frame.clientId);
         this.voided.delete(frame.sessionId);
         this.raw({ t: "resync", sessionIds: this.conversations.ids() });
         this.emitState("online");
@@ -32030,6 +32443,7 @@ var RelayClient = class {
         return;
       }
       case "peer-left":
+        if (frame.clientId) this.conversations.get(frame.sessionId)?.clientIds.delete(frame.clientId);
         this.options.onClientLeft(frame.sessionId, frame.clientId);
         this.emitState("online");
         return;
@@ -32062,6 +32476,7 @@ var RelayClient = class {
       this.voidConversation(frame.sessionId);
       return;
     }
+    if (frame.clientId) conversation.clientIds.add(frame.clientId);
     const records = frame.items ?? (frame.ciphertext === void 0 ? [] : [{ ciphertext: frame.ciphertext }]);
     let decryptedAny = false;
     for (const record2 of records) {
@@ -32080,8 +32495,11 @@ var RelayClient = class {
       decryptedAny = true;
       this.options.onCommand(frame.sessionId, cmd, frame.clientId);
     }
-    if (decryptedAny) conversation.lastActivityAt = this.options.clock.now();
-    if (decryptedAny) this.undecryptable.delete(frame.sessionId);
+    if (decryptedAny) {
+      conversation.lastActivityAt = this.options.clock.now();
+      this.options.onBookActivity?.();
+      this.undecryptable.delete(frame.sessionId);
+    }
   }
   /** 两次解不开就作废（与手机端"两帧解不开就丢配对"对称，避免一端永久静默）。 */
   noteUndecryptable(conversationId) {
@@ -32118,7 +32536,10 @@ var RelayClient = class {
     this.options.onState({
       relay,
       ...problem === void 0 ? {} : { problem },
-      clients: this.conversations.size,
+      // 之前这里写的是 `conversations.size`，把"会话数"顶替成了"客户端数"：
+      // 一部手机解配再重配就多一条会话，于是这个字段会**变大** ——
+      // 拿它回答"现在有几台手机连着"会得出相反的结论。
+      clients: this.conversations.clientCount(),
       conversations: this.conversations.size,
       generation: this.generation
     });
@@ -32230,7 +32651,7 @@ var WATERFALL_EVENTS = [
   "tools/post-execute",
   "tools/code-dispatch-log"
 ];
-var WATERFALL_PARTICIPANTS = ["approval/request"];
+var WATERFALL_PARTICIPANTS = ["approval/request", "user-questions/request"];
 var allowed = new Set(SUBSCRIBABLE_EVENTS);
 var participants = new Set(WATERFALL_PARTICIPANTS);
 function canParticipate(name) {
@@ -32265,11 +32686,45 @@ function guardedSubscribe(on, name, listener, warn) {
 }
 
 // src/platform/carrier-services.ts
+var PARTICIPATE_OPTIONS = { global: true, prepend: true };
+var PARTICIPATED_EVENTS = ["approval/request", "user-questions/request"];
+function fuseSignals(platform, ours) {
+  if (!platform) return ours;
+  const any2 = AbortSignal.any;
+  if (typeof any2 === "function") return any2.call(AbortSignal, [platform, ours]);
+  const fused = new AbortController();
+  for (const source of [platform, ours]) {
+    if (fused.signal.aborted) break;
+    if (source.aborted) {
+      fused.abort(source.reason);
+      break;
+    }
+    source.addEventListener("abort", () => fused.abort(source.reason), { once: true });
+  }
+  return fused.signal;
+}
 var MAX_TITLE_BATCH_DEFAULT = 25;
 var TITLE_TIMEOUT_DEFAULT = 4e3;
 var HISTORY_TIMEOUT_DEFAULT = 15e3;
 var CREATE_TIMEOUT_DEFAULT = 8e3;
 var LIST_LIMIT_DEFAULT = 100;
+var MODEL_FACE_METHODS = [
+  "currentSelection",
+  "list",
+  "listModels",
+  "available",
+  "availableModels",
+  "selections",
+  "options",
+  "get",
+  "set",
+  "select",
+  "setSelection",
+  "setDefault",
+  "update"
+];
+var MODEL_LIST_METHODS = /* @__PURE__ */ new Set(["list", "listModels", "available", "availableModels", "selections", "options"]);
+var MODEL_SET_METHODS = /* @__PURE__ */ new Set(["set", "select", "setSelection", "setDefault", "update"]);
 function createServicesKernel(services, options) {
   const log = (message, fields = {}) => options.log?.(message, fields);
   const titleCache = /* @__PURE__ */ new Map();
@@ -32278,8 +32733,25 @@ function createServicesKernel(services, options) {
   const unmappedEventTypes = /* @__PURE__ */ new Set();
   const injectedUserMessages = /* @__PURE__ */ new Map();
   const listenerErrors = /* @__PURE__ */ new Map();
-  let approvalFace = "not-attached";
-  let questionsFace = "pending";
+  const faces = {
+    "approval/request": {
+      registered: "not-attached",
+      calls: 0,
+      last: "not-called",
+      desktopVoided: 0,
+      handoff: "unknown"
+    },
+    "user-questions/request": {
+      registered: "not-attached",
+      calls: 0,
+      last: "not-called",
+      desktopVoided: 0,
+      handoff: "unknown"
+    }
+  };
+  let approvalAsked = 0;
+  let approvalDecided = "not-seen";
+  const modelMethods = [];
   const fn = (owner, name) => {
     if (!owner) return void 0;
     const value = owner[name];
@@ -32303,6 +32775,17 @@ function createServicesKernel(services, options) {
       return void 0;
     }
   }
+  function firstLiveAgent() {
+    const list = fn(services.agents, "list");
+    if (list) {
+      try {
+        const all = list.call(services.agents);
+        if (Array.isArray(all) && all.length) return all[0];
+      } catch {
+      }
+    }
+    return void 0;
+  }
   function agentStatus(sessionId) {
     const agent = liveAgent(sessionId);
     const status = agent?.status;
@@ -32467,6 +32950,27 @@ function createServicesKernel(services, options) {
       return void 0;
     }
   }
+  function probeModelFace() {
+    const owner = services.agentDefaultModel;
+    if (!owner) return { hits: [], canList: false, canSet: false };
+    const hits = [];
+    for (const name of MODEL_FACE_METHODS) {
+      if (fn(owner, name)) hits.push(name);
+    }
+    modelMethods.length = 0;
+    modelMethods.push(...hits);
+    return {
+      hits,
+      canList: hits.some((n) => MODEL_LIST_METHODS.has(n)),
+      canSet: hits.some((n) => MODEL_SET_METHODS.has(n))
+    };
+  }
+  function modelFaceSummary() {
+    if (!services.agentDefaultModel) return "absent";
+    const { hits, canList, canSet } = probeModelFace();
+    if (!hits.length) return `none (tried=${MODEL_FACE_METHODS.length})`;
+    return `${canList ? "list" : "no-list"}+${canSet ? "set" : "no-set"} via=${hits.join(",")}`.slice(0, 180);
+  }
   async function sendPrompt(sessionId, text) {
     const agent = liveAgent(sessionId);
     if (!agent) return { ok: false, message: `\u4F1A\u8BDD\u6CA1\u6709\u6D3B\u7684 agent\uFF08agents.get(${sessionId}) \u4E3A\u7A7A\uFF0C\u8BF7\u5148\u6062\u590D\u4F1A\u8BDD\uFF09` };
@@ -32591,6 +33095,8 @@ function createServicesKernel(services, options) {
     if (!sessionId || !type) return;
     seenEventTypes.add(type);
     const data = event?.data ?? {};
+    if (type === "approval/asked") approvalAsked += 1;
+    if (type === "approval/decided") approvalDecided = String(data.outcome ?? "?");
     for (const mapped of sessionEventKernelEvents({ sessionId, type, seq: event?.seq, data })) {
       if (mapped.kind === "title") titleCache.set(sessionId, { title: mapped.title, at: options.clock.now() });
       onEvent(mapped);
@@ -32617,59 +33123,34 @@ function createServicesKernel(services, options) {
     sink = next;
     const disposers = [];
     const on = services.on;
-    if (typeof on === "function") {
-      const name = "approval/request";
-      if (canParticipate(name)) {
-        const listener = (...args) => participate(args);
-        try {
-          const disposer = on.call(services, name, listener);
-          approvalFace = "registered";
-          disposers.push(() => {
-            if (typeof disposer === "function") disposer();
-            else if (typeof services.off === "function") services.off(name, listener);
-          });
-        } catch (error62) {
-          approvalFace = `failed: ${messageOf3(error62)}`.slice(0, 80);
-          log("approval/request participation failed", { message: messageOf3(error62) });
-        }
-      } else {
-        approvalFace = "refused by guard";
-      }
-    } else {
-      approvalFace = "no on()";
-    }
-    const questions = services.userQuestions;
-    if (!options.takeOverQuestions) {
-      questionsFace = "not-taken-over";
-    } else if (!questions || typeof questions.registerProvider !== "function") {
-      questionsFace = `no registerProvider (keys=${questions ? shapeOf(questions) : "service absent"})`.slice(0, 120);
-    }
-    if (options.takeOverQuestions && questions && typeof questions.registerProvider === "function") {
-      const provider = {
-        ask: async (request) => {
-          const agent = request.agent;
-          const sessionId = String(agent?.session?.id ?? request.sessionId ?? "");
-          const items = Array.isArray(request.questions) ? request.questions : [];
-          const mapped = items.map((item, index) => mapQuestion(item, index));
-          const answer = await sink?.question({
-            sessionId,
-            questions: mapped,
-            ...request.signal ? { signal: request.signal } : {}
-          });
-          if (!answer) {
-            throw new Error("\u624B\u673A\u7AEF\u672A\u5E94\u7B54\u8FD9\u6B21\u63D0\u95EE\uFF08\u672A\u914D\u5BF9\u3001\u4E0D\u5728\u7EBF\u6216\u5DF2\u8D85\u65F6\uFF09");
-          }
-          return { answers: answer.answers };
-        }
+    if (typeof on !== "function") {
+      for (const name of PARTICIPATED_EVENTS) faces[name].registered = "no on()";
+      return () => {
+        sink = void 0;
       };
+    }
+    for (const name of PARTICIPATED_EVENTS) {
+      const face = faces[name];
+      if (!canParticipate(name)) {
+        face.registered = "refused by guard";
+        continue;
+      }
+      const listener = (...args) => participate(name, args);
       try {
-        const dispose = questions.registerProvider.call(questions, provider);
-        if (typeof dispose === "function") disposers.push(dispose);
-        questionsFace = "registered";
-        log("question provider taken over from the desktop UI");
+        const disposer = on.call(
+          services,
+          name,
+          listener,
+          PARTICIPATE_OPTIONS
+        );
+        face.registered = "registered";
+        disposers.push(() => {
+          if (typeof disposer === "function") disposer();
+          else if (typeof services.off === "function") services.off(name, listener);
+        });
       } catch (error62) {
-        questionsFace = `failed: ${messageOf3(error62)}`.slice(0, 80);
-        log("question provider registration failed", { message: messageOf3(error62) });
+        face.registered = `failed: ${messageOf3(error62)}`.slice(0, 80);
+        log(`${name} participation failed`, { message: messageOf3(error62) });
       }
     }
     return () => {
@@ -32682,23 +33163,103 @@ function createServicesKernel(services, options) {
       }
     };
   }
-  async function participate(args) {
+  async function participate(event, args) {
+    const isApproval = event === "approval/request";
+    const face = faces[event];
+    face.calls += 1;
     const request = args.find(
-      (arg) => arg && typeof arg === "object" && typeof arg.toolName === "string"
+      (arg) => Boolean(arg) && typeof arg === "object" && (isApproval ? typeof arg.toolName === "string" : Array.isArray(arg.questions))
     );
     const next = args.find((arg) => typeof arg === "function");
     const sessionId = String(request?.agent?.session?.id ?? "");
     if (!sink || !sessionId || !servicesPeers()) {
-      return String(await next?.() ?? "unavailable");
+      face.last = "handed-back(no phone target)";
+      const value = await next?.();
+      return isApproval ? String(value ?? "unavailable") : value;
+    }
+    const controller = new AbortController();
+    const platform = request?.signal;
+    if (platform) {
+      if (platform.aborted) controller.abort("platform");
+      else platform.addEventListener("abort", () => controller.abort("platform"), { once: true });
+    }
+    const canceller = new AbortController();
+    let handedOff = false;
+    if (request) {
+      try {
+        const fused = fuseSignals(platform, canceller.signal);
+        request.signal = fused;
+        handedOff = request.signal === fused;
+        face.handoff = handedOff ? "fused" : "ignored";
+      } catch (error62) {
+        face.handoff = `failed: ${messageOf3(error62)}`.slice(0, 80);
+      }
     }
-    const decision = await sink.approval({
+    const finish = (reason) => {
+      if (!canceller.signal.aborted) canceller.abort(reason);
+    };
+    const desktop = Promise.resolve().then(() => next?.()).then(
+      (value) => (
+        // `undefined` 是"这个参与者没认领"（会把整条链冲掉），不是答案；
+        // `'unavailable'` 是审批那条链末端的"没人可问"，也不是答案。
+        value === void 0 || isApproval && value === "unavailable" ? { answered: false, value } : { answered: true, value }
+      ),
+      (error62) => ({ answered: false, error: error62 })
+    );
+    const asked = isApproval ? sink.approval({
       sessionId,
       action: String(request?.toolName ?? "\u5DE5\u5177\u8C03\u7528"),
       ...request?.reason ? { reason: String(request.reason) } : {},
-      ...request?.signal ? { signal: request.signal } : {}
+      signal: controller.signal
+    }) : sink.question({
+      sessionId,
+      questions: (request?.questions ?? []).map((item, index) => mapQuestion(item, index)),
+      signal: controller.signal
     });
-    if (decision === "decline") return String(await next?.() ?? "unavailable");
-    return decision;
+    const phone = asked.then(
+      (value) => (
+        // 每一支都**带着自己是谁**回来：`'rejected'` 这个词手机和桌面都可能给出，
+        // 只比数值就没法知道该收哪一张卡（第一版就是这么错的）。
+        isApproval ? value === "allowed-once" || value === "rejected" ? { answered: true, value } : { answered: false, value } : value === null || value === void 0 ? { answered: false, value } : { answered: true, value }
+      ),
+      // runtime 抛了（未配对、不在线、被撤）同样不算答案。
+      () => ({ answered: false })
+    );
+    const pending = new Promise(() => {
+    });
+    const winner = await Promise.race([
+      phone.then((chain) => chain.answered ? { src: "phone", chain } : pending),
+      desktop.then((chain) => chain.answered ? { src: "desktop", chain } : pending),
+      Promise.all([phone, desktop]).then(([, chain]) => ({ src: "desktop", chain }))
+    ]);
+    if (!winner.chain.answered) {
+      controller.abort("desktop");
+      finish("settled-without-answer");
+      if (isApproval) {
+        face.last = "handed-back(neither answered)";
+        return "unavailable";
+      }
+      face.last = "no-answer";
+      if (winner.chain.error !== void 0) throw winner.chain.error;
+      throw new Error("\u624B\u673A\u7AEF\u672A\u5E94\u7B54\u8FD9\u6B21\u63D0\u95EE\uFF08\u672A\u914D\u5BF9\u3001\u4E0D\u5728\u7EBF\u6216\u5DF2\u8D85\u65F6\uFF09");
+    }
+    if (winner.src === "desktop") controller.abort("desktop");
+    if (winner.src === "phone") {
+      finish("answered-by-phone");
+      if (handedOff) face.desktopVoided += 1;
+    } else {
+      finish("answered-by-desktop");
+    }
+    face.last = `${winner.src === "phone" ? "answered-by-phone" : "answered-by-desktop"}(${describeOutcome(
+      isApproval,
+      winner.chain.value
+    )})`;
+    return winner.chain.value;
+  }
+  function describeOutcome(isApproval, value) {
+    if (isApproval) return String(value);
+    const answers = value?.answers;
+    return Array.isArray(answers) ? `${answers.length} \u9879` : typeof value;
   }
   function servicesPeers() {
     return sink !== void 0;
@@ -32737,6 +33298,22 @@ function createServicesKernel(services, options) {
     // 与发指令/续跑走同一条读取路径：这里原来还有一份实现，而且是 `current()` 裸调用
     // （不带 receiver；真要用 this 的服务方法会当场抛），两份迟早分叉。
     modelSelection: currentSelection,
+    /**
+     * 可切换模型清单。**这一代内核给不出清单也换不了**（`agentDefaultModel` 上只有
+     * `currentSelection`），所以这里报 `canSwitch: false` 并附一句人话。
+     *
+     * 报false 而不是省略这个方法：省略会被 core 当成"只读"但**说不出原因**，
+     * 手机上就只剩一个置灰的模型名，用户不知道是主机不支持还是自己哪里做错了。
+     */
+    modelOptions() {
+      const { hits, canList, canSet } = probeModelFace();
+      return {
+        // 两个都要有才算能切：只有 list 没有 set 时手机上会列出候选却点了没反应，
+        // 那比"换不了"更糟。
+        canSwitch: canList && canSet,
+        reason: canList && canSet ? void 0 : `\u4E3B\u673A\u5185\u6838\u53EA\u63D0\u4F9B\u8BFB\u53D6\uFF08\u547D\u4E2D\uFF1A${hits.join(",") || "\u65E0"}\uFF09`
+      };
+    },
     describe() {
       return {
         carrier: "services",
@@ -32748,19 +33325,41 @@ function createServicesKernel(services, options) {
         // 新建会话只依赖这一条。和 historyFace 同理：真机上"新建没反应"第一件要分清的事
         // 是宿主没有这个能力，还是我们没调对。
         createFace: typeof fn(services.sessionController?.commands, "create") === "function" ? "commands.create" : `absent (keys=${shapeOf(services.sessionController)})`.slice(0, 120),
+        // 第二条换模型的可能路径：命令控制器上自带的方法（`setModel` / `switchModel`…），
+        // 以及活agent 自己暴露的模型字段。前者能列出来就说明这条路通不通。
+        commandsFace: shapeOf(services.sessionController?.commands),
+        agentModelFields: (() => {
+          const first = firstLiveAgent();
+          if (!first) return "no-live-agent";
+          return Object.keys(first).filter((k) => /model|provider|preset/i.test(k)).slice(0, 8).join(",") || "none";
+        })(),
         agents: typeof services.agents === "object",
         agentDefaultModel: typeof services.agentDefaultModel === "object",
+        // 模型面到底有没有"写"的能力（能列可选、能切换）。手机上模型下拉该不该置灰，
+        // 取决于这个而不是取决于"读得到当前值" —— 读得到只够显示一行文字。
+        modelFace: modelFaceSummary(),
         workspaceRegistry: typeof services.workspaceRegistry === "object",
         userQuestions: typeof services.userQuestions === "object",
-        takeOverQuestions: options.takeOverQuestions === true,
         archivedSessions: archivedIds().size,
         hasOn: typeof services.on === "function",
         // 真机排错的第一现场：内核到底发了哪些事件类型、其中哪些我们没认。
         eventTypes: [...seenEventTypes].slice(-24).join("|"),
         unmappedEventTypes: [...unmappedEventTypes].join("|"),
         injectedUserMessages: [...injectedUserMessages].map(([kind, count]) => `${count}\xD7${kind}`).join("|") || "none",
-        approvalFace,
-        questionsFace,
+        approvalFace: faces["approval/request"].registered,
+        approvalCalls: faces["approval/request"].calls,
+        approvalLast: faces["approval/request"].last,
+        approvalAsked,
+        approvalDecided,
+        approvalDesktopVoided: faces["approval/request"].desktopVoided,
+        approvalSignalHandoff: faces["approval/request"].handoff,
+        // 提问那一条与审批同构，所以读数也同一套：登记结果 / 被派发几次 / 最后走到哪一步 /
+        // 手机先答时撤销了几次下游 signal / 那份 signal 换没换成功。
+        questionsFace: faces["user-questions/request"].registered,
+        questionsCalls: faces["user-questions/request"].calls,
+        questionsLast: faces["user-questions/request"].last,
+        questionsDesktopVoided: faces["user-questions/request"].desktopVoided,
+        questionsSignalHandoff: faces["user-questions/request"].handoff,
         listenerErrors: [...listenerErrors].slice(0, 4).map(([key, count]) => `${count}\xD7${key}`).join(" | ") || "none"
       };
     }
@@ -32782,17 +33381,19 @@ function sessionEventKernelEvents(input2) {
   switch (type) {
     case "turn/start":
       return [{ kind: "run-state", sessionId, state: "running" }];
-    case "assistant/message":
+    case "assistant/message": {
+      const text = stripToolCallXml(textOf(data));
       return [
         {
           kind: "delta",
           sessionId,
           messageId: messageIdOf(data, input2.seq),
-          text: textOf(data),
+          text,
           role: "assistant",
           done: true
         }
       ];
+    }
     case "user/message": {
       if (!isHumanUserMessage(data)) return [];
       return [
@@ -32815,8 +33416,8 @@ function sessionEventKernelEvents(input2) {
           callId: String(data.callId ?? data.id ?? `tool_${input2.seq ?? 0}`),
           phase: argsRaw === void 0 || argsRaw === null ? "started" : "args",
           tool: typeof data.name === "string" ? data.name : void 0,
-          title: typeof data.title === "string" ? data.title : previewOf(argsRaw),
-          ...argsRaw === void 0 ? {} : { argsPreview: previewOf(argsRaw) }
+          title: typeof data.title === "string" ? data.title : argsTitle(argsRaw),
+          ...argsRaw === void 0 ? {} : { argsPreview: argsPreviewOf(argsRaw) }
         }
       ];
     }
@@ -32967,9 +33568,67 @@ function messageIdOf(data, seq) {
   if (typeof id === "string" && id) return id;
   return `msg_${String(seq ?? Date.now())}`;
 }
-function previewOf(value) {
+var TOOL_CALL_BLOCK = /<tool_call>\s*<function=[\s\S]*?<\/tool_call>/g;
+var TOOL_CALL_UNCLOSED = /<tool_call>\s*<function=[\s\S]*$/;
+function stripToolCallXml(text) {
+  const stripped = text.replace(TOOL_CALL_BLOCK, "").replace(TOOL_CALL_UNCLOSED, "");
+  return stripped.trim() === "" ? "" : stripped;
+}
+function argsTitle(argsRaw) {
+  const parsed = tryParseJson(argsRaw);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const record2 = parsed;
+    for (const key of ["description", "prompt", "command", "path", "file_path", "pattern", "query", "url"]) {
+      const value = record2[key];
+      if (typeof value === "string" && value.trim()) return oneLine(value);
+    }
+  }
+  return previewOf(argsRaw);
+}
+function argsPreviewOf(argsRaw) {
+  const parsed = tryParseJson(argsRaw);
+  if (parsed !== void 0) {
+    try {
+      return previewOf(JSON.stringify(parsed, null, 2));
+    } catch {
+    }
+  }
+  return previewOf(argsRaw);
+}
+function tryParseJson(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function oneLine(text) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > 120 ? `${flat.slice(0, 120)}\u2026` : flat;
+}
+function readableText(value) {
   if (value === void 0 || value === null) return void 0;
-  const text = typeof value === "string" ? value : safeJson(value);
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    const parts = value.map((part) => readableText(part)).filter((part) => typeof part === "string" && part.length > 0);
+    return parts.length > 0 ? parts.join("\n") : void 0;
+  }
+  if (typeof value === "object") {
+    const record2 = value;
+    for (const key of ["content", "text", "output", "stdout", "stderr", "message", "result", "error"]) {
+      if (record2[key] === void 0 || record2[key] === null) continue;
+      const nested = readableText(record2[key]);
+      if (nested !== void 0 && nested !== "") return nested;
+    }
+    if (typeof record2.type === "string" && record2.type !== "text") return void 0;
+    return safeJson(record2);
+  }
+  return safeJson(value);
+}
+function previewOf(value) {
+  const text = readableText(value);
   if (!text) return void 0;
   return text.length > 200 ? `${text.slice(0, 200)}\u2026` : text;
 }
@@ -33033,7 +33692,7 @@ function createOneShotTimers(clock) {
 
 // src/shell/status.ts
 import { mkdirSync, renameSync, writeFileSync } from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 var StatusFile = class {
   constructor(file2, clock, refreshMs = 3e3) {
     this.file = file2;
@@ -33047,7 +33706,7 @@ var StatusFile = class {
   write(snapshot) {
     if (!this.file) return;
     try {
-      mkdirSync(path.dirname(this.file), { recursive: true });
+      mkdirSync(path2.dirname(this.file), { recursive: true });
       const tmp = `${this.file}.tmp-${process.pid}`;
       writeFileSync(
         tmp,
@@ -33087,9 +33746,174 @@ var StatusFile = class {
   }
 };
 
+// src/shell/host-id.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { chmodSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
+import path3 from "node:path";
+var HOST_ID = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/;
+function newHostId() {
+  return `drc-${randomBytes4(6).toString("hex")}`;
+}
+function resolveHostId(dir, configured) {
+  if (configured) return configured;
+  if (!dir) return newHostId();
+  const file2 = path3.join(dir, "host-id");
+  let existing;
+  try {
+    existing = readFileSync(file2, "utf8").trim();
+  } catch {
+    existing = void 0;
+  }
+  if (existing !== void 0 && HOST_ID.test(existing)) return existing;
+  const fresh = newHostId();
+  try {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(file2, `${fresh}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: existing === void 0 ? "wx" : "w"
+    });
+    chmodSync(file2, 384);
+    return fresh;
+  } catch {
+    try {
+      const raced = readFileSync(file2, "utf8").trim();
+      if (HOST_ID.test(raced)) return raced;
+    } catch {
+    }
+    return fresh;
+  }
+}
+
+// src/shell/pair-store.ts
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import path4 from "node:path";
+var storedConversationSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  /** 配对 PSK（base64）。两把方向密钥在恢复时由它现派生，不落盘。 */
+  psk: external_exports.string().min(1),
+  /** host→client 方向的本地序号。中继会重新编号，客户端从不读它（F13），
+   *  但保留它能让恢复后的编号不跳号，便于对拍排查。 */
+  seqHost: external_exports.number().int().nonnegative(),
+  createdAt: external_exports.number().finite().nonnegative(),
+  lastActivityAt: external_exports.number().finite().nonnegative()
+});
+var storeSchema = external_exports.object({
+  version: external_exports.literal(1),
+  /** 这个文件属于哪台主机：换了主机身份就不该认（凭据不该跨身份复用）。 */
+  hostId: external_exports.string().min(1),
+  savedAt: external_exports.number().finite().nonnegative(),
+  conversations: external_exports.array(storedConversationSchema)
+});
+function safeSegment2(hostId) {
+  const cleaned = hostId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 48);
+  const tag = createHash2("sha256").update(hostId).digest("hex").slice(0, 8);
+  return `${cleaned || "host"}-${tag}`;
+}
+function defaultPairStoreFile(statusFile, hostId) {
+  if (!statusFile) return "";
+  return path4.join(path4.dirname(statusFile), `conversations-${safeSegment2(hostId)}.json`);
+}
+var PairStore = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  /** 上一次成功写盘的时刻，供 status.json 回答"这份落盘是什么时候的"。 */
+  savedAt = 0;
+  /** 上次 save 之后发生过任何变化（含只改了 lastActivityAt）。 */
+  dirty = false;
+  get file() {
+    return this.options.file;
+  }
+  get lastSavedAt() {
+    return this.savedAt;
+  }
+  /** 有没有待落盘的变更。status 的 3 秒 tick 用它决定是否真写盘。 */
+  get hasPendingChanges() {
+    return this.dirty;
+  }
+  /** 只标脏，不写盘。高频变动（每次广播都动 `seqHost`）走这条。 */
+  markDirty() {
+    this.dirty = true;
+  }
+  /**
+   * 读回本机的会话记录。
+   *
+   * 三种"读不出来"都归到**空簿 + 一条日志**，绝不抛（红线：插件起不来比丢配对更糟）：
+   * 文件不存在（第一次跑）、JSON 坏了（半写/被手改）、形状不认识（版本升级）。
+   * `hostId` 不匹配也算读不出来：那份文件属于另一台主机。
+   */
+  load() {
+    const { file: file2, hostId, log } = this.options;
+    if (!file2) return [];
+    let raw;
+    try {
+      raw = readFileSync2(file2, "utf8");
+    } catch {
+      return [];
+    }
+    const parsed = storeSchema.safeParse(safeJsonParse(raw));
+    if (!parsed.success) {
+      log?.("pair-store unreadable, starting with an empty book", {
+        reason: parsed.error.issues[0]?.message?.slice(0, 80) ?? "shape mismatch"
+      });
+      return [];
+    }
+    if (parsed.data.hostId !== hostId) {
+      log?.("pair-store belongs to another host, starting with an empty book", {
+        fileHostId: parsed.data.hostId.slice(0, 24)
+      });
+      return [];
+    }
+    this.savedAt = parsed.data.savedAt;
+    return parsed.data.conversations;
+  }
+  /**
+   * 写盘。**结构性的变化（新建/作废会话）必须立刻调这个**；
+   * 只改了 `lastActivityAt`/`seqHost` 的场合走 {@link markDirty}，由 3 秒 tick 批量落。
+   *
+   * 失败只记日志：写不进盘（目录只读、磁盘满）时，本次运行仍能正常收发，
+   * 只是下次重启要重新扫码 —— 那是可接受的退化，让插件崩掉不是。
+   */
+  save(conversations, now) {
+    const { file: file2, hostId, log } = this.options;
+    if (!file2) return false;
+    const body = JSON.stringify({ version: 1, hostId, savedAt: now, conversations }) + "\n";
+    const tmp = `${file2}.tmp-${process.pid}`;
+    try {
+      mkdirSync3(path4.dirname(file2), { recursive: true });
+      writeFileSync3(tmp, body, { encoding: "utf8", mode: 384 });
+      chmodSync2(tmp, 384);
+      renameSync2(tmp, file2);
+      this.savedAt = now;
+      this.dirty = false;
+      return true;
+    } catch (error62) {
+      log?.("pair-store save failed (pairing will need a rescan after the next restart)", {
+        message: String(error62?.message ?? error62).slice(0, 120)
+      });
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+      return false;
+    }
+  }
+};
+function safeJsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/shell/config.ts
 import { homedir } from "node:os";
-import path2 from "node:path";
+import path5 from "node:path";
 var DEFAULT_CONFIG = {
   enabled: true,
   serverUrl: "ws://127.0.0.1:8787",
@@ -33099,19 +33923,44 @@ var DEFAULT_CONFIG = {
   hostLabel: "dsh-host",
   keepAwake: { enabled: true, idleReleaseSec: 300, keepDisplay: false },
   mockBridge: false,
-  statusFile: path2.join(homedir(), ".dsh", "dsh-remote-control", "status.json"),
+  statusFile: path5.join(homedir(), ".dsh", "dsh-remote-control", "status.json"),
   unarchiveOnPrompt: true,
   pairOnStartSec: 0,
   pairTtlMs: 12e4,
   carrierGraceMs: 5e3,
-  takeOverQuestions: false,
   approvalTimeoutSec: 180,
   listingRefreshSec: 15,
   conversationIdleTtlSec: 86400,
+  // 恢复出来的会话按 7 天剪，与中继的 DRC_CONV_IDLE_TTL_MS 对齐（理由见该字段注释）。
+  restoredIdleTtlSec: 604800,
+  // 密钥簿落盘：默认跟着 statusFile 走（见 `resolvePairStoreFile`）。
+  pairStoreFile: "",
+  // 图片附件落盘：默认 status.json 同目录的 uploads/（见 `resolveUploadDir`）。
+  uploadDir: "",
+  maxImageBytes: 4 * 1024 * 1024,
   // 配对的唯一入口。关掉它 = 这台主机**没有**配对入口（`/drc pair` 与文本二维码都在
   // 2026-10-03 删掉了），所以 index.ts 会把它记成一条 warn 而不是安静地什么都不做。
   pill: { enabled: true }
 };
+var PAIR_STORE_OFF = "off";
+function resolvePairStoreFile(config2, hostId) {
+  if (config2.pairStoreFile === PAIR_STORE_OFF) return "";
+  const configured = config2.pairStoreFile.trim();
+  if (!configured) return defaultPairStoreFile(config2.statusFile, hostId);
+  if (configured.startsWith("/")) return configured;
+  if (!config2.statusFile) return configured;
+  return path5.join(path5.dirname(config2.statusFile), configured);
+}
+function resolveUploadDir(config2) {
+  const configured = config2.uploadDir.trim();
+  if (!configured) {
+    const base = config2.statusFile ? path5.dirname(config2.statusFile) : path5.join(homedir(), ".dsh", "dsh-remote-control");
+    return path5.join(base, "uploads");
+  }
+  if (configured.startsWith("/")) return configured;
+  if (!config2.statusFile) return configured;
+  return path5.join(path5.dirname(config2.statusFile), configured);
+}
 var loopback = /^wss?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/;
 var wsUrl = /^wss?:\/\/.+/;
 function envSeconds(value) {
@@ -33139,7 +33988,6 @@ function readConfig(injected, env = process.env) {
   if (fromEnv("DRC_PAIR_ON_START_SEC")) merged.pairOnStartSec = envSeconds(env.DRC_PAIR_ON_START_SEC);
   if (fromEnv("DRC_PILL")) merged.pill.enabled = envFlag(env.DRC_PILL, merged.pill.enabled);
   if (fromEnv("DRC_MOCK_BRIDGE") === "1") merged.mockBridge = true;
-  if (fromEnv("DRC_TAKE_OVER_QUESTIONS") === "1") merged.takeOverQuestions = true;
   if (merged.hostTokenEnv) merged.hostToken = env[merged.hostTokenEnv] ?? merged.hostToken;
   return merged;
 }
@@ -33196,6 +34044,14 @@ function validateConfig(config2) {
     });
     config2.conversationIdleTtlSec = 86400;
   }
+  if (!secondsSchema.safeParse(config2.restoredIdleTtlSec).success || config2.restoredIdleTtlSec <= 0) {
+    problems.push({
+      level: "warn",
+      field: "restoredIdleTtlSec",
+      message: '\u5FC5\u987B\u662F\u6B63\u6570\u79D2\uFF1B\u8FD9\u91CC\u4E0D\u63A5\u53D7"\u6C38\u4E0D\u526A\u679D"\uFF08\u65E0\u754C\u7684 PSK \u7C3F\u662F\u590D\u6838 \u{1F7E1}8 \u7684\u539F\u59CB\u7F3A\u9677\uFF09\uFF0C\u5DF2\u5939\u56DE 604800'
+    });
+    config2.restoredIdleTtlSec = 604800;
+  }
   if (config2.pairOnStartSec > 0) {
     problems.push({
       level: "warn",
@@ -33206,13 +34062,6 @@ function validateConfig(config2) {
   if (!config2.statusFile) {
     problems.push({ level: "warn", field: "statusFile", message: "\u4E3A\u7A7A\u5C06\u5173\u95ED\u72B6\u6001\u5FEB\u7167\uFF1BGUI \u5BBF\u4E3B\u91CC\u8FD9\u662F\u552F\u4E00\u7684\u6392\u9519\u5165\u53E3" });
   }
-  if (config2.takeOverQuestions) {
-    problems.push({
-      level: "warn",
-      field: "takeOverQuestions",
-      message: "\u63D0\u95EE\u63A5\u7BA1\u4F1A**\u53D6\u4EE3\u684C\u9762 UI \u7684\u63D0\u95EE\u80FD\u529B**\uFF08ctx.userQuestions \u53EA\u5141\u8BB8\u4E00\u4E2A\u6D3B\u8DC3 provider\uFF09\uFF1B\u624B\u673A\u7AEF\u4E0D\u5728\u7EBF\u65F6\u63D0\u95EE\u4F1A\u76F4\u63A5\u5931\u8D25"
-    });
-  }
   return problems;
 }
 function redact(value) {
@@ -33221,7 +34070,7 @@ function redact(value) {
 }
 
 // src/pill/routes.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/platform/qr.ts
 var import_qrcode = __toESM(require_lib(), 1);
@@ -33238,10 +34087,11 @@ async function qrPng(text, options = {}) {
 var PAIR_NEW_ROUTE = "/plugins/dsh-remote-control/pairing/new";
 var PAIR_IMAGE_ROUTE = "/plugins/dsh-remote-control/pairing.png";
 var PAIR_STATUS_ROUTE = "/plugins/dsh-remote-control/status";
+var PAIR_UNPAIR_ROUTE = "/plugins/dsh-remote-control/unpair";
 var PAIR_MARKER_HEADER = "x-drc-pair";
 var PAIR_MARKER_VALUE = "1";
 function pairingEpoch(qr) {
-  return createHash2("sha256").update(qr).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(qr).digest("hex").slice(0, 16);
 }
 async function renderPairingPng(qr) {
   return qrPng(qr);
@@ -33368,20 +34218,45 @@ function pillStatusHandler(deps) {
       json2(response, 200, {
         relay: status.relay,
         paired: status.paired,
-        hostLabel: status.hostLabel,
-        serverUrl: status.serverUrl
+        pairings: status.pairings,
+        serverUrl: status.serverUrl,
+        version: status.version,
+        waiting: status.waiting,
+        waitingOldestSec: status.waitingOldestSec
       });
     } catch (error62) {
       json2(response, 500, { error: String(error62?.message ?? error62).slice(0, 200) });
     }
   };
 }
+function unpairHandler(deps) {
+  return (request, response) => {
+    if (request.method !== "POST") {
+      json2(response, 405, { error: "method not allowed" });
+      return;
+    }
+    const guard = rejectedBy(request);
+    if (guard) {
+      deps.log("\u89E3\u914D\u8BF7\u6C42\u88AB\u5B88\u536B\u62D2", { guard });
+      json2(response, 403, { error: "request-not-trusted", guard });
+      return;
+    }
+    try {
+      const unpaired = deps.unpair();
+      deps.log("\u7ECF\u72B6\u6001\u680F\u9000\u51FA\u914D\u5BF9", { unpaired });
+      json2(response, 200, { state: "ok", unpaired });
+    } catch (error62) {
+      json2(response, 500, { error: String(error62?.message ?? error62).slice(0, 200) });
+    }
+  };
+}
 function registerPillRoutes(webServer, deps) {
   const off = [];
   const definitions = [
     { kind: "exact", path: PAIR_NEW_ROUTE, handler: pairNewHandler(deps) },
     { kind: "exact", path: PAIR_IMAGE_ROUTE, handler: pairImageHandler(deps) },
-    { kind: "exact", path: PAIR_STATUS_ROUTE, handler: pillStatusHandler(deps) }
+    { kind: "exact", path: PAIR_STATUS_ROUTE, handler: pillStatusHandler(deps) },
+    { kind: "exact", path: PAIR_UNPAIR_ROUTE, handler: unpairHandler(deps) }
   ];
   try {
     for (const definition of definitions) off.push(webServer.register(definition));
@@ -33420,6 +34295,7 @@ function startPill(ctx, deps) {
         ensureFresh: () => deps.ensureFresh(),
         current: () => deps.current(),
         status: () => deps.status(),
+        unpair: () => deps.unpair(),
         log
       });
       probe.routes = "registered";
@@ -33505,6 +34381,9 @@ function startPill(ctx, deps) {
   };
 }
 
+// src/version.ts
+var PLUGIN_VERSION = true ? "2.0.1" : "dev";
+
 // src/index.ts
 var SERVICE_NAMES = [
   "sessions",
@@ -33559,7 +34438,7 @@ function applyInner(ctx, injected) {
   const clock = systemClock;
   const oneShot = createOneShotTimers(clock);
   const status = new StatusFile(config2.statusFile, clock);
-  const problems = validateConfig(config2);
+  const hostId = resolveHostId(config2.statusFile ? path6.dirname(config2.statusFile) : "", config2.hostId);
   const log = (message, fields = {}) => {
     try {
       process.stdout.write(
@@ -33569,6 +34448,10 @@ function applyInner(ctx, injected) {
     } catch {
     }
   };
+  const pairStoreFile = resolvePairStoreFile(config2, hostId);
+  const pairStore = new PairStore({ file: pairStoreFile, hostId, log });
+  const restoredAtBoot = pairStoreFile ? pairStore.load() : [];
+  const problems = validateConfig(config2);
   for (const problem of problems) {
     log(`config ${problem.level}`, { field: problem.field, message: problem.message });
   }
@@ -33608,8 +34491,8 @@ function applyInner(ctx, injected) {
     broadcast(payload) {
       return relay ? relay.broadcast(payload) : 0;
     },
-    hasPeer(conversationId) {
-      return relay?.hasPeer(conversationId) ?? false;
+    hasClient(conversationId) {
+      return relay?.hasClient(conversationId) ?? false;
     },
     conversationIds() {
       return relay?.conversationIds() ?? [];
@@ -33624,7 +34507,7 @@ function applyInner(ctx, injected) {
     startedCarrier = port.carrier;
     relay = new RelayClient({
       url: config2.serverUrl,
-      hostId: config2.hostId || `h_${randomBytes4(3).toString("hex")}`,
+      hostId,
       label: config2.hostLabel,
       token: config2.hostToken,
       clock,
@@ -33635,6 +34518,9 @@ function applyInner(ctx, injected) {
         pairingWindow.applyServerTtl(token, ttlMs);
       },
       onPeerJoined: (conversationId, pairingToken2) => {
+        for (const id of relay?.conversationIds() ?? []) {
+          if (id !== conversationId) relay?.voidConversation(id);
+        }
         runtime?.start();
         void runtime?.pushSessions("peer-joined");
         if (pairingToken2) {
@@ -33655,19 +34541,46 @@ function applyInner(ctx, injected) {
       },
       // 配对通道长存（D3）之后必须自己剪枝：中继那边的空闲 TTL 是 7 天，
       // 不剪就是无界的 PSK 簿 + 每次广播对废弃通道逐个密封。
-      prunePolicy: { idleTtlMs: config2.conversationIdleTtlSec * 1e3, maxConversations: MAX_CONVERSATIONS }
+      // 两条 TTL 分开：新配对的按 24 小时剪，从盘上恢复的按 `restoredIdleTtlSec`
+      // （默认 7 天，与中继对齐）—— 理由见 config.ts 与 keys.ts 的 `Conversation.restored`。
+      prunePolicy: {
+        idleTtlMs: config2.conversationIdleTtlSec * 1e3,
+        restoredIdleTtlMs: config2.restoredIdleTtlSec * 1e3,
+        maxConversations: MAX_CONVERSATIONS
+      },
+      // 结构性变化（新配对 / 作废）立刻落盘。只改了 seqHost 与 lastActivityAt 的场合
+      // 由 status 的 3 秒 tick 批量落（见下面 `pairStore.markDirty()` 那一段）——
+      // 挂在这里等于每广播一次写一次盘。
+      onStructuralChange: () => {
+        if (!pairStoreFile || !relay) return;
+        pairStore.save(relay.conversations.snapshot(), clock.now());
+      },
+      onBookActivity: () => {
+        pairStore.markDirty();
+      }
     });
     runtime = new HostRuntime(port, transport, sleep, clock, {
       listingRefreshMs: config2.listingRefreshSec * 1e3,
       unarchiveOnPrompt: config2.unarchiveOnPrompt,
+      uploadDir: resolveUploadDir(config2),
+      maxImageBytes: config2.maxImageBytes,
       approvalTimeoutMs: config2.approvalTimeoutSec * 1e3,
       log: (message, fields) => log(message, fields)
     });
+    const restoredIds = relay.restoreConversations(restoredAtBoot);
+    if (restoredIds.length > 0) {
+      runtime.start();
+      log("runtime started from restored conversations", { conversations: restoredIds.length });
+    }
     relay.connect();
     pairingWindow.tick();
     status.start(() => {
       pairingWindow.tick();
       relay?.pruneConversations();
+      if (pairStoreFile && pairStore.hasPendingChanges && relay) {
+        pairStore.save(relay.conversations.snapshot(), clock.now());
+      }
+      slots.prune();
       return state();
     });
   };
@@ -33692,17 +34605,46 @@ function applyInner(ctx, injected) {
       carrier: startedCarrier || (config2.mockBridge ? "mock" : "probing"),
       serverUrl: config2.serverUrl,
       hostLabel: config2.hostLabel,
+      // 主机身份。中继日志里认的就是它，所以"手机连不上/丢帧涨"第一件事是看这个值
+      // 在两次重启之间有没有变（变了就是身份没稳住，见 shell/host-id.ts）。
+      hostId,
       relay: relay ? relayState() : "idle",
       relayProblem: relayProblem(),
       conversations: relay?.conversationCount ?? 0,
+      /**
+       * 当前连着的手机台数（去重的 clientId）。
+       *
+       * 为什么必须与 `conversations` 分开报：「解除配对 → 重新配对」会开一条**新会话**，
+       * 而手机还是那一台。所以拿会话数回答"几台手机连着"，用户解完配对看到数字反而变大 ——
+       * 那个现象与"我的解配没生效"完全一致，最容易让人把解配按钮当坏的。
+       * `pendingPairs` 是另一个东西：那是**还挂着、还没被用掉的配对码**。
+       */
+      pairedClients: relay?.clientCount ?? 0,
       pendingPairs: slots.size,
+      /**
+       * 密钥簿落盘的排障面。
+       *
+       * `restored` 是"本次启动从盘上恢复了几条会话"——它与 `conversations` 的差值
+       * 就是"落盘没生效"的判据：`conversations > 0 && restored === 0 && pairStore.enabled`
+       * 意味着这些会话是本次运行新配出来的（正常），反过来
+       * `restored > 0` 而 `conversations === 0` 才是异常。
+       *
+       * **`lastSavedAt` 与路径都不含 PSK**：这份快照会被外部脚本读，
+       * 文件路径本身也不是凭据（里面的内容才是）。
+       */
+      pairStore: {
+        enabled: pairStoreFile !== "",
+        file: pairStoreFile || void 0,
+        restored: restoredAtBoot.length,
+        lastSavedAt: pairStoreFile && pairStore.lastSavedAt > 0 ? new Date(pairStore.lastSavedAt).toISOString() : void 0
+      },
       pairing: describeActivePairing(),
       keepAwake: snapshot,
       kernel: kernel?.describe() ?? null,
       // 出站计数：手机上"没收到 X"的第一现场对比点（插件没发 vs 发了但路上丢了）。
       outbound: runtime?.stats ?? null,
       probe,
-      // 配对入口（那颗 pill 的三条路由）为什么没起，是"配不了对"唯一的排查入口：
+      // 配对入口（那颗 pill 的四条路由）为什么没起，是"配不了对"唯一的排查入口：
       // 这里直接把软探测的结果带出来。
       pill: pillRoutes?.probe ?? { webServer: "not-started" },
       // token 永远不出现真值；这条有测试锁住。
@@ -33752,22 +34694,37 @@ function applyInner(ctx, injected) {
   function currentPairing() {
     const shown = active.pairing;
     if (!shown) return null;
-    if (!slots.resolveFor(shown.token)) return null;
-    return { qr: shown.qr, token: shown.token, expiresAt: shown.expiresAt };
+    const slot = slots.resolveFor(shown.token);
+    if (!slot) return null;
+    return { qr: shown.qr, token: shown.token, expiresAt: slot.expiresAt };
   }
   function ensureFreshPairing() {
     const fresh = currentPairing() ?? createPairing();
     if (!fresh) return null;
+    if (fresh.expiresAt <= Date.now()) return createPairing();
     return { qr: fresh.qr, token: fresh.token, expiresAt: fresh.expiresAt };
   }
   function pillStatus() {
+    const waiting = runtime?.waiting ?? { count: 0, oldestSec: 0 };
     return {
       relay: relay ? relayState() : "idle",
-      paired: relay?.conversationCount ?? 0,
-      hostLabel: config2.hostLabel,
-      serverUrl: config2.serverUrl
+      paired: relay?.clientCount ?? 0,
+      // 配对簿里几条会话 = 配对还在不在。为什么必须与 paired 分开：pair-store 之后
+      // 配对按 D3 长存、落盘，手机退后台只是 socket 断——只用 clientCount 回答 配没配上，
+      // 用户把小程序放进后台的每一分钟，桌面那颗 pill 都会说 未配对，点开还会烧一张
+      // 不需要的新码（2026-10-04 用户报的误解）。
+      pairings: relay?.conversationCount ?? 0,
+      serverUrl: config2.serverUrl,
+      version: PLUGIN_VERSION,
+      waiting: waiting.count,
+      waitingOldestSec: waiting.oldestSec
     };
   }
+  function unpairAll() {
+    const ids = relay?.conversationIds() ?? [];
+    for (const id of ids) relay?.voidConversation(id);
+    return ids.length;
+  }
   const pairingWindow = new PairingWindow(
     {
       clock,
@@ -33798,7 +34755,7 @@ function applyInner(ctx, injected) {
         return;
       }
       decided = true;
-      start(createServicesKernel(collected, { log, takeOverQuestions: config2.takeOverQuestions, clock }));
+      start(createServicesKernel(collected, { log, clock }));
       return;
     }
   };
@@ -34025,10 +34982,11 @@ function applyInner(ctx, injected) {
   try {
     pillRoutes = startPill(ctx, {
       enabled: config2.pill.enabled,
-      // 三条路由要的三件事：幂等发码、只读看当前码、读连接状态。
+      // 四条路由要的四件事：幂等发码、只读看当前码、读连接状态、退出配对。
       ensureFresh: () => ensureFreshPairing(),
       current: () => currentPairing(),
       status: () => pillStatus(),
+      unpair: () => unpairAll(),
       log
     });
   } catch (error62) {
@@ -34037,46 +34995,6 @@ function applyInner(ctx, injected) {
       message: String(error62?.message ?? error62).slice(0, 200)
     });
   }
-  const commandDefinition = {
-    name: "drc",
-    description: "DSH \u8FDC\u7A0B\u63A7\u5236\uFF1A\u914D\u5BF9\u8BF7\u70B9\u72B6\u6001\u680F\u7684 dsh-remote-control\uFF1B/drc status \u770B\u8FDE\u63A5\u4E0E\u95EE\u9898\uFF0C/drc unpair \u89E3\u914D",
-    input: { hint: "status | unpair" },
-    handler: async (invocation) => {
-      const argument = String(invocation.rawInput ?? "").trim().toLowerCase();
-      if (argument.startsWith("unpair")) {
-        for (const id of relay?.conversationIds() ?? []) relay?.voidConversation(id);
-        return { kind: "success", text: '\u5DF2\u89E3\u9664\u6240\u6709\u914D\u5BF9\uFF1B\u624B\u673A\u7AEF\u4F1A\u663E\u793A"\u4E3B\u673A\u5DF2\u65AD\u5F00\uFF0C\u8BF7\u91CD\u65B0\u914D\u5BF9"\u3002' };
-      }
-      return { kind: "success", text: JSON.stringify(state(), null, 2) };
-    }
-  };
-  let commandsTaken = false;
-  const takeCommands = (source) => {
-    if (commandsTaken || !source || typeof source !== "object") return;
-    const holder = source;
-    if (typeof holder.register !== "function") return;
-    holder.register(commandDefinition);
-    commandsTaken = true;
-    probe.commands = "registered";
-  };
-  try {
-    takeCommands(ctx.commands);
-  } catch {
-  }
-  try {
-    takeCommands(ctx.get?.("commands", true));
-  } catch {
-  }
-  try {
-    const child = ctx.inject?.(["commands"], ((...cbArgs) => {
-      for (const candidate of [cbArgs[0], ...cbArgs, ctx]) {
-        takeCommands(pickFrom(candidate, "commands"));
-        if (commandsTaken) break;
-      }
-    }));
-    if (child !== void 0) injectChildren.push(["commands", child]);
-  } catch {
-  }
   return {
     config: config2,
     state,
@@ -34085,6 +35003,9 @@ function applyInner(ctx, injected) {
       oneShot.cancelAll();
       pillRoutes?.stop();
       status.stop();
+      if (pairStoreFile && relay && pairStore.hasPendingChanges) {
+        pairStore.save(relay.conversations.snapshot(), clock.now());
+      }
       runtime?.stop();
       relay?.stop();
       sleep.stop();