@sema-agent/server 7.133.0 → 7.135.0

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

@@ -1,21 +1,44 @@
-import { type WorkflowRun, type WorkflowRunStore, type WorkflowRunStatus, type WorkflowRunSummary } from "@sema-agent/core";
+import { type WorkflowCompletionNotifier, type WorkflowRun, type WorkflowRunStore, type WorkflowRunStatus, type WorkflowRunSummary } from "@sema-agent/core";
 import { type FleetEventBus } from "../fleet/fleet-bus.js";
 import { type WorkflowAgentSessionIndex } from "./workflow-agent-session-index.js";
-/** A workflow completion notification's terminal payload — the bounded, redacted shape core's notifier seam
- *  carries, re-derivable from a durable {@link import("@sema-agent/core").WorkflowRun} on the recovery path. */
-export interface WorkflowCompletionPayload {
-    runId: string;
-    status: "completed" | "failed";
-    /** Redacted + length-bounded — never host-internal paths/tokens (parity with core's `boundedSummary`). */
-    summary: string;
-    sourceTaskId?: string;
-    principal?: string;
-    /** core 1.208: the ORIGINATING session id, closed over by the Runner at RunWorkflow mount time —
-     *  the lookup-free routing key for the completion inbox. Present on the LIVE notify path; ABSENT on the
-     *  crash-recovery path (the durable `WorkflowRun` does not carry it — relayed to core to thread it there too,
-     *  parity with `sourceTaskId`'s 1.187 story), where the delivery falls back to the `sourceTaskId` run-row lookup. */
-    originatingSessionId?: string;
-}
+/**
+ * core 的 notify seam 递来的**每一个键**在这条通知链上的处置 —— 载荷型 {@link WorkflowCompletionPayload} 的**唯一来源**(不再手抄 core 入参型的子集)。
+ * core 给 `WorkflowCompletionNotifier.notify` 的入参加一个键 ⇒ 这里编译红(缺一行),逼人对「它上不上这条链」表态;core 删 / 改名一个键 ⇒ 同样红(多一行)。
+ *  · `carry`:搬运到投递(journal 门 → 收件箱 → `workflow_complete` 帧 / 账本行)。`runId` / `status` / `summary` 必带;其余可选键引擎没给(或空串)⇒ 载荷上缺席。
+ *    `completionId` = 引擎的一次完成的相关 id(fill-once,终态转换上铸):逐字、不脱敏、本服务零自铸。
+ *  · `drop`:这条持久链只搬运一句受限摘要 + 路由键 —— `task_id` / `task_type` / `toolUseId` 是 live `task_notification` 帧的键(那条路径自带),`result` / `usage` /
+ *    `diagnostics` 是完整结果 / 计量 / 诊断路由(终态轮询 `TaskOutput` / `WorkflowStatus` 读得到),不进补投帧。
+ * 键名直呼 core 的入参型(型文本里就有 core 名)⇒ 读表的 literals 段收得到这些键。
+ */
+export declare const WORKFLOW_NOTIFY_KEY_DISPOSITION: {
+    readonly runId: "carry";
+    readonly status: "carry";
+    readonly summary: "carry";
+    readonly sourceTaskId: "carry";
+    readonly principal: "carry";
+    readonly originatingSessionId: "carry";
+    readonly completionId: "carry";
+    readonly task_id: "drop";
+    readonly task_type: "drop";
+    readonly toolUseId: "drop";
+    readonly result: "drop";
+    readonly usage: "drop";
+    readonly diagnostics: "drop";
+};
+type NotifyKeyDisposition = typeof WORKFLOW_NOTIFY_KEY_DISPOSITION;
+/** 处置表里 `carry` 的键。 */
+export type WorkflowNotifyCarriedKey = {
+    [K in keyof NotifyKeyDisposition]: NotifyKeyDisposition[K] extends "carry" ? K : never;
+}[keyof NotifyKeyDisposition];
+/**
+ * A workflow completion notification's terminal payload — the bounded, redacted shape core's notifier seam carries,
+ * re-derivable from a durable {@link import("@sema-agent/core").WorkflowRun} on the recovery path.
+ *
+ * **派生型,不是手抄子集**:core `WorkflowCompletionNotifier["notify"]` 入参型按 {@link WORKFLOW_NOTIFY_KEY_DISPOSITION} 里 `carry` 的键挑出来。
+ * 键的语义随键住在 core 的入参型上(`summary` 受限 + 脱敏;`originatingSessionId` = Runner 在挂 RunWorkflow 时闭包的发起会话 id,live 路径在、崩溃恢复路径读
+ * `WorkflowRun` 行上同名键;`completionId` 见处置表)—— 这里不再复述一份会漂的注释。
+ */
+export type WorkflowCompletionPayload = Pick<Parameters<WorkflowCompletionNotifier["notify"]>[0], WorkflowNotifyCarriedKey>;
 /** The downstream delivery the journal guards (the deployment's real completion route — log+meter today, a full
  *  re-invoke into the originator's stream/inbox tomorrow). Idempotent on `runId` by contract; the journal still
  *  de-dups so it is invoked AT MOST once per run in steady state and at most one extra time across a crash. */
