@sema-agent/settings-schema 7.0.0 → 8.0.0

package/dist/conformance/derive.js

@@ -1,6 +1,7 @@
 /**
- * **三腿等价先定义再比**:语料以 `domains`(各域原始文档)为真源,`wire` 与 `local-root` 两腿的**入参**
- * 与**期望**都由本文件派生 —— 派生规则就是三条腿之间那几处**表示差异**的完整登记表。
+ * **读腿等价先定义再比**:语料以 `domains`(各域原始文档)为真源,`wire` 与 `local-root` 两腿的**入参**
+ * 与**期望**都由本文件派生 —— 派生规则就是三条读腿之间那几处**表示差异**的完整登记表(第四条腿
+ * `strictWrite` 的立场见下文与 {@link LEG_EXPECTATION})。
  *
  * 为什么派生期望而不是每腿各写一份 golden:三份手写 golden 之间的关系是**隐含**的,谁也说不清某一处
  * 不同是「设计如此」还是「某一腿读错了」。派生把那层关系变成代码:凡不能由登记的变换解释的差异,一定
@@ -27,6 +28,11 @@
  *
  * 语料可以对某一腿写**显式期望**(带 `why`)来覆盖派生 —— 那是「这条 case 的这条腿不由变换解释」的
  * 明示声明,不是一条暗门。
+ *
+ * **每条腿的期望从哪来**是一张闭集表({@link LEG_EXPECTATION},`Record<LegName, …>` —— 新开一条腿不来这里
+ * 表态就编译红)。`strictWrite`(严写受理)的**入参**与 `domains` 恒等(同一份各域原始文档),**期望不派生**:
+ * 严写的结局不是读结局的一种表示变换,而是另一个判断(读腿抢救的地方严写拒)。把它写成「从 domains 期望派生」
+ * 就等于让 domains 金样的一处错同时改写两条腿的期望 —— 两条腿同错、门照绿。它的金样逐条显式入库、各自冻结。
  */
 import { NON_DOMAIN_CONFIG_FILES, PORTABLE_DOMAINS } from "../file-store.js";
 import { skillContentHash } from "../skills-manifest.js";
@@ -40,6 +46,23 @@ export const DERIVATION_TRANSFORMS = [
     { id: "T5-file-layer-first", legs: ["localRoot"], what: "config.d/<域>.json 必须是 JSON 对象(空/null/数组/标量 throw),这一层在域解析之前" },
     { id: "T6-file-name-classification", legs: ["localRoot"], what: "config.d/ 的文件分三类:域文件 / NON_DOMAIN_CONFIG_FILES(remote-exec.json 自带读取与校验路径)/ 隐藏文件与非 .json(忽略);只有剩下的才报 not-a-domain" },
 ];
+/**
+ * 每条腿的期望从哪来 —— 闭集表态(`Record<LegName, …>`:新开一条腿不在这里表态 ⇒ 编译红)。
+ *
+ *  · `derivable`:语料可以写 `{"derive":true}`,由上面的变换表从 `domains` 期望派生(也可写显式期望并带 `why`)。
+ *  · `explicit`:只收显式金样(`{"derive":true}` 加载即拒)。
+ *
+ * 语料加载器与驱动都读这张表(一条规则),不再各自特判某个腿名。
+ */
+export const LEG_EXPECTATION = {
+    domains: { source: "explicit", why: "真源:domains 腿的期望就是金样本身" },
+    strictWrite: {
+        source: "explicit",
+        why: "入参与 domains 恒等,期望不派生:严写结局不是读结局的表示变换(读腿抢救处严写拒);从 domains 期望派生会让一份金样的错同时改写两条腿",
+    },
+    wire: { source: "derivable", why: "T1 / T2 / T4" },
+    localRoot: { source: "derivable", why: "T3 / T4 / T5 / T6" },
+};
 /** 非便携域 —— 由 {@link PORTABLE_DOMAINS} 派生,零手抄。 */
 export const NON_PORTABLE_DOMAINS = DOMAINS.filter((d) => !PORTABLE_DOMAINS.includes(d));
 const isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);

package/dist/conformance/index.d.ts

@@ -6,7 +6,8 @@
  *
  * 三步接线(消费方侧):
  *   1. 造一个 {@link ConformanceAdapter}:`provenance` = 你**实际加载到**的那份契约包(package.json 路径、
- *      版号、完整性串);`legs` = 你自己的生产读腿,每条带 `entry{module,export}`(生产入口的绝对路径)。
+ *      版号、完整性串);`legs` = **四条腿逐条表态**:你自己的生产入口(每条带 `entry{module,export}`,生产入口的
+ *      绝对路径),或 `{ declined: "no-production-path", why }`(你的生产代码结构上没有这种读法 / 写法)。
  *   2. `const report = await runConformance(adapter, { mode: "release" })`。
  *   3. 断言 `report.ok`;不绿就读 `report.violations` 与每格的 `diff`(effective 的 JSON patch、告警多重集差、
  *      元数据差三面分开)。
@@ -16,7 +17,7 @@
 export { runConformance, materializeLocalRoot, resolveLegExpectation } from "./run.js";
 export { createContractAdapter, type ContractAdapterOptions, type ContractModule } from "./contract-adapter.js";
 export { loadCorpus, loadCase, kitIdentity, DEFAULT_CORPUS_DIR, PACKAGE_ROOT, type Corpus, type ConformanceCase, type CaseInput, type CaseMeta, type LegExpectationJson } from "./corpus.js";
