@sema-agent/server 7.146.0 → 7.147.0

package/dist/execution-placement.d.ts

@@ -162,8 +162,9 @@ export declare class SessionForkInProgressError extends Error {
     constructor(sessionId: string);
 }
 /**
- * 写事务内的认领读命中(读写序律,`plugins/execution-placement-sql.ts` 的 `lockRootAndReadClaim`):改根住客 / 放置的写者在自己的事务里先锁根
- * `session_meta` 行、再锁定读 `task_active(root)`,读到认领 ⇒ 回滚、一个字节不写、抛它。只 SQL 后端(local 不立此律:没有 device 工厂)。
+ * 写口在写事务 / 写锁内的认领读命中:SQL = 读写序律(`plugins/execution-placement-sql.ts` 的 `lockRootAndReadClaim`:改根住客 / 放置的写者在自己的事务里先锁根
+ * `session_meta` 行、再锁定读 `task_active(root)`,读到认领 ⇒ 回滚、一个字节不写、抛它);local = 这只会话的写锁内读 run 店的认领(`markMirror` 返回 `active` 臂;
+ * 三个导入写口经 {@link judgeImportWrite} 抛它)—— 删除终刀与 device 首绑在写事务内的认领读仍只在 SQL 后端(local 没有 device 工厂)。
  * 具名类型、**不带 wire 码**:各门按自己的既有码答(导入 409 `session_active`、删除 409 `conflict.session_active_run`),体带 `activeTaskId`。
  */
 export declare class SessionActiveRunError extends Error {
@@ -181,6 +182,21 @@ export declare const WRITABLE: "writable";
 export declare function settledPlaceOutcome(root: string, reading: ExecutionPlacementReading | undefined, occupant: SessionFace, wanted: ExecutionWriterCell): PlaceOutcome | typeof WRITABLE;
 /** markMirror 的唯一判官(认领那一半在本判官之后,SQL 与 local 各在自己的写事务 / 写锁内判):行不在 / 住客不同 ⇒ `gone`;writer ⇒ `writer`;mirror ⇒ `mirrored`(幂等,零写);absent ⇒ {@link WRITABLE};forking ⇒ 抛。 */
 export declare function settledMirrorOutcome(root: string, reading: ExecutionPlacementReading | undefined, occupant: SessionFace): MarkMirrorOutcome | typeof WRITABLE;
+/** {@link judgeImportWrite} 的判:放行,或拒(拒的载荷是写口抛的那只 typed 错;SQL 的事务内钩原样交给店,local 直接抛)。 */
+export type ImportWriteVerdict = "proceed" | {
+    readonly refuse: SessionActiveRunError | SessionWriterPresentError | SessionForkInProgressError;
+};
+/**
+ * 三个导入写口(整段 `importEntries` / `replaceEntries` / 暂存提交)落定这一行**之前**的唯一判官,**连序**在内(SQL 的事务内钩 `import` 臂与 local 的写锁内同调,两店不各抄一份):
+ * 先读认领 —— 在 ⇒ {@link SessionActiveRunError};再读这一格 —— `writer` ⇒ {@link SessionWriterPresentError}(带车道)、`forking` ⇒ {@link SessionForkInProgressError};
+ * `absent` / `mirror` ⇒ 放行(落 mirror 由调用方写)。读口由调用方给、**按需读**:认领在 ⇒ 不读格(SQL:不发格那一句锁定读;local:不探存档)。
+ * 读与判必须在写者独占的同一刻里:SQL = 锁根行之后、同一连接;local = 这只会话的写锁内、写格之前(取锁 → 读认领 → 判 → 写)。
+ * 返回判、不抛:拒之后一个字节不写由调用方保证(SQL 回滚,local 判在第一笔写之前)。
+ */
+export declare function judgeImportWrite(root: string, read: {
+    readonly claim: () => Promise<string | null | undefined>;
+    readonly cell: () => Promise<ExecutionPlacementCell>;
+}): Promise<ImportWriteVerdict>;
 /** device 车道首绑(absent → writer(device, D) 或 writer(device, ∅) → writer(device, D))的结果(设备店的事务 / 内存参照实现同调)。 */
 export type DeviceBindOutcome = {
     readonly outcome: "bound";

package/dist/execution-placement.js

@@ -94,6 +94,25 @@ export function settledMirrorOutcome(root, reading, occupant) {
         }
     }
 }
