@sema-agent/server 7.50.0 → 7.52.0

package/dist/boot/device-lane.d.ts

@@ -0,0 +1,79 @@
+/**
+ * design/158 A10 分段 —— **device lane 的装配件**(device-executor-lane-v2 §4.6/§4.7/§5,车A-4)。
+ *
+ * 一处建齐三件活对象:**店**(四表双库的 `DeviceStore`)→ **准入链**(`DeviceEnrollment`,含跨副本
+ * 限速座)→ **WS 汇聚端**(`DeviceWsHub`)。三件的依赖是单向的(hub 吃 store+enrollment),所以它们
+ * 必须在同一处按序建 —— 拆到三处装配点会让「hub 拿到的是不是同一只店」变成一个要读三个文件才答得出
+ * 的问题(而答错的后果是 presence 与租约各写各的)。
+ *
+ * ⚠️ **位置即契约**:必须在 `openStores`(拿 backend)之后、`createExecutionEnv`(第七臂要这三件)之前
+ * 调用;`attach(server)` 则要等 `createHttpServer` 造出裸 `http.Server` 之后(main.ts 的顺序)。
+ *
+ * 🔴 本模块**不**做车道选择:`REMOTE_EXEC=device` 与否由调用方判(main.ts)。它只回答一件事 ——
+ * 「这台机器上,device lane 的三件装配得起来吗」。装不起来就返回 `undefined`,由
+ * {@link assertDeviceLaneWired} 响亮拒启(#157:执行车道上没有静默降级臂)。
+ */
+import { type DeviceEnrollRateLimiter, type DeviceEnrollment } from "../device-enrollment.js";
+import type { DeviceStore } from "../device-store.js";
+import { type DeviceWsHub } from "../device-ws-hub.js";
+import type { ServiceConfig } from "../config.js";
+import type { Logger } from "../observability/logger.js";
+import type { Metrics } from "../observability/metrics.js";
+import type { RateGate } from "../observability/rate-limit.js";
+import type { StoreBackend } from "../plugins/store-backend.js";
+export interface DeviceLaneCtx {
+    config: ServiceConfig;
+    logger: Logger;
+    metrics: Metrics;
+    backend: StoreBackend | undefined;
+    /** 本副本 id(写进连接租约行 —— §4.6 的跨副本排障面)。 */
+    replicaId: string;
+    /**
+     * 既有的**跨副本** RateGate(SQL 后端形 = `TiDBRateLimiter`/`PgRateLimiter`;单副本形 = 进程内
+     * `RateLimiter`)。A-2 的移交义务③:enrollment 的限速不自建第二套计数面,适配这一只。
+     *
+     * 🔴 传的是**取值器**不是值:那一只建在 main.ts 的下游(它要 `counterDegradeHook`),而 device lane
+     * 必须建在 `createExecutionEnv` 之前 —— 顺序对不上。取值器让「谁先建」不再是正确性问题:boot 期
+     * 不可能有 enroll 请求,取不到 ⇒ 座**抛**(fail-closed,enrollment 翻成 429),不是放行。
+     */
+    rateGate?: (() => RateGate | undefined) | undefined;
+}
+export interface DeviceLane {
+    store: DeviceStore;
+    enrollment: DeviceEnrollment;
+    hub: DeviceWsHub;
+}
+/**
+ * 把既有的**同步** {@link RateGate} 适配成 enrollment 要的异步座(A-2 移交义务③)。
+ *
+ * 🔴 为什么是适配而不是新建一只:限速面在本仓已有属主(`observability/rate-limit.ts` + 两支 SQL 孪生),
+ * 而 SQL 孪生是**跨副本**的 —— enrollment 自带的 `createFixedWindowRateLimiter` 诚实地只是每副本窗
+ * (它自己的头注就这么写),对 token 撞库来说「N 个副本 = N 倍配额」。适配既有的那一只,撞库预算才是
+ * 全局的一份。
+ *
+ * 键前缀 `device-enroll:` 是必须的:RateGate 的键空间与 HTTP 面的 principal 键**共用一张表**,不加前缀
+ * 会让一次 enrollment 尝试吃掉调用方的普通请求配额(反过来也一样)。
+ */
+export declare function createDeviceEnrollRateLimiter(gate: () => RateGate | undefined): DeviceEnrollRateLimiter;
+/**
+ * 建齐 device lane 的三件。返回 `undefined` = **建不起来**(没有 SQL 后端 ⇒ 没有四表店)。
+ *
+ * 只在调用方判定本部署是 device 车道时调用;非 device 车道调用它是纯浪费(会白建一只 WS server)。
+ */
+export declare function createDeviceLane(ctx: DeviceLaneCtx): DeviceLane | undefined;
+/**
+ * **装配后**的拒启门(car A-1 的 `device-executor-unwired` 换来的真门;先例逐字 =
+ * `boot/leader.ts` 的 `assertLeaderDurableStore`)。
+ *
+ * config 层的门①判的是「运维配没配 SQL 坐标」——那句话回答的是**意图**。它回答不了「这次启动**真的
+ * 拿到**了店吗」:`openStoreBackendWithFallback` 在 `SESSION_BACKEND=auto`(默认)下,SQL 连不上 /
+ * 建表失败 ⇒ `backend=undefined` + 一条 warn 就继续启动。那次启动里 device lane 的四表整个不在,
+ * 而 `boot/execution-env.ts` 的第七臂拿不到三件 ⇒ `executionEnvFactory` 落 `undefined` ⇒ core 拿
+ * `StubExecutionEnv`:**一台自称在员工设备上执行的 worker 实际在自己进程里跑,而且回执同形**。
+ * 那正是 #157「执行车道禁静默降级」点名的样板病,也正是 A-1 那条临时门当初要拦的东西 —— 换执法点,
+ * 不是取消执法。
+ *
+ * 抛而不是 warn:降级的代价由用户承担(他以为命令跑在自己机器上、看到的却是云上一个空目录的结果)。
+ */
+export declare function assertDeviceLaneWired(isDeviceLane: boolean, lane: DeviceLane | undefined, hasFactory: boolean): void;
+//# sourceMappingURL=device-lane.d.ts.map

