@sema-agent/settings-schema 10.1.1 → 11.0.0

package/dist/retired-envs.js

@@ -0,0 +1,114 @@
+/**
+ * 退役 env 名的**墓碑表** —— 一张表,本包是它的唯一属主:引擎(server)起服时按它拒启、目录 wire 的 `retired[]` 由它投影,
+ * 壳在起本机引擎之前、web-admin 在给 worker 渲染 env 之前读同一张(谁都不再手抄、不再从别人的构建产物里正则抽)。
+ *
+ * **进表的判据(一条):没有任何受支持的引擎还读这个名。** 一个名字还被在跑的引擎当活旋钮读时就进表,等于让照旧配置的部署拒启 ——
+ * 改名的那一版只登记现名,旧名等引擎换读现名之后的那一版再进表。
+ *
+ * 🪦 **墓碑是永久的响亮拒,不设到期**。一行墓碑就是那句拒启句本身,成本一行;删掉它 = 旧名重新被悄悄忽略。
+ * ⇒ 本表只增不减,**唯一的删除条件是这个名字要被赋予新含义**:那一次提交同时删掉这一行,并在发布说明里写明旧名改作何用。
+ * (与一次性迁移不是一回事:迁移碰真数据,所以有窗、窗关即删码;墓碑不碰数据,只拒启。)
+ *
+ * **旧名在场即拒,替代名在不在都一样**:判据只问旧名在不在场,不看替代键设没设、设成什么 ——「新旧两个名字都留着」正是
+ * 迁移到一半的部署最常见的形,旧名在那一形里若被静默忽略,运维会以为它还在生效。空串 = 未设(compose `${X:-}` 透传的空值
+ * 不是一次表态),不拒。
+ *
+ * **链只有一跳**:一行的去向永远是现名,不是另一个也已退役的名字(否则照拒句改完仍被拒)。一个名字第二次改名时,指向它的
+ * 旧行同拍改指新名。
+ *
+ * 墓碑分三族,族是**闭集**,每族各说各的尾句(渲染是穷举映射,加一族不写尾句 = 编译红):
+ *  · `renamed`  = 同一能力换了个键名,值语义逐字不变 ⇒「照新名改写即可」;
+ *  · `replaced` = 有替代键,但**值语义变了**(缺省 / `0` 义 / 计量段 / 极性不同)⇒ 点名新键 + 说清变了什么,**不许**说「语义不变」
+ *                 —— 照抄旧值过去就是另一个意思;
+ *  · `removed`  = 能力本身没了,`why` 是「为什么没了」,**没有可 rename 的目标**。
+ * 拒句带码 {@link RETIRED_ENV_REFUSAL_CODE}(拒启码,出现在拒句方括号里)。
+ *
+ * 行形 = 字面元组(第三元是族词),一行一个旧名。纯数据 + 纯函数,零 IO,browser-safe。
+ */
+import { WEB_ADMIN_ENV } from "./web-admin-env.js";
+/** 墓碑拒启码(机读;拒句方括号里)。 */
+export const RETIRED_ENV_REFUSAL_CODE = "config.env_key_retired";
+const OA_REMOVED = "the OA scenario was removed in 5.0.0";
+const negativeAliasWhy = (old, positive) => `negative-name alias retired in server 3.0.0 — unset it; the polarity is inverted: ${old}=true is ${positive}=false (the positive name defaults on)`;
+export const RETIRED_ENVS = [
+    ["TIDB_HOST", "MYSQL_HOST", "renamed"],
+    ["TIDB_PORT", "MYSQL_PORT", "renamed"],
+    ["TIDB_USER", "MYSQL_USER", "renamed"],
+    ["TIDB_PASSWORD", "MYSQL_PASSWORD", "renamed"],
+    ["TIDB_DATABASE", "MYSQL_DATABASE", "renamed"],
+    ["TIDB_POOL_SIZE", "MYSQL_POOL_SIZE", "renamed"],
+    ["ANTHROPIC_BASEURL", "ANTHROPIC_BASE_URL", "renamed"],
+    // web-admin 连接名两代前的 `CONFIG_CENTER_*` / `REGISTRY_ADMIN_TOKEN`,直指现名(一跳)。
+    ["CONFIG_CENTER_URL", WEB_ADMIN_ENV.url, "renamed"],
+    ["CONFIG_CENTER_TOKEN", WEB_ADMIN_ENV.token, "renamed"],
+    ["CONFIG_CENTER_DRY_RUN", WEB_ADMIN_ENV.dryRun, "renamed"],
+    ["CONFIG_CENTER_WORKER", WEB_ADMIN_ENV.worker, "renamed"],
+    ["REGISTRY_ADMIN_TOKEN", WEB_ADMIN_ENV.adminToken, "renamed"],
+    // OA 场景整体退役:配置本身作废,无替代名。
+    ["OA_API_BASEURL", OA_REMOVED, "removed"],
+    ["OA_SERVICE_TOKEN", OA_REMOVED, "removed"],
+    ["OA_ISSUE_TOKEN", OA_REMOVED, "removed"],
+    ["OA_ISSUE_BASEURL", OA_REMOVED, "removed"],
+    ["OA_ISSUE_OWNER", OA_REMOVED, "removed"],
+    ["OA_ISSUE_REPO", OA_REMOVED, "removed"],
+    ["OA_ISSUE_LABELS", OA_REMOVED, "removed"],
+    ["APPROVAL_POLL_MS", "the OA poll-approval lane was removed in 5.0.0; the durable checkpoint lane is the only gate", "removed"],
+    // 合不上 = 交给用户:冲突解决模型整条通道删除,本键没有替代名。
+    ["LEADER_CONFLICT_ROUNDS", "the bounded merge-conflict-resolution agent was deleted in 7.83.0; an unmergeable result goes back to the user: leader returns result.conflict (branch + conflicting files) and the run status is needs_human", "removed"],
+    // 名义「建连」、实际计到响应头的旋钮。替代键计的是同一段,但缺省、`0` 义与重试形都变了。
+    ["MODEL_CONNECT_TIMEOUT_MS", "MODEL_FIRST_BYTE_TIMEOUT_MS", "replaced", "since core 7.33.0 the TCP + TLS connect clock is the transport's own; the wait from sending the request to its response headers — what this key really bounded — is MODEL_FIRST_BYTE_TIMEOUT_MS (unset = core's own default, plus an upload allowance and one widened retry; 0 = no engine clock on that segment and the transport's header / body clocks off too — the TCP + TLS connect keeps the transport's own clock)"],
+    // 旧负名:替代键在、但极性相反(照抄旧值过去恰好是反义)。
+    ["PROJECT_MEMORY_DISABLED", "PROJECT_MEMORY_ENABLED", "replaced", negativeAliasWhy("PROJECT_MEMORY_DISABLED", "PROJECT_MEMORY_ENABLED")],
+    ["CONFIG_LKG_DISABLED", "CONFIG_LKG_ENABLED", "replaced", negativeAliasWhy("CONFIG_LKG_DISABLED", "CONFIG_LKG_ENABLED")],
+    ["HOST_BG_DISABLED", "HOST_BG_ENABLED", "replaced", negativeAliasWhy("HOST_BG_DISABLED", "HOST_BG_ENABLED")],
+    ["HOST_EXEC_SPOOL_DISABLED", "HOST_EXEC_SPOOL_ENABLED", "replaced", negativeAliasWhy("HOST_EXEC_SPOOL_DISABLED", "HOST_EXEC_SPOOL_ENABLED")],
+    // 无人值守腿的模式旋钮退役:这些腿的答集是常量,不是旋钮。
+    ["UNATTENDED_PERMISSION_MODE", "since server 7.109.0 the unattended legs (leader workers and their repair legs, run-local, and their durable resumes) always run permissionMode \"default\" with an approver that answers by ask class: a machine answers only \"ordinary\" asks, and every other class goes to the leg's approver seat (run-local's terminal prompt) or parks / is refused — there is no mode to choose", "removed"],
+];
+// 冻结:拿到导出的人改不了拒启判据(读拒句的与投影 wire 的是同一个数组对象)。
+for (const row of RETIRED_ENVS)
+    Object.freeze(row);
+Object.freeze(RETIRED_ENVS);
+/** 墓碑表 → wire 投影(纯数据)。**同一张表、同序**;族是闭集,穷举 switch(加一族不写这里 ⇒ 编译红)。 */
+export function buildRetiredEnvWire() {
+    return RETIRED_ENVS.map((row) => {
+        switch (row[2]) {
+            case "renamed":
+                return { name: row[0], kind: row[2], replacement: row[1] };
+            case "replaced":
+                return { name: row[0], kind: row[2], replacement: row[1], reason: row[3] };
+            case "removed":
+                return { name: row[0], kind: row[2], reason: row[1] };
+            default: {
+                const unhandled = row;
+                throw new Error(`unhandled retired-env kind: ${String(unhandled[2])}`);
+            }
+        }
+    });
+}
+/** 每族的拒句片段 —— 穷举映射型:加一族不补这里即编译红;句子的**次序**也只读这张表(声明序),不另列一份。 */
+const RETIRED_ENV_SENTENCE = {
+    renamed: (hits) => `${hits.map(([old, to]) => `${old} → use ${to}`).join("; ")} — rename the env key(s); the value semantics are unchanged`,
+    replaced: (hits) => `${hits.map(([old, to, , why]) => `${old} → ${to} (${why})`).join("; ")} — set the replacement deliberately: ` +
+        `its value semantics differ from the retired key's, so do not copy the old value across unread`,
+    removed: (hits) => `${hits.map(([old, why]) => `${old} (${why})`).join("; ")} — remove the env key(s): the capability itself was retired, ` +
+        `there is no replacement name and no rename that restores it`,
+};
+function retiredEnvSentence(kind, hit) {
+    const ofKind = hit.filter((h) => h[2] === kind);
+    return ofKind.length > 0 ? [RETIRED_ENV_SENTENCE[kind](ofKind)] : [];
+}
+/**
+ * 读给它的 env 记录,判有没有退役名在场 —— 拒启句的**唯一铸点**:有 ⇒ 整句(带 {@link RETIRED_ENV_REFUSAL_CODE};族序 renamed →
+ * replaced → removed,族内按表序;只点名键、从不回显值);没有 ⇒ `undefined`。空串 = 未设。
+ *
+ * 纯函数:不读 `process.env`(读方传自己要判的那份 env —— 引擎起服传进程 env,壳传它要交给子进程的那份,web-admin 传它要渲染的
+ * worker env);拒不拒(抛 / 退出码 / 400)是读方的事。
+ */
+export function retiredEnvRefusal(env) {
+    const hit = RETIRED_ENVS.filter(([old]) => env[old] !== undefined && env[old] !== "");
+    if (hit.length === 0)
+        return undefined;
+    const parts = Object.keys(RETIRED_ENV_SENTENCE).flatMap((kind) => retiredEnvSentence(kind, hit));
+    return `retired env name(s) set [${RETIRED_ENV_REFUSAL_CODE}] — refused while present, whether or not the replacement is also set: ${parts.join(" | ")}.`;
+}

