@sema-agent/server 7.142.0 → 7.144.0

package/dist/peer-inbound-face.d.ts

@@ -0,0 +1,122 @@
+/**
+ * **被扣住的跨会话来信的收信方决断面**([ref])—— core 进程级 held 队列在本服务的**投影 + 决断转发**,不存第二份事实。
+ *
+ * ## 病
+ * 一封跨会话来信被扣住时,发信方 A 收到 `held` 回执,收信方 B 只见一帧 `engine_notice peer.inbound_disposition`(而且只在 B 有活腿时),
+ * `GET /v1/approvals` 里什么都没有 ⇒ 一封**等人审**的信(权限档对等判扣下的)B 没有地方批,只能等 `dialogExpiry` 带 `expired` 回执过期。
+ * core 早就给了宿主的决断口(`peerHeldQueueIfAny(scope, sessionId, box?)` → `PeerHeldQueue.list()` / `settle(seq, "approve" | "deny")`),本仓零处接。
+ *
+ * ## 规则
+ *  · **事实只在 core**:一封信被扣住的那一刻起,它的决定是信箱记录自己的字段(store CAS),卡是 core 那只进程级队列上的一张;
+ *    receipt / 投递 / 到期计时都是 core 绑在队列上的 sink(引擎在 run 的 drain 里自己 `configure`,宿主**不**接 sink —— 接了就是第二个写者)。
+ *    本面只做两件事:把队列里等人审的卡(见下「只有人能答的卡」)投成 `pending[]` 的 `peer_inbound` 行;把决断口的 approve / deny 原样交给 `settle`。
+ *    没有行店、没有落账:一张卡在不在、谁赢了 CAS、结局是什么,全是 core 的读数。
+ *  · **属主 = 收信方**:列与决都只在调用方**自己**的信箱 scope 里找队列(`peerHeldQueueIfAny(调用方 scope, …)`;scope 读法与 core 的
+ *    `taskScope = spec.principal ?? "default"` 同一条,见 {@link peerBoxScope})—— 别人的卡结构上取不到,决断口答的 404 与「没有这张卡」同码同文。
+ *    显式 operator **没有**额外射程:一封信是收信人的,不是运维治理面(与停驻门「operator 可决任意行」刻意不同,决断口按族分臂)。
+ *  · **只有人能答的卡才进审批席**(core `PEER_HELD_REVIEW_CAUSES`:`mode-mismatch` / `no-mode-asserted` / `invalid-mode-attestation` —— 权限档
+ *    对等判扣下的信;CC 只对这几个成因开审阅框与到期计时,cli309.js:36111–36116 的句子逐条:`managed-setting` / `repo-setting` / `explicit-setting`
+ *    是「组织 / 仓库 / 你自己的设置在扣」,`your own "accept" cannot override managed policy; ask your admin` —— 收信方**不能**逐封放行)。
+ *    🔴 这是安全轴:core 的 `settle(approve)` 本身不看成因(它信宿主只把可审的卡呈给人),一张被部署策略
+ *    `CROSS_SESSION_INBOUND=hold` 扣下的信若进了审批席,收信方一次 approve 就越过了组织策略。所以设置类 / `cross-principal-default` /
+ *    `mode-unknown` / `bypass-default` 的卡**不列、不收**(决断口 404,与查无此卡同答);它们按 core 的规则等设置改变(每拍重判)。
+ *    成因会在重判时移动,列 / 决每次都读卡上**当下**的成因。
+ *  · **一个调用方、一张卡、一个答案**:决断口只认列表会列出的卡(`decision === "held"` ∧ 可审成因);已批待投(`approved`)/ 已交接(`delivered`)的卡不列、不收。
+ *
+ * ## 枚举(core 7.62.0 `listPeerHeldQueues`)
+ * 列与关停都读 core 进程注册表的快照(`listPeerHeldQueues()`:每只队列的 scope / 打开它的会话 / 卡来自哪只箱 / 同一时刻的卡),本面不记任何表 ——
+ * 一张卡在不在、属于哪个 scope、哪只箱,全是那一读。决断口按行 id 的 (会话, 车道, seq) 回 `peerHeldQueueIfAny(调用方 scope, …)` 取同一只队列。
+ * 箱只有两种(会话自己的箱 / 它也排空的 principal 收件箱,core 的快照注逐字);读到第三种 ⇒ 那只队列的卡不列(没有车道就拼不出决断口 id)+ F 类
+ * `server.peer-inbound.queue-box-unknown` 留痕 —— 信仍被扣、按 core 的期限带回执过期(安全默认)。
+ *
+ * ## 到期
+ * 卡上的到期时刻是 core 的 `PeerHeldEntry.deadlineAt`(到期计时武装时在场:可审成因 ∧ 有限 `dialogExpiry` ∧ 卡仍 `held`;成因一动 core 重武装或清掉它)。
+ * 行的 `deadline` 就是它的原值,本仓不按 `heldAt + dialogExpiry` 自算(成因一动就是第二份、错的读法)。
+ *
+ * ## 关停
+ * CC `HBe` 在宿主:core 不调 `PeerHeldQueue.shutdown()`(全库零生产调用点)。{@link PeerInboundFace.shutdown} 在有序关停的审批收尾那一拍
+ * (`boot/shutdown.ts`,关池之前)对注册表里**每只**队列调它(进程的队列都是本进程的;不求 scope)—— 仍被扣的信按 core 的规则带 `expired` 回执结清
+ * (reason `shutdown`)。core 的 `shutdown()` 等它发出的每条回执落箱再兑现,没落的点名 seq 拒(卡照样全结);各队列互不等,一只拒不挡别的
+ * (`Promise.allSettled`),拒句进读数 `receiptFaults`,由关停链写一行 warn。
+  */
+import { type PeerHeldEntry, type PeerHeldSettleOutcome } from "@sema-agent/core";
+import { type PeerInboundLane } from "./org-delivery-gate.js";
+/**
+ * 调用方 principal 的信箱 scope —— core 写侧 `taskScope = spec.principal ?? "default"` 的同一条读法(无主 ⇒ `"default"`)。列 / 决都按它找队列。
+ */
+export declare function peerBoxScope(principal: string | null | undefined): string;
+/** 决断口 id 的坐标(id 是它的唯一拼法,见 {@link peerInboundIdOf})。 */
+export interface PeerInboundCoord {
+    readonly sessionId: string;
+    readonly lane: PeerInboundLane;
+    readonly seq: number;
+}
+/** 坐标 → 决断口 id:`peer_inbound:<收信会话 id>:<车道>:<箱内 seq>`(会话 id 的文法里没有 `:`,三段无歧义)。 */
+export declare function peerInboundIdOf(c: PeerInboundCoord): string;
+/** 决断口 id → 坐标;不成形(会话 id 不合 core 的地址文法 / 车道不在闭集 / seq 不是非负安全整数)⇒ `undefined`(决断口答 404,不判 400:不给 id 空间当谕示)。 */
+export declare function parsePeerInboundId(id: string): PeerInboundCoord | undefined;
+/**
+ * `pending[]` 的 `peer_inbound` 行(wire 形)。键全部是 core 那张卡的投影,本仓不派生任何一位:
+ *  · `id` —— 决断口 `POST /v1/approvals/:id/decide` 的 `:id`;
+ *  · `recipientSessionId` —— 收信会话(刻意**不**叫 `sessionId`:那个名字在本数组里是停驻门的 `:id`,不分族的消费方拿它去决断会决到
+ *    同会话的停驻卡上;换名之后它读到缺席,而不是错卡);
+ *  · `cause` —— core 的扣信成因(`PeerHeldEntry.cause`,`CrossSessionHoldCause` 闭集);
+ *  · `content` / `fromName` —— 信的存储正文(`[summary] message`,core 的规范存储形)与发信方的显示名,**过凭据脱敏**(显示面;与停驻行的工具入参同一条);
+ *  · `fromSession` / `fromScope` —— 发信会话 / 跨 principal 投递的发信 scope(core 的 typed 归属锚),在场才带;
+ *  · `sentAt` / `heldAt` —— epoch ms;
+ *  · `deadline` —— core 卡上的到期时刻 `deadlineAt` 原值(绝对 epoch ms,与停驻行 `deadline` 同名同义;壳用 `deadline − serverNowMs` 渲倒计时),
+ *    到期计时没武装(`dialogExpiry` 为 `null`)⇒ 缺席。
+ */
+export interface PeerInboundPendingRow {
+    readonly kind: "peer_inbound";
+    readonly id: string;
+    readonly recipientSessionId: string;
+    readonly lane: PeerInboundLane;
+    readonly cause: PeerHeldEntry["cause"];
+    readonly content: string;
+    readonly sentAt: number;
+    readonly heldAt: number;
+    readonly deadline?: number;
+    readonly fromSession?: string;
+    readonly fromName?: string;
+    readonly fromScope?: string;
+}
+/** 决断口给本族的决定词(停驻门的 `decision` 闭集原样;core 的 `cancel` 臂本仓没有门 —— 见收车档未闭环)。 */
+export type PeerInboundDecision = "approve" | "deny";
+/** 决断口 `peer_inbound` 臂的 200 体(键集属主;`outcome` = core `settle` 的答案原词,`gone` 不上 wire —— 它答 404)。 */
+export interface PeerInboundDecideReply {
+    readonly kind: "peer_inbound";
+    readonly id: string;
+    readonly outcome: Exclude<PeerHeldSettleOutcome, "gone">;
+}
+/** 一次决断的结局:`not_found`(调用方 scope 里没有这张待决卡 —— 不存在 / 别人的 / 已不在 held)、`settled`(core 的答案原词)、`unrecorded`(店拒了这一步,core 说什么都没决;`error` = core 抛的那一只,交给调用方留痕)。 */
+export type PeerInboundDecideResult = {
+    readonly kind: "not_found";
+} | {
+    readonly kind: "settled";
+    readonly outcome: Exclude<PeerHeldSettleOutcome, "gone">;
+} | {
+    readonly kind: "unrecorded";
+    readonly error: unknown;
+};
+/**
+ * 关停读数:`queues` = 关了几只队列(注册表里的每一只,含空的);`cards` = 关停那一刻快照里的卡数;`receiptFaults` = 各只拒了的队列的拒句
+ * (core 点名回执没落箱的 seq —— 卡已结清,只是发信方可能没收到那条 `expired`)。
+ */
+export interface PeerInboundShutdownReading {
+    readonly queues: number;
+    readonly cards: number;
+    readonly receiptFaults: readonly string[];
+}
+export interface PeerInboundFace {
+    /** `scope` 里此刻等人审的信({@link awaitsReview} 的卡;读 core 的队列枚举),按 `heldAt` 升序(同刻按 id)。 */
+    list(scope: string): PeerInboundPendingRow[];
+    /** 决断转发:只认 `scope` 里此刻等人审的那张卡(与 {@link list} 同一只判据);`settle` 抛(店拒了 CAS)⇒ `unrecorded`。 */
+    decide(scope: string, coord: PeerInboundCoord, decision: PeerInboundDecision): Promise<PeerInboundDecideResult>;
+    /** 有序关停:core 注册表里每只队列 `shutdown()`(core 的规则:仍 held 的卡带 `expired` 回执结清,reason `shutdown`;等回执落箱)。永不抛。 */
+    shutdown(): Promise<PeerInboundShutdownReading>;
+}
+export declare function createPeerInboundFace(): PeerInboundFace;
+/** 进程单例 —— 决断尾(一张卡一次只过一只决断)是进程级的;审批路由与关停链读的是同一只。 */
+export declare const defaultPeerInboundFace: PeerInboundFace;
+//# sourceMappingURL=peer-inbound-face.d.ts.map

