@sema-agent/server 7.141.0 → 7.143.0

package/dist/orchestration/workflow-notify-journal.d.ts

@@ -8,8 +8,9 @@ import { type WorkflowAgentSessionIndex } from "./workflow-agent-session-index.j
  *    `completionId` = 引擎的一次完成的相关 id(fill-once,终态转换上铸):逐字、不脱敏、本服务零自铸。
  *    `diagnostics` = 引擎在完成通知上铸的诊断教学文本(未完成 agent 的摘要行、完整记录的读取手柄、journal 坐标、续跑句):补投路径是它在原腿已不在(断线重连 / 重启)时唯一的去处,
  *    所以搬运;它是自由文本,出门前在入箱处过出口座(见 `buildWorkflowCompleteInboxEntry`),载荷上仍是引擎值。**崩溃恢复臂不带**:`WorkflowRun` 行上没有这一位,本服务不编。
- *  · `drop`:这条持久链只搬运一句受限摘要 + 诊断文本 + 路由键 —— `task_id` / `task_type` / `toolUseId` 是 live `task_notification` 帧的键(那条路径自带),`result` / `usage` 是完整结果 / 计量
- *    (`WorkflowStatus` 读得到),不进补投帧。
+ *  · `drop`:这条持久链只搬运一句受限摘要 + 诊断文本 + 路由键 —— `task_id` / `task_type` / `toolUseId` 是 live `task_notification` 帧的键(那条路径自带),`result` / `usage` 是完整结果 / 计量,
+ *    不进补投帧:完整结果在引擎存下的运行记录里,上面搬运的 `diagnostics` 点名它的读取手柄(`ReadToolResult`;引擎没存下时那句如实说)—— 自 core 7.61.0 起
+ *    这是模型读到它的唯一一条路(轮询工具已删),所以 `diagnostics` 必须 `carry`。
  * 键名直呼 core 的入参型(型文本里就有 core 名)⇒ 读表的 literals 段收得到这些键。
  */
 export declare const WORKFLOW_NOTIFY_KEY_DISPOSITION: {

package/dist/orchestration/workflow-park-decision.d.ts

@@ -1,4 +1,5 @@
 import { type CheckpointToken, type ResumeOutcome } from "@sema-agent/core";
+import type { ResumeRestatement } from "../http/resume-restatement.js";
 import { type JsonColumnReader } from "../plugins/sql-json-column.js";
 import { type InProcessClaimFence } from "../plugins/store-contracts.js";
 /** 一条人对审批卡的决定(引擎 `ResumeOutcome` 的 `policy_ask` 臂 —— 子代停驻只会是这一门)。 */
@@ -52,11 +53,15 @@ export interface ParkDecisionLaneSeats {
  */
 export declare function parkDecisionStoreRefusal(seats: ParkDecisionLaneSeats): string | undefined;
 /**
- * 决定的同一性判据:判词 + 绑定两位 + 出处词(`decidedBy`)+ 载荷指纹(`updatedInput` / `answer` / `reason` / `feedback`,与 live 腿幂等回放的门⑦
- * 同一只 {@link approvalPayloadFingerprint})。通道自报的 `approver` 不进 —— 它是归属标签,不改引擎铸的结算词。
+ * 决定的同一性判据:判词 + 绑定两位 + 出处(`decidedBy`,带了机器座位 `decidedVia` 时是 `[decidedBy, decidedVia]` 一对)+ 载荷指纹
+ * (`updatedInput` / `answer` / `reason` / `feedback`,与 live 腿幂等回放的门⑦同一只 {@link approvalPayloadFingerprint})。通道自报的 `approver` 不进 ——
+ * 它是归属标签,不改引擎铸的结算词;`decidedVia` 进 —— 它定模型读到的那一句(部署策略拒 / PermissionRequest 钩子拒),换了座位是另一个决定。
+ * 出处位按在场取形(与下面的重述同一条成员律):不带座位 ⇒ 那一位仍是裸 `decidedBy`,字节不变;带了 ⇒ 一对(数组与串不可能相等,不与任何不带座位的决定撞)。
  * 载荷序列化不了 ⇒ 抛(两侧都源自 JSON,走到这里是结构异常;那只函数自己已经响亮 warn)。
+ * 决定体带的续跑请求重述键(`mcpServers` / `a2aPeers`)也是这次决定的一部分:同一决定带另一张表是另一个决定(投递跑还活着时不答首投回执,
+ * 走既有的会话占用拒),同一张表(键序无关,引擎的规范串)才是重投。按在场追加 —— 不带的决定指纹字节不变,落了库的存量指纹不换字节。
  */
-export declare function parkDecisionFingerprint(outcome: WorkflowParkOutcome): string;
+export declare function parkDecisionFingerprint(outcome: WorkflowParkOutcome, restatement?: ResumeRestatement): string;
 /**
  * 存下的决定体 → 内域形的**唯一读者**(SQL 列与 local 账本行共用)。判到本仓自己读的那几格为止(门、判词、绑定两位、出处对象);
  * 其余键的属主是引擎,它在续跑入口 pre-CAS 再判一遍(与 checkpoint 店读 `outcome` 列同一条分工,见 `checkpoint-store-sql.ts` 的形读者注)。

package/dist/orchestration/workflow-park-decision.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { join } from "node:path";
-import { AppendLog, ensureDir } from "@sema-agent/core";
+import { AppendLog, canonicalJsonStringify, ensureDir } from "@sema-agent/core";
 import { approvalPayloadFingerprint } from "../plugins/approval-payload-fingerprint.js";
 import { createObjectColumnReader, isJsonObject } from "../plugins/sql-json-column.js";
 import { replayJsonlGuarded } from "../observability/corrupt-read-seat.js";
@@ -31,7 +31,7 @@ export function parkDecisionStoreRefusal(seats) {
         "its writes are fenced by the run store it was built on, so a different run store means decisions recorded where the session claims are not checked; " +
         "take runStore and workflowParkDecisions from the same store backend (run() and workflowParkDecisions()); refusing to start rather than record decisions the session claim cannot fence");
 }
-export function parkDecisionFingerprint(outcome) {
+export function parkDecisionFingerprint(outcome, restatement) {
     const payload = approvalPayloadFingerprint({
         ...(outcome.updatedInput !== undefined ? { updatedInput: outcome.updatedInput } : {}),
         ...(outcome.answer !== undefined ? { answer: outcome.answer } : {}),
@@ -40,7 +40,9 @@ export function parkDecisionFingerprint(outcome) {
     });
     if (payload === null)
         throw new Error("workflow park decision: the decision payload cannot be serialized — refusing to record a decision whose identity cannot be stated");
-    const identity = JSON.stringify([outcome.decision, outcome.boundCallId, outcome.boundInputHash, outcome.hostDecision.decidedBy, payload]);
+    const { decidedBy, decidedVia } = outcome.hostDecision;
+    const provenance = decidedVia !== undefined ? [decidedBy, decidedVia] : decidedBy;
+    const identity = JSON.stringify([outcome.decision, outcome.boundCallId, outcome.boundInputHash, provenance, payload, ...(restatement !== undefined ? [canonicalJsonStringify(restatement)] : [])]);
     return createHash("sha256").update(identity).digest("hex");
 }
 const readOutcomeObject = createObjectColumnReader();

package/dist/org-delivery-gate.d.ts

@@ -78,4 +78,15 @@ export interface OrgDeliveryGateDeps {
  * 活对象(闭包持有目录 / 两只店 / 消费方)⇒ `create*`(CLAUDE.md 工厂命名律)。
  */
 export declare function createOrgDeliveryGate(deps: OrgDeliveryGateDeps): OrgDeliveryGate;
+/**
+ * 箱址的读侧映射也归门(单一属主:箱址常量只在本文件出现,`test/org-delivery-gate-single-path.test.ts` ①):
+ * 被扣的跨会话信在收信会话的哪条车道上 ⇄ core 队列键的 `box`。消费方 = `src/peer-inbound-face.ts`。
+ */
+/** 一封被扣的信在收信会话的哪条车道上:会话自己的箱,或它代为排空的本 principal 收件箱(core 的 `PRINCIPAL_INBOX_HANDLE`)。闭集。 */
+export declare const PEER_INBOUND_LANES: readonly ["session", "principal_inbox"];
+export type PeerInboundLane = (typeof PEER_INBOUND_LANES)[number];
+/** 车道 → core 队列键的第三位(`peerHeldQueueIfAny` 的 `box`;会话自己的箱 = 缺席)。 */
+export declare function boxOfLane(lane: PeerInboundLane): string | undefined;
+/** 通告里的箱句柄 → 车道(会话箱按 core 的句柄函数比对,不手拼前缀);两者都不是 ⇒ `undefined`。 */
+export declare function laneOfBox(box: string, sessionId: string): PeerInboundLane | undefined;
 //# sourceMappingURL=org-delivery-gate.d.ts.map

package/dist/org-delivery-gate.js

@@ -1,4 +1,4 @@
-import { CrossSessionCodecError, MAILBOX_TOMBSTONED_RECIPIENT_CODE, PRINCIPAL_INBOX_HANDLE, mintCrossPrincipalRecord, uuidv7, } from "@sema-agent/core";
+import { CrossSessionCodecError, MAILBOX_TOMBSTONED_RECIPIENT_CODE, PRINCIPAL_INBOX_HANDLE, peerSessionBoxHandle, mintCrossPrincipalRecord, uuidv7, } from "@sema-agent/core";
 import { principalShapeProblem } from "./security.js";
 import { mailboxKeyProblem } from "./plugins/mailbox-store-sql.js";
 export const ORG_DELIVERY_QUOTA = Object.freeze({ windowMs: 3_600_000, attemptsPerSender: 60, perPair: 10, perRecipient: 30 });
@@ -56,4 +56,22 @@ export function createOrgDeliveryGate(deps) {
         },
     };
 }
