@sema-agent/server 7.56.0 → 7.57.0

package/dist/approval-card.d.ts

@@ -49,30 +49,76 @@ export declare const MAX_RULE_OFFERS = 4;
  * 几条规则),混成一个数会让「上游把 batch 放宽到 6 条成员」误伤到 offer 条数这条无关轴。
  */
 export declare const MAX_RULE_OFFER_BATCH_MEMBERS = 8;
+/**
+ * **一条**「不再询问」OFFER 的形(core 5.58.0 / [ref] §3.1 —— **BREAKING**,取代退役的
+ * `RuleSuggestion`)。同步腿(`ApprovalCardSchema.ruleOffers` / `card_json`)与耐久腿(durable park 行的
+ * `PendingCheckpoint.ruleOffers`,由 `plugins/checkpoint-store-sql.ts` 窄读)**共用这一份**。
+ *
+ * 🔴 单一属主(宪法 [ref]「schema 单一属主禁复制」):两条腿投的是 core 的**同一个** `RuleOffer`
+ * (同步腿 = `AskRequest.ruleOffers`,耐久腿 = `PendingAction.ruleOffers`,core
+ * `checkpoint-store.d.ts` 明写「CONTRACT (same as the synchronous `AskRequest.ruleOffers`)」)。
+ * 各写一份 zod 必然漂——闭词表 `match`/`kind` 加词、上限改口径,只改一处就出两种形。
+ *
+ * 🔴 **闭集判别联合,`kind` 是判别位**(core d.ts 逐字:"A CLOSED discriminated union"):
+ *  · `single` —— 一条覆盖**整串**命令的规则(exact 精确形,或简单命令的 reviewed prefix 形);
+ *  · `batch`  —— 复合命令的**逐段合取**批:选它 = **一次对全部 `rules` 说 yes**,批内**无**逐条子选择。
+ *    成员是判别联合([ref] B3:`command` 逐段 Bash 规则 | `directoryRead` cd 段铸的目录只读授权)。
+ *    `uncoveredSegments` 是铸批时刻的**诚实溢出披露**(既不被本批覆盖、也不被卡的覆盖快照覆盖的段数),
+ *    `0` 读作「这批兑完,这条复合命令在那份快照的眼里就全覆盖了」;`uncoveredDetail`(§3.5,additive)
+ *    逐段说**为什么**还没被覆盖(闭三词集),行数恒等于 count(count 是真源,明细缺席不是断言)。
+ *
+ * 🔴 **序即契约**(core 逐字,消费端可以依赖):至多 2 条;whole-string exact single 在场时**恒 index 0**;
+ * batch 至多一条、**恒末位**。所以本仓一切截断都必须是**取前缀**(保序、保原始下标),绝不重排。
+ */
+/**
+ * [ref] §3.5 —— `uncoveredDetail` **行数**的 server 容忍帽(理由与 {@link MAX_RULE_OFFER_BATCH_MEMBERS}
+ * 同源:纯展示轴上的一条改坏/放宽的上游不该把一行撑爆)。⚠️ 超帽的处置是**丢整座**而不是截断:core 契约
+ * 明写「`uncoveredDetail.length === uncoveredSegments` whenever the seat is present」且「count 座是真源、
+ * 明细缺席不是断言」——截过的座会让一个按契约校验等式的消费端把整只 batch 判假,缺席则只是少一行解释。
+ */
+export declare const MAX_UNCOVERED_DETAIL_ROWS = 32;
 export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"single">;
     rule: z.ZodString;
     match: z.ZodEnum<{
         exact: "exact";
         prefix: "prefix";
+        wildcard: "wildcard";
+        subpath: "subpath";
     }>;
     command: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"batch">;
