@sema-agent/server 7.43.0 → 7.44.0

package/dist/trace/artifacts.js

@@ -1,18 +1,11 @@
-/** Line count of a tool-arg string ("" = 0; no trailing-newline inflation). */
 function lines(v) {
     if (typeof v !== "string" || v.length === 0)
         return 0;
     return v.split("\n").length;
 }
-// Q6 (core 1.161) CC names。5.0.0 RB-476:折叠面退役——本投影跑在历史事件日志上,pre-rename 旧行
-// (如 1.171 时代的 "MultiEdit")不再折到 canonical:旧名行按原名滑过 FILE_TOOLS 判定=不进 artifacts
-// 归类(诚实历史,读面不再兜旧名;耐久面按 [2364] 令牺牲)。
 const FILE_TOOLS = new Set(["Write", "Edit", "NotebookEdit"]);
 const GIT_PUSH_RE = /\bgit\b[^;|&]*\bpush\b\s*(.*)/;
-/** Project the durable event log into artifacts. Events must be in seq order (getEvents guarantees it). */
 export function projectArtifacts(events, run) {
-    // Pair tool_start args with the matching tool_end by toolCallId — only a SUCCESSFUL call (isError false)
-    // produces an artifact (a failed write/push produced nothing).
     const starts = new Map();
     const byKey = new Map();
     for (const ev of events) {
@@ -26,33 +19,25 @@ export function projectArtifacts(events, run) {
         const start = starts.get(d.toolCallId);
         if (!start)
             continue;
-        starts.delete(d.toolCallId); // each call contributes at most once
-        const toolName = start.toolName; // RAW(5.0.0):折叠面退役,历史旧名行按原名处理(见文件头注)
+        starts.delete(d.toolCallId);
+        const toolName = start.toolName;
         if (FILE_TOOLS.has(toolName)) {
-            // Write/Edit key the write target on `file_path`. core 5.1.0([2390])收窄 schema 为 `file_path` 单形,
-            // 但**门读侧 over-read 保留**是同批 KEEP 裁定(fail-closed 方向)——这里是耐久历史行的读侧([2373] D 类),
-            // pre-1.169 emit/旧 durable checkpoint 仍带 `path`,回落臂是对自己旧数据的容忍,不是对上游新帧的兼容。
-            // 再回落 NotebookEdit 的 `notebook_path`(core 1.163)。三键全缺 → 非带路径调用。
             const path = typeof start.args["file_path"] === "string" ? start.args["file_path"] : typeof start.args["path"] === "string" ? start.args["path"] : typeof start.args["notebook_path"] === "string" ? start.args["notebook_path"] : undefined;
             if (!path)
                 continue;
-            // Hunk-level line stats from the call args themselves (zero new storage; args already redacted).
-            // Edit is batch-capable (core 1.202: an `edits[]` array — also the shape of a persisted legacy MultiEdit
-            // row, folded onto "Edit" above): with a batch, sum each edit's new_string/old_string lines; a single
-            // edit keeps the flat new_string/old_string fields.
             const edits = Array.isArray(start.args["edits"]) ? start.args["edits"] : [];
             const add = toolName === "Write" ? lines(start.args["content"])
                 : toolName === "NotebookEdit" ? lines(start.args["new_source"])
                     : edits.length > 0 ? edits.reduce((s, e) => s + lines(e["new_string"]), 0)
-                        : lines(start.args["new_string"]); // Edit (single)
-            const del = toolName !== "Edit" ? 0 // Write/NotebookEdit carry no old_string (NotebookEdit delete-mode → 0 add 0 del = a touched count)
+                        : lines(start.args["new_string"]);
+            const del = toolName !== "Edit" ? 0
                 : edits.length > 0 ? edits.reduce((s, e) => s + lines(e["old_string"]), 0)
                     : lines(start.args["old_string"]);
             const key = `file:${path}`;
             const prev = byKey.get(key);
             byKey.set(key, { kind: "file", ref: path, count: (prev?.count ?? 0) + 1, ts: ev.ts, add: (prev?.add ?? 0) + add, del: (prev?.del ?? 0) + del });
         }
-        else if (toolName === "Bash") { // Q6 (core 1.161): was "bash"; canonical fold above is identity for it today
+        else if (toolName === "Bash") {
             const command = typeof start.args["command"] === "string" ? start.args["command"] : "";
             const m = GIT_PUSH_RE.exec(command);
             if (!m)

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

@@ -1,109 +1,28 @@
-/**
- * `engine_notice` wire 腿(#310,设计稿 = 黑板 [4630],core 表态 [4631] / cli 表态 [4634])——
- * core `EngineNotice` 的**第二终点**:按 sessionId 路由到那条会话的事件投影(SSE + durable 账本)。
- *
- * ## 为什么是白名单而不是全族上 wire
- * `RunnerDeps.onNotice` 是 **deps 级单 sink**(一部署一只),`EngineNotice` 上**没有 runId**——
- * 归属只能靠 `detail.sessionId`。于是:
- *  · `config.*` 族一个都不带 sessionId ⇒ 结构性无处投(投给谁都是猜);
- *  · core 侧**按 sink 去重**的码(`config.read_face_deployment_clamped` / `config.tool_model_gate_*`)
- *    一旦上 per-session 流,语义当场翻面:共享 sink 意味着整进程只发一次,第二条会话的用户看到的是
- *    「随机缺席」而不是「没发生」;
- *  · 运维码(`config.env_timeout_discarded` 一族)推给终端用户 = 跨租户串台面。
- * 白名单里的三码,core 侧的去重单位分别是 **session / harvest / prepared-leg**(不是 sink),所以它们
- * 上 per-session 流不产生上面第二条的翻面——这正是白名单避开去重陷阱的判据,不是随手挑的三个码。
- *
- * ## 缺 sessionId 的白名单码:如实不投
- * 三码的 `detail.sessionId` 在 core 类型上是**可选**的(部分铸点确无 session 语境)。缺席时本腿
- * **不投**(fail-closed 方向 = 宁缺席不串台;猜一个"当前活跃会话"就是串台的定义)。日志终点仍逐字
- * 保留 ⇒ 运维观察面零回退,事实一条不丢。
- *
- * ## 白名单的演化机制(设计稿 ④)—— **注册表已到货(core 5.47/5.48)**
- * core [4631] 认领的 `NOTICE_AUDIENCE` **码级注册表**(code → "user"|"operator";缺席读 `"operator"`,
- * 保守默认)已随 5.47/5.48 到货,`EngineNotice.sessionId` 顶层键亦然。#292 提货批的处置是
- * **消费它当上界,而不是当场把本表整只退役**:
- *  · 本表是**投递可行性**的判定(有没有 sessionId 归属键、core 侧的去重单位是不是 sink),
- *    `NOTICE_AUDIENCE` 是**受众**的判定(这条码是给谁看的)——两者是合取,不是同一件事;
- *  · 于是机器门(`test/engine-notice-wire.test.ts` ⑥)现在**双向**咬:白名单里出现一个 core 判
- *    `"operator"` 的码 ⇒ 红(本仓不许自造第二份受众语义);core 判 `"user"` 的码没入册也没明拒 ⇒ 红。
- *  · 真正的整表退役条件 = 上游把「归属键在不在」也纳入注册表(那时本表退化成一次查表),届时删。
- * 🔴 固定动作不变:**每一次 core 提货批**对表 core `EngineNotice` 码册的新增码,三选一登记
- * (入册 / 明拒 + 理由 / 申裁),并在 `docs/core-consumption/LEDGER.json` 的该批行里留痕。
- * 漏对表的后果不是报错而是**静默缺席**:新码永远不上 wire,消费端(cli)无从知道该码存在。
- */
 import { redactSecrets } from "./redact.js";
 import { recordFailOpen } from "../observability/fail-open.js";
-/**
- * 上 wire 的通告码 —— **显式闭集常量表**(设计稿 ①,起步三码)。
- *
- * 三码同族:都是「这条 session 的记忆姿态」的披露,resume 之后仍然相关 ⇒ 也进 durable 账本
- * (cli 断连补看走既有 events 重放腿,[4634](ii))。
- */
 export const ENGINE_NOTICE_WIRE_CODES = [
-    /** design/178 §3:本会话记忆越过一次性 POLLUTED 态。core 去重单位 = **session**。`detail: { reason, sessionId? }` */
     "memory.session_polluted",
-    /** design/178 §3:被污染会话的 harvest 执行了容纳。core 去重单位 = **harvest**(检查点收与终局收是两件事)。
-     *  `detail: { count, moved, escalated, reason?, sessionId? }` —— 🔴 `moved` 与 `escalated` **不可相减**
-     *  (就地墓碑同时计入两者,core 顶注);消费端并列呈现,不做算术。 */
     "memory.harvest_quarantined",
-    /** design/324 #324①:`memoryDelegationEvidence:"attested-only"` 下,一次静态面本会打的污染标记被豁免。
-     *  core 去重单位 = **prepared leg**。`detail: { reason, subagentType?, sessionId? }` */
     "memory.delegation_static_mark_waived",
-    /** design/336 §4/§6.3(core 5.47/5.48 到货,#292 提货批对表入册):**instruction-hold 生命周期**三码。
-     *  同族三条都是「这条 session 的记忆此刻处在什么姿态」的披露,与既有三码同一条判据:
-     *   · core `NOTICE_AUDIENCE` 明列 **"user"**(到货的码级注册表,见本文件顶注的演化机制);
-     *   · 铸点在 `memoryHoldNotices(report, sessionId)`,`detail.sessionId` 随 harvest 报告一起给 ⇒ 投得出去;
-     *   · core 去重单位 = **harvest**(检查点收与终局收是两件事),不是 sink ⇒ 上 per-session 流不翻面。
-     *  `detail: { count, paths, sessionId? }`(paths 已 neutralize + 截 20 条)。 */
     "memory.hold_opened",
-    /** 同族:被扣住的 instruction 条目在写者会话干净结算(或宿主阀门放行)后重走全套门并提交。
-     *  `detail: { count, paths, sessionId? }` */
     "memory.hold_released",
-    /** 同族:被扣住的条目移交控制面隔离区。`detail: { count, disposed: [{ path, terminal }], sessionId? }`
-     *  —— 🔴 `terminal:"expired"` 是**超时不是定罪**(core 铸文逐字如此),消费端不得渲染成裁决语气。 */
     "memory.hold_disposed",
 ];
 const WIRE_CODES = new Set(ENGINE_NOTICE_WIRE_CODES);
-/** 白名单谓词(单点):路由与门都读这一个,不许第二处手抄码串。 */
 export function isEngineNoticeWireCode(code) {
     return WIRE_CODES.has(code);
 }
-/**
- * 归属键抽取 —— `detail.sessionId` 提升为顶层(设计稿 ②:归属键一等化)。
- *
- * 非串 / 空串一律按**缺席**处理(不铸 `"undefined"` 这种看起来合法的假值——`compactionOutcomeEventData`
- * 的同款缺键守卫纪律)。core [4631] 的顶层 `EngineNotice.sessionId` 到货后,这里先读顶层再回落 detail
- * (两处同值,additive 零 BREAKING),届时本函数是唯一改动点。
- */
 export function engineNoticeSessionId(notice) {
-    const top = notice.sessionId; // core 5.46+ 顶层键(到货前恒 undefined,读它零代价)
+    const top = notice.sessionId;
     if (typeof top === "string" && top.length > 0)
         return top;
     const fromDetail = notice.detail?.sessionId;
     return typeof fromDetail === "string" && fromDetail.length > 0 ? fromDetail : undefined;
 }
-/** 自由文本(message / detail 里的串)的长度上限。`workspaceChangedEventData` 的 300 是**路径**级 bound;
- *  通告的 `reason` 是一整句话(core 侧已 neutralize + bound),这里给它一个不腰斩正常句子的上限。 */
 const NOTICE_TEXT_MAX = 1000;
-/** detail 递归消毒的结构上限。三码的真 detail 都是 ≤5 键的扁平对象 ⇒ 生产上永不触顶;
- *  上限存在的理由是**未来码**(以及被污染输入)不得把任意大小的对象推上 wire。 */
 const DETAIL_MAX_DEPTH = 4;
 const DETAIL_MAX_KEYS = 32;
 const DETAIL_MAX_ITEMS = 32;
-/**
- * `detail` 消毒(设计稿 ②:`redactSecrets` + 尺寸 bound;`workspaceChangedEventData` 先例)。
- *
- * core 已 neutralize 三码的 `reason`(工具名/子代类型是 host/模型可控输入),**server 按纪律再过一遍**
- * ——§E1 的既有姿态:上 wire 的自由文本一律经本仓的脱敏器,不因为上游说过一次就免检。
- *
- * 契约(逐条,门在 `test/engine-notice-wire.test.ts`):
- *  · 串 ⇒ `redactSecrets` + 截到 {@link NOTICE_TEXT_MAX};
- *  · 有限 number / boolean / null ⇒ 逐字(harvest 的 count/moved/escalated 是判据数字,不许变形);
- *  · 非有限 number(NaN/Infinity)⇒ **丢键**(JSON 里它们会变成 `null`,一个看起来合法的假读数);
- *  · 数组 ⇒ 逐项消毒,超 {@link DETAIL_MAX_ITEMS} 截断;对象 ⇒ 逐键消毒,超 {@link DETAIL_MAX_KEYS} 丢尾键;
- *  · 深度超 {@link DETAIL_MAX_DEPTH} ⇒ 该子树丢弃;
- *  · 其余(function / symbol / bigint / undefined)⇒ 丢键(JSON 不可承载或语义不明)。
- */
 export function sanitizeNoticeDetail(detail) {
     const out = sanitizeValue(detail ?? {}, 0);
     return (out ?? {});
@@ -142,15 +61,8 @@ function sanitizeValue(v, depth) {
         }
         return rec;
     }
-    return undefined; // function / symbol / bigint / undefined
+    return undefined;
 }
-/**
- * `engine_notice` 载荷构造器(三条终点腿同源:live SSE / durable 账本 / 未来的任何第四条腿)。
- *
- * 与 `trace/project.ts` 的 `*EventData` 族同纪律(白名单挑键、禁 `{...notice}`),但**不住在那个文件里**:
- * 那一族的入参全是 core `TaskEvent` 的臂(有 `wire-whitelist-exhaustiveness` 的臂集编译门看着),
- * 而 `EngineNotice` 不是 `TaskEvent` —— 混进去会让那道门的语义变成"两个不同来源的联合",判别力反而降。
- */
 export function engineNoticeEventData(notice, sessionId, nowMs) {
     return {
         code: notice.code,
@@ -161,34 +73,12 @@ export function engineNoticeEventData(notice, sessionId, nowMs) {
     };
 }
 let nextLegId = 1;
-/**
- * sessionId → 该会话活跃 run 腿的投递口。**进程内**(`defaultSubagentTailBus` 同款姿势):
- * `onNotice` 是同进程的同步回调,通告与它要投的那条腿必然同副本,跨副本路由这件事结构上不存在。
- *
- * 🔴 跨 session 隔离靠的是 **Map 键的精确串相等**,不是任何「最近活跃」回落 —— 缺席就是缺席(G5)。
- *
- * 🔴 **同 session 的跨代隔离靠 legId「最新代独占」**(#310 codex 对抗复审 R1-[high],验真后修)。
- * 病(真窗,本仓每一处 in-flight 登记都为它写过 identity-guard):run 行在**流体内**就已 setTerminal /
- * setSuspended,而本腿的注销在 `finally` —— 中间那一窗里,同一条 session 上的**下一条腿**(快速续跑 /
- * 紧接着的新提交)已经注册好了自己的口。若按「会话内全量扇出」投,新腿的一条通告会**同时**落进:
- *  · 旧腿那条已 end 的 SSE(顶多记一次 fail-open,无害),以及
- *  · **旧 taskId 的账本** —— 一条不属于那条 run 的、终态之后的行;resume 复用同 taskId 时还会与新腿
- *    抢同一个 `(task_id, seq)` 域。这不是跨租户泄露,是**同租户跨 run 的账本污染**,同样必须关死。
- * 药:每次 `registerLeg` 铸一个单调 legId,`route` **只投最新代**;旧代的口留在表里(它自己的注销仍
- * 按身份精确删,不会误删新代),但一帧都收不到。方向 = fail-closed(宁可旧腿少一帧,不可新腿的事实
- * 写进旧腿的账)。
- */
 export class EngineNoticeRouter {
     legs = new Map();
-    /**
-     * 登记**一条腿**的全部口(live / durable 作为**一代**同进同出)。返回注销函数(幂等,身份精确删)。
-     *
-     * 每只口各自 try 隔离在 {@link route} 里,单口抛不牵连同腿另一口。
-     */
     registerLeg(sessionId, sinks) {
         const leg = { legId: nextLegId++, sinks: [...sinks] };
         const list = this.legs.get(sessionId) ?? [];
-        list.push(leg); // 追加 = 本代成为最新代
+        list.push(leg);
         this.legs.set(sessionId, list);
         let done = false;
         return () => {
@@ -198,39 +88,31 @@ export class EngineNoticeRouter {
             const cur = this.legs.get(sessionId);
             if (!cur)
                 return;
-            const at = cur.indexOf(leg); // 身份精确删:绝不按位置/长度删(会误删新代)
+            const at = cur.indexOf(leg);
             if (at >= 0)
                 cur.splice(at, 1);
             if (cur.length === 0)
                 this.legs.delete(sessionId);
         };
     }
-    /** 单口腿的便捷形(测试与单终点腿用)。 */
     register(sessionId, sink) {
         return this.registerLeg(sessionId, [sink]);
     }
-    /** 诊断/门用:某会话此刻**最新代**有几只口在听(旧代不计——它们收不到帧)。 */
     sinkCount(sessionId) {
         const list = this.legs.get(sessionId);
         return list && list.length > 0 ? list[list.length - 1].sinks.length : 0;
     }
-    /** 诊断/门用:某会话此刻有几代腿在表里(>1 = 正处在换代窗内)。 */
     legCount(sessionId) {
         return this.legs.get(sessionId)?.length ?? 0;
     }
-    /**
-     * 分流器的 wire 半场。返回**真投出去的口数**(0 = 没投:非白名单码 / 缺 sessionId / 该会话无活跃腿)。
-     *
-     * 单只口抛错**不吃掉同腿的其它口**(fleet bus 订阅者隔离同理由),并按 F 类登记留痕。
-     */
     route(notice, nowMs = Date.now()) {
         if (!isEngineNoticeWireCode(notice.code))
             return 0;
         const sessionId = engineNoticeSessionId(notice);
         if (sessionId === undefined)
-            return 0; // 如实不投(顶注:宁缺席不串台)
+            return 0;
         const list = this.legs.get(sessionId);
-        const leg = list && list.length > 0 ? list[list.length - 1] : undefined; // 只投最新代
+        const leg = list && list.length > 0 ? list[list.length - 1] : undefined;
         if (!leg || leg.sinks.length === 0)
             return 0;
         const row = engineNoticeEventData(notice, sessionId, nowMs);
@@ -247,18 +129,7 @@ export class EngineNoticeRouter {
         return delivered;
     }
 }
-/** 进程单例(`defaultSubagentTailBus` 同款):分流器与 run 腿直接 import,不穿长参数列表;测试自 new 独立实例。 */
 export const defaultEngineNoticeRouter = new EngineNoticeRouter();
-/**
- * run 腿的注册助手 —— 三条腿(sync stream / bg / resume-verify)用**同一个**形,免得各写一份漂。
- *
- * `sessionId` 缺席(adhoc 无会话腿)⇒ 返回 no-op 注销函数,一个字节不注册(顶注的 fail-closed 方向)。
- * `live` / `durable` 各自可缺席:bg 腿没有 live SSE(消费方走 events tail),ephemeral sync 腿没有账本。
- *
- * 🔴 两口注册成**两只独立 sink**(不是一只闭包里顺序调两次):route 的隔离粒度是 sink,合成一只会让
- * live 写(断连的 socket、JSON.stringify 抛)吃掉同一拍的 durable 落账 —— 而 durable 那半正是断连之后
- * 唯一还看得见这条通告的地方(G3),两者的失败必须互不牵连。
- */
 export function registerEngineNoticeLeg(opts) {
     const { sessionId, live, durable } = opts;
     if (sessionId === undefined || sessionId.length === 0)
@@ -266,9 +137,6 @@ export function registerEngineNoticeLeg(opts) {
     const sinks = [...(live ? [live] : []), ...(durable ? [durable] : [])];
     if (sinks.length === 0)
         return () => undefined;
-    // 🔴 两口登记成**同一代**(`registerLeg` 一次调用)而不是两次 `register`:代是"腿"的属性,拆成两代
-    // 会让换代时旧腿的一只口先被超代、另一只还没 —— 半代状态没有任何正确语义。口的失败隔离是 `route`
-    // 里的 per-sink try(与代无关),两者是正交的两件事。
     return (opts.router ?? defaultEngineNoticeRouter).registerLeg(sessionId, sinks);
 }
 //# sourceMappingURL=engine-notice-wire.js.map

package/dist/trace/ledger-sink.js

@@ -1,22 +1,6 @@
 import { redactSecrets } from "./redact.js";
 import { toolStartEventData, toolEndEventData, taskProgressEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestEventData, humanInputEventData, turnEndEventData, contextUsageEventData } from "./project.js";
 import { NotifiedKeys, taskNotificationStreamKey } from "../orchestration/workflow-completion-inbox.js";
-/**
- * **单写串行链**的可复用形(#310 codex 对抗复审 R1-[high],验真后修)—— `seq` 的**分配发生在链步内**,
- * 于是「分配序 == 发起序 == 提交序」。
- *
- * 病(实测形,`LedgerSink` 内部早有这条纪律的内联版、其顶注 [1.211 codex H2] 逐字记着它):裸写口
- * (`(type, data) => rs.appendEvent(taskId, ++seq, type, data)`)在**同步分配 seq、立刻发起 insert**。
- * 主循环 await 自己的写,所以主循环内部有序;但只要有**一个 fire-and-forget 写者**(子代 forward 帧、
- * #310 的通告口),它的 N 号 insert 可能在池化 SQL 后端上晚于后发的 N+1 号提交。events tail 的读法是
- * `getEvents(id, afterSeq)` —— 读到 N+1 就把游标推过 N,**那一行此后永远不会被投递**(重连也不会,
- * 游标只前进)。行在库里,消费端结构性看不见。
- *
- * 药:所有写口共用一条 promise 链,`++seq` 在链步内取。链上一步失败**不断链**(catch → undefined),
- * 调用方仍拿到自己那一步的真实结果(await 者照常收到 reject)——与 `LedgerSink` 内联版逐字同语义。
- *
- * ⚠️ 用它的前提是**这条腿的全部写口都走它**(混用一个绕开链的写口 = 病灶原样保留)。
- */
 export function createSerialLedgerAppend(appendEvent, startSeq) {
     let seq = startSeq;
     let chain = Promise.resolve();
@@ -29,49 +13,35 @@ export function createSerialLedgerAppend(appendEvent, startSeq) {
 export function createLedgerSink(opts) {
     const keys = opts.notifiedKeys ?? new NotifiedKeys();
     let seq = 0;
-    // [1.211 codex H2] 单写串行链:seq 的「分配」在链步内发生 ⇒ 分配序 == durable 提交序。没有它,
-    // onForwardEvent 的 fire-and-forget 写与主循环的 awaited 写交错时,高 seq 可先落盘对 events tail 可见,
-    // 迟到的低 seq 在读方游标(afterSeq)前进后被永久遗漏。链上一步失败不断链(catch → undefined),
-    // 调用方拿到的是自己那步的真实结果(await 者照常收到 reject)。
     let chain = Promise.resolve();
     let text = "";
     let reasoning = "";
-    // E18 resume-at: the turn's FIRST text_delta eventId = the message's stable per-message resume handle,
-    // stamped on the durable `text` event (ONE handle per message even when a mid-turn tool_start flushes the
-    // text early). Latched on the first DEFINED eventId of the turn (`??=` — a later part after a tool must not
-    // re-latch), cleared at turn_end — the exact `TurnAnchorCapture.firstTextEventId` semantics. (The bg leg's
-    // anchor tracks the same value for its own anchor-put; both latches see the same events in the same order,
-    // so the stamps agree byte-for-byte — the anchor's extra `turnHadTool` state never feeds the stamp.)
     let textEventId;
-    // #245 S1:活性打点(顶注契约:两打点位之一;抛错吞掉,绝不拖账本/事件循环下水)。
     const beat = () => {
         try {
             opts.onActivity?.();
         }
         catch {
-            /* 分诊打点失败只丢判别材料 */
         }
     };
     const append = (type, data) => {
-        beat(); // 打点位②:不经 onEvent 的直写路径(parked/done/forward)在这里被兜住
+        beat();
         const step = chain.then(() => opts.appendEvent(++seq, type, data));
         chain = step.then(() => undefined, () => undefined);
         return step;
     };
     const flush = async () => {
-        // Thinking precedes content within a turn → flush a buffered reasoning block FIRST (redacted).
         if (reasoning) {
             await append("reasoning", { text: redactSecrets(reasoning) });
             reasoning = "";
         }
         if (text) {
-            // E18: stamp the turn's first-text eventId as the per-message resume handle (additive; tolerate-absent).
-            await append("text", { text, ...(textEventId ? { eventId: textEventId } : {}) }); // persist first; clear only on success so a failed write doesn't drop it
+            await append("text", { text, ...(textEventId ? { eventId: textEventId } : {}) });
             text = "";
         }
     };
     const onEvent = async (ev) => {
-        beat(); // 打点位①:所有流事件(含只进缓冲的 text/reasoning delta)——「事件到达 sink」= turn 在推进
+        beat();
         switch (ev.type) {
             case "text_delta": {
                 const td = ev;
@@ -80,104 +50,57 @@ export function createLedgerSink(opts) {
                 break;
             }
             case "reasoning_delta":
-                // Persist the agent's thinking for the trace UI (core [R57]: reasoning IS on the live stream but NOT in
-                // the metadata Tracer — capturing it is the service's call). Gated by TRACE_THINKING; redacted on flush.
                 if (opts.persistThinking)
                     reasoning += ev.delta;
                 break;
             case "tool_start":
                 await flush();
-                // E1+E2 (shell-host contract): redacted args + identity via the shared whitelist builder — identical
-                // persisted shape across every leg.
                 await append("tool_start", toolStartEventData(ev));
                 break;
             case "tool_end":
                 await flush();
-                // E1: redacted model-facing output (+truncated, core size-bound) + E2 identity, via the shared builder.
                 await append("tool_end", toolEndEventData(ev));
                 break;
             case "status":
-                // S4 (SILENT-FALLBACK P0-a): persist the brain-layer liveness observation. core marks the live frame
-                // EPHEMERAL (it never replays it) — this durable row is OUR observation record so async/replay readers
-                // can attribute a stalled turn. flush() first (review MED-2): a reconnect can fire MID-TEXT — without
-                // the flush the already-streamed text lands AFTER this row and the durable timeline inverts.
-                // design/158 B2: durable row type aligned to the live frame name ("status", not "brain_status") — the
-                // two legs were emitting the SAME logical event under two different `type` strings, and the SDK's
-                // public `AgentEvent` union only declared "status" (a durable-leg reader saw a frame outside its own
-                // public type). 写新读旧:这里只管写新;**存量行救不了**(任何旧部署的账本里都躺着 `brain_status`
-                // 行),所以重放边界配了一次性归一 —— `normalizeRunEventType`(trace/project.ts),唯一调用点是
-                // task_run SSE 的 `formatEvent`(routes/runs.ts)。两半缺一不可:只改写入侧的话,存量行重放时
-                // 仍会漏出公开联合之外的名字。无 migration、无回填(读边界归一比改历史行便宜且不可逆风险为零)。
                 await flush();
                 await append("status", brainStatusEventData(ev));
                 break;
             case "context_usage":
-                // core 1.414 一等分支(server [1669]⑥ 要的上下文用量面)。每个压缩边界上报一次 ⇒ 一次任务多条,
-                // 消费方取最后一条为当前值。两条口径见 `contextUsageEventData` 旁注(别把 windowTokens 当模型上下文)。
                 await flush();
                 await append("context_usage", contextUsageEventData(ev));
                 break;
             case "compacted":
                 await flush();
-                // MF-18 (1.149) trigger/tokensBefore + core 1.219 attachedFiles/preserved_segment via the SHARED
-                // whitelist builder — the shell renders CC's post-compact `Read {path}` cards + the divider from these.
                 await append("compacted", compactedEventData(ev));
                 break;
             case "diagnostics":
-                // core 1.220 (design/121): NEW LSP diagnostics at a turn boundary — the shell's render source for CC's
-                // "Found N new diagnostic issues" row. §E1: language-server output is UNTRUSTED RAW → builder redacts.
                 await flush();
                 await append("diagnostics", diagnosticsEventData(ev));
                 break;
             case "steering_injected":
-                // [1550]/[1552]: core's mid-run system-reminder injection (todo/file-change/date-roll/skills-delta/…) —
-                // the shell's render source for CC's steering-attachment row. §E1: preview is UNTRUSTED free text →
-                // builder redacts. Host/self-session only — NOT mirrored into onForwardEvent (a delegated child's own
-                // reminders are its internal bookkeeping, not host-relevant progress like tool_start/task_progress).
                 await flush();
                 await append("steering_injected", steeringInjectedEventData(ev));
                 break;
             case "compaction_outcome":
-                // [2373]A-2/C-2:此前 durable 双腿零 case ⇒ 回放即消失(与 [1622] label / [1611] workflowRunId
-                // 同族)。共享 builder(§E1 脱敏)三腿同源;差集门 durable-append-arm-parity 看守。
                 await flush();
                 await append("compaction_outcome", compactionOutcomeEventData(ev));
                 break;
             case "workspace_changed":
-                // [1559]二 core 裁定:design/99 §E13 旧臂,L1 门扩臂时首次撞见。durable 记账与其余内容型臂
-                // 同处置(轨迹回放时「何时 cd 到了哪」是合法历史事实,「不当持久态渲染」是 LIVE 消费端纪律,
-                // 不是不许落账)——共享白名单构造器 + §E1 redact。
                 await flush();
                 await append("workspace_changed", workspaceChangedEventData(ev));
                 break;
             case "wiring_manifest":
-                // 🔴 core 5.14.0 design/173:装配自证清单。账本行**同样**要剥 `governance` 段——durable 行可经
-                // `GET /v1/runs/:id/events` 重放给同一批租户订阅者,是与 sync 腿完全相同的泄露面,所以用**同一个**
-                // 构造器(两腿分头挑键就是下一次泄露的种子)。core 契约:no projection ⇒ do not disclose。
                 await flush();
                 await append("wiring_manifest", wiringManifestEventData(ev));
                 break;
             case "human_input":
-                // core 5.14.0 design/171:人类输入生命周期账本(谁/经哪条载体/投递成没成)。落账是本臂的
-                // 正当用途——「这条 run 是谁喂的」正是事后对账要的历史事实;身份串的脱敏在共享构造器里。
                 await flush();
                 await append("human_input", humanInputEventData(ev));
                 break;
             case "task_progress":
-                // core breakpoint⑤: a subagent's live progress tick → an INLINE "subagent working" card for the tailing
-                // client (S2-a). Shared whitelist+redact builder (+ E2 identity for the exact concurrent-tick binding).
                 await append("task_progress", taskProgressEventData(ev));
                 break;
             case "task_notification": {
-                // core 1.202 (design/115 P2): a background task finished while this harness was live — persist the
-                // display projection so a tailing client renders it (summary/result are UNTRUSTED free text → shared
-                // builder redacts). core [784]④a+④b: seq-folded shared key + skip keys this leg already delivered
-                // (start-of-leg inbox drain or observer arm) — core's pend-drain replays a double-parked idle arrival
-                // as a stream event; appending it again doubles the frame in the durable tail. codex F1: a key claimed
-                // by a fire-and-forget arm may have FAILED to land — await the claim's outcome; false ⇒ write anyway
-                // (this stream replay is the notification's last copy on this leg) and promote the key with THIS
-                // write's outcome. The claim promise is registered before the awaited append so a concurrent observer
-                // callback can't double-claim mid-write.
                 await flush();
                 const tn = ev.notification;
                 const tnKey = tn?.task_id ? taskNotificationStreamKey({ task_type: tn.task_type, task_id: tn.task_id, status: String(tn.status), seq: tn.seq }) : undefined;
@@ -185,26 +108,21 @@ export function createLedgerSink(opts) {
                 if (tnPrior === undefined || !(await tnPrior)) {
                     const write = append("task_notification", taskNotificationEventData(ev));
                     if (tnKey !== undefined)
-                        keys.set(tnKey, write.then(() => true, () => false)); // the stream delivered this key
+                        keys.set(tnKey, write.then(() => true, () => false));
                     await write;
                 }
                 break;
             }
             case "turn_end": {
                 await flush();
-                // core 1.76 (service [41]/core [R59]): per-turn usage rides turn_end.usage — persist it for TraceTurn.tokens.
                 const usage = ev.usage;
-                await append("turn_end", turnEndEventData(ev)); // 白名单 builder(此前手写 {usage},剥掉了 stopReason/usageMissing)
-                textEventId = undefined; // next turn latches its own first-text handle (TurnAnchorCapture parity)
+                await append("turn_end", turnEndEventData(ev));
+                textEventId = undefined;
                 break;
             }
-            // `done` / `message_committed` / unknown: deliberate no-ops — see the interface doc.
         }
     };
     const onForwardEvent = (e) => {
-        // 1.78 (review HIGH) + C1 (core 1.219, spec.forwardSubagentEvents): a delegated child's lifecycle rides the
-        // forward sink (each stamped parentToolCallId — the shell nests them under the delegation card). Same
-        // shared builders as the top stream; fire-and-forget (`++seq` is sync → unique seqs vs the awaited loop).
         const t = e.type;
         if (t === "task_progress") {
             void append("task_progress", taskProgressEventData(e)).catch(() => undefined);
@@ -216,15 +134,8 @@ export function createLedgerSink(opts) {
             void append("tool_end", toolEndEventData(e)).catch(() => undefined);
         }
     };
-    // #255:第五席的写口 —— 一行,但**位置**是它的全部:`append` 在这里被**同步**调用,序号槽在回调进入
-    // 的那一刻就占住(理由与判据全文见接口上的 doc 注)。别为了「与 onEvent 同形」把它改写成
-    // `onEvent({type:"status",…})`:那一次 `await flush()` 正是被修掉的病。
     const appendStatus = (ev) => append("status", brainStatusEventData(ev));
-    const appendParked = (kind, result) => 
-    // Never the capability checkpointToken — only the non-secret gate (search [18] Q1b)。
-    // [4913]:结果若已被 graftParkToolCallId 补过待批 toolCallId(调用方在 park 点先 graft),随行投影;
-    // 缺席(tool-less park / graft 未接 / 读失败)= 键不铸([1995]② OMITTED 契约,不编 null)。
-    append(kind, {
+    const appendParked = (kind, result) => append(kind, {
         gate: result?.checkpointGate ?? null,
         ...(typeof result?.toolCallId === "string" ? { toolCallId: result.toolCallId } : {}),
     });