package/dist/retired-form.d.ts

@@ -0,0 +1,31 @@
+/**
+ * retired 形的**拒句**与**墓碑**(11.0.0)—— 包内私有(不进主桶)。
+ *
+ * 一条律:**旧形只有一种去处 —— 登记过窗的一次性迁移改写它(`./one-time-migrations`);读写两面遇旧形都响亮拒,拒句点名迁移 id。**
+ * 拒句只在这里拼(一个模板),三处用它:retired 域(`RETIRED_DOMAINS`,读者 throw `RetiredDomainError`)、retired 键(域 schema 里的
+ * {@link retiredKey} 墓碑字段,zod issue)、保留名闸里「迁移搬得走」的 env 键({@link migrationSignpost})。
+ *
+ * 墓碑是**拒**,不是第二种读法:它不把旧形读成任何值,只说「这里有一份没迁的旧形」以及去哪儿迁。迁移族按登记表的窗整族删,
+ * 墓碑留下 —— 到那时拒句里的迁移 id 由删码那一车改写(登记表那一行的 `removal` 点名了这件事)。
+ */
+import { z } from "zod";
+/** 迁移命令行的唯一拼写:`npx` 全名形 —— 没装本包的运维粘贴即可跑(裸 bin 名在没装本包的机器上是 `command not found`)。参数是一个 `config.d` 目录。 */
+export declare const MIGRATE_COMMAND: "npx @sema-agent/settings-schema migrate";
+/** 拒句尾的迁移指路:存量由哪一条一次性迁移改写、两种跑法(子路径的函数 / 目录命令)。`before` = 旧形不再合法的那一版。
+ *  刻意短:它挂在 zod issue 句尾,读侧逐条容错时每一条被丢的条目都要过一遍出门脱敏。 */
+export declare function migrationSignpost(migration: string, before: string): string;
+/** 一个retired 形的整句:`<form> was retired in <版本> — now <今天住哪>; <指路>`。 */
+export interface RetiredForm {
+    /** retired的版本。 */
+    readonly retiredIn: string;
+    /** 事实今天住哪(一句,点名新位)。 */
+    readonly now: string;
+    /** 改写存量的一次性迁移 id(`./one-time-migrations` 的闭集;到期门核它在登记表里)。 */
+    readonly migration: string;
+}
+export declare function retiredFormSentence(form: string, t: RetiredForm): string;
+/**
+ * retired**键**的墓碑字段:放在该键原来所在的对象形里,键缺席 = 合法,键在场(任何值)= 一条 issue(路径就是那个键、句子点名迁移)。
+ * 输出形里它恒缺席(型上是 `?: undefined`),JSON Schema 上是 `not: {}`(「不许出现」)—— 墓碑写在旧键原来的位置上,schema 自己说明它retired了。
+ */
+export declare function retiredKey(key: string, t: RetiredForm): z.ZodOptional<z.ZodNever>;

