@sema-agent/server 7.100.0 → 7.101.1

package/dist/model-entry-refusal.js

@@ -0,0 +1,157 @@
+import { CC_MODEL_TIER_ALIASES, DEFAULT_TIER_ORDER, expandTiers } from "@sema-agent/core";
+import { ModelEntry } from "@sema-agent/settings-schema";
+import { catalogBrainLane } from "./model-provider.js";
+import { describeSchemaIssueFields, describeSchemaIssues } from "./config-center/read-warnings.js";
+import { DEFAULT_MODEL_REF } from "./model-select.js";
+export const MODEL_ENTRY_REFUSAL_CODES = {
+    no_brain: "config.model_no_brain",
+    entry_invalid: "config.model_entry_invalid",
+};
+export const DEFAULT_MODEL_MISSING_CODE = "config.default_model_missing";
+export const REFUSED_NAME_MINTED_CODE = "config.model_refused_name_minted";
+function laneMount(lane, ctx) {
+    switch (lane) {
+        case "gateway":
+            return { mounted: true, how: "" };
+        case "anthropic":
+            return { mounted: ctx.anthropicRouteMounted, how: "ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN) in this service's env" };
+    }
+}
+export function judgeCatalogEntry(m, ctx) {
+    const shape = ModelEntry.safeParse(m);
+    if (!shape.success) {
+        const fields = describeSchemaIssueFields(shape.error);
+        return entryInvalidRefusal(typeof m.id === "string" ? m.id : "", typeof m.provider === "string" ? m.provider : "", fields, describeSchemaIssues(shape.error) ?? fields.join(", "));
+    }
+    const lane = catalogBrainLane(m.provider);
+    const mount = laneMount(lane, ctx);
+    if (!mount.mounted) {
+        return {
+            reason: "no_brain",
+            code: MODEL_ENTRY_REFUSAL_CODES.no_brain,
+            id: m.id,
+            provider: m.provider,
+            fields: [],
+            detail: `provider "${m.provider}" rides the ${lane} brain, which is not mounted on this deployment — the entry is not served here ` +
+                `(it is never routed to another brain with its own key); set ${mount.how}, ` +
+                'or change the entry\'s provider to an OpenAI-compatible route ("gateway" / "vllm") with its own baseUrl',
+        };
+    }
+    return undefined;
+}
+function entryInvalidRefusal(id, provider, fields, issues) {
+    return {
+        reason: "entry_invalid",
+        code: MODEL_ENTRY_REFUSAL_CODES.entry_invalid,
+        id,
+        provider,
+        fields: [...fields],
+        detail: `the catalog entry does not match the settings-schema ModelEntry shape (${issues}) — it is dropped from this ` +
+            "deployment's catalog on its own (the other entries keep serving) instead of being served with a value nothing validated; fix the entry to bring it back",
+    };
+}
+export function judgeCatalogEntries(enabled, ctx, dropped) {
+    const usable = [];
+    const refused = {};
+    for (const m of enabled) {
+        const r = judgeCatalogEntry(m, ctx);
+        if (r === undefined)
+            usable.push(m);
+        else
+            refused[String(m.name)] = r;
+    }
+    const unreadable = [];
+    for (const d of Array.isArray(dropped) ? dropped : []) {
+        const e = (typeof d === "object" && d !== null ? d : {});
+        const where = typeof e.entry === "string" ? e.entry : "(unknown coordinate)";
+        if (typeof e.name !== "string") {
+            unreadable.push(where);
+            continue;
+        }
+        if (Object.hasOwn(refused, e.name))
+            continue;
+        const fields = Array.isArray(e.fields) ? e.fields.filter((f) => typeof f === "string") : [];
+        refused[e.name] = entryInvalidRefusal(typeof e.id === "string" ? e.id : "", typeof e.provider === "string" ? e.provider : "", fields, typeof e.issues === "string" ? e.issues : fields.join(", "));
+    }
+    return { usable, refused, unreadable };
+}
+export function refusalEventOf(reason) {
+    switch (reason) {
+        case "no_brain":
+            return "sema_registry_model_no_brain";
+        case "entry_invalid":
+            return "sema_registry_model_entry_invalid";
+    }
+}
+export function refusalWarnFields(name, r) {
+    return {
+        model: name,
+        provider: r.provider,
+        code: r.code,
+        ...(r.fields.length > 0 ? { field: r.fields[0], fields: [...r.fields] } : {}),
+        hint: r.detail,
+    };
+}
+export function modelUnavailableMessage(field, requested, name, r) {
+    const alias = requested === name ? "" : ` (catalog entry "${name}")`;
+    return `${field} "${requested}"${alias} is published in the catalog but unavailable on this deployment [${r.code}] — ${r.detail}`;
+}
+export function defaultModelRefusal(view, leg) {
+    if (Object.hasOwn(view.models, DEFAULT_MODEL_REF) && view.models[DEFAULT_MODEL_REF] !== undefined)
+        return undefined;
+    const refused = Object.entries(view.modelRefusals).map(([n, r]) => `"${n}" [${r.code}]`);
+    const unavailable = refused.length > 0 ? ` (every enabled catalog entry is unavailable on this host: ${refused.join(", ")})` : "";
+    switch (leg) {
+        case "env":
+            return (`MODEL_ID is required when no catalog default resolves [${DEFAULT_MODEL_MISSING_CODE}] — this model table has no default model` +
+                unavailable +
+                ". Set MODEL_ID=<model name your gateway serves>, or enable at least one model this host can serve in the catalog " +
+                "(config.d/models.json, or the config center) — either one is enough (a config center that answers after the boot budget " +
+                "counts as absent at boot: raise CONFIG_BOOT_FETCH_BUDGET_MS to wait for it).");
+        case "catalog":
+            return (`this catalog candidate has no default model [${DEFAULT_MODEL_MISSING_CODE}]` +
+                unavailable +
+                " — fix the named entries (each has its own warn with the reason) or enable / bind a default this host can serve, in the catalog itself " +
+                "(a catalog in force replaces the env model table, so MODEL_ID cannot stand in for it).");
+    }
+}
+function mintedVia(name, own, tiers) {
+    if (own)
+        return "catalog-entry";
+    if (Object.hasOwn(CC_MODEL_TIER_ALIASES, name))
+        return `cc-alias of tier "${CC_MODEL_TIER_ALIASES[name]}"`;
+    if (name === "best")
+        return "best-tier alias";
+    if (DEFAULT_TIER_ORDER.includes(name) || Object.hasOwn(tiers, name))
+        return "tier word";
+    return "expansion key";
+}
+export function mintedRefusedNames(view) {
+    const refusedNames = Object.keys(view.modelRefusals);
+    if (refusedNames.length === 0)
+        return [];
+    const expanded = (expandTiers(view.models, view.tiers) ?? view.models);
+    const out = [];
+    for (const name of refusedNames) {
+        if (!Object.hasOwn(expanded, name) || expanded[name] === undefined)
+            continue;
+        const t = expanded[name]?.name;
+        out.push({ name, target: typeof t === "string" && t.length > 0 ? t : name, via: mintedVia(name, Object.hasOwn(view.models, name), view.tiers), code: view.modelRefusals[name].code });
+    }
+    return out;
+}
+export function refusedNameMintedRefusal(view) {
+    const minted = mintedRefusedNames(view);
+    if (minted.length === 0)
+        return undefined;
+    const pairs = minted.map((m) => `"${m.name}" [${m.code}] → "${m.target}" (${m.via})`);
+    return (`unavailable catalog entries would be re-minted onto other entries by the tier/alias expansion [${REFUSED_NAME_MINTED_CODE}]: ${pairs.join(", ")} — ` +
+        "an explicit pick of that name (or a role bound to it) would silently run on the other entry's endpoint and account; " +
+        "rename the unavailable entry, fix it (see its own warn), or rebind / drop the tier binding that mints the name.");
+}
+export function unreadableDroppedRefusal(entries) {
+    return (`catalog entries dropped by the settings-schema read could not be identified [${REFUSED_NAME_MINTED_CODE}]: ${entries.join(", ")} — ` +
+        "the raw document could not be matched to the snapshot that was parsed (e.g. the local file changed between two reads), so the candidate cannot prove the tier/alias expansion does not re-mint their names; " +
+        "the next read re-judges (fix the named entries if this persists).");
+}
+//# sourceMappingURL=model-entry-refusal.js.map

