@sema-agent/server 7.133.0 → 7.135.0

package/dist/approval-card.d.ts

@@ -87,6 +87,7 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
         host: "host";
         path: "path";
         exact: "exact";
+        pattern: "pattern";
         prefix: "prefix";
         wildcard: "wildcard";
         subpath: "subpath";
@@ -104,6 +105,7 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
             host: "host";
             path: "path";
             exact: "exact";
+            pattern: "pattern";
             prefix: "prefix";
             wildcard: "wildcard";
             subpath: "subpath";
@@ -128,116 +130,23 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
         }>;
     }, z.core.$strict>>>;
 }, z.core.$strict>]>;
+/** 读出来的一条 offer 与 core 给它的原始下标(调用方取前缀截时,下标仍是 core 列表里的那一位)。 */
+export interface ReadRuleOffer {
+    readonly index: number;
+    readonly offer: RuleOffer;
+}
 /**
- * {@link RuleOfferSchema} 的**不限长**孪生 —— 只判**结构**(闭词表 `kind`/`match`/`reason` + 若干字符串),
- * 长度由调用方在**脱敏之后**自己截。
- *
- * 🔴 为什么必须有它(codex 交叉复审 [medium],验真后修):`redactSecrets` **会变长**(一条
- * `password=…` 换成更长的遮蔽标记)。拿带 `.max()` 的形去校验**脱敏前**的原文,再脱敏,产出的就可能是
- * 一条超限的文本;而任何**回读**路径若再跑一遍同一个函数,那一条会在第二次校验时被整条丢掉 —— 于是
- * 「落库时在、读回时不在」,并且**只发生在有回读的那条腿上**(SQL 有列回读、LOCAL 直接从 blob 投),
- * 两个后端对同一份素材给出不同的卡面。同族先例逐字在 `tool-approval.ts` 的 `allowRuleShadowed`(7.41.x 时代叫 `persistedRuleShadowed`)
- * 发帧点(「先脱敏再截,一次算定」)。
- *
- * ⇒ 正确顺序:**结构判(本 schema)→ 脱敏 → 截长 → 结果按 {@link RuleOfferSchema} 必然合形**。
- * 这样函数对自己的输出**幂等**,两条腿同形。
- *
- * 🔴 **未知键 `strip`(合并码重扫放宽,重扫二轮改准形):窄读只判结构,多余键剥掉、且不拒收**。
- * base 带 `.strict()`,而 zod 4 的 `.extend()` **保留** strict —— core 给 `RuleOffer` 加一个 additive
- * 字段(它对这条面一贯的做法),逐条 `safeParse` 会**条条失败**,于是耐久腿的整只 offer 静默清零、列落
- * NULL、读口省键,把「有供给」谎报成「无供给」,正是本键存在理由的反面(`checkpoint-store-sql.ts` 顶注与
- * wire 契约都写死「缺席=真的没有 offer」)。同步腿的 `buildApprovalCard` 是显式逐键投影、对加字段天然免疫
- * ⇒ 不放宽这一份,两条腿会在「上游长一格」这条轴上分家。
- *
- * ⚠️ **写的是 `.strip()` 不是 `.loose()`**(重扫二轮,实测更正):zod 4 的 `loose` = **passthrough** ——
- * 未知键**原样留在** `parsed.data` 里,与本注和契约文写的「多余键剥掉」相反。放宽要的是「不拒收」,
- * 剥键是另一件事,`.loose()` 只做到了前者。旧形下真正在剥键的是 {@link boundedRuleOffers} 里那几行
- * 显式投影,于是本 schema 对「剥键」这条判据是**空跑**;而它是**导出符号**,output 类型带 index signature,
- * 任何新消费者拿 `parsed.data` 直投就把上游未知键(其上**没有** `redactSecrets` 覆盖)带上跨租户可见的
- * `GET /v1/approvals`。⇒ 改默认 strip 形:additive 加键照收、未知键当场剥掉,两个意图各自成立。
- * 落库/读回的 {@link ApprovalCardSchema} 仍 `.strict()`(投影只写已知键,多余键根本到不了那一层)。
- *
- * 🔴 **判别联合上的 strip 要逐臂加**(zod 4:`z.union` 自己没有 unknownKeys 政策,政策在成员上)——
- * 两臂各自 `.strip()`,batch 成员的两臂亦然,否则对 additive 加键仍是 strict 的,而那正是本注要拆的雷。
- *
- * 🔴 **闭词表不在放宽之列**([ref] B3 与 [ref] 词表纪律):`kind`(offer 与成员两级)/`match`/`reason`
- * 是闭集 —— 集外词 = 判假 = 整只 offer 丢(成员级的未知 `kind` 丢的是整只 batch,不是那一个成员;理由见
- * {@link RuleOfferBatchMemberSchema} 顶注)。「additive 加键照收」与「闭集加词即拒」是两条轴,别混。
- */
-export declare const RuleOfferRawSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"single">;
-    rule: z.ZodString;
-    match: z.ZodEnum<{
-        name: "name";
-        host: "host";
-        path: "path";
-        exact: "exact";
-        prefix: "prefix";
-        wildcard: "wildcard";
-        subpath: "subpath";
-        name_prefix: "name_prefix";
-        subdomain: "subdomain";
-    }>;
-    command: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"batch">;
-    rules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"command">;
-        rule: z.ZodString;
-        match: z.ZodEnum<{
-            name: "name";
-            host: "host";
-            path: "path";
-            exact: "exact";
-            prefix: "prefix";
-            wildcard: "wildcard";
-            subpath: "subpath";
-            name_prefix: "name_prefix";
-            subdomain: "subdomain";
-        }>;
-        command: z.ZodString;
-        segment: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"directoryRead">;
-        rule: z.ZodString;
-        directory: z.ZodString;
-        segment: z.ZodString;
-    }, z.core.$strip>]>>;
-    uncoveredSegments: z.ZodNumber;
-    uncoveredDetail: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        segment: z.ZodString;
-        reason: z.ZodEnum<{
-            redirection: "redirection";
-            no_rule_form: "no_rule_form";
-            cap_overflow: "cap_overflow";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>]>;
-/** {@link RuleOfferRawSchema} 的输出形(结构已判、文本未限长)—— 素材铸点在它上面做派生一致性与座尺两道后判。 */
-export type RuleOfferRaw = z.infer<typeof RuleOfferRawSchema>;
-/**
- * [ref] §3.5 —— `uncoveredDetail` 明细座的**座级**预筛,两条腿在 {@link RuleOfferRawSchema} 判形之前
- * 各调一次。
+ * **规则提议列表的唯一读者**(core 7.55.0 [ref] P1 阶段二)—— 两条腿同调:耐久腿(`checkpoint-store-sql.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行)
+ * 与同步腿(`tool-approval.ts` `boundRuleOfferTexts`:活 ask 的 `AskRequest.ruleOffers`)。判官是 core 的 `readRuleOffers`:逐元素判、保原始下标、多余键逐级剥、
+ * 闭集词(offer / 成员的 `kind`、`match`)不认 ⇒ 整只丢(batch 不拆成员)、无 `kind` 的存量成员读作 command、明细座不是「每个计数段一行」⇒ 只丢座。
+ * 修前本仓自己一份不限长 zod 形,前面垫两只预筛(无 `kind` 成员的回填、明细座的座级筛)—— 读的是 core 铸的形,读法却是本仓一份;core 对两者的 76 种形逐一对过,不同的三种是本仓的明细座行数帽(留在这里)与两种非 JSON 值(数组带属性、类实例)。
  *
- * 为什么要在整体判形之前单独筛这一座:core 明写「ABSENCE(an older minter, a degraded consumer's re-emit)
- * is not a claim」且 count 座是真源 —— 一座坏掉的明细(集外 reason / 非数组 / 与 count 不等 / 超帽)是
- * **展示轴**上的损坏,正确处置是「丢这一座、留 batch 本体」;让它把整只 batch 判假会把一条真可兑的合取批
- * 从卡上抹掉(方向反了:少一行解释是难看,少一只可兑的 offer 是把人的选项吃掉)。
- * 座被丢**必须留痕**([ref]:F 类 fail-open 走 `recordFailOpen`,计数 + 一次 warn)。
- * 只做浅层判别(不校验成员、不解构别的键),判形权威仍只有 zod 一处。
- */
-export declare function screenUncoveredDetailSeat(item: unknown): unknown;
-/**
- * [ref] B3 的**前一形**:pre-7.2 的 batch 成员没有 `kind`(那一形只有一种成员 —— 逐段 Bash 规则的四键),
- * 而本仓的耐久腿在 park 行 `pendingAction.ruleOffers` 里**已经落了**这种成员(`checkpoint.rule_suggestions`
- * 列),同步腿在 core 7.1.0 npm 字节下(本分支落 main 候 7.2.x)收到的也是它。B3 的降级臂说的是「`kind`
- * 不识 ⇒ 丢整批」;一个**缺席**的 `kind` 不是「不识」——旧形恰好只有一种成员,缺席就是 `command`,零歧义。
- * 所以这里做的是**已知旧形的 additive 回填**(浅层:仅当成员是对象、无 `kind` 键、且四个文本键在场时补
- * `kind:"command"`),不是放宽闭集:带着一个陌生 `kind` 值的成员一个字节不动,照旧在 zod 处判假丢整批。
- * 不回填的代价是真实的:滚动升级窗里,老二进制铸的每一条 park 行在新二进制的读面上整只 batch 消失
- * (「有供给」谎报成「无供给」,本键存在理由的反面)。
+ * 本仓只加一样东西:明细座的展示帽 {@link MAX_UNCOVERED_DETAIL_ROWS}(超帽丢整座,不截 —— 截过的座会让按契约校验「行数 = 计数」的消费端把整只 batch 判假),
+ * **扣在读之前**({@link withoutOverCapDetailSeat}:一只上万行的座不交给读者逐行判 —— 回读腿每 3s 一拍,读放大不许随一行坏数据无界)。
+ * 丢失**响亮**、一种报法:元素读不出(含整只值不是列表)⇒ `server.rule-offers.offer-dropped`(逐元素计);明细座丢(core 判丢或超帽)⇒ `server.rule-offers.uncovered-detail-dropped`。
+ * 缺席(`undefined`)= 没有提议,答空、不计。展示帽(条数、成员前缀、扫描窗)、脱敏与截长归调用方 —— 它们是各腿的展示纪律,不是读法。
  */