+export const PEER_INBOUND_LANES = ["session", "principal_inbox"];
+export function boxOfLane(lane) {
+    switch (lane) {
+        case "session":
+            return undefined;
+        case "principal_inbox":
+            return PRINCIPAL_INBOX_HANDLE;
+        default: {
+            const unreachable = lane;
+            throw new Error(`peer inbound lane outside its closed set: ${String(unreachable)}`);
+        }
+    }
+}
+export function laneOfBox(box, sessionId) {
+    if (box === PRINCIPAL_INBOX_HANDLE)
+        return "principal_inbox";
+    return box === peerSessionBoxHandle(sessionId) ? "session" : undefined;
+}
 //# sourceMappingURL=org-delivery-gate.js.map

package/dist/parked-decide.d.ts

@@ -9,7 +9,8 @@
  * 行永 parked、生命周期分叉)。
  */
 import type { HostDecision } from "./host-decision.js";
-import type { DecideBinding } from "./http/wire-types.js";
+import type { DecideBinding, DecidedAction } from "./http/wire-types.js";
+import type { ResumeRestatement } from "./http/resume-restatement.js";
 import type { BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, CheckpointToken, QuestionAnswer, RunInternals, TaskRegistry, ToolExecuteContext, WorkflowRun, WorkflowRunStore } from "@sema-agent/core";
 import type { ParkedReviveSurfaceFactory } from "./parked-revive-surface.js";
 import type { RebuiltInheritedGate } from "./boot/parked-revive-gate.js";