@@ -201,7 +224,7 @@ export declare class WorkflowNotifyGate {
  * appends, atomic single-line records. Single-instance / TOC-local: a cross-replica TiDB/PG port is a follow-on
  * (the recovery sweep + gate are backend-agnostic).
  *
- * 追加 / 重放走本仓 JSONL 店的**共用口**(S-977;此前是第二 / 第三份私有实现):追加 = core `AppendLog`(惰性打开;单条 `writeSync`
+ * 追加 / 重放走本仓 JSONL 店的**共用口**([ref];此前是第二 / 第三份私有实现):追加 = core `AppendLog`(惰性打开;单条 `writeSync`
  * 循环写满、失败的写截回开写处;**撕尾在打开与每次追加前修**,所以崩在一次 append 中途之后的下一条成功写不会被粘进残尾),
  * 重放 = `replayJsonlSkipping`(登记座 `workflow-notify-journal`:中间坏行跳过 + 逐条披露 + F tag;撕尾不计 —— 它是崩溃的正常落盘形;
  * 末行 JSON 完整但缺换行的认下、下一次追加补换行)。盘上字节 / 0o600 账本 / 0o700 目录与修前逐字同,升级零迁移。
@@ -274,7 +297,7 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     /** MF-Fleet (data contract): publish the workflow's fleet row on every put/update (the same write-observation
      *  point as the notify journal). Optional — undefined ⇒ no fleet publish. */
     private readonly fleetBus?;
-    /** S-185 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
+    /** [ref] 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
     private readonly agentSessionIndex?;
@@ -287,7 +310,7 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     /** MF-Fleet (data contract): publish the workflow's fleet row on every put/update (the same write-observation
      *  point as the notify journal). Optional — undefined ⇒ no fleet publish. */
     fleetBus?: FleetEventBus | undefined, 
-    /** S-185 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
+    /** [ref] 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
     agentSessionIndex?: WorkflowAgentSessionIndex | undefined);
@@ -328,4 +351,5 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
         keep?: number;
     }): Promise<number>;
 }
+export {};
 //# sourceMappingURL=workflow-notify-journal.d.ts.map

package/dist/orchestration/workflow-notify-journal.js

@@ -5,6 +5,21 @@ import { isTerminalWorkflowRowStatus, seedTerminalWorkflowRow } from "../fleet/f
 import { buildParkSessionRows } from "./workflow-agent-session-index.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
+export const WORKFLOW_NOTIFY_KEY_DISPOSITION = {
+    runId: "carry",
+    status: "carry",
+    summary: "carry",
+    sourceTaskId: "carry",
+    principal: "carry",
+    originatingSessionId: "carry",
+    completionId: "carry",
+    task_id: "drop",
+    task_type: "drop",
+    toolUseId: "drop",
+    result: "drop",
+    usage: "drop",
+    diagnostics: "drop",
+};
 const SUMMARY_MAX = 500;
 export function recoverySummary(status, error) {
     if (status === "completed")
@@ -65,6 +80,7 @@ export class WorkflowNotifyGate {
                     ...(input.sourceTaskId ? { sourceTaskId: input.sourceTaskId } : {}),
                     ...(input.principal ? { principal: input.principal } : {}),
                     ...(input.originatingSessionId ? { originatingSessionId: input.originatingSessionId } : {}),
+                    ...(input.completionId ? { completionId: input.completionId } : {}),
                 }, input.scope ?? input.principal ?? "default");
             },
         };
@@ -151,6 +167,7 @@ export class WorkflowNotifyGate {
                     ...(sourceTaskId ? { sourceTaskId } : {}),
                     ...(principal ? { principal } : {}),
                     ...(originatingSessionId ? { originatingSessionId } : {}),
+                    ...(run.completionId ? { completionId: run.completionId } : {}),
                 }, entry.scope);
                 const after = await this.journal.get(entry.runId);
                 if (after?.acked)

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

@@ -52,7 +52,7 @@ export interface ParkDecisionLaneSeats {
  */
 export declare function parkDecisionStoreRefusal(seats: ParkDecisionLaneSeats): string | undefined;
 /**
- * 决定的同一性判据:判词 + 绑定两位 + 出处词(`decidedBy`)+ 载荷指纹(`updatedInput` / `answer` / `reason`,与 live 腿幂等回放的门⑦
+ * 决定的同一性判据:判词 + 绑定两位 + 出处词(`decidedBy`)+ 载荷指纹(`updatedInput` / `answer` / `reason` / `feedback`,与 live 腿幂等回放的门⑦
  * 同一只 {@link approvalPayloadFingerprint})。通道自报的 `approver` 不进 —— 它是归属标签,不改引擎铸的结算词。
  * 载荷序列化不了 ⇒ 抛(两侧都源自 JSON,走到这里是结构异常;那只函数自己已经响亮 warn)。
  */

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

@@ -36,6 +36,7 @@ export function parkDecisionFingerprint(outcome) {
         ...(outcome.updatedInput !== undefined ? { updatedInput: outcome.updatedInput } : {}),
         ...(outcome.answer !== undefined ? { answer: outcome.answer } : {}),
         ...(outcome.reason !== undefined ? { reason: outcome.reason } : {}),
+        ...(outcome.feedback !== undefined ? { feedback: outcome.feedback } : {}),
     });
     if (payload === null)
         throw new Error("workflow park decision: the decision payload cannot be serialized — refusing to record a decision whose identity cannot be stated");

package/dist/outbound-dispatcher.d.ts

@@ -1,5 +1,5 @@
 /**
- * S-776 —— server 进程出网的**唯一**一只 dispatcher:回环目标恒直连,其余按 `HTTP_PROXY` / `HTTPS_PROXY` / `NO_PROXY`
+ * [ref] —— server 进程出网的**唯一**一只 dispatcher:回环目标恒直连,其余按 `HTTP_PROXY` / `HTTPS_PROXY` / `NO_PROXY`
  * 交给 undici `EnvHttpProxyAgent`。**一只 dispatcher、一处安装、零旋钮** —— 代理变量本身就是配置通道。
  *
  * ── 病(test 黑盒追出,core 直讯 09-26)────────────────────────────────────────────────────────────
@@ -29,7 +29,7 @@
  * ⇒ `HTTPS_PROXY` 设了而 `NO_PROXY` 没写 localhost 时,`127.0.0.1` 上的本机网关 / 本机中心会被送进代理 —— 代理够不到本进程的回环,
  * 那是静默全断。所以回环目标在这里**先于** `NO_PROXY` 判、恒走直连 Agent;不看拓扑、不看客户端表态、没有旋钮(旋钮 = 让运维
  * 能把本机流量送进公司代理,没有任何部署形需要它)。判据集与 sema-cli 1.0.136 `src/utils/proxy.ts:104` `isLoopbackHost`
- * (壳 → 本机引擎那一跳的同形修 `LoopbackDirectDispatcher`,L-587)同一集,两段一致。
+ * (壳 → 本机引擎那一跳的同形修 `LoopbackDirectDispatcher`,[ref])同一集,两段一致。
  * **unix socket**:undici 的 `socketPath` 是连接器(`Agent` / `Client` 构造)选项,不是逐请求选项 ⇒ 打 unix socket 的调用必然自带
  * dispatcher,**结构上**不经过全局槽 —— 本模块没有、也不需要一条 unix 臂。
  *
@@ -60,7 +60,7 @@
  * 包装层就是链上多一节、`cause` 那一节换成同形副本)。隧道建好之后的失败(目标的 TLS、
  * 目标的响应)不经这个接缝,不冠代理 —— 那是目标的事。
  *
- * ── http 目标:绝对 URL 形,不建隧道(S-804;test 黑盒验收 A1)──────────────────────────────────────────────────
+ * ── http 目标:绝对 URL 形,不建隧道([ref];test 黑盒验收 A1)──────────────────────────────────────────────────
  * 病:undici `ProxyAgent` 的 `proxyTunnel` **代码缺省是 true**(7.30.0 `lib/dispatcher/proxy-agent.js` 构造器 `const { proxyTunnel = true } = opts`;它的文档写缺省 false,
  * 两处相反,以代码为准)⇒ 修前连 **http 网关**也被对代理发 `CONNECT host:80`;只放行 `:443` CONNECT 的代理(squid 缺省)拒掉它,run 约 175 s 后失败。
  * 现在构造 `EnvHttpProxyAgent` 时显式 `proxyTunnel:false`:**http 目标 ⇒ 绝对 URL 形请求**(`GET http://host/path`,undici 的 `Http1ProxyWrapper`),**https 目标 ⇒ 照旧 CONNECT**。
@@ -86,7 +86,7 @@
  * **拒启**(与 Node 24 `NODE_USE_ENV_PROXY=1` 遇坏值的行为同向)—— 静默直连 = 运维以为出网走了代理而实际没有,那是出网策略面的
  * fail-open;拒因只回显 display-safe 值。
  *
- * ── 建连失败的观察(S-925,7.108.0;test [ref] ② Windows 用户 VPN 中途切换)──────────────────────────────
+ * ── 建连失败的观察([ref],7.108.0;test [ref] ② Windows 用户 VPN 中途切换)──────────────────────────────
  * 病:建连失败(`UND_ERR_CONNECT_TIMEOUT` 一族)只有 undici 原句,不点名起服时读进的代理、不给「环境变了要重启」的出路。
  * 观察点 = undici 的**公开诊断通道**(`undici:request:create` / `:headers` / `:error`,进程级按名订阅,npm undici 与 Node 内建那一份
  * 同名同发):不包 handler、不动 dispatch 的热路径。{@link installOutboundDispatcher} 装一次:

package/dist/parent-watch.d.ts

@@ -1,5 +1,5 @@
 /**
- * 引擎 **parent 监视**([ref] 建座,S-292 改判据)。
+ * 引擎 **parent 监视**([ref] 建座,[ref] 改判据)。
  *
  * ## 防的是什么
  *
@@ -11,7 +11,7 @@
  * 的是「壳崩过一次以后就再也起不来了」。持锁 pid 不存在时 core 已自动剪陈旧锁,缺的只有「父死、子活」
  * 这一形。所以引擎给自己装一只**自查**腿:定期问一句"生我的那个还在吗"。
  *
- * ## 本腿**不**做什么(S-306,硬 breaking)
+ * ## 本腿**不**做什么([ref],硬 breaking)
  *
  * 它**不判死、不 drain、不退进程**。父没了只说明这台引擎成了**孤儿**,而「孤儿该不该退」是**租约**
  * 的问题:还有没有人附着、有没有在飞的 turn、静默够不够久 —— 那是 `boot/engine-lease.ts` 那一条腿,
@@ -45,7 +45,7 @@
  *
  *     强身份支**先判**:它成立时这一拍连探活都不发 —— 弱判据没有资格给一个已经被过继走的进程改口
  *     (僵尸父那一形里 `kill(pid,0)` 恰恰恒成功)。
- *  3. **单拍即判,不去抖**。[ref] 定稿是「15s 一拍、连续两拍才判定」(上界 30s),S-292 整条退役:
+ *  3. **单拍即判,不去抖**。[ref] 定稿是「15s 一拍、连续两拍才判定」(上界 30s),[ref] 整条退役:
  *     部署面的判据是「壳挂了以后数据根要在秒级重新可用」,而 `ESRCH` / `ppid` 都不是会抖的读数(两者
  *     都是内核的直答,不是采样值)。去抖买不到确定性,只买到 15s 的延迟和一个 30s 长的 pid-复用窗口。
  *  4. **命中一次即停探**(父不会复活),出口是 {@link ParentWatchDeps.onOrphaned} —— 装配层据此记下
@@ -88,7 +88,7 @@ export interface ParentWatchDeps {
      *  只会给一次计划内的停机添一条误导的 warn。 */
     isStopped: () => boolean;
     /**
-     * **唯一出口**(S-306):父不在了 ⇒ 把这台引擎标成孤儿。**至多调用一次**(命中即停探)。
+     * **唯一出口**([ref]):父不在了 ⇒ 把这台引擎标成孤儿。**至多调用一次**(命中即停探)。
      *
      * 🔴 它**不是** drain:退不退由 `boot/engine-lease.ts` 的租约律按「无附着 ∧ 无在飞 ∧ 静默满
      * `orphanLingerMs`」判。装配层拿到 reason 之后要做的只有一件事 —— 记下孤儿态(时刻 + 缘由)。

package/dist/parked-decide.d.ts

@@ -9,18 +9,19 @@
  * 行永 parked、生命周期分叉)。
  */
 import type { HostDecision } from "./host-decision.js";
+import type { DecideBinding } from "./http/wire-types.js";
 import type { BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, CheckpointToken, QuestionAnswer, RunInternals, TaskRegistry, ToolExecuteContext, WorkflowRun, WorkflowRunStore } from "@sema-agent/core";
 import type { ParkedReviveSurfaceFactory } from "./parked-revive-surface.js";
 import type { RebuiltInheritedGate } from "./boot/parked-revive-gate.js";
 import { type WorkflowRunParkKey, type WorkflowAgentSessionIndex } from "./orchestration/workflow-agent-session-index.js";
 import type { WorkflowParkDecisionStore, WorkflowParkOutcome } from "./orchestration/workflow-park-decision.js";
-import { type SessionFaceReader } from "./session-incarnation.js";
+import { type HeadRead } from "./session-incarnation.js";
 export interface ParkedAgentMatch {
     handle: string;
     row: BackgroundAgentRecord;
 }
 /**
- * S-185 车CM —— **park 的出身判别式**(全仓唯一的那一个)。
+ * [ref] 车CM —— **park 的出身判别式**(全仓唯一的那一个)。
  *
  * 一条 pending checkpoint 落到 `/decide` 时,它可能来自三种出身:①一只 parked 的**后台委派子代**
  * ([ref] 的第一条腿)、②一只 parked 的 **workflow 子代**(core 7.10.0 [ref] 开的第二条车道)、③一条
@@ -53,7 +54,7 @@ export type ParkOrigin = {
     park: WorkflowRunParkKey;
 }
 /**
- * **这条决定证不了属于哪一条记录**(core 7.44.0 #1319 的「没有持有者」两臂;判决属主 = 索引模块的 `routeWorkflowPark`)。
+ * **这条决定证不了属于哪一条记录**(core 7.44.0 [ref] 的「没有持有者」两臂;判决属主 = 索引模块的 `routeWorkflowPark`)。
  * `cause`:`unreadable` = 某一条点名这个子会话的记录 `parks[]` 读不出(条目形坏 / 这一位在场却不是列表;缺席 = 没有条目,不在此列)—— 它可能正是持有者;
  * `older_engine` = 点名它的条目没有持有者位(写于不带 `parkedBy` / `generation` 的引擎,升级那一刻还停驻着的存量记录)。
  * 两种都**响亮拒**(409 `decide.workflow_parks_unreadable`,码一个、句子按成因两句),一步都不驱动;出路按成因:`older_engine` = 去续跑 `runId` 那条 run
@@ -80,7 +81,7 @@ export type ParkOrigin = {
 /** 判别式的两个源。各自可缺席(部署没接就是没接)—— 缺席 ⇒ 那条臂不判,不是失败。 */
 export interface ParkOriginSources {
     agentStore?: BackgroundAgentStore;
-    /** S-185:workflow 出身的**有界** join 索引(契约见 orchestration/workflow-agent-session-index.ts)。 */
+    /** [ref]:workflow 出身的**有界** join 索引(契约见 orchestration/workflow-agent-session-index.ts)。 */
     workflowIndex?: WorkflowAgentSessionIndex;
     /** 索引只回答「去哪条 run 找」,条目本体(含赎回键)仍以 run 记录的 `parks[]` 为准 ⇒ 两件必须成对在场。 */
     workflowRunStore?: Pick<WorkflowRunStore, "get">;
@@ -144,17 +145,18 @@ export interface ParkedDecideDeps {
     checkpointStore: Pick<CheckpointStore, "get">;
     /** 与 reaper/scenarios 同一个 registry(claim/rollback 的 CAS 与 in-memory handle 收敛在同处)。 */
     registry: Pick<TaskRegistry, "claimParkedAgent" | "rollbackParkedClaim">;
-    /** #1110(core 7.32.0):按**行**解析赎回面 —— 驱动哪一只 Agent 工具(生产装配,与 spawn 同源:subRunner / bg opts /
+    /** [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;
     /**
-     * S-790([ref] §4)—— 会话面读口(`sessionStorage.sessionFaceOf`:属主 + 化身一次读)。**必填**:本腿对根会话读两次 ——
+     * [ref]([ref] §4)—— 会话店按 id 读一行的唯一读口(`sessionStorage.headOf`:属主 + 化身 + 叶子一次读;活住客经 `sessionFaceOfHead`
+     * 投影,空化身响亮拒)。**必填**:本腿对根会话读两次 ——
      * claim 之前一次、claim 成功之后一次 —— 会话不在或两次不是同一位住客 ⇒ 回滚 claim、答既有的 `409 decide.not_parked`;赎回面只在
      * 属主相等且两次是同一位住客时交继承座。读抛 ⇒ claim 前原样上抛(没有东西要回滚),claim 后先回滚再上抛。
-     * (#1110 那只可选的 `sessionOwnerOf` 退役:可选 ⇒ 缺席时静默不复核,正是 S-790 那个窗的形。)
+     * ([ref] 那只可选的 `sessionOwnerOf` 退役:可选 ⇒ 缺席时静默不复核,正是 [ref] 那个窗的形。)
      */
-    sessionFaceOf: SessionFaceReader;
+    headOf: HeadRead;
     /** revive args 的 `subagent_type` 成员性判定集([ref] Q1 修正:非 roster 成员必须省略,否则
      *  unknown subagent_type 拒;字面比对 general-purpose 在 roster 撞名时会错省)。缺省空集=恒省略。 */
     knownAgentTypes?: ReadonlySet<string>;
@@ -172,7 +174,7 @@ export interface ParkedDecideDeps {
         principal: string | undefined;
     }) => Promise<RebuiltInheritedGate | undefined>;
     /**
-     * 🔴 S-877 四续 ⑪ —— 复活子代**自己的**审批席(`ToolExecuteContext.onAsk`:core 的委派工具把它转给子代,子代自己的引擎问 —— 模式写门 /
+     * 🔴 [ref] 四续 ⑪ —— 复活子代**自己的**审批席(`ToolExecuteContext.onAsk`:core 的委派工具把它转给子代,子代自己的引擎问 —— 模式写门 /
      * 形状层 —— 在这里答)。本腿直接调 `execute`,不经 Runner,ctx 由本腿铸;不给 ⇒ 子代自己的问落 subRunner 的 `deps.onAsk`(协调器
      * `ask()` 的无 ALS 上下文臂,没有会话身份 ⇒ 读不了会话授权 ⇒ 每条非只读命令 / 每次写都再 park,`remember:"session"` 对复活子代无效;
      * 子代活着时同一问落父的席、带身份、读得到授权 —— 同一个子代两种答案)。生产 = 协调器的窗 0 席 `boundUnattendedAsk`(与 bg run 腿给父任务
@@ -193,7 +195,7 @@ export interface ParkedDecideRequest {
     /** cp.pendingAction 原样(outcome 铸造的 persisted 回落源,与 legacy 腿 D-1 姿势逐字同形)。 */
     pendingAction: unknown;
     decision: "approve" | "deny";
-    /** [ref] 件6③ / S-136(core 7.6.0 S6-A):**这次结算的事实**,由调用方陈述(必填,理由与 legacy 腿
+    /** [ref] 件6③ / [ref](core 7.6.0 S6-A):**这次结算的事实**,由调用方陈述(必填,理由与 legacy 腿
      *  `resumeCheckpoint` 的同名参数逐字同源 —— 本函数分辨不出谁在叫它,漏报要是编译错而不是假出处)。
      *  🔴 宿主报**事实**(谁结束的 + 通道自报的归属),core 铸**词**:`human_allowed` / `human_refused` /
      *  `park_sla_expired` 由 core 在 resume 入口铸出来,写进行的 `resolvedOutcome.gateOutcome` 与那次调用的
@@ -204,11 +206,7 @@ export interface ParkedDecideRequest {
     reason?: string;
     /** D-1 decision-binding echo(操作员在 GET 看到的 boundCallId/boundInputHash 原样透传;server
      *  绝不重算,core resume 侧做 fail-closed 等值校验——与 legacy 腿同姿势)。 */
-    binding?: {
-        boundCallId?: string;
-        boundInputHash?: string;
-        updatedInput?: unknown;
-    };
+    binding?: Omit<DecideBinding, "checkpointToken">;
     /** body 带了 `remember:"session"` 时路由传入的 grant 执行器([ref] 候裁② 的 server 侧修,经两轮
      *  行为探针实证):豁免必须锚在**行的 root/host 会话 id**——部署侧三个豁免探针(policy 层/fs-write
      *  门/workflow 门)的闭包统一捕获 host 会话键且签名不携身份(1.393 seam 亲读:`sourceTaskId` 只在
@@ -230,7 +228,7 @@ export interface ParkedDecideResult {
     body: Record<string, unknown>;
 }
 /**
- * 两条 park 车道(bg 赎回 / workflow 驱动)共用的 **`ResumeOutcome` 铸点**(S-185 车CM 单点化)。
+ * 两条 park 车道(bg 赎回 / workflow 驱动)共用的 **`ResumeOutcome` 铸点**([ref] 车CM 单点化)。
  *
  * 判据一字未改,只是从 bg 腿里提出来:两条腿结算的是**同一种门**(core gateMatch 的 `policy_ask`),
  * 各铸一份必然漂移,而漂的是「人到底批了什么」这条审计事实。
@@ -247,10 +245,12 @@ export interface ParkedDecideResult {
  * · `hostDecision` = 结算**事实**逐字上 outcome;`gateOutcome` 一格 server **永不**填(core 对宿主
  *   自铸的结算词是 pre-CAS 响亮拒)。
  * · `answer` 原样透传([ref]:header 逐字匹配等语义校验全在 core,server 不预判)。
+ * · `feedback`(core 7.54.0):绑定里有就原样上 outcome —— 决定口只在人的放行上收它(拒决 / 策略的决定上带它是门口 400),本铸点不再按判词剪
+ *   (剪 = 静默丢一段人写的话;门口已拒的形到不了这里,引擎在 claim 前再判一次);什么算写了字(空白读作没写)是引擎的读法,本铸点不 trim。
  */
 export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): WorkflowParkOutcome;
 /**
- * S-185 车CM —— **第三条车道的计划**(纯函数;驱动本身归 resume 家族的那条腿,见下方「为什么不自建驱动」)。
+ * [ref] 车CM —— **第三条车道的计划**(纯函数;驱动本身归 resume 家族的那条腿,见下方「为什么不自建驱动」)。
  *
  * ## 这条车道为什么长这样(亲读 core 实现后的结论,不是从类型面推的)
  * 任务书原案是「server 直接 `startWorkflow({resumeFromRunId, parkedResume})`」。亲读安装的 core
@@ -310,14 +310,14 @@ export type WorkflowParkedDecidePlan = {
  *    `readRunParks`)。续跑**不是**出路:读不出的那条记录的指针不随任何后继记录消失,续跑之后规则 ① 照旧整卡拒(条目形坏的记录引擎本来也拒续跑);
  *    出路 = 运维修好那条记录(`runId`),之后在这里决就正常。
  *
- * 🔴 **S-376(词域门)**:句子不提 `checkpointToken`(契约 D-1 逐字:server-INTERNAL、合规 SDK 绝不发送)与内部机件名;判据与冻结钉见
+ * 🔴 **[ref](词域门)**:句子不提 `checkpointToken`(契约 D-1 逐字:server-INTERNAL、合规 SDK 绝不发送)与内部机件名;判据与冻结钉见
  * `test/api-error-text-lexicon.test.ts` / `test/api-error-text-freeze.test.ts`。
  */
 export declare function denyWorkflowParksUnreadable(origin: Extract<ParkOrigin, {
     kind: "workflow_parks_unreadable";
 }>): ParkedDecideResult;
 /**
- * **分叉**的响亮拒(core 7.44.0 #1319:引擎准入同一条 run 的两次先后续跑,把拒交给消费方)。同一张卡上并列着两条以上同代次的
+ * **分叉**的响亮拒(core 7.44.0 [ref]:引擎准入同一条 run 的两次先后续跑,把拒交给消费方)。同一张卡上并列着两条以上同代次的
  * 持有记录 ⇒ 没有唯一一条可以交付;不猜、不按写序取。体带并列的 `runIds`(升序;与同族 `runId` 同为顶层键)。出路 = 续跑其中一条:
  * 它走到这张停驻时代次更高,之后在这里决就正常。卡仍 pending,什么都没投递。
  */
@@ -330,7 +330,7 @@ export declare function planWorkflowParkedDecide(origin: Extract<ParkOrigin, {
 /**
  * `/decide` parked 赎回腿([ref] 件3d server 半场;[ref]/[ref]/[ref] core 裁定形)。
  *
- * 调用方先经 {@link findParkOrigin} 判出 `kind:"background"` 再进来(S-185 车CM:判别只做一次);
+ * 调用方先经 {@link findParkOrigin} 判出 `kind:"background"` 再进来([ref] 车CM:判别只做一次);
  * 返回的结果对象 = 赎回腿已受理/已拒,调用方直接回 HTTP。
  *
  * 链:`claimParkedAgent`(access = 行镜像双轴

package/dist/parked-decide.js

@@ -1,11 +1,12 @@
+import { compareOccupants } 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";
 import { defaultSubagentTailBus } from "./fleet/subagent-tail-bus.js";
 import { backgroundScopesForCheckpointScope, decodeCheckpointScope, ownerOfCheckpointScope } from "./security.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "./approval-content-kind.js";
-import { sameSessionOccupant } from "./session-incarnation.js";
-import { refusalBody } from "./http/refusal-body.js";
+import { sessionFaceOfHead } from "./session-incarnation.js";
+import { refusalBody, resumeRefusalFacts } from "./http/refusal-body.js";
 export async function findParkOrigin(sources, cp) {
     if (sources.agentStore !== undefined) {
         let match;
@@ -125,6 +126,7 @@ export function buildParkedResumeOutcome(req) {
         boundInputHash: req.binding?.boundInputHash ?? persistedHash,
         decision: req.decision === "approve" ? "allow" : "deny",
         ...(req.decision === "approve" && req.binding?.updatedInput !== undefined ? { updatedInput: req.binding.updatedInput } : {}),
+        ...(req.binding?.feedback !== undefined ? { feedback: req.binding.feedback } : {}),
         ...(req.answer !== undefined ? { answer: req.answer } : {}),
         ...(req.reason !== undefined ? { reason: req.reason } : {}),
         hostDecision: req.hostDecision,
@@ -246,7 +248,7 @@ export async function decideParkedAgent(deps, req, match) {
     if (root === undefined) {
         return { status: 409, body: refusalBody({ errorCode: "decide.row_unrevivable", message: "this agent's row carries no root session anchor — the revive path cannot tell which session this approval belongs to (row damaged?)", facts: { taskId: match.handle } }) };
     }
-    const faceBefore = await deps.sessionFaceOf(root);
+    const faceBefore = sessionFaceOfHead(root, await deps.headOf(root));
     if (faceBefore === undefined)
         return sessionGone(match.handle);
     const inheritedGate = deps.rebuildInheritedGate ? await deps.rebuildInheritedGate(row, { principal: decodeCheckpointScope(req.scope) }) : undefined;
@@ -286,13 +288,13 @@ export async function decideParkedAgent(deps, req, match) {
     };
     let faceAfter;
     try {
-        faceAfter = await deps.sessionFaceOf(root);
+        faceAfter = sessionFaceOfHead(root, await deps.headOf(root));
     }
     catch (e) {
         await rollback("session_face_unreadable");
         throw e;
     }
-    if (!sameSessionOccupant(faceBefore, faceAfter)) {
+    if (compareOccupants(faceBefore, faceAfter) !== "same") {
         await rollback("session_occupant_changed");
         return sessionGone(match.handle);
     }
@@ -369,6 +371,7 @@ export async function decideParkedAgent(deps, req, match) {
                         taskId: match.handle,
                         rollback: disp,
                         ...(cause !== undefined ? { cause } : {}),
+                        ...resumeRefusalFacts(receiptDetails.detail),
                     },
                 }),
             };

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

@@ -1,5 +1,5 @@
 /**
- * #1110(core 7.32.0)—— `/decide` parked 赎回腿的**赎回面**:驱动哪一只 Agent 工具,以及交不交继承座
+ * [ref](core 7.32.0)—— `/decide` parked 赎回腿的**赎回面**:驱动哪一只 Agent 工具,以及交不交继承座
  * `ToolExecuteContext.mountsCallerTool`。
  *
  * core 7.32.0 起 Agent 子代按**身份**继承场景层工具(bundle 交给 Agent 的 `inheritedTools` ∩ 父 run 的 `spec.tools`),由宿主
@@ -11,20 +11,20 @@
  *    给那个会话的 run 组 `spec.tools` 的同一只工厂、同一个会话分区(任务清单店 `taskListStoreFor(root)` 与领队那一张是同一张;
  *    多租户的 WebFetch 过滤同样生效 ⇒ 子代同样拿不到)。座 = `(t) => tools.includes(t)`(身份判:同名副本不算)。
  *  · **禁**用 boot 期单例填座:那只 bundle 没有会话,它的任务清单是一张私有表 —— 填了座,每个会话 / 租户的复活队友都会共用它。
- *  · **根会话现在还是这张卡的那一位住客**才填座(codex r1 [high] + S-790 加严):任务清单店只按会话 id 分区,而会话 id 由调用方自选、
+ *  · **根会话现在还是这张卡的那一位住客**才填座(codex r1 [high] + [ref] 加严):任务清单店只按会话 id 分区,而会话 id 由调用方自选、
  *    删后可被别人(或同一个人)重领 —— 根会话删了(或删了重建)之后赎回一张旧卡,按 id 重解出来的是**下一位住客**的清单。判据两条都要:
  *    ① 根会话的属主与卡的权威 principal 逐字相等;② 赎回腿 claim 前 / 后两次读到的是**同一位住客**(化身逐字相等,
- *    `session-incarnation.ts` 的 `sameSessionOccupant`)—— 只比属主比不出「同一个人删了重建」。任一条不成立 / 读数缺席 ⇒ 不交座
+ *    core 的 `compareOccupants` 答 `same`;`unknown` 不算)—— 只比属主比不出「同一个人删了重建」。任一条不成立 / 读数缺席 ⇒ 不交座
  *    (fail-closed:子代不继承,继承工具上的 allow 回 422、审批待决,deny 照结)。赎回腿自己在两次读不一致时整条拒(`409 decide.not_parked`),
- *    这里的第 ② 条是同一条事实在交座这一处的判据(规则只写在这里,腿只负责读两次)。根删除时把子孙的 parked 卡一并作废 = S-790 件 B
+ *    这里的第 ② 条是同一条事实在交座这一处的判据(规则只写在这里,腿只负责读两次)。根删除时把子孙的 parked 卡一并作废 = [ref] 件 B
  *    (`boot/session-faces.ts` 的删除协调器)。
  *  · 只对**一层**行填座(`rootSessionId` 在场且 = `parentSessionId`:派它的 run 就是根会话的 run,列表正是那个 run 的挂载)。更深的行
  *    (孙代:派它的是一个子代,它的挂载是继承裁剪后的子集,行上读不出来)不填 —— 无座 = core 的 fail-closed 臂;
- *    行上带继承组成是 core #1112(7.32.x)的半场,到货再改读行。
+ *    行上带继承组成是 core [ref](7.32.x)的半场,到货再改读行。
  * 近似如实记:重解的列表是**部署缺省**那一份,读不回那一 run 的逐请求差异(`settings.webSearch` 后端、center overlay 场景)——
  * 座只判 bundle 实例的成员性,继承面是 `[...web, ...scaffolds]`,那两项差异不改变谁在面内。
  *
- * **属主来源(S-1770 / S-1808)与交座是两个独立判据**:赎回工具的停驻挂点(复活的子代再要审批时停驻,`plugins/session-store.ts`)按委派继承律定宿主行属主,
+ * **属主来源([ref] / [ref])与交座是两个独立判据**:赎回工具的停驻挂点(复活的子代再要审批时停驻,`plugins/session-store.ts`)按委派继承律定宿主行属主,
  * 律要的是**委派树根的见证**:根 id(行上本来就带 `rootSessionId`)+ 判断那一刻读到的根行住客(赎回腿 claim 前后两读的那一位 —— 两读不是同一位时赎回腿整条拒,
  * 走不到这里;读数缺席 ⇒ 见证不带住客,挂点那一刻根行在 ⇒ 停驻否决)。所以**每一行**都交出它({@link ScenarioContext} 的 `delegationRoot`):交座的一层行以
  * `{ sessionId: root, delegationRoot }` 重解,不交座的行(更深的行、根住客已变的一层行、读数缺席)以 `{ delegationRoot }` 重解 —— 只喂停驻挂点,不挂任何会话级设施、
@@ -33,7 +33,7 @@
  */
 import { type BackgroundAgentRecord, type ToolSpec } from "@sema-agent/core";
 import type { Scenario } from "./capabilities/scenarios.js";
-import { type SessionFace } from "./session-incarnation.js";
+import type { SessionFace } from "./session-incarnation.js";
 /** 一次赎回用的面:驱动的 Agent 工具(它的停驻挂点绑着行上的根)+ (交座时)与它同出一张列表的继承座。 */
 export interface ParkedReviveSurface {
     readonly reviveTool: ToolSpec;

package/dist/parked-revive-surface.js

@@ -1,5 +1,4 @@
-import { DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
-import { sameSessionOccupant } from "./session-incarnation.js";
+import { DEFAULT_SUBAGENT_TOOL_NAME, compareOccupants } from "@sema-agent/core";
 const agentOf = (tools) => tools.find((t) => t.name === DEFAULT_SUBAGENT_TOOL_NAME);
 export function createParkedReviveSurface(defaultScenario) {
     const bootTool = agentOf(defaultScenario({}).tools);
@@ -20,7 +19,7 @@ export function createParkedReviveSurface(defaultScenario) {
 }
 function holdsSeat(oneLevel, identity) {
     const face = identity.root;
-    if (!oneLevel || face === undefined || !sameSessionOccupant(face.before, face.after))
+    if (!oneLevel || face === undefined || compareOccupants(face.before, face.after) !== "same")
         return false;
     return (face.before.owner ?? undefined) === identity.principal && (face.after.owner ?? undefined) === identity.principal;
 }

package/dist/peer-directory.d.ts

@@ -11,7 +11,7 @@
  * ## 为什么复用那只 lister,而不是自己写一条 JOIN(设计稿 §2 给的是 SQL 形,这里收得更紧)
  *
  * 设计稿 §4-1 的承重条款是「**成员资格 = 会话读面的那一只属主可读谓词,一字不另写**」。自己写一条 JOIN
- * 就必须自己带一份属主谓词 —— 那正是兔子洞 S-487「属主判定单一存取器」要消灭的第 10 处手抄,而且两份
+ * 就必须自己带一份属主谓词 —— 那正是兔子洞 [ref]「属主判定单一存取器」要消灭的第 10 处手抄,而且两份
  * 谓词**一定**会漂(存量 `owner IS NULL` 的窄互认臂、`placement_kind IS NULL` 的 [ref] 义务、keyset 排序
  * 口径三条都要各抄一遍)。改读同一只 `listSessions` 之后,**成员资格**不再是一条需要测试盯住的断言,
  * 而是结构上的同一次调用;SQL 面因此也一个字节都不用改。
@@ -31,7 +31,7 @@
  * ⚠️ 与设计稿的第二处收紧(亲读实现推翻稿面):稿里把谓词写成 `principal-gate.ts runOwnerReadable`。
  * 亲读两只函数后不成立 —— `runOwnerReadable(p, owner, cfg)` 对 `owner === null` **无条件**放行
  * (`principal-gate.ts:136-137`,函数体第一行),而**列表面**的第三条件由 store 的
- * `owner = ? OR owner IS NULL` 承载,开关是 `legacyUnownedAmnestyOpen(requirePrincipal, gateOwner)`
+ * `owner = ? OR owner IS NULL` 承载,开关是 `legacyUnownedAmnestyOpen(deployment, gateOwner)`
  * (`security.ts:119`,它的头注逐字:
  * 「单独存在的唯一理由是**列表面**……单实体读/写点一律用三条件齐的 `legacyUnownedSessionOk`」)。
  * 拿 `runOwnerReadable` 当列表谓词会让目录比 `GET /v1/sessions` **多列出**别人的无主会话 —— 正好违反
@@ -56,7 +56,7 @@
  *    墓碑随箱亡,级联跑完之后那个 id 就是「不存在」—— 理由全文在 `plugins/mailbox-recipient-lifecycle.ts`),
  *    同句柄上**墓碑压过活行**;**`"dead"` v1 不铸**
  *    (core `list-agents-tool.js` 的清单过滤:deleted 行跳过、dead 行在缺省 `includeDead` 下也跳过
- *    —— ⚠️ S-516:这里**不写 dist 行号**,那批坐标每次提货都漂(7.23.5→7.24.2 就整段搬了家);
+ *    —— ⚠️ [ref]:这里**不写 dist 行号**,那批坐标每次提货都漂(7.23.5→7.24.2 就整段搬了家);
  *    要复核请按符号名搜。⇒ 把闲置会话映成 dead
  *    等于把用户自己的闲置会话从 `ListAgents` 里藏掉,正是本席要解的那个面。忙闲一律走 `tempo`);
  *  · `tempo` = `sessionTempoOfRunStatus(lastStatus)`(`plugins/store-contracts.ts` 的那**一张**表,

package/dist/peer-directory.js

@@ -13,7 +13,7 @@ export function createPeerDirectory(ctx) {
     return {
         listPeerSessions: async (access) => {
             const scope = access.scope;
-            const includeUnowned = legacyUnownedAmnestyOpen(requirePrincipal, scope);
+            const includeUnowned = legacyUnownedAmnestyOpen({ requirePrincipal }, scope);
             const rows = await lister({ owner: scope, ...(includeUnowned ? { includeUnowned: true } : {}), limit: PEER_DIRECTORY_CAP + 1 });
             const truncated = rows.length > PEER_DIRECTORY_CAP;
             if (truncated) {

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

@@ -8,10 +8,19 @@
  *
  * 为什么住在一只叶模块里(不留在 `task-settings.ts`):本模块只 import core 与契约包 settings-schema(纯叶),读者引它不成环。
  */
-import { type PathRuleBases, type PermissionRule, type ToolPolicy } from "@sema-agent/core";
+import { type PathRuleBases, type PermissionRule, type PermissionRulePolicyOptions, type ToolPolicy } from "@sema-agent/core";
 /** 一张表里规则条数的上限 —— 请求腿 wire 门(`task-settings.ts` 的 deny / ask 两桶判形)读的也是这一个名字:core 的缺省帽是 256,
  *  不对齐的话第 257 条起编译当场抛,等于服务端自己收下的东西自己反悔。 */
 export declare const MAX_PERMISSION_RULES_PER_LIST = 1000;
+/**
+ * **一张规则表的判据选项** —— 编译口({@link createRuleListPolicy})与预判口(`config.ts` 的 `uncompilableRuleGuidance`:请求 / 存体重放 422 之前的那一问)读的
+ * 是这同一份,于是「这条规则文本编不编得出来、编出来是什么」只有一个答案:预判拒 ⇔ 编译抛,码与句相同(`test/core755-host-rule-deny-faces.test.ts` ④)。
+ *
+ * 型只开 `caps` / `pathBases` 两位,**不含 `ruleFaces`**:规则表在请求受理时编译,那时没有一条腿的名册;引擎不带名册的那条路自己读目录面
+ * (`catalogRuleFaceView`,core 7.55.0 [ref] 起目录给每一行声明参数词表 ⇒ 无面参数 `unsupported.param_unknown`),目录面只在引擎里取这一处。
+ * 交一只名册解析器会多出一种读法:目录没有的名字成 `unsupported.tool_unknown` —— 本仓自铸的工具(`repo_read_file(path:…)`)上一条编得出、真判的规则会在受理口被拒。
+ */
+export declare function buildRuleListJudgeOptions(pathBases: PathRuleBases | undefined): Pick<PermissionRulePolicyOptions, "caps" | "pathBases">;
 /** A name-keyed rule-list ToolPolicy: a tool named by `names` gets `behavior` (`ask` tightens to an approval gate;
  *  `deny` hard-blocks); every other tool is out of scope (`defaultAction: "allow"` = this policy has no opinion about
  *  anything it does not name — core 7.42.0: it states nothing and clears nothing). Composed deny-wins with the rest of

package/dist/permission-rule-list.js

@@ -1,13 +1,15 @@
 import { createPermissionRulePolicy } from "@sema-agent/core";
 import { stripControlAndBidi } from "@sema-agent/settings-schema";
 export const MAX_PERMISSION_RULES_PER_LIST = 1_000;
+export function buildRuleListJudgeOptions(pathBases) {
+    return {
+        caps: { maxRules: MAX_PERMISSION_RULES_PER_LIST },
+        ...(pathBases !== undefined ? { pathBases } : {}),
+    };
+}
 export function createRuleListPolicy(names, behavior, source, pathBases) {
     try {
-        return createPermissionRulePolicy(names.map((name) => ({ rule: name, behavior, source })), {
-            defaultAction: "allow",
-            caps: { maxRules: MAX_PERMISSION_RULES_PER_LIST },
-            ...(pathBases !== undefined ? { pathBases } : {}),
-        });
+        return createPermissionRulePolicy(names.map((name) => ({ rule: name, behavior, source })), { defaultAction: "allow", ...buildRuleListJudgeOptions(pathBases) });
     }
     catch (e) {
         const coreMsg = stripControlAndBidi(e instanceof Error ? e.message : String(e));