@sema-agent/server 7.147.0 → 7.148.0

package/dist/owner-faces.js

@@ -0,0 +1,126 @@
+import { mintDurableOwnerKey, partsOf } from "./owner-brands.js";
+export const LEGACY_UNOWNED_AMNESTY_TENANT = "default";
+export function sameParty(subject, owner) {
+    return subject === owner;
+}
+export function sameKey(subject, key) {
+    if (key === null || subject === null || subject === undefined)
+        return key === null && (subject === null || subject === undefined);
+    return sameParty(subject, key);
+}
+export function ownerKeyOf(persisted) {
+    return persisted === null ? null : mintDurableOwnerKey(persisted);
+}
+export function ownerCellOf(owner) {
+    if (owner === undefined)
+        return undefined;
+    const key = ownerKeyOf(owner);
+    return key === null ? OWNERLESS_ORDINARY : { owner: key };
+}
+export function recoveredSubject(persisted) {
+    const key = persisted === undefined ? null : ownerKeyOf(persisted);
+    return key === null ? undefined : partsOf(key).subject;
+}
+export function qualsOf(caller, cell) {
+    const out = new Set();
+    if (caller.operator)
+        out.add("operator");
+    if (caller.fleet !== undefined)
+        out.add(caller.fleet);
+    if (caller.traceRead)
+        out.add("trace_read");
+    if (cell === undefined)
+        return out;
+    if (cell.owner !== null) {
+        if (caller.subject !== undefined && sameParty(caller.subject, cell.owner))
+            out.add("owner");
+        return out;
+    }
+    if (cell.placed) {
+        if (caller.fleet !== undefined)
+            out.add("anon_tree");
+        return out;
+    }
+    out.add("open");
+    if (!caller.multiTenant && caller.subject === LEGACY_UNOWNED_AMNESTY_TENANT)
+        out.add("j4");
+    return out;
+}
+const READ_FLEET = ["dev_open", "deployment_token"];
+const OWN_FLEET = ["dev_open", "deployment_token"];
+const LIST_FLEET = ["dev_open", "deployment_token", "trace_read"];
+export const FACES = {
+    "run.read": { resource: "run", grants: ["owner", "open"], fleet: READ_FLEET, operator: false, door: "P401", projection: "run_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "run.drive": { resource: "run", grants: ["owner", "open"], fleet: [], operator: false, door: "P401", projection: "run_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "run.supervise": { resource: "run", grants: ["owner", "open"], fleet: [], operator: true, door: "P401", projection: "run_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "run.resume": { resource: "run", grants: ["owner", "open"], fleet: [], operator: true, door: "P401", projection: "task_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "run.decision": { resource: "run", grants: ["owner", "open"], fleet: [], operator: true, door: "none", projection: "decision_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "run.trace": { resource: "run", grants: ["owner", "open"], fleet: ["dev_open", "deployment_token", "trace_read"], operator: false, door: "I401", projection: "task_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "run.preempt": { resource: "run", grants: ["owner", "open"], fleet: [], operator: true, door: "P401", projection: "task_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "run.replay": { resource: "run", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "run_exists", unreadable: "raise", placementUnreadable: "raise" },
+    "run.a2a": { resource: "run", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "run.leader": { resource: "run", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "run.preview": { resource: "run", grants: ["owner", "open"], fleet: [], operator: true, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "run.panel": { resource: "run", grants: ["owner", "open"], fleet: ["dev_open"], operator: true, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "run.anchor": { resource: "run", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "session.read": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: READ_FLEET, operator: false, door: "P401", projection: "session_missing", unreadable: "fold", placementUnreadable: "raise" },
+    "session.placement": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: READ_FLEET, operator: true, door: "P401", projection: "session_missing", unreadable: "fold", placementUnreadable: "raise" },
+    "session.erase": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: false, door: "P401", projection: "session_missing", unreadable: "fold", placementUnreadable: "raise" },
+    "session.act": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: false, door: "P401", projection: "session_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "session.supervise": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: true, door: "P401", projection: "session_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "session.exemption": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: true, door: "none", projection: "exemption_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "session.own": { resource: "session", grants: ["owner", "j4"], fleet: OWN_FLEET, operator: false, door: "I401", projection: "session_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "session.delete": { resource: "session", grants: ["owner", "j4"], fleet: OWN_FLEET, operator: false, door: "I401", projection: "deleted_false", unreadable: "raise", placementUnreadable: "raise" },
+    "session.policy": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: true, door: "I401r", projection: "session_missing", unreadable: "raise", placementUnreadable: "ordinary" },
+    "session.notify": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: true, door: "P401", projection: "session_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "session.attach": { resource: "session", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "attach_absent", unreadable: "raise", placementUnreadable: "ordinary" },
+    "scope.decide": { resource: "scope", grants: ["owner", "open"], fleet: [], operator: true, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "ask.decide": { resource: "ask", grants: ["owner", "open"], fleet: [], operator: true, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "ask.answer": { resource: "ask", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "inbox.drain": { resource: "inbox", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "list.read": { resource: "list", grants: ["owner"], fleet: LIST_FLEET, operator: false, door: "I401", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+    "session.list": { resource: "list", grants: ["owner", "j4"], fleet: LIST_FLEET, operator: false, door: "I401", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
+};
+export function visibleOn(face, quals) {
+    const f = FACES[face];
+    if (f.operator && quals.has("operator"))
+        return true;
+    for (const q of f.fleet)
+        if (quals.has(q))
+            return true;
+    for (const q of f.grants)
+        if (quals.has(q))
+            return true;
+    return false;
+}
+const OWNERLESS_ORDINARY = { owner: null, placed: false };
+const OWNERLESS_PLACED = { owner: null, placed: true };
+export function ownerlessCellWithoutRead(face, caller) {
+    return visibleOn(face, qualsOf(caller, OWNERLESS_ORDINARY)) && visibleOn(face, qualsOf(caller, OWNERLESS_PLACED)) ? OWNERLESS_PLACED : undefined;
+}
+export const OWNERLESS_ORDINARY_CELL = OWNERLESS_ORDINARY;
+export function keyAdmission(face, who, cell) {
+    const quals = qualsOf({ subject: who.subject, operator: who.operator, fleet: undefined, traceRead: false, principalRequired: true, multiTenant: true }, cell);
+    const f = FACES[face];
+    if (f.grants.some((q) => quals.has(q)))
+        return "row";
+    return f.operator && quals.has("operator") ? "operator" : undefined;
+}
+export function keyAdmits(face, who, cell) {
+    return keyAdmission(face, who, cell) !== undefined;
+}
+export function listFilterOf(face, caller) {
+    if (fleetOn(face, caller))
+        return { fleetWide: true, gateOwner: null, includeUnowned: false };
+    const gateOwner = caller.subject || null;
+    if (gateOwner === null)
+        return { fleetWide: false, gateOwner: null, includeUnowned: false };
+    const unownedQuals = qualsOf(caller, OWNERLESS_ORDINARY);
+    const f = FACES[face];
+    return { fleetWide: false, gateOwner, includeUnowned: f.grants.some((q) => q !== "owner" && unownedQuals.has(q)) };
+}
+export function fleetOn(face, caller) {
+    const f = FACES[face];
+    return f.fleet.some((q) => (q === "trace_read" ? caller.traceRead : caller.fleet === q));
+}
+//# sourceMappingURL=owner-faces.js.map

package/dist/parked-decide.d.ts

@@ -11,7 +11,7 @@
 import type { HostDecision } from "./host-decision.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 BackgroundAgentRecord, type BackgroundAgentStore, type CheckpointStore, type CheckpointToken, type QuestionAnswer, type RunInternals, type TaskRegistry, type ToolExecuteContext, type WorkflowParkDelivery, type WorkflowRun, type WorkflowRunStore } from "@sema-agent/core";
 import type { ParkedReviveSurfaceFactory } from "./parked-revive-surface.js";
 import type { RebuiltInheritedGate } from "./boot/parked-revive-gate.js";
 import { type WorkflowRunParkKey, type WorkflowAgentSessionIndex } from "./orchestration/workflow-agent-session-index.js";
@@ -25,6 +25,14 @@ import type { GateIdentity } from "./checkpoint-identity.js";
  * 不留「无席时照旧两读」的臂)。
  */
 export declare const PARKED_REVIVE_EXECUTION_SEAT_REQUIRED = "the parked-agent revive leg (parkedReviveSurface) needs a session store with an execution placement seat (sessionStorage.executionPlacement) \u2014 after the claim, the root session's occupant is judged only by the write on that seat; every built-in session store carries one (the MySQL-protocol and PostgreSQL stores and the local store, i.e. the session store a StoreBackend hands out; the caching and fork-routing wrappers forward it), and an in-memory test or embedding passes InMemoryExecutionPlacementSeat; refusing to start rather than revive parked agents with nobody judging the root session's occupant after the claim";
+/**
+ * 停驻赎回腿四只拒体(`409 decide.revive_rejected` / `500 decide.revive_failed` / `422 parked_resume.startup_failed` / `409 decide.agent_definition_unavailable`)上 `rollback` 的词 = 引擎回滚口
+ * (core `TaskRegistry.rollbackParkedClaim`)对本次 decide 那一次补滚的处置词,原样上 wire;词表与每词的读法登在自铸登记集 `parkedRollbackWord`
+ * (`satisfies Record<ParkedClaimRollbackDisposition, …>`:引擎加一个词而登记没跟 ⇒ 编译红)与契约 parked 赎回段。
+ * `lost` = 补滚时行上已不是这只认领;**是谁拿走的本服务分不出**:驱动之前只能是别的写者,驱动之后(起跑即败)可能是引擎自己先回滚 / 消费了它,
+ * 也可能是引擎接上子代之前别的写者已拿走(引擎那一臂不回滚,回执里也不带它自己的处置)—— 窗口证不出成因,所以不按窗口改写词(要分,需引擎在回执上交它的处置)。
+ */
+export type ParkedClaimRollbackDisposition = Awaited<ReturnType<TaskRegistry["rollbackParkedClaim"]>>;
 export interface ParkedAgentMatch {
     handle: string;
     row: BackgroundAgentRecord;
@@ -155,9 +163,6 @@ export interface ParkedDecideDeps {
      *  checkpointStore 同实例,[ref] 设计稿 §4),以及与它同出一张列表的继承座 `mountsCallerTool`(一层行才有;属主与全部判据
      *  在 `parked-revive-surface.ts`)。修前是 boot 期的一只裸 Agent 工具、从不交座 ⇒ 7.32.0 起停在继承工具上的 allow 恒 422。 */
     reviveSurface: ParkedReviveSurfaceFactory;
-    /** revive args 的 `subagent_type` 成员性判定集([ref] Q1 修正:非 roster 成员必须省略,否则
-     *  unknown subagent_type 拒;字面比对 general-purpose 在 roster 撞名时会错省)。缺省空集=恒省略。 */
-    knownAgentTypes?: ReadonlySet<string>;
     /** [ref]/[ref] 跨进程父约束重供席:按部署配置**重建的同语义**父策略链工厂(host 任务的 toolPolicy
      *  解析槽一条,单层链;exempt 探针锚= row.rootSessionId,与 remember grant 锚同键)。core 1.396 起
      *  `parkedResume.inheritedGate` 席位把它透传进 resume 的官方重供通道——不供 = 重启后带
@@ -302,6 +307,11 @@ export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): Work
 /**
  * [ref] 车CM —— **第三条车道的计划**(纯函数;驱动本身归 resume 家族的那条腿,见下方「为什么不自建驱动」)。
  *
+ * 🔴 **这份计划先交给持有这张卡的那条活 run**({@link deliverToHoldingRun}):run 仍在本进程里跑 ⇒ 决定由引擎在原 run 里用上,
+ * 下面的续跑车道一步都不走;只有那条 run 已不能收决定(本进程里没有它在跑 / 它已挂起收场)时,计划才按下文落到续跑车道。
+ * 判决 / 宿主两只拒臂在交给活 run 之前判:`remember` 拒的理由两条去路同真(两者的 200 都证不出引擎已提交);
+ * 本服务只经会话的 Workflow 工具起 workflow,活在本进程里的 run 恒有发起会话 ⇒ 宿主拒臂只拦得住续跑车道上那种 run。
+ *
  * ## 这条车道为什么长这样(亲读 core 实现后的结论,不是从类型面推的)
  * 任务书原案是「server 直接 `startWorkflow({resumeFromRunId, parkedResume})`」。亲读安装的 core
  * `dist/orchestration/run-workflow-tool.js` 与 `dist/core/runner/prepare-caps-and-workflow.js` 证伪了它:
@@ -319,7 +329,7 @@ export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): Work
  * 开跑前经那一只读者把它放进 internals)。
  *
  * ## 诚实边界(登记,不假装没有)
- * · **模型中介**:决定送达宿主之后,真正的赎回发生在宿主再调一次 `Workflow({resumeFromRunId})` 时。
+ * · **模型中介**(只在续跑车道上):决定送达宿主之后,真正的赎回发生在宿主再调一次 `Workflow({resumeFromRunId})` 时。
  *   core 的 park 回执逐字告诉模型这件事,但它不是一条确定性的机器腿。宿主没照做 ⇒ 卡仍 pending、决定行还在:
  *   宿主会话的下一跑(谁起的都算)照带它,同一个决定重投再触发一次投递(**不会**静默吃掉批准)。
  * · **`inheritedGate` 不供**:那是「跨进程重供 checkpoint 的父约束」的席位,而 wa* 行不带父约束链;
@@ -377,6 +387,58 @@ export declare function denyWorkflowParkForked(origin: Extract<ParkOrigin, {
 export declare function planWorkflowParkedDecide(origin: Extract<ParkOrigin, {
     kind: "workflow";
 }>, req: ParkedDecideRequest): WorkflowParkedDecidePlan;
+/**
+ * **持有这张卡的那条 run 还在本进程里跑吗 —— 在跑就把决定交给它**(workflow 停驻卡的唯一一种去法的前半;后半是续跑车道)。
+ *
+ * ## 律(一条)
+ * 一张 workflow 子代停驻卡的决定先交给持有它的那条 run:引擎根导出 `redeemWorkflowParks(runId, run.scope, [条目])` 是「这张停驻怎么处置」的唯一读法
+ * (它查本进程的活 run 表;别的进程里的 run 它答 `not_active`)。引擎答 run 已不能收(`not_active`;`suspending` 且它的 `ended` 已落定)⇒
+ * 交回 `resume_lane`,调用方照计划走续跑车道;其余每一个答词都在这里落成这次决断的应答,续跑车道一步不走 ——
+ * 同一张卡在同一时刻只有一条去路(活 run 上把决定交给模型去调 `Workflow({resumeFromRunId})` 那一读法退役:引擎的 fork 守卫拒它)。
+ *
+ * ## 条目
+ * 决定恒带结局(`{ token, outcome }`)。**带续跑重述键时送引擎的确认动词**(`{ token }`:确认从不授权驱动,卡仍 pending 时引擎答 `kept_parked`、
+ * 停驻原样留下)—— 重述键只盖得到续跑车道的重建输入,活 run 上的子代带着它停驻时的表继续,所以活 run 在 ⇒ 400 拒(与后台子代同一个码);
+ * run 不在 ⇒ 续跑车道照带重述键。「活不活」只问引擎这一处,不读第二只判官。确认不是无副作用的探针:卡恰在此刻已不待决 ⇒ 引擎把那一调结算成失败(`settled`,
+ * 与任何决定撞上同一形同一个结局)⇒ 答 409 `decide.gate_moved`。
+ *
+ * ## 答词 → 应答(闭集,`switch` 穷尽;引擎加词 ⇒ 编译红)
+ *  · `driving`        —— 驱动起步 ⇒ 200 {@link parkedChildResumedReceipt}(**无**结清证据:resolve CAS 在驱动里才发生,本回执证不出提交);回执记进
+ *                        {@link LIVE_REDEEM_RECEIPTS}(寿命 = 这条 run 在本进程里活着),供同一决定重点一次时回放;
+ *  · `already_taken`  —— 这条 run 先前已收下这张卡的一个决定(驱动可能还在等并发槽,卡此刻仍 pending)⇒ 簿里同一决定(指纹相等)⇒ 原样回放首张回执;
+ *                        否则(另一个决定)⇒ 409 `decide.claim_lost`(与后台子代并发决断同码);
+ *  · `settled`        —— 卡在本次决断之下已离开 pending(到期 / 别处结清),这个决定没被用上(那一调以 `workflow.park_not_pending` 失败)⇒
+ *                        409 `decide.gate_moved`(后台子代对同一事实的既有答;答 200 = 把「卡已到期」说成「你的批准已受理」);
+ *  · `not_parked_here`—— 这条 run 此刻不在这张卡上等(正在收场 / 一个并发决断正拿着它)⇒ 409 `decide.gate_moved`;
+ *  · `unreadable`     —— checkpoint 店的字此刻读不出,停驻原样留下 ⇒ 503 `decide.store_unreachable`(重试);
+ *  · `kept_parked`    —— 只在送的是确认时可达 ⇒ 400 `decide.parked_restatement_unsupported`;送的是决定时引擎不会答它 ⇒ 抛(500);
+ *  · `not_armed`      —— run 没有 checkpoint 座就不可能停驻出这张卡 ⇒ 抛(500,引擎不变量破;不猜一条去路)。
+ */
+export type WorkflowLiveDelivery = {
+    readonly kind: "answered";
+    readonly answer: ParkedDecideResult;
+} | {
+    readonly kind: "resume_lane";
+};
+/** 交给活 run 的那一次决定(计划已过两只拒臂;`fingerprint` = 决定行的同一只同一性判据 `parkDecisionFingerprint`,含重述键)。 */
+export interface WorkflowLiveDecision {
+    readonly token: CheckpointToken;
+    readonly outcome: WorkflowParkOutcome;
+    readonly decision: "approve" | "deny";
+    readonly fingerprint: string;
+    readonly restated: boolean;
+}
+/** 一条活 run 的身份 + 它在本进程里收场的那一刻(读法 = 引擎的观察通道走完;run 不在本进程里跑 ⇒ 立即落定)。 */
+export interface HoldingRun {
+    readonly id: string;
+    readonly ended: () => Promise<void>;
+}
+/** 把决定交给持有这张卡的活 run(律见 {@link WorkflowLiveDelivery})。 */
+export declare function deliverToHoldingRun(origin: Extract<ParkOrigin, {
+    kind: "workflow";
+}>, d: WorkflowLiveDecision): Promise<WorkflowLiveDelivery>;
+/** 引擎的答 → 这次决断的应答(纯读法 + 回执簿;`suspending` 等它的 `ended` 落定)。导出给答词表的钉。 */
+export declare function answerOfParkDelivery(delivery: WorkflowParkDelivery, run: HoldingRun, d: WorkflowLiveDecision): Promise<WorkflowLiveDelivery>;
 /**
  * `/decide` parked 赎回腿([ref] 件3d server 半场;[ref]/[ref]/[ref] core 裁定形)。
  *

package/dist/parked-decide.js

@@ -1,3 +1,4 @@
+import { FORK_SUBAGENT_TYPE, redeemWorkflowParks, subscribeWorkflow } from "@sema-agent/core";
 import { readClosedWordSeat } from "./approval-card.js";
 import { routeWorkflowPark } from "./orchestration/workflow-agent-session-index.js";
 import { recordFailOpen } from "./observability/fail-open.js";
@@ -6,7 +7,7 @@ import { backgroundScopesForCheckpointScope, decodeCheckpointScope, ownerOfCheck
 import { ASK_USER_QUESTION_TOOL_NAME, isEngineQuestionRow } from "./approval-content-kind.js";
 import { refusalBody, resumeRefusalFacts } from "./http/refusal-body.js";
 import { backgroundAgentNameOf } from "./background-agent-name.js";
-import { buildSettlementEvidence } from "./gate-settlement.js";
+import { buildSettlementEvidence, NO_SETTLEMENT_EVIDENCE } from "./gate-settlement.js";
 import { commitExecutionContext } from "./http/execution-context.js";
 import { EXECUTION_PLACEMENT_SEAT_CARRIERS } from "./execution-placement.js";
 export const PARKED_REVIVE_EXECUTION_SEAT_REQUIRED = `the parked-agent revive leg (parkedReviveSurface) needs a session store with an execution placement seat (sessionStorage.executionPlacement) — after the claim, the root session's occupant is judged only by the write on that seat; ${EXECUTION_PLACEMENT_SEAT_CARRIERS}; refusing to start rather than revive parked agents with nobody judging the root session's occupant after the claim`;
@@ -122,13 +123,32 @@ function refusesWhereUnrecordable(remember) {
         }
     }
 }
-function mintReviveArgs(row, knownAgentTypes) {
+function reviveDefinitionOf(row, reviveTool) {
+    if (row.agentType === undefined)
+        return { kind: "revivable", agentType: undefined };
+    const revivable = (reviveTool.ruleFace?.nameValues ?? []).filter((t) => t !== FORK_SUBAGENT_TYPE);
+    return revivable.includes(row.agentType) ? { kind: "revivable", agentType: row.agentType } : { kind: "unavailable" };
+}
+function denyAgentDefinitionUnavailable(taskId, rollback) {
+    return {
+        status: 409,
+        body: refusalBody({
+            errorCode: "decide.agent_definition_unavailable",
+            message: "this approval belongs to a background agent that was started from an agent definition the revive path cannot supply again: a definition sent on the request that started the run is not kept with the approval card, and a deployment definition may have been withdrawn since the agent stopped. Reviving the agent without it would resume it as a general-purpose agent, with a wider tool surface than its definition allowed, so the decision is NOT applied and nothing was resumed. The rollback field says what became of the approval: rolled_back means the card is still pending (it ends by expiry, or when the session's background agents are retired), failed means it had already ended, retry and lost mean read the pending list for its fate. Start the work from a built-in or deployment definition to get an agent whose approval can be decided here",
+            facts: {
+                taskId,
+                rollback,
+            },
+        }),
+    };
+}
+function mintReviveArgs(row, agentType) {
     return {
         prompt: row.description ?? "resume parked agent",
         run_in_background: true,
         name: backgroundAgentNameOf(row),
         description: row.description ?? "revived agent",
-        ...(row.agentType !== undefined && knownAgentTypes.has(row.agentType) ? { subagent_type: row.agentType } : {}),
+        ...(agentType !== undefined ? { subagent_type: agentType } : {}),
     };
 }
 export function buildParkedResumeOutcome(req) {
@@ -217,6 +237,103 @@ export function planWorkflowParkedDecide(origin, req) {
         },
     };
 }
+function parkedChildResumedReceipt(taskId, decision, evidence) {
+    return { status: 200, body: { taskId, status: "resuming", decision, ...evidence } };
+}
+const LIVE_REDEEM_RECEIPTS = new Map();
+async function runChannelEnded(runId, scope) {
+    const channel = subscribeWorkflow(runId, scope)[Symbol.asyncIterator]();
+    while (!(await channel.next()).done) {
+    }
+}
+function holdLiveReceipt(run, token, fingerprint, answer) {
+    let byToken = LIVE_REDEEM_RECEIPTS.get(run.id);
+    if (byToken === undefined) {
+        byToken = new Map();
+        LIVE_REDEEM_RECEIPTS.set(run.id, byToken);
+        const book = byToken;
+        const drop = () => {
+            if (LIVE_REDEEM_RECEIPTS.get(run.id) === book)
+                LIVE_REDEEM_RECEIPTS.delete(run.id);
+        };
+        void run.ended().then(drop, (err) => {
+            recordFailOpen("server.workflow-live-receipt.channel-unreadable", `runId=${run.id} err=${err instanceof Error ? err.message : String(err)}`);
+            drop();
+        });
+    }
+    byToken.set(token, { fingerprint, answer });
+}
+const copyOf = (r) => ({ status: r.status, body: { ...r.body } });
+export async function deliverToHoldingRun(origin, d) {
+    const entry = d.restated ? { token: d.token } : { token: d.token, outcome: d.outcome };
+    const scope = origin.run.scope;
+    return answerOfParkDelivery(await redeemWorkflowParks(origin.runId, scope, [entry]), { id: origin.runId, ended: () => runChannelEnded(origin.runId, scope) }, d);
+}
+export async function answerOfParkDelivery(delivery, run, d) {
+    const runId = run.id;
+    switch (delivery.kind) {
+        case "live":
+            return { kind: "answered", answer: answerOfLiveResult(delivery.results[0], run, d) };
+        case "suspending":
+            await delivery.ended;
+            return { kind: "resume_lane" };
+        case "not_active":
+            return { kind: "resume_lane" };
+        case "not_armed":
+            throw new Error(`workflow run ${runId} answered not_armed to a decision for a card it holds — a run without a checkpoint seat cannot have parked one; refusing to guess where the decision goes`);
+        default: {
+            const unhandled = delivery;
+            throw new Error(`unhandled workflow park delivery: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+function answerOfLiveResult(word, run, d) {
+    const runId = run.id;
+    if (word === undefined)
+        throw new Error(`workflow run ${runId} answered a live delivery without a result for the one decision it was handed`);
+    switch (word) {
+        case "driving": {
+            if (d.restated)
+                throw new Error(`workflow run ${runId} drove a parked call on an acknowledgement — an acknowledgement never authorizes a drive`);
+            const answer = parkedChildResumedReceipt(runId, d.decision, NO_SETTLEMENT_EVIDENCE);
+            holdLiveReceipt(run, d.token, d.fingerprint, answer);
+            return copyOf(answer);
+        }
+        case "already_taken": {
+            const held = LIVE_REDEEM_RECEIPTS.get(runId)?.get(d.token);
+            if (held !== undefined && held.fingerprint === d.fingerprint)
+                return copyOf(held.answer);
+            return {
+                status: 409,
+                body: refusalBody({
+                    errorCode: "decide.claim_lost",
+                    message: "another decision for this approval was already handed to the run that is waiting on it and is being applied — re-check the pending list",
+                    facts: { runId },
+                }),
+            };
+        }
+        case "settled":
+        case "not_parked_here":
+            return { status: 409, body: refusalBody({ errorCode: "decide.gate_moved", message: "the approval gate moved under this decide (re-parked or already settled) — re-check the pending list", facts: { runId } }) };
+        case "unreadable":
+            return { status: 503, body: refusalBody({ errorCode: "decide.store_unreachable", message: "the state of this approval could not be read just now, so the run waiting on it kept waiting and nothing was decided — retry", facts: { runId } }) };
+        case "kept_parked":
+            if (!d.restated)
+                throw new Error(`workflow run ${runId} kept a parked call that was handed a decision — the engine keeps a park only on an acknowledgement`);
+            return {
+                status: 400,
+                body: refusalBody({
+                    errorCode: "decide.parked_restatement_unsupported",
+                    message: "mcpServers / a2aPeers cannot be applied: the run this approval belongs to is still running, and its waiting step continues with the MCP / A2A tables the run already has — re-issue the decide without them to continue it that way",
+                    facts: { runId },
+                }),
+            };
+        default: {
+            const unhandled = word;
+            throw new Error(`unhandled workflow park delivery result: ${String(unhandled)}`);
+        }
+    }
+}
 function sessionGone(taskId) {
     return {
         status: 409,
@@ -322,6 +439,10 @@ export async function decideParkedAgent(deps, req, match) {
         await rollback("revive_surface_threw");
         throw e;
     }
+    const definition = reviveDefinitionOf(row, surface.reviveTool);
+    if (definition.kind === "unavailable") {
+        return denyAgentDefinitionUnavailable(match.handle, await rollback("agent_definition_unavailable"));
+    }
     if (req.remember !== undefined && rememberRoot !== undefined) {
         try {
             await req.remember.anchor(rememberRoot);
@@ -334,6 +455,7 @@ export async function decideParkedAgent(deps, req, match) {
     const ctx = {
         toolCallId: `drv-${ticket.claimId}`,
         ...(surface.mountsCallerTool !== undefined ? { mountsCallerTool: surface.mountsCallerTool } : {}),
+        ...(surface.onBackgroundChildEvent !== undefined ? { onBackgroundChildEvent: surface.onBackgroundChildEvent } : {}),
         ...(deps.approverSeatFor !== undefined && seatRoot !== undefined
             ? { onAsk: deps.approverSeatFor({ owner: ownerOfCheckpointScope(req.scope), taskId: match.handle, sessionId: seatRoot, executionLane: execution.lane }) }
             : {}),
@@ -350,7 +472,7 @@ export async function decideParkedAgent(deps, req, match) {
     defaultSubagentTailBus.forgetHandle(match.handle);
     let receipt;
     try {
-        receipt = await surface.reviveTool.execute(mintReviveArgs(row, deps.knownAgentTypes ?? new Set()), ctx);
+        receipt = await surface.reviveTool.execute(mintReviveArgs(row, definition.agentType), ctx);
     }
     catch (e) {
         const disp = await rollback("execute_threw");
@@ -399,6 +521,6 @@ export async function decideParkedAgent(deps, req, match) {
             }),
         };
     }
-    return { status: 200, body: { taskId: match.handle, status: "resuming", decision: req.decision, ...buildSettlementEvidence({ at: "agent_revived", gate: req.selectedGate }) } };
+    return parkedChildResumedReceipt(match.handle, req.decision, buildSettlementEvidence({ at: "agent_revived", gate: req.selectedGate }));
 }
 //# sourceMappingURL=parked-decide.js.map

package/dist/parked-revive-surface.d.ts

@@ -30,14 +30,20 @@
  * 一层行)以 `{ delegationRoot }` 重解 —— 只喂 relay,不挂任何会话级设施、不带 principal,交座判据(上面三条)一个字不动。行上没有根 ⇒ boot 期那只裸 Agent(没有根可交 ⇒ 不接 relay)。
  * 复活的子代再要审批时的停驻挂点(`plugins/session-store.ts`)不读见证:引擎交它那一行自己的属主,挂点只比对(core 7.62.0 [ref];根见证在挂点的读法随 [ref] P-5 退役)。
  */
-import { type BackgroundAgentRecord, type ToolSpec } from "@sema-agent/core";
+import { type BackgroundAgentRecord, type ToolExecuteContext, type ToolSpec } from "@sema-agent/core";
 import type { Scenario } from "./capabilities/scenarios.js";
 import type { SessionFace } from "./session-incarnation.js";
-/** 一次赎回用的面:驱动的 Agent 工具(它的完成 relay 绑着行上的根)+ (交座时)与它同出一张列表的继承座。 */
+/** 一次赎回用的面:驱动的 Agent 工具(它的完成 relay 绑着行上的根)+ (交座时)与它同出一张列表的继承座 + 进程级后台子代观察者。 */
 export interface ParkedReviveSurface {
     readonly reviveTool: ToolSpec;
     /** 缺席 = 不交座(core fail-closed:复活的子代不继承任何场景层工具)。 */
     readonly mountsCallerTool?: (tool: ToolSpec) => boolean;
+    /**
+     * 进程级后台子代观察者 —— 与 `RunnerDeps.onBackgroundChildEvent` **同一只实例**(fleet 的后台子代发布器,行的 spawn / tick / 终态帧与 `bg_notification` 只经它)。
+     * 引擎经 Runner 起跑的工具调用由 Runner 把它填进 `ToolExecuteContext`;赎回腿自己驱动 `execute`、ctx 由赎回腿铸 ⇒ 由本面带进去,复活的那一轮与首轮
+     * 进同一只发布器(发布器按实例持每只子代的溯源,换一只实例 = 终态找不到 spawn 时记下的行)。缺席 = 这条部署没有观察者(Runner 那一侧同样缺席)。
+     */
+    readonly onBackgroundChildEvent?: NonNullable<ToolExecuteContext["onBackgroundChildEvent"]>;
 }
 /**
  * 按行解析赎回面的入参身份:`principal` = 权威 principal(取 checkpoint 的 scope 列,不取行上有损的 `row.scope`);`rootOccupant` = 写口放行的那一位
@@ -50,8 +56,12 @@ export interface ParkedReviveSurfaceIdentity {
 /** 按行解析赎回面。 */
 export type ParkedReviveSurfaceFactory = (row: BackgroundAgentRecord, identity: ParkedReviveSurfaceIdentity) => ParkedReviveSurface;
 /**
- * 赎回面工厂。入参 = **内建** default 场景工厂(stage-07 在 center overlay 盖名之前取的那一只;赎回要的是与 spawn 同源的生产装配)。
+ * 赎回面工厂。入参 = **内建** default 场景工厂(stage-07 在 center overlay 盖名之前取的那一只;赎回要的是与 spawn 同源的生产装配)+ 进程级后台子代观察者
+ * (`RunnerDeps.onBackgroundChildEvent` 那一只,见 {@link ParkedReviveSurface.onBackgroundChildEvent};每一行的面都带它,与交不交座无关)。键必填、值可为 `undefined`:
+ * 调用方必须表态这条部署有没有观察者 —— 修前正是「没人交」静默成了复活轮零帧。
  * 内建 bundle 里没有 Agent 工具 ⇒ `undefined`(park 本就不可达,赎回腿不接线)。
  */
-export declare function createParkedReviveSurface(defaultScenario: Scenario): ParkedReviveSurfaceFactory | undefined;
+export declare function createParkedReviveSurface(defaultScenario: Scenario, observer: {
+    readonly onBackgroundChildEvent: ParkedReviveSurface["onBackgroundChildEvent"] | undefined;
+}): ParkedReviveSurfaceFactory | undefined;
 //# sourceMappingURL=parked-revive-surface.d.ts.map

package/dist/parked-revive-surface.js

@@ -1,20 +1,21 @@
 import { DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
 const agentOf = (tools) => tools.find((t) => t.name === DEFAULT_SUBAGENT_TOOL_NAME);
-export function createParkedReviveSurface(defaultScenario) {
+export function createParkedReviveSurface(defaultScenario, observer) {
     const bootTool = agentOf(defaultScenario({}).tools);
     if (bootTool === undefined)
         return undefined;
+    const observed = observer.onBackgroundChildEvent !== undefined ? { onBackgroundChildEvent: observer.onBackgroundChildEvent } : {};
     return (row, identity) => {
         const root = row.rootSessionId;
         if (root === undefined)
-            return { reviveTool: bootTool };
+            return { reviveTool: bootTool, ...observed };
         const seated = holdsSeat(row.parentSessionId === root, identity);
         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)
-            return { reviveTool: bootTool };
-        return seated ? { reviveTool, mountsCallerTool: (t) => tools.includes(t) } : { reviveTool };
+            return { reviveTool: bootTool, ...observed };
+        return seated ? { reviveTool, mountsCallerTool: (t) => tools.includes(t), ...observed } : { reviveTool, ...observed };
     };
 }
 function holdsSeat(oneLevel, identity) {

package/dist/peer-directory.d.ts

@@ -24,18 +24,16 @@
  *  · **peer 可寻址性过滤**:语法外 / 非小写规范形 / 与别条会话折到同一只箱的 id 都不入目录(下面那道
  *    单射门),那条路由照列;
  *  · **墓碑**:目录会多出「正在删除中」的 `deleted` 记录,那条路由不列;
- *  · **席位差**:那条路由还有 `runStore.listSessions` 的 legacy 兜底,本席刻意不并(见装配点的注)。
+ *  · **席位差**:无。那条路由与本席读同一只会话店 lister(run 店不列会话,路由没有兜底)。
  * 机器钉因此只钉「同一 principal、无 q、无分页、量在 cap 内」那一格的集合相等(它是那条承重条款的
  * 可执行投影),别把它读成两面恒等。
  *
- * ⚠️ 与设计稿的第二处收紧(亲读实现推翻稿面):稿里把谓词写成 `principal-gate.ts runOwnerReadable`。
- * 亲读两只函数后不成立 —— `runOwnerReadable(p, owner, cfg)` 对 `owner === null` **无条件**放行
+ * ⚠️ 与设计稿的第二处收紧(亲读实现推翻稿面):稿里把谓词写成 `principal-gate.ts qualsOf`。
+ * 亲读两只函数后不成立 —— `qualsOf(p, owner, cfg)` 对 `owner === null` **无条件**放行
  * (`principal-gate.ts:136-137`,函数体第一行),而**列表面**的第三条件由 store 的
- * `owner = ? OR owner IS NULL` 承载,开关是 `legacyUnownedAmnestyOpen(deployment, gateOwner)`
- * (`security.ts:119`,它的头注逐字:
- * 「单独存在的唯一理由是**列表面**……单实体读/写点一律用三条件齐的 `legacyUnownedSessionOk`」)。
- * 拿 `runOwnerReadable` 当列表谓词会让目录比 `GET /v1/sessions` **多列出**别人的无主会话 —— 正好违反
- * 稿子自己那条对拍。所以这里用的是列表面那一只:`legacyUnownedAmnestyOpen` + 同一个 lister。
+ * `owner = ? OR owner IS NULL` 承载,开关是面表列表面 `session.list` 的 `j4` 格(`owner-faces.ts` 的 `listFilterOf` 派生 `includeUnowned`)。
+ * 拿单行读面的放行集当列表谓词会让目录比 `GET /v1/sessions` **多列出**别人的无主会话 —— 正好违反
+ * 稿子自己那条对拍。所以这里用的是列表面那一行:`listFilterOf("session.list", …)` + 同一个 lister(与 `GET /v1/sessions` 同一行面表)。
  *
  * ## scope 轴
  *

package/dist/peer-directory.js

@@ -1,6 +1,7 @@
 import { PEER_SESSION_RECORD_SCHEMA_VERSION, isPeerSessionId, normalizePeerName, peerSessionBoxHandle, SESSION_BOX_PREFIX, } from "@sema-agent/core";
 import { sessionTempoOfRunStatus } from "./plugins/store-contracts.js";
-import { legacyUnownedAmnestyOpen } from "./security.js";
+import { claimCallerOf } from "./security.js";
+import { listFilterOf, recoveredSubject } from "./owner-faces.js";
 export const PEER_DIRECTORY_CAP = 200;
 function displayNameOf(candidate, sessionId) {
     return candidate != null && normalizePeerName(candidate) !== "" ? candidate : `session-${sessionId.slice(0, 8)}`;
@@ -13,7 +14,7 @@ export function createPeerDirectory(ctx) {
     return {
         listPeerSessions: async (access) => {
             const scope = access.scope;
-            const includeUnowned = legacyUnownedAmnestyOpen({ requirePrincipal }, scope);
+            const { includeUnowned } = listFilterOf("session.list", claimCallerOf(recoveredSubject(scope), { requirePrincipal }));
             const answers = await lister({ owner: scope, ...(includeUnowned ? { includeUnowned: true } : {}), limit: PEER_DIRECTORY_CAP + 1 });
             const rows = answers.map((a) => a.row);
             const occupantOf = new Map(answers.map((a) => [a.row.sessionId, a.occupant.incarnation ?? null]));

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

@@ -1,14 +1,59 @@
-import type { RuleBehavior } from "@sema-agent/core";
 /**
- * 一张审批卡的**一键整工具同意**能落在这只工具名上吗 —— 仅当没有任何规则词替这个名字说话:它自己没有规则文法(`ruleToolGrammarOf` 答 undefined),
- * 也不在 shell 面上(`COARSE_SHELL_TOOLS`:`Bash` 与 `Monitor`,它们的命令按 `Bash(…)` 规则判)。引擎为卡铸整工具候选恰在这个条件下(没有规则文法、
- * 也不回答任何规则词的调用);一张 shell 卡上的一键整工具同意 = 对每一个程序的常驻许可,路径 / 名字 / 主机工具的卡各有自己的那一形。
+ * [ref] + [ref](core `e298c9e0`,随 7.2.x 提货生效;[ref])—— 规则车道**闭词表的单一属主**。
+ *
+ * 为什么要一个模块而不是各处各写一份 `z.enum([...])`:同一张词表此前在四处各抄一份字面量
+ * (`approval-card.ts` 两腿的 offer schema、`http/routes/rules.ts` 的直通票口行形、
+ * `plugins/permission-rule-store-sql.ts` 的 `rules_json` 读/写形),core 给 `PersistedRuleMatch` 加两员
+ * (wildcard / subpath)、给 `PersistedRuleTool` 加 Read 时,四份抄件**没有一份**会编译红 —— zod 的 enum
+ * 只是运行期的一个 Set,静默把一次上游语义扩张翻成一整类合法行的拒收([ref] 词表纪律说的正是这形:
+ * 未知词必须是**编译**错,不是运行期一个安静的 false)。
+ *
+ * (7.53.x 及以前:每张表在这里转录一份、各带一条双向全等钉;7.54.0 起值本身由 core 导出,见下一段。)
+ *
+ * ⚠️ 转录**不是**判据:一个词在表里只说「这是 core 定义的一员」,不说「本仓每条腿都接受它」。逐腿的收窄
+ * (例如卡编辑臂对 `subpath` 的拒)写在那条腿自己的穷举 `switch` 里,并各带理由。
  *
- * 读者:卡素材铸点的派生事实一致性(`tool-approval.ts`:整工具候选的工具过不了 ⇒ 丢整只候选,卡上不渲一格按不动的「不再询问」)。
- * 卡编辑面不读它:引擎的编辑门对任何整工具规则一律拒(编辑只改命令规则),编辑面的形闭集(`rules-consent.ts`)跟着恒拒 —— 那张闭集里「shell 卡上一键整只 shell」
- * 的理由就是本谓词的理由,不另写一份判据。方向 fail-closed:答不出 ⇒ 不是。
+ * 🔴 **core 7.54.0([ref] 阶段一 K1 / K1b)起,词表的值本身是 core 的包根导出**(`PERSISTED_RULE_MATCHES` / `RULE_OFFER_BATCH_MEMBER_KINDS` /
+ * `UNCOVERED_SEGMENT_REASONS` / `EDITED_RULE_BREADTH_WARNING_CODES` / `RULE_APPROVAL_RECORD_SCHEMA`,以及 `RULE_APPROVAL_KINDS` / `RULE_APPROVAL_STATES` /
+ * `IMPORTED_SETTINGS_LAYERS` / `RULE_ADD_ORIGINS`)—— 本模块此前的五份转录(各带一条 `Exact<>` 全等钉)随之退役,各消费点直接
+ * import core 的值(一个词一处拼写,在引擎里)。本模块只留**不是词表**的那几件:卡形(工具的卡形与匹配词的逐员表态)、直接写口的逐员表态、撤销后的存活词。
+ *
+ * 持久规则行的工具位**没有**本仓的谓词:「一条持久规则能点名哪只工具」由引擎的校验器从规则文本重投影答(两只店的读写腿、直通票口、直写口都经它);
+ * 整工具形(`match: "tool"`,`command: ""`)对任何引擎认得的工具名成立。此前这里有一只「工具有没有规则文法」的谓词,
+ * 引擎把裸工具名读成整工具规则之后它与校验器分家(无文法工具的整工具行写不进 SQL 店、导不进直通票口)—— 已退役。
  */
-export declare function cardTakesWholeToolConsent(tool: string): boolean;
+import { ruleToolGrammarOf } from "@sema-agent/core";
+import type { RuleBehavior } from "@sema-agent/core";
+/**
+ * 一张审批卡的**卡形** —— 卡上那格「不再询问」说的是哪一种规则。词与定义取自 core 的卡形(`CardRuleForm`,offer 工厂与同意入口共读的那一答):
+ * 命令规则词(`Bash`)的卡铸命令规则;名字文法 / 主机文法工具的卡铸**那一条精确值规则**(`Skill(<名>)` / `WebFetch(domain:<主机>)`);
+ * 没有任何规则词替它说话的工具的卡铸整工具规则(`tool`);其余 —— 路径工具(不铸路径候选)、shell 面上命令规则词的兄弟(`Monitor`:它的命令按 `Bash(…)` 规则判,
+ * 一张 shell 卡上的一键整工具同意 = 对每一个程序的常驻许可)—— 没有卡形。型从 core 的文法词派生(路径文法不是卡形,`tool` 是 core 的第四个词),本仓不抄词表。
+ */
+export type CardRuleForm = Exclude<NonNullable<ReturnType<typeof ruleToolGrammarOf>>, "path"> | "tool";
+/**
+ * 这只工具的卡形(core 判官 `cardRuleFormOf` 不在包根导出面上 —— 依赖方向门禁深路径 —— 本函数按它的同一份定义读包根导出的 `ruleToolGrammarOf`)。
+ * 读者:卡素材铸点的派生事实一致性(`tool-approval.ts`:一只候选的匹配词的卡形 ≠ 这张卡的工具的卡形 ⇒ 丢整只候选,卡上不渲一格按不动的「不再询问」)。
+ * 卡编辑面不读它:引擎的编辑门只改命令规则,编辑面的形闭集(`rules-consent.ts`)对其余各形恒拒。方向 fail-closed:答不出 ⇒ 没有卡形。
+ */
+export declare function cardRuleFormOf(tool: string): CardRuleForm | undefined;
+/**
+ * 每个持久规则匹配词属于哪一种卡形 —— `undefined` = 引擎从不为一张卡铸这一形(名字前缀 / 子域:名字 / 主机工具的卡只铸那一条精确值规则;路径两形:路径工具的卡不铸候选)。
+ * `Record` 穷举:core 给 `PersistedRuleMatch` 加员时这里编译红,新词由人表态([ref] 词表纪律);表态成 `undefined` 是恒丢,不会悄悄放宽。
+ */
+export declare const CARD_RULE_FORM_OF_MATCH: {
+    readonly exact: "command";
+    readonly prefix: "command";
+    readonly wildcard: "command";
+    readonly pattern: "command";
+    readonly tool: "tool";
+    readonly name: "name";
+    readonly host: "domain";
+    readonly name_prefix: undefined;
+    readonly subdomain: undefined;
+    readonly path: undefined;
+    readonly subpath: undefined;
+};
 /**
  * [ref] —— `RuleBehavior` 每一员在**无同意仪式的直接写口**(`POST /v1/rules`)上的逐员表态。
  *