-export declare function backfillLegacyBatchMemberKind(item: unknown): unknown;
+export declare function readRuleOfferList(raw: unknown): readonly ReadRuleOffer[];
 /**
  * 卡面/帧面共用的 offer **投影型**(= {@link RuleOfferSchema} 的输出形)。判别位 `kind` 上闭集,
  * 消费端(SDK/cli 渲染)按 core 契约分臂;`batch.rules` 成员是判别联合(`command` | `directoryRead`),
@@ -248,11 +157,10 @@ export type RuleOfferProjection = z.infer<typeof RuleOfferSchema>;
 /**
  * 帧→卡素材的**显式逐键**复制(与旧形 `ruleSuggestions` 的内联三键 map 同职,换形后判别联合需要
  * 分臂,抽成具名函数)。为什么不 `structuredClone`/展开:显式逐键投影是本模块对「上游 additive
- * 加键」的免疫层(见 {@link RuleOfferRawSchema} 顶注)——加键到不了 `card_json`,strip 语义在
- * 投影处兑现,不靠 schema 层兜。
+ * 加键」的免疫层 —— 加键到不了 `card_json`,strip 语义在投影处兑现(读者 {@link readRuleOfferList} 也剥,两层各自成立)。
  *
- * 到这里的素材已经过素材铸点的结构窄读(`tool-approval.ts` `boundRuleOfferTexts` 拿 {@link RuleOfferRawSchema}
- * 判过形)⇒ 两级 `kind` 的运行期 `default` 臂在健康进程里不可达;它们守的是「本仓 dist 与 core 版本不同步」
+ * 到这里的素材已经过素材铸点的读者(`tool-approval.ts` `boundRuleOfferTexts` 经 {@link readRuleOfferList},判官 core `readRuleOffers`)
+ * ⇒ 两级 `kind` 的运行期 `default` 臂在健康进程里不可达;它们守的是「本仓 dist 与 core 版本不同步」
  * 那一形([ref] 词表范式:core 加臂 ⇒ `satisfies never` 编译红由人裁投影形;运行期撞到未知臂响亮抛,绝不把一个
  * 不认识的臂当 batch/command 硬投)。
  */
@@ -297,8 +205,8 @@ export declare function readProbeCause(req: unknown): ProbeCauseProjection | und
  *
  * 姿势逐条(与 {@link readProbeCause} / {@link readRuleEvidence} 同款分工):
  *  · `safeParse`,非串 ⇒ 按缺席处置(宪法 [ref]);空串 / 纯空白 ⇒ 缺席(core 自己也只在 `trim() !== ""` 时铸)。
