@sema-agent/server 7.130.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-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

@@ -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 掉(`assertRequestMcpToolAxes`),读器根本见不到坏形;
- *  · 请求腿(`task-mcp.ts`)只 import 本模块的**型**:重读座是 `resolveRequestMcp` 的一个形参,没人递就没有;探测口(`validateRequestMcp`)没有这个形参;
+ *    递 `leg: "resume"`);新提交腿递 `"fresh"` 拿不到重读座,且在腿首已经被同一只判官 400 掉(`assertRequestMcpEntries`),读器根本见不到坏形;
+ *  · 两条请求腿(`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