@sema-agent/server 7.122.0 → 7.124.0

package/dist/plugins/web-search.js

@@ -1,6 +1,7 @@
 import { validateHeaderValue } from "node:http";
 import { createSearxngSearchBackend } from "@sema-agent/core";
-import { isHierarchicalUrl, redactSecrets } from "../trace/redact.js";
+import { isHierarchicalUrl } from "@sema-agent/settings-schema";
+import { redactSecrets } from "../trace/redact.js";
 export const WEB_SEARCH_PROVIDERS = ["brave", "tavily", "searxng"];
 function isWebSearchProvider(word) {
     return WEB_SEARCH_PROVIDERS.includes(word);

package/dist/plugins/workflow-run-store-sql.d.ts

@@ -68,8 +68,10 @@ type WorkflowRun = Parameters<WorkflowRunStore["put"]>[1];
 export declare const MAX_RUN_BLOB_BYTES: number;
 declare const onWarnType: (msg: string, meta: Record<string, unknown>) => void;
 export type InboxWarn = typeof onWarnType;
-/** S-107:workflow_run 行的 `error`(脚本抛出的 `err.message`,core 源头不脱)在**两条写腿**(put / update 常态 + oversize 降级)
- *  同一口脱;`result` 由 core 完成时源头脱。幂等,不抛(超大 ⇒ 占位)。 */
+/** S-107:workflow_run 行的 `error`(脚本抛出的 `err.message`)在**两条写腿**(put / update 常态 + oversize 降级)
+ *  同一口脱;`result` 由 core 完成时源头脱。幂等,不抛(超大 ⇒ 占位)。
+ *  core 7.48.0 起 `error` 在铸点也过 core 的 `redactSecrets`,但两张脱敏表互不为超集(本仓的表多认几种记号,core 的表多认另几种)⇒ 这一口暂留;
+ *  退役条件 = core 的脱敏表成为两表的并集(本仓的每一种记号它都认)—— 到那时这一口与它的两条调用一起删。 */
 export declare function withRedactedError<T extends {
     error?: string | undefined;
 }>(run: T): T;

package/dist/posture-source.d.ts

@@ -19,7 +19,7 @@
  * 得到一句谁都不认的空话,或者更坏:一句**对某些键是假的**话。
  *
  * 🔴 `centerMeaning` 是 G-7(test [ref])的修复面,成因是一次真的过期断言:这一臂原本硬编码
- * 「applied from the config-center (**restart-to-apply**)」,而 S-174(core 7.10.0 [ref])之后
+ * 「applied from the web-admin (**restart-to-apply**)」,而 S-174(core 7.10.0 [ref])之后
  * `readFace.face` 是**热换席**(`Runner.swapDeps({readFace})`,下一拍 refresh 当场换进全部 Runner,
  * `read-face` 重启片也不再为它签理由)——运维照那句话去滚动重启一片 fleet,重启的是一个已经生效的变更。
  * 生效时机是**键**的事实,不是四词表的属性,所以它跟 `postureMeaning` 一样归键。

package/dist/read-face-posture.d.ts

@@ -11,14 +11,14 @@
  *
  * 于是本模块把「档位」与「档位是谁定的」拆成两个字段:值仍是 `open | roots | 缺席`,来源是本文件的
  * **四词闭集**。来源不是装饰:
- *  ① `config-center/read-face.ts` 的 **env 恒赢**判据此前用的是「`config.readFace` 键在不在场」这个
+ *  ① `web-admin-client/read-face.ts` 的 **env 恒赢**判据此前用的是「`config.readFace` 键在不在场」这个
  *     **代理**;posture 会铸键,代理当场失真(center 的 face 会被一台从没设过 env 的机器挡掉)。
  *     换成读来源之后判据说的就是它真正想说的那件事:**这台机器的 env 显式占住了这个键吗**。
  *  ② 运维面:`GET /v1/diagnostics/wiring` 报 `{face, source, note}`,「为什么这台机器是 open」有答案
  *     (裁定的补偿项:升级即放开,得让运维看得见并知道怎么钉回)。
  *
  * ## 优先序(三态,与 `config.ts` 的 `postureOn` 同形)
- * `env 显式` > `center 发布` > `posture 派生` > `引擎默认`。env 恒赢的论证逐字见 `config-center/read-face.ts`
+ * `env 显式` > `center 发布` > `posture 派生` > `引擎默认`。env 恒赢的论证逐字见 `web-admin-client/read-face.ts`
  * 头注①(READ 容纳面描述的是**这台机器的磁盘上有什么**,组织的下发面不知道)。
  *
  * ## 定界
@@ -54,7 +54,7 @@ export declare function readFaceForPosture(singleUserTurnkey: boolean): ReadFace
  *
  *  🔴 `center` 那句话的事实来源是 S-174(core 7.10.0 [ref]):`RunnerDeps.readFace` 进了 core 的可换席
  *  闭集 `SWAPPABLE_DEP_SEATS` ⇒ 组织发布/撤回一个档位,**下一拍 refresh 当场换进全部 Runner**,
- *  `config-center/restart-signal.ts` 的 `read-face` 片也不再为它签重启理由(判据同源 =
+ *  `web-admin-client/restart-signal.ts` 的 `read-face` 片也不再为它签重启理由(判据同源 =
  *  `CENTER_READ_FACE_LIVE_KEYS`,由 core 的 `isSwappableDepSeat` 派生)。本句此前逐字写着
  *  「(restart-to-apply)」—— G-7 抓获的那条过期断言,方向恰好是「让运维为一个已生效的变更重启 fleet」。
  *  ⚠️ 只说 `face` 这一席:三个 deny 键仍是 boot-baked,那半场的话不在这条读面上(它们没有来源位)。 */

package/dist/read-face-posture.js

@@ -7,7 +7,7 @@ export function readFaceSourceNote(source) {
     return postureSourceNote({
         knob: "READ_FACE",
         source,
-        centerMeaning: "published by the config-center and applied HOT — the containment FACE is a swappable engine seat (core 7.10.0), so the next refresh (or POST /v1/admin/config/refresh) swaps it into every Runner with NO restart; set READ_FACE on this machine to take the key back",
+        centerMeaning: "published by the web-admin and applied HOT — the containment FACE is a swappable engine seat (core 7.10.0), so the next refresh (or POST /v1/admin/config/refresh) swaps it into every Runner with NO restart; set READ_FACE on this machine to take the key back",
         postureMeaning: "derived from the single-user turnkey posture (REQUIRE_PRINCIPAL is not set): reads outside the workspace roots are allowed by default — set READ_FACE=roots to pin the containing posture back",
     });
 }

package/dist/rule-entry-list.d.ts

@@ -9,10 +9,10 @@
  *  ① **形**({@link ruleEntryListShapeOk}):字符串数组。引擎逐条迭代;一个裸字符串会被逐字符读成几条(deny 侧 = 意图静默落空)。
  *     本谓词不带条数帽(引擎的 `screenAllowedToolsValue` 只判形);条数帽是另一只函数 {@link allowLayerEntryCountIssue}(`MAX_ALLOW_LAYER_ENTRIES`,
  *     请求 allow 桶、技能两只清单、运维表四张表同一只、同一句)。
- *  ② **引擎读不到的一形**({@link emptyToolSegmentEntryOf}):工具段为空的协议名(`mcp__srv__`)—— 引擎的判官答 `current`、条目读成一条精确名行、永不命中;
- *     判据与句子在 `namespaced-rule-name.ts`(配置表、会话规则写口同一只)。四张表都拒。
+ *  ② (7.116.0–7.122.x 的「引擎读不到的一形」—— 工具段为空的协议名 `mcp__srv__` 四张表都拒 —— 随 core 7.48.0 #1400 退役:引擎判官给它判词
+ *     `unmintable_segment`,条目由下面 ③ 读成 `tool_name`,与对端段铸不出的名字同一条路。)
  *  ③ **引擎读成空的条目**({@link inertRuleEntriesOf},判据 = 引擎包根 `compileAllowList(entries, behavior, 名册)`,名册 = 空集 `NO_DECLARED_TOOL_NAMES`
- *     —— 条目的工具名也过引擎判官:退役名 / 无前缀短名 / 对端段铸不出读成 `tool_name`,带判词与 1:1 现名;原因词是引擎的 `ALLOW_ENTRY_INERT_REASONS`):
+ *     —— 条目的工具名也过引擎判官:退役名 / 无前缀短名 / 对端段或工具段铸不出、为空读成 `tool_name`,带判词与 1:1 现名;原因词是引擎的 `ALLOW_ENTRY_INERT_REASONS`):
  *     运维的 allow 表拒启(运维自己的配置,写错了当场改);技能的拒侧(`disallowedTools`)拒 —— 提交 400、存量体重放 409(下面的 {@link skillDenyInertEntryOf});
  *     请求的 allow 侧(`settings.permissions.allow`、技能 `allowedTools`)不拒:引擎在开跑时发 `permission.allowed_tool_not_granted`(受众 = 用户)。
  *     技能拒侧那一拒与引擎 #1372(core 7.43.0:那只技能不激活)是同一件事的两处 —— 7.118.0 重估过、本版**不退**:本仓的续跑腿把引擎的
@@ -20,7 +20,6 @@
  *     (重估读数与退役条件在下面那只函数头注)。
  */
 import { compileAllowList } from "@sema-agent/core";
-import { emptyToolSegmentOf } from "./namespaced-rule-name.js";
 /** ① 形:字符串数组(空串也是字符串 —— 引擎把它读成 `grammar` 并通告 / 拒,见 ③)。 */
 export declare const ruleEntryListShapeOk: (v: unknown) => v is readonly string[];
 /**
@@ -42,15 +41,6 @@ export declare function allowLayerEntryCountIssue(field: string, list: readonly
     readonly count: number;
     readonly cap: number;
 } | undefined;
-/** 一张表里第一条「引擎读不到、却永远匹配不到」的条目(工具段为空的协议名)。 */
-export interface EmptyToolSegmentEntry {
-    readonly entry: string;
-    readonly ns: NonNullable<ReturnType<typeof emptyToolSegmentOf>>;
-}
-/** ② 第一条工具段为空的协议名条目(没有 ⇒ `undefined`)。纯字符串运算。 */
-export declare function emptyToolSegmentEntryOf(list: readonly string[]): EmptyToolSegmentEntry | undefined;
-/** ② 的句子(`<field> names "<entry>", which can never match a tool (…)`;后半与配置表 / 会话规则写口同一只)。 */
-export declare function describeEmptyToolSegmentEntry(field: string, u: EmptyToolSegmentEntry): string;
 /** 一条引擎读成空的条目(引擎的形:原因词,名字层另带判词 / 1:1 现名;包根不导出这只具名型 ⇒ 从 `compileAllowList` 的返回型取,不手抄)。 */
 export type InertRuleEntry = ReturnType<typeof compileAllowList>["inert"][number];
 /** ③ 引擎按 `behavior` 读这张表时读成空的条目(引擎的整表读法:allow 表里的 `*` 让整表读成空;deny 表里的 `*` 只读空它自己);条目名过引擎判官(名册 = 空集)。 */

package/dist/rule-entry-list.js

@@ -1,6 +1,6 @@
 import { compileAllowList } from "@sema-agent/core";
 import { displayListEntry } from "./list-entry-display.js";
-import { describeEmptyToolSegment, emptyToolSegmentOf, NO_DECLARED_TOOL_NAMES, ruleEntryToolName } from "./namespaced-rule-name.js";
+import { NO_DECLARED_TOOL_NAMES } from "./namespaced-rule-name.js";
 export const ruleEntryListShapeOk = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
 export const MAX_ALLOW_LAYER_ENTRIES = 1_000;
 export function describeAllowLayerOverCap(field, count) {
@@ -12,17 +12,6 @@ export function allowLayerEntryCountIssue(field, list) {
         return undefined;
     return { message: describeAllowLayerOverCap(field, list.length), count: list.length, cap: MAX_ALLOW_LAYER_ENTRIES };
 }
-export function emptyToolSegmentEntryOf(list) {
-    for (const entry of list) {
-        const ns = emptyToolSegmentOf(ruleEntryToolName(entry));
-        if (ns !== undefined)
-            return { entry, ns };
-    }
-    return undefined;
-}
-export function describeEmptyToolSegmentEntry(field, u) {
-    return `${field} names ${displayListEntry(u.entry)}, which can never match a tool (${describeEmptyToolSegment(u.ns)})`;
-}
 export function inertRuleEntriesOf(list, behavior) {
     return compileAllowList(list, behavior, NO_DECLARED_TOOL_NAMES).inert;
 }

package/dist/run-local.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { DEFAULT_MODEL_REF, resolveTaskModel } from "./model-select.js";
+import { DEFAULT_AT_MENTION, DEFAULT_MODEL_REF, resolveTaskModel } from "./model-select.js";
 import { defaultModelRefusal, modelUnavailableMessage } from "./model-entry-refusal.js";
 import { createDurableAbsenceSeat } from "./observability/corrupt-read-seat.js";
 import { outwardPlane } from "./terminal.js";
@@ -14,7 +14,7 @@ import { withUnattendedLeg } from "./unattended-permission-mode.js";
 import { buildUnattendedPolicyRefusal } from "./tool-approval.js";
 import { createBrain } from "./brain.js";
 import { assertGuardPatternsUsable, buildOnlySensitiveBaselineWarning, buildApprovalGrantNotice, createApprovalBaselinePolicy, createDeploymentGovernanceInputs, } from "./deployment-governance.js";
-import { applyRuntimeGovernance, autonomyModeFloor } from "./runtime-governance.js";
+import { applyRuntimeGovernance, autonomyModeFloor, entryPermissionMode } from "./runtime-governance.js";
 import { ForkRoutingSessionStore } from "./plugins/fork-routing-session-store.js";
 import { taskWallClockSec } from "./task-workflow.js";
 import { applyCatalogToSource } from "./capabilities/center-prompts.js";
@@ -25,7 +25,8 @@ import { acquireLocalBackendWithWait } from "./plugins/store-lock-wait.js";
 import { configLocalRoot, configProviderKind, createConfigProvider } from "./config-provider.js";
 import { composeExecutionLane } from "./boot/execution-lane.js";
 import { judgeConsolidationValve } from "./boot/memory-consolidation.js";
-import { applyEffective, applyCenterReadFace, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./config-center/facade.js";
+import { logConfigDirMigration, migrateLocalConfigDirectory } from "./config-d-migration.js";
+import { applyEffective, applyCenterReadFace, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./web-admin-client/facade.js";
 import { hostExecutionEnvFactory } from "./plugins/remote-env-host.js";
 import { executionLaneHomeDir, executionLaneOf } from "./execution-lane-caps.js";
 import { makeLoadProjectMemory, makeProbeInstructionSources } from "./project-memory.js";
@@ -337,6 +338,8 @@ export async function runLocal(argv, deps = {}) {
         return 2;
     }
     const configProvider = createConfigProvider(providerInput);
+    if (configProvider.kind === "local")
+        logConfigDirMigration(logger, await migrateLocalConfigDirectory(root));
     let effective;
     try {
         const r = await configProvider.fetchEffective(undefined);
@@ -344,7 +347,7 @@ export async function runLocal(argv, deps = {}) {
             for (const de of r.domainErrors ?? [])
                 logger.warn("config_domain_invalid", { domain: de.domain, error: de.error, note: "domain fell to schema defaults; other domains applied normally" });
             for (const d of r.droppedEntries ?? [])
-                logger.warn("config_entry_dropped", { domain: d.domain, entry: d.entry, error: d.error, version: r.effective.version, phase: "boot", note: "this one entry failed its domain schema and was dropped on its own — the rest of the candidate applies (per-entry tolerance); fix the named entry to bring it back" });
+                logger.warn("config_entry_dropped", { domain: d.domain, entry: d.entry, reasonCode: d.reasonCode, error: d.error, version: r.effective.version, phase: "boot", note: "this one entry failed its domain schema and was dropped on its own — the rest of the candidate applies (per-entry tolerance); fix the named entry to bring it back" });
             effective = r.effective;
             applyEffective(config, r.effective, logger, { leg: "boot" });
             if (effective?.mcp)
@@ -613,7 +616,7 @@ export async function runLocal(argv, deps = {}) {
         }
         throw err;
     }
-    const mention = resolveTaskModel(undefined, args.objective, config.models, undefined, config.modelRefusals);
+    const mention = resolveTaskModel(undefined, args.objective, config.models, DEFAULT_AT_MENTION, config.modelRefusals);
     if (mention.unavailable !== undefined) {
         const { requested, name, refusal } = mention.unavailable;
         printErr(`cannot run: ${modelUnavailableMessage("@-mention", requested, name, refusal)}`);
@@ -633,9 +636,9 @@ export async function runLocal(argv, deps = {}) {
         ...(maxCostUsd !== undefined ? { maxCostUsd } : {}),
         ...(maxTokens !== undefined ? { maxTokens } : {}),
     };
-    const entryFloor = autonomyModeFloor(config.autonomy);
+    const entryWord = entryPermissionMode(undefined, autonomyModeFloor(config.autonomy)).effective;
     const spec = withUnattendedLeg(applyLocalGovernance({
-        ...(entryFloor !== undefined ? { permissionMode: entryFloor } : {}),
+        ...(entryWord !== undefined ? { permissionMode: entryWord } : {}),
         objective: mention.cleanedObjective,
         sessionId,
         backgroundScope: "session",

package/dist/runtime-caps-resolver.d.ts

@@ -65,8 +65,8 @@
  */
 import type { RuntimeCaps } from "@sema-agent/core";
 import type { EntitlementRuntimeCaps } from "@sema-agent/settings-schema";
-import { fetchPrincipalCaps, type ExecutionRuling } from "./config-center/facade.js";
-import type { CenterEndpoint } from "./config-center/center-request.js";
+import { fetchPrincipalCaps, type ExecutionRuling } from "./web-admin-client/facade.js";
+import type { CenterEndpoint } from "./web-admin-client/center-request.js";
 import type { ScenarioRuling } from "./capabilities/scenarios.js";
 import type { ServiceConfig } from "./config-types.js";
 import { type Logger } from "./observability/logger.js";
@@ -75,7 +75,7 @@ export declare function resetExecutionLaneDefaultTraceForTest(): void;
 export interface EntitlementsResolverOpts {
     /** S-651:中心端点(基址 + 凭证**来源**;每次抓取取一次值,不持有启动快照)。 */
     center: CenterEndpoint;
-    /** This worker's name (`SEMA_REGISTRY_WORKER`), passed as `?worker=` so a worker-scoped `wpt_<self>` token can
+    /** This worker's name (`SEMA_WEB_ADMIN_WORKER`), passed as `?worker=` so a worker-scoped `wpt_<self>` token can
      *  resolve its OWN worker's principal caps (caps-only); harmless on a full token (the caps value
      *  is worker-independent). Omitted ⇒ no `?worker=` (a full-token, non-fleet deployment). */
     worker?: string;
@@ -135,7 +135,7 @@ export declare function toCoreRuntimeCaps(ent: EntitlementRuntimeCaps | null | u
  * (`RuntimeCaps.autoMode` 三态逐 principal 解,[ref] 起「缺席=不阻」),任何部署级布尔都对它说不了话——
  * 所以本谓词为 false **不再**意味着 auto 不武装;「会不会武装」由 `auto-mode-face.ts` 的三项合取答。
  */
-export declare function centerEntitlementSourceWired(config: Pick<ServiceConfig, "configCenter">): boolean;
+export declare function centerEntitlementSourceWired(config: Pick<ServiceConfig, "webAdmin">): boolean;
 /** The two per-principal faces served off ONE caps fetch + cache. */
 export interface PrincipalEntitlementsClient {
     /** core's `RunnerDeps.runtimeCapsResolver` seam — FAIL-CLOSED on error (deny workflows/fork/autoMode;

package/dist/runtime-caps-resolver.js

@@ -1,4 +1,4 @@
-import { fetchPrincipalCaps } from "./config-center/facade.js";
+import { fetchPrincipalCaps } from "./web-admin-client/facade.js";
 import { createIdentityBins } from "./center-credential.js";
 import { HttpError } from "./security.js";
 import { createLogger } from "./observability/logger.js";
@@ -53,7 +53,7 @@ export function toCoreRuntimeCaps(ent) {
     return Object.keys(caps).length ? caps : undefined;
 }
 export function centerEntitlementSourceWired(config) {
-    return config.configCenter !== undefined && !config.configCenter.dryRun;
+    return config.webAdmin !== undefined && !config.webAdmin.dryRun;
 }
 export function gateExecutionLane(ruling, ownLane, logger = defaultLogger) {
     if (!ruling) {

package/dist/runtime-governance.d.ts

@@ -1,7 +1,7 @@
 /**
  * Runtime governance compiler — the "second baton" (center §10, core 1.114.0): turn the
- * operator's declarative `runtime.autonomy` + `runtime.commandPolicy` (`@sema-agent/settings-schema`,
- * carried to the service via sema-registry `EffectiveConfig.runtime`) into TIGHTEN-ONLY overrides on the
+ * operator's declarative `governance.autonomy` + `governance.commandPolicy` (`@sema-agent/settings-schema`,
+ * carried to the service in the effective config's `governance` domain) into TIGHTEN-ONLY overrides on the
  * per-task `TaskSpec`. Pure so it is unit-testable in isolation (the spec is otherwise assembled inside
  * main.ts's `resolveSpec`).
  *
@@ -28,7 +28,7 @@ import { GovernanceConfig } from "@sema-agent/settings-schema";
 import { type GovernanceAskMarks } from "./governance-ask-marks.js";
 import { type GovernanceOverrides } from "./governance-overrides.js";
 /** 运维 autonomy 四档的**闭集**(同上)。`config.ts` 的 `parseAutonomy` 也从这里读 —— 四档词表全仓一份。 */
-export declare const AUTONOMY_MODES: ["read-only", "ask", "plan", "auto"];
+export declare const AUTONOMY_MODES: ("plan" | "auto" | "ask" | "read-only")[];
 /** A per-command governance rule (registry `runtime.commandPolicy[]`) —— **型也从契约派生**:
  *  契约给 `command` 加一条 refine / 给 `decision` 加一个判词,本仓的型当场跟上(或在下面的
  *  `RANK` / 穷尽 switch 上编译红),而不是靠人记得把手写联合改一遍。 */
@@ -39,7 +39,7 @@ export type Autonomy = NonNullable<GovernanceConfig["autonomy"]>;
 export declare const COARSE_SHELL_TOOLS_MIRROR: readonly string[];
 /** Validate `commandPolicy` rules — the shape (array of {command, decision}), the `command` (a bare argv[0] name,
  *  see {@link VALID_COMMAND_NAME}), AND the `decision` enum. Returns the list of human-readable errors (empty =
- *  OK). Called at config-apply (config-center/facade.ts `applyRuntimeHot`) so a malformed rule that BYPASSED the
+ *  OK). Called at config-apply (web-admin-client/facade.ts `applyRuntimeHot`) so a malformed rule that BYPASSED the
  *  registry schema (a hand-edited config.d / a non-conformant publish) is rejected LOUDLY rather than
  *  silently mis-compiling — review MEDIUM: an out-of-enum `decision` (e.g. "DENY") would otherwise fall through
  *  {@link compileCommandPolicyLayers}'s `decision==="deny"?…:"ask"` to ASK, silently WEAKENING an intended deny. */
@@ -90,7 +90,7 @@ export declare function compileCommandPolicyLayers(rules: CommandRule[] | undefi
  *
  * 🔴 **规则:按段重折的只有静态围栏,模式词不在这里。** 只读手 + roots、shell 地板没有出口 —— 每一段续跑都该在,所以每一段都折。
  * `plan` 是有出口的**生命周期词**(`plan_review` 把计划带出 plan),不是围栏:它是**提交入口的模式词地板**({@link autonomyModeFloor}),
- * 盖在每一个 spec 出生点一次:受理门盖进存储的提交体(`task-settings.ts` `stampEntryPermissionMode`)、run-local 盖在它自建的 spec 上、
+ * 盖在每一个 spec 出生点一次(词 = {@link entryPermissionMode} 的 `effective`):受理门盖进存储的提交体(`task-settings.ts` `stampEntryPermissionMode`)、run-local 盖在它自建的 spec 上、
  * leader run 盖在它出生时的入口体上(`leader/run-entry.ts`;入口词是 `plan` 的 leader run 进不了那条车道 —— worker 会话没有计划审阅通道 ⇒ 受理口响亮拒)。此后一条 run 的模式词
  * 只有存储体一个源,写者是每一个出生点(新的持久化写都经 `http/checkpoint-ctx.ts` `buildCheckpointCtx`)与 `plan_review` 写回。按段折一个模式词 = 第二个源:被批准的计划会在下一次挂起→续跑
  * 被拉回 plan。收紧入参的型上因此没有 `permissionMode`(`governance-overrides.ts`)。(上一个发布版本里本档不碰模式词,按段折的是只读手 +
@@ -118,18 +118,41 @@ export declare function autonomyOverrides(autonomy: Autonomy | undefined): Gover
 /**
  * 运维 autonomy 给**提交入口**的模式词地板 —— 唯一属主(规则全文见 {@link autonomyOverrides} 顶注)。`plan` ⇒ `"plan"`:每个新提交的 run
  * 以 plan 起步,请求的词按 core 的模式秩钳到它之下;其余三档与缺席 ⇒ 无地板(它们的表态全在按段的围栏里)。
- * 读者:三个 spec 出生点 —— 受理门(`http/admission.ts`,经 `task-settings.ts` `stampEntryPermissionMode` 盖进存储体)、run-local 自建的 spec、
- * leader run 的入口体(`leader/run-entry.ts` `leaderRunEntry`,同一只盖章;leader 的 HTTP 受理口用它判「这条车道收不收」);能力面的两位 ——
- * `taskWriteFaceOpen` 的治理半({@link autonomyKeepsOpenWriteFace})与 `permissionModeAuto.armed` 的意图(`auto-mode-face.ts`),两位都经 core
- * `clampPermissionMode` 读「地板把请求词钳成什么」,与盖章同一只钳;存量停驻体能否重放的第三问(`http/stored-body-replay.ts`:没有当前读法记号的行,
- * 体的生效词被此刻的地板钳会变 ⇒ 拒)。
+ * 「一个词在这块地板下变成什么」只有一只函数答:{@link entryPermissionMode}(读者全表在它的头注)。
  * 闭集**穷尽** switch:契约给 autonomy 加一档 ⇒ 这里编译红([ref])。
  */
 export declare function autonomyModeFloor(autonomy: Autonomy | undefined): PermissionMode | undefined;
+/**
+ * 一个模式词进入一块地板之后的**读数** —— {@link entryPermissionMode} 的答。四键:调用方声明的词(`requested`,缺席 = 没声明)、地板(`floor`,
+ * 缺席 = 这里没有地板)、生效词(`effective`)与「地板改了调用方的词」(`clamped`,core 的同名位:只在声明了词、且那个词被折回地板时为真 ——
+ * 没声明词而取地板本身不算改词)。
+ */
+export interface EntryPermissionMode<W extends PermissionMode | undefined = PermissionMode | undefined> {
+    readonly requested: W;
+    readonly floor: PermissionMode | undefined;
+    readonly effective: W | PermissionMode;
+    readonly clamped: boolean;
+}
+/**
+ * 「请求词 `word` 在地板 `floor` 下变成什么」—— **唯一**的一只函数(本仓对 core `clampPermissionMode` 的唯一调用点;秩只在 core 一处)。
+ *
+ * 规则:地板缺席 ⇒ 词原样、`clamped:false`;地板在场 ⇒ core `clampPermissionMode(word, floor)` 的答(词缺席 ⇒ 地板本身;比地板松的词 ⇒ 折回地板、`clamped:true`)。
+ * 本仓「地板」即 core 的天花板(`plan` 秩最低:比它松的词都折成它)。
+ *
+ * 读者(都调这一只,不另写「缺席原样否则钳」):
+ *  · spec 出生点写 `effective` —— 受理门(`task-settings.ts` `stampEntryPermissionMode` 盖进存储体)、run-local 自建的 spec、
+ *    leader run 的入口词(`leader/run-entry.ts` `leaderRunEntry`)、leader 车道合并口(`leader/leader.ts` `withLeaderLeg`:spec 的词钳在入口词之下)、
+ *    无人值守腿(`unattended-permission-mode.ts` `withUnattendedLeg`:`default` 钳在 spec 的词之下);
+ *  · 「这个词会变成什么」的读者 —— 能力面写面开不开({@link autonomyKeepsOpenWriteFace}:bypass 声明过地板)、能力面 auto 读面
+ *    (`auto-mode-face.ts` `judgeAutoModeArming`:意图过地板;`clamped` 且不是 auto ⇒ 未武装原因 `operator_floor`)、
+ *    存量停驻体能否按此刻的地板重放(`http/stored-body-replay.ts`:体的词经钳会变 ⇒ 拒)。
+ * `test/entry-permission-mode.test.ts` 按语法树钉:core 钳在 `src/` 只此一处调用,上面八处各调本函数一次。
+ */
+export declare function entryPermissionMode<W extends PermissionMode | undefined>(word: W, floor: PermissionMode | undefined): EntryPermissionMode<W>;
 /**
  * 运维 autonomy 留不留得住请求层「掀开写围栏」那条声明(`permissionMode:"bypassPermissions"`,引擎模式表那一列 `writeFace:"open"`)——
- * 能力面 `taskWriteFaceOpen` 的治理那一半。判据读**两只属主本身**,与一条真提交走的路同序:bypass 声明先过入口地板(core
- * `clampPermissionMode`,与受理门的盖章同一只钳;地板缺席 ⇒ 原样),再交给本档的按段围栏(`tightenGoverned` → core `tightenTaskSpec`),
+ * 能力面 `taskWriteFaceOpen` 的治理那一半。判据读**两只属主本身**,与一条真提交走的路同序:bypass 声明先过入口地板({@link entryPermissionMode},
+ * 与受理门的盖章同一只函数),再交给本档的按段围栏(`tightenGoverned` → core `tightenTaskSpec`),
  * 看折出来的 spec 还开不开写面 —— 显式席 `"roots"` 胜过模式列(`read-only`),入口词被钳成别的词时读那个词的模式列(`plan`)。
  * 本仓不另写一张「哪几档钳写面」的表:档位怎么钳 / 怎么折由两只属主说,写面开不开由引擎的模式表说。
  */
@@ -153,7 +176,7 @@ export declare function autonomyKeepsOpenWriteFace(autonomy: Autonomy | undefine
  * 是 always」。`commandPolicy` 不入判据:它产的是 `toolPolicy` 的 ask,不抬 shellGate 档,与本格无关。
  *
  * ⚠️ **已知残留(codex 交叉复审 2026-08-11 逮到,如实登记而不是掩盖)**:本判据读的是**当下**的
- * config,而 `config.autonomy` 是**热改**的(`config-center/apply-effective.ts` 就地写 `config.autonomy`)。
+ * config,而 `config.autonomy` 是**热改**的(`web-admin-client/apply-effective.ts` 就地写 `config.autonomy`)。
  * 于是失真是**双向**的,不是我原先写的「只往缺席方向」:
  *  · 缺席向(常见):mint 之后运维把 `AUTONOMY=ask` 撤了 ⇒ 老 park 行归不出治理出身,少标一个;
  *  · **在场向**(窄):一条**纯 SUP 路由**产的门(`ROUTER_ENABLED` 开 ∧ 路由判 supervisor ∧ 当时治理层

package/dist/runtime-governance.js

@@ -121,9 +121,14 @@ export function autonomyModeFloor(autonomy) {
         }
     }
 }
+export function entryPermissionMode(word, floor) {
+    if (floor === undefined)
+        return { requested: word, floor, effective: word, clamped: false };
+    const { effective, clamped } = clampPermissionMode(word, floor);
+    return { requested: word, floor, effective, clamped };
+}
 export function autonomyKeepsOpenWriteFace(autonomy) {
-    const floor = autonomyModeFloor(autonomy);
-    const entry = floor === undefined ? "bypassPermissions" : clampPermissionMode("bypassPermissions", floor).effective;
+    const entry = entryPermissionMode("bypassPermissions", autonomyModeFloor(autonomy)).effective;
     const folded = tightenGoverned({ objective: "", permissionMode: entry }, autonomyOverrides(autonomy));
     return folded.writeFace !== "roots" && folded.permissionMode !== undefined && modePolicyOf(folded.permissionMode).writeFace === "open";
 }

package/dist/sealed-key.d.ts

@@ -2,7 +2,7 @@ import type { Logger } from "./observability/logger.js";
 /** Algorithm tag — MUST equal registry-core's `SEALED_BOX_ALG` (v1 sole value; a different alg on
  *  the wire is a loud per-model rejection in applyEffective, never a guess). */
 export declare const SEALED_KEY_ALG = "libsodium-sealedbox-x25519";
-/** The subset applyEffective needs (keeps sema-registry decoupled from fs/boot concerns). */
+/** The subset applyEffective needs (keeps web-admin decoupled from fs/boot concerns). */
 export interface SealedKeyOpener {
     has(publicKeyId: string): boolean;
     /** All private-key ids this host holds (surfaces in the no-private-key warn for operator triage). */
@@ -62,17 +62,17 @@ export declare function deriveKeyId(publicKeyRaw: Uint8Array): string;
  */
 export declare function ensureSealedKeyStore(dir: string, logger?: Logger): Promise<SealedKeyStore>;
 /**
- * Best-effort public-key registration with the sema-registry (`POST /api/config/execution-keys`).
+ * Best-effort public-key registration with the web-admin (`POST /api/config/execution-keys`).
  *
  * HONESTY over fake automation: that endpoint is ADMIN-gated, and a fleet worker only holds
  * SERVICE_PULL_TOKEN — so automatic registration works ONLY when the operator deliberately provides
- * an admin token (SEMA_REGISTRY_ADMIN_TOKEN in this service's env; the REGISTRY_ADMIN_TOKEN alias was tombstoned in 5.0.0). Without
+ * an admin token (SEMA_WEB_ADMIN_ADMIN_TOKEN in this service's env; its older names are settings-schema tombstones). Without
  * one we do the next-best REAL thing: print the FULL public key + id at boot (a public key is not a
  * secret) with the exact registration instructions, and warn that the web "paste key" face stays
  * dark for this host until an admin registers it. Never throws (fire-and-forget from boot).
  */
 export declare function reportExecutionPublicKey(opts: {
-    /** sema-registry base URL (config.configCenter.baseUrl). Absent = no center → manual print only. */
+    /** web-admin base URL (config.webAdmin.baseUrl). Absent = no center → manual print only. */
     baseUrl?: string;
     /** Admin bearer for the center's config write face. Absent = manual print (see above). */
     adminToken?: string;

package/dist/sealed-key.js

@@ -4,7 +4,8 @@ import { join } from "node:path";
 import _sodium from "libsodium-wrappers";
 import { buildDisplaySafeUrl } from "./trace/redact.js";
 import { createCenterCredentialSource } from "./center-credential.js";
-import { centerFetch } from "./config-center/center-request.js";
+import { centerFetch } from "./web-admin-client/center-request.js";
+import { WEB_ADMIN_ENV } from "@sema-agent/settings-schema";
 export const SEALED_KEY_ALG = "libsodium-sealedbox-x25519";
 const SEAL_OVERHEAD_BYTES = 48;
 const BASE64_STRICT = /^[A-Za-z0-9+/]+={0,2}$/;
@@ -101,7 +102,7 @@ export async function reportExecutionPublicKey(opts) {
         });
     };
     if (!baseUrl || !adminToken) {
-        manual(!baseUrl ? "no registry configured (SEMA_REGISTRY_URL unset)" : "no admin token (SEMA_REGISTRY_ADMIN_TOKEN unset; the worker's pull token cannot write execution keys)");
+        manual(!baseUrl ? `no web-admin configured (${WEB_ADMIN_ENV.url} unset)` : `no admin token (${WEB_ADMIN_ENV.adminToken} unset; the worker's pull token cannot write execution keys)`);
         return;
     }
     try {

package/dist/security.d.ts

@@ -17,9 +17,9 @@ export interface SessionListItem {
     /** K-5c (shell §K): the latest run's task_id — the shell's one-hop live-tail re-attach anchor on resume. */
     lastRunId: string | null;
     /** [ref]([ref]/[ref]):the LATEST run's **engine run id**(`TaskResult.runId`)when known —— OMIT-when-absent,
-     *  恒不铸 null。runs-ledger listers 从 latest run 的 `result` JSON 提取(终局与 park 时写、认领续跑即清空 —— S-173 ⇒ 在跑 latest 键诚实缺席);
-     *  local lister 走 `noteTaskRun` 席实时记录(⇒ 在跑也在场)——两面缺席集合不完全相等,读法一致:
-     *  缺席 = 「此行无已知 engine runId」,禁读成其它含义。⚠️ 与 `lastRunId`(= latest run 的 **task_id**)
+     *  恒不铸 null。所有 lister(SQL 双生、local 会话店 —— 它的 run 店是必填位)从 latest run 的 `result` JSON 提取(终局与 park 时写、认领续跑即清空 —— S-173
+     *  ⇒ 在跑 latest 键诚实缺席)。
+     *  读法一致:缺席 = 「此行无已知 engine runId」,禁读成其它含义。⚠️ 与 `lastRunId`(= latest run 的 **task_id**)
      *  是两条身份轴,命名对齐 core `SessionStoreSummary.lastTaskRunId`。wire:additive 键零投影透传
      *  (sessions-list.ts);sema-sdk spec `SessionSummary` 闭集候 SDK 半场开键([ref]/.82 班车)。 */
     lastTaskRunId?: string;

package/dist/service-version.d.ts

@@ -1,5 +1,5 @@
 /** Service version for GET /v1/capabilities — read from the package.json shipped next to src/ in the
- *  image (Dockerfile COPYs it). Best-effort: an unreadable file reports "unknown", never crashes boot. */
+ *  image (Dockerfile COPYs it), once per process. Best-effort: an unreadable file reports "unknown", never crashes boot. */
 declare function serviceVersion(): string;
 export { serviceVersion };
 //# sourceMappingURL=service-version.d.ts.map

package/dist/service-version.js

@@ -1,5 +1,10 @@
 import { readFileSync } from "node:fs";
+let cachedServiceVersion;
 function serviceVersion() {
+    cachedServiceVersion ??= readServiceVersion();
+    return cachedServiceVersion;
+}
+function readServiceVersion() {
     try {
         const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
         return pkg.version ?? "unknown";

package/dist/session-policy-wire.d.ts

@@ -29,13 +29,14 @@
  * 里同点同调它;准备阶段的名审计与本仓配置表读的是同一只 `judgeRuleToolName`)—— 本仓手写的那一只(`legacyToolNameOf`)删除,零双读;
  * 「哪几桶装工具名」归 core(它的 `HOLDS_TOOL_NAMES`)。
  *
- * ── 7.116.0:写口读者再多判一问 —— 够不着挂载工具的协议名;7.118.0 收窄到引擎读不到的那一形 ─────────────────────────
- * 对端段铸不出 / 对端段为空(`mcp__github.com__*`、`mcp__`)自 core 7.43.0 #1355 (b) 起是引擎判官自己的判词 `unmintable_segment` ——
- * `assertSessionRuleNamesCurrent` 拒(`legacy_tool_name`,`detail.verdict`)、本仓映射 `400 rules.legacy_tool_name`,与退役名同码同句族;本仓 7.116.0 起
- * 那只自比对端段的对照随之退役。引擎判官放行、却一只工具都够不着的只剩**工具段为空**(`mcp__srv__`):判据与句子是 `namespaced-rule-name.ts` 那一只
- * (配置表同调),码 `400 request.field_invalid`(会话规则写口既有的字段值码;不往 core 的判词闭集里塞本仓的词)。这一问要逐桶判,而 core 不导出
- * `HOLDS_TOOL_NAMES` 的运行期值 ⇒ 桶表 {@link TOOL_NAME_FIELDS} 的键集从 core 判官交回的 `field` 型派生(两向 tsc 配对),随引擎判官给这一形判词那天整只退役。
- * SQL 店写口经 {@link assertSessionRuleNamesReachable} 同判。
+ * ── 7.123.0(core 7.48.0):两问都只剩引擎的判 ──────────────────────────────────────────────────────────────────────
+ * ① **桶**能不能写:core 7.48.0 #1471 起 `normalizeRules` 对「不是一列非空字符串」的桶抛 `TypeError`(裸字符串、`null`、混入非字符串、`""` /
+ *    纯空白项),句子点名桶与值类型。写口读者逐桶问它({@link engineRuleListOf})⇒ 两条写口是唯一拒点(`400 request.field_invalid`,句子原样),
+ *    店里的 `normalizeRules` 对这两条写口的输入不再可能抛。修前本仓的形读者只判「字符串数组」,`[""]` / `["  "]` 过它、在店里抛 ⇒ 500。
+ *    本仓自己的「字符串数组」判只留在**读回**({@link readSessionPermissionRules}:SQL 店读出的行,读不出形 ⇒ `corrupt`)—— 读回与写口是两个问题,
+ *    读回不许判「引擎还肯不肯写」:7.47.x 及以前写下的空串项存量行必须读得出来(运营方清它、准备阶段照常执行它都要先读到它)。
+ * ② **名字**够不够得着工具:core 7.48.0 #1400 起工具段为空的协议名(`mcp__srv__`)也是引擎判官的判词 `unmintable_segment` ⇒ 本仓 7.116.0 起
+ *    自答的那一问(「引擎判官放行、却一只工具都够不着」)整只退役,写口拒码随之由 `request.field_invalid` 变 `rules.legacy_tool_name`。
  *
  * ── 文案也在这里(codex 一轮追加:两条腿各铸一份句子 = 第二份手抄)───────────────────────────────
  * 初版把 wire 文案留在两个路由各自铸,理由是错误文案冻结门(`test/api-error-text-freeze.test.ts`)锚的是
@@ -46,24 +47,9 @@
  */
 import { SessionPolicyError } from "@sema-agent/core";
 import type { SessionPermissionRules, SessionRuleNameRefusal, SessionRulesRecord } from "@sema-agent/core";
-import { emptyToolSegmentOf } from "./namespaced-rule-name.js";
 /** core `SessionPermissionRules` 的桶名全集(派生,不是手抄)。 */
 export declare const SESSION_PERMISSION_RULE_FIELDS: readonly (keyof SessionPermissionRules)[];
-/** 工具名桶里一条引擎判官放行、却一只工具都够不着的协议名(工具段为空);`ns` = 它的协议。 */
-export interface SessionRuleUnreachableName {
-    readonly field: SessionRuleNameRefusal["field"];
-    readonly name: string;
-    readonly ns: NonNullable<ReturnType<typeof emptyToolSegmentOf>>;
-}
-/** 逐桶逐条问引擎读不到的那一形;第一条交回,全部够得着 ⇒ `undefined`。调用方先过引擎判官({@link legacyToolNameRefusalOf} / `assertSessionRuleNamesCurrent`)。 */
-export declare function unreachableSessionRuleNameOf(rules: SessionPermissionRules): SessionRuleUnreachableName | undefined;
-/**
- * SQL 会话规则店写口的同一问(core 判官之后、收紧门之前,与 `assertSessionRuleNamesCurrent` 同点):够不着 ⇒ 抛,一条写语句都不发。
- * 抛的是普通 `Error`(不是 `SessionPolicyError`:core 那张闭集里没有这个词,也不往里塞)—— 本服务的两条 HTTP 写口在读者那一层先拒,
- * 走到这里 = 有一个绕过写口读者的写者,HTTP 上落 500(服务端自身的失误,响亮)。
- */
-export declare function assertSessionRuleNamesReachable(rules: SessionPermissionRules): void;
-/** 一条规则体的**形**问题。判词而非文案(见文件头注的「文案属主」一段)。 */
+/** **读回**的形问题(SQL 店读出的行;判词而非文案,见文件头注的「文案属主」一段)。 */
 export type SessionPermissionRulesShapeProblem = 
 /** 整体不是一只普通对象(`null` / 数组 / 标量 / 缺席)。 */
 {
@@ -74,18 +60,23 @@ export type SessionPermissionRulesShapeProblem =
     kind: "field-not-string-array";
     field: keyof SessionPermissionRules;
 };
-/** 一条**要写进店**的规则体的问题 = 形问题 ∪ S-800 的名字问题(判官 = core 的 `assertSessionRuleNamesCurrent`)。 */
-export type SessionPermissionRulesProblem = SessionPermissionRulesShapeProblem
-/** S-800 / S-1047:形对,但工具名桶里有一条写进去就跑不了的名字;`refusal` = core 判官交回的 detail(原样上 wire)。 */
+/** 一条**要写进店**的规则体的问题 —— 三问都只有一个判官:容器形(本仓)、桶(引擎 `normalizeRules`)、名字(引擎 `assertSessionRuleNamesCurrent`)。 */
+export type SessionPermissionRulesWriteProblem = {
+    kind: "not-an-object";
+}
+/** 引擎不肯把这一桶写成规则表(core 7.48.0 #1471);`refusal` = 引擎的句子(点名桶与值类型),原样上 wire。 */
  | {
-    kind: "legacy-tool-name";
-    refusal: SessionRuleNameRefusal;
+    kind: "field-not-rule-list";
+    field: keyof SessionPermissionRules;
+    refusal: string;
 }
-/** 形对、core 判官也放行,但工具名桶里有一条一只工具都够不着的协议名(工具段为空 —— 引擎读不到的那一形)。 */
+/** S-800 / S-1047:桶形对,但工具名桶里有一条引擎判官判非现役的名字;`refusal` = core 判官交回的 detail(原样上 wire)。 */
  | {
-    kind: "unreachable-tool-name";
-    unreachable: SessionRuleUnreachableName;
+    kind: "legacy-tool-name";
+    refusal: SessionRuleNameRefusal;
 };
+/** 两只读者的判词并集(句子铸点 {@link describeSessionPermissionRulesProblem} 读它)。 */
+export type SessionPermissionRulesProblem = SessionPermissionRulesShapeProblem | SessionPermissionRulesWriteProblem;
 /** 两只读者的读数:有问题给判词,没问题给**已收窄**的规则体(调用方零 cast)。`P` = 这只读者会给的判词集。 */
 export type SessionPermissionRulesRead<P extends SessionPermissionRulesProblem = SessionPermissionRulesProblem> = {
     problem: P;
@@ -95,27 +86,34 @@ export type SessionPermissionRulesRead<P extends SessionPermissionRulesProblem =
     rules: SessionPermissionRules;
 };
 /**
- * **形读者**:读一只 `SessionPermissionRules`,形不对给判词,形对给**只含五桶**的规则体。三个消费者:两条写入腿
- * (经 {@link readWritableSessionPermissionRules})与 SQL 店的**读回**(`session-policy-store-sql.ts` 的
- * `readSessionRulesBody`:读不出形的行判 `corrupt`)。
+ * **读回**的形读者:读一只 `SessionPermissionRules`,形不对给判词,形对给**只含五桶**的规则体。消费者 = SQL 店的读回
+ * (`session-policy-store-sql.ts` 的 `readSessionRulesBody`:读不出形的行判 `corrupt`)。
  *
- * 认识面窄得刻意:**只判形**,不判内容(桶内字符串的 pattern 文法、路径是否可达、tighten-only 是否成立
- * 都不在这里 —— 前两者归 core 的 rule 文法与 `normalizeRules`,后者归 `putRules` 的收紧门;S-800 的名字判官
- * 只在**写口**那一只读者里,见下)。未知键**照旧忽略**(不是新的拒因):core 的 `normalizeRules` 本来就只搬这五桶,
- * 本读者与它同口径。
+ * 认识面窄得刻意:**只判「五桶各是字符串数组」**,不判引擎还肯不肯写(空串 / 纯空白项)、不判名字 —— 那是写口的问题
+ * ({@link readWritableSessionPermissionRules})。7.47.x 及以前写下的空串项存量行必须读得出:读回把它判坏 ⇒ 运营方清它的 PUT 在写前快照上 500、
+ * 准备阶段也读不到它(同 S-800 的「判官只在写口」)。未知键**照旧忽略**:core 的 `normalizeRules` 本来就只搬这五桶,本读者与它同口径。
  */
 export declare function readSessionPermissionRules(raw: unknown): SessionPermissionRulesRead<SessionPermissionRulesShapeProblem>;
 /**
- * **写口读者**(S-800)= 形读者 + 名字判官:两条写入腿(`PUT /v1/sessions/:id/policy`、sync/import 的 `policy`
- * 面经 {@link readSessionRulesRecords})往会话规则店写之前的**唯一**判据。两问,按序:
- *  ① 形(同 {@link readSessionPermissionRules};一份坏形的体答形的 400);
- *  ② 工具名桶里的每一条过 core 的判官({@link legacyToolNameRefusalOf})—— 写进去就让会话之后每一跑都起不来的名字,在写口拒;
- *  ③ 工具名桶里的每一条问引擎读不到的那一形({@link unreachableSessionRuleNameOf}:工具段为空的协议名)—— 写进去永远匹配不到任何挂载工具,在写口拒。
- * 🔴 **只在写口,不在读回**:SQL 店读回同一行时只判形(形读者)。一条早先写进去的退役名行(或够不着的协议名行)必须**读得出来** ——
- * 那是运营方清掉它的唯一路径(operator 的 PUT 先读写前快照),也是 core 准备阶段报 `config.legacy_tool_name`
- * 而不是一只 500 `corrupt` 的前提。把判官放进形读者会让读回把它判坏(7.105.0 车QQ 双库套件实抓,修在同批)。
+ * 一份规则体(写口的入参,或店里读出来的一行)里**引擎不肯写**的第一只桶 —— 没有 ⇒ `undefined`。判官同 {@link engineRuleListOf}。
+ * 两个读者:写口读者(拒)与 2c 重放的同内容判据(`session-sync.ts` 的 `sameRulesContent`:目的端存量行是这一形 ⇒ 答「不同内容」,写交给店的收紧门)。
+ */
+export declare function unwritableRuleListOf(rules: Readonly<Partial<Record<keyof SessionPermissionRules, unknown>>>): {
+    field: keyof SessionPermissionRules;
+    refusal: string;
+} | undefined;
+/**
+ * **写口读者**(S-800)—— 两条写入腿(`PUT /v1/sessions/:id/policy`、sync/import 的 `policy` 面经 {@link readSessionRulesRecords})往会话规则店
+ * 写之前的**唯一**判据,三问按序、每问一个判官:
+ *  ① 容器形 —— 一只普通对象(本仓);
+ *  ② 每一只桶 —— 引擎肯不肯把它写成规则表({@link engineRuleListOf},core 7.48.0 #1471;与引擎店同序:先 `normalizeRules` 再判名);
+ *  ③ 工具名桶里的每一条 —— 引擎判官({@link legacyToolNameRefusalOf}:退役名 / 无前缀 `__` 名 / 对端段或工具段铸不出、为空)。
+ * 拿到规则体 = 店里的 `normalizeRules` 与 `assertSessionRuleNamesCurrent` 对它都不会再抛(同一只判官先问过)。
+ * 🔴 **只在写口,不在读回**:SQL 店读回同一行时只判形({@link readSessionPermissionRules})。早先写进去的退役名行 / 空串项行必须**读得出来** ——
+ * 那是运营方清掉它的唯一路径(operator 的 PUT 先读写前快照),也是 core 准备阶段报 `config.legacy_tool_name` 而不是一只 500 `corrupt` 的前提
+ * (7.105.0 车QQ 双库套件实抓,修在同批)。
  */
-export declare function readWritableSessionPermissionRules(raw: unknown): SessionPermissionRulesRead;
+export declare function readWritableSessionPermissionRules(raw: unknown): SessionPermissionRulesRead<SessionPermissionRulesWriteProblem>;
 /** 一条 `SessionRulesRecord` 的形问题(`policy[]` 的元素级;桶级问题原样转载在 `rules` 位)。 */
 export type SessionRulesRecordProblem = 
 /** `policy` 本身不是数组。 */
@@ -133,11 +131,11 @@ export type SessionRulesRecordProblem =
     kind: "principal-not-a-string";
     index: number;
 }
-/** 第 `index` 条的 `rules` 形不对(转载桶级判词)。 */
+/** 第 `index` 条的 `rules` 写不进(转载写口读者的判词)。 */
  | {
     kind: "rules";
     index: number;
-    problem: SessionPermissionRulesProblem;
+    problem: SessionPermissionRulesWriteProblem;
 };
 /** {@link readSessionRulesRecords} 的读数。 */
 export type SessionRulesRecordsRead = {