@sema-agent/server 7.16.0 → 7.18.0

package/dist/http/routes/trace-usage.js

@@ -2,6 +2,7 @@ import { projectEvents, taskSummary, mapTraceEvent } from "../../trace/project.j
 import { projectArtifacts } from "../../trace/artifacts.js";
 import { usageSummary, usageSeries, usageBreakdown } from "../../usage-analytics.js";
 import { sleep } from "../sse-log.js";
+import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { sendJson, sendError, sseHeaders, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "../send.js";
 import { gatedPrincipal } from "../principal-gate.js";
 // [3321] tool-results 读面**共用这一段守卫**([3318] 的字面承诺):新 sub 进的是同一个 `sub` 捕获组,
@@ -410,7 +411,9 @@ async function streamTaskTrace(req, res, runStore, taskId, staleMs) {
     // SSE shape changed, e.g. when P1 adds token-delta granularity). resumeFrom echoes the honored Last-Event-ID.
     res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", version: 1, mode: "delta", resumeFrom: from })}\n\n`); // [2373]C-12:data.type 双发与内容帧一致
     let closed = false;
-    req.on("close", () => {
+    // design/245 件1:断连清理走共享助手(req+res 双挂 + 一次性闸)。只挂 `req` 时,请求流被读干的
+    // 形下这条旗永远翻不过来,泵会对着死 socket 一路轮询到 15 分钟帽 —— 理由全文在 `sse-lifecycle.ts` 顶注。
+    bindSseLifecycle(req, res, () => {
         closed = true;
     });
     const start = Date.now();

package/dist/http/server.js

@@ -13,6 +13,7 @@ import { parseHooksConfig } from "../hooks/hook-runner.js";
 import { normalizeApproachNotice, validateTaskAgents } from "../spec-fields.js";
 import { isValidCwd, MAX_ADDITIONAL_DIRS } from "../task-cwd.js";
 import { runInBackground, evictIfConflict, stripCheckpointToken, TurnAnchorCapture, HEARTBEAT_MS, markChildrenStoppedByUserOnAbort } from "../runs.js";
+import { recordTurnActivity } from "../turn-activity.js";
 import { looksLikeJwt } from "@sema-agent/registry-core/api/auth-bridge";
 import {} from "../orchestration/workflow-agent-steer.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKey, NotifiedKeys } from "../orchestration/workflow-completion-inbox.js";
@@ -1692,9 +1693,10 @@ export function createHttpServer(rawDeps) {
         // VANISHES from GET /v1/fleet/stream the moment it resumes (the original publisher's row was last touched at
         // suspend; nothing keeps it live or settles it after). Reuse `taskId` (the existing suspended run id) so the row
         // RE-APPEARS as the same fleet row; scope = `principal` (the checkpoint/run-owner scope persisted at suspend —
-        // the original submitter, NOT spoofable; matches the run row's owner). rootTaskId = sessionId: the resume's
-        // rebuilt taskConfig carries NO spec.taskId (resolveSpec omits it), so core's canonical taskId == sessionId,
-        // exactly like the sync leg. No-op when no fleetBus / no taskId.
+        // the original submitter, NOT spoofable; matches the run row's owner). rootTaskId = taskId(codex F3,2026-08-13):
+        // resume 的 taskConfig 自此携带 spec.taskId=run 行 id(下方注入点),core canonical 随之——[3806] 修完 sync
+        // 两腿后本腿曾是最后一条 sessionId fallback 腿(resume 后 noteTaskRun 再铸 lastRunId 污染)。No-op when no
+        // fleetBus / no taskId.
         // 🔒 scope = `fleetScope` (the VERIFIED `gatedPrincipal(req)` the calling route computed) — the SAME identity
         // GET /v1/fleet/stream filters by, mirroring the create-path #6 fix. NOT `principal` (= the spoofable
         // checkpoint/auth header from `principalFrom`): a spoofed header would re-publish the resumed row under a
@@ -1704,8 +1706,13 @@ export function createHttpServer(rawDeps) {
         // resume leg now feeds the forward sink like the sync/bg legs (fleet child rows at any depth + the durable
         // task_progress append; see the resumeStream call in driveResume).
         const fleetPub = taskId && deps.fleetBus
-            ? fleetRunPublisher(deps.fleetBus, { runId: taskId, scope: fleetScope, rootTaskId: sessionId, ...fleetRunLabels(resumeObjective) })
+            ? fleetRunPublisher(deps.fleetBus, { runId: taskId, scope: fleetScope, rootTaskId: taskId, ...fleetRunLabels(resumeObjective) })
             : undefined;
+        // codex F3(2026-08-13):resume 重建的 taskConfig 必须携带 run 行 tid——缺席时 core `spec.taskId ??
+        // sessionId` fallback 喂 noteTaskRun,resume 一次 lastRunId 就再被污染成 sessionId([3806] sync 两腿
+        // 修复的 resume 腿孪生)。canonical taskId 迁移的三个同源消费点(fleet rootTaskId / stoppedBy owner /
+        // model-usage 归因键)本批同改,勿单点回退。
+        const resumeTaskConfig = taskId ? { ...taskConfig, taskId } : taskConfig;
         // C (TOC adversarial review): settle the resumed fleet row EXACTLY once. A plain Error thrown out of the
         // resume (not CheckpointError/cancel) hits the catch's `throw e` BEFORE the final onTerminal below → the
         // re-published row leaks as a stale "running". Route every onTerminal through this guard so the finally can
@@ -1769,19 +1776,18 @@ export function createHttpServer(rawDeps) {
             claimedRow = await deps.runStore.markResuming(taskId);
             if (!claimedRow)
                 return { status: 409, body: { error: "run is not in a resumable (suspended) state (already resumed, decided, or expired)", errorCode: "conflict.not_resumable" } };
-            // stoppedBy — resume leg NOW marked (core 1.256 delivered the mark-by-owner seam): on this
-            // leg core's canonical taskId == sessionId (the rebuilt taskConfig carries no spec.taskId), so a
-            // task-scoped child's owner KEY VALUE coincides with a session-scoped child's — the old `list()` path
-            // couldn't tell them apart (no sessionScoped flag exposed) and took an honest degrade. The seam filters
-            // by the EXPLICIT flag (`skipSessionScoped:true` inside the helper), so only task-scoped children take
-            // the "user" marker; session-scoped ones a cancelled parent deliberately does NOT stop stay unmarked
-            // (CC Backgrounded semantics). Owner = sessionId (this leg's canonical key), NOT the run-row taskId.
+            // stoppedBy — resume leg NOW marked (core 1.256 delivered the mark-by-owner seam): codex F3(2026-08-13)
+            // 起本腿 canonical taskId == run 行 taskId(resumeTaskConfig 注入 spec.taskId),task-scoped 子代的 owner
+            // 键值随之与 session-scoped 的分开——但 seam 仍按 EXPLICIT flag 过滤(`skipSessionScoped:true` inside
+            // the helper),only task-scoped children take the "user" marker; session-scoped ones a cancelled parent
+            // deliberately does NOT stop stay unmarked (CC Backgrounded semantics). Owner = taskId(this leg's
+            // canonical key since the F3 injection), NOT sessionId.
             //
             // 🔴 位置(#168 件3,与 /v1/tasks/stream 同族):归因规则只有**抢到这条 run 的腿**才有资格挂 ——
             // `markResuming` 输掉的那一支(别的副本已经在 resume,或行已被 reap)在上面就 409 走人,从此一次
             // 都不注册。本腿此前把它挂在 CAS 之前,只是因为 `cancelCtrl` 的唯一 abort 源(inflightRuns / 心跳
             // 轮询)也都在 CAS 之后注册才没出事 —— 那是巧合不是保证。
-            markChildrenStoppedByUserOnAbort(cancelCtrl.signal, sessionId, principal);
+            markChildrenStoppedByUserOnAbort(cancelCtrl.signal, taskId, principal); // owner=canonical taskId(codex F3:resumeTaskConfig 带 spec.taskId=run 行 id,core 子代 owner 键随之;此臂在 if(taskId) 块内恒真)
             // MF-Fleet (#7): the row is now `running` again → re-publish it LIVE to the fleet (re-appears as the same row
             // that was sitting "waiting" while parked). After onStart only — never if markResuming lost the CAS (a sibling
             // owns the row). onTerminal at every settle below keeps the row's lifecycle in lock-step with the run-store row.
@@ -1855,7 +1861,7 @@ export function createHttpServer(rawDeps) {
                 if (verifyRounds !== undefined) {
                     // resumeWithVerification runs the SAME pre-CAS guard + atomic CAS as resume() internally, so a lost
                     // CAS rejects with CheckpointError before any work — handled by the catch below, same as the stream path.
-                    const vr = await resumeWithVerification(legRunner, token, outcome, { ...taskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, resumeObjective, verifyRounds); // 快审 F1:整对象直传
+                    const vr = await resumeWithVerification(legRunner, token, outcome, { ...resumeTaskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, resumeObjective, verifyRounds); // 快审 F1:整对象直传;codex F3:带 taskId 的形
                     let safe = stripCheckpointToken(vr);
                     // 🔴 A re-suspend on a LATER gate is NOT terminal: core maps it to status:"failed" +
                     // verification.unverifiedReason with the checkpoint token still live. Treat it exactly like
@@ -1961,7 +1967,7 @@ export function createHttpServer(rawDeps) {
                     // (`++seq` is a sync increment — sink-vs-loop appends get unique seqs); only when a durable log exists.
                     // false once this leg settles — notifications after that take the durable-inbox path.
                     resumeLegLive = true;
-                    const stream = await legRunner.resumeStream(token, outcome, { ...taskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, {
+                    const stream = await legRunner.resumeStream(token, outcome, { ...resumeTaskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, {
                         onForwardEvent: (e) => {
                             fleetPub?.onForwardEvent(e);
                             // S2 live tail(复审 #1:forward sink 有三条腿——resume 腿上 spawn 的 bg 子代同样带
@@ -2042,6 +2048,7 @@ export function createHttpServer(rawDeps) {
                     if (!taskId || !rs)
                         return await stream.result(); // no durable log to persist into → just drain
                     for await (const ev of stream) {
+                        recordTurnActivity(taskId); // codex F5:S1 活性打点网的 resume 腿(sync/bg 双腿在 ledger-sink onActivity,本腿 append 不走那条链)——漏打则 resume 后 msSinceLastActivity 冻在 suspend 前,活跑的 run 被读成僵死
                         fleetPub?.onEvent(ev); // MF-Fleet (#7): turn_end → tokens, tool_start → live activity, in-stream task_progress → child row (parity with the sync leg's onEvent)
                         await appendPromptManifest(append, deps.promptManifests, taskId); // [998]②: the resumed prepare's manifest lands ahead of its first event (runs.ts twin)
                         switch (ev.type) {
@@ -2917,6 +2924,10 @@ const WORKER_SWAP_REDEEMABLE = {
     governed_unwired: true,
     real_approval_damaged: false,
     real_approval_forged: false,
+    // core 5.30.0(#246 提货):v9 read-face 段的行完整性两词——d.ts 逐字与 real_approval 两词同列
+    // 「terminal for the row's current bytes」,换 worker 不可兑,归属同前(invalid_outcome 臂,行留 pending)。
+    read_face_damaged: false,
+    read_face_forged: false,
     constraint_chain_missing: false,
 };
 /** 判别符缺席(旧引擎裸抛)或词表不认得 ⇒ **false**,即维持修前的 TERMINAL 归属。fail-closed 的方向在

package/dist/http/sse-lifecycle.d.ts

@@ -0,0 +1,65 @@
+/**
+ * design/245 件1 —— 一条 SSE 连接的**关闭清理链**接线口。
+ *
+ * ## 为什么必须双监听(而不是只挂 `req`)
+ *
+ * `routes/tasks.ts:232` 早已成文并在生产上验过一次:**请求体一旦被读完,客户端再断开就不会有
+ * `req` 的 `'close'` 了** —— Node 的 readable 在 EOF 被消费掉那一刻就 autoDestroy 并把 `'close'`
+ * 发掉了,之后的断连在 `req` 这一侧无事发生。tasks.ts 的 POST 腿当年正因此让「断连即杀 run」的
+ * 契约整条失效(dropped relay 照烧 token),补的就是 `res` 那一半。
+ *
+ * 四个断连形(客户端 abort / 服务端 `res.destroy()` / 裸 socket RST / 半关 FIN)**实测**
+ * (开发机 node v24.2.0;CI 跑 node 22,未在其上重测 —— 引用这些结论时按此打折),归纳出两条判据:
+ *  1. **`res` 的 `'close'` 恒先于 `req` 的**。socket 一死先落到响应侧;`req` 那一份是 http server
+ *     的 `abortIncoming` 补发的,晚一拍。⇒ 只挂 `req` 等于自愿多跑一拍才收摊。
+ *  2. **请求流被读干后,`req` 的 `'close'` 不再补发**。「读干」不限于 POST 读 body:GET 上任何人
+ *     调 `resume()`/for-await 同样把它烧掉(实测同形)。⇒ 只挂 `req` 的腿,其清理是否发生取决于
+ *     「这条路径上有没有人碰过请求流」这种**远处的、易漂的**前提,而不是自己的接线。
+ *
+ * 所以正解是**两侧都挂**:`res` 那一份是真正管用的那条(恒发、且更早),`req` 那一份保留既有语义
+ * (某些形下它也发,且历史行为依赖它)。`routes/fleet.ts` 与 `routes/workflows.ts` 早就是这个形,
+ * 本模块只是把那对逐字重复的接线收成一个属主,让第三条腿不必再各写一遍、也不会再漏写一半。
+ *
+ * ## 为什么闸是必须的
+ *
+ * 上面第 1 条的另一面:**一次断连通常两个事件都来**。清理动作(`clearInterval` / 迭代器
+ * `return()` / 置 `closed` 旗)本身多数幂等,但「多数」不是「全部」——一旦某个端点的 onClose 里
+ * 掺进不幂等的一手(计数、记一条日志、发一帧、abort 一个已被复用的控制器),重复执行就是真缺陷,
+ * 而且是那种「本地跑不出来、线上偶发」的形。闸放在这里 = 各端点写 onClose 时不必再自证幂等。
+ *
+ * 闸在**调用之前**落下(不是之后):onClose 抛出时,第二个事件不得把一个已经跑了一半的清理再跑
+ * 一遍 —— 半跑过的清理重入,比不跑更难诊断。
+ *
+ * ## 为什么注册完还要回看一眼状态
+ *
+ * 光「订阅未来事件」不够:`'close'` **只发一次**,而四条腿的接线全都排在若干次 await 之后
+ * (trace 是 `getRun`/`retainedFrom`,runs 是 subagent probe,sse-log 是 `retainedFrom`)。客户端
+ * 在那段慢查询里断开 ⇒ 两个 close 都在监听器注册**之前**烧完(实测:后装的监听器不会被补发)⇒
+ * 清理整条不发生,泵对着死连接轮询到 15 分钟帽。这不是假想:`sse-log.ts` 的 preamble 注里记着的
+ * 同一个坑,当时只把 preamble 挪到了接线之后,而接线本身前面还有别的 await。
+ *
+ * 所以注册之后补一次**状态回看**:两条腿(事件订阅 + 当前状态)合起来才覆盖完整时间轴。
+ *
+ * 🔴 判据只能取 `res` 侧。实测三态:窗口内断连 ⇒ `res.destroyed`/`res.closed` 皆 true;连接健在 ⇒
+ * 皆 false;**请求流被读干但连接健在** ⇒ `req.destroyed` 为 true 而 `res` 两位仍为 false。
+ * ⇒ 用 `req.destroyed` 当判据会把「读干形的活连接」当场判死 —— 误杀一条正在服务的流,比漏清理更糟。
+ *
+ * ## 本模块**不**做的事(留给调用方,别在这里加)
+ *
+ * 不区分「正常收流的 close」与「断连的 close」:`res.end()` 之后同样会发 `'close'`。四个调用方的
+ * onClose 在收流后执行都是无害的(旗已无人读、interval 已清、迭代器已 return)。onClose 带**副作用**
+ * 的腿(tasks.ts 的 park/abort 那条)必须自己按 `res.writableEnded` 判别,那条判据是**该腿的语义**,
+ * 不是本助手的 —— 塞进这里会让「正常结束」在别的腿上被误当断连。
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+/**
+ * 把 `onClose` 接到这条连接的两个关闭信号上,并保证**至多执行一次**。
+ *
+ * 连接在调用本函数**之前**就已经断了(接线排在慢查询之后的那种形),`onClose` 会在本函数内
+ * **同步**跑一次 —— 调用方据此可以假定:本函数返回后,「已断连」这件事一定已经被通知过了。
+ * 于是 `closed` 旗在泵进入循环前就已翻好,不需要每条腿再自己判一次 `res.destroyed`。
+ *
+ * @param onClose 本连接的全部清理动作(置 `closed` 旗、`clearInterval`、迭代器 `return()` 等)。
+ */
+export declare function bindSseLifecycle(req: IncomingMessage, res: ServerResponse, onClose: () => void): void;
+//# sourceMappingURL=sse-lifecycle.d.ts.map

package/dist/http/sse-lifecycle.js

@@ -0,0 +1,25 @@
+/**
+ * 把 `onClose` 接到这条连接的两个关闭信号上,并保证**至多执行一次**。
+ *
+ * 连接在调用本函数**之前**就已经断了(接线排在慢查询之后的那种形),`onClose` 会在本函数内
+ * **同步**跑一次 —— 调用方据此可以假定:本函数返回后,「已断连」这件事一定已经被通知过了。
+ * 于是 `closed` 旗在泵进入循环前就已翻好,不需要每条腿再自己判一次 `res.destroyed`。
+ *
+ * @param onClose 本连接的全部清理动作(置 `closed` 旗、`clearInterval`、迭代器 `return()` 等)。
+ */
+export function bindSseLifecycle(req, res, onClose) {
+    let fired = false;
+    const once = () => {
+        if (fired)
+            return;
+        fired = true; // 先落闸再调用:onClose 抛出时不得从第二个事件重入(见顶注)
+        onClose();
+    };
+    res.on("close", once); // 实测恒先到的那一个,也是读干形下唯一到的那一个
+    req.on("close", once);
+    // 回看:接线之前就断掉的连接,两个事件都已烧完,只有状态位还留着证据(理由与判据选取见顶注)。
+    // 先注册再回看,不是反过来 —— 反过来会在「回看与注册之间」新开一个同样的窗。
+    if (res.destroyed || res.closed)
+        once();
+}
+//# sourceMappingURL=sse-lifecycle.js.map

package/dist/http/sse-log.js

@@ -1,3 +1,4 @@
+import { bindSseLifecycle } from "./sse-lifecycle.js";
 import { sendJson, sendError, sseHeaders, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "./send.js";
 /** #151 车3 §5.3:preamble 的**有界**等待上限。挂起的 store 不许拖住开流——开流是壳的主路径,
  *  而 preamble 只是一个锦上添花的对账基准。超时即按「无卡集基准」继续(与今天等同)。 */
@@ -65,8 +66,12 @@ export async function streamSseLog(req, res, provider, id, staleMs) {
     // 只发一次,在等待窗里断连的客户端其 close 事件会在监听器注册之前烧掉 ⇒ `closed` 恒 false ⇒ 泵照常
     // 进轮询循环,对着已死的 res 反复 getEvents/statusOf 直到终态/stale/15 分钟帽。本行原本紧跟
     // sseHeaders,是 preamble 插进来才多出这个窗 —— 所以搬接线、不搬 preamble。
+    //
+    // design/245 件1:接线本身收到共享助手(req+res 双挂 + 一次性闸)。此前只挂 `req`,而请求流被读干
+    // 之后 `req` 的 close 不再补发 —— 本泵是 `task_run` 与 `image_bake` 两条日志共用的 seam,调用方
+    // 是谁、在它之前有没有人碰过请求流,不该由本泵去赌。理由全文在 `sse-lifecycle.ts` 顶注。
     let closed = false;
-    req.on("close", () => {
+    bindSseLifecycle(req, res, () => {
         closed = true;
     });
     // #151 车3 §5.1:preamble 排在 416 判定与 sseHeaders **之后**、日志 tail 之前。有界 + fail-open,
@@ -75,8 +80,8 @@ export async function streamSseLog(req, res, provider, id, staleMs) {
     if (preamble) {
         const frames = await collectSsePreamble(preamble, (reason, err) => provider.onPreambleFailure?.(reason, err));
         // 等待窗里断连了就别再写(`closed` 由上面的 close 监听器置;`writableEnded`/`destroyed` 是
-        // 第二道 —— codex 复审第二轮 medium 指出 res 侧的 close 面本 helper 没听,那半条见终报的存疑单,
-        // 这里先把「往已死的 res 写」这半堵掉,判据与 routes/tasks.ts 心跳处逐字同源)。
+        // 第二道 —— codex 复审第二轮 medium 当时指出 res 侧的 close 面本 helper 没听,那半条已由
+        // design/245 件1 的 `bindSseLifecycle` 补上;这道判据保留为第二重,与 routes/tasks.ts 心跳处逐字同源)。
         if (!closed && !res.writableEnded && !res.destroyed) {
             for (const f of frames)
                 res.write(`event: ${f.event}\ndata: ${JSON.stringify(f.data)}\n\n`);

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

@@ -61,6 +61,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "P-DEBT";
         readonly note: "跨副本赎回 parked 审批时,祖先层在 park 时是 **auto-mode 武装**的,但那只分类器是祖先任务上的活闭包(绑着它自己的转写窗+brain),跨进程重建不出来 ⇒ 本仓交一只如实拒答的 decider,core 收到 `unavailable` 后**不产生任何自动裁决**、原样落到祖先冻结审批席那条链(本腿的席位又是无 ALS 的降级形 ⇒ 再 park 给人)。方向:分类器本会 allow 的改成问人(更严),本会 block 的也改成问人(**不是自动放行**,但比自动拒松一档)⇒ 记债不当合法兜底。计数 = 「丢了祖先分类器判决的继承 ask」次数。收口件二选一:core 把分类器判据持久进链条目,或让祖先 decider 有可跨进程重建的形。";
     };
+    readonly "server.e2b.orphan-skip-unknown": {
+        readonly cls: "F";
+        readonly note: "#242 E2B 孤儿回收对一只沙盒**判不了属主/活性**(metadata 缺 taskId 的病态形 / run 行状态词在 LIVE 与 TERMINAL 两表之外 / getRun 抛错)⇒ 恒不杀,本轮跳过。方向纪律:回收是清理型能力,缺席判据=不动作——误杀是杀活任务的手,漏杀只是钱;但每次跳过必须计数,否则「回收在跑却总有几只杀不掉」的病灶(店故障/新状态词未收编/别家部署共用 key)永不显形。";
+    };
     readonly "server.fleet.subscriber-callback-threw": {
         readonly cls: "F";
         readonly note: "fleet bus 某订阅回调抛错 ⇒ 该回调本帧作废,其余订阅方与发布方不受影响。隔离是承重的:扇出同步,修前异常会传回发布方 put/update 投影点,core 持久化 catch{} 且不推进 storeRev ⇒ durable 行冻在 running 而 notify 已 ack(#183 复审 R3 HIGH)。丢的只是一个消费方的一帧渲染,故 F 类;但必须留痕——静默吞掉等于订阅方病灶永不显形。";

package/dist/observability/fail-open.js

@@ -84,6 +84,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "P-DEBT",
         note: "跨副本赎回 parked 审批时,祖先层在 park 时是 **auto-mode 武装**的,但那只分类器是祖先任务上的活闭包(绑着它自己的转写窗+brain),跨进程重建不出来 ⇒ 本仓交一只如实拒答的 decider,core 收到 `unavailable` 后**不产生任何自动裁决**、原样落到祖先冻结审批席那条链(本腿的席位又是无 ALS 的降级形 ⇒ 再 park 给人)。方向:分类器本会 allow 的改成问人(更严),本会 block 的也改成问人(**不是自动放行**,但比自动拒松一档)⇒ 记债不当合法兜底。计数 = 「丢了祖先分类器判决的继承 ask」次数。收口件二选一:core 把分类器判据持久进链条目,或让祖先 decider 有可跨进程重建的形。",
     },
+    "server.e2b.orphan-skip-unknown": {
+        cls: "F",
+        note: "#242 E2B 孤儿回收对一只沙盒**判不了属主/活性**(metadata 缺 taskId 的病态形 / run 行状态词在 LIVE 与 TERMINAL 两表之外 / getRun 抛错)⇒ 恒不杀,本轮跳过。方向纪律:回收是清理型能力,缺席判据=不动作——误杀是杀活任务的手,漏杀只是钱;但每次跳过必须计数,否则「回收在跑却总有几只杀不掉」的病灶(店故障/新状态词未收编/别家部署共用 key)永不显形。",
+    },
     "server.fleet.subscriber-callback-threw": {
         cls: "F",
         note: "fleet bus 某订阅回调抛错 ⇒ 该回调本帧作废,其余订阅方与发布方不受影响。隔离是承重的:扇出同步,修前异常会传回发布方 put/update 投影点,core 持久化 catch{} 且不推进 storeRev ⇒ durable 行冻在 running 而 notify 已 ack(#183 复审 R3 HIGH)。丢的只是一个消费方的一帧渲染,故 F 类;但必须留痕——静默吞掉等于订阅方病灶永不显形。",

package/dist/plugins/e2b-orphan-reclaim.d.ts

@@ -0,0 +1,74 @@
+/**
+ * #242([3738] / design/242 v1)— E2B 孤儿沙盒回收。
+ *
+ * 病:server 进程崩溃(SIGKILL/OOM)后 core Runner 的 `destroy()` 不跑,E2B 沙盒按自己的
+ * timeout 窗继续存活计费;崩溃循环下泄漏累积。create 侧的归属打标早已在
+ * (`remote-env-e2b.ts` factory:metadata 带 sessionId/taskId,本批补 `semaManaged:"1"`);
+ * 本模块是缺的另一半——回收腿。
+ *
+ * 判据(全部保守方向,**拿不准恒不杀**——回收是清理型能力,缺席判据=不动作,方向纪律见
+ * memory `capability-probe-fail-direction`;误杀的代价是杀死一个活任务的手,漏杀的代价只是钱):
+ *   a. `metadata.semaManaged !== "1"`         → 非我方铸造,provider 侧 query 过滤已排除;防御性重验。
+ *   b. `metadata.taskId` 缺席                 → 病态形(factory 恒打标),不杀 + failOpen 留痕。
+ *   c. run 行在场:
+ *        LIVE 词(running/suspended/needs_review)→ 活,跳过;
+ *        TERMINAL 词                           → 孤儿,kill;
+ *        两表皆不中的词                        → 词表纪律(#157):不杀 + failOpen(新词先安全后收编)。
+ *   d. 行不存在:
+ *        startedAt 距今 < GRACE                → create→行落库窗口,跳过(防误杀新沙盒);
+ *        ≥ GRACE                              → 真孤儿,kill(单库 fleet 方向下行跨副本可见)。
+ *   e. `getRun` 抛错                          → 不杀 + failOpen(不知道 ≠ 孤儿)。
+ *
+ * v1 边界(design/242 §设计②,发车说明同步):跨部署**异库**共用一把 E2B key 的形不支持——
+ * 别家沙盒的 taskId 在本库查不到行,超 GRACE 会被误杀;前置=每部署独立 E2B key(本就是推荐姿势)。
+ * metadata 无跨重启稳定的部署标识可用(instanceId 每 boot 变,恰是要回收上一世代)是结构原因。
+ *
+ * kill 逐只 try/catch(一只失败不挡其余);list 整体失败由调用方(reaper throttled catch)兜底。
+ */
+import type { Logger } from "../observability/logger.js";
+/** create→run 行落库窗口的误杀护栏。非行为表态面,常量不设旋钮(理由:它只需要「远大于一次
+ *  create+首写延迟、远小于沙盒 timeout 窗」,10min 对两端都有量级余量;错设它的运维事故面比
+ *  它保护的窗口更大)。 */
+export declare const E2B_ORPHAN_GRACE_MS: number;
+/** factory 打进 metadata 的归属标(create 半场,remote-env-e2b.ts);值恒 "1"。 */
+export declare const SEMA_MANAGED_METADATA_KEY = "semaManaged";
+/** provider 窄面(真实装配=E2B SDK `Sandbox.list()`/`Sandbox.kill()` 包装;测试注入 fake)。 */
+export interface OrphanSandboxProvider {
+    /** 列出**我方铸造**的沙盒(装配侧用 `query.metadata = { semaManaged: "1" }` 服务端过滤)。 */
+    listManaged(): Promise<OrphanSandboxInfo[]>;
+    kill(sandboxId: string): Promise<void>;
+}
+export interface OrphanSandboxInfo {
+    sandboxId: string;
+    metadata: Record<string, string>;
+    /** SDK `SandboxInfo.startedAt`。 */
+    startedAt: Date;
+}
+export interface OrphanReclaimDeps {
+    provider: OrphanSandboxProvider;
+    /** RunStore 三形(TiDB/Pg/File)共同的窄读口。 */
+    runs: {
+        getRun(taskId: string): Promise<{
+            status: string;
+        } | undefined>;
+    };
+    logger?: Logger;
+    now?: () => number;
+    graceMs?: number;
+}
+export interface OrphanReclaimSummary {
+    scanned: number;
+    reclaimed: number;
+    skippedLive: number;
+    skippedGrace: number;
+    skippedUnknown: number;
+    killFailed: number;
+}
+/** 一轮回收(boot 一次 + reaper interval 周期共用)。list 抛错穿透给调用方(reaper catch 族)。 */
+export declare function reclaimOrphanE2bSandboxes(deps: OrphanReclaimDeps): Promise<OrphanReclaimSummary>;
+/** 真实 provider(E2B SDK 包装)。SDK 静态面动态 import——回收腿只在 e2b 部署形挂载,
+ *  非 e2b 形零加载(与 execution-env 的按需装配同姿势)。 */
+export declare function createE2bOrphanSandboxProvider(cfg: {
+    apiKey: string;
+}): OrphanSandboxProvider;
+//# sourceMappingURL=e2b-orphan-reclaim.d.ts.map

package/dist/plugins/e2b-orphan-reclaim.js

@@ -0,0 +1,135 @@
+/**
+ * #242([3738] / design/242 v1)— E2B 孤儿沙盒回收。
+ *
+ * 病:server 进程崩溃(SIGKILL/OOM)后 core Runner 的 `destroy()` 不跑,E2B 沙盒按自己的
+ * timeout 窗继续存活计费;崩溃循环下泄漏累积。create 侧的归属打标早已在
+ * (`remote-env-e2b.ts` factory:metadata 带 sessionId/taskId,本批补 `semaManaged:"1"`);
+ * 本模块是缺的另一半——回收腿。
+ *
+ * 判据(全部保守方向,**拿不准恒不杀**——回收是清理型能力,缺席判据=不动作,方向纪律见
+ * memory `capability-probe-fail-direction`;误杀的代价是杀死一个活任务的手,漏杀的代价只是钱):
+ *   a. `metadata.semaManaged !== "1"`         → 非我方铸造,provider 侧 query 过滤已排除;防御性重验。
+ *   b. `metadata.taskId` 缺席                 → 病态形(factory 恒打标),不杀 + failOpen 留痕。
+ *   c. run 行在场:
+ *        LIVE 词(running/suspended/needs_review)→ 活,跳过;
+ *        TERMINAL 词                           → 孤儿,kill;
+ *        两表皆不中的词                        → 词表纪律(#157):不杀 + failOpen(新词先安全后收编)。
+ *   d. 行不存在:
+ *        startedAt 距今 < GRACE                → create→行落库窗口,跳过(防误杀新沙盒);
+ *        ≥ GRACE                              → 真孤儿,kill(单库 fleet 方向下行跨副本可见)。
+ *   e. `getRun` 抛错                          → 不杀 + failOpen(不知道 ≠ 孤儿)。
+ *
+ * v1 边界(design/242 §设计②,发车说明同步):跨部署**异库**共用一把 E2B key 的形不支持——
+ * 别家沙盒的 taskId 在本库查不到行,超 GRACE 会被误杀;前置=每部署独立 E2B key(本就是推荐姿势)。
+ * metadata 无跨重启稳定的部署标识可用(instanceId 每 boot 变,恰是要回收上一世代)是结构原因。
+ *
+ * kill 逐只 try/catch(一只失败不挡其余);list 整体失败由调用方(reaper throttled catch)兜底。
+ */
+import { recordFailOpen } from "../observability/fail-open.js";
+/** create→run 行落库窗口的误杀护栏。非行为表态面,常量不设旋钮(理由:它只需要「远大于一次
+ *  create+首写延迟、远小于沙盒 timeout 窗」,10min 对两端都有量级余量;错设它的运维事故面比
+ *  它保护的窗口更大)。 */
+export const E2B_ORPHAN_GRACE_MS = 10 * 60 * 1000;
+/** factory 打进 metadata 的归属标(create 半场,remote-env-e2b.ts);值恒 "1"。 */
+export const SEMA_MANAGED_METADATA_KEY = "semaManaged";
+// 构造侧 satisfies 锚类型真源;容器声明 ReadonlySet<string> 让消费侧(窄读口的 status: string)直判。
+const LIVE_STATUSES = new Set(["running", "suspended", "needs_review"]);
+const TERMINAL_STATUSES = new Set(["completed", "blocked", "failed"]);
+const _statusesCovered = true;
+void _statusesCovered;
+/** 一轮回收(boot 一次 + reaper interval 周期共用)。list 抛错穿透给调用方(reaper catch 族)。 */
+export async function reclaimOrphanE2bSandboxes(deps) {
+    const now = deps.now ?? Date.now;
+    const graceMs = deps.graceMs ?? E2B_ORPHAN_GRACE_MS;
+    const summary = { scanned: 0, reclaimed: 0, skippedLive: 0, skippedGrace: 0, skippedUnknown: 0, killFailed: 0 };
+    const sandboxes = await deps.provider.listManaged();
+    for (const sbx of sandboxes) {
+        summary.scanned++;
+        // a. 防御性重验(provider 装配侧已 query 过滤;fake/将来的宽 provider 不许绕过归属判别)。
+        if (sbx.metadata[SEMA_MANAGED_METADATA_KEY] !== "1") {
+            summary.skippedUnknown++;
+            recordFailOpen("server.e2b.orphan-skip-unknown");
+            continue;
+        }
+        const taskId = sbx.metadata.taskId;
+        // b. 病态形:factory 恒打 taskId(ctx.taskId 缺席时连 sessionId 都在而 taskId 不在)——不杀,留痕。
+        if (!taskId) {
+            summary.skippedUnknown++;
+            recordFailOpen("server.e2b.orphan-skip-unknown");
+            continue;
+        }
+        let verdict;
+        try {
+            const run = await deps.runs.getRun(taskId);
+            if (run === undefined) {
+                // d. 无行:GRACE 内=create→落库窗口;超窗=真孤儿。
+                verdict = now() - sbx.startedAt.getTime() < graceMs ? "grace" : "kill";
+            }
+            else if (LIVE_STATUSES.has(run.status)) {
+                verdict = "live";
+            }
+            else if (TERMINAL_STATUSES.has(run.status)) {
+                verdict = "kill";
+            }
+            else {
+                // c. 词表外的新词:不杀 + failOpen(先安全后收编;收编=上面两表加词,遗漏在 census 计数可见)。
+                verdict = "unknown";
+            }
+        }
+        catch {
+            // e. store 读错:不知道 ≠ 孤儿。
+            verdict = "unknown";
+        }
+        if (verdict === "live")
+            summary.skippedLive++;
+        else if (verdict === "grace")
+            summary.skippedGrace++;
+        else if (verdict === "unknown") {
+            summary.skippedUnknown++;
+            recordFailOpen("server.e2b.orphan-skip-unknown");
+        }
+        else {
+            try {
+                await deps.provider.kill(sbx.sandboxId);
+                summary.reclaimed++;
+                deps.logger?.info("e2b_orphan_reclaimed", { sandboxId: sbx.sandboxId, taskId, ageMs: now() - sbx.startedAt.getTime() });
+            }
+            catch (e) {
+                summary.killFailed++;
+                deps.logger?.warn("e2b_orphan_kill_failed", { sandboxId: sbx.sandboxId, taskId, error: e instanceof Error ? e.message : String(e) });
+            }
+        }
+    }
+    if (summary.reclaimed > 0 || summary.killFailed > 0) {
+        deps.logger?.info("e2b_orphan_reclaim_round", { ...summary });
+    }
+    return summary;
+}
+/** provider RPC 墙钟上限。🔴 codex 对抗复审 R2(验真后修):无超时的 list/kill 一次 provider 挂起会让
+ *  调用方的重入旗永挂(finally 等的 promise 永不结算)⇒ 回收腿从此静默死掉。SDK 原生收
+ *  `requestTimeoutMs`(SandboxApiOpts),用它而非外包 race——超时语义留在 SDK 的连接层。 */
+const PROVIDER_RPC_TIMEOUT_MS = 30_000;
+/** 真实 provider(E2B SDK 包装)。SDK 静态面动态 import——回收腿只在 e2b 部署形挂载,
+ *  非 e2b 形零加载(与 execution-env 的按需装配同姿势)。 */
+export function createE2bOrphanSandboxProvider(cfg) {
+    return {
+        async listManaged() {
+            const { Sandbox } = await import("e2b");
+            const out = [];
+            // 服务端 metadata 过滤(SandboxListOpts.query.metadata,AND 语义);state 默认含 running+paused
+            // ——paused 也计费存储位且同样是孤儿人群,刻意不收窄。
+            const paginator = Sandbox.list({ apiKey: cfg.apiKey, requestTimeoutMs: PROVIDER_RPC_TIMEOUT_MS, query: { metadata: { [SEMA_MANAGED_METADATA_KEY]: "1" } } });
+            while (paginator.hasNext) {
+                const items = await paginator.nextItems();
+                for (const s of items)
+                    out.push({ sandboxId: s.sandboxId, metadata: s.metadata ?? {}, startedAt: s.startedAt });
+            }
+            return out;
+        },
+        async kill(sandboxId) {
+            const { Sandbox } = await import("e2b");
+            await Sandbox.kill(sandboxId, { apiKey: cfg.apiKey, requestTimeoutMs: PROVIDER_RPC_TIMEOUT_MS });
+        },
+    };
+}
+//# sourceMappingURL=e2b-orphan-reclaim.js.map

package/dist/plugins/remote-env-e2b.js

@@ -1236,7 +1236,8 @@ export class RemoteContainerExecutionEnv {
 export function e2bExecutionEnvFactory(config, deps) {
     return (ctx) => new RemoteContainerExecutionEnv({
         ...config,
-        metadata: { ...config.metadata, sessionId: ctx.sessionId, ...(ctx.taskId ? { taskId: ctx.taskId } : {}) },
+        // #242:semaManaged=归属标(孤儿回收腿 e2b-orphan-reclaim.ts 按它服务端过滤;值恒 "1")。
+        metadata: { ...config.metadata, semaManaged: "1", sessionId: ctx.sessionId, ...(ctx.taskId ? { taskId: ctx.taskId } : {}) },
     }, deps);
 }
 // ─────────────────────────────── module helpers ───────────────────────────────

package/dist/runs.js

@@ -3,6 +3,7 @@ import { withPrincipal } from "./observability/principal-context.js";
 import { redactSecrets } from "./trace/redact.js";
 import { taskNotificationEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "./trace/project.js";
 import { createLedgerSink } from "./trace/ledger-sink.js";
+import { recordTurnActivity } from "./turn-activity.js";
 import { createApprovalCardEmitter, resolveApprovalLeg } from "./tool-approval.js";
 import { fleetRunResiduals, isFleetAgentTerminalNotification } from "./fleet/fleet-bus.js";
 import { defaultSubagentTailBus, projectTailFrame } from "./fleet/subagent-tail-bus.js";
@@ -481,7 +482,7 @@ approval) {
     // model-usage/park-terminal/fleet) in place and drives the sink; `append`/`flush` below stay the leg-local
     // names for every out-of-band row (elicit/question frames, model_usage deltas, suggestions, failed) so they
     // share the run's single seq counter. `notifiedKeys` is the same per-leg instance the observer/drain arms use.
-    const sink = createLedgerSink({ appendEvent: (seq, type, data) => runStore.appendEvent(taskId, seq, type, data), persistThinking, notifiedKeys });
+    const sink = createLedgerSink({ appendEvent: (seq, type, data) => runStore.appendEvent(taskId, seq, type, data), persistThinking, notifiedKeys, onActivity: () => recordTurnActivity(taskId) });
     const append = (type, data) => sink.append(type, data);
     const flush = () => sink.flush();
     // E8 (shell-host contract): drain the per-task model-usage accumulator into an append-only `model_usage` DELTA event, so

package/dist/tool-approval.js

@@ -1193,6 +1193,7 @@ export class ToolApprovalCoordinator {
         // 而 `settle` 可能因为人已经答过了而整个是空操作 —— 标志式写法会在那种赛跑里给一个**人类的**终局盖上
         // 「窗到期」的章。只有真正落定这次终局的那一次调用才有资格留下自报词。
         let hostSettled;
+        let denyReasonSettled; // #243:respond deny 的人写理由,shapeOutcome deny 臂消费(声明纪律见 settle 注)
         /**
          * 已落定的本地终局 → `AskOutcome` 的**唯一**成形口。本方法有两个出口(方法尾的正常路,与
          * `earlyAbortDuringEnsure` 的早退路),它们此前各写了一份等价分派 —— 结果就是本批的 `settledBy`
@@ -1201,6 +1202,11 @@ export class ToolApprovalCoordinator {
          *  · allow + 编辑 ⇒ 对象臂带 `updatedInput`;
          *  · deny + 宿主自报 ⇒ 对象臂带 `settledBy`(见 {@link HostSettledBy};allow 侧恒不带 —— core 对
          *    `{allow:true, settledBy:"timeout"}` 是响亮拒,而自报只在 deny 分支产生);
+         *  · deny + 人写理由 ⇒ 对象臂带 `reason`(#243,core 5.29.0 收口:模型经它看到拒因——围栏
+         *    delimitUntrusted 与 REVIEWER_NOTE_MAX_BODY 截断全在 core,server 只透传不预判;空串按 core
+         *    契约的缺席读——truthiness——不铸键;allow 侧恒不带,core 对 allow 行的 reason 恒销毁不渲染,
+         *    审计面由店的 decisionNote 承载)。理由只从 respond 腿流入(finishRespond),窗到期/取消/
+         *    外部清算臂无人写理由,恒缺席。
          *  · 其余 ⇒ 裸 boolean(falsy 纪律)。
          */
         const shapeOutcome = (settled) => {
@@ -1209,13 +1215,21 @@ export class ToolApprovalCoordinator {
             if (settled.allowed) {
                 return settled.updatedInput !== undefined ? { allow: true, updatedInput: settled.updatedInput } : true;
             }
-            return hostSettled !== undefined ? { allow: false, settledBy: hostSettled } : false;
+            if (hostSettled !== undefined || (denyReasonSettled !== undefined && denyReasonSettled !== "")) {
+                return {
+                    allow: false,
+                    ...(hostSettled !== undefined ? { settledBy: hostSettled } : {}),
+                    ...(denyReasonSettled !== undefined && denyReasonSettled !== "" ? { reason: denyReasonSettled } : {}),
+                };
+            }
+            return false;
         };
-        const settle = (allowed, outcome, updatedInput, hostSettledBy) => {
+        const settle = (allowed, outcome, updatedInput, hostSettledBy, denyReason) => {
             if (done)
                 return;
             done = true;
             hostSettled = hostSettledBy;
+            denyReasonSettled = allowed ? undefined : denyReason;
             if (timer)
                 clearTimeout(timer);
             for (const [sig, fn] of abortListeners)
@@ -1877,7 +1891,10 @@ export class ToolApprovalCoordinator {
             this.allowAllSessions.add(sessionAllowKey(entry.owner, entry.sessionId, sessionAllowCategory(entry.toolName)));
         }
         const allowed = parsed.value !== "deny";
-        entry.settle(allowed, allowed ? "allowed" : "denied", parsed.updatedInput);
+        // #243:deny 的 note 同时是给模型的拒因(AskOutcome.reason,core 5.29.0 围栏+上限在 core);allow 的
+        // note 只走店的审计列(core 对 allow 行 reason 恒销毁,不铸注定被丢的键)。第 4 参 hostSettledBy 恒缺席
+        // ——respond 腿是人经 API 决,不是宿主自报臂。
+        entry.settle(allowed, allowed ? "allowed" : "denied", parsed.updatedInput, undefined, allowed ? undefined : parsed.note);
         // updatedInputForwarded=server 已透传(是否被引擎消费取决于 core OnAsk 对象臂是否在——诚实措辞,
         // 不称 applied;cli 版本门+core 单落地后全链生效)。
         // 🔴 codex 交叉复审 round2 R2-4(2026-08-06 真缺陷):这个回显必须以「**这次调用真的把 updatedInput

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

@@ -27,7 +27,7 @@ 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" | "ruleSuggestions" | "persistedRuleShadowed";
-type AskExcluded = "preview" | "principal" | "requiresRealApproval" | "riskAxes" | "boundInputHash";
+type AskExcluded = "preview" | "principal" | "requiresRealApproval" | "riskAxes" | "boundInputHash" | "isDelegatedChild";
 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 _GuardTaskEvent = AssertAllKeysHandled<Exclude<TaskEvent["type"], TaskEventHandled>>;

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

@@ -61,5 +61,11 @@ export declare function createLedgerSink(opts: {
      *  (shared with its observer/drain arms so no arm double-appends a key another arm delivered); a leg with no
      *  other durable arms (sync detach lane) omits it and gets a private instance. */
     notifiedKeys?: NotifiedKeys;
+    /** #245 S1:turn 活性打点(`recordTurnActivity(taskId)`)。打点位有两处且都必须:①`onEvent` 入口
+     *  ——**text_delta/reasoning_delta 只进内存缓冲、到 flush 边界才 append**(codex S1-F1,2026-08-13:
+     *  只打 append 会让长时间流式输出被误读成「无进展」,方向与本键的设计目的正好相反);②`append`
+     *  入口——兜住不经 onEvent 的直写路径(appendParked/appendDone/onForwardEvent)。分诊提示性回调:
+     *  抛错不得断链(打点失败丢的只是判别材料,账本不能陪葬)。 */
+    onActivity?: () => void;
 }): LedgerSink;
 //# sourceMappingURL=ledger-sink.d.ts.map