-    rules: z.ZodArray<z.ZodObject<{
+    rules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"command">;
         rule: z.ZodString;
         match: z.ZodEnum<{
             exact: "exact";
             prefix: "prefix";
+            wildcard: "wildcard";
+            subpath: "subpath";
         }>;
         command: z.ZodString;
         segment: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"directoryRead">;
+        rule: z.ZodString;
+        directory: z.ZodString;
+        segment: z.ZodString;
+    }, z.core.$strict>]>>;
     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.$strict>>>;
 }, z.core.$strict>]>;
 /**
- * {@link RuleOfferSchema} 的**不限长**孪生 —— 只判**结构**(闭词表 `kind`/`match` + 若干字符串),长度由
- * 调用方在**脱敏之后**自己截。
+ * {@link RuleOfferSchema} 的**不限长**孪生 —— 只判**结构**(闭词表 `kind`/`match`/`reason` + 若干字符串),
+ * 长度由调用方在**脱敏之后**自己截。
  *
  * 🔴 为什么必须有它(codex 交叉复审 [medium],验真后修):`redactSecrets` **会变长**(一条
  * `password=…` 换成更长的遮蔽标记)。拿带 `.max()` 的形去校验**脱敏前**的原文,再脱敏,产出的就可能是
@@ -100,7 +146,11 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
  * 落库/读回的 {@link ApprovalCardSchema} 仍 `.strict()`(投影只写已知键,多余键根本到不了那一层)。
  *
  * 🔴 **判别联合上的 strip 要逐臂加**(zod 4:`z.union` 自己没有 unknownKeys 政策,政策在成员上)——
- * 两臂各自 `.strip()`,否则 batch 臂对 additive 加键仍是 strict 的,而那正是本注要拆的雷。
+ * 两臂各自 `.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">;
@@ -108,25 +158,69 @@ export declare const RuleOfferRawSchema: z.ZodUnion<readonly [z.ZodObject<{
     match: z.ZodEnum<{
         exact: "exact";
         prefix: "prefix";
+        wildcard: "wildcard";
+        subpath: "subpath";
     }>;
     command: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"batch">;
-    rules: z.ZodArray<z.ZodObject<{
+    rules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"command">;
         rule: z.ZodString;
         match: z.ZodEnum<{
             exact: "exact";
             prefix: "prefix";
+            wildcard: "wildcard";
+            subpath: "subpath";
         }>;
         command: z.ZodString;
         segment: z.ZodString;
-    }, z.core.$strip>>;
+    }, 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 明写「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 消失
+ * (「有供给」谎报成「无供给」,本键存在理由的反面)。
+ */
+export declare function backfillLegacyBatchMemberKind(item: unknown): unknown;
 /**
  * 卡面/帧面共用的 offer **投影型**(= {@link RuleOfferSchema} 的输出形)。判别位 `kind` 上闭集,
- * 消费端(SDK/cli 渲染)按 core 契约分臂;`batch.rules` 成员带 `segment` 渲染座(core 明写
- * 「渲染座、永不参与裁决」,与 rule/command 同为 UNTRUSTED-for-display)。
+ * 消费端(SDK/cli 渲染)按 core 契约分臂;`batch.rules` 成员是判别联合(`command` | `directoryRead`),
+ * 各自带 `segment` 渲染座(core 明写「渲染座、永不参与裁决」,与 rule/command/directory 同为
+ * UNTRUSTED-for-display);`uncoveredDetail` additive 明细座。
  */
 export type RuleOfferProjection = z.infer<typeof RuleOfferSchema>;
 /**
@@ -134,6 +228,11 @@ export type RuleOfferProjection = z.infer<typeof RuleOfferSchema>;
  * 分臂,抽成具名函数)。为什么不 `structuredClone`/展开:显式逐键投影是本模块对「上游 additive
  * 加键」的免疫层(见 {@link RuleOfferRawSchema} 顶注)——加键到不了 `card_json`,strip 语义在
  * 投影处兑现,不靠 schema 层兜。
+ *
+ * 到这里的素材已经过素材铸点的结构窄读(`tool-approval.ts` `boundRuleOfferTexts` 拿 {@link RuleOfferRawSchema}
+ * 判过形)⇒ 两级 `kind` 的运行期 `default` 臂在健康进程里不可达;它们守的是「本仓 dist 与 core 版本不同步」
+ * 那一形([ref] 词表范式:core 加臂 ⇒ `satisfies never` 编译红由人裁投影形;运行期撞到未知臂响亮抛,绝不把一个
+ * 不认识的臂当 batch/command 硬投)。
  */
 export declare function copyRuleOffer(o: RuleOffer): RuleOfferProjection;
 /**
@@ -242,20 +341,38 @@ export declare const ApprovalCardSchema: z.ZodObject<{
         match: z.ZodEnum<{
             exact: "exact";
             prefix: "prefix";
+            wildcard: "wildcard";
+            subpath: "subpath";
         }>;
         command: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"batch">;
-        rules: z.ZodArray<z.ZodObject<{
+        rules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"command">;
             rule: z.ZodString;
             match: z.ZodEnum<{
                 exact: "exact";
                 prefix: "prefix";
+                wildcard: "wildcard";
+                subpath: "subpath";
             }>;
             command: z.ZodString;
             segment: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"directoryRead">;
+            rule: z.ZodString;
+            directory: z.ZodString;
+            segment: z.ZodString;
+        }, z.core.$strict>]>>;
         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.$strict>>>;
     }, z.core.$strict>]>>>;
     ruleOffersAbsence: z.ZodOptional<z.ZodEnum<{
         mandated: "mandated";
@@ -323,20 +440,38 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
             match: z.ZodEnum<{
                 exact: "exact";
                 prefix: "prefix";
+                wildcard: "wildcard";
+                subpath: "subpath";
             }>;
             command: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"batch">;
-            rules: z.ZodArray<z.ZodObject<{
+            rules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"command">;
                 rule: z.ZodString;
                 match: z.ZodEnum<{
                     exact: "exact";
                     prefix: "prefix";
+                    wildcard: "wildcard";
+                    subpath: "subpath";
                 }>;
                 command: z.ZodString;
                 segment: z.ZodString;
-            }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"directoryRead">;
+                rule: z.ZodString;
+                directory: z.ZodString;
+                segment: z.ZodString;
+            }, z.core.$strict>]>>;
             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.$strict>>>;
         }, z.core.$strict>]>>>;
         ruleOffersAbsence: z.ZodOptional<z.ZodEnum<{
             mandated: "mandated";

package/dist/approval-card.js

@@ -1,38 +1,97 @@
 import { z } from "zod";
 import { ASK_EVIDENCE_ABSENCE_VALUES, MAX_RULE_TEXT_CHARS } from "@sema-agent/core";
 import { redactSecrets } from "./trace/redact.js";
+import { recordFailOpen } from "./observability/fail-open.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;
 export const MAX_RULE_OFFER_BATCH_MEMBERS = 8;
-const SegmentRuleSuggestionSchema = z
-    .object({
-    rule: z.string().max(MAX_RULE_TEXT_CHARS),
-    match: z.enum(["exact", "prefix"]),
-    command: z.string().max(MAX_RULE_TEXT_CHARS),
-    segment: z.string().max(MAX_RULE_TEXT_CHARS),
-})
-    .strict();
+export const MAX_UNCOVERED_DETAIL_ROWS = 32;
+const RuleMatchSchema = z.enum(PERSISTED_RULE_MATCHES);
+const UncoveredReasonSchema = z.enum(UNCOVERED_SEGMENT_REASONS);
+const RuleOfferBatchMemberSchema = z.union([
+    z
+        .object({
+        kind: z.literal("command"),
+        rule: z.string().max(MAX_RULE_TEXT_CHARS),
+        match: RuleMatchSchema,
+        command: z.string().max(MAX_RULE_TEXT_CHARS),
+        segment: z.string().max(MAX_RULE_TEXT_CHARS),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("directoryRead"),
+        rule: z.string().max(MAX_RULE_TEXT_CHARS),
+        directory: z.string().max(MAX_RULE_TEXT_CHARS),
+        segment: z.string().max(MAX_RULE_TEXT_CHARS),
+    })
+        .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: z.enum(["exact", "prefix"]), command: z.string().max(MAX_RULE_TEXT_CHARS) }).strict(),
+    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
         .object({
         kind: z.literal("batch"),
-        rules: z.array(SegmentRuleSuggestionSchema).min(1).max(MAX_RULE_OFFER_BATCH_MEMBERS),
+        rules: z.array(RuleOfferBatchMemberSchema).min(1).max(MAX_RULE_OFFER_BATCH_MEMBERS),
         uncoveredSegments: z.number().int().nonnegative().safe(),
+        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: z.enum(["exact", "prefix"]), command: z.string() }).strip(),
+    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.object({ rule: z.string(), match: z.enum(["exact", "prefix"]), command: z.string(), segment: z.string() }).strip()).min(1),
+        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) {
+    if (typeof item !== "object" || item === null)
+        return item;
+    const candidate = item;
+    if (candidate.kind !== "batch" || !("uncoveredDetail" in candidate) || candidate.uncoveredDetail === undefined)
+        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;
+    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)) };
+}
 export function copyRuleOffer(o) {
     switch (o.kind) {
         case "single":
@@ -40,8 +99,18 @@ export function copyRuleOffer(o) {
         case "batch":
             return {
                 kind: "batch",
-                rules: o.rules.map((r) => ({ rule: r.rule, match: r.match, command: r.command, segment: r.segment })),
+                rules: o.rules.map((r) => {
+                    switch (r.kind) {
+                        case "command":
+                            return { kind: "command", rule: r.rule, match: r.match, command: r.command, segment: r.segment };
+                        case "directoryRead":
+                            return { kind: "directoryRead", rule: r.rule, directory: r.directory, segment: r.segment };
+                        default:
+                            throw new Error(`unknown rule-offer batch member kind: ${JSON.stringify(r)}`);
+                    }
+                }),
                 uncoveredSegments: o.uncoveredSegments,
+                ...(o.uncoveredDetail !== undefined ? { uncoveredDetail: o.uncoveredDetail.map((d) => ({ segment: d.segment, reason: d.reason })) } : {}),
             };
         default:
             throw new Error(`unknown rule-offer kind: ${JSON.stringify(o)}`);

package/dist/approval.d.ts

@@ -36,6 +36,37 @@ export declare function assertGateIntentServiceable(config: {
     approvalNeverAuto: readonly string[];
     durableApproval: boolean;
 }, checkpointStorePresent: boolean): void;
+/**
+ * [ref] 件⑩ —— **center 的 `forceDurableGate` 在无 checkpoint 店的部署上会静默 inert**,补一条 boot 披露。
+ *
+ * 事实链(core 7.2.0 亲读):`RuntimeCaps.forceDurableGate:true` 让引擎**合成**一个
+ * `durableApproval{scope: principal}`(`dist/core/types.d.ts:5279-5283`),好让 policy 的 `ask` 挂到
+ * durable wire 上。但「挂得上去」的前提是这台 worker 真有 checkpoint 店 —— 而本仓的构造条件逐字是
+ * `backend?.checkpoint && config.durableApproval`(main.ts)。`DURABLE_APPROVAL` 关 ⇒ 店缺席 ⇒ 合成出来
+ * 的那把锁**没有锁孔**:core 侧退化成非 durable 的 ask 链,center 那条「fleet-wide interactive runs gate」
+ * 的授权在这台机器上**一个字节都没兑现**,且两侧都不出声(core 侧归 core 的 C-22)。
+ *
+ * 为什么是 warn 不是拒启:`forceDurableGate` 是 **per-principal** 的授权,boot 期没有 principal,判不出
+ * 「今天真的会有人被下发」——能判的只有「这台机器的下发口开着(有 entitlement 源)而承接面关着」。
+ * 拿一个**可能**的下发去挡死一台本来跑得好好的 worker,是本条诊断带来的新故障,不是它治的病
+ * (与 `noticeAutoCompactAboveWindow` 的同一条取舍)。所以:响亮一行,不拒启。
+ *
+ * 为什么在 **boot** 判而不是 resolve 时判:两个入参都是**部署级**的(entitlement 源在不在、durable 门开
+ * 不开),per-principal 的那一半改变不了结论;放 resolve 里就得自己造去重,而 boot 天然只跑一次。
+ *
+ * 纯函数(返回一行或 undefined,不自己写日志)= 红先测得动;调用点在 main.ts 的
+ * {@link assertGateIntentServiceable} 之后(同一段门装配)。
+ */
+export declare function buildForceDurableGateInertNotice(input: {
+    /** center per-principal entitlement 源在不在(`centerEntitlementSourceWired` 的结果 —— 判据单源在那里)。 */
+    entitlementSourceWired: boolean;
+    /** 本进程真建出 checkpoint 店了吗(= `backend?.checkpoint && DURABLE_APPROVAL`)。 */
+    checkpointStorePresent: boolean;
+    durableApproval: boolean;
+}): {
+    event: string;
+    fields: Record<string, unknown>;
+} | undefined;
 /**
  * Durable approval policy (core 1.67 / [ref]): returns three-state **`ask`** for gated tools instead of
  * polling. With `TaskSpec.durableApproval` set + a `checkpointStore` on the Runner, core turns that `ask` into

package/dist/approval.js

@@ -13,6 +13,24 @@ export function assertGateIntentServiceable(config, checkpointStorePresent) {
     }
     throw new Error("DURABLE_APPROVAL=true but no checkpoint store is available — the configured DB backend has no checkpoint face (or no backend is configured). Wire a MySQL-protocol/PostgreSQL/file backend, or unset DURABLE_APPROVAL.");
 }
+export function buildForceDurableGateInertNotice(input) {
+    if (!input.entitlementSourceWired || input.checkpointStorePresent)
+        return undefined;
+    return {
+        event: "center_force_durable_gate_inert",
+        fields: {
+            durableApproval: input.durableApproval,
+            note: "this deployment resolves per-principal entitlements from config-center, but it has NO checkpoint store " +
+                (input.durableApproval
+                    ? "(DURABLE_APPROVAL=true, yet the configured backend exposes no checkpoint face)"
+                    : "(DURABLE_APPROVAL is off)") +
+                " — a center-issued RuntimeCaps.forceDurableGate=true will be INERT here: the engine synthesizes a " +
+                "durableApproval scope, but with no store to suspend into, gated asks fall back to the non-durable chain " +
+                "and the fleet-wide interactive-runs mandate is NOT enforced on this worker. Set DURABLE_APPROVAL=true with " +
+                "a backend that has a checkpoint face (MySQL-protocol / PostgreSQL / file), or stop issuing forceDurableGate for these principals.",
+        },
+    };
+}
 function createNameSetMatcher(names) {
     const exact = new Set(names);
     const covering = names.filter(isNamespacedCoveringRuleName);

package/dist/auto-mode-face.d.ts

@@ -0,0 +1,111 @@
+import { type Model, type ModelRoles, type RuntimeCaps } from "@sema-agent/core";
+import type { SettingsPermissionMode } from "./task-settings.js";
+/**
+ * 分类器**配置**的模型路由 —— 直接复用 core 的 `resolveTaskModel({ modelRole: "classifier" })`(prepare-task 武装时
+ * 走的同一函数:role 回落链 `classifier → summarize → default`,且 `{select}` 形 RoleSpec 按目录选型)。
+ * codex r4 [medium] 验真后改:首版按名字级自算,遇 center 下发的 `{select:{tier}}` 形会错落到 summarize/default,
+ * 对 `sema doctor permissions` 报另一个模型。答的是「配置了什么」;运行期 `derivedRouteFallsBack` 的回落不在射程
+ * (那是 core 状态座的事)。什么都解不出 ⇒ `{id:undefined, fault}`(core 的拒句当数据交出,读面不写 model 键):
+ * 本面是纯披露、不是执法——读面 500 掉整张能力表比少一个 model 键更伤。
+ */
+export declare function classifierRouteFor(deps: {
+    models?: Record<string, Model>;
+    roles?: ModelRoles;
+}): ClassifierRoute;
+/** `classifierRouteFor` 的答:解出 ⇒ `{id}`;解不出 ⇒ `{id:undefined, fault}`(core 的拒句原文,不吞)。 */
+export type ClassifierRoute = {
+    readonly id: string;
+    readonly fault?: undefined;
+} | {
+    readonly id: undefined;
+    readonly fault: string;
+};
+/** core [ref] seam ⑤ 的未武装原因闭集(六词,[ref] 加 settings_denied;顺序 = 判序)。 */
+export declare const AUTO_MODE_UNARMED_REASONS: readonly ["mode_not_auto", "deployment_incapable", "org_denied", "local_denied", "settings_denied", "resolver_fault"];
+export type AutoModeUnarmedReason = (typeof AUTO_MODE_UNARMED_REASONS)[number];
+/** 锁步表:词表与语义一一对应(加员/删员任一侧不同步 = tsc 红)。语义只供文档/测试,不上 wire。 */
+export declare const AUTO_MODE_UNARMED_REASON_SEMANTICS: {
+    readonly mode_not_auto: "本次意图不是 auto(壳发的 permissionMode 不是 \"auto\";座缺席)——只属意图武装式,旧式 core 不读模式";
+    readonly deployment_incapable: "装配面没挂 RunnerDeps.autoMode 分类器席位(本部署/本进程形不具备分类器);旧式 core 下另含「无 center 源 = 零授予路径」";
+    readonly org_denied: "per-principal caps.autoMode === false 且本地 deny 未设:center 显式 deny / center 硬失败 fail-closed 拒项;旧式 core 下另含「center 在场但未授予」";
+    readonly local_denied: "本地 catalog 键 PERMISSIONS_DISABLE_AUTO_MODE=true(center/settings 键名 permissions.disableAutoMode)把 caps.autoMode 折成 false";
+    readonly settings_denied: "settings 层 permissions.disableAutoMode 取 disable 或 true(两套已发布拼写同义;用户/managed 层 kill-switch)把本 run 折成非 auto —— capabilities 查询串不带 settings,本词由 run 级面产([6128] PM 裁定第六员)";
+    readonly resolver_fault: "per-principal caps resolver 抛错/答非记录(core 同形全拒:autoMode:false + onError phase config)";
+};
+/**
+ * 安装包探针:**这台机器上装的 core 用哪套武装极性**。
+ *
+ * 判据([ref] 改,原先用「854b202b 同批的运行时导出 `mailboxCrossProcessMountVerdict`」作代理 —— 那是 385 片2a 的
+ * mailbox 面,与 auto 武装**语义无关**,只是恰好同一个 dist;core 若把 [ref] 单独发一个补丁版,代理就答错):
+ *
+ *  · **主判(语义精确)= [ref] 自己的座**:武装点 `dist/core/runner/prepare-task.js` 里是否出现 `autoModeRequested`。
+ *    亲验(2026-09-03,`git grep autoModeRequested` 两 ref 对拍):v7.2.0 全树**零**处提及,854b202b 起 prepare-task
+ *    有 8 处 —— 单调、且探的就是「武装点读不读意图座」这件事本身。dist 未 mangle(属性名从不被 tsc/esbuild 改名),
+ *    d.ts 不参与判断(类型面运行期探不到,读 js 才是「引擎真这么跑」)。
+ *  · **佐证(只在主判为 false 时读)= 同批到货的运行时导出** `mailboxCrossProcessMountVerdict`(包内随发的
+ *    `node_modules/@sema-agent/core/test/export-surface.snapshot.json`(core 包内随发),core `files` 字段含它 —— 消费账本门 A 的同一真源)。
+ *    - 座缺席 ∧ 标记缺席 ⇒ 就是 npm 7.2.0 那一档 ⇒ `false`(旧式臂,兼容形);
+ *    - 座缺席 ∧ 标记**在场** ⇒ **矛盾**:dist 已是 854b202b 之后,而武装点不再提这个座名(core 重构/换文件)
+ *      ⇒ 判据失效,**抛**(不猜。静默回落旧式臂正是「854 之后的部署悄悄退回 org 授予极性」那一形)。
+ *    - 座在场 ⇒ `true`,不看佐证([ref] 单发的补丁版合法)。
+ *
+ * 🔴 不用 `import * as core`(消费账本门禁命名空间导入:每个消费名必须可按名对账);两个文件都经主入口 resolve
+ * 定位(package `exports` 映射不暴露这些子路径)。**任何读不到 = 抛**,由 boot 装配点承接成拒启(见
+ * {@link coreArmsAutoOnIntent})。
+ *
+ * @param distDir 测试注入的假 `dist/` 根;生产不传(从安装的 core 主入口解)。
+ */
+export declare function coreArmsAutoOnIntentProbe(distDir?: string): boolean;
+/**
+ * {@link coreArmsAutoOnIntentProbe} 的**惰性记忆化**访问器 —— 生产装配点(`main.ts` 的 `autoModeFace` 组装,
+ * 早于 `server.listen`)调一次,探针抛就是**boot 期响亮拒启**并带指路。
+ *
+ * 🔴 为什么必须惰性([ref]):此前是模块顶层 `const … = coreArmsAutoOnIntentProbe()`,而 `main.ts` 顶部 import 本模块
+ * ⇒ 探针在 **import 期**求值,读不到快照就在任何日志器/诊断存在之前把整台 server 抛死(一个 npm 安装瑕疵 =
+ * 一台起不来且没有遗言的机器)。惰性之后,同一条失败落在 boot 装配点,遗言完整、退出码照旧。
+ */
+export declare function coreArmsAutoOnIntent(): boolean;
+/** 装配面交给读面的四件事实(`main.ts` 从 runnerDeps / 合成后的 caps resolver / 到货位取,读面不自算)。 */
+export interface AutoModeFaceDeps {
+    /** `RunnerDeps.autoMode !== undefined`——**读**装配点那一位,不写字面 true(与 parked-revive 的
+     *  `autoModeSeatMounted` 同一纪律:席位哪天改成有条件挂载,这里不能静默错供)。 */
+    readonly seatMounted: boolean;
+    /** {@link coreArmsAutoOnIntent}(生产装配递探针访问器;测试可递 true 走正控)。false ⇒ `deployment_incapable`。 */
+    readonly engineArmsOnIntent: boolean;
+    /** 合成后的 per-principal caps resolver(= 递给 `RunnerDeps.runtimeCapsResolver` 的同一只:center 客户端
+     *  → observer env 基线 → memory grant → 本地 auto deny,单一属主 boot/runtime-caps.ts)。缺席 = 无任何
+     *  per-principal 源(无 center、无本地 deny)⇒ caps undefined ⇒ 三态之「缺席=不阻」。 */
+    readonly resolveCaps?: ((principal: string | undefined) => RuntimeCaps | undefined | Promise<RuntimeCaps | undefined>) | undefined;
+    /** 分类器**配置**的模型路由(server 侧按 core 的 role 回落序 `classifier → summarize → default` 从
+     *  `config.roles` 读到的 catalog 名)。这是「配置了什么」,不是「这次真用了什么」——core 的
+     *  `derivedRouteFallsBack` 可能在运行期回落到主模型;真值候 core 状态座。
+     *  🔴 codex r3 [medium]:是 **getter** 不是快照——config-center 会原地热更新 `config.roles`(Runner 每任务从活引用
+     *  重解),boot 期铸的字符串会在热切换后永久陈旧;生产装配递的 getter 调 `classifierRouteFor({ models: config.models, roles: config.roles })` 并把 fault 记 debug。 */
+    readonly classifierModel?: (() => string | undefined) | undefined;
+}
+export type AutoModeVerdict = {
+    readonly armed: true;
+    readonly model?: string;
+    readonly fault?: undefined;
+} | {
+    readonly armed: false;
+    readonly reason: AutoModeUnarmedReason;
+    readonly model?: string; /** 仅 resolver_fault 臂:错误原文(不上 wire,路由记 warn)。 */
+    readonly fault?: string;
+};
+/**
+ * 三项合取的 server 侧裁决。`requestedMode` 缺席 = 按 auto 意图答(「若请求会不会武装」);`principal` =
+ * 调用方经门验证的身份(匿名 ⇒ undefined ⇒ center 客户端答 undefined,本地 deny 层照样罩)。
+ *
+ * 🔴 resolver 抛错**不吞**:合成腿的每一层都自带 fail-closed/缺席臂(center 客户端 catch-all、grant 腿 onFault),
+ * 走到这里还在抛 = 装配缺陷,读面 500 比一句编出来的 reason 诚实。
+ */
+export declare function judgeAutoModeArming(face: AutoModeFaceDeps | undefined, input: {
+    readonly requestedMode: SettingsPermissionMode | undefined;
+    readonly principal: string | undefined;
+    readonly entitlementSource: boolean;
+    /** 本地 `PERMISSIONS_DISABLE_AUTO_MODE`(= catalog/settings 键 `permissions.disableAutoMode`)是否置 true —— caps false 时分词
+     *  `local_denied` / `org_denied`(seam ⑤;两者对壳的指路不同:改本机 env vs 找组织)。 */
+    readonly localDeny: boolean;
+}): Promise<AutoModeVerdict>;
+//# sourceMappingURL=auto-mode-face.d.ts.map