@sema-agent/server 7.148.0 → 7.149.0

package/dist/boot/stage-02-web-admin-pull.js

@@ -12,18 +12,25 @@ import { defaultModelRefusal, refusedNameMintedRefusal } from "../model-entry-re
 import { isRosterGateArmed } from "../config.js";
 import { judgeServedModelRoute } from "../model-route-endpoint.js";
 import { servedModelTableLeg } from "../model-select.js";
+import { warnAssumedContextWindows } from "../context-window-notice.js";
 import { captureBootStoreEvidence } from "./store-evidence.js";
+import { admitStoreDurability } from "../store-admission.js";
+import { provisionSemaConfigDir } from "../sema-config-dir.js";
 export async function runStage02(ctx) {
     const { config: loaded, localRoot, logger, metrics } = ctx;
     const storeEvidence = await captureBootStoreEvidence({ config: loaded, localRoot });
     const configSource = configSourceKind(loaded);
     if (configSource === "local") {
         await assertLocalConfigDirTrusted({ root: localRoot, declaredOwnerUid: loaded.configLocalOwnerUid });
-        const envModelsMigration = { root: localRoot, env: process.env, envTableIsPlaceholder: isRosterGateArmed(loaded.webAdmin) };
-        logEnvModelsMigration(logger, envModelsMigration, await runEnvModelsMigration(envModelsMigration));
         logConfigDirMigration(logger, await migrateLocalConfigDirectory(localRoot));
     }
     const config = await composeExecutionLane(loaded, { configSource, localRoot, logger, entry: HTTP_SERVICE_LANE_ENTRY });
+    admitStoreDurability(config, storeEvidence);
+    provisionSemaConfigDir(config, logger);
+    if (configSource === "local") {
+        const envModelsMigration = { root: localRoot, env: process.env, envTableIsPlaceholder: isRosterGateArmed(config.webAdmin) };
+        logEnvModelsMigration(logger, envModelsMigration, await runEnvModelsMigration(envModelsMigration));
+    }
     announceConfigRootEnclosingWorkspace(config, logger, launchWorkspaceOf(config));
     const webAdmin = await createWebAdminRuntime({ config, logger, metrics, localRoot });
     const servedLeg = servedModelTableLeg(config);
@@ -40,6 +47,7 @@ export async function runStage02(ctx) {
     if (mintedRefused !== undefined) {
         throw new Error(mintedRefused);
     }
+    warnAssumedContextWindows(config, logger, { envTableIsPlaceholder: isRosterGateArmed(config.webAdmin) });
     const ceilingVerdict = createUnpricedCeilingVerdict({ config, logger });
     ceilingVerdict.judge();
     return { ...ctx, config, ceilingVerdict, storeEvidence, webAdmin };

package/dist/boot/stage-03-store-backend.d.ts

@@ -30,6 +30,7 @@ export declare function runStage03(ctx: Awaited<ReturnType<typeof runStage02>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stage-03-store-backend.js

@@ -1,8 +1,8 @@
 import { uuidv7 } from "@sema-agent/core";
 import { openStores } from "./stores.js";
 export async function runStage03(ctx) {
-    const { config, localRoot, logger, metrics, storeEvidence } = ctx;
-    const { backend, storePosture, memoryEngine, engineDataRoot, memorySyncCursors, rosterStore, backgroundAgentStore, sessionCaptureRecords, taskAttachmentStore, mailboxStore, mailboxRecipientLifecycle, memoryExportStores, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngine, storeSweep, } = await openStores({ config, logger, metrics, localRoot, storeEvidence });
+    const { config, localAdmission, localRoot, logger, metrics, storeEvidence } = ctx;
+    const { backend, storePosture, memoryEngine, engineDataRoot, memorySyncCursors, rosterStore, backgroundAgentStore, sessionCaptureRecords, taskAttachmentStore, mailboxStore, mailboxRecipientLifecycle, memoryExportStores, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngine, storeSweep, } = await openStores({ config, logger, metrics, localRoot, storeEvidence, localAdmission });
     const adoptionWiring = { memoryEngine: memoryExportStores !== undefined, taskAttachment: taskAttachmentStore !== undefined };
     const instanceId = uuidv7();
     return { ...ctx, adoptionWiring, backend, backgroundAgentStore, breakerState, engineDataRoot, instanceId, mailboxRecipientLifecycle, mailboxStore, memoryEngine, memoryExportStores, memoryPosture, memorySyncCursors, memorySyncRunner, rosterStore, sessionCaptureRecords, sessionStore, sqlEngine, storePosture, storeSweep, taskAttachmentStore, taskListLane, usageWindowStore };

package/dist/boot/stage-04-stores.d.ts

@@ -59,6 +59,7 @@ export declare function runStage04(ctx: Awaited<ReturnType<typeof runStage03>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stage-05-execution-env.d.ts

@@ -82,6 +82,7 @@ export declare function runStage05(ctx: Awaited<ReturnType<typeof runStage04>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stage-06-runners.d.ts

@@ -54,7 +54,7 @@ export declare function runStage06(ctx: Awaited<ReturnType<typeof runStage05>>):
     };
     workflowRunStore: import("../orchestration/workflow-notify-journal.js").JournalingWorkflowRunStore | undefined;
     workflowsCapable: boolean;
-    orgDeliveryGate: import("@sema-agent/core").OrgDeliveryGate | undefined;
+    orgDeliveryGate: import("../org-delivery-gate.js").ServerOrgDeliveryGate | undefined;
     deploymentMods: readonly import("@sema-agent/core").ModRegistration<import("@sema-agent/core").EngineDollar>[];
     deploymentModsLoaded: readonly import("./deployment-mods.js").LoadedModPackage[];
     belowTaskChainPatterns: readonly string[];
@@ -137,6 +137,7 @@ export declare function runStage06(ctx: Awaited<ReturnType<typeof runStage05>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stage-07-capability-layer.d.ts

@@ -76,7 +76,7 @@ export declare function runStage07(ctx: Awaited<ReturnType<typeof runStage06>>):
     };
     workflowRunStore: import("../orchestration/workflow-notify-journal.js").JournalingWorkflowRunStore | undefined;
     workflowsCapable: boolean;
-    orgDeliveryGate: import("@sema-agent/core").OrgDeliveryGate | undefined;
+    orgDeliveryGate: import("../org-delivery-gate.js").ServerOrgDeliveryGate | undefined;
     deploymentMods: readonly import("@sema-agent/core").ModRegistration<import("@sema-agent/core").EngineDollar>[];
     deploymentModsLoaded: readonly import("./deployment-mods.js").LoadedModPackage[];
     belowTaskChainPatterns: readonly string[];
@@ -159,6 +159,7 @@ export declare function runStage07(ctx: Awaited<ReturnType<typeof runStage06>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

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

@@ -89,7 +89,7 @@ export declare function runStage08(ctx: Awaited<ReturnType<typeof runStage07>>):
     };
     workflowRunStore: import("../orchestration/workflow-notify-journal.js").JournalingWorkflowRunStore | undefined;
     workflowsCapable: boolean;
-    orgDeliveryGate: import("@sema-agent/core").OrgDeliveryGate | undefined;
+    orgDeliveryGate: import("../org-delivery-gate.js").ServerOrgDeliveryGate | undefined;
     deploymentMods: readonly import("@sema-agent/core").ModRegistration<import("@sema-agent/core").EngineDollar>[];
     deploymentModsLoaded: readonly import("./deployment-mods.js").LoadedModPackage[];
     belowTaskChainPatterns: readonly string[];
@@ -172,6 +172,7 @@ export declare function runStage08(ctx: Awaited<ReturnType<typeof runStage07>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

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

@@ -108,7 +108,7 @@ export declare function runStage09(ctx: Awaited<ReturnType<typeof runStage08>>):
     };
     workflowRunStore: import("../orchestration/workflow-notify-journal.js").JournalingWorkflowRunStore | undefined;
     workflowsCapable: boolean;
-    orgDeliveryGate: import("@sema-agent/core").OrgDeliveryGate | undefined;
+    orgDeliveryGate: import("../org-delivery-gate.js").ServerOrgDeliveryGate | undefined;
     deploymentMods: readonly import("@sema-agent/core").ModRegistration<import("@sema-agent/core").EngineDollar>[];
     deploymentModsLoaded: readonly import("./deployment-mods.js").LoadedModPackage[];
     belowTaskChainPatterns: readonly string[];
@@ -191,6 +191,7 @@ export declare function runStage09(ctx: Awaited<ReturnType<typeof runStage08>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

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

@@ -107,7 +107,7 @@ export declare function runStage10(ctx: Awaited<ReturnType<typeof runStage09>>):
     };
     workflowRunStore: import("../orchestration/workflow-notify-journal.js").JournalingWorkflowRunStore | undefined;
     workflowsCapable: boolean;
-    orgDeliveryGate: import("@sema-agent/core").OrgDeliveryGate | undefined;
+    orgDeliveryGate: import("../org-delivery-gate.js").ServerOrgDeliveryGate | undefined;
     deploymentMods: readonly import("@sema-agent/core").ModRegistration<import("@sema-agent/core").EngineDollar>[];
     deploymentModsLoaded: readonly import("./deployment-mods.js").LoadedModPackage[];
     belowTaskChainPatterns: readonly string[];
@@ -190,6 +190,7 @@ export declare function runStage10(ctx: Awaited<ReturnType<typeof runStage09>>):
     ceilingVerdict: import("./unpriced-ceiling-verdict.js").UnpricedCeilingVerdict;
     storeEvidence: import("../store-posture.js").StoreEvidence;
     webAdmin: import("./web-admin.js").WebAdminRuntime;
+    localAdmission: import("../plugins/local-data-root-admission.js").LocalDataRootAdmission | undefined;
     localRoot: string;
     logger: import("../index.js").Logger;
     metrics: import("../index.js").Metrics;

package/dist/boot/stores.d.ts

@@ -6,6 +6,7 @@ import type { Metrics } from "../observability/metrics.js";
 import { type MemorySyncStore } from "../plugins/memory-sync-store-pg.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import { type StoreBackend } from "../plugins/store-backend.js";
+import type { LocalDataRootAdmission } from "../plugins/local-data-root-admission.js";
 import { type MemoryScopeStores } from "../memory-scope-stores.js";
 import { type StoreEvidence } from "../store-posture.js";
 export interface OpenStoresCtx {
@@ -15,6 +16,8 @@ export interface OpenStoresCtx {
     localRoot: string;
     /** 店的持久性起服证据(起服第 2 段段首 `captureBootStoreEvidence` 取的那一份;直接调本函数的测试同一只取证)。 */
     storeEvidence: StoreEvidence;
+    /** local 数据根准入读数(起服第 1 段在本进程第一笔写之前取的那一只;非 local = `undefined`)。直接调本函数的测试经 `test/helpers/open-stores.ts` 同一只准入取。 */
+    localAdmission: LocalDataRootAdmission | undefined;
 }
 /**
  * durable 回决腿的规则位给 `approval_ask` 加了 `rule_command`/`rule_scope_root` 两列,而 `ensureAsk` 的 INSERT 与每一条读**无条件**引用它们 ⇒ 存量表上整条流内审批协议

package/dist/boot/stores.js

@@ -21,7 +21,7 @@ import { LocalTaskAttachmentStore } from "../plugins/local-task-attachment-store
 import { PgTaskAttachmentStore, TiDBTaskAttachmentStore, ensurePgTaskAttachmentSchema, ensureTiDBTaskAttachmentSchema } from "../plugins/task-attachment-store.js";
 import { createSessionStore } from "../plugins/session-store.js";
 import { buildSqlPoolMissingRefusal, missingSqlCoordinateKeys } from "../sql-engine-coordinates.js";
-import { runAndLogOneTimeMigrations } from "../plugins/one-time-migrations.js";
+import { ONE_TIME_MIGRATIONS, runAndLogOneTimeMigrations } from "../plugins/one-time-migrations.js";
 import { createTaskListLane } from "./task-list-lane.js";
 import { ensurePgTaskListSchema, ensureTiDBTaskListSchema } from "../plugins/task-list-store-sql.js";
 import { assertDeviceAuditRebindEventSchema, ensurePgDeviceSchema, ensureTiDBDeviceSchema } from "../plugins/device-store-sql.js";
@@ -65,19 +65,29 @@ export function buildSessionBoxMountLine(verdict) {
         : { level: "warn", fields: { peerLaneMountable: false, peerLaneRefusal: verdict.code, reason: verdict.reason } };
 }
 export async function openStores(ctx) {
-    const { config, logger, metrics, localRoot, storeEvidence } = ctx;
+    const { config, logger, metrics, localRoot, storeEvidence, localAdmission } = ctx;
     let backend;
     let storeDegradedReason;
+    if (config.requirePrincipal && config.dbBackend === "local") {
+        throw new Error("REQUIRE_PRINCIPAL=true is not supported on the local file backend (DB_BACKEND=local): the lane is single-user " +
+            "by construction — a session created before owners were recorded is claimed by the FIRST principal that submits " +
+            "to it during the upgrade window, and the lane's mutual-recognition arms assume one user — so it cannot enforce " +
+            "a multi-tenant session boundary. Use a SQL backend (DB_BACKEND=mysql|pg) for multi-tenant, or run local " +
+            "single-user with REQUIRE_PRINCIPAL=false (a BFF may still inject x-agent-principal per request for memory " +
+            "scoping and audit attribution).");
+    }
     const dsnConfigured = !!(config.tidb || config.pg);
     await ensureSnapshotBuckets(config, logger);
     const wantDb = config.sessionBackend === "tidb" ||
         config.dbBackend === "local" ||
         (config.sessionBackend === "auto" && dsnConfigured);
     if (wantDb) {
-        const opened = await openStoreBackendWithFallback(config, logger, { runStallVerdicts: (landed) => metrics.inc("runs_reaped_total", { kind: "stale" }, landed) });
+        const opened = await openStoreBackendWithFallback(config, logger, { runStallVerdicts: (landed) => metrics.inc("runs_reaped_total", { kind: "stale" }, landed) }, localAdmission, { dataRootMedium: storeEvidence.dataRoot.verdict });
         backend = opened.backend;
         storeDegradedReason = opened.degradedReason;
     }
+    if (backend)
+        assertCloudSnapshotBlobPosture(backend.kind, config);
     {
         const mysqlPool = backend?.mysqlPool?.();
         const pgPool = backend?.pgPool?.();
@@ -108,8 +118,6 @@ export async function openStores(ctx) {
         else if (mysqlPool)
             await assertSessionExtCascadeOn(mysqlDriver(mysqlPool));
     }
-    if (backend)
-        await runAndLogOneTimeMigrations(logger, backend);
     if ((process.env.REWIND_SNAPSHOT_MAX_MB ?? "") !== "") {
         logger.warn("rewind_snapshot_max_mb_retired", {
             note: "REWIND_SNAPSHOT_MAX_MB no longer has an effect: the whole-tree snapshot epoch is retired (S-15); per-edited-file history captures only files the agent touches, with no tree walk and no size gate. Remove the env var. Per-blob SQL sizing is governed by SNAPSHOT_BLOB_SQL_MAX_BYTES / object storage as before.",
@@ -228,6 +236,7 @@ export async function openStores(ctx) {
         degradedReason: storeDegradedReason,
         evidence: storeEvidence,
         memoryRootWired: config.memoryEngineBackend === "file" && memoryEngine !== undefined,
+        localDeclaration: backend?.localStoreDeclaration?.(),
     });
     metrics.setGauge("store_backend_degraded", storePosture.degradedReason !== undefined ? 1 : 0);
     const freshStart = buildStoreFreshStartLine(storePosture, storeEvidence);
@@ -422,25 +431,19 @@ export async function openStores(ctx) {
                 await assertDeviceAuditRebindEventSchema(mysqlDriver(mysqlPool));
         }
     }
-    {
+    const reconcileSchema = async (pending) => {
         const mysqlPool = backend?.mysqlPool?.();
         const pgPool = backend?.pgPool?.();
         if (pgPool)
-            await assertSchemaMatchesCode(async (sql) => (await pgPool.query(sql)).rows, "pg");
+            await assertSchemaMatchesCode(async (sql) => (await pgPool.query(sql)).rows, "pg", pending);
         else if (mysqlPool)
-            await assertSchemaMatchesCode(async (sql) => (await mysqlPool.query(sql))[0], "mysql");
-    }
-    const sessionStore = createSessionStore(config, backend, metrics);
-    if (config.requirePrincipal && backend?.kind === "local") {
-        throw new Error("REQUIRE_PRINCIPAL=true is not supported on the local file backend (DB_BACKEND=local): the lane is single-user " +
-            "by construction — a session created before owners were recorded is claimed by the FIRST principal that submits " +
-            "to it during the upgrade window, and the lane's mutual-recognition arms assume one user — so it cannot enforce " +
-            "a multi-tenant session boundary. Use a SQL backend (DB_BACKEND=mysql|pg) for multi-tenant, or run local " +
-            "single-user with REQUIRE_PRINCIPAL=false (a BFF may still inject x-agent-principal per request for memory " +
-            "scoping and audit attribution).");
-    }
+            await assertSchemaMatchesCode(async (sql) => (await mysqlPool.query(sql))[0], "mysql", pending);
+    };
+    await reconcileSchema(ONE_TIME_MIGRATIONS);
     if (backend)
-        assertCloudSnapshotBlobPosture(backend.kind, config);
+        await runAndLogOneTimeMigrations(logger, backend);
+    await reconcileSchema([]);
+    const sessionStore = createSessionStore(config, backend, metrics);
     if (!config.requirePrincipal && headReadOf(sessionStore) !== undefined) {
         logger.warn("principal_optional", {
             note: "owner-aware session store with REQUIRE_PRINCIPAL=false — owned sessions are protected, but headerless callers can create/share anonymous sessions; set REQUIRE_PRINCIPAL=true for multi-tenant",

package/dist/capabilities/tool-defer.d.ts

@@ -12,7 +12,7 @@
  *  - 🔴 **候选 ≠ 延迟**(core 7.15.0 [ref] 的行为面收窄,本仓两条真后果见下):候选集整体受**一道**
  *    阈值门,全或无 —— 候选的内联字节(name+description+schema)≥ `floor(上下文 token × 10%) × 3`
  *    才延迟,否则**全内联且不挂 `ToolSearch`**。远端协议铸名因此**不再无条件占位**:本仓缺省窗
- *    (`ASSUMED_CONTEXT_WINDOW`,今天 262144 token)下阈值 = 78 642 字符,一个中小 MCP 名册够不着 ⇒ 首请求带全 schema。
+ *    (`ASSUMED_CONTEXT_WINDOW`,今天 131072 token)下阈值 = 39 321 字符,一个中小 MCP 名册够不着 ⇒ 首请求带全 schema。
  *    唯一不受门的是调用方的 `TaskSpec.deferTools` 字面名单(按字面恒延迟、不计量)。
  *  - `RunnerDeps.deferMode:"auto"` 不是第二道门,而是把候选集**拓宽**到全部 caller spec 后走同一道门 ——
  *    在本仓缺省场景下那会连 Agent 与 Task 四件一起卷进候选(与 CC 姿态相反),所以我们**刻意不开**;

package/dist/capability-facts.d.ts

@@ -473,10 +473,11 @@ export declare function deploymentModPackages(d: Pick<Deps, "deploymentModPackag
 export declare function hostScheduler(c: Pick<ServiceConfig, "schedulerEnabled" | "requirePrincipal" | "remoteExec">): Fact<"scheduler_disabled" | "multi_tenant_deployment" | "not_host_lane">;
 /**
  * 前台命令超时转后台(`AUTO_BACKGROUND_ON_TIMEOUT`)在这台部署上生不生效:旋钮开 ∧ 本车道的执行环境能把**运行中的**命令领养成后台任务。
- * 「能领养」就是执行环境的 `backgroundCapabilities.supportsDetach`,三只声明它的适配器(host / k8s / e2b)上它与后台 shell 的 `supported` 是同一个值 ——
- * 所以按能力表的 `backgroundShell` 一位读:`supported`(k8s / e2b)⇒ 能;`single-user-only`(只有 host 一行)⇒ 单用户且 host 后台 shell 开关开着才能 ——
- * 开关是第二参 `hostBackgroundShellOn`,调用方交 `hostBackgroundShellEnabled()`(`HOST_BG_ENABLED`;host 适配器的能力位读同一只;本模块零 I/O,不自己读 env)。
- * 对账钉 `test/auto-background-on-timeout.test.ts` 逐车道拿装配出的真执行环境的 `supportsDetach` 与本事实对拍。
+ * 「能领养」就是执行环境的 `backgroundCapabilities.supportsDetach`,三只声明它的适配器(host / k8s / e2b)上它与后台 shell 的 `supported` 是同一个值,
+ * 这个值的**唯一**答者是部署形行 `DEPLOYMENT_SHAPE_PREDICATES.backgroundShell`(读能力表那一位:k8s / e2b 任何租户,host 只单主)—— 适配器与本事实读同一行,
+ * 本事实不再自己读能力表的三档。host 另有一个全局关停开关(`HOST_BG_ENABLED`),是旋钮不是部署形,所以只在 host 车道上、在行之上合取:
+ * 开关是第二参 `hostBackgroundShellOn`,调用方交 `hostBackgroundShellEnabled()`(host 适配器的能力位读同一只;本模块零 I/O,不自己读 env)。
+ * 同读钉 `test/auto-background-on-timeout.test.ts` ③ 逐车道 × 单主 / 多租拿装配出的真执行环境的 `supported` / `supportsDetach` 与本事实、行对读。
  * 旋钮先判:关着的部署不论车道都答 `auto_background_off`(运维旋钮无条件,不支持的车道不拒启,只如实报)。
  * `/health.autoBackgroundOnTimeout` 投它的三词({@link autoBackgroundOnTimeoutWord})。
  */

package/dist/capability-facts.js

@@ -8,7 +8,7 @@ import { WEB_ADMIN_ENV } from "@sema-agent/settings-schema";
 import { blobExchangeOf, overwriteWipeIncapable } from "./session-sync.js";
 import { WORKSPACE_PERSIST_DEFAULT, WORKSPACE_SNAPSHOT_KEEP_DEFAULT, workspaceSnapshotTimeoutOf } from "./workspace-space.js";
 import { deletionHeadReadOf, headReadOf } from "./session-incarnation.js";
-import { executionLaneCaps, laneWiresExecutionEnv } from "./execution-lane-caps.js";
+import { laneWiresExecutionEnv } from "./execution-lane-caps.js";
 export const CAPABILITY_FACT_WHY = {
     run_store_absent: "no durable run store is wired (DB_BACKEND=mysql|pg|local)",
     subagent_registry_absent: "the sub-agent steer registry is not wired",
@@ -503,19 +503,8 @@ export function hostScheduler(c) {
 export function autoBackgroundOnTimeout(c, hostBackgroundShellOn) {
     if (c.autoBackgroundOnTimeout !== true)
         return no("auto_background_off");
-    const cap = executionLaneCaps(c.remoteExec.provider).backgroundShell;
-    switch (cap) {
-        case "unsupported":
-            return no("lane_cannot_adopt_running_command");
-        case "supported":
-            return YES;
-        case "single-user-only":
-            return c.requirePrincipal !== true && hostBackgroundShellOn ? YES : no("lane_cannot_adopt_running_command");
-        default: {
-            const unknownCap = cap;
-            throw new Error(`auto-background fact: unknown lane capability ${String(unknownCap)}`);
-        }
-    }
+    const laneCanAdopt = DEPLOYMENT_SHAPE_PREDICATES.backgroundShell.holds(c) && (c.remoteExec.provider !== "host" || hostBackgroundShellOn);
+    return laneCanAdopt ? YES : no("lane_cannot_adopt_running_command");
 }
 export const AUTO_BACKGROUND_ON_TIMEOUT_WORDS = ["armed", "off", "unsupported"];
 export function autoBackgroundOnTimeoutWord(f) {

package/dist/card-settle-stored-scope.d.ts

@@ -0,0 +1,56 @@
+/**
+ * **按令牌把一张 pending 卡 CAS expire —— 全仓唯一的读法**(状态读 `get` 交出的行状态,属主格读店的列,CAS 吃那一格)。六个读者同读这一只,没有第二份:
+ *  · `POST /v1/runs/:id/cancel` 的停驻取消腿(`routes/runs.ts` 的 `cancelSuspended`);
+ *  · 一条续跑腿被取消之后结算它续的那张卡(`resume-legs.ts` 的 `settleCardForCancel`);
+ *  · 审批 SLA 拒扫腿对「准入策略挡住」的续跑当场过期该卡(`http/approval-sweeps.ts` 的 `expirePolicyBlockedCard`);
+ *  · 会话删除 / 显式结清口带走停驻子代时作废它的卡(`session-children-retire.ts` 的 `expireParkedCard`);
+ *  · 停驻写没落定就以失败收场时作废手里那张卡(`card-void.ts` 的 `voidPendingCard`);
+ *  · 复活不了的停驻子代被 deny 时作废它的卡(`parked-decide.ts` 的 `voidUnrevivableCard`)。
+ *
+ * ## 规则一条:顺序恒为「先读状态、(要求归属就)再核归属、最后按存储列 expire」,不读行体里的属主格
+ * 一张停驻卡的事实在店里有两份:列(令牌、归属 run 的会话、门型、属主格 `scope` —— 引擎停驻时盖下,身份迁移时与行体里那一份一起迁)与行体(`checkpoint` 里的 JSON 快照)。
+ * `expire` 的 CAS 谓词吃的是列;拿行体里自带的那一份去配,行体与列不一致(手改 / 外来写者 / 迁移两腿之间)时只会把「列好体坏」说成「被并发决议了」,行体读不成检查点时更是读行体就抛。
+ *  1. **状态**:卡已不在待决面(已结 / 已不在)⇒ 不写 —— 已结的卡上 CAS 恒输,写一次只是多一次店写(店写口故障时那一次还会抛,把「本来什么都不用做」的收场变成失败)。
+ *     状态读 `get` 交出的行状态(状态列权威,不是行体快照里那一份);**读不成检查点的行体**({@link UnreadableCheckpointRowError})读不出状态 ⇒ 不替 CAS 判(「不知道」不当作「已结」),
+ *     下一步吃列的 CAS 自己判;其余读故障(连库 / 超时 / 程序错)原样上抛,店的故障不是答案。
+ *  2. **归属**(调用方要求时):卡的归属会话(`hostSessionOfCard`,列)必须就是调用方说的那只 —— 只作废**这一张**;读不出 / 对不上 ⇒ `host_mismatch`,不写。状态在归属之前:已结的卡不因归属对不上而报警。
+ *  3. **属主格**:`peekScopeByToken`(SQL = `scope` 列,local = 账本行),`null` 是店契约里的匿名值,按契约换成公共哨兵(两只真店的属主列非空,到不了这一臂)。
+ * 找「取消动词会结算哪一张卡」是取消口自己的事(`run-cancel-card.ts`);本模块只管拿到令牌之后怎么结算。
+ */
+import type { CheckpointToken } from "@sema-agent/core";
+import type { CheckpointStoreFull } from "./plugins/store-backend.js";
+/** 「这张卡此刻的状态」那一问要的店口(只读 `get` 交出的行状态;结构型 —— 真店的 `get` 直接对上)。 */
+export interface CardStatusPort {
+    get(token: CheckpointToken): Promise<{
+        readonly status?: string;
+    } | null>;
+}
+/** 结算一张卡要的店口:状态 + 属主格(店的列)+ CAS expire。六个读者的依赖型都从这一份取,不各自另写一份 `Pick`。 */
+export type CardSettlePort = CardStatusPort & Pick<CheckpointStoreFull, "peekScopeByToken" | "expire">;
+/** 要求归属时多要的一口:卡归在哪只会话上(归属列)。 */
+export type CardHostPort = Pick<CheckpointStoreFull, "hostSessionOfCard">;
+/**
+ * 结算的结局(店的事实,不嗅文案):
+ *  · `expired` —— 本调用亲手把一张 pending 的卡 expire 了;
+ *  · `not_pending` —— 卡已不在待决面(已结 / 已不在),没写;
+ *  · `lost` —— 读状态时还 pending、CAS 输给了并发的结算(决定 / 收割 / 别的作废者);
+ *  · `host_mismatch` —— 调用方要求的归属对不上(或说不出),没写。
+ */
+export declare const CARD_EXPIRE_OUTCOME: {
+    readonly expired: "expired";
+    readonly notPending: "not_pending";
+    readonly lost: "lost";
+    readonly hostMismatch: "host_mismatch";
+};
+export type CardExpireOutcome = (typeof CARD_EXPIRE_OUTCOME)[keyof typeof CARD_EXPIRE_OUTCOME];
+/** 调用方要求:这张卡必须归在 `hostSession` 这只会话上(`undefined` = 调用方说不出自己的会话 ⇒ 恒对不上)。 */
+export interface CardHostGuard {
+    readonly hostSession: string | undefined;
+}
+/**
+ * 按店里的属主格把 `token` 那张卡 CAS expire(≈ deny 的 reaper 终局;不是 resolve —— 取消意味着 run 死掉,deny-RESUME 会把拒绝喂回模型烧 token),次序见模块头注。
+ * 要求归属就给 `guard`(店口多带 {@link CardHostPort});不给 ⇒ 不核归属(令牌是调用方按列找来的,如取消口的 `runCancelCardOf`)。
+ */
+export declare function expireCardUnderStoredScope(cs: CardSettlePort, token: CheckpointToken): Promise<CardExpireOutcome>;
+export declare function expireCardUnderStoredScope(cs: CardSettlePort & CardHostPort, token: CheckpointToken, guard: CardHostGuard): Promise<CardExpireOutcome>;
+//# sourceMappingURL=card-settle-stored-scope.d.ts.map

package/dist/card-settle-stored-scope.js

@@ -0,0 +1,27 @@
+import { UnreadableCheckpointRowError } from "./plugins/checkpoint-store-face.js";
+import { CHECKPOINT_PUBLIC_SCOPE } from "./security.js";
+export const CARD_EXPIRE_OUTCOME = { expired: "expired", notPending: "not_pending", lost: "lost", hostMismatch: "host_mismatch" };
+async function cardLeftPending(cs, token) {
+    try {
+        const live = await cs.get(token);
+        return live === null || live.status !== "pending";
+    }
+    catch (e) {
+        if (e instanceof UnreadableCheckpointRowError)
+            return false;
+        throw e;
+    }
+}
+export async function expireCardUnderStoredScope(cs, token, guard) {
+    if (await cardLeftPending(cs, token))
+        return CARD_EXPIRE_OUTCOME.notPending;
+    if (guard !== undefined) {
+        if (guard.hostSession === undefined || cs.hostSessionOfCard === undefined || (await cs.hostSessionOfCard(token)) !== guard.hostSession)
+            return CARD_EXPIRE_OUTCOME.hostMismatch;
+    }
+    const scope = await cs.peekScopeByToken(token);
+    if (scope === undefined)
+        return CARD_EXPIRE_OUTCOME.notPending;
+    return (await cs.expire(token, scope ?? CHECKPOINT_PUBLIC_SCOPE)) ? CARD_EXPIRE_OUTCOME.expired : CARD_EXPIRE_OUTCOME.lost;
+}
+//# sourceMappingURL=card-settle-stored-scope.js.map

package/dist/card-void.d.ts

@@ -1,6 +1,7 @@
 /**
- * **结算时作废一张归本 run 会话的、本服务兑现不了的卡** —— 读卡 → 卡仍 pending ∧ 卡归调用方说的那只会话(归属列,`hostSessionOf`)⇒
- * 按卡**自己的** scope 走 checkpoint 店的 `expire`(与引擎的本进程仲裁器、续跑的 resolve 同一只 CAS,恰一个赢家)。不新增任何持久态。
+ * **结算时作废一张归本 run 会话的、本服务兑现不了的卡** —— 卡仍 pending ∧ 卡归调用方说的那只会话(归属列,`hostSessionOfCard`)⇒
+ * 按店里该卡的属主格走 checkpoint 店的 `expire`(全仓唯一的读法 {@link expireCardUnderStoredScope}:先读状态、再核归属、最后按属主列 CAS;与引擎的本进程仲裁器、续跑的 resolve 同一只 CAS,恰一个赢家)。
+ * 不新增任何持久态。
  *
  * 规则只有一条:**本服务兑现不了的卡不留在待决面上**。产地 = 停驻没落定就以失败收场的腿(`runs.ts` 的 `voidHeldParkCard`:后台腿与
  * 续跑腿):卡在本 run 的会话上,但兑现它的那条 run 已经 `failed`、认领已放 —— 卡的命运先于认领释放(调用方先调本动词、再放认领)。
@@ -8,20 +9,14 @@
  * `verifier-pause-card.ts`);那只动词只收验证器的卡,本 run 自己会话上的卡按引擎的读法仍走店级 `expire`。
  *
  * 不抛:作废没做成(店读 / 作废抛错、卡的会话对不上、没接店)⇒ 卡回到「留在待决面上、由审批兜底收割收走」的形,按产地登记的 tag
- * 响亮留痕(计数 + 探针行 + 一次 warn),结算照常往下走。卡已不 pending / 已不在 ⇒ 什么都不做(CAS 输给了别的结算者,结局相同)。
+ * 响亮留痕(计数 + 探针行 + 一次 warn),结算照常往下走。卡已不 pending / 已不在 ⇒ 什么都不做(别的结算者先收走了,结局相同;先于归属判,已结的卡不因归属对不上而报警)。
  * 店级 `expire` 只作废卡,不动引擎在停驻时给这只会话打的钉(钉在续跑终局 / 续跑失败臂放)。
  */
 import type { CheckpointToken } from "@sema-agent/core";
 import { type FailOpenTag } from "./observability/fail-open.js";
-/** 结算点手里那只 checkpoint 店的三个动词:读卡(取它自己的 scope / 状态)、读它归在哪只会话上 → 按卡自己的 scope CAS 作废。 */
-export interface CardVoidPort {
-    get(token: CheckpointToken): Promise<{
-        readonly scope?: string;
-        readonly status?: string;
-    } | null>;
-    hostSessionOfCard(token: CheckpointToken): Promise<string | null | undefined>;
-    expire(token: CheckpointToken, scope: string): Promise<boolean>;
-}
+import { type CardHostPort, type CardSettlePort } from "./card-settle-stored-scope.js";
+/** 结算点手里那只 checkpoint 店的动词:读卡的状态、读它归在哪只会话上(归属列)、读它的属主格(属主列)→ 按那一格 CAS 作废。 */
+export type CardVoidPort = CardSettlePort & CardHostPort;
 /** 要作废的那一张:停驻带回的凭据 + 它应归的会话(本 run 的会话;对不上就不动它 —— 只作废**这一张**)。 */
 export interface CardRef {
     readonly token: CheckpointToken;

package/dist/card-void.js

@@ -1,5 +1,6 @@
 import { errorText } from "./observability/err-text.js";
 import { recordFailOpen } from "./observability/fail-open.js";
+import { CARD_EXPIRE_OUTCOME, expireCardUnderStoredScope } from "./card-settle-stored-scope.js";
 export async function voidPendingCard(card, cards, tag, at) {
     const miss = (reason, err) => recordFailOpen(tag, `reason=${reason}${at === undefined ? "" : ` ${at}`}${err === undefined ? "" : ` err=${err}`}`);
     if (cards === undefined) {
@@ -7,14 +8,8 @@ export async function voidPendingCard(card, cards, tag, at) {
         return;
     }
     try {
-        const live = await cards.get(card.token);
-        if (live === null || live.status !== "pending")
-            return;
-        if (card.sessionId === undefined || (await cards.hostSessionOfCard(card.token)) !== card.sessionId || typeof live.scope !== "string") {
+        if ((await expireCardUnderStoredScope(cards, card.token, { hostSession: card.sessionId })) === CARD_EXPIRE_OUTCOME.hostMismatch)
             miss("card_mismatch");
-            return;
-        }
-        await cards.expire(card.token, live.scope);
     }
     catch (e) {
         miss("store_error", errorText(e));

package/dist/config-catalog.d.ts

@@ -18,6 +18,16 @@ export type CatalogDangerAxis = (typeof CATALOG_DANGER_AXES)[number];
  */
 export declare const URL_CREDENTIAL_POLICIES: readonly ["refuse", "mask"];
 export type UrlCredentialPolicy = (typeof URL_CREDENTIAL_POLICIES)[number];
+/**
+ * secret 行的值**装着几枚凭据、按什么读出来**(闭集;只在 `type: "secret"` 的行上,其余行恒缺席)—— 本服务凭据的颗粒按本服务读这只变量的那一只解析器定:
+ *  · `whole`       —— 整值是一枚(令牌 / 口令 / 私钥 / 一只模型密钥;名单型旋钮的原文也按凭据类整值对待);
+ *  · `token-table` —— `tok=system` 逗号表,每个 `tok` 是一枚(`SERVICE_AUTH_TOKENS`;读法 = `auth-keys.ts` `parseServiceAuthTokens`,`loadConfig` 同读);
+ *  · `key-set`     —— `{kid,key,status}` JSON 数组,每个 `key` 是一枚(`APPROVAL_HMAC_KEYS`;读法 = `auth-keys.ts` `parseApprovalHmacKeys`,`loadConfig` 同读)。
+ * 读者只有一个:自有凭据声明的值臂(`server-secret-env.ts`)—— 整值总在内,列表形另把每一枚交给引擎 ⇒ 一枚令牌换了个变量名放着,与原变量同扣。
+ * 词加一个而读者不补 ⇒ 编译红(读者是穷举 switch);secret 行不写 ⇒ 编译红(`r()` 的 secret 重载要它)。不上 wire。
+ */
+export declare const SECRET_CREDENTIAL_FORMS: readonly ["whole", "token-table", "key-set"];
+export type SecretCredentialForm = (typeof SECRET_CREDENTIAL_FORMS)[number];
 /** 域 = 配置九组(类型锁步:组集变了这里跟着红)。 */
 export type CatalogDomain = keyof ServiceConfigGroups;
 export declare const CATALOG_RESTART_SLICES: readonly RestartSlice[];
@@ -93,6 +103,8 @@ export interface ConfigCatalogSpec {
     readonly scope?: "bootstrap-only";
     /** url 行的凭据处置披露({@link UrlCredentialPolicy});url 行必填(`r()` 的 url 重载要它,缺 ⇒ 编译红),其余行写不进来。 */
     readonly credentialPolicy?: UrlCredentialPolicy;
+    /** secret 行的凭据颗粒({@link SecretCredentialForm});secret 行必填(`r()` 的 secret 重载要它,缺 ⇒ 编译红),其余行写不进来。 */
+    readonly credentialForm?: SecretCredentialForm;
 }
 export interface ConfigCatalogRowCenter {
     readonly domain: string;