@sema-agent/server 7.134.0 → 7.135.0

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

@@ -15,13 +15,13 @@ 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] 开的第二条车道)、③一条
@@ -54,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
@@ -81,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">;
@@ -145,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>;
@@ -173,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 腿给父任务
@@ -194,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` 与那次调用的
@@ -227,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`),
  * 各铸一份必然漂移,而漂的是「人到底批了什么」这条审计事实。
@@ -249,7 +250,7 @@ export interface ParkedDecideResult {
  */
 export declare function buildParkedResumeOutcome(req: ParkedDecideRequest): WorkflowParkOutcome;
 /**
- * S-185 车CM —— **第三条车道的计划**(纯函数;驱动本身归 resume 家族的那条腿,见下方「为什么不自建驱动」)。
+ * [ref] 车CM —— **第三条车道的计划**(纯函数;驱动本身归 resume 家族的那条腿,见下方「为什么不自建驱动」)。
  *
  * ## 这条车道为什么长这样(亲读 core 实现后的结论,不是从类型面推的)
  * 任务书原案是「server 直接 `startWorkflow({resumeFromRunId, parkedResume})`」。亲读安装的 core
@@ -309,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,什么都没投递。
  */
@@ -329,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,10 +1,11 @@
+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 { sessionFaceOfHead } from "./session-incarnation.js";
 import { refusalBody, resumeRefusalFacts } from "./http/refusal-body.js";
 export async function findParkOrigin(sources, cp) {
     if (sources.agentStore !== undefined) {
@@ -247,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;
@@ -287,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);
     }

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));

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

@@ -10,7 +10,7 @@ import type { RuleBehavior } from "@sema-agent/core";
  */
 export declare function isPersistedRuleTool(name: string): boolean;
 /**
- * S-511 —— `RuleBehavior` 每一员在**无同意仪式的直接写口**(`POST /v1/rules`)上的逐员表态。
+ * [ref] —— `RuleBehavior` 每一员在**无同意仪式的直接写口**(`POST /v1/rules`)上的逐员表态。
  *
  * 为什么是一张**表**而不是一句 `behavior !== "allow"`:后者对 core 加员是**静默放行** —— 将来多一个
  * 放宽方向的态,它会直接从这条收紧口写进店,而没有任何一行代码会红。`Record<RuleBehavior, boolean>`
@@ -41,7 +41,7 @@ export declare function isDirectWritableRuleBehavior(behavior: RuleBehavior): be
  * `"unknown"` = **回答这一问的那次读回没做成** —— 这个域唯一不肯说的那句话是「看不见 ⇒ 没有」,
  * 第三个词就是它的反面。
  *
- * 🔴 **型从 core 的包根导出接过来,本仓零抄**(core 7.26.0 S-538 ⓐ:`RemovalLiveness` 随请托上了导出面)。
+ * 🔴 **型从 core 的包根导出接过来,本仓零抄**(core 7.26.0 [ref] ⓐ:`RemovalLiveness` 随请托上了导出面)。
  * 上一版是 `Extract<RemoveResult, {status:"removed"}>["stillLive"]` —— 那是派生而非手抄(值不会漂),但它把
  * 一只**独立的闭集**寄生在某一个臂的形状上:core 哪天给 `removed` 臂改名、或让这只词表先在别的臂上落地,
  * 派生式就会指向一个与词表无关的东西。现在两者同名同源。

package/dist/plugins/adoption-log-sql.d.ts

@@ -107,7 +107,7 @@ export interface AdoptionLogStore {
 /** MySQL 协议方言的建表语句(展开进 tidb-pool 的中央 `SCHEMA_STATEMENTS`,与 approval-ask 同姿势:
  *  跟着中央 ensureSchema 在 named-lock 的那条 conn 上建,不绕开 DDL 串行化)。 */
 export declare const TIDB_ADOPTION_LOG_STATEMENTS: readonly string[];
-/** S-287:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensurePgAdoptionLogSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
+/** [ref]:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensurePgAdoptionLogSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
 export declare const ADOPTION_LOG_INDEXES: readonly IndexSpec[];
 /** PostgreSQL 孪生(由 `ensurePgSchema` 在 advisory lock 的那条 client 上调用)。 */
 export declare function ensurePgAdoptionLogSchema(q: (text: string, params?: unknown[]) => Promise<unknown>): Promise<void>;

package/dist/plugins/approval-ask-store-file.d.ts