package/dist/model-provider.d.ts

@@ -69,9 +69,11 @@ export declare function modelBrainLane(provider: ModelProvider): ModelBrainLane;
  * unrecognized provider)" 是它的原话)。本函数做的只是把那句散文变成**一个有名字的判词**,于是
  * 「目录里写了个没人认识的 provider」这件事在代码里有一处可指的坐标,而不是散在两个 `=== "anthropic"` 里。
  *
- * ⚠️ **未闭环**(S-461 收车档登记):目录词今天仍然**无声**地落进网关腿。要让它也响亮,需要的是一条
- * **热路径上的**告警/拒收(config-center 应用期逐条校验 + 运维可读的拒因),那是另一件事、另一台车 ——
- * 在这里加一个 throw 会让一次热发布打死在跑的副本,方向反了。
+ * ⚠️ **未闭环(收窄后如实)**:认不出的目录词今天仍然**无声**地落进网关腿(OpenAI 兼容;条目带自己的 baseUrl /
+ * 钥匙,打的是它自己的端点 —— 不是凭据越界,是词面失真)。S-704(7.101.0)已把**热路径上的逐条判据**落地
+ * (`model-entry-refusal.ts`:本部署没有对应 brain 的条目整条不可用 —— 今天那一形是「anthropic 词 + 本机没装
+ * anthropic 路由」),但**域外词**是否也该不可用是另一个问题(web-admin 的新条目缺省就写 `"openai"`,预设写厂商名;
+ * 把它们判不可用会让大量在跑的目录整条消失),另车带三问定。在这里加一个 throw 会让一次热发布打死在跑的副本,方向反了。
  */
 export declare function catalogBrainLane(provider: string | undefined): ModelBrainLane;
 /**
@@ -85,6 +87,10 @@ export declare function catalogBrainLane(provider: string | undefined): ModelBra
  * 所以「这条路由要不要一个 openai 端点」的判据必须同时看词与装配:词判 {@link catalogBrainLane},
  * 装配判路由在不在。本函数是这一合取的**唯一**写法 —— 端点判官(`model-route-endpoint.ts`)、降级腿与
  * 启动摘要(`brain.ts`)都调它,不再各写一个 `=== "anthropic" && config.anthropic`。
+ *
+ * 🔴 S-704(7.101.0):**目录条目**已到不了「anthropic 词、路由没装」这一格 —— 模型面 stage 的逐条判据把它判成不可用
+ * (`config.model_no_brain`,不进 `config.models`)。这一格今天只剩 **env 腿**:`MODEL_PROVIDER=anthropic` 而没配 anthropic
+ * 凭据的部署,env 模型落网关腿、用的是网关自己的 `MODEL_API_KEY`(凭据与端点同属网关,不越界;是否也该拒启另车)。
  */
 export declare function dispatchBrainLane(provider: string | undefined, anthropicRouteMounted: boolean): ModelBrainLane;
 //# sourceMappingURL=model-provider.d.ts.map

package/dist/model-route-endpoint.d.ts

@@ -17,7 +17,7 @@
  * ## 执法点(判据只在这里,执法点在调用处 —— 与 S-475 `gateway-url-userinfo` 同形)
  *  · boot:`config.ts` 九域解析之后的跨域不变量区(锚 `CROSS-INVARIANT:model-route-endpoint`)⇒ 拒启;严格名册
  *    布防(`isRosterGateArmed`)时 env 腿是占位、从不被派发 ⇒ 不判它(备用网关那一条照判);
- *  · 热路径:`config-center/apply-effective.ts` 的模型面 stage ⇒ 候选整批拒、上一代继续服务;
+ *  · 热路径:`config-center/apply-effective.ts` 的模型面 stage ⇒ 模型面组拒(opus 腿 O3:同候选其余组照落)、上一代模型面继续服务;
  *  · run-local:配置源解析完之后按真要派发的表再判一次(`run-local.ts`,7.98.0 合并复审 F2)—— 本入口没有名册门,
  *    loadConfig 对严格名册布防的占位豁免在这里兑现不了;没布防时恒惰性;
  *  · 登记:`config-invariants.ts` 的 `model-route-endpoint` 条(表的「不许有表外不变量」职责);

package/dist/model-select.d.ts

@@ -1,3 +1,4 @@
+import type { ModelEntryRefusal } from "./model-entry-refusal.js";
 /**
  * Resolve the model ref for a task spec from the request (CLI `/model` picker + `run --model`).
  *
@@ -27,12 +28,53 @@
  *  `resolveModel("default", catalog)` 解它)。**单点**:读面要说「这台部署的主模型是谁」时读同一个词
  *  (`auto-mode-face.ts` 的席解析器入参),两处各写一个 `"default"` 字面串正是漂移的成因。 */
 export declare const DEFAULT_MODEL_REF = "default";