package/dist/retired-form.js

@@ -0,0 +1,28 @@
+/**
+ * retired 形的**拒句**与**墓碑**(11.0.0)—— 包内私有(不进主桶)。
+ *
+ * 一条律:**旧形只有一种去处 —— 登记过窗的一次性迁移改写它(`./one-time-migrations`);读写两面遇旧形都响亮拒,拒句点名迁移 id。**
+ * 拒句只在这里拼(一个模板),三处用它:retired 域(`RETIRED_DOMAINS`,读者 throw `RetiredDomainError`)、retired 键(域 schema 里的
+ * {@link retiredKey} 墓碑字段,zod issue)、保留名闸里「迁移搬得走」的 env 键({@link migrationSignpost})。
+ *
+ * 墓碑是**拒**,不是第二种读法:它不把旧形读成任何值,只说「这里有一份没迁的旧形」以及去哪儿迁。迁移族按登记表的窗整族删,
+ * 墓碑留下 —— 到那时拒句里的迁移 id 由删码那一车改写(登记表那一行的 `removal` 点名了这件事)。
+ */
+import { z } from "zod";
+/** 迁移命令行的唯一拼写:`npx` 全名形 —— 没装本包的运维粘贴即可跑(裸 bin 名在没装本包的机器上是 `command not found`)。参数是一个 `config.d` 目录。 */
+export const MIGRATE_COMMAND = "npx @sema-agent/settings-schema migrate";
+/** 拒句尾的迁移指路:存量由哪一条一次性迁移改写、两种跑法(子路径的函数 / 目录命令)。`before` = 旧形不再合法的那一版。
+ *  刻意短:它挂在 zod issue 句尾,读侧逐条容错时每一条被丢的条目都要过一遍出门脱敏。 */
+export function migrationSignpost(migration, before) {
+    return `data stored before ${before}: run the one-time migration ${migration} (@sema-agent/settings-schema/one-time-migrations, or ${MIGRATE_COMMAND} <dir>)`;
+}
+export function retiredFormSentence(form, t) {
+    return `${form} was retired in ${t.retiredIn} — now ${t.now}; ${migrationSignpost(t.migration, t.retiredIn)}`;
+}
+/**
+ * retired**键**的墓碑字段:放在该键原来所在的对象形里,键缺席 = 合法,键在场(任何值)= 一条 issue(路径就是那个键、句子点名迁移)。
+ * 输出形里它恒缺席(型上是 `?: undefined`),JSON Schema 上是 `not: {}`(「不许出现」)—— 墓碑写在旧键原来的位置上,schema 自己说明它retired了。
+ */
+export function retiredKey(key, t) {
+    return z.never({ error: retiredFormSentence(key, t) }).optional();
+}

