@sema-agent/server 7.146.0 → 7.148.0

package/dist/retired-name-host-notice.d.ts

@@ -0,0 +1,21 @@
+/**
+ * core 7.66.0 [ref]([ref] 加注 1 ③)—— 请求体 `settings.permissions.neverAuto`(只有本服务读的限制表:命中的工具恒问真人;引擎不读这张表,
+ * 它编成的策略不带名单投影,引擎的名字审计看不到)上**退役且无后继**的工具名:这一行不拒、原样留着,**读这张表的本服务说那一句** ——
+ * 用户面通告 `config.legacy_tool_name`,句子与 detail 是**引擎的账**(`retiredToolNameAccount`,`detail.layer` = `host_table`,每条 `source` = 这张表的体内坐标),
+ * 本服务只在 `detail` 上加归属键 `sessionId`(core 的话:the host mints its own notice … with `sessionId` added to `detail`)。本文件是这一形的**唯一**铸点。
+ *
+ * ## 判据与句子都不在本仓
+ * 哪几行算(退役且无后继、名册里没有它的另一种大小写)= 引擎的账({@link retiredLeftOutAccount},唯一读法);句子 = 账的 `message`,逐字;
+ * 有后继的改名、无前缀短名、铸不出的对端段不在账里,照旧 422(`task-settings.ts` 的 `neverAutoNamesRefusal`,同一只判官)。
+ *
+ * ## 投递 / 去重
+ * 调用点 = `boot/resolve-spec.ts` 里请求设置编成策略之后(那张表在这一刻被读);经装配期通告口(`opts.onNotice`)收进这一腿的待投通告,
+ * 与请求腿 MCP 丢弃一族同一条投递路(白名单 / 归属 / 消毒 / 隔离一个不绕;`detail.entries[].entry` 走规则文本脱敏表 `RULE_TEXT_DETAIL_FIELDS`)。
+ * 去重单位 = **每次装配一条**(引擎自己的表是 once per audited layer per prepared task,同一个单位)。会话 id 缺席 ⇒ 不铸(无处可投,宁缺不串)。
+ * 铸者:码在 core 码册里的铸者行是 `"engine"`(引擎自己的三张表铸它);本仓这一铸是 core [ref] 为宿主自有表开的同码同句同形(铸者宿主),
+ * 铸者表一行表达不了「引擎 + 宿主」两铸,见本版收车档未闭环。
+ */
+import type { EngineNotice } from "@sema-agent/core";
+/** 一次装配读到的 `neverAuto` 表 → 至多一条通告(读法见文件头)。表的 `field` = `ask`(这张表要的是「问真人」,core 的推荐形)。 */
+export declare function buildNeverAutoRetiredNotice(names: readonly string[] | undefined, sessionId: string | undefined): EngineNotice | undefined;
+//# sourceMappingURL=retired-name-host-notice.d.ts.map

package/dist/retired-name-host-notice.js

@@ -0,0 +1,12 @@
+import { retiredLeftOutAccount } from "./namespaced-rule-name.js";
+import { tightenOnlySeatField } from "./tighten-only-seats.js";
+const LEGACY_TOOL_NAME = "config.legacy_tool_name";
+export function buildNeverAutoRetiredNotice(names, sessionId) {
+    if (names === undefined || names.length === 0 || sessionId === undefined || sessionId.length === 0)
+        return undefined;
+    const account = retiredLeftOutAccount("ask", tightenOnlySeatField("neverAuto"), names);
+    if (account === undefined)
+        return undefined;
+    return { code: LEGACY_TOOL_NAME, message: account.message, detail: { ...account.detail, sessionId } };
+}
+//# sourceMappingURL=retired-name-host-notice.js.map

package/dist/rule-entry-list.d.ts

@@ -17,7 +17,7 @@
  *     **名册只有一张**({@link TOOL_NAME_ROSTER}:引擎目录 ∪ 本仓自铸的工具名),每一处读条目名的地方都传它 —— 请求体的规则表(`settings.permissions.*`)、技能清单、选择器清单、
  *     运维 / 中心的审批名单读同一份,没有「这一处空名册、那一处带名册」的两种读法。
  *     **读成空的哪些原因词是拒面,按方向定**:**限制侧**(读成空 = 静默放行:技能 `disallowedTools`、`excludeTools` / 子代 `denyTools`、`settings.permissions.deny` / `ask`、运维 / 中心的审批名单)四类全拒 ——
- *     近似名 · 退役名 · 文法读不出 · 不带内容形的工具带内容;**放行侧**(读成空 = 想放的什么也没放:`settings.permissions.allow`、根 / 子代 `allowTools`、技能 `allowedTools`)**只拒近似名**
+ *     近似名 · 退役名 · 文法读不出 · 不带内容形的工具带内容(退役名里**无后继**的那一种除外:引擎保留并通告 `config.legacy_tool_name`,判据 = 引擎的账,core 7.65.0 [ref] / 7.66.0 [ref] / [ref]);**放行侧**(读成空 = 想放的什么也没放:`settings.permissions.allow`、根 / 子代 `allowTools`、技能 `allowedTools`)**只拒近似名**
  *     ({@link allowSideReadsAsNothing}):近似名现名唯一、确定是笔误;退役名 / 内容形 / 文法读不出 / 协议名对端段通配照 7.130.0 受理、交引擎既有通告(其中选择器清单 `allowTools` 里**有后继**的退役名〔`Task` ⇒ `Agent`、`bash` ⇒ `Bash`〕core 7.52.0 起由引擎开跑前拒,不在本仓拒面;规则表上的退役名引擎照旧告运维 ——
  *     壳转投的 CC 用户 settings 里这些极常见,尤其内容形里的 `$VAR`(`Bash(echo $HOME)`)读成 `grammar`,拒了 = 每次提交 400)。运维的 `APPROVAL_GRANT` 是运维自己的配置:任何读成空都拒启(写错了当场改)。
  *     技能拒侧那一拒与引擎 [ref](core 7.43.0:那只技能不激活)是同一件事的两处 —— 7.118.0 重估过、本版**不退**:本仓的续跑腿把引擎的
