@sema-agent/server 7.124.1 → 7.125.1

package/dist/trace/redact.d.ts

@@ -1,55 +1,25 @@
 /**
- * Trace thinking-block redaction (service-side). Per core [R57]: the agent's reasoning/CoT is emitted on the
- * live TaskEvent stream but DELIBERATELY kept out of the metadata Tracer because CoT may contain reasoned-about
- * secrets (and is large / ToS-sensitive for some providers). Persisting it for the trace UI is the deployment's
- * call — so when we DO persist it, redact unambiguous secret formats first. Conservative on purpose: only clear
- * key/token shapes are redacted. ⚠️ It is NOT exhaustive: unrecognised secret formats (a free-text password,
- * a JWT) pass through, and the broad `Bearer <20+ chars>` rule can over-match legitimate CoT (false positives
- * tolerated — over-redacting trace text is safe). For sensitive deployments, disable thinking capture entirely
- * via TRACE_THINKING=false. This is a seam — deployments can extend the patterns.
+ * 🔴 **剥后视图 → 原文的坐标映射**(单视律的另一半:臂在剥后视图上认凭据,产物按**原文**坐标拼)。
  *
- * 🔴 **脱敏 ≠ 出站控制**:**工具结果送模主路径**不经过本模块 —— 发往模型的请求体是工具结果**原文**
- * (模型作为执行体必须见原文;出站改写等于静默改坏用户的真实数据)。⚠️ 这句边界只管这一条路径,别读成
- * 「本模块从不出现在模型输入路径上」——本模块同时被两条**反方向**调用复用:项目记忆片段注入
- * (`src/project-memory.ts`,git log/status 与指令文件摘录先脱敏、脱敏结果才拼进注入文本)与 hook
- * asyncRewake 的唤醒文本(`src/boot/resolve-spec.ts` 的 `wake` 回调,先脱敏再经 `stream.steer` 注入模型)。
- * 这两条路径是「先脱敏、脱敏后的结果才给模型看」,与工具结果路径的方向相反,不要混淆。要让内容不出机器,
- * 核对的是**该 run 实际选中的模型路由**——默认网关(`MODEL_GATEWAY_BASEURL`)只是其中一条:还有备用网关
- * (`MODEL_GATEWAY_FALLBACK_URLS`)、`provider:"anthropic"` 的独立直连路由(缺省根
- * `https://api.anthropic.com`,除非显式配 `ANTHROPIC_BASEURL`)、以及 web-admin 可对单个目录模型下发的
- * per-model `baseUrl` 覆盖(见 `src/brain.ts` 的路由装配与 `src/web-admin-client/apply-effective.ts:416`)。
- * 靠**读侧**敏感路径门与确保**全部**生效路由都指向自己控制的基础设施,不靠本模块、也不是设一根 env 就够。
+ * 前提是 core `stripFormatCharacters` 的契约:**逐码点删除** —— 无状态、不插、不换、不改序(本仓的契约钉在全码点空间上
+ * 逐个证它,`test/trace-redact.test.ts` 的输出回原文组)。删除按**原文**的码点切分做(`u` 档正则:高代理后紧跟低代理 =
+ * 一个码点两码元,其余每个码元 —— 含孤代理 —— 各是一个码点),所以本映射也按原文的这一份切分走,逐码点拿它的码元与
+ * 剥后视图当前位置的码元比:
+ *  · 相同 ⇒ 这个码点留下了,它的每个码元记 `map[j] = i`;不同 ⇒ 它被删了,只推原文指针。
+ *  · 为什么按码点而不按码元走:astral 格式字符(U+E0001、U+E0020–U+E007F 标签字符)是代理对,按码元走会让它的半截与
+ *    emoji 代理对的半截错配。为什么按**原文**的切分而不按两边各自的切分:删除能把两枚孤代理**拼成**剥后视图里的一对
+ *    (`<孤高><ZWSP><孤低>` ⇒ 一枚 😀),按剥后视图的切分比,原文那两枚孤代理永远对不上。
+ *  · 唯一的二义:剥后视图里拼出来的那一对恰好与原文当前这一个被删的 astral 码点同码元(拼成的码点本身就是格式字符)。
+ *    BMP 码点没有这一问(下一个保留码元恒不是 BMP 格式字符的值:留下的 BMP 码点不是格式字符,代理码元也不是),所以
+ *    **只在 astral 码点码元相同时**问删除的属主一句「这一枚你删不删」—— 问的是 core 本身,本仓不多写一份格式字符谓词。
  *
- * 🔴 **射程自 7.75.1 起含「模型自由文本」全族**(B-106 / S-268):本模块此前在结果面只管诊断/披露文本,
- * 而**模型自己写的**那一份(`TaskResult.result` / `TaskResult.salvagedOutput` / 账本 `text` 行)整条逐字
- * 上 wire —— 工具结果送模路径给的是原文,模型把里面的凭据**逐字引用**进答复,那一份就绕过了本模块。
- * 现在三面与 CoT(账本 `reasoning` 行)走**同一只** `redactSecrets`、同一张替换串表:零第二只脱敏器、
- * 零 per-face 开关、零体量上限。**装载口只有一只** —— `observability/run-terminal.ts` 的
- * `redactModelText`(四座同调:结果两叶经 `redactTerminalResult`,账本两行经 `redactLedgerEventData`);
- * 它定的是**写回**判据(认出凭据形才改字节、抛则占位),不是第二张规则表。
+ * 返回 `Int32Array(normalized.length + 1)`:`map[j]` = 剥后视图第 `j` 个码元在原文里的下标,末位 `map[normalized.length]`
+ * = `text.length`。O(n) 一遍(只对 astral 码点多一次对 core 的询问);零第二只扫描器。
  *
- * 🔴 **只有一条施加路径:候选池**(S-223 v2 起;此前是「结构段 → 词法关键字段 → 池 → URL 收尾归一化」四步,
- * 每一步都把**上一步改写过的文本**喂给下一步)。四张臂表({@link STRUCTURAL_SECRET_PATTERNS} /
- * {@link KEYWORD_SECRET_PATTERNS} / {@link SHAPE_SECRET_PATTERNS} / {@link FRAGMENT_SECRET_PATTERNS})
- * 加三条体扫描器全是 {@link armPool} 的成员:全臂看**同一份未改写文本**收候选跨度 → 不动点 → 并集律解重叠
- * → **一次**替换,**臂序对输出无语义**(次序只定 `order` = 同起点同长时的稳定裁决)。
- * 左边界律因此有**三种**边界:非词内字符 ∨ 转义分隔单元尾 ∨ **一枚已收候选跨度的尾**(= 凭据尾)。
+ * 失配 = 剥后视图里有码元在原文剩余部分里配不上(原文先走完)⇒ 归一化不再是「只删码点」,core 改了契约 ⇒ **抛**。
+ * 不回退到剥后产物、不吞:装着的 core 上运行期不可达,换 core 时契约钉先红。
  */
