@bd7pil/reeve 0.1.4 → 0.1.6

package/src/gate/state.js

@@ -0,0 +1,129 @@
+// 会话状态机（GATE 里唯一的一份回退状态）。
+//
+// 语义（复刻自 v1 时代那套 fallback 的行为规格）：
+//   · **单向推进**：候选指针只增不减（attemptCount/fallbackIndex 语义）；
+//   · **粘性**：切换成功后，同一 session 的后续请求从切换到的那个候选起（不回头）；
+//   · **冷却**：失败的候选取记时间戳，冷却期（默认 60s）内不再被选；
+//   · **可选恢复**：`restore_primary_after_cooldown` 为真且所有失败记录的冷却都过期 → 指针归零；
+//   · **并发安全**：同一 session 的两次失败只推进一次（`advance` 带去重键）；
+//   · **有界内存**：按 TTL 驱逐 + 条数上限。
+//
+// 时间是注入的（测试用假时钟，不 sleep）。
+export function createSessionStore({ now = Date.now, policy = {}, maxSessions = 10_000 } = {}) {
+  // policy 允许传函数（配置热更后策略即时生效，状态不必重建）
+  const readPolicy = () => (typeof policy === 'function' ? policy() ?? {} : policy)
+  const ttlMs = () => Math.max(1, Number(readPolicy().session_ttl_seconds ?? 1800)) * 1000
+  const cooldownMs = () => Math.max(0, Number(readPolicy().cooldown_seconds ?? 60)) * 1000
+  /** @type {Map<string, {agent: string|null, touchedAt: number, chains: Map<string, {index: number, failed: Map<string, number>, lastNext: {key: string, model: string|null}|null}>}>} */
+  const sessions = new Map()
+
+  const record = (sessionID) => {
+    let rec = sessions.get(sessionID)
+    if (!rec) {
+      rec = { agent: null, touchedAt: now(), chains: new Map() }
+      sessions.set(sessionID, rec)
+    }
+    rec.touchedAt = now()
+    return rec
+  }
+  const chainRec = (sessionID, chainName) => {
+    const rec = record(sessionID)
+    let c = rec.chains.get(chainName)
+    if (!c) {
+      c = { index: 0, failed: new Map(), lastNext: null }
+      rec.chains.set(chainName, c)
+    }
+    return c
+  }
+  const sweep = () => {
+    const cutoff = now() - ttlMs()
+    for (const [id, rec] of sessions) if (rec.touchedAt < cutoff) sessions.delete(id)
+    if (sessions.size <= maxSessions) return
+    // 超上限：按 touchedAt 从旧到新驱逐
+    const ordered = [...sessions.entries()].sort((a, b) => a[1].touchedAt - b[1].touchedAt)
+    for (let i = 0; i < ordered.length - maxSessions; i++) sessions.delete(ordered[i][0])
+  }
+
+  const cooling = (rec, key) => {
+    const failedAt = rec.failed.get(key)
+    if (failedAt === undefined) return false
+    if (cooldownMs() === 0) return false
+    const alive = now() - failedAt < cooldownMs()
+    if (!alive) rec.failed.delete(key) // 过期即清（顺带把恢复判断简化）
+    return alive
+  }
+
+  return {
+    now,
+    cooldownMs,
+    setAgent(sessionID, agent) {
+      if (typeof sessionID !== 'string' || sessionID.length === 0) return
+      record(sessionID).agent = typeof agent === 'string' && agent.length > 0 ? agent : null
+      sweep()
+    },
+    agentOf(sessionID) {
+      const rec = sessions.get(sessionID)
+      if (!rec) return null
+      if (now() - rec.touchedAt >= ttlMs()) {
+        sessions.delete(sessionID)
+        return null
+      }
+      return rec.agent
+    },
+    /** 该 session 在这条链上的起点索引（粘性 + 冷却后恢复）。 */
+    startIndex(sessionID, chainName, keys) {
+      const rec = chainRec(sessionID, chainName)
+      if (rec.index > 0 && readPolicy().restore_primary_after_cooldown === true) {
+        const anyCooling = keys.some((k) => cooling(rec, k))
+        if (!anyCooling) rec.index = 0
+      }
+      return Math.min(rec.index, Math.max(0, keys.length - 1))
+    },
+    /** 某个候选此刻是不是在冷却里。 */
+    isCooling(sessionID, chainName, key) {
+      return cooling(chainRec(sessionID, chainName), key)
+    },
+    /** 失败：记时间戳（冷却起点）。**不**推进指针（推进由 noteSuccess/advance 决定）。 */
+    noteFailure(sessionID, chainName, key) {
+      const rec = chainRec(sessionID, chainName)
+      rec.failed.set(key, now())
+      sweep()
+    },
+    /** 成功：把指针钉在这个候选上（粘性）。 */
+    noteSuccess(sessionID, chainName, key, keys) {
+      const rec = chainRec(sessionID, chainName)
+      const at = keys.indexOf(key)
+      if (at >= 0) rec.index = at
+      rec.failed.delete(key)
+      sweep()
+    },
+    /**
+     * 插件侧要"下一个候选"时用（流已开始/沉默这两类层内换不了的情形）。
+     * `dedupeKey` 保证同一次失败被两条事件各触发一次时**只推进一次**。
+     * @returns {{ model: string|null, index: number }} model 为 null = 没有下一个了
+     */
+    advance(sessionID, chainName, keys, { dedupeKey = null } = {}) {
+      const rec = chainRec(sessionID, chainName)
+      if (dedupeKey !== null && rec.lastNext?.key === dedupeKey) return { model: rec.lastNext.model, index: rec.index }
+      const from = Math.max(rec.index, 0)
+      let nextIndex = -1
+      for (let i = from + 1; i < keys.length; i++) {
+        if (cooling(rec, keys[i])) continue
+        nextIndex = i
+        break
+      }
+      const model = nextIndex >= 0 ? keys[nextIndex] : null
+      if (nextIndex >= 0) rec.index = nextIndex
+      rec.lastNext = { key: dedupeKey, model }
+      sweep()
+      return { model, index: rec.index }
+    },
+    snapshot() {
+      return {
+        sessions: sessions.size,
+        cooling: [...sessions.values()].reduce((n, r) => n + [...r.chains.values()].reduce((m, c) => m + [...c.failed.keys()].filter((k) => cooling(c, k)).length, 0), 0),
+      }
+    },
+    size: () => sessions.size,
+  }
+}