@@ -29,7 +29,7 @@
  *     选择器读一条条目 = 引擎 `judgeToolNameList` 的读法({@link selectorEntryName}):先取工具名那一段再只判名字(限制侧 `Tool(content)` ⇒ 整只工具,内容里写什么都不读;放行侧内容形引擎告「什么也不授」,受理口不拒);
  *     `*` 在放行侧是「本层不设名单」、在限制侧是整名 glob(引擎文法 5,7.137.0 起;此前读成空、受理口拒);限制侧整个协议的名字 `mcp__*` / `mcp__*__*` / `a2a__*` 合法 —— 那是引擎条目读法的读数(core 7.55.0 [ref]:
  *     `compileAllowList(…, "deny", 名册)` 把它们读成这一协议的每一只工具),本仓不另写豁免。
- *  ⑤ **机读位**:拒体的码与句子是第一处命中的清单的(句子冻结),体另带这一遍判下来的**全部**读成空的条目(`entry-problems.ts` 的 `detail.problems`,{@link inertToolListEntryOf} 铸);
+ *  ⑤ **机读位**:拒体的码与句子是第一处命中的清单的(句子冻结),体另带这一遍判下来的**全部**读成空的条目(`entry-problems.ts` 的 `problems`,在拒体根上;{@link inertToolListEntryOf} 铸);
  *     放行侧选择器清单里受理口没拒、却什么也不放的条目随受理应答的 `warnings` 交回({@link allowSelectorWarningsOf})—— 两处读同一次条目读法({@link selectorReadings}),不另判。
  */
 import type { TightenOnlySeatField } from "./tighten-only-seats.js";

package/dist/rule-entry-list.js

@@ -1,7 +1,7 @@
 import { PROTOCOL_TABLE, compileAllowList, parsePermissionRule } from "@sema-agent/core";
 import { displayListEntry } from "./list-entry-display.js";
 import { limitRefusal } from "./limit-refusal.js";
-import { TOOL_NAME_ROSTER } from "./namespaced-rule-name.js";
+import { TOOL_NAME_ROSTER, isRetiredLeftOut } from "./namespaced-rule-name.js";
 import { NOT_IN_ROSTER, entryProblem, entryProblemsFacts } from "./entry-problems.js";
 import { layeredRuleOk } from "./permission-rule-list.js";
 export const ruleEntryListShapeOk = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
