@sema-agent/server 7.76.2 → 7.77.0

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

@@ -7,7 +7,9 @@ export type SubagentTailFrame = Record<string, unknown> & {
     type: string;
 };
 /** core forward 事件 → wire 投影(sync 主流五分支同源;不认识的帧类型=null 不发——tail 面只承诺
- *  content 六类,新 core 帧类型先经这里显式收编再出 wire)。 */
+ *  content 六类,新 core 帧类型先经这里显式收编再出 wire)。
+ *  ⚠️ **本函数是无状态逐帧投影**:`reasoning_end`(S-310 的推理权威段)不在这里 —— 它要按句柄攒段,
+ *  住在 {@link SubagentTailBus.onForwardFrame}(publish 侧是唯一知道句柄的地方)。 */
 export declare function projectTailFrame(e: Record<string, unknown> & {
     type?: string;
 }): SubagentTailFrame | null;
@@ -50,9 +52,33 @@ export declare class SubagentTailBus {
      * 不需要"先有内容帧"才能学到"没有内容帧"。
      */
     private readonly modeByHandle;
+    /**
+     * 句柄 → 该句柄这条 tail 流上**在攒的推理段**(S-310)。
+     *
+     * 键必须是句柄,理由与 {@link modeByHandle} 同源再加一条硬的:两个并发子代的 `reasoning_delta` 在
+     * **同一个** forward sink 上交错到达,一只累积器会把两份思考拼成一段、再盖上其中一个的身份键。
+     *
+     * 生命期 = **有人在听的那段时间**:攒段住在 `hasSubscribers` 快门之内(tail 是 live-only 面,没人听
+     * 就不投影也不攒),最后一个订阅者走掉或句柄终态({@link forgetHandle})时整条删掉 ⇒ 本表恒被
+     * 订阅者数量所界,不需要第二道容量闸。
+     */
+    private readonly segByHandle;
     /** 三条 run 腿的 forward 回调里逐帧调(在 `hasSubscribers` 快门**之前**——没人在听时也要学,
      *  否则晚开的 tail 永远读不到供给形)。同值重复写是 no-op(热路径只付一次 Map.get)。 */
     noteHandleContentMode(bgAgentId: string, mode: TailContentMode): void;
+    /**
+     * 🔴 **三条 run 腿的 forward 回调唯一入口**(S-310 收口)——登记供给形 → 段界收段 → 逐帧投影 → publish。
+     *
+     * 此前这四步以**同一段六行代码**抄在三条腿上(sync 流腿、verify-resume 腿、resume-stream 腿),
+     * 差别为零;S-310 要给 tail 面补 `reasoning_end` 时,那就是第四、第五、第六份拷贝。收成一扇门之后
+     * 腿上只剩「句柄在不在」这一句判断,三腿不可能再分家(`test/subagent-tail-stream.test.ts` G18-G20)。
+     *
+     * 顺序即语义:权威段**先于**触发它的结构帧上 wire(消费端「整段替换已攒 delta」的替换点不与卡片交错),
+     * 与账本腿「文本行先于结构行」逐字同构。
+     */
+    onForwardFrame(bgAgentId: string, mode: TailContentMode, e: Record<string, unknown> & {
+        type?: string;
+    }): void;
     /**
      * 句柄终态时**撤销**登记(三条腿的 `onTaskNotification` 观察者调,与 `task_settled` 帧同处)。
      *
@@ -69,7 +95,7 @@ export declare class SubagentTailBus {
      * 的答案。core 今天把终态通知排在最后一条 forward 之后(fleet-bus 同注),复活又是人手动作,这条窗
      * 实际上不可达;真要关死需要给句柄加墓碑态,代价大于一位诊断标签的收益,故不做。
      */
-    forgetHandleContentMode(bgAgentId: string): void;
+    forgetHandle(bgAgentId: string): void;
     /** 路由读(按 tail 的 target 句柄)。缺席 = 不知道,路由出 `"unknown"`。 */
     handleContentMode(bgAgentId: string): TailContentMode | undefined;
     /** 两条 run 腿的 fwdInternals 调用点:帧已投影(projectTailFrame),null 不进来。 */

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

@@ -1,5 +1,6 @@
 import { redactSecrets } from "../trace/redact.js";
 import { taskProgressEventData, toolStartEventData, toolEndEventData, textEndEventData } from "../trace/project.js";
+import { createReasoningSegments } from "../trace/model-segment.js";
 const TAIL_QUEUE_CAP = 512;
 export function projectTailFrame(e) {
     const t = e.type;
@@ -41,12 +42,31 @@ const HOST_MODE_CAP = 4096;
 export class SubagentTailBus {
     subs = new Map();
     modeByHandle = new Map();
+    segByHandle = new Map();
     noteHandleContentMode(bgAgentId, mode) {
         if (this.modeByHandle.get(bgAgentId) === mode)
             return;
         putBounded(this.modeByHandle, bgAgentId, mode);
     }
-    forgetHandleContentMode(bgAgentId) {
+    onForwardFrame(bgAgentId, mode, e) {
+        this.noteHandleContentMode(bgAgentId, mode);
+        if (!this.hasSubscribers(bgAgentId))
+            return;
+        let segs = this.segByHandle.get(bgAgentId);
+        if (segs === undefined) {
+            segs = createReasoningSegments();
+            this.segByHandle.set(bgAgentId, segs);
+        }
+        for (const end of segs.onEvent(e))
+            this.publish(bgAgentId, end);
+        const f = projectTailFrame(e);
+        if (f)
+            this.publish(bgAgentId, f);
+    }
+    forgetHandle(bgAgentId) {
+        for (const end of this.segByHandle.get(bgAgentId)?.cut() ?? [])
+            this.publish(bgAgentId, end);
+        this.segByHandle.delete(bgAgentId);
         this.modeByHandle.delete(bgAgentId);
     }
     handleContentMode(bgAgentId) {
@@ -84,8 +104,10 @@ export class SubagentTailBus {
             sub.closed = true;
             sub.wake?.();
             set.delete(sub);
-            if (set.size === 0 && this.subs.get(bgAgentId) === set)
+            if (set.size === 0 && this.subs.get(bgAgentId) === set) {
                 this.subs.delete(bgAgentId);
+                this.segByHandle.delete(bgAgentId);
+            }
         };
         const it = {
             [Symbol.asyncIterator]() {

package/dist/http/principal-gate.d.ts

@@ -44,6 +44,25 @@ export declare function principalTokenPresentedButUnverified(req: IncomingMessag
  * 调用链上的**证明三件套**,与本门(身份面)是两道门。
  */
 export declare function sendPrincipalRefusal(res: ServerResponse, req: IncomingMessage, config: ServiceConfig): void;
+/**
+ * 🔴 **「这个调用方读得到这一行 run 吗」的唯一谓词**(S-297 抽取;此前只活在 `server.ts runOwnerOk` 的
+ * 函数体里,而 `runOwnerOk` 把**判断**与**404 怎么发**焊在一起 —— 于是任何需要同一条判断但不想 404 的
+ * 读面(如 `/mcp` 面板的 `lastLegMcp`:非属主就不投这个键、面板照常 200)只能手抄一份,而手抄那份必然
+ * 漏掉下面这条窄互认臂:`explicitOperatorOk` 顶注已经为同族的病写过「SINGLE mint point,不要再造兄弟」)。
+ *
+ * 三条放行臂,别的一律不放:
+ *  · `owner === null` —— 无属主的行(dev / 存量),本来就是开放的;
+ *  · `principal === owner` —— 自己的行。⚠️ `principal` 必须是**验过**的身份(`gatedPrincipal`),
+ *    不是自述头 —— `owner` 是创建时从验过的 principal 落库的,拿自述头来比就等于谁都能读别人的 run;
+ *  · [ref] C8 **窄互认**:非 `requirePrincipal` 部署上那批 `anon:shell-live` 哨兵行 + 无身份的调用方
+ *    (cli 停发哨兵头后的存量会话,否则「能续跑但看不见」)。`gatedPrincipal` 的回值是 `string | undefined`
+ *    ⇒ 原文那半个 `principal === null` 比较结构上不可达,抽取时一并去掉(语义逐字不变)。
+ *
+ * **不含 operator 臂**(刻意,[ref]⑥ 台账):跨属主 operator 在 poll/events/cancel 三读面上今天就是 404,
+ * 放宽它是一次独立裁定。需要 operator 臂的读面在**自己的调用点**显式并上 {@link explicitOperatorOk} ——
+ * 那样「谁多给了 operator 一条路」在代码上看得见,而不是被偷偷塞进共享谓词里。
+ */
+export declare function runOwnerReadable(principal: string | undefined, owner: string | null, config: ServiceConfig): boolean;
 /** The EXPLICIT operator gate (IMAGE-API-DESIGN.md §P2.4a MUST-FIX) — NOT the bare `isOperator` (whose empty-list
  *  "true-for-all" is an unrestricted-write exec door the instant OPERATOR_PRINCIPALS is empty). Requires a non-empty
  *  operator set AND a present principal IN it. The same form the preempt/resume endpoints already use.

package/dist/http/principal-gate.js

@@ -65,6 +65,13 @@ export function sendPrincipalRefusal(res, req, config) {
     }
     sendError(res, 401, "auth.principal_required", `missing principal header '${config.principalHeader}'`);
 }
+export function runOwnerReadable(principal, owner, config) {
+    if (owner === null)
+        return true;
+    if (principal === owner)
+        return true;
+    return !config.requirePrincipal && owner === "anon:shell-live" && principal === undefined;
+}
 export function explicitOperatorOk(principal, operatorPrincipals) {
     return operatorPrincipals.length > 0 && principal !== undefined && operatorPrincipals.includes(principal);
 }

package/dist/http/routes/sessions.js

@@ -3,14 +3,16 @@ import { a2aForScenario, mcpForScenario } from "../../config-center/facade.js";
 import { isUuidV7, isUuidShape, legacyUnownedSessionOk } from "../../security.js";
 import { windowMessages, truncateMessageBlobs } from "../../audit.js";
 import { redactSecrets } from "../../trace/redact.js";
+import { recordFailOpen } from "../../observability/fail-open.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_PERMISSION_RULES, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS } from "../../task-settings.js";
 import { sendJson, sendError, sseHeaders } from "../send.js";
-import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { gatedPrincipal, explicitOperatorOk, runOwnerReadable, sendPrincipalRefusal } from "../principal-gate.js";
 const MCP_STATUS_TTL_MS = 5_000;
 const MCP_MATERIALIZE_TIMEOUT_MS = 10_000;
 const A2A_STATUS_TTL_MS = 5_000;
 const A2A_MATERIALIZE_TIMEOUT_MS = 10_000;
 const MEMORY_STATUS_TTL_MS = 5_000;
+const LAST_LEG_LEDGER_TIMEOUT_MS = 2_000;
 const A2A_PANEL_MAX_TOOL_NAMES = 200;
 export function createSessionsLocal() {
     return {
@@ -21,6 +23,44 @@ export function createSessionsLocal() {
         memoryStatusCache: new Map(),
     };
 }
+async function lastLegMcpFor(deps, sessionId, principal) {
+    let timer;
+    try {
+        return await Promise.race([
+            readLastLegMcp(deps, sessionId, principal),
+            new Promise((r) => { timer = setTimeout(() => { recordFailOpen("server.mcp-panel.last-leg-unreadable", `ledger read exceeded ${LAST_LEG_LEDGER_TIMEOUT_MS}ms`); r(undefined); }, LAST_LEG_LEDGER_TIMEOUT_MS); }),
+        ]);
+    }
+    catch (e) {
+        recordFailOpen("server.mcp-panel.last-leg-unreadable", e instanceof Error ? e.message : String(e ?? ""));
+        return undefined;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function readLastLegMcp(deps, sessionId, principal) {
+    const runStore = deps.runStore;
+    if (!runStore || sessionId === null)
+        return undefined;
+    const latest = await runStore.latestRunForSession(sessionId);
+    if (latest === undefined)
+        return undefined;
+    if (!runOwnerReadable(principal, latest.owner, deps.config) && !explicitOperatorOk(principal, deps.config.operatorPrincipals))
+        return undefined;
+    const events = await runStore.getEvents(latest.taskId, 0);
+    for (let i = events.length - 1; i >= 0; i--) {
+        const ev = events[i];
+        if (ev.type !== "wiring_manifest")
+            continue;
+        const mcp = ev.data?.mcp;
+        if (!Array.isArray(mcp))
+            return undefined;
+        return { runId: latest.taskId, at: ev.ts, mcp };
+    }
+    return undefined;
+}
 export async function handleSessions(req, res, url, ctx) {
     const miss = { fell: false };
     await handleSessionsBody(req, res, url, ctx, miss);
@@ -71,17 +111,18 @@ async function handleSessionsBody(req, res, url, ctx, miss) {
     {
         const mm = /^\/v1\/sessions\/([^/]+)\/mcp$/.exec(url);
         if (mm && req.method === "GET") {
-            if (deps.config.requirePrincipal && !gatedPrincipal(req, deps.config)) {
+            const principal = gatedPrincipal(req, deps.config);
+            if (deps.config.requirePrincipal && !principal) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
+            const lastLegMcp = await lastLegMcpFor(deps, safeDecode(mm[1]), principal);
             const specs = mcpForScenario(deps.config.mcpServers, deps.config.defaultScenario);
+            const cacheKey = `${deps.config.defaultScenario}::${principal ?? ""}`;
             if (!specs || specs.length === 0) {
-                sendJson(res, 200, { servers: [], asOf: new Date().toISOString() });
+                sendJson(res, 200, { servers: [], asOf: new Date().toISOString(), ...(lastLegMcp === undefined ? {} : { lastLegMcp }) });
                 return;
             }
-            const principal = gatedPrincipal(req, deps.config);
-            const cacheKey = `${deps.config.defaultScenario}::${principal ?? ""}`;
             const cached = mcpStatusCache.get(cacheKey);
             if (!cached || Date.now() - cached.at > MCP_STATUS_TTL_MS) {
                 if (mcpStatusCache.size > 1024)
@@ -114,7 +155,7 @@ async function handleSessionsBody(req, res, url, ctx, miss) {
                 })();
                 mcpStatusCache.set(cacheKey, { at: Date.now(), panel });
             }
-            sendJson(res, 200, await mcpStatusCache.get(cacheKey).panel);
+            sendJson(res, 200, { ...(await mcpStatusCache.get(cacheKey).panel), ...(lastLegMcp === undefined ? {} : { lastLegMcp }) });
             return;
         }
     }

package/dist/http/routes/tasks.js

@@ -4,7 +4,8 @@ import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, resumeAtHttpStat
 import { stripResumeToken } from "../../terminal.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../../fleet/fleet-bus.js";
-import { defaultSubagentTailBus, projectTailFrame } from "../../fleet/subagent-tail-bus.js";
+import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
+import { createReasoningSegments, reasoningStreamOfTask } from "../../trace/model-segment.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKey, NotifiedKeys } from "../../orchestration/workflow-completion-inbox.js";
 import { createLedgerSink } from "../../trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "../../trace/engine-notice-wire.js";
@@ -313,23 +314,21 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                     const streamBody = async () => {
                         await withPrincipal(principal, async () => {
                             const tailContentMode = prepared.spec.forwardSubagentEvents === true ? "on" : "progress_only";
+                            const childReasoning = createReasoningSegments();
+                            const topReasoning = createReasoningSegments();
                             const fwdInternals = {
                                 onForwardEvent: (e) => {
                                     fleetPub?.onForwardEvent(e);
                                     ledgerSink?.onForwardEvent(e);
                                     {
                                         const bg = e.bgAgentId;
-                                        if (bg !== undefined) {
-                                            defaultSubagentTailBus.noteHandleContentMode(bg, tailContentMode);
-                                            if (defaultSubagentTailBus.hasSubscribers(bg)) {
-                                                const f = projectTailFrame(e);
-                                                if (f)
-                                                    defaultSubagentTailBus.publish(bg, f);
-                                            }
-                                        }
+                                        if (bg !== undefined)
+                                            defaultSubagentTailBus.onForwardFrame(bg, tailContentMode, e);
                                     }
                                     if (res.writableEnded)
                                         return;
+                                    for (const end of childReasoning.onEvent(e))
+                                        sseData(res, end);
                                     const t = e.type;
                                     if (t === "task_progress") {
                                         sseData(res, { type: "task_progress", ...taskProgressEventData(e) });
@@ -359,7 +358,10 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                                 onTaskNotification: (n, opts) => {
                                     if (n.task_type === "workflow")
                                         return;
-                                    defaultSubagentTailBus.forgetHandleContentMode(n.task_id);
+                                    if (!res.writableEnded)
+                                        for (const end of childReasoning.cut(reasoningStreamOfTask(n.task_id, n.sessionId)))
+                                            sseData(res, end);
+                                    defaultSubagentTailBus.forgetHandle(n.task_id);
                                     if (defaultSubagentTailBus.hasSubscribers(n.task_id)) {
                                         defaultSubagentTailBus.publish(n.task_id, { type: "task_settled", taskId: n.task_id, status: n.status, ...(typeof n.seq === "number" ? { seq: n.seq } : {}), ...(n.summary ? { summary: redactSecrets(n.summary) } : {}) });
                                     }
@@ -393,6 +395,8 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                             for await (const ev of liveStream) {
                                 if (closed)
                                     break;
+                                for (const end of ev.type === "done" ? [...childReasoning.cut(), ...topReasoning.cut()] : topReasoning.onEvent(ev))
+                                    sseData(res, end);
                                 if (ev.type === "message_committed" && ev.role === "user")
                                     userMsgEntryId = ev.entryId;
                                 const cancelVerbAtDone = ev.type === "done" && durableTaskId !== undefined && cancelledViaVerb.has(durableTaskId);

package/dist/http/server.js

@@ -26,7 +26,7 @@ import { looksLikeJwt } from "@sema-agent/settings-schema/api/auth-bridge";
 import {} from "../orchestration/workflow-agent-steer.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKey, NotifiedKeys } from "../orchestration/workflow-completion-inbox.js";
 import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../fleet/fleet-bus.js";
-import { defaultSubagentTailBus, projectTailFrame } from "../fleet/subagent-tail-bus.js";
+import { defaultSubagentTailBus } from "../fleet/subagent-tail-bus.js";
 import { APPROVAL_GATE_KINDS, createApprovalCardEmitter, isApprovalGateKind, resolveApprovalLeg, resolveStreamApprovalGate } from "../tool-approval.js";
 import { buildCheckpointAnchorHash } from "../approval-ask-audit-store.js";
 import { TERMINAL_PARK_GATE_KINDS } from "../plugins/checkpoint-store-sql.js";
@@ -85,7 +85,7 @@ export { cascadeConfig };
 import { handleImages, createImagesLocal, coarseStatusForState, errorCodeForExit } from "./routes/images.js";
 export { coarseStatusForState, errorCodeForExit };
 import { sendJson, sendError, httpErrorCode, msg, isSseResponse } from "./send.js";
-import { authorized, systemFor, gatedPrincipal, explicitOperatorOk, isOperator, sendPrincipalRefusal } from "./principal-gate.js";
+import { authorized, systemFor, gatedPrincipal, explicitOperatorOk, isOperator, runOwnerReadable, sendPrincipalRefusal } from "./principal-gate.js";
 import { buildActiveRunConflict, resumeEntryForGate } from "./active-run-conflict.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../approval-content-kind.js";
 export { explicitOperatorOk, isOperator };
@@ -1453,14 +1453,8 @@ export function createHttpServer(rawDeps) {
                             fleetPub?.onForwardEvent(e);
                             {
                                 const bg = e.bgAgentId;
-                                if (bg !== undefined) {
-                                    defaultSubagentTailBus.noteHandleContentMode(bg, verifyTailContentMode);
-                                    if (defaultSubagentTailBus.hasSubscribers(bg)) {
-                                        const f = projectTailFrame(e);
-                                        if (f)
-                                            defaultSubagentTailBus.publish(bg, f);
-                                    }
-                                }
+                                if (bg !== undefined)
+                                    defaultSubagentTailBus.onForwardFrame(bg, verifyTailContentMode, e);
                             }
                             if (rsV && taskId)
                                 verifySink.onForwardEvent(e);
@@ -1474,7 +1468,7 @@ export function createHttpServer(rawDeps) {
                         onTaskNotification: (n, opts) => {
                             if (n.task_type === "workflow")
                                 return;
-                            defaultSubagentTailBus.forgetHandleContentMode(n.task_id);
+                            defaultSubagentTailBus.forgetHandle(n.task_id);
                             if (defaultSubagentTailBus.hasSubscribers(n.task_id)) {
                                 defaultSubagentTailBus.publish(n.task_id, { type: "task_settled", taskId: n.task_id, status: n.status, ...(typeof n.seq === "number" ? { seq: n.seq } : {}), ...(n.summary ? { summary: redactSecrets(n.summary) } : {}) });
                             }
@@ -1578,14 +1572,8 @@ export function createHttpServer(rawDeps) {
                             fleetPub?.onForwardEvent(e);
                             {
                                 const bg = e.bgAgentId;
-                                if (bg !== undefined) {
-                                    defaultSubagentTailBus.noteHandleContentMode(bg, tailContentMode);
-                                    if (defaultSubagentTailBus.hasSubscribers(bg)) {
-                                        const f = projectTailFrame(e);
-                                        if (f)
-                                            defaultSubagentTailBus.publish(bg, f);
-                                    }
-                                }
+                                if (bg !== undefined)
+                                    defaultSubagentTailBus.onForwardFrame(bg, tailContentMode, e);
                             }
                             if (!rs || !taskId)
                                 return;
@@ -1604,7 +1592,7 @@ export function createHttpServer(rawDeps) {
                         onTaskNotification: (n, opts) => {
                             if (n.task_type === "workflow")
                                 return;
-                            defaultSubagentTailBus.forgetHandleContentMode(n.task_id);
+                            defaultSubagentTailBus.forgetHandle(n.task_id);
                             if (defaultSubagentTailBus.hasSubscribers(n.task_id)) {
                                 defaultSubagentTailBus.publish(n.task_id, { type: "task_settled", taskId: n.task_id, status: n.status, ...(typeof n.seq === "number" ? { seq: n.seq } : {}), ...(n.summary ? { summary: redactSecrets(n.summary) } : {}) });
                             }
@@ -2334,8 +2322,7 @@ export function createHttpServer(rawDeps) {
             sendPrincipalRefusal(res, req, deps.config);
             return false;
         }
-        const legacyShellOwner = !deps.config.requirePrincipal && owner === "anon:shell-live" && (principal === undefined || principal === null);
-        if (!legacyShellOwner && owner !== null && principal !== owner) {
+        if (!runOwnerReadable(principal, owner, deps.config)) {
             if (notFoundForm === "session")
                 sendError(res, 404, "not_found.session", "session not found");
             else

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

@@ -13,6 +13,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "S-136 合并重扫确认项(`terminal.ts persistedPlaneOf`,持久 blob 的平面读面):盘上一条 `terminal` 因由形不合(`paused` 缺 gate / 词出闭集)让 core 的 `terminalProjection` 抛 ⇒ 本读面对这一行答**全格缺席**而不是整只 500。放行的最坏后果=一条坏行在列表/舰队读面上显示为无终局词;计数 + probe 带原句,便于按行回溯。";
     };
+    readonly "server.mcp-panel.last-leg-unreadable": {
+        readonly cls: "F";
+        readonly note: "S-297(`http/routes/sessions.ts lastLegMcpFor`,`/mcp` 面板的可选键 `lastLegMcp`):按会话取最近 run 的索引读 / 那条 run 的账本读**抛错或超期** ⇒ 该键缺席,面板本体照常 200。放行的最坏后果=这一屏少一格「上一次真挂上了什么」(壳退回翻账本),不是门、不是权限、不是凭证 —— 而反方向(让附加键的读失败打掉整张面板)会给一口此前零 MCP 配置下根本不碰账本的**既有**读面新加一条挂掉的理由。缺席本就是本键 wire 上的一等状态(消费端必须会读),所以这条兜底不产生任何新的消费端形态;计数让「某台部署的账本一直读不出来」显形。";
+    };
     readonly "server.workflow-park-index.sync-failed": {
         readonly cls: "P-DEBT";
         readonly note: "S-185 车CM(codex r1-F2 [high],验真后登记):workflow 出身 park 的 join 索引(`workflow_agent_session` / local 账本)在**一次成功的 run 写之后**同步失败 ⇒ 该次同步被吞,重试要等这条 run 的**下一次**写。而 park 恰好常常是这条 run 的**最后**一次写(park = run 终局 `failed`)⇒ 那条 park 可能永久 join 不到,`/decide` 结构性退回本批之前的行为(409 `conflict.resume_context_unavailable`)——**方向是 fail-closed**(不误配、不伪造、不放行任何东西),丢的是「人能不能把这条批准送出去」这个能力。归 P 类的理由是它决定**车道选择**(缺行 ⇒ 选中 legacy 腿),归 DEBT 的理由是真正的解要一条**按子代 checkpoint 键的耐久决议回执 + 重启期回填**(与 codex r1-F3 同一件欠账,另车)。计数非零 = 有 park 因此决不掉,运维要按 detail 里的 runId 去查。";

package/dist/observability/fail-open.js

@@ -4,6 +4,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-136 合并重扫确认项(`terminal.ts persistedPlaneOf`,持久 blob 的平面读面):盘上一条 `terminal` 因由形不合(`paused` 缺 gate / 词出闭集)让 core 的 `terminalProjection` 抛 ⇒ 本读面对这一行答**全格缺席**而不是整只 500。放行的最坏后果=一条坏行在列表/舰队读面上显示为无终局词;计数 + probe 带原句,便于按行回溯。",
     },
+    "server.mcp-panel.last-leg-unreadable": {
+        cls: "F",
+        note: "S-297(`http/routes/sessions.ts lastLegMcpFor`,`/mcp` 面板的可选键 `lastLegMcp`):按会话取最近 run 的索引读 / 那条 run 的账本读**抛错或超期** ⇒ 该键缺席,面板本体照常 200。放行的最坏后果=这一屏少一格「上一次真挂上了什么」(壳退回翻账本),不是门、不是权限、不是凭证 —— 而反方向(让附加键的读失败打掉整张面板)会给一口此前零 MCP 配置下根本不碰账本的**既有**读面新加一条挂掉的理由。缺席本就是本键 wire 上的一等状态(消费端必须会读),所以这条兜底不产生任何新的消费端形态;计数让「某台部署的账本一直读不出来」显形。",
+    },
     "server.workflow-park-index.sync-failed": {
         cls: "P-DEBT",
         note: "S-185 车CM(codex r1-F2 [high],验真后登记):workflow 出身 park 的 join 索引(`workflow_agent_session` / local 账本)在**一次成功的 run 写之后**同步失败 ⇒ 该次同步被吞,重试要等这条 run 的**下一次**写。而 park 恰好常常是这条 run 的**最后**一次写(park = run 终局 `failed`)⇒ 那条 park 可能永久 join 不到,`/decide` 结构性退回本批之前的行为(409 `conflict.resume_context_unavailable`)——**方向是 fail-closed**(不误配、不伪造、不放行任何东西),丢的是「人能不能把这条批准送出去」这个能力。归 P 类的理由是它决定**车道选择**(缺行 ⇒ 选中 legacy 腿),归 DEBT 的理由是真正的解要一条**按子代 checkpoint 键的耐久决议回执 + 重启期回填**(与 codex r1-F3 同一件欠账,另车)。计数非零 = 有 park 因此决不掉,运维要按 detail 里的 runId 去查。",

package/dist/parked-decide.js

@@ -208,7 +208,7 @@ export async function decideParkedAgent(deps, req, match) {
             return "retry";
         }
     };
-    defaultSubagentTailBus.forgetHandleContentMode(match.handle);
+    defaultSubagentTailBus.forgetHandle(match.handle);
     let receipt;
     try {
         receipt = await deps.reviveTool.execute(mintReviveArgs(row, deps.knownAgentTypes ?? new Set()), ctx);

package/dist/plugins/file-run-store.d.ts

@@ -1,6 +1,6 @@
 import { type UsageRow } from "../usage-analytics.js";
 import type { TaskStatus } from "@sema-agent/core";
-import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult } from "./store-contracts.js";
+import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult, LatestRunRef } from "./store-contracts.js";
 import type { RunStoreCheckpointProbe } from "./memory-run-store.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
 /**
@@ -127,6 +127,11 @@ export declare class FileRunStore {
         };
         limit: number;
     }): Promise<RunRecord[]>;
+    /**
+     * S-297 —— 这个会话**最近一条腿**的窄指针({@link SqlRunStore.latestRunForSession} 的孪生:同一个排序口径
+     *  `createdAt DESC, taskId DESC`,与本店 {@link FileRunStore.listSessions} 挑 `rn=1` 那一行的比较器逐字同一份)。
+     */
+    latestRunForSession(sessionId: string): Promise<LatestRunRef | undefined>;
     /** DISTINCT sessions newest-first by last activity (the CC /resume picker): latest run's preview/status + first/last/count. */
     listSessions(opts: {
         owner?: string;

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

@@ -443,6 +443,16 @@ export class FileRunStore {
             .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || (a.taskId < b.taskId ? 1 : a.taskId > b.taskId ? -1 : 0));
         return rows.slice(0, opts.limit).map((r) => this.toRecord(r));
     }
+    async latestRunForSession(sessionId) {
+        let latest;
+        for (const r of this.runs.values()) {
+            if (r.sessionId !== sessionId)
+                continue;
+            if (latest === undefined || r.createdAt.getTime() > latest.createdAt.getTime() || (r.createdAt.getTime() === latest.createdAt.getTime() && r.taskId > latest.taskId))
+                latest = r;
+        }
+        return latest === undefined ? undefined : { taskId: latest.taskId, owner: latest.owner, createdAt: latest.createdAt.toISOString() };
+    }
     async listSessions(opts) {
         const bySession = new Map();
         for (const r of this.runs.values()) {

package/dist/plugins/memory-run-store.d.ts

@@ -1,6 +1,6 @@
 import { type UsageRow } from "../usage-analytics.js";
 import type { TaskStatus } from "@sema-agent/core";
-import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult } from "./store-contracts.js";
+import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult, LatestRunRef } from "./store-contracts.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
 /**
  * [ref] P0 — the local lane's stand-in for the SQL twins' checkpoint-table JOIN. The file/memory run stores
@@ -76,6 +76,11 @@ export declare class MemoryRunStore {
         };
         limit: number;
     }): Promise<RunRecord[]>;
+    /**
+     * S-297 —— 这个会话**最近一条腿**的窄指针({@link SqlRunStore.latestRunForSession} 的孪生:同一个排序口径
+     *  `createdAt DESC, taskId DESC`,与本店 {@link MemoryRunStore.listSessions} 挑 `rn=1` 那一行的比较器逐字同一份)。
+     */
+    latestRunForSession(sessionId: string): Promise<LatestRunRef | undefined>;
     /** DISTINCT sessions newest-first by last activity (the CC /resume picker): latest run's preview/status + first/last/count. */
     listSessions(opts: {
         owner?: string;

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

@@ -190,6 +190,16 @@ export class MemoryRunStore {
             .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || (a.taskId < b.taskId ? 1 : a.taskId > b.taskId ? -1 : 0));
         return rows.slice(0, opts.limit).map((r) => this.toRecord(r));
     }
+    async latestRunForSession(sessionId) {
+        let latest;
+        for (const r of this.runs.values()) {
+            if (r.sessionId !== sessionId)
+                continue;
+            if (latest === undefined || r.createdAt.getTime() > latest.createdAt.getTime() || (r.createdAt.getTime() === latest.createdAt.getTime() && r.taskId > latest.taskId))
+                latest = r;
+        }
+        return latest === undefined ? undefined : { taskId: latest.taskId, owner: latest.owner, createdAt: latest.createdAt.toISOString() };
+    }
     async listSessions(opts) {
         const bySession = new Map();
         for (const r of this.runs.values()) {

package/dist/plugins/run-store-sql.d.ts

@@ -2,10 +2,10 @@ import type { TaskStatus } from "@sema-agent/core";
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type UsageRow } from "../usage-analytics.js";
-import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult } from "./store-contracts.js";
+import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult, LatestRunRef } from "./store-contracts.js";
 import { type SqlDriver } from "./sql-driver.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
-export type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
+export type { RunRecord, SessionSummary, RunEvent, LatestRunRef } from "./store-contracts.js";
 export declare class SqlRunStore {
     protected readonly db: SqlDriver;
     constructor(db: SqlDriver);
@@ -149,6 +149,17 @@ export declare class SqlRunStore {
         };
         limit: number;
     }): Promise<RunRecord[]>;
+    /**
+     * S-297 —— 这个会话**最近一条腿**的窄指针(`/mcp` 面板的 `lastLegMcp` 与任何「上一条 run 是谁」的读面共用)。
+     *
+     * 排序口径与 {@link listSessions} 的 `rn=1` 窗函数**逐字同一句**(`created_at DESC, task_id DESC`)——
+     * 两处答的是同一个问题「哪一条是最新的」,口径分叉会让列表面的 `lastRunId` 与本读口指向不同的 run。
+     * 走的也是同一条索引路径(`idx_task_run_session_status` 的 `session_id` 前缀),所以**不新加索引**:
+     * 会话内行数有界,前缀定位之后的排序只在这一小撮行上。
+     *
+     * 两方言只差占位符(动态子句为零,不像 listRuns/listSessions 那样需要各自的构造器臂)。
+     */
+    latestRunForSession(sessionId: string): Promise<LatestRunRef | undefined>;
     /** GET /v1/sessions (CC /resume picker): DISTINCT sessions newest-first by last activity, keyset-paginated on
      *  (last_activity, session_id). Aggregates task_run by session_id — one window pass picks the latest run per
      *  session (rn=1) for the preview/status and rolls up first/last/count. Owner-scoped when set (the per-user view).

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

@@ -252,6 +252,11 @@ export class SqlRunStore {
         const { rows } = await this.db.query(sql, params);
         return rows.map((r) => this.rowToRun(r));
     }
+    async latestRunForSession(sessionId) {
+        const { rows } = await this.db.query(this.q("SELECT task_id, owner, created_at FROM task_run WHERE session_id = ? ORDER BY created_at DESC, task_id DESC LIMIT 1", "SELECT task_id, owner, created_at FROM task_run WHERE session_id = $1 ORDER BY created_at DESC, task_id DESC LIMIT 1"), [sessionId]);
+        const r = rows[0];
+        return r === undefined ? undefined : { taskId: String(r.task_id), owner: r.owner ?? null, createdAt: iso(r.created_at) };
+    }
     async listSessions(opts) {
         if (this.db.dialect === "tidb") {
             const params = [];

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

@@ -244,6 +244,22 @@ export interface SessionSummary {
      *  titled OR the lister face has no session_meta (the legacy task_run aggregate / memory twins — honest degrade). */
     title: string | null;
 }
+/**
+ * S-297 —— 「这个会话**最近一条腿**是哪一条 run」的窄读面(`latestRunForSession` 的回值)。
+ *
+ * 刻意**不是** {@link RunRecord}:那一形携 `result` 整只 blob,而本读面的三个消费点(run 身份 / 属主门 /
+ * 排序口径的自证)一个都用不到它 —— 与 `listSessions` 只提标量 `lastTaskRunId` 而不拉 `result` 是同一条
+ * 判据([ref]:列表/指针面只拉标量,不把 blob 拖进按会话的高频读)。
+ *
+ * `owner` = 该 run 的**提交 principal**(可为 null = 无属主的存量行),消费点据它判「这条腿的读面该不该
+ * 投给当前调用方」;它与会话的 canonical owner 会分叉,判据与先例逐字见 `run-store-sql.ts deleteBySession`
+ * 的头注(F-A)。`createdAt` = 排序键(ISO),三孪生同一口径 `created_at DESC, task_id DESC`。
+ */
+export interface LatestRunRef {
+    taskId: string;
+    owner: string | null;
+    createdAt: string;
+}
 export interface RunEvent {
     seq: number;
     type: string;

package/dist/runs.js

@@ -10,7 +10,7 @@ import { recordTurnActivity } from "./turn-activity.js";
 import { CANCELLED_CODE, mintCancelledResult } from "./run-cancel-context.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";
+import { defaultSubagentTailBus } from "./fleet/subagent-tail-bus.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKey, NotifiedKeys } from "./orchestration/workflow-completion-inbox.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { errorText as errText } from "./observability/err-text.js";
@@ -275,19 +275,13 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     fleetPublisher?.onForwardEvent(e);
                     sink.onForwardEvent(e);
                     const bg = e.bgAgentId;
-                    if (bg !== undefined) {
-                        defaultSubagentTailBus.noteHandleContentMode(bg, tailContentMode);
-                        if (defaultSubagentTailBus.hasSubscribers(bg)) {
-                            const f = projectTailFrame(e);
-                            if (f)
-                                defaultSubagentTailBus.publish(bg, f);
-                        }
-                    }
+                    if (bg !== undefined)
+                        defaultSubagentTailBus.onForwardFrame(bg, tailContentMode, e);
                 },
                 onTaskNotification: (n, opts) => {
                     if (n.task_type === "workflow")
                         return;
-                    defaultSubagentTailBus.forgetHandleContentMode(n.task_id);
+                    defaultSubagentTailBus.forgetHandle(n.task_id);
                     if (defaultSubagentTailBus.hasSubscribers(n.task_id)) {
                         defaultSubagentTailBus.publish(n.task_id, { type: "task_settled", taskId: n.task_id, status: n.status, ...(typeof n.seq === "number" ? { seq: n.seq } : {}), ...(n.summary ? { summary: redactSecrets(n.summary) } : {}) });
                     }

package/dist/trace/ledger-sink.js

@@ -2,6 +2,7 @@ import { terminalProjection } from "@sema-agent/core";
 import { modelTextEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestEventData, toolRosterDeltaEventData, humanInputEventData, turnEndEventData, contextUsageEventData } from "./project.js";
 import { NotifiedKeys, taskNotificationStreamKey } from "../orchestration/workflow-completion-inbox.js";
 import { isParkLedgerEventType } from "./ledger-events.js";
+import { isModelSegmentBoundary } from "./model-segment.js";
 export function createSerialLedgerAppend(appendEvent, startSeq) {
     let seq = startSeq;
     let chain = Promise.resolve();
@@ -43,6 +44,8 @@ export function createLedgerSink(opts) {
     };
     const onEvent = async (ev) => {
         beat(ev.type);
+        if (isModelSegmentBoundary(ev.type))
+            await flush();
         switch (ev.type) {
             case "text_delta": {
                 const td = ev;
@@ -55,15 +58,12 @@ export function createLedgerSink(opts) {
                     reasoning += ev.delta;
                 break;
             case "tool_start":
-                await flush();
                 await append("tool_start", toolStartEventData(ev));
                 break;
             case "tool_end":
-                await flush();
                 await append("tool_end", toolEndEventData(ev));
                 break;
             case "status":
-                await flush();
                 {
                     const statusData = brainStatusEventData(ev);
                     beat("status", statusData);
@@ -71,49 +71,39 @@ export function createLedgerSink(opts) {
                 }
                 break;
             case "context_usage":
-                await flush();
                 await append("context_usage", contextUsageEventData(ev));
                 break;
             case "compacted":
-                await flush();
                 await append("compacted", compactedEventData(ev));
                 break;
             case "diagnostics":
-                await flush();
                 await append("diagnostics", diagnosticsEventData(ev));
                 break;
             case "steering_injected":
-                await flush();
                 await append("steering_injected", steeringInjectedEventData(ev));
                 break;
             case "compaction_outcome":
-                await flush();
                 await append("compaction_outcome", compactionOutcomeEventData(ev));
                 break;
             case "workspace_changed":
-                await flush();
                 await append("workspace_changed", workspaceChangedEventData(ev));
                 break;
             case "wiring_manifest":
-                await flush();
                 await append("wiring_manifest", wiringManifestEventData(ev));
                 break;
             case "tool_roster_delta": {
-                await flush();
                 const rosterDelta = toolRosterDeltaEventData(ev);
                 if (rosterDelta !== undefined)
                     await append("tool_roster_delta", rosterDelta);
                 break;
             }
             case "human_input":
-                await flush();
                 await append("human_input", humanInputEventData(ev));
                 break;
             case "task_progress":
                 await append("task_progress", taskProgressEventData(ev));
                 break;
             case "task_notification": {
-                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;
                 const tnPrior = tnKey !== undefined ? keys.get(tnKey) : undefined;
@@ -126,7 +116,6 @@ export function createLedgerSink(opts) {
                 break;
             }
             case "turn_end": {
-                await flush();
                 const usage = ev.usage;
                 await append("turn_end", turnEndEventData(ev));
                 textEventId = undefined;

package/dist/trace/model-segment.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 本帧是不是模型文本的段界。**四条消费腿共用这一只**:账本投影 switch(`trace/ledger-sink.ts`)、
+ * 顶层 live 流与转发子代腿(`http/routes/tasks.ts`)、子代 tail 面(`fleet/subagent-tail-bus.ts`)。
+ * 未知/未来词一律 `false` —— 不是兜底,是上面三道钉保证「未知词不存在」之后剩下的诚实答案
+ * (第三方 Runner 塞进来的野帧不该切走宿主的权威段)。
+ */
+export declare function isModelSegmentBoundary(type: string): boolean;
+/** live 面的段末帧(`type` 即事件名;其余键由 `reasoningEndEventData` 白名单铸出)。 */
+export type ReasoningEndFrame = Record<string, unknown> & {
+    type: "reasoning_end";
+};
+/** 登记册**读到的全部字段**,逐个写出来(不是 `Record<string, unknown>`):`TaskEvent` 与转发腿的原始帧
+ *  都结构性满足它,于是调用点一个宽断言都不必写;将来有人想读第七个键,得先在这里加一行。 */
+export interface ReasoningStreamEvent {
+    type?: string;
+    delta?: unknown;
+    eventId?: unknown;
+    parentToolCallId?: unknown;
+    sourceTaskId?: unknown;
+    bgAgentId?: unknown;
+}
+/** 一条**流**的身份(不含 `eventId`:core 给每个内容事件铸各自的 eventId,拿它当流身份会把每块 delta
+ *  切成一段)。三键都缺席 = 宿主自己的流。 */
+export interface ReasoningStreamIdent {
+    parentToolCallId?: string;
+    sourceTaskId?: string;
+    bgAgentId?: string;
+}
+/**
+ * 一条 live 腿上**按流身份分账**的 `reasoning` 段登记册。
+ *
+ * 🔴 **为什么是登记册而不是一只累积器**(codex 对抗复审 R1 两根 [high],亲跑复现后按类修):一条腿上
+ * 并发子代的 `reasoning_delta` 是**交错**到达的。一只累积器只有两种活法,两条都错:
+ *  · 「换身份就收段」⇒ A 说一半、B 插一句、A 说另一半 ⇒ A 被切成两枚权威段,**跨块的凭据正好落在切口上**
+ *    ——本帧存在的唯一理由当场失效(实测:两枚 `reasoning_end` 拼起来仍是明文密钥);
+ *  · 「不换就不收」⇒ 两个子代的思考拼成一段,再盖上其中一个的身份键(串味 + 冤枉归属)。
+ * 分账之后规则反而**更少**:一条流的段,只被**它自己**的段界或**它自己**的终态收走;别人说什么都与它无关。
+ *
+ * 状态的界:每条流的条目在它的首块 delta 上建、在收段时删;腿终局 {@link ReasoningSegments.cut} 不带
+ * 匹配器 = 全收全删。子代终态那一次带匹配器的收段(转发腿的 `onTaskNotification`)是让**活着的子代数**
+ * 而不是「这条 run 一共派过多少子代」成为上界的那一手。
+ */
+export interface ReasoningSegments {
+    /** 喂一帧 → 本帧收走的段末帧(0 或 1 枚,且**只可能是本帧自己那条流**的段)。返回数组只为让调用点
+     *  与 {@link cut} 同形(`for (const f of …) send(f)`),不是「一帧可能收多段」。 */
+    onEvent(ev: ReasoningStreamEvent): ReasoningEndFrame[];
+    /** 收段:`match` 缺省 = 本腿**全部**流(腿终局 / 句柄终态);给了就只收匹配的那几条(某个子代终态)。
+     *  与账本腿 `LedgerSink.onDone → flush()` 同位同义 —— 段界表里没有终局词,终局走这扇门。 */
+    cut(match?: (ident: ReasoningStreamIdent) => boolean): ReasoningEndFrame[];
+}
+/** 「这条流属于这些子代 id 之一」—— 子代终态收段的匹配器(`task_id` 与 `sessionId` 是同一个子代的两个
+ *  id 域,取并集;`undefined` 成员自动忽略)。腿上共用这一只,免得各写一遍 id 域的并集。 */
+export declare function reasoningStreamOfTask(...ids: ReadonlyArray<string | undefined>): (ident: ReasoningStreamIdent) => boolean;
+export declare function createReasoningSegments(): ReasoningSegments;
+//# sourceMappingURL=model-segment.d.ts.map

package/dist/trace/model-segment.js

@@ -0,0 +1,58 @@
+import { reasoningEndEventData } from "./project.js";
+const BOUNDARY = new Set([
+    "tool_start", "tool_end", "status", "context_usage", "compacted", "diagnostics",
+    "steering_injected", "compaction_outcome", "workspace_changed", "wiring_manifest",
+    "tool_roster_delta", "human_input", "task_notification", "turn_end",
+]);
+export function isModelSegmentBoundary(type) {
+    return BOUNDARY.has(type);
+}
+export function reasoningStreamOfTask(...ids) {
+    const set = new Set(ids.filter((v) => typeof v === "string" && v !== ""));
+    return (ident) => (ident.sourceTaskId !== undefined && set.has(ident.sourceTaskId)) || (ident.bgAgentId !== undefined && set.has(ident.bgAgentId));
+}
+function streamKeyOf(ident) {
+    return `${ident.parentToolCallId ?? ""}\u0000${ident.sourceTaskId ?? ""}\u0000${ident.bgAgentId ?? ""}`;
+}
+function identOf(ev) {
+    const s = (v) => (typeof v === "string" ? v : undefined);
+    return { parentToolCallId: s(ev.parentToolCallId), sourceTaskId: s(ev.sourceTaskId), bgAgentId: s(ev.bgAgentId) };
+}
+export function createReasoningSegments() {
+    const open = new Map();
+    const cutKey = (key) => {
+        const seg = open.get(key);
+        if (seg === undefined)
+            return [];
+        open.delete(key);
+        const data = reasoningEndEventData({ ...seg.ident, eventId: seg.eventId, content: seg.buf });
+        return data === null ? [] : [{ type: "reasoning_end", ...data }];
+    };
+    return {
+        onEvent: (ev) => {
+            if (ev.type === "reasoning_delta") {
+                if (typeof ev.delta !== "string" || ev.delta === "")
+                    return [];
+                const ident = identOf(ev);
+                const key = streamKeyOf(ident);
+                const seg = open.get(key);
+                if (seg === undefined)
+                    open.set(key, { ident, eventId: ev.eventId, buf: ev.delta });
+                else
+                    seg.buf += ev.delta;
+                return [];
+            }
+            return isModelSegmentBoundary(ev.type ?? "") ? cutKey(streamKeyOf(identOf(ev))) : [];
+        },
+        cut: (match) => {
+            const out = [];
+            for (const [key, seg] of [...open]) {
+                if (match !== undefined && !match(seg.ident))
+                    continue;
+                out.push(...cutKey(key));
+            }
+            return out;
+        },
+    };
+}
+//# sourceMappingURL=model-segment.js.map

package/dist/trace/project.d.ts

@@ -194,6 +194,23 @@ export declare function screenedStoredEventData(type: string, data: unknown): un
  *  坏形(content 非串/空串)⇒ null(丢帧,不铸「权威空段」:core 契约明言空段不发本帧,消费端收到空段会清掉已攒 delta)。
  *  身份四键零字节变换(live 现状带全四键,消费端可能已依赖)。 */
 export declare function textEndEventData(ev: Record<string, unknown>): Record<string, unknown> | null;
+/**
+ * `reasoning_end` 段末帧的**唯一**铸点(三条 live 腿共用:top stream / 转发子代腿 / 子代 tail 面)——
+ * `text_end` 的推理面孪生({@link textEndEventData}),形逐字同(共用 {@link segmentEndFields})。
+ *
+ * 🔴 **本帧由 server 自铸,core 不发**(`TaskEvent` 上只有 `reasoning_delta`)。`content` = 该段
+ * `reasoning_delta` 的累积原文,经与 durable 面**同一只** `redactModelText` —— 这正是本帧存在的理由:
+ * 逐 chunk 的 `reasoning_delta` 对**跨 chunk** 的凭据形无能为力(半截 `sk-` 在任何一块里都不成形),
+ * 而账本腿攒到 flush 边界的那一整段早就脱得干净;live 面此前没有这份权威副本,壳无可替换。
+ * 段界与账本腿**同一只谓词**(`trace/model-segment.ts` 的 `isModelSegmentBoundary`),所以同一次运行里
+ * 「账本 `reasoning` 行」与本帧的正文逐字节相等。
+ *
+ * **空段不发**,判据比 `text_end` 宽一格(那边是 core 契约的「空段不发」,只需判空串):本帧的正文由
+ * 本仓攒出,一段**全空白**的思考(模型吐了几个换行就去调工具)没有可替换的权威正文,而消费律是
+ * 「整段替换已攒的 delta」—— 发一枚空白权威段 = 让消费端把已渲染的思考清成空白。坏形(`content` 非串)
+ * 同样丢帧,理由与 `text_end` 逐字同源。
+ */
+export declare function reasoningEndEventData(ev: Record<string, unknown>): Record<string, unknown> | null;
 /** The durable `tool_end` payload (shared by both append sites). E1: the model-facing `output` is UNTRUSTED RAW
  *  from core (file/shell/API bodies) — core only SIZE-bounds it (`truncated`), REDACTION is ours (same contract as
  *  `tool_start.args`); never re-fed to a model. E2: identity. Absent `output` ⇒ the tool produced no content body.

package/dist/trace/project.js

@@ -176,14 +176,22 @@ function projectSettlement(st) {
 export function textEndEventData(ev) {
     if (typeof ev.content !== "string" || ev.content.length === 0)
         return null;
+    return segmentEndFields(ev.content, ev);
+}
+function segmentEndFields(content, ev) {
     return {
-        content: redactModelText(ev.content),
+        content: redactModelText(content),
         ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
         ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
         ...(ev.sourceTaskId !== undefined ? { sourceTaskId: ev.sourceTaskId } : {}),
         ...(ev.bgAgentId !== undefined ? { bgAgentId: ev.bgAgentId } : {}),
     };
 }
+export function reasoningEndEventData(ev) {
+    if (typeof ev.content !== "string" || ev.content.trim().length === 0)
+        return null;
+    return segmentEndFields(ev.content, ev);
+}
 export function toolEndEventData(ev) {
     const gate = ev.gate === undefined ? undefined : screenedGate(ev.gate);
     return {

package/dist/trace/redact.js

@@ -358,7 +358,7 @@ const SHAPE_SECRET_PATTERNS = [
     [new RegExp(String.raw `xapp-\d-${atLeast("[A-Za-z0-9-]", 20)}`, "g"), "«redacted:slack-token»"],
     [valueArm("sk-", "[A-Za-z0-9_-]", 16, "self-evident"), "«redacted:key»"],
 ];
-const FULL_SECRET_PATTERNS = [...STRUCTURAL_SECRET_PATTERNS, ...KEYWORD_SECRET_PATTERNS, ...SHAPE_SECRET_PATTERNS];
+const FULL_ARM_PATTERNS = [...STRUCTURAL_SECRET_PATTERNS, ...KEYWORD_SECRET_PATTERNS, ...SHAPE_SECRET_PATTERNS];
 const PEM_HEADER_IDENT_MAX = 31;
 const PEM_BODY_RUN_MIN = 8;
 const isSepCode = (c) => c === CH_SPACE || c === CH_TAB || c === CH_CR || c === CH_LF;
@@ -743,7 +743,7 @@ const FRAGMENT_SECRET_PATTERNS = [
     [valueArm("(?:gl(?:pat|dt|rt|rtr|cbt|ptt|oas|ft|imt|agent|wt|soat|ffct)-|(?:sk|rk)_(?:live|test|org)_|pypi-)", "[A-Za-z0-9_-]", 8, "needs-left-boundary"), "«redacted:key:partial»"],
     [valueArm("xapp-\\d-", "[A-Za-z0-9-]", 4, "needs-left-boundary"), "«redacted:slack-token:partial»"],
 ];
-const REDACTION_TOKENS = new Set([...FULL_SECRET_PATTERNS.map(([, r]) => r), PEM_FRAGMENT_TOKEN, ...FRAGMENT_SECRET_PATTERNS.map(([, r]) => r)]
+const REDACTION_TOKENS = new Set([...FULL_ARM_PATTERNS.map(([, r]) => r), PEM_FRAGMENT_TOKEN, ...FRAGMENT_SECRET_PATTERNS.map(([, r]) => r)]
     .flatMap((r) => r.match(/«[^»]*»/g) ?? []));
 const REDACTION_TOKEN_MAX = Math.max(...[...REDACTION_TOKENS].map((t) => t.length));
 {
@@ -802,9 +802,9 @@ const regexRule = ([re, repl]) => {
     return { run: (text, wantCount) => singleHit(label, arm, applyOnce(text, wantCount)) };
 };
 const URL_USERINFO_PATTERN = (() => {
-    const row = FULL_SECRET_PATTERNS.find(([, repl]) => repl.endsWith("»@"));
+    const row = FULL_ARM_PATTERNS.find(([, repl]) => repl.endsWith("»@"));
     if (row === undefined)
-        throw new Error("redact: URL-userinfo rule missing from FULL_SECRET_PATTERNS");
+        throw new Error("redact: URL-userinfo rule missing from FULL_ARM_PATTERNS");
     return row;
 })();
 const isRegexSpace = (c) => c === 32 || (c >= 9 && c <= 13) || c === 0xa0 || c === 0x1680 || (c >= 0x2000 && c <= 0x200a) || c === 0x2028 || c === 0x2029 || c === 0x202f || c === 0x205f || c === 0x3000 || c === 0xfeff;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.76.2",
+  "version": "7.77.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",