@sema-agent/server 7.43.0 → 7.44.0

package/dist/http/routes/diagnostics.js

@@ -1,9 +1,6 @@
 import { resolveStreamApprovalGate } from "../../tool-approval.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
-/** 纯数据产物(`build*`):三个门的当前读数。`streamApproval` 走**单一谓词**
- *  `resolveStreamApprovalGate` —— 与 `/v1/capabilities` 的 `streamApproval` 位、与回决口的 501 门同一个
- *  符号,所以诊断页读到的与消费端撞到的行为不可能不同。 */
 export function buildServerWiringGates(input) {
     const gate = resolveStreamApprovalGate({
         toolApprovalEnabled: input.toolApprovalEnabled,
@@ -17,25 +14,6 @@ export function buildServerWiringGates(input) {
         checkpointStore: input.checkpointStore !== undefined,
     };
 }
-/**
- * 三项对表(设计稿件二)。判据全是**两个独立谓词对同一件事的答案**,矛盾即装配谎言 —— 装配谎言不是
- * 「配置不理想」,是「服务端对自己接了什么线的两套说法互斥」,继续启动只会把矛盾带进运行期的每一条腿。
- *
- *  ① park 设施:core 从 `spec.checkpointStore ?? deps.checkpointStore` 判 `parkLane.capable`,我方从
- *     `backend.checkpoint ∧ DURABLE_APPROVAL` 判 `parkFacility` 并据此决定流内审批协议上不上场。两者
- *     不等 ⇒ 协议按「窗到期能 park」上场而引擎侧根本不 park(结局是 core fail-closed deny),或反之
- *     白白关掉一个可用的协议。`capable` 真而 `effective` 不真同样致命:能力在、这条部署形上却不会真的
- *     park,窗到期依旧无降级目的地。
- *  ② 会话店持久性:manifest 声明 `declared_durable` 而后端是 local / 根本没有后端 ⇒ 「重启存活」的声明
- *     没有介质兑现。这条与 memory+durable 两条既有拒启同族(声明与介质必须对得上)。
- *  ③ interaction posture 声明 `interactive` 却没有任何 question 投递面 ⇒ 只 **warn**:core 在 prepare 时
- *     会按腿拒,boot 先一步把话说成人话。不拒启,因为部署形本身可能只是暂时没接活体面,而 core 侧已有
- *     兜底门 —— 拒启会把一个可运行的部署挡在门外。
- *  ④ park 车道的持久性读数不可信时 ⇒ **warn**(理由与这条判据为什么不是拒启,见其行内注)。
- *
- * 判决分两级是有判据的:**拒启**留给「两个谓词对同一件事互斥」(其中一个必错,继续跑就是带着谎言服务);
- * **警告**留给「读数不可信/声明不完整」(信号本身还不足以断定谁错,据此拒启会挡住正常部署)。
- */
 export function buildStaticWiringAudit(facts) {
     const refusals = [];
     const warnings = [];
@@ -49,23 +27,10 @@ export function buildStaticWiringAudit(facts) {
         refusals.push(`park facility contradiction: this server assembled its approval gates with parkFacility=true, but the engine's static wiring resolves parkLane.effective=${JSON.stringify(park.effective)} (reasons: ${park.reasons.join(", ") || "none"}). ` +
             `A window expiry would then have no degradation target and adjudicate as a fail-closed deny — refusing to start.`);
     }
-    // 判据写成「不在持久集合里」而不是「是 local」是有方向的:将来多一种 backend kind 时,它会**拒启**
-    // 直到有人显式把它判进持久集,而不是静默通过 —— 声明与介质的对表,失败方向必须朝拒绝那边。
     if (facts.manifest.session.store === "declared_durable" && facts.backendKind !== "mysql" && facts.backendKind !== "pg") {
         refusals.push(`session store durability contradiction: the engine's static wiring reports session.store="declared_durable" while the store backend is ${facts.backendKind === undefined ? "absent (env-only worker)" : `"${facts.backendKind}"`}. ` +
             `A durable declaration with no durable medium is a claim nothing can honor — refusing to start. Wire DB_BACKEND=mysql|pg, or fix the store's durability declaration.`);
     }
-    // park 车道的**持久性读数**(codex 交叉复审 2026-08-07 R2-F2,验真后部分采纳)。`capable` 说的是
-    // 「有没有 checkpoint 店」、`effective` 说的是「这条部署形会不会真 park」—— 两者都为真时仍可能是一个
-    // 重启即丢的店,那样窗到期后被 park 的审批在重启后无法赎回,而流内审批协议正是拿 park 当降级目的地。
-    // ✅ **读数已转可信**(#168 件5,2026-08-07):树上三条 checkpoint 店(SQL 双生 + local 文件形)现在都
-    // 如实声明了 `durability`,所以这条读数不再对真持久部署恒假 —— 它现在说的就是字面意思。
-    //
-    // 🔴 仍然是 **warn 而不是拒启**,判据与 session 那条**刻意不同**,理由写在这里免得下一个人以为是漏改:
-    // session 那条对表的是「声明 durable × 介质不 durable」——两个已知量互相矛盾,拒启是查出了谎。这一条
-    // 对表的是「有没有人声明」,而 core 把**缺席**折成 `process-local`;一个合法的第三方/新增 checkpoint
-    // 店没表态时,拒启会挡住一个本来跑得好好的部署,而**没有任何旋钮**能让它继续启动(补偿为零 ⇒ 不升格)。
-    // 升格的前置件 = core 把「未声明」与「声明为进程内」分成两个可区分读数,或本仓给出一个显式承认旋钮。
     if (facts.parkFacility && facts.manifest.parkLane.checkpointDurability !== "declared_durable") {
         warnings.push(`park facility is enabled but the checkpoint store does not declare durable storage ` +
             `(parkLane.checkpointDurability=${JSON.stringify(facts.manifest.parkLane.checkpointDurability ?? null)}). ` +
@@ -78,10 +43,6 @@ export function buildStaticWiringAudit(facts) {
     }
     return { refusals, warnings };
 }
-/**
- * boot 消费口:`refusals` 非空即抛(拒启,与 memory+durable 两条既有拒启同族的 fail-loud 形),
- * `warnings` 逐条 warn。返回判决本体,调用方可以继续把读数打进启动 info 行。
- */
 export function assertStaticWiringConsistent(facts, logger) {
     const audit = buildStaticWiringAudit(facts);
     for (const w of audit.warnings)
@@ -91,24 +52,10 @@ export function assertStaticWiringConsistent(facts, logger) {
     }
     return audit;
 }
-/**
- * [3399]③ clay 裁 (b)(2026-08-12,core [3648]④ + cli [3649]① 双背书):**零凭证 turnkey 形**的
- * loopback 来源门判据(单一属主,端点与测试同吃)。
- *
- * 只在「operator 名单空 ∧ 非多租户 ∧ 全局 service-credential 门也不在场(没配 SERVICE_AUTH_TOKEN /
- * AUTH_TOKENS)」的部署形上判——那正是全局门整个不设、诊断端点此前无认证可读的形。诊断面泄的是装配
- * 拓扑(store 接线/能力位/治理姿态),对误暴露公网端口的 turnkey 机器构成侦察面。(b) 对本机自用零摩擦
- * (壳缺省钉 BIND_HOST=127.0.0.1,local curl 照常),对远程侦察 fail-closed;配了 token 的部署远程读
- * 走认证(全局门),不进本臂。
- *
- * 判源=TCP 对端地址(`req.socket.remoteAddress`),**非任何头**——XFF 类头在无反代的 turnkey 形上本就
- * 是伪造面;有反代的部署必然配 token(反代后 remoteAddress 恒 loopback,门自然放行,语义仍对:该形的
- * 边界由反代+token 承担)。`remoteAddress` 缺席(socket 已断等边缘)⇒ 判拒(fail-closed,安全轴方向)。
- */
 export function zeroCredentialLoopbackDenied(remoteAddress, config) {
     const anyServiceAuth = Boolean(config.authToken) || Object.keys(config.authTokens ?? {}).length > 0;
     if (anyServiceAuth)
-        return false; // 凭证在场 ⇒ 边界归全局 service-credential 门,本判不参与
+        return false;
     const addr = remoteAddress ?? "";
     const isLoopback = addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
     return !isLoopback;
@@ -120,22 +67,6 @@ export async function handleDiagnostics(req, res, url, ctx) {
 }
 async function handleDiagnosticsBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
-    // 件三:「这台 worker 到底接了什么线」一屏看清 = core 的静态半场(含 `governance` 段 —— 本面**就是**
-    // 那个段的 operator 受众)+ server 自己三个装配谓词的读数。
-    //
-    // 门 = `explicitOperatorOk`(**不是** `isOperator`)。执法条件是**名单在场 ∨ 多租户**,不是只看
-    // `REQUIRE_PRINCIPAL`:本件的 SSE 腿对同一段 governance 恒判 `explicitOperatorOk`,若这里只在
-    // REQUIRE_PRINCIPAL 时判,「列了 operator 名单却没开 REQUIRE_PRINCIPAL」的部署上就成了流里关着、
-    // 端点上开着 —— 一个秘密两套门,严的那道白严(codex 交叉复审 2026-08-07 R2-F1,验真后采纳)。
-    // 名单为空 ∧ 非多租户 = 单租户 turnkey:该部署没有 operator 这个概念,唯一的用户就是 operator,
-    // 边界由全局 service-credential 门把守(与 `GET /v1/outcomes` 同裁)。
-    // 401 由更上游的全局门给出,本域只判 operator 与否。
-    //
-    // ⚠️ 与 SSE 腿的**残余不对称**(显式裁定,不是疏忽):turnkey 形上流里仍然谁都拿不到治理段,而本端点
-    // 给。理由=流是多订阅面且身份来自连接、端点是一次显式的 operator 请求;失败方向因此在流那侧更严。
-    //
-    // **不含** per-leg effective 历史:治理段只存在于 live 帧的 operator 投影里,durable 账本恒存剥后形
-    // (账本写时不知道未来读者是谁)。历史考古是另一件事,不在本面伪装成有。
     if (req.method === "GET" && url === "/v1/diagnostics/wiring") {
         if (deps.config.operatorPrincipals.length > 0 || deps.config.requirePrincipal) {
             const principal = gatedPrincipal(req, deps.config);
@@ -148,25 +79,14 @@ async function handleDiagnosticsBody(req, res, url, ctx, miss) {
             sendError(res, 403, "auth.loopback_only", "wiring diagnostics on a zero-credential deployment are readable from loopback only — configure SERVICE_AUTH_TOKEN to read remotely");
             return;
         }
-        // 静态半场是 **composition root 在 boot 算的**(与拒启自检同一份产物,不可能与它不同)。缺席 ⇒ 这个
-        // 进程不是由 main.ts 装起来的(测试夹具形),此面诚实地不存在 —— 落到全局 404,而不是回一个空壳 200。
         if (!deps.staticWiring) {
             miss.fell = true;
             return;
         }
         sendJson(res, 200, {
             static: deps.staticWiring,
-            // #252 件2:记忆面姿态(backend / vectorMode / 点亮态 / dark 成因 / embedder 身份)。此前这些事实
-            // **只**活在启动日志里,而日志不可查询、跨副本不可聚合 —— cli 的记忆 UX 与运维都只能读日志或按 env
-            // 自己推(推不出来:多租户 file 底座上 `MEMORY_ENGINE=on` 其实是暗的)。additive 键,与 `serverGates`
-            // 同受众(operator-only,门在上方,本段不自带更松的门)。
-            // 缺席 ⇒ 显式 `null`(「这个进程说不出来」),不铸一个看起来像真答案的空壳对象。
             memoryPosture: deps.memoryPosture ?? null,
-            // #322 世代账的 operator 面:按组的 appliedVersion / deferredKeys+铸因 / lastRejected(消毒形——
-            // 只有键名与判据文案,值从不进读面)。/health 那三键是同一份读数的窄投影,两面不可能各说各话。
-            // 缺席 ⇒ 显式 `null`(与 memoryPosture 同姿势:「这个进程说不出来」,不铸空壳)。
             configApply: deps.configApplyState?.() ?? null,
-            // #324:mid-turn MCP 撤销名单(design/338)。null=本进程没有配置管道(说不出来),与上两键同姿势。
             mcpRevocations: deps.mcpRevocationState?.() ?? null,
             serverGates: buildServerWiringGates({
                 toolApprovalEnabled: deps.toolApproval !== undefined,

package/dist/http/routes/fleet.js

@@ -7,106 +7,42 @@ export async function handleFleet(req, res, url, ctx) {
     await handleFleetBody(req, res, url, ctx, miss);
     return !miss.fell;
 }
-/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
- *  = 「本域已应答」;走到函数尾才是「没匹配上」。跨域的东西一律在首行解构出来。 */
 async function handleFleetBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
     const { sessionOwnerScope } = ctx.helpers;
-    void url; // 本域按 `req.url` 的完整 pathname 判路(带 query),`url` 只为域入口签名一致
-    // MF-Fleet (shell-host data contract): GET /v1/fleet/stream — the LIVE multi-row task/workflow fleet view as
-    // an SSE PUSH stream (status/elapsed/tokens/doneCount transitions over time). Owner-gated by scope (the
-    // caller's own active runs) UNLESS fleet-wide (a deployment trace/auth token sees every tenant's rows, like
-    // the trace API). Before the service-credential gate (self-gates by principal), parity with the workflow routes.
+    void url;
     if (req.method === "GET" && new URL(req.url ?? "", "http://x").pathname === "/v1/fleet/stream") {
         if (!deps.fleetBus) {
             sendError(res, 501, "capability.self_orchestration_required", "fleet stream requires self-orchestration / fleet wiring");
             return;
         }
-        const { fleetWide } = sessionOwnerScope(req); // trace-token / system authToken ⇒ fleet-wide (all tenants)
-        const principal = gatedPrincipal(req, deps.config); // direct-door-safe identity (NOT the spoofable header)
+        const { fleetWide } = sessionOwnerScope(req);
+        const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && !principal && !fleetWide) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;
         }
-        // #3 fleet per-session scope (clay 2026-06-30): the shell sends its current sessionId as `?session=` to see ONLY
-        // this session's rows (not other sessions of the same principal — the "他会话 token" leak). Absent ⇒
-        // unscoped (all of the principal's rows — back-compat).
-        // 🔴 cli[1524] HIGH-1(V5c 回归锁首跑抓获):此前 fleetWide 把 callerSession 也强制 null——无 auth
-        // 部署(isFleetWide 第一臂:无 token/无 traceToken/无 requirePrincipal=恒 fleetWide,TOC loopback
-        // 默认形全中)下会话过滤/通知 fail-closed 门整体旁路成全量广播,而 meta 的 bgNotifyFailClosed 照报
-        // true=标说谎;1.245 的注入 fail-closed 与 1.247 的代际标在默认部署从未真正生效(一直是壳侧台账
-        // 在兜)。修:fleetWide 是**能力上限**(可看全量=豁免 scope 授权轴),不是「强制 unscoped」——
-        // 显式带 `?session=` 的请求无论 fleetWide 与否都按会话过滤(观察者要全量=不带 session;要跟单
-        // 会话且不烧 durable 副本=带 session+observe=1,既有防烧口)。meta 的 sessionScoped 由此自动如实,
-        // bgNotifyFailClosed 对 session-bound 连接从此真实。
         const fleetParams = new URL(req.url ?? "", "http://x").searchParams;
         const callerSession = fleetParams.get("session");
-        // `?observe=1` = a session-bound lane that must NOT serve-fence the durable copy
-        // (a non-shell observer following one session). Default (absent) keeps the frame-即-投递 semantics —
-        // today's only session-bound consumer IS the model-injecting shell.
         const observeOnly = fleetParams.get("observe") === "1";
-        // #189:终态行窗的 durable 读交给 streamFleet 在**订阅注册之后**做(见那里的缓冲段)——放在这里
-        // (开流之前)会让"帧已扇出而本连接尚未订阅"的窗口凭空多出一个读的时长,codex R1-H1 红先复现过。
-        // [3156] 轮2 真红修:终态窗的查询键必须与可见性判据**同源**——fleetWide 连接(callerScope=null,
-        // visW 放行全 scope)此前窗却按 caller principal("default")查,而行的 scope 是提交方自报
-        // principal 的透传值(cli 壳本地单用户模式自发 "anon:shell-live";引擎不发明该字面量,[3225]
-        // 后续侦察定谳)⇒ durable pull 恒 miss。fleetWide ⇒ null(窗走进程内 seed 缓存,全 scope)。
-        // 读侧 `?? "default"` 三处与 core 写侧铸链同源(core prepare-task `spec.principal ?? "default"`,
-        // 其 CHANGELOG 成文「Single-tenant spelling is an explicit scope:"default"」)——在 core 撤其
-        // 写侧铸点前,server 单方面撤读侧会把无主部署的 durable pull 面弄瞎,故保持同源不动。
         await streamFleet(req, res, deps.fleetBus, fleetWide ? null : (principal ?? "default"), callerSession || null, observeOnly ? undefined : deps.workflowCompletionInbox, { store: deps.workflowRunStore, scope: fleetWide ? null : (principal ?? "default"), pullScope: principal ?? "default", ready: deps.fleetRecoveryDone });
         return;
     }
     miss.fell = true;
 }
-/** MF-Fleet: SSE the live fleet (active task + workflow rows) — a SNAPSHOT on connect, then every per-row delta
- *  the {@link FleetEventBus} fans out. `callerScope === null` ⇒ fleet-wide (a trace/auth token sees all tenants);
- *  else owner-scoped (only rows whose `scope` matches). The tenant-internal `scope` field is STRIPPED from every
- *  emitted row (it's a gate input, never rendered). A removal is forwarded ONLY for a row this connection actually
- *  saw (no id-existence oracle for an unseen tenant's run). Heartbeat + dual-close cleanup unsubscribe the bus. */
 function streamFleet(req, res, bus, callerScope, callerSession = null, completionInbox, terminal) {
     return new Promise((resolve) => {
         sseHeaders(res);
-        // [1508] 1.247 `bgNotifyFailClosed` — the GENERATION marker cli asked for ([1500]📌/[1502] F2): declares
-        // this server's bg_notification injection path fails CLOSED for scoped subscribers (1.245+ [1493] fix), so
-        // a new-generation shell can drop its frame-level own/foreign checks entirely (incl. the cross-shell
-        // restart edge) while keeping them against older servers whose meta lacks the field. Additive (version
-        // stays 1): older shells ignore unknown fields.
-        // `type: "meta"` 与 `event: meta` 同名双发(tasks/trace-usage/approvals 三流同款):部分代理只转发
-        // `data:` 行,按 data.type 分派的消费端否则认不出首帧。additive,老消费端忽略未知键。
-        // [4119] P-31 Q2(cli design/285,additive):session-bound 连接回显**本连接实际生效**的 session id。
-        // 客户端 `server_fail_closed` 可信臂零内容自校——它信的是「server 按会话过滤了」这句话本身;把过滤
-        // 判据说出来,客户端才能与本 ledger 会话锚**比对相等**后解封最强档,而不是在 keyed 多会话宿主上
-        // 永远诚实封顶。键与 `sessionScoped` 对偶:unscoped 连接缺席(不发空串);值=`callerSession` 逐字
-        // (即 streamFleet 真用于行过滤的那一个量,不另铸第二读点)。
         res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", version: 1, scoped: callerScope !== null, sessionScoped: callerSession !== null, ...(callerSession !== null ? { session: callerSession } : {}), bgNotifyFailClosed: true })}\n\n`);
         const seenTasks = new Set();
         const seenWf = new Set();
-        // #3 fleet per-session scope (clay 2026-06-30): a row is visible iff it matches the caller's principal scope AND
-        // — when the caller sent `?session=` — its `sessionId`. A row WITHOUT a sessionId stays visible (back-compat for
-        // unscoped rows); the leak this closes is a row whose sessionId is ANOTHER session of the same principal.
         const sessionOk = (rowSession) => callerSession === null || rowSession === undefined || rowSession === callerSession;
         const visT = (r) => (callerScope === null || r.scope === callerScope) && sessionOk(r.sessionId);
         const visW = (r) => (callerScope === null || r.scope === callerScope) && sessionOk(r.sessionId);
-        // [1493] fable5 R1 (display plane): an UNATTRIBUTED row (no sessionId — restart lazy-mint / core version
-        // skew edges; post-Part-A every normal spawn is tagged) stays fail-open VISIBLE to a scoped subscriber
-        // (liveness back-compat: your own row after a restart still shows as running), but its content fields are
-        // conversation-derived text — `name` is the objective preview, `description`/`agentType`/`agentName` label
-        // the ask, `currentAction` is a live tool line. None of that may cross the session boundary, so a SCOPED
-        // subscriber gets a content-scrubbed projection (ids/status/progress/timing kept); a fleet-wide observer
-        // (trace/dashboard, callerSession === null) keeps the full row. Rows tagged with the caller's own session
-        // pass sessionOk and are never scrubbed (r.sessionId present ⇒ it equals callerSession here).
-        // codex R6:FleetTaskRow 逐键处置表——`satisfies Record<keyof FleetTaskRow,…>` 使**任何**行新键先在
-        // 编译期红(TS2741),强迫对跨会话可见性表态;"keep" 键必须同步进下方白名单构造,配套钉在
-        // test/fleet-bg-child.test.ts(R6 格:kept 键集 ⊆ 表内 keep∪rewrite 集)。
         const SCOPED_TASK_KEY_DISPOSITION = {
             id: "keep", parentId: "keep", parentToolCallId: "keep", workflowRunId: "keep", status: "keep",
             startedAt: "keep", elapsedMs: "keep", tokens: "keep", queuedCount: "keep",
             awaitingPlanApproval: "keep", toolUses: "keep", usage: "keep", resumable: "keep", sourceLane: "keep",
-            // #261 §2:两键都是**结构事实**,零会话内容 —— `cycleSeq` 是 core registry 行的代际号
-            // (数值,消费端判「复活 vs 前代迟到帧」的唯一钥匙),`retiredBy` 说的是「这条终态是对账腿从
-            // durable 投影的、不是发布方亲报的」。降权投影里丢掉它们 = 未署名会话的行**判不了代**,而复活
-            // 与迟到帧在无代际号时不可区分(正是本 issue 要消灭的那类静默错判)。故 keep。
             cycleSeq: "keep", retiredBy: "keep",
             name: "rewrite", scope: "strip", sessionId: "strip",
             description: "scrub", agentType: "scrub", agentName: "scrub", currentAction: "scrub",
@@ -116,9 +52,6 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
         const stripT = (r) => {
             const { scope: _s, sessionId: _sid, ...rest } = r;
             if (callerSession !== null && r.sessionId === undefined) {
-                // [3136]②→codex R6(确认轮):黑名单形被两次击穿(currentTool、editedFiles)——同一信任边界的键
-                // 靠逐个想起来列,漏一个就是跨会话内容泄漏。改**白名单构造**:kept 对象逐键显式拼,未列键默认
-                // 不过;新键先过上方处置表的编译期门。
                 return {
                     id: rest.id,
                     status: rest.status,
@@ -135,14 +68,12 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     ...(rest.usage !== undefined ? { usage: rest.usage } : {}),
                     ...(rest.resumable !== undefined ? { resumable: rest.resumable } : {}),
                     ...(rest.sourceLane !== undefined ? { sourceLane: rest.sourceLane } : {}),
-                    ...(rest.cycleSeq !== undefined ? { cycleSeq: rest.cycleSeq } : {}), // #261:代际号是结构事实(见处置表)
+                    ...(rest.cycleSeq !== undefined ? { cycleSeq: rest.cycleSeq } : {}),
                     ...(rest.retiredBy !== undefined ? { retiredBy: rest.retiredBy } : {}),
                 };
             }
             return rest;
         };
-        // A-002.5(#194 病族 F2):workflow 行与 task 行同一条降权跨会话边界——stripT 的黑名单三次被
-        // 击穿后改了白名单,stripW 当时漏改(同函数体孪生)。处置表同姿势:行加新键先编译红强迫表态。
         const SCOPED_WORKFLOW_KEY_DISPOSITION = {
             id: "keep", status: "keep", doneCount: "keep", totalCount: "keep", failedCount: "keep",
             startedCount: "keep", elapsedMs: "keep", tokens: "keep",
@@ -153,7 +84,6 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
         const stripW = (r) => {
             const { scope: _s, sessionId: _sid, ...rest } = r;
             if (callerSession !== null && r.sessionId === undefined) {
-                // 白名单构造:kept 逐键显式拼,未列键默认不过(与 stripT 同形;"keep" 键必须同步进处置表)。
                 return {
                     id: rest.id,
                     status: rest.status,
@@ -168,22 +98,11 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
             }
             return rest;
         };
-        // [2373]C-12:data 里补 `type`(=event 名)双发——代理剥 `event:` 行/onmessage 忽略具名事件时,
-        // 按 data.type 分派的客户端在本流拿到的是 undefined(approvals 流注释里的真实约束,同理适用)。
-        // 单点注入:调用方已带 type 的帧(hook_notice/bg_notification)保持原值。
         const send = (event, data) => { if (!res.writableEnded)
             res.write(`event: ${event}\ndata: ${JSON.stringify({ type: event, ...data })}\n\n`); };
-        /** #189:快照里那些**按窗保留**的 workflow 行 id(来自 durable 终态窗,或握手期间才翻终态的行)
-         *  —— 见 workflow / workflow_remove 两臂。 */
         const retainedTerminalWf = new Set();
-        /** 现在是否正在重放握手期缓冲(只在这段里,终态行帧才升级为"保留行")。 */
         let replayingBuffer = false;
-        /** [3193] codex R4:首见即终态的历史行保留**预算**(每连接)。retainedTerminalWf 本身不积累
-         *  (每个 id 的撤行帧即刻消费),真正会无界的是「被豁免撤行、留在面板与 seenWf 里的历史行数」。
-         *  预算=终态窗容量同阶(×2);耗尽后退回旧「终帧→撤行」契约(行瞬态可见)——有界降级,不吞帧。
-         *  快照径的保留行不占预算(已由窗的行数+窗龄双界)。 */
         let retainedHistoryBudget = FLEET_SNAPSHOT_TERMINAL_MAX_ROWS * 2;
-        /** 一条增量帧的处理(**先注册订阅、后组装快照**,故与快照解耦成具名函数——见下方缓冲段)。 */
         const handleFrame = (frame) => {
             switch (frame.type) {
                 case "task":
@@ -194,15 +113,6 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     break;
                 case "workflow":
                     if (visW(frame.row)) {
-                        // #189 / codex R4-M3 → [3193] ①a 泛化:**本连接首见即终态**的行(重放期或活径皆然)与终态窗
-                        // 里的行是同一件事——它对这条连接从来不是"活跃集成员",是历史;它的撤行帧描述的活跃集离场
-                        // 对本连接无意义,照发只会让"看不看得见刚结束的 workflow"取决于 recover 落在握手窗哪一侧
-                        // (cli [3193] 插桩实证:落在重放窗内=保留可见,落在重放窗后=终帧+撤行背靠背、行瞬现即消)。
-                        // ⇒ 判据=「重放期 ∪ 首见即终态」并集(#189 原判据的严格超集):重放期臂保住"快照见过
-                        // running、缓冲里才翻终态"的行(R4-M3);首见臂保住活径上 recover 晚到的行(①a)。见过
-                        // running 的行在活径仍按既有契约走(终帧→撤行),在线消费端语义不变。豁免仍一次性,集合有界如旧。
-                        // [3193] codex R5:已在保留集里的 id(快照径收的)不重复扣预算——否则握手重放把同一批行
-                        // 按"快照+重放"记两次账,40 预算被快照行白耗光,其后真正的首见历史行立刻失去豁免。
                         if ((replayingBuffer || !seenWf.has(frame.row.id)) && isTerminalWorkflowRowStatus(frame.row.status) && !retainedTerminalWf.has(frame.row.id) && retainedHistoryBudget > 0) {
                             retainedTerminalWf.add(frame.row.id);
                             retainedHistoryBudget--;
@@ -212,9 +122,6 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     }
                     break;
                 case "task_remove":
-                    // #261 §2③/§5 Q-d:两个 additive 键随帧透传。撤行帧本就**只投给见过这一行的连接**
-                    // (`seenTasks.delete` 的返回值即判据)—— 这正是 Q-d 那条边界钉的服务端半场:不持行的
-                    // 订阅方连撤行帧都收不到,自然没有"结算"义务。`removeReason` 缺席 = 终态之后的常规清场。
                     if (seenTasks.delete(frame.id)) {
                         send("task_remove", {
                             id: frame.id,
@@ -225,96 +132,41 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     }
                     break;
                 case "workflow_remove":
-                    // 🔴 #189 / codex R2-M1:按窗**刻意保留**的历史行不受本连接的撤行帧影响。行在 durable 读
-                    // 期间翻终态时,活写路径的「终帧 + 撤行」会落进缓冲,重放到这里就会把快照刚保住的那一行
-                    // 又撤掉 —— 于是「看不看得见刚结束的 workflow」重新取决于连接时机(晚 1ms 连上的人看得见,
-                    // 撞上这一拍的人看不见),正是本 issue 要消灭的竞态。撤行帧描述的是**活跃集**离场,而这些
-                    // 行进快照时就已经是终态历史,不在活跃集语义里。id 不复用(runId 每次新铸,终态不回滚),
-                    // 故这层豁免既有界又不会误伤后来的真活行。
-                    // 豁免**一次性**:配对的那一帧撤行到达即消费(codex R5-M3)。否则这个 id 被永久噤声——
-                    // 同 id 若之后又出现活行(帧乱序/未来的行复用),它的撤行帧也会被吞,面板留一条撤不掉的死行;
-                    // 顺带,每条长连接的保留集不再随握手期完成数无界增长。
                     if (retainedTerminalWf.delete(frame.id))
                         break;
                     if (seenWf.delete(frame.id))
                         send("workflow_remove", { id: frame.id, ts: frame.ts });
                     break;
                 case "hook_notice": {
-                    // cli [1786]:一次 hook 判定**未能完成**的观测帧。可见性与 bg_notification **同为 fail-CLOSED** ——
-                    // 一条关于**别人会话**的「这轮没看住」落到这个壳上,会让用户以为是自己这轮出了问题
-                    // (而且 `/goal enforced` 面板会据此说一句不属于这个会话的话)。
-                    // ⇒ scoped 订阅方只收能证明是自己的:`ownerSessionId === callerSession`;`undefined` ⇒ **丢弃**。
-                    //   fleet-wide 观察者(callerSession === null:trace/dashboard)照收。
                     const hn = frame.notice;
                     const hScopeOk = callerScope === null || hn.ownerScope === callerScope;
                     const hSessionOk = callerSession === null || hn.ownerSessionId === callerSession;
                     if (hScopeOk && hSessionOk) {
                         const { ownerScope: _hs, ownerSessionId: _hsid, ...wire } = hn;
-                        // 与 bg_notification 同一帧契约:`type` 也放进 payload(壳的帧桥按 data.type 分派)。
                         send("hook_notice", { type: "hook_notice", ...wire, ts: frame.ts });
                     }
                     break;
                 }
                 case "bg_notification": {
-                    // design/129-B 缺口②(帧契约): a bg child's completion pushed on THIS always-open lane — the
-                    // idle shell renders the receipt immediately (no more one-input-cycle durable-drain lag). Visibility:
-                    // tenant filter on ownerScope (same rule as rows; a notification without one is operator/fleet-wide
-                    // visible only — fail-closed for scoped callers) + `?session=` on ownerSessionId (the HOST session;
-                    // the payload sessionId is the CHILD's uuid — the contract's stable anchor — and never matches the caller's).
                     const n = frame.notification;
                     const scopeOk = callerScope === null || n.ownerScope === callerScope;
-                    // [1493] fail-CLOSED on the MODEL-INJECTION path. bg_notification is auto-injected into the idle
-                    // shell's model (the receipt drives the LLM's next turn). Unlike the display rows — whose absent-
-                    // session `sessionOk` stays fail-OPEN for back-compat (an untagged row is at worst visible, never
-                    // actionable) — an untagged completion delivered to a SCOPED subscriber would inject a DIFFERENT
-                    // session's result into this shell's model (clay's dual-shell repro: two shells sharing one engine +
-                    // principal). So a scoped caller (callerSession !== null) receives a completion ONLY when it is
-                    // provably its own: ownerSessionId === callerSession. undefined ⇒ NOT proven ⇒ dropped. A fleet-wide
-                    // observer (callerSession === null: trace/dashboard) still sees everything. Part A (fleet-bus) is what
-                    // populates ownerSessionId for the legit owner so this gate delivers to it and drops only strangers.
                     const sessionInjectOk = callerSession === null || n.ownerSessionId === callerSession;
                     if (scopeOk && sessionInjectOk) {
                         const { ownerScope: _os, ownerSessionId: _osid, ...wire } = n;
-                        // The frame contract puts `type:'bg_notification'` INSIDE the object (the shell's frame
-                        // bridge dispatches on data.type, not only the SSE event name) — carry it in the payload too.
                         send("bg_notification", { type: "bg_notification", ...wire, ts: frame.ts });
-                        // The frame IS the delivery when it reaches the OWNING shell's session-bound lane —
-                        // serve-fence the durable park (both orders hold: an already-parked entry is acked; a park landing
-                        // AFTER this is refused by the serve fence) so the next stream-open drain can't re-inject the same
-                        // completion into the model (the engine-side steer-inject double the shell cannot dedup — the
-                        // 129-bg variant of that double-injection class, proven from real session logs). ONLY a `?session=`-bound subscriber counts: a fleet-wide
-                        // dashboard consuming the frame must NOT burn the owning shell's durable copy — the park keeps its
-                        // offline/no-active-lane semantics. Keys line up by contract: frame taskId = BackgroundChildEvent
-                        // .taskId = the a*-domain registry handle (stable across kinds) = the parked entry's
-                        // runId (leg onTaskNotification's n.task_id, same domain); ownerSessionId = HOST session = entry key.
-                        // design/144 键升级:park 键=域:taskId:status[#seq],fleet 帧不带 seq → 传家族前缀
-                        // (taskNotificationFoldKey 无 seq 形),markTerminalServed 家族 ack 清同族 seq 键成员。
-                        // PAIR-REVIEW F-2:mark 延至 **write flush 回调** + socket 存活双检——「res.write 已调用」≠投递
-                        // (对端已断本端未感知的窗口里,帧写进死 socket 而 durable 副本被烧=通知永丢,1.334 教训)。
-                        // flush 回调=数据出到内核缓冲(尽力而为的最强本端信号;真端到端 ack 需协议位,另议),回调时
-                        // 再验 socket.destroyed——断连时 Node 会先触发 destroy,此时不 ack,park 副本留给下次开流 drain。
-                        // fence 的防双注入语义不变(已 ack 的重复帧仍被拒),只推迟 ack 时点。
                         if (completionInbox && n.ownerSessionId && callerSession !== null && callerSession === n.ownerSessionId && !res.writableEnded) {
                             const ownerSid = n.ownerSessionId;
-                            // codex R1-H1(修车批):帧带 seq(1.239/core 1.352)→ **精确键** ack(servedAt 只 fence 该
-                            // 周期;revive 周期 N+1 的 park/enqueue 不被连坐)。legacy 无 seq 帧保持家族键 ack(原语义)。
                             const family = taskNotificationFoldKey({ task_id: n.taskId, status: n.status, ...(n.seq !== undefined ? { seq: n.seq } : {}) });
-                            // codex R2-H1(server belt):revive 周期的 park 键在 **uuid 域**(core ≤1.353 的 revive 通知
-                            // task_id=childSessionId,subagent.js:598/655——identity 对齐转 core 在单),帧键在 a\* 域——
-                            // 单键 ack 必 miss=开流二次注入。帧带 sessionId(uuid 别名)时**双域各 ack 一次**,两种 core
-                            // 版本的 park 键都被 fence 住;core 修齐后 uuid 臂自然空转(无同键 park,无害)。
                             const familyUuid = n.sessionId !== undefined && n.sessionId !== n.taskId
                                 ? taskNotificationFoldKey({ task_id: n.sessionId, status: n.status, ...(n.seq !== undefined ? { seq: n.seq } : {}) })
                                 : undefined;
                             const ackIfAlive = () => {
                                 if (res.writableEnded || res.socket?.destroyed)
-                                    return; // 死连接:不烧 durable 副本
+                                    return;
                                 void completionInbox.markTerminalServed(ownerSid, family).catch(() => undefined);
                                 if (familyUuid !== undefined)
                                     void completionInbox.markTerminalServed(ownerSid, familyUuid).catch(() => undefined);
                             };
-                            // res.write 的 flush 回调在上面 send() 内不可达(send 不透传 cb)——补一个零字节注释帧承载回调:
-                            // SSE 注释行(`: ack\n\n`)对消费者不可见(SDK 吞注释),flush 语义等同。
                             res.write(`: ack
 
 `, ackIfAlive);
@@ -323,17 +175,9 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     break;
                 }
                 default:
-                    break; // snapshot frames are connect-time only, never fanned out
+                    break;
             }
         };
-        // 🔴 #189 / codex R1-H1:订阅**先于**快照注册,快照组装期间到达的帧先进缓冲、发完快照再按序重放。
-        // 快照第一次有了一段 await(durable 终态窗读),而 fleet bus 只扇给**当前**订阅者、不重放 —— 先读后
-        // 订阅就等于开了一个"这段时间的帧对本连接不存在"的窗口(bg_notification 是模型注入面,丢一帧=这次
-        // 完成回执要等到下次开流才由 durable inbox 补;task_remove/hook_notice 同理)。
-        // 顺序安全:`bus.snapshot()` 取在**读之后**,缓冲里的行帧描述的都是快照那一刻或更早的状态,重放
-        // 只会把同一状态再叠一次(upsert 幂等);撤行帧仍按 seen 集判(没见过的行不发撤除)。
-        // 缓冲无显式上限:窗口被读预算硬界在 2s,且缓冲存的是**帧对象引用**(不复制行);设一个会丢帧的
-        // 上限反而正好丢掉这段代码要保住的东西。
         let buffered = [];
         const unsubscribe = bus.subscribe((frame) => {
             if (buffered !== null)
@@ -341,7 +185,6 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
             else
                 handleFrame(frame);
         });
-        // Real frame (not an SSE comment) — a per-frame-parsing BFF drops comments (zero-frame window downstream)
         const hb = setInterval(() => { if (!res.writableEnded)
             res.write(`event: heartbeat\ndata: {}\n\n`); }, 15_000);
         if (typeof hb.unref === "function")
@@ -357,18 +200,10 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                 res.end();
             resolve();
         };
-        // 关闭钩子在 await **之前**挂上:快照还在组装时对端就断了,也照常收摊(不然那段时间的断连没人处理)。
         req.on("close", shutdown);
         res.on("close", shutdown);
         void (async () => {
-            // [3193] 病理1:boot recover(判死前世 running 行)与快照组装赛跑——SIGKILL 后壳重连常抢在
-            // recover 之前,此刻 seed/durable 两径皆空,快照永远缺那一行。屏障=recovery 完成 promise
-            // (main.ts 铸,memory 后端/无 gate 部署=已 resolve),**有界**等待(帧订阅已挂上,等待期帧全
-            // 进缓冲不丢):超时=recover 真挂了,按旧行为出快照(可用性路径,行还有 first-sight-terminal
-            // 豁免与下次重连兜底),不无限拖住连接。
             if (terminal?.ready !== undefined) {
-                // A-067 C5 补遗(merge-rescan 车证伪「唯二反例」的第三处):竞速一结束 finally 清
-                // (A-002.10 同款)——unref 只是不吊进程退,不回收定时器本身。
                 let readyTimer;
                 await Promise.race([terminal.ready, new Promise((r) => { readyTimer = setTimeout(r, 3000); if (typeof readyTimer.unref === "function")
                         readyTimer.unref(); })]).finally(() => {
@@ -378,19 +213,12 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                 if (done || res.writableEnded)
                     return;
             }
-            // #189:durable 近期终态行窗(有界 + 永不抛;详见 fleet-terminal-window.ts)。
             const terminalWindow = terminal === undefined ? [] : await recentTerminalWorkflowRows(terminal.store, terminal.scope, terminal.pullScope);
             if (done || res.writableEnded)
-                return; // 组装期间断连:shutdown 已 unsubscribe,不再发任何东西
-            // connect-time snapshot (filtered + scope-stripped) — the visible rows become this connection's "seen" set.
+                return;
             const snap = bus.snapshot();
             const tasks = snap.tasks.filter(visT);
             const live = snap.workflows.filter(visW);
-            // #189:活行(bus 的活跃集)+ durable 终态窗。
-            //  · 一行一 id:同 id 两侧都有(行刚翻转的那一拍)时 **活行优先** —— 活行是唯一写者写的当前态,
-            //    终态窗是读时快照,后者覆盖前者会让面板倒退。
-            //  · 并入行同样过 `visW`(scope + `?session=`),与活行**同一套判据**:终态行泄跨租户是事故。
-            //  · bus 的 Map **不被触碰** —— 单写者不变量原样:活跃集里永远没有终态行,增量帧语义逐字不变。
             const liveIds = new Set(live.map((r) => r.id));
             const retained = terminalWindow.filter((r) => !liveIds.has(r.id) && visW(r));
             retained.forEach((r) => retainedTerminalWf.add(r.id));
@@ -399,20 +227,16 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
             workflows.forEach((r) => seenWf.add(r.id));
             send("snapshot", { tasks: tasks.map(stripT), workflows: workflows.map(stripW), ts: snap.ts });
             const pending = buffered ?? [];
-            buffered = null; // 自此直投(先置空再重放:重放期间新到的帧走直投,不会插到旧帧前面)
+            buffered = null;
             replayingBuffer = true;
             try {
                 for (const frame of pending)
                     handleFrame(frame);
             }
             finally {
-                replayingBuffer = false; // 重放一结束立刻恢复常态语义(哪怕上面抛了)
+                replayingBuffer = false;
             }
         })().catch(() => shutdown());
-        // ⚠️ 上面这个 catch 不是"静默降级":快照组装本身抛错(写向已销毁的 socket 那一族)时**没有**可以继续
-        // 的语义——这条连接已经没救了,干净收摊即正解。它真正防的是把原先同步执行器里的抛错(会直接 reject
-        // 出去)变成一条 **unhandled rejection**(Node 默认带走整个进程)。订阅回调自身的抛错另有隔离层
-        // (fleet bus 的 subscribe,记 fail-open),不经这里。
     });
 }
 //# sourceMappingURL=fleet.js.map