@sema-agent/server 7.134.0 → 7.136.0

package/dist/approval-card.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import { ALLOW_RULE_MEMBERS, ASK_EVIDENCE_ABSENCE_VALUES, BOUND_GRANT_ABSENCES, MAX_RULE_TEXT_CHARS, PERSISTED_RULE_MATCHES, UNCOVERED_SEGMENT_REASONS, 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, TOOL_APPROVAL_CARDS, 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 { readApprovalCard } from "./approval-content-kind.js";
 import { capText } from "./caller-text-echo.js";
 import { retireParkArmWords, retireStoredCardWords } from "./retired-card-words.js";
 export const MAX_AGENT_NAME = 200;
@@ -31,10 +32,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),
@@ -42,56 +42,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) {
@@ -363,11 +346,24 @@ export function parkRowFacts(stored) {
         ...(boundGrantAbsence !== undefined ? { boundGrantAbsence } : {}),
     };
 }
-const DenialLimitFallbackSchema = z
+export function skillCardFacts(summary) {
+    return {
+        ...(summary.boundGrantDigest !== undefined ? { boundGrantDigest: summary.boundGrantDigest } : {}),
+        ...(summary.boundGrants !== undefined ? { boundGrants: summary.boundGrants } : {}),
+        ...(summary.classifierNoRuling !== undefined ? { classifierNoRuling: summary.classifierNoRuling } : {}),
+    };
+}
+export function parkRowCarriesSkillCardFacts(stored) {
+    if (typeof stored !== "object" || stored === null || !("kind" in stored) || stored.kind !== "tool_approval")
+        return false;
+    const digest = "boundGrantDigest" in stored ? stored.boundGrantDigest : undefined;
+    return typeof digest === "string" || ("classifierNoRuling" in stored && stored.classifierNoRuling !== undefined);
+}
+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();
@@ -395,6 +391,7 @@ export const ApprovalCardSchema = z
         .strict(),
     governanceForced: z.literal(true).optional(),
     rememberRefused: z.literal(true).optional(),