package/src/index.js

@@ -33,15 +33,16 @@ import { Supervisor } from './supervisor.js'
 import { reconcileParent } from './reconcile.js'
 import { SnapshotWriter, buildSnapshot, projectAgentTable } from './snapshot.js'
 import { SUBAGENT_ROSTER, withRoster } from './roster.js'
-import { readSetupToken, startOwnedProxy } from './proxy.js'
-import { REEVE_TIERS, BUILTINS_TO_HIDE, mergeTierModels, pickDefaultAgent, readEndpoint } from './models.js'
-import { STATS_DEFAULTS, aggregateBifrostRows, aggregateLedger, buildStats, fetchBifrostLogs, fetchBifrostModels, mergeModelCandidates } from './stats.js'
+import { probeGate, startGate } from './gate/gate.js'
+import { defaultFallbackConfigPath } from './gate/config.js'
+import { REEVE_TIERS, BUILTINS_TO_HIDE, mergeTierModels, pickDefaultAgent, readEndpoint, resolveGateEndpoint } from './models.js'
+import { STATS_DEFAULTS, aggregateGateRows, aggregateLedger, buildStats, fetchGateModels, mergeModelCandidates, readLedgerTail } from './stats.js'
 import { loadAgents, loadSkills } from './register.js'
 import { ensureProviderBlock, reeveProviderBlock } from './config-write.js'
 
 const SUBAGENT_TOOL = 'subagent'