@@ -133,7 +134,7 @@ export declare function heldWorkflowParkDecisions(sources: HeldWorkflowParkDecis
 /**
  * pending checkpoint → parked bg 行匹配。
  *
- * 键链(core 1.390 事实):park 时 cp 落 `sourceTaskId: sessionId`(子会话 id,**不是** bg handle),
+ * 键链(core 1.390 事实):park 时 cp 落 `sourceSessionId: sessionId`(子会话 id,**不是** bg handle),
  * 而 bg 行同样存该子会话 id(`row.sessionId`)与绑定 token(`row.parkedCheckpointToken`)。
  * `listByScope` 只回 summary(含 handle/sessionId、不含 token),故两步:summary.sessionId 初筛 →
  * `get(handle, scope)` 全行复核 token。
@@ -219,7 +220,7 @@ export interface ParkedDecideRequest {
     token: string;
     scope: string;
     sessionId: string;
-    /** cp.pendingAction 原样(outcome 铸造的 persisted 回落源,与 legacy 腿 D-1 姿势逐字同形)。 */
+    /** cp.pendingAction 原样(只读两件行事实:引擎自己的问题工具之判 `isEngineQuestionRow`、AskUserQuestion 预检的工具名;从不作绑定的回落源)。 */
     pendingAction: unknown;
     decision: "approve" | "deny";
     /** [ref] 件6③ / [ref](core 7.6.0 S6-A):**这次结算的事实**,由调用方陈述(必填,理由与 legacy 腿
@@ -231,12 +232,12 @@ export interface ParkedDecideRequest {
      *  deny-sweep 恰是 req 缺席的那条腿,它对 parked 行另有静默跳过臂)⇒ 恒 `decidedBy:"person"`。 */
     hostDecision: HostDecision;
     reason?: string;
-    /** D-1 decision-binding echo(操作员在 GET 看到的 boundCallId/boundInputHash 原样透传;server
-     *  绝不重算,core resume 侧做 fail-closed 等值校验——与 legacy 腿同姿势)。 */
-    binding?: Omit<DecideBinding, "checkpointToken">;
+    /** D-1 决断绑定:决断方点名它看到的那一对(必在 —— 续跑腿的判官 `decidedActionOf` 判过才交下来)与决定体的其余两位;
+     *  server 绝不重算、绝不从停驻行补,core resume 侧做 fail-closed 等值校验 —— 与 legacy 腿同姿势。 */
+    binding: Omit<DecideBinding, "checkpointToken" | "boundCallId" | "boundInputHash"> & DecidedAction;
     /** body 带了 `remember:"session"` 时路由传入的 grant 执行器([ref] 候裁② 的 server 侧修,经两轮
      *  行为探针实证):豁免必须锚在**行的 root/host 会话 id**——部署侧三个豁免探针(policy 层/fs-write
-     *  门/workflow 门)的闭包统一捕获 host 会话键且签名不携身份(1.393 seam 亲读:`sourceTaskId` 只在
+     *  门/workflow 门)的闭包统一捕获 host 会话键且签名不携身份(1.393 seam 亲读:`sourceSessionId` 只在
      *  onAsk 层的 AskRequest,durable 车道无 onAsk),grant 落子代会话则键永不相交(G-F4 原案);落
      *  root 会话则宿主键闭包立即命中,复活子代的后续同工具 ask 被短路(探针 v2 实证),语义与同步车道/
      *  宿主任务的「本会话不再询问」一致(= host 会话树全域)。行无 root 锚(病态形)⇒ claim 前诚实 400。 */
@@ -246,6 +247,9 @@ export interface ParkedDecideRequest {
      *  server 不预判)。core 拒绝形:同步腿 409 invalid_outcome field:"answer",parked 腿经 drive 失败
      *  面 422 parked_resume.startup_failed。 */
     answer?: QuestionAnswer;
+    /** 决定体带的续跑请求重述键(`mcpServers` / `a2aPeers`;路由已过提交腿同一只判官)。两条车道各自决定拿它怎么办:workflow 车道盖在宿主会话的续跑输入上、
+     *  并进决定的同一性({@link parkDecisionFingerprint});bg 赎回腿不从存量提交体重建任务规格,盖不上 ⇒ claim 前诚实 400(`decide.parked_restatement_unsupported`)。 */
+    restatement?: ResumeRestatement;
     /** claim CAS 赢了(≈ legacy 腿的 markResuming 赢)之后、execute 之前触发——remember 豁免 grant
      *  的挂点(调用方自吞错,绝不抛落赎回)。claim 败/判别 miss 恒不触发。 */
     onDecideCommitted?: () => Promise<void>;
@@ -272,8 +276,8 @@ export interface ParkedDecideResult {
  * 判据一字未改,只是从 bg 腿里提出来:两条腿结算的是**同一种门**(core gateMatch 的 `policy_ask`),
  * 各铸一份必然漂移,而漂的是「人到底批了什么」这条审计事实。
  *
- * · D-1 绑定:操作员在 GET 看到的 `boundCallId`/`boundInputHash` 原样透传,server **绝不重算**;
- *   缺席时回落到行上 persisted 的那两位(core resume 侧做 fail-closed 等值校验)。
+ * · D-1 绑定:决断方在 GET 看到的 `boundCallId`/`boundInputHash` 原样透传,server **绝不重算、绝不从行上补**
+ *   (那一对必在,续跑腿的判官判过;core resume 侧做 fail-closed 等值校验)。
  * · `reason` 走**存在性**判定(`!== undefined`),不是真值判定 —— 本铸点不折叠,原样上送。
  *   🔴 但**别把这条读成「空串与缺席在结算上是两件事」**(7.19.0 / [ref] 之前那句话是真的,之后不是):
  *   上送域的属主是引擎的单铸点,它把空文本折成缺席 ⇒ 到了消费端,`reason:""`、不传 `reason`、

package/dist/parked-decide.js

@@ -120,17 +120,14 @@ function mintReviveArgs(row, knownAgentTypes) {
     };
 }
 export function buildParkedResumeOutcome(req) {
-    const pa = req.pendingAction;
-    const persistedCallId = pa?.kind === "tool_approval" ? (pa.toolCallId ?? "") : "";
-    const persistedHash = pa?.kind === "tool_approval" ? (pa.boundInputHash ?? "") : "";
     const engineQuestion = isEngineQuestionRow(req.pendingAction);
     return {
         gate: "policy_ask",
-        boundCallId: req.binding?.boundCallId ?? persistedCallId,
-        boundInputHash: req.binding?.boundInputHash ?? persistedHash,
+        boundCallId: req.binding.boundCallId,
+        boundInputHash: req.binding.boundInputHash,
         decision: req.decision === "approve" ? "allow" : "deny",
-        ...(req.decision === "approve" && !engineQuestion && req.binding?.updatedInput !== undefined ? { updatedInput: req.binding.updatedInput } : {}),
-        ...(req.binding?.feedback !== undefined ? { feedback: req.binding.feedback } : {}),
+        ...(req.decision === "approve" && !engineQuestion && req.binding.updatedInput !== undefined ? { updatedInput: req.binding.updatedInput } : {}),
+        ...(req.binding.feedback !== undefined ? { feedback: req.binding.feedback } : {}),
         ...(req.answer !== undefined ? { answer: req.answer } : {}),
         ...(req.reason !== undefined ? { reason: req.reason } : {}),
         hostDecision: req.hostDecision,
@@ -263,6 +260,9 @@ export async function decideParkedAgent(deps, req, match) {
     if (req.grantRemember !== undefined && rememberRoot === undefined) {
         return { status: 400, body: refusalBody({ errorCode: "decide.parked_remember_unsupported", message: "remember cannot be applied: this parked agent row carries no root/parent session anchor for the exemption", facts: { taskId: match.handle } }) };
     }
+    if (req.restatement !== undefined) {
+        return { status: 400, body: refusalBody({ errorCode: "decide.parked_restatement_unsupported", message: "mcpServers / a2aPeers cannot be applied: this approval belongs to a background agent that stopped to wait for it, and that agent resumes with the MCP / A2A tables it had when it stopped — re-issue the decide without them to resume it that way", facts: { taskId: match.handle } }) };
+    }
     const pendingTool = req.pendingAction?.toolName;
     if (pendingTool === ASK_USER_QUESTION_TOOL_NAME && req.decision === "approve" && req.answer === undefined) {
         return { status: 400, body: refusalBody({ errorCode: "decide.parked_answer_required", message: "pending action is AskUserQuestion — approve requires body.answer (the operator's answers[]); deny needs none", facts: { taskId: match.handle } }) };

package/dist/parked-revive-surface.js

@@ -9,7 +9,7 @@ export function createParkedReviveSurface(defaultScenario) {
         if (root === undefined)
             return { reviveTool: bootTool };
         const seated = holdsSeat(row.parentSessionId === root, identity);
-        const delegationRoot = { sessionId: root, incarnation: identity.rootOccupant.incarnation };
+        const delegationRoot = { sessionId: root, owner: identity.rootOccupant.owner, incarnation: identity.rootOccupant.incarnation };
         const tools = (seated ? defaultScenario({}, identity.principal, { sessionId: root, delegationRoot }) : defaultScenario({}, undefined, { delegationRoot })).tools;
         const reviveTool = agentOf(tools);
         if (reviveTool === undefined)

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

@@ -0,0 +1,127 @@
+/**
+ * **被扣住的跨会话来信的收信方决断面**([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 的枚举口到货即退役)
+ * core 的队列注册表是模块私有的,只能按 (scope, 会话, 箱) 查 —— 宿主拿不到「这个进程里有哪些队列」。本面因此记一张**坐标表**:
+ * (会话 id, 车道) —— 只是「去哪儿查」,不是卡,不含任何卡的事实。喂它的是 core 自己的两条通告(经部署级通告转发席,
+ * `boot/runner-deps.ts` 的 `createEngineNoticeForwarder`):`peer.inbound_disposition{disposition:"held"}`(成因可审)进表,
+ * `peer.held_settled{heldCount:0}` 出表。读的时候每一行都回 core 的队列取当下的卡,表里多一行 = 多查一次空队列,少一行 = 那张卡不列
+ * (信仍按 core 的期限带回执过期 —— 安全默认)。退役条件:core 导出进程内 held 队列的枚举(连同各队列的 scope)。
+ * 🚧 **坐标不带 scope**(通告 detail 里没有):同一会话 id 在本进程里被两个主体各排空出一只队列时(无主会话行 / 别的主体跑了这只会话),
+ * 一只队列清空的那条 `heldCount:0` 把坐标带出表,另一只队列里的卡就不再列出,直到它的下一条 `held`(失败方向 = 上一句的安全默认)。
+ * 钉 = `test/peer-inbound-approvals.test.ts` 的 🚧 R2 特征化格;core 请托 = 两条通告的 detail 带队列 scope(或上面的枚举口)。
+ *
+ * ## 关停
+ * CC `HBe` 在宿主:core 不调 `PeerHeldQueue.shutdown()`(全库零生产调用点)。{@link PeerInboundFace.shutdown} 在有序关停的审批收尾那一拍
+ * (`boot/shutdown.ts`,关池之前)对坐标表里每只队列调它 —— 仍被扣的信按 core 的规则带 `expired` 回执结清(reason `shutdown`)。
+ * scope 读自会话行属主(`owner ?? "default"`,与 `boot/session-faces.ts` 信箱腿同读),调用方给读口。
+ * 🚧 core 的队列 scope 是排空那条 run 的主体(`spec.principal ?? "default"`):无主会话被具名主体跑过时两者不同,关停找不到那只队列
+ * (失败方向同崩溃:信仍被扣在箱里,下一位消费者重新领它)。钉 = 🚧 R4 特征化格;core 请托同上。
+ * 🚧 core 的结清回执是投出即返(排空汇点 `void routePeerDeliveryReceipt(…)`):`shutdown()` 兑现时回执可能还没落箱,关池在它之后 ⇒ 那一条回执可能丢
+ * (信本身已结清)。宿主没有可等的句柄;core 请托 = `shutdown()` 等回执落箱再兑现。
+ */
+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"`)。
+ * 列 / 决用调用方的 principal,关停用会话行属主;两者在属主围栏下同值(`resolve-spec.ts` 的 `fenceSessionOwner`),
+ * 无主存量会话被具名壳续聊的混属主形是既有残余(`boot/session-faces.ts` 信箱腿同一条登记)。
+ */
+export declare function peerBoxScope(principalOrOwner: 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 队列里(在扣信、成因变动、换绑时各自起表),卡上不带它;本仓若按 `heldAt + dialogExpiry` 自算,
+ * 成因一动就是一个错的截止时刻(第二份读法)。core 给卡加上到期时刻即补上(请托见 [ref] 收车档)。
+ */
+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 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;
+};
+/** 关停读数:结清了几只队列、几只会话的 scope 读不出(那几只的卡随进程离开 —— 信仍在箱里被扣着,下一位消费者重新领它)。 */
+export interface PeerInboundShutdownReading {
+    readonly queues: number;
+    readonly scopeUnresolved: number;
+}
+export interface PeerInboundFace {
+    /** 部署级通告转发席的观察口:只读两条码的坐标,其余一概不看。永不抛(转发席不许把异常回抛给引擎)。 */
+    observe(notice: {
+        readonly code: string;
+        readonly detail?: Record<string, unknown>;
+    }): void;
+    /** `scope` 里此刻等人审的信({@link awaitsReview} 的卡),按 `heldAt` 升序(同刻按 id)。 */
+    list(scope: string): PeerInboundPendingRow[];
+    /** 决断转发:只认 `scope` 里此刻等人审的那张卡(与 {@link list} 同一只判据);`settle` 抛(店拒了 CAS)⇒ `unrecorded`。 */
+    decide(scope: string, coord: PeerInboundCoord, decision: PeerInboundDecision): Promise<PeerInboundDecideResult>;
+    /** 有序关停:坐标表里每只队列 `shutdown()`(core 的规则:仍 held 的卡带 `expired` 回执结清,reason `shutdown`)。 */
+    shutdown(scopeOfSession: (sessionId: string) => Promise<string | undefined>): Promise<PeerInboundShutdownReading>;
+}
+export declare function createPeerInboundFace(): PeerInboundFace;
+/** 进程单例 —— 与 core 的 held 队列注册表同一个寿命(进程级);部署级通告转发席与审批路由读的是同一只。 */
+export declare const defaultPeerInboundFace: PeerInboundFace;
+//# sourceMappingURL=peer-inbound-face.d.ts.map

package/dist/peer-inbound-face.js

@@ -0,0 +1,158 @@
+import { PEER_HELD_REVIEW_CAUSES, isPeerSessionId, 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(principalOrOwner) {
+    return principalOrOwner ?? "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,
+        ...(fromSession !== undefined ? { fromSession } : {}),
+        ...(card.from !== undefined ? { fromName: seatText("peer-inbound-card-text", card.from) } : {}),
+        ...(fromScope !== undefined ? { fromScope } : {}),
+    };
+}
+function coordinatesOf(code, detail) {
+    const sessionId = detail?.sessionId;
+    const box = detail?.box;
+    if (typeof sessionId === "string" && typeof box === "string" && isPeerSessionId(sessionId)) {
+        const lane = laneOfBox(box, sessionId);
+        if (lane !== undefined)
+            return { sessionId, lane };
+    }
+    recordFailOpen("server.peer-inbound.notice-coordinates-unreadable", `code=${code}`);
+    return undefined;
+}
+const indexKey = (e) => JSON.stringify([e.lane, e.sessionId.toLowerCase()]);
+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 index = new Map();
+    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 {
+        observe(notice) {
+            switch (notice.code) {
+                case "peer.inbound_disposition": {
+                    if (notice.detail?.disposition !== "held" || !isReviewCause(notice.detail.cause))
+                        return;
+                    const e = coordinatesOf(notice.code, notice.detail);
+                    if (e !== undefined && !index.has(indexKey(e)))
+                        index.set(indexKey(e), e);
+                    return;
+                }
+                case "peer.held_settled": {
+                    if (notice.detail?.heldCount !== 0)
+                        return;
+                    const e = coordinatesOf(notice.code, notice.detail);
+                    if (e !== undefined)
+                        index.delete(indexKey(e));
+                    return;
+                }
+                default:
+                    return;
+            }
+        },
+        list(scope) {
+            const rows = [];
+            for (const e of index.values()) {
+                const q = queueOf(scope, e);
+                if (q === undefined)
+                    continue;
+                for (const card of q.list())
+                    if (awaitsReview(card))
+                        rows.push(rowOf(e.sessionId, e.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(scopeOfSession) {
+            let queues = 0;
+            let scopeUnresolved = 0;
+            const scopes = new Map();
+            for (const e of [...index.values()]) {
+                const sid = e.sessionId.toLowerCase();
+                if (!scopes.has(sid))
+                    scopes.set(sid, await scopeOfSession(e.sessionId).catch(() => undefined));
+                const scope = scopes.get(sid);
+                if (scope === undefined) {
+                    scopeUnresolved += 1;
+                    continue;
+                }
+                const q = queueOf(scope, e);
+                if (q === undefined)
+                    continue;
+                await q.shutdown();
+                queues += 1;
+            }
+            return { queues, scopeUnresolved };
+        },
+    };
+}
+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;
 }