@sema-agent/settings-schema 7.0.1 → 8.1.0

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"];