-export { DERIVATION_TRANSFORMS, NON_PORTABLE_DOMAINS, EPOCH_ISO, deriveWireInput, deriveLocalInput, deriveWireExpectation, deriveLocalExpectation, foreignKeysOf, toManifestDoc, type DerivationTransform, type LegExpectation, } from "./derive.js";
+export { DERIVATION_TRANSFORMS, LEG_EXPECTATION, NON_PORTABLE_DOMAINS, EPOCH_ISO, deriveWireInput, deriveLocalInput, deriveWireExpectation, deriveLocalExpectation, foreignKeysOf, toManifestDoc, type DerivationTransform, type LegExpectation, } from "./derive.js";
 export { canonicalize, deepEqual, diffJson, stableKey, type JsonPatchOp } from "./canonical.js";
 export { WARNING_KINDS, projectWarning, normalizeProjection, projectionKey, projectionValue, diffWarningMultiset, findSecretLeaks, type WarningKind, type WarningProjection, } from "./warnings.js";
-export { LEG_NAMES, REJECT_STAGES, type ConformanceAdapter, type ConformanceLeg, type ConformanceMode, type ConformanceNormalizer, type ConformanceOptions, type ConformanceProvenance, type ConformanceReport, type ConformanceResult, type ConformanceStatus, type KnownDivergence, type OutcomeDivergence, type PathDivergence, type LedgerRow, type LegEntry, type LegInput, type LegName, type LegOutcome, type RejectStage, } from "./types.js";
+export { LEG_DECLINE_REASONS, LEG_NAMES, REJECT_STAGES, type ConformanceAdapter, type ConformanceLeg, type DomainDocsInput, type LegDeclineReason, type LegDeclined, type LegStance, type ConformanceMode, type ConformanceNormalizer, type ConformanceOptions, type ConformanceProvenance, type ConformanceReport, type ConformanceResult, type ConformanceStatus, type KnownDivergence, type OutcomeDivergence, type PathDivergence, type LedgerRow, type LegEntry, type LegInput, type LegName, type LegOutcome, type RejectStage, } from "./types.js";

package/dist/conformance/index.js

@@ -6,7 +6,8 @@
  *
  * 三步接线(消费方侧):
  *   1. 造一个 {@link ConformanceAdapter}:`provenance` = 你**实际加载到**的那份契约包(package.json 路径、
- *      版号、完整性串);`legs` = 你自己的生产读腿,每条带 `entry{module,export}`(生产入口的绝对路径)。
+ *      版号、完整性串);`legs` = **四条腿逐条表态**:你自己的生产入口(每条带 `entry{module,export}`,生产入口的
+ *      绝对路径),或 `{ declined: "no-production-path", why }`(你的生产代码结构上没有这种读法 / 写法)。
  *   2. `const report = await runConformance(adapter, { mode: "release" })`。
  *   3. 断言 `report.ok`;不绿就读 `report.violations` 与每格的 `diff`(effective 的 JSON patch、告警多重集差、
  *      元数据差三面分开)。
@@ -16,7 +17,7 @@
 export { runConformance, materializeLocalRoot, resolveLegExpectation } from "./run.js";
 export { createContractAdapter } from "./contract-adapter.js";
 export { loadCorpus, loadCase, kitIdentity, DEFAULT_CORPUS_DIR, PACKAGE_ROOT } from "./corpus.js";
-export { DERIVATION_TRANSFORMS, NON_PORTABLE_DOMAINS, EPOCH_ISO, deriveWireInput, deriveLocalInput, deriveWireExpectation, deriveLocalExpectation, foreignKeysOf, toManifestDoc, } from "./derive.js";
+export { DERIVATION_TRANSFORMS, LEG_EXPECTATION, NON_PORTABLE_DOMAINS, EPOCH_ISO, deriveWireInput, deriveLocalInput, deriveWireExpectation, deriveLocalExpectation, foreignKeysOf, toManifestDoc, } from "./derive.js";
 export { canonicalize, deepEqual, diffJson, stableKey } from "./canonical.js";
 export { WARNING_KINDS, projectWarning, normalizeProjection, projectionKey, projectionValue, diffWarningMultiset, findSecretLeaks, } from "./warnings.js";
-export { LEG_NAMES, REJECT_STAGES, } from "./types.js";
+export { LEG_DECLINE_REASONS, LEG_NAMES, REJECT_STAGES, } from "./types.js";

package/dist/conformance/run.d.ts

