@sema-agent/server 7.142.0 → 7.144.0

package/dist/http/routes/tasks.js

@@ -5,9 +5,9 @@ import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpS
 import { atHostBoundary, sealResultForExit, outwardPlane } from "../../terminal.js";
 import { voidVerifierPauseCard } from "../../verifier-pause-card.js";
 import { withPrincipal } from "../../observability/principal-context.js";
-import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../../fleet/fleet-bus.js";
+import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals } from "../../fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
-import { createReasoningSegments, reasoningStreamOfTask } from "../../trace/model-segment.js";
+import { createLiveModelText, modelStreamOfTask } from "../../trace/model-segment.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKeyOf, NotifiedKeys } from "../../orchestration/workflow-completion-inbox.js";
 import { createForwardAppendFailedNote, createLedgerSink, createLedgerTwinEmit } from "../../trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "../../trace/engine-notice-wire.js";
@@ -16,7 +16,7 @@ import { buildCancelledLedgerRow, createRunAbort, mintCancelledResult } from "..
 import { recordResourceWindow } from "../../resource-window.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { writeLiveFrame, writeLiveHeartbeat } from "../live-frame.js";
-import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, textEndEventData, liveIdentityFields } from "../../trace/project.js";
+import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, liveIdentityFields } from "../../trace/project.js";
 import { cascadeConfig, runMeta } from "../run-meta.js";
 import { idemCallerOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
 import { replayOfExistingRun } from "../submit-replay.js";
@@ -36,12 +36,11 @@ import * as facts from "../../capability-facts.js";
 import { persistSubmitCtx } from "../submit-ctx.js";
 import { serviceVersion } from "../../service-version.js";
 import { withModelReachScope } from "../../model-reach-scope.js";
-import { runSkillsOf } from "../../capabilities/skills.js";
 import { createInstructionSelectionLeg } from "../../instruction-selection.js";
 import { fieldConflictFacts } from "../../field-conflict.js";
 import { refusalBody } from "../refusal-body.js";
 import { heldWorkflowParkDecisions } from "../../parked-decide.js";
-import { createSessionWorkspaceRecorder, legSessionWitnessOf, sessionWorkspaceStoreOf } from "../../session-workspace.js";
+import { createSessionWorkspaceRecorder, sessionWorkspaceStoreOf } from "../../session-workspace.js";
 const DISCONNECT_PARK_GRACE_MS = 10_000;
 async function mintSubmitExitResult(result, checkpoints) {
     return redactTerminalResult(sealResultForExit(await graftParkToolCallId(result, checkpoints)));
@@ -166,7 +165,7 @@ export async function handleTasks(req, res, match, ctx) {
             const wiringOperatorFace = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config);
             let wiringReceipt;
             const instructionLeg = createInstructionSelectionLeg();
-            const legWiringSections = () => ({ instructions: instructionLeg.segment(), skills: runSkillsOf(prepared.spec) });
+            const legWiringSections = () => ({ instructions: instructionLeg.segment(), skills: prepared.legFacts?.skills });
             const withRunReceipt = (out) => wiringReceipt !== undefined ? { ...out, wiringManifest: wiringReceipt } : out;
             if (liveStream) {
                 if (prepared.verify || prepared.cascade) {
@@ -418,8 +417,8 @@ export async function handleTasks(req, res, match, ctx) {
                         const streamBody = async () => {
                             await withPrincipal(principal, async () => {
                                 const tailContentMode = prepared.spec.forwardSubagentEvents === true ? "on" : "progress_only";
-                                const childReasoning = createReasoningSegments();
-                                const topReasoning = createReasoningSegments();
+                                const childText = createLiveModelText();
+                                const topText = createLiveModelText();
                                 const heldDecisions = await heldWorkflowParkDecisions(deps, prepared.spec.sessionId);
                                 const fwdInternals = {
                                     ...heldDecisions,
@@ -433,8 +432,8 @@ export async function handleTasks(req, res, match, ctx) {
                                         }
                                         if (res.writableEnded)
                                             return;
-                                        for (const end of childReasoning.onEvent(e))
-                                            writeLiveFrame(res, end);
+                                        for (const f of childText.onEvent(e))
+                                            writeLiveFrame(res, f);
                                         const t = e.type;
                                         if (t === "task_progress") {
                                             writeLiveFrame(res, { type: "task_progress", ...taskProgressEventData(e) });
@@ -450,34 +449,20 @@ export async function handleTasks(req, res, match, ctx) {
                                             const te = e;
                                             writeLiveFrame(res, { type: "tool_end", ...toolEndEventData(te) });
                                         }
-                                        else if (t === "text_delta") {
-                                            const td = e;
-                                            writeLiveFrame(res, { type: "text_delta", delta: td.delta, ...(td.eventId ? { eventId: td.eventId } : {}), ...(td.parentToolCallId ? { parentToolCallId: td.parentToolCallId } : {}) });
-                                        }
-                                        else if (t === "text_end") {
-                                            const tend = textEndEventData(e);
-                                            if (tend !== null)
-                                                writeLiveFrame(res, { type: "text_end", ...tend });
-                                        }
-                                        else if (t === "reasoning_delta") {
-                                            const rd = e;
-                                            writeLiveFrame(res, { type: "reasoning_delta", delta: redactSecrets(rd.delta), ...(rd.eventId ? { eventId: rd.eventId } : {}), ...(rd.parentToolCallId ? { parentToolCallId: rd.parentToolCallId } : {}) });
-                                        }
                                     },
                                     onTaskNotification: (n, opts) => {
                                         if (n.task_type === "workflow")
                                             return;
                                         if (!res.writableEnded)
-                                            for (const end of childReasoning.cut(reasoningStreamOfTask(n.task_id, n.sessionId)))
-                                                writeLiveFrame(res, end);
+                                            for (const f of childText.cut(modelStreamOfTask(n.task_id)))
+                                                writeLiveFrame(res, f);
                                         defaultSubagentTailBus.forgetHandle(n.task_id);
                                         if (defaultSubagentTailBus.hasSubscribers(n.task_id)) {
                                             defaultSubagentTailBus.publish(n.task_id, { type: "task_settled", taskId: n.task_id, status: n.status, ...(typeof n.seq === "number" ? { seq: n.seq } : {}), ...(n.summary ? { summary: redactSecrets(n.summary) } : {}) });
                                         }
-                                        const hadRow = isFleetAgentTerminalNotification(n) ? (fleetPub?.onChildTerminal(n.sessionId ?? n.task_id, n.status, n.task_id, n.toolUseId) ?? false) : false;
                                         const deliverable = syncLegLive && !res.writableEnded && !res.destroyed;
                                         const parked = !deliverable && deps.workflowCompletionInbox !== undefined;
-                                        deps.logger?.info?.("task_notification_observed", { route: "sync-stream", taskId: n.task_id, taskType: n.task_type, status: n.status, hadFleetRow: hadRow, legLive: syncLegLive, parkedDurable: parked });
+                                        deps.logger?.info?.("task_notification_observed", { route: "sync-stream", taskId: n.task_id, taskType: n.task_type, status: n.status, legLive: syncLegLive, parkedDurable: parked });
                                         if (parked) {
                                             void deps.workflowCompletionInbox.enqueue(taskNotificationInboxEntry(prepared.spec.sessionId, askOwner, n, Date.now(), durableTaskId, opts?.priority)).catch((err) => deps.logger?.warn?.("park_enqueue_failed", { route: "sync-stream", taskId: n.task_id, err: err instanceof Error ? err.message : String(err) }));
                                         }
@@ -503,12 +488,12 @@ export async function handleTasks(req, res, match, ctx) {
                                 if (durableTaskId)
                                     steerableRuns.set(durableTaskId, liveStream);
                                 prepared.acceptance.attachStream({ reachable: () => !closed && !res.writableEnded && !res.destroyed, write: (frame) => writeLiveFrame(res, { ...frame }) });
-                                const liveWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), legSessionWitnessOf(prepared.spec));
+                                const liveWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), prepared.legFacts?.sessionWitness);
                                 for await (const ev of liveStream) {
                                     if (closed)
                                         break;
-                                    for (const end of ev.type === "done" ? [...childReasoning.cut(), ...topReasoning.cut()] : topReasoning.onEvent(ev))
-                                        writeLiveFrame(res, end);
+                                    for (const f of ev.type === "done" ? [...childText.cut(), ...topText.cut()] : topText.onEvent(ev))
+                                        writeLiveFrame(res, f);
                                     const promptEntryId = promptCommit(ev);
                                     if (promptEntryId !== undefined)
                                         userMsgEntryId = promptEntryId;
@@ -569,8 +554,7 @@ export async function handleTasks(req, res, match, ctx) {
                                             writeLiveFrame(res, { type: "task_notification", ...taskNotificationEventData(ev) });
                                         }
                                     }
-                                    else if (ev.type === "reasoning_delta" && typeof ev.delta === "string") {
-                                        writeLiveFrame(res, { type: "reasoning_delta", delta: redactSecrets(ev.delta), ...(ev.eventId ? { eventId: ev.eventId } : {}), ...(ev.parentToolCallId ? { parentToolCallId: ev.parentToolCallId } : {}) });
+                                    else if (ev.type === "text_delta" || ev.type === "text_end" || ev.type === "reasoning_delta") {
                                     }
                                     else if (ev.type === "task_progress") {
                                         writeLiveFrame(res, { type: "task_progress", ...taskProgressEventData(ev) });
@@ -619,25 +603,19 @@ export async function handleTasks(req, res, match, ctx) {
                                     else if (ev.type === "human_input") {
                                         writeLiveFrame(res, { type: "human_input", ...humanInputEventData(ev) });
                                     }
-                                    else if (ev.type === "text_delta" || ev.type === "text_end" || ev.type === "turn_end" || ev.type === "message_committed" || ev.type === "context_usage") {
+                                    else if (ev.type === "turn_end" || ev.type === "message_committed" || ev.type === "context_usage") {
                                         const e = ev;
                                         const ident = liveIdentityFields(e);
-                                        const textEnd = ev.type === "text_end" ? textEndEventData(e) : undefined;
-                                        const arm = ev.type === "text_delta"
-                                            ? { type: "text_delta", delta: e.delta, ...ident }
-                                            : ev.type === "text_end"
-                                                ?
-                                                    textEnd === null || textEnd === undefined ? null : { type: "text_end", ...textEnd }
-                                                : ev.type === "turn_end"
-                                                    ? { type: "turn_end", ...turnEndEventData(ev), ...ident }
-                                                    : ev.type === "message_committed"
-                                                        ? { type: "message_committed", entryId: e.entryId, role: e.role, ...(e.toolCallId !== undefined ? { toolCallId: e.toolCallId } : {}), ...ident }
-                                                        : { type: "context_usage", ...contextUsageEventData(ev), ...ident };
-                                        if (arm !== null)
-                                            writeLiveFrame(res, arm);
+                                        const arm = ev.type === "turn_end"
+                                            ? { type: "turn_end", ...turnEndEventData(ev), ...ident }
+                                            : ev.type === "message_committed"
+                                                ? { type: "message_committed", entryId: e.entryId, role: e.role, ...(e.toolCallId !== undefined ? { toolCallId: e.toolCallId } : {}), ...ident }
+                                                : { type: "context_usage", ...contextUsageEventData(ev), ...ident };
+                                        writeLiveFrame(res, arm);
                                     }
                                     else {
-                                        writeLiveFrame(res, { ...ev });
+                                        const unknownArm = ev;
+                                        writeLiveFrame(res, { ...unknownArm });
                                     }
                                 }
                             });
@@ -959,7 +937,7 @@ export async function handleTasks(req, res, match, ctx) {
                         const cascadeLeg = () => runCascade(prepared.runner, specWithSignal, cascadeConfig(deps.config.cascadeLadder, prepared.spec.limits?.maxCostUsd), heldDecisions);
                         const plainLeg = async () => {
                             const stream = prepared.runner.runTaskStream(specWithSignal, undefined, heldDecisions);
-                            const syncWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), legSessionWitnessOf(prepared.spec));
+                            const syncWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), prepared.legFacts?.sessionWitness);
                             for await (const ev of stream) {
                                 observeSyncLegEvent(ev);
                                 prepared.acceptance.observe(ev);
@@ -977,7 +955,7 @@ export async function handleTasks(req, res, match, ctx) {
                             inflightRuns.delete(durableTaskId);
                     }
                     const syncAbortCause = syncCancelCtrl.cause();
-                    await voidVerifierPauseCard(result, deps.checkpointStore);
+                    await voidVerifierPauseCard(result, prepared.runner);
                     if (syncAbortCause !== undefined) {
                         result = mintCancelledResult({
                             taskId: durableTaskId ?? "",

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` —— 那是一句表态,不是一个回落。
@@ -480,12 +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
+     *  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<MemorySyncResponse>;
+    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
@@ -767,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;
@@ -917,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

@@ -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) => {
@@ -206,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/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/index.d.ts

@@ -4,6 +4,7 @@ export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend, type StoreBackend, type SessionCaptureRecordSource } from "./plugins/store-backend.js";
 export { RetiredSchemaPresentError } from "./plugins/schema-consistency.js";
+export { LocalDataRootSchemaMismatchError, type LocalSidecarMismatch } from "./plugins/local-session-store.js";
 export { CachingSessionStore, type CachingOptions } from "./plugins/caching-session-store.js";
 export type { RunRecord, RunEvent } from "./plugins/store-contracts.js";
 export { runInBackground } from "./runs.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend } from "./plugins/store-backend.js";
 export { RetiredSchemaPresentError } from "./plugins/schema-consistency.js";
+export { LocalDataRootSchemaMismatchError } from "./plugins/local-session-store.js";
 export { CachingSessionStore } from "./plugins/caching-session-store.js";
 export { runInBackground } from "./runs.js";
 export { createHardenedVmRunner, runInHardenedVm } from "./orchestration/hardened-vm-runner.js";

package/dist/lane-home-probe.d.ts

@@ -15,6 +15,9 @@
  *  · **有主张 ⇒ 证**:座 = 主张原样(下单门与引擎 prepare 在环境开起来之前就要基);开环境那一拍读一次(与命令同一条 shell、同一份 env:
  *    `printf %s "$HOME"`;host 直接读它自己组合给子进程的那份 env),两者不一致 ⇒ 这只执行环境不开(拒句点名两值与改法),环境答了的判定记在环境上
  *    (同一镜像 / 同一目标机再问也是同一个答案,不重试成风暴);读不出同样不开(证不了主张 = 不拿一个没证过的目录去守),但不记 —— 与任何一次建连失败同,下一次重问。
+ *    「不开」落在读数到手的那一刻:读数在铸环境时就到手的车道(host:读数是适配器自己组合给子进程的那份 env)⇒ 环境**不铸** —— 构造抛带码的拒
+ *    ({@link laneHomeRefusal},码 `env.home_unconfirmed`),工厂原样抛出,引擎在准备期再抛、不建环境,run 的失败终局原样承运码与句:没有命令、没有读边界判,
+ *    任何形状的命令都是同一首拒;读数要环境起来才有的车道(远端五条)⇒ 开环境那一拍拒,环境的门回同一句。
  *  · **没主张 ⇒ 实测**:同一拍问同一句;答出绝对路径 ⇒ 座 = 它,之后不再问;
  *  · **实测也缺席**(问不出 / 答的不是绝对路径,含空串)⇒ 座缺席(引擎失败关闭,不猜、不补 `/`),环境照开(没主张就没有主张可拒),一行 warn(点名读到了什么与出路)。
  * 读不了家目录的车道(device:设备协议没有读数)不持座 —— 声明就是座,起服披露「来自声明、未实测」(`execution-lane-caps.ts` `buildLaneHomeBootNote`)。
@@ -68,6 +71,18 @@ export type LanePathFlavor = "posix" | "win32";
  * 次序:读不出 → 不是绝对路径 → 一致 → 不一致(「绝对」先于「一致」:主张自己是相对串时,一个同样相对的读数也不放行)。
  */
 export declare function judgeLaneHome(lane: string, claim: LaneHomeClaim, probe: LaneHomeProbe, paths?: LanePathFlavor): LaneHomeVerdict;
+/**
+ * 本仓自铸的**执行环境拒码**闭集(`env.*` 族;今天一员)—— 一只执行环境在交给引擎之前就被拒时,工厂抛出的错带的 `code`。引擎在准备期原样再抛、不建环境,
+ * run 的 `failed` 终局原样承运码与句;同步提交腿按零工作拒落档(`runs.ts` 的 `EXECUTION_ENV_REFUSAL_HTTP_STATUS`,按本闭集键控:加一员而档没跟 ⇒ tsc 红)。
+ *  · `env.home_unconfirmed` —— 家目录主张证不了({@link judgeLaneHome} 的三形拒句:读不出 / 不是绝对路径 / 与实测不一致)。三形一个码:出路都在部署
+ *    (声明、环境里的 `HOME`,或会话 `settings.env` 里的 `HOME`),消费端不按形分岔;是哪一形、怎么改,句子里说。
+ */
+export declare const EXECUTION_ENV_REFUSAL_CODES: readonly ["env.home_unconfirmed"];
+export type ExecutionEnvRefusalCode = (typeof EXECUTION_ENV_REFUSAL_CODES)[number];
+/** 家目录拒的带码错误:句 = 判官的拒句原文,码 = `env.home_unconfirmed`。读数在铸环境时就到手的车道(host)构造时抛它,工厂原样抛出。 */
+export declare function laneHomeRefusal(verdict: NonNullable<LaneHomeVerdict>): Error & {
+    readonly code: Extract<ExecutionEnvRefusalCode, "env.home_unconfirmed">;
+};
 /** 起服与每只环境「家目录答不出」那一行 warn 的事件名 —— 一只 code,起服(车道读不了)与环境(实测缺席)共用。 */
 export declare const LANE_HOME_UNDECLARED_EVENT = "execution_lane_home_undeclared";
 /**

package/dist/lane-home-probe.js

@@ -61,6 +61,10 @@ export function judgeLaneHome(lane, claim, probe, paths = "posix") {
         answered: true,
     };
 }
+export const EXECUTION_ENV_REFUSAL_CODES = ["env.home_unconfirmed"];
+export function laneHomeRefusal(verdict) {
+    return Object.assign(new Error(verdict.refusal), { code: "env.home_unconfirmed" });
+}
 export const LANE_HOME_UNDECLARED_EVENT = "execution_lane_home_undeclared";
 const HOME_ABSENT_COST = "the engine cannot place its home-anchored read-deny rows, so every contents-disclosing recursive read (grep -r, rg, git grep, tar c, …) asks a person on the full shell — " +
     "no allow rule, mode or bypass releases that question — and is refused on the read-only face, so unattended tasks cannot search code; \"~/\" permission rules are refused at submission.";

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

package/dist/leg-facts.js

@@ -0,0 +1,15 @@
+const SEAT = new WeakMap();
+export function mintLegFacts(resolved, facts) {
+    if (SEAT.has(resolved))
+        throw new TypeError("leg facts are already minted for this resolved spec — a second writer would make the two readings drift");
+    SEAT.set(resolved, Object.freeze({
+        hands: facts.hands,
+        skills: Object.freeze(facts.skills.map((e) => Object.freeze({ ...e }))),
+        sessionWitness: Object.freeze({ ...facts.sessionWitness }),
+    }));
+    return resolved;
+}
+export function legFactsOf(resolved) {
+    return SEAT.get(resolved);
+}
+//# sourceMappingURL=leg-facts.js.map

package/dist/memory-bundle-engine.d.ts

@@ -50,7 +50,6 @@
  */
 import { type MemoryExportBundle, type MemoryImportReport } from "@sema-agent/core";
 import { type MemoryScopeStores } from "./memory-scope-stores.js";
-import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
 /** 两口 HTTP 面消费的窄能力面(`ServiceDeps.memoryBundle{Export,Import}` 的实参来源)。 */
 export interface MemoryBundleFaces {
     exportScopes: (scopes: readonly string[]) => Promise<MemoryExportBundle>;
@@ -68,7 +67,5 @@ export interface MemoryBundleFaces {
  * `test/memory-bundle-engine.test.ts`:给一个不存在的 `memoryDir` 也照样工作),传对的那一只是为了
  * 万一 core 日后真用上时,它拿到的是本部署真正的挂载平面,而不是高一层的配置根。
  */
-export declare function createMemoryBundleFaces(stores: MemoryScopeStores, opts?: {
-    captureRecords?: SessionCaptureRecordSource;
-}): MemoryBundleFaces | undefined;
+export declare function createMemoryBundleFaces(stores: MemoryScopeStores): MemoryBundleFaces | undefined;
 //# sourceMappingURL=memory-bundle-engine.d.ts.map