@sema-agent/server 7.151.0 → 7.152.0

package/dist/leader/wire.d.ts

@@ -1,15 +1,14 @@
-import { type Brain, type Model, type ModelRoles, type ModelPricing, type TaskSpec, type ExecutionEnvFactory, type RemoteExecutionEnv, type ToolResultStore, type SessionStore, type ExecutionEnv, type RunnerDeps, type CheckpointToken } from "@sema-agent/core";
+import { type TaskSpec, type ExecutionEnvFactory, type RemoteExecutionEnv, type ToolResultStore, type SessionStore, type ExecutionEnv, type CheckpointToken } from "@sema-agent/core";
 import type { Autonomy } from "../runtime-governance.js";
-import { type CheckpointCtxSealer } from "../http/checkpoint-ctx.js";
-import type { CheckpointStoreFull } from "../plugins/store-backend.js";
-import { type LeaderDeps, type LeaderResult } from "./leader.js";
-import { type DeploymentPostureSeats } from "../boot/runner-deps.js";
+import { type LeaderDiffStore } from "./diffup.js";
+import { type LeaderBirth, type LeaderDurableSeat, type LeaderDeps, type LeaderResult } from "./leader.js";
+import type { DeploymentPlaneDeps } from "../boot/runner-deps.js";
+import type { SandboxPathEnvSlots } from "../boot/deferred-sandbox-path-env.js";
 import type { LeaderRequestBody } from "./endpoint.js";
 /**
- * leader worker 停驻行的两只 scope —— **唯一属主**(审批停驻 / 资源分片停驻各一只;保留标识见 `principal-shape.ts` 的 `RESERVED_PRINCIPALS` /
- * `RESERVED_PRINCIPAL_PREFIXES`)。worker 的 durable spec 与取消时的残留过期({@link createLeaderParkExpirer})读这同一对。
+ * leader worker 资源分片停驻行的 scope —— **唯一属主**(保留前缀见 `principal-shape.ts` 的 `RESERVED_PRINCIPAL_PREFIXES`;审批停驻那一只
+ * `LEADER_APPROVAL_SCOPE` 的属主是出生口所在的 `leader.ts`)。worker 的资源分片 spec 与取消时的残留过期({@link createLeaderParkExpirer})读这同一对。
  */
-export declare const LEADER_APPROVAL_SCOPE = "_leader";
 export declare function leaderResourceScope(workerId: string): string;
 /** 过期残留停驻要的那两口(SQL 两方言与 local 店都有;结构型,单测用假件)。 */
 export interface LeaderParkStore {
@@ -30,18 +29,6 @@ export declare function createLeaderParkExpirer(store: LeaderParkStore): (worker
     readonly workerId: string;
     readonly sessionId: string;
 }>) => Promise<LeaderParkExpiry>;