package/dist/boot/device-lane.js

@@ -0,0 +1,63 @@
+import { createDeviceEnrollment, createFixedWindowRateLimiter } from "../device-enrollment.js";
+import { createDeviceWsHub } from "../device-ws-hub.js";
+export function createDeviceEnrollRateLimiter(gate) {
+    return {
+        check: async (key) => {
+            const g = gate();
+            if (!g)
+                throw new Error("device enrollment rate gate is not wired yet (boot window) — refusing rather than admitting unmetered enrollment attempts");
+            const verdict = g.check(`device-enroll:${key}`);
+            return { allowed: verdict.allowed, retryAfterSec: verdict.retryAfterSec };
+        },
+    };
+}
+export function createDeviceLane(ctx) {
+    const { config, logger, metrics, backend, replicaId } = ctx;
+    const store = backend?.device?.();
+    if (!store)
+        return undefined;
+    const knobs = config.remoteExec?.provider === "device" ? config.remoteExec : undefined;
+    const enrollment = createDeviceEnrollment({
+        store,
+        ...(ctx.rateGate ? { rateLimiter: createDeviceEnrollRateLimiter(ctx.rateGate) } : { rateLimiter: createFixedWindowRateLimiter({ limit: 10, windowMs: 60_000 }) }),
+    });
+    const hub = createDeviceWsHub({
+        store,
+        enrollment,
+        replicaId,
+        logger: {
+            warn: (msg, fields) => logger.warn(msg, fields),
+            error: (msg, fields) => logger.error(msg, fields),
+            info: (msg, fields) => logger.info(msg, fields),
+        },
+        metrics: { inc: (name, labels) => metrics.inc(name, labels) },
+        ...(knobs?.deliveryTimeoutMs != null ? { dispatchTimeoutMs: knobs.deliveryTimeoutMs } : {}),
+        ...(knobs?.reconnectGraceMs != null ? { reconnectGraceMs: knobs.reconnectGraceMs } : {}),
+        ...(knobs?.maxInflightPerDevice != null ? { maxInflightPerDevice: knobs.maxInflightPerDevice } : {}),
+        ...(knobs?.supersede ? { supersede: knobs.supersede } : {}),
+    });
+    logger.info("device_lane_enabled", {
+        replicaId,
+        maxInflightPerDevice: knobs?.maxInflightPerDevice ?? 4,
+        crossReplicaEnrollRateLimit: ctx.rateGate !== undefined,
+    });
+    return { store, enrollment, hub };
+}
+export function assertDeviceLaneWired(isDeviceLane, lane, hasFactory) {
+    if (!isDeviceLane)
+        return;
+    if (!lane) {
+        throw new Error("REMOTE_EXEC=device but the device lane could not be wired at boot [device-lane-unwired]: the SQL backend is " +
+            "configured yet this replica did not get one (an unreachable DB / failed DDL degrades to the in-memory fallback " +
+            "when SESSION_BACKEND=auto), so the device registry / session↔device binding / audit tables are absent. " +
+            "Refusing to serve a lane that would silently fall back to the in-process stub env — a worker claiming to " +
+            "execute on the employee's device while actually running inside its own process (#157). Fix the database " +
+            "(or unset REMOTE_EXEC) and restart (device-executor-lane-v2 §4.7)");
+    }
+    if (!hasFactory) {
+        throw new Error("REMOTE_EXEC=device but no DeviceExecutionEnv factory was built [device-lane-unwired]: the lane's stores are up " +
+            "yet `boot/execution-env.ts` produced no factory, so core would fall back to the in-process stub env. This is " +
+            "an assembly bug, not a configuration one — refusing to start rather than silently execute in-process (#157)");
+    }
+}
+//# sourceMappingURL=device-lane.js.map

package/dist/boot/engine-lease.d.ts

