@sema-agent/server 7.141.0 → 7.143.0

package/dist/session-error-wire.d.ts

@@ -57,6 +57,12 @@
  *
  * core 给闭集加一个词 ⇒ 下面的 `switch` 编译红,由人裁定它在两面上的答复,而不是让它静默落进某个恰好存在的臂
  * ([ref] 词表纪律;同形先例 `session-policy-wire.ts` 的 `sessionPolicyErrorHttp`)。
+ *
+ * ## 读一只会话的存档时的故障:一张表、两个读者({@link openFaceFaultWire})
+ * open 面映射有臂 ⇒ 那一格;否则(open 面留白的词,与不是 `SessionError` 的读故障 —— I/O 级的 EACCES / EISDIR …,core 的读腿只吞 ENOENT、其余 errno 原样抛)
+ * ⇒ 通用 500 {@link INTERNAL_ERROR_WIRE}。读者:① 全局兜底(`http/server.ts`:路由里逃出来的故障就按它答 —— 会话视图 / 头探针 / 事件流 / 改名门放行之后对坏档答的码
+ * 都出自这里);② 会话列表行的 `unreadable`({@link sessionUnreadableOf}:列表行 = 会话行,头的叶子读不出 ⇒ 行带标记,码 = 打开它时读口答的那一个)。
+ * 两个读者读同一只函数,列表说的码与读口答的码不会分叉。
  */
 import { SessionError } from "@sema-agent/core";
 /** core `SessionError` 的码闭集(core 不从包根导出这个型名 ⇒ 从导出类的 `code` 键派生,不手抄)。 */
@@ -96,6 +102,18 @@ export declare class StampedSessionArchiveError extends SessionError {
     readonly sessionId: string;
     constructor(sessionId: string);
 }
+/**
+ * local 店的具名拒(唯一铸点 `plugins/local-session-store.ts` 的 `metaRead`):这只会话的**属主读不出**。会话的行事实(属主 / 化身)只住在会话元数据边档的那一格;
+ * 7.104.0 之前写下、此后从没被读过的会话没有这一格,要从存档补铸它(第一次读时的惯例),存档又用不了(会话头坏 / 截断 / 日志结构走不通)——
+ * 于是没有任何一位调用方能被判成它的属主。要读它的行事实的店方法(`headOf` / 执行席的读 / 会话元数据读口)抛本错。
+ *
+ * 码与句子**就是**那只存档故障的(`cause` = 它;码不另铸 —— 只会是 `corrupt_session` / `invalid_session`,读不出而说不出在不在的 I/O 级故障不换型):
+ * 不认识本型的站点看到的与此前逐字相同(`sessionErrorHttp` 按码映射,wire 与运维日志不变)。认识本型的站点 —— 会话读面的属主读
+ * (`http/owner-access.ts` 的 `foldOwnerUnreadable`)—— 把它读成「没有这一行」:与对非属主、对不存在的会话同一只 404,原故障进运维日志。
+ */
+export declare class SessionOwnerUnreadableError extends SessionError {
+    constructor(code: "corrupt_session" | "invalid_session", fault: SessionError);
+}
 /** {@link StampedSessionArchiveError} 的 wire 固定句(fork 与改日志的推送同一句;不点名会话 id;出路在句里 —— 从头再同步照样撞)。 */
 export declare const STAMPED_SESSION_ARCHIVE_SENTENCE = "this session's stored archive still carries an owner stamp written by an earlier server version, so it cannot be forked or have its log replaced; nothing was written \u2014 delete the session and push it again";
 /**
@@ -103,6 +121,24 @@ export declare const STAMPED_SESSION_ARCHIVE_SENTENCE = "this session's stored a
  * 按码答复不同),其余按码({@link sessionErrorHttp})。
  */
 export declare function sessionErrorWireOf(e: SessionError, face: SessionErrorFace): SessionErrorWire | undefined;
+/**
+ * 全局兜底的末臂:open 面映射没有臂的故障(登记过的留白词;不是 `SessionError` 的故障)⇒ 通用 500,句子固定(故障的原句只进运维日志 `request_error`,
+ * 不上 wire —— I/O 级的原句带 errno 与盘上路径)。
+ */
+export declare const INTERNAL_ERROR_WIRE: SessionErrorWire & {
+    readonly sentence: string;
+};
+/** 一只读存档的故障在 open 面上的 wire 答复(两个读者见文件头注「一张表、两个读者」):有臂 ⇒ 那一格;否则 {@link INTERNAL_ERROR_WIRE}。 */
+export declare function openFaceFaultWire(fault: unknown): SessionErrorWire;
+/**
+ * 会话列表行的加性键 `unreadable`:这只会话的头的叶子读不出(存档读不出)。present-iff 读不出;`errorCode` = 读口打开这只会话时答的码
+ * (`GET /v1/sessions/:id` / `…/head` / `…/events` / `PATCH` 门放行之后)。今天读得到的值:`corrupt_session`(会话头坏)· `internal.error`(I/O 级)。
+ */
+export interface SessionUnreadable {
+    readonly errorCode: string;
+}
+/** {@link SessionUnreadable} 的唯一铸点(列表行的那只标记;码经 {@link openFaceFaultWire},与全局兜底同表)。 */
+export declare function sessionUnreadableOf(fault: unknown): SessionUnreadable;
 export declare function sessionErrorHttp(code: SessionErrorCode, face: SessionErrorFace): SessionErrorWire | undefined;
 export declare function isSessionErrorCode(code: string): code is SessionErrorCode;
 //# sourceMappingURL=session-error-wire.d.ts.map

