@sema-agent/server 7.147.0 → 7.149.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/park-row-commit.d.ts

@@ -0,0 +1,67 @@
+/**
+ * **卡已提交之后,停驻的唯一提交点** —— run 行的停驻写(`setSuspended` / `setNeedsReview`:对本腿持有的这条行的 CAS,保 `task_active` 认领)。
+ *
+ * 引擎交回停驻之前已把卡落进 checkpoint 店(卡已提交):这条 run 此刻在等那张卡。腿的收场只由行的这一笔写回答,规则一句 ——
+ * **店答出的拒是答案,店的故障不是**(与续跑认领之后的提交同一条律、同一对类别词:店答出 = `refused`,店没答出来 = `faulted`;
+ * 判在写口的两只出口上,结构判 —— 交回值 vs 抛 —— 不读错误文案)。
+ *
+ * 停驻写的 CAS = **行仍归本腿(持有腿 `legId`,认领交给本腿的那一只)∧ 仍在跑(或已停在本词上)∧ 没挂取消请求**(三件的属主 = 店的两只写口,
+ * `run-store-sql.ts` 的 `setSuspended` 头注;内存 / 文件孪生同判)。第一笔与每一次再提交是**同一个形**:写;店答出「不」⇒ 读行、由行答 ——
+ *  · 行不在 ⇒ 兑现卡的 run 没了 ⇒ 作废卡(`card-void.ts` 的结算作废;卡的命运跟着行,行先、卡后);
+ *  · 行已终局(不论哪条腿持有)⇒ run 收场了 ⇒ 作废卡(已不 pending 的卡作废是空操作);
+ *  · 行归别的腿、还活着(在跑 / 停驻)⇒ 本腿先前那一笔落下了、卡被决、下一条腿接走了这条行(重开的同一张卡此刻归它)⇒ 停驻成立过,不写、卡不碰;
+ *  · 行归本腿、停在本词上 ⇒ 本腿先前那一笔落下了(一笔抛了的写结局未知)⇒ 停驻成立;
+ *  · 行归本腿、在跑、挂着取消请求(`POST /v1/runs/:id/cancel` 对在跑行只置旗)⇒ 取消先到:先作废卡、再落取消终局
+ *    (唯一铸点 `mintCancelledResult`,码 `cancelled`)—— 不把一次已答「取消中」的 run 停成可决的停驻;
+ *  · 行归本腿、在跑、没挂取消 ⇒ 店自相矛盾(CAS 说不、读说该写)= 不变量破 ⇒ 响亮记一次(`server.park.row-commit-contradicted`,带 taskId 与读到的词),
+ *    再当店故障处置(下面的再提交路)。
+ * 店故障(写 / 读 / 收场写抛:故障 / 超时 / 程序错)= `faulted` ⇒ **不收场**:不落 failed、不作废卡、认领原样留着,同一笔停驻再提交 ——
+ * 当拍一次,仍没答出 ⇒ 按心跳节拍续,直到店答出。上界 = 这台部署判活窗的两倍(`REAP_RUN_STALE_SEC`:一窗让这条不再有心跳的行落到既有的
+ * 失联判决射程里,一窗让判决落下、被下一次再提交读到 —— 读到即作废卡)。过了上界仍没答 ⇒ 停手,交既有出路:行由失联收割(`reapStale` /
+ * 观察口)按同一只判活窗收成 failed、放认领,卡由审批兜底收割按它的截止 / 绝对兜底时刻作废。不新造出路。
+ * 停驻的账本投影(停驻帧、它之前的用量差)不在这里:写口 `appendParkRow` 写不下只留痕,不改判词。
+ */
+import { type CardRef, type CardVoidPort } from "./card-void.js";
+import type { RunStore } from "./plugins/store-backend.js";
+import { type PersistedTaskResult, type RunRecord } from "./plugins/store-contracts.js";
+import type { ParkLedgerEventType } from "./trace/ledger-events.js";
+/**
+ * 一次停驻提交交回的读数(调用方按它收场,三形穷举):
+ *  · `parked` —— 停驻成立(这一笔落下,或本腿先前那一笔已落下 —— 此后行可能已交给接手腿);
+ *  · `pending` —— 店故障,再提交在续(行留 `running`、卡待决);
+ *  · `ended` —— 这条 run 没有停住、已收场:`row` = 提交点读到 / 写下之后读回的那一行(终局;`undefined` = 行不在),卡已交作废。
+ *    这次收场是不是取消,读行的码(`row.errorCode === "cancelled"`,终局码的唯一读法)。
+ */
+export type ParkCommitOutcome = {
+    readonly kind: "parked";
+} | {
+    readonly kind: "pending";
+} | {
+    readonly kind: "ended";
+    readonly row: RunRecord | undefined;
+};
+export interface ParkRowCommit {
+    readonly runStore: Pick<RunStore, "setSuspended" | "setNeedsReview" | "getRun" | "setTerminal">;
+    readonly taskId: string;
+    /** 停在哪个词上(同一扇门的词:`plan_review` 落 `needs_review`,其余落 `suspended`)。 */
+    readonly word: ParkLedgerEventType;
+    /** 落在行上的结果(店入口再封口;`null` = 这条腿手里没有停驻结果 —— 重开 / 放回 / 兜底腿)。 */
+    readonly result: PersistedTaskResult | null;
+    /** 这次停驻在等的那张卡(凭据 + 它应归的会话 = 本 run 的会话)。店答出 run 已收场 ⇒ 作废的就是它。 */
+    readonly card: CardRef;
+    /** 读卡 / 作废的 checkpoint 店(缺席 ⇒ 作废那一步响亮留痕,见 `card-void.ts`)。 */
+    readonly cards: CardVoidPort | undefined;
+    /** 探针行上的产地(`leg=<…>`)。 */
+    readonly leg: "bg" | "resume" | "sync";
+    /** 本腿的持有腿(`RunRecord.legId`):认领交给本腿的那一只 —— 建行 `createRun` 的 `{ ok: true, legId }`、续跑认领 `markResuming` 的交回值。
+     *  停驻写只许它落下;拒后判拿它比行上的那一只。不是读来的:读到的持有腿可能已是接手腿的。 */
+    readonly legId: string;
+    /** 这台部署的判活窗(ms,`REAP_RUN_STALE_SEC` × 1000,活配置);缺席 ⇒ 缺省窗(不经装配直接调用的嵌入方 / 夹具)。 */
+    readonly staleWindowMs: number | undefined;
+}
+/**
+ * 提交一次停驻(见模块头注)。不抛:第一笔抛 ⇒ 当拍再提交一次,仍抛 ⇒ 交回 `pending` 并起续提交;每一次失败、以及到上界停手,都经 F 类 tag
+ * `server.park.row-commit-deferred` 计数 + 探针行(detail `leg=<…> step=<first|again|retry|gave_up> err=<原句>`,不含凭据)。
+ */
+export declare function commitParkRow(c: ParkRowCommit): Promise<ParkCommitOutcome>;
+//# sourceMappingURL=park-row-commit.d.ts.map

