@sema-agent/server 7.49.0 → 7.50.0

package/USAGE.md

@@ -554,6 +554,45 @@ SEMA_PARENT_PID=$$      # 壳把自己的 pid 传给它 spawn 出来的引擎
   PID 1 是典型;终端 / launchd / systemd 不在此列),pid 表项仍在,探活同样判"活着"。两条同源:
   `kill(pid, 0)` 是**弱身份**判据。这条腿是**尽力自愈**,不是强一致的父子生命周期绑定。
 
+**可选 — 附着租约自退(`ENGINE_AUTO_EXIT`,默认关)**
+
+上一节那条腿盯的是「**生我的那个 pid** 还在吗」。多个壳会话共享**同一只**引擎时它问错了问题:首壳退了、
+peer 还在用。这条腿问的是那个真正的问题 —— **还有没有人附着**。
+
+```bash
+ENGINE_AUTO_EXIT=true    # 壳 spawn 引擎时注入;服务器部署**不要**设
+ENGINE_LINGER_MS=60000   # 可选,默认 60s,下界 1000
+```
+
+- **默认 `false` = 整件不装配**,存量部署逐字零变化。一台 k8s 上的 replica 半夜没人用是**正常低谷**,
+  不是「该退了」;自退只对**壳自 spawn 的本机引擎**有意义,所以由壳在 spawn 时显式打开。
+- **自退判据 = 三合取,且必须连续满 `ENGINE_LINGER_MS`**:① 没有附着的 SSE 流;② 没有在飞的 run
+  (与 `/health` 的 `inflight` **同一个读数**);③ 没有非探针 HTTP 触点(`/health`、`/metrics*` 不算 ——
+  探针不是「有人在用」),**且**最后一条附着流断开也已满窗。任何一条不满足即把计时**清零**。
+  (最后那半句不是修辞:一条活得比 15s 拍频还短的流整个生命周期都落在两拍之间,自查腿从没看见过它 ——
+  只有在**关闭点**记一笔离场时刻,「已经没人附着满 N 秒」才是精确的。)
+- **「run 在跑就不退」是结构性保护,没有旋钮可以关掉它** —— 最后一个壳关掉、后台 run 还在烧的场景里,
+  引擎必须活到那条 run 落地。
+- **`ENGINE_LINGER_MS` 防的是壳重启窗**:壳崩了/重启的 1-3s 里附着数确实是 0,窗太短就在用户眼皮底下
+  把引擎杀了。窗内任何一次重连即清零重新起算。
+- **实际等待 = `[ENGINE_LINGER_MS, ENGINE_LINGER_MS + 15s)`**:自查拍频固定 15s(不开旋钮),最后一条
+  租约灭在两拍之间时要到下一拍才被看见。方向是**保守**的(只会等更久)。
+- 判死后走的是**和 `SIGTERM` 逐字同一条**优雅排空腿:拒新提交(503 + `Retry-After`)→ 候在途腿跑完 →
+  停机。in-flight 的 run 照常结算 / park,**不是**裸退出;而且因为是受控退,`crash-last.json` 会被清掉
+  ⇒ 下次启动**不会**把这次自退误读成崩溃。
+- 日志:装配时一行 `engine_lease_armed`(带 `lingerMs`),自退时一行 `engine_lease_auto_exit`
+  (带 `attached` / `inflight` / `idleForMs` 三个读数),随后就是那条 `draining_started`。
+- **坏值拒启**:`ENGINE_LINGER_MS` 必须是落在 **`[1000, 86400000]`(1s…24h)** 的整数毫秒,**两端都承重**:
+  下界防 `ENGINE_LINGER_MS=60`(以为单位是秒)—— 60ms 的窗等于把整条防误杀腿静默摘掉;上界防 `1e100`
+  这类值 —— 它能过朴素的「是正整数吗」检查,而计时**永远追不上它**,于是配置看着好好的、自退其实整件
+  失效。两端一律**拒启并指路**而不是夹取。本键**没有**「关掉」的取值 —— 关自退的唯一开关是
+  `ENGINE_AUTO_EXIT=false`。校验**不看** `ENGINE_AUTO_EXIT` 的表态:否则手滑值可以在一台今天关着自退的
+  机器上一直躺着,等哪天有人打开时当场生效。
+- 🔴 **已知收窄(成文,现版不收)**:**parked-待赎回** 的 run 不在判据里,只看 running。数 parked 要发
+  SQL,而这是一只每 15s 无限期跑下去的定时器 —— 不值得为它引入周期性 SQL 轮询。parked 行是 **durable**
+  的,引擎退掉不丢:下次起来(壳的下一次 spawn)仍可赎回,伤害面是**赎回被推迟**而不是丢失。
+- 与 `SEMA_PARENT_PID` 是**两件**,可以同时设,各走各的判据。
+
 **布尔旋钮的取值与极性(运维必读)**
 
 布尔 env **只认 `true` / `false` 两个字面量**。写成 `1` / `yes` / `TRUE` ⇒ 该旋钮退回自己的缺省值,并在启动时

package/dist/boot/engine-lease.d.ts