@@ -174,7 +174,14 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
      * 「没带编辑」的记录,而活路径那一侧是抛。编码抛 ⇒ 账本一个字节没写、内核一个字节没动(与内核自己的
      * 「先编码、编码成功才一次性提交」同一条原子性)。
      */
-    decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * 🔴 [ref] —— **出域的一次决议不落账本**。作用域的属主维(`owner`,判据 {@link askRowCarriesOwner})不在记录上:行此刻不带着门判过的那位属主
+     * ⇒ 内核上这一笔必输、零写(读钟也在判定之后,不开账本窗)⇒ 没有要重放的东西,直调内核拿它的输者答案(与留存两动词「空的一次不落」同一条先例)。
+     * 判定、落账、内核调用都在同一个同步前缀里,其间行不可能换属主。于是**落了账的每一条决议都在域内**,重放按行自己的属主喂属主维
+     * ({@link FileApprovalAskStore.replayOp})—— 记录形一个字节不变:升级前写下的账本、升级后写下的账本、降级回老版本时老读者读新账本,三者同读,
+     * 零迁移、零双读。
+     */
+    decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
     claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent, opts?: AskTerminalClaimOpts): Promise<AskTerminalClaimOutcome>;
     expireAsk(askId: string, batchId: string): Promise<ExpireResult>;
     bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;

package/dist/plugins/approval-ask-store-file.js

@@ -5,6 +5,7 @@ import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { StoreBootRefusalError } from "./store-contracts.js";
 import { InMemoryApprovalAskStore, encodeDecideUpdatedInput, encodeStoreJsonPayload } from "./approval-ask-store-memory.js";
+import { askRowCarriesOwner } from "./approval-ask-store-sql.js";
 export const APPROVAL_ASK_DIR = "approval-asks";
 export const APPROVAL_ASK_JOURNAL_FILE = "asks.jsonl";
 export const ASK_JOURNAL_COMPACT_MIN_RECORDS = 2_000;
