@sema-agent/server 7.131.0 → 7.132.0

package/dist/sql-engine-posture.d.ts

@@ -24,9 +24,34 @@
  * 不在这里 —— 在 `sql-driver.ts` 的连接初始化里(TiDB 乐观模式设不成悲观 / 隔离级复核不符 ⇒ 响亮抛)。
  * 本模块在 boot 期借一条连接**触发**那次初始化,于是那句拒绝落在启动期而不是第一次业务写上。
  */
-import { type SqlEngineFacts } from "./plugins/sql-driver.js";
+import { type SqlEngineFacts, type SqlEngineReading } from "./plugins/sql-driver.js";
+import type { StoreBackend } from "./plugins/store-backend.js";
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
+/**
+ * 一只店后端交出的 SQL 池(至多一只:`mysqlPool()` 只在 MySQL 协议后端上有值,`pgPool()` 只在 PG 后端上;local 后端 / 没有后端 ⇒ 两个都 `undefined`)。
+ * **「SQL 后端在场」只有这一个谓词**:boot 期据它建立引擎读口({@link establishSqlEnginePosture}),`createHttpServer` 据它判「读口必填」——
+ * 两处读同一只函数,所以本服务自己的装配(有池 ⇒ 有读口)恒满足那道起服门,嵌入方少给读口则被它拒。
+ */
+export declare function sqlPoolsOf(backend: Pick<StoreBackend, "mysqlPool" | "pgPool"> | undefined): {
+    mysqlPool: MySqlPool | undefined;
+    pgPool: PgPool | undefined;
+};
+/**
+ * `ServiceDeps.sqlEngine` 座的**值形**判:`{ dialect: "tidb" | "pg", facts }`,`facts` 是 `null`(池上连接初始化还没成功)或一份引擎事实 —— 判到墙判官 `sqlWallsOf` 读的那几位
+ * (`maxRowBytes` / `maxPacketBytes` 是 `null` 或数,`wallSources` 两位是出处词)。一个函数(7.131.x 的事实读口 `() => facts` 只改了键名)、缺 `facts` 的对象、错方言词都不是它。
+ * `facts` 是活读(getter):这里读一次,判的是装配这一刻看得到的那一份。
+ */
+export declare function isSqlEngineReading(v: unknown): v is SqlEngineReading;
+/** 引擎读口座的装配问题(闭集;{@link sqlEngineSeatIssue} 的产物):`required` = SQL 后端在场而座缺席;`bad_shape` = 座在场但形不对。 */
+export type SqlEngineSeatIssue = "required" | "bad_shape";
+/**
+ * 🔴 **引擎读口座的装配判官**(`createHttpServer` 起服时调;两臂一只函数):
+ *  · 座在场 ⇒ 判值形({@link isSqlEngineReading}),不对 ⇒ `bad_shape`;
+ *  · 座缺席 ⇒ 看后端交没交出 SQL 池({@link sqlPoolsOf},与 boot 期建立读口同一个谓词):交了 ⇒ `required`(席缺席只表示「没有 SQL 后端」,不能被判官读成「没有墙」);没交 ⇒ 过。
+ * 都是 fail-closed:墙门只认这一席,席坏了或漏了,代价是每份超出库墙的体照样受理或每次提交 500,不是起服时一句话。
+ */
+export declare function sqlEngineSeatIssue(backend: Pick<StoreBackend, "mysqlPool" | "pgPool"> | undefined, sqlEngine: unknown): SqlEngineSeatIssue | undefined;
 /** 消费端窄投影(`GET /v1/capabilities` 的 `store.sql` 位;7.106.0 前是顶层 `sql`,S-866 ①)。`null` = 驱动此刻给不出事实 ⇒ `store.sql` 缺席。 */
 export interface SqlEngineCapability {
     engine: SqlEngineFacts["engine"];
@@ -34,8 +59,8 @@ export interface SqlEngineCapability {
     txnMode: SqlEngineFacts["txnMode"];
 }
 /**
- * Boot 期建立引擎事实:借一条池连接(初始化随之跑),再原样归还。返回一个 **live getter** —— 事实由
- * 驱动持有,重连后它会被下一次初始化刷新,快照会说谎。
+ * Boot 期建立引擎事实:借一条池连接(初始化随之跑),再原样归还。返回本池的**引擎读口**(驱动本身:方言 + 活的 `facts`)—— 事实由
+ * 驱动持有,重连后它会被下一次初始化刷新,快照会说谎;方言与事实同出这一只,写入要装进的墙(`sqlWallsOf`)只读它。
  *
  * 抛出 = 拒启:连接初始化拒绝了这个后端(TiDB 乐观模式设不成悲观、隔离级复核不符、服务器太旧读不出
  * `@@transaction_isolation`)。这条错**刻意不吞** —— 本仓所有 `FOR UPDATE` 判据都以它为前提。
@@ -43,7 +68,7 @@ export interface SqlEngineCapability {
 export declare function establishSqlEnginePosture(pools: {
     mysqlPool?: MySqlPool | undefined;
     pgPool?: PgPool | undefined;
-}): Promise<(() => SqlEngineFacts | null) | undefined>;
+}): Promise<SqlEngineReading | undefined>;
 /** operator 面 → 消费端面的窄投影(`version` 是运维料,刻意不进能力位:它只对排障有意义)。 */
 export declare function projectSqlEngineCapability(facts: SqlEngineFacts | null | undefined): SqlEngineCapability | null;
 //# sourceMappingURL=sql-engine-posture.d.ts.map

package/dist/sql-engine-posture.js

@@ -1,11 +1,46 @@
 import { mysqlDriver, pgDriver } from "./plugins/sql-driver.js";
+export function sqlPoolsOf(backend) {
+    return { mysqlPool: backend?.mysqlPool?.(), pgPool: backend?.pgPool?.() };
+}
+const DIALECT_WORDS = { tidb: true, pg: true };
+const WALL_SOURCE_WORDS = { reported: true, assumed: true };
+const isWallBytes = (v) => v === null || (typeof v === "number" && Number.isFinite(v) && v >= 0);
+const isWallSourceWord = (v) => typeof v === "string" && Object.hasOwn(WALL_SOURCE_WORDS, v);
+export function isSqlEngineReading(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const r = v;
+    if (typeof r.dialect !== "string" || !Object.hasOwn(DIALECT_WORDS, r.dialect))
+        return false;
+    if (!("facts" in v))
+        return false;
+    const facts = v.facts;
+    if (facts === null)
+        return true;
+    if (typeof facts !== "object")
+        return false;
+    const f = facts;
+    if (!isWallBytes(f.maxRowBytes) || !isWallBytes(f.maxPacketBytes))
+        return false;
+    const sources = f.wallSources;
+    if (typeof sources !== "object" || sources === null)
+        return false;
+    const src = sources;
+    return isWallSourceWord(src.maxRowBytes) && isWallSourceWord(src.maxPacketBytes);
+}
+export function sqlEngineSeatIssue(backend, sqlEngine) {
+    if (sqlEngine !== undefined)
+        return isSqlEngineReading(sqlEngine) ? undefined : "bad_shape";
+    const { mysqlPool, pgPool } = sqlPoolsOf(backend);
+    return mysqlPool !== undefined || pgPool !== undefined ? "required" : undefined;
+}
 export async function establishSqlEnginePosture(pools) {
     const driver = pools.mysqlPool ? mysqlDriver(pools.mysqlPool) : pools.pgPool ? pgDriver(pools.pgPool) : undefined;
     if (driver === undefined)
         return undefined;
     const conn = await driver.connect();
     conn.release();
-    return () => driver.facts;
+    return driver;
 }
 export function projectSqlEngineCapability(facts) {
     return facts == null ? null : { engine: facts.engine, isolation: facts.isolation, txnMode: facts.txnMode };

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

@@ -1,5 +1,5 @@
 /**
- * 一次性迁移 M19 —— 续跑重放腿上,升级前存下的请求体里引擎判官判不过的 `mcpServers[].toolAxes`,窗内按升级前的读法重读一次。
+ * 一次性迁移 M19 —— 续跑重放腿上,升级前存下的请求体里引擎判官判不过的 `mcpServers[].toolAxes` 与 `a2aPeers[].toolAxes`,窗内按升级前的读法重读一次。
  * 🔴 M19 · 窗口见 `plugins/one-time-migrations.ts` 的 ONE_TIME_MIGRATIONS 登记表(窗、删法、删后由谁接住只写在那一行)。
  *
  * ## 为什么要它(持久数据面)
@@ -9,17 +9,32 @@
  * ⇒ 永远批不过去。持久数据面不能「翻红」,所以给它一次性迁移:窗开着时,续跑重放腿把判官判不过的那一格按升级前的读法重读一次,产物**再交同一只判官**
  * (不过 ⇒ 原臂:整条不进);真挂上的这类 server 由请求腿说一行运维 warn `mcp_tool_axes_read_as_before_upgrade`。窗关之后回到今天的读法,删码零行为变化。
  *
+ * ## A2A 一面(同一种病,同一只重读座;core 7.53.0 #1835 提货批)
+ * core 7.53.0 起 A2A 请求腿的 `toolAxes` 读者也是引擎的判官(`readToolAxes(…, "a2a")`)。7.131.x 的 A2A 请求腿读者对每只 skill 的记录只挑三个轴、**多余成员静默忽略**、
+ * 照挂 ⇒ 存量体里带多余成员的那条对端,续跑重放时整条不进,停驻在它某只 skill 审批上的任务同样永远批不过去。同一只重读座覆盖它,律只有一句:**重读复现那一面升级前
+ * 的读法,一个成员都不多救** —— A2A 那一面交 {@link readA2aToolAxesAsServer7131M19}(7.131.x 的读者逐字:未知成员忽略;已知轴写坏 —— `effect` / `irreversibility` 出词表、
+ * `egress` 非布尔、某只 skill 的值不是对象、整份不是对象含 `null` —— ⇒ 那条对端当时就整条丢,重读照旧整条丢,不交判官),产物再交同一只判官;
+ * 真挂上的对端一行运维 warn `a2a_tool_axes_read_as_before_upgrade`。所以 7.131.x 当时没挂上的对端,窗内续跑也不挂(不扩大外部工具集)。
+ *
  * ## 可达面(结构上只在续跑重放腿)
  *  · 本模块的值只被 `boot/resolve-spec.ts` 引用一处,挂在 `opts.leg` 不是 `"fresh"` 的那一臂(续跑家族经 `http/resume-legs.ts` 的 `resolveResumeSpec`
  *    递 `leg: "resume"`);新提交腿递 `"fresh"` 拿不到重读座,且在腿首已经被同一只判官 400 掉(`assertRequestMcpEntries`),读器根本见不到坏形;
- *  · 请求腿(`task-mcp.ts`)只 import 本模块的**型**:重读座是 `resolveRequestMcp` 的一个形参,没人递就没有;探测口(`validateRequestMcp`)没有这个形参;
+ *  · 两条请求腿(`task-mcp.ts` / `task-a2a.ts`)只 import 本模块的**型**:重读座是 `resolveRequestMcp` / `resolveRequestA2a` 的一个形参,没人递就没有(`resolve-spec.ts`
+ *    求值一次、两腿同递那一份);探测口(`validateRequestMcp`)与 `validateRequestA2a` 没有这个形参;
  *  · 部署腿(`web-admin-client/skills-mcp.ts` 的 `resolveMcpServers`)是另一只铸 spec 处,不读本模块。
  * 机器锚:`test/mcp-tool-axes-m19.test.ts` 的结构格。
  */
 import type { McpServerSpec } from "@sema-agent/core";
 type ToolAxes = NonNullable<McpServerSpec["toolAxes"]>;
-/** 重读座:一份原始 `toolAxes` 声明 → 升级前的读法读出的那一份(`undefined` = 升级前读成「没声明」)。产物由调用方再交引擎判官。 */
-export type StoredToolAxesRereadM19 = (declared: unknown) => ToolAxes | undefined;
+/**
+ * 重读座:一份原始 `toolAxes` 声明 → **那一面**升级前的读法读出的那一份,产物由调用方再交引擎判官。两面各一只读者,因为两面升级前的读法不同:
+ *  · `mcp`(≤7.129.x 的 MCP 请求腿):`undefined` = 升级前读成「没声明」(server 照挂);升级前从不因 `toolAxes` 丢 server;
+ *  · `a2a`(7.131.x 的 A2A 请求腿):`undefined` 同上;`null` = 7.131.x 当时就把这条对端整条丢了 —— 重读不救活,调用方按原臂整条不进。
+ */
+export interface StoredToolAxesRereadM19 {
+    readonly mcp: (declared: unknown) => ToolAxes | undefined;
+    readonly a2a: (declared: unknown) => ToolAxes | undefined | null;
+}
 /**
  * 此刻(`today` = UTC 日历日 YYYY-MM-DD)M19 的窗开着 ⇒ 交回重读座;关了 ⇒ `undefined`(今天的读法)。窗只读登记表 M19 那一行
  * (`migrationWindowOpen`,与 M10 的认领窗同一只判据)。登记表里没有 M19 ⇒ 响亮抛:重读臂活过了它的登记行,该随那一行一起删。

package/dist/stored-request-tool-axes-m19.js

@@ -1,5 +1,8 @@
 import { ONE_TIME_MIGRATIONS, migrationWindowOpen } from "./plugins/one-time-migrations.js";
-import { isToolAxisIrreversibility, isToolEffect } from "./tool-axis-words.js";
+const TOOL_EFFECT_WORDS_M19 = ["read", "write", "idempotent"];
+const TOOL_AXIS_IRREVERSIBILITY_WORDS_M19 = ["always", "never"];
+const isToolEffect = (v) => typeof v === "string" && TOOL_EFFECT_WORDS_M19.includes(v);
+const isToolAxisIrreversibility = (v) => typeof v === "string" && TOOL_AXIS_IRREVERSIBILITY_WORDS_M19.includes(v);
 function readToolAxesAsServer7129M19(declared) {
     if (!declared || typeof declared !== "object" || Array.isArray(declared))
         return undefined;
@@ -18,10 +21,35 @@ function readToolAxesAsServer7129M19(declared) {
     }
     return Object.keys(axes).length > 0 ? axes : undefined;
 }
+function readA2aToolAxesAsServer7131M19(declared) {
+    if (!declared || typeof declared !== "object" || Array.isArray(declared))
+        return null;
+    const axes = {};
+    for (const [skill, ax] of Object.entries(declared)) {
+        if (!ax || typeof ax !== "object" || Array.isArray(ax))
+            return null;
+        const a = ax;
+        if (a.effect !== undefined && !isToolEffect(a.effect))
+            return null;
+        if (a.egress !== undefined && typeof a.egress !== "boolean")
+            return null;
+        if (a.irreversibility !== undefined && !isToolAxisIrreversibility(a.irreversibility))
+            return null;
+        const entry = {
+            ...(isToolEffect(a.effect) ? { effect: a.effect } : {}),
+            ...(typeof a.egress === "boolean" ? { egress: a.egress } : {}),
+            ...(isToolAxisIrreversibility(a.irreversibility) ? { irreversibility: a.irreversibility } : {}),
+        };
+        if (Object.keys(entry).length > 0)
+            axes[skill] = entry;
+    }
+    return Object.keys(axes).length > 0 ? axes : undefined;
+}
+const REREAD_M19 = { mcp: readToolAxesAsServer7129M19, a2a: readA2aToolAxesAsServer7131M19 };
 export function storedToolAxesRereadM19(today) {
     const window = ONE_TIME_MIGRATIONS.find((w) => w.id === "M19");
     if (window === undefined)
         throw new Error("stored-request-tool-axes-m19: the one-time migration registry has no M19 row (the replay-leg toolAxes re-read window) — the re-read arm outlived its registry row; delete it with that row");
-    return migrationWindowOpen(window, today) ? readToolAxesAsServer7129M19 : undefined;
+    return migrationWindowOpen(window, today) ? REREAD_M19 : undefined;
 }
 //# sourceMappingURL=stored-request-tool-axes-m19.js.map

package/dist/task-a2a.d.ts

@@ -42,6 +42,7 @@
  * 「广告了却拦不住」的那一类缺口。钉在 `test/task-a2a.test.ts`(含到货后该怎么改那一格的原地说明)。
  */
 import { type A2aServerSpec, type CompliancePosture } from "@sema-agent/core";
+import type { StoredToolAxesRereadM19 } from "./stored-request-tool-axes-m19.js";
 /** Bound on caller-supplied peers (anti-DoS; a real declaration names a handful of agents). */
 export declare const MAX_REQUEST_A2A_PEERS = 32;
 /** The deployment-facing shape this module reads. `lockedConfigKeys` is deliberately `readonly string[]`
@@ -69,6 +70,8 @@ export interface A2aGateConfig {
  * deployment with a broken posture keep advertising the capability (仓规:安全轴禁静默兜底).
  */
 export declare function a2aInjectionHonored(config: A2aGateConfig): boolean;
+/** 读这条对端的是哪条腿:`fresh` = 新提交;`resume` = 续跑重放升级前存下的请求体(`boot/resolve-spec.ts` 的 `opts.leg` 分流,同一个读法)。 */
+type A2aRequestLeg = "fresh" | "resume";
 /**
  * Shape-check the raw `body.a2aPeers`. `null` → a non-array (caller error; the route may 400). Otherwise the
  * valid subset + the names of dropped (malformed/over-cap) entries.
@@ -110,5 +113,10 @@ export declare function mergeRequestA2a(baseline: A2aServerSpec[] | undefined, g
 export declare function resolveRequestA2a(baseline: A2aServerSpec[] | undefined, bodyA2a: unknown, config: A2aGateConfig, logger?: {
     info?(m: string, meta?: unknown): void;
     warn(m: string, meta?: unknown): void;
-}): A2aServerSpec[] | undefined;
+}, 
+/** 哪条腿在读(`boot/resolve-spec.ts` 按 `opts.leg` 递;缺省 = 新提交,最严的读法):只决定 `headers` 里 `__proto__` 名成员的处置(见 {@link normalizeA2aPeer})。 */
+leg?: A2aRequestLeg, 
+/** 一次性迁移 M19 的重读座(窗口见 `plugins/one-time-migrations.ts` 登记表):只在续跑重放腿、只在窗开着时由 `boot/resolve-spec.ts` 递进来 —— 与 MCP 请求腿同一份。 */
+storedToolAxes?: StoredToolAxesRereadM19): A2aServerSpec[] | undefined;
+export {};
 //# sourceMappingURL=task-a2a.d.ts.map

package/dist/task-a2a.js

@@ -1,7 +1,8 @@
-import { resolveComplianceDenies } from "@sema-agent/core";
-import { isUsableWireName } from "./wire-name-bound.js";
+import { readToolAxes, resolveComplianceDenies } from "@sema-agent/core";
+import { isUsableWireName } from "@sema-agent/settings-schema";
 import { HttpError } from "./security.js";
-import { isToolAxisIrreversibility, isToolEffect } from "./tool-axis-words.js";
+import { readPlainStringRecord } from "./plain-string-record.js";
+import { echoKeyName } from "./request-key-closure.js";
 import { GOVERNANCE_HTTP_STATUS } from "./governance-http-status.js";
 export const MAX_REQUEST_A2A_PEERS = 32;
 export function a2aInjectionHonored(config) {
@@ -14,79 +15,83 @@ export function a2aInjectionHonored(config) {
     }
     return config.requirePrincipal !== true;
 }
-function isStringRecord(v) {
-    return !!v && typeof v === "object" && !Array.isArray(v) && Object.values(v).every((x) => typeof x === "string");
-}
 const HTTP_URL_RE = /^https?:\/\//i;
-function normalizeA2aPeer(e) {
+function normalizeA2aPeer(e, leg, storedToolAxes) {
+    const dropped = { spec: null };
     if (!e || typeof e !== "object")
-        return null;
+        return dropped;
     const o = e;
     if (!isUsableWireName(o.name))
-        return null;
+        return dropped;
     if (typeof o.url !== "string" || !HTTP_URL_RE.test(o.url))
-        return null;
+        return dropped;
     if (o.cardUrl !== undefined && (typeof o.cardUrl !== "string" || !HTTP_URL_RE.test(o.cardUrl)))
-        return null;
-    if (o.headers !== undefined && !isStringRecord(o.headers))
-        return null;
+        return dropped;
+    const headers = o.headers === undefined ? undefined : readPlainStringRecord(o.headers);
+    if (headers !== undefined && (!headers.ok || (headers.stripped.length > 0 && leg === "fresh")))
+        return dropped;
+    const lost = headers?.ok === true && headers.stripped.length > 0 ? { headersLost: headers.stripped.map((m) => echoKeyName("headers.", m.name)) } : {};
     if (o.principalHeader !== undefined && typeof o.principalHeader !== "string")
-        return null;
+        return dropped;
     if (o.allowSkills !== undefined && !(Array.isArray(o.allowSkills) && o.allowSkills.every((s) => typeof s === "string")))
-        return null;
+        return dropped;
     const spec = { name: o.name, url: o.url };
     if (typeof o.cardUrl === "string")
         spec.cardUrl = o.cardUrl;
-    if (isStringRecord(o.headers))
-        spec.headers = o.headers;
+    if (headers?.ok === true)
+        spec.headers = headers.record;
     if (typeof o.principalHeader === "string")
         spec.principalHeader = o.principalHeader;
     if (Array.isArray(o.allowSkills))
         spec.allowSkills = o.allowSkills;
     if (o.toolAxes !== undefined) {
-        if (!o.toolAxes || typeof o.toolAxes !== "object" || Array.isArray(o.toolAxes))
-            return null;
-        const axes = {};
-        for (const [skill, ax] of Object.entries(o.toolAxes)) {
-            if (!ax || typeof ax !== "object" || Array.isArray(ax))
-                return null;
-            const a = ax;
-            if (a.effect !== undefined && !isToolEffect(a.effect))
-                return null;
-            if (a.egress !== undefined && typeof a.egress !== "boolean")
-                return null;
-            if (a.irreversibility !== undefined && !isToolAxisIrreversibility(a.irreversibility))
-                return null;
-            const entry = {
-                ...(isToolEffect(a.effect) ? { effect: a.effect } : {}),
-                ...(typeof a.egress === "boolean" ? { egress: a.egress } : {}),
-                ...(isToolAxisIrreversibility(a.irreversibility) ? { irreversibility: a.irreversibility } : {}),
-            };
-            if (Object.keys(entry).length > 0)
-                axes[skill] = entry;
+        const axes = readToolAxes(o.toolAxes, "a2a");
+        if (!axes.ok && storedToolAxes !== undefined) {
+            const before = storedToolAxes.a2a(o.toolAxes);
+            if (before === null)
+                return dropped;
+            const again = readToolAxes(before, "a2a");
+            if (!again.ok)
+                return dropped;
+            if (again.toolAxes !== undefined)
+                spec.toolAxes = again.toolAxes;
+            return { spec, toolAxesReread: axes.problem, ...lost };
         }
-        if (Object.keys(axes).length > 0)
-            spec.toolAxes = axes;
+        if (!axes.ok)
+            return dropped;
+        if (axes.toolAxes !== undefined)
+            spec.toolAxes = axes.toolAxes;
     }
-    return spec;
+    return { spec, ...lost };
 }
 export function validateRequestA2a(raw) {
+    const v = validateRequestA2aEntries(raw, "fresh");
+    return v === null ? null : { ok: v.ok, dropped: v.dropped };
+}
+function validateRequestA2aEntries(raw, leg, storedToolAxes) {
     if (raw === undefined || raw === null)
-        return { ok: [], dropped: [] };
+        return { ok: [], dropped: [], toolAxesReread: [], headersLost: [] };
     if (!Array.isArray(raw))
         return null;
     const ok = [];
     const dropped = [];
+    const toolAxesReread = [];
+    const headersLost = [];
     for (const e of raw.slice(0, MAX_REQUEST_A2A_PEERS)) {
-        const v = normalizeA2aPeer(e);
-        if (v)
+        const { spec: v, toolAxesReread: reread, headersLost: lost } = normalizeA2aPeer(e, leg, storedToolAxes);
+        if (v) {
             ok.push(v);
+            if (reread !== undefined)
+                toolAxesReread.push({ peer: v.name, problem: reread });
+            if (lost !== undefined)
+                headersLost.push({ peer: v.name, lost });
+        }
         else
             dropped.push(e && typeof e === "object" && typeof e.name === "string" ? String(e.name).slice(0, 128) : "<malformed>");
     }
     if (raw.length > MAX_REQUEST_A2A_PEERS)
         dropped.push(`(+${raw.length - MAX_REQUEST_A2A_PEERS} over cap of ${MAX_REQUEST_A2A_PEERS})`);
-    return { ok, dropped };
+    return { ok, dropped, toolAxesReread, headersLost };
 }
 export function assertRequestA2aUnlocked(bodyA2a, lockedKeys) {
     if (!lockedKeys.has("a2a"))
@@ -104,20 +109,41 @@ export function mergeRequestA2a(baseline, gated) {
     const add = gated.filter((p) => !taken.has(p.name));
     return add.length === 0 ? baseline : [...(baseline ?? []), ...add];
 }
-export function resolveRequestA2a(baseline, bodyA2a, config, logger) {
+export function resolveRequestA2a(baseline, bodyA2a, config, logger, leg = "fresh", storedToolAxes) {
     if (bodyA2a === undefined || bodyA2a === null)
         return baseline;
     if (!a2aInjectionHonored(config)) {
         logger?.warn("a2a_injection_ignored", { reason: "gate_closed (per-request A2A peers honored only on a single-user, unlocked, compliance-permitted deployment)" });
         return baseline;
     }
-    const v = validateRequestA2a(bodyA2a);
+    const v = validateRequestA2aEntries(bodyA2a, leg, storedToolAxes);
     if (v === null) {
         logger?.warn("a2a_injection_ignored", { reason: "a2aPeers not an array" });
         return baseline;
     }
     if (v.dropped.length > 0)
         logger?.warn("a2a_injection_dropped", { dropped: v.dropped });
-    return mergeRequestA2a(baseline, v.ok);
+    const merged = mergeRequestA2a(baseline, v.ok);
+    const baselineNames = new Set((baseline ?? []).map((p) => p.name));
+    for (const r of v.toolAxesReread) {
+        if (baselineNames.has(r.peer))
+            continue;
+        logger?.warn("a2a_tool_axes_read_as_before_upgrade", {
+            peer: r.peer,
+            migration: "M19",
+            problem: r.problem,
+            note: "this replayed request was stored before the upgrade and the peer's toolAxes declaration does not pass the engine's reader; while one-time migration M19 is open it is read the way the pre-upgrade reader reads it (members that do not fit are dropped) and the peer stays mounted — once the window closes the same request leaves this peer unmounted",
+        });
+    }
+    for (const h of v.headersLost) {
+        if (baselineNames.has(h.peer))
+            continue;
+        logger?.warn("a2a_peer_headers_members_dropped", {
+            peer: h.peer,
+            lost: h.lost,
+            note: "this replayed request carries a headers member named \"__proto__\" for this peer (the engine refuses that name); the peer stays mounted with every other header as written, the named member left out. A new submission with the same peer leaves it unmounted",
+        });
+    }
+    return merged;
 }
 //# sourceMappingURL=task-a2a.js.map

package/dist/task-mcp.d.ts

@@ -37,10 +37,9 @@ export declare const MAX_REQUEST_MCP_SERVERS = 32;
  * ——同一条链上后续的正常事件全部排在它们后面。修前的名字数组把超上限折成**一条**聚合串,所以无界的
  * 是本批新写的那两个循环。
  *
- * 为什么不改成「数组太长就 400」(codex 的另一条建议,**未采纳**):今天 33 台的请求是**照常受理、挂前
- * 32 台**的,加一条新的拒绝面为了一个资源边界去改受理语义,爆炸半径比病本身大(而且 resume 腿重放存量
- * body 会当场砖死一批已 park 的任务——本仓 `opts.leg` 三处先例逐字写着「砖死 resume 比降级糟」)。
- * 有界点名两头都占:该说的仍然说得出,量级钉死在与挂载同阶。
+ * 新提交腿上超过 {@link MAX_REQUEST_MCP_SERVERS} 条的列表在腿首整份 400({@link requestMcpDeclarationRefusal}),走不到这里;
+ * 有界点名守的是**重放存量 body** 的腿(那条腿不拒 —— 砖死 resume 比降级糟,本仓 `opts.leg` 三处先例)与闸关腿:
+ * 存量 body 的长度只受当时的 HTTP 体上限约束,该说的仍然说得出,量级钉死在与挂载同阶。
  */
 export declare const MAX_REQUEST_MCP_DROP_NAMES = 32;
 /**
@@ -58,30 +57,20 @@ export declare const MAX_REQUEST_MCP_DROP_NAMES = 32;
  * (唯一一格不在 core 型上的键 = http 传输的 `assertionHeader`:引擎尚无座,本仓承载 —— 那一支的门钉在
  * `mcp-assertion-header.ts` 的 {@link RequestMcpServerSpec} 上,引擎一旦长出同名座,那里的退役门当场红。)
  *
- * ## 两个消费点的处置**刻意不同**(同一张表,不同的门)
- *  · 提交腿({@link normalizeServer})对词表外的键**宽容**(读不认识的键就当没有)—— 那条腿要能安全地
- *    重放存量 body,一个 4xx 打在 resume 上会永久砖死一条 parked 任务(本仓三处 `opts.leg` 先例);
- *  · 探测口**响亮拒**(400,点名 `mcpServers[i].<键>`)—— 它问的是「这台到底能不能用」,把一个拼错的键
- *    悄悄忽略再回一份好看的名单,正是那条面要根除的假答案。
- * 两个门,一个词表。表在这里,门在各自的腿上。
+ * ## 一个回答者,两扇门;读器另算
+ * 「这份声明能不能原样用」只有 {@link requestMcpDeclarationRefusal} 一只回答者:词表外的键(条目层 / 本形 `transport` 层)⇒ `400 request.body_shape` 带 `unknownKeys`,
+ * fresh 提交腿({@link assertRequestMcpEntries})与探测口同码同句 —— 一个拼错的键被悄悄不读,声明方会以为它生效了。
+ * 读器({@link normalizeServer})对词表外的键仍**宽容**(读不认识的键就当没有):它只服务重放存量 body 的腿,一个 4xx 打在 resume 上会永久砖死一条 parked 任务(本仓三处 `opts.leg` 先例)。
  *
  * ## 受理键的判官表也钉在这张表上
- * fresh 提交腿对**受理键的值**同样响亮拒({@link assertRequestMcpEntries}):逐键判官表 {@link ENTRY_KEY_JUDGES} 是 `{ [K in 本表的键]: 判官 }` 的映射型 ——
- * 本表多一个键而没写判官 ⇒ 编译红,不会出现「这个键写坏了却被悄悄受理」的新键。词表外的键仍由读器宽容、由探测口闭集拒(上面两条不变)。
+ * 逐键判官表 {@link ENTRY_KEY_JUDGES} 是 `{ [K in 本表的键]: 判官 }` 的映射型 —— 本表多一个键而没写判官 ⇒ 编译红,不会出现「这个键写坏了却被悄悄受理」的新键。
  */
-export declare const MCP_SERVER_ENTRY_KEYS: readonly ["allowTools", "contentOrigin", "elicitation", "name", "source", "toolAxes", "toolFaces", "transport"];
+export declare const MCP_SERVER_ENTRY_KEYS: readonly ["allowTools", "contentOrigin", "elicitation", "name", "source", "startupTimeoutMs", "toolAxes", "toolFaces", "transport"];
 /** `transport.kind:"stdio"` 的键闭集(两向钉在 core 那一支上)。 */
 export declare const STDIO_MCP_TRANSPORT_KEYS: readonly ["args", "command", "env", "kind"];
 /** `transport.kind:"http"` 的键闭集(同上)。`assertionHeader` 是本仓承载、引擎尚无座的一格(见 {@link RequestMcpServerSpec}):
  *  表两向钉在**请求面的 http 传输型**上 = 引擎的键 ∪ 这一格;引擎一旦长出同名座,`mcp-assertion-header.ts` 的退役门当场红。 */
 export declare const HTTP_MCP_TRANSPORT_KEYS: readonly ["assertionHeader", "headers", "kind", "principalHeader", "url"];
-/** 条目层:`{}` 与缺席等价的可选 Record 键。 */
-export declare const MCP_ENTRY_EMPTY_RECORD_KEYS: readonly ["toolAxes", "toolFaces"];
-/** 条目层:`[]` 与缺席等价的可选数组键。 */
-export declare const MCP_ENTRY_EMPTY_ARRAY_KEYS: readonly ["allowTools"];
-/** 传输层(两种合起来):`{}` / `[]` 与缺席等价的键。 */
-export declare const MCP_TRANSPORT_EMPTY_RECORD_KEYS: readonly ["env", "headers"];
-export declare const MCP_TRANSPORT_EMPTY_ARRAY_KEYS: readonly ["args"];
 /**
  * Does THIS deployment honor caller-supplied per-request MCP servers? TRUE for a SINGLE-USER deployment
  * (`requirePrincipal !== true`) — the requester is the super-admin of their own worker, so their `.mcp.json` is
@@ -152,54 +141,53 @@ export declare function assertRequestMcpUnlocked(bodyMcp: unknown, lockedKeys: R
 /** 一条**原始**请求条目上两个身份头的问题类(没有问题 / 不是对象 / 不是 http 传输 ⇒ `undefined`)—— 提交腿的门、探测口、重放腿的披露三处共读,
  *  判据本体在 `mcp-assertion-header.ts`;这里只负责把「条目 → 传输对象」那一步读出来。 */
 export declare function requestEntryIdentityIssue(entry: unknown): McpIdentityHeadersIssue | undefined;
-/** 问题类 → 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;
+/** 请求面 `mcpServers` 的一次拒:码 + 句 + 词表外的键名表(只在闭集那一形上在场)。两扇门(fresh 提交腿 / 探测口)同一份,状态恒 400。 */
+export interface RequestMcpRefusal {
+    readonly errorCode: "request.body_shape" | "request.field_invalid";
+    readonly message: string;
+    /** 词表外的键,全路径形(`mcpServers[0].transport.header`;已清洗 + 截长 + 排序 + 封顶)。 */
+    readonly unknownKeys?: readonly string[];
+}
 /**
- * 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 调用方,「收窄声明没生效」与「放宽声明没生效」同样是一份没有生效的声明,响亮拒比两种沉默都好。
+ * 请求面 `mcpServers`「这份声明能不能原样用」的**唯一回答者** —— fresh 提交腿({@link assertRequestMcpEntries})与探测口
+ * (`capabilities/mcp-probe.ts` 的 `readMcpProbeBody`)都问它、都原样转述它的答案(码与句逐字相同)。`undefined` = 能原样用,或列表缺席 / `null`(没声明;各门自己定缺席的意思)。
+ *
+ * ## 律:一个回答者、一个拒形,先列表后条目、条目里先键名后键值,第一处坏形即答
+ *  ① **列表**:在场却不是数组 / 超过 {@link MAX_REQUEST_MCP_SERVERS} 条 / 某一条不是对象 ⇒ `400 request.field_invalid`,点名 `mcpServers` 或 `mcpServers[i]`(句尾同一句,见 {@link LIST_REFUSAL_TAIL})。
+ *     整份拒而不是挂前 32 条 / 摘掉读不出的那条 / 整只忽略:一份被悄悄截短、少了几条或整只没生效的声明,在发送方那里读起来是「生效了」。
+ *  ② **键名**:条目层、或 `transport` 按 `kind` 那一形的键闭集之外的键 ⇒ `400 request.body_shape`,拒体带 `unknownKeys`(拼错的键被悄悄不读,同样读起来像生效了)。
+ *  ③ **身份头的键组合**(`principalHeader` 与 `assertionHeader` 同设 / `assertionHeader` 非串)⇒ {@link requestEntryIdentityRefusal}(同设那一句对契约包解析期原句逐字)。
+ *  ④ **受理键的值** ⇒ 逐键问判官表 {@link ENTRY_KEY_JUDGES},`400 request.field_invalid`,拒句点名 `mcpServers[i].<键路径>`、server 名与**该键判官的原因句**({@link entryFieldRefusal})。
+ *     判官**就是读器用的那一只**,不是第二份:`toolAxes` = 引擎根导出的 `readMcpToolAxes`;`toolFaces` = `readMcpToolFaces`;`contentOrigin` = `isContentOriginWord`;`source` = `isMcpSourceLabel`;
+ *     `name` = `isUsableWireName`;`allowTools` / `transport.args` = {@link isStringArray};`transport.env` / `headers` = {@link readPlainStringRecord};`elicitation` = {@link isElicitationFlag};
+ *     `transport` 的硬字段(`kind` / `command` / `url`)与软字段(`args` / `env` / `headers` / `principalHeader`)= {@link readRequestTransport}(读器投影 transport 的那一只函数,门读它报的 `lost`)。
+ *     判官只在引擎里、包根没给读口的键(今天只有 `startupTimeoutMs`)不在这里判,原样过境、由引擎在拨号时按 server 拒(不写第二份判据;到货读口即换)。
+ * 于是判官受理的条目,读器({@link normalizeServer})交回的就是申报本身(只差判官自己的合法归一:空容器 / `skillScopeEligible:false` 折成缺席、`toolAxes` 取引擎的拷贝)——
+ * 探测口拨的那一份因此就是提交腿会挂的那一份,不另比一遍(另比就是第二只回答者)。唯一按门分的后果是「声明了 `assertionHeader`」这一个事实(引擎尚无座,
+ * 承载、不发送):新提交照挂 + 运维 info,探测口整条拒 —— 判据是同一只谓词 `declaresMcpAssertionHeader`,不是第二份判法(见 `readMcpProbeBody`)。
  *
- * ## 每个键一只判官({@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` 的那一句对契约包原句逐字),在逐键之前先判。
+ * ## 射程
+ * 纯值域、与租户车道无关(一个写坏的请求在哪条车道上都是写坏的;多租户腿本来就忽略整只数组,告诉调用方「你写错了」只多不少)。
+ * 重放存量 body 的腿**不问它**:那条腿走宽容读器(见 {@link assertRequestMcpEntries} 的 leg 分流)。
+ * 关于 `contentOrigin` 的信任语义(core 把它定性为**部署面**键):请求腿的条目只有在 {@link mcpInjectionHonored} 为真(单用户 = 请求者就是这台 worker 的超管)时才被读进 `TaskSpec.mcp`,
+ * 多租户部署整只数组被忽略 ⇒ 租户**结构上**够不着这个键;名字撞车时 baseline 恒赢({@link mergeRequestMcp})⇒ 调用方也改写不了一台**已配置** server 的声明。
+ */
+export declare function requestMcpDeclarationRefusal(list: unknown): RequestMcpRefusal | undefined;
+/**
+ * fresh 提交腿的 `mcpServers` 门:{@link requestMcpDeclarationRefusal} 有答案 ⇒ 同步 400(码 / 句 / `unknownKeys` 原样)。
  *
  * ## 位置与 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 的声明。
+ * 重放腿走读器({@link normalizeServer} / {@link classifyRequestMcp}),处置:整只不是数组 ⇒ 整只忽略 + 运维 warn `mcp_injection_ignored`;条目不是对象 / 坏硬键
+ * (`name` / `transport` 硬字段 / `allowTools` / `toolAxes` / `toolFaces`)⇒ 这一条 server 整条不进 + 运维 warn `mcp_injection_dropped` + 用户面通告 `mcp.injection_dropped` 点名 `field`
+ * (`toolAxes` 在一次性迁移 M19 的窗开着时先按升级前读法重读一次,过了就挂,见读器的注);超上限的尾项 ⇒ `over_cap` 点名;坏软键(`contentOrigin` / `elicitation` / `source`)
+ * 与词表外的键 ⇒ 丢键、server 照挂(`contentOrigin` 另有 `mcp_content_class_dropped` 留声);`transport` 软字段 ⇒ 只不交坏的那几处(`env` / `headers` 对 JSON 存体按 7.131.x 的判据整键交或不交,
+ * 交出去的剔掉 `__proto__` 名成员),server 照挂,运维 warn `mcp_transport_members_dropped` 逐处点名 —— 续跑重放腿不静默丢声明。
  */
 export declare function assertRequestMcpEntries(bodyMcp: unknown): void;
-/**
- * 一条**原始**请求条目上 `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";
-    message: string;
-} | undefined;
 /**
  * The ONE predicate for "this MCP server name belongs to the deployment": the scenario baseline (what mounted for
  * this scenario) ∪ every name the deployment DECLARED (`CenterMcp.reservedNames` — mounted or not, any scenario).