@@ -0,0 +1,95 @@
+/**
+ * #118(黑板 [5371]②,cli [5394] 认领消费)—— 引擎**附着租约自退**。
+ *
+ * ## 防的是什么
+ *
+ * 壳自 spawn 引擎的本机形里,壳正常退出之后引擎**继续活着**:占端口、占库连接池、占模型配额,而且
+ * 用户已经离开了、再没有人会关心它。#219 的 parent 监视只覆盖「生我的那个 pid 没了」这一形,而
+ * **多壳共享一只引擎**时它结构性地问错了问题 —— 首壳退了 peer 还在用,监视父 pid 要么误杀要么永不触发。
+ * 本件问的是那个真正的问题:**还有没有人附着**。
+ *
+ * ## 机制(逐条都是契约)
+ *
+ *  1. **opt-in**:`ENGINE_AUTO_EXIT` 默认 **false** ⇒ 整件不装配(`boot/shutdown.ts` 连本函数都不调)。
+ *     服务器部署形逐字零变化 —— 一台 k8s 上的 replica 半夜没人用不是「该退了」,是**正常的低谷**。
+ *     壳 spawn 形由壳在 spawn 时显式注入 `true`。**部署级旋钮无条件生效**:它不派生自任何客户端表态
+ *     (本仓 operator-knob 铁律,#153 同病两犯史),`ENGINE_LINGER_MS` 的坏值校验也不挂在本键的表态上。
+ *  2. **自退判据 = 三合取,且必须持续满 `lingerMs`**:
+ *       · 附着租约集空(`attachedStreams() === 0`);
+ *       · 无在飞 run(`inflight() === 0` —— **与 /health 的 `inflight` 同一只 getter**,不另立第二判据);
+ *       · HTTP 触点静默(`now() - lastActivityAt() >= lingerMs`),**且**最后一条附着流的**离场**
+ *         也已满窗(`now() - lastAttachEndedAt() >= lingerMs` —— codex R1-F1,见该 dep 的注)。
+ *     任何一条不满足即把计时清零(连续性判据,不是累计)。
+ *  3. **为什么 HTTP 触点是独立的第三条**(不是冗余):纯轮询壳(零 SSE,每 2s 一次 `GET /v1/sessions`)
+ *     的请求是毫秒级的,而本腿 15s 采样一拍 —— 采样点几乎必然落在两次轮询之间,`attached` 与
+ *     `inflight` **同时读到 0**。只看那两条的实现会在一只**正被使用**的引擎底下把它关掉。租约的
+ *     建立面按设计就是「首个 HTTP/SSE 接触」,不只是 SSE。
+ *  4. **退出 = 走 `drain`**,即 `boot/shutdown.ts` 里 SIGTERM 用的那一条 `drainThenShutdown`:拒新提交
+ *     (503+Retry-After)→ 候在途腿跑完 → `hardShutdown`。in-flight run 的结算 / park 语义与人工停机
+ *     **逐字一致**。本模块自己**从不** `process.exit`。
+ *  5. **crash-last 判别位**([5371] ④「flush 判别位标 auto-exit 非崩溃」):走上面那条受控退,
+ *     `hardShutdown` 一进来就 `clearCrashLast` ⇒ 遗言文件被删 ⇒「文件在场 ⇔ 上次退出=崩溃」这条契约
+ *     对自退**自动成立**。刻意**不**另写一条 `reason:"auto-exit"` 的遗言行:那会把该文件的语义从
+ *     「崩溃判别位」稀释成「上次退出记录」,而运维读它就是为了判前者(见 `crash-last.ts` 顶注)。
+ *     自退的可观察面是 `engine_lease_auto_exit` + 随后的 `draining_started` 两行日志。
+ *  6. **interval 必须 unref**:自退检查腿不得成为「进程本该退出却退不掉」的理由(与 drain tick 刻意
+ *     不 unref 的取向相反 —— 那一只 tick 就是停机驱动,这一只只是观察者)。
+ *  7. **装配即起算**:armed 那一刻若已空闲,计时**当场**开始。覆盖的是「壳 spawn 了引擎,自己却在
+ *     第一次接触之前就崩了」这一形 —— 那只引擎一辈子没有过租约,正是本件要收的孤儿。
+ *  8. **实际窗 = `[lingerMs, lingerMs + tickMs)`**(采样腿的固有滞后,成文而非隐藏):最后一条租约是在
+ *     **两拍之间**灭的,本腿要到下一拍才看见,空闲计时从**那一拍**起表。⇒ 真实等待比 `lingerMs` 多出
+ *     0~1 拍。方向是**保守**的(等得更久,不会更早),所以不修 —— 要修就得让 SSE 关闭点反向通知本腿,
+ *     那是把一只自洽的观察者改成有状态的被通知者,不值当。运维读数以 `engine_lease_auto_exit.idleForMs`
+ *     为准(它报的是真实空闲时长,不是 `lingerMs`)。
+ *
+ * ## 已知收窄(成文,现版不收)
+ *
+ *  · **parked-待赎回 run 不入判据**:设计稿 ② 原文含「无 running/parked-待赎回 run」,本版**只看
+ *    running**。理由 = 廉价读口不存在:parked 是 store 里的**durable 行**,数它必须发 SQL,而本腿是一只
+ *    每 15s 无限期跑下去的定时器 —— 为它引入周期性 SQL 轮询,代价压过收益。**bg run 在跑不退**那一臂
+ *    已由 `inflight()` 结构性守住;parked 行是 durable 的,引擎退掉不丢:下次起来仍可赎回(spawn 形里
+ *    「下次」就是壳的下一次 spawn)。伤害面 = 一条 parked run 的赎回被推迟到下次启动,不是丢失。
+ *    这是**允许的收窄,不是静默**:有了廉价 parked 计数口(或本腿改成事件驱动)之后应当补上。
+ *  · **`/health` 探针不算触点**:`lastActivityAt` 的属主(`http/server.ts` 的 `noteActivity`)按既有契约
+ *    把 `/health` 与 `/metrics*` 排除在活性时钟之外(常态采样噪音不得把空闲窗永远撑开)。⇒ 一只**只**
+ *    轮询 `/health` 的壳不构成租约。这与 SIGHUP 空闲窗的判据同源,刻意保持一致而非在本腿另开一份。
+ */
+/** 自退检查拍频。**固定值,不开 env 旋钮**(与 `PARENT_WATCH_INTERVAL_MS` 同纪律:有真需求再议,防旋钮增殖)。 */
+export declare const ENGINE_LEASE_TICK_MS = 15000;
+export interface EngineLeaseDeps {
+    /** 活附着数 = 本副本当前**打开着的 SSE 流**条数(`drainState.attachedStreams`,由 `createHttpServer` 自赋)。 */
+    attachedStreams: () => number;
+    /** 在飞腿数 —— **`/health` 的 `inflight` 同一只 getter**(`drainState.inflight`)。不自建第二套计数:
+     *  两套计数迟早分叉,而分叉的那一侧恰好是「以为没 run 了」就把引擎关掉。 */
+    inflight: () => number;
+    /** 最后一次**非探针** HTTP 触点的单调时刻(`drainState.lastActivityAt`)。
+     *  ⚠️ 时基契约:必须与本模块的 `now` 同为 `performance.now()` 单调域(`server.ts` 的打点即该域)——
+     *  混入 `Date.now()` 会让 `now() - lastActivityAt` 差出 epoch 量级,静默判据恒真。 */
+    lastActivityAt: () => number;
+    /** 最后一条**附着流断开**的单调时刻(`drainState.lastAttachEndedAt`)。
+     *
+     *  🔴 codex 对抗复审 R1-F1(验真后修):`attachedStreams` 是**采样**面,`lastActivityAt` 记的是
+     *  **入场**(admission)时刻 —— 两者合起来仍漏一个形:一条**整个生命周期都落在两拍之间**的流
+     *  (活得比拍频短)从没被任何一拍看见,于是 `idleSince` 保持着这条流出现**之前**的旧值,而
+     *  「已经没人附着满 lingerMs」这句承诺可以提前至多一整拍兑现。补这条**离场**触点之后,判据变成
+     *  精确的「距最后一次附着结束已满 lingerMs」。缺席(0)= 本进程还没有过附着流结束。 */
+    lastAttachEndedAt: () => number;
+    /** 已有停机属主(`closing || draining`)时本腿站下:一次正在进行的优雅 drain 不该被「也没人附着了」
+     *  升级成第二信号硬停(那会斩掉 in-flight leg)。 */
+    isStopped: () => boolean;
+    /** 自退出口 = SIGTERM 那条 graceful drain(见顶注 4/5)。 */
+    drain: () => void;
+    /** 三合取**持续**满这么久才触发(`config.engineLingerMs`,默认 60s)。 */
+    lingerMs: number;
+    log: (event: string, fields: Record<string, unknown>) => void;
+    /** 检查拍频 seam(测试)。缺省 {@link ENGINE_LEASE_TICK_MS}。 */
+    tickMs?: number;
+    /** 时钟 seam,缺省 `() => performance.now()`(**单调**域)。用 `Date.now()` 会让 NTP/手动跳变吞掉或
+     *  拉长 linger 窗 —— 前跳把窗直接跳过去 = 在一只还有人用的引擎底下提前关停。 */
+    now?: () => number;
+}
+/** 装配并**立刻**起自退检查(装配即 `engine_lease_armed`)。返回停机链用的 `stop()`。 */
+export declare function createEngineLeaseTracker(deps: EngineLeaseDeps): {
+    stop(): void;
+};
+//# sourceMappingURL=engine-lease.d.ts.map

