@sema-agent/server 7.144.0 → 7.146.0

package/dist/plugins/tidb-session-store.js

@@ -152,6 +152,9 @@ export class TiDBSessionStore {
         }
     }
     async listSessions(opts) {
+        return (await this.listSessionRows(opts)).map((a) => a.row);
+    }
+    async listSessionRows(opts) {
         const params = [];
         const where = ["sm.placement_kind IS NULL"];
         if (opts.owner !== undefined) {
@@ -166,7 +169,7 @@ export class TiDBSessionStore {
             where.push("(sm.updated_at < ? OR (sm.updated_at = ? AND sm.session_id < ?))");
             params.push(new Date(opts.cursor.lastActivityAt), new Date(opts.cursor.lastActivityAt), opts.cursor.sessionId);
         }
-        return (await this.selectListRows({ where, params, limit: opts.limit })).map((a) => a.row);
+        return this.selectListRows({ where, params, limit: opts.limit });
     }
     async sessionSummaryOf(sessionId) {
         return (await this.listRowOf(sessionId))?.row;
@@ -246,8 +249,8 @@ export class TiDBSessionStore {
     async recordSessionWorkspace(sessionId, incarnation, workspace) {
         await this.pool.query("UPDATE session_meta SET workspace = ? WHERE session_id = ? AND incarnation = ?", [encodeSessionWorkspaceCell(workspace, JSON.stringify, sessionId), sessionId, incarnation]);
     }
-    async fork(sourceId, owner) {
-        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner);
+    async fork(sourceId, owner, opts) {
+        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner, opts);
     }
     async forkTo(sourceId, owner, target) {
         for (let attempt = 0; attempt < 2; attempt++) {
@@ -275,7 +278,8 @@ export class TiDBSessionStore {
         try {
             await conn.beginTransaction();
             try {
-                await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, fork_key) VALUES (?,?,?,?,?,?,?,?)", [target.id, forkOwner, now, now, forkLeafId, eventRows.length, mintSessionIncarnation(), target.key ?? null]);
+                await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, fork_key, " +
+                    "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)", [target.id, forkOwner, now, now, forkLeafId, eventRows.length, mintSessionIncarnation(), target.key ?? null, ...placementInsertValues(target.placement, now)]);
             }
             catch (err) {
                 if (!isMysqlDupKeyError(err))

package/dist/prompt-screen.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 「这条腿上有没有 prompt 屏」的**唯一读法** —— 提交时问一次,问的是这条腿两座注册**声明**的事件(部署座 `RunnerDeps.mods` + 任务座 `TaskSpec.mods`)。
+ *
+ * ## 为什么问它
+ * prompt 屏(引擎的 `prompt.submit` 扩展站,底层 `classic.UserPromptSubmit`)可以在交付模型之前改写或拦下一条目标。屏装着的腿上,目标的哪一份
+ * 会被交付,只有屏判完才知道;本服务存 / 转目标的每张面(run 行预览、续跑输入、标题器取材)因此只能在交付之后写交付的那一份
+ * (律的属主 = `run-acceptance.ts`)。屏**不在**的腿上没有「屏前」:交付的就是请求原文,提交那一刻就知道 —— 与没有屏这回事之前逐字同。
+ *
+ * ## 判据(一条,引擎的)
+ * 引擎的 `promptScreenDeclaredBy`:两座的注册并起来,任一张的 `uses.events`(名字或 `<前缀>.*`,按引擎准入的读法展开)选中屏听的任一站
+ * (引擎的 `PROMPT_SCREEN_STATIONS`)⇒ 有屏。引擎准入保证一张注册挂上的 handler 不越出它声明的事件(越出 = 准入拒),所以「声明里没有」⇒
+ * 这条腿的总线上**一定**没有屏 —— 判据只会多判有屏(声明了、`register` 时没挂),不会漏判。多判的代价是这条腿的那几张面等到交付才写
+ * (写的仍是交付的那一份),不是放行。站名表与前缀展开只住在引擎里:引擎给屏加一站,本服务同一拍就认。
+ */
+import { type ModRegistration } from "@sema-agent/core";
+/** 这条腿的两座(缺席的座 = 没有注册)里有没有一张注册声明了 prompt 屏。 */
+export declare function promptScreenDeclared(seats: ReadonlyArray<ReadonlyArray<Pick<ModRegistration, "uses">> | undefined>): boolean;
+//# sourceMappingURL=prompt-screen.d.ts.map

package/dist/prompt-screen.js

@@ -0,0 +1,5 @@
+import { promptScreenDeclaredBy } from "@sema-agent/core";
+export function promptScreenDeclared(seats) {
+    return promptScreenDeclaredBy(seats.flatMap((seat) => seat ?? []));
+}
+//# sourceMappingURL=prompt-screen.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 RedeemedBatchMember, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type RuleWriteCommitted, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
+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 { 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";
 /**
@@ -142,11 +142,12 @@ export declare const MAX_LOCAL_IMPORT_BYTES: number;
  *    救回来",而不是等下一次 prepare。运维旋钮暂不开(没有部署形要求它可调)。
  */
 export declare const LOCAL_IMPORT_CLAIM_LEASE_MS = 60000;
-/** 一条规则的 wire 身份键(**态** + 规则文本 + {@link serializeRuleScope} 的判别式串)。两个面
- *  (预览 / 兑付回执)用**同一把键**,客户端拿它把两张表 join 起来。
+/** 一条规则的 wire 身份键(**态** + 规则文本 + {@link serializeRuleScope} 的判别式串)。local-import 的两个面
+ *  (预览 / 兑付回执)用**同一把键**,客户端拿它把两张表 join 起来;cc-import 的兑付回执也是这一把(两只 redeem 口
+ *  同一张回执,见 {@link ImportOutcome}),scope 串与 `GET /v1/rules` 列举行逐字同形,对账直接按它比。
  *  🔴 `behavior` 自 7.67.0 起是这把键的一格(core 7.9.0 [ref]:规则的身份是三元组)—— 少了它,同文本
  *  同作用域的 deny 与 allow 两行会被本口判成 `duplicate_row`,而它们是两条不同的规则。 */
-export interface LocalImportRuleKey {
+export interface ImportRuleKey {
     behavior: RuleBehavior;
     rule: string;
     scope: string;
@@ -189,65 +190,68 @@ export type LocalImportRefusalCode =
 /** 过了本层全部判据,却没能成为引擎的候选(= 本仓与 core 的判据分了家)。**响亮**而不是静默丢:
  *  它意味着两侧的规则语法判据漂了,那是要人去看的事。 */
  | "not_importable";
-/** 兑付面的**成员级终态**(闭集,机读;`detail` 是给人看的那一半)。
- *
- *  🔴 **`refused` 在本版的兑付面结构上到不了,这是如实登记而不是遗漏**:走到兑付这一步的成员,已经
- *  在 prepare 过了全部内容判据 —— 于是 core 交回的 `refused` 行只剩店侧成因(读不出店 / 写面抛 / OCC
- *  用尽),而那些**都是"不知道落没落"**,不是"这条规则不行"。core 的 `RedeemedBatchMember` 拒绝臂
- *  只带一个**自由文本** `reason`,把它按串去猜「这是裁定还是瞬时」正是本仓明令禁止的自造判读,
- *  所以一律落到 `indeterminate`(安全方向)。词仍留在表里是因为它进了**落盘回执的边界 schema**
- *  (`LocalImportOutcomeSchema` 的 z.enum——`redeemed_outcome` 列回读同一张词表,旧行 / 别版本进程写下的
- *  `refused` 必须读得回),不是留一个死枝;⚠️ 预览面**不用**这个词:那一面的拒绝形是
- *  `admitted:false + LocalImportRefusalCode`({@link LocalImportPreviewMember}),两面词表**不同**。
- *  收窄需要 core 给拒绝臂一个**带类型的**
- *  瞬时/裁定判别位 —— 已作为上游请托登记(server 不在下游造第二份判据,[ref])。 */
-export type LocalImportMemberOutcome = 
+/** 兑付回执的**成员级终态**(闭集,机读;`detail` 是给人看的那一半)。两只 redeem 口(cc-import / local-import)同一张表。
+ *
+ *  🔴 **引擎拒的成员,结局只读引擎的两词 `committed`**(core 7.63.0 [ref],`RedeemedBatchMember` 拒臂必填):`no` ⇒ `refused`
+ *  (引擎确知这一条没落 —— 裁定,如旧导入记录里从 `/` 写起的全局规则的 `unsupported.layer_root`;同批放行被扣下的 `withheld`)、
+ *  `unknown` ⇒ `indeterminate`(写面抛 / 读回读不出 —— 那一条**可能已经落了**)。本仓不按串判,不另写第二份判据。
+ *  它进了**落盘回执的边界 schema**(`ImportOutcomeSchema`;`redeemed_outcome` 列回读同一张词表)。⚠️ 预览面**不用**这个词表:那一面的拒绝形是
+ *  `admitted:false + LocalImportRefusalCode`({@link LocalImportPreviewMember}),两面词表**不同**。 */
+export type ImportMemberOutcome = 
 /** 这一次真的写进店里了。 */
 "persisted"
 /** 等价规则**已经在店**(引擎的 `deduped`)—— 同意早就生效,这次什么都不用做。 */
  | "no-op"
-/** 这条被拒了(落盘回执 schema 的历史词位——现行两面都不铸它:预览面用 admitted:false +
- *  LocalImportRefusalCode,兑付面见上方登记恒折 indeterminate;留词只为旧行回读)。 */
+/** 引擎拒了这一条,并答 `committed: "no"` —— 确知没落。重来同一条拒因(`reason`)会得同一个答,出路在 `detail`(引擎原话)。 */
  | "refused"
-/** **不知道落没落**:店在这一条上出了状况。如实编,禁猜(猜"成了"会谎报一次没发生的授权,猜"没成"
- *  会让人以为可以重来一次,而重来会撞上一条其实已经存在的规则)。 */
+/** 引擎拒了这一条,并答 `committed: "unknown"` —— **不知道落没落**。如实编,禁猜。这一词**不进落定的回执**(落定律:任一成员
+ *  结局不知 ⇒ 不落定、503 同票重走,见 {@link unsettledDetailOf});词表留着它,是因为 7.145.x 及更早落定的票行(`redeemed_outcome`)
+ *  里有它,回放读那份存量。 */
  | "indeterminate";
-/** `indeterminate` 的成因(闭集)。 */
-export type LocalImportIndeterminateCode = 
-/** 引擎在这一条上答了 refused,而拒因只有自由文本 ⇒ 落不了裁定,如实说"不知道"。 */
-"store_refused"
-/** 兑付走本身没走完(本层抛出/中断)⇒ 这一条连走都没走到。 */
- | "walk_failed";
 /** prepare 面的一行。判别式联合:被收下的行**没有**拒因字段可读,被拒的行**必然**带拒因 ——
  *  「admitted 却带 reason」这种矛盾态在类型上不可表达。
  *  收下的**收紧**(deny / ask)在 prepare 当场经直写接缝落店,行带它的结局 `outcome`(`persisted` = 这次写了 / `no-op` = 等价规则已在店);
  *  收下的**放行**没有 `outcome` —— 它的结局在 redeem 回执里(放行要同意,收紧不等同意;见 `prepareLocalImport`)。 */
 export type LocalImportPreviewMember = {
-    key: LocalImportRuleKey;
+    key: ImportRuleKey;
     admitted: true;
 } | {
-    key: LocalImportRuleKey;
+    key: ImportRuleKey;
     admitted: true;
     outcome: LocalImportTighteningOutcome;
 } | {
-    key: LocalImportRuleKey;
+    key: ImportRuleKey;
     admitted: false;
     reason: LocalImportRefusalCode;
     detail: string;
 };
 /** 一条收紧在 prepare 当场落店的结局(与兑付回执的 `persisted` / `no-op` 同词同义;直写接缝 `addPersistedRule` 的 `added` / `no-op`)。 */
 export type LocalImportTighteningOutcome = "persisted" | "no-op";
-/** 兑付回执的一行。 */
-export interface LocalImportOutcomeMember {
-    key: LocalImportRuleKey;
-    outcome: LocalImportMemberOutcome;
-    reason?: LocalImportIndeterminateCode;
+/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link buildImportOutcomeMembers})。`reason` / `detail` 在场 ⇔ 引擎拒了这一条
+ *  (`refused` / `indeterminate`):`reason` = 引擎的闭集拒因码(`RuleRefusalCode`,core 属主,逐字),`detail` = 引擎给人看的那句话。 */
+export interface ImportOutcomeMember {
+    key: ImportRuleKey;
+    outcome: ImportMemberOutcome;
+    reason?: RuleRefusalCode;
     detail?: string;
 }
-/** 兑付回执整只 = **写进票行 `redeemed_outcome` 的逐字体**(回放同源:回放答的就是它)。 */
-export interface LocalImportOutcome {
-    members: readonly LocalImportOutcomeMember[];
-    /** 这只桶在兑付结束时的 OCC 版本(与 cc-import 的 `result.rev` 同义)。 */
+/**
+ * 一次兑付的回执整只 —— **两只 redeem 口同一张**(cc-import / local-import 的 200 体都是 `{ members, rev }`,路由同一个铸点),
+ * local-import 另把它**逐字**写进票行 `redeemed_outcome`(回放同源:回放答的就是它)。
+ *
+ * 🔴 **落定律(一条,两口同读)**:兑付走完、拿到引擎的完整成员表、**且每个成员的结局都确定**(`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
+ * `state.rule_import_retry`,同一张票重来就是重走一遍 —— 兑付按引擎的设计幂等(记录里的 dot 台账),重走交出完整表,
+ * 被打断的那一走已落的成员读 `no-op`。确知的成员拒**不**按票自动重试:一条永久被拒的成员(旧记录里的 `unsupported.layer_root`)
+ * 若走重试臂,客户端会 503 到票过期、临期放不回 ⇒ 404,已落成员不撤、被拒成员永不落 —— 7.144.0 及更早 cc-import 口就是这一形。
+ */
+export interface ImportOutcome {
+    members: readonly ImportOutcomeMember[];
+    /** 这只桶在兑付结束时的 OCC 版本。 */
     rev: number;
 }
 /** A7 prepare 的产物。第二臂(`ticket` 整键缺席)= **零可导入行** —— 与 cc-import 的「预览无票」臂
@@ -288,7 +292,7 @@ export type LocalImportRedeemed =
 /** `replayed` = 这份终局不是本次走出来的,是从票行里逐字读回来的(⑥ 丢响应重试那条路)。 */
 {
     ok: true;
-    outcome: LocalImportOutcome;
+    outcome: ImportOutcome;
     replayed: boolean;
 }
 /** 五类票拒(不存在 / 别人的 / 错车道 / 过期 / 已用过而无从回放)—— wire 面同形 404。 */
@@ -329,18 +333,19 @@ export type RuleImportPrepared = {
     reason: "too-many-candidates";
     candidates: number;
 };
-/** 导入 redeem 的结果。wire 口径写死(端点=http/routes/rules.ts):票拒五类(自造 / 别人的 / 错车道 /
- *  过期 / 已用过)与裁定性拒绝(record-unusable / payload-mismatch)同形 404(零存在性 oracle,顶注 ①);
- *  `retryable === true` ⇒ 503 `state.rule_import_retry`;`state-unreadable` ⇒ 503
- *  `state.rule_ticket_unreadable`。分类保留只为服务端日志/诊断与上述三分支的判据。 */
-export type RuleImportRedeemed = {
+/** 导入 redeem 的结果。wire 口径写死(端点=http/routes/rules.ts):成功 ⇒ 200 回执 `{ members, rev }`(与 local-import 口
+ *  同一张、同一个铸点;落定律见 {@link ImportOutcome});票拒五类(自造 / 别人的 / 错车道 / 过期 / 已用过)与裁定性拒绝
+ *  (record-unusable / payload-mismatch)同形 404(零存在性 oracle,顶注 ①);`retryable === true` ⇒ 503
+ *  `state.rule_import_retry`;`state-unreadable` ⇒ 503 `state.rule_ticket_unreadable`。分类保留只为服务端日志/诊断与
+ *  上述三分支的判据。 */
+export type RuleImportRedeemed = 
+/** 兑付走完、拿到完整成员表且每个成员结局确定 ⇒ 落定(引擎确知没落的成员也在这一臂,那几行 `refused`)。 */
+{
     ok: true;
-    result: {
-        members: readonly RedeemedBatchMember[];
-        rev: number;
-    };
+    outcome: ImportOutcome;
 }
-/** `retryable` = 这次失败**没有裁定任何事**(store 抛错 / CAS 冲突),认领已放回,属主原样重试即可。
+/** `retryable` = 这次兑付**没有落定**(store 抛错 / CAS 冲突 / 引擎走之前整批拒 / 循环里仍抛出来的异常 / 某个成员结局不知),
+ *  认领已放回,属主原样重试即重走。
  *  它与裁定性拒绝(载荷被改写、记录不存在)分家是承重的:把两者塌成一格,一次数据库抖动就会被
  *  客户端读成「这张票永远不能用了」。⚠️ wire 面**不再**折 404:`retryable === true` ⇒ 503
  *  `state.rule_import_retry` + Retry-After(http/routes/rules.ts;走到这一步的调用方已赢下 principal
@@ -620,7 +625,7 @@ export type RuleBucketRef = string | RuleOwner;
  *
  * 🔴 三臂**刻意不塌成布尔**:「落了」「早就有了」「不知道落没落」对调用方是三种不同的处置,而把第三种
  * 折进前两种里的任一边都是编一个结论(猜"成了"会谎报一次没发生的写,猜"没成"会让人以为可以重来)。
- * 与导入面的成员级四态({@link LocalImportMemberOutcome})同一条纪律,词更少是因为本口只有一行。
+ * 与导入面的成员级四态({@link ImportMemberOutcome})同一条纪律,词更少是因为本口只有一行。
  */
 export type RuleWritten = 
 /** `persisted` = 这一次**真的往店里写了**;`no-op` = 这条身份**此前就站在店里**,本次调用**一个字都没写**

package/dist/rules-consent.js

@@ -5,7 +5,7 @@ import { createLogger } from "./observability/logger.js";
 import { ABSOLUTE_HOST_PATH_MAX, hasControlOrBidi } from "@sema-agent/settings-schema";
 import { isDirectWritableRuleBehavior } from "./permission-rule-vocab.js";
 import { hasBidiControls } from "./text-bidi.js";
-import { confirmRuleApproval, RULE_BEHAVIORS, parseRuleText, ruleReachesProgramRun, precheckEditedRuleText, prepareCardApproval, prepareCcImport, redeemRuleBatch, redeemRuleTicket, addPersistedRule, removePersistedRule, isValidDurableScope, effectiveOrThrow, readRowBehavior, readRuleOwner, } from "@sema-agent/core";
+import { confirmRuleApproval, RULE_BEHAVIORS, RULE_REFUSAL_CODES, parseRuleText, ruleReachesProgramRun, precheckEditedRuleText, prepareCardApproval, prepareCcImport, redeemRuleBatch, redeemRuleTicket, addPersistedRule, removePersistedRule, isValidDurableScope, effectiveOrThrow, readRowBehavior, readRuleOwner, } from "@sema-agent/core";
 import { buildRulePayloadHash } from "./plugins/permission-rule-store-sql.js";
 export const RULE_IMPORT_TICKET_TTL_MS = 10 * 60_000;
 export const RULE_IMPORT_RETRY_AFTER_SEC = 2;
@@ -15,13 +15,13 @@ export const MAX_LOCAL_IMPORT_BYTES = 256 * 1024;
 export const LOCAL_IMPORT_CLAIM_LEASE_MS = 60_000;
 const LOCAL_IMPORT_CLAIM_WAIT_MS = RULE_IMPORT_RETRY_AFTER_SEC * 1000;
 const LOCAL_IMPORT_CLAIM_POLL_MS = 25;
-const LocalImportOutcomeSchema = z
+const ImportOutcomeSchema = z
     .object({
     members: z.array(z
         .object({
         key: z.object({ behavior: z.preprocess((v) => readRowBehavior(v) ?? v, z.enum(RULE_BEHAVIORS)), rule: z.string().min(1), scope: z.string().min(1) }).strict(),
         outcome: z.enum(["persisted", "no-op", "refused", "indeterminate"]),
-        reason: z.enum(["store_refused", "walk_failed"]).optional(),
+        reason: z.enum(RULE_REFUSAL_CODES).optional(),
         detail: z.string().optional(),
     })
         .strict()),
@@ -137,6 +137,52 @@ function confirmRefusalWord(reason) {
         }
     }
 }
+function isRuleStoreFault(code) {
+    switch (code) {
+        case "store_read":
+        case "store_write":
+            return true;
+        case "unsupported.layer_root":
+        case "ticket_invalid":
+        case "record_missing":
+        case "wrong_principal":
+        case "record_schema_stale":
+        case "not_confirmed":
+        case "record_malformed":
+        case "not_chosen":
+        case "parse_rejected":
+        case "store_unavailable":
+        case "record_changed":
+        case "withheld":
+        case "session_ended":
+        case "occ":
+        case "dot_removed":
+            return false;
+        default:
+            return code;
+    }
+}
+class RuleStoreFaultError extends Error {
+    code;
+    constructor(refusal) {
+        super(refusal.reason);
+        this.name = "RuleStoreFaultError";
+        this.code = refusal.code;
+    }
+}
+function throwIfRuleStoreFault(refusal) {
+    const { code } = refusal;
+    if (!isRuleStoreFault(code))
+        return;
+    switch (refusal.committed) {
+        case "no":
+            throw new RuleStoreFaultError({ code, reason: refusal.reason });
+        case "unknown":
+            return;
+        default:
+            return refusal.committed;
+    }
+}
 function refusedMembersOf(members) {
     const refused = [];
     for (const m of members) {
@@ -241,7 +287,7 @@ function buildLocalImportLayers(candidates) {
         return root === "" ? { layer: "userSettings", path: LOCAL_IMPORT_LAYER_PATH, readFile } : { layer: "projectSettings", path: `${LOCAL_IMPORT_LAYER_PATH}:${root}`, root, readFile };
     });
 }
-function buildLocalImportMembers(members) {
+function buildImportOutcomeMembers(members) {
     return members.map((m) => {
         const key = { behavior: m.behavior, rule: m.rule, scope: serializeRuleScope(m.scope) };
         switch (m.status) {
@@ -250,7 +296,7 @@ function buildLocalImportMembers(members) {
             case "deduped":
                 return { key, outcome: "no-op" };
             case "refused":
-                return { key, outcome: "indeterminate", reason: "store_refused", detail: m.reason };
+                return { key, outcome: refusedOutcomeOf(m.committed), reason: m.code, detail: m.reason };
             default: {
                 const unknown = m;
                 throw new Error(`unknown redeemed-batch member status: ${JSON.stringify(unknown)}`);
@@ -258,6 +304,22 @@ function buildLocalImportMembers(members) {
         }
     });
 }
+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 ?? ""}`;
+}
+function refusedOutcomeOf(committed) {
+    switch (committed) {
+        case "no":
+            return "refused";
+        case "unknown":
+            return "indeterminate";
+        default: {
+            const unknown = committed;
+            throw new Error(`unknown redeemed-batch member committed word: ${JSON.stringify(unknown)}`);
+        }
+    }
+}
 export function createRuleConsentLane(stores, opts) {
     const deps = { provider: stores.provider, approvals: stores.approvals, cardEdits: true };
     const ticketTtlMs = opts?.ticketTtlMs ?? RULE_IMPORT_TICKET_TTL_MS;
@@ -300,10 +362,15 @@ export function createRuleConsentLane(stores, opts) {
                 if (!confirmed.ok)
                     return { ok: false, reason: "confirm-refused", detail: confirmed.reason };
                 const result = await redeemRuleBatch({ approvalId: prepared.approvalId, principal: input.principal, deps });
-                if ("status" in result)
+                if ("status" in result) {
+                    throwIfRuleStoreFault(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);
                     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 };
@@ -351,8 +418,10 @@ export function createRuleConsentLane(stores, opts) {
                 ticket = minted.ticket;
             }
             const redeemed = await redeemRuleTicket({ ticket, principal: input.principal, deps });
-            if (redeemed.status !== "redeemed")
+            if (redeemed.status !== "redeemed") {
+                throwIfRuleStoreFault(redeemed);
                 return { ok: false, reason: "redeem-refused", detail: redeemed.reason };
+            }
             return { ok: true, kind: "single", rule: redeemed.rule, rev: redeemed.rev, alreadyRedeemed: redeemed.alreadyRedeemed };
         },
         async prepareImport(principal, layers) {
@@ -449,11 +518,11 @@ export function createRuleConsentLane(stores, opts) {
                 if ("status" in result) {
                     return await indeterminate(result.reason);
                 }
-                const refused = refusedMembersOf(result.members);
-                if (refused.length > 0) {
-                    return await indeterminate(`partial import: ${refused.length} member(s) refused (${refused.map((x) => x.reason).join("; ")})`);
-                }
-                return { ok: true, result };
+                const members = buildImportOutcomeMembers(result.members);
+                const open = unsettledDetailOf(members);
+                if (open !== undefined)
+                    return await indeterminate(open);
+                return { ok: true, outcome: { members, rev: result.rev } };
             }
             catch (err) {
                 return await indeterminate(err instanceof Error ? err.message : String(err));
@@ -535,7 +604,7 @@ export function createRuleConsentLane(stores, opts) {
         },
         async redeemLocalImport(principal, ticket) {
             const readSettled = (raw) => {
-                const parsed = LocalImportOutcomeSchema.safeParse(raw);
+                const parsed = ImportOutcomeSchema.safeParse(raw);
                 if (!parsed.success) {
                     throw new Error(`the settled outcome recorded on this import ticket does not carry a readable shape: ${parsed.error.message}`);
                 }
@@ -609,8 +678,11 @@ export function createRuleConsentLane(stores, opts) {
                     if ("status" in result) {
                         return await transient(result.reason);
                     }
-                    members = buildLocalImportMembers(result.members);
+                    members = buildImportOutcomeMembers(result.members);
                     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));

package/dist/run-acceptance.d.ts

@@ -1,27 +1,44 @@
 /**
- * **一次提交的「受理」读法** —— 标题器只在引擎**受理**这条 run 之后起(一条律,唯一属主 = 本文件)。
+ * **一次提交的「受理」与「交付」读法** —— 标题器只在引擎**受理**这条 run 之后起;本服务存 / 转这条 run 的目标的每一张面只取引擎**交付**的那一份
+ * (一条律,唯一属主 = 本文件)。
  *
  * ## 受理是哪一刻
  * 引擎把这次提交的 objective 收进会话的那一帧:`human_input{ carrier: "objective", delivery: "applied" }`。它是第一次模型调用
  * 之前的最后一帧;在它之前引擎能拒的一切 —— prepare 门(`config.tool_face_control` / `config.user_invoked_skill_unknown` /
- * `config.memory_capture_unsupported` …)、第一回合前的内联图片准入(`config.image_invalid`)、部署的 UserPromptSubmit 拦截、
- * 开跑前的预算 / 墙钟 —— 都还没让这次输入进会话。`wiring_manifest` 不是受理:它在 prepare 通过时就出了,图片准入与提示拦截
+ * `config.memory_capture_unsupported` …)、第一回合前的内联图片准入(`config.image_invalid`)、部署的 prompt 屏(`prompt.submit` 丢弃 / 抛错、
+ * `classic.UserPromptSubmit` 拦截)、开跑前的预算 / 墙钟 —— 都还没让这次输入进会话。`wiring_manifest` 不是受理:它在 prepare 通过时就出了,图片准入与提示拦截
  * 都在它之后(core `run-identity-wiring.js` 推 wiring_manifest,`run-leg.js` 才做图片准入、推 human_input、调模型)。
  *
  * 只回结果、不交流的腿(verify / cascade:core 在自己里面排空每条腿的流,宿主手里没有流)看不到那一帧。它们的受理证据是结果本身:
- * 结果里跑过 turn(`stats.turns > 0`)⇒ objective 进过会话、模型答过。**token 不是证据**:被 UserPromptSubmit 拦下的 objective 不进会话,
+ * 结果里跑过 turn(`stats.turns > 0`)⇒ objective 进过会话、模型答过。**token 不是证据**:被屏拦下的 objective 不进会话,
  * 而同一条 run 的收尾压缩可以在已有历史的会话上花 token(turns 0、tokens > 0)—— 按 token 判会把被拦下的输入送去起名。
  * 两种证据说的是同一件事,本文件把它们收成一只闩:先到的那一个算数,只算一次。
  *
+ * ## 交付的是哪一份(律:本服务的目标副本 = 引擎交付的那一份,屏判完之前一个字节都不存)
+ * prompt 屏(`prompt-screen.ts` 判这条腿有没有)可以改写或拦下目标:模型与会话转录只见屏后文本,调用方的原话没送达。本服务存 / 转目标的面 ——
+ * run 行预览(`objectivePreview`:`GET /v1/tasks` / 收件箱 `objective` / 运维任务视图 / 会话列表 / fleet 行名同读)、续跑输入(checkpoint ctx 体里的
+ * `objective`)、标题器取材 —— 于是只读本座交出的那一份,不读请求体:
+ *  · **腿上没有屏** ⇒ 交付的就是请求原文,提交那一刻就知道({@link RunAcceptance.objectiveAtSubmit} 在场):各面在提交时照写,与没有屏这回事之前逐字同;
+ *  · **腿上有屏** ⇒ 提交时什么都不写(`objectiveAtSubmit` 缺席:预览列 NULL、续跑输入标上 `promptScreened` 而 `objective` 留空、fleet 行不带名);屏判完、引擎交付时
+ *    本座把交付的那一份交给各面登记的补写口({@link RunAcceptance.onDelivered}:run 行预览、fleet 行名),持流的腿在那一帧上等补写落定再往下走。
+ *    续跑输入**不**登记补写口、一直留空,续跑腿的展示面只看它上面的标记(那一行在跑的时候还有别的写者,交付时整行重写会与它抢写;理由、代价、
+ *    verify 形那份原文与留空的体记下的模型全文 `http/submit-ctx.ts`):
+ *     - 受理帧不带 `rewrittenBy`(引擎:缺席 = 原样送达)⇒ 交付的 = 请求原文;
+ *     - 受理帧带 `rewrittenBy`(屏改写过)⇒ 引擎今天不把屏后文本交给宿主 ⇒ **没有**可写的那一份:各面保持提交时的空,标题器不起。
+ *       引擎把屏后文本交给宿主之后,这一臂改读它 —— 读口换,律不变;
+ *     - 没有受理帧(屏丢弃 / 抛错 / 受理前取消或失败)⇒ 没有交付,各面保持空;
+ *     - 只回结果的腿:宿主看不到受理帧,也就分不出改写 ⇒ 有屏时没有可写的那一份(各面保持空、标题器不起);没屏时照提交时写好的。
+ * 不加第二份脱敏、不按内容猜:屏改没改由引擎的 `rewrittenBy` 说,不由本服务比字符串。
+ *
  * ## 受理之后 / 之前
- *  · 受理 ⇒ 标题器起一次(会话没有标题时它才真去生成;判据在标题器里,本文件不重复)。
+ *  · 受理 ⇒ 有交付的那一份时标题器起一次(会话没有标题时它才真去生成;判据在标题器里,本文件不重复)。
  *  · 没受理就收场(零工作的拒、受理前取消 / 拦截)⇒ 标题器不起:被拒的输入不花一次模型调用,也不被送去起名。
  *    这次提交在提交门铸下的会话行照旧留下(无标题、零消息),与此前同 —— 「提交没让引擎受理就收场」的会话去留是另一件事,不在本文件。
  *
  * ## 谁喂它
- * 三条提交腿(同步 / 流式 / durable)各在两处喂同一只:持流的那一形把每一帧交给 {@link RunAcceptance.observe};终局落行之后调一次
- * {@link RunAcceptance.settle}。腿上不再有「什么时候起标题」的判断,标题器的唯一调用点是本文件的闩。座由提交门在 `prepareSpec` 里
- * 随 spec 一起铸(`PreparedTaskSubmission.acceptance`);不经提交门的内部车道铸一只不带标题器的座,也就不起标题。
+ * 三条提交腿(同步 / 流式 / durable)各在两处喂同一只:持流的那一形把每一帧交给 {@link RunAcceptance.observe}(并等它交回的那一拍 —— 有补写时
+ * 补写落定才往下);终局落行之后调一次 {@link RunAcceptance.settle}。腿上不再有「什么时候起标题」「目标写哪一份」的判断,标题器与补写的唯一调用点是本文件的闩。
+ * 座由提交门在 `prepareSpec` 里随 spec 一起铸(`PreparedTaskSubmission.acceptance`);不经提交门的内部车道铸一只不带标题器的座,也就不起标题。
  *
  * ## 标题写成之后(`session_titled` 帧,契约 §4a-ttl)
  * 标题器写成时把那一帧交回本座({@link RunAcceptanceDeps.sessionTitler} 的 `onTitled`);本座是这条 run 的流与标题器之间**唯一**的接缝:
@@ -45,21 +62,34 @@ export interface RunStreamSink {
 }
 export interface RunAcceptanceInput {
     sessionId?: string;
+    /** 请求里的目标原文 —— 本座是它在受理之后唯一的读者(交付的那一份由它与引擎的交付帧定,见头注「交付的是哪一份」)。 */
     objective: string;
+    /** 这条腿上有没有 prompt 屏(唯一读法 `prompt-screen.ts` 的 `promptScreenDeclared`;不经提交门的内部车道交自己负责的字,恒 `false`)。 */
+    screened: boolean;
     /** 本 turn 真实驱动的模型 id(标题器与 turn 同链路)。 */
     model?: string;
 }
+/** 登记补写口的那张面(fail-open 留痕里点名哪一面没补上)。闭集:加一张面 = 加一个词。 */
+export type DeliveryFace = "run-preview" | "fleet-name";
 export interface RunAcceptance {
-    /** 持流的腿逐帧调用(判哪一帧算受理只在这里)。不抛、不等。 */
+    /** 持流的腿逐帧调用(判哪一帧算受理、交付的是哪一份只在这里)。不抛;交回的那一拍在有补写时等补写落定(补写失败不抛,留痕),腿 await 它再往下。 */
     observe(ev: {
         type: string;
-    }): void;
+    }): Promise<void>;
     /** 终局落行之后:还没在流上见过受理帧、而结果里跑过 turn(只回结果的腿)⇒ 受理。只读 `stats.turns`。不抛、不等。 */
     settle(result: {
         readonly stats: {
             readonly turns: number;
         };
     }): void;
+    /** 提交那一刻就知道的交付文本(腿上没有屏 ⇒ 请求原文);腿上有屏 ⇒ 缺席:各面提交时不写,交付时经 {@link onDelivered} 补。 */
+    readonly objectiveAtSubmit: string | undefined;
+    /**
+     * 一张面在提交时按 {@link objectiveAtSubmit} 写过之后,登记它的补写口:腿上有屏、引擎交付了可写的那一份时,本座以交付的文本调它一次
+     * (持流的腿在受理帧那一拍等它落定)。腿上没有屏 ⇒ 提交时已写完,永不调。补写抛错 ⇒ 不抛给腿(那张面保持提交时的空),留一次 F 类痕。
+     * 须在腿起跑之前登记(交付之后才登记的口当场补,不等)。
+     */
+    onDelivered(face: DeliveryFace, fill: (objective: string) => Promise<void>): void;
     /** 持活流的腿开流时挂上它的写口(一次提交至多一条活流;重挂以最后一次为准)。不挂 = 本次提交没有可写的流,标题写成的帧丢弃。 */
     attachStream(sink: RunStreamSink): void;
 }

package/dist/run-acceptance.js

@@ -1,35 +1,68 @@
+import { recordFailOpen } from "./observability/fail-open.js";
+import { seatText } from "./trace/exit-seat.js";
 function isObjectiveApplied(ev) {
     if (ev.type !== "human_input")
         return false;
     const h = ev;
     return h.carrier === "objective" && h.delivery === "applied";
 }
+function rewrittenOnDelivery(ev) {
+    return ev.rewrittenBy !== undefined;
+}
 export function createRunAcceptance(deps, input) {
     let accepted = false;
+    let delivered;
     let terminalSeen = false;
     let stream;
+    const fills = [];
     const deliver = (frame) => {
         if (stream === undefined || terminalSeen || !stream.reachable())
             return;
         stream.write(frame);
     };
-    const accept = () => {
+    const runFill = async (face, fill, objective) => {
+        try {
+            await fill(objective);
+        }
+        catch (err) {
+            recordFailOpen("server.objective-delivery.face-fill-failed", `face=${face} err=${seatText("operator-log-text", err instanceof Error ? err.message : String(err))}`);
+        }
+    };
+    const accept = (objective) => {
         if (accepted)
-            return;
+            return Promise.resolve();
         accepted = true;
+        delivered = objective;
+        if (objective === undefined)
+            return Promise.resolve();
         if (input.sessionId)
-            deps.sessionTitler?.maybeTitle(input.sessionId, input.objective, input.model, deliver);
+            deps.sessionTitler?.maybeTitle(input.sessionId, objective, input.model, deliver);
+        if (!input.screened)
+            return Promise.resolve();
+        return Promise.all(fills.map(({ face, fill }) => runFill(face, fill, objective))).then(() => undefined);
     };
     return {
+        objectiveAtSubmit: input.screened ? undefined : input.objective,
         observe(ev) {
             if (ev.type === "done")
                 terminalSeen = true;
             if (!accepted && isObjectiveApplied(ev))
-                accept();
+                return accept(rewrittenOnDelivery(ev) ? undefined : input.objective);
+            return Promise.resolve();
         },
         settle(result) {
             if (result.stats.turns > 0)
-                accept();
+                void accept(input.screened ? undefined : input.objective);
+        },
+        onDelivered(face, fill) {
+            if (!input.screened)
+                return;
+            if (accepted) {
+                if (delivered !== undefined)
+                    void runFill(face, fill, delivered);
+                return;
+            }
+            fills.push({ face, fill });
         },
         attachStream(sink) {
             stream = sink;

package/dist/run-cancel-context.d.ts

@@ -136,6 +136,9 @@ export declare function buildCancelledLedgerRow(c: PersistedTaskResult): {
  * `signal.reason`:那会改掉引擎与 provider 层收到的拒绝值,是在下游改上游接缝的输入(立宪禁区)。
  */
 export interface RunAbort {
+    /** 这条腿的**属主**(run 行的 `owner` 列;无主体 = `null`)—— 在飞集(`inflightRuns`)里「谁占着几条」的唯一读处:并发帽按主体数在飞腿时读它
+     *  (`http/run-concurrency-cap.ts`),不另起一张按 taskId 键控的旁表。句柄与腿同寿,换腿就是换句柄。 */
+    readonly owner: string | null;
     /** 交给引擎的那只信号(`spec.signal` / 审批 / 提问 ALS 的 `abortSignal` / 子代 stoppedBy 归因都用它)。 */
     readonly signal: AbortSignal;
     /** 以 `cause` 中止本腿。已中止 ⇒ no-op(成因不改写)。 */
@@ -143,6 +146,6 @@ export interface RunAbort {
     /** 让本腿停下来的那次中止的成因;未中止 ⇒ `undefined`。 */
     cause(): AbortCause | undefined;
 }
-export declare function createRunAbort(): RunAbort;
+export declare function createRunAbort(owner: string | null): RunAbort;
 export {};
 //# sourceMappingURL=run-cancel-context.d.ts.map

package/dist/run-cancel-context.js

@@ -51,10 +51,11 @@ export function buildCancelledLedgerRow(c) {
         ...(c.abortCause !== undefined ? { abortCause: c.abortCause } : {}),
     };
 }
-export function createRunAbort() {
+export function createRunAbort(owner) {
     const ctrl = new AbortController();
     let landed;
     return {
+        owner,
         signal: ctrl.signal,
         abort(cause) {
             if (ctrl.signal.aborted)