package/dist/peer-inbound-face.js

@@ -0,0 +1,123 @@
+import { PEER_HELD_REVIEW_CAUSES, isPeerSessionId, listPeerHeldQueues, peerHeldQueueIfAny, } from "@sema-agent/core";
+import { PEER_INBOUND_LANES, boxOfLane, laneOfBox } from "./org-delivery-gate.js";
+import { PEER_INBOUND_ID_PREFIX } from "./approval-queue-kind.js";
+import { recordFailOpen } from "./observability/fail-open.js";
+import { seatText } from "./trace/exit-seat.js";
+export function peerBoxScope(principal) {
+    return principal ?? "default";
+}
+export function peerInboundIdOf(c) {
+    return `${PEER_INBOUND_ID_PREFIX}${c.sessionId}:${c.lane}:${c.seq}`;
+}
+export function parsePeerInboundId(id) {
+    if (!id.startsWith(PEER_INBOUND_ID_PREFIX))
+        return undefined;
+    const parts = id.slice(PEER_INBOUND_ID_PREFIX.length).split(":");
+    if (parts.length !== 3)
+        return undefined;
+    const [sessionId, lane, seqText] = parts;
+    if (!isPeerSessionId(sessionId))
+        return undefined;
+    if (!PEER_INBOUND_LANES.includes(lane))
+        return undefined;
+    if (!/^(0|[1-9][0-9]*)$/.test(seqText))
+        return undefined;
+    const seq = Number(seqText);
+    if (!Number.isSafeInteger(seq))
+        return undefined;
+    return { sessionId, lane: lane, seq };
+}
+function rowOf(sessionId, lane, card) {
+    const fromSession = card.peerMeta?.fromSession;
+    const fromScope = card.peerMeta?.fromScope;
+    return {
+        kind: "peer_inbound",
+        id: peerInboundIdOf({ sessionId, lane, seq: card.seq }),
+        recipientSessionId: sessionId,
+        lane,
+        cause: card.cause,
+        content: seatText("peer-inbound-card-text", card.content),
+        sentAt: card.sentAt,
+        heldAt: card.heldAt,
+        ...(card.deadlineAt !== undefined ? { deadline: card.deadlineAt } : {}),
+        ...(fromSession !== undefined ? { fromSession } : {}),
+        ...(card.from !== undefined ? { fromName: seatText("peer-inbound-card-text", card.from) } : {}),
+        ...(fromScope !== undefined ? { fromScope } : {}),
+    };
+}
+function laneOfQueue(q) {
+    const lane = laneOfBox(q.box, q.sessionId);
+    if (lane === undefined)
+        recordFailOpen("server.peer-inbound.queue-box-unknown", `cards=${q.size}`);
+    return lane;
+}
+function awaitsReview(card) {
+    return card.decision === "held" && isReviewCause(card.cause);
+}
+function isReviewCause(cause) {
+    return typeof cause === "string" && PEER_HELD_REVIEW_CAUSES.includes(cause);
+}
+function queueOf(scope, e) {
+    return peerHeldQueueIfAny(scope, e.sessionId, boxOfLane(e.lane));
+}
+export function createPeerInboundFace() {
+    const tails = new WeakMap();
+    const serially = (q, seq, step) => {
+        const perQueue = tails.get(q) ?? new Map();
+        tails.set(q, perQueue);
+        const prev = perQueue.get(seq);
+        const run = prev === undefined ? step() : prev.then(step);
+        perQueue.set(seq, run);
+        return run.finally(() => {
+            if (perQueue.get(seq) === run)
+                perQueue.delete(seq);
+        });
+    };
+    return {
+        list(scope) {
+            const rows = [];
+            for (const q of listPeerHeldQueues()) {
+                if (q.scope !== scope)
+                    continue;
+                const reviewable = q.entries.filter(awaitsReview);
+                if (reviewable.length === 0)
+                    continue;
+                const lane = laneOfQueue(q);
+                if (lane === undefined)
+                    continue;
+                for (const card of reviewable)
+                    rows.push(rowOf(q.sessionId, lane, card));
+            }
+            return rows.sort((a, b) => a.heldAt - b.heldAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        },
+        async decide(scope, coord, decision) {
+            const q = queueOf(scope, coord);
+            if (q === undefined)
+                return { kind: "not_found" };
+            return serially(q, coord.seq, async () => {
+                if (!q.list().some((c) => c.seq === coord.seq && awaitsReview(c)))
+                    return { kind: "not_found" };
+                let outcome;
+                try {
+                    outcome = await q.settle(coord.seq, decision);
+                }
+                catch (error) {
+                    return { kind: "unrecorded", error };
+                }
+                return outcome === "gone" ? { kind: "not_found" } : { kind: "settled", outcome };
+            });
+        },
+        async shutdown() {
+            const snapshots = listPeerHeldQueues();
+            const queues = snapshots.flatMap((s) => {
+                const q = peerHeldQueueIfAny(s.scope, s.sessionId, s.box);
+                return q === undefined ? [] : [q];
+            });
+            const settled = await Promise.allSettled(queues.map((q) => q.shutdown()));
+            const receiptFaults = settled.flatMap((r) => (r.status === "rejected" ? [r.reason instanceof Error ? r.reason.message : String(r.reason)] : []));
+            return { queues: queues.length, cards: snapshots.reduce((n, s) => n + s.size, 0), receiptFaults };
+        },
+    };
+}
+export const defaultPeerInboundFace = createPeerInboundFace();
+//# sourceMappingURL=peer-inbound-face.js.map

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

@@ -1,6 +1,6 @@
 /**
  * **规则表的唯一编译口** —— 一张工具名规则表(`ask` / `deny` 之一)编成一只 `ToolPolicy`。读者:请求腿的 `settings.permissions.{ask,deny}`
- * 两桶(`task-settings.ts` 的 `deriveSettingsPolicy`,每桶按根至多编两集,见文件尾 {@link ruleRootOf})。设置层条目的形与层 → 根表也住这里(文件尾一节)。
+ * 两桶(`task-settings.ts` 的 `deriveSettingsPolicy`,每桶按根至多编两集,见文件尾 {@link ruleRootOf})。设置层条目的形与层 → 根表也住这里(文件尾一节;三桶同一张表、同一只分集读法)。
  *
  * 🔴 core 7.42.0 起策略只说 deny / ask:allow 规则有且只有引擎 allow 层的两个席位 —— 请求的 `settings.permissions.allow` 整份投
  * `TaskSpec.allowedTools`(`task-settings.ts` 的 `applyTaskSettings`),运维的 `APPROVAL_GRANT` 投 `RunnerDeps.allowedTools`
@@ -8,7 +8,7 @@
  *
  * 为什么住在一只叶模块里(不留在 `task-settings.ts`):本模块只 import core 与契约包 settings-schema(纯叶),读者引它不成环。
  */
-import { type PathRuleBases, type PermissionRule, type PermissionRulePolicyOptions, type ToolPolicy } from "@sema-agent/core";
+import { type PathRuleBases, type PermissionRule, type PermissionRulePolicyOptions, type RuleBehavior, type ToolPolicy } from "@sema-agent/core";
 import { type SettingsSource } from "@sema-agent/settings-schema";
 /** 一张表里规则条数的上限 —— 请求腿 wire 门(`task-settings.ts` 的 deny / ask 两桶判形)读的也是这一个名字:core 的缺省帽是 256,
  *  不对齐的话第 257 条起编译当场抛,等于服务端自己收下的东西自己反悔。 */
@@ -80,15 +80,15 @@ export declare function buildRuleListJudgeOptions(pathBases: PathRuleBases | und
  *  `table` = 这一集出自哪只桶(只进编不出时的兜底句;逐条坐标由先跑的受理判 `rulePolicyBucketsRefusal` 给)。 */
 export declare function createRuleListPolicy(rules: readonly SourcedRule[], behavior: PermissionRule["behavior"], table: string, pathBases: PathRuleBases | undefined): ToolPolicy;
 /**
- * deny / ask 桶的一个条目:**纯串** = 请求自己写的规则(今天的形,读在任务根);**带层条目** `{ rule, layer }` = 端从某个设置层读来的规则,`layer` 是
+ * 三桶(`allow` / `deny` / `ask`)的一个条目:**纯串** = 请求自己写的规则(今天的形,读在任务根);**带层条目** `{ rule, layer }` = 端从某个设置层读来的规则,`layer` 是
  * 契约包 `SETTINGS_SOURCES` 的来源词(= 参照实现的设置来源词)。层只决定这条规则的 `/` 读在哪个根({@link layerRuleRoot}),**不决定准入档**
- * (准入只由凭据推,`http/caller-trust.ts`):调用方自报任何层,挪动的只是它自己那条收紧读在哪,与它自己写 `//abs` 等价。
+ * (准入只由凭据推,`http/caller-trust.ts`):调用方自报任何层,挪动的只是它自己那条规则读在哪,与它自己写 `//abs` 等价(allow 照旧按放宽成员要它的档)。
  *
  * 为什么是「条目带层」而不是一只新键:本版之前的每一个读者(回滚、滚动发布中的旧副本)对一只没见过的键是**静默忽略**(续跑重放走宽容层),
  * 带层的收紧会整批消失;对一个不是串的条目则在桶门上 `bad_entry` —— 新提交 400、续跑 409,响亮拒。条数帽也因此仍是「一桶一张表」。
  */
 export type RuleListEntry = string | LayeredRule;
-/** 带层条目(恰两键;受理判 {@link ruleListEntryOk})。 */
+/** 带层条目(恰两键;受理判 {@link layeredRuleOk})。 */
 export interface LayeredRule {
     readonly rule: string;
     readonly layer: SettingsSource;
@@ -98,8 +98,12 @@ export interface SourcedRule {
     readonly rule: string;
     readonly source: string;
 }
-/** 一个条目合不合 deny / ask 桶的条目律:非空串;或恰 `rule`(非空串)+ `layer`(`SETTINGS_SOURCES` 里的词)两键的纯对象。别的形一律不合(多键、空串、未知层、数组、原型对象)。 */
+/** 带层条目的判据(三桶同一只):恰 `rule`(非空串)+ `layer`(`SETTINGS_SOURCES` 里的词)两键的纯对象。别的形一律不合(多键、空串、未知层、数组、原型对象)。 */
+export declare function layeredRuleOk(x: unknown): x is LayeredRule;
+/** deny / ask 桶的条目律:非空串(规则编译器读不出空串),或合形的带层条目。 */
 export declare function ruleListEntryOk(x: unknown): x is RuleListEntry;
+/** allow 桶的条目律:任意串(空串交引擎的 allow 层,读成 `grammar` 并通告),或合形的带层条目。 */
+export declare function allowListEntryOk(x: unknown): x is RuleListEntry;
 /** 条目的规则原文(纯串即它自己)。 */
 export declare function ruleTextOf(entry: RuleListEntry): string;
 /** 条目进编译口的出处串:纯串 = 桶坐标(今天的字面);带层 = 桶坐标 + 层(`settings.permissions.deny, layer userSettings`)。 */
@@ -114,7 +118,7 @@ export type RuleRoot = (typeof RULE_ROOTS)[number];
  */
 export declare function layerRuleRoot(layer: SettingsSource): RuleRoot;
 /**
- * 一个条目编进哪一集:**只有 `/` 随层变** —— 带层条目的层根是配置根 ∧ 这条规则要 `root`(core 的必需基分类 `ruleBasesNeeded`)⇒ `configuration`;
+ * 一个条目编进哪一集(deny / ask 编成哪只策略、allow 投成哪一员 —— 三桶同读):**只有 `/` 随层变** —— 带层条目的层根是配置根 ∧ 这条规则要 `root`(core 的必需基分类 `ruleBasesNeeded`)⇒ `configuration`;
  * 其余一律 `task`(纯串、别的层、`~/` / 相对形、`//abs` 与 subpath 这类分类为空的规则 —— 后者在 Windows 族上仍随声明的根选盘,必须留在今天那一集)。
  * 文法读不出的串 ⇒ `task`(受理判在前面就拒它,这里不另说一句)。
  *
@@ -122,7 +126,7 @@ export declare function layerRuleRoot(layer: SettingsSource): RuleRoot;
  * `policyAnchors`)—— 「一层一集」在任务根读不出的腿(未登记工作目录的 host 腿、每一条沙箱腿)上会把 user 层的相对规则读到配置根下。配置根那一集只装要
  * `root` 的规则,`cwd` 永远不被问。
  */
-export declare function ruleRootOf(entry: RuleListEntry, behavior: PermissionRule["behavior"]): RuleRoot;
+export declare function ruleRootOf(entry: RuleListEntry, behavior: RuleBehavior): RuleRoot;
 /** 一桶的条目按根分集(受理判与编译读同一只:判的就是要编的那一集);集内保持原序。 */
-export declare function ruleSetsOf(entries: readonly RuleListEntry[], behavior: PermissionRule["behavior"]): Readonly<Record<RuleRoot, readonly RuleListEntry[]>>;
+export declare function ruleSetsOf(entries: readonly RuleListEntry[], behavior: RuleBehavior): Readonly<Record<RuleRoot, readonly RuleListEntry[]>>;
 //# sourceMappingURL=permission-rule-list.d.ts.map

package/dist/permission-rule-list.js

@@ -17,9 +17,7 @@ export function createRuleListPolicy(rules, behavior, table, pathBases) {
     }
 }
 const SETTINGS_SOURCE_SET = new Set(SETTINGS_SOURCES);
-export function ruleListEntryOk(x) {
-    if (typeof x === "string")
-        return x.length > 0;
+export function layeredRuleOk(x) {
     if (x === null || typeof x !== "object" || Array.isArray(x) || Object.getPrototypeOf(x) !== Object.prototype)
         return false;
     const keys = Object.keys(x);
@@ -28,6 +26,12 @@ export function ruleListEntryOk(x) {
     const { rule, layer } = x;
     return typeof rule === "string" && rule.length > 0 && typeof layer === "string" && SETTINGS_SOURCE_SET.has(layer);
 }
+export function ruleListEntryOk(x) {
+    return typeof x === "string" ? x.length > 0 : layeredRuleOk(x);
+}
+export function allowListEntryOk(x) {
+    return typeof x === "string" || layeredRuleOk(x);
+}
 export function ruleTextOf(entry) {
     return typeof entry === "string" ? entry : entry.rule;
 }

package/dist/plugins/approval-ask-store-file.js

@@ -32,6 +32,18 @@ const JOURNAL_V1_CLAIM_INTENTS = ["expire", "cancel"];
 const JOURNAL_V1_CLAIM_INTENT_WORDS = new Set(JOURNAL_V1_CLAIM_INTENTS);
 const JOURNAL_ENVELOPE = 2;
 const JOURNAL_V1_ENVELOPE = 1;
+function askRowToDisk(row) {
+    const { sourceSessionId, ...rest } = row;
+    return { ...rest, sourceTaskId: sourceSessionId };
+}
+function askRowFromDisk(row, refuse) {
+    const sourceTaskId = row !== null && typeof row === "object" ? row.sourceTaskId : undefined;
+    if (typeof sourceTaskId !== "string")
+        return refuse("ask row without a string sourceTaskId (the on-disk name of the ask's source session)");
+    const { sourceTaskId: _onDisk, ...rest } = row;
+    return { ...rest, sourceSessionId: sourceTaskId };
+}
+const callToDisk = (call) => (call.op === "ensureAsk" ? { ...call, row: askRowToDisk(call.row) } : call);
 const V1_ENDING_STATES = new Set(["VOID", "DENIED"]);
 const V1_TRIGGER_STATES = new Set(["PARKING", "PARKED"]);
 function translateJournalV1Record(raw, refuse) {
@@ -120,9 +132,9 @@ export class FileApprovalAskStore {
     }
     write(call, run) {
         const t = Date.now();
-        const record = { v: JOURNAL_ENVELOPE, k: "op", t, ...call };
-        const encoded = encodeStoreJsonPayload(`${call.op} call`, record);
-        this.logFor().append(encoded, true);
+        const encoded = encodeStoreJsonPayload(`${call.op} call`, { v: JOURNAL_ENVELOPE, k: "op", t, ...call });
+        const onDisk = { v: JOURNAL_ENVELOPE, k: "op", t, ...callToDisk(encoded) };
+        this.logFor().append(onDisk, true);
         this.records += 1;
         this.pinnedNow = t;
         let out;
@@ -151,7 +163,7 @@ export class FileApprovalAskStore {
     compact(snapshot = this.core.exportRows()) {
         const lines = [
             ...snapshot.batches.map((row) => `${JSON.stringify({ v: JOURNAL_ENVELOPE, k: "batch", row })}\n`),
-            ...snapshot.asks.map((row) => `${JSON.stringify({ v: JOURNAL_ENVELOPE, k: "ask", row })}\n`),
+            ...snapshot.asks.map((row) => `${JSON.stringify({ v: JOURNAL_ENVELOPE, k: "ask", row: askRowToDisk(row) })}\n`),
         ];
         this.log?.closeForSwap();
         atomicWriteFile(this.tmpDir, this.path, lines.join(""));
@@ -182,7 +194,7 @@ export class FileApprovalAskStore {
             if (typeof key !== "string" || key.length === 0)
                 refuse(`snapshot record without a ${probe.k === "ask" ? "askId" : "batchId"}`);
             if (probe.k === "ask")
-                this.core.importRows({ asks: [row] });
+                this.core.importRows({ asks: [askRowFromDisk(row, refuse)] });
             else
                 this.core.importRows({ batches: [row] });
             return;
@@ -200,7 +212,7 @@ export class FileApprovalAskStore {
             if (!Array.isArray(anchors) || !anchors.every((a) => typeof a === "string"))
                 refuse("reapSettledAsks record without a string-array keepAnchors");
         }
-        const rec = raw;
+        const rec = (probe.op === "ensureAsk" ? { ...raw, row: askRowFromDisk(probe.row, refuse) } : raw);
         this.pinnedNow = rec.t;
         try {
             void this.replayOp(rec).catch((e) => {

package/dist/plugins/approval-ask-store-memory.js

@@ -1,7 +1,7 @@
 import { ASK_TERMINAL, canAskTransition } from "../approval-ask-machine.js";
 import { isExecutionLane } from "../execution-lane-caps.js";
 import { APPROVAL_ENDING_CAUSES } from "../approval-deny-reasons.js";
-import { askRowCarriesOwner, askRowOnCall, assertDecideSettledBy, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
+import { askRowCarriesOwner, askRowOnCall, assertDecideSource, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
 function applyPatch(row, patch) {
     if (patch.decision !== undefined)
         row.decision = patch.decision;
@@ -58,7 +58,7 @@ export class InMemoryApprovalAskStore {
     }
     importRows(snapshot) {
         for (const r of snapshot.asks ?? [])
-            this.asks.set(r.askId, { ...r, settledBy: r.settledBy ?? null });
+            this.asks.set(r.askId, { ...r, settledBy: r.settledBy ?? null, decidedVia: r.decidedVia ?? null });
         for (const b of snapshot.batches ?? [])
             this.batches.set(b.batchId, { ...b });
     }
@@ -82,7 +82,7 @@ export class InMemoryApprovalAskStore {
         const created = {
             askId: row.askId,
             taskId: row.taskId,
-            sourceTaskId: row.sourceTaskId,
+            sourceSessionId: row.sourceSessionId,
             sessionId: row.sessionId,
             owner: row.owner ?? null,
             executionLane: row.executionLane,
@@ -98,6 +98,7 @@ export class InMemoryApprovalAskStore {
             decisionActor: null,
             decisionNote: null,
             settledBy: null,
+            decidedVia: null,
             decidedAtMs: null,
             endingCause: null,
             parkTrigger: null,
@@ -132,7 +133,7 @@ export class InMemoryApprovalAskStore {
     async decideAsk(askId, batchId, owner, decision) {
         if (decision.idempotencyKey != null)
             assertIdempotencyKeyShape(decision.idempotencyKey);
-        assertDecideSettledBy(decision);
+        assertDecideSource(decision);
         const reading = (row) => projectDecideReading(row ? { ...row } : null, owner);
         const batch = this.batches.get(batchId);
         if (!batch || batch.state !== "OPEN") {
@@ -160,6 +161,7 @@ export class InMemoryApprovalAskStore {
         ask.decisionActor = decision.decisionActor ?? null;
         ask.decisionNote = decision.decisionNote ?? null;
         ask.settledBy = decision.settledBy ?? null;
+        ask.decidedVia = decision.decidedVia ?? null;
         if (decision.updatedInput === undefined)
             delete ask.updatedInput;
         else
@@ -188,7 +190,7 @@ export class InMemoryApprovalAskStore {
                 break;
             }
             case "refuse": {
-                assertDecideSettledBy(POLICY_REFUSAL_DECISION);
+                assertDecideSource(POLICY_REFUSAL_DECISION);
                 const to = claimTargetState(intent);
                 if (!canAskTransition("STREAM_PENDING", to))
                     throw new Error(`InMemoryApprovalAskStore.claimTerminal: illegal terminal claim STREAM_PENDING -> ${to} (askId=${askId})`);
@@ -390,7 +392,7 @@ export class InMemoryApprovalAskStore {
     }
     planReapSettledAsks(cutoffMs, limit, keepAnchors) {
         assertReapBounds(cutoffMs, limit);
-        const anchored = (r) => keepAnchors.has(r.taskId) || keepAnchors.has(r.sessionId) || keepAnchors.has(r.sourceTaskId);
+        const anchored = (r) => keepAnchors.has(r.taskId) || keepAnchors.has(r.sessionId) || keepAnchors.has(r.sourceSessionId);
         return [...this.asks.values()]
             .filter((r) => ASK_TERMINAL.has(r.state) && !r.provisional && r.updatedAtMs < cutoffMs && !anchored(r))
             .sort((a, b) => a.updatedAtMs - b.updatedAtMs || (a.askId < b.askId ? -1 : a.askId > b.askId ? 1 : 0))

package/dist/plugins/approval-ask-store-sql.d.ts

@@ -42,6 +42,7 @@ import type { PgQueryFn } from "./pg-query.js";
 import { type SqlDriver, type SqlDialect } from "./sql-driver.js";
 import { type AskState, type BatchState } from "../approval-ask-machine.js";
 import type { HostSettledBy } from "../host-decision.js";
+import { type DecidedVia } from "@sema-agent/core";
 import { type AskRowEndingCause, type SettleCause, type ParkTriggerCause } from "../approval-deny-reasons.js";
 import { type IndexSpec } from "./ensure-index.js";
 import { type ExecutionLane } from "../execution-lane-caps.js";
@@ -49,7 +50,7 @@ export type AskDecision = "approve" | "deny";
 export interface AskRow {
     askId: string;
     taskId: string;
-    sourceTaskId: string;
+    sourceSessionId: string;
     sessionId: string;
     /** 租户 scope——哨兵归一在消费层(车2+),店里存原值(设计定稿 §3)。 */
     owner: string | null;
@@ -69,7 +70,7 @@ export interface AskRow {
      * 与下面 PARKED 坐标里的 `gateBoundInputHash` 是**两件不同的东西**,别混:
      *   - `boundInputHash`(本列)= ask **铸行时**的入参摘要,一次写定永不改;对账收敛器判据 1 用它跟
      *     checkpoint 行的同名列做**硬相等**——它是**身份三元组之外的第二道等式**,身份本身是
-     *     (`sourceTaskId`, `toolCallId`, 因果下界)三维([ref] 件1 换轴,判据属主 = `approval-reconciler.ts`
+     *     (`sourceSessionId`, `toolCallId`, 因果下界)三维([ref] 件1 换轴,判据属主 = `approval-reconciler.ts`
      *     的 `classifyGateMatch`;本注上一版写的「identity 四元组」是换轴前的旧口径,`sessionId` 从来不是
      *     内存判据维)。任一侧缺席 ⇒ 判据 1 **不命中**;归因看走到哪一层:身份先判(候选集非空却没有同身份
      *     的一条 ⇒ `identity_miss`),身份这层还够得着时缺席才记 `single_mint`(禁「能取到时才比」的可选谓词
@@ -90,7 +91,7 @@ export interface AskRow {
     /**
      * 🔴 [ref]([ref] 的持久半场)—— 这条决议的**结算来源**:`null` = 一个人答的(= 缺席律,core 对
      * 不带这一格的 outcome 逐字按 `"human"` 读),非 null = 宿主自报的那个词([ref] 起写进来的只有决定体出处位
-     * `decidedBy:"policy"` 经 `liveSettledBy` 映射来的 `"policy"`,allow 与 deny 两向都写;词表属主恒是 core —— 见 {@link HostSettledBy})。
+     * `decidedBy:"policy"` 经 `liveHostSource` 映射来的 `"policy"`,allow 与 deny 两向都写;词表属主恒是 core —— 见 {@link HostSettledBy})。
      *
      * **为什么必须是行上的一格**(病灶,7.93.3 合并树 codex ① 验真):`settledBy` 此前只到达**当次**回决的
      * 即时回调,行上不留痕 ⇒ 重放 / 再入 / 同 askId 的兄弟等待者 / 歧义提交恢复读回的是裸 `false`,
@@ -113,6 +114,14 @@ export interface AskRow {
      * 三态收成两态是刻意的:`"human"` 与缺席在 core 那边逐字同义,故店只存「非人」的那些词,`null` 即人。
      */
     settledBy: HostSettledBy | null;
+    /**
+     * core 7.61.0([ref])—— `settledBy = "policy"` 旁的**机器座位**:哪一个机器座位替这台部署答的(core `DECIDED_VIA`:`"policy"` 部署自己的策略 /
+     * `"permission_request_hook"` 一只 PermissionRequest 钩子)。`null` = 没陈述(旧行同读)= 部署自己的策略。它决定模型读哪一句拒句
+     * (「这一跑没有交互审批通道」vs「一只 PermissionRequest 钩子拒了」),所以与 {@link settledBy} 同一条理由住在行上、与决议同一条 UPDATE 落列:
+     * 活卡腿的结算输入只从行读,不在行上 = 重放 / 兄弟 / 再入 / 歧义恢复 / 迟到成功 / 跨副本广播六条路把钩子的拒读回成部署策略的拒。
+     * 只在 `settledBy = "policy"` 旁(core 同一条律;店门 {@link assertDecideSource} 守)。
+     */
+    decidedVia: DecidedVia | null;
     /**
      * [ref]([ref] / [ref] 收口):人批准时带的 **ctrl+g 编辑实参**(wire `updatedInput`),与决议**同一条
      * UPDATE** 原子落列 `updated_input`。语义三态,读法**严格**:
@@ -186,7 +195,7 @@ export interface AskRow {
 export interface NewAskRow {
     askId: string;
     taskId: string;
-    sourceTaskId: string;
+    sourceSessionId: string;
     sessionId: string;
     owner?: string | null;
     /** 出处的执行车道(必填;语义见 {@link AskRow.executionLane})。 */
@@ -250,10 +259,12 @@ export interface DecideAskInput {
      * 🔴 [ref]:本次回决的**结算来源**,与决议同一条 UPDATE 落列 `settled_by`(语义/两态读法/为什么是
      * 自己一列,全在 {@link AskRow.settledBy})。缺席 ⇒ 列 NULL ⇒ 读回是「一个人答的」。
      *
-     * 店**不判词**(词表属主是 core):写什么存什么。店只判**形** —— `assertDecideSettledBy` 的那一条
+     * 店**不判词**(词表属主是 core):写什么存什么。店只判**形** —— `assertDecideSource` 的那一条
      * (长度 ≤ 列宽;[ref] 起 approve 行也可以带来源位),理由见那只门的顶注;三 twin 同判。
      */
     settledBy?: HostSettledBy;
+    /** core 7.61.0([ref]):`settledBy:"policy"` 旁的机器座位,与决议同一条 UPDATE 落列 `decided_via`(语义见 {@link AskRow.decidedVia});缺席 ⇒ 列 NULL。 */
+    decidedVia?: DecidedVia;
     /** [ref]:ctrl+g 编辑实参,与决议同一条 UPDATE 落列(语义三态见 {@link AskRow.updatedInput})。
      *  缺席 / `undefined` ⇒ 列 NULL(没带编辑);**`null` 是值**(编辑成 null),照存 JSON `"null"`。
      *  调用方纪律:deny 不传(店不替调用方判决议方向,写什么存什么)。 */
@@ -293,7 +304,7 @@ export declare function assertReapBounds(cutoffMs: number, limit: number): void;
 export declare function assertIdempotencyKeyShape(key: string): void;
 /** `settled_by` 列宽 = 这一格的唯一尺(两方言 DDL 与下面的形门读同一个常量,不手抄第二份)。 */
 export declare const MAX_SETTLED_BY_CHARS = 16;
-/** `settled_by` 这一列装得下这个词吗(1..{@link MAX_SETTLED_BY_CHARS})—— 店门口形门({@link assertDecideSettledBy})的**谓词本身**。
+/** `settled_by` 这一列装得下这个词吗(1..{@link MAX_SETTLED_BY_CHARS})—— 店门口形门({@link assertDecideSource})的**谓词本身**。
  *  [ref] 起决定口不再读它:wire 上的出处位是闭集(`host-decision.ts` 的 `APPROVAL_DECIDED_BY`),映射到这一列的词恒在尺内。 */
 export declare function settledByFitsColumn(v: string): boolean;
 /**
@@ -307,9 +318,11 @@ export declare function settledByFitsColumn(v: string): boolean;
  * 🔴 [ref]:此前的第二条「只与 `deny` 同行」**删了** —— 它的前提(「只有人能批准一个要执行的动作,core 对 `{allow:true,settledBy}`
  * 一律 fail-closed 拒」)自 core 7.39.0 起不成立:策略的放行铸 `policy_allowed`,决定体的出处位 `decidedBy:"policy"` 在 allow 与 deny
  * 上都落这一列,approve 行带来源位是一条合法的行(读回铸点 `outcomeOfDecidedRow` 两向都读它)。今天写这一列的只有两条路:决定口经
- * `liveSettledBy` 映射来的 `"policy"`,与 `claimTerminal(refuse)` 的 {@link POLICY_REFUSAL_DECISION} —— 都是 core 在两向上都收的词。
+ * `liveHostSource` 映射来的 `"policy"`,与 `claimTerminal(refuse)` 的 {@link POLICY_REFUSAL_DECISION} —— 都是 core 在两向上都收的词。
  */
-export declare function assertDecideSettledBy(decision: Pick<DecideAskInput, "settledBy">): void;
+export declare function assertDecideSource(decision: Pick<DecideAskInput, "settledBy" | "decidedVia">): void;
+/** `decided_via` 列宽 = 这一格的唯一尺(两方言 DDL 读同一个常量)。core `DECIDED_VIA` 今天最长 23 字符(`permission_request_hook`)。 */
+export declare const MAX_DECIDED_VIA_CHARS = 32;
 /**
  * [ref] 车3 刀 3b(§14.2 遗留记账):两条**重放读口**被调用方的 deadline 掐断时抛的具名错误。
  *
@@ -353,7 +366,7 @@ export interface AskTerminalClaimOpts {
 /**
  * `refuse` 意图落行的决议(NP-2)—— **部署政策拒**:deny + 结算来源 `policy`。来源词的型取 core 的 `HostSettledBy`
  * (core 改词 / 退词 ⇒ 这里 tsc 红);协调器交给 core 的那一只(`tool-approval.ts` 的 `UnattendedPolicyRefusal`)读的是
- * **同一个**常量,于是「行上记的来源」与「首判交出去的来源」在构造上是一个词。三 twin 落行前都过 {@link assertDecideSettledBy}
+ * **同一个**常量,于是「行上记的来源」与「首判交出去的来源」在构造上是一个词。三 twin 落行前都过 {@link assertDecideSource}
  * (settled_by 的唯一形门:长度 ≤ 列宽)。
  */
 export declare const POLICY_REFUSAL_DECISION: {
@@ -391,6 +404,8 @@ export type AskTerminalClaimCurrent = {
     /** [ref]:赢家决议的**结算来源**(语义与两态读法见 {@link AskRow.settledBy})。**必填**(不是可选)——
      *  可选会让投影漏挑这一列时静默编译过,而漏挑的后果恰是本批要修的病:CAS 输家把赢家的策略拒读成人拒。 */
     settledBy: HostSettledBy | null;
+    /** core 7.61.0([ref]):赢家决议的机器座位(语义见 {@link AskRow.decidedVia});必填,理由与 `settledBy` 同。 */
+    decidedVia: DecidedVia | null;
     /** 行上记着的终态成因(`ending_cause` 列,经唯一读口 `askRowEndingCause` 读出)。**只在读得出时在场**(没写 / 与 state 不配 ⇒ 缺席;DECIDED 的败方读数逐字不变)。
      *  CAS 输家据它按**行上那个成因**结算(而不是把别人撤的卡读成一次拒绝);投影的唯一函数是 {@link projectAskTerminalClaimTruth},三 twin 不各自挑列,原始列值不出店层。 */
     endingCause?: AskRowEndingCause;
@@ -451,7 +466,7 @@ export interface BatchRow {
 }
 /** design 定稿 §4 的持久层接口。协调器接线(车2)、恢复扫描消费(车5)不在本车范围——本车只落这些方法。 */
 /** 一次调用在一条腿上的坐标({@link ApprovalAskStore.listByCall} 的四列;型从 {@link AskRow} 派生,不手抄)。 */
-export type AskCallCoordinate = Pick<AskRow, "taskId" | "legKey" | "toolCallId" | "sourceTaskId">;
+export type AskCallCoordinate = Pick<AskRow, "taskId" | "legKey" | "toolCallId" | "sourceSessionId">;
 /** 「这一行在这次调用上」的唯一判据(四列逐字相等):InMemory twin 的筛子与 SQL twin 的出口对齐读同一只。 */
 export declare function askRowOnCall(row: AskRow, call: AskCallCoordinate): boolean;
 /**
@@ -535,12 +550,12 @@ export interface ApprovalAskStore {
      *  后续件。 */
     listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
     /**
-     * 🔴 [ref] / SN-C1:**这次调用在这条腿上的全部行** —— 任意状态、任意 ask 身份(同一调用不同类集 = 不同 askId 的几只问、升级前按旧派生
+     * 🔴 [ref] / SN-C1:**这次调用在这条腿上的全部行** —— 任意状态、任意 ask 身份(同一调用不同类集 / 不同展示动作 = 不同 askId 的几只问、升级前按旧派生
      * 写的行,都在其中)。坐标 = {@link AskCallCoordinate} 四列**精确**匹配;序 = `created_at_ms ASC, ask_id ASC`(确定性)。
      *
      * 唯一消费者 = 会话授权短路的争议判据(`tool-approval.ts` `sessionGrantUncontestedByRow`):「这次调用在腿内有行 ⇒ 一揽子放行不得代答」。
      * 为什么按调用而不是按 askId 点读:争议的真源是**调用**(人对这次调用说过什么 / 这次调用还有一张卡挂着),ask 身份只是其中一问的主键;
-     * 身份可以加轴([ref] 加了类集),争议判据不得依赖身份 —— 按身份点读在身份加轴的那一刻就把同调用的别的问、旧派生的行读成「不存在」。
+     * 身份可以加轴([ref] 加了类集,7.143.0 加了展示的动作),争议判据不得依赖身份 —— 按身份点读在身份加轴的那一刻就把同调用的别的问、旧派生的行读成「不存在」。
      *
      * 三 twin 同答:SQL twin 读后按四列逐字再滤一遍 —— MySQL 协议的 VARCHAR 等值带 PAD SPACE(`'tc'` = `'tc '`),PG(`COLLATE "C"`)与
      * InMemory 严格比较;不在入口拒(调用 id 是引擎铸的原值,首尾空白不归本店判),在出口对齐。索引:走 `idx_ask_task_state`
@@ -568,7 +583,7 @@ export interface ApprovalAskStore {
     /**
      * **审批账本留存律的问账半场之一:问行**(律、节律与「还能动的 run」一处成文在 `approval-ask-retention.ts`;维护 tick 是唯一调用方)。
      * 删至多 `limit` 只**结了**的问行 —— `state ∈ ASK_TERMINAL` ∧ `provisional = false`(provisional 行还能被 {@link resolveProvisional} 改判,没结)
-     * ∧ `updatedAtMs < cutoffMs` ∧ 行挂靠的三格(`taskId` / `sessionId` / `sourceTaskId`)都不在 `keepAnchors`(还能动的东西的挂靠集:
+     * ∧ `updatedAtMs < cutoffMs` ∧ 行挂靠的三格(`taskId` / `sessionId` / `sourceSessionId`)都不在 `keepAnchors`(还能动的东西的挂靠集:
      * 它还会回读这些行 —— 会话授权的争议判据 {@link listByCall} 把「这次调用在腿内没有行」读成可以代答)。非终态行多老都不删(它们归对账器
      * 与起服收敛)。只删不改。
      * 一条语句:要么删了并交回删掉的行数,要么一行没删就抛。三形同答(InMemory = 内核;File 形把这次调用照常落成一条账本动词,