@sema-agent/server 7.150.0 → 7.152.0

package/dist/parked-decide.d.ts

@@ -15,7 +15,7 @@ import { type BackgroundAgentRecord, type BackgroundAgentStore, type CheckpointS
 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";
-import type { WorkflowParkDecisionStore, WorkflowParkOutcome } from "./orchestration/workflow-park-decision.js";
+import type { HolderFenceVerdict, WorkflowParkDecision, WorkflowParkDecisionStore, WorkflowParkOutcome } from "./orchestration/workflow-park-decision.js";
 import { type ApprovalLegOrigin } from "./approval-leg-origin.js";
 import type { SessionFace } from "./session-incarnation.js";
 import { type CardSettlePort } from "./card-settle-stored-scope.js";
@@ -127,16 +127,43 @@ type ParkedResumeEntry = NonNullable<RunInternals["workflowParkedResume"]>[numbe
  * 产物原样摊进那一跑的 `RunInternals`(部署方铸的 TRUSTED internals:不是 `TaskSpec` 字段、不是工具参数 —— 模型永远不能自己决定一次审批)。
  *
  * 产物 = 调用方自己带的那一份(`carried`:`/decide` 的投递跑带着它刚受理、行还没落的那条决定)∪ 这个会话的决定行(律与寿命的属主 =
- * `orchestration/workflow-park-decision.ts` 文件头),同一张卡以 `carried` 为准(它是要取代行上旧决定的那一个)。行这一侧逐条:
- *  · 子代卡此刻**仍 pending** 才供:读回 `null` / 状态不是 `pending` ⇒ 不供(引擎对「记着停驻、卡却已不 pending」的序数,有条目 ⇒ 当确认
- *    结算、没条目 ⇒ 拒续跑 —— 供一条过期条目会把后者改成前者);读卡抛 ⇒ 不供并计 `server.workflow-park-decision.card-unreadable`
- *    (这一读失败不代表引擎随后的那一读也失败;不供的方向是这一跑不带它、行留着给下一跑 —— 绝不把它变成一次确认);
- *  · 投递目标 = 这张卡**当下**的持有者 run(`findParkOrigin`,与 `/decide` 路由同一只判官):持有者判不出唯一一条(分叉 / 证不了 / 卡
- *    已在新 token 下再停)⇒ 不供(引擎只把条目交给 `resumeFromRunId` 恰是持有者的续跑;没有唯一持有者就没有可交付的那一跑)。
+ * `orchestration/workflow-park-decision.ts` 文件头),同一张卡以 `carried` 为准(它是要取代行上旧决定的那一个)。行这一侧逐条经
+ * {@link deliverableEntryOf}(子代卡仍 pending ∧ 当下持有者;引擎只把条目交给 `resumeFromRunId` 恰是持有者的续跑)。
  * 决定店读抛(local 账本闸合上 / SQL 一行坏体)⇒ 与读卡失败同律:这一店当「没有可供的行」,只交回 `carried`,计 `server.workflow-park-decision.store-unreadable`
  * (不跳过坏行照供其余:读不出的那一行可能正是取代了旧决定的那一笔;不拒起跑:不供是安全方向,卡仍 pending、可再决)。决定的写口照旧由店闸住。
  */
 export declare function heldWorkflowParkDecisions(sources: HeldWorkflowParkDecisionSources, hostSessionId: string, carried?: readonly ParkedResumeEntry[]): Promise<Pick<RunInternals, "workflowParkedResume">>;
+/**
+ * 一条决定行此刻的可交付性(闭集):
+ *  · `deliverable`     —— 交给引擎的那一条 + 它的当下持有者 + 子代那张卡此刻的存储行(仍 pending;属主 scope 与子会话 —— 收场送达按它判内部授权);
+ *  · `not_deliverable` —— 卡已不 pending / 读回 `null` / 判不出唯一的当下持有者(分叉 / 证不了 / 卡已在新 token 下再停);
+ *  · `unreadable`      —— 卡或持有者此刻读不出(店抛)。三个读者各按自己的语义处置:起跑读者 = 这一跑不带它;拉取腿 = 下一拍;收场送达 = 重投。
+ */
+export type DeliverableParkDecision = {
+    readonly kind: "deliverable";
+    readonly entry: ParkedResumeEntry;
+    readonly origin: Extract<ParkOrigin, {
+        kind: "workflow";
+    }>;
+    readonly card: {
+        readonly scope: string;
+        readonly sessionId: string;
+    };
+} | {
+    readonly kind: "not_deliverable";
+} | {
+    readonly kind: "unreadable";
+};
+/**
+ * 🔴 **一条决定行此刻可不可交付、交给谁 —— 逐行判的唯一一只**(交付行的三方同读:起跑读者 {@link heldWorkflowParkDecisions}、持有进程的拉取腿、run 收场送达):
+ *  · 子代卡此刻**仍 pending** 才交付:读回 `null` / 状态不是 `pending` ⇒ 不交付(引擎对「记着停驻、卡却已不 pending」的序数,有条目 ⇒ 当确认结算、没条目 ⇒ 拒续跑 ——
+ *    交一条过期条目会把后者改成前者);
+ *  · 投递目标 = 这张卡**当下**的持有者 run(与 `/decide` 路由同一只判官 `routeWorkflowPark`):判不出唯一一条 ⇒ 不交付;
+ *  · 卡或持有者读不出 ⇒ `unreadable`,计 `server.workflow-park-decision.card-unreadable`(这一读失败不代表引擎随后那一读也失败;不交付的方向是这一次不带它、行留着 ——
+ *    绝不把它变成一次确认)。
+ * 不读行上的承运者(`deliveredTaskId`):承运者是谁与「此刻交给谁」无关。
+ */
+export declare function deliverableEntryOf(sources: Required<Pick<HeldWorkflowParkDecisionSources, "checkpointStore" | "workflowAgentSessionIndex" | "workflowRunStore">>, row: WorkflowParkDecision): Promise<DeliverableParkDecision>;
 /**
  * pending checkpoint → parked bg 行匹配。
  *
@@ -223,7 +250,7 @@ export interface ParkedDecideDeps {
  * 「本会话放行」落在**记不住的车道**上怎么答(闭集;两扇门之间唯一允许的差 —— 其余两口同读同答,铸点只有续跑腿一只):
  *  · `refuse` —— `/decide` 体上的 `remember:"session"`:那是一个硬意图键,认领之前 400 点名车道(`decide.workflow_remember_unsupported` /
  *    `decide.parked_remember_unsupported`),去掉它再决即可,零副作用;
- *  · `decide_once` —— 应答口命中停驻行的 `allow_session`:那是卡上的一个选项,主内容是「放行」。照常放行这一次、不落豁免、回执
+ *  · `decide_once` —— 决断口命中停驻行的 `remember:"session"`(7.151.x 及以前是应答口的 `allow_session`):那是卡上的一个选项,主内容是「放行」。照常放行这一次、不落豁免、回执
  *    `rememberApplied:false` —— 与活卡上「记不住的卡点 allow_session」同一答法;不把一次已经成立的批准改成 400(窗到期那一拍的按键今天是成的)。
  * 记不住的车道 = workflow 车道(它的 200 证不出引擎已提交这次决定)、无会话锚的 bg 停驻行(豁免无处可锚)。
  */
@@ -256,7 +283,7 @@ export interface ParkedDecideRequest {
     /** D-1 决断绑定:决断方点名它看到的那一对(必在 —— 续跑腿的判官 `decidedActionOf` 判过才交下来)与决定体的其余两位;
      *  server 绝不重算、绝不从停驻行补,core resume 侧做 fail-closed 等值校验 —— 与 legacy 腿同姿势。 */
     binding: Omit<DecideBinding, "checkpointToken" | "boundCallId" | "boundInputHash"> & DecidedAction;
-    /** 这次决定带着「本会话放行」请求(`/decide` 的 `remember:"session"` / 应答口命中停驻行的 `allow_session`,两口同一只请求;
+    /** 这次决定带着「本会话放行」请求(`/decide` 的 `remember:"session"` / 决断口命中停驻行的 `remember:"session"`,两口同一只请求;
      *  铸点 = 续跑腿 `resumeCheckpoint`)时,续跑腿交下来的**锚点记录器** + 记不住时怎么答({@link ParkedRemember})。 */
     remember?: ParkedRemember;
     /** [ref](core 5.7.0,F6 翻案):AskUserQuestion 的 approve 携操作员答案——原样透传进
@@ -309,10 +336,10 @@ export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): Work
 /**
  * [ref] 车CM —— **第三条车道的计划**(纯函数;驱动本身归 resume 家族的那条腿,见下方「为什么不自建驱动」)。
  *
- * 🔴 **这份计划先交给持有这张卡的那条活 run**({@link deliverToHoldingRun}):run 仍在本进程里跑 ⇒ 决定由引擎在原 run 里用上,
- * 下面的续跑车道一步都不走;只有那条 run 已不能收决定(本进程里没有它在跑 / 它已挂起收场)时,计划才按下文落到续跑车道。
- * 判决 / 宿主两只拒臂在交给活 run 之前判:`remember` 拒的理由两条去路同真(两者的 200 都证不出引擎已提交);
- * 本服务只经会话的 Workflow 工具起 workflow,活在本进程里的 run 恒有发起会话 ⇒ 宿主拒臂只拦得住续跑车道上那种 run。
+ * 🔴 **持有这张卡的 run 仍读作 `running` ⇒ 这份计划先进记录栅栏**(唯一仲裁点;`orchestration/workflow-park-decision.ts` 文件头的律):决定行落在那条 run 的
+ * 记录行锁里,交给引擎由跑那条 run 的进程做({@link answerOfHolderRedeem} / 持有进程的拉取腿 / run 收场送达),下面的续跑车道一步都不走;
+ * 只有记录已不读作 `running` 时,计划才按下文落到续跑车道。判决 / 宿主两只拒臂在进栅栏之前判:`remember` 拒的理由两条去路同真(两者的 200 都证不出引擎已提交);
+ * 本服务只经会话的 Workflow 工具起 workflow,读作 `running` 的 run 恒有发起会话 ⇒ 宿主拒臂只拦得住续跑车道上那种 run。
  *
  * ## 这条车道为什么长这样(亲读 core 实现后的结论,不是从类型面推的)
  * 任务书原案是「server 直接 `startWorkflow({resumeFromRunId, parkedResume})`」。亲读安装的 core
@@ -390,57 +417,81 @@ export declare function planWorkflowParkedDecide(origin: Extract<ParkOrigin, {
     kind: "workflow";
 }>, req: ParkedDecideRequest): WorkflowParkedDecidePlan;
 /**
- * **持有这张卡的那条 run 还在本进程里跑吗 —— 在跑就把决定交给它**(workflow 停驻卡的唯一一种去法的前半;后半是续跑车道)。
+ * 续跑车道交给宿主模型的**指路**(`/decide` 的计划与 run 收场送达同一只;两条交付续跑车道的路读同一份文本)。
+ * 消息是给宿主模型的**指路**,不是能力:决定本身走 internals 的可信通道(模型永远不能自己决定审批)。
  *
- * ## 律(一条)
- * 一张 workflow 子代停驻卡的决定先交给持有它的那条 run:引擎根导出 `redeemWorkflowParks(runId, run.scope, [条目])` 是「这张停驻怎么处置」的唯一读法
- * (它查本进程的活 run 表;别的进程里的 run 它答 `not_active`)。引擎答 run 已不能收(`not_active`;`suspending` 且它的 `ended` 已落定)⇒
- * 交回 `resume_lane`,调用方照计划走续跑车道;其余每一个答词都在这里落成这次决断的应答,续跑车道一步不走 ——
- * 同一张卡在同一时刻只有一条去路(活 run 上把决定交给模型去调 `Workflow({resumeFromRunId})` 那一读法退役:引擎的 fork 守卫拒它)。
+ * 🔴 **本服务唯一的 `trusted: true` 铸点**。文本框架只看文本出自谁,不看按下按钮的是谁:这段话是**服务自己铸的**
+ * (下面三个结构位,没有一个字来自调用方),所以以系统源投递 —— 不论决定者是不是运维(wake 腿 `resumeWake` 原样转交,
+ * 不再从决定者身份推)。调用方的话(HTTP steer / `/wake` 的正文、hook 输出)恒 `trusted: false`;
+ * 结构钉 `test/steer-text-framing.test.ts` 普查全仓只此一处。
  *
- * ## 条目
- * 决定恒带结局(`{ token, outcome }`)。**带续跑重述键时送引擎的确认动词**(`{ token }`:确认从不授权驱动,卡仍 pending 时引擎答 `kept_parked`、
- * 停驻原样留下)—— 重述键只盖得到续跑车道的重建输入,活 run 上的子代带着它停驻时的表继续,所以活 run 在 ⇒ 400 拒(与后台子代同一个码);
- * run 不在 ⇒ 续跑车道照带重述键。「活不活」只问引擎这一处,不读第二只判官。确认不是无副作用的探针:卡恰在此刻已不待决 ⇒ 引擎把那一调结算成失败(`settled`,
- * 与任何决定撞上同一形同一个结局)⇒ 答 409 `decide.gate_moved`。
+ * 🔴 **只含结构位**(7.69.0 合并重扫 c1,安全轴)。core 对 `trusted:true` 的 steer 走 `formatHookFeedback` ⇒ 铸成**带 mark 的**
+ * `<system-reminder>`,而那个 mark 正是 core 教模型「带 mark 的才是引擎权威」的防冒名位。所以进这条
+ * 文本的每一个字都必须是 server/引擎自己能负责的事实:`runId`(引擎铸的 `w*`)、`callKey`
+ * (引擎铸的 `ordinal:specIdentityHash`)、判决词二选一。
+ * 🔴 **[ref] 之后这条纪律不再需要一条「别内插 label」的特判**:出身实体换成了记录上的 `parks[]` 条目,
+ * 而那是一只 **KEYS ONLY** 的对象(`callKey` / `sessionId` / `token` / `originRunId`,core 顶注逐字),
+ * 结构上就没有 LLM 撰写的位可插。人要读 label,读面已经有了(`GET /v1/workflows/:id` 的 agents[].label,
+ * 那条既有投影带脱敏);这里**不**再铸第二份清洗——少一条规则,而不是多一条。
  *
- * ## 答词 → 应答(闭集,`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,引擎不变量破;不猜一条去路)。
+ * 🔴 **为什么点名「同一份脚本源」**([ref] 真跑撞获,亲读 core 后成文):`resumeFromRunId` **不是**
+ * 自足入参 —— 安装的 core `dist/orchestration/run-workflow-tool.js` 在解析完 scriptPath/script/name
+ * 三选一之后就 `structuredError("Must provide script, name, or scriptPath")`(那一臂对带不带
+ * `resumeFromRunId` 一视同仁),它的 schema 描述逐字也是「resume a PRIOR run of the **SAME script**」。
+ * 修前这句话只说 `resumeFromRunId`,照着念的宿主会拿到那条结构化错误,而这条车道**是**这条审批唯一的
+ * 投递腿 ⇒ 决定送到了、兑不出来。文本是两条腿(wake / fresh)共用的那一份,改在这里 = 改在唯一属主上。
  */
-export type WorkflowLiveDelivery = {
-    readonly kind: "answered";
-    readonly answer: ParkedDecideResult;
-} | {
-    readonly kind: "resume_lane";
+export declare function workflowParkGuidance(runId: string, callKey: string, decision: "approve" | "deny"): {
+    text: string;
+    trusted: true;
 };
-/** 交给活 run 的那一次决定(计划已过两只拒臂;`fingerprint` = 决定行的同一只同一性判据 `parkDecisionFingerprint`,含重述键)。 */
-export interface WorkflowLiveDecision {
+/** 交给持有这张卡的那条 run 的一次决定(计划已过两只拒臂)。 */
+export interface WorkflowHolderDecision {
     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>;
+/**
+ * 🔴 **把行上的决定交给引擎的唯一调用点**(`redeemWorkflowParks`,引擎对「这张停驻怎么处置」的唯一读法):两个调用方 —— 记录栅栏立住之后 `/decide` 的本进程快路
+ * ({@link answerOfHolderRedeem})与持有进程的拉取腿({@link holderPullDisposition})。恒送一个**决定**(`{ token, outcome }`):重述键在记录栅栏里判(`restated` 结局),
+ * 不再送引擎的确认动词去探「活不活」。引擎只查本进程:run 不在这里跑 ⇒ `not_active`(决定行已立住,交付归持有进程的拉取或收场送达)。
+ */
+export declare function redeemHere(runId: string, scope: string, d: Pick<WorkflowHolderDecision, "token" | "outcome">): Promise<WorkflowParkDelivery>;
+/**
+ * 记录栅栏三只零写拒结局 → 应答(闭集;`stands` / `not_running` 不在本表:前者进 {@link answerOfHolderRedeem},后者走续跑车道)。码全是既有码。
+ *  · `not_held`       —— run 仍在跑,已不持有这张卡(改停驻 / 已被驱动)⇒ 409 `decide.gate_moved`;
+ *  · `restated`       —— 决断带 `mcpServers` / `a2aPeers`,而持有它的 run 仍在跑(子代带着 run 已有的表继续)⇒ 400 `decide.parked_restatement_unsupported`,卡留 pending;
+ *  · `other_decision` —— 行上已是另一个决定(先受理者立)⇒ 409 `decide.claim_lost`。
+ */
+export declare function answerOfHolderFence(verdict: Exclude<HolderFenceVerdict, "stands" | "not_running">, runId: string): ParkedDecideResult;
+/** 记录栅栏这一段店没答出来(读记录 / 落行 / 锁定读)⇒ 503 `decide.store_unreachable`:什么都没决,持有这张卡的 run 照旧等着,重试。 */
+export declare function holderFenceFaultAnswer(runId: string): ParkedDecideResult;
+/**
+ * **记录栅栏立住之后,`/decide` 的本进程快路**:引擎对 {@link redeemHere} 的答 → 这次决断的应答(闭集,`switch` 穷尽;引擎加词 ⇒ 编译红)。
+ * 决定已在唯一仲裁点上立住 ⇒ 除「卡在本次决断之下已离开 pending」外,一律答同一张 200 回执({@link parkedChildResumedReceipt},无结清证据);本口**不**再等 `ended`、
+ * **不**再起续跑车道 —— 写了行的一方从不起宿主一跑,交付由持有进程的拉取(下一个维护拍)或 run 的收场送达完成。
+ *  · `live`/`driving`、`live`/`already_taken` ⇒ 200(单一仲裁之下,run 收下过的只可能是这同一个决定);
+ *  · `live`/`settled` ⇒ 409 `decide.gate_moved`(卡已离开 pending,这个决定没被用上;行惰性 —— 读者只供 pending 卡);
+ *  · `not_active`、`suspending`、`live`/`not_parked_here`、`live`/`unreadable` ⇒ 200(run 在别处跑 / 正在收场 / 本进程此刻读不出卡:行立住了,交付在后);
+ *  · `live`/`kept_parked` ⇒ 抛(送的是决定,引擎只对确认答它);`not_armed` ⇒ 抛(run 没有 checkpoint 座就停驻不出这张卡,引擎不变量破)。
+ * 「收场窗」的判放在管道事实上:run 收场之后由收场送达把行交给续跑车道,本表不读 `not_active` 的字面去区分「在别处跑」与「本进程收场中」。
+ */
+export declare function answerOfHolderRedeem(delivery: WorkflowParkDelivery, runId: string, decision: "approve" | "deny"): ParkedDecideResult;
+/**
+ * 持有进程的拉取腿对 {@link redeemHere} 的答的处置(闭集,`switch` 穷尽):
+ *  · `delivered` —— `driving` / `already_taken` / `settled`:引擎收下了(或卡已离开 pending、行惰性);
+ *  · `next_beat` —— `not_parked_here` / `unreadable`:此刻交不进去,行留着,下一拍再来;
+ *  · `left`      —— `suspending` / `not_active`:run 正在收场 / 已不在本进程,交付归 run 的收场送达;
+ *  · 抛          —— `kept_parked` / `not_armed`(与 {@link answerOfHolderRedeem} 同两只不变量)。
+ */
+export type HolderPullDisposition = "delivered" | "next_beat" | "left";
+export declare function holderPullDisposition(delivery: WorkflowParkDelivery, runId: string): HolderPullDisposition;
+/**
+ * 引擎的观察通道走完 = 这条 run 在本进程里收场了(`subscribeWorkflow` 在 run 收场的最后一步关闭;不在本进程里跑的 run 一开始就是空的 ⇒ 立即落定)。
+ * 三个读者:持有进程的视图(执行器寿命,`workflow-park-holder.ts`)、续跑车道开跑之前那一等(收场窗里引擎答 `not_active` 而 run 仍登记在跑,
+ * 宿主一跑的续跑会撞 fork 守卫 ⇒ 先等它走完)。core 的观察队列只关不拒。
+ */
+export declare function runChannelEnded(runId: string, scope: string): Promise<void>;
 /**
  * `/decide` parked 赎回腿([ref] 件3d server 半场;[ref]/[ref]/[ref] core 裁定形)。
  *

package/dist/parked-decide.js

@@ -30,36 +30,39 @@ export async function findParkOrigin(sources, cp) {
     if (index === undefined || runStore === undefined)
         return undefined;
     try {
-        const pointers = await index.listByAgentSession(cp.sessionId);
-        if (pointers.length === 0)
-            return undefined;
-        const runs = [];
-        for (const runId of new Set(pointers.map((p) => p.runId))) {
-            const run = await runStore.get(runId);
-            if (run !== null)
-                runs.push(run);
-        }
-        const route = routeWorkflowPark(cp.sessionId, runs);
-        switch (route.kind) {
-            case "held":
-                return route.park.token === cp.token ? { kind: "workflow", runId: route.runId, run: route.run, park: route.park } : undefined;
-            case "forked":
-                return { kind: "workflow_park_forked", runIds: route.runIds };
-            case "unproven":
-                return { kind: "workflow_parks_unreadable", runId: route.runId, run: route.run, ...(route.readableHolderRunId !== undefined ? { readableHolderRunId: route.readableHolderRunId } : {}) };
-            case "none":
-                return undefined;
-            default: {
-                const unhandled = route;
-                throw new Error(`unhandled workflow park route: ${JSON.stringify(unhandled)}`);
-            }
-        }
+        return await routeWorkflowOrigin(index, runStore, cp);
     }
     catch (e) {
         quiet(sources.warn, "workflow_park_probe_failed", { error: e instanceof Error ? e.message : String(e) });
         return undefined;
     }
 }
+async function routeWorkflowOrigin(index, runStore, cp) {
+    const pointers = await index.listByAgentSession(cp.sessionId);
+    if (pointers.length === 0)
+        return undefined;
+    const runs = [];
+    for (const runId of new Set(pointers.map((p) => p.runId))) {
+        const run = await runStore.get(runId);
+        if (run !== null)
+            runs.push(run);
+    }
+    const route = routeWorkflowPark(cp.sessionId, runs);
+    switch (route.kind) {
+        case "held":
+            return route.park.token === cp.token ? { kind: "workflow", runId: route.runId, run: route.run, park: route.park } : undefined;
+        case "forked":
+            return { kind: "workflow_park_forked", runIds: route.runIds };
+        case "unproven":
+            return { kind: "workflow_parks_unreadable", runId: route.runId, run: route.run, ...(route.readableHolderRunId !== undefined ? { readableHolderRunId: route.readableHolderRunId } : {}) };
+        case "none":
+            return undefined;
+        default: {
+            const unhandled = route;
+            throw new Error(`unhandled workflow park route: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
 export async function heldWorkflowParkDecisions(sources, hostSessionId, carried) {
     const entries = [...(carried ?? [])];
     const { workflowParkDecisions: decisions, checkpointStore: cs, workflowAgentSessionIndex: workflowIndex, workflowRunStore } = sources;
@@ -73,20 +76,38 @@ export async function heldWorkflowParkDecisions(sources, hostSessionId, carried)
         for (const row of held.rows) {
             if (own.has(String(row.token)))
                 continue;
-            const card = await cs.get(row.token).then((cp) => ({ cp }), (err) => ({ err }));
-            if ("err" in card) {
-                recordFailOpen("server.workflow-park-decision.card-unreadable", `runId=${row.runId} err=${card.err instanceof Error ? card.err.message : String(card.err)}`);
-                continue;
-            }
-            if (card.cp === null || card.cp.status !== "pending")
-                continue;
-            const origin = await findParkOrigin({ workflowIndex, workflowRunStore }, { token: row.token, scope: card.cp.scope, sessionId: card.cp.sessionId });
-            if (origin?.kind === "workflow")
-                entries.push({ runId: origin.runId, token: row.token, outcome: row.outcome });
+            const deliverable = await deliverableEntryOf({ checkpointStore: cs, workflowAgentSessionIndex: workflowIndex, workflowRunStore }, row);
+            if (deliverable.kind === "deliverable")
+                entries.push(deliverable.entry);
         }
     }
     return entries.length > 0 ? { workflowParkedResume: entries } : {};
 }
+export async function deliverableEntryOf(sources, row) {
+    const unreadable = (step, err) => {
+        recordFailOpen("server.workflow-park-decision.card-unreadable", `step=${step} runId=${row.runId} err=${err instanceof Error ? err.message : String(err)}`);
+        return { kind: "unreadable" };
+    };
+    let cp;
+    try {
+        cp = await sources.checkpointStore.get(row.token);
+    }
+    catch (err) {
+        return unreadable("card", err);
+    }
+    if (cp === null || cp.status !== "pending")
+        return { kind: "not_deliverable" };
+    let origin;
+    try {
+        origin = await routeWorkflowOrigin(sources.workflowAgentSessionIndex, sources.workflowRunStore, { token: row.token, sessionId: cp.sessionId });
+    }
+    catch (err) {
+        return unreadable("holder", err);
+    }
+    if (origin?.kind !== "workflow")
+        return { kind: "not_deliverable" };
+    return { kind: "deliverable", entry: { runId: origin.runId, token: row.token, outcome: row.outcome }, origin, card: { scope: cp.scope, sessionId: cp.sessionId } };
+}
 function quiet(warn, event, fields) {
     try {
         warn?.(event, fields);
@@ -224,63 +245,87 @@ export function planWorkflowParkedDecide(origin, req) {
             },
         };
     }
-    const verdict = req.decision === "approve" ? "APPROVED" : "DENIED";
     return {
         ok: true,
         hostSessionId,
         runId: origin.runId,
         outcome: buildParkedResumeOutcome(req),
-        message: {
-            text: `The human approval that workflow run "${origin.runId}" parked on (agent callKey "${origin.park.callKey}") has been ${verdict}. ` +
-                `Resume that run now: re-invoke Workflow with the SAME script source you launched it from (script / name / scriptPath) ` +
-                `AND resumeFromRunId: "${origin.runId}" — the decision is already held by the deployment and will be applied to the parked ` +
-                `agent; completed steps replay from the journal. Do not re-issue the original call.`,
-            trusted: true,
-        },
+        message: workflowParkGuidance(origin.runId, origin.park.callKey, req.decision),
     };
 }
+export function workflowParkGuidance(runId, callKey, decision) {
+    const verdict = decision === "approve" ? "APPROVED" : "DENIED";
+    return {
+        text: `The human approval that workflow run "${runId}" parked on (agent callKey "${callKey}") has been ${verdict}. ` +
+            `Resume that run now: re-invoke Workflow with the SAME script source you launched it from (script / name / scriptPath) ` +
+            `AND resumeFromRunId: "${runId}" — the decision is already held by the deployment and will be applied to the parked ` +
+            `agent; completed steps replay from the journal. Do not re-issue the original call.`,
+        trusted: true,
+    };
+}
+export function redeemHere(runId, scope, d) {
+    return redeemWorkflowParks(runId, scope, [{ token: d.token, outcome: d.outcome }]);
+}
 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();
-        });
+export function answerOfHolderFence(verdict, runId) {
+    switch (verdict) {
+        case "not_held":
+            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 "restated":
+            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 },
+                }),
+            };
+        case "other_decision":
+            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 },
+                }),
+            };
+        default: {
+            const unhandled = verdict;
+            throw new Error(`unhandled workflow holder fence verdict: ${String(unhandled)}`);
+        }
     }
-    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 function holderFenceFaultAnswer(runId) {
+    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 } }) };
 }
-export async function answerOfParkDelivery(delivery, run, d) {
-    const runId = run.id;
+export function answerOfHolderRedeem(delivery, runId, decision) {
+    const receipt = () => parkedChildResumedReceipt(runId, decision, NO_SETTLEMENT_EVIDENCE);
     switch (delivery.kind) {
-        case "live":
-            return { kind: "answered", answer: answerOfLiveResult(delivery.results[0], run, d) };
+        case "live": {
+            const word = delivery.results[0];
+            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":
+                case "already_taken":
+                case "not_parked_here":
+                case "unreadable":
+                    return receipt();
+                case "settled":
+                    return answerOfHolderFence("not_held", runId);
+                case "kept_parked":
+                    throw new Error(`workflow run ${runId} kept a parked call that was handed a decision — the engine keeps a park only on an acknowledgement`);
+                default: {
+                    const unhandled = word;
+                    throw new Error(`unhandled workflow park delivery result: ${String(unhandled)}`);
+                }
+            }
+        }
         case "suspending":
-            await delivery.ended;
-            return { kind: "resume_lane" };
         case "not_active":
-            return { kind: "resume_lane" };
+            return receipt();
         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: {
@@ -289,53 +334,44 @@ export async function answerOfParkDelivery(delivery, run, d) {
         }
     }
 }
-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 },
-                }),
-            };
+export function holderPullDisposition(delivery, runId) {
+    switch (delivery.kind) {
+        case "live": {
+            const word = delivery.results[0];
+            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":
+                case "already_taken":
+                case "settled":
+                    return "delivered";
+                case "not_parked_here":
+                case "unreadable":
+                    return "next_beat";
+                case "kept_parked":
+                    throw new Error(`workflow run ${runId} kept a parked call that was handed a decision — the engine keeps a park only on an acknowledgement`);
+                default: {
+                    const unhandled = word;
+                    throw new Error(`unhandled workflow park delivery result: ${String(unhandled)}`);
+                }
+            }
         }
-        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 },
-                }),
-            };
+        case "suspending":
+        case "not_active":
+            return "left";
+        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`);
         default: {
-            const unhandled = word;
-            throw new Error(`unhandled workflow park delivery result: ${String(unhandled)}`);
+            const unhandled = delivery;
+            throw new Error(`unhandled workflow park delivery: ${JSON.stringify(unhandled)}`);
         }
     }
 }
+export async function runChannelEnded(runId, scope) {
+    const channel = subscribeWorkflow(runId, scope)[Symbol.asyncIterator]();
+    while (!(await channel.next()).done) {
+    }
+}
 function sessionGone(taskId) {
     return {
         status: 409,

package/dist/peer-directory.d.ts

@@ -37,8 +37,8 @@
  *
  * ## scope 轴
  *
- * core 递进来的 `access.scope` = `taskScope` = `internals?.registryScope ?? spec.principal ?? "default"`
- * (core `prepare-task.js`)× server `resolve-spec.ts:701 principal: auth?.principal` ⇒ **裸 principal 串**,
+ * core 递进来的 `access.scope` = 引擎的任务 scope(core 写侧规则与本仓的唯一换算见 `engine-identity.ts` 的 `engineScopeOf` 头注)
+ * × 落点 `taskSpecIdentityOf` 只写人 ⇒ **裸 principal 串**,
  * 无 principal 的部署上是字面量 `"default"`,而同一情形下 `session_meta.owner` 是 SQL NULL ——
  * 这正是窄互认臂(`LEGACY_UNOWNED_AMNESTY_TENANT === "default"`)要接住的那一格,不必另铸编解码。
  *

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

@@ -11,8 +11,8 @@
  *    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 与「没有这张卡」同码同文。
+ *  · **属主 = 收信方**:列与决都只在调用方**自己**的信箱 scope 里找队列(`peerHeldQueueIfAny(调用方 scope, …)`;core 按收信 run 的任务 scope 开队列,
+ *    调用方那一格只经唯一换算 `engine-identity.ts` 的 `engineScopeOfOwner` 读,路由在调用点换好再交进来)—— 别人的卡结构上取不到,决断口答的 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`
@@ -41,10 +41,6 @@
   */
 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;

package/dist/peer-inbound-face.js

@@ -3,9 +3,6 @@ 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}`;
 }