package/dist/boot/engine-lease.js

@@ -0,0 +1,56 @@
+export const ENGINE_LEASE_TICK_MS = 15_000;
+export function createEngineLeaseTracker(deps) {
+    const tickMs = deps.tickMs ?? ENGINE_LEASE_TICK_MS;
+    const now = deps.now ?? (() => performance.now());
+    let stopped = false;
+    let idleSince = now();
+    deps.log("engine_lease_armed", {
+        lingerMs: deps.lingerMs,
+        tickMs,
+        note: "engine self-exits once NO shell session is attached AND no run is in flight AND no HTTP touch, " +
+            "continuously for lingerMs — via the same graceful drain as SIGTERM. Set ENGINE_AUTO_EXIT=false to disable.",
+    });
+    const timer = setInterval(() => {
+        if (stopped)
+            return;
+        if (deps.isStopped()) {
+            stop();
+            return;
+        }
+        const attached = deps.attachedStreams();
+        const inflight = deps.inflight();
+        if (attached > 0 || inflight > 0) {
+            idleSince = null;
+            return;
+        }
+        const t = now();
+        if (idleSince === null) {
+            idleSince = t;
+            return;
+        }
+        if (t - deps.lastActivityAt() < deps.lingerMs)
+            return;
+        if (t - deps.lastAttachEndedAt() < deps.lingerMs)
+            return;
+        if (t - idleSince < deps.lingerMs)
+            return;
+        stop();
+        deps.log("engine_lease_auto_exit", {
+            attached,
+            inflight,
+            lingerMs: deps.lingerMs,
+            idleForMs: Math.round(t - Math.max(idleSince, deps.lastActivityAt(), deps.lastAttachEndedAt())),
+            note: "no attached shell session, no in-flight run and no HTTP touch for the full linger window — entering the SIGTERM graceful drain path",
+        });
+        deps.drain();
+    }, tickMs);
+    timer.unref?.();
+    function stop() {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(timer);
+    }
+    return { stop };
+}
+//# sourceMappingURL=engine-lease.js.map

package/dist/boot/shutdown.d.ts

@@ -64,6 +64,8 @@ export interface ShutdownCtx {
         since?: number;
         inflight?: () => number;
         lastActivityAt?: () => number;
+        attachedStreams?: () => number;
+        lastAttachEndedAt?: () => number;
     };
     /** #131-2:store 活体探针(main 建)——不停的话 hardShutdown 后仍对正在关闭的池发探针,刷假
      *  store_probe_dead 告警(文件头契约 3 的同族漏网)。缺席 = 该部署形没建探针。 */

package/dist/boot/shutdown.js

@@ -2,6 +2,7 @@ import { Runner, defaultTaskRegistry } from "@sema-agent/core";
 import { writeCrashLast, clearCrashLast, readCrashLast } from "./crash-last.js";
 import { createSighupIdleHandler } from "../sighup-idle.js";
 import { createParentWatch } from "../parent-watch.js";