package/dist/park-row-commit.js

@@ -0,0 +1,76 @@
+import { voidPendingCard } from "./card-void.js";
+import { LIVENESS_HEARTBEAT_MS } from "./config-invariants.js";
+import { RUN_STALE_SEC_DEFAULT } from "./run-stale-default.js";
+import { mintCancelledResult } from "./run-cancel-context.js";
+import { errorText } from "./observability/err-text.js";
+import { recordFailOpen } from "./observability/fail-open.js";
+import { isTerminalRunStatus } from "./plugins/store-contracts.js";
+const DEFERRED_TAG = "server.park.row-commit-deferred";
+const CONTRADICTED_TAG = "server.park.row-commit-contradicted";
+const VOID_TAG = "server.park.held-card-void-failed";
+const CANCELLED_WHILE_PARKING = "cancelled before its park was committed (the pending approval was settled)";
+const PARK_WRITE = {
+    suspended: (s, taskId, result, legId) => s.setSuspended(taskId, result, legId),
+    needs_review: (s, taskId, result, legId) => s.setNeedsReview(taskId, result, legId),
+};
+async function ended(c, row, at) {
+    await voidPendingCard(c.card, c.cards, VOID_TAG, `leg=${c.leg} at=${at}`);
+    return { kind: "ended", row };
+}
+async function settleByRow(c, row) {
+    if (row === undefined || isTerminalRunStatus(row.status))
+        return ended(c, row, "park_commit_refused");
+    if (row.legId !== c.legId)
+        return { kind: "parked" };
+    if (row.status !== "running")
+        return { kind: "parked" };
+    if (row.cancelRequested) {
+        await voidPendingCard(c.card, c.cards, VOID_TAG, `leg=${c.leg} at=park_commit_cancelled`);
+        const cancelled = mintCancelledResult({ taskId: c.taskId, sessionId: row.sessionId, startedAtMs: Date.parse(row.createdAt), message: CANCELLED_WHILE_PARKING, cause: "cancel_verb" });
+        await c.runStore.setTerminal(c.taskId, "failed", cancelled, CANCELLED_WHILE_PARKING);
+        return { kind: "ended", row: await c.runStore.getRun(c.taskId) };
+    }
+    recordFailOpen(CONTRADICTED_TAG, `leg=${c.leg} taskId=${c.taskId} word=${c.word} status=${row.status} holder=self cancel=false`);
+    throw new Error(`park commit: the store refused the ${c.word} write of run ${c.taskId} while its row reads as this leg's, running, with no cancel request`);
+}
+async function attempt(c) {
+    if ((await PARK_WRITE[c.word](c.runStore, c.taskId, c.result, c.legId)) !== false)
+        return { kind: "parked" };
+    return settleByRow(c, await c.runStore.getRun(c.taskId));
+}
+export async function commitParkRow(c) {
+    try {
+        return await attempt(c);
+    }
+    catch (e) {
+        recordFailOpen(DEFERRED_TAG, `leg=${c.leg} step=first err=${errorText(e)}`);
+    }
+    try {
+        return await attempt(c);
+    }
+    catch (e) {
+        recordFailOpen(DEFERRED_TAG, `leg=${c.leg} step=again err=${errorText(e)}`);
+    }
+    continueParkCommit(c);
+    return { kind: "pending" };
+}
+function continueParkCommit(c) {
+    const untilMs = Date.now() + 2 * (c.staleWindowMs ?? RUN_STALE_SEC_DEFAULT * 1000);
+    let inFlight = false;
+    const timer = setInterval(() => {
+        if (inFlight)
+            return;
+        inFlight = true;
+        void attempt(c).then(() => clearInterval(timer), (e) => {
+            inFlight = false;
+            if (Date.now() < untilMs) {
+                recordFailOpen(DEFERRED_TAG, `leg=${c.leg} step=retry err=${errorText(e)}`);
+                return;
+            }
+            clearInterval(timer);
+            recordFailOpen(DEFERRED_TAG, `leg=${c.leg} step=gave_up err=${errorText(e)}`);
+        });
+    }, LIVENESS_HEARTBEAT_MS);
+    timer.unref?.();
+}
+//# sourceMappingURL=park-row-commit.js.map

