@sema-agent/server 7.76.1 → 7.77.0

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/tool-approval.js

@@ -2,7 +2,7 @@ import { contentKindOf } from "./approval-content-kind.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { uuidv7, MAX_RULE_TEXT_CHARS, parseRuleText, pathConfinableWriteToolNames } from "@sema-agent/core";
 import { precheckCardRuleText } from "./rules-consent.js";
-import { normalizeForRedaction, redactDeep, redactSecrets } from "./trace/redact.js";
+import { redactDeep, redactSecrets, redactSecretsWithArms } from "./trace/redact.js";
 import { hasBidiControls } from "./text-bidi.js";
 import { approvalPayloadFingerprint } from "./plugins/approval-payload-fingerprint.js";
 import { createLogger } from "./observability/logger.js";
@@ -32,7 +32,7 @@ const DEFAULT_PARK_TOMBSTONE_TTL_MS = 60 * 60_000;
 const DEFAULT_PARK_TOMBSTONE_PER_PRINCIPAL_MAX = 128;
 const PARKING_RETRY_AFTER_MS = 250;
 function ruleMaterialCarriesCredentialShape(command) {
-    return redactSecrets(command, { observe: false }) !== normalizeForRedaction(command);
+    return redactSecretsWithArms(command, { observe: false }).arms.has("full");
 }
 function durableRuleMaterial(material) {
     if (material === undefined)

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.d.ts

@@ -69,7 +69,9 @@ export declare function resetPpkScanBytesForTest(): void;
  *  core [ref] 落地后这一支**趋零是证据、不归零不是证明**。别把它当截断事实的度量用。 */
 export type RedactionArm = "full" | "fragment";
 export interface RedactionHitMeta {
-    /** `"fragment"` = {@link FRAGMENT_SECRET_PATTERNS} 里的前缀残片臂;`"full"` = 完整臂。闭集两词。 */
+    /** 命中臂的**判别力档位**(闭集两词,S-303):`"fragment"` = {@link FRAGMENT_SECRET_PATTERNS} 那一族
+     *  「短前缀 + 长度/熵阈值」的弱证据臂;`"full"` = 其余全部(结构锚 / 词法关键字 / 定长裸形)。
+     *  判据 = 表归属,不是 token 的 `:partial` 后缀 —— 两条轴的分家逐字见 {@link armOfToken}。 */
     arm: RedactionArm;
 }
 export declare function setRedactionObserver(fn: ((patternLabel: string, count: number, meta: RedactionHitMeta) => void) | undefined): void;
@@ -77,6 +79,26 @@ export declare function redactSecrets(text: string, opts?: {
     observe?: boolean;
     json?: boolean;
 }): string;
+/**
+ * 脱敏 + **这一遍命中了哪些档位的臂**({@link RedactionArm} 闭集两词)—— 与 {@link redactSecrets} 同一只
+ * 脱敏器、同一张表、同一遍扫描的另一个出口。
+ *
+ * 🔴 **为什么要这个出口**(S-303):下游有一类消费方问的不是「脱完长什么样」而是「这段文本里有没有
+ * **强证据**的凭据形」——`tool-approval.ts` 的规则素材闸是头一个。旧形只能拿「字节变了没有」当谓词,
+ * 于是弱证据臂(短前缀 + 阈值启发式)的一次多脱就等于一次「素材整只扣下」,用户拿不到常驻放行。
+ * 出口开在脱敏器**自己**身上是硬约束:全仓只该有一个「什么算凭据」的属主,消费方**不许**按 token 字面
+ * (`includes(":partial»")`)或另跑一遍正则去反推 —— 那就是第二只脱敏器。
+ *
+ * `arms` 是**这一遍真命中的档位集合**:空集 = 一条臂都没命中(文本可能仍被归一化剥了 `\p{Cf}`,
+ * 所以「`text !== 入参`」与「`arms` 非空」不是一回事,后者才是凭据形的证据)。
+ */
+export declare function redactSecretsWithArms(text: string, opts?: {
+    observe?: boolean;
+    json?: boolean;
+}): {
+    text: string;
+    arms: ReadonlySet<RedactionArm>;
+};
 /**
  * 🔴 环 + 深度预算(2026-07-25 补)。原实现是纯递归、**既不记已访问节点也不限深度**,而它的调用位置是
  * **最不可信的边界**:`toolStart`/`toolEnd` 把工具的 `args`/`output`/`structured` 直接喂进来。后果两条:

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));
 {
@@ -761,7 +761,20 @@ function redactionTokenEndAt(s, p, limit) {
     return 0;
 }
 const labelOfToken = (token) => token.replace(/[«»]/g, "").replace(/^redacted:/, "");
-const armOfToken = (repl) => (repl.match(/«[^»]*»/g) ?? [repl]).some((t) => t.endsWith(":partial»")) ? "fragment" : "full";
+const FRAGMENT_ARM_TOKENS = new Set(FRAGMENT_SECRET_PATTERNS.map(([, repl]) => repl));
+{
+    const partialSuffix = ":partial»";
+    const hasPartialToken = (repl) => (repl.match(/«[^»]*»/g) ?? [repl]).some((t) => t.endsWith(partialSuffix));
+    for (const [, repl] of FRAGMENT_SECRET_PATTERNS) {
+        if (!hasPartialToken(repl))
+            throw new Error(`redact: fragment-arm replacement ${JSON.stringify(repl)} must end with ${partialSuffix}`);
+    }
+    for (const [, repl] of [...STRUCTURAL_SECRET_PATTERNS, ...KEYWORD_SECRET_PATTERNS, ...SHAPE_SECRET_PATTERNS]) {
+        if (hasPartialToken(repl))
+            throw new Error(`redact: strong-arm replacement ${JSON.stringify(repl)} must not end with ${partialSuffix}`);
+    }
+}
+const armOfToken = (repl) => (FRAGMENT_ARM_TOKENS.has(repl) ? "fragment" : "full");
 const NO_HITS = [];
 const singleHit = (label, arm, r) => r.count > 0 ? { out: r.out, hits: [{ label, count: r.count, arm }] } : { out: r.out, hits: NO_HITS };
 const regexRule = ([re, repl]) => {
@@ -789,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;
@@ -1021,10 +1034,24 @@ const armPoolRule = (() => {
             const out = applySpans(text, kept).out;
             if (!wantCount || kept.length === 0)
                 return { out, hits: NO_HITS };
-            const byToken = new Map();
-            for (const sp of kept)
-                byToken.set(sp.repl, (byToken.get(sp.repl) ?? 0) + 1);
-            return { out, hits: [...byToken].map(([token, count]) => ({ label: labelOfToken(token), count, arm: armOfToken(token) })) };
+            const strong = spans.filter((sp) => armOfToken(sp.repl) === "full").sort((a, b) => a.start - b.start);
+            const byArmedToken = new Map();
+            let si = 0;
+            let strongMaxEnd = -1;
+            for (const sp of kept) {
+                while (si < strong.length && strong[si].start < sp.end) {
+                    strongMaxEnd = Math.max(strongMaxEnd, strong[si].end);
+                    si += 1;
+                }
+                const arm = strongMaxEnd > sp.start ? "full" : armOfToken(sp.repl);
+                const key = `${sp.repl}\u0000${arm}`;
+                const cur = byArmedToken.get(key);
+                if (cur === undefined)
+                    byArmedToken.set(key, { token: sp.repl, arm, count: 1 });
+                else
+                    cur.count += 1;
+            }
+            return { out, hits: [...byArmedToken.values()].map(({ token, arm, count }) => ({ label: labelOfToken(token), count, arm })) };
         },
     };
 })();
@@ -1063,13 +1090,20 @@ function reportHits(hits) {
         }
     }
 }
-export function redactSecrets(text, opts) {
-    const wantCount = onRedaction !== undefined && (opts?.observe ?? true);
-    const json = opts?.json === true;
-    const r = applyRules(normalizeForRedaction(text), wantCount, json, opts?.observe ?? true);
+function runRedaction(text, observe, json, wantHits) {
+    const wantCount = wantHits || (onRedaction !== undefined && observe);
+    const r = applyRules(normalizeForRedaction(text), wantCount, json, observe);
     forgetEscapedSeparatorTails();
-    reportHits(r.hits);
-    return r.out;
+    if (observe)
+        reportHits(r.hits);
+    return { text: r.out, hits: r.hits };
+}
+export function redactSecrets(text, opts) {
+    return runRedaction(text, opts?.observe ?? true, opts?.json === true, false).text;
+}
+export function redactSecretsWithArms(text, opts) {
+    const r = runRedaction(text, opts?.observe ?? true, opts?.json === true, true);
+    return { text: r.text, arms: new Set(r.hits.map((h) => h.arm)) };
 }
 const REDACT_MAX_DEPTH = 64;
 export function redactDeep(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.76.1",
+  "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",