package/dist/safety-merge-spec.d.ts

@@ -1,10 +1,10 @@
 /**
  * #14 SAFETY MERGE-SPEC — the ONE machine-readable per-category merge/enforcement table that every settings
- * resolver (TOC shell-adapter + TOB center/service) reads, so they never re-implement (and drift on) the merge
+ * resolver (TOC shell-adapter + TOB web-admin/service) reads, so they never re-implement (and drift on) the merge
  * law. This formalizes settings-core's v2-design §3 merge-spec into a published-data contract; the SEMANTIC
- * author is settings-core, center maintains the formalized artifact here (registry-core), the axis VALUE domains
+ * author is settings-core, web-admin maintains the formalized artifact here (this package), the axis VALUE domains
  * are core's (@sema-agent/core SAFETY_AXIS_VOCABULARY — validated by a dev-only conformance test, never a runtime
- * import). Each consumer keeps its OWN key→category map (client's SemaSettings KEY_CONTRACTS, center's
+ * import). Each consumer keeps its OWN key→category map (client's SemaSettings KEY_CONTRACTS, web-admin's
  * config-field→category map); THIS file is only the shared category spec they all cite — no third copy of the law.
  *
  * Per-category behavior is fully determined by `mergeShape` + `minTrust` + `tighten` + `enforcement` + `fail` — and,
@@ -52,7 +52,13 @@
  */
 import { z } from "zod";
 /** How values from different layers/principals combine for a category. */