@@ -68,7 +68,7 @@ export interface EngineLeaseDeps {
     lastActivityAt: () => number;
     /** 最后一条**附着流断开**的单调时刻(`drainState.lastAttachEndedAt`)。
      *
-     *  🔴 codex 对抗复审 R1-F1(验真后修):`attachedStreams` 是**采样**面,`lastActivityAt` 记的是
+     *  🔴 codex 交叉复审 R1-F1(验真后修):`attachedStreams` 是**采样**面,`lastActivityAt` 记的是
      *  **入场**(admission)时刻 —— 两者合起来仍漏一个形:一条**整个生命周期都落在两拍之间**的流
      *  (活得比拍频短)从没被任何一拍看见,于是 `idleSince` 保持着这条流出现**之前**的旧值,而
      *  「已经没人附着满 lingerMs」这句承诺可以提前至多一整拍兑现。补这条**离场**触点之后,判据变成

package/dist/boot/execution-env.d.ts

@@ -5,19 +5,65 @@ import type { ServiceConfig } from "../config.js";
 import type { Logger } from "../observability/logger.js";
 import type { Metrics } from "../observability/metrics.js";
 import { PerTaskImageRegistry } from "../per-task-image.js";
+import type { DeviceEnrollment } from "../device-enrollment.js";
+import type { DeviceStore } from "../device-store.js";
+import type { DeviceWsHub } from "../device-ws-hub.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
+/**
+ * per-session 的 **cwd / shellEnv 登记簿**(TOC cwd seam + R-survey shellEnv seam)+ 它们的**租户围栏**。
+ *
+ * ── 为什么围栏不是可选的(codex R1-F1,判真)────────────────────────────────────────────────────
+ * 这两张表只按 `sessionId` 键控。在 host lane 上那是安全的:那条车道的闸带 `requirePrincipal !== true`,
+ * 整台机器就一个用户。**device lane 把这个前提撤掉了** —— 它的闸(`deviceCwdHonored`)刻意不要求单用户
+ * (员工各连各的设备)。于是一条真实的超范围路径出现了:
+ *   ① sessionId 由**调用方自选**,而且 `DELETE /v1/sessions/:id` 之后可以被**别人** `register` 重新登记
+ *      (`boot/session-faces.ts` 的化身围栏注逐字写着这件事);
+ *   ② 会话删除的级联删的是库里的行,**够不着这两张进程内的表**;
+ *   ③ 新主如果没有重发 `settings.env`,工厂读到的就是**上一位主人的** shell env —— 那是秘密面(NPM_TOKEN
+ *      一类),而且会被注进新主自己设备上的指令;cwd 也会跨化身残留。
+ *
+ * 所以围栏做在**身份已知**的那一处:每次提交经 resolve-spec 调 {@link SessionScopedRegistries.fenceSessionOwner}
+ * 对拍,换主即清。删除侧再加一条 {@link SessionScopedRegistries.dropSession}(E21 级联)——那条不是为了
+ * 关这个洞(读面必经提交、提交必过围栏),而是**右侧删除权**:一次删除之后,秘密不该还留在进程内存里。
+ *
+ * ⚠️ 诚实残余(如实登记,不假装关掉):两张表是**每副本进程内**的。围栏与清除都只在处理该请求/该删除的
+ * 那一个副本上发生。跨副本的陈值靠「读面必经本副本的一次提交 ⇒ 必过本副本的围栏」兜住 —— 这条推理成立
+ * 是因为 run 在受理它的那个副本上执行(ARCHITECTURE 副本模型)。device lane 的部署形本身也是单副本(§4.6)。
+ */
+export interface SessionScopedRegistries {
+    readonly perSessionCwd: Map<string, string>;
+    readonly perSessionShellEnv: Map<string, Record<string, string>>;
+    setSessionCwd(sid: string, cwd: string): void;
+    setSessionShellEnv(sid: string, env: Record<string, string>): void;
+    /** 记录/对拍本会话的主人。与上次不同 ⇒ **先清两张表**再记新主(换主即清)。`null` = 匿名会话,
+     *  它同样是一个**稳定**的身份值(不是「未知」),所以匿名重入不会被判成换主。 */
+    fenceSessionOwner(sid: string, owner: string | null): void;
+    /** 会话删除:两张表 + 身份记录一起清(留着身份记录会让同 id 的下一位与一个幽灵身份比对成「同主」)。 */
+    dropSession(sid: string): void;
+}
+export declare function createSessionScopedRegistries(maxEntries?: number): SessionScopedRegistries;
+/** device lane 的三件活对象(店 / 汇聚端 / 准入链)。缺席 = 本部署没有 device 车道。 */
+export interface DeviceLaneWiring {
+    store: DeviceStore;
+    hub: DeviceWsHub;
+    enrollment: DeviceEnrollment;
+}
 export interface ExecutionEnvCtx {
     config: ServiceConfig;
     logger: Logger;
     metrics: Metrics;
     taskAttachmentStore: TaskAttachmentStore | undefined;
+    /** 车A-4:device lane 的装配件(`REMOTE_EXEC=device` 且 SQL 店在场时由 main.ts 建好传进来)。 */
+    deviceLane?: DeviceLaneWiring;
 }
 export declare function createExecutionEnv(ctx: ExecutionEnvCtx): {
     perTaskImage: PerTaskImageRegistry;
     sessionEnvSelection: SessionEnvironmentSelection;
     perSessionCwd: Map<string, string>;
-    setSessionCwd: (sid: string, value: string) => void;
-    setSessionShellEnv: (sid: string, value: Record<string, string>) => void;
+    setSessionCwd: (sid: string, cwd: string) => void;
+    setSessionShellEnv: (sid: string, env: Record<string, string>) => void;
+    fenceSessionOwner: (sid: string, owner: string | null) => void;
+    dropSessionScoped: (sid: string) => void;
     executionEnvFactory: import("@sema-agent/core").ExecutionEnvFactory | undefined;
     worktreeReap: (() => Promise<void>) | undefined;
     sendUserFileTaskEnvs: TaskEnvRegistry | undefined;

package/dist/boot/execution-env.js

@@ -7,6 +7,7 @@ import { createE2bLspManager } from "../lsp/e2b-manager.js";
 import { evictLspOnDestroy } from "../lsp-evict.js";
 import { PerTaskImageRegistry } from "../per-task-image.js";
 import { adbExecutionEnvFactory } from "../plugins/remote-env-adb.js";
+import { deviceExecutionEnvFactory } from "../plugins/remote-env-device.js";
 import { e2bExecutionEnvFactory } from "../plugins/remote-env-e2b.js";
 import { hostExecutionEnvFactory, RemoteHostExecutionEnv } from "../plugins/remote-env-host.js";
 import { k8sExecutionEnvFactory } from "../plugins/remote-env-k8s.js";
@@ -27,15 +28,51 @@ function boundedSessionSetter(map, maxEntries) {
             map.delete(map.keys().next().value);
     };
 }
+const MAX_CWD_SESSIONS = 4096;
+export function createSessionScopedRegistries(maxEntries = MAX_CWD_SESSIONS) {
+    const perSessionCwd = new Map();
+    const perSessionShellEnv = new Map();
+    const owners = new Map();
+    const dropSession = (sid) => {
+        perSessionCwd.delete(sid);
+        perSessionShellEnv.delete(sid);
+        owners.delete(sid);
+    };
+    const touch = (sid, owner) => {
+        const next = owner === undefined ? (owners.has(sid) ? owners.get(sid) : null) : owner;
+        owners.delete(sid);
+        owners.set(sid, next);
+        while (owners.size > maxEntries)
+            dropSession(owners.keys().next().value);
+    };
+    return {
+        perSessionCwd,
+        perSessionShellEnv,
+        setSessionCwd: (sid, cwd) => {
+            perSessionCwd.set(sid, cwd);
+            touch(sid, undefined);
+        },
+        setSessionShellEnv: (sid, env) => {
+            perSessionShellEnv.set(sid, env);
+            touch(sid, undefined);
+        },
+        fenceSessionOwner: (sid, owner) => {
+            if (owners.has(sid) && owners.get(sid) !== owner) {
+                perSessionCwd.delete(sid);
+                perSessionShellEnv.delete(sid);
+            }
+            touch(sid, owner);
+        },
+        dropSession,
+    };
+}
 export function createExecutionEnv(ctx) {
     const { config, logger, metrics, taskAttachmentStore } = ctx;
     const perTaskImage = new PerTaskImageRegistry();
     const sessionEnvSelection = new SessionEnvironmentSelection();
-    const MAX_CWD_SESSIONS = 4096;
-    const perSessionCwd = new Map();
-    const setSessionCwd = boundedSessionSetter(perSessionCwd, MAX_CWD_SESSIONS);
-    const perSessionShellEnv = new Map();
-    const setSessionShellEnv = boundedSessionSetter(perSessionShellEnv, MAX_CWD_SESSIONS);
+    const sessionScoped = createSessionScopedRegistries();
+    const { perSessionCwd, setSessionCwd } = sessionScoped;
+    const { perSessionShellEnv, setSessionShellEnv } = sessionScoped;
     let executionEnvFactory;
     let worktreeReap;
     if (config.remoteExec?.provider === "e2b") {
@@ -85,6 +122,19 @@ export function createExecutionEnv(ctx) {
             ...(config.remoteExec.hostKey !== undefined ? { hostKey: config.remoteExec.hostKey } : {}),
         });
     }
+    else if (config.remoteExec?.provider === "device") {
+        if (ctx.deviceLane) {
+            executionEnvFactory = deviceExecutionEnvFactory({
+                hub: ctx.deviceLane.hub,
+                store: ctx.deviceLane.store,
+                enrollment: ctx.deviceLane.enrollment,
+                ...(config.remoteExec.execTimeoutMs != null ? { execTimeoutMs: config.remoteExec.execTimeoutMs } : {}),
+                perSessionCwd,
+                perSessionShellEnv,
+                logger,
+            });
+        }
+    }
     else if (config.remoteExec?.provider === "adb") {
         executionEnvFactory = adbExecutionEnvFactory({
             serial: config.remoteExec.serial,
@@ -236,6 +286,8 @@ export function createExecutionEnv(ctx) {
         logger.info("lsp_enabled", { provider: lspProvider });
     return {
         perTaskImage, sessionEnvSelection, perSessionCwd, setSessionCwd, setSessionShellEnv,
+        fenceSessionOwner: sessionScoped.fenceSessionOwner,
+        dropSessionScoped: sessionScoped.dropSession,
         executionEnvFactory, worktreeReap, sendUserFileTaskEnvs, lspManager,
     };
 }

package/dist/boot/governance-seams.d.ts

@@ -75,7 +75,7 @@ export interface GovernanceSeamsCtx {
      * #270 车1 —— **本 build 是否真的接了留存执行器**(sweep lane;车2 的 `startRetentionLane()`)。
      * 缺席 = `false`。
      *
-     * 🔴 为什么这一位必须存在(codex 对抗复审 R2-[critical],验真后修):core 的
+     * 🔴 为什么这一位必须存在(codex 交叉复审 R2-[critical],验真后修):core 的
      * `assertRetentionCapability` 只读**店的声明位**。#270 车1 让三只 SQL 店如实声明了 `"managed"`
      * (它们的行确实由托管留存删),于是那道门从此**放行** locked policy —— 可执行器还在车2 手里。
      * 两者之间的窗口如果什么都不做,后果正是本仓最忌的那种:部署自述「策略已受管」、审计与能力面
@@ -96,7 +96,7 @@ export declare function assertLockAssemblable(input: {
     deploymentMcpConfigured: boolean;
 }): void;
 /**
- * 治理面的**装配相容性**总判据(codex 对抗复审 R2-F2 起扩面)——锁与合规档位在这条轴上是同一件事:
+ * 治理面的**装配相容性**总判据(codex 交叉复审 R2-F2 起扩面)——锁与合规档位在这条轴上是同一件事:
  * 两者都可能把「本部署自己的装配」判成 core 门口的违规,而那不是「配得更严」,是**这台从此每条腿必失败**。
  *
  * 合规半场的判据来自亲核 core 的 prepare 门(`prepare-task` 的 compliance 段):被否决的能力若**已在

package/dist/boot/leader.d.ts

@@ -40,7 +40,7 @@ export interface LeaderCtx {
  */
 export declare function leaderK8sMinioGap(leaderEnabled: boolean, leaderProvider: string | undefined, hasS3: boolean): string[] | null;
 /**
- * #193 车4 件2 的**能力面**门(codex 对抗复审 R1-high①,验真后修)。
+ * #193 车4 件2 的**能力面**门(codex 交叉复审 R1-high①,验真后修)。
  *
  * config 层的门②判的是 `DB_BACKEND` 的字面值 —— 那句话回答的是「运维要没要 durable」。它回答不了
  * 「这次启动**真的拿到**了 durable 吗」:`openStoreBackendWithFallback` 在 `SESSION_BACKEND=auto`

package/dist/boot/memory-boundary.d.ts

@@ -2,8 +2,8 @@
  * #214 记忆边界不变式(板 [3492]② 立案,[3521] 裁1 与 core #151 同窗)—— 启动期把「结构性写不进的记忆
  * 部署形」说出来。
  *
- * 病根(test 仓 [3479] 实测,[3490]② 定位):core 的记忆工具面是 `memory_search`/`memory_get` 两只**只读**
- * 工具;**写**记忆没有专用工具 —— 模型用 fs 工具往记忆根写文件,harvest 再从那里收编。于是整条链的成立
+ * 根本问题(test 仓 [3479] 实测,[3490]② 定位):core 的记忆工具面是 `memory_search`/`memory_get`/
+ * `memory_index`(#493 第五单起第三只,枚举面,仍只读)三只**只读**工具;**写**记忆没有专用工具 —— 模型用 fs 工具往记忆根写文件,harvest 再从那里收编。于是整条链的成立
  * 条件是「记忆根落在该次任务的 fs 授权边界之内」。server 把根交给 core(`RunnerDeps.memoryEngineDir`)
  * 之后,没有任何一处保证这一点,也没有任何一处说过「这台部署的记忆写面够不着」。默认根是
  * `~/.ai-agent`(或 `AGENT_DATA_DIR`),默认围栏是任务 cwd —— 两者天然不相交:用户说「记住 X」,模型照

package/dist/boot/memory-consolidation.d.ts

@@ -31,7 +31,7 @@ export interface ConsolidationDriverSeat {
  */
 export declare function resolveConsolidationDriverSeat(deps: MemoryConsolidationDriverDeps): ConsolidationDriverSeat;
 /**
- * **每 scope 单飞**(codex 对抗复审 [high],验真后修)—— 同一 scope 上在飞的那一轮被后来者**并入**,
+ * **每 scope 单飞**(codex 交叉复审 [high],验真后修)—— 同一 scope 上在飞的那一轮被后来者**并入**,
  * 而不是各起一轮。`create*`:返回带状态的活对象。
  *
  * ## 病(不是理论)
@@ -47,7 +47,7 @@ export declare function resolveConsolidationDriverSeat(deps: MemoryConsolidation
  * 本仓没有 —— 同 §遗留 遗-1 的那条基建缺口)。今天够得着这条阀门的部署形态是 file 记忆后端,那种部署
  * 实际上是单副本,所以进程内单飞覆盖了真实的失败形;但话按**它真正保证的**说,不按它常常够用说。
  *
- * 单飞**不是缓存**:那一轮落定(无论成败)即刻放行下一轮 —— 否则一次失败会把这个 scope 永久钉死。
+ * 单飞**不是缓存**:那一轮落定(无论成败)即刻放行下一轮 —— 否则一次失败会把这个 scope 永久卡住。
  */
 export declare function createPerScopeSingleFlight<T>(): (scope: string, run: () => Promise<T>) => Promise<T>;
 /**
@@ -80,7 +80,7 @@ export declare function assertConsolidationDriverWirable(input: {
     provenance?: "off" | "carry";
 }): void;
 /**
- * 阀门上了场之后的**可达性**告警两条(自查 + codex 对抗复审;姿态=warn 不拒启)。
+ * 阀门上了场之后的**可达性**告警两条(自查 + codex 交叉复审;姿态=warn 不拒启)。
  *
  * ## 病(结构性,而且**只在**这条阀门够得着的那种部署上成立)
  *
@@ -114,11 +114,11 @@ export declare function buildConsolidationValveAudit(input: {
     }>;
 };
 /**
- * 停因诊断行的**运维日志**投影(codex 对抗复审 R2-[medium],验真后修)。`build*`:纯数据。
+ * 停因诊断行的**运维日志**投影(codex 交叉复审 R2-[medium],验真后修)。`build*`:纯数据。
  *
  * `stopDetail` 已经不上 wire(`routes/memory-consolidation.ts` 的同名段:core 的 `driver_failed` 支把
  * 模型座抛出的 `Error.message` 逐字拼进去)。但**落日志同样要有信任边界** —— 集中式日志是人读的,
- * 而一段来路不明的文本混在自家诊断里,既可能夹带凭据,也可能把攻击者写的"操作建议"摆成本服务的口吻。
+ * 而一段来路不明的文本混在自家诊断里,既可能夹带凭据,也可能把不当调用方写的"操作建议"摆成本服务的口吻。
  * 三件:
  *  ① 字段名 `untrustedDetail` **自陈**(一个叫 `detail` 的键会被下一个读日志的人当成本服务自己的诊断);
  *  ② `redactSecrets` 脱敏(与审批卡片面同一只属主函数,不在本层另写一份模式表);
@@ -159,7 +159,7 @@ export interface MemoryConsolidationFaces {
  *
  * 本仓**没有**一个长命的 `MemoryEngine` 实例:`boot/stores.ts` 装配出来的 `memoryEngine` 是
  * `{ backend, root }` 二元组,真引擎由 core 的 Runner **每任务现构**。HTTP 面要一个引擎就得自己构。
- * 两只引擎不会各说各话:控制面由后端钉死(`backend.controlPlaneRoot`),gate / run 账 / plan 归档
+ * 两只引擎不会各说各话:控制面由后端写死(`backend.controlPlaneRoot`),gate / run 账 / plan 归档
  * 全住在那里,所以操作面引擎与每任务引擎看的是**同一本**账。
  *
  * ## `consolidation: {}` = 出厂缺省,**显式在场**

package/dist/boot/org-memory.d.ts

@@ -35,7 +35,7 @@ export interface OrgMemoryAdmissionWiring {
      * 🔴 A-057.40:这一席**故意**留快照,不跟 `config.projects` 的热应用走,理由是 core 根本不优先吃它:
      * 本仓每个请求都在 `boot/resolve-spec.ts` 现读 `config.projects[...].defaultScopes`(热加的项目当场
      * 进 spec),并在 `memory-scope.ts` 按 `originPolicy.multiTenant` 给每个 `org:` 键**盖章**;core 的
-     * `memory-admission` 先看盖章、只有没盖章时才查这张表 ⇒ 单用户部署下热注册项目的 org 键恒被盖成
+     * `memory-admission` 先看盖章、只有没盖章时才查这张表 ⇒ 单用户部署下热注册项目的 org 键恒被覆盖为
      * `deployment`,这张表陈旧只会让 `governed` / `orgGovernedProvenance` 两个布尔偏保守,**不产生拒绝**。
      * 需要跟着热应用走的是另一个消费点(共享记忆读面)—— 见 {@link deploymentMemoryScopesLive}。
      */

package/dist/boot/parked-revive-gate.d.ts

@@ -23,7 +23,7 @@ export interface ParkedReviveGateDeps {
      * 部署级活体审批席 —— `RunnerDeps.onAsk` 的**同源铸法**(main.ts 递 `createRunnerDepsOnAsk(toolApproval)`,
      * 单一属主同 boot/runner-deps.ts)。
      *
-     * ⚠️ **本仓确有 per-task `spec.onAsk` 装配点**(codex 对抗复审 R1-中1 验真纠正 —— 别照抄
+     * ⚠️ **本仓确有 per-task `spec.onAsk` 装配点**(codex 交叉复审 R1-中1 验真纠正 —— 别照抄
      * `createRunnerDepsOnAsk` 头注那句「bg/resume 两条腿没有 per-task 装配点」,那句话的射程只是那两条腿):
      * `http/routes/tasks.ts` 的宿主 sync/stream 腿在装配点写 `spec.onAsk = toolApproval.boundAsk({owner,
      * taskId, sessionId, legKey…})`(windowZero 形则写一个恒返 `"unavailable"` 的闭包)。core 冻的是
@@ -72,7 +72,7 @@ export interface ParkedReviveGateDeps {
 /**
  * core 1.396 的父约束席位形(`parkedResume.inheritedGate`)—— 从**载体自己的签名位推导**,绝不手写。
  *
- * 🔴 手写这个形状会**藏住轴**(codex 对抗复审 R1-高2 的真回归):第一版在这里手抄了一个只有
+ * 🔴 手写这个形状会**藏住轴**(codex 交叉复审 R1-高2 的真回归):第一版在这里手抄了一个只有
  * `parentConstraints` 的接口,于是 core 载体上那个 `shellGate` 槽在类型层面根本看不见,「shellGate 轴
  * 也要交回」这件事就无声地漏了一整刀。推导形让「core 又加了一条能收紧的轴」变成本仓的编译期/钉子面
  * 事件(载体键集钉见 test/parked-revive-gate-wiring.test.ts)。
@@ -124,7 +124,7 @@ export type RebuiltParentConstraint = NonNullable<RebuiltInheritedGate["parentCo
  *    (test/parked-revive-e2e.test.ts);真 settings→park→赎回的端到端钉未建(候件,随收口件一起)。
  */
 /**
- * 🔴 A-057.44 第二半(codex 对抗复审 medium,验真后采纳)—— 席位多收一位**权威 principal**。
+ * 🔴 A-057.44 第二半(codex 交叉复审 medium,验真后采纳)—— 席位多收一位**权威 principal**。
  *
  * 为什么不能只看 `row.scope`:`principal ?? "default"` 这套约定在那一列上是**有损**的(匿名与一个真名叫
  * `default` 的租户同形),而匿名别名匹配(见 `parked-decide.ts` 的 `backgroundScopesForCheckpointScope`)

package/dist/boot/reapers.d.ts

@@ -69,7 +69,7 @@ export interface ReapersCtx {
     rateLimiter: RateLimiter | RateLimiterStore | undefined;
     costQuota: CostQuota | CostQuotaStore | undefined;
     toolResultStore: ToolResultStoreFull | undefined;
-    fileSnapshotStore: ReturnType<StoreBackend["fileSnapshot"]> | undefined;
+    fileHistoryStore: ReturnType<StoreBackend["fileHistory"]> | undefined;
     taskAttachmentStore: TaskAttachmentStore | undefined;
     imageBakes: ImageBake | undefined;
     worktreeReap: (() => Promise<void>) | undefined;
@@ -154,7 +154,7 @@ interface ReapSessionsInputs {
  *    的 id 会回落 transient(进程内 no-op),那会让 core 数出一次**从未发生**的 release
  *    (`orphanPlacedReleased` 当场变成谎)而字节还在库里。故先按**持久化元组**判(一次 PK 探针),
  *    placed 走 host 店的真删除;其余 id 原样保留 [1522] 裁定的双店语义。
- *  · 🔴 探针本身失败 ⇒ **响亮抛**(codex 对抗复审 R1-[medium],验真后修:本函数的初版把探针错误
+ *  · 🔴 探针本身失败 ⇒ **响亮抛**(codex 交叉复审 R1-[medium],验真后修:本函数的初版把探针错误
  *    改写成 `undefined` 再落路由店 —— 而重启后路由店不认识 placed id ⇒ transient no-op,core 却因为
  *    release 正常 resolve 而 `orphanPlacedReleased++`。间歇性 DB 故障于是被**伪装成 GC 成功**:监控
  *    报着「收掉了 N 条孤儿」,durable 字节一条没动。这正是本函数顶注要防的那个形,初版自己踩了。

package/dist/boot/reapers.js

@@ -56,7 +56,7 @@ export function createPlacementAwareReapSessions(deps) {
     };
 }
 export function startReapers(ctx) {
-    const { config, logger, metrics, localRoot, backend, subRunner, runStore, checkpointStore, rateLimiter, costQuota, toolResultStore, fileSnapshotStore, taskAttachmentStore, imageBakes, worktreeReap, workflowNotifyGate, workflowRecoverOpts, workflowJournalStore, sqlWorkflowRunStore, workflowNotifyJournal, rosterStore, backgroundAgentStore, mailboxStore, toolApproval, permissionRuleStores, getRunDenySweep, } = ctx;
+    const { config, logger, metrics, localRoot, backend, subRunner, runStore, checkpointStore, rateLimiter, costQuota, toolResultStore, fileHistoryStore, taskAttachmentStore, imageBakes, worktreeReap, workflowNotifyGate, workflowRecoverOpts, workflowJournalStore, sqlWorkflowRunStore, workflowNotifyJournal, rosterStore, backgroundAgentStore, mailboxStore, toolApproval, permissionRuleStores, getRunDenySweep, } = ctx;
     const leg = (p) => {
         if (p !== undefined)
             trackMaintenanceLeg(p);
@@ -85,7 +85,8 @@ export function startReapers(ctx) {
     const runsReapSuspendedGuard = createThrottledReaperCatch("runs_reap_suspended", logger);
     const checkpointReapCtxGuard = createThrottledReaperCatch("checkpoint_reap_ctx", logger);
     const toolResultReapOlderThanGuard = createThrottledReaperCatch("tool_result_reap_older_than", logger);
-    const fileSnapshotSweepOrphanBlobsGuard = createThrottledReaperCatch("file_snapshot_sweep_orphan_blobs", logger);
+    const fileHistorySweepOrphanBlobsGuard = createThrottledReaperCatch("file_history_sweep_orphan_blobs", logger);
+    const legacySnapshotBlobSweepGuard = createThrottledReaperCatch("legacy_snapshot_blob_sweep", logger);
     const attachmentReapUnboundGuard = createThrottledReaperCatch("attachment_reap_unbound", logger);
     const sessionSweepStagingGuard = createThrottledReaperCatch("session_sweep_staging", logger);
     const imageBakesReapStaleGuard = createThrottledReaperCatch("image_bakes_reap_stale", logger);
@@ -100,6 +101,8 @@ export function startReapers(ctx) {
     const leaderRunStore = config.leaderEnabled ? backend?.leaderRun?.() : undefined;
     const scratchpadSweepStaleGuard = createThrottledReaperCatch("scratchpad_sweep_stale", logger);
     const approvalReconcileGuard = createThrottledReaperCatch("approval_reconcile", logger);
+    const approvalSuspendedPollGuard = createThrottledReaperCatch("approval_suspended_poll", logger);
+    let approvalSuspendedPollInFlight = false;
     const permissionRuleReapGuard = createThrottledReaperCatch("permission_rule_reap_expired", logger);
     let permissionRuleReapInFlight = false;
     let approvalReconcileInFlight = false;
@@ -220,9 +223,12 @@ export function startReapers(ctx) {
         leg(toolResultStore
             ?.reapOlderThan?.(Date.now() - config.toolResultTtlSec * 1000)
             ?.then(() => toolResultReapOlderThanGuard.onSuccess(), toolResultReapOlderThanGuard.onError));
-        leg(fileSnapshotStore
+        leg(fileHistoryStore
             ?.sweepOrphanBlobs?.()
-            .then(() => fileSnapshotSweepOrphanBlobsGuard.onSuccess(), fileSnapshotSweepOrphanBlobsGuard.onError));
+            .then(() => fileHistorySweepOrphanBlobsGuard.onSuccess(), fileHistorySweepOrphanBlobsGuard.onError));
+        leg(backend?.legacySnapshotBlobSweep?.()
+            .then(reapCount("legacy_snapshot_blobs_swept_total", {}))
+            .then(() => legacySnapshotBlobSweepGuard.onSuccess(), legacySnapshotBlobSweepGuard.onError));
         leg(taskAttachmentStore
             ?.reapUnbound(Date.now() - config.attachmentUnboundTtlMs)
             .then(reapCount("attachments_reaped_total", {}))
@@ -295,6 +301,13 @@ export function startReapers(ctx) {
                 .then(() => approvalReconcileGuard.onSuccess(), approvalReconcileGuard.onError)
                 .finally(() => (approvalReconcileInFlight = false)));
         }
+        if (toolApproval && !approvalSuspendedPollInFlight) {
+            approvalSuspendedPollInFlight = true;
+            leg(toolApproval
+                .pollSuspendedDecisions()
+                .then(() => approvalSuspendedPollGuard.onSuccess(), approvalSuspendedPollGuard.onError)
+                .finally(() => (approvalSuspendedPollInFlight = false)));
+        }
         if (!permissionRuleReapInFlight) {
             permissionRuleReapInFlight = true;
             leg(permissionRuleStores

package/dist/boot/resolve-spec.d.ts

@@ -18,6 +18,7 @@ import type { StoreBackend } from "../plugins/store-backend.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import { type createPrincipalEntitlementsClient } from "../runtime-caps-resolver.js";
 import { type OwnerAwareSessionStore } from "../security.js";
+import type { RunnerDepsOnAsk } from "./runner-deps.js";
 type PrincipalCaps = ReturnType<typeof createPrincipalEntitlementsClient>;
 /** `resolveSpec` 原先从 `main()` 闭包里拿到的全部 boot 局部量。 */
 export interface ResolveSpecCtx {
@@ -40,6 +41,9 @@ export interface ResolveSpecCtx {
     perSessionCwd: Map<string, string>;
     setSessionCwd: (sid: string, cwd: string) => void;
     setSessionShellEnv: (sid: string, env: Record<string, string>) => void;
+    /** 两张 per-session 登记簿的**租户围栏**(codex R1-F1):每次提交对拍本会话的主人,换主即清。
+     *  论证(为什么 device lane 把这条从「不需要」变成「必需」)逐字见 `createSessionScopedRegistries` 头注。 */
+    fenceSessionOwner: (sid: string, owner: string | null) => void;
     hookLlm: ReturnType<typeof createHookLlm>["hookLlm"];
     hookAgent: HookLlmCall;
     fleetBus: FleetEventBus;
@@ -65,6 +69,17 @@ export interface ResolveSpecCtx {
      *  ASK_QUESTION_ENABLED)时 durable question 门按活流上下文分腿、spec 不再 stamp QUESTION_AWAITS_RESUME
      *  (否则 spec.onQuestion 恒遮蔽 RunnerDeps.onQuestion 的活人腿);缺席时行为与旧形逐字一致。 */
     liveQuestionFace: LiveQuestionFace | undefined;
+    /**
+     * S-46 件C —— 部署级**活体审批席**(`RunnerDeps.onAsk` 的同源铸法,main.ts 递
+     * `createRunnerDepsOnAsk(toolApproval)`;单一属主同 `boot/runner-deps.ts`,与 `parked-revive-gate.ts`
+     * 的 `approverSeat` 是同一格)。
+     *
+     * 本域**只**用于逐腿 `interactionPosture` 判据(见下方 `declaresInteractivePosture`),不参与任何
+     * 装配 —— spec 上的 per-task `onAsk` 由 `http/routes/tasks.ts` 在 resolveSpec **之后**写(bound 席),
+     * 而 core 的 posture 门读的是 `spec.onAsk ?? deps.onAsk`,两个装配点是**同一个条件**的两种表达
+     * (spec 位只在 `deps.toolApproval` 在场时才写,且写的也是函数)⇒ 拿 deps 位判「席位形」恒等。
+     */
+    approverSeat: RunnerDepsOnAsk | undefined;
     approvalExemptionStore: ReturnType<StoreBackend["approvalExemption"]> | undefined;
     singleUserAutoAcceptBaseline: boolean;
     checkpointStore: ReturnType<NonNullable<StoreBackend["checkpoint"]>> | undefined;