@sema-agent/server 7.86.0 → 7.87.1

package/dist/observability/fail-open.d.ts

@@ -141,6 +141,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "#261 fleet 存活对账腿的一次 durable 读失败/超预算(2s)⇒ **本周期整轮跳过**并开熔断,不做任何投影。放行的最坏后果 = 幽灵行(发布方已死、行僵在内存 Map 里)在面板上多活几个周期,与本腿存在之前的行为等同(那时它永远活着),不是新损失;真源不受影响(`GET /v1/runs/:id` 照常)。方向刻意 fail-open 且**只向留行一侧**:读不出来 ≠ 该退休——库抖一下就把一屏在跑的任务从面板上抹掉,比多留一条幽灵行伤得多。必须留痕:静默吞掉之后「对账腿为什么一直没生效」在遥测里没有任何痕迹,而本腿的全部价值就是「幽灵行会自己走」。";
     };
+    readonly "server.fleet.terminal-notify": {
+        readonly cls: "F";
+        readonly note: "S-450:**两条臂共用**(detail 里 `read-failed` 分得开)—— ① `observability/run-terminal.ts` 的**行为订阅者**扇出(唯一铸点 `notifyRunTerminal`,三只 store 的 CAS 赢分支各调一次):某个订阅者(今天只有 fleet 对账腿的候补窗升级腿)在 `setTerminal` 的调用栈上抛错 ⇒ 吞掉并计数,终局写照常成功;② `fleet/fleet-reconciler.ts` 的事件腿在收到事件后那一次 durable 点读失败 ⇒ 这条行留在候补窗里等周期臂。⚠️ 同一只铸点上的**日志腿**(`setRunTerminalLogObserver`)走的是**相反**契约(刻意不 try、抛出让 `setTerminal` reject),**不计本 tag** —— 读遥测别把两席混成一件。方向承重:这条腿的全部价值是「把候补窗行的成对终帧从『下一个对账周期(≤60s)』提前到『durable 写落地的同一 tick』」,它是一格**投影提速**;把它的 bug 外溢成终局写 reject 会让 run 卡 running 到 reaper、claim 悬挂([868] 指纹),代价高出几个量级。放行的最坏后果 = 这条行的成对终帧退回到周期臂补发,**与本件存在之前的行为逐字等同**,不是新损失;故 F 类。必须留痕:静默吞掉之后「事件腿为什么一直没生效」在遥测里没有任何痕迹,而面板上看到的只是『偶尔慢一分钟』这种没人会立案的症状。";
+    };
     readonly "server.fleet.run-status-unmapped": {
         readonly cls: "F";
         readonly note: "A-032 P1-④:`runStatusToFleet` 收到**词表外**的 run 状态词(闭集签名之外的唯一来路 = `rowToRun` 把无约束的 status 文本列裸 cast,滚动升级里更新的副本写的新词被旧副本读到)⇒ 折成 `idle`。放行的最坏后果 = 该行在 fleet 面板上**永久滞留**(removal 集 {completed,failed,killed} 收不到 idle),纯展示面、不影响 run 本身与任何执法判据,故 F 类。方向刻意不改(把 miss 折成终局会把一条还在跑的任务从面板上摘掉,误摘比多一行更伤)。留痕是承重的:2026-06-28 on-box e2e 逮到的 `blocked` 泄漏当年只能靠人眼在面板上发现——计数让下一次词表漂移在遥测里当场显形。编译期一侧已由闭集入参 + `never` 臂执法。";
@@ -189,6 +193,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "S-02 codex R1-[medium](验真后修):decide 的 409 `approval_stale` 臂对**调用方回显的旧 token** 做归属判定(`cs.get(binding.checkpointToken)`),那次读**抛了**(store 抖动 / 版本守卫 / 行恰被清理)。修前这里是静默 `catch(()=>null)`,「读不出」被折成「确认不在库」——叠上 S-02 的 404 收口后,一次 store 抖动就会把合法旧 token 的 409+terminal 谎报成 404「没有这条审批」。修后:unreadable ⇒ **保持 409**(`terminal` 不披露——证不出归属就不说,与 2026-07-26 纪律同向;404 折叠只在读成功且未命中时走,探测方无法自控 store 故障 ⇒ 谕示封闭不破)。放行的最坏后果 = 该次拒体 `terminal` 诚实缺席(`currentPending` 由它自己的读口与属主复核另判,不受本臂牵连),壳退回重拉列表,judgment 面 fail-safe,故 F 类。留痕理由:这次读是 terminal 披露与 404 折叠两个判定的输入,长期抖动必须在遥测显形。";
     };