@@ -19,9 +19,9 @@ export declare function resolveLegExpectation(c: ConformanceCase, leg: LegName,
 /**
  * 跑一遍门。
  *
- * `release`:版本三方对齐(适配器加载到的包 == 语料 VERSION == kit 所在包)+ 每条登记的腿都指向一个
- * **真存在、且不在契约包 node_modules 之下**的生产入口 + 禁 `only` + 至少登记一条腿 + **登记的腿必须跑**
- * (未登记的腿只记 `skipped: no adapter`,不算违例)+ 账本条目的形 + 零陈腐账本条目。
+ * `release`:版本三方对齐(适配器加载到的包 == 语料 VERSION == kit 所在包)+ **每条腿都有表态**(实现,或显式声明
+ * 不承担:闭集理由词 + why;缺表态 / 形不对 = 违例)+ 每条实现了的腿都指向一个**真存在、且不在契约包自己身上**的生产入口
+ * + 禁 `only` + 至少实现一条腿 + **实现的腿必须跑** + 账本条目的形 + 零陈腐账本条目。声明不承担的腿逐格记 `skipped`(带理由)。
  * `historical`:对旧版包跑,只记行为 diff;归一器可在场且必须自陈有损。
  */
 export declare function runConformance(adapter: ConformanceAdapter, opts: ConformanceOptions): Promise<ConformanceReport>;

package/dist/conformance/run.js

@@ -19,7 +19,7 @@ import { diffWarningMultiset, findSecretLeaks, projectWarning } from "./warnings
 import { deriveLocalExpectation, deriveLocalInput, deriveWireExpectation, deriveWireInput, toManifestDoc } from "./derive.js";
 import { kitIdentity, loadCorpus } from "./corpus.js";
 import { contractOwnedEntry, contractOwnedEntryWhy } from "./entry-origin.js";
-import { LEG_NAMES, } from "./types.js";
+import { LEG_DECLINE_REASONS, LEG_NAMES, } from "./types.js";
 /** 一个**模块**文件的样子 —— 来源律用它挡住「随便找个存在的文件当入口」(`package.json` 也是文件)。 */
 const MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".tsx", ".js", ".mjs", ".cjs", ".jsx"];
 /**
@@ -77,6 +77,7 @@ function legInput(c, leg) {
     const { version, updatedAt } = c.input.meta;
     switch (leg) {
         case "domains":
+        case "strictWrite": // 两条腿吃同一份真源(恒等,不派生入参)
             return { leg, docs: c.input.domains, version, updatedAt };
         case "wire":
             return c.input.wirePayload === undefined ? deriveWireInput(c.input.domains, version, updatedAt) : { leg, payload: c.input.wirePayload };
@@ -254,6 +255,31 @@ function judge(c, leg, expected, actual, normalizer, ledger, hits) {
     }
     return { ...base, status: "diff", detail, diff };
 }
+function stanceOf(adapter, leg) {
+    const legs = adapter.legs;
+    const s = legs !== null && typeof legs === "object" ? legs[leg] : undefined;
+    if (s === undefined)
+        return { kind: "missing" };
+    if (s === null || typeof s !== "object")
+        return { kind: "malformed", why: "the stance is not an object" };
+    const runs = typeof s.run === "function";
+    const declines = Object.prototype.hasOwnProperty.call(s, "declined");
+    // 与类型同律(两臂互斥):声明臂上出现实现臂的任一字段(`entry` / `run`)都算「既实现又声明」。
+    const carriesImplementation = runs || Object.prototype.hasOwnProperty.call(s, "entry") || Object.prototype.hasOwnProperty.call(s, "run");
+    if (declines && carriesImplementation)
+        return { kind: "malformed", why: "it both implements the leg (`entry` / `run`) and declines it (`declined`) — 一条腿只能有一种表态" };
+    if (runs)
+        return { kind: "implemented", impl: s };
+    if (!declines)
+        return { kind: "malformed", why: "it neither implements the leg (`run` + `entry`) nor declines it (`declined` + `why`)" };
+    const { declined, why } = s;
+    if (!LEG_DECLINE_REASONS.includes(declined)) {
+        return { kind: "malformed", why: `decline reason ${JSON.stringify(declined)} is not one of ${LEG_DECLINE_REASONS.join(" | ")}` };
+    }
+    if (typeof why !== "string" || why.trim().length === 0)
+        return { kind: "malformed", why: "a declined leg has an empty `why` — 说不出「为什么结构上没有」的一句声明等于没声明" };
+    return { kind: "declined", declined: { declined: declined, why } };
+}
 /** release 模式的**来源律 + 版本护栏**(historical 模式不跑这几条:它就是拿旧版包比行为的)。 */
 async function releaseViolations(adapter, opts, corpus, kit) {
     const v = [];
@@ -307,9 +333,30 @@ async function releaseViolations(adapter, opts, corpus, kit) {
         if (!Array.isArray(cases) || cases.length === 0)
             v.push(`known divergence \`${e.ref}\` is an outcome divergence that must name at least one case — 结局形不许按前缀大包一整条腿的拒绝面`);
     }
-    const legs = Object.entries(adapter.legs).filter(([, l]) => l !== undefined);
+    // **每条腿都要表态**:实现,或显式声明不承担(闭集理由词 + why)。缺表态 / 形不对 ⇒ 违例 —— 不许静默跳过,也不许默认当通过。
+    const legs = [];
+    for (const leg of LEG_NAMES) {
+        const s = stanceOf(adapter, leg);
+        switch (s.kind) {
+            case "implemented":
+                legs.push([leg, s.impl]);
+                break;
+            case "declined":
+                break;
+            case "missing":
+                v.push(`leg \`${leg}\` has no stance — 每条腿要么实现、要么显式声明不承担(\`{ declined: ${LEG_DECLINE_REASONS.map((r) => JSON.stringify(r)).join(" | ")}, why }\`);不表态不是一种表态`);
+                break;
+            case "malformed":
+                v.push(`leg \`${leg}\` has a malformed stance: ${s.why}`);
+                break;
+            default: {
+                const unhandled = s;
+                throw new Error(`conformance: unhandled stance ${JSON.stringify(unhandled)}`);
+            }
+        }
+    }
     if (legs.length === 0)
-        v.push("adapter registers no leg at all");
+        v.push("adapter implements no leg at all");
     for (const [name, leg] of legs) {
         const mod = leg.entry.module;
         if (!isAbsolute(mod)) {
@@ -338,18 +385,34 @@ async function releaseViolations(adapter, opts, corpus, kit) {
     }
     return v;
 }
+/** 一格「没跑」的那句话:按表态说清是哪一种没跑(实现了的腿走不到这里)。 */
+function notRunDetail(s) {
+    switch (s.kind) {
+        case "declined":
+            return `consumer declines this leg (${s.declined.declined}): ${s.declined.why}`;
+        case "missing":
+            return "no stance: this consumer neither implements nor declines this leg";
+        case "malformed":
+            return `malformed stance: ${s.why}`;
+        default: {
+            const unhandled = s;
+            throw new Error(`conformance: unhandled stance ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
 /**
  * 跑一遍门。
  *
- * `release`:版本三方对齐(适配器加载到的包 == 语料 VERSION == kit 所在包)+ 每条登记的腿都指向一个
- * **真存在、且不在契约包 node_modules 之下**的生产入口 + 禁 `only` + 至少登记一条腿 + **登记的腿必须跑**
- * (未登记的腿只记 `skipped: no adapter`,不算违例)+ 账本条目的形 + 零陈腐账本条目。
+ * `release`:版本三方对齐(适配器加载到的包 == 语料 VERSION == kit 所在包)+ **每条腿都有表态**(实现,或显式声明
+ * 不承担:闭集理由词 + why;缺表态 / 形不对 = 违例)+ 每条实现了的腿都指向一个**真存在、且不在契约包自己身上**的生产入口
+ * + 禁 `only` + 至少实现一条腿 + **实现的腿必须跑** + 账本条目的形 + 零陈腐账本条目。声明不承担的腿逐格记 `skipped`(带理由)。
  * `historical`:对旧版包跑,只记行为 diff;归一器可在场且必须自陈有损。
  */
 export async function runConformance(adapter, opts) {
     const corpus = await loadCorpus(opts.corpusDir);
     const kit = await kitIdentity();
     const violations = opts.mode === "release" ? await releaseViolations(adapter, opts, corpus, kit) : [];
+    const stances = new Map(LEG_NAMES.map((leg) => [leg, stanceOf(adapter, leg)]));
     const only = opts.only === undefined ? undefined : new Set(opts.only);
     const cases = only === undefined ? corpus.cases : corpus.cases.filter((c) => only.has(c.id));
     if (only !== undefined) {
@@ -368,17 +431,16 @@ export async function runConformance(adapter, opts) {
                 results.push({ caseId: c.id, leg, status: "skipped", detail: `case declares this leg not applicable: ${spec.why}` });
                 continue;
             }
-            const impl = adapter.legs[leg];
-            if (impl === undefined) {
-                // 未登记 = 这个消费方结构上没有这条读法(docs/CONFORMANCE.md §1「没有的腿不要造」)。逐格记
-                // `skipped: no adapter`,覆盖矩阵看得见它没跑,**不算违例** —— 律指向的是**登记过的东西**
-                // (至少一条腿 + 登记的腿必须跑),而不是「三条腿必须都有」。
-                results.push({ caseId: c.id, leg, status: "skipped", detail: "no adapter: this consumer registered no such read leg" });
+            const stance = stances.get(leg);
+            if (stance.kind !== "implemented") {
+                // 声明不承担 ⇒ 逐格 `skipped`,detail 带理由词与 why(覆盖矩阵看得见它没跑、为什么没跑)。缺表态 / 形不对同样
+                // 没法跑 ⇒ 也记 `skipped`,但 release 门已把它记成违例(见 releaseViolations)—— 不表态不是一种表态。
+                results.push({ caseId: c.id, leg, status: "skipped", detail: notRunDetail(stance) });
                 continue;
             }
             let actual;
             try {
-                actual = await impl.run(legInput(c, leg));
+                actual = await stance.impl.run(legInput(c, leg));
             }
             catch (e) {
                 results.push({ caseId: c.id, leg, status: "harness-error", detail: `the adapter threw instead of returning an outcome: ${e instanceof Error ? e.message : String(e)}` });
@@ -394,12 +456,12 @@ export async function runConformance(adapter, opts) {
         ? { ref: e.ref, kind: e.kind, leg: e.leg, pathPrefix: e.pathPrefix, ...(e.cases === undefined ? {} : { cases: e.cases }), flipWhen: e.flipWhen, hits: hits[i] }
         : { ref: e.ref, kind: e.kind, leg: e.outcome.leg, outcome: { expected: e.outcome.expected, actual: e.outcome.actual }, cases: e.outcome.cases, flipWhen: e.flipWhen, hits: hits[i] });
     if (opts.mode === "release") {
-        // **登记的腿必须跑**:登记了却在整套语料上一格真读数都没有,那条登记是空的。
+        // **实现的腿必须跑**:实现了却在整套语料上一格真读数都没有,那份实现是空的。
         for (const leg of LEG_NAMES) {
-            if (adapter.legs[leg] === undefined)
+            if (stances.get(leg).kind !== "implemented")
                 continue;
             if (!results.some((r) => r.leg === leg && r.status !== "skipped")) {
-                violations.push(`leg \`${leg}\` is registered yet never ran — 整套语料上一格真读数都没有(登记的腿必须跑)`);
+                violations.push(`leg \`${leg}\` is implemented yet never ran — 整套语料上一格真读数都没有(实现的腿必须跑)`);
             }
         }
         // **棘轮只降不升**:账本里一条从未命中的登记,自己就是违例 —— 债还了就得把账本删掉。
@@ -411,7 +473,15 @@ export async function runConformance(adapter, opts) {
     const uniqueViolations = [...new Set(violations)];
     return {
         mode: opts.mode,
-        adapter: { name: adapter.name, provenance: adapter.provenance, legs: LEG_NAMES.filter((l) => adapter.legs[l] !== undefined) },
+        adapter: {
+            name: adapter.name,
+            provenance: adapter.provenance,
+            legs: LEG_NAMES.filter((l) => stances.get(l).kind === "implemented"),
+            declined: LEG_NAMES.flatMap((leg) => {
+                const s = stances.get(leg);
+                return s.kind === "declined" ? [{ leg, ...s.declined }] : [];
+            }),
+        },
         corpusVersion: corpus.version,
         kitVersion: kit.version,
         ...(opts.normalizer === undefined ? {} : { normalizer: { id: opts.normalizer.id, lossy: opts.normalizer.lossy, why: opts.normalizer.why } }),

package/dist/conformance/types.d.ts

@@ -10,21 +10,31 @@
  * 复述的规范化就是第二份真源,而两份真源的分歧正是本门要抓的那类病。
  */
 import type { EffectiveReadWarning, WarningProjection } from "../config-fns.js";
-/** 三条读腿的名字。**闭集** —— 新开一条腿要同时在语料派生表(`derive.ts` 的 `DERIVATION_TRANSFORMS`)里表态。
+/** 四条腿的名字。**闭集** —— 新开一条腿要同时在 `derive.ts` 的 {@link LEG_EXPECTATION}(`Record<LegName, …>`,
+ *  不表态即编译红)里说清它的期望从哪来,且每个消费方的 {@link ConformanceAdapter.legs} 都要对它表态(实现或声明不承担)。
  *
- *  · `domains`:各域**原始文档**(center 侧存储形)→ effective。契约仓的 `buildEffective`。
+ *  · `domains`:各域**原始文档**(center 侧存储形)→ effective。契约仓的 `buildEffective`(读:逐条抢救 + 降级 + 告警)。
+ *  · `strictWrite`:同一份各域原始文档 → **严写受理**(写入席收下这份文档集与否)。契约仓的 `parseDomain`;管理面的
+ *    域写受理。结局复用 {@link LegOutcome} 的两类:全部受理 ⇒ `effective` = 严格解析出的域文档集(只含入参里的键,
+ *    不补缺席域);任何一份不受理 ⇒ `rejected{stage:"validate"}`。读腿抢救的(坏条目丢弃、整域降级、主机名夹紧)
+ *    在这条腿上是拒 —— 写入席不替运维删他的条目。
  *  · `wire`:`GET /effective` 载荷 → effective。契约仓的 `readEffectiveWire`。
  *  · `localRoot`:`config.d/` 目录快照(文件名 → 文件内容)→ effective。契约仓的 `loadLocalConfig`。 */
-export type LegName = "domains" | "wire" | "localRoot";
-/** 三条腿的名字表(运行期枚举用;与 {@link LegName} 同源 —— 多一员少一员编译红)。 */
-export declare const LEG_NAMES: readonly ["domains", "wire", "localRoot"];
-/** 一条读腿的入参。腿名决定形,`domains` 是真源,另两形由 harness 派生(见 derive.ts 的变换表)。 */
-export type LegInput = {
-    leg: "domains";
+export type LegName = "domains" | "strictWrite" | "wire" | "localRoot";
+/** 四条腿的名字表(运行期枚举用;与 {@link LegName} 同源 —— 多一员少一员编译红)。 */
+export declare const LEG_NAMES: readonly ["domains", "strictWrite", "wire", "localRoot"];
+/** 各域原始文档集 —— `domains` 与 `strictWrite` 两条腿**同一份**入参形(真源;一份字段表,两臂共用)。 */
+export interface DomainDocsInput {
     docs: Readonly<Record<string, unknown>>;
     version: number;
     updatedAt: string;
-} | {
+}
+/** 一条腿的入参。腿名决定形:`domains` / `strictWrite` 吃真源本身,另两形由 harness 派生(见 derive.ts 的变换表)。 */
+export type LegInput = ({
+    leg: "domains";
+} & DomainDocsInput) | ({
+    leg: "strictWrite";
+} & DomainDocsInput) | {
     leg: "wire";
     payload: unknown;
 } | {
@@ -95,11 +105,36 @@ export interface LegEntry {
     /** 该文件里被当作读腿入口的导出名。 */
     export: string;
 }
-/** 一条登记进 kit 的读腿:它的生产入口 + 真正跑它的那只函数。 */
+/** 一条登记进 kit 的腿:它的生产入口 + 真正跑它的那只函数。与 {@link LegDeclined} **互斥**(类型层与运行期同律):
+ *  实现臂不许同时带 `declined`。 */
 export interface ConformanceLeg {
     entry: LegEntry;
     run(input: LegInput): Promise<LegOutcome> | LegOutcome;
+    declined?: never;
+}
+/**
+ * 「不承担这条腿」的理由。**闭集** —— 一个词就是一条理由,报告里逐格可见,release 门按词判(不认识的词 = 违例)。
+ *
+ *  · `no-production-path`:这个消费方的**生产代码里结构上就没有**这种读法 / 写法 —— 例:worker 只读不写,没有严写受理
+ *    (`strictWrite`);worker 不从各域原始文档建 effective,只吃 wire 与本地目录(`domains`);管理面不读 `config.d/`(`localRoot`)。
+ *
+ * 刻意**没有**「有这条路径但还没接」的词:有路径就接(那正是门要比的东西);一份结局上的已知差走 {@link KnownDivergence} 账本,
+ * 它带台账号、带翻转条件、受 stale 律管 —— 不必在这里再开一扇不受律管的门。
+ */
+export type LegDeclineReason = "no-production-path";
+/** {@link LegDeclineReason} 的运行期表(release 门校验用;与类型同源)。 */
+export declare const LEG_DECLINE_REASONS: readonly ["no-production-path"];
+/** 一条腿的**显式不承担**声明:理由词 + 一句人读的事实(`why`,非空 —— 「为什么结构上没有」要说得出来)。
+ *  与 {@link ConformanceLeg} **互斥**:声明臂不许带 `entry` / `run`(从声明迁到实现时 spread 合并留下的旧声明,编译期就红)。 */
+export interface LegDeclined {
+    declined: LegDeclineReason;
+    why: string;
+    entry?: never;
+    run?: never;
 }
+/** 消费方对一条腿的表态:实现它({@link ConformanceLeg}),或声明不承担({@link LegDeclined})。两臂互斥;没有第三种 —— 不表态不是一种表态。
+ *  release 门在运行期按同一条律判(适配器可能来自 JS / `as`):带 `declined` 又带 `entry` 或 `run` = 形不对。 */
+export type LegStance = ConformanceLeg | LegDeclined;
 /**
  * 消费方对金样的一条**已知合法差异**的登记位 —— 临时欠账,或成文语义。
  *
@@ -164,14 +199,15 @@ export interface ConformanceAdapter {
     name: string;
     provenance: ConformanceProvenance;
     /**
-     * **只登记你真有的腿**。未登记 = 这个消费方结构上没有这条读法(例:worker 服务的生产代码里没有
-     * `buildEffective` 调用点,它只有 wire 腿与 local-root 腿)—— 报告逐格记 `skipped: no adapter`
-     * (覆盖矩阵看得见它没跑),**不算违例**。
+     * **每条腿都要表态**(一条规则,四条腿同律):实现它,或显式声明不承担({@link LegDeclined},带理由词)。
+     * 类型是**全量** `Record` —— 闭集 {@link LegName} 加一员,每个消费方的适配器就编译红,直到它对新腿表态;
+     * 运行期(适配器可能来自 JS / `as`)release 门照判:缺表态 / 形不对 / 理由词不在闭集 / `why` 为空 ⇒ 违例。
+     * 声明不承担的腿逐格记 `skipped`(detail 带理由词与 `why`),并列进报告的 `adapter.declined` —— 看得见、不算通过、也不算红。
      *
-     * release 模式的两条律都指向**登记过的东西**:①至少登记一条腿;②**登记的腿必须跑** —— 登记了却在
-     * 整套语料上一格真读数都没有,那条登记是空的,违例。
+     * release 模式另两条律指向**实现了的腿**:①至少实现一条腿;②**实现的腿必须跑** —— 实现了却在整套语料上一格真读数都没有,
+     * 那份实现是空的,违例。
      */
-    legs: Partial<Record<LegName, ConformanceLeg>>;
+    legs: Record<LegName, LegStance>;
     /** 已知的**合法**差异账本(见 {@link KnownDivergence})。缺席 = 零容忍,任何 diff 都阻塞。 */
     knownDivergences?: readonly KnownDivergence[];
 }
@@ -200,7 +236,7 @@ export interface ConformanceNormalizer {
 }
 /**
  * 一格结局。`pass` / `expected-rejected` / `diff-ledgered` 不阻塞,`diff` / `harness-error` 红,
- * `skipped` 既不绿也不红(没跑)。
+ * `skipped` 既不绿也不红(没跑:语料声明本腿不适用,或消费方声明不承担 / 没表态 —— detail 说是哪一种)。
  *
  * `diff-ledgered`(3.0.0 车 FT):这一格的 effective 差**逐坐标**落在适配器的
  * {@link KnownDivergence} 账本里 —— 一笔登记在案的合法差异,不阻塞,但单独计数、按 `ref` 列出来。
@@ -261,10 +297,14 @@ export interface LedgerRow {
 /** 一次跑的报告。 */
 export interface ConformanceReport {
     mode: ConformanceMode;
+    /** `legs` = 实现了的腿;`declined` = 显式声明不承担的腿(理由词 + `why`)。两者之外的腿 = 没表态(release 模式违例)。 */
     adapter: {
         name: string;
         provenance: ConformanceProvenance;
         legs: readonly LegName[];
+        declined: readonly ({
+            leg: LegName;
+        } & LegDeclined)[];
     };
     /** 语料版本(`conformance/VERSION`)。 */
     corpusVersion: string;

package/dist/conformance/types.js

@@ -1,4 +1,6 @@
-/** 三条腿的名字表(运行期枚举用;与 {@link LegName} 同源 —— 多一员少一员编译红)。 */
-export const LEG_NAMES = ["domains", "wire", "localRoot"];
+/** 四条腿的名字表(运行期枚举用;与 {@link LegName} 同源 —— 多一员少一员编译红)。 */
+export const LEG_NAMES = ["domains", "strictWrite", "wire", "localRoot"];
 /** {@link RejectStage} 的运行期表(语料校验用;与类型同源)。 */
 export const REJECT_STAGES = ["envelope", "parse", "validate", "hash", "store"];
+/** {@link LegDeclineReason} 的运行期表(release 门校验用;与类型同源)。 */
+export const LEG_DECLINE_REASONS = ["no-production-path"];

package/dist/execution-lane-index.d.ts

@@ -1,7 +1,14 @@
 /**
- * 包内私有:车道表({@link EXECUTION_LANES})的两只**派生索引**,供 `types.ts`(写闸)与 `migrate-workers.ts`(一次性迁移)同读。
+ * 包内私有:车道表({@link EXECUTION_LANES})的两只**派生索引** + 「迁移能搬哪些键」的**一份**键集与指路句,
+ * 供 `types.ts`(写闸)与 `migrate-workers.ts`(一次性迁移)同读。
  * 不进主桶、不进 `package.json` 的 `exports`(与 `secret-scan.ts` 同一姿势)—— 消费方只拿表本身,索引是本包的实现细节。
  * 索引只从表派生,不另存任何词:表改了,这里跟着变。
+ *
+ * ## 迁移指路(7.0.1)
+ * 拒因要不要带迁移指路只有一条规则:**这个键「旧形 ⇒ 迁移能搬」就带,搬不了的保留名(`PORT` / `MODEL_*` …)不带**。
+ * 「迁移能搬」= 迁移自己识别的键集(车道键 {@link isLaneEnvKey} ∪ 店键 {@link STORE_ENV_KEYS}),写闸读的是**同一只谓词**
+ * ({@link isMigratableEnvKey}),不是第二张手抄的表 —— 迁移多认一个键而写闸没跟,或反过来,不会静默分叉
+ * (`test/migration-signpost-7.0.1.test.ts` 用真跑迁移的读数逐个保留名对拍)。
  */
 import { type ExecutionLane, type ExecutionLaneRow } from "./execution-lanes.js";
 /** 一条车道的表行。词表与表行由 `execution-lanes.ts` 的 `satisfies Record<ExecutionLane, …>` 一一对应 ——
@@ -17,3 +24,15 @@ export interface LaneEnvOwner {
 export declare const LANE_ENV_OWNER: ReadonlyMap<string, LaneEnvOwner>;
 /** 一个车道 env 名在 WorkerSpec 里的**唯一写位**(保留键的拒因指路用它)。 */
 export declare function laneEnvSeat(name: string, owner: LaneEnvOwner): string;
+/** 车道块的两个特殊键(不在车道表里,但归车道块:迁移把 `REMOTE_EXEC` 搬成 `runtime.execution.lane`、`REQUIRE_EXECUTION_LANE` 丢弃)。 */
+export declare const LANE_WORD_KEYS: readonly ["REMOTE_EXEC", "REQUIRE_EXECUTION_LANE"];
+/** 渲染器以前不渲、运维只能写在 env 逃生口里的店键(7.0.0 起归 `runtime.store`;迁移搬进 `store`)。 */
+export declare const STORE_ENV_KEYS: readonly ["DB_BACKEND", "MEMORY_ENGINE", "MEMORY_ENGINE_BACKEND"];
+/** 一个名字是不是车道块的键:车道词两键,或车道表里的任一车道 env 名。 */
+export declare function isLaneEnvKey(name: string): boolean;
+/** 一个名字是不是迁移会处理的 6.x env 键(搬进结构块 / 丢弃 / 点名它拒):车道块的键 ∪ 店键。写闸拒因带不带迁移指路只看它。 */
+export declare function isMigratableEnvKey(name: string): boolean;
+/** 迁移命令的唯一拼写(design/327 §3.4 原句):`npx` 全名形 —— 没装本包的运维粘贴即可跑;裸 bin 名 `settings-schema …` 在没装本包的机器上是 `command not found`。 */
+export declare const MIGRATE_WORKERS_COMMAND: "npx @sema-agent/settings-schema migrate-workers";
+/** 拒因里的迁移指路 —— **一句话、一个常量**:保留名闸(`env` / `secretEnv` 里的 {@link isMigratableEnvKey} 键)与删除项预处理(七个被删旧键)引用同一个。 */
+export declare const MIGRATION_SIGNPOST: string;

package/dist/execution-lane-index.js

@@ -1,7 +1,14 @@
 /**
- * 包内私有:车道表({@link EXECUTION_LANES})的两只**派生索引**,供 `types.ts`(写闸)与 `migrate-workers.ts`(一次性迁移)同读。
+ * 包内私有:车道表({@link EXECUTION_LANES})的两只**派生索引** + 「迁移能搬哪些键」的**一份**键集与指路句,
+ * 供 `types.ts`(写闸)与 `migrate-workers.ts`(一次性迁移)同读。
  * 不进主桶、不进 `package.json` 的 `exports`(与 `secret-scan.ts` 同一姿势)—— 消费方只拿表本身,索引是本包的实现细节。
  * 索引只从表派生,不另存任何词:表改了,这里跟着变。
+ *
+ * ## 迁移指路(7.0.1)
+ * 拒因要不要带迁移指路只有一条规则:**这个键「旧形 ⇒ 迁移能搬」就带,搬不了的保留名(`PORT` / `MODEL_*` …)不带**。
+ * 「迁移能搬」= 迁移自己识别的键集(车道键 {@link isLaneEnvKey} ∪ 店键 {@link STORE_ENV_KEYS}),写闸读的是**同一只谓词**
+ * ({@link isMigratableEnvKey}),不是第二张手抄的表 —— 迁移多认一个键而写闸没跟,或反过来,不会静默分叉
+ * (`test/migration-signpost-7.0.1.test.ts` 用真跑迁移的读数逐个保留名对拍)。
  */
 import { EXECUTION_LANES } from "./execution-lanes.js";
 /** 一条车道的表行。词表与表行由 `execution-lanes.ts` 的 `satisfies Record<ExecutionLane, …>` 一一对应 ——
@@ -21,3 +28,19 @@ export const LANE_ENV_OWNER = new Map(EXECUTION_LANES.flatMap((r) => {
 export function laneEnvSeat(name, owner) {
     return `runtime.execution.${owner.secret ? "secretRefs" : "coords"}.${name}`;
 }
+/** 车道块的两个特殊键(不在车道表里,但归车道块:迁移把 `REMOTE_EXEC` 搬成 `runtime.execution.lane`、`REQUIRE_EXECUTION_LANE` 丢弃)。 */
+export const LANE_WORD_KEYS = ["REMOTE_EXEC", "REQUIRE_EXECUTION_LANE"];
+/** 渲染器以前不渲、运维只能写在 env 逃生口里的店键(7.0.0 起归 `runtime.store`;迁移搬进 `store`)。 */
+export const STORE_ENV_KEYS = ["DB_BACKEND", "MEMORY_ENGINE", "MEMORY_ENGINE_BACKEND"];
+/** 一个名字是不是车道块的键:车道词两键,或车道表里的任一车道 env 名。 */
+export function isLaneEnvKey(name) {
+    return LANE_WORD_KEYS.some((k) => k === name) || LANE_ENV_OWNER.has(name);
+}
+/** 一个名字是不是迁移会处理的 6.x env 键(搬进结构块 / 丢弃 / 点名它拒):车道块的键 ∪ 店键。写闸拒因带不带迁移指路只看它。 */
+export function isMigratableEnvKey(name) {
+    return isLaneEnvKey(name) || STORE_ENV_KEYS.some((k) => k === name);
+}
+/** 迁移命令的唯一拼写(design/327 §3.4 原句):`npx` 全名形 —— 没装本包的运维粘贴即可跑;裸 bin 名 `settings-schema …` 在没装本包的机器上是 `command not found`。 */
+export const MIGRATE_WORKERS_COMMAND = "npx @sema-agent/settings-schema migrate-workers";
+/** 拒因里的迁移指路 —— **一句话、一个常量**:保留名闸(`env` / `secretEnv` 里的 {@link isMigratableEnvKey} 键)与删除项预处理(七个被删旧键)引用同一个。 */
+export const MIGRATION_SIGNPOST = `lift a stored 6.x spec once with migrateWorkersDomain(doc) (on the raw document, ahead of parseDomain) or \`${MIGRATE_WORKERS_COMMAND} <file>\``;

package/dist/hooks.d.ts

@@ -1575,26 +1575,26 @@ export declare const MessageDisplayHookInput: z.ZodObject<{
     /** Newly completed lines since the prior flush (final flush may end mid-line / be empty). */
     delta: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    index: number;
     session_id: string;
     transcript_path: string;
     cwd: string;
     hook_event_name: "MessageDisplay";
     turn_id: string;
     message_id: string;
-    index: number;
     final: boolean;
     delta: string;
     agent_type?: string | undefined;
     permission_mode?: string | undefined;
     agent_id?: string | undefined;
 }, {
+    index: number;
     session_id: string;
     transcript_path: string;
     cwd: string;
     hook_event_name: "MessageDisplay";
     turn_id: string;
     message_id: string;
-    index: number;
     final: boolean;
     delta: string;
     agent_type?: string | undefined;
@@ -3040,26 +3040,26 @@ export declare const HookInput: z.ZodDiscriminatedUnion<"hook_event_name", [z.Zo
     /** Newly completed lines since the prior flush (final flush may end mid-line / be empty). */
     delta: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    index: number;
     session_id: string;
     transcript_path: string;
     cwd: string;
     hook_event_name: "MessageDisplay";
     turn_id: string;
     message_id: string;
-    index: number;
     final: boolean;
     delta: string;
     agent_type?: string | undefined;
     permission_mode?: string | undefined;
     agent_id?: string | undefined;
 }, {
+    index: number;
     session_id: string;
     transcript_path: string;
     cwd: string;
     hook_event_name: "MessageDisplay";
     turn_id: string;
     message_id: string;
-    index: number;
     final: boolean;
     delta: string;
     agent_type?: string | undefined;

package/dist/migrate-workers.d.ts

@@ -1,7 +1,7 @@
 /**
  * workers 域的**一次性迁移**(7.0.0,M-R2 WorkerSpec 结构块)—— 持久面唯一允许的过渡,窗口关了就整文件删除
  * (连同 `types.ts` 里「删除项读到即拒」那一只预处理)。纯函数、无 I/O、不改入参;文件形的入口是
- * `settings-schema migrate-workers <file>`(`bin/settings-schema.mjs`,同一只函数)。
+ * `npx @sema-agent/settings-schema migrate-workers <file>`(`bin/settings-schema.mjs`,同一只函数;命令拼写的唯一正本 = `MIGRATE_WORKERS_COMMAND`)。
  *
  * ## 谁跑、在哪
  * 读前抬升:在 `parseDomain("workers", raw)` / `DOMAIN_SCHEMAS.workers.safeParse` **之前**对**原始 JSON** 跑 —— workers 是

package/dist/migrate-workers.js

@@ -1,7 +1,7 @@
 /**
  * workers 域的**一次性迁移**(7.0.0,M-R2 WorkerSpec 结构块)—— 持久面唯一允许的过渡,窗口关了就整文件删除
  * (连同 `types.ts` 里「删除项读到即拒」那一只预处理)。纯函数、无 I/O、不改入参;文件形的入口是
- * `settings-schema migrate-workers <file>`(`bin/settings-schema.mjs`,同一只函数)。
+ * `npx @sema-agent/settings-schema migrate-workers <file>`(`bin/settings-schema.mjs`,同一只函数;命令拼写的唯一正本 = `MIGRATE_WORKERS_COMMAND`)。
  *
  * ## 谁跑、在哪
  * 读前抬升:在 `parseDomain("workers", raw)` / `DOMAIN_SCHEMAS.workers.safeParse` **之前**对**原始 JSON** 跑 —— workers 是
@@ -32,16 +32,12 @@
  * 已迁形(没有任何旧键、该有的块都在)⇒ 原样(同一引用)返回、`changed = []`。所以再跑一次 ⇒ 零变化、`doc` 字节相等。
  */
 import { formatConfigPath, redactSecrets } from "./config-fns.js";
-import { LANE_ENV_OWNER } from "./execution-lane-index.js";
+import { LANE_ENV_OWNER, STORE_ENV_KEYS, isLaneEnvKey } from "./execution-lane-index.js";
 import { EXECUTION_LANE_WORDS, MEMORY_ENGINE_BACKENDS, STORE_BACKENDS } from "./execution-lanes.js";
 import { WorkerSpec } from "./types.js";
 function isRec(v) {
     return v !== null && typeof v === "object" && !Array.isArray(v);
 }
-/** 车道块的两个特殊键(不在车道表里,但归车道块)。 */
-const LANE_WORD_KEYS = ["REMOTE_EXEC", "REQUIRE_EXECUTION_LANE"];
-/** 渲染器以前不渲、运维只能写在 env 逃生口里的店键(7.0.0 起归 `runtime.store`)。 */
-const STORE_ENV_KEYS = ["DB_BACKEND", "MEMORY_ENGINE", "MEMORY_ENGINE_BACKEND"];
 /** 6.x 删除项:`[容器, 键]`。 */
 const SIX_X_STORE_FIELDS = [
     ["runtime", "sessionBackend"],
@@ -78,7 +74,7 @@ function migrateEntry(raw, index) {
     const refuse = (field, reason) => ({ kind: "refused", refusal: { name, index, field, reason: redactSecrets(reason), original: raw } });
     const enabled = raw.enabled !== false;
     const has = (container, key) => isRec(container) && Object.hasOwn(container, key);
-    const laneKeysOf = (rec) => isRec(rec) ? Object.keys(rec).filter((k) => LANE_WORD_KEYS.some((w) => w === k) || LANE_ENV_OWNER.has(k)) : [];
+    const laneKeysOf = (rec) => (isRec(rec) ? Object.keys(rec).filter(isLaneEnvKey) : []);
     const storeKeysOf = (rec) => (isRec(rec) ? STORE_ENV_KEYS.filter((k) => Object.hasOwn(rec, k)) : []);
     const envLaneKeys = laneKeysOf(raw.env);
     const secretLaneKeys = laneKeysOf(raw.secretEnv);