@sema-agent/server 7.130.0 → 7.131.0

package/dist/runs.d.ts

@@ -137,6 +137,38 @@ export declare function releaseKeyIfZeroWorkRefusal(runStore: {
  * surfaces the degrade (a metric) so a SYSTEMATIC failure — e.g. an un-migrated DB missing `resume_anchor` — is
  * observable instead of a silent feature outage.
  */
+/**
+ * 「这一次用户消息提交是不是一句**提问**」的唯一读法 —— 三处用户回退锚(后台腿与续跑腿的 {@link TurnAnchorCapture}、`/v1/tasks/stream`
+ * 腿的 `userMsgEntryId`)同调这一只。
+ *
+ * 目标声明了附件时,引擎把每只附件铸成**一条自己的用户消息**,紧跟在目标后面提交(core `human_input.attachments` 顶注:
+ * 「each attachment is delivered as its own message after the objective; its `message_committed` is the delivery」)。
+ * 所以一次带 N 只附件的提交会出 1 + N 次 `message_committed{role:"user"}`,而「回到这条提问」的锚要的是**人的那条**
+ * (core 的 `resumeAt` 认它:「a `resumeAt` that keeps the message keeps its group」;以附件帧作 `resumeAt` 引擎拒 `resume_at.not_a_message`),
+ * 不是排在最后的附件帧。目标**之前**还可能有引擎排队的注入消息同批提交(亲读 core `engine/harness/agent-harness.js` 的 `takePrompts`:
+ * 排队消息 ⇒ 目标 ⇒ 附件帧;真案 = 工作区是 git 仓且带图时,git 状态帧单独排在目标前面),所以「窗口里第一次用户提交」不是判据。
+ *
+ * **为什么是「窗口 + 严格吻合」而不是读标记**:`message_committed` 上只有 `entryId / role / toolCallId?`,附件帧与用户真提交在事件上**不可辨认**;
+ * 落盘的行上有标记(`attachment` 键;引擎收尾的中断标记带 `provenance: "engine-note"`),但事件到手的那一刻本仓读不到那一行
+ * (会话店面没有按条目读的口,只有整日志导出),所以只能数。数的前提是「目标之后紧接恰好 N 只帧、其后才是别的」—— 前提成立才落锚,
+ * **不成立就不猜**:猜错的锚会落在附件帧上(引擎拒)或引擎的中断标记上(回到的不是用户那句)。
+ *
+ * 读法:
+ *  · `human_input{delivery:"applied"}` 带 N 只附件 ⇒ 开窗;窗内的用户提交只攒、不落锚(此刻还不知道它们是不是『目标 + N 只帧』)。
+ *  · 窗被**非用户提交**(第一次助手消息 / 工具结果)关上 ⇒ 窗内共 k 次用户提交,k ≥ N+1 时提问 = 倒数第 N+1 次(严格吻合);k < N+1(帧数不符)⇒ 不猜。
+ *  · 窗被 `turn_end` 先切断 ⇒ 第一次模型调用没出任何提交就收了(halt / interrupt / 空失败):窗里可能夹着引擎收尾的中断标记,数 N 会落在帧或标记上 ⇒ 不猜。
+ *  · 窗内又应用了一条别的输入(`human_input{applied}`,如第一次模型调用前排进来的 steer;事件先于它的正文提交到手)⇒ 窗里多了一条别人的消息,数 N 会落在帧上 ⇒ 窗作废、不猜,
+ *    之后的用户提交(含那条 steer 正文)是窗口之外的提交,最后一次赢。排队未应用(`delivery: "queued"`)的输入不动窗。
+ *  · 「不猜」= 返回 `undefined`、这次提交不落锚;拿这次 run 的 taskId 去 `resumeAt` 得 404 `resume_at.unknown_event`(文案点名这一类成因)。
+ *    窗口之外的用户提交(如 interrupt 带话的 steer 正文,在 `turn_end` 之后提交)照修前读法(是提问,最后一次赢)。
+ * 返回这次提交之后的提问 `entryId`(调用方照旧「最后一次赢」地落锚),不是提问相关的提交返回 `undefined`。
+ *
+ * 退役条件:引擎在落盘的帧上(`message_committed`)带上附件标记之日,本读法整体换成「按标记判一次」(零计数、无窗口、无拒臂),
+ * 窗口 / 严格吻合 / 不猜三臂与 `resume_at.unknown_event` 文案里对应的那一句一并删除。
+ */
+export declare function createPromptCommitReader(): (ev: {
+    readonly type: string;
+}) => string | undefined;
 export declare class TurnAnchorCapture {
     private readonly capture;
     private readonly onCaptureFail?;
@@ -151,6 +183,8 @@ export declare class TurnAnchorCapture {
     /** The turn's FIRST text_delta eventId = the message's stable resume handle (also stamped on the durable text event). */
     firstTextEventId: string | undefined;
     private turnHadTool;
+    /** 用户提交是不是提问的唯一读法({@link createPromptCommitReader};附件帧不是提问)。 */
+    private readonly promptCommit;
     constructor(capture: ((eventId: string) => Promise<void>) | undefined, onCaptureFail?: (() => void) | undefined, 
     /** R8 (CC-parity rewind): capture a USER-message anchor straight from the
      *  `message_committed{role:"user"}` event — its `entryId` is the persisted user-message `SessionTreeEntry.id`,
@@ -160,9 +194,15 @@ export declare class TurnAnchorCapture {
      *  Keyed by the run's taskId (the handle the shell already holds from the POST response — no eventId→entryId
      *  side map / no `getLeafId` inference needed). The assistant-turn capture above stays as an additive bonus. */
     captureUser?: ((entryId: string) => Promise<void>) | undefined);
+    /** A `human_input` arrived — the objective's declared attachments open the frame window of {@link createPromptCommitReader}. */
+    onHumanInput(ev: {
+        readonly type: string;
+    }): void;
     /** A `message_committed` arrived — capture a USER-message rewind anchor (CC parity). Best-effort (a failure only
-     *  makes that one prompt non-rewindable). Only `role==="user"`; assistant/toolResult committed entries are handled
-     *  by the turn-text path (assistant) or deliberately not anchored (toolResult — `resumeAt` rejects them). */
+     *  makes that one prompt non-rewindable). Only a user commit that is a PROMPT (not an attachment frame trailing the
+     *  objective — {@link createPromptCommitReader}; an attachment window is decided when a non-user commit closes it, so
+     *  the anchor of an attachment-carrying prompt lands on THAT call); assistant/toolResult committed entries are handled by
+     *  the turn-text path (assistant) or deliberately not anchored (toolResult — `resumeAt` rejects them). */
     onMessageCommitted(role: string | undefined, entryId: string | undefined): Promise<void>;
     /** A text_delta arrived — latch the first DEFINED eventId as the message handle (eventId is optional on the stream). */
     onText(eventId: string | undefined): void;

package/dist/runs.js

@@ -76,6 +76,7 @@ const PREPARE_REFUSAL_HTTP_STATUS = {
     "config.skill_listing_budget_invalid": 400,
     "config.user_invoked_skill_unknown": 400,
     "config.image_invalid": 400,
+    "config.user_attachment_invalid": 400,
     "config.tool_face_control": 400,
     "config.memory_capture_unsupported": 409,
 };
@@ -109,20 +110,58 @@ export async function releaseKeyIfZeroWorkRefusal(runStore, taskId, result) {
     if (syncRefusalHttpStatus(result) !== undefined)
         await runStore.releaseIdemKey(taskId);
 }
+export function createPromptCommitReader() {
+    let attachmentWindow;
+    return (ev) => {
+        if (ev.type === "human_input") {
+            const h = ev;
+            if (h.delivery !== "applied")
+                return undefined;
+            attachmentWindow = Array.isArray(h.attachments) && h.attachments.length > 0 ? { frames: h.attachments.length, commits: [] } : undefined;
+            return undefined;
+        }
+        if (ev.type === "turn_end") {
+            attachmentWindow = undefined;
+            return undefined;
+        }
+        if (ev.type !== "message_committed")
+            return undefined;
+        const c = ev;
+        const entryId = typeof c.entryId === "string" && c.entryId.length > 0 ? c.entryId : undefined;
+        if (c.role === "user") {
+            if (attachmentWindow !== undefined) {
+                attachmentWindow.commits.push(entryId);
+                return undefined;
+            }
+            return entryId;
+        }
+        const closed = attachmentWindow;
+        attachmentWindow = undefined;
+        if (closed === undefined || closed.commits.length < closed.frames + 1)
+            return undefined;
+        return closed.commits[closed.commits.length - 1 - closed.frames];
+    };
+}
 export class TurnAnchorCapture {
     capture;
     onCaptureFail;
     captureUser;
     firstTextEventId;
     turnHadTool = false;
+    promptCommit = createPromptCommitReader();
     constructor(capture, onCaptureFail, captureUser) {
         this.capture = capture;
         this.onCaptureFail = onCaptureFail;
         this.captureUser = captureUser;
     }
+    onHumanInput(ev) {
+        this.promptCommit(ev);
+    }
     async onMessageCommitted(role, entryId) {
-        if (role === "user" && entryId && this.captureUser) {
-            await this.captureUser(entryId).catch(() => this.onCaptureFail?.());
+        const committed = { type: "message_committed", role, entryId };
+        const prompt = this.promptCommit(committed);
+        if (prompt !== undefined && this.captureUser) {
+            await this.captureUser(prompt).catch(() => this.onCaptureFail?.());
         }
     }
     onText(eventId) {
@@ -135,6 +174,7 @@ export class TurnAnchorCapture {
         this.turnHadTool = true;
     }
     async onTurnEnd() {
+        this.promptCommit({ type: "turn_end" });
         if (this.firstTextEventId && !this.turnHadTool && this.capture) {
             await this.capture(this.firstTextEventId).catch(() => this.onCaptureFail?.());
         }
@@ -373,6 +413,9 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     case "status":
                         metrics?.inc("brain_retry_total", { phase: String(ev.phase) });
                         break;
+                    case "human_input":
+                        anchor.onHumanInput(ev);
+                        break;
                     case "message_committed":
                         await anchor.onMessageCommitted(ev.role, ev.entryId);
                         break;

package/dist/spec-fields.d.ts

@@ -51,7 +51,7 @@ export declare const MAX_TASK_AGENTS = 32;
  * `ruleEntryListShapeOk`):引擎直接 `for (const entry of list)` —— 一个裸字符串 `"Bash"` 会被逐字符迭代成 `B` / `a` / `s` / `h` 四条
  * (deny 侧 = 意图静默落空,安全轴上的放宽方向)。条目的**文法与名字**是引擎的读法:允侧读不出的条目(`*` / 写路径 / 域名 / 退役名 …)引擎在开跑时发
  * `permission.allowed_tool_not_granted`(受众 = 用户);拒侧读成空的条目(文法或名字层)在 `resolveSpec` 拒(提交 400 / 续跑 409,`rule-entry-list.ts` 的
- * `skillDenyInertEntryOf`,判据 = 引擎的条目读法)。形对之后两道门再问 {@link skillToolListRefusal}(条数帽 ⇒ 400)。
+ * `inertToolListEntryOf`,判据 = 引擎的条目读法;同一只函数也拒请求的工具名选择器清单里的近似名 / 退役名)。形对之后两道门再问 {@link skillToolListRefusal}(条数帽 ⇒ 400)。
  * 条数帽 = 条目表那一只(`rule-entry-list.ts` `allowLayerEntryCountIssue`,准备开销的界;与请求 allow 桶、运维表同一只),
  * 在 {@link skillToolListRefusal} 里判;无长度帽([ref])。
  */
@@ -67,12 +67,16 @@ export declare function skillToolListRefusal(skill: Record<string, unknown>): st
  *  白名单外键 fail-loud —— 与 resilience/limits 的「容忍未知键」相反:agents 是能力定义,静默丢字段 =
  *  定义被悄悄削(一个丢掉的 isolation 就是放宽),比 400 更危险,故整条拒。`allowTools` / `denyTools` 本门只判形与条数(`toolList`),
  *  **名字归引擎一只判**(core 7.49.0 #1623 / #1433 第二步起与根 run 的 `allowTools` / `excludeTools` 是同一只选择器,开跑前,三来源同判):core 7.51.0 #1736 起
- *  没有任何工具答应的名字(无人挂的名、大小写孪生 / 退役名 `bash` / `BASH`)**不拒 run** —— 条目原样保留、经 onError(config)告知一次(带该写的拼法);
- *  只有任何工具名都不可能有的拼法(`grammar`)与非字符串条目 ⇒ 整 run 拒 `config.agent.unknown_tool` —— 主车道的委派工具带 extraTools 工厂,本仓在同一处
+ *  没有任何工具答应的名字(无人挂的名、大小写孪生 / 退役名 `bash` / `BASH`)**引擎不拒 run** —— 条目原样保留、经 onError(config)告知一次(带该写的拼法);
+ *  其中**写错现名的**(`denyTools:["BASH"]` 想禁的照用 = 静默放行;`allowTools:["BASH"]` 想放的什么也没放 = 静默收窄)由 `resolveSpec` 前置拒:**限制侧**(`denyTools`)四类全拒(近似名 · 退役名 · 文法读不出 · `*`),
+ *  **放行侧**(`allowTools`)只拒近似名 —— 放行侧的退役名 / 内容形 / 文法读不出照 7.130.0 受理、交引擎既有通告(文法读不出的放行条目引擎在子代 prepare 整 run 拒 `config.agent.unknown_tool`,根 `allowTools` 同步腿 400 `config.tool_face_control`;`rule-entry-list.ts` `inertToolListEntryOf`:近似名提交 400 `config.agent.unknown_tool` 点名现名、续跑按方向分流;
+ *  判官仍是引擎的条目读法,不是第二个判官);
+ *  **真未知名**(没有近似也没有退役对应:懒挂载的合法形)照旧只告运维、不拒。
+ *  任何工具名都不可能有的拼法(`grammar`)与非字符串条目引擎照旧整 run 拒 `config.agent.unknown_tool` —— 主车道的委派工具带 extraTools 工厂,本仓在同一处
  *  声明它的名册(core 7.46.0 `extraToolNames`;工厂与名册读同一批工具对象,`capabilities/builtin-tools.ts` `createSubagentExtraTools`),引擎因此列得出子代工具池。
  *  两张表管子代可挂载的**全部**工具:委派池、hands 内建、引擎自己的工具(`Monitor` / `Artifact` / `Skill` / 记忆工具 …)与父的 MCP 挂载 ——
  *  `denyTools:["Monitor"]` ⇒ 子代没有 `Monitor`;`allowTools` 只点了调用方工具 ⇒ 子代只剩那几只与它这条腿的协议工具。`denyTools` 的 `Tool(content)` ⇒ 整只工具。
- *  本仓不在受理口另做名字对照(那会是同一问的第二个判官)。
+ *  本门不做名字对照(拒侧的那一判在 `resolveSpec`,见上;本门只判形与条数)。
  *  ⚠️ 键判断必须 Object.hasOwn:`in` 走原型链,JSON 里的 "toString"/"constructor"/"__proto__" 键会被
  *  误判为白名单字段,随后 SHAPES[k].ok 不是函数 ⇒ TypeError(fresh 500 / resume 砖;cross-review 复现)。 */
 export declare function taskAgentIssue(item: unknown): string | null;

package/dist/stored-request-hooks-m20.d.ts

@@ -0,0 +1,23 @@
+import { type ParseHooksConfigResult, type RunnableHooksConfig } from "./hooks/hook-runner.js";
+/** 一次重读的产物:读者对剥键之后的文档的答案,与被剥掉的每个坐标(出门形,经契约包的脱敏出门)。 */
+export interface StoredHooksRereadM20Result {
+    readonly config: RunnableHooksConfig;
+    readonly stripped: readonly string[];
+}
+/** 重读座:存下的 `settings.hooks` 原值 → 迁移产物(`undefined` = 不迁移,调用方走原臂)。 */
+export type StoredHooksRereadM20 = (raw: unknown) => StoredHooksRereadM20Result | undefined;
+/** 读者(= `parseHooksConfig`);作形参只为让「读者交回什么拒因」可被替身喂(默认值就是生产读者)。 */
+export type HooksReader = (raw: unknown) => ParseHooksConfigResult;
+/**
+ * 重读一份存体 hooks:读者拒因全部属于两形 ⇒ 剥掉被点名的块里按类型确属未知的键、再问读者,**剥到读者受理为止**,过了就交回产物 + 被剥坐标;否则 `undefined`(原臂:整份不采纳)。
+ * 调用方只在读者**已经拒过**这份原值之后才来问;读者一开始就受理的值不进这里(进来也返回 `undefined`:没有可迁移的东西)。
+ *
+ * 终止:循环体以一次读开头(最后一次剥键之后必有一次读);继续下一轮的条件是本轮真从文档里剥掉了至少一个对象键,文档只减不增 ⇒ 必停;同一块只会被点名一次 ⇒ 轮数 ≤ 被点名的块数 + `__proto__` 键数。
+ */
+export declare function rereadStoredHooksM20(raw: unknown, read?: HooksReader): StoredHooksRereadM20Result | undefined;
+/**
+ * 此刻(`today` = UTC 日历日 YYYY-MM-DD)M20 的窗开着 ⇒ 交回重读座;关了 ⇒ `undefined`(今天的读法)。窗只读登记表 M20 那一行
+ * (`migrationWindowOpen`,与 M10 / M19 同一只判据)。登记表里没有 M20 ⇒ 响亮抛:重读臂活过了它的登记行,该随那一行一起删。
+ */
+export declare function storedHooksRereadM20(today: string): StoredHooksRereadM20 | undefined;
+//# sourceMappingURL=stored-request-hooks-m20.d.ts.map

package/dist/stored-request-hooks-m20.js

@@ -0,0 +1,124 @@
+import { HOOK_ENTRY_TYPES } from "@sema-agent/settings-schema/hooks";
+import { hooksCoordinate, parseHooksConfig } from "./hooks/hook-runner.js";
+import { ONE_TIME_MIGRATIONS, migrationWindowOpen } from "./plugins/one-time-migrations.js";
+const ENTRY_FIELD_NAMES = {
+    command: { type: true, if: true, timeout: true, statusMessage: true, once: true, command: true, shell: true, async: true, asyncRewake: true },
+    prompt: { type: true, if: true, timeout: true, statusMessage: true, once: true, prompt: true, model: true },
+    agent: { type: true, if: true, timeout: true, statusMessage: true, once: true, prompt: true, model: true },
+    http: { type: true, if: true, timeout: true, statusMessage: true, once: true, url: true, headers: true, allowedEnvVars: true },
+    mcp_tool: { type: true, if: true, timeout: true, statusMessage: true, once: true, server: true, tool: true, input: true },
+};
+const MATCHER_FIELD_NAMES = { matcher: true, hooks: true };
+function isRecord(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function isEntryType(v) {
+    return typeof v === "string" && HOOK_ENTRY_TYPES.includes(v);
+}
+function nodeAt(node, path) {
+    let cur = node;
+    for (const seg of path) {
+        if (Array.isArray(cur))
+            cur = typeof seg === "number" ? cur[seg] : undefined;
+        else if (isRecord(cur) && typeof seg === "string")
+            cur = Object.hasOwn(cur, seg) ? cur[seg] : undefined;
+        else
+            return undefined;
+    }
+    return cur;
+}
+function contractFieldsOf(code, block) {
+    if (!isRecord(block))
+        return undefined;
+    if (code === "guard-matcher-invalid")
+        return MATCHER_FIELD_NAMES;
+    const type = Object.hasOwn(block, "type") ? block.type : undefined;
+    return isEntryType(type) ? ENTRY_FIELD_NAMES[type] : undefined;
+}
+function stripTargetsOf(piece, doc) {
+    const [root, ...rel] = piece.path;
+    if (root !== "hooks")
+        return undefined;
+    if ((piece.code === "unknown-event" || piece.code === "guard-under-unknown-event") && rel.length === 1 && rel[0] === "__proto__")
+        return [rel];
+    if ((piece.code === "guard-entry-invalid" || piece.code === "guard-matcher-invalid") && typeof piece.field === "string") {
+        const block = nodeAt(doc, rel);
+        const known = contractFieldsOf(piece.code, block);
+        if (known === undefined || !isRecord(block) || Object.hasOwn(known, piece.field) || !Object.hasOwn(block, piece.field))
+            return undefined;
+        return Object.keys(block)
+            .filter((key) => !Object.hasOwn(known, key))
+            .map((key) => [...rel, key]);
+    }
+    return undefined;
+}
+function cloneDoc(root) {
+    const isContainer = (v) => Array.isArray(v) || isRecord(v);
+    const shell = (v) => (Array.isArray(v) ? [] : isRecord(v) ? {} : v);
+    const copy = shell(root);
+    const pending = isContainer(root) ? [[root, copy]] : [];
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        const [source, target] = next;
+        if (Array.isArray(source)) {
+            for (const value of source) {
+                const child = shell(value);
+                target.push(child);
+                if (isContainer(value))
+                    pending.push([value, child]);
+            }
+        }
+        else if (isRecord(source)) {
+            for (const [key, value] of Object.entries(source)) {
+                const child = shell(value);
+                Object.defineProperty(target, key, { value: child, writable: true, enumerable: true, configurable: true });
+                if (isContainer(value))
+                    pending.push([value, child]);
+            }
+        }
+    }
+    return copy;
+}
+function removeKeyAt(doc, path) {
+    const key = path[path.length - 1];
+    const parent = nodeAt(doc, path.slice(0, -1));
+    if (!isRecord(parent) || typeof key !== "string" || !Object.hasOwn(parent, key))
+        return false;
+    delete parent[key];
+    return true;
+}
+export function rereadStoredHooksM20(raw, read = parseHooksConfig) {
+    const doc = cloneDoc(raw);
+    const stripped = [];
+    for (;;) {
+        const r = read(doc);
+        if (r.config !== undefined)
+            return stripped.length > 0 ? { config: r.config, stripped } : undefined;
+        const pieces = r.pieces;
+        if (pieces === undefined || pieces.length === 0)
+            return undefined;
+        const targets = [];
+        for (const piece of pieces) {
+            const pieceTargets = stripTargetsOf(piece, doc);
+            if (pieceTargets === undefined)
+                return undefined;
+            for (const target of pieceTargets)
+                targets.push(target);
+        }
+        let removedAny = false;
+        for (const target of targets) {
+            if (!removeKeyAt(doc, target))
+                continue;
+            stripped.push(hooksCoordinate(["hooks", ...target]));
+            removedAny = true;
+        }
+        if (!removedAny)
+            return undefined;
+    }
+}
+export function storedHooksRereadM20(today) {
+    const window = ONE_TIME_MIGRATIONS.find((w) => w.id === "M20");
+    if (window === undefined)
+        throw new Error("stored-request-hooks-m20: the one-time migration registry has no M20 row (the replay-leg stored-hooks re-read window) — the re-read arm outlived its registry row; delete it with that row");
+    return migrationWindowOpen(window, today) ? (raw) => rereadStoredHooksM20(raw) : undefined;
+}
+//# sourceMappingURL=stored-request-hooks-m20.js.map

package/dist/stored-request-tool-axes-m19.d.ts

@@ -11,7 +11,7 @@
  *
  * ## 可达面(结构上只在续跑重放腿)
  *  · 本模块的值只被 `boot/resolve-spec.ts` 引用一处,挂在 `opts.leg` 不是 `"fresh"` 的那一臂(续跑家族经 `http/resume-legs.ts` 的 `resolveResumeSpec`
- *    递 `leg: "resume"`);新提交腿递 `"fresh"` 拿不到重读座,且在腿首已经被同一只判官 400 掉(`assertRequestMcpToolAxes`),读器根本见不到坏形;
+ *    递 `leg: "resume"`);新提交腿递 `"fresh"` 拿不到重读座,且在腿首已经被同一只判官 400 掉(`assertRequestMcpEntries`),读器根本见不到坏形;
  *  · 请求腿(`task-mcp.ts`)只 import 本模块的**型**:重读座是 `resolveRequestMcp` 的一个形参,没人递就没有;探测口(`validateRequestMcp`)没有这个形参;
  *  · 部署腿(`web-admin-client/skills-mcp.ts` 的 `resolveMcpServers`)是另一只铸 spec 处,不读本模块。
  * 机器锚:`test/mcp-tool-axes-m19.test.ts` 的结构格。

package/dist/task-mcp.d.ts

@@ -64,6 +64,10 @@ export declare const MAX_REQUEST_MCP_DROP_NAMES = 32;
  *  · 探测口**响亮拒**(400,点名 `mcpServers[i].<键>`)—— 它问的是「这台到底能不能用」,把一个拼错的键
  *    悄悄忽略再回一份好看的名单,正是那条面要根除的假答案。
  * 两个门,一个词表。表在这里,门在各自的腿上。
+ *
+ * ## 受理键的判官表也钉在这张表上
+ * fresh 提交腿对**受理键的值**同样响亮拒({@link assertRequestMcpEntries}):逐键判官表 {@link ENTRY_KEY_JUDGES} 是 `{ [K in 本表的键]: 判官 }` 的映射型 ——
+ * 本表多一个键而没写判官 ⇒ 编译红,不会出现「这个键写坏了却被悄悄受理」的新键。词表外的键仍由读器宽容、由探测口闭集拒(上面两条不变)。
  */
 export declare const MCP_SERVER_ENTRY_KEYS: readonly ["allowTools", "contentOrigin", "elicitation", "name", "source", "toolAxes", "toolFaces", "transport"];
 /** `transport.kind:"stdio"` 的键闭集(两向钉在 core 那一支上)。 */
@@ -145,92 +149,52 @@ type ValidatedRequestMcp = {
  * 任务。同样是失败,同步 400 至少是**立刻可诊断**的那一种,而且拒得出理由(锁在哪、怎么改)。
  */
 export declare function assertRequestMcpUnlocked(bodyMcp: unknown, lockedKeys: ReadonlySet<LockedKey>): void;
-/**
- * [ref](core 5.60.0 提货批件②)—— 请求体里 `mcpServers[].contentOrigin` 的**值域门**,腿首同步拒。
- *
- * ## 先把 core 的硬条款抄下来,因为本腿的全部争议都在它上面
- * `McpServerSpec.contentOrigin` 顶注逐字:「TRUST SOURCE — a DEPLOYMENT-plane key … any assembly layer
- * that accepts REQUEST-side MCP entries **must reject or strip this key** from them … A single-tenant
- * superuser surface (a host reading its own `--mcp-config` file) **IS the deployment plane and needs no
- * such gate**.」
- *
- * ## 本仓怎么兑现这条义务(**结构性**,不是靠纪律)
- * 请求腿的条目只有在 {@link mcpInjectionHonored} 为真时才被读进 `TaskSpec.mcp`,而那只谓词的语义正是
- * 「本部署是单用户 ⇒ 请求者就是这台 worker 的超管」—— core 点名豁免的那一格。多租户部署
- * (`requirePrincipal===true`)整只 `mcpServers` 被忽略,租户**结构上**够不着这个键(钉见
- * `test/task-mcp.test.ts` 的多租户格)。同一条腿今天已经透传 `toolAxes`(喂**审批门**,权限比本键**高**
- * 一档 —— core 明写 contentOrigin「no gate/policy/roster effect」)与 stdio 的**任意命令**(worker 宿主
- * 上的真无限制执行);在那两样之后,「我声明我自己这台 server 的内容不算外来」不构成任何新的暴露面。
- * 名字撞车时 baseline 恒赢(`mergeRequestMcp`)⇒ 调用方也改写不了一台**已配置** server 的声明。
- *
- * ## 为什么 fresh 腿是 400 而不是静默丢键
- * 静默丢键会把一次**信任边界声明**变成探针 —— 调用方以为声明生效了,其实没有。本仓 `opts.leg` 的成文
- * 契约(`ServiceDeps.resolveSpec` 顶注)逐字写着 fresh 腿「may fail-loud 400 on combos that would
- * silently discard caller payload」,这正是那种 combo。
- *
- * ## 🔴 但只在 fresh 腿(与 {@link assertRequestMcpUnlocked} **刻意分歧**)
- * 锁那条敢在 resume 腿同拒,是因为它有一个本门**没有**的前提:锁在场 ⇒ core 的 preflight 无论如何都会
- * 拒这条腿,放进去只换来一个跑起来又终态失败的任务。而坏 `contentOrigin` 在本仓两个平面都被**降级**掉了
- * (`normalizeServer` / `resolveMcpServers`),core 根本看不到它,也就永远不会拒。
- * 与此同时 `checkpoint_ctx` 存的是**原始** `TaskRequestBody`,耐久 resume 逐字重放它,从本门逃出去的
- * `HttpError` 会被 `src/http/server.ts` 折成 `409 resume_blocked_by_policy` ⇒ 一条**升级前** park、body 里
- * 带着当时被静默忽略的坏值的任务,升级后**永久**恢复不了(codex 交叉复审 R1-[high],验真后采纳)。
- * ⇒ 照本仓成文的三处 `opts.leg` 先例(`appendSystemPrompt` 案 / `@model` 名单 [ref] 终裁 (a) /
- * `compactionModel` 案,都逐字写着「砖死 resume 比降级糟」):fresh fail-loud,resume 降级 + 留声
- * (留声点 = {@link resolveRequestMcp} 的 `mcp_content_class_dropped`)。挂点判据在 `boot/resolve-spec.ts`。
- *
- * ## 位置与射程
- * 排在腿首、`assertRequestMcpUnlocked` 旁边 —— **任何副作用之前**(附件绑定 / per-session cwd·env 写入;
- * 理由逐字见 `boot/resolve-spec.ts` 那两行的注)。判据是**纯值域**、与**租户车道**无关:一个写坏的请求
- * 在哪条车道上都是写坏的,而多租户腿本来就要忽略整只数组,告诉调用方「你这个键写错了」只多不少。
- * 形不合(非数组 / 条目非对象)**不归本门**——那是 `validateRequestMcp` 的既有宽容形,本门不抢裁决。
- */
-export declare function assertRequestMcpContentOrigin(bodyMcp: unknown): void;
-/**
- * S-1515 —— `mcpServers[].transport`(http)上两个身份头的**值域门**(fresh 腿限定,同步 400):`principalHeader` 与 `assertionHeader`
- * **同设**(`request.body_shape`),或 `assertionHeader` 在场而**不是字符串**(`request.field_invalid`)。
- *
- * 前者:两个键回答同一个问题(「这台 http 服务器的请求上用哪个头送身份」),同设 = 两个答案。settings 面由契约包在解析期判拒;
- * 请求面在这里判拒 —— **同一条规则、两处执行者**,判据与拒句单点在 `mcp-assertion-header.ts`(对契约包原句逐字,差分钉守)。
- * 后者:契约包的 zod 类型拒它;请求面若把它读成"没写过",一条鉴权声明就无声消失、server 却照常挂上去连。
- *
- * ## 位置与 leg 分流(与 {@link assertRequestMcpContentOrigin} 同款理由,不发明第二套)
- * 排在腿首、任何副作用之前;**只在 fresh 腿**:`checkpoint_ctx` 存的是原始 `TaskRequestBody`,耐久 resume 逐字重放它,
- * 从这里逃出去的 `HttpError` 会被折成 `409 resume_blocked_by_policy`,把一条 park 任务永久砖死。resume 腿走读器
- * ({@link normalizeServer}):**降级到升级前的读法**(server 照挂、`principalHeader` 胜、`assertionHeader` 不生效)+ `classifyHonored` 一行 warn ——
- * 不拒、也不摘 server。判据是纯值域、与租户车道无关(多租户腿本来就忽略整只数组,告诉调用方「你这条写错了」只多不少)。
- */
-export declare function assertRequestMcpIdentityHeaders(bodyMcp: unknown): void;
 /** 一条**原始**请求条目上两个身份头的问题类(没有问题 / 不是对象 / 不是 http 传输 ⇒ `undefined`)—— 提交腿的门、探测口、重放腿的披露三处共读,
  *  判据本体在 `mcp-assertion-header.ts`;这里只负责把「条目 → 传输对象」那一步读出来。 */
 export declare function requestEntryIdentityIssue(entry: unknown): McpIdentityHeadersIssue | undefined;
-/** 问题类 → wire 拒面(码 + 句子):两扇拒绝门(提交腿 / 探测口)同一份。条目名进句子,过唯一的回显清洗(剥控制 / 双向字符 + 截长);
- *  读不出名字的条目用与丢弃点同一个占位。 */
-export declare function requestEntryIdentityRefusal(entry: unknown): {
+/** 问题类 → wire 拒面(码 + 句子):两扇拒绝门(提交腿 / 探测口)同一份。`both_set` 是键**组合**不合法(`request.body_shape`),句子对契约包解析期原句逐字,条目名过唯一的回显清洗
+ *  (剥控制 / 双向字符 + 截长;读不出名字的条目用与丢弃点同一个占位);`assertionHeader` 非串是该键的值不合法,与其余所有受理键同一个拒形({@link entryFieldRefusal},点名 `<at>.transport.assertionHeader`)。 */
+export declare function requestEntryIdentityRefusal(entry: unknown, at: string): {
     errorCode: "request.body_shape" | "request.field_invalid";
     message: string;
 } | undefined;
 /**
- * S-1604 —— `mcpServers[].toolAxes` 的**值域门**(fresh 腿限定,同步 400):判官是引擎根导出的 `readMcpToolAxes`(与部署腿铸 spec 处同一只),
- * 判出 `ok:false` ⇒ `400 request.field_invalid`,点名 `mcpServers[i].toolAxes`、server 名与引擎的原因句(点名工具与成员,不带值)。
- *
- * ## 为什么拒而不是剔
- * `toolAxes` 是调用方对这台 server 每只工具的**双向**风险轴声明(能压低一只工具的效应让审批门放行,也能抬高)。静默剔掉坏成员 = 调用方拿到 2xx、
- * 以为整份声明生效,实际只有另一半在力 —— 一份没有生效的信任根声明。引擎的读法本就是「整份一坏全拒、好的那几只也不留、什么都不默认」,
- * 请求腿修前自铸的读者与它相反;从此只有一只判官,两条腿同读。
- *
- * ## 位置与 leg 分流(与 {@link assertRequestMcpContentOrigin} / {@link assertRequestMcpIdentityHeaders} 同款理由,不发明第二套)
- * 排在腿首、任何副作用之前;**只在 fresh 腿**:`checkpoint_ctx` 存的是原始 `TaskRequestBody`,耐久 resume 逐字重放它,从这里逃出去的 `HttpError`
- * 会被折成 `409 resume_blocked_by_policy`,把一条升级前 park 的任务永久砖死。resume 腿走读器({@link normalizeServer}):同一只判官判出坏形 ⇒ 这一条 server
- * 不进 + `malformed_entry` 点名(运维 warn + 用户面通告,不抛);一次性迁移 M19 的窗开着时先按升级前读法重读一次(见那只读器的注)。
- * 判据是纯值域、与租户车道无关(多租户腿本来就忽略整只数组,告诉调用方「你这条写错了」只多不少)。
- * 探测口读同一只 {@link requestEntryToolAxesRefusal},同一句拒。
+ * S-1629 —— 请求体 `mcpServers[i]` **每个受理键**的值域门(fresh 腿限定,同步 400):**一条律**,取代此前按键各开一扇的三道门
+ * (`contentOrigin` / 身份头 / `toolAxes`)与其余键上「整条悄悄摘掉」「悄悄丢键」两种沉默。
+ *
+ * ## 律
+ * fresh 提交腿上,条目的**任一受理键**写坏 ⇒ `400 request.field_invalid`,拒句点名 `mcpServers[i].<键路径>`、server 名与**该键判官的原因句**。
+ * 不挂一半、不丢声明、不默认:调用方是请求体作者,同一扇门对同一类错误只有一种答案。修前同一条条目上有三种(`toolAxes` / `contentOrigin` 坏 ⇒ 400;
+ * `allowTools` / `toolFaces` / `name` / `transport` 坏 ⇒ 200 + 整条 server 不进 + 运维 warn;`elicitation` / `source` / `transport.{args,env,headers,principalHeader}`
+ * 坏 ⇒ 200 + 悄悄丢键),而「两个键方向相反所以处置不同」只是读器**对存量 body** 的取舍({@link normalizeServer}),不是给在场调用方的答复该有的差别:
+ * 对一个 fresh 调用方,「收窄声明没生效」与「放宽声明没生效」同样是一份没有生效的声明,响亮拒比两种沉默都好。
+ *
+ * ## 每个键一只判官({@link ENTRY_KEY_JUDGES},表的键集两向钉在 `MCP_SERVER_ENTRY_KEYS` 上:新增受理键而没写判官 ⇒ 编译红)
+ * 判官**就是读器用的那一只**,不是第二份:`toolAxes` = 引擎根导出的 `readMcpToolAxes`;`toolFaces` = `readMcpToolFaces`;`contentOrigin` = `isContentOriginWord`;
+ * `source` = `isMcpSourceLabel`;`name` = `isUsableWireName`;`allowTools` / `transport.args` = {@link isStringArray};`transport.env` / `headers` = {@link isStringRecord};
+ * `elicitation` = {@link isElicitationFlag};`transport` 的硬字段(`kind` / `command` / `url`)与软字段(`args` / `env` / `headers` / `principalHeader`)= {@link readRequestTransport}
+ * (读器投影 transport 的那一只函数,门读它报的 `lost`)。两个身份头的**键组合**(同设 / `assertionHeader` 非串)仍归 `mcp-assertion-header.ts` 的判官({@link requestEntryIdentityRefusal},
+ * 码 `request.body_shape` 的那一句对契约包原句逐字),在逐键之前先判。
+ *
+ * ## 位置与 leg 分流(沿用本仓成文的 `opts.leg` 姿势,不发明第二套)
+ * 排在腿首、`assertRequestMcpUnlocked` 旁边 —— **任何副作用之前**(①阶段会把附件行持久绑定到 session,②阶段会写 per-session 的 cwd/env 表;一个最终 400 的请求若已经改掉这两样,
+ * 它就改变了后续被接受的任务会物化什么、在哪执行)。**只在 fresh 腿**:`checkpoint_ctx` 存的是**原始** `TaskRequestBody`,耐久 resume 逐字重放它,从这里逃出去的 `HttpError`
+ * 会被 `src/http/server.ts` 折成 `409 resume_blocked_by_policy` ⇒ 一条**升级前** park、body 里带着当时被受理的坏值的任务,升级后永久恢复不了
+ * (本仓三处 `opts.leg` 先例 —— `appendSystemPrompt` 案 / `@model` 名单 [ref] 终裁 (a) / `compactionModel` 案 —— 逐字写着「砖死 resume 比降级糟」)。
+ * 重放腿走读器({@link normalizeServer}),处置**逐字不变**:坏硬键(`name` / `transport` 硬字段 / `allowTools` / `toolAxes` / `toolFaces`)⇒ 这一条 server 整条不进 + 运维 warn
+ * `mcp_injection_dropped` + 用户面通告 `mcp.injection_dropped` 点名 `field`(`toolAxes` 在一次性迁移 M19 的窗开着时先按升级前读法重读一次,过了就挂,见读器的注);坏软键(`contentOrigin` / `elicitation` / `source` / `transport` 软字段)⇒ 丢键、server 照挂(`contentOrigin` 另有 `mcp_content_class_dropped` 留声)。
+ *
+ * ## 射程
+ * 判据是**纯值域**、与租户车道无关:一个写坏的请求在哪条车道上都是写坏的,而多租户腿本来就忽略整只数组,告诉调用方「你这个键写错了」只多不少。
+ * 只判前 `MAX_REQUEST_MCP_SERVERS` 条(能被挂载的那一段,与读器同一个切片)。不在本门的:条目本身不是对象 / `mcpServers` 不是数组(`validateRequestMcp` 的既有宽容形)、词表外的键(读器对未知键宽容,探测口才闭集)、超上限的尾项(`over_cap` 点名;它们不挂载,为一个永远不会生效的声明拒掉整份请求是新开一条拒绝面)。
+ * 关于 `contentOrigin` 的信任语义(core 把它定性为**部署面**键):请求腿的条目只有在 {@link mcpInjectionHonored} 为真(单用户 = 请求者就是这台 worker 的超管)时才被读进 `TaskSpec.mcp`,
+ * 多租户部署整只数组被忽略 ⇒ 租户**结构上**够不着这个键;名字撞车时 baseline 恒赢({@link mergeRequestMcp})⇒ 调用方也改写不了一台**已配置** server 的声明。
  */
-export declare function assertRequestMcpToolAxes(bodyMcp: unknown): void;
+export declare function assertRequestMcpEntries(bodyMcp: unknown): void;
 /**
- * 一条**原始**请求条目上 `toolAxes` 的拒面(码 + 句子);没有问题 / 条目不是对象 / 没写 `toolAxes` ⇒ `undefined`。提交腿的门({@link assertRequestMcpToolAxes})与探测口
- * (`mcp-probe.ts` 的 `entryValueIssue`)两扇拒绝门同读这一只,所以两处是**同一句**。判官是引擎的 `readMcpToolAxes`,句子里的原因句逐字取它的 `problem`
- * (只剥控制与双向字符:工具名是调用方写的);不回显值 —— 引擎的句子点名工具与成员、不带值。`at` = 条目的键路径(`mcpServers[3]`)。
+ * 一条**原始**请求条目上 `toolAxes` 的拒面(码 + 句子);没有问题 / 条目不是对象 / 没写 `toolAxes` ⇒ `undefined`。探测口(`mcp-probe.ts` 的 `entryValueIssue`)在它自己的通用读器之前读这一只,
+ * 所以 `toolAxes` 在两扇拒绝门上是**同一句**:判官 = {@link ENTRY_KEY_JUDGES} 的 `toolAxes` 格(引擎的 `readMcpToolAxes`),句子 = {@link entryFieldRefusal}(与 fresh 提交腿的每个键同一个形)。
+ * `at` = 条目的键路径(`mcpServers[3]`)。
  */
 export declare function requestEntryToolAxesRefusal(entry: unknown, at: string): {
     errorCode: "request.field_invalid";