+    readonly "server.resume.reopen-confirm-unreadable": {
+        readonly cls: "F";
+        readonly note: "S-447(#60 M2 自查项,`http/resume-legs.ts` 的 `confirmCheckpointReopened`):续跑腿在 core 给出 reopen 族失败后按 **token** 复核「这张 checkpoint 是不是又 pending 了」,这一读抛(库拖/版本太新/店不可达)。**方向本来就是 fail-closed**:读不出 ⇒ `return true` ⇒ 「不写任何终局、重新 park」(`:1206-1212` 头注已把取舍与有界代价写死:错 park 由 `reapSuspended` 兑,错终局会孤儿化一张活 park 到 TTL)—— 所以这条腿不是 P 类,缺的只是**留痕**。放行的最坏后果 = 多一次多余的 re-park(一张已经被决掉的卡重新挂到 reaper 窗里),人面上是「这条续跑没动」而不是谁被放行了。必须登记的理由是 **uniformity**:同文件三只同形读(`:249` `server.approvals.stale-echoed-token-unreadable` · `:288` `server.approvals.stale-current-pending-unreadable` · 本腿)中只有它是黑的,于是「店一直读不出所以每条续跑都在白白 re-park」与「一切正常」在遥测上同形。计数非零 = 这台机器的 checkpoint 店在拖,运维要去看库。";
+    };
     readonly "server.approvals.stale-current-pending-unreadable": {
         readonly cls: "F";
         readonly note: "S-02 件2([5522]④→[5525]):409 `approval_stale` 拒体铸 additive 指路键 `currentPending`(本会话当前 pending 的 D-1 坐标,壳一跳重定位)时,当前 pending 行的 `cs.get(token)` 读**抛了**(store 抖动 / 滚动升级期 checkpoint 格式 version guard / 行恰被并发消费)⇒ 本次拒体**缺 `currentPending` 键**,409 本体与 `terminal` 判定照旧。放行的最坏后果 = 壳退回该键到货前的行为(重拉 GET /v1/approvals 自行重定位),纯指路/便利面,不参与任何门/CAS/resume 判定,故 F 类(同族先例:`server.park.toolcallid-read-failed`,同为 cs.get 投影读失败臂)。必须留痕:键缺席与「此刻确实没有 pending」在 wire 上同形,不计数则「指路为什么总缺」在遥测里永不显形。";

package/dist/observability/fail-open.js

@@ -132,6 +132,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "#261 fleet 存活对账腿的一次 durable 读失败/超预算(2s)⇒ **本周期整轮跳过**并开熔断,不做任何投影。放行的最坏后果 = 幽灵行(发布方已死、行僵在内存 Map 里)在面板上多活几个周期,与本腿存在之前的行为等同(那时它永远活着),不是新损失;真源不受影响(`GET /v1/runs/:id` 照常)。方向刻意 fail-open 且**只向留行一侧**:读不出来 ≠ 该退休——库抖一下就把一屏在跑的任务从面板上抹掉,比多留一条幽灵行伤得多。必须留痕:静默吞掉之后「对账腿为什么一直没生效」在遥测里没有任何痕迹,而本腿的全部价值就是「幽灵行会自己走」。",
     },
+    "server.fleet.terminal-notify": {
+        cls: "F",
+        note: "S-450:**两条臂共用**(detail 里 `read-failed` 分得开)—— ① `observability/run-terminal.ts` 的**行为订阅者**扇出(唯一铸点 `notifyRunTerminal`,三只 store 的 CAS 赢分支各调一次):某个订阅者(今天只有 fleet 对账腿的候补窗升级腿)在 `setTerminal` 的调用栈上抛错 ⇒ 吞掉并计数,终局写照常成功;② `fleet/fleet-reconciler.ts` 的事件腿在收到事件后那一次 durable 点读失败 ⇒ 这条行留在候补窗里等周期臂。⚠️ 同一只铸点上的**日志腿**(`setRunTerminalLogObserver`)走的是**相反**契约(刻意不 try、抛出让 `setTerminal` reject),**不计本 tag** —— 读遥测别把两席混成一件。方向承重:这条腿的全部价值是「把候补窗行的成对终帧从『下一个对账周期(≤60s)』提前到『durable 写落地的同一 tick』」,它是一格**投影提速**;把它的 bug 外溢成终局写 reject 会让 run 卡 running 到 reaper、claim 悬挂([868] 指纹),代价高出几个量级。放行的最坏后果 = 这条行的成对终帧退回到周期臂补发,**与本件存在之前的行为逐字等同**,不是新损失;故 F 类。必须留痕:静默吞掉之后「事件腿为什么一直没生效」在遥测里没有任何痕迹,而面板上看到的只是『偶尔慢一分钟』这种没人会立案的症状。",
+    },
     "server.fleet.run-status-unmapped": {
         cls: "F",
         note: "A-032 P1-④:`runStatusToFleet` 收到**词表外**的 run 状态词(闭集签名之外的唯一来路 = `rowToRun` 把无约束的 status 文本列裸 cast,滚动升级里更新的副本写的新词被旧副本读到)⇒ 折成 `idle`。放行的最坏后果 = 该行在 fleet 面板上**永久滞留**(removal 集 {completed,failed,killed} 收不到 idle),纯展示面、不影响 run 本身与任何执法判据,故 F 类。方向刻意不改(把 miss 折成终局会把一条还在跑的任务从面板上摘掉,误摘比多一行更伤)。留痕是承重的:2026-06-28 on-box e2e 逮到的 `blocked` 泄漏当年只能靠人眼在面板上发现——计数让下一次词表漂移在遥测里当场显形。编译期一侧已由闭集入参 + `never` 臂执法。",
@@ -180,6 +184,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-02 codex R1-[medium](验真后修):decide 的 409 `approval_stale` 臂对**调用方回显的旧 token** 做归属判定(`cs.get(binding.checkpointToken)`),那次读**抛了**(store 抖动 / 版本守卫 / 行恰被清理)。修前这里是静默 `catch(()=>null)`,「读不出」被折成「确认不在库」——叠上 S-02 的 404 收口后,一次 store 抖动就会把合法旧 token 的 409+terminal 谎报成 404「没有这条审批」。修后:unreadable ⇒ **保持 409**(`terminal` 不披露——证不出归属就不说,与 2026-07-26 纪律同向;404 折叠只在读成功且未命中时走,探测方无法自控 store 故障 ⇒ 谕示封闭不破)。放行的最坏后果 = 该次拒体 `terminal` 诚实缺席(`currentPending` 由它自己的读口与属主复核另判,不受本臂牵连),壳退回重拉列表,judgment 面 fail-safe,故 F 类。留痕理由:这次读是 terminal 披露与 404 折叠两个判定的输入,长期抖动必须在遥测显形。",
     },