@@ -187,7 +188,7 @@ export class FileApprovalAskStore {
             case "transitionAsk":
                 return this.core.transitionAsk(rec.askId, rec.from, rec.to, rec.patch);
             case "decideAsk":
-                return this.core.decideAsk(rec.askId, rec.batchId, rec.decision);
+                return this.core.decideAsk(rec.askId, rec.batchId, this.core.peekAsk(rec.askId)?.owner ?? null, rec.decision);
             case "claimTerminal":
                 return this.core.claimTerminal(rec.askId, rec.batchId, rec.intent, rec.cause !== undefined ? { cause: rec.cause } : undefined);
             case "claimTerminalRefuse":
@@ -220,9 +221,11 @@ export class FileApprovalAskStore {
     async transitionAsk(askId, from, to, patch) {
         return this.write({ op: "transitionAsk", askId, from, to, patch }, (c) => this.core.transitionAsk(c.askId, c.from, c.to, c.patch));
     }
-    async decideAsk(askId, batchId, decision) {
+    async decideAsk(askId, batchId, owner, decision) {
         const journalled = decision.updatedInput === undefined ? decision : { ...decision, updatedInput: encodeDecideUpdatedInput(decision.updatedInput) };
-        return this.write({ op: "decideAsk", askId, batchId, decision: journalled }, (c) => this.core.decideAsk(c.askId, c.batchId, c.decision));
+        if (!askRowCarriesOwner(this.core.peekAsk(askId), owner))
+            return this.core.decideAsk(askId, batchId, owner, journalled);
+        return this.write({ op: "decideAsk", askId, batchId, decision: journalled }, (c) => this.core.decideAsk(c.askId, c.batchId, owner, c.decision));
     }
     async claimTerminal(askId, batchId, intent, opts) {
         switch (intent) {

package/dist/plugins/approval-ask-store-memory.d.ts

@@ -4,7 +4,7 @@
  * Node 单线程下这就是天然原子:`Promise.all` 发起的并发调用不会在方法体内部交错执行,与
  * `approval-ask-store-sql.ts` 的 CAS UPDATE 语义逐字段一致(SQL twin 对拆套件的基准就是这份实现）。
  *
- * 🔴 **S-384:本类同时是 `FileApprovalAskStore` 的内核**(local 车道的持久形不再是「第二份手抄」——
+ * 🔴 **[ref]:本类同时是 `FileApprovalAskStore` 的内核**(local 车道的持久形不再是「第二份手抄」——
  * 它把本类**原样**包起来,每次写前先把**调用本身**落 JSONL、重放时用同一只内核重放同一串调用)。
  * 为此本类多了这几件、且**只**多这几件(全是数据面,零转移判定):
  *  · {@link InMemoryApprovalAskStore.constructor} 的可注入钟 `now` —— 五个动词(decideAsk / claimTerminal /
@@ -18,6 +18,8 @@
  *    File 形里另写一套「哪些行还算数」的判据 —— 那才是第二份手抄。
  *  · {@link InMemoryApprovalAskStore.planReapSettledAsks} / {@link InMemoryApprovalAskStore.planReapEmptyBatches} —— 两只留存动词的
  *    **纯读选择**(删哪些行)。File 形据它判「这一次有没有东西可删」,空的一次不落账本;删除本身仍是接口动词,与选择共用这一只。
+ *  · {@link InMemoryApprovalAskStore.peekAsk} —— 一行的**同步**点读(纯读,零判定)。File 形在写口的同步前缀里据它判「这次决议在不在
+ *    属主域内」(出域的一次不落账本)、重放时据它喂行自己的属主([ref],理由在 File 形的 `decideAsk`)。
  *
  * 行为口径与 `SqlApprovalAskStore` 逐条对齐:
  *  - ensureAsk 幂等 upsert(ask_id 已在 ⇒ 返回既有行,不改写;batch 行若不存在则以 OPEN 补齐）。
@@ -35,7 +37,7 @@ import type { AskCallCoordinate, AskDecision, AskRow, AskTerminalClaimIntent, As
  * 循环引用 ⇒ `JSON.stringify` 抛(两侧同抛);顶层函数 / `undefined` ⇒ `stringify` 交出 `undefined`
  * (「编出来什么都不是」)⇒ 本函数**响亮拒**,而不是让它在库里变成 NULL、在内存里变成活函数。
  *
- * 🔴 为什么必须是一只**导出**函数而不是 `decideAsk` 里的内联段(S-384):`FileApprovalAskStore` 要在
+ * 🔴 为什么必须是一只**导出**函数而不是 `decideAsk` 里的内联段([ref]):`FileApprovalAskStore` 要在
  * **落日志之前**把这一步做掉 —— 它的日志本身就是 JSON,而 `JSON.stringify` 对顶层函数是**静默丢键**
  * 不是抛。内联在 decideAsk 里的话,File 形只能在自己那侧再写一遍同样的判定(第二份手抄),或者
  * 让「活路径抛 / 重放路径成功 DECIDE」这条真分岔活下来。
@@ -49,7 +51,7 @@ export declare function encodeStoreJsonPayload(what: string, value: unknown): un
 /** [ref] `updatedInput` 的入店编码 = 上面那只的一次具名调用(词固定在一处,两 twin 与 File 形账本共用)。 */
 export declare function encodeDecideUpdatedInput(updatedInput: unknown): unknown;
 /** {@link InMemoryApprovalAskStore.exportRows} 的产出 / {@link InMemoryApprovalAskStore.importRows} 的入参
- *  —— **纯行**,零判定。压实(S-384 File 形)与测试的状态对拆共用。 */
+ *  —— **纯行**,零判定。压实([ref] File 形)与测试的状态对拆共用。 */
 export interface ApprovalAskRowsSnapshot {
     asks: readonly AskRow[];
     batches: readonly BatchRow[];
@@ -57,20 +59,22 @@ export interface ApprovalAskRowsSnapshot {
 export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     private readonly asks;
     private readonly batches;
-    /** 店钟(S-384)。缺省 = 本进程墙钟,与本类落地以来逐字同值;File 形注入一只**钉住的**钟,让
+    /** 店钟([ref])。缺省 = 本进程墙钟,与本类落地以来逐字同值;File 形注入一只**钉住的**钟,让
      *  「同一串调用重放出同一份状态」成立。读钟纪律见类顶注(只许在同步前缀里读)。 */
     private readonly now;
     constructor(opts?: {
         now?: () => number;
     });
     /**
-     * S-384:整本行快照(压实用)。**深拷到行级**(与每个读口交出 `{ ...row }` 同一条纪律:交出去的行
+     * [ref]:整本行快照(压实用)。**深拷到行级**(与每个读口交出 `{ ...row }` 同一条纪律:交出去的行
      * 不再是店内那一份,调用方改它碰不到店)。行内的 `cardJson`/`updatedInput`/`decisionActor` 仍是引用 ——
      * 与 `getAsk`/`listByState` 逐字同宽,不在这一口上单独加深拷(那会让快照口与读口对同一份 blob 给出
      * 两种可变性)。
      */
     exportRows(): ApprovalAskRowsSnapshot;
-    /** S-384:把快照里的行**原样**装回两张 Map(同键覆盖)。零谓词、零状态机 —— 它不是一条转移,是重放
+    /** [ref]:一行的**同步**点读(拷贝;纯读,零判定)—— File 形在写口的同步前缀里用它(见类顶注)。 */
+    peekAsk(askId: string): AskRow | null;
+    /** [ref]:把快照里的行**原样**装回两张 Map(同键覆盖)。零谓词、零状态机 —— 它不是一条转移,是重放
      *  的起手状态。压实产物与本口是一对:压实写出 {@link exportRows} 的行,启动时由本口装回。 */
     importRows(snapshot: {
         asks?: readonly AskRow[];
@@ -78,7 +82,7 @@ export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     }): void;
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
-    decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;
+    decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
     /**
      * [ref] 原子终局 claim(接口契约见 SQL 侧 {@link ApprovalAskStore.claimTerminal})。**委托形**:CAS 走
      * 既有 verb(expire ⇒ `this.expireAsk`;cancel ⇒ `this.transitionAsk(STREAM_PENDING→VOID)`)——律 2

package/dist/plugins/approval-ask-store-memory.js

@@ -1,6 +1,6 @@
 import { ASK_TERMINAL, canAskTransition } from "../approval-ask-machine.js";
 import { APPROVAL_ENDING_CAUSES } from "../approval-deny-reasons.js";
-import { askRowOnCall, assertDecideSettledBy, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth } from "./approval-ask-store-sql.js";
+import { askRowCarriesOwner, askRowOnCall, assertDecideSettledBy, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
 function applyPatch(row, patch) {
     if (patch.decision !== undefined)
         row.decision = patch.decision;
@@ -41,6 +41,10 @@ export class InMemoryApprovalAskStore {
     exportRows() {
         return { asks: [...this.asks.values()].map((r) => ({ ...r })), batches: [...this.batches.values()].map((b) => ({ ...b })) };
     }
+    peekAsk(askId) {
+        const row = this.asks.get(askId);
+        return row ? { ...row } : null;
+    }
     importRows(snapshot) {
         for (const r of snapshot.asks ?? [])
             this.asks.set(r.askId, { ...r, settledBy: r.settledBy ?? null });
@@ -112,19 +116,18 @@ export class InMemoryApprovalAskStore {
         row.updatedAtMs = patch.updatedAtMs;
         return true;
     }
-    async decideAsk(askId, batchId, decision) {
+    async decideAsk(askId, batchId, owner, decision) {
         if (decision.idempotencyKey != null)
             assertIdempotencyKeyShape(decision.idempotencyKey);
         assertDecideSettledBy(decision);
-        const now = this.now();
+        const reading = (row) => projectDecideReading(row ? { ...row } : null, owner);
         const batch = this.batches.get(batchId);
         if (!batch || batch.state !== "OPEN") {
-            const row = this.asks.get(askId);
-            return { ok: false, reason: "batch_closed", row: row ? { ...row } : null };
+            return { ok: false, reason: "batch_closed", row: reading(this.asks.get(askId)) };
         }
         const ask = this.asks.get(askId);
-        if (!ask || ask.state !== "STREAM_PENDING" || ask.batchId !== batchId) {
-            return { ok: false, reason: "ask_not_pending", row: ask ? { ...ask } : null };
+        if (!ask || ask.state !== "STREAM_PENDING" || ask.batchId !== batchId || !askRowCarriesOwner(ask, owner)) {
+            return { ok: false, reason: "ask_not_pending", row: reading(ask) };
         }
         if (decision.idempotencyKey != null) {
             for (const [id, r] of this.asks) {
@@ -136,6 +139,7 @@ export class InMemoryApprovalAskStore {
         let encodedUpdatedInput;
         if (decision.updatedInput !== undefined)
             encodedUpdatedInput = encodeDecideUpdatedInput(decision.updatedInput);
+        const now = this.now();
         batch.rev += 1;
         batch.updatedAtMs = now;
         ask.state = "DECIDED";