@sema-agent/server 7.12.0 → 7.14.0

package/dist/plugins/tidb-pool.js

@@ -187,13 +187,20 @@ export const SCHEMA_STATEMENTS = [
      KEY idx_rate_limit_window (window_bucket)
    ) COLLATE utf8mb4_bin`,
     // Durable backing for offloaded large tool results (core 1.47/1.49). One row per offload ref
-    // (`tr_<sessionId>_<toolCallId>`, globally unique → PK); content is the full tool output moved out of
+    // (`tr_<sessionId>~<toolCallId>~<contentSeg>` since core 5.26.0 #119, globally unique → PK); content is the full tool output moved out of
     // context. Write-once (INSERT IGNORE); TTL-reaped by created_at (idx_created). LONGTEXT holds large
     // file/diff reads. Lets an async run wake on any replica and still read_tool_result the full text.
+    // #119(core 5.26.0 提货):`ref` 从 VARCHAR(190) 抬到 518 = core 导出的 `MAX_MINTED_TOOL_RESULT_REF_CHARS`
+    // (`"tr_"` + 四段 × 128 + 三个 `~` 分隔),并新增 #119 出处两列(NULL = 该行无属主,读面 fail-closed)。
+    // 抬宽不是保守裕度:core 的 d.ts 逐字点名过旧宽度(「TiDB's was VARCHAR(191), which a long three-segment
+    // ref overruns — a truncating key aliases distinct refs」)—— 截断的主键会把两枚不同的 ref 折成同一行,
+    // 于是 A 的产物能从 B 的 ref 读出来。utf8mb4 下 518 字符 = 2072 字节,仍在 InnoDB/TiDB 3072 字节键长内。
     `CREATE TABLE IF NOT EXISTS tool_result (
-     ref        VARCHAR(190) NOT NULL,
-     content    LONGTEXT     NOT NULL,
-     created_at DATETIME(3)  NOT NULL,
+     ref              VARCHAR(518) NOT NULL,
+     content          LONGTEXT     NOT NULL,
+     owner_session_id VARCHAR(190) NULL,
+     owner_task_id    VARCHAR(190) NULL,
+     created_at       DATETIME(3)  NOT NULL,
      PRIMARY KEY (ref),
      KEY idx_tool_result_created (created_at)
    ) COLLATE utf8mb4_bin`,

package/dist/plugins/tool-result-store-sql.d.ts

@@ -1,4 +1,4 @@
-import type { ToolResultStore, ToolResultSlice } from "@sema-agent/core";
+import type { ToolResultProvenance, ToolResultStore, ToolResultSlice } from "@sema-agent/core";
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool, PoolClient as PgPoolClient } from "pg";
 import { type SqlDriver } from "./sql-driver.js";
@@ -8,6 +8,21 @@ import { type SqlDriver } from "./sql-driver.js";
 export declare const PG_TOOL_RESULT_SCHEMA: string[];
 /** Idempotent schema apply for the tool_result table (for the integration test to call). */
 export declare function ensureSchema(pool: PgPool | PgPoolClient): Promise<void>;
+/**
+ * #119 升级前置断言 —— **拒启**,不是 warn(codex 复审 [high],已核真)。
+ *
+ * 病:本仓不发 `ALTER TABLE` 迁移(标准裁定:改列就改 CREATE + 删库重建)。于是一台**没删表**就升上来的
+ * 部署,`CREATE TABLE IF NOT EXISTS` 对它是空操作,旧表既没有出处两列也只有 `VARCHAR(190)` 的 ref 列。
+ * 那样跑起来的后果不是「少个功能」:每一次 offload 写都会撞 unknown column 报错,而 core 的 offload
+ * 失败臂会把错误吞成一条内联占位("[offload LOST at write time…]")—— 服务照跑,工具产物全丢,日志里只有
+ * 一句看不出根因的话。这正是「响亮或 fail-closed,禁静默降级」那条要挡的形态。
+ *
+ * 判据用**能力探测**而不是版本号/information_schema:发一条恒空的 `WHERE 1=0` 读,列不在就报错。
+ * 探不通即拒启,错误文案直接给出两条方言的动作(删表重建),不让运维去猜。
+ */
+export declare function assertToolResultProvenanceSchema(query: (sql: string) => Promise<{
+    rows: Record<string, unknown>[];
+}>, dialect: "tidb" | "pg"): Promise<void>;
 /** Dual-dialect durable ToolResultStore. See the file header for the dialect-delta ledger. */
 export declare class SqlToolResultStore implements ToolResultStore {
     protected readonly db: SqlDriver;
@@ -24,7 +39,25 @@ export declare class SqlToolResultStore implements ToolResultStore {
      *  抛错文案与 core 逐字相同,所以 wire 与既有钉都不变。 */
     private isUnsafeRef;
     private assertSafeRef;
-    put(ref: string, content: string): Promise<void>;
+    /**
+     * #119(core 5.26.0)—— 出处的**写面**。语义一律取 core 单源(`assertToolResultProvenanceMatch`),
+     * 本方法只负责把它落到 SQL 上:
+     *  · **写一次选举同时定属主** —— 内容与属主是同一条 INSERT,不存在「内容写进去了属主还没跟上」的窗口
+     *    (core 头注允许 file 双对象后端出现这个窗口,单行后端没有,别自造);
+     *  · 抢输的那一方(IGNORE / DO NOTHING ⇒ affected=0)回读已存属主再判:同属主(或本次无出处)=
+     *    幂等空转;异属主 = `ToolResultRefConflictError` typed 拒。**绝不静默 keep-first**:ref 是主键,
+     *    静默空转会让第二位写者拿着自己的 ref 读回第一位的字节;
+     *  · 无出处的行永久 unowned —— 后续带出处的 put 不回填(没有证据的收养),`ownerOf` 继续答 undefined。
+     */
+    put(ref: string, content: string, provenance?: ToolResultProvenance): Promise<void>;
+    /** 一次回读同时回答两件事:**行在不在**(reap/purge 窗口的判别位)与**属主是谁**。两件事必须来自同一
+     *  条 SELECT —— 分两次问会重新引入它要消灭的那个窗口。 */
+    private readOwner;
+    /**
+     * #119 —— 出处的**读面**。未知 ref 与「存了但无属主」两种情况都答 `undefined`:读面对二者一视同仁
+     * (fail-closed,谁都没被授权),所以这里也不必把它们分开报。
+     */
+    ownerOf(ref: string): Promise<ToolResultProvenance | undefined>;
     get(ref: string, opts?: {
         offset?: number;
         limit?: number;

package/dist/plugins/tool-result-store-sql.js

@@ -9,7 +9,8 @@
  * offloaded result (the ref misses → the model is told it's unavailable; the preview still stands, so it
  * degrades, never crashes). A durable store survives wake/resume across the stateless fleet.
  *
- * core namespaces the ref as `tr_<sessionId>_<toolCallId>` (1.49) → globally unique → usable directly as
+ * core namespaces the ref as `tr_<sessionId>~<toolCallId>~<contentCoordinate>` (1.49, re-minted injectively in
+ * 5.26.0 #119 — `~`-separated, four segments max, content-addressed) → globally unique → usable directly as
  * the PRIMARY KEY (no composite key needed). `put` is write-once (idempotent on replay/retry: a retry is
  * a NEW toolCallId → new ref, so a given ref never changes content). Retention is anchored to a run's
  * RECOVERABLE window via TTL (`reapOlderThan`): a resumable run may re-fetch an old ref after wake, but a
@@ -35,7 +36,7 @@
  *     sessions' rows); PG spells `ESCAPE '\'` (its default escape char already, kept for lock-step intent
  *     with the TiDB twin rather than out of necessity).
  */