-/** leader worker 的 durable 审批座(`LeaderWireConfig.durable` 函数席每次产出的一份)。 */
-export interface LeaderDurableSeat {
-    readonly checkpointStore: CheckpointStoreFull;
-    /** [ref]:写 worker 续跑上下文的封口(`ServiceDeps.checkpointCtxSealing` 同一只;规则属主 `http/checkpoint-ctx.ts` 末段「凭据位密封」)。
-     *  worker 的续跑体只有入口词 + 子任务 objective、不带凭据位 ⇒ 实际不封任何值,但写 ctx 的每一笔都经同一只封口(没有不封的第二种写法)。 */
-    readonly ctxSealer: CheckpointCtxSealer | undefined;
-    readonly requireApproval: string[];
-    readonly deny?: string[];
-    readonly ttlMs?: number;
-    readonly autoBudget?: number;
-    readonly neverAuto?: string[];
-}
 export interface LeaderWireConfig {
     /** Static-env compat mode (E2B only): the leader provisions/owns each env. Required when `envFactory` unset. */
     e2bApiKey?: string;
@@ -49,17 +36,17 @@ export interface LeaderWireConfig {
      *  REMOTE_EXEC (e2b or k8s/Kata) — workers and the integration sandbox run on envs from THIS factory.
      *  Requires `s3` (diff-out is the worker's self-upload; there is no leader-held env to pull from). */
     envFactory?: ExecutionEnvFactory;
-    /** Durable suspend/resume for SUB-WORKERS ([ref] C4): when the seat yields a value, that worker task carries
-     *  the durable question/ask policy + checkpoint store, so a gated ask/AskUserQuestion SUSPENDS the worker
-     *  (checkpoint + paused env) instead of failing — the trigger replan-lite C4 arbitrates on. Mirrors main.ts's
-     *  per-task durable wiring; ctx is seeded at provision so the surfaced token is resumable on the single-agent path.
-     *
-     *  🔴 **函数席,不是快照**([ref] 波 2 ①;先例 = 下方 `deploymentPosture` 的 [ref] 函数席):审批名单
-     *  (`governance.approvalRequire`)自本批起在进程内会被中心热换。boot 期取一次值会把这条腿钉在起服那一刻的名单上
-     *  —— 起服时名单为空 ⇒ 整块缺席、之后加进来的工具在 leader worker 上**永远**不被门住(fail-OPEN)。
-     *  `provisionWorker` 每只 worker 调一次(同一只 worker 的 toolPolicy / resource 停车 / ctx 保温读同一份);
-     *  返回 `undefined` = 这只 worker 不接 durable 审批(与修前「键缺席」同义)。 */
-    durable?: () => LeaderDurableSeat | undefined;
+    /** 部署的停驻设施([ref] C4):键在场 ⟺ 部署接了停驻店。worker 首跑的出生点按车道决定递不递给这条腿:工厂车道 = 递(worker 的环境由它自己的 Runner
+     *  经工厂铸,停驻续得上);静态车道 = `leader.ts` 的 `staticLaneWorkerPark`(上一发布版的条件:另要任一审批名单在场,见 {@link approvalListInForce})。
+     *  递了且续跑上下文真落了 ⇒ 这条腿**耐久**(唯一读者 `leader.ts` 的 `leaderLegDurability`):停驻设施进 spec、ctx 保温、开资源分片停驻。
+     *  函数席:`provisionWorker` 每只 worker 调一次,同一只 worker 的停驻设施 / ctx 保温 / 资源分片读同一份。 */
+    durable?: () => LeaderDurableSeat;
+    /** 这台部署此刻有没有任一审批名单在场(`APPROVAL_REQUIRE` / `APPROVAL_DENY` / `APPROVAL_NEVER_AUTO`,含中心热换的那一张;装配处闭包同一个活 config,与
+     *  {@link baseline} 同源)。**唯一读者** = 静态车道 worker 的停驻设施条件(`leader.ts` 的 `staticLaneWorkerPark`,上一发布版的条件);引擎提供
+     *  「宿主声明本腿审批停驻不可续」的声明位后,那条条件退役,本席随之删。函数席:每只 worker 现读一次。 */
+    approvalListInForce: () => boolean;
+    /** 审批基线的两臂(`LeaderBirth.baseline`;装配处闭包活 config,leader 不读 config)—— 每一条腿出生时经 {@link withLeaderLeg} 按它的耐久事实取一臂。 */
+    baseline: LeaderBirth["baseline"];
     /** Durable tool-result offload store (TiDB). REQUIRED for `durable` to actually suspend: core's suspend
      *  pre-commit refuses with the default InMemoryToolResultStore (offloaded results would deref to null after
      *  a cross-replica resume) and silently falls back to the synchronous onAsk gate — which the leader does not
@@ -70,109 +57,35 @@ export interface LeaderWireConfig {
      *  the resume dies with SessionError "Entry <leafId> not found" (found live: drill c3 deny path). */
     sessionStore?: SessionStore;
     /**
-     * [ref] 件B/C/D([ref],codex R2-F1)—— 部署治理三座席,**原样递给本车道的每一只 Runner**。
-     * 主车道的 `boot/governance-seams.ts` 是唯一属主(判据、拒启、解析全在那里),本字段只是把它的产物
-     * 搬过来:一个进程里「这台部署禁哪些能力、锁了哪些键」只能有一个答案。缺席 = 与接线前逐字相同。
+     * **部署平面层**(唯一铸点 `boot/runner-deps.ts` 的 `createDeploymentPlaneDeps`;起服第 6 段交出、`boot/leader.ts` 递进来)—— 本车道的每一只
+     * `new Runner` 头一项展开它,零逐席搬运:收紧面(治理三座 / 按主体准入 resolver / MCP 撤销台账 / 部署姿态座席族 / 豁免根)、计量面(tracer /
+     * 治理窗两键)、服务表(brain / 模型目录 / 定价 / 提示词目录)、部署座 / 手带、两条披露出口(通告 / 错误汇)。新的部署键进那一层即到达这里。
+     * 🔴 **函数席**([ref] 先例):姿态族与模型目录会被中心热换,本车道的 Runner 逐调用现构 ⇒ 每只构造时现铸一份,与主车道经 swap 门换代同代。
      */
-    governance?: Pick<RunnerDeps, "compliancePostureResolver" | "lockedConfig" | "retentionPolicy">;
-    /**
-     * [ref](黑板 [ref])—— **部署姿态座席族**(readFace 四席 `readFace`/`readDenyPatterns`/`readDenyBuiltinTiers`/
-     * `readDenyBuiltinExclude` + `memoryDelegationEvidence`/`memoryProvenance`/`memoryCapturePolicy`/
-     * `delegationEntryCaps`),**原样递给本车道的每一只 Runner**。唯一属主 = `boot/runner-deps.ts` 的
-     * `buildDeploymentPostureSeats(config)`(主 runner / subRunner / run-local 的共享基座展开的就是它),
-     * `boot/leader.ts` 把**同一函数、同一 config** 的产物搬过来:一个进程里「这台部署的 READ 面 / 记忆姿态 /
-     * 委派 caps」只能有一个答案。缺席 = 展开空对象 = 五处字面量键缺席(与接线前逐字相同)。
-     * 修前(≤7.53)这五只 Runner 一席都没有:运维写的 READ_DENY_PATTERNS / MEMORY_DELEGATION_EVIDENCE 等对
-     * leader 编排的 planner / worker / repair / conflict 四类任务**静默不生效**(core 内建 deny 表仍在)。
-     *
-     * 🔴 **是 provider 不是快照**([ref] 追加,codex 对抗复审 r1 [high] 验真后修):本车道的 Runner 是
-     * **逐调用现构**的,而 [ref] 起 `config.readFace` 在进程内**会变**(center 下发的 read face 转成了
-     * `Runner.swapDeps` 热换席)。boot 期取一次值再五处复用,等于让 leader 车道永远停在起服那一刻的 READ
-     * 姿态:读面(`/v1/capabilities`、`/v1/diagnostics/wiring`)报新档、`restart.reasons` 也不再要求重启,
-     * 而**新建的 leader Runner 仍在旧档上跑** —— 组织把 `open` 收紧成 `roots` 之后这条腿还在 open,方向是
-     * fail-OPEN。改成函数席之后每只 Runner 构造时现读,与主车道经 swap 门换代**同代**;已经准备好的腿
-     * 保留它准备时的那一份(core 的自然快照语义,两条腿同律)。 */
-    deploymentPosture?: () => DeploymentPostureSeats;
+    plane: () => DeploymentPlaneDeps;
     /**
-     * 运维 `AUTONOMY`(活 config 的那一位)—— 本车道每条 leader run **出生那一拍**读一次,经 `run-entry.ts` 的 `leaderRunEntry`(入口地板 + 受理门同一只入口函数 `entryPermissionMode`)
-     * 得出这条 run 的入口体(`LeaderDeps.entry`);本 run 铸的每一条 spec 与 worker 的续跑体都从它取词。入口词是 `plan` 的 run 进不了这条车道
-     * (`leaderEntryRefusal`:worker 会话没有计划审阅通道)⇒ 出生处即以拒句收场;HTTP 受理口用同一只判据先答 422。
-     *
-     * 🔴 **函数席**(与 `deploymentPosture` / `durable` 同一条先例):`config.autonomy` 被 web-admin 原地热改,boot 期取一次值会把这条腿钉在起服那一刻。
-     * **必填**:没有 AUTONOMY 的装配递 `() => undefined` —— 缺席不是「没有地板」的合法拼法(权限轴上不许静默放宽)。
-     */
-    autonomy: () => Autonomy | undefined;
-    /**
-     * [ref]([ref])—— **计费/遥测追踪席**,原样递给本车道的每一只 Runner。唯一属主 =
-     * `boot/budget-tracing.ts` 的 `createTracer(...)`(主 runner / subRunner / hook runner 经共享基座吃的
-     * 就是它),`boot/leader.ts` 搬的是**同一只**。
-     *
-     * 🔴 为什么这一席是承重的:`src/budget.ts` 的 `createTracer` 是 `brain.call` **唯一**的记账点 ——
-     * `costQuota.add` / `fleetUsage.record` / `fleetLease.recordSpend` / `model_cost_micro_usd_total` 四个写口
-     * 全在那里(`createBrain` 自己不记账)。而 `POST /v1/leader` 的准入处**读**的正是 costQuota / fleetLease
-     * 这两个桶。缺席 ⇒ 门查的桶与花钱的手不是同一只:`MAX_PRINCIPAL_COST_USD` 与 fleet 租约对这条腿结构性
-     * 失效,而一条 leader run 扇出 ≤6 个带手 worker + planner + repair/conflict 环,全是实钱。
-     * 归因的另一半在 `leader/endpoint.ts` 的 `drive()`(ALS `withSubject`)—— 记账臂按 `currentPerson()`
-     * 分租户,只补席不包裹 = 归因恒 undefined = 假绿。缺席 ⇒ 展开空对象(与接线前逐字相同)。
+     * 部署治理折叠(`LeaderBirth.govern`;装配处闭包活 config,leader 不读 config)—— 每一条腿出生时经 {@link withLeaderLeg} 调一次。
      */
-    tracer?: RunnerDeps["tracer"];
+    govern: LeaderBirth["govern"];
     /**
-     * **部署座**(`RunnerDeps.mods`),原样递给本车道的每一只 Runner。唯一铸点 = 起服第 5 段的装配口 `assembleDeploymentMods`(本服务自铸的注册在前、
-     * 运维声明的 mod 包在后、整列过引擎准入);主 / 无手 / hook 代理 / 子代经共享基座吃的就是它,`boot/leader.ts` 搬的是**同一份**。
-     * leader 不自铸、不自己装配(一个进程两份部署注册 = 主车道与 leader 车道各按一套扩展跑)。缺失时整个部署座在这条车道上缺席:运维声明的守卫包
-     * 管不到 leader 派出的腿,拒绝计量 / 工具追踪也漏这条腿。缺席 ⇒ 展开空对象。
+     * 每条腿的 per-model 凭据席(`LeaderBirth.auth`;装配处铸,与任务面同一只活引用)—— 本车道每一只 Runner 跑的 spec 都带它:五个出生点经 {@link withLeaderLeg},
+     * planner 路由在它的 Runner 构造那一拍取一只。**必填**:没有 per-model 钥匙的装配照样递(席对每只模型答「没有自己的钥」⇒ 网关钥,与不递逐字同)。
      */
-    mods?: RunnerDeps["mods"];
+    auth: LeaderBirth["auth"];
     /**
-     * **手带**(`RunnerDeps.hands`),原样递给本车道的每一只 Runner。唯一铸点 = `boot/runner-deps.ts` 的 `buildHandsBand`(共享基座调的同一只):
-     * 前台命令超时转后台读部署旋钮 `AUTO_BACKGROUND_ON_TIMEOUT`,本车道不署名。缺失时本车道的 Runner 没有手带(超时即杀、不署名)。缺席 ⇒ 展开空对象。
+     * 腿的路径裁决的槽表(进程内唯一那一只,`boot/deferred-sandbox-path-env.ts`)。本车道**手里握着 env** 的腿 —— 静态车道的 worker、集成修复腿 ——
+     * 的 env 不是部署工厂为那条腿铸的,工厂装饰器登记不到;每一次 run 由本车道按跑它的会话号登记、run 收场即注销(守卫在沙盒车道上按会话号取真身)。
      */
-    hands?: RunnerDeps["hands"];
+    legSlots: Pick<SandboxPathEnvSlots, "bind">;
     /**
-     * [ref]([ref],[ref]-T1)—— **部署级 token 治理窗**两键,**成对**递给本车道的每一只 Runner。
-     * 属主 = `config.usageWindows`(声明)+ `boot/stores.ts` 造的账本店(两者同真同假,与
-     * `boot/runner-deps.ts` 的共享基座同规);leader 不自己读 config。
-     *
-     * 成对的理由是 core 的消费形:`prepare-task.js` 的 `buildUsageGovernance(usageWindows, deps, …)` 要求
-     * 声明与 `deps.usageWindowStore` **同时**在场才铸 `usageGovernance`,缺一即 undefined(既不 check 也不
-     * commit)⇒ 半席只是死键。缺席 ⇒ 展开空对象。
-     * 提交面那一半(`POST /v1/leader` 的 `usageWindowDenied` 门)在 `src/http/routes/leader.ts`。
-     */
-    usageWindows?: RunnerDeps["usageWindows"];
-    usageWindowStore?: RunnerDeps["usageWindowStore"];
-    /**
-     * [ref]([ref])—— **center 发布的 prompt catalog** 席,原样递给本车道的每一只 Runner。唯一属主 =
-     * `boot/web-admin.ts` 的 `webAdmin.promptSource`(主 runner / subRunner 同一只;run-local 有自己
-     * 的等价腿)。缺席 ⇒ leader 的 planner/worker/repair/conflict 四类**顶层**任务跑引擎内置提示词,而同一
-     * 部署的 `/v1/tasks`、`/v1/runs` 跑运维发布的那一份 —— 且 core 顶层新任务走的是**静默**臂(pinned /
-     * parentCenterArtifactDigest 两支才 `prompt.snapshot_unavailable` fail-loud),运维面零信号。
-     * 缺席 ⇒ 展开空对象(与接线前逐字相同)。
-     */
-    promptSource?: RunnerDeps["promptSource"];
-    /**
-     * [ref] 的**披露半件**([ref],codex 对抗复审 r2-[high],亲读装树 core 后修)—— 部署级错误汇。
-     *
-     * 🔴 为什么它与治理窗席**同生共死**:core 对「治理窗最终扣账失败」的唯一出口就是这一席 ——
-     * `dist/core/runner/runtask.js` 收尾段 `catch (flushErr) { this.deps.onError?.(flushErr, { phase: "config", … }) }`
-     * (以及 10s 慢盘披露的同一只回调),抛错之后任务**按原结果收尾**。挂了窗席却不挂本席 = 一次窗账
-     * 永久丢失时这条腿上零日志零计数,后续提交继续读偏低的窗被放行 —— CLAUDE.md [ref]「治理/门轴禁静默
-     * fail-open」正是说这个。它顺带也把 leader 车道其余 phase(degraded / rewind / memory / mcp / a2a /
-     * prompt-cache …)的既有观测面补齐,与 `onNotice` 席当年([ref]②)同一个理由。
+     * 运维 `AUTONOMY`(活 config 的那一位)—— 本车道每条 leader run **出生那一拍**读一次,经 `run-entry.ts` 的 `leaderRunEntry`(入口地板 + 受理门同一只入口函数 `entryPermissionMode`)
+     * 得出这条 run 的入口体(`LeaderDeps.birth.entry`);本 run 铸的每一条 spec 与 worker 的续跑体都从它取词。入口词是 `plan` 的 run 进不了这条车道
+     * (`leaderEntryRefusal`:worker 会话没有计划审阅通道)⇒ 出生处即以拒句收场;HTTP 受理口用同一只判据先答 422。
      *
-     * 属主唯一 = `boot/runner-deps.ts` `createRunnerDeps` 铸的那一只;`boot/leader.ts` 直引
-     * `runnerDeps.onError`(**同一实例**,[ref]§三族A 的最强同源形,与 main.ts subRunner 的先例逐字同姿势),
-     * leader 绝不另写一份臂表(两份必漂)。缺席 ⇒ 展开空对象(与接线前逐字相同)。
+     * 🔴 **函数席**(与 `deploymentPosture` / `durable` 同一条先例):`config.autonomy` 被 web-admin 原地热改,boot 期取一次值会把这条腿钉在起服那一刻。
+     * **必填**:没有 AUTONOMY 的装配递 `() => undefined` —— 缺席不是「没有地板」的合法拼法(权限轴上不许静默放宽)。
      */
-    onError?: RunnerDeps["onError"];
-    /** Worker model brain + catalog (the same the service runs tasks on). */
-    brain: Brain;
-    models: Record<string, Model>;
-    roles: ModelRoles;
-    /** The active tier table of the served catalog (boot hands the same object as `config.tiers`, mutated in place on a hot apply).
-     *  Every leader Runner gets it with `models` / `roles` (one seat, `servedTableSeat`): a role resolves in the tier-expanded view,
-     *  exactly as the main runner resolves it — absent ⇒ no tiers (the env table has none). */
-    tiers?: NonNullable<RunnerDeps["tiers"]>;
-    pricing: Record<string, ModelPricing>;
+    autonomy: () => Autonomy | undefined;
     /** Workspace root inside each E2B VM. Default /home/user. */
     workspace?: string;
     /** Git identity for the Coordinator's local clone/commit. */
@@ -198,14 +111,7 @@ export interface LeaderWireConfig {
      *  complete path; a suspended worker's paused env is exempt from the leader reap by construction) and diff-out
      *  is the worker's mandatory self-upload to this MinIO/S3 store (presigned per worker; creds adapter-held).
      *  Unset = the original leader-owned static-env mode (pullDiff compat). */
-    s3?: {
-        endpoint: string;
-        bucket: string;
-        accessKey: string;
-        secretKey: string;
-        region?: string;
-        keyPrefix?: string;
-    };
+    s3?: LeaderDiffStore;
     logger?: {
         warn?: (m: string, x?: Record<string, unknown>) => void;
         info?: (m: string, x?: Record<string, unknown>) => void;
@@ -279,6 +185,10 @@ export declare function stageWorkerEnv(env: WireEnv, opts: {
  * (URL) silently killed long autonomous builds or expired the diff upload mid-run. core's turn cap is now a
  * high net (10000), so the leader gives each worker an explicit triple bound; a sub-task's own limits override.
  */
+/** The leader's diff-out URL lifetime (`presignTtlSec` = `LEADER_TIMEOUT_MS` / 1000 + 600: the URL outlives the worker) over the SigV4 ceiling ⇒ the
+ *  refusal sentence, naming the knob and its largest value; within it ⇒ `undefined`. The runner refuses to be built with a diff-out store on such a
+ *  configuration (boot), instead of signing URLs the store would refuse at the end of a worker's run. */
+export declare function leaderDiffUrlTtlRefusal(presignTtlSec: number): string | undefined;
 export declare function leaderResourceConfig(env?: NodeJS.ProcessEnv): {
     leaderTimeoutMs: number;
     workerMaxTurns: number;

package/dist/leader/wire.js

@@ -3,30 +3,30 @@ import { parseNumOrFail } from "../config.js";
 import { execFileSync } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { Runner, combinePolicies, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, delimitUntrusted, hasDestroy, } from "@sema-agent/core";
+import { Runner, delimitUntrusted, hasDestroy, } from "@sema-agent/core";
 import { leaderEntryRefusal, leaderRunEntry } from "./run-entry.js";
 import { buildCheckpointCtx } from "../http/checkpoint-ctx.js";
+import { submissionPermissionModeWrite } from "../permission-mode-admission.js";
 import { serviceVersion } from "../service-version.js";
 import { RemoteContainerExecutionEnv } from "../plugins/remote-env-e2b.js";
 import { buildLaneHomeClaim } from "../execution-lane-caps.js";
 const e2bBaseTemplateHomeSeat = buildLaneHomeClaim({ remoteExec: { provider: "e2b" } });
-import { createDurableAskPolicy } from "../approval.js";
 import { gitSubprocessEnv } from "../server-secret-env.js";
-import { presignS3Url } from "../plugins/s3-presign.js";
-import { buildUploadScript, buildUploadLoopScript, uploadLoopCommand, uploadLoopScriptPath, uploadStepSuffix, fetchUploadedDiff, withStaging, UPLOAD_LOOP_PERIOD_SEC } from "./diffup.js";
+import { buildLeaderDiffUrls, buildUploadScript, buildUploadLoopScript, uploadLoopCommand, uploadLoopScriptPath, uploadStepSuffix, fetchUploadedDiff, withStaging, UPLOAD_LOOP_PERIOD_SEC } from "./diffup.js";
 import { pullDiff, safeRev } from "./diffout.js";
-import { runLeaderTask, withLeaderLeg } from "./leader.js";
+import { LEADER_APPROVAL_SCOPE, leaderLegDurability, runLeaderTask, staticLaneWorkerPark, withLeaderLeg } from "./leader.js";
 import { attachRepairLoopDeps } from "./repair-wire.js";
 import { routePlanWithFallback, validateSubtasks } from "./planner.js";
-import { createEngineNoticeSeat } from "../boot/runner-deps.js";
 import { buildInternalRunCtx } from "../internal-run-env.js";
 import { currentSubject } from "../observability/principal-context.js";
 import { partsOf } from "../owner-brands.js";
 import { taskSpecIdentityOf } from "../engine-identity.js";
 import { redactHead } from "../observability/run-terminal.js";
+import { seatText } from "../trace/exit-seat.js";
+import { SIGV4_PRESIGN_MAX_SEC } from "../object-store-buckets.js";
 const REPAIR_LOOP_WIRED = true;
-export const LEADER_APPROVAL_SCOPE = "_leader";
 export function leaderResourceScope(workerId) {
     return `_leader-resource-${workerId}`;
 }
@@ -104,6 +104,12 @@ function parseNumOrFailNonNegative(name, raw) {
         throw new Error(`env ${name}=${n} must not be negative`);
     return n;
 }
+export function leaderDiffUrlTtlRefusal(presignTtlSec) {
+    if (presignTtlSec <= SIGV4_PRESIGN_MAX_SEC)
+        return undefined;
+    const maxTimeoutMs = (SIGV4_PRESIGN_MAX_SEC - 600) * 1000;
+    return `LEADER_TIMEOUT_MS makes the leader's diff-out links live ${presignTtlSec} s (the worker timeout + 600 s), longer than a presigned URL can (at most ${SIGV4_PRESIGN_MAX_SEC} s (7 days)) — set LEADER_TIMEOUT_MS to at most ${maxTimeoutMs}`;
+}
 export function leaderResourceConfig(env = process.env) {
     const leaderTimeoutMs = Math.max(600_000, Math.floor(parseNumOrFailNonNegative("LEADER_TIMEOUT_MS", env.LEADER_TIMEOUT_MS) || 0) || 86_400_000);
     const workerMaxTurns = Math.floor(parseNumOrFailNonNegative("LEADER_WORKER_MAX_TURNS", env.LEADER_WORKER_MAX_TURNS) || 0) || 10_000;
@@ -199,22 +205,28 @@ export function createLeaderRunner(cfg) {
     };
     const ident = cfg.git ?? { name: "leader", email: "leader@local" };
     const { leaderTimeoutMs, workerLimits, presignTtlSec, resourceSuspend: resourceCfg } = leaderResourceConfig();
+    const ttlRefusal = cfg.s3 !== undefined ? leaderDiffUrlTtlRefusal(presignTtlSec) : undefined;
+    if (ttlRefusal !== undefined)
+        throw new Error(ttlRefusal);
     const { repairRounds, repairBudgetUsd, repairLoopOn, measureGatesOn, repairLoopAttempts, oracleFlakyK, replanBudgetUsd, } = leaderLoopConfig({ repairRounds: cfg.repairRounds });
-    const onNoticeSeat = createEngineNoticeSeat(cfg.logger);
-    const governanceSeat = cfg.governance ?? {};
-    const deploymentPostureSeat = () => cfg.deploymentPosture?.() ?? {};
-    const tracerSeat = cfg.tracer ? { tracer: cfg.tracer } : {};
-    const modsSeat = cfg.mods ? { mods: cfg.mods } : {};
-    const handsSeat = cfg.hands ? { hands: cfg.hands } : {};
-    const servedTableSeat = { models: cfg.models, roles: cfg.roles, ...(cfg.tiers ? { tiers: cfg.tiers } : {}) };
-    const usageWindowSeat = cfg.usageWindows && cfg.usageWindowStore ? { usageWindows: cfg.usageWindows, usageWindowStore: cfg.usageWindowStore } : {};
-    const promptSourceSeat = cfg.promptSource ? { promptSource: cfg.promptSource } : {};
-    const onErrorSeat = cfg.onError ? { onError: cfg.onError } : {};
-    const principalSpec = () => {
-        const subject = currentSubject();
-        return taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject));
+    const mintLegSessionId = (stem) => `leader-${stem}-${Date.now()}-${randomUUID()}`;
+    const bindLegSlot = (key, env) => {
+        const release = cfg.legSlots.bind(key, env);
+        if (release === undefined)
+            cfg.logger?.warn?.("sandbox_path_env_slot_at_capacity", { sessionId: key, leg: "leader" });
+        return release ?? (() => { });
+    };
+    const withLegSlot = (runner, env, key) => {
+        const orig = runner.runTaskStream.bind(runner);
+        runner.runTaskStream = (...args) => {
+            const release = bindLegSlot(key, env);
+            const stream = orig(...args);
+            void stream.result().then(release, release);
+            return stream;
+        };
+        return runner;
     };
-    const mkRepair = (rawEnv, repoDir, oracleFiles, entry) => {
+    const mkRepair = (rawEnv, repoDir, oracleFiles, birth) => {
         if (repairRounds <= 0)
             return undefined;
         return {
@@ -227,7 +239,6 @@ export function createLeaderRunner(cfg) {
                         throw new Error(`oracle still present after remove (${f.path}) — refusing repair (measurement integrity)`);
                 }
                 try {
-                    const runner = new Runner({ brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, ...handsSeat, executionEnv: rawEnv, rootPath: repoDir });
                     const objective = [
                         `The integrated project at ${repoDir} fails its build/test. Make the MINIMAL change to the working tree so this command exits 0 (cd into the repo and run it yourself to confirm):`,
                         `  ${testCmd}`,
@@ -236,17 +247,20 @@ export function createLeaderRunner(cfg) {
                         ``,
                         delimitUntrusted("FAILING OUTPUT (untrusted)", errorText),
                     ].join("\n");
+                    const repairSessionId = mintLegSessionId(`repair-${round}`);
+                    const runner = withLegSlot(new Runner({ ...cfg.plane(), executionEnv: rawEnv, rootPath: repoDir }), rawEnv, repairSessionId);
                     const res = await runner
                         .runTaskStream(withLeaderLeg({
                         objective,
-                        ...principalSpec(),
-                        sessionId: `leader-repair-${Date.now()}-${round}`,
+                        sessionId: repairSessionId,
                         signal,
                         limits: { maxCostUsd: repairBudgetUsd, maxWalltimeMs: Math.max(300_000, Math.floor(leaderTimeoutMs / 2)) },
-                    }, entry))
+                    }, birth, { slotKey: repairSessionId, durability: leaderLegDurability({ continuation: "in_run" }), executor: { kind: "fresh" } }))
                         .result();
-                    if (res.terminal.kind !== "completed")
-                        throw new Error(`repair round ${round} did not complete (status=${outwardPlane(res.terminal).status})`);
+                    if (res.terminal.kind !== "completed") {
+                        const plane = outwardPlane(res.terminal);
+                        throw new Error(`repair round ${round} did not complete (status=${plane.status}${plane.errorMessage !== undefined ? `: ${plane.errorMessage}` : ""})`);
+                    }
                     return { costUsd: res.stats?.costMicroUsd !== undefined ? res.stats.costMicroUsd / 1e6 : undefined, note: res.result?.slice(0, 200) };
                 }
                 finally {
@@ -274,6 +288,8 @@ export function createLeaderRunner(cfg) {
         const refused = leaderEntryRefusal(entry);
         if (refused !== undefined)
             return { ok: false, reports: [], cancelled: false, error: refused };
+        const subject = currentSubject();
+        const birth = { entry, identity: taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject)), govern: cfg.govern, baseline: cfg.baseline, auth: cfg.auth };
         const injectOracles = async (env) => {
             const ofs = body.oracleFiles ?? [];
             if (ofs.length === 0)
@@ -295,15 +311,21 @@ export function createLeaderRunner(cfg) {
             if (Array.isArray(body.subtasks) && body.subtasks.length > 0) {
                 return validateSubtasks(body.subtasks);
             }
-            const planRunner = new Runner({ brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, ...handsSeat });
+            const planRunner = new Runner({ ...cfg.plane() });
+            const routeAuth = birth.auth(undefined);
             const runRoute = async (prompt) => {
                 const res = await planRunner.runTaskStream({
                     objective: prompt,
-                    ...principalSpec(),
-                    sessionId: `leader-route-${Date.now()}`,
+                    ...birth.identity,
+                    getApiKeyAndHeaders: routeAuth,
+                    sessionId: mintLegSessionId("route"),
                     signal,
                     ...(cfg.routerModel ? { model: cfg.routerModel } : { modelRole: "classifier" }),
                 }).result();
+                if (res.terminal.kind !== "completed") {
+                    const plane = outwardPlane(res.terminal);
+                    cfg.logger?.warn?.("plan_route_run_incomplete", { status: plane.status, ...(plane.errorMessage !== undefined ? { err: seatText("operator-log-error", plane.errorMessage) } : {}) });
+                }
                 return res.result ?? "";
             };
             const { subs, collapsed, rawSample } = await routePlanWithFallback(body.objective, runRoute, {
@@ -315,23 +337,18 @@ export function createLeaderRunner(cfg) {
             return subs;
         };
         const provisionWorker = async (sub) => {
-            const sessionId = `leader-${sub.workerId}-${Date.now()}`;
-            const durable = cfg.durable?.();
+            const sessionId = mintLegSessionId(sub.workerId);
+            const factory = cfg.s3 !== undefined && cfg.envFactory !== undefined ? { s3: cfg.s3, envFactory: cfg.envFactory } : undefined;
+            const park = factory !== undefined ? cfg.durable?.() : staticLaneWorkerPark(cfg.durable?.(), cfg.approvalListInForce());
             const resumeBody = { ...entry, objective: sub.spec.objective };
-            const storedResumeCtx = durable !== undefined ? buildCheckpointCtx({ body: resumeBody, unattendedLeg: true, writerVersion: serviceVersion() }, durable.ctxSealer, sessionId) : undefined;
-            let durableSpec = {};
-            if (durable && storedResumeCtx !== undefined) {
-                const d = durable;
-                durableSpec = {
-                    toolPolicy: combinePolicies(createDurableQuestionPolicy(), createDurableAskPolicy({ requireApproval: d.requireApproval, ...(d.deny ? { deny: d.deny } : {}), ...(d.autoBudget ? { autoBudget: d.autoBudget } : {}), ...(d.neverAuto ? { neverAuto: d.neverAuto } : {}) })),
-                    checkpointStore: d.checkpointStore,
-                    durableApproval: { scope: LEADER_APPROVAL_SCOPE, ...(d.ttlMs ? { ttlMs: d.ttlMs } : {}) },
-                    onQuestion: QUESTION_AWAITS_RESUME,
-                };
-                await d.checkpointStore.putCtx(sessionId, storedResumeCtx).catch((e) => {
+            const storedResumeCtx = park !== undefined ? buildCheckpointCtx({ body: resumeBody, unattendedLeg: true, writerVersion: serviceVersion(), permissionModeWrite: submissionPermissionModeWrite(resumeBody) }, park.ctxSealer, sessionId) : undefined;
+            const durability = leaderLegDurability(park === undefined || storedResumeCtx === undefined
+                ? { continuation: "replay", resumeCtx: "unwritten" }
+                : await park.checkpointStore.putCtx(sessionId, storedResumeCtx).then(() => ({ continuation: "replay", resumeCtx: "landed", park }), (e) => {
                     cfg.logger?.warn?.("leader_putctx_failed", { workerId: sub.workerId, err: redactHead(e instanceof Error ? e.message : String(e), 2000) });
-                });
-            }
+                    return { continuation: "replay", resumeCtx: "lost" };
+                }));
+            const durable = durability.kind === "durable" ? durability.park : undefined;
             let resourceSpec = {};
             const repairLoopActive = repairLoopOn && REPAIR_LOOP_WIRED;
             if (repairLoopActive && resourceCfg) {
@@ -348,8 +365,8 @@ export function createLeaderRunner(cfg) {
             else if (resourceCfg && !repairLoopActive) {
                 cfg.logger?.warn?.("leader_resource_suspend_inactive", {
                     workerId: sub.workerId,
-                    reason: !durable
-                        ? "no durable checkpoint store"
+                    reason: durability.kind === "transient"
+                        ? durability.why
                         : !cfg.toolResultStore
                             ? "no durable tool-result store"
                             : "no durable session store",
@@ -360,8 +377,8 @@ export function createLeaderRunner(cfg) {
                 if (!d || storedResumeCtx === undefined)
                     return runner;
                 const orig = runner.runTaskStream.bind(runner);
-                runner.runTaskStream = (spec, resume) => {
-                    const stream = orig(spec, resume);
+                runner.runTaskStream = (...args) => {
+                    const stream = orig(...args);
                     const iv = setInterval(() => {
                         void d.checkpointStore.putCtx(sessionId, storedResumeCtx).catch(() => { });
                     }, 45_000);
@@ -371,16 +388,11 @@ export function createLeaderRunner(cfg) {
                 };
                 return runner;
             };
-            if (cfg.s3 && cfg.envFactory) {
-                const s3 = cfg.s3;
-                const envFactory = cfg.envFactory;
+            if (factory !== undefined) {
+                const { s3, envFactory } = factory;
                 const baseSha = body.baseSha;
                 const seedCmd = body.seedCmd;
-                const key = `${s3.keyPrefix ?? "leader-diff"}/${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}/${sub.workerId}.patch`;
-                const ttl = presignTtlSec;
-                const base = { endpoint: s3.endpoint, bucket: s3.bucket, accessKey: s3.accessKey, secretKey: s3.secretKey, ...(s3.region ? { region: s3.region } : {}), key, expiresSec: ttl };
-                const putUrl = presignS3Url({ ...base, method: "PUT" });
-                const getUrl = presignS3Url({ ...base, method: "GET" });
+                const { putUrl, getUrl } = buildLeaderDiffUrls(s3, sub.workerId, presignTtlSec);
                 const script = buildUploadScript({ repoDir: repo, baseSha, putUrl, workDir: W });
                 const stage = async (env) => {
                     await stageWorkerEnv(env, { seedCmd, repo, branch: sub.branch, uploadScriptPath: `${W}/.leader-upload.sh`, uploadScript: script });
@@ -389,21 +401,22 @@ export function createLeaderRunner(cfg) {
                 return {
                     workerId: sub.workerId, sessionId, branch: sub.branch,
                     baseSha,
-                    runner: keepCtxWarm(new Runner({
-                        brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, ...handsSeat,
+                    runner: keepCtxWarm(new Runner({ ...cfg.plane(),
                         ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}),
                         ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}),
                         executionEnvFactory: async (ctx) => {
                             const env = await envFactory(ctx);
                             assertLeaderOwnedEnvReapable(env, "leader worker sandbox");
+                            const releaseSlot = bindLegSlot(sessionId, env);
                             return withStaging(env, stage, async (e) => {
+                                releaseSlot();
                                 await stopUploadLoop(e, sub.workerId);
                                 await sh(e)(`cd ${repo} && git add -A && git -c user.name='leader-belt' -c user.email='belt@leader' commit -qm 'belt: auto-commit uncommitted worker output' || true; sh ${W}/.leader-upload.sh`);
                             });
                         },
                     })),
                     fetchDiff: () => fetchUploadedDiff(getUrl),
-                    spec: withLeaderLeg({ ...workerLimits, ...sub.spec, ...durableSpec, ...resourceSpec, ...principalSpec(), objective: `${sub.spec.objective}${uploadStepSuffix(W)}` }, resumeBody),
+                    spec: withLeaderLeg({ ...workerLimits, ...sub.spec, ...resourceSpec, objective: `${sub.spec.objective}${uploadStepSuffix(W)}` }, birth, { slotKey: sessionId, durability, executor: { kind: "fresh" } }),
                 };
             }
             if (!cfg.e2bApiKey)
@@ -415,15 +428,15 @@ export function createLeaderRunner(cfg) {
             const baseSha = await sh(env)(`cd ${repo} && git rev-parse HEAD`);
             return {
                 workerId: sub.workerId, sessionId, branch: sub.branch, baseSha,
-                runner: keepCtxWarm(new Runner({ brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, ...handsSeat, ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}), ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}), executionEnv: env })),
+                runner: keepCtxWarm(withLegSlot(new Runner({ ...cfg.plane(), ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}), ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}), executionEnv: env }), env, sessionId)),
                 diffEnv: env,
                 destroy: () => env.destroy().then(() => { }),
-                spec: withLeaderLeg({ ...workerLimits, ...sub.spec, ...durableSpec, ...resourceSpec, ...principalSpec() }, resumeBody),
+                spec: withLeaderLeg({ ...workerLimits, ...sub.spec, ...resourceSpec }, birth, { slotKey: sessionId, durability, executor: { kind: "fresh" } }),
             };
         };
         const provisionIntegrationSandbox = async () => {
             if (cfg.envFactory) {
-                const integSessionId = `leader-integ-${Date.now()}`;
+                const integSessionId = mintLegSessionId("integ");
                 const env = await cfg.envFactory(buildInternalRunCtx(integSessionId));
                 const reap = createEnvReaper(env, "leader integration sandbox");
                 try {
@@ -436,7 +449,7 @@ export function createLeaderRunner(cfg) {
                 }
                 const rawEnv = env;
                 const oracleFiles = body.oracleFiles ?? [];
-                const repair = mkRepair(rawEnv, repo, oracleFiles, entry);
+                const repair = mkRepair(rawEnv, repo, oracleFiles, birth);
                 return { env: asIntegrationEnv(env), destroy: reap, ...(repair ? { repair } : {}) };
             }
             if (!cfg.e2bApiKey)
@@ -454,11 +467,12 @@ export function createLeaderRunner(cfg) {
                 await env.destroy().catch(() => { });
                 throw e;
             }
-            return { env: asIntegrationEnv(env), destroy: () => env.destroy().then(() => { }), ...(mkRepair(env, repo, body.oracleFiles ?? [], entry) ? { repair: mkRepair(env, repo, body.oracleFiles ?? [], entry) } : {}) };
+            const repair = mkRepair(env, repo, body.oracleFiles ?? [], birth);
+            return { env: asIntegrationEnv(env), destroy: () => env.destroy().then(() => { }), ...(repair ? { repair } : {}) };
         };
         const push = createCoordinatorPush(body.durableRemote, body.targetRef, ident);
         const deps = {
-            entry,
+            birth,
             signal,
             plan,
             provisionWorker,
@@ -476,7 +490,7 @@ export function createLeaderRunner(cfg) {
         const resolveRepair = async (solo, _sub) => {
             let env;
             if (cfg.envFactory) {
-                const graderSessionId = `leader-grader-${Date.now()}`;
+                const graderSessionId = mintLegSessionId("grader");
                 env = await cfg.envFactory(buildInternalRunCtx(graderSessionId));
             }
             else {

package/dist/memory-scope.d.ts

@@ -174,20 +174,31 @@ export declare function memoryEngineRootFor(config: Pick<ServiceConfig, "memoryE
  *  所以它的根必须走这条链而不是 `memoryEngineRootFor` 的分派(codex 修复验证轮 [medium]:分派会把 run-local 的
  *  记忆搬到 `<localDataRoot>/memory-work`,存量记忆与控制面升级后隐形)。 */
 export declare function fileMemoryEngineRoot(config: Pick<ServiceConfig, "memoryEngineDir">, fallbackRoot?: string): string;
+/**
+ * 一段路径**在不在盘**的唯一读法(三态,{@link canonicalPathOf} 逐段走用它;host 车道托管判在「读不出就不删」那一臂登记根时也读它):
+ *  · `stat` 得动(跟随符号链接)⇒ `true`(在);
+ *  · `ENOENT` / `ENOTDIR`(这一处不存在、悬空链接的目标不存在、中间一段不是目录)⇒ `false`(不在);
+ *  · 其余错误(`EACCES` 没有搜索权限的段、`ELOOP` 链接成环、I/O 错误……)⇒ **原样抛**(读不出)。读不出不是「不在」:把它读成不在,
+ *    下游的路径包含判就会把一处它根本看不见的目录判成「不在根里」—— 那正是删除面上的 fail-open。
+ */
+export declare function presentOnDisk(p: string): boolean;
 /**
  * 一条路径的**规范形**(给 {@link judgeMemoryRootOutsideDataRoot} 的 `canonical` 座用的生产实现;host 车道的工作区托管判也读它):
- *  · 既存的绝对路径 ⇒ **原样**交给 `realpath`(core `physicalPathOf` = realpath(3):大小写不敏感的文件系统上返回盘上的拼写;符号链接、macOS 的 `/var` → `/private/var` 在这一步展平)。
+ *  · 在盘的绝对路径 ⇒ **原样**交给 `realpath`(core `physicalPathOf` = realpath(3):大小写不敏感的文件系统上返回盘上的拼写;符号链接、macOS 的 `/var` → `/private/var` 在这一步展平)。
  *    不先在字串上折 `..`:操作系统在展开符号链接**之后**才折 `..`,`/link/..` 的真身是链接目标的父目录,字串折叠会把它读成 `/`;
- *  · 其余(尚不存在 / 相对)⇒ 绝对化(**不折叠**)后逐段走:既存的前缀每进一段取一次 `realpath`(符号链接在这一步展开),`..` 折在**已展开**的前缀上 ——
- *    与操作系统同序(`/别名/../新目录` 的真身在链接目标的父目录下;先在字串上折会读成别名的父目录,判到另一只挂载上);第一段不存在起,余下是尚不存在的尾巴
+ *  · 其余(尚不在盘 / 相对)⇒ 绝对化(**不折叠**)后逐段走:在盘的前缀每进一段取一次 `realpath`(符号链接在这一步展开),`..` 折在**已展开**的前缀上 ——
+ *    与操作系统同序(`/别名/../新目录` 的真身在链接目标的父目录下;先在字串上折会读成别名的父目录,判到另一只挂载上);第一段不在盘起,余下是尚不在盘的尾巴
  *    (尾巴只做字串规范化,与 `mkdir -p` 建出来的同形)。
  *
- * 为什么按「最深既存祖先」而不是直接 `realpath(p)`:boot 期记忆根常常还没建出来(新数据根),`realpath` 对不存在的路径抛 ENOENT,
- * 而数据根那一侧已经存在、会被展平 —— 两侧拼写空间不一样,同一个目录会被读成「不在其下」。祖先用 `existsSync` 找(它对 ENOENT / ENOTDIR / EACCES / ELOOP
- * 一律答 `false`,不抛),所以走到的那一级一定 stat 得动;`realpath` 仍可能在「探完到取值之间目录被挪走 / 搜索权限被收」的竞态里抛 ——
- * 不在本函数里吞(吞了就是一条无声的降级臂),由 boot 调用点接住并响亮报一行(`memory_engine_dir_check_unavailable`),起服照常。
+ * 为什么按「最深在盘祖先」而不是直接 `realpath(p)`:boot 期记忆根常常还没建出来(新数据根),`realpath` 对不存在的路径抛 ENOENT,
+ * 而数据根那一侧已经存在、会被展平 —— 两侧拼写空间不一样,同一个目录会被读成「不在其下」。
+ *
+ * **读不出就抛**:每一段在不在盘读 {@link presentOnDisk}(三态)—— 不在(`ENOENT` / `ENOTDIR`)才接成尾巴;没有搜索权限的段、成环的链接、`realpath` 在
+ * 「探完到取值之间目录被挪走 / 搜索权限被收」的竞态里失败,一律**原样抛**,不在本函数里吞(吞了就是一条无声的降级臂:把看不见的一段当成「还不存在」,包含判就答
+ * 「不在里面」)。调用方各自接住、按自己的面响亮说「查不了」:起服记忆根判(`memory_engine_dir_check_unavailable`)· 配置根判(`sema_config_root_workspace_check_unavailable`)·
+ * 店的持久性取证(`path_unresolvable`)· host 车道托管判(铸时 ⇒ 这条腿不铸;删前 ⇒ 不删、留给退出兜底)。
  *
- * 取舍:尾巴(不存在的那几段)只比规范化字串,**不折大小写**,尾巴里的 `..` 按字串折:两个只差大小写、且都还不存在的拼写在大小写不敏感的盘上会被读成两处 ——
+ * 取舍:尾巴(不在盘的那几段)只比规范化字串,**不折大小写**,尾巴里的 `..` 按字串折:两个只差大小写、且都还不在盘的拼写在大小写不敏感的盘上会被读成两处 ——
  * 方向是多报一条 warn(这条判据的失败方向),不会漏报。
  */
 export declare function canonicalPathOf(p: string): string;
@@ -195,7 +206,7 @@ export declare function canonicalPathOf(p: string): string;
  * **路径包含**(含相等)的判官:`child` 是不是 `root` 本身或它的后代 —— `path.relative(canonical(root), canonical(child))` 不是 `..`、不以 `..` 加分隔符起头、也不是绝对路径(跨盘符)。
  * `..` 要按**整段**判:名为 `..data` 的子目录在其下;`startsWith("..")` 会把它读成在其外。`canonical` 座缺省 `path.resolve`(字串规范形),boot 递 {@link canonicalPathOf} 取符号链接展平后的形;
  * 两侧同一只座(先 root、后 child)。读者三处:记忆根「在数据根之外」那一判({@link judgeMemoryRootOutsideDataRoot})、起服时「配置根是不是工作区的祖先」那一判(`sema-config-dir.ts`)
- * 与 host 车道工厂「腿的目录落在哪只本服务铸的临时根里」那一判(`plugins/remote-env-host.ts`,座 = {@link canonicalPathOf});
+ * 与 host 车道工厂托管的两判(`plugins/remote-env-host.ts`,座 = {@link canonicalPathOf}:铸时「腿的目录落在哪只本服务铸的临时根里」· 删前「此刻谁的工作目录在这只根里」);
  * 树里别处内联的同形表达式(`boot/deployment-mods.ts` · `plugins/local-data-dir-modes-m39.ts` · `plugins/remote-env-host.ts` 的残余镜像写判 · `plugins/worktree-isolation.ts`)不在本次收口范围。
  */
 export declare function pathIsWithin(root: string, child: string, canonical?: (p: string) => string): boolean;