@sema-agent/server 7.141.0 → 7.143.0

package/dist/http/run-read-face.js

@@ -1,13 +1,19 @@
 import { persistedPlaneOf } from "../terminal.js";
-import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, sealRunRowResult } from "../observability/run-terminal.js";
+import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, sealStoredRunRowResult } from "../observability/run-terminal.js";
 import { RUN_HOLDER_DEATH_CODES, isTerminalRunStatus } from "../plugins/store-contracts.js";
 import { composeSupervisorCost, infraCost, infraUsageFromEvents, hasInfraPricing } from "../observability/cost-taxonomy.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { readTurnActivityMs } from "../turn-activity.js";
 import { buildCrossSliceUsage, readResourceWindow } from "../resource-window.js";
+export function runRowStale(deps, run) {
+    return run.status === "running" && Date.now() - new Date(run.updatedAt).getTime() > deps.config.runStaleSec * 1000;
+}
+export function runRowExitResult(run) {
+    return isTerminalRunStatus(run.status) ? memoRedactTerminalResult("run.result", run.result ?? undefined) : (sealStoredRunRowResult(run.result ?? null, "run.result") ?? undefined);
+}
 export async function readRunFace(deps, runStore, run) {
     const taskId = run.taskId;
-    const stale = run.status === "running" && Date.now() - new Date(run.updatedAt).getTime() > deps.config.runStaleSec * 1000;
+    const stale = runRowStale(deps, run);
     const infraRates = deps.config.infraCostRates;
     const needCost = Boolean(run.result?.stats && !stale && infraRates && hasInfraPricing(infraRates));
     const needSuggestions = !stale && run.status === "completed";
@@ -53,7 +59,7 @@ export async function readRunFace(deps, runStore, run) {
         status: stale ? "failed" : run.status,
         ...(lastActivityAt !== undefined ? { msSinceLastActivity: Math.max(0, Date.now() - lastActivityAt) } : {}),
         ...(crossSliceUsage !== undefined ? { crossSliceUsage } : {}),
-        result: isTerminalRunStatus(run.status) ? memoRedactTerminalResult("run.result", run.result ?? undefined) : (sealRunRowResult(run.result ?? null, "run.result") ?? undefined),
+        result: runRowExitResult(run),
         supervisorCost,
         suggestions,
         errorCode: stale ? RUN_HOLDER_DEATH_CODES.stalled : (persistedPlaneOf(run.result).errorCode ?? run.errorCode ?? undefined),

package/dist/http/send.d.ts

@@ -123,6 +123,11 @@ export declare function sendSessionPolicyError(res: ServerResponse, e: unknown,
  * (路径只进运维面:`server.session-repo.corrupt-record-skipped` 的探针行,[ref];SQL 两店走各自的拒绝句)。
  */
 export declare function sendSessionError(res: ServerResponse, e: unknown, face: SessionErrorFace): boolean;
+/**
+ * 全局兜底的 open 面一臂(`http/server.ts`:路由里逃出来的、不是 `HttpError` 的故障)—— 码经 {@link openFaceFaultWire}(会话列表行的 `unreadable` 同读这一只:
+ * 列表说的码就是读口答的码,`session-error-wire.ts` 头注「一张表、两个读者」)。有臂的 `SessionError` 同 {@link sendSessionError};其余落通用 500,固定句。
+ */
+export declare function sendOpenFaceFault(res: ServerResponse, e: unknown): void;
 export declare function msg(e: unknown): string;
 /**
  * 路由抛出的未归类错误的运维行 `request_error` —— **唯一写者**。外层兜底(`server.ts`)与「就地经映射下发」的站点(会话同步的暂存提交 catch)同调它:

package/dist/http/send.js

@@ -1,6 +1,6 @@
 import { SessionError, SessionPolicyError } from "@sema-agent/core";
 import { sessionPolicyErrorFacts, sessionPolicyErrorHttp, sessionPolicyErrorSentence } from "../session-policy-wire.js";
-import { sessionErrorWireOf } from "../session-error-wire.js";
+import { openFaceFaultWire, sessionErrorWireOf } from "../session-error-wire.js";
 import { redactErrorMessage, redactHead } from "../observability/run-terminal.js";
 import { createCodedHttpError } from "../security.js";
 import { refusalBody } from "./refusal-body.js";
@@ -82,9 +82,16 @@ export function sendSessionError(res, e, face) {
     const wire = sessionErrorWireOf(e, face);
     if (wire === undefined)
         return false;
-    sendError(res, wire.status, wire.errorCode, wire.sentence ?? redactErrorMessage(e.message) ?? "session store error", wire.detail === undefined ? undefined : { detail: wire.detail });
+    sendSessionWire(res, e, wire);
     return true;
 }
+export function sendOpenFaceFault(res, e) {
+    sendSessionWire(res, e, openFaceFaultWire(e));
+}
+function sendSessionWire(res, e, wire) {
+    const sentence = wire.sentence ?? (e instanceof SessionError ? redactErrorMessage(e.message) : undefined) ?? "session store error";
+    sendError(res, wire.status, wire.errorCode, sentence, wire.detail === undefined ? undefined : { detail: wire.detail });
+}
 export function msg(e) {
     return e instanceof Error ? e.message : String(e);
 }

package/dist/http/server.d.ts

@@ -12,7 +12,7 @@ import type { PeerDesk, PeerLease } from "../peer-seat.js";
 import type { ExecutionRoot, ResolvedTaskSpec } from "./execution-context.js";
 import type { RunStore, ImageIndex, ImageBake, CheckpointStoreFull, ResumeAnchorStore, ApprovalExemptionStore, ApprovalNonceStore, ServiceSessionPolicyStore, ServiceFileHistoryStore, ToolResultStoreFull, StoreBackend } from "../plugins/store-backend.js";
 import type { RuleConsentLane } from "../rules-consent.js";
-import { type MemorySyncRequest, type MemorySyncResponse } from "../memory-sync.js";
+import { type MemorySyncAnswer, type MemorySyncRequest } from "../memory-sync.js";
 import type { MemorySyncRunner } from "../memory-sync-client.js";
 import type { TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { LeaderEndpoint } from "../leader/endpoint.js";
@@ -38,6 +38,7 @@ import { cascadeConfig } from "./run-meta.js";
 export { cascadeConfig };
 import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
+import type { SessionNotifyDoor } from "../session-notify-door.js";
 import { MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
 import { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath } from "./route-table.js";
 export { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, hasServiceAuth };
@@ -139,11 +140,11 @@ export interface ServiceCoreDeps {
         execution: ExecutionRoot;
     }) => ResolvedTaskSpec | Promise<ResolvedTaskSpec>;
     /**
-     * [ref] 场景 hands lane 选路:按 `resolveSpec` 刚产出的 TaskSpec 取本任务的执行 Runner。
-     * 装配点(`boot/stage-10-http-server.ts`)传的是 `createHandsRunnerSelector` —— 选路规则只有那一份实现,
-     * 本层不解释场景,只取用。
+     * [ref] 场景 hands lane 选路:按 `resolveSpec` 刚产出的那一只对象取本任务的执行 Runner —— 两只漏斗(受理 / 续跑)在盖根复制
+     * (`stampSpecRoot`)之前以装配输出调它,不交复制品。装配点(`boot/stage-10-http-server.ts`)传的是 `createHandsRunnerSelector`
+     * (读这条腿的部署事实里的车道,`leg-facts.ts`)—— 选路规则只有那一份实现,本层不解释场景,只取用。
      * 🔴 **必填**([ref],7.105.0):修前这一席可选,缺席 ⇒ 静默落 {@link ServiceDeps.runner} —— 最宽的那只
-     * (带全量手的主 Runner)。而同一轴上「车道**字段**缺席」早已是拒([ref],`handsLaneOf` 抛
+     * (带全量手的主 Runner)。而同一轴上「车道读不到」早已是拒(选路器抛
      * `HandsLaneUnstampedError`),席缺席回落最宽 = 同一件事两条律。现在缺席是**编译错**;绕过类型
      * (JS 嵌入方 / `as` 硬转)造的 deps 在 {@link createHttpServer} 入口**拒启**。单 Runner 的嵌入方显式传
      * `runnerFor: () => runner` —— 那是一句表态,不是一个回落。
@@ -464,7 +465,8 @@ export interface ServiceSeamDeps {
     }>;
     /** 142-S5 §1.4: per-scope memory export reader (main.ts wires `exportMemoryScope` over the DB memory
      *  backend). Enables GET /v1/memory/export — present ONLY on a DB memory plane (MEMORY_ENGINE_BACKEND=
-     *  pg|mysql); absent / file posture ⇒ 501 (single-user file memory exports by copying the memory dir). */
+     *  pg|mysql); absent ⇒ 501 (single-user file memory exports by copying the memory dir). The gate and the capability bit
+     *  `memoryExport` read ONE fact (`capability-facts.ts` `memoryExport`) — whether this face is wired, never the backend name. */
     memoryExport?: (scope: string) => Promise<MemoryEntry[]>;
     /**
      * [ref](core 5.57.0 `routePairingStatus`)—— **key↔URL 配对读面**:`GET /v1/models` 每行的
@@ -479,10 +481,12 @@ export interface ServiceSeamDeps {
     routeJudgeBrain?: Pick<Brain, "adjudicateRoute">;
     /** 142-S2.5(设计 §2.5;裁定 plan 随数据走,core 零运行时半场):one full sync round for one
      *  (scope, peer) — main.ts wires `performMemorySync` over the DB memory backend + the sync-cursor
-     *  store. Enables POST /v1/memory/sync/:scope — present ONLY on a DB memory plane
-     *  (MEMORY_ENGINE_BACKEND=pg|mysql); absent / file posture ⇒ 501 honestly (a single-user file plane
-     *  IS the TOC side of a sync — it has no central-authority half to serve). */
-    memorySync?: (scope: string, syncReq: MemorySyncRequest) => Promise<MemorySyncResponse>;
+     *  store. Enables POST /v2/memory/sync/:scope — present ONLY on a DB memory plane
+     *  (MEMORY_ENGINE_BACKEND=pg|mysql); absent ⇒ 501 honestly (a single-user file plane
+     *  IS the TOC side of a sync — it has no central-authority half to serve). [ref]: the face also needs the center's
+     *  declared sync identity (`config.memorySyncServeIdentity`) — the gate and the capability bit `memorySyncServe` read ONE
+     *  fact (`capability-facts.ts` `memorySyncServe`). */
+    memorySync?: (scope: string, syncReq: MemorySyncRequest) => Promise<MemorySyncAnswer>;
     /** [ref] v2-c(core 5.40.0 `MemoryEngine.exportMemoryScopes`):治理完备包的**携出**面。main.ts 把它接到
      *  装配好的 memory engine 上。启用 `POST /v1/memory/export`(operator-only)。
      *  🔴 缺席 = 这个部署**没有记忆引擎**(`MEMORY_ENGINE=off` / 多租 file 底座等暗态)⇒ 501
@@ -538,8 +542,10 @@ export interface ServiceSeamDeps {
      * [ref] —— 本**部署**的记忆同步腿(客户端半场):`MEMORY_SYNC_URL` 设了且 file 记忆引擎亮着、执行器起了才在场(`boot/stores.ts`)。
      * `GET /v1/sessions/:id/memory-status` 的 `memorySync` 格只读它的 `parked()` —— 停驻事实的唯一读口(写者 = 执行器的轮,运维行 `memory_sync_layer_parked` 读同一份);
      * 缺席 ⇒ 那一格缺席(没有同步腿)。与 `memoryAutoConsolidationArmed` 同类:部署事实,不随会话、不随层座。
+     * [ref]:会话记忆同步触发口(`POST /v1/sessions/:id/memory/sync`)读它的 `peer`(目标比对)与 `syncOnce`(一轮,交回每层每次调用;从不 reject)——
+     * 能力事实 `sessionMemorySync` 的第一格就是它在不在。
      */
-    memorySyncLeg?: Pick<MemorySyncRunner, "parked">;
+    memorySyncLeg?: Pick<MemorySyncRunner, "parked" | "peer" | "syncOnce">;
     /**
      * [ref] / [ref] + 车PI 修复轮 ④ —— 记忆整理阀门的**生效判决**(boot 第 4 段 `createConsolidationValve`:显式词,或出厂缺省按
      * 装配结果派生)。配置目录那一行(`GET /v1/config/catalog` 的 `MEMORY_CONSOLIDATION_DRIVER` `effectiveValue`)读它 —— 那一列的契约是
@@ -698,10 +704,11 @@ export interface ServiceDeploymentDeps {
     /** [ref] ②:caps `centerWiring` 的读面(`capabilities/center-wiring.ts` `createCenterWiringReader`;入参 = 请求的已验 principal)。
      *  缺席 = 没接中心(或测试夹具)⇒ 键整个缺席。 */
     centerWiring?: (principal: string | undefined) => import("../capabilities/center-wiring.js").CenterWiring;
-    /** The member git-credential plane's one reading (`sandbox-git-plane.ts`; stage 5 computes it once — config premises + the boot's secret
-     *  seat answer + the static patch judge). Caps `credentialPlane.sandboxGit` projects it as is. Absent = not built by the composition root
-     *  (a fixture) ⇒ the same judge on config alone, the seat counted as not asked. */
-    sandboxGitPlane?: import("../sandbox-git-plane.js").SandboxGitPlane;
+    /** The member git-credential plane's read function (`sandbox-git-plane.ts` `createSandboxGitPlaneSeat`'s `now`: the judge over the boot readings — the
+     *  secret seat answer stage 5 settles, the static patch judge — and the live config, whose `sandboxGit` block hot-swaps with each effective-config commit).
+     *  Caps `credentialPlane.sandboxGit` calls it on every read and projects the answer as is. Absent = not built by the composition root (a fixture) ⇒
+     *  the same judge on config alone, the seat counted as not asked. */
+    sandboxGitPlane?: () => import("../sandbox-git-plane.js").SandboxGitPlane;
     /**
      * 本进程起服装上的**运维声明** mod 包数(部署座装配口 `assembleDeploymentMods` 的 `loaded.length`;本服务自铸的注册不算)。一个事实两个出口,同读这一格:
      * `/health` 的 `mods: { deploymentPackages }` 与 `/v1/capabilities` 的 `modsDeploymentPackages: true` —— 都只在 > 0 时在场;0 / 缺席(没声明,或不是由
@@ -761,6 +768,9 @@ export interface ServiceDeploymentDeps {
      *  `candidateRejectionState: () => webAdmin.candidateRejectionState()`;座 = web-admin 的 `candidateRejection`,`config_candidate_rejected` 日志行的去重键读同一份)。
      *  present-iff 当前生效配置是因候选被拒而回落的那一份;缺席 / 返回 undefined = 没有被拒的候选或没有配置管道 ⇒ `GET /v1/models` 不出该键(additive)。 */
     candidateRejectionState?: () => import("../web-admin-client/candidate-gate.js").CandidateRejection | undefined;
+    /** `GET /v1/models.modelPlane.planeRefusalCode` 与 `catalog` 模型面那一半的取值口(`boot/stage-10-http-server.ts` → `latestPlaneRefusalState: () => webAdmin.latestPlaneRefusalState()`):
+     *  最新到达的目录候选被模型面组拒的码。缺席 / 返回 undefined = 最新到达的候选没有被模型面组拒,或没有配置管道 ⇒ 读面不出该键。 */
+    latestPlaneRefusalState?: () => import("@sema-agent/settings-schema").ModelPlaneRefusalCode | undefined;
     /** `/health.configHandoff`(只上 `/health`):在场 ⇔ 部署声明了耐久接力 ∧ 应用着的那一代没被确认(web-admin 接力账的 `configHandoffState()`;合成律
      *  `fleet/engine-signal.ts` 的 `buildConfigHandoff`)。缺席 / 返回 undefined = 有接力、没有中心或本地腿 ⇒ 键缺席。 */
     configHandoffState?: () => import("../fleet/engine-signal.js").ConfigHandoff | undefined;
@@ -911,6 +921,8 @@ export declare function createHttpServer(rawDeps: ServiceDeps): http.Server & {
     isRunLiveOnThisReplica: (taskId: string) => boolean;
     /** [ref]:live 回决腿的 PARKED 赎回席(装配层把它接进协调器的晚绑座,见 {@link redeemParkedAsk})。 */
     redeemParkedAsk: ParkedAskRedeem;
+    /** 会话通知门(装配层把它接进场景层后台完成 sink 的晚绑座;门与律见 `session-notify-door.ts`)。 */
+    sessionNotifyDoor: SessionNotifyDoor;
 };
 /** SSE: replay durable events after Last-Event-ID, then tail until the run is terminal (or stale). */
 /**

package/dist/http/server.js

@@ -18,7 +18,7 @@ import { cascadeConfig } from "./run-meta.js";
 export { cascadeConfig };
 import { coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
-import { sendError, sendHttpError, sendSessionError, logRequestError } from "./send.js";
+import { sendError, sendHttpError, sendOpenFaceFault, logRequestError } from "./send.js";
 import { createRequestGuards } from "./request-guards.js";
 import { sqlEngineSeatIssue } from "../sql-engine-posture.js";
 import { parkDecisionStoreRefusal } from "../orchestration/workflow-park-decision.js";
@@ -152,7 +152,7 @@ export function createHttpServer(rawDeps) {
     }
     const { quotaExceeded, ownerCostQuotaDenied, ownerFleetLeaseDenied, ownerLeaseDenied, ownerQuotaDenied, leaseDenied, usageWindowDenialFor, usageWindowDenied, rateLimited, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk, readJson, readRawBody } = createRequestGuards({ deps });
     const { prepareSpec } = createAdmission({ deps, readJson, runnerFor });
-    const { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, mayDiscloseRowError, resumePreempted, startFreshHostTurn, resumeWake } = createResumeLegs({ deps, runnerFor, idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints, counters, readJson, readRawBody, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, usageWindowDenied, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk, prepareSpec, finalizeTaskResult, ownerCostQuotaDenied, ownerFleetLeaseDenied, usageWindowDenialFor });
+    const { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, mayDiscloseRowError, resumePreempted, startFreshHostTurn, resumeWake, sessionNotifyDoor } = createResumeLegs({ deps, runnerFor, idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints, counters, readJson, readRawBody, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, usageWindowDenied, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk, prepareSpec, finalizeTaskResult, ownerCostQuotaDenied, ownerFleetLeaseDenied, usageWindowDenialFor });
     const { denyExpiredApprovals, redeemParkedAsk } = createApprovalSweeps({ deps, resumeCheckpoint, mayDiscloseRowError });
     const { handle } = createDispatch({ deps, noteActivity, routeCtxBase, counters });
     const server = http.createServer((req, res) => {
@@ -169,13 +169,11 @@ export function createHttpServer(rawDeps) {
                 res.end();
                 return;
             }
-            if (sendSessionError(res, err, "open"))
-                return;
             if (err instanceof SessionForkInProgressError) {
                 sendError(res, 409, err.code, err.message);
                 return;
             }
-            sendError(res, 500, "internal.error", "internal error");
+            sendOpenFaceFault(res, err);
         });
     });
     const deviceLane = facts.deviceLane(deps);
@@ -208,6 +206,6 @@ export function createHttpServer(rawDeps) {
         deps.planCacheProbe?.record(principal, objective, result.terminal.kind === "completed");
     }
     const isRunLiveOnThisReplica = (taskId) => inflightRuns.has(taskId) || steerableRuns.has(taskId);
-    return Object.assign(server, { denyExpiredApprovals, isRunLiveOnThisReplica, redeemParkedAsk });
+    return Object.assign(server, { denyExpiredApprovals, isRunLiveOnThisReplica, redeemParkedAsk, sessionNotifyDoor });
 }
 //# sourceMappingURL=server.js.map

package/dist/http/stored-body-replay.js

@@ -1,4 +1,4 @@
-import { REQUEST_SETTINGS_REFUSAL_PREFIX, SETTINGS_RULE_REFUSAL_CODE, neverAutoNamesRefusal, rulePolicyBucketsRefusal, settingsPermissionBucketIssue, storedBodyPermissionMode } from "../task-settings.js";
+import { REQUEST_SETTINGS_REFUSAL_PREFIX, SETTINGS_PERMISSION_BUCKETS, SETTINGS_RULE_REFUSAL_CODE, neverAutoNamesRefusal, rulePolicyBucketsRefusal, settingsPermissionBucketIssue, storedBodyPermissionMode } from "../task-settings.js";
 import { readTightenOnlySeats, tightenOnlySeatField, tightenOnlySeatIssue } from "../tighten-only-seats.js";
 import { entryProblemsFacts } from "../entry-problems.js";
 import { autonomyModeFloor, entryPermissionMode } from "../runtime-governance.js";
@@ -15,6 +15,11 @@ export function permissionModeReadingUnstated(ctx, floor) {
 }
 const RETIRED_KEY_REWRITE_MIGRATION = { promptProfile: "M30" };
 const BUCKET_GATE_CODE = "request.field_invalid";
+const BUCKET_SIDE = {
+    "settings.permissions.allow": "allow",
+    "settings.permissions.deny": "deny",
+    "settings.permissions.ask": "deny",
+};
 function storedPermissions(body) {
     const permissions = body?.settings?.permissions;
     return permissions !== null && typeof permissions === "object" && !Array.isArray(permissions) ? permissions : undefined;
@@ -23,7 +28,7 @@ function storedPermissionBucketRefusal(body) {
     const issue = settingsPermissionBucketIssue(storedPermissions(body));
     if (issue === null)
         return undefined;
-    return replayInertEntry(issue.fields.field, issue.fields.field === "settings.permissions.allow" ? "allow" : "deny", BUCKET_GATE_CODE, issue.message, { ...issue.fields });
+    return replayInertEntry(issue.fields.field, BUCKET_SIDE[issue.fields.field], BUCKET_GATE_CODE, issue.message, { ...issue.fields });
 }
 function storedTightenOnlySeatRefusal(body) {
     const issue = tightenOnlySeatIssue(body?.settings);
@@ -37,9 +42,15 @@ function storedRulePolicyRefusal(body, deployment) {
         return undefined;
     const home = executionLaneHomeDir(deployment);
     const configRoot = executionConfigRootOf(deployment);
-    const refused = rulePolicyBucketsRefusal({ ...(Array.isArray(permissions["ask"]) ? { ask: permissions["ask"] } : {}), ...(Array.isArray(permissions["deny"]) ? { deny: permissions["deny"] } : {}) }, { ...(home !== undefined ? { home } : {}), ...(configRoot !== undefined ? { configRoot } : {}) });
+    const buckets = {};
+    for (const bucket of SETTINGS_PERMISSION_BUCKETS) {
+        const entries = permissions[bucket];
+        if (Array.isArray(entries))
+            buckets[bucket] = entries;
+    }
+    const refused = rulePolicyBucketsRefusal(buckets, { ...(home !== undefined ? { home } : {}), ...(configRoot !== undefined ? { configRoot } : {}) });
     if (refused !== undefined)
-        return replayInertEntry(`settings.permissions.${refused.bucket}`, "deny", SETTINGS_RULE_REFUSAL_CODE, `${REQUEST_SETTINGS_REFUSAL_PREFIX}${refused.message}`, { ...entryProblemsFacts(refused.problems) });
+        return replayInertEntry(`settings.permissions.${refused.bucket}`, BUCKET_SIDE[`settings.permissions.${refused.bucket}`], SETTINGS_RULE_REFUSAL_CODE, `${REQUEST_SETTINGS_REFUSAL_PREFIX}${refused.message}`, { ...entryProblemsFacts(refused.problems) });
     const neverAuto = readTightenOnlySeats({ permissions }).values.neverAuto;
     if (neverAuto === undefined)
         return undefined;

package/dist/http/submit-replay.d.ts

@@ -18,9 +18,10 @@
  *
  * ## 回执两形(按提交腿)
  *  · `durable`(`POST /v1/runs`、A2A `message/send`)—— `202 { taskId, sessionId, status }`(这条腿首答的既有形);
- *  · `sync`(`POST /v1/tasks`;`/v1/tasks/stream` 把同一份体放进 `done.result`)—— `200 { …run 行读面, replay: true }`
- *    (读面 = `GET /v1/runs/:id` 的 200 体,同一只投影口 `readRunFace`)。同步腿的首答是引擎结果,而重放时手里只有行;
- *    `replay: true` 是这一形的判别位。
+ *  · `sync`(`POST /v1/tasks`;`/v1/tasks/stream` 把同一份体放进 `done.result`)—— `200 { …首答的信封, replay: true }`:
+ *    首答的信封由 `http/sync-submit-body.ts` 铸(`buildSyncSubmitBody`),重放经同文件的 `syncSubmitBodyOfRow` 读行 ——
+ *    终局 / 停驻行上有结果 ⇒ 与首答同形(结果的键在顶层,`result` 是串);行上没有结果可交(首投还在跑)⇒ 轮询回执 `{ taskId, sessionId, status }`。
+ *    `replay: true` 是重放的判别位(本函数叠上,不在信封里)。
  */
 import type { RunIdemBinding, RunRecord } from "../plugins/store-contracts.js";
 import type { RunStore } from "../plugins/store-backend.js";

package/dist/http/submit-replay.js

@@ -1,5 +1,5 @@
 import { runRowReadable } from "./owner-access.js";
-import { readRunFace } from "./run-read-face.js";
+import { syncSubmitBodyOfRow } from "./sync-submit-body.js";
 import { refusalBody } from "./refusal-body.js";
 export function isRunExistsConflictBody(body) {
     return typeof body === "object" && body !== null && body.errorCode === "conflict.run_exists";
@@ -19,7 +19,7 @@ export async function replayOfExistingRun(row, caller, face, deps, runStore) {
         case "durable":
             return { status: 202, body: { taskId: row.taskId, sessionId: row.sessionId, status: row.status } };
         case "sync":
-            return { status: 200, body: { ...(await readRunFace(deps, runStore, row)), replay: true } };
+            return { status: 200, body: { ...syncSubmitBodyOfRow(deps, row), replay: true } };
         default: {
             const unknown = face;
             throw new Error(`replayOfExistingRun: unknown submit face ${String(unknown)}`);

package/dist/http/sync-submit-body.d.ts

@@ -25,14 +25,19 @@
  * (`observability/run-terminal.ts`),调用方铸一次交进来;本函数只负责「体长什么样」。凭据(`paused.token` /
  * `failed.nestedPause.token`)因此在进本函数之前就已摘掉,幂等缓存存的正是本函数的产物,重放体同体同脱。
  */
-import type { ParkedRunStatus, PersistedTaskResult } from "../plugins/store-contracts.js";
-/** park 中的 run 在同步 200 体上带的 poll 回执三键(修前 park 体的全部内容,值逐字不变)。 */
-export interface SyncParkReceipt {
+import { type ParkedRunStatus, type PersistedTaskResult, type RunRecord } from "../plugins/store-contracts.js";
+import { type RunFaceDeps } from "./run-read-face.js";
+/** 同步 200 体上的 poll 回执三键:一条 run 的 poll 键、会话、对外词。park 体叠在结果之上带它({@link SyncParkReceipt});重放命中一条还没有结果可交的行时,它**就是**整个体({@link syncSubmitBodyOfRow})。 */
+export interface SyncRunReceipt {
     /** 同步腿提交时铸的 durable run id —— `GET /v1/runs/:taskId` 的 poll 键。 */
     taskId: string;
     /** 提交的会话。 */
     sessionId: string;
-    /** 对外词 = `GET /v1/runs/:id` 行上的 `status`(park 两词之一,闭集从 `RUN_STATUS_CLASS` 派生)。 */
+    /** 对外词 = `GET /v1/runs/:id` 行上的 `status`。 */
+    status: RunRecord["status"];
+}
+/** park 中的 run 在同步 200 体上带的 poll 回执三键(修前 park 体的全部内容,值逐字不变);`status` 是 park 两词之一(闭集从 `RUN_STATUS_CLASS` 派生)。 */
+export interface SyncParkReceipt extends SyncRunReceipt {
     status: ParkedRunStatus;
 }
 /**
@@ -40,4 +45,16 @@ export interface SyncParkReceipt {
  * 返回的是纯数据(无方法、无闭包)⇒ `build*`。
  */
 export declare function buildSyncSubmitBody<R extends PersistedTaskResult>(exitResult: R, parkReceipt?: SyncParkReceipt): R | (R & SyncParkReceipt);
+/**
+ * **同键重放读行的出口** —— 同一条 run 的同步 200 体,首答与重放读**同一只信封**:终局行 / 停驻行上有结果 ⇒ 经 {@link buildSyncSubmitBody} 铸
+ * (终局 = 结果本身;停驻 = 结果 + 回执三键),与首答的三个 200 出口逐字同形 —— 首答恒 = 「出口封口 + 脱敏后的引擎结果」,那份对象就是落在行上的那一份
+ * (调用方铸一次、既落行又进体),重放读到的是它被读入口(同一只 {@link runRowExitResult},`GET /v1/runs/:id` 的 `result` 读的也是它)再封再脱的样子。
+ * 行上没有结果可交(首投还在跑、在别的副本上没落定;或终局行的结果已被收割清空)⇒ 首答在这一刻**不存在**,体只剩 {@link SyncRunReceipt} 三键 —— 去 `GET /v1/runs/:taskId` 轮询,
+ * 不把「读面」塞进同步体里充首答(失联折叠与读面同一只判据 {@link runRowStale}:折成 `failed`)。
+ *
+ * 首答体上另有两类**本次请求**的附注(`notice` / `warnings`,见 `routes/tasks.ts` 的 `withSyncSubmitKeys`):重放在 `prepareSpec` 之前就答了,
+ * 结构上不知道本次请求带没带 verify / cascade、放行侧选择器里有没有空条目 ⇒ 重放体没有它们。判别位 `replay: true` 由重放出口(`submit-replay.ts`)叠上,不在信封里。
+ * 纯数据 ⇒ `build*` 的近亲;名字取 `…OfRow`(行 → 体的读法),与 `buildSyncSubmitBody` 同文件同铸点。
+ */
+export declare function syncSubmitBodyOfRow(deps: RunFaceDeps, row: RunRecord): ReturnType<typeof buildSyncSubmitBody> | SyncRunReceipt;
 //# sourceMappingURL=sync-submit-body.d.ts.map

package/dist/http/sync-submit-body.js

@@ -1,4 +1,17 @@
+import { isParkedRunStatus, isTerminalRunStatus } from "../plugins/store-contracts.js";
+import { runRowExitResult, runRowStale } from "./run-read-face.js";
 export function buildSyncSubmitBody(exitResult, parkReceipt) {
     return parkReceipt === undefined ? exitResult : { ...exitResult, ...parkReceipt };
 }
+export function syncSubmitBodyOfRow(deps, row) {
+    const stale = runRowStale(deps, row);
+    const exit = stale ? undefined : runRowExitResult(row);
+    if (exit !== undefined) {
+        if (isTerminalRunStatus(row.status))
+            return buildSyncSubmitBody(exit);
+        if (isParkedRunStatus(row.status))
+            return buildSyncSubmitBody(exit, { taskId: row.taskId, sessionId: row.sessionId, status: row.status });
+    }
+    return { taskId: row.taskId, sessionId: row.sessionId, status: stale ? "failed" : row.status };
+}
 //# sourceMappingURL=sync-submit-body.js.map

package/dist/http/wire-types.d.ts

@@ -587,18 +587,28 @@ export interface TaskRequestBody {
     enableFork?: boolean;
     [k: string]: unknown;
 }
-/** [ref] D-1: the operator-echoed decision-action binding carried on POST /v1/approvals/:sessionId/decide([ref]C-4:裸 :id 臂已删).
- *  All optional for back-compat — a legacy BFF caller omitting them resumes on the current-pending values
- *  exactly as before (the pre-D-1 path), tracked by a deprecation counter.
+/** [ref] D-1 —— **一个答案只属于它被展示的那一个动作**:决断方在队列行上看到的那一对(`GET /v1/approvals` 行的 `boundCallId` /
+ *  `boundInputHash`),原样回显、从不重算,引擎在认领前逐字比对。本服务从不拿当前停驻行替决断方补任何一位 —— 补上的是此刻停在门上的动作,
+ *  不是决断方看到的那一个。判官 = `http/resume-legs.ts` 的 `decidedActionOf`。 */
+export type DecidedAction = {
+    /** The pendingAction.toolCallId the decider saw — echoed into ResumeOutcome.boundCallId. */
+    readonly boundCallId: string;
+    /** The engine-minted opaque boundInputHash the decider saw — echoed VERBATIM (never recomputed here). */
+    readonly boundInputHash: string;
+};
+/** [ref] D-1: the decision-action binding as read off POST /v1/approvals/:sessionId/decide([ref]C-4:裸 :id 臂已删).
+ *  The body's value-shape gate only checks "a string when present"; the pair {@link DecidedAction} is REQUIRED and judged by the
+ *  resume leg after its gate-kind guard (a wrong gate kind gets its 409 pointer first): either half missing ⇒ 400
+ *  `decide_requires_binding` naming `missingKeys`. 7.142.x and earlier filled a missing half from the current pending row.
  *  [ref] A9: hoisted VERBATIM out of `createHttpServer`'s closure so the approvals/assistant route domain
  *  and the resume leg can name the SAME shape without a routes/* → server.ts value edge. */
 export type DecideBinding = {
-    /** The capability token the operator actually SAW (from listPending). A mismatch with the current pending
-     *  ⇒ approval_stale (they decided a superseded/resolved view). */
+    /** The capability token the decider saw (never surfaced on the queue row; the server-internal seats hold it). A mismatch
+     *  with the current pending ⇒ approval_stale (they decided a superseded/resolved view). Optional, and never a substitute for the pair. */
     checkpointToken?: string;
-    /** The pendingAction.toolCallId the operator saw — echoed into ResumeOutcome.boundCallId. */
+    /** {@link DecidedAction.boundCallId} as echoed (required for a decision; see the type note). */
     boundCallId?: string;
-    /** The server-minted opaque boundInputHash the operator saw — echoed VERBATIM (never recomputed here). */
+    /** {@link DecidedAction.boundInputHash} as echoed (required for a decision; see the type note). */
     boundInputHash?: string;
     /** [ref] edit: operator-corrected tool args, applied by core AFTER the binding check, on approve only. */
     updatedInput?: unknown;

package/dist/identity-source.d.ts

@@ -12,9 +12,13 @@
  * 3. **缺席一种读法**:`null` = 这一行**没有「属主在受理时验过的凭据」的记录** —— 三列存在之前写下的行、没有任何验过凭据的受理(无鉴权写面
  *    `ALLOW_UNAUTHED_WRITES`)、以及别人替属主按下的那一跑(受理请求验过的主体不是这一行的属主:唤醒 / 决定投递铸的新一跑)。读者一律按「不合格」处置
  *    (fail-closed),不分辨三种成因;存量行不回填(没有事实可回填)。
+ * 4. **令牌声明装不进它的列就不记**(不截断:截断 = 两个不同的值折成一个):`sso` 臂从验过的令牌铸元组时,某一格装不进它的列宽({@link RUN_IDENTITY_CLAIM_COLUMNS})
+ *    ⇒ 那一格「未记录」—— 可空的格(化身号)记 `null`;必填的格(scope)装不下就铸不出合形元组 ⇒ 无元组。两格结果不同来自元组的型,不是两条规则:
+ *    同一只判({@link runIdentityClaimOverflow})、同一行告警 `run_identity_claim_unrecorded { claim, chars, max }`(凭据门的铸点发;只名与长度,不带值)。
  *
- * 化身号 `principalInc`:令牌 `sub_inc` 声明原样,经契约包 `VerifiedIdentity.principalInc` 读(settings-schema 14.7.0 加的可选字段,已提货:验证腿随身份带出);本版接线未做 ⇒ 恒 `null`,
- * 接线点在 `admitRunIdentity` 的 `sso` 臂(不在本仓另定一份读法)。
+ * 化身号 `principalInc`:令牌 `sub_inc` 声明原样(契约包 `VerifiedIdentity.principalInc`)。来源链只有一条 —— 验证器读出 → 注入边界再判形(`auth-bridge.ts` 的
+ * `admitBridgeIdentity`)→ 入口预认证挂 request-local(`security.ts` 的 `setSsoPrincipalInc`)→ 凭据门 `admitRunIdentity` 的 `sso` 臂铸进元组(律 4)→ 建行原样写入。
+ * `null` 化身号只有一种读法:**未记录**(契约 §12.8「缺 ⇒ 化身号未记录」)—— 存量行、令牌没带、装不下,三种成因同一读法。
  */
 /** 验过的身份来源的**闭集**(序 = 判定次序 = `/health.auth.kinds` 的出现序;加一个来源 = 加一个词,读它的各只穷举 `switch` 不接就编译红)。 */
 export declare const IDENTITY_SOURCES: readonly ["service_token", "sso", "direct_door_jwt"];
@@ -36,6 +40,21 @@ export type RunIdentity = {
 export declare const RUN_IDENTITY_SCOPE_MAX_CHARS = 190;
 /** `identity_principal_inc` 的列宽(字符):化身号是签发方插入时铸的不透明随机串(与会话化身同宽)。 */
 export declare const RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS = 64;
+/** 令牌声明 → 它落的那一列的列宽(字符;律 4 的判读这一张)。 */
+export declare const RUN_IDENTITY_CLAIM_COLUMNS: {
+    readonly scope: 190;
+    readonly principalInc: 64;
+};
+export type RunIdentityClaim = keyof typeof RUN_IDENTITY_CLAIM_COLUMNS;
+/**
+ * 律 4 的判:这一格令牌声明装不装得进它的列(按码点数,与两方言 VARCHAR 同口径)。装得下 ⇒ `undefined`;装不下 ⇒ 告警行 `run_identity_claim_unrecorded` 的载荷
+ * (`claim` 名 + 码点数 + 列宽,不带值)。调用方按格的型处置:可空格记 `null`,必填格无元组。
+ */
+export declare function runIdentityClaimOverflow(claim: RunIdentityClaim, value: string): {
+    readonly claim: RunIdentityClaim;
+    readonly chars: number;
+    readonly max: number;
+} | undefined;
 /**
  * `task_run` 三列的列定义 —— 两方言各一段,**唯一属主**:中央建表语句(`tidb-pool.ts` / `pg-pool.ts` 的 `CREATE TABLE task_run`)内插这同一段;
  * 存量库缺列时起服列册对账(`schema-consistency.ts`)拒启,拒句里的 `ALTER TABLE task_run ADD COLUMN …` 由同一份建表语句解析生成 ⇒

package/dist/identity-source.js

@@ -1,6 +1,12 @@
 export const IDENTITY_SOURCES = ["service_token", "sso", "direct_door_jwt"];
 export const RUN_IDENTITY_SCOPE_MAX_CHARS = 190;
 export const RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS = 64;
+export const RUN_IDENTITY_CLAIM_COLUMNS = { scope: RUN_IDENTITY_SCOPE_MAX_CHARS, principalInc: RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS };
+export function runIdentityClaimOverflow(claim, value) {
+    const chars = [...value].length;
+    const max = RUN_IDENTITY_CLAIM_COLUMNS[claim];
+    return chars > max ? { claim, chars, max } : undefined;
+}
 export const RUN_IDENTITY_COLUMNS = {
     mysql: [
         "identity_source VARCHAR(32) NULL",

package/dist/leader/leader.js

@@ -4,6 +4,7 @@ import { pullDiff } from "./diffout.js";
 import { mergeBranches } from "./merge.js";
 import { Runner, runWithVerification, resumeWithVerification } from "@sema-agent/core";
 import { pausedCauseOf, outwardPlane } from "../terminal.js";
+import { voidVerifierPauseCard } from "../verifier-pause-card.js";
 import { entryPermissionMode } from "../runtime-governance.js";
 import { withUnattendedLeg } from "../unattended-permission-mode.js";
 const MAX_RESUME_SLICES = 200;
@@ -93,11 +94,13 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
                     const w = bySession.get(st.sessionId);
                     const base = { workerId: w.workerId, sessionId: w.sessionId, branch: w.branch, baseSha: w.baseSha };
                     const cfg = w.verifierTools ? { ...verify, verifierTools: w.verifierTools } : verify;
-                    let vr = await runWithVerification(w.runner, { ...w.spec, sessionId: w.sessionId, signal }, cfg);
+                    const workerRunner = w.runner;
+                    let vr = await runWithVerification(workerRunner, { ...w.spec, sessionId: w.sessionId, signal }, cfg);
                     vr = await autoResumeOnResource(vr, signal, async (token, slice) => {
                         deps.logger?.info?.("worker_resource_resume", { workerId: w.workerId, slice });
-                        return resumeWithVerification(w.runner, token, { gate: "resource_limit", decision: "continue" }, { ...w.spec, sessionId: w.sessionId, signal }, w.spec.objective ?? "", cfg);
+                        return resumeWithVerification(workerRunner, token, { gate: "resource_limit", decision: "continue" }, { ...w.spec, sessionId: w.sessionId, signal }, w.spec.objective ?? "", cfg);
                     });
+                    await voidVerifierPauseCard(vr, workerRunner);
                     const vrPlane = outwardPlane(vr.terminal);
                     deps.logger?.info?.("verify_outcome", { workerId: w.workerId, status: vrPlane.status, verdict: vr.verification.verdict, rounds: vr.verification.rounds, finding: redactHead(vr.verification.findings[0] ?? "", 220) });
                     const pass = vr.terminal.kind === "completed" && vr.verification.verdict === "PASS";

package/dist/leader/wire.d.ts

@@ -138,6 +138,10 @@ export interface LeaderWireConfig {
     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>;
     /** Workspace root inside each E2B VM. Default /home/user. */
     workspace?: string;
@@ -152,7 +156,9 @@ export interface LeaderWireConfig {
      *  classification; running it on a heavy reasoning model (deepseek-v4-pro + reasoning) returns an EMPTY
      *  completion ~2/3 of the time — the budget is spent on reasoning with no answer text → "not valid JSON" →
      *  collapse-to-single, silently defeating fan-out (search 2026-06-14, reproduced 3×). A cheap non-reasoning
-     *  model (deepseek-v4-flash) routes correctly 51/51 in probes. Unset → the route runs on the default model. */
+     *  model (deepseek-v4-flash) routes correctly 51/51 in probes. Unset → the route resolves the `classifier` role
+     *  in the served table (the same `models` / `roles` every task of this leader resolves against; core's fallback
+     *  chain classifier → summarize → default: the env cheap slot binds `summarize`, an adopted catalog binds its own). */
     routerModel?: string;
     /** Max bounded integration-repair rounds on a clean-merge-but-failing-build (see merge.ts IntegrationRepair).
      *  0 / unset = OFF (a failing integration test is terminal, the pre-2026-06-14 behavior). Env override:

package/dist/leader/wire.js

@@ -168,6 +168,7 @@ export function createLeaderRunner(cfg) {
     const deploymentPostureSeat = () => cfg.deploymentPosture?.() ?? {};
     const tracerSeat = cfg.tracer ? { tracer: cfg.tracer } : {};
     const modsSeat = cfg.mods ? { mods: cfg.mods } : {};
+    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 } : {};
@@ -188,7 +189,7 @@ 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, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, executionEnv: rawEnv, rootPath: repoDir });
+                    const runner = new Runner({ brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, 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}`,
@@ -255,13 +256,13 @@ export function createLeaderRunner(cfg) {
             if (Array.isArray(body.subtasks) && body.subtasks.length > 0) {
                 return validateSubtasks(body.subtasks);
             }
-            const planRunner = new Runner({ brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat });
+            const planRunner = new Runner({ brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat });
             const runRoute = async (prompt) => {
                 const res = await planRunner.runTaskStream({
                     objective: prompt,
                     ...principalSpec(),
                     sessionId: `leader-route-${Date.now()}`,
-                    ...(cfg.routerModel ? { model: cfg.routerModel } : {}),
+                    ...(cfg.routerModel ? { model: cfg.routerModel } : { modelRole: "classifier" }),
                 }).result();
                 return res.result ?? "";
             };
@@ -349,7 +350,7 @@ export function createLeaderRunner(cfg) {
                     workerId: sub.workerId, sessionId, branch: sub.branch,
                     baseSha,
                     runner: keepCtxWarm(new Runner({
-                        brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat,
+                        brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat,
                         ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}),
                         ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}),
                         executionEnvFactory: async (ctx) => {
@@ -374,7 +375,7 @@ 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, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}), ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}), executionEnv: env })),
+                runner: keepCtxWarm(new Runner({ brain: cfg.brain, ...servedTableSeat, pricing: cfg.pricing, ...onNoticeSeat, ...governanceSeat, ...deploymentPostureSeat(), ...tracerSeat, ...usageWindowSeat, ...promptSourceSeat, ...onErrorSeat, ...modsSeat, ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}), ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}), executionEnv: env })),
                 diffEnv: env,
                 destroy: () => env.destroy().then(() => { }),
                 spec: withLeaderLeg({ ...workerLimits, ...sub.spec, ...durableSpec, ...resourceSpec, ...principalSpec() }, resumeBody),

package/dist/leg-facts.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 一条腿的**部署事实**(执行车道 · run 技能名册 · 受理见证)—— server 自有的载体,**不搭引擎 spec 的车**。
+ *
+ * 规则:`TaskSpec` 是引擎的类型面,上面只放引擎读的成员。本仓装配器(`boot/resolve-spec.ts` 的 `createResolveSpec`)同时还判出三件
+ * 只有 server 自己读的事实 —— 它们以装配器**自己的输出对象**为键登记在这一张表里(单一铸点 {@link mintLegFacts}),由两只漏斗
+ * (受理 `http/admission.ts` 的 `prepareSpec` · 续跑 `http/resume-legs.ts` 的 `resolveResumeSpec`)在拿到装配输出的**同一只对象**时
+ * 读一次(唯一读口 {@link legFactsOf},读在 `stampSpecRoot` 复制之前),此后作普通值随 `PreparedTaskSubmission.legFacts` /
+ * `DriveResumeArgs.legFacts` 走到各读者。生产选路器(`capabilities/hands-lane.ts` 的 `createHandsRunnerSelector`)经公共缝
+ * `runnerFor(spec)` 被同两只漏斗以同一只装配输出调用,读同一只读口。
+ *
+ * 为什么是「以输出对象为键的表 + 漏斗处一读」而不是 spec 上的字段:引擎的 TaskSpec 一读门按 `Reflect.ownKeys` 判自有成员,
+ * 任何不是它声明的键(含 symbol 键)都拒(fresh `config.spec_unknown_key` / 续跑 `checkpoint.config_refused`)。表的键身份只需在
+ * 「装配器返回 → 漏斗读」这一步成立,两步相邻、按构造成立;复制出来的对象(`{...spec}` / rest 解构)读不到 —— 读晚了是响亮拒,不是静默放宽。
+ *
+ * 嵌入方自带的 `resolveSpec` 不铸事实 ⇒ 读口得 `undefined`:选路响亮拒(`HandsLaneUnstampedError`),名册与见证缺席(腿的
+ * `wiring_manifest` 不带技能段 / 会话行记录座不写住客)。
+ */
+import type { ScenarioHands } from "./capabilities/hands-lane.js";
+import type { RunSkillEntry } from "./capabilities/skills.js";
+import type { DelegationRootWitness } from "./delegated-session-owner.js";
+/** 一条腿的部署事实(冻结记录)。 */
+export interface LegFacts {
+    /** 执行车道:`none` ⇒ 无手孪生 Runner。读者 = 生产选路器。 */
+    readonly hands: ScenarioHands;
+    /** 这条 run 交给引擎的技能名册(`{ name, description, source }[]`)。读者 = 每条投 `wiring_manifest` 的腿。 */
+    readonly skills: readonly RunSkillEntry[];
+    /** 受理时读根会话行的那一读(会话 id + 住客)。读者 = 腿的会话行记录座(`session-workspace.ts`)。 */
+    readonly sessionWitness: DelegationRootWitness;
+}
+/**
+ * 铸事实(**单一属主**:只允许 `createResolveSpec` 的出口调用)。同一只对象被第二次铸 ⇒ 当场抛 —— 两个写者是漂移的成因,
+ * 响亮好过后到者悄悄赢。值冻结(名册条目与见证各自冻结)。
+ */
+export declare function mintLegFacts<T extends object>(resolved: T, facts: LegFacts): T;
+/** 唯一读口:交装配器输出的**那一只**对象。复制品 / 嵌入方装配器的输出 ⇒ `undefined`。 */
+export declare function legFactsOf(resolved: object): LegFacts | undefined;
+//# sourceMappingURL=leg-facts.d.ts.map