+export async function judgeImportWrite(root, read) {
+    const claim = await read.claim();
+    if (claim !== null && claim !== undefined)
+        return { refuse: new SessionActiveRunError(root, claim) };
+    const cell = await read.cell();
+    switch (cell.role) {
+        case "writer":
+            return { refuse: new SessionWriterPresentError(root, cell.lane) };
+        case "forking":
+            return { refuse: new SessionForkInProgressError(root) };
+        case "absent":
+        case "mirror":
+            return "proceed";
+        default: {
+            const unknownRole = cell;
+            throw new Error(`judgeImportWrite: no arm for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
 export function settledDeviceBindOutcome(root, reading, occupant, deviceId) {
     if (reading === undefined || !sameOccupant(reading.occupant, occupant))
         return { outcome: "gone" };

package/dist/file-history-disclosure.d.ts

@@ -2,9 +2,9 @@
  * [ref]④ —— SQL file-history 店的 **typed 永久失败**披露座:散文一个铸点 + 机器面一只 sink。
  *
  * ## 病(基线 v7.79.0 逐行亲核 + 亲跑)
- * `plugins/blob-backend.ts:55` 的 `BlobTooLargeError` 带 typed 判别码 `blob_too_large_for_sql`,头注
+ * `stores-sql/blob-index-sql.ts` 的 `BlobTooLargeError` 带 typed 判别码 `blob_too_large_for_sql`,头注
  * 原话「绝不能与 transient 写失败混在一类(那类是可重试的 502;这类重试永远不会成功)」。可它一旦被
- * `plugins/file-history-store-sql.ts` 的任何一条 `catch` 折进 `FileHistoryResult.error.message`,判别码
+ * `stores-sql/file-history-store-sql.ts` 的任何一条 `catch` 折进 `FileHistoryResult.error.message`,判别码
  * 就只剩散文,**机器一位都读不到**。两条腿各自的后果:
  *
  * · **snapshot(边界捕获)腿**:引擎把失败包成一句散文交给 `RunnerDeps.onError({phase:"rewind"})`

package/dist/fleet/drain-entry.d.ts

@@ -69,27 +69,34 @@ export interface DrainDeadlineRefusal {
 /** 入口的答:契约回执(进入 / 已在排空),或期限越界的拒(只在调用方声明了上界时出现)。按 `state` 穷举。 */
 export type DrainEntryAnswer = DrainReceipt | DrainDeadlineRefusal;
 /**
- * 在飞数的**分项**(`GET /health` 的 `inflightBreakdown`)—— 同一份分项派生**两个事实**,不是两份计数:
- *  · **总数**(可观测事实,{@link inflightTotal} = `/health.inflight`):这台引擎此刻托管着多少活 = `http + leader + sessionResident`;
- *  · **阻断集**(判据,{@link blockingInflightOf} = `drainState.blockingInflight`):还有没有**必须等完**的活 = `http + leader`。
+ * 在飞数的**分项**(`GET /health` 的 `inflightBreakdown`)—— 同一份分项派生**两个事实**,不是两份计数(计法表全文 = 契约 `docs/ASSISTANT-WIRE-CONTRACT.md` 的 `/health` 节):
+ *  · **总数**(可观测事实,{@link inflightTotal} = `/health.inflight`):这台引擎此刻托管着多少活 = `http + leader + backgroundAgents + sessionResident`;
+ *  · **阻断集**(判据,{@link blockingInflightOf} = `drainState.blockingInflight`):还有没有**必须等完**的活 = `http + leader + backgroundAgents`。
  *    排空等的、孤儿窗 / 附着租约自退 / SIGHUP 空闲窗判「可以停了吗」读它。`sessionResident` 不在其内。
- * 三项:
+ * 四项:
  *  · `http` —— 本副本的 HTTP 腿:在飞 run 集(`inflightRuns ∪ steerableRuns`)+ 没有登记身份的同步计费腿(`/v1/tasks` 的同步腿)+ admission 期的非探针请求;
  *  · `leader` —— leader 口的后台 run(`leaderEndpoint.inflight()`);
- *  · `sessionResident` —— 会话驻留的后台 shell / monitor(活过起它的那一条腿;`session-resident-background.ts` 的读法:不含 retain 行)。
+ *  · `backgroundAgents` —— 活过起它的那一条腿、仍在跑的后台子代理(core `backgroundScope:"session"`;`session-resident-background.ts` 的读法:停驻的不计)。
+ *    它进阻断集:它是一条在干活的模型腿,干完自己收尾(在审批 / 问答卡上等人时行仍是 `running`、照计;窗满转成耐久停驻后不再计);不等 = 受控退把还在干活的子代理中断。
+ *    上界 = 停滞收割窗 `BG_AGENT_STALL_MS`:读口每读一次先让引擎收掉静默满窗的子代理(挂死的,或收尾时 core 等的那次账本写挂住的)再数 —— 判停窗不再被一只僵尸无界地撑着;
+ *    SIGTERM 排空另以期限为界;
+ *  · `sessionResident` —— 会话驻留的后台 shell / monitor(同一读法:不含 retain 行)。
  *    它只进总数、不进阻断集:一只不退出的驻留 shell(`while true`)若阻断,崩溃孤儿引擎就永生、排空每次等满窗;窗到 / 排空完成即由退出边界的后台收割收掉
  *    (retain 行按 retain 既有语义,活过受控退)。
- * 三项在同一次读里求出,`/health` 的 `inflight` 与 `inflightBreakdown` 因此永远自洽。只有这两个函数各写一次这两个和,没有第三张计法表。
- * 阻断集只需要前两项:判停路径(排空 1 s 拍 / 租约拍 / SIGHUP 拍)**不求值** `sessionResident`(那是对进程级注册表的一次逐会话走查,只在 `/health` 与崩溃遗言里付)。
+ * 不进任何一项的(计法表成文的行):停驻待赎回的 run 与停驻的后台子代理(耐久,不占执行座)· 活过起它的腿的 workflow(任务表分不出它在干活还是在等人,见
+ * `session-resident-background.ts` 头注)· retain 的后台 shell · 只读订阅流(只进 `attachedStreams`)。
+ * 四项在同一次读里求出(`http/server.ts` 的 `inflightBreakdown` 是唯一的分项函数,两个和都读它),`/health` 的 `inflight` 与 `inflightBreakdown` 因此永远自洽,
+ * 判停与 `/health` 也不会各有一份算法。只有这两个函数各写一次这两个和,没有第三张计法表。
  */
 export interface InflightBreakdown {
     readonly http: number;
     readonly leader: number;
+    readonly backgroundAgents: number;
     readonly sessionResident: number;
 }
 /** 阻断集 = 必须等完的活 = `drainState.blockingInflight()`(`sessionResident` 不在内)。 */
-export declare function blockingInflightOf(b: Pick<InflightBreakdown, "http" | "leader">): number;
-/** 总数 = 引擎此刻托管的全部活 = `/health.inflight`(= 阻断集 + 会话驻留项)。 */
+export declare function blockingInflightOf(b: InflightBreakdown): number;
+/** 总数 = 引擎此刻托管的全部活 = `/health.inflight`(= 阻断集 + 会话驻留的 shell / monitor 项)。 */
 export declare function inflightTotal(b: InflightBreakdown): number;
 /**
  * 引擎与 HTTP 面共享的排空盒子(装配层建一只,`createHttpServer` 与收尾链各自往上装读口 / 入口)。
@@ -114,7 +121,7 @@ export interface DrainState {
     inflight?: () => number;
     /** 分项读口(`createHttpServer` 装,与 `inflight` / `blockingInflight` 同一次装、同一份求值)。`/health` 读它一次,同时出 `inflight` 与 `inflightBreakdown` 两键。 */
     inflightBreakdown?: () => InflightBreakdown;
-    /** **阻断集**读口(`createHttpServer` 装):还有没有必须等完的活 = `blockingInflightOf(inflightBreakdown())` = `http + leader`。排空等的(`boot/shutdown.ts` 的排空驱动表)、
+    /** **阻断集**读口(`createHttpServer` 装):还有没有必须等完的活 = `blockingInflightOf(inflightBreakdown())` = `http + leader + backgroundAgents`。排空等的(`boot/shutdown.ts` 的排空驱动表)、
      *  孤儿窗 / 附着租约自退(`boot/engine-lease.ts`)、SIGHUP 空闲窗(`sighup-idle.ts`)的「可以停了吗」都读它;会话驻留的后台 shell / monitor 不在内。 */
     blockingInflight?: () => number;
     lastActivityAt?: () => number;

package/dist/fleet/drain-entry.js

@@ -11,7 +11,7 @@ export const DRAIN_CAUSE_COUNTS_AS_FIRST_STOP_SIGNAL = {
     "self-exit:attachment": false,
 };
 export function blockingInflightOf(b) {
-    return b.http + b.leader;
+    return b.http + b.leader + b.backgroundAgents;
 }
 export function inflightTotal(b) {
     return blockingInflightOf(b) + b.sessionResident;

package/dist/fleet/serving-lease.js

@@ -1,5 +1,6 @@
-import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { atomicWriteFileSync } from "../plugins/owner-only-file-mode.js";
 import { SERVING_LEASE_TTL_DEFAULT_MS, readServingLeaseResponse } from "@sema-agent/settings-schema/fleet";
 import { centerFetch } from "../web-admin-client/center-request.js";
 import { recordFailOpen } from "../observability/fail-open.js";
@@ -66,10 +67,8 @@ export function createServingLeaseClient(o) {
             return false;
         }
         const record = { worker: o.center.worker, generation: o.generation, reason, at: epoch() };
-        const tmp = `${stickyPath}.tmp-${process.pid}`;
         try {
-            writeFileSync(tmp, `${JSON.stringify(record)}\n`, { mode: 0o600 });
-            renameSync(tmp, stickyPath);
+            atomicWriteFileSync(stickyPath, `${JSON.stringify(record)}\n`, { durability: "best-effort" });
             return true;
         }
         catch (err) {

package/dist/history-anchor.d.ts

@@ -0,0 +1,22 @@
+import type { ResumeAnchorStore } from "./plugins/store-backend.js";
+/** 两族:码与句尾(出路)。键 = 族名;加一族 = 加一行(两只调用方按族名取,不手写码)。 */
+declare const HISTORY_ANCHOR_FAMILIES: {
+    /** 分叉式回卷(会话在那条消息处分叉)。 */
+    readonly resumeAt: {
+        readonly code: "resume_at.unknown_event";
+        readonly wayOut: "give an explicit resumeAt";
+    };
+    /** 只恢复代码(提交体 `rewindFilesTo` 与 run 外口的 `to` 同族同码)。 */
+    readonly rewindFilesTo: {
+        readonly code: "rewind_files_to.unknown_event";
+        readonly wayOut: "name another prompt";
+    };
+};
+export type HistoryAnchorFamily = keyof typeof HISTORY_ANCHOR_FAMILIES;
+/**
+ * 手柄 → entry id;未知 ⇒ 抛 404(族码 + 共用半句)。`owner` = 锚行的属主键(锚店的 null-safe 属主守卫):提交面传提交者,run 外口传会话属主
+ * (门已证调用方读得到这只会话;锚由这只会话的提交落下,属主键就是会话属主 —— 运维代人回退读的是同一把键)。`field` = 句首点名的请求字段。
+ */
+export declare function resolveHistoryAnchor(family: HistoryAnchorFamily, store: Pick<ResumeAnchorStore, "resolve">, sessionId: string, handle: string, owner: string | null, field: string): Promise<string>;
+export {};
+//# sourceMappingURL=history-anchor.d.ts.map

package/dist/history-anchor.js

@@ -0,0 +1,14 @@
+import { HttpError } from "./security.js";
+const NO_ANCHOR_HINT = "no rewind anchor is recorded under that handle (a prompt that carried attachments records none when its attachment frames were interrupted or their count did not match)";
+const HISTORY_ANCHOR_FAMILIES = {
+    resumeAt: { code: "resume_at.unknown_event", wayOut: "give an explicit resumeAt" },
+    rewindFilesTo: { code: "rewind_files_to.unknown_event", wayOut: "name another prompt" },
+};
+export async function resolveHistoryAnchor(family, store, sessionId, handle, owner, field) {
+    const entryId = await store.resolve(sessionId, handle, owner);
+    if (entryId !== undefined)
+        return entryId;
+    const { code, wayOut } = HISTORY_ANCHOR_FAMILIES[family];
+    throw new HttpError(404, `${field}: no such message in this session (${code}) — ${NO_ANCHOR_HINT}; ${wayOut}`, { code });
+}
+//# sourceMappingURL=history-anchor.js.map

package/dist/hooks/command-spawn.d.ts

@@ -6,13 +6,10 @@ export interface HookPluginContext {
     readonly dataDir?: string;
     readonly options?: Readonly<Record<string, string>>;
 }
-/** 本仓会跑的 command 条目:契约形 + 本仓读的两只 wire 键。 */
+/** 本仓会跑的 command 条目:契约形(含 `args` / `onFailure`)+ 本仓先于契约读的 wire 键 `plugin`(契约包不承运它;收口票 [ref])。 */
 export type RunnableCommandHookEntry = CommandHookEntry & {
-    readonly args?: readonly string[];
     readonly plugin?: HookPluginContext;
 };
-/** 受理面:`args` 合形(串数组、元素无 NUL)⇒ 拷贝;否则 `undefined`。 */
-export declare function readHookArgs(raw: unknown): string[] | undefined;
 /** 受理面:`plugin` 合形 ⇒ 拷贝;否则 `undefined`。路径与 `skills[i].baseDir` 同一只判(契约包 `isAbsoluteHostPath`:绝对、无 `..` 段、无 NUL、有长度上限);不做存在性检查(那是执行面的事)。 */
 export declare function readHookPlugin(raw: unknown): HookPluginContext | undefined;
 /** 插件上下文的总字符数(服务侧上限 `plugin` 帽的量):名 + 根 + 数据目录 + 各选项的键与值。 */

package/dist/hooks/command-spawn.js

@@ -8,17 +8,6 @@ function isRecord(v) {
     const proto = Object.getPrototypeOf(v);
     return proto === Object.prototype || proto === null;
 }
-export function readHookArgs(raw) {
-    if (!Array.isArray(raw))
-        return undefined;
-    const out = [];
-    for (const a of raw) {
-        if (typeof a !== "string" || a.includes("\0"))
-            return undefined;
-        out.push(a);
-    }
-    return out;
-}
 export function readHookPlugin(raw) {
     if (!isRecord(raw))
         return undefined;

package/dist/hooks/hook-runner.d.ts

@@ -110,7 +110,7 @@ export type SupportedHookEntryType = {
 }[HookEntryType];
 /** 本仓会真跑的条目类型闭集(契约 {@link HOOK_ENTRY_TYPES} 的次序)—— 拒句 `supported: …` 的词表与 {@link RunnableHookEntry} 的类型都出自这一张表。 */
 export declare const SUPPORTED_HOOK_ENTRY_TYPES: readonly SupportedHookEntryType[];
-/** 本 runner 会真跑的条目(契约 `HookEntry` 取表态为 `true` 的那几型;command 条目另带本仓读的两只 wire 键 `args` / `plugin`,见 `command-spawn.ts`)。 */
+/** 本 runner 会真跑的条目(契约 `HookEntry` 取表态为 `true` 的那几型;command 条目另带本仓读的 wire 键 `plugin`,见 `command-spawn.ts`)。 */
 export type RunnableHookEntry = {
     [T in SupportedHookEntryType]: T extends "command" ? RunnableCommandHookEntry : Extract<HookEntry, {
         type: T;
@@ -331,11 +331,12 @@ export interface UnnamedHooksRefusalIssue {
     readonly reason: "unnamed_refusal";
     readonly path: ConfigPath;
 }
-/** 本仓读的 wire 键(契约分类器不认、会剥掉的那三只)。 */
-export type HooksWireKey = "source" | "plugin" | "args";
+/** 本仓读的 wire 键(契约分类器不认、会剥掉的那两只)。 */
+export type HooksWireKey = "source" | "plugin";
 /**
- * 本仓的 wire 键形错(`path` 指那只键:组的 `source` / command 条目的 `plugin` / `args`)。这三只键分类器不认(它对未知键一律剥除),
- * 由 {@link parseHooksConfig} 在分类器装上的同一坐标上读 —— 形错 = 拒,**不**再被静默剥掉(剥掉 `source` = 托管组落进非托管道;剥掉 `args` = exec 形只剩可执行名)。
+ * 本仓的 wire 键形错(`path` 指那只键:组的 `source` / command 条目的 `plugin`)。这两只键分类器不认(它对未知键一律剥除),
+ * 由 {@link parseHooksConfig} 在分类器装上的同一坐标上读 —— 形错 = 拒,**不**再被静默剥掉(剥掉 `source` = 托管组落进非托管道;剥掉 `plugin` = 插件上下文不在)。
+ * (`args` 自契约包 19.0.0 起由分类器承运,形错是分类器的块码,不在这里。)
  */
 export interface HooksWireKeyIssue {
     readonly reason: "wire_key_invalid";
@@ -451,10 +452,11 @@ export declare function hooksCoordinate(path: ConfigPath): string;
  *    一块被剔(`loaded-partial`)或整份被拒(`rejected`)都是拒 —— wire 面「剔掉坏块、其余照装」会让写的人以为生效的钩子无声消失(分类器的宽松粒度是读设置文件的宿主用的)。
  *    拒的判决 = 分类器给的**码 + 坐标 + 坏字段**({@link HooksPieceIssue};分类器不写句子,句子与 400 体的机读位由 {@link buildHooksRefusal} 铸)。
  *  · **本仓不执行的条目类型整份拒**:分类器受理契约的全部五型,而本仓只跑 {@link SUPPORTED_HOOK_ENTRY_TYPES}。含其余类型的配置整份拒,不留跳过臂。
- *  · **本仓的 wire 键**(分类器不认、会剥掉的三只):组上的 `source`(来源闭集,`hook-source.ts`)、command 条目上的 `plugin` / `args`(执行上下文,`command-spawn.ts`)——
+ *  · **本仓的 wire 键**(分类器不认、会剥掉的两只):组上的 `source`(来源闭集,`hook-source.ts`)、command 条目上的 `plugin`(插件上下文,`command-spawn.ts`)——
  *    在分类器装上的**同一坐标**上读原值(分类器只在 `loaded` 时放行,装上的件与原值逐位对齐),形错 ⇒ {@link HooksWireKeyIssue}。
- *    `plugin` / `args` 只在 command 条目上有义。值为 `undefined` 与缺席同读(与分类器读可选字段同一口径)。
- *  · **读者不携带的键**(分类器不认的字段、非 command 条目上的 `plugin` / `args`、组上的拼错键):本读者的可跑形里没有它们(读法照分类器)。
+ *    `plugin` 只在 command 条目上有义。值为 `undefined` 与缺席同读(与分类器读可选字段同一口径)。
+ *    契约字段(含 19.0.0 起承运的 `args` / `onFailure`)随分类器装上的条目整条到达,本读者不再读第二遍原值。
+ *  · **读者不携带的键**(分类器不认的字段、非 command 条目上的 `plugin`、契约只给别的型的字段(如 http 条目上的 `args`)、组上的拼错键):本读者的可跑形里没有它们(读法照分类器)。
  *    「写了却被剥掉」在 FRESH 提交面由键闭集门的第三个实例拒(`task-settings.ts` 的 `hooksKeyIssue`,词表 = 本函数交回的可跑形,400 `request.body_shape`);
  *    续跑重放腿不过那道门,存量体按受理时的读法重放(剥掉,不砖停驻任务)。
  *  · **服务侧上限**(广度闸;契约本身不设量纲)。exec 形的命令行(`command` + 各 `args`)计入 `command` 帽;插件上下文一道总字符帽。
@@ -616,6 +618,48 @@ export declare const PERMISSIVE_VERDICT_EVENTS: {
     readonly PreModelSwitch: false;
     readonly PostModelSwitch: false;
 };
+/**
+ * 条目 `onFailure: "block"` 在哪些事件上**生效**(`true` = 这一条在这个事件上被选中却没给出裁决 ⇒ 按 exit 2 算,见 {@link blocksOnFailure})。
+ * 一条读法 = 参照实现 CC 2.1.309(`cli309.js:263822`:`kGe(e,n) = yGe(e) && !_Ge.has(n)`,`_Ge` = Stop / SubagentStop / TaskCompleted / TeammateIdle —— 「该停的停不下」比「守卫起不来」更糟的四站);
+ * 本服务一处偏离:观察站 StopFailure / PostCompact 取 `false` —— 本服务里这两站的 exit 2 无处兑现(观察站骨架把它记成故障帧),按 exit 2 算只会把原故障帧(成因 / 退出码)改写掉、
+ * 结局仍是放行,与参照实现在这两站「阻断了也无物可阻」同一结局。壳属事件本服务不跑,按参照实现取值(哪天挪进引擎属主,缺省方向是生效 = 失效关闭)。
+ * 按事件名穷举(`satisfies Record<HookEventName, boolean>`,与 {@link PERMISSIVE_VERDICT_EVENTS} 同形):契约加一个事件而这里没表态 = 编译红。
+ */
+export declare const ON_FAILURE_BLOCK_EVENTS: {
+    readonly PreToolUse: true;
+    readonly PostToolUse: true;
+    readonly PostToolUseFailure: true;
+    readonly PostToolBatch: true;
+    readonly Notification: true;
+    readonly UserPromptSubmit: true;
+    readonly UserPromptExpansion: true;
+    readonly SessionStart: true;
+    readonly SessionEnd: true;
+    readonly Stop: false;
+    readonly StopFailure: false;
+    readonly SubagentStart: true;
+    readonly SubagentStop: false;
+    readonly PreCompact: true;
+    readonly PostCompact: false;
+    readonly PermissionRequest: true;
+    readonly PermissionDenied: true;
+    readonly Setup: true;
+    readonly TeammateIdle: false;
+    readonly TaskCreated: true;
+    readonly TaskCompleted: false;
+    readonly Elicitation: true;
+    readonly ElicitationResult: true;
+    readonly ConfigChange: true;
+    readonly WorktreeCreate: true;
+    readonly WorktreeRemove: true;
+    readonly InstructionsLoaded: true;
+    readonly CwdChanged: true;
+    readonly FileChanged: true;
+    readonly MessageDisplay: true;
+    readonly DirectoryAdded: true;
+    readonly PreModelSwitch: true;
+    readonly PostModelSwitch: true;
+};
 /**
  * hook 上下文片段 → 喂给模型的单串。**所有** `additionalContext` 聚合点的唯一属主(此前是同一个
  * `contexts.join("\n")` 表达式抄在二十余处,总量帽无处可挂 —— 那正是漂移成因)。