+import { createEngineLeaseTracker } from "./engine-lease.js";
 import { isScriptRealmRejection, describeRejectionReason } from "../orchestration/hardened-vm-runner.js";
 export function installShutdownHandlers(ctx) {
     const { config, logger, server, reaper, fleetReconcile, retentionLane, releaseRetentionLease, otelExporter, breakerState, costQuota, rateLimiter, runner, subRunner, lspManager, workflowNotifyJournal, fleetClient, backend, drainState, storeLiveProbe, configCenter, version, } = ctx;
@@ -45,6 +46,7 @@ export function installShutdownHandlers(ctx) {
     process.on("unhandledRejection", onUnhandledRejection);
     let closing = false;
     let parentWatch;
+    let engineLease;
     const hardShutdown = () => {
         if (closing)
             return;
@@ -62,6 +64,7 @@ export function installShutdownHandlers(ctx) {
                 .catch(() => undefined);
         fleetReconcile.reconciler.stop();
         parentWatch?.stop();
+        engineLease?.stop();
         storeLiveProbe?.stop();
         configCenter?.stopRefreshLoop();
         otelExporter?.stop();
@@ -145,6 +148,18 @@ export function installShutdownHandlers(ctx) {
             log: (event, fields) => logger.info(event, fields),
         });
     }
+    if (config.engineAutoExit) {
+        engineLease = createEngineLeaseTracker({
+            attachedStreams: () => drainState.attachedStreams?.() ?? 0,
+            inflight: () => drainState.inflight?.() ?? 0,
+            lastActivityAt: () => drainState.lastActivityAt?.() ?? 0,
+            lastAttachEndedAt: () => drainState.lastAttachEndedAt?.() ?? 0,
+            isStopped: () => closing || draining,
+            drain: drainThenShutdown,
+            lingerMs: config.engineLingerMs,
+            log: (event, fields) => logger.info(event, fields),
+        });
+    }
     let disposed = false;
     return {
         dispose: () => {
@@ -162,6 +177,7 @@ export function installShutdownHandlers(ctx) {
                 drainTick = undefined;
             }
             parentWatch?.stop();
+            engineLease?.stop();
         },
     };
 }

package/dist/config-types.d.ts

@@ -1223,6 +1223,25 @@ export interface ServiceConfigFlat {
      *  已知残余(成文,不收窄):两拍窗口内 pid 被系统复用 ⇒ 探活看到的是**新**进程,监视判"父还活着"
      *  而不自退。监视是**尽力自愈**、不是强一致的父子生命周期绑定。 Env: `SEMA_PARENT_PID`。 */
     parentPid?: number;
+    /** #118(黑板 [5371]②):引擎**附着租约自退**总开关。壳自 spawn 引擎的本机形里,壳退出之后引擎
+     *  继续活着 = 占端口/占库连接/占模型配额的孤儿。设了本键 = 引擎每 15s 自查一次「还有没有人附着」,
+     *  **三合取**(无附着 SSE 流 ∧ 无在飞 run ∧ 无非探针 HTTP 触点)**持续**满 {@link engineLingerMs}
+     *  才自退,且自退走的是与 SIGTERM **逐字同一条** graceful drain 腿(不是裸 `process.exit`)。
+     *  **默认 false** —— 服务器部署形永不自退(k8s replica 半夜没人用是正常低谷,不是「该退了」);
+     *  壳 spawn 形由壳显式注入 `true`。**部署级旋钮无条件生效**,不派生自任何客户端表态。
+     *  与 {@link parentPid} 是**两件**:那条问「生我的 pid 还在吗」(多壳共享一引擎时结构性问错),
+     *  这条问「还有没有人附着」。两条可同时装,各走各的判据。 Env: `ENGINE_AUTO_EXIT`(默认 off)。 */
+    engineAutoExit: boolean;
+    /** #118:自退前三合取必须**持续**成立的静默窗。默认 60s —— 防的是**壳重启窗**:壳崩了/重启的 1-3s
+     *  里附着数确实是 0,窗太短就在用户眼皮底下把引擎杀了,窗内任何一次重连即把计时清零。
+     *  {@link engineAutoExit} 关着时本值不生效,但**照样解析、坏值照样拒启**(部署级旋钮的解析不挂在
+     *  另一个旋钮的表态上 —— 否则手滑值躺在配置里,等哪天有人打开自退时当场生效且从没人报过警)。
+     *  **坏值拒启**(#210 A 档):非安全整数 / 落在 `[1000, 86400000]`(1s…24h)之外一律 boot 期 throw
+     *  带指路 —— 「把 60(秒)填进一个毫秒键」是这类旋钮最常见的手滑,而 60ms 的 linger 等于把整条防误杀
+     *  腿静默摘掉;上界那一侧同样承重(codex R1-F2):`1e100` 能过朴素的「正整数吗」检查,而 elapsed
+     *  **永远追不上它** ⇒ 看着配好了、自退其实整件失效。要「永不自退」请用 `ENGINE_AUTO_EXIT=false`。
+     *  Env: `ENGINE_LINGER_MS`(默认 60000,闭区间 [1000, 86400000])。 */
+    engineLingerMs: number;
     /** E23 (shell-host contract): inbound MCP elicitation HITL. When enabled, the service mounts `RunnerDeps.onElicit` + the
      *  `POST /v1/elicitations/:id/respond` route so an opted-in MCP server (`McpServerSpec.elicitation`, itself default
      *  OFF) can ask the END USER for input mid-tool-call. LIVE-ONLY (no durable suspend; lost on crash/replica-change).
@@ -1496,7 +1515,7 @@ export type ServiceAuthConfig = Pick<ServiceConfigFlat, "authToken" | "authToken
 /** 组:orchestration(编排 + 执行车道 + 沙箱面 + workflow/后台 agent 存留)。 */
 export type ServiceOrchestrationConfig = Pick<ServiceConfigFlat, "remoteExec" | "worktreeIsolation" | "leaderEnabled" | "leaderFanoutEnabled" | "routerEnabled" | "selfOrchestrationEnabled" | "selfOrchestrationModels" | "selfOrchestrationWorkerIsolation" | "forkEnabled" | "experimentalObserverAgents" | "schedulerEnabled" | "schedulerSessionWakeup" | "schedulerSessionLifetime" | "schedulerStorePath" | "planModeEnabled" | "hooksTimeoutMs" | "workflowRunStoreBackend" | "workflowOrphanGraceMs" | "workflowJournalRetentionMs" | "workflowRunRetentionMs" | "usageWindows" | "workflowAgentsReadOnly" | "workflowSizeGuideline" | "backgroundAgentRetentionMs" | "backgroundAgentStaleRunningMs" | "backgroundAgentParkClaimStaleMs" | "delegationEntryCaps" | "rosterRetentionMs" | "leaderRunStaleMs" | "scratchpadSweepTtlMs" | "sandboxPkgSource" | "sessionAutoTitle" | "selectEnvironmentTool" | "envFactsEnabled" | "toolDeferLongtail" | "lspEnabled" | "lspHostEnabled" | "imageBakes" | "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude">;
 /** 组:limitsHttp(HTTP 面 + 各类上限/配额/回收窗)。 */
-export type ServiceLimitsHttpConfig = Pick<ServiceConfigFlat, "port" | "attachmentOrphanGraceMs" | "workspaceFileMaxBytes" | "attachmentMaxBytes" | "attachmentMimeAllowlist" | "attachmentUnboundTtlMs" | "infraCostRates" | "drainGraceMs" | "sighupIdleGraceMs" | "parentPid" | "rateLimitPerMin" | "maxTaskCostUsd" | "maxTaskTokens" | "maxPrincipalCostUsd" | "costQuotaWindowSec" | "reapIntervalSec" | "runStaleSec" | "toolResultTtlSec">;
+export type ServiceLimitsHttpConfig = Pick<ServiceConfigFlat, "port" | "attachmentOrphanGraceMs" | "workspaceFileMaxBytes" | "attachmentMaxBytes" | "attachmentMimeAllowlist" | "attachmentUnboundTtlMs" | "infraCostRates" | "drainGraceMs" | "sighupIdleGraceMs" | "parentPid" | "engineAutoExit" | "engineLingerMs" | "rateLimitPerMin" | "maxTaskCostUsd" | "maxTaskTokens" | "maxPrincipalCostUsd" | "costQuotaWindowSec" | "reapIntervalSec" | "runStaleSec" | "toolResultTtlSec">;
 /** 组:observability(可观测)。 */
 export type ServiceObservabilityConfig = Pick<ServiceConfigFlat, "metricsToken" | "traceToken" | "toolTrace" | "traceThinking" | "logLevel" | "otel">;
 /** 组:integrations(外部集成)。`mcpServers` / `a2aPeers` 由 sema-registry 适配器填(无 env 腿),归本组。 */

package/dist/config.js

@@ -962,6 +962,24 @@ function parentPidEnv() {
     }
     return { parentPid: n };
 }
+const ENGINE_LINGER_FLOOR_MS = 1_000;
+const ENGINE_LINGER_CEIL_MS = 24 * 60 * 60 * 1_000;
+function engineLingerMsEnv() {
+    const raw = process.env.ENGINE_LINGER_MS;
+    if (raw === undefined || raw.trim() === "")
+        return 60_000;
+    const n = parseNumOrFail("ENGINE_LINGER_MS", raw);
+    if (!Number.isSafeInteger(n) || n < ENGINE_LINGER_FLOOR_MS || n > ENGINE_LINGER_CEIL_MS) {
+        throw new Error(`env ENGINE_LINGER_MS="${raw}" must be an INTEGER number of MILLISECONDS in ` +
+            `[${ENGINE_LINGER_FLOOR_MS}, ${ENGINE_LINGER_CEIL_MS}] (1s … 24h) — it is how long ` +
+            `"nobody attached, no run in flight, no HTTP touch" must hold CONTINUOUSLY before the engine self-exits. ` +
+            `A value like "60" is the seconds-for-milliseconds slip: a 60ms window kills the engine inside a shell's own ` +
+            `restart gap. A value like "1e100" passes a naive "is it a positive integer" check but the elapsed clock can ` +
+            `NEVER reach it, which silently turns self-exit off while looking configured. ` +
+            `There is no "disable" value here — set ENGINE_AUTO_EXIT=false to turn self-exit off entirely.`);
+    }
+    return n;
+}
 function parseMemoryEmbedder(ctx) {
     const endpoint = process.env.MEMORY_EMBEDDER_ENDPOINT || undefined;
     const model = process.env.MEMORY_EMBEDDER_MODEL || undefined;
@@ -1472,6 +1490,8 @@ function parseLimitsHttpDomain() {
         drainGraceMs: clampEnvWithWarn("DRAIN_GRACE_MS", String(10 * 60 * 1000), LIMITS_HTTP_FLOORS.drainGraceMs),
         sighupIdleGraceMs: clampEnvWithWarn("SIGHUP_IDLE_GRACE_MS", String(120_000), 5_000),
         ...parentPidEnv(),
+        engineAutoExit: boolEnv("ENGINE_AUTO_EXIT", false),
+        engineLingerMs: engineLingerMsEnv(),
         rateLimitPerMin: numEnv("RATE_LIMIT_RPM", "0"),
         maxTaskCostUsd: numEnv("MAX_TASK_COST_USD", "0"),
         maxTaskTokens: numEnv("MAX_TASK_TOKENS", "0"),
@@ -1667,7 +1687,9 @@ const ORCHESTRATION_GROUP_KEYS = [
 ];
 const LIMITS_HTTP_GROUP_KEYS = [
     "port", "attachmentOrphanGraceMs", "workspaceFileMaxBytes", "attachmentMaxBytes", "attachmentMimeAllowlist",
-    "attachmentUnboundTtlMs", "infraCostRates", "drainGraceMs", "sighupIdleGraceMs", "parentPid", "rateLimitPerMin", "maxTaskCostUsd",
+    "attachmentUnboundTtlMs", "infraCostRates", "drainGraceMs", "sighupIdleGraceMs", "parentPid",
+    "engineAutoExit", "engineLingerMs",
+    "rateLimitPerMin", "maxTaskCostUsd",
     "maxTaskTokens", "maxPrincipalCostUsd", "costQuotaWindowSec", "reapIntervalSec", "runStaleSec", "toolResultTtlSec",
 ];
 const OBSERVABILITY_GROUP_KEYS = ["metricsToken", "traceToken", "toolTrace", "traceThinking", "logLevel", "otel"];

package/dist/fleet/subagent-tail-bus.d.ts

@@ -7,7 +7,7 @@ export type SubagentTailFrame = Record<string, unknown> & {
     type: string;
 };
 /** core forward 事件 → wire 投影(sync 主流五分支同源;不认识的帧类型=null 不发——tail 面只承诺
- *  content 五类,新 core 帧类型先经这里显式收编再出 wire)。 */
+ *  content 六类,新 core 帧类型先经这里显式收编再出 wire)。 */
 export declare function projectTailFrame(e: Record<string, unknown> & {
     type?: string;
 }): SubagentTailFrame | null;

package/dist/fleet/subagent-tail-bus.js

@@ -18,6 +18,16 @@ export function projectTailFrame(e) {
         const td = e;
         return { type: "text_delta", delta: td.delta, ...(td.eventId ? { eventId: td.eventId } : {}), ...(td.parentToolCallId ? { parentToolCallId: td.parentToolCallId } : {}) };
     }
+    if (t === "text_end") {
+        if (typeof e.content !== "string" || e.content.length === 0)
+            return null;
+        return {
+            type: "text_end",
+            content: e.content,
+            ...(typeof e.eventId === "string" ? { eventId: e.eventId } : {}),
+            ...(typeof e.parentToolCallId === "string" ? { parentToolCallId: e.parentToolCallId } : {}),
+        };
+    }
     if (t === "reasoning_delta") {
         const rd = e;
         return { type: "reasoning_delta", delta: redactSecrets(rd.delta), ...(rd.eventId ? { eventId: rd.eventId } : {}), ...(rd.parentToolCallId ? { parentToolCallId: rd.parentToolCallId } : {}) };

package/dist/http/routes/approvals-assistant.js

@@ -60,7 +60,7 @@ async function decideIdempotentReplay(cs, args) {
                 return undefined;
             }
         }
-        if (row.boundInputHash !== (binding.boundInputHash ?? null))
+        if (binding.boundInputHash !== undefined && row.boundInputHash !== binding.boundInputHash)
             return undefined;
         if (row.decision !== decision)
             return undefined;

package/dist/http/routes/sessions.js

@@ -366,7 +366,7 @@ async function handleSessionsBody(req, res, url, ctx, miss) {
                     sendError(res, 503, "state.sse_probe_cap", "session-events probe cap reached — fall back to /head polling");
                     return;
                 }
-                res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache, no-transform", connection: "keep-alive", "x-accel-buffering": "no" });
+                sseHeaders(res, { "cache-control": "no-cache, no-transform", "x-accel-buffering": "no" });
                 writeRaw(": connected\n\n");
                 started = true;
                 if (preVal !== undefined)

package/dist/http/routes/tasks.js

@@ -331,6 +331,10 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                                         const td = e;
                                         sseData(res, { type: "text_delta", delta: td.delta, ...(td.eventId ? { eventId: td.eventId } : {}), ...(td.parentToolCallId ? { parentToolCallId: td.parentToolCallId } : {}) });
                                     }
+                                    else if (t === "text_end") {
+                                        const tend = e;
+                                        sseData(res, { type: "text_end", content: tend.content, ...(tend.eventId ? { eventId: tend.eventId } : {}), ...(tend.parentToolCallId ? { parentToolCallId: tend.parentToolCallId } : {}) });
+                                    }
                                     else if (t === "reasoning_delta") {
                                         const rd = e;
                                         sseData(res, { type: "reasoning_delta", delta: redactSecrets(rd.delta), ...(rd.eventId ? { eventId: rd.eventId } : {}), ...(rd.parentToolCallId ? { parentToolCallId: rd.parentToolCallId } : {}) });
@@ -459,7 +463,7 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                                 else if (ev.type === "human_input") {
                                     sseData(res, { type: "human_input", ...humanInputEventData(ev) });
                                 }
-                                else if (ev.type === "text_delta" || ev.type === "turn_end" || ev.type === "message_committed" || ev.type === "context_usage") {
+                                else if (ev.type === "text_delta" || ev.type === "text_end" || ev.type === "turn_end" || ev.type === "message_committed" || ev.type === "context_usage") {
                                     const e = ev;
                                     const ident = {
                                         ...(e.eventId !== undefined ? { eventId: e.eventId } : {}),
@@ -469,11 +473,13 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                                     };
                                     const arm = ev.type === "text_delta"
                                         ? { type: "text_delta", delta: e.delta, ...ident }
-                                        : ev.type === "turn_end"
-                                            ? { type: "turn_end", ...(e.usage !== undefined ? { usage: e.usage } : {}), ...(e.usageMissing !== undefined ? { usageMissing: e.usageMissing } : {}), ...(e.stopReason !== undefined ? { stopReason: e.stopReason } : {}), ...ident }
-                                            : ev.type === "message_committed"
-                                                ? { type: "message_committed", entryId: e.entryId, role: e.role, ...(e.toolCallId !== undefined ? { toolCallId: e.toolCallId } : {}), ...ident }
-                                                : { type: "context_usage", ...contextUsageEventData(ev), ...ident };
+                                        : ev.type === "text_end"
+                                            ? { type: "text_end", content: e.content, ...ident }
+                                            : ev.type === "turn_end"
+                                                ? { type: "turn_end", ...(e.usage !== undefined ? { usage: e.usage } : {}), ...(e.usageMissing !== undefined ? { usageMissing: e.usageMissing } : {}), ...(e.stopReason !== undefined ? { stopReason: e.stopReason } : {}), ...ident }
+                                                : ev.type === "message_committed"
+                                                    ? { type: "message_committed", entryId: e.entryId, role: e.role, ...(e.toolCallId !== undefined ? { toolCallId: e.toolCallId } : {}), ...ident }
+                                                    : { type: "context_usage", ...contextUsageEventData(ev), ...ident };
                                     sseData(res, arm);
                                 }
                                 else {

package/dist/http/send.d.ts

@@ -8,6 +8,20 @@
  * now imports them from here, so all ~500 existing `sendJson(...)` call sites are unchanged text.
  */
 import type { ServerResponse } from "node:http";
+/**
+ * #118(黑板 [5371]②)—— 一条响应「是 SSE 流」的**在场标记**。
+ *
+ * 引擎附着租约把**打开着的 SSE 流**当作壳的附着租约来数,于是 `handle()` 需要判「这条响应是不是流」。
+ * 🔴 **不能靠读回 content-type**(本机 node v24.2.0 实测):`res.writeHead(status, headersObject)` 直接
+ * 把头写进网络缓冲,`res.getHeader("content-type")` / `res.hasHeader(...)` 在那之后**仍然**回
+ * `undefined` / `false`。照那条路写会得到一个恒为 0 的附着计数 —— 而恒 0 的方向恰好是「以为没人附着」
+ * ⇒ 在一只有人用的引擎底下触发自退。所以判据必须是我们自己在开流那一刻盖的这个章。
+ *
+ * symbol 键:不上 wire、不进 `JSON.stringify`、不与任何应用属性撞名。
+ */
+export declare const SSE_RESPONSE_MARK: unique symbol;
+/** 这条响应是否已开成 SSE 流(= 走过 {@link sseHeaders})。 */
+export declare function isSseResponse(res: ServerResponse): boolean;
 export declare function sseHeaders(res: ServerResponse, extra?: Record<string, string>): void;
 /**
  * 一条 SSE 连接的墙钟上限。到点发一帧 `error`/`STREAM_MAX_DURATION`(**不是**静默关闭 —— 客户端分不出

package/dist/http/send.js

@@ -1,4 +1,9 @@
+export const SSE_RESPONSE_MARK = Symbol("sema.http.sse-response");
+export function isSseResponse(res) {
+    return res[SSE_RESPONSE_MARK] === true;
+}
 export function sseHeaders(res, extra) {
+    res[SSE_RESPONSE_MARK] = true;
     res.writeHead(200, {
         "content-type": "text/event-stream",
         "cache-control": "no-cache",

package/dist/http/server.d.ts

@@ -513,6 +513,9 @@ export interface ServiceDeploymentDeps {
      *  • `inflight` is ASSIGNED BY createServer (a live union of this replica's in-flight legs: durable bg/resume
      *    `inflightRuns` + live sync/resume streams `steerableRuns`) — main.ts polls it to know when drain is done.
      *  • /health carries `draining:true` (k8s readiness 摘流信号) + `version` (build self-description).
+     *  • #118:`attachedStreams` 同样 ASSIGNED BY createServer —— 本副本当前打开着的 SSE 流条数
+     *    (= 引擎附着租约集的大小)。消费方是 `boot/engine-lease.ts` 的自退判据;与 `inflight` 同族,
+     *    同一个共享盒子,不另开第二条 main↔server 的通道。
      */
     drainState?: {
         draining: boolean;
@@ -520,6 +523,8 @@ export interface ServiceDeploymentDeps {
         reason?: string;
         inflight?: () => number;
         lastActivityAt?: () => number;
+        attachedStreams?: () => number;
+        lastAttachEndedAt?: () => number;
     };
     /** boot ready 门(b):false = registry 部署无显式 env 模型且首次 effective pull 尚未落 roster
      *  (worker 只有占位模型)。计费提交 503 + /health 加性 `ready:false`。absent = 恒 ready(env 模型在/非

package/dist/http/server.js

@@ -70,7 +70,7 @@ import { cascadeConfig } from "./run-meta.js";
 export { cascadeConfig };
 import { handleImages, createImagesLocal, coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
-import { sendJson, sendError, httpErrorCode, msg } from "./send.js";
+import { sendJson, sendError, httpErrorCode, msg, isSseResponse } from "./send.js";
 import { authorized, systemFor, gatedPrincipal, explicitOperatorOk, isOperator } from "./principal-gate.js";
 import { buildActiveRunConflict, resumeEntryForGate } from "./active-run-conflict.js";
 export { explicitOperatorOk, isOperator };
@@ -179,6 +179,18 @@ export function createHttpServer(rawDeps) {
     };
     if (deps.drainState)
         deps.drainState.lastActivityAt = () => lastBillableActivityAt;
+    const openResponses = new Set();
+    let lastAttachEndedAt = 0;
+    if (deps.drainState) {
+        deps.drainState.attachedStreams = () => {
+            let n = 0;
+            for (const r of openResponses)
+                if (isSseResponse(r))
+                    n++;
+            return n;
+        };
+        deps.drainState.lastAttachEndedAt = () => lastAttachEndedAt;
+    }
     if (deps.hookWakeBus) {
         deps.hookWakeBus.deliver = async (sessionId, text) => {
             try {
@@ -247,6 +259,8 @@ export function createHttpServer(rawDeps) {
         const admitted = method !== "OPTIONS" && url !== "/health" && !url.startsWith("/metrics");
         if (admitted)
             counters.admittedInflight++;
+        if (admitted)
+            openResponses.add(res);
         let logged = false;
         const reqState = { streamTaskId: undefined, streamDetached: false, source: null };
         const ctx = { deps: routeCtxBase.deps, registry: routeCtxBase.registry, helpers: routeCtxBase.helpers, local: routeCtxBase.local, legs: routeCtxBase.legs, req: reqState };
@@ -256,6 +270,8 @@ export function createHttpServer(rawDeps) {
             logged = true;
             if (admitted)
                 counters.admittedInflight--;
+            if (openResponses.delete(res) && isSseResponse(res))
+                lastAttachEndedAt = performance.now();
             const route = routeLabel(method, url);
             const seconds = (Date.now() - startedAt) / 1000;
             const aborted = viaClose && !res.writableEnded;

package/dist/http/wire-types.d.ts

@@ -216,7 +216,7 @@ export interface TaskRequestBody {
         skillsListing?: boolean;
     };
     /** C1 (core 1.219, subagent viewing pane): opt-in — forward a delegated child's live CONTENT events
-     *  (text_delta/reasoning_delta/tool_start/tool_end, each stamped `parentToolCallId`) onto this run's stream/durable
+     *  (text_delta/text_end/reasoning_delta/tool_start/tool_end, each stamped `parentToolCallId`) onto this run's stream/durable
      *  log, so a shell can render the child's transcript live ("enter 看详情"). Default OFF = progress-only (prior
      *  behavior). Purely a render channel — core never merges the child stream into the parent's model context. */
     forwardSubagentEvents?: boolean;

package/dist/plugins/usage-window-store-sql.d.ts

@@ -30,13 +30,13 @@ export declare function ensurePgUsageWindowSchema(q: (text: string, params?: unk
 export declare class TiDBUsageWindowStore implements UsageWindowStore {
     private readonly pool;
     constructor(pool: MySqlPool);
-    charge(key: string, tokens: number, at: number, windows: readonly UsageWindow[]): Promise<void>;
+    charge(key: string, tokens: number, at: number, windows: readonly UsageWindow[], costMicroUsd?: number | null): Promise<void>;
     read(key: string, windows: readonly UsageWindow[], now: number): Promise<readonly UsageWindowReading[]>;
 }
 export declare class PgUsageWindowStore implements UsageWindowStore {
     private readonly pool;
     constructor(pool: PgPool);
-    charge(key: string, tokens: number, at: number, windows: readonly UsageWindow[]): Promise<void>;
+    charge(key: string, tokens: number, at: number, windows: readonly UsageWindow[], costMicroUsd?: number | null): Promise<void>;
     read(key: string, windows: readonly UsageWindow[], now: number): Promise<readonly UsageWindowReading[]>;
 }
 //# sourceMappingURL=usage-window-store-sql.d.ts.map

package/dist/plugins/usage-window-store-sql.js

@@ -14,13 +14,24 @@ function parseRecord(raw, key) {
     }
     const badShape = (detail) => new Error(`usage_window record for key "${key}" has an invalid shape (${detail}) — refusing to mis-count a governance window`);
     const finite = (x) => typeof x === "number" && Number.isFinite(x);
+    const costKeys = (e) => {
+        if (e.costMicroUsd !== undefined && (typeof e.costMicroUsd !== "number" || !Number.isSafeInteger(e.costMicroUsd) || e.costMicroUsd < 0)) {
+            throw badShape("`costMicroUsd` present but not a non-negative safe integer");
+        }
+        if (e.costUnknown !== undefined && e.costUnknown !== true)
+            throw badShape("`costUnknown` present but not literal true");
+        return {
+            ...(e.costMicroUsd !== undefined ? { costMicroUsd: e.costMicroUsd } : {}),
+            ...(e.costUnknown === true ? { costUnknown: true } : {}),
+        };
+    };
     const slots = r.slots.map((s) => {
         if (s === null || typeof s !== "object")
             throw badShape("`slots` entry is not an object");
         const { at, tokens } = s;
         if (!finite(at) || !finite(tokens))
             throw badShape("`slots` entry has a non-finite-numeric `at`/`tokens`");
-        return { at, tokens };
+        return { at, tokens, ...costKeys(s) };
     });
     const buckets = r.buckets.map((b) => {
         if (b === null || typeof b !== "object")
@@ -29,7 +40,7 @@ function parseRecord(raw, key) {
         if (!finite(windowMs) || windowMs <= 0 || !finite(openedAt) || !finite(tokens)) {
             throw badShape("`buckets` entry has a non-finite-numeric `windowMs`/`openedAt`/`tokens` (windowMs must be > 0)");
         }
-        return { windowMs, openedAt, tokens };
+        return { windowMs, openedAt, tokens, ...costKeys(b) };
     });
     return { slots, buckets };
 }
@@ -54,7 +65,7 @@ export class TiDBUsageWindowStore {
     constructor(pool) {
         this.pool = pool;
     }
-    async charge(key, tokens, at, windows) {
+    async charge(key, tokens, at, windows, costMicroUsd) {
         const c = await this.pool.getConnection();
         try {
             await c.beginTransaction();
@@ -68,7 +79,7 @@ export class TiDBUsageWindowStore {
                 throw new Error(`usage_window row for key "${key}" vanished between ensure and lock — refusing to drop a governance charge`);
             }
             const record = parseRecord(rows[0].record, key);
-            const next = chargeUsageRecord(record, tokens, at, windows);
+            const next = chargeUsageRecord(record, tokens, at, windows, costMicroUsd);
             await c.query(`UPDATE ${USAGE_WINDOW_TABLE} SET record = ?, updated_at_ms = ? WHERE usage_key = ?`, [JSON.stringify(next), at, key]);
             await c.commit();
         }
@@ -91,7 +102,7 @@ export class PgUsageWindowStore {
     constructor(pool) {
         this.pool = pool;
     }
-    async charge(key, tokens, at, windows) {
+    async charge(key, tokens, at, windows, costMicroUsd) {
         const c = await this.pool.connect();
         try {
             await c.query("BEGIN");
@@ -105,7 +116,7 @@ export class PgUsageWindowStore {
                 throw new Error(`usage_window row for key "${key}" vanished between ensure and lock — refusing to drop a governance charge`);
             }
             const record = parseRecord(rows[0].record, key);
-            const next = chargeUsageRecord(record, tokens, at, windows);
+            const next = chargeUsageRecord(record, tokens, at, windows, costMicroUsd);
             await c.query(`UPDATE ${USAGE_WINDOW_TABLE} SET record = $1, updated_at_ms = $2 WHERE usage_key = $3`, [JSON.stringify(next), at, key]);
             await c.query("COMMIT");
         }

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

@@ -27,9 +27,9 @@ type _GuardBgNotif = AssertAllKeysHandled<Exclude<keyof BackgroundChildEvent, Bg
 type RosterProjected = "name" | "agentId" | "sessionId" | "toolUseId" | "owner" | "scope" | "sessionScoped" | "rootSessionId" | "model" | "modelFallback" | "createdAt";
 type _GuardRoster = AssertAllKeysHandled<Exclude<keyof RosterEntry, RosterProjected>>;
 type AskProjected = "toolName" | "toolCallId" | "args" | "message" | "sourceTaskId" | "fromSubagent" | "sourceAgentName" | "delegation" | "ruleOffers" | "persistedRuleShadowed" | "probeCause" | "ruleEvidence" | "requiresRealApproval";
-type AskExcluded = "preview" | "principal" | "riskAxes" | "boundInputHash" | "isDelegatedChild" | "probeReason" | "hasBidiControls";
+type AskExcluded = "preview" | "principal" | "riskAxes" | "boundInputHash" | "isDelegatedChild" | "probeReason" | "hasBidiControls" | "previewWithheld";
 type _GuardAsk = AssertAllKeysHandled<Exclude<keyof AskRequest, AskProjected | AskExcluded>>;
-type TaskEventHandled = "text_delta" | "reasoning_delta" | "tool_start" | "tool_end" | "turn_end" | "compacted" | "diagnostics" | "message_committed" | "status" | "task_notification" | "task_progress" | "steering_injected" | "workspace_changed" | "done" | "context_usage" | "compaction_outcome" | "human_input" | "wiring_manifest";
+type TaskEventHandled = "text_delta" | "reasoning_delta" | "tool_start" | "tool_end" | "turn_end" | "compacted" | "diagnostics" | "message_committed" | "status" | "task_notification" | "task_progress" | "steering_injected" | "workspace_changed" | "done" | "context_usage" | "compaction_outcome" | "human_input" | "wiring_manifest" | "text_end";
 type _GuardTaskEvent = AssertAllKeysHandled<Exclude<TaskEvent["type"], TaskEventHandled>>;
 type MailboxProjected = "seq" | "from" | "content" | "sentAt" | "hopChain";
 type _GuardMailbox = AssertAllKeysHandled<Exclude<keyof MailboxMessage, MailboxProjected>>;
@@ -45,7 +45,7 @@ type _GuardPermissionTraceReverse = AssertAllKeysHandled<Exclude<PermissionTrace
 type AssertNonEmpty<T> = [T] extends [never] ? "EMPTY" : never;
 type _GuardPermissionTraceNonEmpty = AssertAllKeysHandled<AssertNonEmpty<PermissionTraceKind>>;
 type SummaryProjected = "sessionId" | "scope" | "createdAt" | "gateKind" | "severity" | "spentMicroUsd" | "deadline" | "hasBidiControls";
-type SummaryExcluded = "token" | "toolInput" | "toolName" | "toolCallId" | "preview" | "principal" | "sourceTaskId" | "contentKind" | "restoreMode" | "checkpointId";
+type SummaryExcluded = "token" | "toolInput" | "toolName" | "toolCallId" | "preview" | "principal" | "sourceTaskId" | "contentKind" | "restoreMode" | "checkpointId" | "previewWithheld";
 type _GuardInboxSummary = AssertAllKeysHandled<Exclude<keyof CheckpointSummary, SummaryProjected | SummaryExcluded>>;
 export type CoreKeysetGuards = [
     _GuardNotification,

package/dist/trace/engine-notice-wire.d.ts

@@ -14,7 +14,7 @@
  * 同文件 G1 e2e 的全码扇出夹具、以及契约文档附录 D.3 那张表(含**小节标题里的码数** —— 那道门本批
  * 刚立,立完就在下一次加码时自己咬住了)。
  */
-export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "task.user_steer_undrained", "task.user_followup_undrained"];
+export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "steering.parked_input_blocked", "task.user_steer_undrained", "task.user_followup_undrained"];
 export type EngineNoticeWireCode = (typeof ENGINE_NOTICE_WIRE_CODES)[number];
 /** 白名单谓词(单点):路由与门都读这一个,不许第二处手抄码串。 */
 export declare function isEngineNoticeWireCode(code: string): code is EngineNoticeWireCode;

package/dist/trace/engine-notice-wire.js

@@ -8,6 +8,7 @@ export const ENGINE_NOTICE_WIRE_CODES = [
     "memory.hold_released",
     "memory.hold_disposed",
     "task.turn_interrupted",
+    "steering.parked_input_blocked",
     "task.user_steer_undrained",
     "task.user_followup_undrained",
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.49.0",
+  "version": "7.50.0",
   "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,8 +54,8 @@
     "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": "^5.61.0",
-    "@sema-agent/settings-schema": "^1.0.0",
+    "@sema-agent/core": "5.63.0",
+    "@sema-agent/settings-schema": "1.0.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",
     "mysql2": "^3.22.4",