+    "server.resume.reopen-confirm-unreadable": {
+        cls: "F",
+        note: "S-447(#60 M2 自查项,`http/resume-legs.ts` 的 `confirmCheckpointReopened`):续跑腿在 core 给出 reopen 族失败后按 **token** 复核「这张 checkpoint 是不是又 pending 了」,这一读抛(库拖/版本太新/店不可达)。**方向本来就是 fail-closed**:读不出 ⇒ `return true` ⇒ 「不写任何终局、重新 park」(`:1206-1212` 头注已把取舍与有界代价写死:错 park 由 `reapSuspended` 兑,错终局会孤儿化一张活 park 到 TTL)—— 所以这条腿不是 P 类,缺的只是**留痕**。放行的最坏后果 = 多一次多余的 re-park(一张已经被决掉的卡重新挂到 reaper 窗里),人面上是「这条续跑没动」而不是谁被放行了。必须登记的理由是 **uniformity**:同文件三只同形读(`:249` `server.approvals.stale-echoed-token-unreadable` · `:288` `server.approvals.stale-current-pending-unreadable` · 本腿)中只有它是黑的,于是「店一直读不出所以每条续跑都在白白 re-park」与「一切正常」在遥测上同形。计数非零 = 这台机器的 checkpoint 店在拖,运维要去看库。",
+    },
     "server.approvals.stale-current-pending-unreadable": {
         cls: "F",
         note: "S-02 件2([5522]④→[5525]):409 `approval_stale` 拒体铸 additive 指路键 `currentPending`(本会话当前 pending 的 D-1 坐标,壳一跳重定位)时,当前 pending 行的 `cs.get(token)` 读**抛了**(store 抖动 / 滚动升级期 checkpoint 格式 version guard / 行恰被并发消费)⇒ 本次拒体**缺 `currentPending` 键**,409 本体与 `terminal` 判定照旧。放行的最坏后果 = 壳退回该键到货前的行为(重拉 GET /v1/approvals 自行重定位),纯指路/便利面,不参与任何门/CAS/resume 判定,故 F 类(同族先例:`server.park.toolcallid-read-failed`,同为 cs.get 投影读失败臂)。必须留痕:键缺席与「此刻确实没有 pending」在 wire 上同形,不计数则「指路为什么总缺」在遥测里永不显形。",

package/dist/observability/metrics.d.ts

@@ -28,6 +28,9 @@ export declare class Metrics {
      *  needed). Counters are cumulative totals; histograms are reported as averages (sum/count). */
     summarize(): MetricsSummary;
 }