-import { assertSafeToolResultRef } from "@sema-agent/core";
+import { MAX_MINTED_TOOL_RESULT_REF_CHARS, assertSafeToolResultRef, assertToolResultProvenanceMatch, normalizeToolResultProvenance } from "@sema-agent/core";
 import { escapeLike } from "./sql-escape.js";
 import { pgSanitizeText } from "./pg-safe-json.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
@@ -43,10 +44,14 @@ import { mysqlDriver, pgDriver } from "./sql-driver.js";
  *  (LONGTEXT→TEXT, DATETIME(3)→TIMESTAMPTZ(3), inline KEY→separate CREATE INDEX). Disjoint from other stores'
  *  tables, so a self-contained ensureSchema is safe (central pg-pool aggregation is done separately). */
 export const PG_TOOL_RESULT_SCHEMA = [
+    // #119(core 5.26.0):宽度与出处两列与 TiDB 双生逐字对齐 —— 理由写在 tidb-pool.ts 的同一张 DDL 上
+    // (`MAX_MINTED_TOOL_RESULT_REF_CHARS` = 518;截断主键 = 两枚 ref 折成一行 = 身份故障)。
     `CREATE TABLE IF NOT EXISTS tool_result (
-     ref        VARCHAR(190) COLLATE "C" NOT NULL,
-     content    TEXT COLLATE "C"         NOT NULL,
-     created_at TIMESTAMPTZ(3) NOT NULL,
+     ref              VARCHAR(518) COLLATE "C" NOT NULL,
+     content          TEXT COLLATE "C"         NOT NULL,
+     owner_session_id VARCHAR(190) COLLATE "C" NULL,
+     owner_task_id    VARCHAR(190) COLLATE "C" NULL,
+     created_at       TIMESTAMPTZ(3) NOT NULL,
      PRIMARY KEY (ref)
    )`,
     `CREATE INDEX IF NOT EXISTS idx_tool_result_created ON tool_result (created_at)`,
@@ -56,6 +61,49 @@ export async function ensureSchema(pool) {
     for (const stmt of PG_TOOL_RESULT_SCHEMA)
         await pool.query(stmt);
 }
+/**
+ * #119 升级前置断言 —— **拒启**,不是 warn(codex 复审 [high],已核真)。
+ *
+ * 病:本仓不发 `ALTER TABLE` 迁移(标准裁定:改列就改 CREATE + 删库重建)。于是一台**没删表**就升上来的
+ * 部署,`CREATE TABLE IF NOT EXISTS` 对它是空操作,旧表既没有出处两列也只有 `VARCHAR(190)` 的 ref 列。
+ * 那样跑起来的后果不是「少个功能」:每一次 offload 写都会撞 unknown column 报错,而 core 的 offload
+ * 失败臂会把错误吞成一条内联占位("[offload LOST at write time…]")—— 服务照跑,工具产物全丢,日志里只有
+ * 一句看不出根因的话。这正是「响亮或 fail-closed,禁静默降级」那条要挡的形态。
+ *
+ * 判据用**能力探测**而不是版本号/information_schema:发一条恒空的 `WHERE 1=0` 读,列不在就报错。
+ * 探不通即拒启,错误文案直接给出两条方言的动作(删表重建),不让运维去猜。
+ */
+export async function assertToolResultProvenanceSchema(query, dialect) {
+    // ② 键宽(codex 复审 round2 [high],已核真):只探两列会放过「有出处列、但 ref 仍是 VARCHAR(190)」的
+    // 半迁移表 —— 而这道断言的文案与 CHANGELOG 都在宣称它护着加宽后的键。截断的主键把两枚不同的 ref 折成
+    // 同一行 = 身份故障,正是本次升级要消灭的东西,所以宽度必须**真查**,不能靠「列在 ⇒ 表是新的」推断。
+    const widthRow = await query(dialect === "tidb"
+        ? "SELECT CHARACTER_MAXIMUM_LENGTH AS len FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'tool_result' AND column_name = 'ref'"
+        : "SELECT character_maximum_length AS len FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = 'tool_result' AND column_name = 'ref'").catch(() => ({ rows: [] }));
+    const width = Number(widthRow.rows[0]?.len ?? NaN);
+    // 查不到宽度(权限受限的 information_schema / 意外的列类型)⇒ **不**据此拒启:那是「没看见」,不是
+    // 「看见了不合格」。看见了才判,判就判死。
+    if (Number.isFinite(width) && width < MAX_MINTED_TOOL_RESULT_REF_CHARS) {
+        throw new Error(`tool_result.ref is VARCHAR(${width}) but core 5.26.0 mints refs up to ${MAX_MINTED_TOOL_RESULT_REF_CHARS} characters ` +
+            `(#119 made the ref injective: four \`~\`-separated segments). A truncating primary key aliases two distinct refs onto ` +
+            `one row — one run's tool output reads back from another run's ref. This repository ships no ALTER TABLE migrations: ` +
+            `run \`DROP TABLE tool_result;\` on the ${dialect === "pg" ? "PostgreSQL" : "MySQL-protocol"} backend and restart ` +
+            `(the schema is recreated at boot; offloaded results are a recoverable-window cache, inline previews are unaffected).`);
+    }
+    try {
+        await query("SELECT owner_session_id, owner_task_id FROM tool_result WHERE 1=0");
+    }
+    catch (err) {
+        throw new Error(`tool_result is missing the #119 provenance columns (owner_session_id / owner_task_id) — refusing to start. ` +
+            `This release picks up @sema-agent/core 5.26.0, which changed how an offloaded tool result is addressed ` +
+            `(the ref grew past the old VARCHAR(190) key) and made the store record who wrote each row. This repository ` +
+            `ships no ALTER TABLE migrations, so the table must be recreated: run \`DROP TABLE tool_result;\` on the ` +
+            `${dialect === "pg" ? "PostgreSQL" : "MySQL-protocol"} backend and restart — the schema is recreated at boot. ` +
+            `Offloaded tool results are a recoverable-window cache (the inline previews in transcripts are unaffected), ` +
+            `so the cost is at most the full text of results from runs still in flight. ` +
+            `Underlying probe error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /** Dual-dialect durable ToolResultStore. See the file header for the dialect-delta ledger. */
 export class SqlToolResultStore {
     db;
@@ -87,7 +135,17 @@ export class SqlToolResultStore {
     assertSafeRef(ref) {
         assertSafeToolResultRef(ref);
     }
-    async put(ref, content) {
+    /**
+     * #119(core 5.26.0)—— 出处的**写面**。语义一律取 core 单源(`assertToolResultProvenanceMatch`),
+     * 本方法只负责把它落到 SQL 上:
+     *  · **写一次选举同时定属主** —— 内容与属主是同一条 INSERT,不存在「内容写进去了属主还没跟上」的窗口
+     *    (core 头注允许 file 双对象后端出现这个窗口,单行后端没有,别自造);
+     *  · 抢输的那一方(IGNORE / DO NOTHING ⇒ affected=0)回读已存属主再判:同属主(或本次无出处)=
+     *    幂等空转;异属主 = `ToolResultRefConflictError` typed 拒。**绝不静默 keep-first**:ref 是主键,
+     *    静默空转会让第二位写者拿着自己的 ref 读回第一位的字节;
+     *  · 无出处的行永久 unowned —— 后续带出处的 put 不回填(没有证据的收养),`ownerOf` 继续答 undefined。
+     */
+    async put(ref, content, provenance) {
         this.assertSafeRef(ref);
         // Sanitize invalid UTF-16 (lone/half surrogates — a JS string CAN hold them, e.g. a binary-ish tool
         // output) to U+FFFD so the column accepts the FULL value via a Buffer utf8 round-trip (valid content is
@@ -102,7 +160,58 @@ export class SqlToolResultStore {
         if (this.db.dialect === "pg")
             safe = pgSanitizeText(safe);
         // write-once / keep-first: a replay re-puts the SAME ref+content → IGNORE / DO NOTHING keeps the original row.
-        await this.db.query(this.q("INSERT IGNORE INTO tool_result (ref, content, created_at) VALUES (?,?,?)", "INSERT INTO tool_result (ref, content, created_at) VALUES ($1,$2,$3) ON CONFLICT (ref) DO NOTHING"), [ref, safe, new Date()]);
+        const owner = provenance !== undefined ? normalizeToolResultProvenance(provenance) : undefined;
+        const insert = async () => (await this.db.query(this.q("INSERT IGNORE INTO tool_result (ref, content, owner_session_id, owner_task_id, created_at) VALUES (?,?,?,?,?)", "INSERT INTO tool_result (ref, content, owner_session_id, owner_task_id, created_at) VALUES ($1,$2,$3,$4,$5) ON CONFLICT (ref) DO NOTHING"), [ref, safe, owner?.sessionId ?? null, owner?.taskId ?? null, new Date()])).affected;
+        // 🔴 codex 复审(medium,已核真)——**抢输之后那一行可能已经不在了**。选举(INSERT)与观察(SELECT)
+        // 是两条语句,中间可以插进 TTL reap 或 §0.5 会话清除。那时 `readOwner` 回 `absent`,而 core 的比较器
+        // 对「缺一侧」是**不下判决**的(设计如此:无出处的行不许被收养)—— 于是 put 会**成功返回**,而库里
+        // 既没有内容也没有属主,调用方拿着一枚当场读不出来的 ref。
+        //
+        // 🔴 处置是**抛**,不是重投(codex 复审两轮的合取解;第一版写的重投被第二轮当场驳回,理由成立):
+        // 重投会让**删除输**。§0.5 会话清除 DELETE 掉这一行之后,一次重投就把它原地复活 —— 而 core 的部分
+        // offload 写点是不 await 的,能活过 active-run 围栏,于是被删会话的产物重新落库、留到 TTL 才消失,
+        // 直接违背 E21 的删除权保证。「少存一份可恢复窗口内的缓存」与「删了又回来」不是同一个量级的代价。
+        // 抛出去会走到 core 的 offload 失败臂 —— 它把这次卸载记成 "[offload LOST at write time: …]" 并保住
+        // 内联预览,模型看到的是实话。
+        if ((await insert()) > 0)
+            return; // 本次赢下选举:内容与属主同一条语句落地
+        const stored = await this.readOwner(ref);
+        if (stored.present) {
+            // 抢输(或纯重放):属主判定归 core 的单源比较器 —— 「同属主」在两个 store 里不许有两种含义。
+            assertToolResultProvenanceMatch(ref, stored.owner, owner);
+            return;
+        }
+        throw new Error(`tool-result store: ref ${JSON.stringify(ref)} lost the write-once election and the elected row was already gone ` +
+            `(a concurrent TTL reap or session purge deleted it). Nothing was stored — reporting the loss rather than ` +
+            `re-inserting (which would resurrect a purged session's content) or returning a ref that reads back empty.`);
+    }
+    /** 一次回读同时回答两件事:**行在不在**(reap/purge 窗口的判别位)与**属主是谁**。两件事必须来自同一
+     *  条 SELECT —— 分两次问会重新引入它要消灭的那个窗口。 */
+    async readOwner(ref) {
+        const { rows } = await this.db.query(this.q("SELECT owner_session_id, owner_task_id FROM tool_result WHERE ref = ?", "SELECT owner_session_id, owner_task_id FROM tool_result WHERE ref = $1"), [ref]);
+        const row = rows[0];
+        if (!row)
+            return { present: false, owner: undefined };
+        // 🔴 缺席的判别位**只有 SQL NULL**(codex 复审 round2 [medium],已核真):曾经写成
+        // `sessionId.length === 0` 也算无属主 —— 那会把一个 `sessionId: ""` 的合法(core 的
+        // `normalizeToolResultProvenance` 不拒空串)出处在往返中悄悄折成 unowned,与内存后端的逐字比较分家;
+        // `taskId: ""` 折成缺席更糟 —— 授权面会从「task 级」放宽成「整条 session」。字符串一律原样还原。
+        const sessionId = row.owner_session_id;
+        if (typeof sessionId !== "string")
+            return { present: true, owner: undefined }; // NULL 列 = 行在但无属主
+        const taskId = row.owner_task_id;
+        // 键**缺席**而不是 present-as-undefined:core 的比较器把「缺 taskId」与「显式 undefined」当同一个值,
+        // 但调用方(和本仓的 toEqual 钉)看得见键在不在,落库的 NULL 只能还原成缺席形。
+        return { present: true, owner: typeof taskId === "string" ? { sessionId, taskId } : { sessionId } };
+    }
+    /**
+     * #119 —— 出处的**读面**。未知 ref 与「存了但无属主」两种情况都答 `undefined`:读面对二者一视同仁
+     * (fail-closed,谁都没被授权),所以这里也不必把它们分开报。
+     */
+    async ownerOf(ref) {
+        if (this.isUnsafeRef(ref))
+            return undefined; // 与 get 同尺:写面拒过的 ref 必不在库,不把驱动层错误漏出去
+        return (await this.readOwner(ref)).owner;
     }
     async get(ref, opts = {}) {
         // D1 读面半条(RB-266「the read face degrades instead」):unsafe ref 在读面**降级**返回 undefined
@@ -147,11 +256,18 @@ export class SqlToolResultStore {
      * data-layer protection that matters (a crafted id can't widen the prefix across tenants).
      */
     async deleteBySession(sessionId) {
-        // Escape the WHOLE literal prefix `tr_<sessionId>_` (incl. both literal underscores) so the only LIKE wildcard
-        // is the trailing `%` — a `_` left un-escaped is a single-char wildcard that could over-match across tenants.
-        const prefix = `${escapeLike(`tr_${sessionId}_`)}%`;
+        // Escape the WHOLE literal prefix `tr_<sessionId><sep>` (incl. the literal underscore in `tr_` and, on the
+        // legacy arm, the separator underscore) so the only LIKE wildcard is the trailing `%` — a `_` left
+        // un-escaped is a single-char wildcard that could over-match across tenants.
+        //
+        // 🔴 #119(core 5.26.0):**两个前缀**,因为铸法在 5.26.0 换了分隔符。5.25.0 及以前铸 `tr_<sid>_<callId>`,
+        // 5.26.0 起铸 `tr_<sid>~<callId>~<contentSeg>`(单射 ref)。只留旧前缀 = 升级后一行也命不中,§0.5 会话
+        // 删除**静默清零**;只留新前缀 = 升级前写下的存量行永远删不掉。删除面漏删比多跑一次 LIKE 贵得多,
+        // 所以两条都发,而且都保持「整段字面量转义 + 只有末尾 % 是通配」的老纪律。
+        const legacyPrefix = `${escapeLike(`tr_${sessionId}_`)}%`;
+        const modernPrefix = `${escapeLike(`tr_${sessionId}~`)}%`;
         // Explicit `ESCAPE` clause — see the file-header dialect-delta note for why each dialect spells it as it does.
-        const { affected } = await this.db.query(this.q("DELETE FROM tool_result WHERE ref LIKE ? ESCAPE '\\\\'", "DELETE FROM tool_result WHERE ref LIKE $1 ESCAPE '\\'"), [prefix]);
+        const { affected } = await this.db.query(this.q("DELETE FROM tool_result WHERE ref LIKE ? ESCAPE '\\\\' OR ref LIKE ? ESCAPE '\\\\'", "DELETE FROM tool_result WHERE ref LIKE $1 ESCAPE '\\' OR ref LIKE $2 ESCAPE '\\'"), [legacyPrefix, modernPrefix]);
         return affected;
     }
 }

package/dist/plugins/web-search.d.ts

@@ -15,7 +15,9 @@
  *
  * ── 立案:装配层四条缺口([2176] 我方认领,2026-08-01 调研,**尚未实施**)────────────────────
  *
- * ① **`opts` 只有 tavily 腿在消费**(`brave`/`searxng` 的 switch 分支不传 `opts`)。
+ * ① **`opts` 仍有 brave 腿不消费**(只剩 `brave` 的 switch 分支不传 `opts`;`searxng` 腿已随 ② 的
+ *    还债改动接住 `opts` 并透传给 core 的 adapter,由它把 `allowedDomains` 原生下推成 `site:` 前缀。
+ *    立案时的原话是「`opts` 只有 tavily 腿在消费(`brave`/`searxng` 都不传)」,② 落地后已部分还清)。
  *    定性:**优化缺失,不是正确性缺口** —— 上面那句「core 再执行一次 FLOOR」经亲验属实
  *    (core `dist/tools/web.js` 的 `webSearchResultAllowed(url, allowed, blocked)`,按 hostname
  *    逐条过滤 blocked/allowed)。所以模型请求的域限制**不会**被静默丢弃。

package/dist/plugins/web-search.js

@@ -15,7 +15,9 @@
  *
  * ── 立案:装配层四条缺口([2176] 我方认领,2026-08-01 调研,**尚未实施**)────────────────────
  *
- * ① **`opts` 只有 tavily 腿在消费**(`brave`/`searxng` 的 switch 分支不传 `opts`)。
+ * ① **`opts` 仍有 brave 腿不消费**(只剩 `brave` 的 switch 分支不传 `opts`;`searxng` 腿已随 ② 的
+ *    还债改动接住 `opts` 并透传给 core 的 adapter,由它把 `allowedDomains` 原生下推成 `site:` 前缀。
+ *    立案时的原话是「`opts` 只有 tavily 腿在消费(`brave`/`searxng` 都不传)」,② 落地后已部分还清)。
  *    定性:**优化缺失,不是正确性缺口** —— 上面那句「core 再执行一次 FLOOR」经亲验属实
  *    (core `dist/tools/web.js` 的 `webSearchResultAllowed(url, allowed, blocked)`,按 hostname
  *    逐条过滤 blocked/allowed)。所以模型请求的域限制**不会**被静默丢弃。

package/dist/rules-consent.d.ts

@@ -1,4 +1,4 @@
-import { type ImportPreview, type ImportResult, type ImportedSettingsLayer, type PersistedAllowRule, type RemoveResult, type RuleScope } from "@sema-agent/core";
+import { type RuleOwner, type ImportPreview, type ImportResult, type ImportedSettingsLayer, type PersistedAllowRule, type RemoveResult, type RuleScope } from "@sema-agent/core";
 import type { PermissionRuleStoreProvider, RuleApprovalRecordStore } from "@sema-agent/core";
 import { type RuleImportTicket, type RuleTicketRedeemResult } from "./plugins/permission-rule-store-sql.js";
 /**
@@ -47,6 +47,16 @@ export interface PermissionRuleStoreBundle extends RuleConsentStores {
     /** #203 §3:库里已有几只规则桶(一 owner 一桶)。boot 期休眠行审计的**唯一**依赖;
      *  为什么数桶不数规则、以及读失败必须响亮,见 `boot/permission-rules-audit.ts` 与两个实现处的注。 */
     countBuckets(): Promise<number>;
+    /**
+     * A-010.17 保留期腿:清掉**可证已死**的导入票与孤儿 pending 审批记录,返回删掉的总行数。
+     * 谓词与「为什么不需要旋钮」逐字见 `plugins/permission-rule-store-sql.ts` 的同名成员。
+     *
+     * 🔴 **可选**,而缺席是**如实登记**过的:File 车道(`permission-rule-store-file.ts`)的审批/票两面是
+     * **追加日志**,删一行等于重写整个日志 —— 那是一次压实(compaction)设计,与 SQL 的一条 DELETE 不是
+     * 同一件事,不在本条射程内。缺席的实际后果有界:File 车道 = 单用户本地形,两只日志的增长由**一个人**
+     * 的导入次数封顶,不是多租户共享库那种无界增长。要做压实时在这里补实现,消费点(reaper)零改动。
+     */
+    reapExpired?(nowMs: number): Promise<number>;
 }
 /** 导入票的存活窗。人从「看到预览」到「按下确认」是一次交互,不是一段会话——十分钟宽到不会误伤,
  *  窄到一张泄漏的票不会常驻。运维旋钮暂不开(没有部署形要求它可调;要开时走 config.ts 的既有姿势)。 */
@@ -147,6 +157,20 @@ export interface PersistedRuleListing {
     rows: PersistedRuleWireRow[];
     rev: number;
 }
+/**
+ * 撤销面两口寻址的**桶**(#203 收官件,core 5.24.0 提货批 [3427])。
+ *
+ * 裸串 = principal 简写(既有调用方逐字不变);结构形 {@link RuleOwner} 多出 `{kind:"local-owner"}`
+ * —— 身份缺席的单机形自己那只桶。这不是 server 发明的第二种寻址:core 的
+ * `PermissionRuleStoreProvider.forLocalOwner()`(design/182 §4.5)一直就有这只桶,缺的是**撤销入口
+ * 叫不出它的名字** —— 我方 [3399]① 请托、core 5.24.0 把 `removePersistedRule` 的 `principal` 入参扩成
+ * `string | RuleOwner` 兑现(d.ts 那段注逐字写着「downstream request, 2026-08-10」)。
+ *
+ * 🔴 **绝不用哨兵串**表示身份缺席(core 的 `RuleOwner` 头注就是这条纪律的出处):`forPrincipal("")` /
+ * `forPrincipal("local-owner")` 都会让一个**编出来的名字**流进身份面,而身份面上编的名字与真名在下游
+ * 不可分。判别式联合是唯一诚实的形。
+ */
+export type RuleBucketRef = string | RuleOwner;
 export interface RuleConsentLane {
     /** 卡道兑付口:一次 ask 决议携规则确认 ⇒ prepare→confirm→redeem 一气呵成。 */
     persistCardRule(input: {
@@ -165,13 +189,15 @@ export interface RuleConsentLane {
     /** 导入道:原子消费票 → confirm → redeemRuleBatch。 */
     redeemImport(principal: string, ticket: string): Promise<RuleImportRedeemed>;
     /**
-     * 撤销面读半场:列出一位 principal 名下**活着**的规则(墓碑已折算)。
+     * 撤销面读半场:列出一只桶名下**活着**的规则(墓碑已折算)。
      *
      * 排序 = (scope, rule) 字典序,**确定性**:分页游标是 keyset 形,而 keyset 的全部前提就是「同一份
      * 数据每次以同一个顺序出现」。core 的 `list()` 不承诺顺序(SQL 形按写入顺序、File 形按文件内顺序),
      * 所以序在这里定,不在店里。
+     *
+     * 入参裸串 = principal 简写(既有调用方逐字不变);{@link RuleBucketRef} 的结构形另开 local-owner 桶。
      */
-    listRules(principal: string): Promise<PersistedRuleListing>;
+    listRules(bucket: RuleBucketRef): Promise<PersistedRuleListing>;
     /**
      * 撤销面写半场。**恒经 core `removePersistedRule`**(design/203 §2 裁定)——它产墓碑,而墓碑是
      * `screenRuleSyncState` 的筛子保证「别的副本不把这条规则回灌回来」的唯一凭据。直接删 SQL 行/文件行
@@ -180,9 +206,12 @@ export interface RuleConsentLane {
      * 返回值逐字是 core 的 `RemoveResult` 三态(removed / no-op / failed),**不塌**:
      * `removed.stillLive:true` 意思是「墓碑落了,但本次调用期间又落了一次新的批准,规则按 add-wins
      * 仍然活着」——那是一个**有名字的真结果**,不是异常,更不是「撤销完成」。
+     *
+     * `principal` 裸串 = principal 简写(既有调用方逐字不变);{@link RuleBucketRef} 的结构形让
+     * local-owner 桶**真可撤**(core 5.24.0 起 `removePersistedRule` 的入参 union 扩,#203 收官件)。
      */
     removeRule(input: {
-        principal: string;
+        principal: RuleBucketRef;
         rule: string;
         scope: RuleScope;
     }): Promise<RemoveResult>;

package/dist/rules-consent.js

@@ -87,6 +87,42 @@ export function parseRuleScope(text) {
     // (空前缀包含一切)——一条项目内规则就此悄悄升成全局规则(cc-import 那侧同判据,同一条 codex 发现)。
     return root === "" ? undefined : { kind: "project", root };
 }
+/**
+ * 桶引用 → 具体的规则店。
+ *
+ * 🔴 **穷举判别,未知形一律抛**(CLAUDE.md 词表闭集律 + codex 对抗复审 R3-[medium],验真后改)。
+ * 第一稿写的是 `kind === "principal" ? 甲 : 乙` 的二分:TS 那侧是穷举的,**运行期不是** —— 本车道是
+ * 一个**导出**的束,调用方可以是任何一层(HTTP 路由今天只递裸串,但这条口正是为了将来递结构形才开的)。
+ * 于是 `{kind:"principle"}`(拼错)或 `{}` 会静默落进 local-owner 那支 = 一次**跨桶读**;更坏的是
+ * 同一个坏值递给 core 的 `removePersistedRule` 时它按 `kind === "local-owner"` 反着判,落到
+ * `forPrincipal(undefined)`(空店)—— 列举和撤销**指向两只不同的桶**,而两边都不报错。
+ * 身份面上「不认识的形」只有一个正确答案:响亮拒。
+ *
+ * 🔴 local-owner 桶而 provider 没有 `forLocalOwner` ⇒ 同样**抛**,不静默回落到别的桶。回落到
+ * `forPrincipal(…)` 会把「读/删身份缺席桶」变成「读/删某个 principal 的桶」——那是一次跨桶的读或写,
+ * 是本车道最不该出的错。报文与 core 的 `removePersistedRule` 同支同措辞(那侧回 `failed` 带
+ * `forLocalOwner` 字样),两侧一起读日志时对得上。
+ */
+function storeForBucket(provider, ref) {
+    // 裸串 = principal 简写(core `removePersistedRule` 的同款归一,两侧对同一个输入判同一只桶)。
+    if (typeof ref === "string")
+        return provider.forPrincipal(ref);
+    // `ref.kind` 在类型上是闭集;`switch` 的 default 是**运行期**的那道门(不是死码)。
+    switch (ref.kind) {
+        case "principal":
+            return provider.forPrincipal(ref.principal);
+        case "local-owner":
+            if (provider.forLocalOwner === undefined) {
+                throw new Error("this provider has no local-owner bucket (forLocalOwner is not implemented) — a local-owner rule cannot be listed or removed through it");
+            }
+            return provider.forLocalOwner();
+        default: {
+            // core 给 `RuleOwner` 加员时这里是**编译**红(`never` 赋值失败),不是静默继承某一支。
+            const unknown = ref;
+            throw new Error(`unrecognised permission-rule bucket reference (${JSON.stringify(unknown)}) — refusing to guess which bucket it names`);
+        }
+    }
+}
 export function createRuleConsentLane(stores, opts) {
     const deps = { provider: stores.provider, approvals: stores.approvals };
     const ticketTtlMs = opts?.ticketTtlMs ?? RULE_IMPORT_TICKET_TTL_MS;
@@ -222,10 +258,10 @@ export function createRuleConsentLane(stores, opts) {
                 return await indeterminate(err instanceof Error ? err.message : String(err));
             }
         },
-        async listRules(principal) {
+        async listRules(bucket) {
             // `list()` 已经把墓碑折算掉(`applyTombstones`)⇒ 这里拿到的就是**活着**的规则,治理面看到的
             // 与引擎放行时看到的是同一份。空桶 = 空表 + rev 0,不是错误(「这个人没有规则」是合法状态)。
-            const stored = await stores.provider.forPrincipal(principal).list();
+            const stored = await storeForBucket(stores.provider, bucket).list();
             const rows = stored.rules.map((r) => ({ rule: r.rule, scope: serializeRuleScope(r.scope), tool: r.tool, match: r.match, command: r.command, adds: r.adds }));
             rows.sort((a, b) => (a.scope < b.scope ? -1 : a.scope > b.scope ? 1 : a.rule < b.rule ? -1 : a.rule > b.rule ? 1 : 0));
             return { rows, rev: stored.rev };
@@ -233,6 +269,11 @@ export function createRuleConsentLane(stores, opts) {
         async removeRule(input) {
             // 🔴 一行也不自己写:OCC 重试、墓碑铸造、`stillLive` 的读回全在 core 那条原语里,而它的语义
             // (add-wins、observed-remove、失败必须由读回确认「什么都没写」)是 core 的单一属主。
+            // 桶引用**原样**递下去(裸串走 core 的 principal 简写臂,结构形走 owner 臂)——我方不在这里
+            // 归一成 owner 对象:core 5.24.0 的 `removePersistedRule` 自己就做那次归一(`typeof === "string"`),
+            // 多归一一次等于把上游的简写语义抄一份到下游,抄件会漂。local-owner 而 provider 无 `forLocalOwner`
+            // 的那支也归 core:它回的是 `failed` + 报文含 `forLocalOwner`(C13 判据),比抛错更适合这条
+            // 三态返回的口。
             return await removePersistedRule({ rule: input.rule, scope: input.scope, principal: input.principal, provider: stores.provider });
         },
     };

package/dist/run-local.js

@@ -582,6 +582,11 @@ export async function runLocal(argv, deps = {}) {
      */
     const sharedRunnerDeps = createSharedRunnerDeps({
         config,
+        // 交接件⑤:commit 尾注署名座进**共享基座** ⇒ 主 runner 与 subRunner 同源。
+        // [931]① clay 拍:run-local = Sema 品牌本地形态,commit 尾注接 Sema 署名(core 1.300 缺省已翻转不署)。
+        // 修前它只写在下面主 runner 的差异键里 ⇒ **委派出去的子代提交不带署名**,而它提交进的是同一个仓、
+        // 代表的是同一个部署。那不是一次有理由的分歧(差异键注释块逐条列了理由,唯独没提它),是漏配。
+        hands: { commitCoAuthor: "Sema <noreply@vivi-ai.com>" },
         brain,
         pricing,
         tracer: createTracer(metrics),
@@ -601,8 +606,7 @@ export async function runLocal(argv, deps = {}) {
     const runnerDeps = {
         ...sharedRunnerDeps,
         // ── 以下为主 runner 的差异键(不在共享基座;逐个有因)──────────────────────────────────────
-        // [931]① clay 拍:run-local=Sema 品牌本地形态,commit 尾注接 Sema 署名(core 1.300 缺省已翻转不署)。
-        hands: { commitCoAuthor: "Sema <noreply@vivi-ai.com>" },
+        // (`hands` 已随共享基座展开 —— 交接件⑤;这里手写同名键会 override 展开、把 subRunner 重新甩开。)
         sessionStore,
         ...(memoryEngine ? { memoryBackend: memoryEngine.backend, memoryEngineDir: memoryEngine.root } : {}),
         checkpointStore: fileBackend.checkpointStore,

package/dist/runtime-governance.d.ts

@@ -93,6 +93,39 @@ export declare function compileCommandPolicy(rules: CommandRule[] | undefined):
  *  - `auto` / `undefined` → `{}` (no extra tightening; still subject to the deployment baseline + commandPolicy).
  */
 export declare function autonomyOverrides(autonomy: Autonomy | undefined): Partial<TaskSpec>;
+/**
+ * #220:**部署级**判据 —— 本部署的治理层自己是否把 shellGate 抬到 `"always"`。
+ *
+ * 用途 = 持久门(park 行)的出身归因。活卡腿判「这只 ask 是治理层产的」靠 ALS 标记表(见本文件
+ * `createGovernanceAskMarkingPolicy` / `createGovernanceShellGateMarkPolicy`),而 park 腿天然跨副本、
+ * 跨重启,进程内的表在那里结构上够不着;行上唯一的取证格是 core 写的
+ * `gate.riskDescriptor.shellGateDoctrine`。
+ *
+ * 🔴 **为什么单看行上那一格不够**:有效档 `"always"` **不止治理层一个产地** —— `resolve-spec` 的 SUP 路由
+ * 姿态(`supPostureOverrides`)在 governance **之后**叠,同样产 `"always"`(本文件 `manualModeShellGate`
+ * 合成段的注释里已如实记着这条时序)。只看行 ⇒ 一条 SUP 路由出来的门会被谎报成「运维治理层强制」,
+ * 而那恰是这个信号要回答的那个问题。所以归因取**合取**:行上是 `always` **∧** 本部署的治理层本来就
+ * 要求 `always`(后者成立时,治理层就是一个真成因,SUP 是否也抬过不改变这句话的真假)。
+ *
+ * 判据逐字对着两个产地(与 `applyRuntimeGovernance` 里 `overrides.shellGate` 的取值同源):
+ * `autonomyOverrides(autonomy).shellGate`(`AUTONOMY=ask`)与 `MANUAL_MODE_SHELL_GATE` 旋钮,取「有一个
+ * 是 always」。`commandPolicy` 不入判据:它产的是 `toolPolicy` 的 ask,不抬 shellGate 档,与本格无关。
+ *
+ * ⚠️ **已知残留(codex 对抗复审 2026-08-11 逮到,如实登记而不是掩盖)**:本判据读的是**当下**的
+ * config,而 `config.autonomy` 是**热改**的(`config-center/apply-effective.ts` 就地写 `config.autonomy`)。
+ * 于是失真是**双向**的,不是我原先写的「只往缺席方向」:
+ *  · 缺席向(常见):mint 之后运维把 `AUTONOMY=ask` 撤了 ⇒ 老 park 行归不出治理出身,少标一个;
+ *  · **在场向**(窄):一条**纯 SUP 路由**产的门(`ROUTER_ENABLED` 开 ∧ 路由判 supervisor ∧ 当时治理层
+ *    并不要求 always),之后运维把 autonomy 热改成 `ask`,那条老行会被标成治理出身 —— 五个前提要**同时**
+ *    成立,且该行仍未决。
+ * 根治要**在 mint 那一刻把出身写进行里**(core 的 `CheckpointGate` 属主面,不是本仓能单方面做的);
+ * 在那之前这一位的定位是**分诊提示**,不是裁决输入 —— 它不参与任何门/CAS/resume 判定,消费端也只拿它
+ * 渲染徽标。登记在此,不加特征化测试(把已知残留钉成契约是另一种病)。
+ */
+export declare function governanceMandatesShellGateAlways(governance: {
+    autonomy?: Autonomy;
+    manualModeShellGate?: "always" | "classify";
+}): boolean;
 /**
  * Apply the operator's runtime governance (autonomy + commandPolicy + manualModeShellGate) onto a base
  * `TaskSpec`, TIGHTEN-ONLY, in a SINGLE {@link tightenTaskSpec} call: commandPolicy compiles to a `toolPolicy`

package/dist/runtime-governance.js

@@ -219,6 +219,38 @@ export function autonomyOverrides(autonomy) {
             return {};
     }
 }
+/**
+ * #220:**部署级**判据 —— 本部署的治理层自己是否把 shellGate 抬到 `"always"`。
+ *
+ * 用途 = 持久门(park 行)的出身归因。活卡腿判「这只 ask 是治理层产的」靠 ALS 标记表(见本文件
+ * `createGovernanceAskMarkingPolicy` / `createGovernanceShellGateMarkPolicy`),而 park 腿天然跨副本、
+ * 跨重启,进程内的表在那里结构上够不着;行上唯一的取证格是 core 写的
+ * `gate.riskDescriptor.shellGateDoctrine`。
+ *
+ * 🔴 **为什么单看行上那一格不够**:有效档 `"always"` **不止治理层一个产地** —— `resolve-spec` 的 SUP 路由
+ * 姿态(`supPostureOverrides`)在 governance **之后**叠,同样产 `"always"`(本文件 `manualModeShellGate`
+ * 合成段的注释里已如实记着这条时序)。只看行 ⇒ 一条 SUP 路由出来的门会被谎报成「运维治理层强制」,
+ * 而那恰是这个信号要回答的那个问题。所以归因取**合取**:行上是 `always` **∧** 本部署的治理层本来就
+ * 要求 `always`(后者成立时,治理层就是一个真成因,SUP 是否也抬过不改变这句话的真假)。
+ *
+ * 判据逐字对着两个产地(与 `applyRuntimeGovernance` 里 `overrides.shellGate` 的取值同源):
+ * `autonomyOverrides(autonomy).shellGate`(`AUTONOMY=ask`)与 `MANUAL_MODE_SHELL_GATE` 旋钮,取「有一个
+ * 是 always」。`commandPolicy` 不入判据:它产的是 `toolPolicy` 的 ask,不抬 shellGate 档,与本格无关。
+ *
+ * ⚠️ **已知残留(codex 对抗复审 2026-08-11 逮到,如实登记而不是掩盖)**:本判据读的是**当下**的
+ * config,而 `config.autonomy` 是**热改**的(`config-center/apply-effective.ts` 就地写 `config.autonomy`)。
+ * 于是失真是**双向**的,不是我原先写的「只往缺席方向」:
+ *  · 缺席向(常见):mint 之后运维把 `AUTONOMY=ask` 撤了 ⇒ 老 park 行归不出治理出身,少标一个;
+ *  · **在场向**(窄):一条**纯 SUP 路由**产的门(`ROUTER_ENABLED` 开 ∧ 路由判 supervisor ∧ 当时治理层
+ *    并不要求 always),之后运维把 autonomy 热改成 `ask`,那条老行会被标成治理出身 —— 五个前提要**同时**
+ *    成立,且该行仍未决。
+ * 根治要**在 mint 那一刻把出身写进行里**(core 的 `CheckpointGate` 属主面,不是本仓能单方面做的);
+ * 在那之前这一位的定位是**分诊提示**,不是裁决输入 —— 它不参与任何门/CAS/resume 判定,消费端也只拿它
+ * 渲染徽标。登记在此,不加特征化测试(把已知残留钉成契约是另一种病)。
+ */
+export function governanceMandatesShellGateAlways(governance) {
+    return autonomyOverrides(governance.autonomy).shellGate === "always" || governance.manualModeShellGate === "always";
+}
 /**
  * [2942]/[2943] `governanceForced` 的**写侧** —— 把内层策略(治理层自己合成的那些)产的 `ask` 记进标记表。
  *

package/dist/security.js

@@ -171,7 +171,9 @@ export function createAuthorizer(config, sessionStore) {
                     }
                 }
                 // Enforce ownership whenever the session HAS an owner — including against callers that present
-                // no principal (audit B, security.ts:77): with the old `principal &&` guard, a caller that
+                // no principal (audit B — the fix IS this guard, right here in `createAuthorizer`; no line-number
+                // anchor on purpose, the old `security.ts:77` pointer had drifted onto an unrelated JSDoc):
+                // with the old `principal &&` guard, a caller that
                 // omitted the header under requirePrincipal=false could attach to ANY owned session by id.
                 // Anonymous callers may still attach to anonymous (owner=null) sessions, so single-tenant dev
                 // (no principals anywhere) is unaffected; flipping the requirePrincipal default is NOT needed.

package/dist/tool-approval.d.ts

@@ -61,6 +61,38 @@ export interface ToolApprovalFrame {
      * `governance-ask-marks.ts` 顶注。
      */
     governanceForced?: true;
+    /**
+     * #144(core 5.25.0,[3438] 接力契约 / [3443] 主件;**ADDITIVE**,`"tool_approval"` only)——
+     * 这只 ask **命中了**调用方的一条持久 allow 规则,而那条规则**没能清掉它**。值 = 被越级的那条规则
+     * **原文**(core `AskRequest.persistedRuleShadowed`,四个 mint 点全带;core 侧已过 `inlineUntrusted`)。
+     *
+     * 🔴 **它存在的理由是一次真实的用户面回归**:core 5.25.0 收窄了消音边界(裁定逐字:「Allow rules
+     * silence the CLASSIFIER's questions, never a MANDATED one」)—— `shellGate:"always"` 的部署、工具自带
+     * egress/irreversible mark、以及既有的 governance 三类门下,用户此前被规则消掉的 ask **重新出现**。
+     * 没有这个键,人看到的是「我明明点过『不再询问』,它怎么又问」,唯一合理的结论是「我的规则坏了/没存上」。
+     * 有了它,壳能渲「你的规则仍在,只是这次调用被(运维令 / 工具本性)要求逐次确认」。
+     *
+     * 🔴 **缺席 ≠「你没有规则」**:本键只在「有规则命中 ∧ 规则清不掉这只 ask」时在场。绝大多数 ask
+     * 压根没有规则命中(缺席),而**命中且清掉了**的那些根本不会变成 ask(它们被消音了,没有卡)。
+     * 消费端禁把缺席读成「你在这条命令上没有规则」。
+     *
+     * 与 {@link ToolApprovalFrame.governanceForced} **刻意分列、不合并**:那个键回答「门是谁下的」
+     * (运维治理层),本键回答「你那条规则怎么了」。governance 只是不可消音的三个来源之一,另两个
+     * (doctrine `always` / 工具自带 mark)不打 governance 标 —— 合并会让后两类的 ask 要么谎报治理出身、
+     * 要么丢掉规则解释。出身的完整推法见 [3438]:`gate.safetyAxis` + `riskDescriptor.shellGateDoctrine` +
+     * `realApproval.origin` 组合读,server 不新铸出身键。
+     *
+     * 值是**用户内容族**(规则原文是人写的文本)⇒ 与 `message`/`sourceAgentName` 同待遇:`redactSecrets`
+     * 后上帧,UNTRUSTED-for-display。空串**不铸键**(core 只在真有命中时带它,空串是坏值不是「空规则」)。
+     *
+     * 耐久路(park 行)的对偶是 `gate.riskDescriptor.shadowedRule` —— 我方对 `riskDescriptor` 是**整体透传**
+     * (SQL 双生落整只 JSON 列、`listPending` 整只回读、两条 durable 读面整行上 wire),所以那一路**键集**零施工;
+     * 唯一的施工是**内容**:那两条读面(`GET /v1/approvals` + `/v1/approvals/stream`)在读边界对这一格补
+     * `redactSecrets`(core 只中和不脱敏,而运维队列是跨租户可见的那一条 —— 见
+     * `http/routes/approvals-assistant.ts` 的 `redactPendingDisclosures` 顶注)。
+     * 两路的钉见 `test/approval-shadowed-rule-wire.test.ts` 与 db-integration 的「#209 件4」格。
+     */
+    persistedRuleShadowed?: string;
     /**
      * #154 车二(core 5.18.0 design/179):`"tool_approval"` only —— 引擎为这次 ask 铸的**规则候选**
      * (`AskRequest.ruleSuggestions`,逐字透传:闭词表 `match` + 引擎铸的文本,server 不重铸不重排)。