package/dist/parked-decide.d.ts

@@ -11,13 +11,15 @@
 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";
 import type { 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 ExecutionCommitDeps, type RootedExecutionContext } from "./http/execution-context.js";
+import { type CardSettlePort } from "./card-settle-stored-scope.js";
+import { type ClaimFace, type ExecutionCommitDeps, type RootedExecutionContext } from "./http/execution-context.js";
 import type { GateIdentity } from "./checkpoint-identity.js";
 /**
  * 本腿的**装配前提**(`createHttpServer` 起服拒的拒句;规则见 {@link ParkedDecideDeps} 的 `execution`):接了本腿(`parkedReviveSurface` 在场)的部署,
@@ -25,6 +27,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;
@@ -147,17 +157,14 @@ export declare function findParkedAgentForCheckpoint(agentStore: BackgroundAgent
 }): Promise<ParkedAgentMatch | undefined>;
 export interface ParkedDecideDeps {
     agentStore: BackgroundAgentStore;
-    /** `expire`:[ref] deny 作废复活不了的卡(按卡自己的 scope CAS);`get`:引擎的 claim / 对账读卡。 */
-    checkpointStore: Pick<CheckpointStore, "get" | "expire">;
+    /** `expire` + `peekScopeByToken` + 状态读:[ref] deny 作废复活不了的卡(`expireCardUnderStoredScope`:先读状态、再按店里该卡的属主格 CAS);`get`:引擎的 claim / 对账读卡。 */
+    checkpointStore: Pick<CheckpointStore, "get" | "expire"> & CardSettlePort;
     /** 与 reaper/scenarios 同一个 registry(claim/rollback 的 CAS 与 in-memory handle 收敛在同处;[ref] 作废之后的对账也是它)。 */
     registry: Pick<TaskRegistry, "claimParkedAgent" | "rollbackParkedClaim" | "reconcileParkedAgents">;
     /** [ref](core 7.32.0):按**行**解析赎回面 —— 驱动哪一只 Agent 工具(生产装配,与 spawn 同源:subRunner / bg opts /
      *  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 的官方重供通道——不供 = 重启后带
@@ -183,19 +190,19 @@ export interface ParkedDecideDeps {
         owner: string | null;
         taskId: string;
         sessionId: string;
-        executionLane: import("./execution-lane-caps.js").ExecutionLane;
-    }) => NonNullable<ToolExecuteContext["onAsk"]>;
+    } & ApprovalLegOrigin) => NonNullable<ToolExecuteContext["onAsk"]>;
     /**
      * 边界 9 的执行上下文(设计 §3.2;与提交腿 / 续跑家族同一只解析器、同一只写口)—— 本腿对根会话的住客**一读一判**:
      *  · `resolve` —— **认领之前**按行的根取上下文:解析器那一次行读(执行席:住客 + 格)就是本腿对根会话的**唯一一读**;根行不在 ⇒ `gone`
-     *    (本腿答既有的 `decide.not_parked`);其余拒(mirror / 车道不再服务 / 主体的车道裁定)按续跑家族的折叠律答好交回(`answer`)—— 不认领、不驱动。
+     *    (本腿答既有的 `decide.not_parked`);其余拒(mirror / 车道不再服务 / 主体的车道裁定)按续跑家族的折叠律答好交回(`answer`);店没答出来 ⇒ 本腿交来的这一面
+     *    `face` 的瞬时答复(`answer`,与认领那一笔撞店故障同答)—— 不认领、不驱动。
      *    成功形的 `occupant` **必有**:接本腿的部署必须带执行席(无席的会话店交不出这一读;`createHttpServer` 在装配时拒无席形);
      *  · `commitDeps` —— 认领之后 `commitExecutionContext` 读的部署件:唯一写口按那一读的住客定址写 / 再读(化身 ∧ 属主),这就是认领之后对根住客的
      *    **唯一一判**(拒 ⇒ 先回滚认领)。写口放行的那一位就是赎回面的根住客见证;写口之后本腿不再读根。
      * 复活子代的审批席带这只上下文的车道(`approverSeatFor` 的 `executionLane`)。
      */
     execution: {
-        resolve: (root: string) => Promise<{
+        resolve: (root: string, face: ClaimFace) => Promise<{
             readonly ok: true;
             readonly ctx: RootedExecutionContext & {
                 readonly occupant: SessionFace;
@@ -302,6 +309,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 +331,7 @@ export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): Work
  * 开跑前经那一只读者把它放进 internals)。
  *
  * ## 诚实边界(登记,不假装没有)
- * · **模型中介**:决定送达宿主之后,真正的赎回发生在宿主再调一次 `Workflow({resumeFromRunId})` 时。
+ * · **模型中介**(只在续跑车道上):决定送达宿主之后,真正的赎回发生在宿主再调一次 `Workflow({resumeFromRunId})` 时。
  *   core 的 park 回执逐字告诉模型这件事,但它不是一条确定性的机器腿。宿主没照做 ⇒ 卡仍 pending、决定行还在:
  *   宿主会话的下一跑(谁起的都算)照带它,同一个决定重投再触发一次投递(**不会**静默吃掉批准)。
  * · **`inheritedGate` 不供**:那是「跨进程重供 checkpoint 的父约束」的席位,而 wa* 行不带父约束链;
@@ -377,6 +389,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 裁定形)。
  *