+/** S-451:`/metrics/summary` 上「失败最多的路由」保留几条。看板要的是**头部**,不是全表;
+ *  `routeLabel` 的值域本来就有界(路由声明表 + `"other"`),这个上限只是让这张脸的大小与路由表长解耦。 */
+export declare const HTTP_ERROR_ROUTE_TOP_N = 10;
 export interface MetricsSummary {
     runsActive: number;
     tasks: Record<string, number>;
@@ -61,6 +64,15 @@ export interface MetricsSummary {
     verifications: Record<string, number>;
     councilRuns: Record<string, number>;
     toolErrors: Record<string, number>;
+    /** S-451(additive,7.87.0):窗内 HTTP **失败**请求数,按状态码**类**聚合 —— 键只有 `"4xx"` / `"5xx"`
+     *  两种,2xx/3xx 一格不进。⚠️ `"4xx"` 里**含 `499`**(本仓给「客户端在响应结束前断连」铸的标签,
+     *  SSE 长连接上是常态)—— 看一场真风暴时按 {@link httpErrorsByRoute} 分辨是哪条腿。
+     *  空对象 = 窗内零失败(与 `tasks`/`toolErrors` 同律:键恒在场,不用缺席表示零)。 */
+    httpErrorsByClass: Record<string, number>;
+    /** S-451(additive,7.87.0):失败(4xx+5xx 合计)最多的前 {@link HTTP_ERROR_ROUTE_TOP_N} 条 **route 标签**
+     *  (`routeLabel` 的低基数形,id 已折成 `:id`;未命中路由表的落 `"other"`)。按计数降序。
+     *  这是「180 次 404 到底打在哪」的那一格。 */
+    httpErrorsByRoute: Record<string, number>;
 }
 export interface MetricSnapshot {
     counters: Array<{

package/dist/observability/metrics.js

@@ -188,9 +188,25 @@ export class Metrics {
             toolErrors: Object.fromEntries([...(this.counters.get("tool_calls_total")?.series.values() ?? [])]
                 .filter((s) => s.labels.ok === "false")
                 .map((s) => [s.labels.name ?? "?", s.value])),
+            ...(() => {
+                const failures = [...(this.counters.get("http_requests_total")?.series.values() ?? [])]
+                    .map((s) => ({ cls: /^([45])\d\d$/.exec(s.labels.status ?? "")?.[1], route: s.labels.route ?? "?", value: s.value }))
+                    .filter((x) => x.cls !== undefined);
+                const byClass = {};
+                const byRoute = {};
+                for (const f of failures) {
+                    byClass[`${f.cls}xx`] = (byClass[`${f.cls}xx`] ?? 0) + f.value;
+                    byRoute[f.route] = (byRoute[f.route] ?? 0) + f.value;
+                }
+                return {
+                    httpErrorsByClass: byClass,
+                    httpErrorsByRoute: Object.fromEntries(Object.entries(byRoute).sort((a, b) => b[1] - a[1]).slice(0, HTTP_ERROR_ROUTE_TOP_N)),
+                };
+            })(),
         };
     }
 }
+export const HTTP_ERROR_ROUTE_TOP_N = 10;
 export function createMetrics() {
     const m = new Metrics();
     m.counter("metric_gauge_eval_errors_total", "Dynamic gauge eval errors by gauge name (an erroring gauge emits NO sample that scrape — absence means unknown, not 0)");
@@ -270,6 +286,7 @@ export function createMetrics() {
     m.counter("compaction_events_total", "Compaction lifecycle events by outcome (started/completed/failed/skipped) and trigger");
     m.counter("hook_llm_calls_total", "prompt/agent hook entries that completed a model call (hooks 3b), by type");
     m.counter("auth_bridge_verify_total", "Registry SSO JWT verifications (auth-bridge), by outcome");
+    m.counter("fleet_rows_reconciled_total", "Fleet rows the #261 liveness-reconcile leg acted on, by `disposition`: 'retired' = durable was terminal, the leg projected the settled pair (terminal task frame → task_remove); 'retired_deferred' = a row that had already left declaratively (removeReason:\"orphaned\") got its settled pair BACKFILLED once durable turned terminal; 'orphaned' / 'orphaned_child' = declarative exit, NO terminal was minted (the reaper owns the death ruling); 'workflow_retired' = same projection for a workflow row. `trigger` rides ONLY the retired_deferred series (S-450): 'event' = the backfill fired on the same tick a terminal write landed through the run-store write口 (single replica), 'cycle' = it fired on the 60s reconcile cycle (cross-replica writes, and terminals flipped by the BATCH reapers, which never pass through the write口). A retired_deferred series that is 100% trigger=cycle means the event leg is not wired or this deployment\'s terminals all come from those two families");
     m.counter("fleet_lease_issued_total", "Fleet trace-lease tokens issued");
     m.counter("fleet_lease_rejected_total", "Fleet trace-lease requests rejected");
     m.counter("fleet_lease_exhausted_total", "Fleet trace-lease requests rejected because the pool was exhausted");

package/dist/observability/{run-terminal-log.d.ts → run-terminal.d.ts}

@@ -3,8 +3,14 @@ import { type RunRecord } from "../plugins/store-contracts.js";
 export interface RunTerminalRecord {
     /** 这条 run 的账本 id = `GET /v1/runs/:id` 的 id(本仓 run 行主键名为 taskId,同一个值)。 */
     runId: string;
-    sessionId: string;
-    owner: string | null;
+    /**
+     * 🔴 **只在「这条终局要出声」时在场**(S-450):三只 store 只在 `runTerminalLogLevel(...) !== undefined`
+     * 时才多付那一次 PK 读去装它(成功终局零额外查询 —— 那条注在 `run-store-sql.ts` 的 `setTerminal` 里)。
+     * 日志腿恰好只在同一形下运行,所以**它读到的恒是在场的**;行为订阅者不得依赖它。
+     */
+    sessionId?: string;
+    /** 同 {@link RunTerminalRecord.sessionId}:只在要出声的那一形在场。`null` = 行上没有 owner。 */
+    owner?: string | null;
     status: RunRecord["status"];
     /** 终局结果里的引擎侧 taskId —— 只在与 {@link RunTerminalRecord.runId} **不同**时进日志(sync 腿上 core 会把它
      *  铸成 sessionId,两者同值时重复一遍只是噪音)。 */
@@ -15,8 +21,16 @@ export interface RunTerminalRecord {
     /** 行创建到终局的墙钟毫秒(store 侧用行的 createdAt 算;算不出=不传,键缺席)。 */
     elapsedMs?: number | undefined;
 }
-/** 观测者收到的是**已判级 + 已脱敏 + 已截断**的成品——装配层只负责把它送进 logger。 */
-export type RunTerminalObserver = (level: "error" | "info", fields: Record<string, unknown>) => void;
+/** **日志腿**收到的是**已判级 + 已脱敏 + 已截断**的成品——装配层只负责把它送进 logger。 */
+export type RunTerminalLogObserver = (level: "error" | "info", fields: Record<string, unknown>) => void;
+/**
+ * **行为订阅者**(S-450):CAS 赢的那一刻收到整只 {@link RunTerminalRecord}。
+ *
+ * 🔴 载荷是**这次写自己的视角**,不是回读的 durable 行 —— 只有 `runId` / `status` 两位在**任何**形下
+ * 都为真(CAS 赢 ⇒ 行就是这个词)。日志腿专用的那几位在成功终局上**刻意缺席**(store 不为它们多付一次
+ * PK 往返,见 {@link RunTerminalRecord.sessionId})。要更多事实的订阅者请自己按 `runId` 读 durable。
+ */
+export type RunTerminalSubscriber = (rec: RunTerminalRecord) => void;
 /**
  * 终局行的级别判据。`undefined` = 不打行。
  *
@@ -25,13 +39,39 @@ export type RunTerminalObserver = (level: "error" | "info", fields: Record<strin
  * 穷举 switch,并在 `blocked` 那一格给出与 fleet 读面互斥的答案)。表的编译期双向钉在属主处。
  */
 export declare function runTerminalLogLevel(status: RunRecord["status"], errorCode: string | undefined): "error" | "info" | undefined;
-/** 装配点(`main.ts` 唯一)。传 `undefined` 卸载(测试隔离)。 */
-export declare function setRunTerminalObserver(fn: RunTerminalObserver | undefined): void;
+/** **日志腿**的装配点(`boot/stage-01-config.ts` 唯一)。传 `undefined` 卸载(测试隔离)。 */
+export declare function setRunTerminalLogObserver(fn: RunTerminalLogObserver | undefined): void;
+/**
+ * **行为订阅者**的登记口(S-450)。返回解除登记的句柄。
+ *
+ * 与 {@link setRunTerminalLogObserver} 是**两个语义不同的席**,不是一个带旗的列表:
+ *  · 日志腿**恰一只**、装配层亲接、**不隔离**(抛出会让 `setTerminal` reject —— 见 {@link notifyRunTerminal});
+ *  · 行为订阅者**可多只**、运行期来去、**逐只隔离**(抛出吞掉 + `recordFailOpen`)。
+ * 两条失败契约相反,所以它们必须是两个名字;混进一个列表再加一个 `isolate` 位,就是把「这条腿出事
+ * 该不该把 run 拖下水」这个**语义**降级成一个**配置**。
+ */
+export declare function subscribeRunTerminal(fn: RunTerminalSubscriber): () => void;
+/** test-only:清空行为订阅者(用例之间不串台;日志腿用 `setRunTerminalLogObserver(undefined)`)。 */
+export declare function resetRunTerminalSubscribersForTest(): void;
 /**
- * store 的终局写口在 **CAS 赢了之后**调用它。未装配观测者 ⇒ 无操作(纯内存/无 boot 的单测车道)。
+ * 🔴 **run 行翻终局的唯一铸点** —— 三个 run store 的 `setTerminal` 在 **CAS 赢了之后**各调它一次
+ * (SQL 腿 `w.affected > 0`,file / memory 腿在同判据的 CAS 分支内)。「CAS 赢了才发」是**恰一次**的来源:
+ * 调用侧的兜底腿有意会对同一行重复写(cancel × leg-throw × reaper 三向),打空的那几次一个字都不发。
+ *
+ * 两条出口,**失败契约相反**,顺序承重:
+ *  ① **行为订阅者先**({@link subscribeRunTerminal},逐只 try)—— 它们要在日志腿万一违约抛出之前跑完;
+ *  ② **日志腿后**({@link setRunTerminalLogObserver},级别筛 + 脱敏 + 不 try)。
+ *
+ * 为什么日志腿**刻意不 try**(原文保留,[ref] 的成文理由):静默吞掉观测者异常 = 又造一条「走了兜底与
+ * 一切正常同形」的路,方向与本模块的存在理由相反;生产装配的那一只只调 `Logger`(`createLogger` 的 emit
+ * 内部已把 JSON.stringify 与 write 全部 try 住,结构上不抛)。
+ * 为什么行为订阅者**必须 try**(S-450 新加的那一半):它们是**行为腿**,不是一只结构上不抛的 logger;
+ * 而本函数跑在 `setTerminal` 的调用栈上、**CAS 已经赢了、行已经落盘**,此时把订阅者的 bug 放大成
+ * 「终局写 reject」= run 卡 `running` 到 reaper + claim 悬挂([ref] 指纹)。吞但**不静默**:
+ * `recordFailOpen("server.fleet.terminal-notify")`(F 类,普查登记在案)。
  *
- * 脱敏:`errorMessage` 过 `redactSecrets` 再截断到 {@link MESSAGE_CAP} —— provider 的错误体
- * 会原样回显请求片段(取证里的 403 体带订阅链接;别的 provider 会回显 Authorization 头前缀),
+ * 脱敏(只在日志腿那一格):`errorMessage` 过 `redactSecrets` 再截断到 {@link MESSAGE_CAP} —— provider 的
+ * 错误体会原样回显请求片段(取证里的 403 体带订阅链接;别的 provider 会回显 Authorization 头前缀),
  * 而引擎日志是运维面、常被整条采集走。`errorCode` / `model` 是闭集式短标量,verbatim。
  */
 export declare function notifyRunTerminal(rec: RunTerminalRecord): void;
@@ -164,4 +204,4 @@ export declare function memoRedactTerminalResult<T extends Parameters<typeof red
 export declare function diffScanShadowCountForTest(): number;
 export declare function resetDiffScanShadowCountForTest(): void;
 export declare function resetReadRedactionMemoForTest(): void;
-//# sourceMappingURL=run-terminal-log.d.ts.map
+//# sourceMappingURL=run-terminal.d.ts.map

package/dist/observability/{run-terminal-log.js → run-terminal.js}

@@ -10,20 +10,38 @@ export function runTerminalLogLevel(status, errorCode) {
         return undefined;
     return errorCode === "cancelled" ? "info" : "error";
 }
-let observer;
-export function setRunTerminalObserver(fn) {
-    observer = fn;
+let logObserver;
+const subscribers = new Set();
+export function setRunTerminalLogObserver(fn) {
+    logObserver = fn;
+}
+export function subscribeRunTerminal(fn) {
+    subscribers.add(fn);
+    return () => {
+        subscribers.delete(fn);
+    };
+}
+export function resetRunTerminalSubscribersForTest() {
+    subscribers.clear();
 }
 export function notifyRunTerminal(rec) {
+    for (const fn of [...subscribers]) {
+        try {
+            fn(rec);
+        }
+        catch (err) {
+            recordFailOpen("server.fleet.terminal-notify", `runId=${rec.runId} err=${errorText(err)}`);
+        }
+    }
     const level = runTerminalLogLevel(rec.status, rec.errorCode);
-    if (level === undefined || !observer)
+    if (level === undefined || !logObserver)
         return;
     const raw = rec.errorMessage;
     const message = raw === undefined ? undefined : (redactErrorMessage(raw) ?? "").slice(0, MESSAGE_CAP);
-    observer(level, {
+    logObserver(level, {
         runId: rec.runId,
-        sessionId: rec.sessionId,
-        ...(rec.owner !== null ? { owner: rec.owner } : {}),
+        sessionId: rec.sessionId ?? "",
+        ...(rec.owner !== undefined && rec.owner !== null ? { owner: rec.owner } : {}),
         status: rec.status,
         ...(rec.resultTaskId !== undefined && rec.resultTaskId !== rec.runId ? { taskId: rec.resultTaskId } : {}),
         ...(rec.model !== undefined ? { model: rec.model } : {}),
@@ -365,6 +383,7 @@ const STATS_GATE_ROW_TREATMENT = {
     decision: "verbatim",
     toolName: "verbatim",
     toolArg: "model-text",
+    toolCallId: "verbatim",
 };
 const STATS_REPETITION_EVENT_TREATMENT = {
     turn: "verbatim",
@@ -667,4 +686,4 @@ export function resetReadRedactionMemoForTest() {
     readMemoDirty.clear();
     readMemoDirtyBytes = 0;
 }
-//# sourceMappingURL=run-terminal-log.js.map
+//# sourceMappingURL=run-terminal.js.map

package/dist/plugins/file-run-store.js

@@ -1,4 +1,4 @@
-import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { join } from "node:path";
 import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
@@ -7,7 +7,7 @@ import { terminalProjection } from "@sema-agent/core";
 import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprint, readJsonlRecords, sanitizePathComponent, writeThenLink } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { StoreBootRefusalError } from "./store-contracts.js";
-import { notifyRunTerminal } from "../observability/run-terminal-log.js";
+import { notifyRunTerminal } from "../observability/run-terminal.js";
 import { migrateRetiredAskOrigin } from "./one-time-migrations.js";
 const ownerEq = (a, b) => (a ?? null) === (b ?? null);
 const CLAIM_TAKEOVER_ATTEMPTS = 3;

package/dist/plugins/memory-run-store.js

@@ -1,7 +1,7 @@
-import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { terminalProjection } from "@sema-agent/core";
-import { notifyRunTerminal } from "../observability/run-terminal-log.js";
+import { notifyRunTerminal } from "../observability/run-terminal.js";
 const ownerEq = (a, b) => (a ?? null) === (b ?? null);
 export class MemoryRunStore {
     runs = new Map();

package/dist/plugins/remote-scratchpad.js

@@ -1,4 +1,4 @@
-import { redactHead } from "../observability/run-terminal-log.js";
+import { redactHead } from "../observability/run-terminal.js";
 const REMOTE_SCRATCHPAD_LANES = new Set(["e2b", "k8s", "local-docker", "ssh", "device"]);
 export function isRemoteScratchpadLane(provider) {
     return provider !== undefined && REMOTE_SCRATCHPAD_LANES.has(provider);

package/dist/plugins/run-store-sql.js

@@ -1,10 +1,10 @@
-import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal.js";
 import { terminalProjection } from "@sema-agent/core";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { escapeLike } from "./sql-escape.js";
 import { pgSanitizeText } from "./pg-safe-json.js";
 import { parseJsonLenient as parseJson, toIso as iso } from "./sql-row-helpers.js";
-import { notifyRunTerminal, runTerminalLogLevel } from "../observability/run-terminal-log.js";
+import { notifyRunTerminal, runTerminalLogLevel } from "../observability/run-terminal.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
 const RUN_ROW_COLS = "task_id, session_id, owner, status, result, error, error_code, job_id, source, instance_id, cancel_requested, objective_preview, created_at, updated_at";
@@ -121,6 +121,7 @@ export class SqlRunStore {
         result = redactTerminalResult(result);
         error = error === null ? null : (redactErrorMessage(error) ?? null);
         const errorCode = result === null ? null : (terminalProjection(result.terminal).errorCode ?? null);
+        let won = false;
         let observed;
         await this.tx(async (conn) => {
             const w = await conn.query(this.q("UPDATE task_run SET status = ?, result = ?, error = ?, error_code = ?, updated_at = ? WHERE task_id = ? AND status IN ('running','suspended','needs_review')", "UPDATE task_run SET status = $1, result = $2::jsonb, error = $3, error_code = $4, updated_at = $5 WHERE task_id = $6 AND status IN ('running','suspended','needs_review')"), [
@@ -131,7 +132,8 @@ export class SqlRunStore {
                 new Date(),
                 taskId,
             ]);
-            if (w.affected > 0 && runTerminalLogLevel(status, errorCode ?? undefined) !== undefined) {
+            won = w.affected > 0;
+            if (won && runTerminalLogLevel(status, errorCode ?? undefined) !== undefined) {
                 const { rows } = await conn.query(this.q("SELECT owner, session_id, created_at FROM task_run WHERE task_id = ?", "SELECT owner, session_id, created_at FROM task_run WHERE task_id = $1"), [taskId]);
                 const row = rows[0];
                 const createdAt = row ? Date.parse(iso(row.created_at)) : NaN;
@@ -143,17 +145,16 @@ export class SqlRunStore {
             }
             await conn.query(this.q("DELETE FROM task_active WHERE task_id = ?", "DELETE FROM task_active WHERE task_id = $1"), [taskId]);
         });
-        if (observed) {
+        if (won) {
             notifyRunTerminal({
                 runId: taskId,
-                sessionId: observed.sessionId,
-                owner: observed.owner,
+                ...(observed ? { sessionId: observed.sessionId, owner: observed.owner } : {}),
                 status,
                 resultTaskId: result?.taskId,
                 model: result?.model,
                 errorCode: errorCode ?? undefined,
                 errorMessage: (result === null ? undefined : terminalProjection(result.terminal).errorMessage) ?? error ?? undefined,
-                elapsedMs: observed.createdAt === undefined ? undefined : Math.max(0, Date.now() - observed.createdAt),
+                elapsedMs: observed?.createdAt === undefined ? undefined : Math.max(0, Date.now() - observed.createdAt),
             });
         }
     }

package/dist/plugins/store-contracts.d.ts

@@ -153,7 +153,7 @@ export interface RunRecord {
  *  · `parked` —— 停在门上还能再动(`suspended` 审批/资源门、`needs_review` 评审门)。
  *
  * 🔴 为什么是**一张表**而不是三张 switch(S-213③,2026-09-11):`blocked` 这个词此前在本仓有**两个
- * 独立写者**且答案互斥 —— `observability/run-terminal-log.ts` 判它是「治理判决,不是失败 ⇒ 不打行」,
+ * 独立写者**且答案互斥 —— `observability/run-terminal.ts` 判它是「治理判决,不是失败 ⇒ 不打行」,
  * `fleet/fleet-bus.ts` 判它是「非成功终局(agent 放弃)⇒ failed 桶、行离场」。两处各自穷举、各自正确
  * 地编译,而一条 `report_blocked` 的 run 在面板上离场、在引擎日志里一个字都没有。三张手抄的 switch
  * 就是三个写者;收成一张表之后,词的语义只有这一处能改。
@@ -165,7 +165,7 @@ export interface RunRecord {
  * core 已经没有的词同样红(超出键)。终局词表真变过(core 5.8.0 把 `"timeout"` 从 `TaskStatus` 删了)。
  *
  * 判据不许再被手抄成第二份:消费点(`approval-reconciler.ts` 判据 2、`http/routes/runs.ts` 的取消后
- * 复读、`observability/run-terminal-log.ts` 的级别判、`fleet/fleet-bus.ts` 的 failed 桶编译钉)都从这里取。
+ * 复读、`observability/run-terminal.ts` 的级别判、`fleet/fleet-bus.ts` 的 failed 桶编译钉)都从这里取。
  */
 export type RunStatusClass = "live" | "succeeded" | "unsuccessful" | "parked";
 export declare const RUN_STATUS_CLASS: {

package/dist/plugins/workflow-run-store-sql.js

@@ -1,4 +1,4 @@
-import { redactErrorMessage, redactHead } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactHead } from "../observability/run-terminal.js";
 import { summarizeWorkflowRun, isTerminalWorkflowStatus, WorkflowRunStoreError } from "@sema-agent/core";
 import { foldKeyFamily, MAX_PENDING_PER_SESSION, PURGE_FENCE_MS, SERVED_FENCE_MS, } from "../orchestration/workflow-completion-inbox.js";
 import {} from "../orchestration/workflow-agent-session-index.js";

package/dist/runs.js

@@ -1,7 +1,7 @@
 import { runWithVerification, runCascade, defaultTaskRegistry, terminalProjection, DURABLE_AGENT_HANDLE_RE } from "@sema-agent/core";
 import { failureCodeOf, stripResumeToken } from "./terminal.js";
 import { GOVERNANCE_HTTP_STATUS } from "./governance-http-status.js";
-import { redactErrorMessage } from "./observability/run-terminal-log.js";
+import { redactErrorMessage } from "./observability/run-terminal.js";
 import { withPrincipal } from "./observability/principal-context.js";
 import { redactSecrets } from "./trace/redact.js";
 import { taskNotificationEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "./trace/project.js";

package/dist/session-titler.js

@@ -26,6 +26,10 @@ export function createSessionTitler(deps) {
         deps.logger?.debug?.("session_title_failed", { sessionId, error: error.slice(0, 200) });
         recordFailOpen("server.session-titler.gateway-unreachable", error.slice(0, FAIL_CAUSE_KEY_CHARS));
     };
+    const probeOrContinue = async (sessionId, continueWord) => deps
+        .probeTitle(sessionId)
+        .then((state) => ({ state, unreadable: false }))
+        .catch(() => ({ state: continueWord, unreadable: true }));
     return {
         maybeTitle(sessionId, objective, model) {
             if (!sessionId || !objective.trim())
@@ -39,10 +43,10 @@ export function createSessionTitler(deps) {
             }
             seen.add(sessionId);
             void (async () => {
-                let state = await deps.probeTitle(sessionId).catch(() => "untitled");
+                let state = (await probeOrContinue(sessionId, "untitled")).state;
                 if (state === "none") {
                     await new Promise((r) => setTimeout(r, NO_ROW_RETRY_MS));
-                    state = await deps.probeTitle(sessionId).catch(() => "untitled");
+                    state = (await probeOrContinue(sessionId, "untitled")).state;
                     if (state === "none") {
                         seen.delete(sessionId);
                         deps.metrics?.inc("session_title_total", { outcome: "row_not_yet" });
@@ -66,10 +70,10 @@ export function createSessionTitler(deps) {
                 }
                 const landed = await deps.setTitleIfNull(sessionId, title);
                 if (!landed) {
-                    const after = await deps.probeTitle(sessionId).catch(() => "titled");
-                    if (after === "none")
+                    const after = await probeOrContinue(sessionId, "none");
+                    if (after.state === "none")
                         seen.delete(sessionId);
-                    deps.metrics?.inc("session_title_total", { outcome: after === "none" ? "row_not_yet" : "already_titled" });
+                    deps.metrics?.inc("session_title_total", { outcome: after.unreadable ? "probe_failed" : after.state === "none" ? "row_not_yet" : "already_titled" });
                     return;
                 }
                 deps.metrics?.inc("session_title_total", { outcome: "set" });

package/dist/tool-approval.d.ts

@@ -420,6 +420,22 @@ export interface LivePendingRow {
      *  `approval-content-kind.ts`,与 durable 两读面 / core summarize 面同词,OMIT 契约同族)。
      *  缺席 = 普通工具 ask。展示/分诊分型用,永不参与决议路由。 */
     contentKind?: "content_ask";
+    /**
+     * 🔴 S-454(P1;cli L-397 / 板 [ref]):这只 ask **本来会 emit 的那只活卡帧**。
+     *
+     * 值 = {@link PendingApproval.frame} 的**引用** —— `askBroadcast` 里那一处唯一构造(已过
+     * `redactDeep` / 字节帽 / [ref] 窗三键补写)的**同一个对象**,悬挂与可达两条路共用它。⇒ 这一格
+     * **不是**为列表另算的第二份卡投影:一处脱敏属主不变、零第二脱敏面,「wire 帧与列表行同一份判据」
+     * 是结构事实而不是两处各算一遍的巧合(同 `card_json` 与帧的关系)。
+     *
+     * 🔴 为什么本行不再守「input/args 不上列表」那条窄化:那条纪律的理由原文是「详情走流帧」——
+     * 而**悬挂 ask 永远没有流帧**(铸造时刻零投递目标,`suspended`),对它这条理由结构上不成立。
+     * 消费方要出卡就必须在这一行上拿到卡体,否则「列得到但渲不出」。一视同仁给**全部** live 行
+     * (规则集不因 `suspended` 分叉:有活流的 ask 多带一份它自己那张卡的副本无害)。
+     *
+     * 缺席 = 老 server(7.86.0 及以前);本服务自 7.87.0 起**恒在场**(条目上是必填格)。恒不铸 `null`。
+     */
+    frame?: ToolApprovalFrame;
 }
 export interface ToolApprovalRunContext {
     taskId: string;
@@ -1309,8 +1325,12 @@ export declare class ToolApprovalCoordinator {
      *  方法体的逐字搬运([ref] 车2 拆分,行为零改动)。 */
     private finishRespond;
     /** [ref]([ref] 案):live pending 的**列表读面**——`GET /v1/approvals` 响应第二顶层键 `livePending`
-     *  的唯一数据源。纯读投影,零锁/零结算语义;行键集刻意窄(**input/args 不上列表**,不开第二个脱敏
-     *  面;详情走流帧)。`scope` 与 durable 面同一表达式:`undefined` = operator 全量(含 owner null 的
+     *  的唯一数据源,**同时**是 `/v1/approvals/stream` 的 live 半场 diff 源(推与拉必须同源:feed 收到
+     *  `live_pending` 事件就会去 `list()`,两处各读各的会给出一条列不出来的事件)。纯读投影,零锁/零结算
+     *  语义。
+     *  🔴 **S-454 起行上带整只活卡帧**(`frame`,见 {@link LivePendingRow.frame}):旧文那句「input/args
+     *  不上列表,详情走流帧」对**悬挂 ask 结构上不成立**(它永远没有流帧),而 `frame` 是 `askBroadcast`
+     *  那一处构造的同一个对象 ⇒ 仍然只有**一个**脱敏属主、零第二投影。`scope` 与 durable 面同一表达式:`undefined` = operator 全量(含 owner null 的
      *  条目),串 = 只见 `owner === scope` 的条目(null-owner 行对 principal 不可见,fail-closed——
      *  宁少列不超范围;`"__none__"` 未鉴权哨兵自然恒空)。行的 `approvalId` 就是 `respond()` 收的 id
      *  (同源可达,[ref] 判据);`expiresAtMs` 照抄登记时单点铸定的窗死线([ref] 三键同一个数)。 */

package/dist/tool-approval.js

@@ -1361,6 +1361,7 @@ export class ToolApprovalCoordinator {
             ...(reachability === "unreached" ? { suspended: true } : {}),
             ...(child ? { originTaskId: req.sourceTaskId } : primary ? { targetCtxs: new Set(aliveCtxs), onTargetGone } : {}),
             ...(origin.sessionId ? { sessionId: origin.sessionId } : {}),
+            frame,
             toolName: req.toolName,
             registeredAtMs: Date.now(),
             expiresAtMs: persistedExpiresAtMs,
@@ -1981,6 +1982,7 @@ export class ToolApprovalCoordinator {
                 ...(e.governanceForced ? { governanceForced: true } : {}),
                 ...(e.originTaskId !== undefined ? { fromSubagent: true, originTaskId: e.originTaskId } : {}),
                 ...(contentKind !== undefined ? { contentKind } : {}),
+                frame: e.frame.approvalId === id ? e.frame : { ...e.frame, approvalId: id },
             });
         }
         return rows;

package/dist/trace/core-keyset-guard.d.ts

@@ -21,7 +21,7 @@ import type { TaskNotificationPayload, SemaProvenance, BackgroundChildEvent, Ros
 import type { ToolApprovalFrame } from "../tool-approval.js";
 /** 编译期断言:T 必须收敛到 never(有残余键 = tsc 红)。
  *  🔴 **导出**([ref] U1/U2):本仓「词表闭集,未处置成员=编译红」的钉法只许有**一个**形 ——
- *  `observability/run-terminal-log.ts` 的三张叶表 + 结果顶层键表用同一只断言,而不是各自再抄一份
+ *  `observability/run-terminal.ts` 的三张叶表 + 结果顶层键表用同一只断言,而不是各自再抄一份
  *  `type X<T extends never> = T`(抄一份就是第二个写者,两处哪天分岔谁都发现不了)。
  *  本文件只有类型、不产 JS,所以被 `import type` 引用不新增任何运行期边。 */
 export type AssertAllKeysHandled<T extends never> = T;

package/dist/trace/ledger-events.d.ts

@@ -74,7 +74,7 @@ export type LedgerEventType = "reasoning" | "text" | "tool_start" | "tool_end" |
  * 🔴 **park 行名的运行时闭集**(合并重扫 [4])。
  *
  * 此前这两个词在仓里有**三处**并列的字面量:`ledger-sink.ts` 的 `appendParked` 形参与 `onDone` 的分诊、
- * 以及 `observability/run-terminal-log.ts` 的脱敏臂。`LedgerEventType` 只是类型联合、运行期取不到,
+ * 以及 `observability/run-terminal.ts` 的脱敏臂。`LedgerEventType` 只是类型联合、运行期取不到,
  * 所以脱敏臂只能自己再抄一份 —— 而抄的那一份**加词不红**:仓里/引擎加第三个 park 词并登记进
  * `LedgerEventType` 之后,`appendParked` 与 resume 腿的动态首参照写照落,回放时那一行的
  * `gate.riskDescriptor.summary` 明文,脱敏臂一声不吭。

package/dist/trace/project.d.ts

@@ -116,7 +116,7 @@ export type TraceBlock = {
  * 那一案 —— 七个调用点只有三个记得拼,**漏的正是 resume 腿与 ledger-sink 落盘这两处**。
  *
  * ## 🔴 脱敏**不在这里**(写口不是脱敏属主)
- * 两行的字节由模型写,必须脱 —— 但脱敏口是 `observability/run-terminal-log.ts` 的
+ * 两行的字节由模型写,必须脱 —— 但脱敏口是 `observability/run-terminal.ts` 的
  * `redactLedgerEventData`:三孪生 store 的 `appendEvent` 落库前 + `GET /v1/runs/:id/events` 读面各过一次
  * (幂等)。理由与 park 行逐字同源(`trace/ledger-sink.ts` 的 `appendParked` 顶注是那条规矩的属主):
  * 写口脱 = 一个语义面上两个写者,且**盖不住存量行**(升级前落下的明文 `text` 行每次重连照样回放)。

package/dist/trace/project.js

@@ -1,4 +1,4 @@
-import { redactErrorMessage, redactModelText } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactModelText } from "../observability/run-terminal.js";
 import { MCP_DELIVERY_VERDICTS, screenGateOutcome, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
 import { Value } from "typebox/value";
 import { recordFailOpen } from "../observability/fail-open.js";

package/dist/trace/redact.d.ts

@@ -24,7 +24,7 @@
  * 而**模型自己写的**那一份(`TaskResult.result` / `TaskResult.salvagedOutput` / 账本 `text` 行)整条逐字
  * 上 wire —— 工具结果送模路径给的是原文,模型把里面的凭据**逐字引用**进答复,那一份就绕过了本模块。
  * 现在三面与 CoT(账本 `reasoning` 行)走**同一只** `redactSecrets`、同一张替换串表:零第二只脱敏器、
- * 零 per-face 开关、零体量上限。**装载口只有一只** —— `observability/run-terminal-log.ts` 的
+ * 零 per-face 开关、零体量上限。**装载口只有一只** —— `observability/run-terminal.ts` 的
  * `redactModelText`(四座同调:结果两叶经 `redactTerminalResult`,账本两行经 `redactLedgerEventData`);
  * 它定的是**写回**判据(认出凭据形才改字节、抛则占位),不是第二张规则表。
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.86.0",
+  "version": "7.87.1",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -54,7 +54,7 @@
     "build:binary:run-local:darwin-arm64": "bun build --compile --target=bun-darwin-arm64 src/run-local.ts --outfile dist/run-local-darwin-arm64"
   },
   "dependencies": {
-    "@sema-agent/core": "7.22.0",
+    "@sema-agent/core": "7.23.0",
     "@sema-agent/settings-schema": "2.1.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",