package/dist/session-error-wire.js

@@ -13,6 +13,12 @@ export class StampedSessionArchiveError extends SessionError {
         this.name = "StampedSessionArchiveError";
     }
 }
+export class SessionOwnerUnreadableError extends SessionError {
+    constructor(code, fault) {
+        super(code, fault.message, fault);
+        this.name = "SessionOwnerUnreadableError";
+    }
+}
 export const STAMPED_SESSION_ARCHIVE_SENTENCE = "this session's stored archive still carries an owner stamp written by an earlier server version, so it cannot be forked or have its log replaced; nothing was written — delete the session and push it again";
 const CORRUPT_SESSION = { status: 500, errorCode: "corrupt_session" };
 const STORED_LOG_INVALID = { status: 500, errorCode: "invalid_session" };
@@ -23,6 +29,13 @@ const STAMPED_SESSION_ARCHIVE = { status: 409, errorCode: "conflict", sentence:
 export function sessionErrorWireOf(e, face) {
     return e instanceof StampedSessionArchiveError ? STAMPED_SESSION_ARCHIVE : sessionErrorHttp(e.code, face);
 }
+export const INTERNAL_ERROR_WIRE = { status: 500, errorCode: "internal.error", sentence: "internal error" };
+export function openFaceFaultWire(fault) {
+    return (fault instanceof SessionError ? sessionErrorWireOf(fault, "open") : undefined) ?? INTERNAL_ERROR_WIRE;
+}
+export function sessionUnreadableOf(fault) {
+    return { errorCode: openFaceFaultWire(fault).errorCode };
+}
 export function sessionErrorHttp(code, face) {
     switch (code) {
         case "corrupt_session":

package/dist/session-incarnation.d.ts

@@ -11,7 +11,7 @@
  *    所以化身与属主不是同一条律(读法分三种,见下「两读」)。删除随行消失,同 id 重新登记铸新的。
  *  · **两读(住客的三种问法,各读各的格,不混用)**:
  *    K1 **住客自己的记录**(工作区、记忆、空间分区……按「这一位住客」落的东西)只按化身绑 —— 同一位住客的属主换代(推送重戳 / 认领)不换住客,记录照落;
- *    K2 **以「这一行的这一代」为条件的写**(执行放置的换绑 / 收回、执行上下文的复核)比属主与化身整对,判官 = core 的行期望判官 `sessionRowMatches`
+ *    K2 **以「这一行的这一代」为条件的写**(执行放置的换绑 / 收回、执行上下文的复核、会话通知门投递前的复核 —— 条目按属主排空)比属主与化身整对,判官 = core 的行期望判官 `sessionRowMatches`
  *    (`execution-placement.ts` 的 `sameOccupant`,SQL `incarnation = ? AND owner <=> ?` 的对位)—— 读与写之间属主换了一代 ⇒ 不是判过的那一行;
  *    K0 **只问属主的门**(授权门、暂存提交的属主 CAS)只读属主那一格。三种都读会话**行**;local 店的行 = 会话元数据边档那一格(引擎仓里的存档是匿名内容仓,
  *    存档头上的属主不是行事实 —— `plugins/local-session-store.ts` 头注)。

package/dist/session-notify-door.d.ts

@@ -0,0 +1,106 @@
+/**
+ * 🔴 **会话通知门 —— 一只会话外的事件进一只会话,只有这一处,两臂**。
+ *
+ * ## 门
+ *  · **目标** = 会话 + 调用方判过的那一位住客(那一次头读的属主与化身令牌)+ 那一位无主时条目盖谁。门**不**替调用方判授权(属主门在调用方);门只保证交到的是那一位。
+ *  · **活**:这只会话在本副本有活流 —— 判据一读:`runStore.getActiveTaskId(会话)` 交回的 run 在本副本的活流登记簿里(`steerableRuns`,属主是 HTTP 服务)
+ *    ⇒ core `TaskStream.notify(事件, { priority: "next" })`。core 铸 `task_type: "external"`(外来的事件穿不上引擎内部车道的类型),载荷校验 / 消毒 / 围栏全在
+ *    core;档位**写死** `"next"`(最早边界投递;core 的无参缺省是收官座 `"later"`,不写就静默推迟到 run 收尾)。core 的明确拒(码以 `notify.` 开头)原样交回;
+ *    别的抛 = 活流刚收尾的竞态 ⇒ 落空闲臂。
+ *  · **空闲**:这只会话的完成收件箱(`externalNotificationInboxEntry`,external 键域;脱敏 / 限长在入箱口内)⇒ 下次开流排空成 `task_notification` 帧。
+ *    部署没有收件箱 ⇒ 如实交回 `no_inbox`(调用方各自答:HTTP 门 501,引擎完成告警)。
+ *  · **复核住客**:两臂的投递动作(注入 / 入箱)之前**紧邻**一次头读,与目标的住客比 —— 判官是仓里那一只 `sameOccupant`(`execution-placement.ts`:属主 ∧ 化身,
+ *    写口与执行上下文解析器判的也是它):不在 ⇒ `withdrawn: gone`;两样里任一样变了 ⇒ `withdrawn: replaced`。会话店不铸化身(嵌入方自建的店)时两侧都没有令牌,
+ *    判官只剩属主那一半:属主没变 ⇒ 投,变了 ⇒ 撤回。这一读是动作之前的最后一次让出:判活读(及活臂刚收尾时的那次注入)都在它前面 ——
+ *    令牌永不复用,此刻还是那一位 ⇒ 判活读那一刻也是那一位 ⇒ 判出的 run 是它的 run。
+ *  · **条目属主** = 目标住客的属主(调用方判过的那一读;复核放行 ⇒ 与这一读的属主逐字相等);那一位无主 ⇒ `ownerlessEntryOwner`(调用方交)。
+ *
+ * ## 竞态(两个调用方同一句话,只写在这里)
+ *  · 判活之后、注入之前活流收尾:core 对已收尾的 run 不抛,按会话暂存、本进程同一会话的下一个 run 开轮时投递(core `notify` 契约);抛了 ⇒ 空闲臂(入箱前再复核一次)。
+ *  · 判空闲之后、入箱之前同一会话开了新流:新腿开流那一拍的排空可能已读过收件箱 ⇒ 这一条在**再下一次**开流排空(至少一次,晚一次开流)。
+ *  · 跨副本:活流在别的副本 ⇒ 本副本判空闲 ⇒ 入箱(收件箱随 run 店同一后端,哪个副本开流都排得到)。
+ *  · 复核之后、入箱写落库之前别的副本删了这只会话并同 id 重新登记:条目带的是判过那一位的属主 —— 排空时按属主比开流者,另一位属主排不到;
+ *    同一属主重新登记的那一只会排到它(余窗 = 一次入箱写的时长;这一形不再收窄)。
+ *
+ * ## 调用方(两只,都经 {@link SessionNotifyDoor.deliver},不各写一份臂)
+ *  · `POST /v1/sessions/:id/notify`(`http/routes/notify-wake.ts`):入站鉴权、验型、属主门在路由;属主 = 会话行的属主。
+ *  · **Runner 之外的后台子代完成**({@link createBackgroundCompletionRelay}):停驻赎回腿的复活、操作员 `handle.resume` —— 这些续跑不是哪一次 run 内的调用,
+ *    没有调用车道(`ToolExecuteContext.onTaskNotification`),引擎把完成交给委派工具挂载期的 `background.notify`;那只 sink 在 `capabilities/scenarios.ts` 接一次,
+ *    交到委派树根会话的这只门。Runner 之内的调用照旧走调用车道(引擎 `resolveCompletionSink` = 调用 ?? 挂载),这只门不经手。
+ */
+import type { ExternalNotificationInput, SessionHead, SubagentToolOptions, TaskStream } from "@sema-agent/core";
+import { type WorkflowCompletionInbox } from "./orchestration/workflow-completion-inbox.js";
+import type { DelegationRootWitness } from "./delegated-session-owner.js";
+import type { HeadRead } from "./session-incarnation.js";
+import type { Logger } from "./observability/logger.js";
+/** 门的一次投递结局(闭集;调用方 `switch` 穷尽)。 */
+export type SessionNotifyOutcome = {
+    readonly delivery: "live";
+} | {
+    readonly delivery: "parked";
+}
+/** core 的明确拒(`notify.invalid_payload` 等):码与句原样。 */
+ | {
+    readonly delivery: "refused";
+    readonly code: string;
+    readonly message: string;
+}
+/** 会话空闲而部署没有收件箱:这一条无处可放。 */
+ | {
+    readonly delivery: "no_inbox";
+}
+/** 投递动作之前的复核:会话不在(`gone`)/ 住客不是目标那一位(`replaced`)⇒ 没交。 */
+ | {
+    readonly delivery: "withdrawn";
+    readonly reason: "gone" | "replaced";
+};
+/** 投递目标。 */
+export interface SessionNotifyTarget {
+    readonly sessionId: string;
+    /** 调用方判过的那一位住客:那一次头读的属主与化身令牌(化身缺席 = 那一读里没有令牌;复核见头注)。它的属主也是收件箱条目的属主(排空时与开流者比对)。 */
+    readonly occupant: Pick<SessionHead, "owner" | "incarnation">;
+    /** 那一位无主(`occupant.owner === null`)时条目盖的属主(`null` = 无主条目,谁开流都排)。 */
+    readonly ownerlessEntryOwner: string | null;
+}
+export interface SessionNotifyDoor {
+    deliver(target: SessionNotifyTarget, event: ExternalNotificationInput): Promise<SessionNotifyOutcome>;
+}
+/** 门要读的四样(都由 HTTP 服务交:活流登记簿是它的,run 店、会话店与收件箱是它的依赖)。 */
+export interface SessionNotifyDoorIo {
+    /** 会话 → 它的在飞 run(run 店的单活认领读)。部署没有 run 店 ⇒ 交 `undefined` ⇒ 恒判空闲。读失败按空闲。 */
+    readonly activeTaskIdOf: (sessionId: string) => Promise<string | null | undefined>;
+    /** 本副本持活 core 流的腿(taskId → 流)。 */
+    readonly liveRuns: ReadonlyMap<string, Pick<TaskStream, "notify">>;
+    readonly inbox: WorkflowCompletionInbox | undefined;
+    /** 会话店的按 id 头读(复核住客的那一读)。店没有 ⇒ `undefined`:调用方先判(路由 501;后台完成 relay 照交,门响亮抛 ⇒ relay 告警)。 */
+    readonly headOf: HeadRead | undefined;
+}
+export declare function createSessionNotifyDoor(io: SessionNotifyDoorIo): SessionNotifyDoor;
+/** 委派工具挂载期的完成 sink 的型(取自 core 的选项型,不手抄)。 */
+export type BackgroundCompletionSink = NonNullable<NonNullable<SubagentToolOptions["background"]>["notify"]>;
+/** 把一只委派树根见证变成挂载期 sink 的工厂(`ScenarioDeps.backgroundCompletionSinkFor` 的型)。 */
+export type BackgroundCompletionSinkFor = (root: DelegationRootWitness) => BackgroundCompletionSink;
+export interface BackgroundCompletionRelayIo {
+    /** 会话通知门。门的属主是 HTTP 服务、场景层先于它装配 ⇒ 晚绑取值;未绑 ⇒ 交不出去(告警)。 */
+    readonly door: () => SessionNotifyDoor | undefined;
+    /** 交不出去的那一行告警写到这里(本仓的 `Logger`:写口自己吞掉输出故障、不抛 —— relay 的收尾臂依赖这一条)。 */
+    readonly logger: Pick<Logger, "warn">;
+}
+/** 交不出去的成因(闭集;告警 `background_completion_undelivered` 的 `reason`)。 */
+export type BackgroundCompletionUndelivered = "root_gone" | "root_replaced" | "door_unbound" | "refused" | "no_inbox" | "relay_failed";
+/**
+ * **Runner 之外的后台子代完成 → 委派树根会话的会话通知门**(挂载期 `background.notify` 的唯一实现)。
+ *
+ *  · **地址** = 场景层交出的委派树根见证(`ScenarioContext.delegationRoot`:会话 id + 判断那一刻的根住客)—— 停驻赎回面按行上的 `rootSessionId`
+ *    与赎回腿写口放行的那一位住客交,请求腿按本请求会话与受理时那一读交;不读完成帧上的任何键定址。一层行的根就是父会话;更深的行(孙代)报给根 ——
+ *    委派终态的受众是整棵委派树的根会话(孙代的父是一只没人开流的委派会话,交给它等于没交)。
+ *  · **目标住客 = 见证的那一位**(属主与化身,见证铸点那一读):门在投递动作之前紧邻地复核(头注「复核住客」)—— 不在 ⇒ 不交(`root_gone`);
+ *    不是见证的那一位(删了、同 id 被重新登记、属主变了)⇒ 不交(`root_replaced`):这棵树的结果不交给同 id 的下一位住客。条目属主 = 见证的属主;
+ *    根无主 ⇒ 无主条目(relay 不是谁的请求,没有请求主体可落)。见证那一读里根行不在(化身 `null`)⇒ 目标住客 = 「无主、无令牌」,只有不铸化身的店上
+ *    此刻也无主的根与它同(铸化身的店上它恒不同 ⇒ 不交,与停驻挂点「见证不在而根在 ⇒ 否决」同向)。
+ *  · **事件** = 完成帧的 `task_id` / `status` / `summary` / `result` / `seq`(后台子代的 `seq` = 停驻周期号,同一只子代两次复活的完成在收件箱折叠键上不相撞)。
+ *    帧上别的键不过门:门的事件型只有这几位(活臂 core 铸 external,空闲臂入箱同一形),两臂一个形。
+ *  · 交不出去一律一行 warn(`background_completion_undelivered`,带成因),不抛回引擎(sink 是 fire-and-forget)。
+ */
+export declare function createBackgroundCompletionRelay(io: BackgroundCompletionRelayIo): BackgroundCompletionSinkFor;
+//# sourceMappingURL=session-notify-door.d.ts.map

package/dist/session-notify-door.js

@@ -0,0 +1,93 @@
+import { externalNotificationInboxEntry } from "./orchestration/workflow-completion-inbox.js";
+import { sameOccupant } from "./execution-placement.js";
+export function createSessionNotifyDoor(io) {
+    async function recheck(target) {
+        if (io.headOf === undefined)
+            throw new Error("session notify door: the session store has no head read (headOf); the occupant cannot be re-checked before delivery");
+        const head = await io.headOf(target.sessionId);
+        if (head === undefined)
+            return { delivery: "withdrawn", reason: "gone" };
+        return sameOccupant(target.occupant, head) ? undefined : { delivery: "withdrawn", reason: "replaced" };
+    }
+    return {
+        async deliver(target, event) {
+            const liveTaskId = await io.activeTaskIdOf(target.sessionId).catch(() => undefined);
+            if (liveTaskId !== undefined && liveTaskId !== null && io.liveRuns.has(liveTaskId)) {
+                const withdrawn = await recheck(target);
+                if (withdrawn !== undefined)
+                    return withdrawn;
+                const live = io.liveRuns.get(liveTaskId);
+                if (live !== undefined) {
+                    try {
+                        await live.notify(event, { priority: "next" });
+                        return { delivery: "live" };
+                    }
+                    catch (e) {
+                        const code = e.code;
+                        if (typeof code === "string" && code.startsWith("notify."))
+                            return { delivery: "refused", code, message: e instanceof Error ? e.message : "invalid notification" };
+                    }
+                }
+            }
+            if (io.inbox === undefined)
+                return { delivery: "no_inbox" };
+            const withdrawn = await recheck(target);
+            if (withdrawn !== undefined)
+                return withdrawn;
+            await io.inbox.enqueue(externalNotificationInboxEntry(target.sessionId, target.occupant.owner ?? target.ownerlessEntryOwner, { task_type: "external", ...event }, Date.now()));
+            return { delivery: "parked" };
+        },
+    };
+}
+export function createBackgroundCompletionRelay(io) {
+    return (root) => (n) => {
+        void relayToRoot(io, root, n).catch((err) => io.logger.warn("background_completion_undelivered", { ...completionFields(root, n), reason: "relay_failed", error: err instanceof Error ? err.message : String(err) }));
+    };
+}
+async function relayToRoot(io, root, n) {
+    const undelivered = (reason, extra) => io.logger.warn("background_completion_undelivered", { ...completionFields(root, n), reason, ...extra });
+    const door = io.door();
+    if (door === undefined)
+        return undelivered("door_unbound");
+    const out = await door.deliver({ sessionId: root.sessionId, occupant: { owner: root.owner, incarnation: root.incarnation ?? undefined }, ownerlessEntryOwner: null }, completionEvent(n));
+    switch (out.delivery) {
+        case "live":
+        case "parked":
+            return;
+        case "refused":
+            return undelivered("refused", { code: out.code });
+        case "no_inbox":
+            return undelivered("no_inbox");
+        case "withdrawn":
+            return undelivered(withdrawnReason(out.reason));
+        default: {
+            const unhandled = out;
+            throw new Error(`unhandled session notify outcome: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+function withdrawnReason(reason) {
+    switch (reason) {
+        case "gone":
+            return "root_gone";
+        case "replaced":
+            return "root_replaced";
+        default: {
+            const unhandled = reason;
+            throw new Error(`unhandled withdrawn reason: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+function completionEvent(n) {
+    return {
+        task_id: n.task_id,
+        status: n.status,
+        summary: n.summary,
+        ...(n.result !== undefined ? { result: n.result } : {}),
+        ...(n.seq !== undefined ? { seq: n.seq } : {}),
+    };
+}
+function completionFields(root, n) {
+    return { sessionId: root.sessionId, taskId: n.task_id, taskType: n.task_type, status: n.status };
+}
+//# sourceMappingURL=session-notify-door.js.map

package/dist/session-sync.d.ts

@@ -46,7 +46,7 @@
 import type { StoreBackend } from "./plugins/store-backend.js";
 import { type SyncRelation } from "./session-sync-kernel.js";
 import { type SessionTreeEntry, type SessionRulesRecord, type FileHistoryError, type FileHistoryExport, type FileHistoryResult, type SessionPermissionRules, type StoredSessionRules, type SessionPolicyStore } from "@sema-agent/core";
-import type { ServiceFileHistoryStore, ServiceSessionPolicyStore, ResumeAnchorStore } from "./plugins/store-backend.js";
+import type { ServiceBlobExchange, ServiceFileHistoryStore, ServiceSessionPolicyStore, ResumeAnchorStore } from "./plugins/store-backend.js";
 /**
  * core 7.55.0 [ref] T2([ref]):一只会话的文件历史**读不全**(撕裂 / 读不出的边界、读不出的跟踪集 —— 店的 `exportHistory` 答 `{ ok: false }`,`adopt_failed`
  * 带店判的 `permanence`)。它**不是**「没有历史」:读成 `null` 的同步会把这只会话的全部 rewind 历史丢在路上、还答成功。会话同步的两只拉取口
@@ -67,20 +67,15 @@ export declare function exportedFileHistory(store: Pick<ServiceFileHistoryStore,
  *  Returned by {@link exportSessionManifest} (closes over the source store); consumed wherever a caller pulls
  *  content-addressed history bytes lazily (the live PUSH route's `importHistory` replay). */
 export type BlobGetter = (hash: string) => Promise<Uint8Array | undefined>;
-/** blob 两面(`putBlob` / `getBlob`)齐备的文件历史店(marker 门,不做名字探测:local 的引擎文件店带同名私有助手)。 */
-export type SyncBlobHistoryStore = ServiceFileHistoryStore & {
-    readonly syncBlobFaces: true;
-} & {
-    [P in "putBlob" | "getBlob"]-?: NonNullable<ServiceFileHistoryStore[P]>;
-};
 /**
- * 「这只文件历史店有没有 blob 两面」的**唯一**读法:marker `syncBlobFaces`(只有 SQL 两只店立它)∧ 两面在场。能力事实 `sessionSyncFileHistory`(capability-facts)
- * 与取值口 {@link blobGetterOf} 都读它 —— 事实说有,取值口就通到事实店的 `getBlob`;事实说没有,取值口恒空。
- * 名字探测(`store.getBlob?.…`)不可靠:core 的 local 文件店带与服务面同名的**私有**助手(同形 `putBlob` 已被 marker 挡过一次),名字探会错拿到它。
+ * 「这只文件历史店能不能交换 blob」的**唯一**读法:店的 `blobExchange` 组,经 core 的判官 `fileHistoryBlobExchangeOf` 读 —— 没有组 ⇒ `undefined`
+ * (core 的 local 文件店);整组 ⇒ 三只成员(判官已绑好);缺一员 / 组不是对象 / 店还带退役的标记词 ⇒ 判官拒(`config.invalid_argument`,响亮,不是「没有」)。
+ * 能力事实 `sessionSyncFileHistory`(capability-facts)与取值口 {@link blobGetterOf} 都读它 —— 事实说有,取值口就通到同一组的 `get`;事实说没有,取值口恒空。
+ * 返回型收窄到本仓的 {@link ServiceBlobExchange}:判官交回的是店自己那一组的成员(只绑定、不包装),店型声明的组就是那一型。
  */
-export declare function syncBlobFacesOf(store: ServiceFileHistoryStore): SyncBlobHistoryStore | undefined;
-/** 一只文件历史店自己的 blob 取值口({@link BlobGetter}):从 {@link syncBlobFacesOf} 派生 —— 有 blob 两面 ⇒ 绑在店上的 `getBlob`;没有(core 的 local 文件店)⇒ 恒答 `undefined`(「这里取不到」)。
- *  拉取面(manifest 的 `getBlob`)、identical 自愈臂、提交臂三处读同一只,不各写一份「无面则 undefined」。 */
+export declare function blobExchangeOf(store: ServiceFileHistoryStore): ServiceBlobExchange | undefined;
+/** 一只文件历史店自己的 blob 取值口({@link BlobGetter}):从 {@link blobExchangeOf} 派生 —— 有交换组 ⇒ 组的 `get`;没有(core 的 local 文件店)⇒ 恒答 `undefined`(「这里取不到」)。
+ *  拉取面(manifest 的 `getBlob`)、identical 自愈臂、提交臂三处读同一只,不各写一份「无组则 undefined」。 */
 export declare function blobGetterOf(store: ServiceFileHistoryStore): BlobGetter;
 /** The history-import capability face of a `FileHistoryStore` (`importHistory` is OPTIONAL on the core
  *  contract — a store without it cannot be a 2c history sink). */
@@ -123,7 +118,7 @@ export type FileHistoryReplayFailure = Extract<FileHistoryReplayResult, {
  * The alternative (keeping the old graph) would wedge every retry on the same typed conflict forever.
  *
  * 缺 blob 的事实只在这里读一次:每次尝试给店的 getter 都包一层观察,店取到 `undefined` 就记下那枚 hash(按次计,替换臂的第二次尝试从空白起),
- * 失败时随结果交出({@link FileHistoryReplayResult.missingBlob})。预检({@link sessionSyncFileHistory} 事实 + `hasBlobs`)管「这台部署根本收不到 / 索引里没有」,
+ * 失败时随结果交出({@link FileHistoryReplayResult.missingBlob})。预检({@link sessionSyncFileHistory} 事实 + 交换组的 `has`)管「这台部署根本收不到 / 索引里没有」,
  * 这里管「预检过了而这一枚取不到」(对象存储里已丢 / 校验和不符按缺席读 / 预检与重放之间被孤儿回收清走)—— 同一只不变量的两端,wire 上同一个词。
  */
 export declare function replayFileHistory(store: ServiceFileHistoryStore, scope: string, envelope: FileHistoryExport, srcGetBlob: BlobGetter, opts: {

package/dist/session-sync.js

@@ -2,7 +2,7 @@ import { anchorEntryDeclared, classifySyncRelationship } from "./session-sync-ke
 import { recordFailOpen } from "./observability/fail-open.js";
 import { loosenReasons, normalizeRules } from "@sema-agent/core";
 import { headReadOf } from "./session-incarnation.js";
-import { judgeSessionRulesWrite } from "@sema-agent/core";
+import { fileHistoryBlobExchangeOf, judgeSessionRulesWrite } from "@sema-agent/core";
 export class FileHistoryUnreadableError extends Error {
     sessionId;
     failure;
@@ -22,12 +22,12 @@ export async function exportedFileHistory(store, sessionId) {
         throw new FileHistoryUnreadableError(sessionId, exported.error);
     return exported.history;
 }
-export function syncBlobFacesOf(store) {
-    return store.syncBlobFaces === true && typeof store.putBlob === "function" && typeof store.getBlob === "function" ? store : undefined;
+export function blobExchangeOf(store) {
+    return fileHistoryBlobExchangeOf(store);
 }
 export function blobGetterOf(store) {
-    const faces = syncBlobFacesOf(store);
-    return faces ? (hash) => faces.getBlob(hash) : async () => undefined;
+    const exchange = blobExchangeOf(store);
+    return exchange ? exchange.get : async () => undefined;
 }
 export function fileHistoryImportFace(fs) {
     const candidate = fs?.importHistory;

package/dist/session-workspace.d.ts

@@ -11,7 +11,7 @@
  *    门在 `trace/core-keyset-guard.ts` ⑰ 读同一张表)。**唯一写者** = 腿的记录座 {@link createSessionWorkspaceRecorder}
  *    (持流的四条腿逐帧喂同一只;委派子代转上来的帧 —— 带 `parentToolCallId` / `sourceTaskId` / `bgAgentId` —— 不是这条腿的位置,不认)。
  *    每一笔写**在腿的流循环里等完**(不排队、没有在飞的写:腿从任何出口离开时都没有它的写还悬着 ⇒ 写恒落在这条腿的 run 认领之内,
- *    同一会话的下一条腿不会被一笔晚到的写盖掉),并且**只写受理时见证到的那一位住客**({@link stampLegSessionWitness}:resolveSpec
+ *    同一会话的下一条腿不会被一笔晚到的写盖掉),并且**只写受理时见证到的那一位住客**(这条腿的部署事实 `sessionWitness`,`leg-facts.ts`:resolveSpec
  *    受理时读会话行的化身那一读,同一只值也是委派树根的见证)—— 会话被删掉又以同一 id 重建之后,上一位住客的腿写不进新住客的行。
  *  · **每条腿声明一个值**:`TaskSpec.projectId` = 这次提交自己带的 `projectId`(新提交的请求体;续跑腿重放的是持久化的同一个体)
  *    ?? 会话行上最后一帧的 `project.id` —— **只当它是调用方声明过的**(`source: "declared"`:没有记号的检出里声明就是身份,行存它就是为了接着声明);
@@ -34,7 +34,7 @@
  *  · **行读在 run 认领之前**(resolveSpec 的每一读都是):同一会话两次提交交叠、后一次的装配读行之后前一次才落定并放认领 ⇒ 后一次读到的是更早
  *    一条腿的项目(有记号的检出里多一次 409,没有记号的检出里续声明旧项目)。修法要把声明的装配挪到认领之后,不在本模块补第二个写者。
  */
-import type { TaskEvent, TaskSpec } from "@sema-agent/core";
+import type { TaskEvent } from "@sema-agent/core";
 import type { DelegationRootWitness } from "./delegated-session-owner.js";
 /**
  * `workspace_changed` 帧在会话行上的样子(**唯一**一张表;表序 = 存储形的键序)。`forward` = 原值存进行;`strip` = 不进行。
@@ -84,16 +84,6 @@ export interface SessionWorkspaceStore {
 }
 /** 店有没有这一面 —— 结构判(包装店 `CachingSessionStore` 逐方法转发,判的是能力不是名字)。没有 ⇒ 不记、不读(core 的内存 dev 店)。 */
 export declare function sessionWorkspaceStoreOf(store: unknown): SessionWorkspaceStore | undefined;
-/**
- * 这条腿的会话**在受理时**是哪一位住客(会话 id + 化身令牌)的 spec 字段键 —— 与 run 名册 / 执行车道字段同一形:symbol 键随 spread / rest 解构走
- * (续跑腿的 `taskConfig` 是 rest 解构出来的),对引擎的键面不可见(JSON / 结构化克隆跳过 symbol 键)。铸点唯一 = resolveSpec 出口
- * ({@link stampLegSessionWitness}),值 = 受理时读会话行的那**一**读(同一只值也交给场景层作委派树根的见证);读点唯一 = {@link legSessionWitnessOf}。
- */
-export declare const LEG_SESSION_WITNESS_FIELD: unique symbol;
-/** 铸见证(**单一属主**:只许 resolveSpec 的出口调用)。`writable:false` + `configurable:false`:同一只 spec 被第二次铸 ⇒ 当场 TypeError。缺席 ⇒ 不铸。 */
-export declare function stampLegSessionWitness<T extends TaskSpec>(spec: T, witness: DelegationRootWitness | undefined): T;
-/** 读见证。`undefined` = 这只 spec 不是本仓装配出口产的,或这条腿没有会话 ⇒ 记录座不写(没有住客可认)。入参收 `object`:续跑腿手里是 rest 解构出来的 taskConfig。 */
-export declare function legSessionWitnessOf(spec: object): DelegationRootWitness | undefined;
 /**
  * 一帧 → 会话行上那一格的值。只认这条腿**自己的**帧(腿身份三键任一在场 = 委派子代转上来的,不是这条腿站在哪里);
  * 按表投影后过存储形的同一只读者(写得进的就是读得出的)。读不出(引擎不会铸出这种帧)⇒ 不记、计一次。
@@ -109,7 +99,7 @@ export interface SessionWorkspaceRecorder {
 }
 /**
  * 记录座的**唯一**铸点(四条持流腿各在开流时铸一只:后台腿 `runs.ts`、活流腿与同步腿 `http/routes/tasks.ts`、续跑腿 `http/resume-legs.ts`),
- * `witness` = 这条腿 spec 上的受理见证({@link legSessionWitnessOf})。店没有这一面、或见证缺席 / 受理时这只会话还没有住客令牌 ⇒
+ * `witness` = 这条腿的受理见证(部署事实 `LegFacts.sessionWitness`,`leg-facts.ts`;嵌入方自带装配器 ⇒ 缺席)。店没有这一面、或见证缺席 / 受理时这只会话还没有住客令牌 ⇒
  * 一只什么都不做的座(诚实缺席:认不出住客就不写 —— 写错住客比少记一次坏)。
  *
  * 失败方向(F 类):写失败(库抖 / 盘满 / 锁等待超时)⇒ 行停在上一帧,计一次;下一帧照写。放行的最坏后果 = 下一条不带 `projectId` 的提交读到旧的

package/dist/session-workspace.js

@@ -19,15 +19,6 @@ export function sessionWorkspaceStoreOf(store) {
         return undefined;
     return { readSessionWorkspace: s.readSessionWorkspace.bind(s), recordSessionWorkspace: s.recordSessionWorkspace.bind(s) };
 }
-export const LEG_SESSION_WITNESS_FIELD = Symbol("sema-server.legSessionWitness");
-export function stampLegSessionWitness(spec, witness) {
-    if (witness !== undefined)
-        Object.defineProperty(spec, LEG_SESSION_WITNESS_FIELD, { value: Object.freeze({ ...witness }), enumerable: true, writable: false, configurable: false });
-    return spec;
-}
-export function legSessionWitnessOf(spec) {
-    return spec[LEG_SESSION_WITNESS_FIELD];
-}
 export function sessionWorkspaceOfFrame(ev) {
     if (ev.type !== "workspace_changed")
         return undefined;

package/dist/standing-answer-grant.d.ts

@@ -35,6 +35,11 @@ export type GrantBinding = {
 /** 载体上的授予绑定 —— 只读引擎的词(读法见文件头注):摘要是串 ⇒ bound;摘要不在且词是 `not_bindable` ⇒ none;其余 ⇒ unreadable。
  *  形参是任意对象(载体不论):读自持久层的停驻行(运维队列行的投影、`/decide` 的原始行)两座都按 `unknown` 读,结构上满足 {@link StandingAnswerCard} 的载体照传。 */
 export declare function grantBindingOf(card: StandingAnswerCard | object): GrantBinding;
+/**
+ * 同一只问的两份授予绑定读数取严(7.143.0;读者 = `tool-approval.ts` 幂等重入那一臂:这一腿的请求 × 行上记着的事实座)。
+ * 两份逐臂同 ⇒ 那一份;不同(含任一份 `unreadable`)⇒ `unreadable`(本会话放行记不住)。只收窄、永不放宽任一份。
+ */
+export declare function agreedGrantBinding(a: GrantBinding, b: GrantBinding): GrantBinding;
 /** 授予绑定在读面上的形:恰一臂 —— 摘要,或缺席词(闭集 core `BOUND_GRANT_ABSENCES`)。 */
 export type GrantBindingArm = {
     readonly boundGrantDigest: string;

package/dist/standing-answer-grant.js

@@ -7,6 +7,16 @@ export function grantBindingOf(card) {
     const word = "boundGrantAbsence" in card ? card.boundGrantAbsence : undefined;
     return digest === undefined && word === NOT_BINDABLE ? { kind: "none" } : { kind: "unreadable" };
 }
+export function agreedGrantBinding(a, b) {
+    switch (a.kind) {
+        case "none":
+            return b.kind === "none" ? a : { kind: "unreadable" };
+        case "bound":
+            return b.kind === "bound" && b.digest === a.digest ? a : { kind: "unreadable" };
+        case "unreadable":
+            return a;
+    }
+}
 export function grantBindingArm(binding) {
     switch (binding.kind) {
         case "bound":

package/dist/stores-sql/session-policy-store-sql.d.ts

@@ -86,8 +86,10 @@ export declare class SqlSessionPolicyStore implements SessionPolicyStore {
      *    `main`'s statement sequence, zero mark table involved): InnoDB 1 winner / 7 `ER_LOCK_DEADLOCK`, TiDB 0,
      *    PG 0 — i.e. this is a PRE-EXISTING MySQL-leg defect that [ref]'s lock-shape site made visible, not a new one.
      *    After the first insert commits, the retried writers find the row and take the UPDATE path (record lock,
-     *    no gap) ⇒ the loop converges in one extra round per missing-row window; the bound is the suite's concurrency.
-     *  Lock-WAIT-TIMEOUT is deliberately NOT retried ({@link isDeadlockError}'s own note: it is a latency signal,
+     *    no gap) ⇒ the loop converges in one extra round per missing-row window; the bound is the suite's concurrency
+     *    (a writer is picked at most once per missing-row window, and there are 1 + this round's erases of them) —
+     *    the repo's one bound, `DEADLOCK_RETRY_LIMIT`, owned with the loop itself by `retryOnDeadlock` in `sql-errors.ts`.
+     *  Lock-WAIT-TIMEOUT is deliberately NOT retried (`isDeadlockError`'s own note: it is a latency signal,
      *  and retrying it multiplies an already-long wait).
      */
     private retrying;

package/dist/stores-sql/session-policy-store-sql.js

@@ -4,10 +4,9 @@ import { SESSION_RULES_COLUMN } from "../plugins/session-rules-column.js";
 import { decodeJsonColumn, isJsonColumnBodyProblem, jsonColumnText } from "../plugins/sql-json-column.js";
 import { pgHasUnstorable } from "../plugins/pg-safe-json.js";
 import { mysqlDriver, pgDriver } from "../plugins/sql-driver.js";
-import { isDeadlockError, isDupKeyError } from "../plugins/sql-errors.js";
+import { isDupKeyError, retryOnDeadlock } from "../plugins/sql-errors.js";
 export const policyKeyFor = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
 const policyKey = policyKeyFor;
-const RETRY_LIMIT = 8;
 const RULES = SESSION_RULES_COLUMN.name;
 export function readSessionRulesBody(body) {
     const read = readSessionRulesShape(body);
@@ -129,17 +128,8 @@ export class SqlSessionPolicyStore {
             return structuredClone({ ...clean, rev: nextRev, gen: nextGen });
         }));
     }
-    async retrying(attempt) {
-        for (let tries = 0;; tries++) {
-            try {
-                return await attempt();
-            }
-            catch (e) {
-                if (tries < RETRY_LIMIT && (this.isDupKey(e) || isDeadlockError(this.db.dialect, e)))
-                    continue;
-                throw e;
-            }
-        }
+    retrying(attempt) {
+        return retryOnDeadlock(this.db.dialect, attempt, (e) => this.isDupKey(e));
     }
     async deleteBySession(sessionId) {
         const sealed = await this.retrying(() => this.tx(async (conn) => {

package/dist/task-mcp.d.ts

@@ -71,7 +71,7 @@ export declare const MCP_SERVER_ENTRY_KEYS: readonly ["allowTools", "contentOrig
 /** `transport.kind:"stdio"` 的键闭集 = stdio 臂处置表的键(`env` 是件,其余进声明)。 */
 export declare const STDIO_MCP_TRANSPORT_KEYS: readonly ("env" | "kind" | "args" | "command")[];
 /** `transport.kind:"http"` 的键闭集 = http 臂处置表的键(`headers` 是件,`assertionHeader` 承载不发送,其余进声明)。 */
-export declare const HTTP_MCP_TRANSPORT_KEYS: readonly ("headers" | "kind" | "url" | "principalHeader" | "assertionHeader")[];
+export declare const HTTP_MCP_TRANSPORT_KEYS: readonly ("headers" | "url" | "kind" | "principalHeader" | "assertionHeader")[];
 /**
  * Does THIS deployment honor caller-supplied per-request MCP servers? TRUE for a SINGLE-USER deployment
  * (deployment-shape row `multiTenant` does not hold) — the requester is the super-admin of their own worker, so their `.mcp.json` is