@sema-agent/server 7.145.0 → 7.147.0

package/dist/approval-card.d.ts

@@ -54,7 +54,7 @@ export declare const MAX_RULE_OFFER_BATCH_MEMBERS = 8;
 /**
  * **一条**「不再询问」OFFER 的形(core 5.58.0 / [ref] §3.1 —— **BREAKING**,取代退役的
  * `RuleSuggestion`)。同步腿(`ApprovalCardSchema.ruleOffers` / `card_json`)与耐久腿(durable park 行的
- * `PendingCheckpoint.ruleOffers`,由 `plugins/checkpoint-store-sql.ts` 窄读)**共用这一份**。
+ * `PendingCheckpoint.ruleOffers`,由 `plugins/checkpoint-store-face.ts` 的 `boundedRuleOffers` 窄读)**共用这一份**。
  *
  * 🔴 单一属主(宪法 [ref]「schema 单一属主禁复制」):两条腿投的是 core 的**同一个** `RuleOffer`
  * (同步腿 = `AskRequest.ruleOffers`,耐久腿 = `PendingAction.ruleOffers`,core
@@ -138,7 +138,7 @@ export interface ReadRuleOffer {
     readonly offer: RuleOffer;
 }
 /**
- * **规则提议列表的唯一读者**(core 7.55.0 [ref] P1 阶段二)—— 两条腿同调:耐久腿(`checkpoint-store-sql.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行)
+ * **规则提议列表的唯一读者**(core 7.55.0 [ref] P1 阶段二)—— 两条腿同调:耐久腿(`checkpoint-store-face.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行)
  * 与同步腿(`tool-approval.ts` `boundRuleOfferTexts`:活 ask 的 `AskRequest.ruleOffers`)。判官是 core 的 `readRuleOffers`:逐元素判、保原始下标、多余键逐级剥、
  * 闭集词(offer / 成员的 `kind`、`match`)不认 ⇒ 整只丢(batch 不拆成员)、无 `kind` 的存量成员读作 command、明细座不是「每个计数段一行」⇒ 只丢座。
  * 修前本仓自己一份不限长 zod 形,前面垫两只预筛(无 `kind` 成员的回填、明细座的座级筛)—— 读的是 core 铸的形,读法却是本仓一份;core 对两者的 76 种形逐一对过,不同的三种是本仓的明细座行数帽(留在这里)与两种非 JSON 值(数组带属性、类实例)。
@@ -149,15 +149,6 @@ export interface ReadRuleOffer {
  * 缺席(`undefined`)= 没有提议,答空、不计。展示帽(条数、成员前缀、扫描窗)、脱敏与截长归调用方 —— 它们是各腿的展示纪律,不是读法。
  */
 export declare function readRuleOfferList(raw: unknown): readonly ReadRuleOffer[];
-/**
- * 一份(已解码的)规则提议列表里,**带着无 `kind` 存量成员**的 batch offer 有几只 —— 判官是 core `readRuleOffers` 给每只读出的 offer 打的 `kindlessForm` 记号
- * (「这一只 batch 里至少一个成员是经无 `kind` 的存量形读的」;与 {@link readRuleOfferList} 同一只读者,不是本仓自己再写一遍「成员没有 `kind` 键」)。
- * 起服普查(`approval-batch-census.ts`)用它给存量行记数:读者那条存量臂退役的前提是「零行还靠它读」。
- *
- * **只数,不落任何痕迹**:读不出的元素(`dropped`)与整只值不是列表(`problem`)是 {@link readRuleOfferList} 的计数口径(`server.rule-offers.offer-dropped`),这里不重复记,
- * 它们也不是「靠存量臂读出来」的 —— 一个读不出的无 `kind` 成员(缺文本键)退役前后同样被丢,不改变任何一行的读法,所以不计入。
- */
-export declare function countKindlessBatchOffers(raw: unknown): number;
 /**
  * 卡面/帧面共用的 offer **投影型**(= {@link RuleOfferSchema} 的输出形)。判别位 `kind` 上闭集,
  * 消费端(SDK/cli 渲染)按 core 契约分臂;`batch.rules` 成员是判别联合(`command` | `directoryRead`),
@@ -518,7 +509,7 @@ export declare function parkRowFacts(stored: unknown): ParkRowFacts;
  * 本仓**不重算哈希**(core 的 `boundInputHashOf` 不在公开导出面上,清单校验读口 `readBoundBinding` 同样不导出),所以**不许**拿寄存行 `pendingAction` 上的原清单直接投 ——
  * 原值上的清单是未经哈希校验的(这正是它此前不上队列行的原因,见 `trace/core-keyset-guard.ts` ⑧b 记账的旧注)。两只店各自拿到「这一行的摘要」的办法不同
  * (LOCAL 孪生本来就握着 core 对同一行投的摘要;SQL 孪生在判官要的那一次整行读里调 core 的 `summarizeCheckpoint` —— 两位与 `rowVerdict` 同一次读、
- * 同一份按字节摘要的记忆,见 `plugins/checkpoint-store-sql.ts` 的 `storedRowProjections`),
+ * 同一份按字节摘要的记忆,见 `stores-sql/checkpoint-store-sql.ts` 的 `storedRowProjections`),
  * 但投影只有这一只:OMIT 契约 —— 缺席即缺席,恒不铸 `undefined` 值的键。
  *
  * `boundGrants` 是**部署文本**(技能名、清单条目):本函数不脱敏、不转义,与收件箱行逐字同口径 —— 渲染按上下文转义是客户端的事(契约同句)。
@@ -583,13 +574,13 @@ export declare const ApprovalCardSchema: z.ZodObject<{
     governanceForced: z.ZodOptional<z.ZodLiteral<true>>;
     rememberRefused: z.ZodOptional<z.ZodLiteral<true>>;
     approvalCard: z.ZodOptional<z.ZodEnum<{
-        question: "question";
+        shell: "shell";
         plan: "plan";
         skill: "skill";
+        question: "question";
         "file-edit": "file-edit";
         "file-write": "file-write";
         "notebook-edit": "notebook-edit";
-        shell: "shell";
         fetch: "fetch";
         workflow: "workflow";
         generic: "generic";
@@ -761,13 +752,13 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
         governanceForced: z.ZodOptional<z.ZodLiteral<true>>;
         rememberRefused: z.ZodOptional<z.ZodLiteral<true>>;
         approvalCard: z.ZodOptional<z.ZodEnum<{
-            question: "question";
+            shell: "shell";
             plan: "plan";
             skill: "skill";
+            question: "question";
             "file-edit": "file-edit";
             "file-write": "file-write";
             "notebook-edit": "notebook-edit";
-            shell: "shell";
             fetch: "fetch";
             workflow: "workflow";
             generic: "generic";

package/dist/approval-card.js

@@ -64,10 +64,6 @@ export function readRuleOfferList(raw) {
     reading.dropped.forEach((d) => recordOfferDropped(d.problem, d.index));
     return reading.offers.map(withDetailSeatBounded);
 }
-export function countKindlessBatchOffers(raw) {
-    const reading = readRuleOffers(raw);
-    return "problem" in reading ? 0 : reading.offers.filter((o) => o.kindlessForm === true).length;
-}
 function withoutOverCapDetailSeat(item, index) {
     if (typeof item !== "object" || item === null)
         return item;

package/dist/approval-gate-currency.d.ts

@@ -65,7 +65,7 @@
  *  (时刻与方向两处自 core 7.56.0 [ref] 起由筛判:I10 / I11。trace 投影读同一种记录、经同一只筛,零改即得 I10 —— 坏时刻在两个读者那里是同一个答法。)
  */
 import { type Checkpoint, type CheckpointToken, type SettlementKind } from "@sema-agent/core";