-/** 本模块替换 token 的**闭形**正则源(`«redacted»` / `«redacted:aws-key»` / `«redacted:gh-token:partial»` …):
- *  URL-userinfo 臂用它把「用户名位上已经是本模块 token」整个当一个用户名单元吃掉。模块加载时对
- *  {@link REDACTION_TOKENS} 逐个校验闭形(表加了新 token 形而这里没跟 ⇒ 加载即抛,fail-closed)。 */
-import { stripFormatCharacters } from "@sema-agent/core";
-/**
- * `redactSecrets` 的**归一化前置**(S-103 ①):把全部 `\p{Cf}`(零宽空格 / 词连接符 / BOM / 软连字符 / ZWJ / ZWNJ …)
- * 剥掉。实现单一属主是 core 的 `stripFormatCharacters`(`@sema-agent/core`,7.3.1 起导出,正是为「先扫描后渲染」这一序
- * 开的口),本模块只**转出**它,不抄第二份 —— 两份实现漂了就等于两个「什么是格式字符」的定义。
- *
- * 🔴 **需要判断「这次脱敏到底有没有认出凭据形」的调用方,比较基准是它、不是原文**:
- * `redactSecrets(x) !== x` 在本版里对**任何**含 Cf 的文本都为真(输出是剥后文本),拿它当谓词会把一条带 emoji ZWJ
- * 的普通 `git commit` 判成「含凭据形」;正确的谓词是 `redactSecrets(x) !== normalizeForRedaction(x)`。
- * 现役消费方:`src/tool-approval.ts` 的 `durableRuleMaterial`(规则车道素材闸)与语料的 FP=0 格。
- */
-export declare const normalizeForRedaction: typeof stripFormatCharacters;
+export declare function mapNormalizedToOriginal(text: string, normalized: string): Int32Array;
 export declare const REDACTION_TOKEN_RE_SRC: string;
 export declare function armPoolBudgetForTest(): {
     spanCount: number;
@@ -60,6 +30,7 @@ export declare function armPoolBudgetForTest(): {
     boundaryArmCount: number;
     forensicLevels: number;
     ssh2ScanBytes: number;
+    mappedUnits: number;
 };
 export declare function resetArmPoolBudgetForTest(): void;
 /** 本模块会写进文本的全部替换 token(`«…»` 字面),从三张表现算 —— 表改这里自动跟,不另抄一份。
@@ -124,8 +95,9 @@ export declare function redactSecrets(text: string, opts?: {
  * 出口开在脱敏器**自己**身上是硬约束:全仓只该有一个「什么算凭据」的属主,消费方**不许**按 token 字面
  * (`includes(":partial»")`)或另跑一遍正则去反推 —— 那就是第二只脱敏器。
  *
- * `arms` 是**这一遍真命中的档位集合**:空集 = 一条臂都没命中(文本可能仍被归一化剥了 `\p{Cf}`,
- * 所以「`text !== 入参`」与「`arms` 非空」不是一回事,后者才是凭据形的证据)。
+ * `arms` 是**这一遍真命中的档位集合**。「`text !== 入参`」与「`arms` 非空」仍不是一回事(S-1435 起理由换了):
+ * 前者 ⇔ 至少一条跨度改写了字节(强弱两档都算 —— 格式字符不再改字节);后者 = 至少一条臂命中,**含**字节没变的那种
+ * (重扫已脱敏文本时,臂命中自己产出的记号、换回同一枚记号)。凭据形的证据是档位:规则素材闸问的是 `arms.has("full")`。
  */
 export declare function redactSecretsWithArms(text: string, opts?: {
     observe?: boolean;
@@ -138,7 +110,8 @@ export declare function redactSecretsWithArms(text: string, opts?: {
  * 🧪 **跨度出口 —— 只给测试**(车 UH 脱敏基线门 `test/redaction-baseline-gate.test.ts`:判「必隐字节**每一个**都被盖住」,
  * 而不是「必隐串整串不在」—— 后者对截断式脱敏(值的前缀被洗、尾段留着)恒判已藏,gpt-6 腿 r1-F1 [high])。
  *
- * 同一只 {@link runRedaction}、同一遍扫描,原样交出池已经算好的 `kept` 跨度(S-497 那一份;坐标在**归一化视图**上),
+ * 同一只 {@link runRedaction}、同一遍扫描,交出池算好的 `kept` 跨度映回**原文**之后的那一份(S-497 那一份;坐标在原文上,
+ * 与产物同一套 —— S-1435 起;此前在剥后视图上),
  * 不是第二只脱敏器、不改任何判据、不喂观察者(`observe:false`,与影子重扫同口);`opts.json` 与 {@link redactSecrets} 的同名选项
  * 逐字同义(JSON 模式,`redactedPreview` 走的那一条)。生产代码不调用它:
  * 问「有没有凭据形」的消费方走 {@link redactSecretsWithArms}。

package/dist/trace/redact.js

@@ -1,7 +1,33 @@
 import { displayUrlOf, stripFormatCharacters } from "@sema-agent/core";
 import { isHierarchicalUrl } from "@sema-agent/settings-schema";
 import { recordFailOpen } from "../observability/fail-open.js";
-export const normalizeForRedaction = stripFormatCharacters;
+const normalizeForRedaction = stripFormatCharacters;
+export function mapNormalizedToOriginal(text, normalized) {
+    mappedUnits += normalized.length;
+    const map = new Int32Array(normalized.length + 1);
+    let i = 0;
+    for (let j = 0; j < normalized.length;) {
+        if (i >= text.length) {
+            throw new Error(`redact: the normalized view is not a code-point subsequence of the original (at normalized index ${j} of ${normalized.length}) — format-character stripping must only delete code points; refusing to map redaction spans back`);
+        }
+        const unit = text.charCodeAt(i);
+        if (unit >= 0xd800 && unit <= 0xdbff && (text.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
+            if (unit === normalized.charCodeAt(j) && text.charCodeAt(i + 1) === normalized.charCodeAt(j + 1) && normalizeForRedaction(text.slice(i, i + 2)) !== "") {
+                map[j] = i;
+                map[j + 1] = i + 1;
+                j += 2;
+            }
+            i += 2;
+        }
+        else {
+            if (unit === normalized.charCodeAt(j))
+                map[j++] = i;
+            i += 1;
+        }
+    }
+    map[normalized.length] = text.length;
+    return map;
+}
 export const REDACTION_TOKEN_RE_SRC = String.raw `«redacted(?::[a-z-]{1,16}){0,2}»`;
 const ARM_VALUE_CLASSES = [];
 const atLeast = (cls, min) => {
@@ -251,8 +277,9 @@ let headScreenHits = 0;
 let fullYCalls = 0;
 let forensicLevels = 0;
 let ssh2ScanBytes = 0;
+let mappedUnits = 0;
 export function armPoolBudgetForTest() {
-    return { spanCount: poolSpanCount, coveredPositions, headScreenHits, fullYCalls, armCount: poolArmCount, boundaryArmCount: poolBoundaryArmCount, forensicLevels, ssh2ScanBytes };
+    return { spanCount: poolSpanCount, coveredPositions, headScreenHits, fullYCalls, armCount: poolArmCount, boundaryArmCount: poolBoundaryArmCount, forensicLevels, ssh2ScanBytes, mappedUnits };
 }
 export function resetArmPoolBudgetForTest() {
     poolSpanCount = 0;
@@ -261,6 +288,7 @@ export function resetArmPoolBudgetForTest() {
     fullYCalls = 0;
     forensicLevels = 0;
     ssh2ScanBytes = 0;
+    mappedUnits = 0;
 }
 const unitBit = (t, c) => (t[c >>> 5] >>> (c & 31)) & 1;
 let codeUnitDomain;
@@ -1740,9 +1768,8 @@ const armPool = (() => {
         }
         poolSpanCount += spans.length;
         const kept = resolveSpanOverlaps(spans);
-        const out = applySpans(text, kept).out;
         if (!wantCount || kept.length === 0)
-            return { out, hits: NO_HITS, kept };
+            return { hits: NO_HITS, kept };
         const tokenOf = (sp) => members[sp.order].token;
         const strong = spans.filter((sp) => armOfToken(tokenOf(sp)) === "full").sort((a, b) => a.start - b.start);
         const byArmedToken = new Map();
@@ -1762,7 +1789,7 @@ const armPool = (() => {
             else
                 cur.count += 1;
         }
-        return { out, hits: [...byArmedToken.values()].map(({ token, arm, count }) => ({ label: labelOfToken(token), count, arm })), kept };
+        return { hits: [...byArmedToken.values()].map(({ token, arm, count }) => ({ label: labelOfToken(token), count, arm })), kept };
     };
 })();
 let onRedaction;
@@ -1790,7 +1817,14 @@ function runRedaction(text, observe, json, wantHits, scope) {
     forgetEscapedSeparatorTails();
     if (observe)
         reportHits(r.hits);
-    return { text: r.out, hits: r.hits, spans: r.kept };
+    const spans = spansInOriginal(text, normalized, r.kept);
+    return { text: applySpans(text, spans).out, hits: r.hits, spans };
+}
+function spansInOriginal(text, normalized, kept) {
+    if (kept.length === 0 || normalized === text)
+        return kept;
+    const map = mapNormalizedToOriginal(text, normalized);
+    return kept.map((s) => ({ ...s, start: map[s.start], end: map[s.end - 1] + 1 }));
 }
 export function redactSecrets(text, opts) {
     return runRedaction(text, opts?.observe ?? true, opts?.json === true, false, "free-text").text;
@@ -1930,13 +1964,12 @@ if (!REDACTION_TOKENS.has(WITHHELD_PATH_SEGMENT_TOKEN)) {
     throw new Error(`redact: ${WITHHELD_PATH_SEGMENT_TOKEN} is no longer produced by the arm tables — the path-segment filler must stay a closed-set member`);
 }
 function shapeLawCredentialInQueryOrFragment(canonical) {
-    const normalized = normalizeForRedaction(canonical);
-    const boundary = normalized.indexOf("?");
+    const boundary = canonical.indexOf("?");
     if (boundary < 0)
         return false;
     if (runRedaction(canonical, false, false, false, "free-text").spans.some((sp) => sp.end > boundary))
         return true;
-    for (const unit of normalized.slice(boundary + 1).split("&").flatMap((sg) => {
+    for (const unit of canonical.slice(boundary + 1).split("&").flatMap((sg) => {
         const eq = sg.indexOf("=");
         return eq === -1 ? [sg] : [sg.slice(0, eq), sg.slice(eq + 1)];
     })) {

package/dist/trace/self-minted-wire.d.ts

@@ -364,6 +364,31 @@ export declare const SELF_MINTED_WIRE: {
             };
         };
     };
+    /**
+     * 提交幂等(契约 §0.7:幂等 = 资源行上的唯一键)本版新上 wire 的面:同步腿读行重放体的 `replay` 键、两只按键读的读口、
+     * `Idempotency-Key` 命中一条读不到 / 不是这次 taskId 所指的行时的 409。行为由 `test/submit-idempotency-one-ledger.test.ts` 钉。
+     */
+    readonly submitIdempotency: {
+        readonly at: "提交幂等(<端点>#<面> → 应答状态)";
+        readonly members: {
+            readonly "POST /v1/tasks#replay": {
+                readonly attr: 200;
+                readonly since: "7.125.0";
+            };
+            readonly "GET /v1/runs?idempotencyKey": {
+                readonly attr: 200;
+                readonly since: "7.125.0";
+            };
+            readonly "GET /v1/leader?idempotencyKey": {
+                readonly attr: 200;
+                readonly since: "7.125.0";
+            };
+            readonly "POST /v1/runs|/v1/tasks Idempotency-Key#conflict.run_exists": {
+                readonly attr: 409;
+                readonly since: "7.125.0";
+            };
+        };
+    };
     /** 本仓在出口对 core 值做的变换(值变、键不变)。 */
     readonly wireValueRule: {
         readonly at: "出口值变换(<端点>#<键> → 变换)";

package/dist/trace/self-minted-wire.js

@@ -127,6 +127,15 @@ export const SELF_MINTED_WIRE = {
             unknown: { attr: "-", since: "7.121.0" },
         },
     },
+    submitIdempotency: {
+        at: "提交幂等(<端点>#<面> → 应答状态)",
+        members: {
+            "POST /v1/tasks#replay": { attr: 200, since: "7.125.0" },
+            "GET /v1/runs?idempotencyKey": { attr: 200, since: "7.125.0" },
+            "GET /v1/leader?idempotencyKey": { attr: 200, since: "7.125.0" },
+            "POST /v1/runs|/v1/tasks Idempotency-Key#conflict.run_exists": { attr: 409, since: "7.125.0" },
+        },
+    },
     wireValueRule: {
         at: "出口值变换(<端点>#<键> → 变换)",
         members: {

package/dist/web-admin-client/apply-effective.d.ts

@@ -12,6 +12,7 @@ import type { Logger } from "../observability/logger.js";
 import type { EffectiveConfig } from "./types.js";
 import { type ModelRefusalVerdict } from "../model-entry-refusal.js";
 import { type ConfigApplyReport } from "./apply-ledger.js";
+import { type ConfigCandidateRead } from "./candidate-gate.js";
 /** Apply center config OVER the env-derived config (mutates `config`). Empty domains keep env defaults. */
 /** Replace a record's contents IN PLACE (clear keys, copy source) so holders of the SAME reference see the
  *  change. This is what makes models/roles/pricing HOT-apply: core's Runner reads
@@ -82,19 +83,16 @@ export type ModelPlaneOf = Pick<EffectiveConfig, ModelPlaneDomain>;
  */
 export declare function withModelPlaneOf<E extends EffectiveConfig>(target: E, source: ModelPlaneOf): E;
 /**
- * E-1(7.103.1 修复轮,opus 腿):boot 读到的这一代**整套落地**了吗 —— 只有整套落地的那一代才可以成为 LKG(`latestEffective` /
- * 盘上 LKG 候选)、才让它的 ETag 做条件请求(§9.5-2 + codex R2-F1)。三件同判,缺一不算:读腿没报坏域(`domainErrors`)、
- * prompts 面过候选门同一只判形、apply 报告没有被整拒的组(`fullyApplied`;报告缺席 = 没 apply,dry-run 只判前两件)。
- * boot 的两条落地路径(候选拉取、整份 LKG 读回)与 refresh / 迟到 boot 两腿的 apply 之后都调这一只,禁在调用点各写一份(此前候选路径三件、LKG 路径只抄了一件,
- * refresh / 迟到 boot 两腿各内联了第三件)。
- * LKG 读回路径上前两件在上游已有门(`loadLkg` 的载荷复判拒坏 prompts;读回不产 `domainErrors`),这里同判是同一条规则的同一只谓词,
- * 不是第二道门。refresh / 迟到 boot 两腿的候选门在 apply **之前**整拒坏域与坏 prompts(拒的是整份候选,不只是 LKG 推进),所以到 apply 之后那两腿调本谓词时
- * 前两件恒真、实判的是 `fullyApplied` 一件 —— 调它是为了「干净落地」只有这一个读法,不是再加一道门。
+ * E-1(7.103.1 修复轮,opus 腿):读到的这一代**整套落地**了吗 —— 只有整套落地的那一代才可以成为 LKG(`latestEffective` /
+ * 盘上 LKG 候选)、才让它的 ETag 做条件请求(§9.5-2 + codex R2-F1)。两件同判,缺一不算:候选判官判它 `clean`(形:读腿没报坏域、
+ * prompts 面判形过 —— 判据只在 `judgeConfigCandidate` 一处)、apply 报告没有被整拒的组(落地:`fullyApplied`;报告缺席 = 没 apply)。
+ * 分工:判官判**形**,本谓词判**落地**;形那一半读判官,不另写一份。起服的两条落地路径(候选拉取、整份 LKG 读回)与刷新 / 迟到起服两腿的
+ * apply 之后都调这一只,禁在调用点各写一份。
+ * 起服 / 刷新 / 迟到起服三条候选腿都在 apply **之前**经判官整拒坏形的候选(一个域都不应用),LKG 读回路径上形那一半在上游已有门(`loadLkg` 的载荷复判
+ * 拒坏 prompts;读回不产 `domainErrors`)—— 所以到 apply 之后调本谓词时形那一半恒真、实判的是 `fullyApplied` 一件;调它是为了「干净落地」只有这一个读法,
+ * 不是再加一道门。
  */
-export declare function fullyLandedForLkg(read: {
-    readonly effective: EffectiveConfig;
-    readonly domainErrors?: readonly unknown[];
-}, report: ApplyReport | undefined): boolean;
+export declare function fullyLandedForLkg(read: ConfigCandidateRead, report: ApplyReport | undefined): boolean;
 /**
  * S-768:组拒码 → 铸它的那条模型面不变量 —— **以码为键**(组拒码闭集的属主是 settings-schema `MODEL_PLANE_REFUSAL_CODES`;那边加一个码
  * ⇒ 本表缺键 ⇒ 本仓 tsc 红)。模型面 stage 的组拒按**码**铸(码是判决那刻的数据),不变量 id 由本表派生 —— 一个 id 两个码

package/dist/web-admin-client/apply-effective.js

@@ -15,7 +15,7 @@ import { DEFAULT_MODEL_MISSING_CODE, REFUSED_NAME_MINTED_CODE, judgeCatalogEntri
 import { judgeModelRouteEndpoint } from "../model-route-endpoint.js";
 import { gateIntentUnserviceableReason } from "../approval.js";
 import { refusedGroups } from "./apply-ledger.js";
-import { validatePromptsDomain } from "../prompts-domain-validate.js";
+import { judgeConfigCandidate } from "./candidate-gate.js";
 const charsPerTokenOf = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined);
 function envDerivedModel(config) {
     const m = config.envModel;
@@ -197,8 +197,7 @@ function takeModelPlaneDomain(out, source, d) {
         out[d] = v;
 }
 export function fullyLandedForLkg(read, report) {
-    const prompts = read.effective.prompts;
-    return (read.domainErrors ?? []).length === 0 && (prompts === undefined || validatePromptsDomain(prompts).ok) && report?.fullyApplied !== false;
+    return judgeConfigCandidate(read).verdict === "clean" && report?.fullyApplied !== false;
 }
 function modelRefusalVerdictOf(group) {
     const entries = group.refused ?? {};

package/dist/web-admin-client/candidate-gate.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 配置候选的**唯一判官**:一份候选(中心有效视图,或本地 `config.d` 读出的那份)能不能收 —— 只有这一种判法。
+ *
+ * 判据(两件,缺一即拒):读腿交出的 `domainErrors`(某个域读不懂 / 拼错键 / 坏文件:那个域已落 schema 缺省)与 prompts 面的判形
+ * (`validatePromptsDomain`;坏形的 pack 会让 core 在每个任务的装配期抛)。任一不过 ⇒ `rejected`:**整份候选不收**,一个域都不应用。
+ * 读腿的逐条丢弃(`droppedEntries`)不在这里 —— 颗粒是条目的失效留在条目上,候选照收(调用方响亮点名)。
+ *
+ * 调用面(全部只调这一只,不内联第二份):
+ *  · 起服(候选拉到之后、应用之前)—— `rejected` ⇒ 与「候选拉取失败」同一条回落链(候选 → 盘上 LKG → env);
+ *  · dry-run 起服 —— `clean` 才推进校验子;
+ *  · 刷新拍 —— `rejected` ⇒ 活配置不动、校验子不进、持续可见到修复;
+ *  · 迟到起服(超窗的那一拉到货)—— 同刷新;
+ *  · `run-local` 一次性入口 —— `rejected` ⇒ env(没有 LKG、没有刷新环);
+ *  · `fullyLandedForLkg`(E-1)的形那一半 —— E-1 判的是「整套落地」= 形(本判官)∧ 应用报告里没有被整拒的组。
+ * 拒判的运维行 `config_candidate_rejected` 的体只在 {@link buildCandidateRejectedFields} 一处铸(各入口同一体,`leg` 说是哪一拉)。
+ * 分工:**判官判形**(候选本身能不能收);**E-1 判落地**(收下之后,装配期按组被拒的那一组 —— 例:模型面组拒(凭证 / 网关事实)
+ * 是另一个问题,不是第二个判官)。
+ *
+ * `domains` 排序去重:收集器的顺序没有承诺,它是拒行去重键的一部分(同一份候选、同一组坏域只响一次)。`errors` 原样逐条
+ * (读腿的诊断在前、prompts 在后)—— 那是可操作的诊断,不是键。纯函数:不改入参,不读环境。
+ *
+ * **判官交值**:`clean` 判决带着 prompts 面的已判形值(`prompts`;候选不带 prompts 键 ⇒ `undefined`)。采纳 prompts 的各处(起服 / 刷新 /
+ * 迟到起服 / LKG 起服 / `run-local`)直接用这一份值,不再自己判第二遍 —— `validatePromptsDomain` 在 src 里只有本判官一个调用点
+ * (盘上 LKG 的读回复判也经本判官,`config-lkg.ts`)。
+ */
+import { type PromptsDomainFaces } from "../prompts-domain-validate.js";
+import type { EffectiveConfig } from "./types.js";
+/** 读腿交出的一条域级诊断(与 `FetchEffectiveResult.domainErrors` 同形;error 文案已在产出边界脱敏)。 */
+export interface CandidateDomainError {
+    readonly domain: string;
+    readonly error: string;
+}
+/** 判官的输入:一份读出来的候选。 */
+export interface ConfigCandidateRead {
+    readonly effective: EffectiveConfig;
+    readonly domainErrors?: readonly CandidateDomainError[];
+}
+export type ConfigCandidateVerdict = 
+/** `prompts` = 候选 prompts 面的已判形值(候选不带 prompts 键 ⇒ `undefined` = 撤回中心包、内置提示词服务)。 */
+{
+    readonly verdict: "clean";
+    readonly prompts: PromptsDomainFaces | undefined;
+} | {
+    readonly verdict: "rejected";
+    readonly domains: readonly string[];
+    readonly errors: readonly CandidateDomainError[];
+};
+export declare function judgeConfigCandidate(r: ConfigCandidateRead): ConfigCandidateVerdict;
+/** `config_candidate_rejected` 的 `leg`(闭集):被判官整拒的候选是**哪一拉**的 —— 起服那一拉 / 起服超窗、到货才判的那一拉 / 刷新拍的一拉 /
+ *  `run-local` 一次性入口读的那一份。 */
+export type CandidateLeg = "boot" | "late-boot" | "refresh" | "run-local";
+/**
+ * `config_candidate_rejected` 一行的体(纯数据,各入口同一体):`domains` 是排序去重的域集逗号串(也是去重键的一半),`errors` 原样,
+ * 读腿逐条丢弃的条目与读腿不读的文件随行(被整拒的拍不再逐条单发),`lkgVersion` = 此刻在服务的最后一份整套落地的候选(没有 ⇒ `"(env)"`),
+ * `dir` = 本地读腿的配置根(远程读腿缺席;读腿的域诊断只带配置坐标,拒行据 dir + 域点得出文件)。
+ */
+export declare function buildCandidateRejectedFields(r: {
+    readonly effective: EffectiveConfig;
+    readonly droppedEntries?: readonly unknown[];
+    readonly unreadFiles?: readonly unknown[];
+}, verdict: Extract<ConfigCandidateVerdict, {
+    verdict: "rejected";
+}>, leg: CandidateLeg, ctx: {
+    readonly lkgVersion: number | "(env)";
+    readonly dir?: string;
+}): Record<string, unknown>;
+/** `config_domain_invalid` 逐域坐标行的 note(各入口同一句):这一行说「哪一域、为什么坏」,判决只有 `config_candidate_rejected` 一行。 */
+export declare const CONFIG_DOMAIN_INVALID_NOTE = "this domain failed its schema \u2014 the candidate judge rejects the whole candidate (see config_candidate_rejected); fix the named file / center data";
+//# sourceMappingURL=candidate-gate.d.ts.map

package/dist/web-admin-client/candidate-gate.js

@@ -0,0 +1,27 @@
+import { validatePromptsDomain } from "../prompts-domain-validate.js";
+export function judgeConfigCandidate(r) {
+    const prompts = r.effective.prompts;
+    const promptsGate = prompts === undefined ? undefined : validatePromptsDomain(prompts);
+    const errors = [
+        ...(r.domainErrors ?? []).map((de) => ({ domain: de.domain, error: de.error })),
+        ...(promptsGate !== undefined && !promptsGate.ok ? [{ domain: "prompts", error: promptsGate.error }] : []),
+    ];
+    if (errors.length === 0)
+        return { verdict: "clean", prompts: promptsGate?.ok ? promptsGate.value : undefined };
+    return { verdict: "rejected", domains: [...new Set(errors.map((e) => e.domain))].sort(), errors };
+}
+export function buildCandidateRejectedFields(r, verdict, leg, ctx) {
+    return {
+        version: r.effective.version,
+        domains: verdict.domains.join(","),
+        leg,
+        ...(ctx.dir !== undefined ? { dir: ctx.dir } : {}),
+        errors: verdict.errors,
+        ...(r.droppedEntries !== undefined ? { droppedEntries: r.droppedEntries } : {}),
+        ...(r.unreadFiles !== undefined ? { unreadFiles: r.unreadFiles } : {}),
+        lkgVersion: ctx.lkgVersion,
+        note: "candidate rejected whole (§9.5-5) — live config keeps the last-known-good; fix the named files to unblock",
+    };
+}
+export const CONFIG_DOMAIN_INVALID_NOTE = "this domain failed its schema — the candidate judge rejects the whole candidate (see config_candidate_rejected); fix the named file / center data";
+//# sourceMappingURL=candidate-gate.js.map

package/dist/web-admin-client/http-client.d.ts

@@ -1,7 +1,7 @@
 import { type EffectiveReadWarning, type EntitlementRuntimeCaps } from "@sema-agent/settings-schema";
 import type { ScenarioRuling } from "../capabilities/scenarios.js";
 import type { EffectiveConfig, ExecutionRuling } from "./types.js";
-import { type DroppedConfigEntry } from "./read-warnings.js";
+import { type DroppedConfigEntry, type UnreadConfigFile } from "./read-warnings.js";
 import { type CenterEndpoint } from "./center-request.js";
 /** GET the effective config (Bearer + ETag). null = 304 (unchanged). Throws on transport/HTTP error, and on a
  *  payload that is not an effective config at all(非对象 / version 非有限数 / gate 域坏形——[ref] 裁B)。
@@ -23,6 +23,7 @@ export declare function fetchEffective(center: CenterEndpoint, etag: string | un
         error: string;
     }>;
     droppedEntries?: DroppedConfigEntry[];
+    unreadFiles?: UnreadConfigFile[];
     readWarnings: readonly EffectiveReadWarning[];
     credentialIdentity: string;
 } | null>;

package/dist/web-admin-client/http-client.js

@@ -18,7 +18,7 @@ export async function fetchEffective(center, etag, fetchImpl = fetch, worker) {
         delete wire.prompts;
     else
         wire.prompts = centerPrompts;
-    const { domainErrors, droppedEntries, droppedCatalogEntries } = splitFoldedReadWarnings(warnings);
+    const { domainErrors, droppedEntries, droppedCatalogEntries, unreadFiles } = splitFoldedReadWarnings(warnings);
     const effective = withDroppedCatalogEntries(wire, droppedCatalogEntries);
     return {
         effective,
@@ -27,6 +27,7 @@ export async function fetchEffective(center, etag, fetchImpl = fetch, worker) {
         credentialIdentity: identity,
         ...(domainErrors.length > 0 ? { domainErrors } : {}),
         ...(droppedEntries.length > 0 ? { droppedEntries } : {}),
+        ...(unreadFiles.length > 0 ? { unreadFiles } : {}),
     };
 }
 export async function fetchPrincipalCaps(center, principal, etag, fetchImpl = fetch, worker) {

package/dist/web-admin-client/pull-state.d.ts

@@ -6,8 +6,9 @@
  */
 /**
  * 最近一次**实拉**的结局 —— 新状态,运行时只此一枚。闭集:
- *  · `none` —— 本进程还没有一次中心实拉落地(LKG 起服 / env 兜底起服 / 拉取还在飞 / 配置源是本地目录 `CONFIG_PROVIDER=local`);
- *  · `ok` —— 最近一拍拉取 + 处理完成(boot 实拉、迟到 boot 到货、refresh 拍任一;304 与被候选门整拒的拍也算:中心答了);
+ *  · `none` —— 本进程还没有一次中心实拉落地(拉取失败 / 超窗后的 LKG 起服或 env 兜底起服 / 拉取还在飞 / 配置源是本地目录 `CONFIG_PROVIDER=local`);
+ *  · `ok` —— 最近一拍拉取 + 处理完成(boot 实拉、迟到 boot 到货、refresh 拍任一;304 与被候选判官整拒的拍也算:中心答了 ——
+ *    起服遇拒而读回 LKG 起服也是 `ok`,区别于拉取失败后的 LKG 起服);
  *  · `failed` —— 最近一个 refresh 拍抛了(中心超时 / 不可达 / 读不了 / 应用抛错 —— 与 `POST /v1/admin/config/refresh` 的 `"failed"` 同一判)。
  */
 export declare const CENTER_PULL_STATES: readonly ["none", "ok", "failed"];
@@ -18,8 +19,9 @@ export interface CenterPullView {
     /**
      * 生效修订号 —— 与 `/health.configAppliedVersion` **同一只** ledger 视图取值(同一事实的第三个面:`/health` 与
      * `GET /v1/diagnostics/wiring` 是运维面,caps 是调用方面);`updatedAt` 取最近一份整套落地的候选(`latestEffective`)的
-     * `updatedAt`。`null` = 还没有一代真落地,或 ledger 的已应用代与整套落地的那一代对不上(部分应用窗 / boot 带域错的候选)——
-     * 给不出一对同代的 `{version, updatedAt}` 就不拼一对(拼出来的是两代各取一半)。
+     * `updatedAt`。`null` = 还没有一代真落地,或 ledger 的已应用代与整套落地的那一代对不上(某组被拒的部分应用 —— 那一代不算已应用、
+     * 也不进整套落地)—— 给不出一对同代的 `{version, updatedAt}` 就不拼一对(拼出来的是两代各取一半)。被候选判官整拒的候选不进这两侧
+     * 任何一侧(只推进 target):起服遇拒读回 LKG ⇒ 两侧都是 LKG 那一代,配得上一对。
      */
     readonly effectiveRevision: {
         readonly version: number;

package/dist/web-admin-client/read-warnings.d.ts

@@ -12,7 +12,9 @@
  *
  * **归族判据**(下游两个消费者:候选门 = 非空 ⇒ 这棵树整拒、保 LKG;逐条丢弃面 = 响亮点名、其余照用):每一种告警都是
  * 「写了没生效」,按**失效的颗粒**分:丢的是**一条条目**(`entry-dropped`)⇒ `scope:"entry"` —— 这条条目单独不在,同域其余条目照用,
- * 候选**不**因它整拒;丢的是一个域 / 一组键 / 一个文件 ⇒ `scope:"domain"` —— 候选门错误。(settings-schema 11 起读路径上零抬升臂:
+ * 候选**不**因它整拒;丢的是一个域 / 一组键 / 一份**读的**域文件 ⇒ `scope:"domain"` —— 候选门错误。`config.d` 里**读腿根本不读**的文件
+ * (`unread-config-file`:名字不是域,或是域但不便携 —— `workers.json` / `hosts.json` / 任意非域 `*.json`)⇒ `scope:"unread"` —— 不是
+ * 「读的域判形失败」,候选判官只收读腿读的域;它与逐条丢弃同一「点名不判拒」律(调用方一份文件一行 `config_unread_file`,其余照用)。(settings-schema 11 起读路径上零抬升臂:
  * 此前「值已被收编接受」的两种告警 `hosts-grandfathered` / `legacy-governance-lifted` 随抬升臂一起退役,旧形由一次性迁移改写,
  * 读侧遇旧形一律拒 —— 没有「不入诊断面」的那一族了。)
  *
@@ -24,7 +26,8 @@
  */
 import { z } from "zod";
 import { type DroppedEntryIdentity, type DroppedEntryReasonCode, type EffectiveReadWarning } from "@sema-agent/settings-schema";
-/** 折叠产物:`scope` 决定消费方做什么 —— `"domain"` 进候选门(`domainErrors`),`"entry"` 进逐条丢弃面(`droppedEntries`)。 */
+/** 折叠产物:`scope` 决定消费方做什么 —— `"domain"` 进候选门(`domainErrors`),`"entry"` 进逐条丢弃面(`droppedEntries`),
+ *  `"unread"` 进读腿不读的文件面(`unreadFiles`;点名不判拒)。 */
 export type FoldedReadWarning = {
     readonly scope: "domain";
     readonly domain: string;
@@ -35,7 +38,17 @@ export type FoldedReadWarning = {
     readonly entry: string;
     readonly error: string;
     readonly reasonCode: DroppedEntryReasonCode;
+} | ({
+    readonly scope: "unread";
+} & UnreadConfigFile);
+/** `config.d` 里读腿不读的一份文件(本地读腿才有;`why` / `domain` 是契约告警的原值)。 */
+export type UnreadConfigFile = {
+    readonly file: string;
+    readonly why: "not-a-domain" | "non-portable-domain";
+    readonly domain?: string;
 };
+/** `config_unread_file` 一行的体(纯数据;起服 / 刷新 / 迟到起服与 `run-local` 同一体):`dir` = 本地读腿的配置根。 */
+export declare function buildUnreadConfigFileFields(f: UnreadConfigFile, dir: string | undefined): Record<string, unknown>;
 /** 逐条丢弃面的一行(两条读腿的 `droppedEntries` 同形,`config_entry_dropped` 日志行读它):`entry` = 被丢那条的出门形坐标(`models.1`),
  *  `error` = 哪些字段、为什么(人读),`reasonCode` = 为什么丢的**闭集词**(S-1295:settings-schema 铸、原样过境 —— 目录行的
  *  `GET /v1/models.droppedEntries[].reasonCode` 就是这同一个词,取自同一次折叠的同一行)。 */
@@ -60,13 +73,23 @@ export declare function describeSchemaIssueFields(error: unknown): string[];
 /** 契约句子里**值**的位置在本仓诊断面上的写法(一个洞,不回显值;句子的固定词 —— 迁移指路、词表出路、字段名 —— 原样)。 */
 export declare const SCHEMA_OPERAND_HOLE = "\u00ABvalue\u00BB";
 /**
- * 整域失效(`domain-defaulted`)的诊断文案:逐条 issue `坐标: 句子`,句子读 {@link issueSentenceOf}(与逐条丢弃面同一只):带结构化操作数的契约句重铸、
- * 操作数换成 {@link SCHEMA_OPERAND_HOLE};不带的(zod 内建句、退役键墓碑句、迁移指路)原样。读不出 issues 形 ⇒ 退回 {@link errorText}。
+ * 整域失效(`domain-defaulted`)的诊断文案:逐条 issue `坐标: 句子`,句子读 {@link issueSentenceOf}(与逐条丢弃面同一只):custom issue 的结构化句子重铸、
+ * 操作数换成 {@link SCHEMA_OPERAND_HOLE};zod 内建码(含墓碑字段的 `invalid_type`)读 message 原样。读不出 issues 形 ⇒ 退回 {@link errorText}。
  * 为什么不直接用 `error.message`:zod 4 的 message 是整份 issues 的 JSON —— 本地腿出口的引号段指纹(`redactConfigError`)会把它从第一个
  * 引号到最后一个引号整段吞掉,契约拒句里点名的迁移 id(「旧形读写两面响亮拒、拒句点名迁移 id」)就到不了运维眼前。
  */
 export declare function describeDomainIssues(error: unknown): string;
-/** 一条读告警 → 它的诊断面(每一种都进:见文件头「归族判据」)。 */
+/** 一条读告警 → 它的诊断面(每一种都进:见文件头「归族判据」)。按 kind 的重载只是让调用方拿到窄型(`unread` 一面没有 `error` 句)。 */
+export declare function foldEffectiveReadWarning(w: Extract<EffectiveReadWarning, {
+    kind: "unread-config-file";
+}>): Extract<FoldedReadWarning, {
+    scope: "unread";
+}>;
+export declare function foldEffectiveReadWarning(w: Exclude<EffectiveReadWarning, {
+    kind: "unread-config-file";
+}>): Exclude<FoldedReadWarning, {
+    scope: "unread";
+}>;
 export declare function foldEffectiveReadWarning(w: EffectiveReadWarning): FoldedReadWarning;
 /**
  * 🔴 S-712 / S-1295 —— **被丢目录条目的载体行**(载体 = `EffectiveConfig.models.droppedCatalogEntries`,读腿铸,随 effective 走 —— 盘上 LKG
@@ -114,6 +137,7 @@ export declare function splitFoldedReadWarnings(warnings: readonly EffectiveRead
     }>;
     droppedEntries: DroppedConfigEntry[];
     droppedCatalogEntries: DroppedCatalogEntry[];
+    unreadFiles: UnreadConfigFile[];
 };
 /** 把本次读交出的目录载体挂上 effective 的模型域(两腿同一只;空 ⇒ 不挂键)。 */
 export declare function withDroppedCatalogEntries<E extends {

package/dist/web-admin-client/read-warnings.js

@@ -1,5 +1,14 @@
 import { z } from "zod";
 import { DROPPED_ENTRY_REASON_CODES, formatConfigPath, isDisclosableIdentity, renderQuotedSentence, } from "@sema-agent/settings-schema";
+export function buildUnreadConfigFileFields(f, dir) {
+    return {
+        ...(dir !== undefined ? { dir } : {}),
+        file: f.file,
+        why: f.why,
+        ...(f.domain !== undefined ? { domain: f.domain } : {}),
+        note: "config.d holds a file the local read never reads (not a domain, or a domain that is not portable) — it is not applied and does not block the candidate; move it out of config.d if it is stray",
+    };
+}
 export function describeSchemaIssues(error) {
     const issues = schemaIssuesOf(error);
     if (issues === undefined)
@@ -13,8 +22,13 @@ function issueCoordinateOf(raw) {
     return Array.isArray(p) && p.length > 0 ? formatConfigPath(p) : undefined;
 }
 function issueSentenceOf(raw) {
-    const message = typeof raw === "object" && raw !== null ? raw.message : undefined;
-    return contractSentenceOf(raw) ?? (typeof message === "string" ? message : "(unreadable issue)");
+    const issue = typeof raw === "object" && raw !== null ? raw : {};
+    if (issue.code === "custom")
+        return contractSentenceOf(raw) ?? sentencelessCustomIssue(issueCoordinateOf(raw));
+    return typeof issue.message === "string" ? issue.message : "(unreadable issue)";
+}
+function sentencelessCustomIssue(at) {
+    return `(issue code "custom" at ${at ?? "(entry)"} carries no contract sentence — its message is withheld)`;
 }
 function contractSentenceOf(raw) {
     const params = (typeof raw === "object" && raw !== null ? raw.params : undefined);
@@ -74,7 +88,7 @@ export function foldEffectiveReadWarning(w) {
         case "unknown-keys-carried":
             return { scope: "domain", domain: w.domain, error: keyList("unknown keys carried to consumer (spelling?): ", w.keys, w.truncatedFrom) };
         case "unread-config-file":
-            return { scope: "domain", domain: w.domain ?? "config.d", error: cap(`unread config file ${w.file} (${w.why})`) };
+            return { scope: "unread", file: w.file, why: w.why, ...(w.domain !== undefined ? { domain: w.domain } : {}) };
         default: {
             const never = w;
             throw new Error(`unhandled EffectiveReadWarning kind: ${JSON.stringify(never)}`);
@@ -109,6 +123,7 @@ export function splitFoldedReadWarnings(warnings) {
     const domainErrors = [];
     const droppedEntries = [];
     const droppedCatalogEntries = [];
+    const unreadFiles = [];
     for (const w of warnings) {
         const f = foldEffectiveReadWarning(w);
         switch (f.scope) {
@@ -124,13 +139,18 @@ export function splitFoldedReadWarnings(warnings) {
                 }
                 break;
             }
+            case "unread": {
+                const { scope: _scope, ...file } = f;
+                unreadFiles.push(file);
+                break;
+            }
             default: {
                 const never = f;
                 throw new Error(`unhandled folded read-warning scope: ${JSON.stringify(never)}`);
             }
         }
     }
-    return { domainErrors, droppedEntries, droppedCatalogEntries };
+    return { domainErrors, droppedEntries, droppedCatalogEntries, unreadFiles };
 }
 export function withDroppedCatalogEntries(effective, rows) {
     if (rows.length === 0 || effective.models === undefined)