-/** 自持代理的默认端口（与写进配置的端点一致）。 */
-const PROXY_DEFAULT_PORT = 8080
+/** GATE（唯一代理层）的默认端口（与写进配置的端点一致）。 */
+const GATE_DEFAULT_PORT = 8080
 
 export default {
   id: PLUGIN_ID,
@@ -73,10 +74,8 @@ export default {
     // 名册注入的证据：注入成功过一次就记下来（进快照）——"藏起来不削弱委派"这条设计
     // 靠它可核对，而不是靠"模型应该看得见"。
     let roster = null
-    /** 代理层自持的状态（进快照：面板可显示、上机可核对）。必须在快照块之前声明。 */
-    let proxyState = null
-    /** 链文件的状态（代理那边在维护，这里只留引用给快照）。必须在快照块之前声明。 */
-    let chainRef = null
+    /** GATE 的运行态（进快照：面板可显示、上机可核对）。必须在快照块之前声明。 */
+    let gateState = null
     /** 性能统计（进快照）。必须在快照块之前声明。 */
     let statsState = null
     /** 模型候选（面板的链编辑选择器用）。必须在快照块之前声明。 */
@@ -130,12 +129,11 @@ export default {
           version: PLUGIN_VERSION,
           agents: agentTable,
           roster,
-          proxy: proxyState,
-          chain: chainRef,
           models: modelsState,
           registered: { agents: registeredAgents, skills: registeredSkills },
           endpoint: endpointState,
           stats: statsState,
+          gate: gateState,
         })
       snapshotFlush = () => snapshot.schedule(build)
       ledger.onChange = () => snapshot.schedule(build)
@@ -149,7 +147,7 @@ export default {
     // （只加不改 / 备份 / 写完自校验 / 保留注释）。
     let endpointWrite = null
     if (options.ownEndpoint !== false) {
-      const wantPort = Number(options.proxy?.port ?? PROXY_DEFAULT_PORT)
+      const wantPort = resolveGateEndpoint({ gate: options.gate === true ? null : options.gate, proxy: options.proxy === true ? null : options.proxy, fallbackPort: GATE_DEFAULT_PORT }).port
       endpointWrite = await ensureProviderBlock({
         configDir: options.engineConfigDir ?? null,
         block: reeveProviderBlock({ port: wantPort }),
@@ -159,60 +157,74 @@ export default {
       endpointState = { status: endpointWrite.status, path: endpointWrite.path, detail: endpointWrite.detail }
     }
 
-    // ---- 代理层自持（opt-in：options.proxy.enabled）----
-    // 纯插件形态：取件 → 派生链 → 拉起/复用 → 等就绪 → 收敛 → 守护。
-    // 不需要任何外部脚本；失败只记日志（代理起不来时引擎照常跑，模型会吵地报错）。
-    let proxyHandle = null
-    // 两种写法都行：`proxy: true`（简写）或 `proxy: { enabled: true, ... }`
-    // 默认开：这样配置里可以真的只写一行插件（`proxy: false` 关闭；`proxy: true` 或对象都行）
-    if (options.proxy !== false && options.proxy?.enabled !== false) {
-      // 端口不用用户重复写：从配置里的 `providers.reeve.settings.baseURL` 推（读不到就用 options/默认）
-      let opts = options.proxy === true || options.proxy === undefined ? {} : options.proxy
-      if (opts.port == null) {
-        const endpoint = await readEndpoint({})
-        if (endpoint) {
-          opts = { ...opts, port: endpoint.port, host: endpoint.host }
-          logger.debug(`[reeve] 代理端口取自配置：${endpoint.host}:${endpoint.port}（来自 ${endpoint.from}）`)
+    // ---- GATE（代理层 —— 唯一入口；opt-out：`gate: false`）----
+    // 引擎认的是 `providers.reeve` 那个 baseURL，GATE 就占那个端口；路由/回退/执行/台账都在
+    // 它里面（唯一代理层，见 docs/GATE.md）。失败只记日志：引擎照常跑，模型会吵地报错。
+    //
+    // **复用优先**：引擎是**按工作区**加载插件的 —— 同一个引擎里可能有多个插件实例（每个工作区一个）。
+    // 第一个实例把 GATE 拉到端点口上，后面的实例**用健康检查接上**（`external: true`），
+    // 而不是去抢同一个口（抢必失败 → 快照里会出现假的"GATE 未就绪"，面板跟着误报）。
+    // 卸载语义：**都不在卸载时关端口** —— GATE 是引擎级服务，插件实例（工作区）被闲置驱逐
+    // 并不意味着引擎退出。以前"自己起的自己关"会让起服务的工作区被驱逐后，其它活跃工作区的
+    // 请求永久拿不到代理（2026-10-22 两台机器实测）。`detach()` 只清空闲连接，不阻塞进程退出。
+    let gateHandle = null
+    if (options.gate !== false && options.gate?.enabled !== false) {
+      const endpoint = await readEndpoint({})
+      const { port: gatePort, host: gateHost } = resolveGateEndpoint({
+        gate: options.gate === true ? null : options.gate,
+        proxy: options.proxy === true ? null : options.proxy,
+        endpoint,
+        fallbackPort: GATE_DEFAULT_PORT,
+      })
+      const configPath = options.gate?.configPath ?? options.fallbackConfigPath ?? defaultFallbackConfigPath()
+      const probe = await probeGate({ port: gatePort, host: gateHost })
+      if (probe.ok) {
+        gateState = { ...probe.snapshot, reused: true }
+        logger.debug(`[reeve] GATE 已在 :${gatePort} 上跑着（复用；链 ${(probe.snapshot?.chains ?? []).join('/')}）`)
+      } else {
+        try {
+          gateHandle = await startGate({
+            port: gatePort,
+            host: gateHost,
+            configPath,
+            ledgerPath: options.gate?.ledgerPath ?? undefined,
+            logger,
+          })
+          gateState = gateHandle.snapshot()
+          logger.debug(`[reeve] GATE：:${gateHandle.port}（链 ${gateState.chains.join('/')}）`)
+        } catch (err) {
+          gateState = { error: String(err).slice(0, 200) }
+          logger.debug(`[reeve] GATE 起不来（忽略，引擎照常）：${gateState.error}`)
         }
       }
-      // 状态一变就刷新快照 —— 尤其"后台取件完成、代理起来了"那一刻（否则面板会一直显示未就绪）
-      const onState = (st) => {
-        proxyState = { ready: st.ready, detail: st.detail, port: st.port, host: st.host }
-        // 链的状态对象由代理那边持续更新（热更、收敛复核都会写它）—— 这里只留引用，快照时再取
-        if (st.chain) chainRef = st.chain
-        snapshotFlush()
-      }
-      proxyHandle = await startOwnedProxy({ opts, logger, onState })
-      onState(proxyHandle)
-      logger.debug(`[reeve] 代理层自持：${proxyHandle.ready ? '就绪' : '未就绪'} —— ${proxyHandle.detail ?? '?'}`)
+      // 状态一变就刷快照 —— 尤其"起来了"或"起不来（如实报错）"这一刻。
+      // 少了这一次，消费方只能等下一次台账变化才看到 gate 段（起不来时会一直显示 null）。
+      snapshotFlush()
     }
 
     const admission = acquireAdmissionRuntime(ctx.location?.directory, { limits })
 
-    // ---- ⑦ 性能统计（Bifrost 归因 + 台账聚合 → 快照）----
-    // 为什么在插件里做而不是面板里做：面板跑在 openchamber 的 iframe 里，**没有网络能力**，
-    // 只有宿主给的 readFile 与 writeFile。而 `/api/logs`、`/v1/models` 是本机回环的 HTTP ——
-    // 只有引擎进程里的插件够得着。所以插件取数 + 聚合，面板只读快照。
+    // ---- ⑦ 性能统计（GATE 台账聚合 + 编排台账聚合 → 快照）----
+    // 为什么在插件里做而不是面板里做：面板跑在 openchamber 的 iframe 里，**没有网络/文件能力**，
+    // 只有宿主给的 readFile 与 writeFile。台账是引擎进程能读到的本地文件；模型目录是本机回环
+    // 的 HTTP（GATE 的 `/v1/models`）—— 只有插件够得着。所以插件取数 + 聚合，面板只读快照。
     const statsOpts = typeof options.stats === 'object' && options.stats !== null ? options.stats : {}
     const statsIntervalMs = Number(statsOpts.intervalMs ?? STATS_DEFAULTS.intervalMs)
     const statsLimit = Number(statsOpts.limit ?? STATS_DEFAULTS.limit)
     const statsWindowMs = Number(statsOpts.windowMs ?? STATS_DEFAULTS.windowMs)
-    // 模型目录多久刷一次。**别跟统计同频**：`/v1/models` 是一次真去上游的探测，
-    // Bifrost 会为每个 provider 记一行日志（实测一次探测 = 7 行）—— 一分钟一次会把
-    // 用户自己的归因日志灌满探测噪声。模型目录本身变化很慢，半小时足够。
+    // 模型目录多久刷一次。**别跟统计同频**：`/v1/models` 会真去上游探测池（9router 那条），
+    // 一分钟一次没必要。模型目录本身变化很慢，半小时足够。
     const modelsIntervalMs = Number(statsOpts.modelsIntervalMs ?? STATS_DEFAULTS.modelsIntervalMs)
     let statsTimer = null
-    let statsSignature = null
     let statsInFlight = false
     let lastModelsAt = 0
 
     /** 链上已经在用的模型（面板选择器的候选之一：发现不全时至少这些能选）。 */
     const chainedRefs = () => {
       const out = []
-      for (const spec of Object.values(chainRef?.tiers ?? {})) {
-        for (const t of spec?.targets ?? []) if (t?.model) out.push(`${t.provider}/${t.model}`)
-        for (const f of spec?.fallbacks ?? []) {
-          const s = String(f ?? '')
+      for (const targets of Object.values(gateState?.chain_targets ?? {})) {
+        for (const ref of targets ?? []) {
+          const s = String(ref ?? '')
           if (s && !s.endsWith('/') && s.includes('/')) out.push(s)
         }
       }
@@ -221,53 +233,35 @@ export default {
     const engineModels = () => REEVE_TIERS.map((t) => `reeve/${t.id}`)
 
     const refreshStats = async () => {
-      if (!proxyHandle || statsInFlight) return
+      if (!gateHandle || statsInFlight) return
       statsInFlight = true
       const now = Date.now()
-      const { port, host, paths } = proxyHandle
+      const nowMs = now
       try {
-        const token = await readSetupToken(paths.token)
-        if (!token) {
-          statsState = buildStats({ now, windowMs: statsWindowMs, source: 'unavailable', error: '读不到代理的 setup token（统计接口要它）', checkedAt: now })
-          snapshotFlush()
-          return
-        }
-        // 先探一行：`total_count` + 最新 id 没变就说明没有新调用 —— 省掉一次上百行的抓取
-        const probe = await fetchBifrostLogs({ port, host, token, limit: 1 })
-        if (probe.error) {
-          statsState = buildStats({ now, windowMs: statsWindowMs, source: 'unavailable', error: `读 /api/logs 失败：${probe.error}`, checkedAt: now })
-          snapshotFlush()
-          return
-        }
-        if (probe.signature && probe.signature === statsSignature && statsState?.bifrost) {
-          statsState = { ...statsState, checkedAt: now }
-          snapshotFlush()
-          return
-        }
-        const full = await fetchBifrostLogs({ port, host, token, limit: statsLimit })
-        statsSignature = full.signature
-        const bifrost = full.error ? null : aggregateBifrostRows(full.rows, { now, windowMs: statsWindowMs })
-        const ledgerAgg = aggregateLedger(ledger.all(), { now })
+        const tail = await readLedgerTail({ path: gateHandle.ledgerPath, limit: statsLimit })
+        const gateAgg = tail.error ? null : aggregateGateRows(tail.rows, { now: nowMs, windowMs: statsWindowMs })
+        const ledgerAgg = aggregateLedger(ledger.all(), { now: nowMs })
         statsState = buildStats({
-          now,
-          checkedAt: now,
+          now: nowMs,
+          checkedAt: nowMs,
           windowMs: statsWindowMs,
-          source: bifrost ? 'bifrost.api' : 'unavailable',
-          error: full.error ? `读 /api/logs 失败：${full.error}` : null,
-          bifrost,
+          source: gateAgg ? 'gate.ledger' : 'unavailable',
+          error: tail.error ? `读台账失败：${tail.error}` : null,
+          gate: gateAgg,
           orchestrate: {
             ...ledgerAgg,
             queue: { active: admission.activeCount, waiting: admission.waitingCount },
           },
         })
+        gateState = gateHandle.snapshot()
         // 顺手把模型候选也刷一遍（半小时一次；链编辑器的选择器用它）
-        if (now - lastModelsAt >= modelsIntervalMs) {
-          const discovered = await fetchBifrostModels({ port, host })
-          lastModelsAt = now
+        if (nowMs - lastModelsAt >= modelsIntervalMs) {
+          const discovered = await fetchGateModels({ port: gateHandle.port, host: gateHandle.host })
+          lastModelsAt = nowMs
           const candidates = mergeModelCandidates({ discovered: discovered.models, chained: chainedRefs(), engine: engineModels() })
           modelsState = {
-            generatedAt: now,
-            source: discovered.error ? 'chain+engine' : 'bifrost',
+            generatedAt: nowMs,
+            source: discovered.error ? 'chain+engine' : 'gate',
             error: discovered.error,
             discovered: discovered.models.length,
             candidates,
@@ -281,11 +275,11 @@ export default {
       }
     }
 
-    if (statsIntervalMs > 0 && proxyHandle) {
+    if (statsIntervalMs > 0 && gateHandle) {
       void refreshStats()
       statsTimer = setInterval(() => void refreshStats(), statsIntervalMs)
       statsTimer.unref?.()
-      logger.debug(`[reeve] 性能统计：每 ${Math.round(statsIntervalMs / 1000)}s 刷一次（近 ${statsLimit} 行 / ${Math.round(statsWindowMs / 3600000)}h 窗口）`)
+      logger.debug(`[reeve] 性能统计：每 ${Math.round(statsIntervalMs / 1000)}s 刷一次（台账尾 ${statsLimit} 行 / ${Math.round(statsWindowMs / 3600000)}h 窗口）`)
     }
     const supervisor = new Supervisor({
       ledger,
@@ -571,7 +565,9 @@ export default {
         snapshot.cancel()
         void snapshot.flush().catch(() => {})
       }
-      if (proxyHandle) void proxyHandle.dispose().catch(() => {})
+      // GATE 是引擎级服务：卸载只"松手"（清空闲连接、不关监听口）。真正关端口只在进程退出
+      // 或测试里显式 dispose；`detach` 的定时器都是 unref 的，CLI 一次性进程照样能立刻退出。
+      if (gateHandle) gateHandle.detach?.()
       logger.debug('[reeve] 已卸载')
     }
   },

package/src/models.js

@@ -112,3 +112,14 @@ export function pickDefaultAgent(editor, id = 'foreman') {
   }
   return false
 }
+
+/**
+ * GATE 该在哪个 `host:port` 上服务（纯函数，四级回落：显式 gate → 旧 proxy 键 → 配置里的端点 → 默认）。
+ * 抽出来是为了**可测**：真实回落链要碰机器上的真实配置（和真实的 18080），不该在单测里跑。
+ */
+export function resolveGateEndpoint({ gate = null, proxy = null, endpoint = null, fallbackPort = 8080, fallbackHost = '127.0.0.1' } = {}) {
+  return {
+    port: Number(gate?.port ?? proxy?.port ?? endpoint?.port ?? fallbackPort),
+    host: gate?.host ?? endpoint?.host ?? fallbackHost,
+  }
+}

package/src/snapshot.js

@@ -92,7 +92,7 @@ export class SnapshotWriter {
  */
 export function buildSnapshot(
   records,
-  { now = Date.now(), version = null, agents = null, roster = null, proxy = null, registered = null, endpoint = null, chain = null, models = null, stats = null } = {},
+  { now = Date.now(), version = null, agents = null, roster = null, registered = null, endpoint = null, models = null, stats = null, gate = null } = {},
 ) {
   const tasks = records
     .map((r) => ({
@@ -123,8 +123,7 @@ export function buildSnapshot(
     version,
     agentTable: agents,
     roster,
-    proxy,
-    chain: chain == null ? null : projectChain(chain),
+    gate,
     models,
     registered,
     endpoint,
@@ -134,27 +133,6 @@ export function buildSnapshot(
   }
 }
 
-/**
- * 链的状态 → 面板要的那一小块。
- * `tiers` 就是 `~/.reeve/chain.json` 里那份形状（面板编辑的就是它，写回也是它）。
- */
-export function projectChain(chain) {
-  if (!chain) return null
-  return {
-    tiersPath: chain.tiersPath ?? null,
-    source: chain.source ?? null,
-    from: chain.from ?? null,
-    derived: chain.derived === true,
-    tiers: chain.tiers ?? null,
-    problems: chain.problems ?? [],
-    error: chain.error ?? null,
-    changedAt: chain.changedAt ?? null,
-    appliedAt: chain.appliedAt ?? null,
-    drift: chain.drift ?? null,
-    lastError: chain.lastError ?? null,
-  }
-}
-
 /**
  * 从 `ctx.agent.list()` 的返回里抽出"谁可见"的最小形状。
  * 读不到就返回 null —— 快照里没有这一节，不假装知道。