dsh-plugin-mobile-link 0.6.0 → 0.6.6

package/lib/router.js

@@ -17,6 +17,7 @@ import { FileFetcher, FSGET_CANCEL } from './files-out.js'
 import { GitBridge, isGitMethod } from './git.js'
 import { isHelloMethod, helloPayload, parseClientInfo } from './hello.js'
 import { isHistoryMethod } from './history.js'
+import { trimRecordsForWire } from './history/records.js'
 
 /**
  * 后台大文件上传的桥接帧（relay → 连接器），名字见 `docs/relay-contract.json`
@@ -75,6 +76,62 @@ export function errorObject(code, message, details = {}) {
   return { code, message, details }
 }
 
+/**
+ * 旧分页通道（`session/page`）的下发形态清洗（016）。
+ *
+ * 这一路是**降级通道**：宿主自己回一页记录，连接器只是转发。它和精确窗口
+ * （`_link/sessionWindow`）必须守同一条口径 —— 只用于诊断的宿主模型输出日志
+ * 不下发（见 `specs/016-history-load-perf/contracts/history-record-trim.md`）。
+ *
+ * 两种形态都要认：宿主 RPC 的信封 `{ ok, value: { records } }`，以及直接给
+ * `{ records }` 的桩/测试形态。其余方法或结构一律原样返回，不做推断。
+ */
+export function trimHistoryPageForWire(method, result) {
+  if (method !== 'session/page') return result
+  if (result === null || typeof result !== 'object') return result
+  const page = result.value ?? result
+  if (page === null || typeof page !== 'object' || !Array.isArray(page.records)) return result
+  const trimmed = { ...page, records: trimRecordsForWire(page.records) }
+  return result.value === undefined ? trimmed : { ...result, value: trimmed }
+}
+
+import { DeviceTimeline } from './diagnostics.js'
+import { SESSION_DIGEST_METHOD, digestSessionList, encodeDigest } from './session-digest.js'
+
+/** 慢请求阈值默认值（毫秒）；0 = 关闭逐条慢请求记录。 */
+export const DEFAULT_SLOW_REQUEST_MS = 2000
+
+/** App 把自己那份阶段记录推上来的方法（契约 connector-diagnostics-method.md）。 */
+export const DIAGNOSTICS_METHOD = '_link/diagnostics'
+/** 单批上限：超过就截断并如实报 `accepted`，剩下的由 App 下次再推（水位不推进）。 */
+export const DIAGNOSTICS_BATCH_BYTES = 32 * 1024
+/** 单条事件里字符串字段的保留长度。 */
+const DIAGNOSTICS_MAX_TEXT = 400
+
+/**
+ * 只留标量（字符串/数字/布尔）与标量数组。
+ *
+ * **必须把 App 的 `detail` 摊平到顶层**：App 侧的 JSONL 信封是
+ * `{kind, seq, ms, at, detail:{...}}`（见 DSHKit 的 `LinkDiagnostics.Event`），而连接器
+ * 自己的流水是**扁平**的。不摊平的话 `phase`/`ms` 这些字段会在清洗时被当成嵌套对象丢掉——
+ * 实测症状：`app.dial` 落盘后一个字段都没有（2026-10-13 09:25 的中转运行）。
+ */
+function sanitizeDiagnosticEvent(event) {
+  if (!event || typeof event !== 'object' || typeof event.kind !== 'string') return null
+  const { detail, ...envelope } = event
+  const flat = { ...envelope, ...(detail && typeof detail === 'object' ? detail : {}) }
+  const clean = { kind: event.kind }
+  for (const [key, value] of Object.entries(flat)) {
+    if (key === 'kind') continue
+    if (typeof value === 'string') clean[key] = value.slice(0, DIAGNOSTICS_MAX_TEXT)
+    else if (typeof value === 'number' || typeof value === 'boolean') clean[key] = value
+    else if (Array.isArray(value) && value.every((item) => typeof item === 'string' || typeof item === 'number')) {
+      clean[key] = value.slice(0, 32)
+    }
+  }
+  return clean
+}
+
 export class DeviceRouter {
   /**
    * @param {object} options
@@ -84,13 +141,28 @@ export class DeviceRouter {
    */
   constructor({
     dsh, send, logger = console, onChange = () => {}, now = Date.now, protocolVersion = 1,
-    eventsBacklog = DEFAULT_EVENTS_BACKLOG, notify = () => {},
+    eventsBacklog = DEFAULT_EVENTS_BACKLOG, notify = () => {}, onEvent = () => {},
+    slowRequestMs = DEFAULT_SLOW_REQUEST_MS, diagnostics = true,
   } = {}) {
     this.dsh = dsh
     this.eventsBacklog = eventsBacklog
+    this.slowRequestMs = Number(slowRequestMs) || 0
+    this.diagnosticsEnabled = diagnostics !== false
+    /** 每个 deviceId 当前这次接入的计时（attach 时建、detach 时收）。 */
+    this.timelines = new Map()
+    /**
+     * 当前这次请求已经发出去的字节数（在 `noteSent` 里累加、在请求收尾时取走）。
+     *
+     * 同一设备上并发请求会把字节算到一起——诊断只要量级对得上（"这次响应是几 KB 还是几 MB"），
+     * 不值得为它引入逐请求关联（那要改所有回包点的形状）。
+     */
+    this._sentBytes = new Map()
     // 「跑完了 / 待你回应」这类事件到了就报一声（见 `notifyFor`）。默认空函数，
     // 测试与不关心提醒的调用方可以不管它。帧由 link.js 发（router 不发帧）。
     this.notify = notify
+    // 生命周期事件（设备 attach/detach 等）的去处，由 link.js 接到流水（journal.js）。
+    // 默认空函数，所以 router 单独用时（单测、本地脚本）不需要日志设施。
+    this.onEvent = onEvent
     // Reported to the app so it can tell which wire revision it is talking to.
     this.protocolVersion = protocolVersion
     this.send = send
@@ -156,9 +228,12 @@ export class DeviceRouter {
       return
     }
     switch (frame.t) {
-      case 'req':
+      case 'req': {
+        const startedAt = this.now()
         await this.handleRequest(deviceId, frame)
+        this.#noteRequest(deviceId, frame.method, startedAt)
         return
+      }
       case 'open':
         await this.handleOpen(deviceId, frame)
         return
@@ -259,16 +334,117 @@ export class DeviceRouter {
 
   // ── device lifecycle ────────────────────────────────────────────────────
 
+  /**
+   * 记一条请求的耗时与字节（spec 020 的 FR-001–FR-003）。
+   *
+   * `bytes` 取"这次请求期间发出去的字节"（见 `noteSent`）——它是一个近似值，
+   * 只在同一设备上并发请求时才会串味，而诊断要回答的是"这次响应是几 KB 还是几 MB"。
+   */
+  #noteRequest(deviceId, method, startedAt) {
+    const timeline = this.timelines.get(deviceId)
+    if (!timeline) return
+    const bytes = this._sentBytes.get(deviceId) ?? 0
+    this._sentBytes.set(deviceId, 0)
+    timeline.noteRequest({ method, startedAt, ms: this.now() - startedAt, bytes })
+  }
+
+  /** 每发一帧给某台设备就累加它的字节数（由 `link.js` 的 `sendToDevice` 调用）。 */
+  noteSent(deviceId, bytes) {
+    if (!deviceId || !Number.isFinite(bytes)) return
+    this._sentBytes.set(deviceId, (this._sentBytes.get(deviceId) ?? 0) + bytes)
+  }
+
+  /**
+   * 收下 App 推来的阶段记录（spec 020 的 FR-011 / 契约 §2）。
+   *
+   * 三条硬规则：
+   *   1. **时刻照抄**：App 事件的 `at`/`ms` 是它自己钟上的读数，连接器不许改写
+   *      （否则"手机侧几点了"这条信息就没了，而它正是区分"App 挂起"与"拨号卡住"的依据）；
+   *   2. **按序号幂等**：同一批重推不会写两遍（水位记在设备记录上）；
+   *   3. **超批上限就截断**：只收前若干条并如实报 `accepted`/`lastSeq`，剩下的下次再推——
+   *      绝不假装收全了。
+   *
+   * @returns {{ok: true, value: {accepted: number, lastSeq: number}}}
+   */
+  acceptDiagnostics(deviceId, args = {}) {
+    if (!this.diagnosticsEnabled) {
+      // 回退闸：关掉时明确拒绝，手机据此静默忽略（不影响连接）。
+      return { ok: false, error: errorObject('diagnostics/disabled', 'diagnostics intake is disabled on this connector') }
+    }
+    const record = this.devices.get(deviceId)
+    const watermark = Number(record?.diagnosticsSeq) || 0
+    const events = Array.isArray(args.events) ? args.events : []
+    let accepted = 0
+    let lastSeq = watermark
+    let bytes = 0
+    for (const raw of events) {
+      const event = sanitizeDiagnosticEvent(raw)
+      if (!event) continue
+      const seq = Number(event.seq)
+      if (Number.isFinite(seq) && seq <= watermark) continue
+      const size = JSON.stringify(event).length
+      if (bytes > 0 && bytes + size > DIAGNOSTICS_BATCH_BYTES) break
+      // 用 recordForeign：App 的时刻照抄（它是"手机侧几点"的唯一来源）。
+      // 补 `deviceId`：App 自己不知道它的 id，而多设备时没有这一列就没法把事件归到某台手机上。
+      this.onEvent(event.kind, { ...event, deviceId, source: 'app' }, { foreign: true })
+      bytes += size
+      accepted += 1
+      if (Number.isFinite(seq)) lastSeq = Math.max(lastSeq, seq)
+    }
+    if (record) record.diagnosticsSeq = lastSeq
+    const sentAt = Number(args.sentAt)
+    this.onEvent('app.push', {
+      deviceId,
+      count: accepted,
+      dropped: Number(args.dropped) || 0,
+      sentAt: Number.isFinite(sentAt) ? sentAt : undefined,
+      // 手机时钟与本机时钟的差（单向延迟几十毫秒）；采集侧的对齐就靠这一个数。
+      skewMs: Number.isFinite(sentAt) ? this.now() - sentAt : undefined,
+    })
+    return { ok: true, value: { accepted, lastSeq } }
+  }
+
+  /** 起一次新的接入计时（回头客也重起：那确实是一次新连接）。 */
+  #startTimeline(deviceId) {
+    this.timelines.get(deviceId)?.finish()
+    this.timelines.set(deviceId, new DeviceTimeline({
+      deviceId,
+      slowRequestMs: this.slowRequestMs,
+      now: this.now,
+      onEvent: this.onEvent,
+    }))
+    this._sentBytes.set(deviceId, 0)
+  }
+
+  /** 收掉一次接入计时（断开、撤销、进程收尾都走这里）。 */
+  #finishTimeline(deviceId) {
+    const timeline = this.timelines.get(deviceId)
+    if (!timeline) return
+    timeline.finish()
+    this.timelines.delete(deviceId)
+    this._sentBytes.delete(deviceId)
+  }
+
   async attachDevice(deviceId, info = {}) {
     if (!nonEmptyString(deviceId)) return
+    this.#startTimeline(deviceId)
     const existing = this.devices.get(deviceId)
     if (existing) {
       // 回头客：手机又连上了。流和攒下的提问都还在，交给 handleOpen 补发。
       if (existing.offlineSince !== undefined) {
+        const offlineForMs = this.now() - existing.offlineSince
         existing.offlineSince = undefined
+        this.onEvent('device.reattach', { deviceId, offlineForMs, pending: existing.eventsPending.size })
         this.logger.info?.(
           `mobile-link: device ${deviceId} reattached with ${existing.eventsPending.size} unanswered question(s)`)
         this.#changed()
+      } else {
+        // **这条是"同一台设备同时又开了一条"**：中转的 `attach_device` 会直接覆盖旧
+        // 链路，旧的那条既不会再收到 `deviceDetach`、也不会出现在任何一方的状态里
+        // （2026-10-13 01:10 实测：attach 与上一条 detach 之间空了 34 秒）。记下来，
+        // 否则事后只看得到"它连上了"，看不到"它连了两条"。
+        this.onEvent('device.attach-again', { deviceId, connectedForMs: this.now() - existing.connectedAt })
+        this.logger.warn?.(`mobile-link: device ${deviceId} attached again while still attached`)
       }
       return
     }
@@ -288,6 +464,7 @@ export class DeviceRouter {
       offlineSince: undefined,
       eventsPending: new Map(),
     })
+    this.onEvent('device.attach', { deviceId, name: info?.name, model: info?.model })
     this.logger.info?.(`mobile-link: device ${deviceId} attached (${info?.name ?? 'unknown'})`)
     this.#changed()
     await this.ensureEventsStream(deviceId)
@@ -304,10 +481,12 @@ export class DeviceRouter {
    * 那段的说明）。这也是「撤销即放下」是唯一出口的原因。
    */
   async detachDevice(deviceId, reason) {
+    this.#finishTimeline(deviceId)
     const record = this.devices.get(deviceId)
     if (!record) return
     if (reason === 'revoked') {
       await this.#dropDevice(deviceId)
+      this.onEvent('device.revoked', { deviceId })
       this.logger.info?.(`mobile-link: device ${deviceId} 已被撤销，放下（不再替它值班）`)
       return
     }
@@ -326,6 +505,7 @@ export class DeviceRouter {
     for (const entry of keep) record.dlpIds.add(entry.dlpId)
 
     if (record.offlineSince === undefined) record.offlineSince = this.now()
+    this.onEvent('device.detach', { deviceId, reason: reason ?? 'closed' })
     this.logger.info?.(
       `mobile-link: device ${deviceId} detached (${reason ?? 'closed'})；`
       + '$events 流一直替它留着，直到设备被撤销或进程退出')
@@ -366,16 +546,48 @@ export class DeviceRouter {
   teardownAll() {
     const muxIds = []
     for (const deviceId of [...this.devices.keys()]) {
+      // 进程收尾/链路重建也要把这次接入的汇总写掉，否则"连上过、发过请求"这件事没有数字。
+      this.#finishTimeline(deviceId)
       muxIds.push(...this.streams.removeDevice(deviceId))
       this.devices.delete(deviceId)
     }
     this.streams = new StreamTable()
+    // 不该有残留：上面的循环已经逐个收过；这里兜底，防止 attach 之后没进 devices 的路径留下脏项。
+    this.timelines.clear()
+    this._sentBytes.clear()
     return muxIds
   }
 
   // ── device requests ─────────────────────────────────────────────────────
 
   async handleRequest(deviceId, frame) {
+    // App 推上来的阶段记录：**只落盘，不影响任何连接行为**（契约
+    // connector-diagnostics-method.md §4）。放在最前面，免得被后面的方法族顺序影响。
+    // 精简版会话列表（spec 021）：同一份宿主数据，去掉 App 侧零读取点的字段，可按要求 gzip。
+    // 老方法 `session/list` 一个字节都不改——老版本手机继续走它，这是兼容的前提。
+    if (frame.method === SESSION_DIGEST_METHOD) {
+      const args = frame.args ?? {}
+      let result
+      try {
+        result = await this.dsh.rpc('session/list', { _request: args._request ?? {} })
+      } catch (error) {
+        result = { ok: false, error: errorObject('host/unavailable', messageOf(error)) }
+        this.lastError = messageOf(error)
+        this.#changed()
+      }
+      const payload = result?.ok === true
+        ? { ok: true, value: encodeDigest(digestSessionList(result), args.encoding) }
+        : result
+      this.send(deviceId, resultFrame(frame.id, payload, deviceId))
+      return
+    }
+
+    if (frame.method === DIAGNOSTICS_METHOD) {
+      const result = this.acceptDiagnostics(deviceId, frame.args ?? {})
+      this.send(deviceId, resultFrame(frame.id, result, deviceId))
+      return
+    }
+
     // Files the phone sends are answered here rather than forwarded: the Host
     // has no upload endpoint, and carrying them on the existing unary frame
     // means neither the relay nor the protocol has to change.
@@ -458,6 +670,7 @@ export class DeviceRouter {
     let result
     try {
       result = await this.dsh.rpc(frame.method, frame.args ?? {})
+      result = trimHistoryPageForWire(frame.method, result)
     } catch (error) {
       result = { ok: false, error: errorObject('host/unavailable', messageOf(error)) }
       this.lastError = messageOf(error)

package/lib/routes.js

@@ -94,40 +94,9 @@ export function registerMobileLinkRoutes(ctx, { agent, logger, config = {}, hist
   const guard = makeGuard(ctx, logger)
   const STATUS_ROUTE = '/mobile-link/status'
   const PAIR_ROUTE = '/mobile-link/pair-code'
-  /// SPIKE（spec 007 / T008）：只读测量宿主窗口与检索 API 的语义。
-  /// 默认关闭，只有 `DSH_MOBILE_LINK_HISTORY_PROBE=1` 时注册——它是一次性测量工具，
-  /// 不是产品面（结论已写回 specs/007-transcript-history/plan.md 的 Phase 0）。
-  const PROBE_ROUTE = '/mobile-link/history-probe'
+  const REGENERATE_ROUTE = '/mobile-link/pair-code/regenerate'
   const disposers = []
 
-  if (history !== undefined && process.env.DSH_MOBILE_LINK_HISTORY_PROBE === '1') {
-    disposers.push(ctx.webServer.register({
-      kind: 'exact',
-      path: PROBE_ROUTE,
-      handler: async (req, res) => {
-        if (guard(req, res)) return
-        if (req.method !== 'GET') {
-          res.statusCode = 405
-          res.setHeader('allow', 'GET')
-          res.end()
-          return
-        }
-        const url = new URL(req.url ?? '/', 'http://127.0.0.1')
-        try {
-          const result = await history.probe({
-            sessionId: url.searchParams.get('sessionId') ?? '',
-            seq: url.searchParams.get('seq') ?? undefined,
-            n: url.searchParams.get('n') ?? undefined,
-            text: url.searchParams.get('text') ?? undefined,
-          })
-          sendJson(res, 200, result)
-        } catch (error) {
-          sendJson(res, 500, { ok: false, error: String(error?.message ?? error) })
-        }
-      },
-    }))
-  }
-
   disposers.push(ctx.webServer.register({
     kind: 'exact',
     path: STATUS_ROUTE,
@@ -163,10 +132,14 @@ export function registerMobileLinkRoutes(ctx, { agent, logger, config = {}, hist
         sendJson(res, 400, { ok: false, message: 'invalid JSON body' })
         return
       }
-      const ttlMs = ttlFrom(body.ttlMs, Number(config.pairTtlMs) || 10 * 60 * 1000)
+      // 032：调用方**没提** ttlMs 就要一张持久码（面板走这条路）；显式给了才限时，
+      // 那是老行为，留给还在用的调用方。
+      const wantsTtl = Object.prototype.hasOwnProperty.call(body, 'ttlMs')
+      const ttlMs = wantsTtl ? ttlFrom(body.ttlMs, Number(config.pairTtlMs) || 10 * 60 * 1000) : null
       try {
         const minted = await agent.mintPairCode({ ttlMs })
-        logger.info?.(`mobile-link: minted a pairing code for ${minted.agentId}`)
+        logger.info?.(`mobile-link: minted a ${minted.persistent ? 'persistent' : 'time-limited'}`
+          + ` pairing code for ${minted.agentId}`)
         // The picture travels with the code. It used to be a route of its own
         // (`GET /mobile-link/qr`) that a person opened in a browser; the pairing
         // entry is now the connector's own panel in the DSH client, so the one
@@ -180,5 +153,32 @@ export function registerMobileLinkRoutes(ctx, { agent, logger, config = {}, hist
     },
   }))
 
+  disposers.push(ctx.webServer.register({
+    kind: 'exact',
+    path: REGENERATE_ROUTE,
+    handler: async (req, res) => {
+      if (guard(req, res, { requireFence: true })) return
+      if (req.method !== 'POST') {
+        res.statusCode = 405
+        res.setHeader('allow', 'POST')
+        res.end()
+        return
+      }
+      const body = await readJsonBody(req)
+      if (body === undefined) {
+        sendJson(res, 400, { ok: false, message: 'invalid JSON body' })
+        return
+      }
+      try {
+        const minted = await agent.regeneratePairCode()
+        logger.info?.(`mobile-link: regenerated the pairing code for ${minted.agentId}`
+          + ` (revoked ${minted.revoked})`)
+        sendJson(res, 200, { ok: true, ...minted, svg: qrSvg(minted.qrPayload) })
+      } catch (error) {
+        sendJson(res, 502, { ok: false, code: 'relay/unavailable', message: String(error?.message ?? error) })
+      }
+    },
+  }))
+
   return disposers
 }

package/lib/session-digest.js

@@ -0,0 +1,117 @@
+/**
+ * `_link/sessionDigest`：`session/list` 的精简同形副本（spec 021）。
+ *
+ * 为什么要有它：`session/list` 占经中转下行字节的 **96%**，一次固定 714 KB，而中转出口实测只有
+ * 16–112 KB/s（2026-10-13 现场诊断）。其中 **58.8% 的字节是 App/DSHKit 从来不读的字段**
+ * （逐字段扫 79 个源文件核对，清单见 `contracts/session-digest.md` §4）。
+ *
+ * 三条硬约束：
+ *   1. **不动 `session/list`**：老 App 只认它，字段删掉就没有回退路径。
+ *   2. **不改入参**：宿主返回什么就基于它生成新对象，方便"同一份数据两条路径"逐字节对比。
+ *   3. **只删名单里的**：名单之外的字段（包括以后宿主新增的）一律原样透传，避免"裁剪"变成"猜"。
+ */
+
+import { deflateRawSync } from 'node:zlib'
+
+/** 方法名（设备发起，中转不校验方法名，所以不需要中转改动）。 */
+export const SESSION_DIGEST_METHOD = '_link/sessionDigest'
+
+/** 会话项里剔掉的字段：零读取点（`agentAvailable` 1.8%）。 */
+export const DROPPED_ITEM_KEYS = Object.freeze(['agentAvailable'])
+
+/**
+ * 投影键里剔掉的字段（合计 56.7%）。
+ *
+ * 每一条都能在 App/DSHKit 里复查"零读取点"：
+ * `turnOutline` 33.4%（每轮 prompt/response 原文）、`imageLimits` 6.2%（上传限制）、
+ * `sessionStats` 4.2%、`todos` 2.6%、`subagentCatalog` 2.6%、`contextBreakdown` 2.5%、
+ * `sessionListMetadata` 1.9%（唯一被读的 `blank` 在顶层已有同名字段）、
+ * `subagentTiming` 1.5%、`agentPreset` 0.8%（`SessionCreateRequest.agentPreset` 是请求字段）。
+ */
+export const DROPPED_PROJECTION_KEYS = Object.freeze([
+  'turnOutline', 'imageLimits', 'sessionStats', 'todos', 'subagentCatalog',
+  'contextBreakdown', 'sessionListMetadata', 'subagentTiming', 'agentPreset',
+])
+
+/**
+ * 只接受的压缩编码；其它一律按不压缩处理（保守，不因为多写一个字段就让调用方失败）。
+ *
+ * `deflate-raw` = RFC1951 原始 DEFLATE，**不带** gzip/zlib 包装。选它而不是 gzip 的原因是
+ * 手机侧：Apple 的 `Compression` 框架（`COMPRESSION_ZLIB`）一行 `compression_decode_buffer`
+ * 就能解开原始 DEFLATE，而 gzip 包装它不认，得引 libz 的 `inflateInit2(MAX_WBITS+16)` 做 C 互操作。
+ * 两者压缩比实测相同（239 KiB → 36.8 KiB）。
+ */
+export const DEFLATE_ENCODING = 'deflate-raw'
+export const IDENTITY_ENCODING = 'identity'
+
+/** 按原键序复制并跳过剔除名单：键序稳定才能做"逐字节对比"。 */
+function omit(source, dropped) {
+  const out = {}
+  for (const key of Object.keys(source)) {
+    if (dropped.has(key)) continue
+    out[key] = source[key]
+  }
+  return out
+}
+
+/**
+ * 裁剪一份会话列表的**值**（`{ items: [...] }`）。
+ *
+ * 认两种输入（与 `trimHistoryPageForWire` 同款）：宿主信封 `{ ok, value: { items } }`，
+ * 以及直接给的 `{ items }`。**返回的始终是列表值本身**，调用方不需要再猜信封在哪一层
+ * （曾经因为这里保留信封、外面又包一层，响应成了 `{encoding, value:{ok, value:{items}}}`）。
+ *
+ * 结构不是预期的样子就**原样返回入参**——裁剪不许把"看不懂"变成"删掉"。
+ *
+ * @param {unknown} result 宿主响应或其 `value`
+ * @returns {unknown} 裁剪后的列表值；不合法时原样返回入参
+ */
+export function digestSessionList(result) {
+  if (result === null || typeof result !== 'object') return result
+  const container = Array.isArray(result.items) ? result : result.value
+  if (container === null || typeof container !== 'object' || !Array.isArray(container.items)) {
+    return result
+  }
+  return { ...container, items: container.items.map(digestItem) }
+}
+
+/** 单条会话：剔顶层字段与投影键；`projections` 缺失或形状不对就原样留着。 */
+function digestItem(item) {
+  if (item === null || typeof item !== 'object') return item
+  const out = omit(item, new Set(DROPPED_ITEM_KEYS))
+  const projections = item.projections
+  if (projections === null || typeof projections !== 'object') return out
+  // `kind: "sequenced"` 是信封常量，App 侧模型没解码它（1.3%）。
+  const envelope = omit(projections, new Set(['kind']))
+  const values = projections.values
+  if (values !== null && typeof values === 'object') {
+    envelope.values = omit(values, new Set(DROPPED_PROJECTION_KEYS))
+  }
+  out.projections = envelope
+  return out
+}
+
+/**
+ * 按调用方要求编码裁剪后的值。
+ *
+ * **只在应用层压**：中转的 `WebSocketResponse(compress=False)`，手机侧
+ * `URLSessionWebSocketTask` 也不支持 permessage-deflate，所以 WS 层压缩救不了手机那一跳。
+ * 压缩后的字节 base64 放进 JSON 文本帧（与 `_link/diagnostics` 同款），中转不需要任何改动。
+ *
+ * `rawBytes` 是**解压后的字节长度**：Apple 的 `compression_decode_buffer` 必须预先给足输出缓冲区，
+ * 带上它调用方就能一次分配到位，不必"猜容量、失败再翻倍重试"。
+ *
+ * @param {unknown} value 裁剪后的值
+ * @param {unknown} encoding 调用方要求；只认 `"deflate-raw"`
+ * @returns {{encoding: string, value: unknown, rawBytes?: number}} 带回执，调用方据此决定解不解压
+ */
+export function encodeDigest(value, encoding) {
+  if (encoding !== DEFLATE_ENCODING) return { encoding: IDENTITY_ENCODING, value }
+  const json = JSON.stringify(value ?? null)
+  const raw = Buffer.from(json, 'utf8')
+  return {
+    encoding: DEFLATE_ENCODING,
+    value: deflateRawSync(raw).toString('base64'),
+    rawBytes: raw.length,
+  }
+}

package/lib/status.js

@@ -6,7 +6,7 @@
  * 函数只读 agent 的字段，不持有状态，因此可以直接被单测调用。
  */
 
-import { SERVER_CAPABILITIES, SERVER_VERSION } from './hello.js'
+import { SERVER_CAPABILITIES, SERVER_VERSION, hostVersion } from './hello.js'
 
 const PROTOCOL_VERSION = 1
 
@@ -33,8 +33,7 @@ export const HOST_HINTS = {
   unknown: { hint: '无法识别当前宿主；若连不上，请按"排查"一节处理', docAnchor: '排查：连不上时看这里' },
 }
 
-/** 本机 DSH 侧的诊断块（老字段一个不少，新字段只增）。 */
-function dshBlock(agent) {
+/** 本机 DSH 侧的诊断块（老字段一个不少，新字段只增）。 */function dshBlock(agent) {
   const errorKind = agent.dshError ? (agent.dsh?.errorKind ?? 'unreachable') : null
   const entry = errorKind ? DSH_HINTS[errorKind] : undefined
   return {
@@ -51,6 +50,31 @@ function dshBlock(agent) {
   }
 }
 
+/**
+ * 生命周期流水的读法（只增字段）。
+ *
+ * 为什么状态接口要给这一块：`lastError` 只有最后一条，而"手机为什么连不上"往往要
+ * 看**之前**发生过什么（拆了几次链、每次什么原因、设备是不是同时开了两条）。
+ *
+ * 读法要说清楚：`recent` / `recorded` / `dropped` 都是**当前这个实例**的（热更会换实例，
+ * 换完这几个数从零开始）；跨实例的完整历史只在 `path` 指的 JSONL 文件里——两者互补，
+ * 别拿 `recorded` 当"这台机器一共连过几次"。没有流水对象（老调用方、单测的假 agent）
+ * 时给空块，不是 `undefined`——读者不用做判空。
+ */
+function journalBlock(agent) {
+  const journal = agent.journal
+  return {
+    path: journal?.path ?? null,
+    recorded: journal?.recorded ?? 0,
+    dropped: journal?.dropped ?? 0,
+    fileErrors: journal?.fileErrors ?? 0,
+    recent: journal?.recent?.(STATUS_JOURNAL_ENTRIES) ?? [],
+  }
+}
+
+/** `/status` 里随每次轮询带出的流水条数。完整历史读 `journal.path` 那个文件。 */
+const STATUS_JOURNAL_ENTRIES = 20
+
 /**
  * @param {import('./link.js').MobileLinkAgent} agent
  * @returns {Record<string, unknown>} 可直接序列化给 `/status` 的对象
@@ -69,6 +93,9 @@ export function statusSnapshot(agent) {
     // Same facts as `_link/hello`, which is the channel the app actually uses:
     // this route only exists on the direct path.
     serverVersion: SERVER_VERSION,
+    // 宿主 DSH 的版本（`null` = 这个宿主没把版本放进环境）。与 `serverVersion`
+    // 是两个命名空间：前者是连接器，后者是跑它的 DSH。
+    hostVersion: hostVersion(),
     capabilities: SERVER_CAPABILITIES,
     enroll: {
       // A phone (or the user's browser) can read this to find out that the
@@ -97,5 +124,7 @@ export function statusSnapshot(agent) {
     startedAt: agent.startedAt ?? null,
     connectedAt: agent.connectedAt ?? null,
     reconnectAttempts: agent.reconnectAttempts,
+    // 新增（只增不改）：生命周期流水的摘要与最近若干条，见上面的 journalBlock。
+    journal: journalBlock(agent),
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-mobile-link",
-  "version": "0.6.0",
+  "version": "0.6.6",
   "description": "Put your PC's DeepSeek Harness in your pocket: dials a relay over WSS so the native iOS client reaches this machine even without a public IP.",
   "keywords": [
     "dsh",