+    approvalCard: z.enum(TOOL_APPROVAL_CARDS).optional(),
     inputHasBidi: z.literal(true).optional(),
     allowRuleShadowed: z
         .array(z
@@ -462,6 +459,7 @@ export function buildApprovalCard(source, req, requiresRealApproval) {
     const sourceTaskId = capText(source.sourceTaskId, MAX_IDENT);
     const sourceAgentName = capText(source.sourceAgentName, MAX_AGENT_NAME);
     const allowRuleShadowed = readAllowRuleShadowed(req);
+    const approvalCard = readApprovalCard(source.approvalCard);
     return {
         toolName: capText(source.toolName, MAX_IDENT) ?? "",
         message: capText(source.message, MAX_MESSAGE) ?? "",
@@ -474,6 +472,7 @@ export function buildApprovalCard(source, req, requiresRealApproval) {
         },
         ...(source.governanceForced === true ? { governanceForced: true } : {}),
         ...(source.rememberRefused === true ? { rememberRefused: true } : {}),
+        ...(approvalCard !== undefined ? { approvalCard } : {}),
         ...(source.inputHasBidi === true ? { inputHasBidi: true } : {}),
         ...(allowRuleShadowed !== undefined ? { allowRuleShadowed } : {}),
         ...(probeCause !== undefined ? { probeCause } : {}),

package/dist/approval-content-kind.d.ts

@@ -1,12 +1,12 @@
 /**
  * 审批卡的**卡词**读口(server 侧唯一一处)与保留问答工具名的再导出。
  *
- * ── 规则(core 7.49.0 #1414 / #1468 A-S4)────────────────────────────────────────────────────────────
+ * ── 规则(core 7.49.0 [ref] / [ref] A-S4)────────────────────────────────────────────────────────────
  * 「这一问 / 这一行用哪张卡」只有一个事实源 = **引擎铸的 `approvalCard`**(闭集 core `TOOL_APPROVAL_CARDS`):活 ask 上是
  * `AskRequest.approvalCard`,停驻行上是门的 `gate.approvalCard`(core `summarizeCheckpoint` 投给 `CheckpointSummary.approvalCard`
  * 的同一个词)。停驻行到期走哪条路只有一个判官 = core `facetOf(gate)`(问答卡 ⇒ `B`,到期作废;其余审批门 ⇒ `A`,SLA 拒扫腿 deny)。
  * 本仓**不从工具名回推卡**:此前的 `contentKindOf`(工具名 ⇒ `"content_ask"`)、两只店里按 `tool_name` 判问答的 SQL 字面臂与 LOCAL
- * 比较,以及 wire 上的第二个卡词 `contentKind`,随 #1414 整删(零别名、零双读)。
+ * 比较,以及 wire 上的第二个卡词 `contentKind`,随 [ref] 整删(零别名、零双读)。
  *
  * ── 存量行(7.49.0 之前的引擎停驻、门上没有卡)────────────────────────────────────────────────────────
  * 按 core 的读法:**无卡 = 不是一问**(core 不从名字回推,本仓也不)。持久数据面不留第二种读法 —— 按工具名回退的臂一旦留下,
@@ -14,12 +14,12 @@
  * 本仓 CHANGELOG 对应条目:旧问答行在队列上不带卡词;过了 deadline 走 SLA 拒扫腿(模型拿到一次「拒」),不再作废整条 run。
  *
  * ── 为什么保留工具名常量 ────────────────────────────────────────────────────────────────────────────
- * `ASK_USER_QUESTION_TOOL_NAME` 是 core 根导出的那一枚(S-213①:本仓一个字节都不自铸),仍有**决断面**的读者(回决时「批准问答必须
+ * `ASK_USER_QUESTION_TOOL_NAME` 是 core 根导出的那一枚([ref]①:本仓一个字节都不自铸),仍有**决断面**的读者(回决时「批准问答必须
  * 带答」、问答不可记为会话放行、durable 问答门的政策臂)—— 那几处与 core 自己的答案绑定(`engineCardOf`,按 wire 名)同读法,
  * 不是卡的渲染读法,不在本模块的规则里。
  */
 export { ASK_USER_QUESTION_TOOL_NAME } from "@sema-agent/core";
-import { type ToolApprovalCard } from "@sema-agent/core";
+import { PAUSE_REGISTRY, type GateKind, type ToolApprovalCard } from "@sema-agent/core";
 /**
  * 一格卡词的**闭集窄读**(三个载体共用这一只:活 ask、LOCAL 店的停驻门、SQL 店读出的门子树)。成员 ⇒ 那个词;缺席 ⇒ `undefined`(不计);
  * 在场却不是成员(世代差 —— 新引擎加了卡词而本版没跟上 —— 或手改行)⇒ `undefined` + 计一次 `server.approval-card.closed-word-out-of-set`
@@ -32,7 +32,7 @@ export interface ParkedGateFace {
     readonly approvalCard?: unknown;
 }
 /**
- * 停驻行的卡 —— 读法只有引擎那一只:core 包根导出 `parkedApprovalCardOf(gate)`(core 7.54.0 #1468 K2;审批门 = 门型的寄存臂是 `tool_approval`,
+ * 停驻行的卡 —— 读法只有引擎那一只:core 包根导出 `parkedApprovalCardOf(gate)`(core 7.54.0 [ref] K2;审批门 = 门型的寄存臂是 `tool_approval`,
  * 只在那里读卡,只有闭集成员算卡)。四态逐一处置(穷举 `switch`:core 加一态 ⇒ 编译红):`card` ⇒ 那个词;`no_card` / `not_approval` ⇒ 无卡;
  * `unknown_word`(引擎交回**未经筛**的存储原值)⇒ 无卡 + 响亮:计一次 `server.approval-card.closed-word-out-of-set`(与 {@link readApprovalCard} 同一只计数、
  * 同一只回显口径 —— 截 40、脱敏,对象只报形名)。修前本函数自己判「是不是审批门」(读 `PAUSE_REGISTRY` 的寄存臂)再交 {@link readApprovalCard},
@@ -44,4 +44,22 @@ export declare function parkedApprovalCard(gate: ParkedGateFace | undefined): To
  * 门型不是 core 登记的门(存量行无门型 / 手改)⇒ `undefined`,调用方按「不是 `A`」处置(与无门型存量行的既有作废路同向)。
  */
 export declare function parkedFacetOf(gate: ParkedGateFace | undefined): "A" | "B" | "-" | undefined;
+/**
+ * 审批门型 = core `PAUSE_REGISTRY` 里寄存臂是 `tool_approval` 的登记门 —— 与 core `parkedApprovalCardOf` 判「是不是审批门」同一条判据(只在这些门上读卡)。
+ * **派生,不手写**(core 7.55.0 [ref] P1 阶段二):此前本仓手写一份二员词表([ref] 时 core 没有导出词表),一次性迁移 M21 又自派生一份;
+ * core 加一行审批味的门,这里跟着变,零处要改。读者:决断口与拒扫腿按门型绑定取行(`gateKinds`)、`/decide` 的门型守卫、M21 / M29 的候选扫描。
+ * 包根同出(`index.ts`):嵌入方 / sdk 读这一只,不手抄。
+ * 到期分法**不**读这张表 —— SQL 里是由 core 两张表生成的 facet 谓词(`plugins/checkpoint-index-columns.ts`),JS 里是 {@link denySweepOwns}。
+ */
+export type ApprovalGateKind = {
+    [K in GateKind]: (typeof PAUSE_REGISTRY)[K]["pending"] extends "tool_approval" ? K : never;
+}[GateKind];
+export declare const APPROVAL_GATE_KINDS: readonly ApprovalGateKind[];
+export declare function isApprovalGateKind(k: string | undefined): k is ApprovalGateKind;
+/**
+ * 停驻行的到期归 SLA 拒扫腿(deny)而不是作废(expire)?—— **一只谓词** = core `facetOf(gate)` 读作 `A`(按 core 的定义,`A` 就是「审批门、deadline 是 SLA 拒」;
+ * 问答卡 ⇒ `B`,到期作废;非审批门 / 未登记门 / 无门 ⇒ 不归拒扫)。LOCAL 孪生的拒扫选行与作废腿的补集读这一只;SQL 孪生读由同两张表生成的谓词,逐行与它同答
+ * (`test/checkpoint-index-columns.test.ts` B 节)。修前多一个「∧ 审批门型」合取 —— 在 core 的登记表下恒真,删。
+ */
+export declare function denySweepOwns(gate: ParkedGateFace | undefined): boolean;
 //# sourceMappingURL=approval-content-kind.d.ts.map

package/dist/approval-content-kind.js

@@ -1,5 +1,5 @@
 export { ASK_USER_QUESTION_TOOL_NAME } from "@sema-agent/core";
-import { TOOL_APPROVAL_CARDS, facetOf, isGateKind, parkedApprovalCardOf } from "@sema-agent/core";
+import { PAUSE_REGISTRY, TOOL_APPROVAL_CARDS, facetOf, isGateKind, parkedApprovalCardOf } from "@sema-agent/core";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { redactSecrets } from "./trace/redact.js";
 export function readApprovalCard(raw) {
@@ -33,4 +33,11 @@ export function parkedApprovalCard(gate) {
 export function parkedFacetOf(gate) {
     return gate !== undefined && isGateKind(gate.kind) ? facetOf({ kind: gate.kind, approvalCard: gate.approvalCard }) : undefined;
 }
+export const APPROVAL_GATE_KINDS = Object.freeze(Object.keys(PAUSE_REGISTRY).filter((k) => PAUSE_REGISTRY[k].pending === "tool_approval"));
+export function isApprovalGateKind(k) {
+    return k !== undefined && APPROVAL_GATE_KINDS.includes(k);
+}
+export function denySweepOwns(gate) {
+    return parkedFacetOf(gate) === "A";
+}
 //# sourceMappingURL=approval-content-kind.js.map

package/dist/approval-deny-reasons.d.ts

@@ -95,7 +95,7 @@ export type ApprovalEndingCause = (typeof APPROVAL_ENDING_CAUSES)[keyof typeof A
 /** 全部成因词(机器判据用:值域互不相同 + 列宽 ≤ 64 的钉子在 test/approval-reconciler.test.ts)。 */
 export declare const ALL_APPROVAL_ENDING_CAUSES: readonly ApprovalEndingCause[];
 /**
- * 审计 settle 行 `cause` 的读盘词表(S-929 形):{@link SettleCause} 的穷举,`satisfies Record<SettleCause, true>` ⇒ 闭集加一个非决断类的词而本表没跟 = **编译红**(多一个词同样红);
+ * 审计 settle 行 `cause` 的读盘词表([ref] 形):{@link SettleCause} 的穷举,`satisfies Record<SettleCause, true>` ⇒ 闭集加一个非决断类的词而本表没跟 = **编译红**(多一个词同样红);
  * 判定走 `Object.hasOwn`,原型链上的名字不算词。决断类三词({@link DecisionRefusalCause})拒一次决议、不结束一张卡 ⇒ 不是 settle 行的成因,读到它们照词表外处置(计坏行)。
  * 唯一读者 = {@link isSettleCause}。
  */

package/dist/approval-gate-currency.d.ts

@@ -9,9 +9,24 @@
  * ## 判官
  * 问题:**这把 gate token 是不是该会话当前待决的审批门?**(应答口的答法:`resumeCheckpoint` 的 stale 臂 —— 回显的 token ≠ 该会话当前待决的审批门 ⇒ `409 approval_stale`。)
  *  · {@link currentApprovalGateToken} —— 该会话当前待决的审批门(审批门型优先,没有再退到任一待决行);应答口读它,读口读它,别处不再内联第二份;
- *  · {@link readGateCurrency} —— 一把 token 对着它的读数:`current` / `absent`(店里没有这一行)/ `settled`(行在,但不再是当前待决门:已结算、已过期、被取代);
+ *  · {@link readGateCurrency} —— 一把 token 对着它的读数:`current`(带那一行)/ `absent`(店里没有这一行)/ `settled`(行在,但不再是当前待决门:已结算、已过期、被取代);
  *  · {@link createParkedGateRead} —— 协调器读口的门读席:把读数译成读口要的四种读法({@link ParkedGateReading}),`state` 闭集不加字。
  *
+ * ## 一个读数只取自一个时刻([ref])
+ * 门身份就是 token:引擎重开一张门(`reopen`:续跑腿在被批准的动作开跑之前失败)翻的是**同一行**(resolved → pending,token 不变)。所以「这张卡此刻在哪」可以在两次店读之间
+ * 来回变(待决 → 被决 → 被重开);判官的分类只用**同一时刻成立**的读数:
+ *  ① 行不在 ⇒ `absent`;行不 pending ⇒ 按这一行分类(不 pending 的行不可能是「当前待决」的那一把,不必再问);
+ *  ② 行 pending ⇒ 问「当前待决」,**问完再读一次行**:世代号没动(`rev`:core 的单调世代号,每一次 resolve / reopen 都推它)⇒ 两次行读之间没有 resolve / reopen 落地 ⇒
+ *     「当前待决」那一读时它就是这一行(连同行上的重开事实)⇒ 答的是它 ⇒ `current`(带这一行),答的不是它 ⇒ 被取代(`settled`);
+ *     世代号动了 ⇒ 两次行读之间这张卡被决又被重开 ⇒ 用新的那一行**从 ① 重判**(有界 {@link GATE_READ_ROUNDS};摸到上界 ⇒ 抛,读口按店故障姿势处置);
+ *     第二读不在 / 不再 pending ⇒ 从 ① 按它分类。两个答案(是 / 不是当前待决)过的是**同一道**世代号核对:
+ *     拿「被决那一瞬」读到的当前待决与「重开之后」读到的 pending 拼出 `void`,或拿第一读的旧行(那一刻它还不是当前待决、也还没被重开)答「当前待决」,都是同一种拼法。
+ *
+ * ## 被重开的门怎么读([ref])
+ * `current` 的那一行上若带 core 的重开事实(`reopenReason`,闭集 `REOPEN_REASONS`;下一次 resolve 清掉它),读法是 `open` + `reopened`:core 的因由词原样 +
+ * **重开之前的决议**(core 跨重开保留赢家 `resolvedOutcome`;读它的是已结算门 `decided` 的**同一只**决议读法 {@link decisionReading} —— 一个记录一个读者)。
+ * 那只读法读不出决议 ⇒ 只带因由词,不编一个决议;因由词不在 core 的闭集里(只有手改行带得出)⇒ 不带 `reopened`(读不懂的词说不出「重开」是哪一种)。
+ *
  * ## `settled` 怎么译(读口只说 checkpoint 上有凭据的话;一条规矩)
  * 落盘的行不受类型面约束(旧版 / 手改 / 坏体 / 更新版本 core 写下的行可带闭集外的词或坏形),所以已结算门只按**一条规矩**读:
  *  ① 两个闭集词(行的 `status`、结算记录的种类 `settlement.kind`)各查一张穷举表,**同一查法**({@link throughTable}:只认表自己的键,非字符串不进表):
@@ -45,16 +60,20 @@ export interface GateCurrencyStore {
  * 无序读会选中别的门型 —— 没有审批门才退到任一待决行(错门型诊断由 `/decide` 的 gate-kind 守卫点名)。应答口的 stale 臂与按问读口读这一只。
  */
 export declare function currentApprovalGateToken(cs: Pick<GateCurrencyStore, "findPendingTokenBySession">, sessionId: string): Promise<CheckpointToken | null | undefined>;
-/** 一把 gate token 对着判官的读数。 */
+/** 一把 gate token 对着判官的读数(`current` / `settled` 带分类用的那一行)。 */
 export type GateCurrency = {
     readonly kind: "current";
+    readonly checkpoint: Checkpoint;
 } | {
     readonly kind: "absent";
 } | {
     readonly kind: "settled";
     readonly checkpoint: Checkpoint;
 };
-/** 这把 gate token 是不是它那条会话当前待决的审批门。读不出(店抛错)⇒ 原样上抛,由调用方的故障姿势处置。 */
+/**
+ * 这把 gate token 是不是它那条会话当前待决的审批门 —— 分类只用同一时刻成立的读数(规矩见模块头注「一个读数只取自一个时刻」)。
+ * 读不出(店抛错)⇒ 原样上抛,由调用方的故障姿势处置;行一直在动、摸到 {@link GATE_READ_ROUNDS} ⇒ 抛。
+ */
 export declare function readGateCurrency(cs: GateCurrencyStore, gateToken: string): Promise<GateCurrency>;
 /** 一个闭集词对已结算门的读法类:有人 / 有策略决过(往下读决议),或没有人决过它。 */
 type SettledClass = "decided" | "void";

package/dist/approval-gate-currency.js

@@ -1,20 +1,32 @@
-import { screenGateOutcome } from "@sema-agent/core";
+import { REOPEN_REASONS, screenGateOutcome } from "@sema-agent/core";
 import { approvalDecisionOfWinner } from "./plugins/checkpoint-store-sql.js";
-import { APPROVAL_GATE_KINDS } from "./tool-approval.js";
+import {} from "./tool-approval.js";
+import { APPROVAL_GATE_KINDS } from "./approval-content-kind.js";
 export async function currentApprovalGateToken(cs, sessionId) {
     return (await cs.findPendingTokenBySession(sessionId, undefined, { gateKinds: APPROVAL_GATE_KINDS })) ?? (await cs.findPendingTokenBySession(sessionId));
 }
+function revisionOf(cp) {
+    return cp.rev ?? 0;
+}
+const GATE_READ_ROUNDS = 3;
 export async function readGateCurrency(cs, gateToken) {
-    const first = await cs.get(gateToken);
-    if (first === null)
-        return { kind: "absent" };
-    if (first.status !== "pending")
-        return { kind: "settled", checkpoint: first };
-    const current = await currentApprovalGateToken(cs, first.sessionId);
-    if (current === gateToken)
-        return { kind: "current" };
-    const fresh = await cs.get(gateToken);
-    return fresh === null ? { kind: "absent" } : { kind: "settled", checkpoint: fresh };
+    const token = gateToken;
+    let row = await cs.get(token);
+    for (let round = 1;; round += 1) {
+        if (row === null)
+            return { kind: "absent" };
+        if (row.status !== "pending")
+            return { kind: "settled", checkpoint: row };
+        const isCurrent = (await currentApprovalGateToken(cs, row.sessionId)) === gateToken;
+        const again = await cs.get(token);
+        if (again !== null && again.status === "pending") {
+            if (revisionOf(again) === revisionOf(row))
+                return isCurrent ? { kind: "current", checkpoint: again } : { kind: "settled", checkpoint: again };
+            if (round === GATE_READ_ROUNDS)
+                throw new Error(`the checkpoint row moved between reads in ${GATE_READ_ROUNDS} rounds in a row (decided and reopened each time): there is no single-instant reading of its gate`);
+        }
+        row = again;
+    }
 }
 const SETTLED_GATE_READING = { resolved: "decided", expired: "void", pending: "void" };
 export const SETTLEMENT_KIND_READING = {
@@ -42,17 +54,18 @@ function throughTable(table, word, field) {
     return table[word] === "decided" ? "decided" : { kind: "void" };
 }
 function settledReading(checkpoint, gateBoundCallId) {
+    const byStatus = throughTable(SETTLED_GATE_READING, checkpoint.status, "checkpoint status");
+    return byStatus === "decided" ? decisionReading(checkpoint, gateBoundCallId) : byStatus;
+}
+function decisionReading(checkpoint, gateBoundCallId) {
     try {
-        return readSettledRow(checkpoint, gateBoundCallId);
+        return readWinner(checkpoint, gateBoundCallId);
     }
     catch (e) {
         return unreadable([`the settled row could not be read (${e instanceof Error ? e.name : "non-Error throw"})`]);
     }
 }
-function readSettledRow(checkpoint, gateBoundCallId) {
-    const byStatus = throughTable(SETTLED_GATE_READING, checkpoint.status, "checkpoint status");
-    if (byStatus !== "decided")
-        return byStatus;
+function readWinner(checkpoint, gateBoundCallId) {
     const winner = checkpoint.resolvedOutcome;
     const recorded = winner?.gateOutcome;
     const [defect, ...more] = screenGateOutcome(recorded, { reading: "archive" });
@@ -73,12 +86,25 @@ function readSettledRow(checkpoint, gateBoundCallId) {
     const note = typeof winner?.reason === "string" && winner.reason !== "" ? winner.reason : undefined;
     return { kind: "decided", decision: direction === "approve" ? "allow" : "deny", decidedAtMs: settlement.when, ...(note !== undefined ? { decisionNote: note } : {}) };
 }
+function isReopenReason(word) {
+    return typeof word === "string" && REOPEN_REASONS.includes(word);
+}
+function openReading(checkpoint, gateBoundCallId) {
+    const reason = checkpoint.reopenReason;
+    if (!isReopenReason(reason))
+        return { kind: "open" };
+    const prior = decisionReading(checkpoint, gateBoundCallId);
+    const reopened = prior.kind === "decided"
+        ? { reason, decision: prior.decision, decidedAtMs: prior.decidedAtMs, ...(prior.decisionNote !== undefined ? { decisionNote: prior.decisionNote } : {}) }
+        : { reason };
+    return { kind: "open", reopened };
+}
 export function createParkedGateRead(cs) {
     return async ({ gateToken, gateBoundCallId }) => {
         const currency = await readGateCurrency(cs, gateToken);
         switch (currency.kind) {
             case "current":
-                return { kind: "open" };
+                return openReading(currency.checkpoint, gateBoundCallId);
             case "absent":
                 return { kind: "unknown", why: "row_absent" };
             case "settled":

package/dist/approval-hmac.d.ts

@@ -13,25 +13,25 @@ import type { ApprovalHmacKey } from "./auth-keys.js";
  * 被接管的客户端 —— 正是 HMAC 要防的风险模型)可以在操作员批准同一个动作的那次决定里,把落账理由换成
  * 别的:动作没变,**审计记录变了**。三方裁定纳入签名载荷,不留 `reasonUnsigned` 宽限代际(未上生产)。
  *
- * ── 🔴 **两把绑定的分工**(S-433 F1 立此,别再把它们当成一回事)─────────────────────────────────
+ * ── 🔴 **两把绑定的分工**([ref] F1 立此,别再把它们当成一回事)─────────────────────────────────
  * `principal-jwt.ts` 的 `approvalBnd`(JWT `cnf.bnd`)只哈希**前三位** `[sessionId, boundCallId, boundInputHash]`
  * —— 它绑的是**「哪一张卡」**(这份身份凭据被签发去决哪一次待决动作),所以决定内容改了它**不该**变。
  * 本文件的 HMAC 信封绑的是**「决了什么」**—— 决定本身的每一个会改变后果的字段都在里面(`decision`、
- * `reason`,以及 S-433 起的 `permissionModeAfter`)。⇒ 「同一张卡上把 approve 的档偷偷调宽」这件事,
+ * `reason`,以及 [ref] 起的 `permissionModeAfter`)。⇒ 「同一张卡上把 approve 的档偷偷调宽」这件事,
  * 结构上只有 HMAC 这一把拦得住;往 `cnf.bnd` 里加位既不解决它,还会把一份合法 JWT 绑死在一个它签发时
- * 根本不知道的值上。**本次(S-433 F1)只动 HMAC 这一把,`approvalBnd` 一个字节不动。**
+ * 根本不知道的值上。**本次([ref] F1)只动 HMAC 这一把,`approvalBnd` 一个字节不动。**
  *
  * ── 🔴 字节构造规则(权威定义;跨仓签名器照此实现,docs/ASSISTANT-WIRE-CONTRACT.md §6.2 同源)──────────
  * 被 HMAC 的是下面这个字符串的 **UTF-8 字节**:
  *   1. **恒 5 元素、定序**的紧凑 JSON 数组(元素间**无空格**):
  *      `[sessionId, boundCallId|null, boundInputHash|null, decision, reason|null]`
  *      —— 恒定长度是刻意的:签名器里少一个"有 reason 才追加"的条件分支,就少一类跨实现漂移。
- *      🔴 **唯一的例外是尾位**(S-452,server 7.87.0 起是**一只扩展对象**;7.86.0 的裸尾位形已删除):
+ *      🔴 **唯一的例外是尾位**([ref],server 7.87.0 起是**一只扩展对象**;7.86.0 的裸尾位形已删除):
  *      对扩展键**闭集** {@link APPROVAL_ENVELOPE_EXT_KEYS}(字典序即声明序)逐键判 `!== undefined`,
  *      在场的收进一只对象 `ext`;**`ext` 为空 ⇒ 一个字节都不追加**(消息与 7.85.0 逐字节相同),
  *      非空 ⇒ 追加为第 6 位 `[…head, ext]`。`JSON.stringify` 对 `ext` 的键序 = 插入序 = 闭集字典序,
  *      所以规范化无歧义,**与调用方给键的顺序无关**。
- *      为什么不继续用「裸的第 6、7 格」(S-433 的形):两个扩展位都可选 ⇒ 只有 `answer` 在场时它落在
+ *      为什么不继续用「裸的第 6、7 格」([ref] 的形):两个扩展位都可选 ⇒ 只有 `answer` 在场时它落在
  *      第 6 格、与 `permissionModeAfter` 撞位,靠类型猜是谁 = 签名歧义。扩展对象让「在场的是谁」自带
  *      名字,而且以后再加决裁字段不动数组形(规则集不再长)。
  *      向后兼容仍然成立的那一半:**不带任何扩展键的体**,字节与 7.85.0 逐字相同 ⇒ 不签这些位的既有
@@ -95,7 +95,7 @@ export interface ApprovalEnvelope {
     decision: string;
     reason?: string | null;
     /**
-     * 🔴 **S-452(7.87.0)—— 操作员对一次 AskUserQuestion 的回答进签名载荷。**
+     * 🔴 **[ref](7.87.0)—— 操作员对一次 AskUserQuestion 的回答进签名载荷。**
      *
      * 它此前**不在**信封里 ⇒ 一个能改写线上字节的中间人(反代 / 被接管的客户端 —— 正是 HMAC 的风险
      * 模型)可以在操作员签过的那次批准里只换 `answer`:动作没变、MAC 照过,**模型收到的答案变了**。
@@ -106,7 +106,7 @@ export interface ApprovalEnvelope {
      */
     answer?: QuestionAnswerProjection;
     /**
-     * 🔴 **S-433 合并复审 F1 [high]**(7.86.0 立,S-452 把它从裸尾位挪进扩展对象)—— `plan_review` 的
+     * 🔴 **[ref] 合并复审 F1 [high]**(7.86.0 立,[ref] 把它从裸尾位挪进扩展对象)—— `plan_review` 的
      * `permissionModeAfter` 选的是**批准之后这条 run 有没有手**(`acceptEdits` = 工作目录内的写不再逐次
      * 征询)。它铸下来时没有进签名载荷 ⇒ 中间人可以把操作员签的那次 `default` 批准原地改成 `acceptEdits`:
      * 动作没变、MAC 照过,**权限变了**。

package/dist/approval-policy-settlement.d.ts

@@ -1,5 +1,5 @@
 /**
- * S-702 / S-706 —— 「无人可答」的**政策感知终态 claim**:全仓唯一一只(NP-2 的政策结算抽出来,四处调用,不写第二份)。
+ * [ref] / [ref] —— 「无人可答」的**政策感知终态 claim**:全仓唯一一只(NP-2 的政策结算抽出来,四处调用,不写第二份)。
  *
  * 一句话:一只没人答的 ask 在持久 ask 行上**落什么终局**,由部署政策(`UNATTENDED_APPROVAL_POLICY`)一处决定 ——
  *  · `park` ⇒ `expire` 意图:STREAM_PENDING→PARKING、批转投递面、同批流内兄弟连坐 VOID(park 路由的单位是整批,core 随后
@@ -15,7 +15,7 @@
  *  3. 两兜底臂 —— `ensureAsk` 行不可用 / ensure 身份不定(`tool-approval.ts` `landUnattendedOutcome`,只在交给 core 的是**结算**时
  *     调:park 路由不是结算,行留给投递面的既有机器,park 行为逐字不变),以及后者迟到落盘那条行的收尾;
  *  4. 崩溃恢复腿 —— 对账收敛器段二的孤儿 STREAM_PENDING 代打(`approval-reconciler.ts`):它就是窗到期竞争者在崩溃后的补位,
- *     同一只 claim、同一个转移(S-706 之前它无条件 `expireAsk`,deny 部署上崩溃后行进 PARKING,run 完成后成不带来源的 DENIED)。
+ *     同一只 claim、同一个转移([ref] 之前它无条件 `expireAsk`,deny 部署上崩溃后行进 PARKING,run 完成后成不带来源的 DENIED)。
  *
  * 形:纯委托 —— 店的原子终局 claim(`ApprovalAskStore.claimTerminal`,三 twin 一台 CAS 机器,律 2)+ 政策→意图的穷举映射。
  * 答案自足(律 1):赢 ⇒ `{claimed:true, voidedSiblings}`(refuse 恒空名单);输 ⇒ 携行真相;抛错 ⇒ 什么也不证明。

package/dist/approval-reconciler.d.ts

@@ -192,7 +192,7 @@ export interface ReconcileStats {
      *  (见 {@link RECONCILE_SEGMENT_BUDGET_MS})。 */
     budgetExhausted: number;
     /** 段二:被代打**窗到期终局 claim** 的孤儿 `STREAM_PENDING` 行数(赢 CAS 的)。「expired」指触发(窗过了没人收),
-     *  不指意图 —— 与 live 腿 `window_expired` 同一个读法:park 部署 ⇒ expire(进投递面);deny 部署 ⇒ refuse(当场落政策结算,S-706)。 */
+     *  不指意图 —— 与 live 腿 `window_expired` 同一个读法:park 部署 ⇒ expire(进投递面);deny 部署 ⇒ refuse(当场落政策结算,[ref])。 */
     orphansExpired: number;
 }
 /** 撤卡帧的投递面(逐 ctx 分发:durable 腿落账本、sync 腿 live,见 `ApprovalRevokeFrame` 顶注)。
@@ -226,13 +226,13 @@ export interface ApprovalReconcilerDeps {
     adhocGraceMs: number;
     orphanTtlMs: number;
     /**
-     * S-706:部署的无人值守政策(`UNATTENDED_APPROVAL_POLICY`)—— 段二孤儿代打打的是哪个终局 claim。**必填**、恒传(与协调器
+     * [ref]:部署的无人值守政策(`UNATTENDED_APPROVAL_POLICY`)—— 段二孤儿代打打的是哪个终局 claim。**必填**、恒传(与协调器
      * 读同一个部署值;没有缺省 —— 缺省 park 会让 deny 部署在崩溃恢复这一形上静默退回「进投递面 → 不带来源的 DENIED」)。
      */
     unattendedPolicy: UnattendedApprovalPolicy;
     emitRevoke?: ApprovalRevokeEmitter | undefined;
     /**
-     * S-1280:park 提交的唯一观察点(`plugins/park-commit-watch.ts`;在场 ⇔ 本部署有 checkpoint 店)。在场 ⇒ 收敛器订阅它:一只审批停车行
+     * [ref]:park 提交的唯一观察点(`plugins/park-commit-watch.ts`;在场 ⇔ 本部署有 checkpoint 店)。在场 ⇒ 收敛器订阅它:一只审批停车行
      * 提交的那一拍,对**这次调用**的 `PARKING` 行即时跑判据 1(与周期扫同一只执行体),`put` 等它收完才交还 core。缺席 ⇒ 只有周期扫(修前形)。
      */
     parkCommits?: Pick<ParkCommitWatch, "onParkCommitted" | "track"> | undefined;

package/dist/approval.d.ts

@@ -9,7 +9,7 @@ import { type ExecutionLane } from "./execution-lane-caps.js";
 import { type ApprovalExemptionStore } from "./plugins/approval-exemption-store.js";
 /**
  * 门意图判据读的五个量(`ServiceConfig` 结构满足)。单独成型是为了让**热路径**能拿「候选视图」来判
- * (S-668 波 2:`{ ...config, approvalRequire: 候选名单 }`)—— 判据只有一份,输入可以是活配置也可以是候选。
+ * ([ref] 波 2:`{ ...config, approvalRequire: 候选名单 }`)—— 判据只有一份,输入可以是活配置也可以是候选。
  */
 export interface GateIntentView {
     readonly approvalRequire: readonly string[];
@@ -21,7 +21,7 @@ export interface GateIntentView {
 /**
  * 三张审批名单(require / deny / never-auto)里**有没有一张在场** —— 「这台部署有一份要执行的审批策略」。
  *
- * 🔴 S-668 波 2(codex r1 F1):leader 车道的 durable 审批席曾只按 `approvalRequire` 非空给出。require 名单转热之后,
+ * 🔴 [ref] 波 2(codex r1 F1):leader 车道的 durable 审批席曾只按 `approvalRequire` 非空给出。require 名单转热之后,
  * 中心热撤空它就把 leader worker 上**独立**的 deny / never-auto 两张表一起撤掉(主车道照旧 deny / ask)—— 三张表是
  * 三条独立的限制,任何一张在场都要装策略。{@link hasOperatorGateIntent} 的名单三格就是本函数(同一判据,不写两份)。
  */
@@ -42,9 +42,9 @@ export declare function hasApprovalListIntent(config: Pick<GateIntentView, "appr
  */
 export declare function hasOperatorGateIntent(config: GateIntentView): boolean;
 /**
- * 单用户 turnkey 的 **auto-accept 基线**适用吗 —— 单用户(未开 `REQUIRE_PRINCIPAL`)∧ 运维零门意图。
+ * 单用户 turnkey 的 **auto-accept 基线**适用吗 —— 单用户(部署形表行 `multiTenant` 不成立)∧ 运维零门意图。
  *
- * 🔴 S-668 波 2 ③:**每请求现算**,不是 boot 常量。判据的输入 `approvalRequire` 自本批起在进程内会被中心
+ * 🔴 [ref] 波 2 ③:**每请求现算**,不是 boot 常量。判据的输入 `approvalRequire` 自本批起在进程内会被中心
  * 热换;boot 期算好的一个布尔会让「名单从空变非空」之后 allow-all 基线仍挂在每个新任务上 —— 运维刚表达的
  * 门意图被基线静默吞掉([ref] 方向)。所以消费点(`boot/resolve-spec.ts` 每个任务、stage-07 的 boot 姿态行、
  * run-local 的补偿 warn)一律调本函数,谁也不持有它的快照。
@@ -58,10 +58,10 @@ export declare function singleUserAutoAcceptBaselineApplies(config: GateIntentVi
  *    HIGH;与 env 墓碑族同谱系)。v4.3.0 的轮询门形(APPROVAL_REQUIRE + DB backend + DURABLE_APPROVAL 未设)在
  *    5.0.0 只剩 core 每任务 warn——**原先拦、现在放**(方向反转)。「留 undefined 让 core warn」对新配置是
  *    曝露误配,对升级存量是门静默消失,后者必须响亮。
- *  · **热路径**(S-668 波 2 ④,`web-admin-client/apply-effective.ts` 的审批组 stage):对**候选视图**
+ *  · **热路径**([ref] 波 2 ④,`web-admin-client/apply-effective.ts` 的审批组 stage):对**候选视图**
  *    (活配置 + 候选名单)判,拒因 ⇒ 审批组**整组拒**、活配置零变化、世代账停旧代。进程在跑,拒启不是选项;
  *    而放行一份「没有 checkpoint 店可停车」的名单 = 单用户 auto-accept 基线仍在、名单静默不生效。
- *  · **每个任务的装配**(S-1144,`boot/resolve-spec.ts` 的 `resolveSpec` 头一道):对**活配置**判,拒因 ⇒ 请求 501
+ *  · **每个任务的装配**([ref],`boot/resolve-spec.ts` 的 `resolveSpec` 头一道):对**活配置**判,拒因 ⇒ 请求 501
  *    `capability.checkpoint_store_required`。部署形到不了(boot 已拒启);可达的是嵌入方装配 / 直调 `resolveSpec`(自己递 ctx、没经 stage-07)。
  *    修前这一形把审批基线静默铸成 `undefined`,请求的 allow 清「普通问」后任务零卡落盘 —— 同一条规则在起服层拒、在装配层静默 = 一事两读。
  * `checkpointStorePresent` 是**部署事实**(本进程建没建出 checkpoint 店),不在 `ServiceConfig` 里 ⇒ 调用方显式递。
@@ -69,7 +69,7 @@ export declare function singleUserAutoAcceptBaselineApplies(config: GateIntentVi
  */
 export declare function gateIntentUnserviceableReason(config: GateIntentView, checkpointStorePresent: boolean): string | undefined;
 /**
- * S-602 C3 —— 「**无应答面**」两条 boot warn 的判据与文案(纯函数;stage-07 只负责打日志)。
+ * [ref] C3 —— 「**无应答面**」两条 boot warn 的判据与文案(纯函数;stage-07 只负责打日志)。
  *
  * 两条 warn 警的是同一类失败:一个 `ask` 发生了,而这台部署既没有活体协调器(`TOOL_APPROVAL_ENABLED`)也没有
  * durable 停车(`DURABLE_APPROVAL`)⇒ core `resolveAsk` 无 onAsk ⇒ headless 自动拒(fail-closed,写进转录)。
@@ -191,7 +191,7 @@ export declare function createDeploymentListExemption(store: Pick<ApprovalExempt
  */
 export declare const AUTO_APPROVE_BUDGET_APPROVER = "auto_approve_budget";
 /**
- * **请求叶策略:`settings.permissions.neverAuto`**(S-1351)—— 命中名单的工具恒问真人;名单外「本层没有意见」(裸 allow)。叶只管请求自己写的那张表,部署的 `APPROVAL_NEVER_AUTO`
+ * **请求叶策略:`settings.permissions.neverAuto`**([ref])—— 命中名单的工具恒问真人;名单外「本层没有意见」(裸 allow)。叶只管请求自己写的那张表,部署的 `APPROVAL_NEVER_AUTO`
  * 在基线里({@link createDurableAskPolicy}),两者经 `tightenGoverned` 的 deny-wins 折叠取并:请求叶只会**多**问,删不掉基线里的任何一行。
  *
  * 名字读法与部署名单是**同一只**({@link createApprovalListVerdict} → 精确 ∪ covering,收紧臂读调用答得上的全部名字):一条规则只有一种读法。问的铸点是

package/dist/approval.js

@@ -2,7 +2,9 @@ import { createApprovalPolicy, isNamespacedCoveringRuleName, namespacedRuleNameC
 import { operatorAlwaysHumanAsk, operatorAsk, requestAlwaysHumanAsk } from "./operator-ask.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "./approval-content-kind.js";
 import { isExplicitPosture } from "./posture-source.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
 import { handsOnWorkerFilePlane } from "./execution-lane-caps.js";
+import { NAME_TABLE_BEHAVIOR } from "./namespaced-rule-name.js";
 import { heldRuleName } from "./tool-rule-names.js";
 import { DURABLE_CONVERGE_READ_TIMEOUT_MS, policyAskStandingAnswerFacts, standingAnswerDurablyRecordable } from "./tool-approval.js";
 import { APPROVAL_EXEMPTED_EVENT } from "./plugins/approval-exemption-store.js";
@@ -16,7 +18,7 @@ export function hasOperatorGateIntent(config) {
         (config.durableApproval && isExplicitPosture(config.durableApprovalSource)));
 }
 export function singleUserAutoAcceptBaselineApplies(config) {
-    return config.requirePrincipal !== true && !hasOperatorGateIntent(config);
+    return !DEPLOYMENT_SHAPE_PREDICATES.multiTenant.holds(config) && !hasOperatorGateIntent(config);
 }
 export function gateIntentUnserviceableReason(config, checkpointStorePresent) {
     if (!hasOperatorGateIntent(config) || checkpointStorePresent)
@@ -114,7 +116,7 @@ export function createDeploymentListExemption(store, sessionId, logger, leg) {
 }
 function createNameSetMatcher(names) {
     const exact = new Set(names);
-    const covering = names.filter(isNamespacedCoveringRuleName);
+    const covering = names.filter((name) => isNamespacedCoveringRuleName(name, NAME_TABLE_BEHAVIOR));
     if (covering.length === 0)
         return (toolName) => exact.has(toolName);
     return (toolName) => exact.has(toolName) || covering.some((rule) => namespacedRuleNameCovers(rule, toolName));