@sema-agent/server 7.142.0 → 7.144.0

package/dist/boot/stage-07-capability-layer.js

@@ -23,8 +23,10 @@ import { createUserInputLedgerAtBoot, writerGoneEvidenceFor } from "../user-inpu
 import { createParkedReviveInheritedGate } from "./parked-revive-gate.js";
 import { createParkedReviveSurface } from "../parked-revive-surface.js";
 import { createWebFetchSummarizeLane } from "./webfetch-summarize-lane.js";
+import { assertGovernanceAssemblable } from "./governance-seams.js";
 import { createRunnerDepsOnAsk } from "./runner-deps.js";
-import { bindRateLimiter, bindRunStore } from "./late-binds.js";
+import { bindRateLimiter, bindRunStore, sessionNotifyDoor } from "./late-binds.js";
+import { createBackgroundCompletionRelay } from "../session-notify-door.js";
 import { buildDisplaySafeUrl } from "../trace/redact.js";
 import * as facts from "../capability-facts.js";
 import { WEB_ADMIN_ENV } from "@sema-agent/settings-schema";
@@ -153,6 +155,7 @@ export async function runStage07(ctx) {
     bindRateLimiter(rateLimiter);
     let skills = loadDeploymentSkills(config, logger);
     skills = await webAdmin.applyCenterCapabilities(skills, peerDesk, peerDesk.lease("roster"));
+    assertGovernanceAssemblable(config);
     const repoClient = config.gitApiBaseUrl ? createRepoClient(config.gitApiKind, config.gitApiBaseUrl, config.gitApiToken) : undefined;
     const webSearchCfg = webSearchConfigFromEnv();
     const webSearch = webSearchCfg ? createWebSearchBackend(webSearchCfg) : undefined;
@@ -169,7 +172,7 @@ export async function runStage07(ctx) {
             .catch((e) => logger.warn("web_search_probe_failed", { provider: webSearchCfg.provider, error: seatText("operator-log-text", e instanceof Error ? e.message : String(e)) }));
     }
     const ensureChildSessionDurable = checkpointStore && resolveSubagentTranscriptTier(backgroundAgentStore !== undefined, sessionStore) === "full"
-        ? (sessionId, root) => attestChildSessionDurable(sessionStore, sessionId, root, logger)
+        ? (sessionId, given) => attestChildSessionDurable(sessionStore, sessionId, given)
         : undefined;
     const webFetchSummarize = createWebFetchSummarizeLane({ brain, config, getKeyResolver: () => webAdmin.getKeyResolver(), logger });
     const scenarioDeps = {
@@ -181,6 +184,7 @@ export async function runStage07(ctx) {
         ensureChildSessionDurable: ensureChildSessionDurable ? ensureChildSessionDurable : undefined,
         taskListStoreFor: taskListLane.storeFor,
         subagentExtraTools: sendUserFileToolSpec ? subagentSendUserFileExtraTools({ spec: sendUserFileToolSpec }) : undefined,
+        backgroundCompletionSinkFor: createBackgroundCompletionRelay({ door: () => sessionNotifyDoor, logger }),
     };
     const scenarios = buildScenarios(scenarioDeps);
     const builtinDefaultScenario = scenarios.default;

package/dist/boot/stage-08-reapers.d.ts

@@ -138,14 +138,17 @@ export declare function runStage08(ctx: Awaited<ReturnType<typeof runStage07>>):
     sessionMemoryStatusFace: import("../memory-operator-faces.js").SessionMemoryStatusFace | undefined;
     sessionPolicyStore: import("@sema-agent/core").SessionPolicyStore | undefined;
     sideQueryAccounting: import("../budget.js").SideQueryAccounting;
-    toolResultStore: import("../plugins/store-backend.js").ToolResultStoreFull | undefined;
+    toolResultStore: import("@sema-agent/core").ToolResultStore | undefined;
     tracer: import("@sema-agent/core").TracerHook;
     backend: import("../index.js").StoreBackend | undefined;
     backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
     breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
     engineDataRoot: string;
     instanceId: string;
-    mailboxRecipientLifecycle: import("../plugins/mailbox-recipient-lifecycle.js").MailboxRecipientLifecycle | undefined;
+    mailboxRecipientLifecycle: Readonly<{
+        retireRecipient: NonNullable<import("@sema-agent/core").MailboxStore["retireRecipient"]>;
+        listRetiredRecipients: NonNullable<import("@sema-agent/core").MailboxStore["listRetiredRecipients"]>;
+    }> | undefined;
     mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
     memoryEngine: import("../memory-scope-stores.js").MemoryScopeStores | undefined;
     memoryExportStores: import("../memory-scope-stores.js").MemoryScopeStores | undefined;

package/dist/boot/stage-09-leader.d.ts

@@ -162,14 +162,17 @@ export declare function runStage09(ctx: Awaited<ReturnType<typeof runStage08>>):
     sessionMemoryStatusFace: import("../memory-operator-faces.js").SessionMemoryStatusFace | undefined;
     sessionPolicyStore: import("@sema-agent/core").SessionPolicyStore | undefined;
     sideQueryAccounting: import("../budget.js").SideQueryAccounting;
-    toolResultStore: import("../plugins/store-backend.js").ToolResultStoreFull | undefined;
+    toolResultStore: import("@sema-agent/core").ToolResultStore | undefined;
     tracer: import("@sema-agent/core").TracerHook;
     backend: import("../index.js").StoreBackend | undefined;
     backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
     breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
     engineDataRoot: string;
     instanceId: string;
-    mailboxRecipientLifecycle: import("../plugins/mailbox-recipient-lifecycle.js").MailboxRecipientLifecycle | undefined;
+    mailboxRecipientLifecycle: Readonly<{
+        retireRecipient: NonNullable<import("@sema-agent/core").MailboxStore["retireRecipient"]>;
+        listRetiredRecipients: NonNullable<import("@sema-agent/core").MailboxStore["listRetiredRecipients"]>;
+    }> | undefined;
     mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
     memoryEngine: import("../memory-scope-stores.js").MemoryScopeStores | undefined;
     memoryExportStores: import("../memory-scope-stores.js").MemoryScopeStores | undefined;

package/dist/boot/stage-10-http-server.d.ts

@@ -161,14 +161,17 @@ export declare function runStage10(ctx: Awaited<ReturnType<typeof runStage09>>):
     sessionMemoryStatusFace: import("../memory-operator-faces.js").SessionMemoryStatusFace | undefined;
     sessionPolicyStore: import("@sema-agent/core").SessionPolicyStore | undefined;
     sideQueryAccounting: import("../budget.js").SideQueryAccounting;
-    toolResultStore: import("../plugins/store-backend.js").ToolResultStoreFull | undefined;
+    toolResultStore: import("@sema-agent/core").ToolResultStore | undefined;
     tracer: import("@sema-agent/core").TracerHook;
     backend: import("../plugins/store-backend.js").StoreBackend | undefined;
     backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
     breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
     engineDataRoot: string;
     instanceId: string;
-    mailboxRecipientLifecycle: import("../plugins/mailbox-recipient-lifecycle.js").MailboxRecipientLifecycle | undefined;
+    mailboxRecipientLifecycle: Readonly<{
+        retireRecipient: NonNullable<import("@sema-agent/core").MailboxStore["retireRecipient"]>;
+        listRetiredRecipients: NonNullable<import("@sema-agent/core").MailboxStore["listRetiredRecipients"]>;
+    }> | undefined;
     mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
     memoryEngine: import("../memory-scope-stores.js").MemoryScopeStores | undefined;
     memoryExportStores: import("../memory-scope-stores.js").MemoryScopeStores | undefined;

package/dist/boot/stage-10-http-server.js

@@ -13,6 +13,7 @@ import { backgroundAgentOutput, taskHandleOutput, taskHandleStop } from "../runs
 import { createStoreLiveProbe } from "../store-live-probe.js";
 import { counterStoreLabel } from "../plugins/store-backend.js";
 import { sessionStoreLabelOf } from "../store-posture.js";
+import { defaultPeerInboundFace } from "../peer-inbound-face.js";
 import { startFleetClientFromConfig } from "../fleet-client.js";
 import { createCenterWiringReader } from "../capabilities/center-wiring.js";
 import { mintEngineSignal } from "../fleet/engine-signal.js";
@@ -187,6 +188,7 @@ export async function runStage10(ctx) {
         centerIdentityNoticeState: () => webAdmin.centerIdentityNoticeState(),
         modelRefusalsState: () => webAdmin.modelRefusalsState(),
         candidateRejectionState: () => webAdmin.candidateRejectionState(),
+        latestPlaneRefusalState: () => webAdmin.latestPlaneRefusalState(),
         configHandoffState: () => webAdmin.configHandoffState(),
         mcpRevocations,
         mcpRevocationState: () => webAdmin.mcpRevocationState(),
@@ -225,7 +227,7 @@ export async function runStage10(ctx) {
         ...(runStore ? { runs: runStore } : {}),
         ...(workflowRunStore ? { workflows: workflowRunStore } : {}),
         agents: backgroundAgentStore,
-        hasPendingAsk: toolApproval ? (originTaskId) => toolApproval.hasLivePendingFrom(originTaskId) : undefined,
+        hasPendingAsk: toolApproval ? (names) => toolApproval.hasLivePendingFromLeg(names) : undefined,
         instanceId,
         logger,
         metrics,
@@ -342,6 +344,7 @@ export async function runStage10(ctx) {
         retentionLane: retentionLaneStarted,
         releaseRetentionLease: retentionLaneStore !== undefined ? () => retentionLaneStore.release(instanceId) : undefined,
         servingLease,
+        peerInbound: defaultPeerInboundFace,
     });
     servingLease?.resumeStickyDenial();
     return { ...ctx };

package/dist/boot/stores.d.ts

@@ -3,7 +3,6 @@ import { type MemorySyncRunner } from "../memory-sync-client.js";
 import type { Logger } from "../observability/logger.js";
 import type { Metrics } from "../observability/metrics.js";
 import { type MemorySyncStore } from "../plugins/memory-sync-store-pg.js";
-import { type MailboxRecipientLifecycle } from "../plugins/mailbox-recipient-lifecycle.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import { type StoreBackend } from "../plugins/store-backend.js";
 import { type MemoryScopeStores } from "../memory-scope-stores.js";
@@ -29,7 +28,10 @@ export declare function openStores(ctx: OpenStoresCtx): Promise<{
     memorySyncCursors: MemorySyncStore | undefined;
     rosterStore: import("@sema-agent/core").RosterStore | undefined;
     backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
-    mailboxRecipientLifecycle: MailboxRecipientLifecycle | undefined;
+    mailboxRecipientLifecycle: Readonly<{
+        retireRecipient: NonNullable<import("@sema-agent/core").MailboxStore["retireRecipient"]>;
+        listRetiredRecipients: NonNullable<import("@sema-agent/core").MailboxStore["listRetiredRecipients"]>;
+    }> | undefined;
     taskAttachmentStore: TaskAttachmentStore | undefined;
     mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
     memoryExportStores: MemoryScopeStores | undefined;
@@ -40,5 +42,6 @@ export declare function openStores(ctx: OpenStoresCtx): Promise<{
     memoryPosture: import("../memory-posture.js").MemoryPosture;
     taskListLane: import("./task-list-lane.js").TaskListLane;
     sqlEngine: import("../plugins/sql-driver.js").SqlEngineReading | undefined;
+    sessionCaptureRecords: import("../plugins/store-backend.js").SessionCaptureRecordSource | undefined;
 }>;
 //# sourceMappingURL=stores.d.ts.map

package/dist/boot/stores.js

@@ -12,7 +12,7 @@ import { MinioBlobBackend } from "../plugins/blob-backend.js";
 import { ensureSnapshotBuckets } from "../plugins/snapshot-bucket-presence.js";
 import { PgBackgroundAgentStore, TiDBBackgroundAgentStore, ensurePgBackgroundAgentSchema, ensureTiDBBackgroundAgentSchema } from "../stores-sql/background-agent-store-sql.js";
 import { PgMailboxStore, TiDBMailboxStore, ensurePgMailboxSchema, ensureTiDBMailboxSchema } from "../plugins/mailbox-store-sql.js";
-import { createDropOnlyRecipientLifecycle } from "../plugins/mailbox-recipient-lifecycle.js";
+import { recipientLifecycleOf } from "../plugins/mailbox-recipient-lifecycle.js";
 import { PgUsageWindowStore, TiDBUsageWindowStore, ensurePgUsageWindowSchema, ensureTiDBUsageWindowSchema } from "../stores-sql/usage-window-store-sql.js";
 import { PgRosterStore, TiDBRosterStore, ensurePgRosterSchema, ensureTiDBRosterSchema } from "../plugins/roster-store-sql.js";
 import { LocalTaskAttachmentStore } from "../plugins/local-task-attachment-store.js";
@@ -29,7 +29,7 @@ import { assertCloudSnapshotBlobPosture, openStoreBackendWithFallback } from "..
 import { createMemoryEngineIncidentSink } from "../memory-incident-sink.js";
 import { announceLockedLegacyMemoryLayers } from "../memory-layer-legacy-lock.js";
 import { createEngineNoticeForwarder } from "./runner-deps.js";
-import { buildMemoryRemoteLaneWarn, memoryEngineBackendFor, memoryEngineRemoteLanePosture, memoryEngineRootFor, memoryLayersNamedBy, memoryMountRootOf } from "../memory-scope.js";
+import { buildMemoryRemoteLaneWarn, memoryEngineBackendFor, memoryEngineRemoteLanePosture, memoryEngineRootFor, memoryMountRootOf } from "../memory-scope.js";
 import { createMemoryScopeStores } from "../memory-scope-stores.js";
 import { assertToolResultProvenanceSchema } from "../plugins/tool-result-store-sql.js";
 import { assertPermissionRuleApprovalSchema, assertPermissionRuleTicketSchema } from "../plugins/permission-rule-store-sql.js";
@@ -124,7 +124,8 @@ export async function openStores(ctx) {
     let memoryEngine;
     const engineDataRoot = memoryEngineRootFor(config, localRoot);
     const memoryEngineIncident = createMemoryEngineIncidentSink({ logger, metrics });
-    const scopeStoresOver = (deployment) => createMemoryScopeStores({ backend: deployment, root: engineDataRoot, namedLayers: () => memoryLayersNamedBy(config), onIncident: memoryEngineIncident });
+    const sessionCaptureRecords = backend?.sessionCaptureRecords();
+    const scopeStoresOver = (deployment) => createMemoryScopeStores({ backend: deployment, root: engineDataRoot, onIncident: memoryEngineIncident, ...(sessionCaptureRecords !== undefined ? { captureRecords: sessionCaptureRecords } : {}) });
     let memorySyncCursors;
     let vectorMode;
     if (config.memoryEngineBackend !== "file" && config.memoryEngineEnabled) {
@@ -301,20 +302,19 @@ export async function openStores(ctx) {
             await ensurePgMailboxSchema(async (text, params) => pgPool.query(text, params));
             const store = new PgMailboxStore(pgPool, logger);
             mailboxStore = store;
-            mailboxRecipientLifecycle = store;
         }
         else if (mysqlPool) {
             await ensureTiDBMailboxSchema(mysqlPool);
             const store = new TiDBMailboxStore(mysqlPool, logger);
             mailboxStore = store;
-            mailboxRecipientLifecycle = store;
         }
         else if (backend?.kind === "local") {
             mailboxStore = new FileMailboxStore(config.localDataRoot ?? localRoot, {
                 onCorruptRead: createCorruptReadFailOpenSeat("server.mailbox.corrupt-record-skipped"),
             });
-            mailboxRecipientLifecycle = createDropOnlyRecipientLifecycle(mailboxStore);
         }
+        if (mailboxStore)
+            mailboxRecipientLifecycle = recipientLifecycleOf(mailboxStore);
         if (mailboxStore) {
             const laneVerdict = mailboxCrossProcessMountVerdict(mailboxStore);
             logger.info("mailbox_store_enabled", {
@@ -439,7 +439,7 @@ export async function openStores(ctx) {
     return {
         backend, storePosture, memoryEngine, engineDataRoot, memorySyncCursors, rosterStore, backgroundAgentStore, mailboxRecipientLifecycle,
         taskAttachmentStore, mailboxStore, memoryExportStores, memorySyncRunner, sessionStore, breakerState,
-        usageWindowStore, memoryPosture, taskListLane, sqlEngine,
+        usageWindowStore, memoryPosture, taskListLane, sqlEngine, sessionCaptureRecords,
     };
 }
 //# sourceMappingURL=stores.js.map

package/dist/boot/web-admin.d.ts

@@ -1,4 +1,4 @@
-import { type ModelRefusalsSignal } from "@sema-agent/settings-schema";
+import { type ModelPlaneRefusalCode, type ModelRefusalsSignal } from "@sema-agent/settings-schema";
 import { CenterPromptSource, type SwappableDeps } from "@sema-agent/core";
 import { buildPricing } from "../budget.js";
 import { type Scenario, type ScenarioDeps, type ScenarioDetail } from "../capabilities/scenarios.js";
@@ -128,6 +128,10 @@ export interface WebAdminRuntime {
      *  名 → 码 + 组拒码)。描述**最近一次被判的那份中心候选目录**(每次候选 apply 的报告 `ApplyReport.modelRefusals` 投影;组拒时就是被拒
      *  的那份 —— 引擎自己的拒因表不换代)。没有可报的拒 / 没有配置管道 / 还没判过候选 ⇒ `undefined`(键缺席)。值变了 ⇒ 通知自报订阅者。 */
     modelRefusalsState(): ModelRefusalsSignal | undefined;
+    /** `GET /v1/models.modelPlane` 的 `planeRefusalCode` 与 `catalog` 的模型面那一半的**同一只**取值口:**最新到达**的目录候选被模型面组拒的码。
+     *  在场 ⇔ 模型拒因信号带 `plane` ∧ 落下它的那次 apply 是最新一次到达(到达计数相等,不按收货序数比 —— 本地腿只改决定文件时同一序数再到达)。
+     *  与 {@link modelRefusalsState} 的 `plane` 分两个主语:那一键 = 最近一份**被 stage 判过**的模型面的组拒判决(不随更新的到达撤);本口随每一次更新的到达撤。 */
+    latestPlaneRefusalState(): ModelPlaneRefusalCode | undefined;
     /** [ref]:`GET /v1/models.candidateRejected` 的取值口 —— 最近一次候选被判官整拒的结论(`candidateRejection` 座;域集就是判官交出的 `rejected.domains`)。
      *  present-iff 当前生效的配置是因判官整拒了最近一份候选而回落的那一份:后来的候选被判 clean 即撤下;还没判过候选 / 没有配置管道 ⇒ `undefined`(键缺席)。
      *  dry-run 姿势(`webAdmin.dryRun`,compare-only)恒 `undefined`:候选从不被应用,生效配置恒是 env,拒判是预演读数(日志行照响),不是配置没换的原因。 */

package/dist/boot/web-admin.js

@@ -18,6 +18,7 @@ import { createCenterConfigTier } from "../center-config-tier.js";
 import { buildCenterCredentialHealthView, createCenterCredentialRenewer } from "../center-credential-renewer.js";
 import { centerManagedConfigKeys } from "../web-admin-client/apply-effective.js";
 import { configSourceKind, createConfigProvider, raceBootFetch, BOOT_FETCH_DEFERRED } from "../config-provider.js";
+import { REMOTE_CATALOG_SOURCE } from "../env-model-table-gate.js";
 import { ConfigDirUntrustedError } from "../config-dir-trust.js";
 import { createKeyResolver } from "../key-resolver.js";
 import { buildSealedKeyPublicFace, ensureCheckpointCtxSealing, ensureSealedKeyStore, reportExecutionPublicKey } from "../sealed-key.js";
@@ -55,11 +56,14 @@ export async function createWebAdminRuntime(ctx) {
     let latestEffective;
     let candidateRejection;
     let judgedOrdinal = 0;
-    const noteCandidateVerdict = (ordinal, rejection) => {
+    let arrivalSeq = 0;
+    const admitArrival = (ordinal, rejection) => {
         if (ordinal < judgedOrdinal)
-            return;
+            return { seq: undefined };
         judgedOrdinal = ordinal;
         candidateRejection = rejection;
+        arrivalSeq += 1;
+        return { seq: arrivalSeq };
     };
     const applyLedger = createConfigApplyLedger();
     let lastPull = "none";
@@ -88,6 +92,7 @@ export async function createWebAdminRuntime(ctx) {
     let bootSkillStale = false;
     let pendingRestart;
     let modelRefusals;
+    let modelRefusalsArrival;
     const cc = config.webAdmin;
     const bootCredential = cc?.credential.read();
     const bootVerdict = bootCredential === undefined ? undefined : judgeCenterCredentialAtBoot(bootCredential);
@@ -208,7 +213,7 @@ export async function createWebAdminRuntime(ctx) {
         const domains = verdict.domains.join(",");
         if (candidateRejection?.version === r.effective.version && candidateRejection.domains.join(",") === domains)
             return;
-        noteCandidateVerdict(ordinal, candidateRejectionOf(r, verdict, candidateSource().kind, Date.now()));
+        admitArrival(ordinal, candidateRejectionOf(r, verdict, candidateSource().kind, Date.now()));
         logger.warn("config_candidate_rejected", buildCandidateRejectedFields(r, verdict, leg, { lkgVersion: latestEffective?.version ?? "(env)", ...localDirField }));
     };
     const noteSourceAtApplied = () => {
@@ -217,7 +222,7 @@ export async function createWebAdminRuntime(ctx) {
         if (rejected === undefined || rejected.version === appliedVersion)
             return;
         const gen = generationOf(appliedVersion);
-        noteCandidateVerdict(gen, undefined);
+        admitArrival(gen, undefined);
         if (!cc?.dryRun)
             applyLedger.applied(gen, appliedVersion);
         logger.info("config_source_back_to_applied", {
@@ -258,8 +263,9 @@ export async function createWebAdminRuntime(ctx) {
         if (!same)
             notifySelfReport("model_refusals");
     };
-    const recordApply = (rep) => {
+    const recordApply = (rep, ticket) => {
         applyLedger.recordApply(rep);
+        modelRefusalsArrival = ticket.seq;
         publishModelRefusals(buildModelRefusalsSignal(rep.modelRefusals));
     };
     let adoptedArtifact;
@@ -518,19 +524,21 @@ export async function createWebAdminRuntime(ctx) {
             const lkgEffective = read.lkg.effective;
             candidateIdentity.set(lkgEffective, identity);
             bindValidator(read.lkg.etag, identity);
-            return { effective: lkgEffective, ...(read.lkg.etag !== undefined ? { etag: read.lkg.etag } : {}), prompts: read.prompts };
+            return { effective: lkgEffective, ...(read.lkg.etag !== undefined ? { etag: read.lkg.etag } : {}), prompts: read.prompts, catalogSource: REMOTE_CATALOG_SOURCE };
         };
         const bootApplyLkgInline = async (lkgR) => {
             const lkgGen = generationOf(lkgR.effective.version);
             applyLedger.seenTarget(lkgGen, lkgR.effective.version);
+            const lkgArrival = admitArrival(lkgGen, undefined);
             let lkgReport;
             applyEffective(config, lkgR.effective, logger, {
                 leg: "boot",
+                catalogSource: lkgR.catalogSource,
                 sealedKeys,
                 generation: lkgGen,
                 report: (rep) => {
                     lkgReport = rep;
-                    recordApply(rep);
+                    recordApply(rep, lkgArrival);
                 },
             });
             const lkgIdentity = candidateIdentityOf(lkgR.effective);
@@ -613,7 +621,7 @@ export async function createWebAdminRuntime(ctx) {
                     }
                     else {
                         warnReadNotices(r, "boot");
-                        logEffectiveDiff(config, r.effective, logger);
+                        logEffectiveDiff(config, r.effective, r.catalogSource, logger);
                         ccEtag = r.etag;
                     }
                 }
@@ -631,14 +639,16 @@ export async function createWebAdminRuntime(ctx) {
                         warnReadNotices(r, "boot");
                         const bootGen = generationOf(r.effective.version);
                         applyLedger.seenTarget(bootGen, r.effective.version);
+                        const bootArrival = admitArrival(bootGen, undefined);
                         let bootReport;
                         applyEffective(config, r.effective, logger, {
                             leg: "boot",
+                            catalogSource: r.catalogSource,
                             sealedKeys,
                             generation: bootGen,
                             report: (rep) => {
                                 bootReport = rep;
-                                recordApply(rep);
+                                recordApply(rep, bootArrival);
                             },
                         });
                         markApplied(bootGen, r.effective);
@@ -651,7 +661,7 @@ export async function createWebAdminRuntime(ctx) {
                             const lkgPlane = await bootFromLkg("boot candidate's model plane was refused", "model-plane");
                             if (lkgPlane) {
                                 let planeReport;
-                                applyEffective(config, withModelPlaneOf(r.effective, lkgPlane.effective), logger, { leg: "boot", sealedKeys, generation: bootGen, report: (rep) => (planeReport = rep) });
+                                applyEffective(config, withModelPlaneOf(r.effective, lkgPlane.effective), logger, { leg: "boot", catalogSource: lkgPlane.catalogSource, sealedKeys, generation: bootGen, report: (rep) => (planeReport = rep) });
                                 if (modelPlaneCommitted(planeReport)) {
                                     bootPlaneEff = lkgPlane.effective;
                                     logger.warn("config_model_plane_from_lkg", { version: r.effective.version, lkgVersion: lkgPlane.effective.version, note: "the live candidate's model plane was refused at boot — serving the LKG's model plane (the catalog and what rides with it) with the live candidate's other groups; the refresh cadence re-judges the candidate" });
@@ -746,6 +756,7 @@ export async function createWebAdminRuntime(ctx) {
         restartState: () => buildRestartSignal(pendingRestart, planeDeferredNoHandoff),
         configHandoffState: () => (configProvider === undefined || configProvider.kind === "local" || !lkgSurvivesRestart ? undefined : buildConfigHandoff(latchHandoff(), handoffMissingSince)),
         modelRefusalsState: () => modelRefusals,
+        latestPlaneRefusalState: () => (modelRefusals?.plane !== undefined && modelRefusalsArrival !== undefined && modelRefusalsArrival === arrivalSeq ? modelRefusals.plane : undefined),
         candidateRejectionState: () => (cc?.dryRun ? undefined : candidateRejection),
         configApplyState: () => (configProvider ? applyLedger.view() : undefined),
         centerPullState: () => {
@@ -905,11 +916,12 @@ export async function createWebAdminRuntime(ctx) {
                     const committed = applyEffective(config, eff, logger, {
                         leg: "hot",
                         checkpointStorePresent,
+                        catalogSource: c.catalogSource,
                         sealedKeys,
                         generation: gen,
                         report: (rep) => {
                             report = rep;
-                            recordApply(rep);
+                            recordApply(rep, c.arrival);
                         },
                         ...(planeChanged ? { swapPlane: swapRunnerDeps } : {}),
                     });
@@ -937,14 +949,14 @@ export async function createWebAdminRuntime(ctx) {
                 const demoteToNoCenter = async (awaiting) => {
                     const gen = reserveArrivalGeneration();
                     applyLedger.seenTarget(gen, NO_CENTER_EFFECTIVE.version);
-                    const hot = await commitHot({ eff: NO_CENTER_EFFECTIVE, prompts: undefined, gen, phase: "no-center" });
+                    const arrival = admitArrival(gen, undefined);
+                    const hot = await commitHot({ eff: NO_CENTER_EFFECTIVE, catalogSource: REMOTE_CATALOG_SOURCE, prompts: undefined, gen, arrival, phase: "no-center" });
                     if (!hot.committed) {
                         throw new Error("the no-center tier was refused (the Runners did not accept the env model table) — the previous account's center configuration is still in force; retried next tick");
                     }
                     if (hot.report !== undefined && !hot.report.fullyApplied) {
                         logger.warn("center_identity_demotion_partial", { groups: refusedGroups(hot.report).map((g) => g.group), note: "a group of the no-center tier was refused — that group keeps its previous values (loud; the env base for that group could not be applied)" });
                     }
-                    noteCandidateVerdict(gen, undefined);
                     latestEffective = undefined;
                     ccEtag = undefined;
                     announceTier(tier.demote(awaiting, hot.report !== undefined ? refusedGroups(hot.report).map((g) => g.group) : []));
@@ -1013,14 +1025,14 @@ export async function createWebAdminRuntime(ctx) {
                                 announceCandidateRejected(r, verdict, arrival !== undefined ? "late-boot" : "refresh", tickGen);
                                 return "ok";
                             }
-                            noteCandidateVerdict(tickGen, undefined);
+                            const tickArrival = admitArrival(tickGen, undefined);
                             warnReadNotices(r, "refresh");
                             if (ccRef?.dryRun) {
-                                logEffectiveDiff(config, r.effective, logger);
+                                logEffectiveDiff(config, r.effective, r.catalogSource, logger);
                                 ccEtag = r.etag;
                             }
                             else {
-                                const hot = await commitHot({ eff: r.effective, prompts: verdict.prompts, gen: tickGen, phase: "refresh" });
+                                const hot = await commitHot({ eff: r.effective, catalogSource: r.catalogSource, prompts: verdict.prompts, gen: tickGen, arrival: tickArrival, phase: "refresh" });
                                 if (!hot.committed)
                                     return "ok";
                                 const applyReport = hot.report;
@@ -1127,14 +1139,14 @@ export async function createWebAdminRuntime(ctx) {
                         announceCandidateRejected(r, lateVerdict, "late-boot", lateGen);
                         return;
                     }
-                    noteCandidateVerdict(lateGen, undefined);
+                    const lateArrival = admitArrival(lateGen, undefined);
                     warnReadNotices(r, "boot-deferred");
                     if (ccRef?.dryRun) {
-                        logEffectiveDiff(config, r.effective, logger);
+                        logEffectiveDiff(config, r.effective, r.catalogSource, logger);
                         ccEtag = r.etag;
                         return;
                     }
-                    const hotLate = await commitHot({ eff: r.effective, prompts: lateVerdict.prompts, gen: lateGen, phase: "boot-deferred" });
+                    const hotLate = await commitHot({ eff: r.effective, catalogSource: r.catalogSource, prompts: lateVerdict.prompts, gen: lateGen, arrival: lateArrival, phase: "boot-deferred" });
                     if (!hotLate.committed)
                         return;
                     const applyReportLate = hotLate.report;

package/dist/capabilities/hands-lane.d.ts

@@ -12,8 +12,8 @@
  *     不是静默继承 full(词表闭集纪律)。
  *  ② {@link HANDS_EXCLUSIVE_TOOL_NAMES} + {@link handsDenyPolicy} —— 纵深:hands=none 的任务即便被误接到
  *     有手 Runner 上,手独占名单逐一 deny。**不是**主保证(主保证是根本不挂 factory ⇒ 工具面不可见)。
- *  ③ {@link stampHandsLane} / {@link handsLaneOf} —— 车道作为 TaskSpec 上的**显式字段**([ref]):
- *     resolveSpec 出口铸一次,执行点读一次,**缺席即拒**(不是回落最宽车道)。
+ *  ③ {@link createHandsRunnerSelector} —— 车道是这条腿的部署事实(`leg-facts.ts`:装配器出口铸一次,两只漏斗以装配输出调选路器时读一次),
+ *     **缺席即拒**(不是回落最宽车道)。
  */
 import { type Runner, type TaskSpec, type ToolPolicy } from "@sema-agent/core";
 /** 场景对手带工具面的表态(闭集)。`full` = core 手带 band 照常 mount;`none` = 不挂 executionEnvFactory 的 Runner。 */
@@ -114,32 +114,7 @@ export declare function tightenWithHandsDeny(base: ToolPolicy | undefined): Tool
 /** 装配点的取用形:`full` 原样放行基线,`none` 叠 deny。**穷举 switch**,无缺省臂。 */
 export declare function toolPolicyForHands(hands: ScenarioHands, base: ToolPolicy | undefined): ToolPolicy | undefined;
 /**
- * 执行车道在 TaskSpec 上的**显式字段键**([ref];修前是一张以 spec **对象身份**为键的 WeakMap 旁表)。
- *
- * 为什么是 symbol 而不是字符串键:`TaskSpec` 是**上游 core 的类型面**,一个字符串键会进
- * `Object.keys` / `JSON.stringify` / core 自己的键审计,等于 server 在别人的契约上私自加一个键;
- * symbol 键随 spread(`{...spec}`)与 rest 解构(`const {objective, ...taskConfig} = spec`)结构性
- * 地跟着走,却对上游的键面**不可见**(结构化克隆与 JSON 同样跳过 symbol 键)。于是「车道是 spec 上
- * 的一个字段、复制 spec 不丢车道」与「不污染上游契约」两件事同时成立。
- *
- * 修前的旁表要求「从 resolveSpec 出来的那一只对象必须一路原样活到执行点」——一条**隐形**的对象身份
- * 契约:任何一次 `{...spec}` 都会静默把车道降级成最宽的 `full`(实测:登记 `none` 的 spec 复制后
- * `laneOf` 答 `full`)。字段化把那条隐形要求整条删掉。
- */
-export declare const HANDS_LANE_FIELD: unique symbol;
-/** 已铸车道的 TaskSpec。铸点唯一(`boot/resolve-spec.ts` 的 resolveSpec 出口),读点唯一({@link handsLaneOf})。 */
-export type LanedTaskSpec = TaskSpec & {
-    readonly [HANDS_LANE_FIELD]: ScenarioHands;
-};
-/**
- * 铸车道(**单一属主**:只允许 resolveSpec 的出口调用)。
- *
- * 字段是 `enumerable`(所以复制得走)、`writable:false` + `configurable:false`(所以同一只 spec 被
- * 第二次铸车道会当场 TypeError —— 两个写者是漂移的成因,响亮好过后到者悄悄赢)。
- */
-export declare function stampHandsLane<T extends TaskSpec>(spec: T, hands: ScenarioHands): T & LanedTaskSpec;
-/**
- * 车道字段缺席的拒因 —— 具名类,便于调用点/测试按类型判,而不是嗅文案。
+ * 车道读不到的拒因 —— 具名类,便于调用点/测试按类型判,而不是嗅文案。
  *
  * 🔴 **刻意不是 `HttpError`、刻意不铸新的 wire 错误码**:它落到 `http/server.ts` 的兜底 catch,
  * wire 上是 500 `internal.error`(内部文本不回显,只进 `request_error` 日志行)。理由两条:
@@ -153,19 +128,14 @@ export declare class HandsLaneUnstampedError extends Error {
     constructor();
 }
 /**
- * 读车道 —— **缺席即拒**([ref] P 类:车道选择是保护型量,fail-closed;`observability/fail-open.ts`
- * 头注把「车道选择」逐字列在「正解是 fail-closed,不是留痕后继续放行」那一族里)。
+ * 装配点的选路席:`{full, handsless}` 两只 Runner + 这条腿的车道 ⇒ 本任务跑哪一只。公共缝 `runnerFor(spec)` 的生产实现;
+ * 两只漏斗(受理 / 续跑)以**装配器输出的那一只对象**调它(`leg-facts.ts`:读在 `stampSpecRoot` 复制之前)。
  *
- * 修前此处是 `?? "full"`:一只没经过本仓 resolver 的 spec 会**静默拿到最宽的车道**(全量可写手带)。
- * 「唯一可达形是测试桩」这个论证不是防线 —— 它是一句关于今天调用图的断言,而防线要防的正是明天多出
- * 来的第二个执行点。缺席现在整只拒(500 + 日志留原句),而不是把一个未经裁定的任务放进有手车道。
- */
-export declare function handsLaneOf(spec: TaskSpec): ScenarioHands;
-/**
- * 装配点的选路席:`{full, handsless}` 两只 Runner + 车道字段 ⇒ 本任务跑哪一只。
+ * 车道读不到 ⇒ **缺席即拒**([ref] P 类:车道选择是保护型量,fail-closed;`observability/fail-open.ts` 头注把「车道选择」逐字列在
+ * 「正解是 fail-closed,不是留痕后继续放行」那一族里)。读不到的两种来路:嵌入方自带的 `resolveSpec`(不铸本仓的腿事实),
+ * 或有人把复制品交了进来(读晚了)—— 都整只拒(500 + 日志留原句),绝不把一个未经裁定的任务放进最宽的有手车道。
  *
- * 具名工厂而不是在 main.ts 手搓闭包:选路规则(读字段 → 穷举 switch)于是只有**一份实现**,
- * 测试与生产装配拿的是同一只(手搓等价闭包 = 第二真源,正是本件要删的那一类)。
+ * 具名工厂而不是在 main.ts 手搓闭包:选路规则(读车道 → 穷举 switch)于是只有**一份实现**,测试与生产装配拿的是同一只。
  */
 export declare function createHandsRunnerSelector(pair: HandsRunnerPair): (spec: TaskSpec) => Runner;
 //# sourceMappingURL=hands-lane.d.ts.map

package/dist/capabilities/hands-lane.js

@@ -1,4 +1,5 @@
 import { handBandEffects, judgeRuleToolName, combinePolicies, createAllowDenyPolicy } from "@sema-agent/core";
+import { legFactsOf } from "../leg-facts.js";
 import { TOOL_NAME_ROSTER } from "../namespaced-rule-name.js";
 export function withoutHands(deps) {
     const { executionEnvFactory: _handsDropped, ...rest } = deps;
@@ -29,7 +30,7 @@ export const HANDS_BAND_TOOL_NAMES = Object.freeze([
     "ExitWorktree",
     "ListAgents",
 ].filter((n, i, all) => judgeRuleToolName(n, TOOL_NAME_ROSTER).kind === "current" && all.indexOf(n) === i));
-export const HANDS_DUAL_USE_TOOL_NAMES = Object.freeze(["TaskOutput", "TaskStop", "SendMessage", "AgentTranscript", "ListAgents"]);
+export const HANDS_DUAL_USE_TOOL_NAMES = Object.freeze(["TaskStop", "SendMessage", "AgentTranscript", "ListAgents"]);
 export const HANDS_EXCLUSIVE_TOOL_NAMES = Object.freeze(HANDS_BAND_TOOL_NAMES.filter((n) => !HANDS_DUAL_USE_TOOL_NAMES.includes(n)));
 export const OFFICE_KEPT_HAND_TOOL_NAMES = Object.freeze(["Read", "Glob", "Grep"]);
 export const OFFICE_EXCLUDED_TOOL_NAMES = Object.freeze(HANDS_EXCLUSIVE_TOOL_NAMES.filter((n) => !OFFICE_KEPT_HAND_TOOL_NAMES.includes(n)));
@@ -48,24 +49,18 @@ export function toolPolicyForHands(hands, base) {
             return tightenWithHandsDeny(base);
     }
 }
-export const HANDS_LANE_FIELD = Symbol("sema-server.handsLane");
-export function stampHandsLane(spec, hands) {
-    Object.defineProperty(spec, HANDS_LANE_FIELD, { value: hands, enumerable: true, writable: false, configurable: false });
-    return spec;
-}
 export class HandsLaneUnstampedError extends Error {
     constructor() {
         super("execution lane is not stamped on this task spec — refusing to run it rather than falling back to the widest (full-hands) lane");
         this.name = "HandsLaneUnstampedError";
     }
 }
-export function handsLaneOf(spec) {
-    const lane = spec[HANDS_LANE_FIELD];
-    if (lane === undefined)
-        throw new HandsLaneUnstampedError();
-    return lane;
-}
 export function createHandsRunnerSelector(pair) {
-    return (spec) => pickHandsRunner(handsLaneOf(spec), pair);
+    return (spec) => {
+        const hands = legFactsOf(spec)?.hands;
+        if (hands === undefined)
+            throw new HandsLaneUnstampedError();
+        return pickHandsRunner(hands, pair);
+    };
 }
 //# sourceMappingURL=hands-lane.js.map

package/dist/capabilities/mcp-probe.d.ts

@@ -354,8 +354,9 @@ export declare function buildMcpProbeInflightRefusal(): McpProbeRefusal;
  * 在任何传输被触碰**之前**就被拒)。
  *
  * 异源复核 [medium]:修前这一形在两条口上都被抛给分派器尾 ⇒ `500 internal.error`。可自带申报那一口的申报
- * 是**调用方**写的,把它答成 500 是把调用方的错说成这台机器故障;中心申报那一口反过来 —— 那是部署方写的,
- * 5xx 才是对的方向。⇒ 一条规则:**谁写的申报,谁的错**。
+ * 是**调用方**写的,把它答成 500 是把调用方的错说成这台机器故障 ⇒ 自带申报那一口答 400 `request.field_invalid`(本句)。
+ * 中心申报那一口**不走本句**:那是部署方写的、部署上挂不起来,引擎的拒按同步提交腿读的同一张「码 → 状态」表读成应答
+ * (409 `config.mcp_server_name_collision` + 引擎原句,`http/engine-refusal.ts`),与同一份声明集在提交腿上的答复同码同状态同句。
  *
  * 🔴 **不回显因由**:那句话来自申报集本身,可能带调用方的内情(名字、地址形)。调用方手里有自己的体,
  * 点名「两台撞了命名空间」就够他自己找;原文留在那一层的日志里。