@sema-agent/server 7.146.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;
@@ -63,20 +71,16 @@ export type ParkOrigin = {
     park: WorkflowRunParkKey;
 }
 /**
- * **这条决定证不了属于哪一条记录**(core 7.44.0 [ref] 的「没有持有者」两臂;判决属主 = 索引模块的 `routeWorkflowPark`)。
- * `cause`:`unreadable` = 某一条点名这个子会话的记录 `parks[]` 读不出(条目形坏 / 这一位在场却不是列表;缺席 = 没有条目,不在此列)—— 它可能正是持有者;
- * `older_engine` = 点名它的条目没有持有者位(写于不带 `parkedBy` / `generation` 的引擎,升级那一刻还停驻着的存量记录)。
- * 两种都**响亮拒**(409 `decide.workflow_parks_unreadable`,码一个、句子按成因两句),一步都不驱动;出路按成因:`older_engine` = 去续跑 `runId` 那条 run
- * (新引擎准入后走到这张停驻会写下自己的持有者行,之后在这里决就正常);`unreadable` = 修好那条记录(它的指针不随任何后继记录消失,续跑解不开)。
- * 不回落读 `agents[]`(那是被退役的第二种读法)。
- * `readableHolderRunId`(只在 `unreadable` 上可能在场):其余可读记录里持有这张卡的最高代次恰一条 —— 读不出的那条引擎往往恰拒续跑,健康的持有者
+ * **这条决定证不了属于哪一条记录**(core 7.44.0 [ref] 的「没有持有者」一臂;判决属主 = 索引模块的 `routeWorkflowPark`):某一条点名这个子会话的记录
+ * `parks[]` 读不出(条目形坏 / 这一位在场却不是列表;缺席 = 没有条目,不在此列)—— 它可能正是持有者。**响亮拒**(409 `decide.workflow_parks_unreadable`),
+ * 一步都不驱动;出路 = 修好那条记录(`runId`;它的指针不随任何后继记录消失,续跑解不开)。不回落读 `agents[]`(那是被退役的第二种读法)。
+ * `readableHolderRunId`:其余可读记录里持有这张卡的最高代次恰一条 —— 读不出的那条引擎往往恰拒续跑,健康的持有者
  * 就在旁边,拒体多给这一条线索(判决不变,仍是整卡拒;不是解除阻断的出路)。
  */
  | {
     kind: "workflow_parks_unreadable";
     runId: string;
     run: WorkflowRun;
-    cause: "unreadable" | "older_engine";
     readableHolderRunId?: string;
 }
 /**
@@ -159,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 的官方重供通道——不供 = 重启后带
@@ -216,6 +217,24 @@ export interface ParkedDecideDeps {
     };
     warn?: (event: string, fields: Record<string, unknown>) => void;
 }
+/**
+ * 「本会话放行」落在**记不住的车道**上怎么答(闭集;两扇门之间唯一允许的差 —— 其余两口同读同答,铸点只有续跑腿一只):
+ *  · `refuse` —— `/decide` 体上的 `remember:"session"`:那是一个硬意图键,认领之前 400 点名车道(`decide.workflow_remember_unsupported` /
+ *    `decide.parked_remember_unsupported`),去掉它再决即可,零副作用;
+ *  · `decide_once` —— 应答口命中停驻行的 `allow_session`:那是卡上的一个选项,主内容是「放行」。照常放行这一次、不落豁免、回执
+ *    `rememberApplied:false` —— 与活卡上「记不住的卡点 allow_session」同一答法;不把一次已经成立的批准改成 400(窗到期那一拍的按键今天是成的)。
+ * 记不住的车道 = workflow 车道(它的 200 证不出引擎已提交这次决定)、无会话锚的 bg 停驻行(豁免无处可锚)。
+ */
+export type RememberLaneCannotRecord = "refuse" | "decide_once";
+/**
+ * 停驻车道上的「本会话放行」请求。`anchor` 由车道在认领赢下之后、驱动之前调,只**记下**锚(行的 root/host 会话 id —— 部署侧三个豁免探针
+ * (policy 层 / fs-write 门 / workflow 门)的闭包统一捕获 host 会话键,落子代会话则键永不相交;[ref] 候裁② 的 server 侧修,经两轮行为探针实证);
+ * 豁免**落店**只在续跑腿拿到「这次决定被证明已结清」之后(`resumeCheckpoint` 的唯一铸点),车道从不写店。
+ */
+export interface ParkedRemember {
+    readonly anchor: (rootSessionId: string) => Promise<void>;
+    readonly laneCannotRecord: RememberLaneCannotRecord;
+}
 export interface ParkedDecideRequest {
     token: string;
     scope: string;
@@ -235,13 +254,9 @@ export interface ParkedDecideRequest {
     /** 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 亲读:`sourceSessionId` 只在
-     *  onAsk 层的 AskRequest,durable 车道无 onAsk),grant 落子代会话则键永不相交(G-F4 原案);落
-     *  root 会话则宿主键闭包立即命中,复活子代的后续同工具 ask 被短路(探针 v2 实证),语义与同步车道/
-     *  宿主任务的「本会话不再询问」一致(= host 会话树全域)。行无 root 锚(病态形)⇒ claim 前诚实 400。 */
-    grantRemember?: (rootSessionId: string) => Promise<void>;
+    /** 这次决定带着「本会话放行」请求(`/decide` 的 `remember:"session"` / 应答口命中停驻行的 `allow_session`,两口同一只请求;
+     *  铸点 = 续跑腿 `resumeCheckpoint`)时,续跑腿交下来的**锚点记录器** + 记不住时怎么答({@link ParkedRemember})。 */
+    remember?: ParkedRemember;
     /** [ref](core 5.7.0,F6 翻案):AskUserQuestion 的 approve 携操作员答案——原样透传进
      *  `ResumeOutcome.answer`(形状校验在路由层 isQuestionAnswer;header 逐字匹配等语义校验在 core,
      *  server 不预判)。core 拒绝形:同步腿 409 invalid_outcome field:"answer",parked 腿经 drive 失败
@@ -250,9 +265,6 @@ export interface ParkedDecideRequest {
     /** 决定体带的续跑请求重述键(`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>;
 }
 /**
  * 后台子代赎回腿({@link decideParkedAgent})收的请求 = 两条车道共用的那一份 + 选中这张卡的**门身份片段**。workflow 车道是投递、不收它
@@ -295,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` 证伪了它:
@@ -312,7 +329,7 @@ export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): Work
  * 开跑前经那一只读者把它放进 internals)。
  *
  * ## 诚实边界(登记,不假装没有)
- * · **模型中介**:决定送达宿主之后,真正的赎回发生在宿主再调一次 `Workflow({resumeFromRunId})` 时。
+ * · **模型中介**(只在续跑车道上):决定送达宿主之后,真正的赎回发生在宿主再调一次 `Workflow({resumeFromRunId})` 时。
  *   core 的 park 回执逐字告诉模型这件事,但它不是一条确定性的机器腿。宿主没照做 ⇒ 卡仍 pending、决定行还在:
  *   宿主会话的下一跑(谁起的都算)照带它,同一个决定重投再触发一次投递(**不会**静默吃掉批准)。
  * · **`inheritedGate` 不供**:那是「跨进程重供 checkpoint 的父约束」的席位,而 wa* 行不带父约束链;
@@ -331,7 +348,10 @@ export type WorkflowParkedDecidePlan = {
     ok: true;
     hostSessionId: string;
     runId: string;
-    message: string;
+    message: {
+        text: string;
+        trusted: true;
+    };
     outcome: WorkflowParkOutcome;
 } | {
     ok: false;
@@ -339,19 +359,16 @@ export type WorkflowParkedDecidePlan = {
 };
 /**
  * **证不了这条决定属于哪一条记录**的响亮拒(与上面那族拒臂同一种返回形)—— 判决属主 = 索引模块的 `routeWorkflowPark`
- * (「没有持有者」两臂)。码一个(409 `decide.workflow_parks_unreadable`),句子按成因两句,体键 `runId` = 去续跑的那一条;`unreadable` 臂另带顶层
+ * (「没有持有者」一臂:某一条点名这张卡的记录读不出)。码一个(409 `decide.workflow_parks_unreadable`),体键 `runId` = 读不出的那一条;另带顶层
  * `readableHolderRunId`(与 `runId` / `runIds` 同为顶层键)—— **在场才带,缺席整键不在**(没有 / 并列的可读持有者不编一个):读不出的那条引擎往往恰拒续跑,
  * 健康的持有者在旁时指给人看工作可以从哪条记录续上。**只是线索,不是解除阻断的出路**:判决仍是整卡拒(规则 ①),读不出的那条的指针不随任何后继记录消失 ——
  * 续跑可读持有者之后这张卡照旧答本码,直到读不出的那条被修好(拒句如实说了这一点)。
  *
  * 为什么是拒而不是「尽力而为地投递一次」:「这条记录的 run 站在这张停驻上」只有一种读法(`parkedBy === record.id`),读不出来 ⇒
  * 这条决定结构上送不出去,答 200「已交给宿主的下一跑」就是一张兑付不了的回执:卡还 pending、人以为决完了。⇒ 拒,把真话说出来;
- * 卡仍 pending,什么都没有被伪造。不回落读 `agents[]`(那正是被退役的第二种读法)。
- *  · `older_engine`:点名这张卡的条目写于不带持有者位的引擎(升级那一刻还停驻着的存量记录)。续跑这条 run ⇒ 新引擎准入、走到这张
- *    停驻时写下自己的持有者行 ⇒ 之后在这里决就正常;
- *  · `unreadable`:某一条点名这张卡的记录读不出(条目形坏 / 这一份在场却不是列表;记录上**没有**这一份 = 没有条目,不到这里 —— 规则见
- *    `readRunParks`)。续跑**不是**出路:读不出的那条记录的指针不随任何后继记录消失,续跑之后规则 ① 照旧整卡拒(条目形坏的记录引擎本来也拒续跑);
- *    出路 = 运维修好那条记录(`runId`),之后在这里决就正常。
+ * 卡仍 pending,什么都没有被伪造。不回落读 `agents[]`(那正是被退役的第二种读法)。读不出 = 条目形坏 / 这一份在场却不是列表(记录上**没有**这一份 = 没有条目,
+ * 不到这里 —— 规则见 `readRunParks`)。续跑**不是**出路:读不出的那条记录的指针不随任何后继记录消失,续跑之后规则 ① 照旧整卡拒(条目形坏的记录引擎本来也拒续跑);
+ * 出路 = 运维修好那条记录(`runId`),之后在这里决就正常。
  *
  * 🔴 **[ref](词域门)**:句子不提 `checkpointToken`(契约 D-1 逐字:server-INTERNAL、合规 SDK 绝不发送)与内部机件名;判据与冻结钉见
  * `test/api-error-text-lexicon.test.ts` / `test/api-error-text-freeze.test.ts`。
@@ -370,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 裁定形)。
  *