@sema-agent/server 7.134.0 → 7.135.0

package/dist/boot/deferred-sandbox-path-env.d.ts

@@ -46,12 +46,6 @@
  * 该面由 test/task-settings.test.ts 的「真身胜过名字」特征化钉机器可见。
  */
 import { FileError, StubExecutionEnv, type ExecutionEnv, type ExecutionEnvFactory, type FileInfo, type Result } from "@sema-agent/core";
-/** 哪些 lane 用本模块的代理裁决写门 —— 文件平面**不在** worker 本机的全部(= 能力表 `hostFilePlane` 答否)。
- *  与 resolve-spec 的 `hostSemanticsLane` 是同一判别式的两面,取值处**只此一个**(两处各写一份正是漂移的成因)。
- *  🔴 S-602:改前写的是 `provider !== undefined && provider !== "host"` —— 把缺席并进 host 的同义折(门 D R3),
- *  今天改读表那一位(`in-process` / `host` 答 YES,其余答 NO;读数逐格不变)。认不出的词 ⇒ 走代理裁决:
- *  代理 slot 空 ⇒ 写门 fail-closed(本模块头注裁定 2),与改前同向。 */
-export declare function isSandboxPathAdjudicationLane(provider: string | undefined): boolean;
 /** slot 取值的三态。`ok:false` 的两支都是 fail-closed,分开只为让留痕说得出**哪一种**缺席。 */
 export type SandboxPathEnvLookup = {
     readonly ok: true;

package/dist/boot/deferred-sandbox-path-env.js

@@ -1,10 +1,5 @@
 import { FileError, StubExecutionEnv, err, ok } from "@sema-agent/core";
 import { normalizeAbsolutePathLexically } from "../task-cwd.js";
-import { executionLaneCaps, executionLaneOf } from "../execution-lane-caps.js";
-export function isSandboxPathAdjudicationLane(provider) {
-    const lane = executionLaneOf(provider);
-    return lane === undefined || executionLaneCaps(lane).hostFilePlane !== "supported";
-}
 const MAX_BOUND_SESSIONS = 4096;
 export class SandboxPathEnvSlots {
     bySession = new Map();

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

@@ -8,16 +8,16 @@
  * **多壳共享一只引擎**时它结构性地问错了问题 —— 首壳退了 peer 还在用,监视父 pid 要么误杀要么永不触发。
  * 本件问的是那个真正的问题:**还有没有人附着**。
  *
- * ## S-306:自退律只剩这一条(硬 breaking)
+ * ## [ref]:自退律只剩这一条(硬 breaking)
  *
  * `SEMA_PARENT_PID` 看门狗的 drain 臂**整条删**了:父死只是把引擎标成**孤儿**(`parent_watch_orphaned`),
  * 孤儿走的是**本腿这一条**判据,只有一处不同 —— 窗长从 {@link EngineLeaseDeps.lingerMs} 换成
  * {@link EngineLeaseOrphanLane.lingerMs}(`ENGINE_ORPHAN_LINGER_MS`,默认 2s)。于是:
  *  · 规则集 **−1**(「父死即退」那条判据没了),参数 +1(孤儿窗);
- *  · 「有人附着 / 有 run 在飞就不退」这条结构性保护**对孤儿同样成立** —— cli 拒绝 S-292 的那一形
+ *  · 「有人附着 / 有 run 在飞就不退」这条结构性保护**对孤儿同样成立** —— cli 拒绝 [ref] 的那一形
  *    (A 起引擎、B 按 engine.port 复用、A 正常退)不会再在 B 的 turn 中间把引擎拆掉;
  *  · 装配判据随之变成 `parentPid 在场 ∨ engineAutoExit`;`ENGINE_AUTO_EXIT` 关着的 owned 引擎窗长
- *    是 **`Infinity`** —— 父还活着就**永不自退**(与 S-306 前逐字同),父一死才由孤儿窗接手。
+ *    是 **`Infinity`** —— 父还活着就**永不自退**(与 [ref] 前逐字同),父一死才由孤儿窗接手。
  *
  * ## 机制(逐条都是契约)
  *
@@ -47,7 +47,7 @@
  *  6. **interval 必须 unref**:自退检查腿不得成为「进程本该退出却退不掉」的理由(与 drain tick 刻意
  *     不 unref 的取向相反 —— 那一只 tick 就是停机驱动,这一只只是观察者)。**恒一只 interval**:
  *     孤儿态不另起第二只定时器(两只定时器 = 两条自退律,正是本件要消灭的那件事)。
- *  9. **拍频由窗推导,不是第二个旋钮**(S-306):`tickMs = min(`{@link ENGINE_LEASE_TICK_MS}`, 本腿可能
+ *  9. **拍频由窗推导,不是第二个旋钮**([ref]):`tickMs = min(`{@link ENGINE_LEASE_TICK_MS}`, 本腿可能
  *     执行的每一个窗)`。理由是顶注 8 那句话的逆命题 —— 实际窗 `[linger, linger+tickMs)` 里,采样滞后
  *     不得压过窗本身:15s 一拍去执行一个 2s 的孤儿窗,「2s」这句承诺就只是个装饰。所以装了孤儿车道
  *     (= 壳 spawn 形)的引擎按 2s 采样,没装的(纯服务器形)仍是 15s —— 存量部署一拍都没多跳。
@@ -67,7 +67,7 @@
  *    已由 `inflight()` 结构性守住;parked 行是 durable 的,引擎退掉不丢:下次起来仍可赎回(spawn 形里
  *    「下次」就是壳的下一次 spawn)。伤害面 = 一条 parked run 的赎回被推迟到下次启动,不是丢失。
  *    这是**允许的收窄,不是静默**:有了廉价 parked 计数口(或本腿改成事件驱动)之后应当补上。
- *  · **活过父 run 的后台子代理不入判据**(codex R1 [high] 验真后**如实登记**,不是本件引入:S-306 之前
+ *  · **活过父 run 的后台子代理不入判据**(codex R1 [high] 验真后**如实登记**,不是本件引入:[ref] 之前
  *    父死走的是**当场** drain,而 `drainThenShutdown` 读的是同一只 `inflight()` ⇒ 同一个缺口,只是那时
  *    连这 2s 都没有)。`inflight()` 的口径是**本副本的 HTTP 腿 ∪ leader 腿**(`http/server.ts` 的
  *    `inflightRuns`/`steerableRuns`/两只计数器),而 core 侧 `backgroundScope:"session"` 的子代理可以

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

@@ -12,14 +12,14 @@ import { type SpaceCommitRows } from "../workspace-space-commit.js";
 import * as facts from "../capability-facts.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { TaskInheritEnv } from "../request-value-closure.js";
-import type { IncarnationRead } from "../session-incarnation.js";
+import { type HeadRead } from "../session-incarnation.js";
 import type { SpaceReclaimer } from "../workspace-space.js";
 /**
  * per-session 的 **cwd / shellEnv 登记簿**(TOC cwd seam + R-survey shellEnv seam)+ 它们的**租户围栏**。
  *
  * ── 为什么围栏不是可选的(codex R1-F1,判真)────────────────────────────────────────────────────
- * 这两张表只按 `sessionId` 键控。在 host lane 上那是安全的:那条车道的闸带 `requirePrincipal !== true`,
- * 整台机器就一个用户。**device lane 把这个前提撤掉了** —— 它的闸(`deviceCwdHonored`)刻意不要求单用户
+ * 这两张表只按 `sessionId` 键控。在 host lane 上那是安全的:那条车道的闸(部署形表行 `callerCwd` 的 host 臂)
+ * 要求单主,整台机器就一个用户。**device lane 把这个前提撤掉了** —— 同一行的 device 臂刻意不要求单用户
  * (员工各连各的设备)。于是一条真实的超范围路径出现了:
  *   ① sessionId 由**调用方自选**,而且 `DELETE /v1/sessions/:id` 之后可以被**别人** `register` 重新登记
  *      (`boot/session-faces.ts` 的化身围栏注逐字写着这件事);
@@ -38,12 +38,12 @@ import type { SpaceReclaimer } from "../workspace-space.js";
 export interface SessionScopedRegistries {
     readonly perSessionCwd: Map<string, string>;
     readonly perSessionShellEnv: Map<string, Record<string, string>>;
-    /** S-895:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装;写只经 {@link setSessionInheritEnv}。 */
+    /** [ref]:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装;写只经 {@link setSessionInheritEnv}。 */
     readonly perSessionInheritEnv: ReadonlyMap<string, TaskInheritEnv>;
     setSessionCwd(sid: string, cwd: string): void;
     setSessionShellEnv(sid: string, env: Record<string, string>): void;
     /**
-     * S-895 —— 第三只 per-session 绑定(与 cwd / shellEnv 同一只 LRU 权威、同一条围栏、同一条删除)。
+     * [ref] —— 第三只 per-session 绑定(与 cwd / shellEnv 同一只 LRU 权威、同一条围栏、同一条删除)。
      * `undefined` = **清掉**这一格(不是「不动」):`inheritEnv` 是「本条请求要什么」,缺席的请求要的是缺省清洗 ——
      * 与 cwd / shellEnv 的「缺席 = 留着上一条的值」刻意不同(那两位由壳每条请求重发,粘住无害;这一位粘住 = 替一个没说话的
      * 请求放宽凭据面)。
@@ -59,10 +59,10 @@ export declare function createSessionScopedRegistries(maxEntries?: number): Sess
 /**
  * k8s 车道的**每 run 绑定**:部署级适配器配置 × 三只 run 作用域的座(都按本 run 的 `ctx.sessionId` 取)——
  *  · 镜像:§7 P0.5 per-task 镜像(resolveSpec 按调用方 principal 解出、按会话登记;缺席 ⇒ 部署缺省镜像);
- *  · **工作区空间的分区 = 会话化身**(`spaceOccupant.incarnation`):建这只 env 时按 id 读一次会话店的 `incarnationOf`(会话行上的那一格,
- *    `session-incarnation.ts`;本工厂不取会话,正是 core 给「没取会话的读者」的那只读)。读数是闭集三臂(`SpaceOccupant`,适配器那边逐臂处置):
+ *  · **工作区空间的分区 = 会话化身**(`spaceOccupant.incarnation`):建这只 env 时按 id 读一次会话店的头(`headOf`,会话行上的那一格,
+ *    `session-incarnation.ts`;本工厂不取会话,正是 core 给「没取会话的读者」的那只读),经 `sessionFaceOfHead` 投成一位活住客。读数是闭集三臂(`SpaceOccupant`,适配器那边逐臂处置):
  *    答令牌 ⇒ 已知;答 `undefined`(没有这只会话)⇒ `{ unread: "incarnation_unknown" }` —— 没有空间:空间车道不开、缓存卷不挂,各一行;
- *    读抛 / 超时(`rpcTimeoutMs`,同一次 connect 里读围栏行与 `latest` 的那一只墙)/ 答出的不是非空串 ⇒ `{ fault: <code> }` —— 读不到空间 ≠ 没有空间:开着的空间车道 / 缓存卷让这只 env 一只 pod 都不建,
+ *    读抛 / 超时(`rpcTimeoutMs`,同一次 connect 里读围栏行与 `latest` 的那一只墙)/ 行在而没有令牌(`session.incarnation_missing`)/ 答出的不是非空串 ⇒ `{ fault: <code> }` —— 读不到空间 ≠ 没有空间:开着的空间车道 / 缓存卷让这只 env 一只 pod 都不建,
  *    connect 与 resumeVM 都答 `connect_failed`(与 `latest` 读失败同一铸点),一行 `workspace_space_unreadable_occupant`;`code` 是店的错误码,
  *    从不带正文、从不带令牌。**绝不**以会话 id 代替;
  *    同时开这只 env 在空间提交围栏上的座(`spaceOccupant.fence`,run 店的 `workspace_space_commit` 行;法见 `workspace-space-commit.ts`);
@@ -76,9 +76,10 @@ export declare function createSessionScopedRegistries(maxEntries?: number): Sess
  */
 export declare function createK8sRunEnvFactory(k8sCfg: K8sEnvConfig, seats: {
     imageOf(sessionId: string): string | undefined;
-    /** The session store's by-id occupant read (`SessionStore.incarnationOf`, picked once by `incarnationReadOf`); absent ⇔ the store
-     *  has none, which `assertWorkspaceSpaceReadable` refuses together with `space` (embeddings that wire another lane pass none). */
-    incarnationOf: IncarnationRead | undefined;
+    /** The session store's by-id head read (`SessionStore.headOf`, picked once by `headReadOf`); the occupant is its live-occupant projection
+     *  (`sessionFaceOfHead`). Absent ⇔ the store has none, which `assertWorkspaceSpaceReadable` refuses together with `space` (embeddings that
+     *  wire another lane pass none). */
+    headOf: HeadRead | undefined;
     /** The run store's commit-fence rows (`workspace_space_commit`); answers `undefined` only before stage 7 binds the run store
      *  or without a store backend — the latter `assertWorkspaceSpaceReadable` refuses together with `space`. */
     spaceCommits(): SpaceCommitRows | undefined;
@@ -87,7 +88,7 @@ export declare function createK8sRunEnvFactory(k8sCfg: K8sEnvConfig, seats: {
  * k8s 工作区空间的**起服前提**(装配后的真门;同段先例 = `assertDeviceLaneWired`)。法只有一条:
  * **生效策略 `space`(事实 `workspaceSpace`)∧ {@link createK8sRunEnvFactory} 的两只座缺一 ⇒ 拒启。**
  *
- * 空间车道每条 run 开不开,只看工厂的两只座:住客的按 id 读(会话店的 `incarnationOf`,`incarnationReadOf` 在第 5 段判一次,本门与工厂
+ * 空间车道每条 run 开不开,只看工厂的两只座:住客的按 id 读(会话店的 `headOf`,`headReadOf` 在第 5 段判一次,本门与工厂
  * 读同一只返回值)与提交围栏的行(run 店 —— 住在存储后端里;没有存储后端 ⇒ 没有这只座)。缺一 ⇒ 每条 run 都不存,而能力位
  * `workspaceSync.persist` 只读配置、照报 `"space"`。事实**保持只读配置**;让它恒真的办法是拒掉这一组合,不是给事实加运行期依赖。
  * 生效策略缺席(非 k8s 车道 / 没配快照存储:能力位本就不在场,后者有起服一行 `workspace_persist_unavailable`)或 `off` ⇒ 不判。
@@ -96,7 +97,7 @@ export declare function createK8sRunEnvFactory(k8sCfg: K8sEnvConfig, seats: {
  * 拒句一行,点名:旋钮词、缺的是哪一只座、会话店种类(`sessionStoreLabelOf` —— `/health.sessionBackend` 同一读法)、出路。
  */
 export declare function assertWorkspaceSpaceReadable(space: ReturnType<typeof facts.workspaceSpace>, seats: {
-    readonly incarnationOf: IncarnationRead | undefined;
+    readonly headOf: HeadRead | undefined;
     readonly spaceCommits: (() => SpaceCommitRows | undefined) | undefined;
 }, cache: ReturnType<typeof facts.workspaceCache>, sessionStoreLabel: string): void;
 /** device lane 的三件活对象(店 / 汇聚端 / 准入链)。缺席 = 本部署没有 device 车道。 */
@@ -116,8 +117,8 @@ export interface ExecutionEnvCtx {
      *  (`late-binds.ts`),工厂在 run 期才求值。装配(第 5 段)在有存储后端时传、没有时不传(起服门据此判);不传(含只装别的车道的嵌入 /
      *  测试)⇒ 读不到行 ⇒ k8s 空间车道按「住客读不到」不开,每 env 一行 `workspace_space_unavailable`(响亮,不静默)。 */
     spaceCommits?: () => SpaceCommitRows | undefined;
-    /** k8s 工作区空间的住客读:会话店的按 id 读(`incarnationReadOf(sessionStore)`,第 5 段判一次、与起服门同一只)。不传 ⇒ 同上,不开、响亮。 */
-    incarnationOf?: IncarnationRead;
+    /** k8s 工作区空间的住客读:会话店的按 id 读(`headReadOf(sessionStore)`,第 5 段判一次、与起服门同一只)。不传 ⇒ 同上,不开、响亮。 */
+    headOf?: HeadRead;
 }
 export declare function createExecutionEnv(ctx: ExecutionEnvCtx): {
     perTaskImage: PerTaskImageRegistry;

package/dist/boot/execution-env.js

@@ -1,7 +1,8 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { createHostLspManager } from "../host-lsp-manager.js";
-import { sandboxSendLaneEnabled, TaskEnvRegistry } from "../capabilities/sandbox-file-send.js";
+import { TaskEnvRegistry } from "../capabilities/sandbox-file-send.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "../deployment-shape.js";
 import { SessionEnvironmentSelection } from "../capabilities/select-environment-tool.js";
 import { createE2bLspManager } from "../lsp/e2b-manager.js";
 import { evictLspOnDestroy } from "../lsp-evict.js";
@@ -15,7 +16,7 @@ import { createRunWorkspaceSnapshotSeat } from "../fleet/workspace-snapshot-resi
 import { createSpaceCommitFence } from "../workspace-space-commit.js";
 import { localDockerExecutionEnvFactory } from "../plugins/remote-env-local-docker.js";
 import { sshExecutionEnvFactory } from "../plugins/remote-env-ssh.js";
-import { isRemoteScratchpadLane, withRemoteScratchpad } from "../plugins/remote-scratchpad.js";
+import { withRemoteScratchpad } from "../plugins/remote-scratchpad.js";
 import { FileSchedulerBackend, defaultSchedulerStorePath } from "../plugins/scheduler-support.js";
 import * as facts from "../capability-facts.js";
 import { materializeAttachmentsInto } from "../plugins/task-attachment-store.js";
@@ -23,12 +24,13 @@ import { reapOrphanWorktrees, withWorktreeIsolation } from "../plugins/worktree-
 import { derivePkgSourceEnv } from "../sandbox-pkg-source.js";
 import { effectiveHostWorkspace } from "../task-cwd.js";
 import { taskInheritEnvRefusal } from "../hosted-posture.js";
+import { sessionFaceOfHead } from "../session-incarnation.js";
 import { createCacheMissMemory } from "../workspace-cache.js";
 import { workspaceSnapshotTimeoutOf } from "../workspace-space.js";
 import { sayEgressPolicyReading } from "../sandbox-egress-policy.js";
-import { isSandboxPathAdjudicationLane, sandboxPathEnvSlots, withSandboxPathEnvSlot } from "./deferred-sandbox-path-env.js";
+import { sandboxPathEnvSlots, withSandboxPathEnvSlot } from "./deferred-sandbox-path-env.js";
 import { LANE_HOME_UNDECLARED_EVENT, createLaneHomeAbsenceReporter } from "../lane-home-probe.js";
-import { REMOTE_EXEC_PROVIDER_WORDS, buildUndeclaredHomeNote, executionLaneHomeDir, executionLaneOf, isSingleMachineDefaultLane, laneBindsReads, laneIsolated } from "../execution-lane-caps.js";
+import { REMOTE_EXEC_PROVIDER_WORDS, buildUndeclaredHomeNote, executionLaneHomeDir, executionLaneOf, laneBindsReads, laneIsolated } from "../execution-lane-caps.js";
 function boundedSessionSetter(map, maxEntries) {
     return (sid, value) => {
         map.delete(sid);
@@ -132,14 +134,14 @@ const INCARNATION_READ_TIMEOUT = "incarnation_read_timeout";
 async function occupantOf(seats, sessionId, taskId, boundMs) {
     let answer;
     try {
-        const read = seats.incarnationOf;
+        const read = seats.headOf;
         answer =
             read === undefined
                 ? undefined
-                : await boundedStoreCall(() => read(sessionId), {
+                : sessionFaceOfHead(sessionId, await boundedStoreCall(() => read(sessionId), {
                     ms: boundMs,
                     onTimeout: () => Object.assign(new Error(`session occupant read did not answer within ${boundMs}ms`), { code: INCARNATION_READ_TIMEOUT }),
-                });
+                }))?.incarnation;
     }
     catch (e) {
         const code = e?.code;
@@ -147,8 +149,6 @@ async function occupantOf(seats, sessionId, taskId, boundMs) {
     }
     if (answer === undefined)
         return { unread: "incarnation_unknown" };
-    if (typeof answer !== "string" || answer === "")
-        return { fault: "incarnation_read_failed" };
     const rows = seats.spaceCommits();
     return rows !== undefined ? { incarnation: answer, fence: createSpaceCommitFence(rows, answer, taskId) } : { unread: "incarnation_unknown" };
 }
@@ -158,7 +158,7 @@ function spaceOff(store) {
 }
 export function assertWorkspaceSpaceReadable(space, seats, cache, sessionStoreLabel) {
     if (space.available && persistNeedsOccupant(space.policy.persist)) {
-        const missing = seats.incarnationOf === undefined ? `the session store (${sessionStoreLabel}) has no by-id occupant read (incarnationOf)`
+        const missing = seats.headOf === undefined ? `the session store (${sessionStoreLabel}) has no by-id occupant read (headOf)`
             : seats.spaceCommits === undefined ? `this deployment has no store backend to hold the space's commit rows (the session store is ${sessionStoreLabel})`
                 : undefined;
         if (missing === undefined)
@@ -169,9 +169,9 @@ export function assertWorkspaceSpaceReadable(space, seats, cache, sessionStoreLa
             "DB_BACKEND=memory has none), or set WORKSPACE_PERSIST=off (the default is space), and restart");
         return;
     }
-    if (cache.available && (seats.incarnationOf === undefined || seats.spaceCommits === undefined)) {
-        const missing = seats.incarnationOf === undefined
-            ? `the session store (${sessionStoreLabel}) has no by-id occupant read (incarnationOf)`
+    if (cache.available && (seats.headOf === undefined || seats.spaceCommits === undefined)) {
+        const missing = seats.headOf === undefined
+            ? `the session store (${sessionStoreLabel}) has no by-id occupant read (headOf)`
             : `this deployment has no store backend to hold the space durably (the session store is ${sessionStoreLabel})`;
         throw new Error(`WORKSPACE_CACHE=volume but ${missing} [workspace-space-unreadable]: ` +
             "the k8s build-cache volume belongs to the workspace space, which is keyed by the session occupant, so here no run would get its volume while " +
@@ -187,7 +187,7 @@ function persistNeedsOccupant(persist) {
     }
 }
 function buildRealSystemNote(remoteExec) {
-    if (!isSingleMachineDefaultLane(remoteExec))
+    if (!DEPLOYMENT_SHAPE_PREDICATES.singleMachineDefaultLane.holds({ remoteExec }))
         return "non-isolated target — actions are permanent; rely on the policy gate + HITL (design/61 §5)";
     const sandboxLanes = REMOTE_EXEC_PROVIDER_WORDS.filter((lane) => laneIsolated(lane)).join("|");
     return ("hands run on this machine with no OS sandbox (single-machine default: REMOTE_EXEC unset, CONFIG_PROVIDER=local) — actions are permanent, " +
@@ -245,7 +245,7 @@ export function createExecutionEnv(ctx) {
             logger,
             ...((env) => (env !== undefined ? { podEnv: env } : {}))(buildSandboxLaneEnv(config, config.remoteExec.sandboxEnv)),
         };
-        executionEnvFactory = createK8sRunEnvFactory(k8sCfg, { imageOf: (sid) => perTaskImage.get(sid), incarnationOf: ctx.incarnationOf, spaceCommits: ctx.spaceCommits ?? (() => undefined) });
+        executionEnvFactory = createK8sRunEnvFactory(k8sCfg, { imageOf: (sid) => perTaskImage.get(sid), headOf: ctx.headOf, spaceCommits: ctx.spaceCommits ?? (() => undefined) });
         if (k8sCfg.cache !== undefined || k8sCfg.s3Snapshot !== undefined)
             spaceReclaimer = createSpaceReclaimer(k8sCfg);
         void checkSandboxEgressPolicy(k8sCfg)
@@ -341,7 +341,7 @@ export function createExecutionEnv(ctx) {
             ...(config.remoteExec.env ? { env: config.remoteExec.env } : {}),
         });
     }
-    if (executionEnvFactory && isRemoteScratchpadLane(config.remoteExec?.provider)) {
+    if (executionEnvFactory && DEPLOYMENT_SHAPE_PREDICATES.remoteScratchpad.holds(config)) {
         executionEnvFactory = withRemoteScratchpad(executionEnvFactory, logger);
     }
     if (config.worktreeIsolation && executionEnvFactory) {
@@ -387,8 +387,7 @@ export function createExecutionEnv(ctx) {
         }
     }
     const sendUserFileTaskEnvs = (() => {
-        const provider = config.remoteExec?.provider;
-        if (!config.sendUserFile || !executionEnvFactory || !sandboxSendLaneEnabled(provider, config.requirePrincipal))
+        if (!config.sendUserFile || !executionEnvFactory || !DEPLOYMENT_SHAPE_PREDICATES.sandboxSendUserFile.holds(config))
             return undefined;
         const registry = new TaskEnvRegistry();
         executionEnvFactory = registry.wrapFactory(executionEnvFactory);
@@ -405,13 +404,12 @@ export function createExecutionEnv(ctx) {
             return env;
         };
     }
-    if (executionEnvFactory && isSandboxPathAdjudicationLane(config.remoteExec?.provider)) {
+    if (executionEnvFactory && DEPLOYMENT_SHAPE_PREDICATES.sandboxPathAdjudication.holds(config)) {
         executionEnvFactory = withSandboxPathEnvSlot(executionEnvFactory, sandboxPathEnvSlots, logger);
     }
     if (executionEnvFactory) {
         const isolated = laneIsolated(executionLaneOf(config.remoteExec.provider));
-        const suspendable = config.remoteExec.provider === "e2b" ||
-            (config.remoteExec.provider === "k8s" && !!config.remoteExec.s3Snapshot);
+        const suspendable = DEPLOYMENT_SHAPE_PREDICATES.suspendableHands.holds(config);
         const sandboxEnvKeys = forwardedSandboxEnvKeys(config.remoteExec);
         logger.info("remote_exec_enabled", { provider: config.remoteExec.provider, isolated, suspendable, ...(sandboxEnvKeys.length > 0 ? { sandboxEnvKeys } : {}) });
         if (!isolated)

package/dist/boot/fatal-exit.d.ts

@@ -9,8 +9,8 @@ export declare function buildFatalErrorText(err: unknown): string;
 /**
  * 进程级 fatal 出口的**唯一一只腿**:同一只 {@link buildFatalErrorText} 产物写两个面,然后按崩溃码退。
  *
- * ── 病(S-555,test [ref] P2)────────────────────────────────────────────────────────────────────
- * 出口过去只有那条 JSON 行。而拒启文案是**多行**的 —— S-547 的列集对账会生成
+ * ── 病([ref],test [ref] P2)────────────────────────────────────────────────────────────────────
+ * 出口过去只有那条 JSON 行。而拒启文案是**多行**的 —— [ref] 的列集对账会生成
  * `ALTER TABLE <表> ADD COLUMN <列定义>;`,它存在的全部理由就是「运维直接粘进 psql」;塞进 JSON 字符串后
  * 整段变成一串 `\n` 转义,**粘不走**。dist 里也没有 pretty / `isTTY` 分支去把它摊开(有也不该有:出口的
  * 可读性不该取决于终端是谁)。

package/dist/boot/late-binds.d.ts

@@ -1,5 +1,5 @@
 /**
- * 晚绑席(S-151 十段切分的**唯一**跨段可变面)—— 四只 cell,读点在前段、写点在后段。
+ * 晚绑席([ref] 十段切分的**唯一**跨段可变面)—— 四只 cell,读点在前段、写点在后段。
  *
  * 为什么是模块级 live binding 而不是 ctx 字段:读点的原文是**裸标识符**(`() => runStore`、
  * `() => parkedAskRedeem`),而 ctx 字段是**快照** —— 把读点改成 `ctx.runStore` 就是正文改写,

package/dist/boot/leader.d.ts

@@ -23,7 +23,7 @@ export interface LeaderCtx {
     toolResultStore: ToolResultStoreFull | undefined;
     sessionStore: ReturnType<typeof createSessionStore>;
     checkpointStore: CheckpointStoreFull | undefined;
-    /** S-1907:停驻行凭据的封签器(与 HTTP 面 `ServiceDeps.checkpointCtxSealing` 同一只;起服第 6 段已对「店在、它不在」拒启)。必填键,值可为 undefined。 */
+    /** [ref]:停驻行凭据的封签器(与 HTTP 面 `ServiceDeps.checkpointCtxSealing` 同一只;起服第 6 段已对「店在、它不在」拒启)。必填键,值可为 undefined。 */
     checkpointCtxSealing: import("../http/checkpoint-ctx.js").CheckpointCtxSealing | undefined;
     /** [ref] 件B/C/D([ref],codex R2-F1):部署治理三座席 —— leader 车道的每一只 Runner 都要带上它,
      *  否则开了 leader 端点的部署就有一条在部署治理**之外**的执行面(合规否决/锁都够不着)。 */

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

@@ -95,7 +95,7 @@ export interface MemoryWriteBoundaryFacts {
      *  core 7.16.0([ref])之后写家还要再深一层(`<平面>/<label>`),但 label 归引擎注册簿,boot 期说不出口;
      *  平面是**包含关系上等价**的那一只(家恒为平面的直接子目录),所以判据停在平面,不猜 label。 */
     memoryRoot: string | undefined;
-    /** 执行车道名,只进文案(归一读口 `executionLaneOf` 的答案;S-602 起不在调用点手写 `?? "in-process"`)。 */
+    /** 执行车道名,只进文案(归一读口 `executionLaneOf` 的答案;[ref] 起不在调用点手写 `?? "in-process"`)。 */
     lane: ExecutionLane;
     /** 该车道的文件工具是否跑在**本机** fs 上(in-process / `REMOTE_EXEC=host`)。false = 沙箱盘,与记忆根分平面。
      *  ⚠️ 这一位管的是**文件平面**,与下面的 `coreRemoteExecutionEnv` 是**两根轴**,别合并(codex round2
@@ -119,7 +119,7 @@ export interface MemoryWriteBoundaryFacts {
     containmentRoots: readonly string[];
 }
 /**
- * S-602 —— 审计的**车道那四位**由本函数从能力表派生(boot/stores.ts 的装配点只调它,不再就地手写):
+ * [ref] —— 审计的**车道那四位**由本函数从能力表派生(boot/stores.ts 的装配点只调它,不再就地手写):
  * 改前 stores 里是 `lane === undefined || lane === "host"`(同义折,门 D R3)+ `config.remoteExec !== undefined`
  * (座位上的裸缺席判,R4)+ `lane ?? "in-process"` ×3(R2)。两根轴各读表里各自那一位,不合并:
  *  · `hostSemanticsLane` ⇐ `hostFilePlane`(文件平面在不在本机);

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

@@ -11,10 +11,10 @@ type ConsolidationSeatOptions = ReturnType<typeof resolveMemoryConsolidationDriv
 export type ConsolidationSeatLabel = "explicit" | "role:consolidate" | "role:summarize";
 /** {@link buildConsolidationValveAudit} 的告警名闭集(事件名进日志 ⇒ 运维可按名过滤/告警)。 */
 export type ConsolidationValveWarningTag = "memory_consolidation_valve_unreachable" | "memory_consolidation_run_credential_gated";
-/** {@link resolveConsolidationValve} 的起服提示名闭集(S-824 / [ref];事件名进日志 ⇒ 运维可按名过滤/告警)。 */
+/** {@link resolveConsolidationValve} 的起服提示名闭集([ref] / [ref];事件名进日志 ⇒ 运维可按名过滤/告警)。 */
 export type ConsolidationValveNoticeTag = "memory_consolidation_default_off_no_cheap_model" | "memory_consolidation_on_main_model";
 /**
- * 阀门判决(S-824 / [ref])。`build*`/`create*` 之外的第三种:纯数据,由 {@link resolveConsolidationValve} 产出。
+ * 阀门判决([ref] / [ref])。`build*`/`create*` 之外的第三种:纯数据,由 {@link resolveConsolidationValve} 产出。
  * 阀门开关的**唯一**属主:座解析、操作面、引擎面两席、审计告警、武装日志全读 `enabled`,不再各读一次表态。
  */
 export interface ConsolidationValve {
@@ -22,7 +22,7 @@ export interface ConsolidationValve {
     /** 这一位是谁定的:运维的显式词(`explicit`),还是出厂缺省派生(`derived`)。 */
     readonly source: "explicit" | "derived";
     /**
-     * 这一判决**随目录变**吗(S-824 codex 车内复审 F2)。真 = 派生判决读了整理座落在谁身上(未设 ∧ 结构上跑得起来),
+     * 这一判决**随目录变**吗([ref] codex 车内复审 F2)。真 = 派生判决读了整理座落在谁身上(未设 ∧ 结构上跑得起来),
      * 中心热改 roles / 档位就可能翻它 ⇒ 要有一份重启读数盯着({@link createConsolidationValveWatch})。显式词、以及结构上
      * 跑不起来的派生关 ⇒ 假(目录怎么改都翻不动)。
      */
@@ -34,7 +34,7 @@ export interface ConsolidationValve {
     };
 }
 /**
- * 整理座若开,会落在哪只模型上 —— **相对主模型**(S-824 的「便宜模型在场」判据;{@link consolidationSeatBillingOf} 产出)。
+ * 整理座若开,会落在哪只模型上 —— **相对主模型**([ref] 的「便宜模型在场」判据;{@link consolidationSeatBillingOf} 产出)。
  *  · `own-model`   = 座解到的目录条目**不是**主模型那一条(按条目身份 = 对象引用判,不比 id 串;`MODEL_CHEAP_ID`,或目录的
  *                    consolidate / summarize / flash 档位绑定);
  *  · `main-model`  = 座解到主模型那一条本身(env 角色表在 `MODEL_CHEAP_ID` 缺席 —— 或与 `MODEL_ID` 同 id、不铸 cheap 槽 —— 时把
@@ -80,7 +80,7 @@ export interface ConsolidationDriverSeat {
  */
 export declare function resolveConsolidationDriverSeat(deps: MemoryConsolidationDriverDeps): ConsolidationDriverSeat;
 /**
- * S-668 波 0([ref] §3)—— 整理驱动席的 **restart 读数**。过渡件:**波 1 转热后删**(那时每轮 run 起手
+ * [ref] 波 0([ref] §3)—— 整理驱动席的 **restart 读数**。过渡件:**波 1 转热后删**(那时每轮 run 起手
  * 现取当前代的席,不再有 boot 烤死的席,这只表也就没有要比的东西了)。
  *
  * ## 为什么要它
@@ -152,7 +152,7 @@ export declare function createPerScopeSingleFlight<T>(): (scope: string, run: ()
  *
  * 阀门关着 ⇒ 整条门不判(缺省姿态,[ref]「缺席不在律内」)。
  *
- * 🔴 S-824 起判据拆成「判官 + 拒启包装」两半:判官 {@link consolidationDriverUnwirable} 是三条臂的**唯一**
+ * 🔴 [ref] 起判据拆成「判官 + 拒启包装」两半:判官 {@link consolidationDriverUnwirable} 是三条臂的**唯一**
  * 属主,拒启包装只在阀门开着时把它的拒因抛出去;出厂缺省派生({@link resolveConsolidationValve})读同一只判官决定
  * 「结构上跑不起来 ⇒ 缺省恒关」—— 两处读一只,不是两份三臂。
  */
@@ -180,7 +180,7 @@ export type ConsolidationUnwirable = "no-memory-engine" | "no-control-plane" | "
  */
 export declare function consolidationDriverUnwirable(input: ConsolidationWiringFacts): ConsolidationUnwirable | undefined;
 /**
- * 整理座若开会落在哪只模型上(S-824 的「便宜模型在场」判据)—— **问 core 的同一只解析器**,不抄 role 链
+ * 整理座若开会落在哪只模型上([ref] 的「便宜模型在场」判据)—— **问 core 的同一只解析器**,不抄 role 链
  * ({@link seatLabel} 注里同一条理由:抄一份就是第二真源,而 `ROLE_TIER_DEFAULTS` 的 flash 缺省会让手抄版答错)。
  *
  * 为什么不按 env `MODEL_CHEAP_ID` 的拼写判:它只是供座的一条路。env 角色表在它缺席时把 summarize 指回
@@ -201,7 +201,7 @@ export declare function consolidationDriverUnwirable(input: ConsolidationWiringF
  */
 export declare function consolidationSeatBillingOf(plane: ConsolidationSeatPlane): ConsolidationSeatBilling;
 /**
- * 🔴 S-824 / clay **[ref]** —— **阀门判决**:开不开、谁定的、起服时要说什么。阀门开关的**唯一**属主(stage-06 的座解析 /
+ * 🔴 [ref] / clay **[ref]** —— **阀门判决**:开不开、谁定的、起服时要说什么。阀门开关的**唯一**属主(stage-06 的座解析 /
  * 操作面 / 引擎面两席 / 审计告警 / 武装日志全读它的 `enabled`)。
  *
  *  · **显式词恒赢**:`off` ⇒ 关、零提示、**零探针**(一眼都不看角色表 —— off = 零装配零探针那句承诺);`on` ⇒ 开
@@ -214,7 +214,7 @@ export declare function consolidationSeatBillingOf(plane: ConsolidationSeatPlane
  *      座不落主模型({@link consolidationSeatBillingOf} = `own-model`)⇒ **开**;
  *      否则(落主模型 / 解不出)⇒ **关** + 一行 `memory_consolidation_default_off_no_cheap_model`(点名 `MODEL_CHEAP_ID`,
  *      出路 = 配便宜模型,或显式 `off` 静音)。
- *  · **半配拒启**(`MEMORY_EMBEDDER_*` 同族,S-824 起判定点挪到这里):scope 表 / 节律配了而阀门最终**没开** ⇒ 拒启,
+ *  · **半配拒启**(`MEMORY_EMBEDDER_*` 同族,[ref] 起判定点挪到这里):scope 表 / 节律配了而阀门最终**没开** ⇒ 拒启,
  *    拒因说清「为什么没开」。在 `loadConfig` 判会把「未设 + scope + 便宜模型在场」这台本该派生成开的部署当场拒掉。
  *
  * ⚠️ **起服判一次**(restart-to-apply):判决落在 boot 第 4 段的装配点 {@link createConsolidationValve} —— 目录已应用
@@ -239,7 +239,7 @@ export declare function resolveConsolidationValve(input: {
  * baked = boot 判决的投影,current = 此刻拿活配置**重判**一次的投影(`plane` 给活引用的 getter,refresh 就地换代后现取)。
  *  · 判决翻了(派生开 → 关:主模型被挪到整理座那一条上,或座被挪回主模型;派生关 → 开:目录给整理座绑上别的模型 / 目录迟到)
  *    ⇒ 两侧不等 ⇒ 签重启(重启后 boot 重判)。修前是两臂:开时只盯座位指纹、关时只盯「会不会开」—— 只动主模型的那一形零信号。
- *  · 开着而座漂了(中心改了座会解到的那只模型)⇒ 座位指纹不等 ⇒ 签(S-668 波 0 的既有信号,显式 on 同走这一臂)。
+ *  · 开着而座漂了(中心改了座会解到的那只模型)⇒ 座位指纹不等 ⇒ 签([ref] 波 0 的既有信号,显式 on 同走这一臂)。
  *  · 关着而目录怎么变都不翻 ⇒ 两侧同为 `{ valve: "off" }` ⇒ 不签(主模型换代而判决不翻,不造一次什么都不改变的重启)。
  * 主模型条目是判决的**输入**(它决定开 / 关),不进投影本身 —— 进了就会在每一次主模型换代时签一次不翻判决的重启。
  * 显式 off / 结构上跑不起来的派生关 ⇒ `undefined`(判决不随目录变,没有可盯的东西)。
@@ -283,7 +283,7 @@ export interface ConsolidationValveInput {
  *
  * 两个入口各调它一次:HTTP 服务第 4 段经 {@link createConsolidationValve};`run-local` 在记忆引擎接线之后直接调(它没有整理座 ——
  * 不挂手动口、不接 `RunnerDeps` 的整理两席 —— 判决本身对它没有用处,要的只是拒因)。修前这道拒只长在 HTTP 那条装配链上
- * (S-824 从 `loadConfig` 挪过来时 `run-local` 没跟上):共享 `.env` 上同一组键,HTTP 服务拒启、`run-local` 带着零效果的 scope 表
+ * ([ref] 从 `loadConfig` 挪过来时 `run-local` 没跟上):共享 `.env` 上同一组键,HTTP 服务拒启、`run-local` 带着零效果的 scope 表
  * 静默起跑。判据只有这一只 ⇒ 两个入口对同一份 env 同判同句(未设 + 便宜模型在场 ⇒ 两边都派生开、都照起)。
  */
 export declare function judgeConsolidationValve(input: ConsolidationValveInput): {
@@ -312,7 +312,7 @@ export declare function judgeConsolidationValve(input: ConsolidationValveInput):
  * 反过来说,**沉默**同样不行:那正是「设了但没生效」病族,而这一形连能力位都是诚实的假,唯一缺的
  * 就是一句把因果说清楚的话。
  *
- * ## 只审**显式**开的阀门(S-824 / [ref] 起)
+ * ## 只审**显式**开的阀门([ref] / [ref] 起)
  *
  * 两条告警的前提都是「运维**显式**拧了 on」(上面那句原话)——它们是一次**表态**够不着的诊断。出厂缺省**派生**开的
  * 那台(配了便宜模型的单用户部署)没有表态可审:引擎面的自动整理照跑(不走这两个口),手动口是一件它没要过的东西。
@@ -360,7 +360,7 @@ export declare function buildStopDetailAudit(input: {
     untrustedDetail: string;
 };
 /**
- * S-362 / S-399 —— **`RunnerDeps.autoRunOnRecommendation` 武装席的装配不变量**(D1 的姊妹门)。
+ * [ref] / [ref] —— **`RunnerDeps.autoRunOnRecommendation` 武装席的装配不变量**(D1 的姊妹门)。
  *
  * 与 {@link assertConsolidationDriverWirable} 刻意**分家**而不是加第四臂:那道门问「阀门这根旋钮
  * (`MEMORY_CONSOLIDATION_DRIVER`)开着而这台机器结构上跑不了」,本门问「武装这根旋钮
@@ -377,7 +377,7 @@ export declare function buildStopDetailAudit(input: {
  * ## 判据取的是**结构事实**,不是一个手抄的布尔
  *
  * `memoryConsolidationWired` 由调用点从**它刚刚铸出来的那只 `RunnerDeps`** 上读(`deps.memoryConsolidation
- * !== undefined`),不是在这里写一个常量 —— S-399 把两席接上之后,本门**自动**从「恒拒」变成「阀门开着
+ * !== undefined`),不是在这里写一个常量 —— [ref] 把两席接上之后,本门**自动**从「恒拒」变成「阀门开着
  * 就放行」,没有人需要记得回来改一个数。
  *
  * 🔴 **core 的拒绝谓词是两个析取项,本门只覆盖第一个**(对抗复审 F5 [low],验真后如实登记):
@@ -500,7 +500,7 @@ export declare function createMemoryConsolidationFaces(store: {
      *  🔴 这只引擎是四只 operator 面里**真读名册**的那只:`consolidationEligibility` 第四臂
      *  (engine.js `listCaptureOptOutSessions`)拿它筛掉 opt-out 会话的贡献条目 —— SQL 部署上漏喂
      *  = 驱动器读文件空名册 ⇒ 蒸馏器放大用户明说不要记的内容(S-5 真实失效形;全站同批注入律,
-     *  机器钉 capture-optout-lane ②)。S-215 起 local 车道在引擎接线时也供(core 文件三腿,同一只控制面);
+     *  机器钉 capture-optout-lane ②)。[ref] 起 local 车道在引擎接线时也供(core 文件三腿,同一只控制面);
      *  缺席 ⇒ 记忆面暗(引擎未接线),与 Runner 同本。 */
     captureRecordStore?: SessionCaptureRecordStore;
     /** core 7.50.0:整理跑的**写判官座**(必填 —— 缺席不是「没有规则」,core 也拒)。操作面不判任何东西,只把它原样递给驱动动词:

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

@@ -7,7 +7,7 @@ import type { ApprovalExemptionStore } from "../plugins/approval-exemption-store
 /** 本腿读的配置切面(`ServiceConfig` 结构满足)。两个构造口各自的切面 + lane 判别式读的 `remoteExec`。 */
 export interface ParkedReviveGateConfigView extends DeploymentGovernanceConfigView, ApprovalBaselineConfigView {
     readonly remoteExec?: ServiceConfig["remoteExec"];
-    /** S-213④:`executionLaneHomeDir` 读的运维声明(切面必须点名本腿消费的每一个字段,否则窄视图字面量会静默丢掉旋钮)。 */
+    /** [ref]④:`executionLaneHomeDir` 读的运维声明(切面必须点名本腿消费的每一个字段,否则窄视图字面量会静默丢掉旋钮)。 */
     readonly remoteExecHomeDir?: ServiceConfig["remoteExecHomeDir"];
     /** host 腿裁决 env 的 cwd 占位根(见下方 `hostGateCwd`)。 */
     readonly localDataRoot?: ServiceConfig["localDataRoot"];
@@ -63,7 +63,7 @@ export interface ParkedReviveGateDeps {
     readonly autoModeSeatMounted?: boolean;
     /** [ref]:父 run 的 auto 意图(core 7.34.0 起 = 父腿的 `permissionMode === "auto"`,旧键 `autoModeRequested` 已退役)——
      *  意图武装式下重建 decider 的第三项。⚠️ 今日**本仓无读口**(RunRecord 无 body),生产装配不递 ⇒ 恒缺席。
-     *  S-877 登记:core 7.34.0 起子代 checkpoint 的数据半持久 `inheritedGate.permissionMode`(链在 spawn 时的**生效**模式),
+     *  [ref] 登记:core 7.34.0 起子代 checkpoint 的数据半持久 `inheritedGate.permissionMode`(链在 spawn 时的**生效**模式),
      *  这一座可改读它 —— 接线不在本次提货单内,见 7.106.0 收车档「未闭环」。 */
     readonly parentAutoModeIntent?: ((row: BackgroundAgentRecord) => boolean) | undefined;
     readonly logger: {
@@ -115,7 +115,7 @@ export type RebuiltParentConstraint = NonNullable<RebuiltInheritedGate["parentCo
  * (core 对这三个都是 seed 兜底)。
  *
  * 时点语义(成文进 docs/ASSISTANT-WIRE-CONTRACT.md,免运维当 bug 报):
- *  · toolPolicy 轴 = **当前** config(与 resume 重折一致)。S-877(core 7.35.0 #1200)起部署治理层经 `wrapToolPolicy` 携带内层 `projection`
+ *  · toolPolicy 轴 = **当前** config(与 resume 重折一致)。[ref](core 7.35.0 [ref])起部署治理层经 `wrapToolPolicy` 携带内层 `projection`
  *    ⇒ 父链那一层的**内容**进了 `cpv1` 摘要:挂起期间改了治理 config(收紧或放松)⇒ 重建链摘要对不上 ⇒ core pre-CAS 响亮拒、卡留 pending
  *    (此前那一层 opaque,收紧与放松都按当前 config 兑现;特征化钉 test/parked-revive-e2e.test.ts 已随之翻);
  *  · shellGate 轴 = core 取 max(live, park 时 seed)—— 收紧兑现、放松**不**兑现(fail-safe)。

package/dist/boot/parked-revive-gate.js

@@ -4,7 +4,8 @@ import { recordFailOpen } from "../observability/fail-open.js";
 import { decodeCheckpointScope } from "../security.js";
 import { createApprovalBaselinePolicy, createDeploymentGovernanceInputs, } from "../deployment-governance.js";
 import { applyRuntimeGovernance } from "../runtime-governance.js";
-import { DeferredSandboxPathEnv, isSandboxPathAdjudicationLane, sandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
+import { DeferredSandboxPathEnv, sandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "../deployment-shape.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
 import { createDeploymentListExemption } from "../approval.js";
 function hostGateCwd(config, localRoot) {
@@ -17,7 +18,7 @@ export function createParkedReviveInheritedGate(deps) {
         const metadata = await chainMetadataOf(deps, row, identity);
         const laneHome = executionLaneHomeDir(config);
         const homeBase = laneHome !== undefined ? { taskHome: laneHome } : {};
-        const pathAdjudication = isSandboxPathAdjudicationLane(config.remoteExec?.provider)
+        const pathAdjudication = DEPLOYMENT_SHAPE_PREDICATES.sandboxPathAdjudication.holds(config)
             ? {
                 env: new DeferredSandboxPathEnv({
                     sessionId: row.sessionId,

package/dist/boot/reapers.d.ts

@@ -70,12 +70,12 @@ export interface ReapersCtx {
     subRunner: Runner;
     runStore: ReturnType<StoreBackend["run"]> | undefined;
     checkpointStore: CheckpointStoreFull | undefined;
-    /** S-1280:checkpoint 店的 park 提交观察层(stage-06 与店同一处铸;在场 ⇔ 有 checkpoint 店)。对账收敛器订阅它,在停车行提交那一拍收口 PARKING。 */
+    /** [ref]:checkpoint 店的 park 提交观察层(stage-06 与店同一处铸;在场 ⇔ 有 checkpoint 店)。对账收敛器订阅它,在停车行提交那一拍收口 PARKING。 */
     parkCommits: ParkCommitWatch | undefined;
     rateLimiter: RateLimiter | RateLimiterStore | undefined;
     costQuota: CostQuota | CostQuotaStore | undefined;
     toolResultStore: ToolResultStoreFull | undefined;
-    /** S-589:文件历史的**擦除脸**(后端在即在,与 `FILE_HISTORY_CAPTURE` 无关)—— 本段只用它的孤儿 blob GC。 */
+    /** [ref]:文件历史的**擦除脸**(后端在即在,与 `FILE_HISTORY_CAPTURE` 无关)—— 本段只用它的孤儿 blob GC。 */
     fileHistoryErasure: FileHistoryErasureFace | undefined;
     taskAttachmentStore: TaskAttachmentStore | undefined;
     imageBakes: ImageBake | undefined;
@@ -103,9 +103,9 @@ export interface ReapersCtx {
      *  (`boot/permission-rules-audit.ts` 的 `DormantRuleCounter` 是同一条判据的先例)。
      *  生产传的仍是整只束(结构上满足这个窄口)。 */
     permissionRuleStores: PermissionRuleRetentionSweeper | undefined;
-    /** S-928 用户输入受理账本(stage-07 装配;缺席 = 无 backend)。每拍在 reapStale **之后**收敛一次(同一条腿串行,理由见 tick 里那一行)。 */
+    /** [ref] 用户输入受理账本(stage-07 装配;缺席 = 无 backend)。每拍在 reapStale **之后**收敛一次(同一条腿串行,理由见 tick 里那一行)。 */
     userInputLedger: Pick<UserInputLedger, "converge"> | undefined;
-    /** S-280 直连门 nonce 的消费记录店 —— 本 tick 只用它的**到期清扫**一手。行至多活 ~150 秒(= 证明还能被
+    /** [ref] 直连门 nonce 的消费记录店 —— 本 tick 只用它的**到期清扫**一手。行至多活 ~150 秒(= 证明还能被
      *  受理的最后一刻),所以存量是「到达率 × TTL」而不是历史总量,清扫无需分批。无 backend 的 env-only
      *  部署 ⇒ undefined ⇒ 本腿零调用(那种部署也没有 durable 审批门)。 */
     approvalNonceStore: ApprovalNonceStore | undefined;

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

@@ -57,7 +57,7 @@ export interface ResolveSpecCtx {
         backend: MemoryBackend;
         root: string;
     } | undefined;
-    /** S-640:记忆同步腿(开 `MEMORY_SYNC_*` 且记忆引擎接线时在场)—— 项目层准备一步把本任务的项目层交给它跟踪(`memory-project-layer.ts`)。 */
+    /** [ref]:记忆同步腿(开 `MEMORY_SYNC_*` 且记忆引擎接线时在场)—— 项目层准备一步把本任务的项目层交给它跟踪(`memory-project-layer.ts`)。 */
     memorySyncRunner: MemorySyncRunner | undefined;
     durableEnabled: boolean;
     /** [ref] ([ref] 案二):活体 AskUserQuestion 面(QuestionCoordinator 的判决探针切面)。在场(=