-import { type PendingRowBinding } from "./plugins/checkpoint-store-sql.js";
+import { type PendingRowBinding } from "./plugins/checkpoint-store-face.js";
 import { type ParkedGateRead } from "./tool-approval.js";
 /**
  * 决断方回显的「我看到的那道门」—— 门的两个身份面之一(两面的来历与读法见模块头注「`approval_stale` 律」)。

package/dist/approval-gate-currency.js

@@ -1,5 +1,5 @@
 import { REOPEN_REASONS, checkpointRevOf, screenGateOutcome } from "@sema-agent/core";
-import { approvalDecisionOfWinner } from "./plugins/checkpoint-store-sql.js";
+import { approvalDecisionOfWinner } from "./plugins/checkpoint-store-face.js";
 import {} from "./tool-approval.js";
 import { APPROVAL_GATE_KINDS } from "./approval-content-kind.js";
 import { trustedCheckpointId } from "./checkpoint-identity.js";

package/dist/approval-reconciler.d.ts

@@ -1,7 +1,7 @@
 import type { AskRow, ApprovalAskStore } from "./plugins/approval-ask-store-sql.js";
 import type { UnattendedApprovalPolicy } from "./tool-approval.js";
 import type { BatchState } from "./approval-ask-machine.js";
-import type { CheckpointAskCandidate } from "./plugins/checkpoint-store-sql.js";
+import type { CheckpointAskCandidate } from "./plugins/checkpoint-store-face.js";
 import { type RunRecord } from "./plugins/store-contracts.js";
 import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";

package/dist/approval.d.ts

@@ -76,12 +76,12 @@ export declare function gateIntentUnserviceableReason(config: GateIntentView, ch
  * 运维要在 **boot** 就知道,否则会把随之而来的拒绝读成故障。两条 warn 按「ask 从哪来」**划分车道**,互补不重叠:
  *  · `fs_write_gate_no_responder` —— 写门的 Write/Edit ask。它只在**手写本机盘**时才会发生(写门挂在 host
  *    语义上,而 ask 要有手去触发)⇒ 判据 = {@link handsOnWorkerFilePlane}(今天 = `host`)。改前写的是
- *    `remoteExec === undefined || provider === "host"`(门 D R3 同义折):把没有手的 in-process 也算进来,
+ *    `remoteExec === undefined || provider === "host"`(门 D R3 同义折):把没有手的那一形(今名 `none`)也算进来,
  *    那一形上一次 Write ask 都不会发生,warn 是假话;
  *  · `workflow_gate_no_responder` —— `run_workflow` 的 ask,**每条车道都挂**(不以挂手为前提,见
  *    `createWorkflowAskPolicy`)⇒ 判据 = 自编排开着 ∧ **不在上一条的射程里**(上一条的文案已覆盖本机手的车道)。
- *    改前写的是 `remoteExec !== undefined && provider !== "host"` —— 依赖上一条对 in-process 的兜底;
- *    上一条收窄之后,in-process ∧ 自编排 ∧ 无应答面必须由这一条接住(否则整形零告警)。
+ *    改前写的是 `remoteExec !== undefined && provider !== "host"` —— 依赖上一条对无手形的兜底;
+ *    上一条收窄之后,`none` ∧ 自编排 ∧ 无应答面必须由这一条接住(否则整形零告警)。
  */
 export declare function buildNoResponderBootWarns(input: {
     /** 本部署的执行车道(归一读口 `executionLaneOf` 的答案)。 */

package/dist/audit.js

@@ -1,6 +1,6 @@
 import { StoredSession } from "@sema-agent/core";
-import { TiDBSessionStorage } from "./plugins/tidb-session-storage.js";
-import { PgSessionStorage } from "./plugins/pg-session-storage.js";
+import { TiDBSessionStorage } from "./stores-sql/tidb-session-storage.js";
+import { PgSessionStorage } from "./stores-sql/pg-session-storage.js";
 import { LocalSessionWindow } from "./plugins/local-session-window.js";
 import { redactModelText } from "./observability/run-terminal.js";
 import { redactDeepWith } from "./trace/redact.js";

package/dist/bench/s1/live-deps.js

@@ -1,6 +1,8 @@
 import { outwardPlane } from "../../terminal.js";
 import { Runner, runWithVerification, resumeWithVerification, runRepairLoop, combinePolicies, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, } from "@sema-agent/core";
 import { loadConfig } from "../../config.js";
+import { composeDeclaredExecutionLane } from "../../boot/execution-lane.js";
+import { ALL_EXECUTION_LANES } from "../../execution-lane-caps.js";
 import { assertServedModelRoute } from "../../model-route-endpoint.js";
 import { withUnattendedLeg } from "../../unattended-permission-mode.js";
 import { createBrain } from "../../brain.js";
@@ -51,7 +53,7 @@ function buildBrainIngredients(rt) {
         process.env.MODEL_COST_CACHE_READ = String(rt.costCacheRead);
     if (rt.costCacheWrite != null)
         process.env.MODEL_COST_CACHE_WRITE = String(rt.costCacheWrite);
-    const config = loadConfig();
+    const config = composeDeclaredExecutionLane(loadConfig(), { info: () => { } }, { name: "the s1 bench", runs: ALL_EXECUTION_LANES, declares: "none" });
     assertServedModelRoute(config, { envTableIsPlaceholder: false });
     const brain = createBrain(config, {});
     const pricing = buildPricing(config.models);

package/dist/boot/crash-last.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { redactSecrets } from "../trace/redact.js";
+import { OWNER_ONLY_FILE_MODE } from "../plugins/owner-only-file-mode.js";
 const CrashLastSchema = z.object({
     at: z.string(),
     version: z.string(),
@@ -25,7 +26,7 @@ export function writeCrashLast(dataRoot, info) {
             ...(info.inflight !== undefined ? { inflight: info.inflight } : {}),
             err: redactSecrets(firstLine),
         };
-        writeFileSync(crashLastPath(dataRoot), JSON.stringify(body) + "\n");
+        writeFileSync(crashLastPath(dataRoot), JSON.stringify(body) + "\n", { mode: OWNER_ONLY_FILE_MODE });
     }
     catch {
     }

package/dist/boot/deployment-mods.d.ts

@@ -40,11 +40,21 @@ export interface LoadedModPackage {
     /** 读包者交回的三件字节摘要(`ModPackageRegistration.digest`,按给值记)—— 认得出「装的是哪几份字节」,不是代码完整性凭据。 */
     readonly digest: string;
 }
-/** 装配的结果:部署座的注册(自铸在前、声明在后,整列已过引擎准入)与装上的声明包(只数声明的包,自铸的不算)。 */
+/** 装配的结果:部署座的注册(自铸在前、声明在后,整列已过引擎准入)、装上的声明包(只数声明的包,自铸的不算)与部署座的链站点式样。 */
 export interface DeploymentModsAssembly {
     readonly registrations: readonly ModRegistration<EngineDollar>[];
     readonly loaded: readonly LoadedModPackage[];
+    /** 部署座在**任务座之下**挂了链成员(不是观察者)的站点式样 —— 引擎这一次准入的记录读出({@link belowTaskChainPatternsOf})。读者:请求 `settings.hooks` 托管车道的只许收紧判据(`hooks/hook-runner.ts` 的 `managedTightenOnlyOn`)。 */
+    readonly belowTaskChainPatterns: readonly string[];
 }
+/**
+ * 部署座在**任务座之下**挂了链成员的站点式样(去重,按准入序)。「之下」按引擎的跑序读:先按档(`MOD_TIERS` 的序),同档里部署座在任务座之前 ⇒
+ * 只有档排在任务座档之后的部署注册(今天是 `append`)在任务座之下;`prepend` 与同档 `user` 的部署注册在任务座之上(它们先判、再在答回来的结果上判,运维 handler 恒在请求钩子之上)。
+ * 每张准入了的、站在任务座之下的部署注册取 `events`(引擎记下的、它真挂了 handler 的式样)减去 `observe`(那张注册在该式样上只挂了观察者)。
+ * 读的是引擎的准入记录,不是注册自报的 `uses` —— 一处事实一个读法。式样的文法(精确站名或 `<前缀>.*`)由读者按引擎的定义读(`hooks/hook-runner.ts` 的 `chainsBelowTaskOn`)。
+ * 是**上界**:记录不带匹配器,带匹配器的 handler 在不中的那一次派发里不进链(引擎按派发取链)⇒ 读者只拿它收紧、从不拿它换挂法或放宽。
+ */
+export declare function belowTaskChainPatternsOf(records: readonly ModAdmissionRecord[]): readonly string[];
 /** 部署座的唯一装配口(两只起服入口同调;三段与失败见文件头注)。 */
 export declare function assembleDeploymentMods(input: {
     readonly metrics: Pick<Metrics, "inc">;

package/dist/boot/deployment-mods.js

@@ -1,6 +1,6 @@
 import { realpathSync, statSync } from "node:fs";
 import { isAbsolute, relative, sep } from "node:path";
-import { admitModChain, KERNEL_CONTRACT_VERSION, loadModPackage } from "@sema-agent/core";
+import { admitModChain, KERNEL_CONTRACT_VERSION, loadModPackage, MOD_TIERS } from "@sema-agent/core";
 import { createBrandIdentityRegistration } from "../capabilities/brand-identity.js";
 import { createPermissionDeniedMeter, createToolTracer } from "../observability/tool-trace.js";
 import { errorCodeOf, errorText } from "../observability/err-text.js";
@@ -14,6 +14,19 @@ export function createDeploymentMods(input) {
         ...(input.brandIdentity === true ? [createBrandIdentityRegistration()] : []),
     ].map((registration) => ({ ...registration, provenance: MOD_PROVENANCE.minted }));
 }
+const TASK_SEAT_TIER = "user";
+export function belowTaskChainPatternsOf(records) {
+    const out = new Set();
+    const taskTier = MOD_TIERS.indexOf(TASK_SEAT_TIER);
+    for (const r of records) {
+        if (r.seat !== "deployment" || "refusedBy" in r || MOD_TIERS.indexOf(r.tier) <= taskTier)
+            continue;
+        for (const p of r.events)
+            if (!(r.observe ?? []).includes(p))
+                out.add(p);
+    }
+    return [...out];
+}
 export async function assembleDeploymentMods(input) {
     const minted = createDeploymentMods(input);
     const resolved = resolveDeclaredPackages(input.declaration);
@@ -25,7 +38,7 @@ export async function assembleDeploymentMods(input) {
     const loaded = resolved.map(({ pkg }, i) => ({ name: pkg.name, tier: admittedRecordOf(records, pkg.name).tier, contract: KERNEL_CONTRACT_VERSION, digest: declared[i].digest }));
     for (const row of loaded)
         input.logger.info("mods_package_loaded", { name: sanitizeWireText(row.name), tier: row.tier, contract: row.contract, digest: row.digest });
-    return { registrations, loaded };
+    return { registrations, loaded, belowTaskChainPatterns: belowTaskChainPatternsOf(records) };
 }
 function fsCauseOf(e) {
     const code = errorCodeOf(e);

package/dist/boot/device-lane.js

@@ -10,7 +10,7 @@ export function createDeviceLane(ctx) {
         throw new Error("device lane: the device store is wired but the session store carries no execution placement seat — the session↔device binding lives on the " +
             "root session row and is read only through that seat; refusing to start a device lane that could neither bind nor read a binding (assembly bug)");
     }
-    const knobs = config.remoteExec?.provider === "device" ? config.remoteExec : undefined;
+    const knobs = config.remoteExec.provider === "device" ? config.remoteExec : undefined;
     const enrollment = createDeviceEnrollment({
         store,
         seat,
@@ -30,12 +30,14 @@ export function createDeviceLane(ctx) {
         ...(knobs?.reconnectGraceMs != null ? { reconnectGraceMs: knobs.reconnectGraceMs } : {}),
         ...(knobs?.maxInflightPerDevice != null ? { maxInflightPerDevice: knobs.maxInflightPerDevice } : {}),
         ...(knobs?.maxPreAuthPerRemote !== undefined ? { maxPreAuthConnectionsPerRemote: knobs.maxPreAuthPerRemote } : {}),
+        ...(knobs?.trustedProxyCidrs !== undefined ? { trustedProxyCidrs: knobs.trustedProxyCidrs } : {}),
         ...(knobs?.supersede ? { supersede: knobs.supersede } : {}),
     });
     logger.info("device_lane_enabled", {
         replicaId,
         maxInflightPerDevice: knobs?.maxInflightPerDevice ?? 4,
         maxPreAuthPerRemote: knobs?.maxPreAuthPerRemote ?? 8,
+        trustedProxyCidrs: knobs?.trustedProxyCidrs?.length ?? 0,
         enrollRateLimit: `${DEVICE_ENROLL_RATE_POLICY.limit}/${DEVICE_ENROLL_RATE_POLICY.windowMs / 1000}s per caller identity (per replica; independent of RATE_LIMIT_RPM)`,
     });
     return { store, enrollment, hub, seat };
@@ -46,14 +48,14 @@ export function assertDeviceLaneWired(isDeviceLane, lane, hasFactory) {
     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, 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 " +
+            "Refusing to serve a lane that would silently fall back to the engine's stub env with no hands mounted — 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)");
+            "(or declare another lane, e.g. REMOTE_EXEC=none) 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)");
+            "yet `boot/execution-env.ts` produced no factory, so core would fall back to its stub env with no hands mounted. This is " +
+            "an assembly bug, not a configuration one — refusing to start rather than silently run with no execution environment (#157)");
     }
 }
 export async function noteDeviceRelayBindings(relay, store, logger) {

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

@@ -28,7 +28,8 @@
  *     `ENGINE_AUTO_EXIT` / `SEMA_PARENT_PID` 的表态上。
  *  2. **自退判据 = 三合取,且必须持续满 `linger`**(`linger` = 孤儿态 `orphan.lingerMs`,否则 `lingerMs`):
  *       · 附着租约集空(`attachedStreams() === 0`);
- *       · 无在飞 run(`inflight() === 0` —— **与 /health 的 `inflight` 同一只 getter**,不另立第二判据);
+ *       · 无必须等完的活(`inflight() === 0` —— 读 `drainState.blockingInflight` = **阻断集** `http + leader + backgroundAgents`,与排空等的、SIGHUP 空闲窗**同一只**,不另立第二判据;
+ *         `/health.inflight` 是它再加会话驻留的后台 shell / monitor 的**总数**:同一只分项函数 `/health.inflightBreakdown` 派生的两个事实,不是两套计数,见下「已知收窄」);
  *       · HTTP 触点静默(`now() - lastActivityAt() >= lingerMs`),**且**最后一条附着流的**离场**
  *         也已满窗(`now() - lastAttachEndedAt() >= lingerMs` —— codex R1-F1,见该 dep 的注)。
  *     任何一条不满足即把计时清零(连续性判据,不是累计)。
@@ -66,23 +67,101 @@
  *    每 15s 无限期跑下去的定时器 —— 为它引入周期性 SQL 轮询,代价压过收益。**bg run 在跑不退**那一臂
  *    已由 `inflight()` 结构性守住;parked 行是 durable 的,引擎退掉不丢:下次起来仍可赎回(spawn 形里
  *    「下次」就是壳的下一次 spawn)。伤害面 = 一条 parked run 的赎回被推迟到下次启动,不是丢失。
- *    这是**允许的收窄,不是静默**:有了廉价 parked 计数口(或本腿改成事件驱动)之后应当补上。
- *  · **活过父 run 的后台子代理不入判据**(codex R1 [high] 验真后**如实登记**,不是本件引入:[ref] 之前
- *    父死走的是**当场** drain,而 `drainThenShutdown` 读的是同一只 `inflight()` ⇒ 同一个缺口,只是那时
- *    连这 2s 都没有)。`inflight()` 的口径是**本副本的 HTTP 腿 ∪ leader 腿**(`http/server.ts` 的
- *    `inflightRuns`/`steerableRuns`/两只计数器),而 core 侧 `backgroundScope:"session"` 的子代理可以
- *    **活过**生它的那条 HTTP 腿 —— 那之后它在本腿眼里是 0。伤害面 = 壳没了且没人附着时,一条还在跑的
- *    后台子代理会随引擎的受控退被中断(它的账本行照常落终态,不是静默丢)。收口需要一只**廉价**的
- *    「本副本活跃子代理数」读口(与 parked 那条同族:要么 core 给计数,要么本腿改事件驱动),归属
- *    `inflight()` 的属主而不是本腿 —— 在那之前这条收窄**成文在此**,不许再被读成「bg 全被守住」。
+ *    这是**允许的收窄,不是静默**:有了廉价 parked 计数口(或本腿改成事件驱动)之后应当补上。停驻的后台子代理(任务表 `parked`)同一条律、同样不计。
+ *  · **会话驻留的后台 shell / monitor 不入判据**。阻断集 `http + leader + backgroundAgents` 是「还有没有**必须等完**的活」:HTTP 腿(在飞 run 集 · 同步计费腿 ·
+ *    admission 期请求)、leader 腿,以及活过起它的那条 HTTP 腿、仍在跑的后台子代理(core `backgroundScope:"session"`;它是一条在干活的模型腿,干完自己收尾,不等它 = 受控退把它中断)。
+ *    会话驻留的后台 shell / monitor(`session-resident-background.ts` 读;running ∧ 会话驻留 ∧ 非 retain)**报**在 `/health.inflight`(总数)与
+ *    `inflightBreakdown.sessionResident` 里 —— 外部判官据此判「这台引擎此刻托管着多少活」—— 但**不阻断**自退:它不是一条腿,等它没有意义,而一只不退出的 shell
+ *    (`while true`)若阻断,崩溃孤儿引擎就永生(孤儿窗 / SIGHUP 空闲窗同读阻断集,排空也每次等满窗)。窗到 / 排空完成,退出边界的后台收割
+ *    (`reapAllSessionBackground` + 硬面,`boot/exit-boundary.ts`)收掉它们;retain 行按 retain 既有语义活过受控退。伤害面 = 壳没了且没人附着时,引擎照退、
+ *    驻留的进程随受控退被收掉(与 7.145.x 逐字同,只把它报出来)。
+ *  · **活过起它的腿的 workflow 不入判据**:任务表对它只投 `running`,一条腿停在审批门上等人时也是 `running`,读法分不出「在干活」与「在等人」;
+ *    等人的活若阻断,一张没人答的审批就让崩溃孤儿引擎永生(同上一条的病)。伤害面 = 壳没了且没人附着时,一条还在干活的 workflow 随受控退被收掉
+ *    (与 7.146.x 同)。停驻位由 core 任务表投出后按停驻律分(见 `session-resident-background.ts` 头注)。
+ *    (修前后台子代理也在这一条里:它们活过生它的 HTTP 腿之后在本腿眼里是 0,受控退把还在跑的子代理中断 —— 7.147.0 起收进阻断集,这条收窄只剩上面两类。)
  *  · **`/health` 探针不算触点**:`lastActivityAt` 的属主(`http/server.ts` 的 `noteActivity`)按既有契约
  *    把 `/health` 与 `/metrics*` 排除在活性时钟之外(常态采样噪音不得把空闲窗永远撑开)。⇒ 一只**只**
  *    轮询 `/health` 的壳不构成租约。这与 SIGHUP 空闲窗的判据同源,刻意保持一致而非在本腿另开一份。
+ *
+ * ## [ref]:首次附着前的宽限 —— 窗表从两态变三态(判据 / 钟 / 出口都不变;[ref] 起并进下面那张四行车道表)
+ *
+ * 病:壳在 spawn 与**首次接触**之间被饿住(一次性 `-p` 车道 / CI / 高载宿主)超过 owned 窗 ⇒ 一只**从没被碰过**
+ * 的引擎按 owned 窗自退,壳醒来起步失败。收法只改「生效窗 = f(态)」这一张表,不加第二只钟、不加第二条自退路径:
+ *
+ *  | 态(优先级从上到下) | 进入                                     | 生效窗                         |
+ *  |----------------------|------------------------------------------|--------------------------------|
+ *  | 孤儿                 | 装了孤儿车道 ∧ 看门狗已判父死            | `orphan.lingerMs`              |
+ *  | 候首触               | 起服以来还没有过非探针触点 ∧ 非孤儿      | `max(lingerMs, firstAttach.windowMs)` |
+ *  | 已触(owned)        | 有过触点 ∧ 非孤儿                        | `lingerMs`                     |
+ *
+ *  · **首触的唯一属主 = 活性时钟的写者**(`http/server.ts` 的 `noteActivity`,{@link EngineLeaseFirstAttachLane.firstTouchAt}):
+ *    第一个非探针请求(含打开 SSE 流 —— 它本身就是一个非探针请求)写一次就定,之后不回 null ⇒ 态**单向**。探针律不变;
+ *    **在飞不翻态**(boot 赎回的 leader 腿没有客户端到场 —— 它在跑时三合取本就不成立,跑完仍按候首触窗计)。
+ *  · **孤儿压过候首触**:宽限保护的是「父还活着、只是被饿住」的壳;父没了就没人会回来,顶注 7 那句「壳在接触前崩了 ⇒ 孤儿窗内退」不变。
+ *  · **宽限只拉长不缩短**:`max(lingerMs, …)` —— 旋钮 `0`(或任何不大于 owned 窗的值)= 候首触窗落成 owned 窗 = [ref] 前逐字同;
+ *    owned 窗 = `Infinity`(`ENGINE_AUTO_EXIT` 关着)⇒ 候首触窗也是 `Infinity`。
+ *  · **拍频与 `/health.engineLease.lingerMs` 不变**:候首触窗 ≥ owned 窗,不进「最短窗」推导(顶注 9 / [ref])。
+ *
+ * ## [ref]([ref] v3):交接车道 —— 一只车道函数、一张四行表、一只区间、一只谓词
+ *
+ * 「Move to background and exit」:壳经 `POST /v1/engine/handover` 把引擎交给后台、自己退出(不 SIGTERM 引擎);下一只壳 `POST /v1/engine/attach`
+ * 即收回。规则只有一条 —— 车道是闭集 {@link ENGINE_LANES},由 {@link deriveEngineLane} 一处派生(从上到下第一条成立者),每条车道 = 表里一行:
+ *
+ *  | 车道                 | 进入                                   | 窗(唯一选窗处 `windowOf`)            | 后台 shell 计入工作 | SIGHUP 空闲窗 |
+ *  |----------------------|----------------------------------------|----------------------------------------|---------------------|---------------|
+ *  | handover             | 交接口置位(attach 口清位)            | `handover.lingerMs`                    | 是                  | 让位本腿      |
+ *  | orphan               | 装了孤儿车道 ∧ 看门狗已判父死          | `orphan.lingerMs`                      | 否                  | 照旧          |
+ *  | awaitingFirstAttach  | 还没有过非探针触点                     | `max(lingerMs, firstAttach.windowMs)`  | 否                  | 照旧          |
+ *  | owned                | 其余                                   | `lingerMs`                             | 否                  | 照旧          |
+ *
+ *  · **工作谓词一只**({@link laneWork}):附着 > 0 ∨ 在飞 > 0 ∨(本车道计后台 shell ∧ 运行中、引擎一退就会被收掉的后台 shell > 0)。本腿与
+ *    `sighup-idle.ts` 都只调它(读者词 `"lease"` / `"sighup"`);SIGHUP 读者在「让位」那一格恒读到「有工作」—— handover 车道的寿命只归本腿这一只
+ *    定时器,终端关闭不会按另一套谓词 / 另一个窗把引擎拆掉(两只定时器判同一件事 = 两条自退律,顶注 6 那句纪律)。
+ *  · **后台 shell 只在 handover 那一格计入**:owned / orphan 若也计,一只 `while true` 就让崩溃孤儿永生([ref] 倒退)。不是特判,是表里一格的值。
+ *  · **孤儿照旧只由看门狗判**(没有租约集):交接压过孤儿;父已死时 attach ⇒ 回到 orphan(与 [ref]「复用孤儿引擎」同)。壳在交接之后退出不是
+ *    本腿的事件 —— 车道一直是 handover,直到新的 attach。
+ *  · **交接车道与计数读口捆在一起**({@link EngineLeaseHandoverLane},与孤儿车道同理):缺席 ⇒ 门不建、车道结构上不可达。读口 = 退出边界此刻会硬收的
+ *    后台 shell 行数(`boot/exit-boundary.ts` 的 `countShellsExitWouldKill`;数与收同一只 `includeRetained`);装配层只按「非多租户」给,
+ *    不再有「读口缺席」这一态。它**不是** `/health.inflightBreakdown.sessionResident`(那是总数里会话驻留的分项;两问之差见 exit-boundary 那只函数的注)。
+ *  · **窗与拍频**:交接窗进「最短窗」推导(本腿会执行它);判据 / 钟 / 出口(SIGTERM 那条 drain + `exit-last.json`)全不变。
+ *  · 自退读数 `lane` 一键说清那一拍的车道(`orphan` / `firstAttachWindowExpired` 两只布尔随 `exit-last.json` 格式 3 退役 —— 同一事实只留一种读法);
+ *    不变量 `reason !== "idle"` ⟺ `lane === "orphan"`,同一处铸出。
  */
 import type { ParentOrphanReason } from "../parent-watch.js";
 /** 自退检查拍频的**上限**。**不开 env 旋钮**(与 `PARENT_WATCH_INTERVAL_MS` 同纪律:有真需求再议,
  *  防旋钮增殖);实际拍频由顶注 9 的推导取更小者。 */
 export declare const ENGINE_LEASE_TICK_MS = 15000;
+/** [ref] 车道闭集(书写序 = 派生优先序,见 {@link deriveEngineLane})。 */
+export declare const ENGINE_LANES: readonly ["handover", "orphan", "awaitingFirstAttach", "owned"];
+export type EngineLane = (typeof ENGINE_LANES)[number];
+/** 车道表里与配置无关的两列(窗那一列随配置,在 {@link createEngineLeaseTracker} 的 `windowOf` 里一处选)。
+ *  `Record<EngineLane, …>`:加一条车道而这里没跟 ⇒ 编译红。 */
+export interface EngineLaneRow {
+    /** 运行中、引擎一退就会被收掉的后台 shell 计入工作谓词吗。 */
+    readonly countsBackgroundShells: boolean;
+    /** SIGHUP 空闲窗在这条车道上让位本腿吗(让位 = SIGHUP 读者恒读到「有工作」)。 */
+    readonly sighupYieldsToLease: boolean;
+}
+export declare const ENGINE_LANE_TABLE: Readonly<Record<EngineLane, EngineLaneRow>>;
+/** 车道派生 —— **唯一**一处(从上到下第一条成立者;交接压过孤儿,孤儿压过候首触)。三个输入都是持久态。 */
+export declare function deriveEngineLane(s: {
+    readonly handedOver: boolean;
+    readonly orphaned: boolean;
+    readonly touched: boolean;
+}): EngineLane;
+/** 工作谓词的采样输入。`backgroundShells` 惰性:只在本车道计它时才读(那是一次注册表遍历)。 */
+export interface EngineWorkSample {
+    readonly attached: number;
+    readonly inflight: number;
+    readonly backgroundShells: () => number;
+}
+/** 谁在读工作谓词(闭集):本腿 = `"lease"`;SIGHUP 空闲窗 = `"sighup"`。 */
+export type EngineWorkReader = "lease" | "sighup";
+/**
+ * **一只**工作谓词(采样格;活性钟 / 离场钟 / 连续空闲满窗由各读者自己的窗判)。`lane` 缺席 = 租约腿未装配(纯服务器形)或已停 ——
+ * 那时没有任何一行可读,谓词 = 附着 ∨ 在飞(与 [ref] 之前的 SIGHUP 逐字同)。
+ */
+export declare function laneWork(lane: EngineLane | undefined, s: EngineWorkSample, reader: EngineWorkReader): boolean;
 /**
  * 孤儿态读数(装配层把看门狗的 `onOrphaned` 落成这一笔)。
  *
@@ -109,55 +188,142 @@ export interface EngineLeaseOrphanLane {
      *  `null` = 父还活着。 */
     read: () => EngineOrphanState | null;
 }
-/** 自退缘由闭集:`"idle"` = 没人用了(owned 态);另两个词 = 看门狗判的孤儿那两支。
- *  `orphan === (reason !== "idle")` 是不变量 —— 两者在**同一处**铸出(见 {@link createEngineLeaseTracker}),
- *  不存在各算一次的可能。 */
+/**
+ * [ref] 首次附着车道 —— 窗长与读口**捆在一起**(与 {@link EngineLeaseOrphanLane} 同理:平行的两只 dep 会让「配了首窗、却没有
+ * 首触读口」成为一个可表达的状态)。装配层恒给(旋钮恒有值);`windowMs` 为 `0` 即不给额外宽限。
+ */
+export interface EngineLeaseFirstAttachLane {
+    /** 旋钮值(`config.engineFirstAttachMs`;`0` = 关)。生效窗 = `max(lingerMs, windowMs)` —— 由本模块一处算,不在装配层算。 */
+    windowMs: number;
+    /** 首个**非探针** HTTP 触点的单调时刻(`drainState.firstActivityAt`;与 `now` 同为 `performance.now()` 域)。`null` = 还没有过。
+     *  属主 = 活性时钟的写者(写一次就定):本腿只读,不锁存、不另算 —— 首触的判据(探针律)只有那一处。 */
+    firstTouchAt: () => number | null;
+}
+/**
+ * [ref] 交接车道 —— 窗长与后台 shell 计数读口**捆在一起**(与孤儿车道同理:「配了交接窗、却数不了后台 shell」不可表达)。
+ * 装配层只在「非多租户」时给;缺席 ⇒ 把手上没有交接门,handover 车道结构上不可达。
+ */
+export interface EngineLeaseHandoverLane {
+    /** 交接车道的窗(`config.engineHandoverLingerMs`,缺省 30 min)。 */
+    lingerMs: number;
+    /** 此刻运行中、引擎一退就会被收掉的后台 shell 行数(装配层给退出边界的 `shellsExitWouldKill`:与硬收面同一只 `includeRetained`,读不出按 1 计、不抛)。 */
+    backgroundShells: () => number;
+}
+/** 交接的缘由闭集(交接口体的 `reason`)。 */
+export declare const HANDOVER_REASONS: readonly ["background_exit"];
+export type HandoverReason = (typeof HANDOVER_REASONS)[number];
+/** `engine_lane_changed` 的缘由闭集(只由交接门铸:孤儿已有 `parent_watch_orphaned`,首触今天无日志)。 */
+export type EngineLaneChangeReason = "handover_requested" | "attached";
+/** 自退缘由闭集:`"idle"` = 不在孤儿车道;另两个词 = 看门狗判的孤儿那两支。
+ *  不变量 `reason !== "idle"` ⟺ `lane === "orphan"` —— 两者在**同一处**铸出(见 {@link createEngineLeaseTracker})。 */
 export type EngineLeaseExitReason = "idle" | ParentOrphanReason;
 /**
  * 自退那一刻的**判据读数**(一个对象,三个消费者:`engine_lease_auto_exit` 日志行、数据根上的
  * `exit-last.json` 留痕、以及 drain 本身)。一处铸出 ⇒ 日志与留痕永远不会各说各话。
  */
 export interface EngineLeaseExitReport {
-    /** 父已经不在了那一路退的吗(壳的 exit watch 读这一键把 pid 归入**预期**退出)。 */
-    orphan: boolean;
+    /** [ref]:自退那一拍的车道(窗就是按它选的)。 */
+    lane: EngineLane;
     reason: EngineLeaseExitReason;
     /** 真实空闲时长(不是配置的窗长 —— 见顶注 8)。 */
     idleForMs: number;
     attached: number;
     inflight: number;
-    /** 本次**生效**的窗长(孤儿态 = 孤儿窗)。 */
+    /** 本次**生效**的窗长(= 那一拍车道的窗)。 */
     lingerMs: number;
-    /** 成孤儿到自退之间隔了多久;非孤儿退出时键缺席(不编 0)。 */
+    /** 成孤儿到自退之间隔了多久;非孤儿车道退出时键缺席(不编 0)。 */
     orphanedForMs?: number;
 }
 /**
  * [ref] —— 租约窗的 wire 读数(`GET /health` 的 `engineLease`;壳持租约的触点节拍据此定,别处起的短窗引擎不再让第二句失败)。
  *
  * ## 报的是什么
- *  · `lingerMs` = 本腿**会执行的最短静默窗**:父还活着的窗({@link EngineLeaseDeps.lingerMs})与孤儿窗({@link EngineLeaseOrphanLane.lingerMs},只在看门狗装了时存在)取小。
+ *  · `lingerMs` = 本腿**会执行的最短静默窗**:父还活着的窗({@link EngineLeaseDeps.lingerMs})、孤儿窗({@link EngineLeaseOrphanLane.lingerMs},只在看门狗装了时存在)、
+ *    交接窗({@link EngineLeaseHandoverLane.lingerMs},只在交接车道装了时存在)取小。
  *    取**最短**而不是「此刻生效」:此刻生效的窗在父死那一拍从 owned 窗掉到孤儿窗,按旧读数定节拍的壳会在下一次读 `/health` 之前被拆台;
  *    最短窗是配置的性质、不随状态变,壳的触点只要比它密,在任何状态下都留得住引擎。
  *  · `tickMs` = 自退检查的采样拍。自退发生在**生效窗**满之后、至多再晚一拍(顶注 8);生效窗恒 ≥ `lingerMs`(`lingerMs` 是各窗里最短的一个),所以触点比 `lingerMs` 密 ⇒ 在任何状态下都先于自退。
  *    读数**不预言**自退时刻:父还活着时生效的是 owned 窗,自退只会更晚。
+ *  · `lane`([ref])= 此刻的车道(与自退判据同一只派生函数,每次现读)。
  *
  * ## 一源
  * 与租约腿自己的行为同一处铸出:`engine_lease_armed` 日志、自退判据用的窗、拍频推导(`tickMs = min(15s, 最短窗)`)和本读数读的是同一组数 ——
- * 不存在第二处去「算一遍租约窗」。一个永远不到期的窗(owned 窗 = `Infinity` 且没有孤儿车道)不是租约:读数整个缺席,不补 0、不把 `Infinity` 送进 JSON。
+ * 不存在第二处去「算一遍租约窗」。一个永远不到期的窗(owned 窗 = `Infinity` 且没有孤儿 / 交接车道)不是租约:读数整个缺席,不补 0、不把 `Infinity` 送进 JSON。
  */
 export interface EngineLeaseFacts {
     readonly lingerMs: number;
     readonly tickMs: number;
+    /** [ref]:此刻的车道。 */
+    readonly lane: EngineLane;
+    /** [ref] 首窗格({@link EngineLeaseFirstAttachFacts}):候首触窗有限(owned 窗有限)才在场 —— 永不到期的窗不上 wire(同上一段那条律)。 */
+    readonly firstAttach?: EngineLeaseFirstAttachFacts;
+    /** [ref] 交接格({@link EngineHandoverFacts}):只在 handover 车道在场。 */
+    readonly handover?: EngineHandoverFacts;
+}
+/**
+ * [ref] —— `GET /health` 的 `engineLease.firstAttach`:首次附着前的宽限窗。
+ *
+ *  · `windowMs` = **生效**的候首触窗 `max(owned 窗, ENGINE_FIRST_ATTACH_MS)`(解析后的真值,不是旋钮回声;旋钮 `0` ⇒ 等于 owned 窗)。
+ *  · `since` = 窗开始的时刻(装配那一拍,epoch ms)。父一直活着且一直没人碰时,`since + windowMs` 是「最早何时自退」的**下界**,不是预言 —— 父死之后孤儿窗优先、可以更早退
+ *    (那一态的窗看同一格的 `lingerMs`:最短窗已含孤儿窗;本格在孤儿态照旧在场,codex 对抗审 F2 成文);
+ *    候首触期间有在飞会让它后移,另有至多一拍的采样滞后(顶注 8)。没有单列 `until` —— 它可由这两格推出(一个事实一处读)。
+ *  · `attachedAt` = 首个非探针触点的时刻(epoch ms);`null` = 还在候首触。非 null ⇒ 首窗已永久关闭(单向)。
+ *  · 两个时刻是**同一只单调钟**的投影:装配时只采一次挂钟作锚,`epoch = since + (单调时刻 − 装配单调时刻)`。不跑第二只钟;系统改钟之后它与真实期限会漂开(成文)。
+ */
+export interface EngineLeaseFirstAttachFacts {
+    readonly windowMs: number;
+    readonly since: number;
+    readonly attachedAt: number | null;
+}
+/**
+ * [ref] —— 交接格(`GET /health` 的 `engineLease.handover`;交接口 200 体 = 其中 `since` / `lingerMs` / `backgroundShells` 三键加 `lane`)。
+ *  · `since` = 进入交接车道的时刻(epoch ms,与首窗格同一只单调钟投影);幂等的再次交接回同一个值。
+ *  · `lingerMs` = 交接窗;`backgroundShells` = 退出边界此刻会硬收的后台 shell 行数(现读)。窗只在它为 0、阻断集在飞为 0、且无附着与触点时起算。
+ *  · 不带在飞数:阻断集在同一份 `/health` 里已由 `inflightBreakdown.http + leader + backgroundAgents` 读出(一个事实一处读);交接口 200 体若带它,读到的恒含这次请求自己。
+ */
+export interface EngineHandoverFacts {
+    readonly since: number;
+    readonly reason: HandoverReason;
+    readonly lingerMs: number;
+    readonly backgroundShells: number;
+}
+/** 交接口的应答(200 体):`lane` 恒 `"handover"` + 交接格里的三键。 */
+export interface EngineHandoverEntry {
+    readonly lane: "handover";
+    readonly since: number;
+    readonly lingerMs: number;
+    readonly backgroundShells: EngineHandoverFacts["backgroundShells"];
+}
+/** attach 口的应答(200 体):清位之后的车道;`handedOverForMs` 只在这一次 attach 真的清掉了交接位时在场。 */
+export interface EngineAttachAnswer {
+    readonly lane: EngineLane;
+    readonly handedOverForMs?: number;
+}
+/**
+ * [ref] 交接门 —— 本腿交给装配层(经排空盒子到两只 HTTP 口)的**唯一**写口。只在交接车道装了时存在。
+ * `observing` = 腿还在观察(停了 ⇒ 能力事实答不可用;两口不再写)。
+ */
+export interface EngineHandoverDoor {
+    readonly observing: boolean;
+    /** 置交接位(幂等:已在 handover ⇒ 回同一个 `since`,不再打日志)。 */
+    enter(reason: HandoverReason): EngineHandoverEntry;
+    /** 清交接位(不在 handover ⇒ 照回此刻车道)。 */
+    attach(): EngineAttachAnswer;
 }
 /** {@link createEngineLeaseTracker} 的把手:`stop()` 收摊;`facts` 现读 —— **腿还在观察**时才有(收摊 / 自退触发之后缺席,says-yes ⟺ 腿在转)。 */
 export interface EngineLeaseHandle {
     stop(): void;
     readonly facts: EngineLeaseFacts | undefined;
+    /** [ref]:此刻的车道(腿在观察才有;SIGHUP 读者经它读同一只车道函数)。 */
+    lane(): EngineLane | undefined;
+    /** [ref]:交接门(交接车道装了才有)。 */
+    readonly handover?: EngineHandoverDoor;
 }
 export interface EngineLeaseDeps {
     /** 活附着数 = 本副本当前**打开着的 SSE 流**条数(`drainState.attachedStreams`,由 `createHttpServer` 自赋)。 */
     attachedStreams: () => number;
-    /** 在飞腿数 —— **`/health` 的 `inflight` 同一只 getter**(`drainState.inflight`)。不自建第二套计数:
-     *  两套计数迟早分叉,而分叉的那一侧恰好是「以为没 run 了」就把引擎关掉。 */
+    /** 必须等完的活的数 —— **阻断集** `drainState.blockingInflight`(`http + leader + backgroundAgents`;与排空等的、SIGHUP 空闲窗同一只 getter。会话驻留的后台 shell / monitor 在
+     *  `/health.inflight` 的总数里、不在这里,见顶注「已知收窄」)。不自建第二套计数:两套计数迟早分叉,而分叉的那一侧恰好是「以为没 run 了」就把引擎关掉。 */
     inflight: () => number;
     /** 最后一次**非探针** HTTP 触点的单调时刻(`drainState.lastActivityAt`)。
      *  ⚠️ 时基契约:必须与本模块的 `now` 同为 `performance.now()` 单调域(`server.ts` 的打点即该域)——
@@ -180,8 +346,12 @@ export interface EngineLeaseDeps {
     /** owned 态(父还活着 / 没被监视)下三合取**持续**满这么久才触发(`config.engineLingerMs`,默认 60s)。
      *  **`Infinity`** = 永不自退(`ENGINE_AUTO_EXIT` 关着的 owned 引擎;窗永远追不上 ⇒ 无需第二条分支)。 */
     lingerMs: number;
-    /** 孤儿车道(`SEMA_PARENT_PID` 在场才给)。缺席 ⇒ 这台引擎不可能成孤儿,窗恒为 `lingerMs`。 */
+    /** 孤儿车道(`SEMA_PARENT_PID` 在场才给)。缺席 ⇒ 这台引擎不可能成孤儿。 */
     orphan?: EngineLeaseOrphanLane;
+    /** [ref] 首次附着车道(恒给;见 {@link EngineLeaseFirstAttachLane})。 */
+    firstAttach: EngineLeaseFirstAttachLane;
+    /** [ref] 交接车道(非多租户才给;见 {@link EngineLeaseHandoverLane})。缺席 ⇒ 把手上没有交接门。 */
+    handover?: EngineLeaseHandoverLane;
     log: (event: string, fields: Record<string, unknown>) => void;
     /** 检查拍频 seam(测试)。缺省 = 顶注 9 的推导(`min(ENGINE_LEASE_TICK_MS, 本腿可能执行的每个窗)`)。 */
     tickMs?: number;
@@ -189,6 +359,9 @@ export interface EngineLeaseDeps {
      *  拉长 linger 窗 —— 前跳把窗直接跳过去 = 在一只还有人用的引擎底下提前关停。 */
     now?: () => number;
 }
+/** 后台 shell 计数在没有交接车道时**结构上读不到**(只有 handover 那一格读它,而 handover 车道只经交接门进入,门只在车道装了时建)。
+ *  真被读到 = 不变量破了 —— 响亮抛,不回一个看起来合理的 0([ref])。 */
+export declare const backgroundShellsUnreachable: () => number;
 /** 装配并**立刻**起自退检查(装配即 `engine_lease_armed`)。返回停机链用的 `stop()`。 */
 export declare function createEngineLeaseTracker(deps: EngineLeaseDeps): EngineLeaseHandle;
 //# sourceMappingURL=engine-lease.d.ts.map