-export declare const MergeShape: z.ZodEnum<["denyFirst", "replace", "runAll", "overrideByName", "concat"]>;
+export declare const MergeShape: z.ZodEnum<{
+    concat: "concat";
+    replace: "replace";
+    denyFirst: "denyFirst";
+    runAll: "runAll";
+    overrideByName: "overrideByName";
+}>;
 export type MergeShape = z.infer<typeof MergeShape>;
 /** The trust-tier VOCABULARY a category — or, since 1.1.0, one of its members — names as its admission floor
  *  (the MINIMUM trust a layer/principal must have to set it). The RANK is v2-design §1:29,
@@ -60,7 +66,14 @@ export type MergeShape = z.infer<typeof MergeShape>;
  *  {@link isAtLeast}. `task` (1.2.0) is the runtime task overlay — the lowest trust, the loosest floor.
  *  ⚠️ This enum's DECLARATION ORDER is NOT the rank (it is the 1.1.0 order with `task` appended — kept byte-stable
  *  because reordering is breaking); never index it as a ladder — use {@link trustRank}. */
-export declare const MinTrust: z.ZodEnum<["local", "session", "project", "global", "managed", "task"]>;
+export declare const MinTrust: z.ZodEnum<{
+    local: "local";
+    session: "session";
+    global: "global";
+    project: "project";
+    managed: "managed";
+    task: "task";
+}>;
 export type MinTrust = z.infer<typeof MinTrust>;
 /** The trust RANK of a floor / layer word — v2-design §1:29 verbatim (`MANAGED 6 > GLOBAL 5 > PROJECT 4 > LOCAL 3 >
  *  SESSION 2 > TASK 1`), the ONE published ladder every resolver compares against (1.2.0). Higher = more trusted.
@@ -80,7 +93,10 @@ export declare function isAtLeast(layer: MinTrust, minTrust: MinTrust): boolean;
  *  suggestion (consent flow) rather than drop it silently. This package returns that metadata only — it performs
  *  no admission and no degradation; whether a given consumer version implements the outlet is that consumer's
  *  contract. */