- *  · 长度(S-733 信封):core 铸不出的长度 ⇒ **整只丢,不截**(判据与 `probeCause.code` 超限同形;截出来的是**另一句话**)。判官是 core 包根导出的
- *    `isMintableProbeReason`(core 7.53.0 #1883:上限 = core 的 cap + 它那一枚截断记号的宽度,「+1」只写在 core 一处;修前本仓手抄
+ *  · 长度([ref] 信封):core 铸不出的长度 ⇒ **整只丢,不截**(判据与 `probeCause.code` 超限同形;截出来的是**另一句话**)。判官是 core 包根导出的
+ *    `isMintableProbeReason`(core 7.53.0 [ref]:上限 = core 的 cap + 它那一枚截断记号的宽度,「+1」只写在 core 一处;修前本仓手抄
  *    `MAX_PROBE_REASON_CODEPOINTS = 201` —— 数字与「+1」两件事都是抄的)。超过它的值**不是 core 铸的**(第三方 producer / 世代差)。
  *    先判长度再脱敏 ⇒ 喂给脱敏器的永远是个短串(脱敏器的 RangeError 面是超大输入)。
  *  · 内容族(部署自写的探针散文,人眼信任边界上的文本)⇒ `redactSecrets`。脱敏后**不再截**:耐久面同样不截,
@@ -309,7 +217,7 @@ export declare function readProbeReason(req: unknown): string | undefined;
 /**
  * [ref](core 7.19.0)—— `readRootCandidate.dir` 的**上限**。
  *
- * 🔴 **本地孪生退役,改读 core 的导出**(core 7.26.0 / S-538 ⓐ,[ref] 手抄投影下线):此前这里是
+ * 🔴 **本地孪生退役,改读 core 的导出**(core 7.26.0 / [ref] ⓐ,[ref] 手抄投影下线):此前这里是
  * `export const MAX_READ_ROOT_CANDIDATE_DIR = 1024`,注里写着「core 的 `READ_ROOT_CANDIDATE_DIR_MAX`
  * **未从包根导出**,故钉本地孪生」—— 那句话在 7.26.0 起是过期的,而一份手抄的界与它的属主分家时**不会红**:
  * core 把界调宽,本仓照旧按旧数扣掉一个 core 认可的目录(卡上少一条出路,而人只会读成「没有出路」)。
@@ -366,7 +274,7 @@ export interface AllowRuleShadowProjection {
     omitted?: number;
 }
 /**
- * `AskRequest.allowRuleShadowed`(core 7.42.0 #1327)的**边界窄读** —— 活卡帧(`ToolApprovalFrame.allowRuleShadowed`)与 `card_json`
+ * `AskRequest.allowRuleShadowed`(core 7.42.0 [ref])的**边界窄读** —— 活卡帧(`ToolApprovalFrame.allowRuleShadowed`)与 `card_json`
  * (`buildApprovalCard`)的**唯一**铸造点,两面结构性同值(与 {@link readRuleEvidence} 同款分工)。姿势:
  *  · 整只形不合(不是数组 / 某条成员不在 core 闭集 / 条目不是字符串表 / `omitted` 不是正整数)⇒ 按缺席处置(半解上卡比缺席更坏);空数组 = 缺席;
  *  · 条目 = 内容族 ⇒ `redactSecrets` 后截 `MAX_RULE_TEXT_CHARS`,**先脱敏再截一次算定**(redact 会变长,两面各截会漂);超过
@@ -390,7 +298,7 @@ export declare function readRuleEvidence(req: unknown): RuleEvidenceProjection |
 /**
  * [ref] 第五单(core [ref] 修②)—— `ruleOffers` 缺席因由的**闭集**。
  *
- * 🔴 **型与运行期词表都读 core 的导出**(core 7.51.0 #1515 起 core 导出 `RULE_OFFERS_ABSENCES` 与 `RuleOffersAbsence`):
+ * 🔴 **型与运行期词表都读 core 的导出**(core 7.51.0 [ref] 起 core 导出 `RULE_OFFERS_ABSENCES` 与 `RuleOffersAbsence`):
  * 此前 core 刻意不导出这张词表,本仓只能自持一份手抄运行期表(zod 要字面元组)+ 两向编译围栏;core 给了常量之后
  * 那份手抄表与围栏退役(一个事实一个来源)—— 与 {@link AskEvidenceAbsenceSchema}「上游给了运行期常量就零词表」同一条纪律。
  * 7.51.0 的词:`mandated` / `allow_outranked` / `ask_rule_matched` / `lane_cannot_speak`(`shadowed` 退役、拆成中间两词)。
@@ -403,7 +311,7 @@ export declare const RuleOffersAbsenceSchema: z.ZodEnum<{
     lane_cannot_speak: "lane_cannot_speak";
 }>;
 /**
- * `ruleOffersAbsence` 座的**三态读数**(S-663 codex r1 起;此前是 {@link readRuleOffersAbsence} 函数体内的两步)。
+ * `ruleOffersAbsence` 座的**三态读数**([ref] codex r1 起;此前是 {@link readRuleOffersAbsence} 函数体内的两步)。
  * 一只 schema、一处解析,两个读者各自处置「**在场却读不出**」(集外词 / 非串值 = 世代差或第三方 producer):
  *  · 展示面 {@link readRuleOffersAbsence}(活卡帧 / `card_json`)—— 按缺席丢并计 F 类(卡上少一行解释 ≪ 卡上出现生词);
  *  · 耐久 `/decide` 腿的 remember 判据(`tool-approval.ts` 的 `parkRowStandingAnswerFacts` 的 `mandated` 一格,读 park 行上的
@@ -425,7 +333,7 @@ export declare function readRuleOffersAbsenceSeat(x: unknown): RuleOffersAbsence
  * `AskRequest.ruleOffersAbsence`(core [ref] 修②)的**边界窄读** —— 活卡帧与 `card_json` 的唯一铸造点
  * (与 {@link readProbeCause} 同款分工),两面结构性同值。闭集词 verbatim(非内容族,零 redact);
  * 形不合/缺席 ⇒ 不铸键(缺席不是断言 —— 它同时覆盖「有 offers」与结构性无车道的门,core 契约逐字)。
- * 解析在 {@link readRuleOffersAbsenceSeat}(与耐久腿判据共用一只 schema)。S-700 起第三个读者:运维队列行经
+ * 解析在 {@link readRuleOffersAbsenceSeat}(与耐久腿判据共用一只 schema)。[ref] 起第三个读者:运维队列行经
  * {@link parkRowFacts} 读寄存行上的 park 孪生座(`PendingAction.tool_approval.ruleOffersAbsence`,core 同一个 factory 铸的同一
  * 闭集)—— 同一只 schema、同一个集外 tag,三面结构性同值;集外 detail 经 {@link outOfSetDetail}(只读值,从不调用值)。
  */
@@ -433,20 +341,20 @@ export declare function readRuleOffersAbsence(req: unknown): RuleOffersAbsence |
 /**
  * park 行上两只 **`?: true` 孪生座**的名(core d.ts:「present (`true`) ⇔ … Absent otherwise (never `false`)」):
  *  · `requiresRealApproval`([ref])—— 这一问只有**真人**清得掉(连一揽子席也不得答;蕴含下一位);
- *  · `mandated`(#1079,core 7.31.0;S-663 二段 / S-723)—— 没有任何持久规则、也没有任何站着的答案退得掉这一问
+ *  · `mandated`([ref],core 7.31.0;[ref] 二段 / [ref])—— 没有任何持久规则、也没有任何站着的答案退得掉这一问
  *    (`AskRequest.mandated` 的 park 孪生,core 从行的规则报价工厂读的**同一份**清障事实铸)。
  * 两位同形同律 ⇒ 同一只读法 {@link readParkRowTrueSeat}(一处解析,名字是参数,不是两只各写一遍的函数)。
  * 型从 core 寄存行上取键(`keyof ToolApprovalPark` 约束):core 改名 / 退役任一位 ⇒ 这里 tsc 红。
  */
 export type ParkRowTrueSeat = Extract<keyof ToolApprovalPark, "requiresRealApproval" | "mandated">;
 /**
- * park 行 `?: true` 座的读数(NP-1 起;S-663 二段起名字是参数)—— **`=== true` 严判**,`false` 与其它值读作缺席
+ * park 行 `?: true` 座的读数(NP-1 起;[ref] 二段起名字是参数)—— **`=== true` 严判**,`false` 与其它值读作缺席
  * (core d.ts「Absent otherwise (never `false`)」;与 core `summarizeCheckpoint` 同一条判法:它把两位都筛成字面 `true`)。
  * `kind` 由调用方先判(本函数只读这一位)。两个读者共用这一只,解析单源、处置各归读者(与 {@link readRuleOffersAbsenceSeat}
  * 同一条分工):展示投影 {@link parkRowFacts}(队列行顶层展开)与耐久 `/decide` 腿的 remember 判据(`tool-approval.ts`
  * 的 `parkRowStandingAnswerFacts`)。这两位在两处方向相同(在场才算、读不出 = 缺席)⇒ 不需要三态、不计数(inbox 面对同一形
  * 同样静默缺席,两面同律);也因此权限面读它们**不经** `parkRowFacts` —— 那只展示投影顺手读 `ruleOffersAbsence` 并对集外词计
- * 展示面的 F 类 tag,而权限面对同一格是 fail-closed 的另一种处置(S-663 codex r1 钉「权限面不计展示面 tag」)。
+ * 展示面的 F 类 tag,而权限面对同一格是 fail-closed 的另一种处置([ref] codex r1 钉「权限面不计展示面 tag」)。
  */
 export declare function readParkRowTrueSeat(toolApproval: object, seat: ParkRowTrueSeat): boolean;
 /** core 寄存行的 `tool_approval` 臂(park 行事实全部住在这一臂上;其余臂没有工具字段)。 */
@@ -454,21 +362,21 @@ type ToolApprovalPark = Extract<CorePendingAction, {
     kind: "tool_approval";
 }>;
 /**
- * 🔴 **闭集词座的唯一窄读**(S-721 起 `mandate`;S-755 起 `origin`;S-1170 起 `classifierNoRuling` / `differs`)—— 一座一只成员筛,**名字是参数**(与
+ * 🔴 **闭集词座的唯一窄读**([ref] 起 `mandate`;[ref] 起 `origin`;[ref] 起 `classifierNoRuling` / `differs`)—— 一座一只成员筛,**名字是参数**(与
  * {@link readParkRowTrueSeat} 同一条:一处解析,不是两只各写一遍的函数)。
- *  · `mandate`(core 7.32.0 #1092)—— 一问**站在哪一个 mandate 词上**(`mandated` 说「站在强制上」,本座说是 core
+ *  · `mandate`(core 7.32.0 [ref])—— 一问**站在哪一个 mandate 词上**(`mandated` 说「站在强制上」,本座说是 core
  *    `PERSISTED_RULE_MANDATES` 六词里的哪一个;core 只在强制位的**整因**是那一个词时铸 —— 治理 / hook / 祖先,或不止一个理由
  *    ⇒ 缺席:缺席从不命名一个词)。读者:活卡帧与活挂起行读 `AskRequest.mandate`(`tool-approval.ts`),运维队列行读寄存行
  *    孪生座 `PendingAction.tool_approval.mandate`({@link parkRowFacts})。**不绑 `mandated`**(与 core `summarizeCheckpoint` 同一条筛法)。
- *  · `origin`(core 7.5.0 [ref] 的 park 孪生座;S-755)—— **谁提的这一问**,core `ASK_ORIGINS` 闭集一词。读者:运维队列行读寄存行
+ *  · `origin`(core 7.5.0 [ref] 的 park 孪生座;[ref])—— **谁提的这一问**,core `ASK_ORIGINS` 闭集一词。读者:运维队列行读寄存行
  *    孪生座 `PendingAction.tool_approval.origin`({@link parkRowFacts})。活卡帧**不经**本函数:它读引擎在门上刚盖好的
  *    `AskRequest.origin`(盖章点即 core 的筛点),照旧只过「非空串」形门(`tool-approval.ts` 帧键 `origin` 顶注)。
- *  · `classifierNoRuling`(core 7.43.0 #1353)—— 分类器没给判词的成因词,core `AUTO_MODE_FALLBACK_CAUSES` 闭集一词(筛 = `isAutoModeFallbackCause`)。
+ *  · `classifierNoRuling`(core 7.43.0 [ref])—— 分类器没给判词的成因词,core `AUTO_MODE_FALLBACK_CAUSES` 闭集一词(筛 = `isAutoModeFallbackCause`)。
  *    读者:活卡帧读 `AskRequest.classifierNoRuling`(`tool-approval.ts`);inbox 行读 core `CheckpointSummary` 已筛过的同名位、直投不经本函数。
- *  · `cause`(core 7.51.0 #1448)—— **载体是引擎续跑回执的 `details`**(不是 ask 的三个载体之一),值是起跑失败的成因词,core `RESUME_STARTUP_CAUSES` 闭集一词
+ *  · `cause`(core 7.51.0 [ref])—— **载体是引擎续跑回执的 `details`**(不是 ask 的三个载体之一),值是起跑失败的成因词,core `RESUME_STARTUP_CAUSES` 闭集一词
  *    (成员表取 core 常量;core 的 `resumeStartupCauseOf` 从失败的**码**读出)。读者:`parked-decide.ts` 的 422 `parked_resume.startup_failed` 体(`cause`)。
  *    回执没说 ⇒ 缺席(不计数,「分不出」是一等状态);集外词 / 非串 ⇒ 按缺席(键不上 wire)+ 计一次,与卡上的闭集词同一只计数。
- *  · `differs`(core 7.44.0 #1374)—— **载体是引擎拒 steer 重放那只错的 `detail`**(不是 ask 的三个载体之一),值是 core `STEER_REPLAY_FACETS` 的**非空子集**
+ *  · `differs`(core 7.44.0 [ref])—— **载体是引擎拒 steer 重放那只错的 `detail`**(不是 ask 的三个载体之一),值是 core `STEER_REPLAY_FACETS` 的**非空子集**
  *    (core:「恒非空」;筛 = 本文件 {@link isSteerReplayDiffers},成员表取 core 常量)。读者:`runs.ts` 的 409 `steering.duplicate_input_id` 体(`detail.differs`)。
  *    集外成员 / 空数组 / 非数组 ⇒ 按缺席(不铸 `detail`,码仍是契约)+ 计一次;detail 只报形名(`differs=<array>` —— 数组从不展开成员,见 {@link outOfSetDetail})。
  *
@@ -480,12 +388,12 @@ type ToolApprovalPark = Extract<CorePendingAction, {
  * **不抄词表**([ref]):闭集判定 = core 的成员筛({@link CLOSED_WORD_SEAT_GUARDS});值型 = core 寄存行上那一座的型。本仓对这些词
  * **零分支**(echo-only:core 原话「What a surface does with a word is the surface's own rule」)⇒ 没有需要穷举的 switch;将来本仓若按
  * 词分支,必须 `switch` 在 core 的值型上穷举。在场却读不出(集外词 / 非串值 —— 世代差、手改行)⇒ 按缺席处置 + 计一次
- * `server.approval-card.closed-word-out-of-set`(S-249 族:缺席从不计数、读不出计一次;detail 前缀 = 座名,诊断经 {@link outOfSetDetail},
+ * `server.approval-card.closed-word-out-of-set`([ref] 族:缺席从不计数、读不出计一次;detail 前缀 = 座名,诊断经 {@link outOfSetDetail},
  * 只读值不调用值)。
  */
 export declare function readClosedWordSeat<S extends ClosedWordSeat>(carrier: object, seat: S): ClosedWordOf<S> | undefined;
 /** ask 载体上的闭集词座名:三个 core 载体上**同名**(`AskRequest` / 寄存行 `tool_approval` 臂 / `CheckpointSummary`)—— 任一处改名 / 退役 ⇒ 下面的围栏编译红。
- *  S-1493(core 7.51.0 #1688)起第四座 `boundGrantAbsence`:卡为什么没有授予绑定摘要(`not_bindable` / `unreadable`)。 */
+ *  [ref](core 7.51.0 [ref])起第四座 `boundGrantAbsence`:卡为什么没有授予绑定摘要(`not_bindable` / `unreadable`)。 */
 type AskClosedWordSeat = "mandate" | "origin" | "classifierNoRuling" | "boundGrantAbsence";
 /** 闭集词座的名 = ask 载体上的三座 + 引擎拒 steer 重放那只错的 `detail.differs`(载体不同、读法同一只)。 */
 type ClosedWordSeat = AskClosedWordSeat | "differs" | "cause";
@@ -493,15 +401,15 @@ type ClosedWordSeat = AskClosedWordSeat | "differs" | "cause";
  *  `cause` = core 的 `ResumeStartupCause`(续跑回执 `details.cause` 的型)。 */
 type ClosedWordOf<S extends ClosedWordSeat> = S extends AskClosedWordSeat ? NonNullable<ToolApprovalPark[S]> : S extends "differs" ? readonly SteerReplayFacet[] : ResumeStartupCause;
 /**
- * 🔴 **S-934 ②(core 7.37.0 #1214)—— ask 类对的唯一窄读**:`askClass`(一问的类 = `classes` 的首员)与 `classes`(这一问属于的全部类,core
+ * 🔴 **[ref] ②(core 7.37.0 [ref])—— ask 类对的唯一窄读**:`askClass`(一问的类 = `classes` 的首员)与 `classes`(这一问属于的全部类,core
  * `ASK_CLASSES` 序)。三个载体上同名:`AskRequest`(活卡帧 / 呈卡帧的卡读它)、寄存行 `PendingAction.tool_approval`(运维队列行经
  * {@link parkRowFacts} 读它);`CheckpointSummary` 不回显(core 原句「read the row」)⇒ inbox 行不带。
  *
  * 判据(display,不是裁决输入 —— 裁决在 core 的仲裁点,本仓无人值守腿的按类作答读的是 core 交来的 `AskRequest.classes` 本身,不经本函数):
  *  · **两键都缺席 ⇒ 缺席**(不计数):老引擎(core 7.37.0 之前)、老行(续跑不补,KL-1214-b)、不盖 `origin` 的站(KL-1214-a)。缺席从不编默认类;
- *  · **在场 ⇒ 读法就是 core 的屏** `screenAskClassMembers`(S-955 ⑥,core 7.38.0 #1249 导出;引擎在写停车行前用的同一只):`askClass` 在集、`classes`
+ *  · **在场 ⇒ 读法就是 core 的屏** `screenAskClassMembers`([ref] ⑥,core 7.38.0 [ref] 导出;引擎在写停车行前用的同一只):`askClass` 在集、`classes`
  *    非空数组且每员在集、无重复、按 `ASK_CLASSES` 规范序取首员 === `askClass`;屏收 ⇒ 投屏给的规范序副本。屏拒(半对 / 集外词 / 首员不符 /
- *    重复员)⇒ **两键都不投**(卡上少一行类 ≪ 卡上出现生词或半只对)+ 计一次 `server.approval-card.closed-word-out-of-set`(S-249 族,detail 前缀
+ *    重复员)⇒ **两键都不投**(卡上少一行类 ≪ 卡上出现生词或半只对)+ 计一次 `server.approval-card.closed-word-out-of-set`([ref] 族,detail 前缀
  *    `askClass=` / `classes=` 判别是哪一格读不出 —— 前缀只是诊断,判据只有屏一条)。
  *  · 本仓**零自写对判**(修前这里与 {@link ApprovalCardSchema} 的 superRefine 各写一份「`classes[0] === askClass`」,按输入首员比、收重复员,与引擎的
  *    屏是两条规则)。投出去的 `classes` 是新数组(帧不与载体共享可变引用;屏给的是冻结数组)。
@@ -513,31 +421,31 @@ export interface AskClassPair {
     classes: Array<NonNullable<ToolApprovalPark["classes"]>[number]>;
 }
 /**
- * 🔴 S-700 P1(client-core CC-180 / cli L-652 的根子;板 [ref] 订正 → [ref] 立案)—— **park 行事实**:
- * 运维队列行(`GET /v1/approvals` + `/stream`)顶层展开的那几位。型**从 core 寄存行派生,不手抄**(S-249 同一条
+ * 🔴 [ref] P1(client-core [ref] / cli [ref] 的根子;板 [ref] 订正 → [ref] 立案)—— **park 行事实**:
+ * 运维队列行(`GET /v1/approvals` + `/stream`)顶层展开的那几位。型**从 core 寄存行派生,不手抄**([ref] 同一条
  * 纪律):core 改名 / 退役任一位 ⇒ 这里 tsc 红;这一位与 {@link RuleOffersAbsence}(从 `AskRequest` 派生)两个
  * 联合漂开 ⇒ {@link parkRowFacts} 的返回处 tsc 红(core 说两座是同一个 factory 铸的同一闭集,本仓照此钉)。
  *
  * 两只店的 `PendingCheckpoint` **直接继承本型**(`extends`),于是 core 再给这一臂加一位同类事实时,两店与路由零改 ——
- * S-663 二段(core #1079,7.31.0)的 `mandated` 就是这么到货的。要改的三处,编译器逐一点名:这张 Pick 表加一个名 +
+ * [ref] 二段(core [ref],7.31.0)的 `mandated` 就是这么到货的。要改的三处,编译器逐一点名:这张 Pick 表加一个名 +
  * {@link parkRowFacts} 函数体一行 + `trace/core-keyset-guard.ts` ⑧b 的 EXCLUDED 簿删掉这个名(⑧b 的事实段**从本型派生**,
  * 8D-1 / 车OC 起单写者 —— 名字进了本表却还躺在 EXCLUDED 里 ⇒ `_NoDoubleBookParkArmQueue` 当拍红);`test/park-row-facts.test.ts`
  * 的 `FACT_KEYS` 对本型双向围栏,少列一名同样编译红。
  * core d.ts 说三位彼此独立:`requiresRealApproval`(只有人能清 —— 蕴含 `mandated`)、`mandated`(没有规则能清)、
  * `ruleOffersAbsence`(报价车道有什么可给;「never a substitute for this one」)—— 投影逐位照投,不互推。
- * S-721(core 7.32.0 #1092)第四位 `mandate`:强制位站在哪一个词上(经 {@link readClosedWordSeat};词缺席 ≠ 不强制,不从 `mandated` 推)。
- * S-755(cli L-695 / [ref],client-core [ref])第五位 `origin`:谁提的这一问(core `ASK_ORIGINS` 闭集一词,经 {@link readClosedWordSeat};
+ * [ref](core 7.32.0 [ref])第四位 `mandate`:强制位站在哪一个词上(经 {@link readClosedWordSeat};词缺席 ≠ 不强制,不从 `mandated` 推)。
+ * [ref](cli [ref] / [ref],client-core [ref])第五位 `origin`:谁提的这一问(core `ASK_ORIGINS` 闭集一词,经 {@link readClosedWordSeat};
  * 与活卡帧 `origin` / inbox 行 `origin` 同名同义同值)。此前只有活卡帧与 inbox 行带它 ⇒ 耐久重开 / 重连时壳从队列行读不到出身词,
- * bypass 姿态下按 `ask_rule` / `hook` 照问的那条壳规则无从落地。缺席 = 老行(core 7.5.0 之前 park 的)/ 集外词(计 S-249 tag)。
- * S-934 ②(core 7.37.0 #1214)第六 / 七位 `askClass` / `classes`:这一问的类对(经 {@link readAskClassPair};两位同在同缺,与活卡帧 / 呈卡帧的卡
- * 同名同义同值)—— durable 审批席按类答的依据。缺席 = 老行(core 7.37.0 之前 park 的,续跑不补)/ 读不出(计 S-249 tag)。
- * S-1493(core 7.51.0 #1688)第八位 `boundGrantAbsence`:这张卡为什么没有授予绑定摘要(经 {@link readClosedWordSeat};与活卡帧 / inbox 行同名同义同值)——
+ * bypass 姿态下按 `ask_rule` / `hook` 照问的那条壳规则无从落地。缺席 = 老行(core 7.5.0 之前 park 的)/ 集外词(计 [ref] tag)。
+ * [ref] ②(core 7.37.0 [ref])第六 / 七位 `askClass` / `classes`:这一问的类对(经 {@link readAskClassPair};两位同在同缺,与活卡帧 / 呈卡帧的卡
+ * 同名同义同值)—— durable 审批席按类答的依据。缺席 = 老行(core 7.37.0 之前 park 的,续跑不补)/ 读不出(计 [ref] tag)。
+ * [ref](core 7.51.0 [ref])第八位 `boundGrantAbsence`:这张卡为什么没有授予绑定摘要(经 {@link readClosedWordSeat};与活卡帧 / inbox 行同名同义同值)——
  * `not_bindable` = 这一问不绑任何授予(「本会话放行」可按工具记)。缺席 = 技能卡(带摘要;摘要不上队列行,见 ⑧b)/ 7.51.0 之前停驻的行(core inbox 投
- * `unreadable`,队列行如实缺席)/ 集外词(计 S-249 tag)。
+ * `unreadable`,队列行如实缺席)/ 集外词(计 [ref] tag)。
  */
 export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "ruleOffersAbsence" | "mandated" | "mandate" | "origin" | "askClass" | "classes" | "boundGrantAbsence">;
 /**
- * S-700 —— park 行事实的**唯一投影**(`pendingAction` 是寄存行上 core 铸的那一只,读自持久层 ⇒ `unknown`)。
+ * [ref] —— park 行事实的**唯一投影**(`pendingAction` 是寄存行上 core 铸的那一只,读自持久层 ⇒ `unknown`)。
  *
  * 病:core 在寄存行 `PendingAction.tool_approval` 上铸的「卡读者该看的事实」(core [ref] 原话:「the SAME fact,
  * restated where a card reader looks for it」)中 `requiresRealApproval` 经 core `summarizeCheckpoint` 早就上了 inbox(`ruleOffersAbsence`
@@ -563,12 +471,12 @@ export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "rule
  * 不许拿本函数的产物去推强制 —— 两者共用的是 schema,不是折叠。
  */
 export declare function parkRowFacts(stored: unknown): ParkRowFacts;
-/** S-114(core 7.4.0 [ref])—— 回落卡的计数与窗。`limit` 是**闭二词**(core d.ts 逐字),两个计数是
+/** [ref](core 7.4.0 [ref])—— 回落卡的计数与窗。`limit` 是**闭二词**(core d.ts 逐字),两个计数是
  *  非负整数,`autoDenyAfterMs` 是 core 契约里的 `0..2147483647` 非负整数(`0` = 本卡不武装窗:部署把
  *  旋钮关了,或 TOTAL 档的卡按 [ref]① 恒 0 等人)。四成员**全必填**——core 的 `DenialLimitFallback` 上
  *  没有一个可选位,所以「少一位」不是老 core 而是坏值,整键不铸(与 `readRuleEvidence` 的恰一不变量
  *  同款判据:形不合 ⇒ 丢整键,绝不半铸一张让人误读计数的卡)。 */
-declare const DenialLimitFallbackSchema: z.ZodObject<{
+export declare const DenialLimitFallbackSchema: z.ZodObject<{
     consecutive: z.ZodNumber;
     total: z.ZodNumber;
     limit: z.ZodEnum<{
@@ -636,6 +544,7 @@ export declare const ApprovalCardSchema: z.ZodObject<{
             host: "host";
             path: "path";
             exact: "exact";
+            pattern: "pattern";
             prefix: "prefix";
             wildcard: "wildcard";
             subpath: "subpath";
@@ -653,6 +562,7 @@ export declare const ApprovalCardSchema: z.ZodObject<{
                 host: "host";
                 path: "path";
                 exact: "exact";
+                pattern: "pattern";
                 prefix: "prefix";
                 wildcard: "wildcard";
                 subpath: "subpath";
@@ -717,8 +627,8 @@ export declare const ApprovalCardSchema: z.ZodObject<{
         }, z.core.$strict>>>;
         personalRuleDotsAbsent: z.ZodOptional<z.ZodCustom<AskEvidenceAbsence, AskEvidenceAbsence>>;
     }, z.core.$strict>>;
-    askClass: z.ZodOptional<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>;
-    classes: z.ZodOptional<z.ZodArray<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>>;
+    askClass: z.ZodOptional<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>>;
     fromSubagent: z.ZodOptional<z.ZodLiteral<true>>;
     sourceTaskId: z.ZodOptional<z.ZodString>;
     sourceAgentName: z.ZodOptional<z.ZodString>;
@@ -774,6 +684,7 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
                 host: "host";
                 path: "path";
                 exact: "exact";
+                pattern: "pattern";
                 prefix: "prefix";
                 wildcard: "wildcard";
                 subpath: "subpath";
@@ -791,6 +702,7 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
                     host: "host";
                     path: "path";
                     exact: "exact";
+                    pattern: "pattern";
                     prefix: "prefix";
                     wildcard: "wildcard";
                     subpath: "subpath";
@@ -855,8 +767,8 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
             }, z.core.$strict>>>;
             personalRuleDotsAbsent: z.ZodOptional<z.ZodCustom<AskEvidenceAbsence, AskEvidenceAbsence>>;
         }, z.core.$strict>>;
-        askClass: z.ZodOptional<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>;
-        classes: z.ZodOptional<z.ZodArray<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>>;
+        askClass: z.ZodOptional<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>;
+        classes: z.ZodOptional<z.ZodArray<z.ZodCustom<"mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", "mode" | "hook" | "org_rule" | "write_protection" | "target_unresolved" | "content_question" | "ask_rule" | "denial_limit_fallback" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "rule_unreadable" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary">>>;
         fromSubagent: z.ZodOptional<z.ZodLiteral<true>>;
         sourceTaskId: z.ZodOptional<z.ZodString>;
         sourceAgentName: z.ZodOptional<z.ZodString>;
@@ -901,7 +813,7 @@ export interface ApprovalCardSource {
      *  `ApprovalCardSchema.ruleOffers`)。与 wire 帧**同一份素材** ⇒ live 帧 / `card_json` / 重放帧
      *  三面同源。 */
     ruleOffers?: readonly RuleOffer[];
-    /** S-934 ②:类对 —— 与 wire 帧**同一份素材**(发帧点经 `readAskClassPair` 窄读定;`ToolApprovalFrame` 结构上满足本接口)⇒ live 帧 /
+    /** [ref] ②:类对 —— 与 wire 帧**同一份素材**(发帧点经 `readAskClassPair` 窄读定;`ToolApprovalFrame` 结构上满足本接口)⇒ live 帧 /
      *  `approval_request` / `card_json` / 重放帧四面同源。两键同在同缺。 */
     askClass?: AskClass;
     classes?: readonly AskClass[];
@@ -929,7 +841,7 @@ export declare function buildApprovalCard(source: ApprovalCardSource, req: unkno
 /** 落库信封的纯构造(写侧;读侧 = {@link readStoredCardEnvelope},**同一个 schema**)。 */
 export declare function buildApprovalCardEnvelope(approvalId: string, card: ApprovalCard): ApprovalCardEnvelope;
 /**
- * 🔴 **存下的卡的唯一读者入口**(S-1562)—— `approval_ask.card_json` 的每一个读点(断连重放 {@link buildReplayFrame}、回决口的「要不要人」
+ * 🔴 **存下的卡的唯一读者入口**([ref])—— `approval_ask.card_json` 的每一个读点(断连重放 {@link buildReplayFrame}、回决口的「要不要人」
  * {@link storedCardDemandsAPerson}、幂等重入与规则兑付两处(`tool-approval.ts`)、local 车道的启动收敛(`approval-crash-convergence.ts`))都经这一只,
  * 不各自 `safeParse`(修前五处各写一遍 —— 读法的任何一次改动都要改五处,漏一处就是两种读法)。
  *
@@ -941,7 +853,7 @@ export declare function buildApprovalCardEnvelope(approvalId: string, card: Appr
  */
 export declare function readStoredCardEnvelope(cardJson: unknown): ApprovalCardEnvelope | undefined;
 /**
- * 🔴 **停驻行 `tool_approval` 臂的读侧入口**(S-1562;一次性迁移 M18 的读侧半场)—— 读它两座的两个读者(运维队列行 {@link parkRowFacts}、
+ * 🔴 **停驻行 `tool_approval` 臂的读侧入口**([ref];一次性迁移 M18 的读侧半场)—— 读它两座的两个读者(运维队列行 {@link parkRowFacts}、
  * 耐久 `/decide` 的 remember 判据 `tool-approval.ts` `parkRowStandingAnswerFacts`)先经这一只:7.50.x 停驻的行上两座的退役词按 M18 那一只改写读,
  * 响亮(同一个 tag)。停驻行是**引擎写的文档**,没有起服改写这一半:引擎的行摘要覆盖类对 `askClass` / `classes`,本服务改写 = 续跑判官判 `damaged`、拒续跑 ⇒ **所有**停驻行
  * (SQL 店的、local 车道引擎 File 店的)都只在这里读时改写,交的是浅拷贝,被读的行一个字节不动。
@@ -993,7 +905,7 @@ export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
     /** = SSE 具名事件名(与 `tool_approval` 同约定)。 */
     type: "approval_request";
     schemaVersion: 1;
-    /** `deriveAskId` 派生(持久层主键;六元身份元组 —— S-944 / 7.109.0 起含这一问的类集 —— 见 approval-ask-machine.ts)。 */
+    /** `deriveAskId` 派生(持久层主键;六元身份元组 —— [ref] / 7.109.0 起含这一问的类集 —— 见 approval-ask-machine.ts)。 */
     askId: string;
     /** wire run id(= 协调器 ctx 的 taskId)。 */
     taskId: string;
@@ -1105,7 +1017,7 @@ export declare function buildRevokeFrame(batchId: string, askIds: readonly strin
  */
 export declare function buildReplayFrame(row: AskRow, nowMs: number): ApprovalRequestFrame | undefined;
 /**
- * S-1154 —— 持久行上那张卡**要不要人**:卡面 `risk.requiresRealApproval`(铸卡时取自引擎在 `AskRequest` 上盖的同一位,
+ * [ref] —— 持久行上那张卡**要不要人**:卡面 `risk.requiresRealApproval`(铸卡时取自引擎在 `AskRequest` 上盖的同一位,
  * {@link buildApprovalCard} 第三参)。读者 = 耐久 ask 回决口在裁决之前交给引擎判官 `policyCannotAnswer` 的那一问(`host-decision.ts` 的 `heldAskOf`)。
  * 🔴 读不出卡(`card_json` 形不合)⇒ **按要人读**(fail-closed):这一位只用来**拒**策略的放行,读坏的行上拒一次可以改成人答 / 策略拒
  * 再来;反方向(读坏当不要人)会让一次引擎终将拒掉的放行先落成一条宣称 approve 的行。

package/dist/approval-card.js

@@ -1,10 +1,9 @@
 import { z } from "zod";
-import { ALLOW_RULE_MEMBERS, ASK_EVIDENCE_ABSENCE_VALUES, BOUND_GRANT_ABSENCES, MAX_RULE_TEXT_CHARS, READ_ROOT_CANDIDATE_DIR_MAX, RESUME_STARTUP_CAUSES, RULE_OFFERS_ABSENCES, STEER_REPLAY_FACETS, isAskClass, isAskOrigin, isAutoModeFallbackCause, isMintableProbeReason, isPersistedRuleMandate, screenAskClassMembers } from "@sema-agent/core";
+import { ALLOW_RULE_MEMBERS, ASK_EVIDENCE_ABSENCE_VALUES, BOUND_GRANT_ABSENCES, DENIAL_LIMIT_BOUNDS, MAX_RULE_TEXT_CHARS, PERSISTED_RULE_MATCHES, UNCOVERED_SEGMENT_REASONS, READ_ROOT_CANDIDATE_DIR_MAX, RESUME_STARTUP_CAUSES, RULE_OFFERS_ABSENCES, RULE_OFFER_KINDS, STEER_REPLAY_FACETS, isAskClass, readRuleOffers, isAskOrigin, isAutoModeFallbackCause, isMintableProbeReason, isPersistedRuleMandate, screenAskClassMembers } from "@sema-agent/core";
 import { redactSecrets } from "./trace/redact.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { capText } from "./caller-text-echo.js";
 import { retireParkArmWords, retireStoredCardWords } from "./retired-card-words.js";
-import { PERSISTED_RULE_MATCHES, UNCOVERED_SEGMENT_REASONS } from "./permission-rule-vocab.js";
 export const MAX_AGENT_NAME = 200;
 const MAX_IDENT = 200;
 export const MAX_RULE_OFFERS = 4;
@@ -32,10 +31,9 @@ const RuleOfferBatchMemberSchema = z.union([
         .strict(),
 ]);
 const UncoveredSegmentDetailSchema = z.object({ segment: z.string().max(MAX_RULE_TEXT_CHARS), reason: UncoveredReasonSchema }).strict();
-const UncoveredSegmentDetailRawSchema = z.object({ segment: z.string(), reason: UncoveredReasonSchema }).strip();
-export const RuleOfferSchema = z.union([
-    z.object({ kind: z.literal("single"), rule: z.string().max(MAX_RULE_TEXT_CHARS), match: RuleMatchSchema, command: z.string().max(MAX_RULE_TEXT_CHARS) }).strict(),
-    z
+const RULE_OFFER_ARMS = {
+    single: z.object({ kind: z.literal("single"), rule: z.string().max(MAX_RULE_TEXT_CHARS), match: RuleMatchSchema, command: z.string().max(MAX_RULE_TEXT_CHARS) }).strict(),
+    batch: z
         .object({
         kind: z.literal("batch"),
         rules: z.array(RuleOfferBatchMemberSchema).min(1).max(MAX_RULE_OFFER_BATCH_MEMBERS),
@@ -43,56 +41,39 @@ export const RuleOfferSchema = z.union([
         uncoveredDetail: z.array(UncoveredSegmentDetailSchema).max(MAX_UNCOVERED_DETAIL_ROWS).optional(),
     })
         .strict(),
-]);
-export const RuleOfferRawSchema = z.union([
-    z.object({ kind: z.literal("single"), rule: z.string(), match: RuleMatchSchema, command: z.string() }).strip(),
-    z
-        .object({
-        kind: z.literal("batch"),
-        rules: z
-            .array(z.union([
-            z.object({ kind: z.literal("command"), rule: z.string(), match: RuleMatchSchema, command: z.string(), segment: z.string() }).strip(),
-            z.object({ kind: z.literal("directoryRead"), rule: z.string(), directory: z.string(), segment: z.string() }).strip(),
-        ]))
-            .min(1),
-        uncoveredSegments: z.number().int().nonnegative().safe(),
-        uncoveredDetail: z.array(UncoveredSegmentDetailRawSchema).optional(),
-    })
-        .strip(),
-]);
-export function screenUncoveredDetailSeat(item) {
+};
+export const RuleOfferSchema = z.union([RULE_OFFER_ARMS.single, RULE_OFFER_ARMS.batch]);
+const OFFER_DROP_WHY = {
+    not_an_array: "the stored value is not a list",
+    unknown_word: "a closed-set member holds a word this engine does not know",
+    malformed: "an element is not an offer this engine reads",
+};
+function recordOfferDropped(problem, index) {
+    recordFailOpen("server.rule-offers.offer-dropped", `${index !== undefined ? `index=${index} ` : ""}problem=${problem} (${OFFER_DROP_WHY[problem]})`);
+}
+export function readRuleOfferList(raw) {
+    const reading = readRuleOffers(Array.isArray(raw) ? raw.map(withoutOverCapDetailSeat) : raw);
+    if ("problem" in reading) {
+        recordOfferDropped(reading.problem);
+        return [];
+    }
+    reading.dropped.forEach((d) => recordOfferDropped(d.problem, d.index));
+    return reading.offers.map(withDetailSeatBounded);
+}
+function withoutOverCapDetailSeat(item, index) {
     if (typeof item !== "object" || item === null)
         return item;
     const candidate = item;
-    if (candidate.kind !== "batch" || !("uncoveredDetail" in candidate) || candidate.uncoveredDetail === undefined)
+    if (candidate.kind !== "batch" || !Array.isArray(candidate.uncoveredDetail) || candidate.uncoveredDetail.length <= MAX_UNCOVERED_DETAIL_ROWS)
         return item;
-    const rows = candidate.uncoveredDetail;
-    const wellFormed = Array.isArray(rows) &&
-        rows.length <= MAX_UNCOVERED_DETAIL_ROWS &&
-        rows.length === candidate.uncoveredSegments &&
-        rows.every((r) => UncoveredSegmentDetailRawSchema.safeParse(r).success);
-    if (wellFormed)
-        return item;
-    recordFailOpen("server.rule-offers.uncovered-detail-dropped", Array.isArray(rows) ? `rows=${rows.length} count=${String(candidate.uncoveredSegments)}` : `seat is ${typeof rows}`);
-    const { uncoveredDetail: _dropped, ...rest } = candidate;
+    recordFailOpen("server.rule-offers.uncovered-detail-dropped", `index=${index} rows=${candidate.uncoveredDetail.length} cap=${MAX_UNCOVERED_DETAIL_ROWS}`);
+    const { uncoveredDetail: _overCap, ...rest } = candidate;
     return rest;
 }
-export function backfillLegacyBatchMemberKind(item) {
-    if (typeof item !== "object" || item === null)
-        return item;
-    const candidate = item;
-    if (candidate.kind !== "batch" || !Array.isArray(candidate.rules))
-        return item;
-    const isLegacy = (m) => typeof m === "object" &&
-        m !== null &&
-        !("kind" in m) &&
-        typeof m.rule === "string" &&
-        typeof m.match === "string" &&
-        typeof m.command === "string" &&
-        typeof m.segment === "string";
-    if (!candidate.rules.some(isLegacy))
-        return item;
-    return { ...candidate, rules: candidate.rules.map((m) => (isLegacy(m) ? { kind: "command", ...m } : m)) };
+function withDetailSeatBounded(read) {
+    if (read.uncoveredDetailDropped === true)
+        recordFailOpen("server.rule-offers.uncovered-detail-dropped", `index=${read.index} seat is not one well-formed row per counted segment`);
+    return { index: read.index, offer: read.offer };
 }
 export function copyRuleOffer(o) {
     switch (o.kind) {
@@ -364,11 +345,11 @@ export function parkRowFacts(stored) {
         ...(boundGrantAbsence !== undefined ? { boundGrantAbsence } : {}),
     };
 }
-const DenialLimitFallbackSchema = z
+export const DenialLimitFallbackSchema = z
     .object({
     consecutive: z.number().int().nonnegative(),
     total: z.number().int().nonnegative(),
-    limit: z.enum(["consecutive", "total"]),
+    limit: z.enum(DENIAL_LIMIT_BOUNDS),
     autoDenyAfterMs: z.number().int().nonnegative().max(2147483647),
 })
     .strict();