@@ -107,9 +107,8 @@ function requestAllowRuleInertEntriesOf(list) {
 }
 function inertEntriesOfList(list, layer) {
     const face = TOOL_LIST_FACES[layer];
-    if (face.kind === "selector")
-        return selectorInertEntriesOf(list, face.side);
-    return face.side === "deny" ? inertRuleEntriesOf(list, "deny") : requestAllowRuleInertEntriesOf(list);
+    const inert = face.kind === "selector" ? selectorInertEntriesOf(list, face.side) : face.side === "deny" ? inertRuleEntriesOf(list, "deny") : requestAllowRuleInertEntriesOf(list);
+    return face.side === "deny" ? inert.filter((i) => !isRetiredLeftOut(i.entry)) : inert;
 }
 function* toolListsOf(body) {
     const skills = body["skills"];

package/dist/rule-issue-reading.d.ts

@@ -0,0 +1,58 @@
+/**
+ * **本仓怎样读 core 规则编译器的拒句** —— 一只判官({@link deploymentRuleRefusal})、一张受众表({@link RULE_ISSUE_AUDIENCE})。
+ *
+ * core 的每条规则拒句({@link PermissionRuleIssue})分两层说话:
+ *  · `message`(与 `code` / `rule`)写给**写规则的人** —— 这一条错在哪、该怎么改;
+ *  · `libraryOption` 写给**宿主程序** —— 这条拒句涉及的库坐标:编译调用的构造选项(`primaryFieldGeneric: "allow-lexical"`、`caps.*`、`pathBases.*`、`defaultAction`、`ruleFaces`)、
+ *    允许表的座位(`TaskSpec.allowedTools` / `RunnerDeps.allowedTools`)、MCP 服务器声明里的 `toolAxes`。
+ * core 的契约(`PermissionRuleIssue.libraryOption`)逐字:**句子从不点名那一位**;暴露这些坐标的宿主自己渲染它,别的宿主只给句子。
+ *
+ * 本仓是「别的宿主」,读法只有一条:**部署面的句子 = `code` + core 的句,`libraryOption` 不渲染**。理由分两种,都是读码得来的:
+ *  · 坐标是本仓装配编译调用时自己选 / 自己推的(`caps` / `pathBases`,见 `buildRuleListJudgeOptions`;`primaryFieldGeneric` 本仓零设点)—— 写规则的人没有旋钮,渲染它 = 一条够不着的出路;
+ *  · 坐标在部署上有够得着的面(请求的 / 运维的允许表、MCP 服务器声明里的 `toolAxes`)—— core 的句子已经用人的话说了那个面(「the request's allow list, or the deployment's」、「declared per tool in the MCP server's spec」),
+ *    再渲染库的拼写(`TaskSpec.allowedTools`)只是把库的字段名摆到给人看的句子里。
+ *
+ * ── 怎么保证只有一条读法 ─────────────────────────────────────────────────────────────────────
+ *  · {@link RULE_ISSUE_AUDIENCE} 给拒句的**每一位**定受众,`satisfies Record<keyof PermissionRuleIssue, …>`:core 多一位 / 少一位 ⇒ 这里 tsc 红,先决定那一位面向谁,
+ *    不会悄悄落成「没人读它」或「谁都渲染它」。返回型 {@link PersonFacingRuleIssue} 由这张表**推出来**(每一位面向人的位都必填,可选位也一样),判官里逐位挑,多挑 / 漏挑一位 ⇒ tsc 红。
+ *  · 判官**不在运行期扫句子**:那是对 core 句子的第二套判。core 把库坐标写回句子里,是 core 契约的回归 —— 由 `test/rule-issue-reading.test.ts` 的 pickup 钉在提货时红
+ *    (真 core 规则编译器铸得出的每一种坐标各一格;坐标名单是类型联合上的穷尽表,core 多一种坐标 ⇒ 那张表 tsc 红)。
+ *  · 读拒句的口只有 `config.ts` 的预判口 `uncompilableRuleGuidance` 一个(名表 / 规则表的各条受理腿 —— env 审批名单、中心下发的审批名单、请求体 `settings.permissions.deny` / `ask`、
+ *    存体重放 —— 都经它);源码钉保证 `validatePermissionRules` 与 `libraryOption` 不在别处出现。编译口 `createRuleListPolicy` 只转 core 抛出的整句(`[码] 规则: 句`,同样只有面向人的位)。
+ *
+ * 范围(如实):本模块只管**规则编译器的拒句**。core 的其它出路话(无头审批的 `headlessApprovalRemedy` 句子与 `remedies`、`delegation.ask_unresolvable` 通告)是别的契约、别的读法
+ * —— core 把那句子标为面向用户、`remedies` 标为宿主自选渲染的数据 —— 不在这条读法里。
+ */
+import type { PermissionRuleIssue } from "@sema-agent/core";
+/** 拒句的一位写给谁:`person` = 写规则的人(部署者 / 请求方);`library` = 宿主程序(本仓不渲染)。 */
+type Audience = "person" | "library";
+/**
+ * core 拒句每一位的受众 —— **穷尽表**(`satisfies Record<keyof PermissionRuleIssue, …>`:缺一位 / 多一位 tsc 红)。
+ * `rule` 是写规则的人自己写下的文本(本仓点名条目时用自己手里的那一份,不读这一位),但它面向人,所以标 `person`。
+ */
+export declare const RULE_ISSUE_AUDIENCE: {
+    readonly rule: "person";
+    readonly code: "person";
+    readonly message: "person";
+    readonly libraryOption: "library";
+};
+type FieldsFor<A extends Audience> = {
+    [K in keyof typeof RULE_ISSUE_AUDIENCE]: (typeof RULE_ISSUE_AUDIENCE)[K] extends A ? K : never;
+}[keyof typeof RULE_ISSUE_AUDIENCE];
+/**
+ * 拒句里面向人的那几位(型由 {@link RULE_ISSUE_AUDIENCE} 推出)。刻意不用 `Pick`:`Pick` 保留可选性,core 加一个**可选**位并标 `person` 时,漏挑它不报错;
+ * 这里的映射型不跟随原型的可选标记,每一位面向人的位都必填(值型仍是 core 的,可选位的值可以是 `undefined`)。
+ */
+export type PersonFacingRuleIssue = {
+    readonly [K in FieldsFor<"person">]: PermissionRuleIssue[K];
+};
+/**
+ * core 的规则文法判「这一条编不出来」时,本仓交给部署面的一句话:`<码> — core's rule grammar cannot compile this entry: <core 的句>`。
+ * 码与句逐字是 core 的;`libraryOption` 不进句子、也不进出口(出口只有 `code` / `guidance`)。
+ */
+export declare function deploymentRuleRefusal(issue: PermissionRuleIssue): {
+    readonly code: string;
+    readonly guidance: string;
+};
+export {};
+//# sourceMappingURL=rule-issue-reading.d.ts.map

package/dist/rule-issue-reading.js

@@ -0,0 +1,14 @@
+export const RULE_ISSUE_AUDIENCE = {
+    rule: "person",
+    code: "person",
+    message: "person",
+    libraryOption: "library",
+};
+function personFacing(issue) {
+    return { rule: issue.rule, code: issue.code, message: issue.message };
+}
+export function deploymentRuleRefusal(issue) {
+    const { code, message } = personFacing(issue);
+    return { code, guidance: `${code} — core's rule grammar cannot compile this entry: ${message}` };
+}
+//# sourceMappingURL=rule-issue-reading.js.map

package/dist/rules-consent.d.ts

@@ -1,5 +1,5 @@
 import { type DirectWritableRuleBehavior, type RemovalLiveness } from "./permission-rule-vocab.js";
-import { type RuleOwner, type ImportPreview, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type RuleRefusalCode, type RuleWriteCommitted, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
+import { type ConfirmRefusalReason, type RuleOwner, type ImportPreview, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type RuleRefusalCode, type RuleWriteCommitted, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
 import type { DurableRulePartitionProvider, PermissionRuleStoreProvider, RuleApprovalRecordStore } from "@sema-agent/core";
 import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./plugins/permission-rule-store-sql.js";
 /**
@@ -192,9 +192,10 @@ export type LocalImportRefusalCode =
  | "not_importable";
 /** 兑付回执的**成员级终态**(闭集,机读;`detail` 是给人看的那一半)。两只 redeem 口(cc-import / local-import)同一张表。
  *
- *  🔴 **引擎拒的成员,结局只读引擎的两词 `committed`**(core 7.63.0 [ref],`RedeemedBatchMember` 拒臂必填):`no` ⇒ `refused`
- *  (引擎确知这一条没落 —— 裁定,如旧导入记录里从 `/` 写起的全局规则的 `unsupported.layer_root`;同批放行被扣下的 `withheld`)、
- *  `unknown` ⇒ `indeterminate`(写面抛 / 读回读不出 —— 那一条**可能已经落了**)。本仓不按串判,不另写第二份判据。
+ *  🔴 **引擎拒的成员,结局只读引擎的两位**(core 7.65.0 [ref] / [ref]:`committed` 一种读法 + `retriable` 另席,拒臂皆必填):
+ *  `committed: "no"` ∧ 不可重试 ⇒ `refused`(引擎定了这一条不立 —— 裁定,如旧导入记录里从 `/` 写起的全局规则的 `unsupported.layer_root`;
+ *  同批放行被扣下的 `withheld`;人撤掉了它的 `dot_removed`)。可重试(写前的店故障)或 `committed: "unknown"`(写已发出而结局未知)
+ *  ⇒ 这一走**未定**,整走不落定(见 {@link settleImportWalk})。本仓不按串判,不按码猜,不另写第二份判据。
  *  它进了**落盘回执的边界 schema**(`ImportOutcomeSchema`;`redeemed_outcome` 列回读同一张词表)。⚠️ 预览面**不用**这个词表:那一面的拒绝形是
  *  `admitted:false + LocalImportRefusalCode`({@link LocalImportPreviewMember}),两面词表**不同**。 */
 export type ImportMemberOutcome = 
@@ -202,11 +203,10 @@ export type ImportMemberOutcome =
 "persisted"
 /** 等价规则**已经在店**(引擎的 `deduped`)—— 同意早就生效,这次什么都不用做。 */
  | "no-op"
-/** 引擎拒了这一条,并答 `committed: "no"` —— 确知没落。重来同一条拒因(`reason`)会得同一个答,出路在 `detail`(引擎原话)。 */
+/** 引擎拒了这一条,并答 `committed: "no"`、不可重试 —— 定了不立。重来同一条拒因(`reason`)会得同一个答,出路在 `detail`(引擎原话)。 */
  | "refused"
-/** 引擎拒了这一条,并答 `committed: "unknown"` —— **不知道落没落**。如实编,禁猜。这一词**不进落定的回执**(落定律:任一成员
- *  结局不知 ⇒ 不落定、503 同票重走,见 {@link unsettledDetailOf});词表留着它,是因为 7.145.x 及更早落定的票行(`redeemed_outcome`)
- *  里有它,回放读那份存量。 */
+/** 7.145.x 及更早落定的票行(`redeemed_outcome`)里的词:引擎答 `committed: "unknown"` 的成员。7.146.0 起这一词**不再铸**(落定律:任一成员
+ *  未定 ⇒ 不落定、503 同票重走,见 {@link settleImportWalk});词表留着它只为回放读那份存量。 */
  | "indeterminate";
 /** prepare 面的一行。判别式联合:被收下的行**没有**拒因字段可读,被拒的行**必然**带拒因 ——
  *  「admitted 却带 reason」这种矛盾态在类型上不可表达。
@@ -227,7 +227,7 @@ export type LocalImportPreviewMember = {
 };
 /** 一条收紧在 prepare 当场落店的结局(与兑付回执的 `persisted` / `no-op` 同词同义;直写接缝 `addPersistedRule` 的 `added` / `no-op`)。 */
 export type LocalImportTighteningOutcome = "persisted" | "no-op";
-/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link buildImportOutcomeMembers})。`reason` / `detail` 在场 ⇔ 引擎拒了这一条
+/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link settleImportWalk})。`reason` / `detail` 在场 ⇔ 引擎拒了这一条
  *  (`refused` / `indeterminate`):`reason` = 引擎的闭集拒因码(`RuleRefusalCode`,core 属主,逐字),`detail` = 引擎给人看的那句话。 */
 export interface ImportOutcomeMember {
     key: ImportRuleKey;
@@ -239,12 +239,12 @@ export interface ImportOutcomeMember {
  * 一次兑付的回执整只 —— **两只 redeem 口同一张**(cc-import / local-import 的 200 体都是 `{ members, rev }`,路由同一个铸点),
  * local-import 另把它**逐字**写进票行 `redeemed_outcome`(回放同源:回放答的就是它)。
  *
- * 🔴 **落定律(一条,两口同读)**:兑付走完、拿到引擎的完整成员表、**且每个成员的结局都确定**(`persisted` / `no-op` / 引擎答
- * `committed: "no"` 的 `refused`)⇒ 这次兑付落定,回执逐成员交出,票不放回、不答 503:cc-import 一次性用掉、答 200 回执;local-import 把回执
+ * 🔴 **落定律(一条,两口同读,{@link settleImportWalk})**:兑付走完、拿到引擎的完整成员表、**且每个成员的结局都定了**(`persisted` / `no-op` / 引擎答
+ * `committed: "no"` 且不可重试的 `refused`)⇒ 这次兑付落定,回执逐成员交出,票不放回、不答 503:cc-import 一次性用掉、答 200 回执;local-import 把回执
  * 落进票行(SETTLED)后答 200 —— 落定这一跳答不成(落定写抛 / 认领被租约接管而新持有者还没落定)⇒ 照旧答 409
  * `conflict.rule_import_in_flight`,同票再来读到的是权威的那一份回执(那一跳不改成员结局,只决定哪一份是权威)。**没有**完整
- * 成员表(引擎在走之前整批拒 / confirm 输给并发写者 / 店在走之前抛 / 循环里仍抛出来的异常),或任一成员结局**不知**(引擎答
- * `committed: "unknown"`:规则店的写抛 / 读回读不出,引擎 7.64.0 起还有成员循环里审批记录店的记 dot CAS / dot 分配失败)⇒ 不落定:放回认领、503
+ * 成员表(引擎在走之前整批拒 / confirm 输给并发写者或撞记录店故障 / 店在走之前抛 / 循环里仍抛出来的异常),或任一成员**未定**(引擎答
+ * `retriable: true`:成员循环里审批记录店的记 dot CAS / dot 分配 / 读记录在规则写之前失败;或 `committed: "unknown"`:规则店的写抛 / 读回读不出)⇒ 不落定:放回认领、503
  * `state.rule_import_retry`,同一张票重来就是重走一遍 —— 兑付按引擎的设计幂等(记录里的 dot 台账),重走交出完整表,
  * 被打断的那一走已落的成员读 `no-op`。确知的成员拒**不**按票自动重试:一条永久被拒的成员(旧记录里的 `unsupported.layer_root`)
  * 若走重试臂,客户端会 503 到票过期、临期放不回 ⇒ 404,已落成员不撤、被拒成员永不落 —— 7.144.0 及更早 cc-import 口就是这一形。
@@ -286,6 +286,14 @@ export type LocalImportPrepared = {
     reason: "tightening-write-failed";
     committed: RuleWriteCommitted;
     detail: string;
+}
+/** 放行那一半的审批记录建不成(引擎 `prepareCcImport` 答可重试的店拒;同 {@link RuleImportPrepared} 同名臂):无票;同批更早的收紧
+ *  可能已生效,同一批原样重发即是出路(已生效的答 no-op)。 */
+ | {
+    ok: false;
+    reason: "record-store-refused";
+    committed: RuleWriteCommitted;
+    detail: string;
 };
 /** A7 redeem 的结果。 */
 export type LocalImportRedeemed = 
@@ -332,6 +340,14 @@ export type RuleImportPrepared = {
     ok: false;
     reason: "too-many-candidates";
     candidates: number;
+}
+/** 引擎的审批记录店建记录失败(core 7.65.0 起 `prepareCcImport` 答拒臂而不是抛):`retriable` 为真 ⇒ 本臂(无票、无规则落店,
+ *  同一请求原样重发即是出路;`committed` 原样是引擎那一词)。引擎说不可重试的拒(契约上不出现)不进本臂,响亮抛。 */
+ | {
+    ok: false;
+    reason: "record-store-refused";
+    committed: RuleWriteCommitted;
+    detail: string;
 };
 /** 导入 redeem 的结果。wire 口径写死(端点=http/routes/rules.ts):成功 ⇒ 200 回执 `{ members, rev }`(与 local-import 口
  *  同一张、同一个铸点;落定律见 {@link ImportOutcome});票拒五类(自造 / 别人的 / 错车道 / 过期 / 已用过)与裁定性拒绝
@@ -535,8 +551,8 @@ export type DurableRuleScope = Exclude<RuleScope, {
  *  🔴 **收不收只有一只判据:core 的 `isValidDurableScope`**(引擎 7.46.0 起 project root 必须是完整绝对路径:`/…`、`X:\…` /
  *  `X:/…`、`\\host\…`)。四个 wire 入口(`/v1/rules` 写 / 撤 / 列举过滤、local-import 的行)都经这里;cc-import 的层 root 调同一只
  *  谓词(`http/routes/rules.ts`)。修前这里手抄了一份「root 非空」:`project:myproj` 本仓收、引擎写臂拒(写口答 503「再发一次」——
- *  客户端会无限重试)、引擎读侧丢(撤销口删不动),一条规则在两侧是两种命运。存量的那种行由一次性迁移 M11 删
- *  (`plugins/one-time-migrations.ts` 登记表)。 */
+ *  客户端会无限重试)、引擎读侧丢(撤销口删不动),一条规则在两侧是两种命运。存量的那种行(7.119.x 及更早收下的)不再被起服删除 ——
+ *  引擎读侧继续丢它并告知(`permission.rule_row_dropped`),出路是运维在库里删那一行。 */
 export declare function parseRuleScope(text: string): DurableRuleScope | undefined;
 /** 引擎不收的 scope 的**唯一一句**拒句:写 / 撤 / 列举过滤三个路由口、local-import 的成员拒因 `scope_unreadable` 都出站这一只
  *  (各口的码照旧各自的),不在读点各抄一份。cc-import 预览的层 root 判据是同一只(`isValidDurableScope`),但那份体里没有 scope 字段,
@@ -666,11 +682,13 @@ export type RuleWritten =
     stillLive: Exclude<RemovalLiveness, "yes">;
     row?: undefined;
 }
-/** 裁定性不收(内容判据 / 方向判据)。`detail` 是给人看的那一半,`reason` 是给客户端分流的那一半。 */
+/** 裁定性不收(内容判据 / 方向判据)。`detail` 是给人看的那一半(进拒句),`reason` 是给客户端分流的那一半;
+ *  `canonical` 只在「写入原样不是店会存的拼写」那一臂:店会存的规范拼写原串,调用方原样重发即可(机读位,不必从句子里抠)。 */
  | {
     status: "rejected";
     reason: LocalImportRefusalCode;
     detail: string;
+    canonical?: string;
 }
 /** 终态写失败。`detail` 是给人看的那一半;`committed`({@link RuleWriteCommitted},core 的两词闭集)是
  *  给机器分流的那一半 —— 它回答的是**调用方下一步该做什么**。
@@ -768,6 +786,18 @@ export interface RuleConsentLane {
         scope: DurableRuleScope;
     }): Promise<RuleWritten>;
 }
+/**
+ * 兑付腿拒绝里的**店故障**两词(审批记录店的读 / CAS / dot 分配失败与规则店自己的读写失败同两词):`store_read` / `store_write`。
+ * 其余十五词是裁定性拒。卡道重不重试 = 引擎的 `retriable` **∧** 本谓词(见 {@link throwIfRetriable}):`retriable` 真而码不是店故障 = 版本不同步,不重试、响一行;
+ * 两只导入口不读本谓词(只读 `retriable` 与 `committed`,见 `openRefusalOf`)。
+ * 闭集穷举(词表属主 core 加词 ⇒ 这里编译红,由人裁新词归哪边)。
+ */
+export declare function isRuleStoreFault(code: RuleRefusalCode): code is "store_read" | "store_write";
+/**
+ * 确认拒里**同一请求重来即可**的三词(闭集穷举):`conflict`(CAS 输给并发写者)、`store_read`(读记录抛,确认一个字没写)、`store_write`
+ * (记确认的 CAS 抛:记录可能已落 —— 同一确认重来,已落的记录答幂等的 yes;core 7.65.0 [ref])。其余是裁定。两只导入口读它定「放回认领 / 裁定拒」。
+ */
+export declare function confirmRefusalRetries(reason: ConfirmRefusalReason): boolean;
 export declare function createRuleConsentLane(stores: RuleConsentStores, opts?: {
     ticketTtlMs?: number;
     newTicketId?: () => string;

package/dist/rules-consent.js

@@ -114,8 +114,12 @@ function isCommandRuleMatch(match) {
     }
 }
 const unknownReasonLogger = createLogger();
-function confirmRefusalWord(reason) {
+function confirmRefusalWord(confirmed) {
+    const { reason } = confirmed;
     switch (reason) {
+        case "store_read":
+        case "store_write":
+            throw new RuleStoreFaultError({ code: reason, reason: confirmed.detail?.message ?? reason });
         case "edit_disabled":
         case "edit_binding_mismatch":
             return "edit-unsupported";
@@ -137,7 +141,7 @@ function confirmRefusalWord(reason) {
         }
     }
 }
-function isRuleStoreFault(code) {
+export function isRuleStoreFault(code) {
     switch (code) {
         case "store_read":
         case "store_write":
@@ -158,8 +162,11 @@ function isRuleStoreFault(code) {
         case "occ":
         case "dot_removed":
             return false;
-        default:
-            return code;
+        default: {
+            const unknown = code;
+            unknownReasonLogger.warn("isRuleStoreFault: unknown RuleRefusalCode from core (dist/core version skew?) — read as not a store failure", { code: String(unknown) });
+            return false;
+        }
     }
 }
 class RuleStoreFaultError extends Error {
@@ -170,17 +177,37 @@ class RuleStoreFaultError extends Error {
         this.code = refusal.code;
     }
 }
-function throwIfRuleStoreFault(refusal) {
-    const { code } = refusal;
-    if (!isRuleStoreFault(code))
+const retriableSkewLogger = createLogger();
+function throwIfRetriable(refusal) {
+    if (!refusal.retriable)
         return;
-    switch (refusal.committed) {
-        case "no":
-            throw new RuleStoreFaultError({ code, reason: refusal.reason });
-        case "unknown":
-            return;
-        default:
-            return refusal.committed;
+    const { code } = refusal;
+    if (isRuleStoreFault(code))
+        throw new RuleStoreFaultError({ code, reason: refusal.reason });
+    retriableSkewLogger.warn("an engine refusal says retriable but its code is not a store failure (core/dist skew?) — not retried", { code });
+}
+export function confirmRefusalRetries(reason) {
+    switch (reason) {
+        case "conflict":
+        case "store_read":
+        case "store_write":
+            return true;
+        case "record_not_found":
+        case "record_schema_stale":
+        case "record_malformed":
+        case "selection_missing":
+        case "selection_invalid":
+        case "selection_mismatch":
+        case "not_pending":
+        case "edit_disabled":
+        case "edit_binding_mismatch":
+        case "edit_rejected":
+            return false;
+        default: {
+            const unknown = reason;
+            unknownReasonLogger.warn("confirmRefusalRetries: unknown ConfirmRefusalReason from core (dist/core version skew?) — read as not retriable", { reason: String(unknown) });
+            return false;
+        }
     }
 }
 function refusedMembersOf(members) {
@@ -287,39 +314,51 @@ function buildLocalImportLayers(candidates) {
         return root === "" ? { layer: "userSettings", path: LOCAL_IMPORT_LAYER_PATH, readFile } : { layer: "projectSettings", path: `${LOCAL_IMPORT_LAYER_PATH}:${root}`, root, readFile };
     });
 }
-function buildImportOutcomeMembers(members) {
-    return members.map((m) => {
+function settleImportWalk(members) {
+    const settled = [];
+    for (const m of members) {
         const key = { behavior: m.behavior, rule: m.rule, scope: serializeRuleScope(m.scope) };
         switch (m.status) {
             case "persisted":
-                return { key, outcome: "persisted" };
+                settled.push({ key, outcome: "persisted" });
+                break;
             case "deduped":
-                return { key, outcome: "no-op" };
-            case "refused":
-                return { key, outcome: refusedOutcomeOf(m.committed), reason: m.code, detail: m.reason };
+                settled.push({ key, outcome: "no-op" });
+                break;
+            case "refused": {
+                const open = openRefusalOf(m);
+                if (open !== undefined)
+                    return { open: `the outcome of ${m.rule} is not settled (${m.code}, ${open}): ${m.reason}` };
+                settled.push({ key, outcome: "refused", reason: m.code, detail: m.reason });
+                break;
+            }
             default: {
                 const unknown = m;
                 throw new Error(`unknown redeemed-batch member status: ${JSON.stringify(unknown)}`);
             }
         }
-    });
-}
-function unsettledDetailOf(members) {
-    const open = members.find((m) => m.outcome === "indeterminate");
-    return open === undefined ? undefined : `the outcome of ${open.key.rule} is not known (${open.reason ?? "unknown"}): ${open.detail ?? ""}`;
+    }
+    return { settled };
 }
-function refusedOutcomeOf(committed) {
-    switch (committed) {
+function openRefusalOf(refusal) {
+    if (refusal.retriable)
+        return "retriable";
+    switch (refusal.committed) {
         case "no":
-            return "refused";
+            return undefined;
         case "unknown":
-            return "indeterminate";
+            return "committed unknown";
         default: {
-            const unknown = committed;
+            const unknown = refusal.committed;
             throw new Error(`unknown redeemed-batch member committed word: ${JSON.stringify(unknown)}`);
         }
     }
 }
+function importRecordRefusal(refusal) {
+    if (!refusal.retriable)
+        throw new Error(`the engine refused to prepare this import and says repeating will not help (${refusal.code}): ${refusal.reason}`);
+    return { ok: false, reason: "record-store-refused", committed: refusal.committed, detail: refusal.reason };
+}
 export function createRuleConsentLane(stores, opts) {
     const deps = { provider: stores.provider, approvals: stores.approvals, cardEdits: true };
     const ticketTtlMs = opts?.ticketTtlMs ?? RULE_IMPORT_TICKET_TTL_MS;
@@ -351,6 +390,10 @@ export function createRuleConsentLane(stores, opts) {
             if (prepared === undefined) {
                 return { ok: false, reason: "no-candidates", detail: "the rule lane cannot speak for this command (compound / redirection / unsupported tool)" };
             }
+            if ("status" in prepared) {
+                throwIfRetriable(prepared);
+                return { ok: false, reason: "redeem-refused", detail: prepared.reason };
+            }
             const redemption = input.redemption;
             if (redemption.kind === "batch") {
                 const wanted = new Set(redemption.offer.rules.map((r) => r.rule));
@@ -360,17 +403,17 @@ export function createRuleConsentLane(stores, opts) {
                 }
                 const confirmed = await confirmRuleApproval({ approvalId: prepared.approvalId, principal: input.principal, selectedOffer: offerIndex, deps });
                 if (!confirmed.ok)
-                    return { ok: false, reason: "confirm-refused", detail: confirmed.reason };
+                    return { ok: false, reason: confirmRefusalWord(confirmed), detail: confirmed.detail?.message ?? confirmed.reason };
                 const result = await redeemRuleBatch({ approvalId: prepared.approvalId, principal: input.principal, deps });
                 if ("status" in result) {
-                    throwIfRuleStoreFault(result);
+                    throwIfRetriable(result);
                     return { ok: false, reason: "redeem-refused", detail: result.reason };
                 }
                 const refused = refusedMembersOf(result.members);
                 if (refused.length > 0) {
-                    if (refused.length === result.members.length && refused.every((m) => m.committed === "no"))
-                        for (const m of refused)
-                            throwIfRuleStoreFault(m);
+                    const first = refused[0];
+                    if (first !== undefined && refused.length === result.members.length && refused.every((m) => m.retriable))
+                        throwIfRetriable(first);
                     return { ok: false, reason: "redeem-refused", detail: `partial batch: ${refused.length} member(s) refused (${refused.map((x) => x.reason).join("; ")})` };
                 }
                 return { ok: true, ...anchorBatchMembers(result.members, redemption.offer), rev: result.rev };
@@ -385,7 +428,7 @@ export function createRuleConsentLane(stores, opts) {
                 }
                 const confirmed = await confirmRuleApproval({ approvalId: prepared.approvalId, principal: input.principal, selectedOffer: offerIndex, deps });
                 if (!confirmed.ok)
-                    return { ok: false, reason: "confirm-refused", detail: confirmed.reason };
+                    return { ok: false, reason: confirmRefusalWord(confirmed), detail: confirmed.detail?.message ?? confirmed.reason };
                 ticket = offered;
             }
             else {
@@ -403,7 +446,7 @@ export function createRuleConsentLane(stores, opts) {
                     deps,
                 });
                 if (!confirmed.ok)
-                    return { ok: false, reason: confirmRefusalWord(confirmed.reason), detail: confirmed.detail?.message ?? confirmed.reason };
+                    return { ok: false, reason: confirmRefusalWord(confirmed), detail: confirmed.detail?.message ?? confirmed.reason };
                 const minted = confirmed.mintedCandidate;
                 if (minted === undefined) {
                     return { ok: false, reason: "confirm-refused", detail: "the edited confirmation landed without a minted candidate — nothing to redeem" };
@@ -419,7 +462,7 @@ export function createRuleConsentLane(stores, opts) {
             }
             const redeemed = await redeemRuleTicket({ ticket, principal: input.principal, deps });
             if (redeemed.status !== "redeemed") {
-                throwIfRuleStoreFault(redeemed);
+                throwIfRetriable(redeemed);
                 return { ok: false, reason: "redeem-refused", detail: redeemed.reason };
             }
             return { ok: true, kind: "single", rule: redeemed.rule, rev: redeemed.rev, alreadyRedeemed: redeemed.alreadyRedeemed };
@@ -429,7 +472,10 @@ export function createRuleConsentLane(stores, opts) {
                 const readFile = async () => l.content;
                 return l.layer === "userSettings" ? { layer: l.layer, path: l.path, readFile } : { layer: l.layer, path: l.path, root: l.root, readFile };
             });
-            const { preview, approvalId } = await prepareCcImport({ layers: ccLayers, principal, deps });
+            const prepared = await prepareCcImport({ layers: ccLayers, principal, deps });
+            if ("status" in prepared)
+                return importRecordRefusal(prepared);
+            const { preview, approvalId } = prepared;
             if (approvalId === undefined) {
                 return { ok: true, preview };
             }
@@ -509,8 +555,8 @@ export function createRuleConsentLane(stores, opts) {
                 if (record.state === "pending") {
                     const confirmed = await confirmRuleApproval({ approvalId: consumed.approvalId, principal, deps });
                     if (!confirmed.ok) {
-                        if (confirmed.reason === "conflict")
-                            return await indeterminate(confirmed.reason);
+                        if (confirmRefusalRetries(confirmed.reason))
+                            return await indeterminate(confirmed.detail?.message ?? confirmed.reason);
                         return { ok: false, reason: "record-unusable", detail: confirmed.reason };
                     }
                 }
@@ -518,11 +564,10 @@ export function createRuleConsentLane(stores, opts) {
                 if ("status" in result) {
                     return await indeterminate(result.reason);
                 }
-                const members = buildImportOutcomeMembers(result.members);
-                const open = unsettledDetailOf(members);
-                if (open !== undefined)
-                    return await indeterminate(open);
-                return { ok: true, outcome: { members, rev: result.rev } };
+                const walk = settleImportWalk(result.members);
+                if ("open" in walk)
+                    return await indeterminate(walk.open);
+                return { ok: true, outcome: { members: walk.settled, rev: result.rev } };
             }
             catch (err) {
                 return await indeterminate(err instanceof Error ? err.message : String(err));
@@ -580,7 +625,10 @@ export function createRuleConsentLane(stores, opts) {
             }
             if (allows.length === 0)
                 return { ok: true, preview: { members } };
-            const { preview, approvalId } = await prepareCcImport({ layers: buildLocalImportLayers(allows), principal, deps });
+            const prepared = await prepareCcImport({ layers: buildLocalImportLayers(allows), principal, deps });
+            if ("status" in prepared)
+                return importRecordRefusal(prepared);
+            const { preview, approvalId } = prepared;
             const engineKeys = new Set(preview.candidates.map((c) => `${c.behavior}${LOCAL_IMPORT_KEY_SEP}${serializeRuleScope(c.scope)}${LOCAL_IMPORT_KEY_SEP}${c.rule}`));
             for (let i = 0; i < members.length; i++) {
                 const m = members[i];
@@ -669,8 +717,8 @@ export function createRuleConsentLane(stores, opts) {
                     if (record.state === "pending") {
                         const confirmed = await confirmRuleApproval({ approvalId, principal, deps });
                         if (!confirmed.ok) {
-                            if (confirmed.reason === "conflict")
-                                return await transient(confirmed.reason);
+                            if (confirmRefusalRetries(confirmed.reason))
+                                return await transient(confirmed.detail?.message ?? confirmed.reason);
                             return await verdict("record-unusable", confirmed.reason);
                         }
                     }
@@ -678,11 +726,11 @@ export function createRuleConsentLane(stores, opts) {
                     if ("status" in result) {
                         return await transient(result.reason);
                     }
-                    members = buildImportOutcomeMembers(result.members);
+                    const walk = settleImportWalk(result.members);
+                    if ("open" in walk)
+                        return await transient(walk.open);
+                    members = walk.settled;
                     rev = result.rev;
-                    const open = unsettledDetailOf(members);
-                    if (open !== undefined)
-                        return await transient(open);
                 }
                 catch (err) {
                     return await transient(err instanceof Error ? err.message : String(err));
@@ -824,6 +872,7 @@ export function createRuleConsentLane(stores, opts) {
                     reason: "rule_rejected",
                     detail: `this rule text is not the spelling the store would hold: send ${JSON.stringify(written.rule.rule)} instead ` +
                         `— a rule written under one spelling and held under another cannot be listed or revoked by the bytes you sent`,
+                    canonical: written.rule.rule,
                 };
             }
             const row = {

package/dist/run-acceptance.d.ts

@@ -33,7 +33,7 @@
  * ## 受理之后 / 之前
  *  · 受理 ⇒ 有交付的那一份时标题器起一次(会话没有标题时它才真去生成;判据在标题器里,本文件不重复)。
  *  · 没受理就收场(零工作的拒、受理前取消 / 拦截)⇒ 标题器不起:被拒的输入不花一次模型调用,也不被送去起名。
- *    这次提交在提交门铸下的会话行照旧留下(无标题、零消息),与此前同 —— 「提交没让引擎受理就收场」的会话去留是另一件事,不在本文件。
+ *    这只闩也是提交出口(`submission-exit.ts`)判「这次提交铸下的会话留不留」的第一读:闩上 ⇒ 留;没上 ⇒ 出口按它自己的律判({@link RunAcceptance.accepted})。
  *
  * ## 谁喂它
  * 三条提交腿(同步 / 流式 / durable)各在两处喂同一只:持流的那一形把每一帧交给 {@link RunAcceptance.observe}(并等它交回的那一拍 —— 有补写时
@@ -92,6 +92,8 @@ export interface RunAcceptance {
     onDelivered(face: DeliveryFace, fill: (objective: string) => Promise<void>): void;
     /** 持活流的腿开流时挂上它的写口(一次提交至多一条活流;重挂以最后一次为准)。不挂 = 本次提交没有可写的流,标题写成的帧丢弃。 */
     attachStream(sink: RunStreamSink): void;
+    /** 闩此刻上没上(引擎受理过这次提交)。提交出口的唯一读法;只读,不改闩。 */
+    readonly accepted: boolean;
 }
 export declare function createRunAcceptance(deps: RunAcceptanceDeps, input: RunAcceptanceInput): RunAcceptance;
 //# sourceMappingURL=run-acceptance.d.ts.map

package/dist/run-acceptance.js

@@ -67,6 +67,9 @@ export function createRunAcceptance(deps, input) {
         attachStream(sink) {
             stream = sink;
         },
+        get accepted() {
+            return accepted;
+        },
     };
 }
 //# sourceMappingURL=run-acceptance.js.map