-export declare const MemberDirection: z.ZodEnum<["loosen", "tighten"]>;
+export declare const MemberDirection: z.ZodEnum<{
+    loosen: "loosen";
+    tighten: "tighten";
+}>;
 export type MemberDirection = z.infer<typeof MemberDirection>;
 /** One member's admission row. `minTrust` ABSENT ⇒ the category's `minTrust` applies: a row can refine the floor
  *  only by SAYING so; omission never lowers it (fail-closed by construction).
@@ -95,33 +111,30 @@ export type MemberDirection = z.infer<typeof MemberDirection>;
  *  fail-closed (it loses only the convenience of low-trust tightening, it can never admit a loosening write).
  *  Resolution is value-aware: pass the candidate value to {@link memberAdmission} / {@link memberMinTrust}. */
 export declare const MemberAdmission: z.ZodObject<{
-    direction: z.ZodEnum<["loosen", "tighten"]>;
-    minTrust: z.ZodOptional<z.ZodEnum<["local", "session", "project", "global", "managed", "task"]>>;
+    direction: z.ZodEnum<{
+        loosen: "loosen";
+        tighten: "tighten";
+    }>;
+    minTrust: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        session: "session";
+        global: "global";
+        project: "project";
+        managed: "managed";
+        task: "task";
+    }>>;
     boolPole: z.ZodOptional<z.ZodObject<{
         strict: z.ZodBoolean;
-        minTrust: z.ZodEnum<["local", "session", "project", "global", "managed", "task"]>;
-    }, "strip", z.ZodTypeAny, {
-        strict: boolean;
-        minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-    }, {
-        strict: boolean;
-        minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    direction: "loosen" | "tighten";
-    minTrust?: "local" | "session" | "global" | "project" | "managed" | "task" | undefined;
-    boolPole?: {
-        strict: boolean;
-        minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-    } | undefined;
-}, {
-    direction: "loosen" | "tighten";
-    minTrust?: "local" | "session" | "global" | "project" | "managed" | "task" | undefined;
-    boolPole?: {
-        strict: boolean;
-        minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-    } | undefined;
-}>;
+        minTrust: z.ZodEnum<{
+            local: "local";
+            session: "session";
+            global: "global";
+            project: "project";
+            managed: "managed";
+            task: "task";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type MemberAdmission = z.infer<typeof MemberAdmission>;
 /** The RESOLVED admission a consumer branches on — the category fallback already applied, so `minTrust` is never
  *  absent here. Produced by {@link resolveMemberAdmission} / {@link memberAdmission}. */
@@ -137,187 +150,114 @@ export interface ResolvedMemberAdmission {
 }
 /** WHERE the category is enforced (STRENGTH) — MUST stay in lockstep with `EffectiveKey.enforcement` (types.ts).
  *  gate=data-plane engine, server=control-plane/TOB boundary, resolver=merger correctness, client=UI only. */
-export declare const SpecEnforcement: z.ZodEnum<["gate", "server", "resolver", "client"]>;
+export declare const SpecEnforcement: z.ZodEnum<{
+    gate: "gate";
+    server: "server";
+    resolver: "resolver";
+    client: "client";
+}>;
 export type SpecEnforcement = z.infer<typeof SpecEnforcement>;
 /** Fail direction when enforcement can't be evaluated. fail-OPEN is allowed for `client` OR `resolver`
  *  enforcement on NON-secret keys (additive merges like mcpServers/rules/env); `gate`/`server`/secret → CLOSED. */
-export declare const FailMode: z.ZodEnum<["closed", "open"]>;
+export declare const FailMode: z.ZodEnum<{
+    closed: "closed";
+    open: "open";
+}>;
 export type FailMode = z.infer<typeof FailMode>;
 /** The monotone tighten-only direction for a category (which way is "stricter"). `enumRank.order` lists values
- *  from LOOSEST→STRICTEST; `boolStricter.strict` is the bool value that is the tighter one; `setNarrower` = a
- *  subset is tighter; `policyDenyWins` = deny beats allow; `none` = not rank-tightenable (replace / conflict-reject). */
-export declare const TightenRule: z.ZodDiscriminatedUnion<"rule", [z.ZodObject<{
+ *  from LOOSEST→STRICTEST — the category's whole vocabulary: a word outside it is refused, and a ONE-word order (11.0.0:
+ *  `shellGate`, whose engine vocabulary is the single floor word) is the degenerate rank where the only merge is identity;
+ *  `boolStricter.strict` is the bool value that is the tighter one; `setNarrower` = a subset is tighter; `policyDenyWins` =
+ *  deny beats allow; `none` = not rank-tightenable (replace / conflict-reject). */
+export declare const TightenRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
     rule: z.ZodLiteral<"none">;
-}, "strip", z.ZodTypeAny, {
-    rule: "none";
-}, {
-    rule: "none";
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     rule: z.ZodLiteral<"policyDenyWins">;
-}, "strip", z.ZodTypeAny, {
-    rule: "policyDenyWins";
-}, {
-    rule: "policyDenyWins";
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     rule: z.ZodLiteral<"setNarrower">;
-}, "strip", z.ZodTypeAny, {
-    rule: "setNarrower";
-}, {
-    rule: "setNarrower";
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     rule: z.ZodLiteral<"boolStricter">;
     strict: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    strict: boolean;
-    rule: "boolStricter";
-}, {
-    strict: boolean;
-    rule: "boolStricter";
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     rule: z.ZodLiteral<"enumRank">;
-    order: z.ZodArray<z.ZodString, "many">;
-}, "strip", z.ZodTypeAny, {
-    rule: "enumRank";
-    order: string[];
-}, {
-    rule: "enumRank";
-    order: string[];
-}>]>;
+    order: z.ZodArray<z.ZodString>;
+}, z.core.$strip>], "rule">;
 export type TightenRule = z.infer<typeof TightenRule>;
 export declare const MergeCategorySpec: z.ZodObject<{
-    mergeShape: z.ZodEnum<["denyFirst", "replace", "runAll", "overrideByName", "concat"]>;
-    minTrust: z.ZodEnum<["local", "session", "project", "global", "managed", "task"]>;
-    tighten: z.ZodDiscriminatedUnion<"rule", [z.ZodObject<{
+    mergeShape: z.ZodEnum<{
+        concat: "concat";
+        replace: "replace";
+        denyFirst: "denyFirst";
+        runAll: "runAll";
+        overrideByName: "overrideByName";
+    }>;
+    minTrust: z.ZodEnum<{
+        local: "local";
+        session: "session";
+        global: "global";
+        project: "project";
+        managed: "managed";
+        task: "task";
+    }>;
+    tighten: z.ZodDiscriminatedUnion<[z.ZodObject<{
         rule: z.ZodLiteral<"none">;
-    }, "strip", z.ZodTypeAny, {
-        rule: "none";
-    }, {
-        rule: "none";
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         rule: z.ZodLiteral<"policyDenyWins">;
-    }, "strip", z.ZodTypeAny, {
-        rule: "policyDenyWins";
-    }, {
-        rule: "policyDenyWins";
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         rule: z.ZodLiteral<"setNarrower">;
-    }, "strip", z.ZodTypeAny, {
-        rule: "setNarrower";
-    }, {
-        rule: "setNarrower";
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         rule: z.ZodLiteral<"boolStricter">;
         strict: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        strict: boolean;
-        rule: "boolStricter";
-    }, {
-        strict: boolean;
-        rule: "boolStricter";
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         rule: z.ZodLiteral<"enumRank">;
-        order: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        rule: "enumRank";
-        order: string[];
-    }, {
-        rule: "enumRank";
-        order: string[];
-    }>]>;
-    enforcement: z.ZodEnum<["gate", "server", "resolver", "client"]>;
-    fail: z.ZodEnum<["closed", "open"]>;
-    /** The compile target / seam this category lands on (free text, for traceability). */
+        order: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>], "rule">;
+    enforcement: z.ZodEnum<{
+        gate: "gate";
+        server: "server";
+        resolver: "resolver";
+        client: "client";
+    }>;
+    fail: z.ZodEnum<{
+        closed: "closed";
+        open: "open";
+    }>;
     seam: z.ZodString;
-    /** When the category's VALUE domain is core's, the cited `SAFETY_AXIS_VOCABULARY` dimension (conformance-checked). */
-    coreAxis: z.ZodOptional<z.ZodEnum<["toolEffect", "egress", "irreversibility", "safetyAxis", "severity", "shellGate", "permissionDecision"]>>;
-    /** 1.1.0 — member-level admission (see the file header). ABSENT ⇒ the category is a whole key: its `minTrust`
-     *  admits or rejects the whole value. PRESENT ⇒ each named member is admitted on its own row (fallback to the
-     *  category `minTrust` when the row omits one); the member set is closed — {@link membersOf} enumerates it. */
+    coreAxis: z.ZodOptional<z.ZodEnum<{
+        permissionDecision: "permissionDecision";
+        toolEffect: "toolEffect";
+        egress: "egress";
+        irreversibility: "irreversibility";
+        safetyAxis: "safetyAxis";
+        severity: "severity";
+        shellGate: "shellGate";
+    }>>;
     members: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        direction: z.ZodEnum<["loosen", "tighten"]>;
-        minTrust: z.ZodOptional<z.ZodEnum<["local", "session", "project", "global", "managed", "task"]>>;
+        direction: z.ZodEnum<{
+            loosen: "loosen";
+            tighten: "tighten";
+        }>;
+        minTrust: z.ZodOptional<z.ZodEnum<{
+            local: "local";
+            session: "session";
+            global: "global";
+            project: "project";
+            managed: "managed";
+            task: "task";
+        }>>;
         boolPole: z.ZodOptional<z.ZodObject<{
             strict: z.ZodBoolean;
-            minTrust: z.ZodEnum<["local", "session", "project", "global", "managed", "task"]>;
-        }, "strip", z.ZodTypeAny, {
-            strict: boolean;
-            minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-        }, {
-            strict: boolean;
-            minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        direction: "loosen" | "tighten";
-        minTrust?: "local" | "session" | "global" | "project" | "managed" | "task" | undefined;
-        boolPole?: {
-            strict: boolean;
-            minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-        } | undefined;
-    }, {
-        direction: "loosen" | "tighten";
-        minTrust?: "local" | "session" | "global" | "project" | "managed" | "task" | undefined;
-        boolPole?: {
-            strict: boolean;
-            minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-        } | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    enforcement: "gate" | "server" | "resolver" | "client";
-    tighten: {
-        rule: "none";
-    } | {
-        rule: "policyDenyWins";
-    } | {
-        rule: "setNarrower";
-    } | {
-        strict: boolean;
-        rule: "boolStricter";
-    } | {
-        rule: "enumRank";
-        order: string[];
-    };
-    minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-    mergeShape: "concat" | "replace" | "denyFirst" | "runAll" | "overrideByName";
-    fail: "closed" | "open";
-    seam: string;
-    members?: Record<string, {
-        direction: "loosen" | "tighten";
-        minTrust?: "local" | "session" | "global" | "project" | "managed" | "task" | undefined;
-        boolPole?: {
-            strict: boolean;
-            minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-        } | undefined;
-    }> | undefined;
-    coreAxis?: "permissionDecision" | "toolEffect" | "egress" | "irreversibility" | "safetyAxis" | "severity" | "shellGate" | undefined;
-}, {
-    enforcement: "gate" | "server" | "resolver" | "client";
-    tighten: {
-        rule: "none";
-    } | {
-        rule: "policyDenyWins";
-    } | {
-        rule: "setNarrower";
-    } | {
-        strict: boolean;
-        rule: "boolStricter";
-    } | {
-        rule: "enumRank";
-        order: string[];
-    };
-    minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-    mergeShape: "concat" | "replace" | "denyFirst" | "runAll" | "overrideByName";
-    fail: "closed" | "open";
-    seam: string;
-    members?: Record<string, {
-        direction: "loosen" | "tighten";
-        minTrust?: "local" | "session" | "global" | "project" | "managed" | "task" | undefined;
-        boolPole?: {
-            strict: boolean;
-            minTrust: "local" | "session" | "global" | "project" | "managed" | "task";
-        } | undefined;
-    }> | undefined;
-    coreAxis?: "permissionDecision" | "toolEffect" | "egress" | "irreversibility" | "safetyAxis" | "severity" | "shellGate" | undefined;
-}>;
+            minTrust: z.ZodEnum<{
+                local: "local";
+                session: "session";
+                global: "global";
+                project: "project";
+                managed: "managed";
+                task: "task";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type MergeCategorySpec = z.infer<typeof MergeCategorySpec>;
 /** The category spec. Keys = the unified settings categories both seats map their concrete keys/fields into.
  *  Faithful to settings-core v2-design §3 (the semantic source of record). */
@@ -374,7 +314,7 @@ export declare const SAFETY_MERGE_SPEC: {
         readonly minTrust: "global";
         readonly tighten: {
             readonly rule: "enumRank";
-            readonly order: ["off", "classify", "always"];
+            readonly order: ["always"];
         };
         readonly enforcement: "gate";
         readonly fail: "closed";
@@ -582,7 +522,7 @@ export declare const SAFETY_MERGE_SPEC: {
         };
         readonly enforcement: "server";
         readonly fail: "closed";
-        readonly seam: "config-center → governanceBaseline (SSO/SCIM/audit/budget, TOB-only)";
+        readonly seam: "web-admin → governanceBaseline (SSO/SCIM/audit/budget, TOB-only)";
     };
 };
 export type SafetyMergeCategory = keyof typeof SAFETY_MERGE_SPEC;