-export declare function resolveTaskModel(bodyModel: unknown, objective: string, catalog: Record<string, unknown>, allowlist?: readonly string[]): {
+export declare function resolveTaskModel(bodyModel: unknown, objective: string, catalog: Record<string, unknown>, allowlist?: readonly string[], refusals?: Readonly<Record<string, ModelEntryRefusal>>): {
     model: string;
     cleanedObjective: string;
     unknownExplicit?: string;
     notAllowed?: ModelNotAllowed;
+    unavailable?: ModelUnavailable;
 };
+/**
+ * S-704 判别式拒因:这次**用户选择**点中的是一条已发布、但本部署不可用的目录条目(`config.modelRefusals`)。
+ * 与 {@link ModelNotAllowed} 同一种处置口:本函数不 throw,调用点按 leg 分流(fresh 400 `request.model_unavailable` /
+ * resume 留声降级)。拒因句由 `model-entry-refusal.ts` 的 `modelUnavailableMessage` 铸(一处)。
+ */
+export interface ModelUnavailable {
+    /** 调用方发来的原始 ref(name / id / `@name`),已做过日志安全的 repr 归一。 */
+    requested: string;
+    /** 命中的不可用条目的 catalog name。 */
+    name: string;
+    refusal: ModelEntryRefusal;
+    /** 走的是哪条用户通道:`explicit`=body.model/settings.model,`mention`=objective 内联 `@name`。 */
+    source: "explicit" | "mention";
+}
+/**
+ * S-704 —— **用户可选目录**:服务的目录经 core `expandTiers` 增广(档位词 / CC 别名 / `best`),再把**不可用条目的名字**
+ * 从增广出来的别名键里**让出**。全部用户**显式**选择通道(body.model / `@name` / settings.model / compactionModel /
+ * agents[].model / side-query 的 body.model / 名单判定 / `/v1/models` 的可点性)都在这一只上解析 —— 一个优先序,不各写一份;
+ * 与之配套的另一半是 {@link matchCatalogModel} 的「保留名不走 id 回退」。
+ * ⚠️ 射程只到显式选择:引擎自己的隐式选路(角色的档位缺省、档位梯、workflow 名单在 core 里的解析)用的是 core 的增广目录,
+ * 本函数**不**进那里(codex 验修轮 V4:让出名字会改变只带 `modelRole` 的隐式选路)。不可用条目名撞上别名词时引擎侧的改绑
+ * (运维配置里点名它的角色绑定 / workflow 名单)自 S-712 起由不变量 `refused-names-not-minted`(`model-entry-refusal.ts`)在
+ * 源头收口:增广会把被拒名铸到别的条目上的候选,模型面整组被拒、进不了引擎 —— 于是本函数的「让出」在已采纳的配置上恒是
+ * 空操作,保留作 HTTP 选择面的第二道(绕过 stage 的写者若造出这种表,选择面仍不改绑)。
+ *
+ * 为什么要让出(codex r1 [high],真复现):一条已发布的条目占着它的名字;它可用时,core 的别名展开**让它**(`shadowed`,
+ * 同名别名不生成)。它因不可用被摘出目录之后,展开会把同名的别名(条目恰好叫 `sonnet` / `pro` …)重新指到另一只模型 ——
+ * 一次点它的选择被静默改绑到另一只模型(及其端点、账号),一张写着它的 @-名单也随之准了那一只。让出之后,它的名字在可选
+ * 目录里不存在,选择走 {@link refusedCatalogEntry} 拿到拒因码,名单里的它解析不到任何条目(准不了任何东西)。
+ * 可用条目的真名永远不会被让出:目录里 name 唯一,不可用条目的名字只可能撞上**展开生成**的别名键。
+ */
+export declare function selectableCatalog<M>(models: Record<string, M>, tiers: Record<string, string> | undefined, refusals: Readonly<Record<string, ModelEntryRefusal>> | undefined): Record<string, M>;
+/**
+ * S-704 —— ref(name 或上游 id)→ 它命中的**不可用条目**;未命中 ⇒ undefined。与 {@link matchCatalogModel} 同一种双键
+ * 索引(name 用 `Object.hasOwn`,id 扫值)。调用方**先**查可用目录、再查这里(一个 id 被可用与不可用条目共享时,可用那条胜)。
+ */
+export declare function refusedCatalogEntry(ref: string, refusals: Readonly<Record<string, ModelEntryRefusal>> | undefined): {
+    name: string;
+    refusal: ModelEntryRefusal;
+} | undefined;
 /** [ref] 判别式拒因:名单在场且这次**用户选择**落在名单外。`resolved` 已是目录 name 形(归一后)。 */
 export interface ModelNotAllowed {
     /** 调用方发来的原始 ref(name / 档位词 / 别名 / id / `@name`),已做过日志安全的 repr 归一。 */
@@ -64,7 +106,7 @@ export interface ModelNotAllowed {
  * ⚠️ 射程:本门是**提交时**门。core 运行时路由(degrade 降级链 / cascade 梯 / roles 解析)按 operator
  * 配置自己走,**不经本门**——那不是一次用户选择,如实声明,不假装是运行时执法。
  */
-export declare function isModelAllowlisted(ref: string, catalog: Record<string, unknown>, allowlist: readonly string[] | undefined): boolean;
+export declare function isModelAllowlisted(ref: string, catalog: Record<string, unknown>, allowlist: readonly string[] | undefined, refusals?: Readonly<Record<string, ModelEntryRefusal>>): boolean;
 /**
  * [ref] —— ref → **终端 catalog name**(拒因/日志的可读形)。
  *
@@ -73,15 +115,18 @@ export declare function isModelAllowlisted(ref: string, catalog: Record<string,
  * 取条目自己的 `Model.name`(applyEffective 建目录时 `models[m.name].name === m.name`,env lane 同)
  * 才是终端名;拿不到时如实退回匹配键(诚实缺席,不猜)。
  */
-export declare function terminalCatalogName(ref: string, catalog: Record<string, unknown>): string | undefined;
+export declare function terminalCatalogName(ref: string, catalog: Record<string, unknown>, refusals?: Readonly<Record<string, ModelEntryRefusal>>): string | undefined;
 /**
  * [ref]② name+id 双键目录索引:返回 ref 命中的目录 **name 键**(spec.model 的规范形),未知 → undefined。
  *  - name 命中用 Object.hasOwn(🔴 不用真值索引:Object.prototype 继承键 "constructor"/"__proto__" 等在裸
  *    索引下是真值,会跳过 allow-list——沿袭原实现的纪律)。
  *  - id 命中扫目录值(`Model.id`),跳过 "default" 别名键(它与其指向的真身共享 id,解析到别名会让 /model
  *    面板与实际路由再度撕裂);同 id 多 name 时取目录序第一个(与 /v1/models 列表序一致,确定性)。
+ *  - 🔴 S-704(codex 验修轮 V1):**名字先于 id** 这条序对不可用条目同样成立 —— `refusals` 里的名字是一条已发布
+ *    条目的名字,它不在可用目录里时**不许**被 id 回退解析成另一条可用条目(v7.100.0 那条条目在目录里,name 命中先返回
+ *    它自己)。命中保留名 ⇒ undefined,调用方接着问 {@link refusedCatalogEntry} 拿拒因码。
  */
-export declare function matchCatalogModel(ref: string, catalog: Record<string, unknown>): string | undefined;
+export declare function matchCatalogModel(ref: string, catalog: Record<string, unknown>, refusals?: Readonly<Record<string, ModelEntryRefusal>>): string | undefined;
 /**
  * vision precheck: a catalog model can read images iff its `input` modality list
  * includes `"image"` (the SAME test as the vision capability on GET /v1/models — `server.ts`). FALSE-SAFE on

package/dist/model-select.js

@@ -1,31 +1,60 @@
-import { parseModelMention } from "@sema-agent/core";
+import { expandTiers, parseModelMention } from "@sema-agent/core";
 export const DEFAULT_MODEL_REF = "default";
-export function resolveTaskModel(bodyModel, objective, catalog, allowlist) {
-    const mention = parseModelMention(objective, Object.keys(catalog));
-    const explicit = typeof bodyModel === "string" ? matchCatalogModel(bodyModel, catalog) : undefined;
+export function resolveTaskModel(bodyModel, objective, catalog, allowlist, refusals) {
+    const mention = parseModelMention(objective, [...Object.keys(refusals ?? {}), ...Object.keys(catalog)]);
+    const mentionUsable = mention.model !== undefined && Object.hasOwn(catalog, mention.model) ? mention.model : undefined;
+    const explicit = typeof bodyModel === "string" ? matchCatalogModel(bodyModel, catalog, refusals) : undefined;
     const present = bodyModel !== undefined && bodyModel !== null;
-    const unknown = present && explicit === undefined;
     const repr = typeof bodyModel !== "string" ? `<non-string:${typeof bodyModel}>` : bodyModel === "" ? "<empty-string>" : bodyModel;
-    const model = explicit ?? mention.model ?? DEFAULT_MODEL_REF;
-    const picked = explicit !== undefined ? { ref: explicit, source: "explicit", requested: repr } : mention.model !== undefined ? { ref: mention.model, source: "mention", requested: mention.model } : undefined;
-    const notAllowed = picked !== undefined && !isModelAllowlisted(picked.ref, catalog, allowlist)
-        ? { requested: picked.requested, resolved: terminalCatalogName(picked.ref, catalog) ?? picked.ref, source: picked.source }
+    const refusedExplicit = present && explicit === undefined && typeof bodyModel === "string" ? refusedCatalogEntry(bodyModel, refusals) : undefined;
+    const refusedMention = explicit === undefined && refusedExplicit === undefined && mention.model !== undefined && mentionUsable === undefined ? refusedCatalogEntry(mention.model, refusals) : undefined;
+    const unavailable = refusedExplicit !== undefined
+        ? { requested: repr, name: refusedExplicit.name, refusal: refusedExplicit.refusal, source: "explicit" }
+        : refusedMention !== undefined
+            ? { requested: mention.model, name: refusedMention.name, refusal: refusedMention.refusal, source: "mention" }
+            : undefined;
+    const unknown = present && explicit === undefined && refusedExplicit === undefined;
+    const model = explicit ?? mentionUsable ?? DEFAULT_MODEL_REF;
+    const picked = explicit !== undefined ? { ref: explicit, source: "explicit", requested: repr } : mentionUsable !== undefined ? { ref: mentionUsable, source: "mention", requested: mentionUsable } : undefined;
+    const notAllowed = picked !== undefined && !isModelAllowlisted(picked.ref, catalog, allowlist, refusals)
+        ? { requested: picked.requested, resolved: terminalCatalogName(picked.ref, catalog, refusals) ?? picked.ref, source: picked.source }
         : undefined;
     return {
         model,
         cleanedObjective: mention.cleanedText || objective,
         ...(unknown ? { unknownExplicit: repr } : {}),
         ...(notAllowed ? { notAllowed } : {}),
+        ...(unavailable ? { unavailable } : {}),
     };
 }
-export function isModelAllowlisted(ref, catalog, allowlist) {
+export function selectableCatalog(models, tiers, refusals) {
+    const expanded = (expandTiers(models, tiers ?? {}) ?? models);
+    const reserved = Object.keys(refusals ?? {}).filter((n) => Object.hasOwn(expanded, n) && !Object.hasOwn(models, n));
+    if (reserved.length === 0)
+        return expanded;
+    const out = { ...expanded };
+    for (const n of reserved)
+        delete out[n];
+    return out;
+}
+export function refusedCatalogEntry(ref, refusals) {
+    if (refusals === undefined)
+        return undefined;
+    if (Object.hasOwn(refusals, ref))
+        return { name: ref, refusal: refusals[ref] };
+    for (const [name, r] of Object.entries(refusals))
+        if (r.id === ref)
+            return { name, refusal: r };
+    return undefined;
+}
+export function isModelAllowlisted(ref, catalog, allowlist, refusals) {
     if (allowlist === undefined || allowlist.length === 0)
         return true;
-    const entry = catalogEntryOf(ref, catalog);
+    const entry = catalogEntryOf(ref, catalog, refusals);
     if (entry === undefined)
         return true;
     for (const name of allowlist) {
-        const allowed = catalogEntryOf(name, catalog);
+        const allowed = catalogEntryOf(name, catalog, refusals);
         if (allowed === undefined)
             continue;
         if (allowed === entry)
@@ -33,20 +62,22 @@ export function isModelAllowlisted(ref, catalog, allowlist) {
     }
     return false;
 }
-function catalogEntryOf(ref, catalog) {
-    const name = matchCatalogModel(ref, catalog);
+function catalogEntryOf(ref, catalog, refusals) {
+    const name = matchCatalogModel(ref, catalog, refusals);
     return name === undefined ? undefined : catalog[name];
 }
-export function terminalCatalogName(ref, catalog) {
-    const key = matchCatalogModel(ref, catalog);
+export function terminalCatalogName(ref, catalog, refusals) {
+    const key = matchCatalogModel(ref, catalog, refusals);
     if (key === undefined)
         return undefined;
     const name = catalog[key]?.name;
     return typeof name === "string" && name.length > 0 ? name : key;
 }
-export function matchCatalogModel(ref, catalog) {
+export function matchCatalogModel(ref, catalog, refusals) {
     if (Object.hasOwn(catalog, ref))
         return ref;
+    if (refusals !== undefined && Object.hasOwn(refusals, ref))
+        return undefined;
     for (const [name, m] of Object.entries(catalog)) {
         if (name === "default")
             continue;

package/dist/observability/fail-open.d.ts

@@ -123,7 +123,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.approvals.park-row-blob-unreadable": {
         readonly cls: "F";
-        readonly note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` 而读)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的两位 park 行事实缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。";
+        readonly note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。";
     };
     readonly "server.sql-json.checkpoint.pending-steer-queue-lossy": {
         readonly cls: "F";
@@ -173,6 +173,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "A-032 P1-④:`runStatusToFleet` 收到**词表外**的 run 状态词(闭集签名之外的唯一来路 = `rowToRun` 把无约束的 status 文本列裸 cast,滚动升级里更新的副本写的新词被旧副本读到)⇒ 折成 `idle`。放行的最坏后果 = 该行在 fleet 面板上**永久滞留**(removal 集 {completed,failed,killed} 收不到 idle),纯展示面、不影响 run 本身与任何执法判据,故 F 类。方向刻意不改(把 miss 折成终局会把一条还在跑的任务从面板上摘掉,误摘比多一行更伤)。留痕是承重的:2026-06-28 on-box e2e 逮到的 `blocked` 泄漏当年只能靠人眼在面板上发现——计数让下一次词表漂移在遥测里当场显形。编译期一侧已由闭集入参 + `never` 臂执法。";
     };
+    readonly "server.fleet.agent-status-unmapped": {
+        readonly cls: "F";
+        readonly note: "S-751:fleet 对账腿问 bg registry「这只子代还活着吗」时,读到**词表外**的 `BackgroundAgentRecord.status`(闭集之外的唯一来路 = SQL 孪生把 status 文本列裸 cast 成联合,滚动升级里更新的 core 写下的新词被本副本读到)⇒ 按「属主作保」处置:子代行**留在面板上**。放行的最坏后果 = 一条其实已终局的子代行多留在面板上(它的终态通知仍会结算它;与 #261 之前「子代行永远不走」同形),纯展示面、不影响子代本身与任何执法判据,故 F 类。方向刻意不折成「死」:把不认识的词读成死会把一只正在跑的后台子代从面板上摘掉,而那正是 S-751 报案的症状(误摘比多一行更伤,与 `server.fleet.run-status-unmapped` 同一条判据)。编译期一侧由 `bgAgentVouches` 的穷举 switch + `never` 臂执法;留痕让词表漂移在遥测里当场显形。";
+    };
     readonly "server.run-store.stale-claim-quarantine-unremoved": {
         readonly cls: "F";
         readonly note: "#213 陈旧 claim 接管:claim 已 rename 进 tmp/ 隔离名(接管本体已完成、正确性不受影响),但隔离件 rmSync 失败留在 tmp。放行的最坏后果 = tmp 里多一个死文件(不在 activeDir,hydrate 永不把它当 claim 复活);故 F 类。必须留痕:反复删不掉 = tmp 权限/fs 病灶,静默吞掉会让 tmp 无声膨胀。";
@@ -193,6 +197,14 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "#310(codex 对抗复审 R1-[medium],验真后修):三条 run 腿把一条白名单通告写进 durable 账本时,那次 `appendEvent` **异步 reject**(store 抖动 / 连接断 / 行冲突)。结构上不能 await —— `onNotice` 是 core 的同步回调,拿一次账本写去阻塞引擎是更坏的交易 —— 所以写口只能 fire-and-forget,`route` 的同步 try 结构性观察不到这次失败 —— 「投出去了」与「真落盘了」不是同一件事。放行的最坏后果按腿分档,如实登记:**sync stream 腿**还有 live SSE 那一份(在线的人看得见,丢的是断连补看);**bg / resume 两腿账本是唯一的用户可见终点** ⇒ 那条通告对用户永久消失。仍判 F 而不是 P:通告是**披露**面不是执法面(不参与任何门/裁决),且运维面那一份(结构化日志 `engine_notice`)在分流之前就已经落定、一条不丢。此前是裸 `.catch(() => undefined)` —— 同文件 resume 腿的子代 forward 写口早在 C2/C5 批2 就因为「裸吞 = 事件从 durable log 永久消失且零信号」补过 `warnAppend`,本 tag 是同一条纪律在通告口的落实(warn 留细节 + 计数让「系统性在漏」显形)。不做重试队列是刻意的:账本里没有任何一族行做有界重试,单给通告开一条会造出第二套持久化语义。";
     };
+    readonly "server.memory.locked-layer-probe-partial": {
+        readonly cls: "F";
+        readonly note: "O2(7.101.0 合并复审,`memory-layer-legacy-lock.ts announceLockedLegacyMemoryLayers`,boot 期锁住记忆层探测;detail 只报 `unreadable=<条数>`):挂载面或某个层里的目录**读不出**(EACCES 之类 —— 不是 ≤7.30.x 引擎的锁形,那种 0555 目录可读)⇒ 那棵子树看不全,照常起服。放行的最坏后果 = 一个锁住的层在 boot 日志里没被点名 —— 探测是**披露**面,不参与任何门 / 裁决;core 在真正失败的那一次删除上仍给出自己的 `chmod -R u+w` 补救句。不放行的代价严重不对称:为一条 warn 打死起服(混跑窗里能服务的副本)。计数让「这台部署的记忆树有读不出的目录」显形。";
+    };
+    readonly "server.instruction-source.announce-degraded": {
+        readonly cls: "F";
+        readonly note: "S-690(`instruction-source-notice.ts announceInstructionSource`,项目指令换源通告的唯一铸点;detail 的 `op` 点名哪一步):基线**读**失败或超期(会话店抖动 / 列形坏 / 2s 期限到,detail 带 `timeout=`)⇒ 本 run 不比也不写;基线**写**失败或超期 ⇒ 本 run 的换源帧照发(它对本 run 为真),下一 run 可能再说一遍同一次换源(超期后才落地的写由 CAS 挡住,盖不掉更新的基线);通告**出口**抛 ⇒ 本 run 缺这一帧。放行的最坏后果 = 一次换源没被说出来或被多说一次 —— 通告是**披露**面,不参与任何门 / 裁决,模型读到的指令本身不受影响。不放行的代价严重不对称:铸点跑在 core 的 `loadProjectMemory` 席内,抛回去 core 会把这次 prepare 的项目记忆整块丢掉(不注入),为一条通告赔上指令本身。计数让「某台部署的会话店一直读不出基线」与「这台部署从来没换过源」在遥测上分得开。";
+    };
     readonly "server.engine-notice.wire-sink-threw": {
         readonly cls: "F";
         readonly note: "#310:`engine_notice` 分流器把一条白名单通告投给某条 run 腿的登记口时,那只口抛了(live 口写向已断/已撕裂的 SSE socket,或 durable 口的账本写同步抛)。放行的最坏后果 = **这一条通告的这一个终点**缺席:①日志终点在分流之前已经逐字打过(事实一条不丢);②两个终点注册成两只独立 sink ⇒ live 抛不牵连 durable(断连后仍看得见的那半保住);③同会话其余口照投。故 F 类。不放行的代价是把异常回抛给 core 的 `deliverEngineNotice` —— 它会吞掉,于是同一次失败**既没有留痕也没有第二只口**,正是本 tag 要根除的形。留痕是承重的:静默吞掉之后「wire 腿为什么总有几条通告不到」在遥测里与「core 本来就没发」同形。";

package/dist/observability/fail-open.js

@@ -114,7 +114,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.park-row-blob-unreadable": {
         cls: "F",
-        note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` 而读)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的两位 park 行事实缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。",
+        note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。",
     },
     "server.sql-json.checkpoint.pending-steer-queue-lossy": {
         cls: "F",
@@ -164,6 +164,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "A-032 P1-④:`runStatusToFleet` 收到**词表外**的 run 状态词(闭集签名之外的唯一来路 = `rowToRun` 把无约束的 status 文本列裸 cast,滚动升级里更新的副本写的新词被旧副本读到)⇒ 折成 `idle`。放行的最坏后果 = 该行在 fleet 面板上**永久滞留**(removal 集 {completed,failed,killed} 收不到 idle),纯展示面、不影响 run 本身与任何执法判据,故 F 类。方向刻意不改(把 miss 折成终局会把一条还在跑的任务从面板上摘掉,误摘比多一行更伤)。留痕是承重的:2026-06-28 on-box e2e 逮到的 `blocked` 泄漏当年只能靠人眼在面板上发现——计数让下一次词表漂移在遥测里当场显形。编译期一侧已由闭集入参 + `never` 臂执法。",
     },
+    "server.fleet.agent-status-unmapped": {
+        cls: "F",
+        note: "S-751:fleet 对账腿问 bg registry「这只子代还活着吗」时,读到**词表外**的 `BackgroundAgentRecord.status`(闭集之外的唯一来路 = SQL 孪生把 status 文本列裸 cast 成联合,滚动升级里更新的 core 写下的新词被本副本读到)⇒ 按「属主作保」处置:子代行**留在面板上**。放行的最坏后果 = 一条其实已终局的子代行多留在面板上(它的终态通知仍会结算它;与 #261 之前「子代行永远不走」同形),纯展示面、不影响子代本身与任何执法判据,故 F 类。方向刻意不折成「死」:把不认识的词读成死会把一只正在跑的后台子代从面板上摘掉,而那正是 S-751 报案的症状(误摘比多一行更伤,与 `server.fleet.run-status-unmapped` 同一条判据)。编译期一侧由 `bgAgentVouches` 的穷举 switch + `never` 臂执法;留痕让词表漂移在遥测里当场显形。",
+    },
     "server.run-store.stale-claim-quarantine-unremoved": {
         cls: "F",
         note: "#213 陈旧 claim 接管:claim 已 rename 进 tmp/ 隔离名(接管本体已完成、正确性不受影响),但隔离件 rmSync 失败留在 tmp。放行的最坏后果 = tmp 里多一个死文件(不在 activeDir,hydrate 永不把它当 claim 复活);故 F 类。必须留痕:反复删不掉 = tmp 权限/fs 病灶,静默吞掉会让 tmp 无声膨胀。",
@@ -184,6 +188,14 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "#310(codex 对抗复审 R1-[medium],验真后修):三条 run 腿把一条白名单通告写进 durable 账本时,那次 `appendEvent` **异步 reject**(store 抖动 / 连接断 / 行冲突)。结构上不能 await —— `onNotice` 是 core 的同步回调,拿一次账本写去阻塞引擎是更坏的交易 —— 所以写口只能 fire-and-forget,`route` 的同步 try 结构性观察不到这次失败 —— 「投出去了」与「真落盘了」不是同一件事。放行的最坏后果按腿分档,如实登记:**sync stream 腿**还有 live SSE 那一份(在线的人看得见,丢的是断连补看);**bg / resume 两腿账本是唯一的用户可见终点** ⇒ 那条通告对用户永久消失。仍判 F 而不是 P:通告是**披露**面不是执法面(不参与任何门/裁决),且运维面那一份(结构化日志 `engine_notice`)在分流之前就已经落定、一条不丢。此前是裸 `.catch(() => undefined)` —— 同文件 resume 腿的子代 forward 写口早在 C2/C5 批2 就因为「裸吞 = 事件从 durable log 永久消失且零信号」补过 `warnAppend`,本 tag 是同一条纪律在通告口的落实(warn 留细节 + 计数让「系统性在漏」显形)。不做重试队列是刻意的:账本里没有任何一族行做有界重试,单给通告开一条会造出第二套持久化语义。",
     },
+    "server.memory.locked-layer-probe-partial": {
+        cls: "F",
+        note: "O2(7.101.0 合并复审,`memory-layer-legacy-lock.ts announceLockedLegacyMemoryLayers`,boot 期锁住记忆层探测;detail 只报 `unreadable=<条数>`):挂载面或某个层里的目录**读不出**(EACCES 之类 —— 不是 ≤7.30.x 引擎的锁形,那种 0555 目录可读)⇒ 那棵子树看不全,照常起服。放行的最坏后果 = 一个锁住的层在 boot 日志里没被点名 —— 探测是**披露**面,不参与任何门 / 裁决;core 在真正失败的那一次删除上仍给出自己的 `chmod -R u+w` 补救句。不放行的代价严重不对称:为一条 warn 打死起服(混跑窗里能服务的副本)。计数让「这台部署的记忆树有读不出的目录」显形。",
+    },
+    "server.instruction-source.announce-degraded": {
+        cls: "F",
+        note: "S-690(`instruction-source-notice.ts announceInstructionSource`,项目指令换源通告的唯一铸点;detail 的 `op` 点名哪一步):基线**读**失败或超期(会话店抖动 / 列形坏 / 2s 期限到,detail 带 `timeout=`)⇒ 本 run 不比也不写;基线**写**失败或超期 ⇒ 本 run 的换源帧照发(它对本 run 为真),下一 run 可能再说一遍同一次换源(超期后才落地的写由 CAS 挡住,盖不掉更新的基线);通告**出口**抛 ⇒ 本 run 缺这一帧。放行的最坏后果 = 一次换源没被说出来或被多说一次 —— 通告是**披露**面,不参与任何门 / 裁决,模型读到的指令本身不受影响。不放行的代价严重不对称:铸点跑在 core 的 `loadProjectMemory` 席内,抛回去 core 会把这次 prepare 的项目记忆整块丢掉(不注入),为一条通告赔上指令本身。计数让「某台部署的会话店一直读不出基线」与「这台部署从来没换过源」在遥测上分得开。",
+    },
     "server.engine-notice.wire-sink-threw": {
         cls: "F",
         note: "#310:`engine_notice` 分流器把一条白名单通告投给某条 run 腿的登记口时,那只口抛了(live 口写向已断/已撕裂的 SSE socket,或 durable 口的账本写同步抛)。放行的最坏后果 = **这一条通告的这一个终点**缺席:①日志终点在分流之前已经逐字打过(事实一条不丢);②两个终点注册成两只独立 sink ⇒ live 抛不牵连 durable(断连后仍看得见的那半保住);③同会话其余口照投。故 F 类。不放行的代价是把异常回抛给 core 的 `deliverEngineNotice` —— 它会吞掉,于是同一次失败**既没有留痕也没有第二只口**,正是本 tag 要根除的形。留痕是承重的:静默吞掉之后「wire 腿为什么总有几条通告不到」在遥测里与「core 本来就没发」同形。",

package/dist/observability/metrics.js

@@ -239,6 +239,7 @@ export function createMetrics() {
     m.counter("cost_quota_rejected_total", "Tasks refused because the principal is over its cumulative cost quota");
     m.counter("degraded_total", "Tasks degraded to a cheaper model (1.40), by reason (budget/rate_limit/breaker_open)");
     m.counter("task_model_not_allowlisted_resume_total", "Resumed legs whose model/compactionModel is outside the @-mention allowlist (allowed to keep running by design — the allowlist gates fresh picks only)");
+    m.counter("task_model_unavailable_fallback_total", "Resumed legs whose explicit model pick names a catalog entry that is unavailable on this deployment (no brain mounted for its provider / entry fails its schema) — the leg runs on the default model; fresh submits get 400 request.model_unavailable");
     m.counter("prompt_constitution_total", "Prompt assembly constitution mode per task (core 1.243 提示词主权): steady state = core; provider-assembled/replaced/legacy warrant eyes");
     m.counter("rewind_snapshot_failed_total", "Per-turn rewind file snapshots that failed, by the engine's FileHistoryResult.error.code (snapshot_failed/aborted/…; `unknown` = the disclosure text carried no readable code). COARSE on purpose — whether a failure is permanent (the same file will fail every turn until the deployment changes) is counted by file_history_permanent_failure_total instead, from the typed error object rather than from prose");
     m.counter("verifications_total", "Tasks run through the verification gate (1.44), by final verdict");

package/dist/observability/secret-env-scrub.d.ts

@@ -1,11 +1,32 @@
 import type { ServerSecretEnvFinding } from "../server-secret-env.js";
 import type { Logger } from "./logger.js";
 import type { Metrics } from "./metrics.js";
+/**
+ * 一个剥除现场的登记:`note` = 这条腿上泄漏意味着什么;`remedy` = 部署方能不能自己把某个被剥的键放回来。
+ *
+ * 🔴 S-699:`remedy` 在场与否决定披露行的**级别**,规则一句 —— **有出路的现场用 warn,并把出路句与当前放行名单写进同一行**;
+ * 没有出路的现场是纯保护留痕,照旧 info。理由:没有出路的剥除(模型可驱动的 shell、git 钩子)是本服务替部署方做的决定,
+ * 读者只需要知道它生效了;有出路的剥除(语言服务器)可能让一件功能静默变差(补全 / 诊断缺了私有 registry 的依赖),
+ * 那是部署方要自己决定的事 —— 看不见 = 无从归因。出路句不带任何值。
+ */
+export interface SecretEnvScrubSiteSpec {
+    readonly note: string;
+    readonly remedy: string | null;
+}
 /** 登记过的剥除现场。闭集:未登记的 site 传不进 {@link recordSecretEnvScrub}(编译期拒,同 FAIL_OPEN_TAGS 纪律)。 */
 export declare const SECRET_ENV_SCRUB_SITES: {
-    readonly "server.remote-env-host.inherit-scrub": "模型可驱动的 host shell 继承 env(`inheritEnv:\"scrub\"` 默认腿)——这条腿上的一次泄漏等于把编排器的脑钥/仓库令牌交给模型选的命令";
-    readonly "server.project-memory.git-subprocess": "project-memory 读仓叙事时的 git 子进程 env —— 仓内的钩子/凭证助手会以本进程身份运行";
-    readonly "server.lsp.spawn-env": "宿主车道本地语言服务器子进程 env(core 7.30.1 #1073 的 `NodeLspManagerOptions.env`)—— 语言服务器会执行仓里的代码(构建脚本/插件/工作区配置),一次泄漏等于把本进程的凭据交给仓";
+    readonly "server.remote-env-host.inherit-scrub": {
+        readonly note: "模型可驱动的 host shell 继承 env(`inheritEnv:\"scrub\"` 默认腿)——这条腿上的一次泄漏等于把编排器的脑钥/仓库令牌交给模型选的命令";
+        readonly remedy: null;
+    };
+    readonly "server.project-memory.git-subprocess": {
+        readonly note: "project-memory 读仓叙事时的 git 子进程 env —— 仓内的钩子/凭证助手会以本进程身份运行";
+        readonly remedy: null;
+    };
+    readonly "server.lsp.spawn-env": {
+        readonly note: "宿主车道本地语言服务器子进程 env(core 7.30.1 #1073 的 `NodeLspManagerOptions.env`)—— 语言服务器会执行仓里的代码(构建脚本/插件/工作区配置),一次泄漏等于把本进程的凭据交给仓";
+        readonly remedy: `LSP_ENV_ALLOW=NAME,NAME \u70B9\u540D\u653E\u884C(\u539F\u6837\u4EA4\u7ED9\u8BED\u8A00\u670D\u52A1\u5668,\u90E8\u7F72\u65B9\u663E\u5F0F\u627F\u62C5;${string});\u503C\u4E0D\u8FDB\u65E5\u5FD7`;
+    };
 };
 /** 词表键推导的闭集类型。 */
 export type SecretEnvScrubSite = keyof typeof SECRET_ENV_SCRUB_SITES;
@@ -16,8 +37,10 @@ interface Sink {
 /**
  * 记一次剥除。**总不抛** —— 观测本身绝不能变成故障(同 `recordFailOpen` / reapers 的判据)。
  * `findings` 为空(这一次没丢任何 key)时什么也不做:那不是事件,是常态。
+ * `findings` 只许装**最终没进子进程**的键 —— 点名放回的键不是剥除(不计数、不披露)。
+ * `allowed` = 这一次生效的点名放行名单(S-699),只在有出路的现场(`remedy` 在场)写进披露行;没有放行面的腿传 `[]`。
  */
-export declare function recordSecretEnvScrub(site: SecretEnvScrubSite, findings: readonly ServerSecretEnvFinding[]): void;
+export declare function recordSecretEnvScrub(site: SecretEnvScrubSite, findings: readonly ServerSecretEnvFinding[], allowed: readonly string[]): void;
 /** 装配层把 logger/metrics 接上(main.ts,与 `installFailOpenRecorder` 同一处)。装配前累计的次数在此补进 metrics。 */
 export declare function installSecretEnvScrubRecorder(deps: Sink): void;
 /** 已留驻的「现场×键」条数(测试/诊断读面)。恒 ≤ {@link DISCLOSED_CAP}。 */

package/dist/observability/secret-env-scrub.js

@@ -1,8 +1,18 @@
 import { summarizeRedactions } from "@sema-agent/core";
+import { describeAllowlistPostures } from "../env-name-allowlist-knobs.js";
 export const SECRET_ENV_SCRUB_SITES = {
-    "server.remote-env-host.inherit-scrub": "模型可驱动的 host shell 继承 env(`inheritEnv:\"scrub\"` 默认腿)——这条腿上的一次泄漏等于把编排器的脑钥/仓库令牌交给模型选的命令",
-    "server.project-memory.git-subprocess": "project-memory 读仓叙事时的 git 子进程 env —— 仓内的钩子/凭证助手会以本进程身份运行",
-    "server.lsp.spawn-env": "宿主车道本地语言服务器子进程 env(core 7.30.1 #1073 的 `NodeLspManagerOptions.env`)—— 语言服务器会执行仓里的代码(构建脚本/插件/工作区配置),一次泄漏等于把本进程的凭据交给仓",
+    "server.remote-env-host.inherit-scrub": {
+        note: "模型可驱动的 host shell 继承 env(`inheritEnv:\"scrub\"` 默认腿)——这条腿上的一次泄漏等于把编排器的脑钥/仓库令牌交给模型选的命令",
+        remedy: null,
+    },
+    "server.project-memory.git-subprocess": {
+        note: "project-memory 读仓叙事时的 git 子进程 env —— 仓内的钩子/凭证助手会以本进程身份运行",
+        remedy: null,
+    },
+    "server.lsp.spawn-env": {
+        note: "宿主车道本地语言服务器子进程 env(core 7.30.1 #1073 的 `NodeLspManagerOptions.env`)—— 语言服务器会执行仓里的代码(构建脚本/插件/工作区配置),一次泄漏等于把本进程的凭据交给仓",
+        remedy: `LSP_ENV_ALLOW=NAME,NAME 点名放行(原样交给语言服务器,部署方显式承担;${describeAllowlistPostures()});值不进日志`,
+    },
 };
 const SCRUB_COUNTER = "secret_env_scrubbed_total";
 const DISCLOSED_CAP = 512;
@@ -31,7 +41,7 @@ function drainToMetrics() {
         }
     }
 }
-export function recordSecretEnvScrub(site, findings) {
+export function recordSecretEnvScrub(site, findings, allowed) {
     if (findings.length === 0)
         return;
     try {
@@ -49,12 +59,17 @@ export function recordSecretEnvScrub(site, findings) {
         const fresh = findings.filter((f) => !disclosed.has(`${site}${SEP}${f.key}`)).slice(0, room);
         if (fresh.length === 0)
             return;
-        logger.info("secret_env_scrubbed", {
+        const spec = SECRET_ENV_SCRUB_SITES[site];
+        const fields = {
             site,
-            note: SECRET_ENV_SCRUB_SITES[site],
+            note: spec.note,
             keys: fresh.map((f) => f.key),
             summary: summarizeRedactions(fresh),
-        });
+        };
+        if (spec.remedy === null)
+            logger.info("secret_env_scrubbed", fields);
+        else
+            logger.warn("secret_env_scrubbed", { ...fields, allowed: [...allowed], hint: spec.remedy });
         for (const f of fresh)
             disclosed.add(`${site}${SEP}${f.key}`);
     }

package/dist/plugins/caching-session-store.d.ts

@@ -2,6 +2,7 @@ import type { AcquiredSession, PlacedSessionRow, RetentionDeclaration, SessionPl
 import type { SessionListItem } from "../security.js";
 import type { StagingHandle } from "../session-sync-kernel.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
+import type { InstructionSourceStore } from "../instruction-source-notice.js";
 export interface CachingOptions {
     /** Idle seconds a woken session is kept warm. 0 disables caching (pure passthrough). */
     ttlSec: number;
@@ -64,6 +65,11 @@ export declare class CachingSessionStore implements SessionStore {
     /** Write-once auto-title (SQL twins + local sidecar carry it; pure pass-through). */
     readonly setTitleIfNull?: (sessionId: string, title: string) => Promise<boolean>;
     readonly probeTitle?: (sessionId: string) => Promise<"none" | "untitled" | "titled">;
+    /** S-690 —— 换源通告的基线面(`session_meta.instruction_source` / local sidecar),纯转发、不经暖缓存。
+     *  🔴 必须转发(与 retention / placements 同一条教训):默认 `SESSION_CACHE_TTL_SEC=300` 把真店包进本类,
+     *  而装配点按「店上两个方法都在」判席 —— 不转发 = 默认部署上换源通告**静默不发**,且没有任何一处报错。 */
+    readonly readInstructionSource?: InstructionSourceStore["readInstructionSource"];
+    readonly recordInstructionSource?: InstructionSourceStore["recordInstructionSource"];
     /** E18 — delegate the leaf read straight to inner (a cache-bypassing single SELECT; the resume-at turn-capture
      *  reads the DURABLE leaf, not a possibly-stale cached view — same discipline as the §0.5 repo ops above). */
     readonly getLeafId?: (sessionId: string) => Promise<string | null>;