@sema-agent/server 7.147.0 → 7.148.0

package/dist/trace/project.d.ts

@@ -24,6 +24,7 @@
  * 新加一只构造器 ⇒ 同批往登记表加一行,否则普查格红。
  */
 import type { GateOutcome, McpDelivered, TaskResult, SystemInjectionPriority } from "@sema-agent/core";
+import { type InputAuthor, type RunOrigin } from "@sema-agent/core";
 import type { RunEvent, RunRecord } from "../plugins/store-contracts.js";
 import type { ModelUsageDelta, ModelUsageTracker, PromptManifestTracker } from "../budget.js";
 import { type SafeText } from "./exit-seat.js";
@@ -104,7 +105,7 @@ export declare function aggregateModelUsage(events: RunEvent[]): Record<string,
 export type TraceBlock = {
     type: "thinking";
     text: string;
-} | {
+} | ({
     type: "tool-call";
     id: string;
     name: string;
@@ -112,12 +113,10 @@ export type TraceBlock = {
     input: unknown;
     recovered?: true;
     requestedBy?: ExtensionRequesterFace;
-    eventId?: string;
-    parentToolCallId?: string;
-} | {
+} & EventIdentity) | {
     type: "content";
     text: string;
-} | {
+} | ({
     type: "tool-result";
     callId: string;
     label?: string;
@@ -135,12 +134,40 @@ export type TraceBlock = {
     answeredBy?: string;
     requestedBy?: ExtensionRequesterFace;
     rewrite?: ToolInputRewriteFace;
-    eventId?: string;
-    parentToolCallId?: string;
-} | {
+} & EventIdentity) | {
     type: "prompt-assembled";
     readonly [member: string]: unknown;
 };
+/**
+ * 内容帧的**身份**(core `TaskEventIdentity` 全集,四键)—— 引擎盖在每只内容帧上的那组键,本仓只有**这一只**投影:每只共享构造器都经它,
+ * live 帧、durable 账本行、trace 读投影(turns 面 / trace SSE 面)于是是同一组键,引擎盖了哪几枚就上哪几枚。
+ *  · `eventId` —— 引擎逐帧铸的 uuidv7(去重句柄 / 回卷锚;live 腿 SSE `id:` 行的唯一来源);
+ *  · `parentToolCallId` —— 委派子代的帧才有(这段属于哪一次委派调用);
+ *  · `sourceTaskId` —— 作为子代跑的任务的内容帧才有(起跑那只任务的 id,消费方按它把子代的帧归到子代);
+ *  · `bgAgentId` —— 后台子代经宿主转发道上来的帧才有(`a*` 句柄;嵌套时是最外层那一只)。
+ * 值判据一条({@link identityKey}:非空 `string` 才上 wire,绝不强转)。
+ *
+ * 🔴 **型必须说得出口**([ref]):`eventId` 是续流游标的来源 —— 一个连值的型都说不出的键不许铸成游标。非串 / 空串 ⇒ 键缺席(与「无锚不发 `id:` 行」
+ * 同一条纪律:不可锚的位置绝不伪装成可锚)。转发子代腿的帧是 UNTRUSTED RAW(§E1),这一道同时是它的形判门。
+ * [ref] 门①:条件展开的臂逐条是直写字面量(键名对扫描器可见)。
+ */
+export declare function identityFields(src: {
+    eventId?: unknown;
+    parentToolCallId?: unknown;
+    sourceTaskId?: unknown;
+    bgAgentId?: unknown;
+}): EventIdentity;
+/**
+ * {@link identityFields} 的形。🔴 **`type` 而不是 `interface`**(它与 {@link SegmentEndFields} 两处都是,别改回去):TS 只给**类型别名**
+ * 隐式索引签名,interface 没有 ⇒ 写成 interface 的话,每一个把本形交给 `Record<string, unknown>` 形参(tail 总线帧、live 帧写口)的调用点
+ * 都得手抄一次 `{ ...frame }` 展开。别名让「声明出来的形」原样流经既有写口,零调用点噪声。
+ */
+export type EventIdentity = {
+    eventId?: string;
+    parentToolCallId?: string;
+    sourceTaskId?: string;
+    bgAgentId?: string;
+};
 /**
  * 🔴 **模型自由文本账本行(`text` / `reasoning`)的唯一载荷铸点**([ref] / [ref],7.75.1)。
  *
@@ -235,42 +262,13 @@ export declare function screenedStoredEventData(type: string, data: unknown): un
  *  逐块的 `text_delta` 由 `trace/model-segment.ts` 的登记册铸(7.143.0 起经同一只脱敏器的放行窗,一段的逐块拼接 = 本帧 content);
  *  本函数由登记册在段末调,三腿不再各自调。
  *  坏形(content 非串/空串)⇒ null(丢帧,不铸「权威空段」:core 契约明言空段不发本帧,消费端收到空段会清掉已攒 delta)。
- *  身份**四键**随行(live 现状带全四键,消费端可能已依赖);值经 {@link identityKey} —— 非空 string 才上 wire
- *  ([ref] 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
+ *  身份经 {@link identityFields}(与每只共享构造器同一只;[ref] 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
 export declare function textEndEventData(ev: Record<string, unknown>, before?: string): SegmentEndFields | null;
-/**
- * live 面的**身份四键**(core `TaskEventIdentity` 全集)—— 一个属主,两处共用({@link segmentEndFields}
- * 与 sync 腿白名单 catch-all 的 `ident`;此前是两份手抄)。与 durable 面的 {@link identityFields} 的差别
- * **只剩键集**:那边两键(durable builder 对另两键的既定排除),这边四键(live 现状,消费端已依赖);
- * **值判据是同一条** —— 两只都问 {@link identityKey}(非空 `string` 才上 wire,绝不强转)。
- *
- * 🔴 **型必须说得出口**([ref]):`eventId` 是 live 腿 SSE `id:` 行的**唯一**来源,而 `id:` 行是续流游标
- * ——一个连值的型都说不出的键不许铸成游标。非串/空串 ⇒ 键缺席(与「无锚不发 `id:` 行」同一条纪律:
- * 不可锚的位置绝不伪装成可锚)。转发子代腿的帧是 UNTRUSTED RAW(§E1),这一道同时是它的形判门。
- *
- * 🔴 **`type` 而不是 `interface`**(它与 {@link SegmentEndFields} 两处都是,别改回去):TS 只给**类型别名**
- * 隐式索引签名,interface 没有 ⇒ 写成 interface 的话,每一个把本形交给 `Record<string, unknown>` 形参
- * (tail 总线帧、live 帧写口)的调用点都得手抄一次 `{ ...frame }` 展开。别名让「声明出来的形」原样流经
- * 既有写口,零调用点噪声。
- */
-export type LiveEventIdentity = {
-    eventId?: string;
-    parentToolCallId?: string;
-    sourceTaskId?: string;
-    bgAgentId?: string;
-};
 /** 段末帧(`text_end` / `reasoning_end`)的载荷**形**(两只帧一个字节不差 —— 一个 wire 概念一份形,
  *  消费端的读法只学一次;差别只有各自铸点的空段判据)。 */
-export type SegmentEndFields = LiveEventIdentity & {
+export type SegmentEndFields = EventIdentity & {
     content: string;
 };
-/** {@link LiveEventIdentity} 的铸点。[ref] 门①:条件展开的臂逐条是直写字面量(键名对扫描器可见)。 */
-export declare function liveIdentityFields(ev: {
-    eventId?: unknown;
-    parentToolCallId?: unknown;
-    sourceTaskId?: unknown;
-    bgAgentId?: unknown;
-}): LiveEventIdentity;
 /**
  * `reasoning_end` 段末帧的**唯一**铸点(三条 live 腿共用:top stream / 转发子代腿 / 子代 tail 面)——
  * `text_end` 的推理面孪生({@link textEndEventData}),形逐字同(共用 {@link segmentEndFields})。
@@ -464,7 +462,7 @@ export declare function appendParkRow(append: AppendFn, usage: ModelUsageSeat |
  *    不是模型自由文本);`startedAt` 是有限数才上 wire;
  *  · `name` / `workflowAgentLabel` —— UNTRUSTED 展示文本 ⇒ `redactSecrets`(同 `task_progress.name` / `.workflowAgentLabel`);
  *  · `spawnName` —— 出生点校验过的队友**身份键** ⇒ verbatim(理由全文在 {@link taskProgressEventData} 的同名键注);
- *  · 身份两键经 `identityFields`(信封上的 `sourceTaskId` / `bgAgentId` 不由本族构造器投,见 `FRAME_ENVELOPE_KEYS`)。
+ *  · 身份经 `identityFields`(四键,引擎盖了哪枚上哪枚 —— 与每只共享构造器同一只)。
  * 缺席即缺席:可选键缺席不铸键(`taskType` 缺席 = 前台子代,禁读作某个默认种类;`seq` 缺席 = 无 `a*` 行,禁读作 cycle 1)。
  */
 export declare function taskStartedEventData(ev: {
@@ -661,7 +659,7 @@ export declare function compactionOutcomeEventData(ev: {
 }>;
 /**
  * `compaction_started`([ref],core 7.53.0 [ref])—— 一次压缩 pass 在提交点(触发闸过了、切点在、`preCompact` 没拦)宣告开始,先于摘要调用:
- * 一次在供应方重试表里等很久的摘要(core 实测 503 × 11、173 s)从此在流上不是静默的。**原样投影**:`{ trigger, pass, startedAt }` + 身份两键,
+ * 一次在供应方重试表里等很久的摘要(core 实测 503 × 11、173 s)从此在流上不是静默的。**原样投影**:`{ trigger, pass, startedAt }` + 身份(`identityFields`),
  * 不自铸相位、不铸 run / session id(那是流的,不是帧的键)。三键都是引擎铸的闭形值:`trigger` 闭集词(`auto` / `manual` / `forced`,与结束帧同一张词表)、
  * `pass` 不透明 id(结束这次 pass 的那一帧 —— `compacted` 或 `compaction_outcome` —— 带同一个 `pass`)、`startedAt` 引擎时钟 epoch 毫秒 ⇒ 不脱敏、逐字;
  * 形不合即缺席(与 {@link compactionOutcomeEventData} 同款守卫,不编值)。三条消费腿(live 帧、两条 durable 腿)共用这一只。
@@ -1004,6 +1002,14 @@ export declare function wiringManifestFaceEventData(ev: {
  *  · `rewrittenBy[]`(core 7.62.0 [ref],只在腿的 prompt 屏 `prompt.submit` 改写过这条输入时在场)—— 改写它的扩展注册名,按改写序 ⇒ verbatim:
  *    名字的形由引擎在注册入口判(`MOD_REGISTRATION_NAME`,能引号 / 括号 / 折句的名在入口拒),与会话行上同名位(`audit.ts` 的 `rewrittenBy: "verbatim"`)
  *    同一读法。非数组不投、非串 / 空串成员丢、丢完为空不铸键(缺席 = 原样送达,不是空数组)。
+ *  · `author` / `extension`(core 7.66.0 [ref]:**谁写的这条输入**,不是本人时才在场 —— `"extension"` = 扩展经 `$.prompt.submit` 交的提示,`"observer"` = 观察者的
+ *    报告;缺席 = 本人(或替本人转述的宿主),公共动词的每条输入)—— `author` 是 core 闭集 `INPUT_AUTHORS` 的词(`isInputAuthor` 判,`"operator"` 不在帧上)⇒ verbatim;
+ *    `extension` = 发起它的注册名(引擎只在 `author: "extension"` 旁铸)⇒ 过 {@link sanitizeWireText}(与 `tool_start.requestedBy.name` 同一只注册名出口纪律)。
+ *    不投它们 = 扩展 / 观察者的输入在 wire 上读成无署名的本人输入(core 的话:never render a non-operator input as the person's)。形不对 ⇒ 丢那一位、计一次
+ *    `server.trace.projection-input-malformed`(纯归因位的丢弃律,见 `extension-call-face.ts`);两键的配对是引擎的不变式,本仓不复判。
+ *  · `attachments[].declinedBy`(core 7.66.0 [ref]:拒了这只附件的 `prompt.mention` 扩展,`ExtensionRequester` 形)⇒ 与 `requestedBy` 同一只读法 {@link extensionRequesterOf}。
+ *  · `runOrigin`(core 7.58.0 [ref] / [ref]:这条输入由部署的调度器交来,闭集 `RUN_ORIGINS`;缺席 = 宿主什么也没说,**从不**读成「有人发的」)⇒ 引擎词、归因位、无自由文本 ⇒ 逐字,
+ *    读法 {@link runOriginOnFrame}(与 `wiring_manifest.leg.runOrigin` 的 {@link runOriginOnLeg} 同一只 core 谓词 `isRunOrigin`、各一处丢弃口;四面一条规则见 `test/run-origin-faces.test.ts` 头注)。不投 = 渲染方把调度者的输入当成人敲的(core 点名的病)。
  *
  * `actor` 逐键挑(禁 spread):core 已声明 `ActorAssertion` 是冻结三键形,但白名单的意义正是「core 加第
  * 四键时由人处置」——身份对象上多出来的键裸上线是本文件反复登记的病族。
@@ -1021,6 +1027,9 @@ export declare function humanInputEventData(ev: {
     entryId?: unknown;
     attachments?: unknown;
     rewrittenBy?: unknown;
+    author?: unknown;
+    extension?: unknown;
+    runOrigin?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
 }): FrameData<{
@@ -1031,7 +1040,11 @@ export declare function humanInputEventData(ev: {
     }>;
     attachments?: Array<FrameData<{
         label?: SafeText;
+        declinedBy?: ExtensionRequesterFace;
     }>>;
+    author?: Exclude<InputAuthor, "operator">;
+    extension?: string;
+    runOrigin?: RunOrigin;
 }>;
 /** S4 (SILENT-FALLBACK P0-a): the durable `brain_status` observation row, shared by the bg + resume append
  *  sites. core marks the live `status` frame EPHEMERAL (never replayed by core on resume) — this row is the
@@ -1164,7 +1177,7 @@ export declare function contextUsageEventData(ev: {
  * (白名单没跟上 core 新增字段)。补 builder 的同时也就把它纳入了 `wire-whitelist-exhaustiveness` 的编译期差集门。
  *
  * 🔴 **本构造器是 `turn_end` 帧载荷的唯一铸点**(core 7.29.0 提货批,车LY):三条腿同调 —— live SSE
- * (`http/routes/tasks.ts` 的 `/v1/tasks/stream` 臂,身份键另由 `liveIdentityFields` 补四键)、durable 账本
+ * (`http/routes/tasks.ts` 的 `/v1/tasks/stream` 臂)、durable 账本
  * (`ledger-sink.ts`)、resume 腿(`resume-legs.ts`)。live 臂此前是一份**手抄**的键集,于是 core 7.29.0 加的
  * `responseModel` 在 durable 面由这里补上以后,live 面仍会被那份手抄静默剥掉 —— 同一帧两条腿两套键集。
  *

package/dist/trace/project.js

@@ -1,5 +1,5 @@
 import { admitProviderEcho, redactErrorMessage, redactModelText } from "../observability/run-terminal.js";
-import { MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROLES, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
+import { isInputAuthor, isRunOrigin, MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROLES, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
 import { Value } from "typebox/value";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets, redactDeep } from "./redact.js";
@@ -92,10 +92,12 @@ export function aggregateModelUsage(events) {
             total[model].usageBasis = basis;
     return any ? total : undefined;
 }
-function identityFields(src) {
+export function identityFields(src) {
     return {
         ...(identityKey(src.eventId) !== undefined ? { eventId: identityKey(src.eventId) } : {}),
         ...(identityKey(src.parentToolCallId) !== undefined ? { parentToolCallId: identityKey(src.parentToolCallId) } : {}),
+        ...(identityKey(src.sourceTaskId) !== undefined ? { sourceTaskId: identityKey(src.sourceTaskId) } : {}),
+        ...(identityKey(src.bgAgentId) !== undefined ? { bgAgentId: identityKey(src.bgAgentId) } : {}),
     };
 }
 function identityKey(v) {
@@ -231,16 +233,8 @@ export function textEndEventData(ev, before = "") {
         return null;
     return segmentEndFields(ev.content, ev, before);
 }
-export function liveIdentityFields(ev) {
-    return {
-        ...(identityKey(ev.eventId) !== undefined ? { eventId: identityKey(ev.eventId) } : {}),
-        ...(identityKey(ev.parentToolCallId) !== undefined ? { parentToolCallId: identityKey(ev.parentToolCallId) } : {}),
-        ...(identityKey(ev.sourceTaskId) !== undefined ? { sourceTaskId: identityKey(ev.sourceTaskId) } : {}),
-        ...(identityKey(ev.bgAgentId) !== undefined ? { bgAgentId: identityKey(ev.bgAgentId) } : {}),
-    };
-}
 function segmentEndFields(content, ev, before = "") {
-    return { content: redactModelText(content, before), ...liveIdentityFields(ev) };
+    return { content: redactModelText(content, before), ...identityFields(ev) };
 }
 export function reasoningEndEventData(ev) {
     if (typeof ev.content !== "string" || ev.content.trim().length === 0)
@@ -394,7 +388,7 @@ export function taskNotificationEventData(ev) {
         ...(n.source !== undefined ? { source: seatText("trace-frame-text", n.source) } : {}),
         ...(n.exitCode !== undefined ? { exitCode: n.exitCode } : {}),
         ...(n.partial !== undefined ? { partial: n.partial } : {}),
-        ...(n.diagnostics !== undefined ? { diagnostics: seatText("trace-frame-text", n.diagnostics) } : {}),
+        ...(n.diagnostics !== undefined ? { diagnostics: seatText("completion-diagnostics-text", n.diagnostics) } : {}),
         ...(n.recentSteps !== undefined
             ? { recentSteps: n.recentSteps.map((s) => ({ tool: s.tool, target: seatText("trace-frame-text", s.target), outcome: seatText("trace-frame-text", s.outcome) })) }
             : {}),
@@ -533,6 +527,7 @@ export function wiringManifestEventData(ev, minted) {
     const sessionIn = sec(m.session) ?? {};
     const fleetIn = sec(m.fleet) ?? {};
     const legIn = sec(m.leg) ?? {};
+    const legRunOrigin = runOriginOnLeg(legIn.runOrigin);
     const interactionIn = sec(m.interaction) ?? {};
     const rulesIn = sec(m.permissionRules) ?? {};
     const ask = nonEmpty({
@@ -733,7 +728,7 @@ export function wiringManifestEventData(ev, minted) {
     })();
     return {
         ...(num(m.schemaVersion) !== undefined ? { schemaVersion: m.schemaVersion } : {}),
-        ...(str(legIn.kind) !== undefined ? { leg: { kind: legIn.kind } } : {}),
+        ...(str(legIn.kind) !== undefined ? { leg: { kind: legIn.kind, ...(legRunOrigin !== undefined ? { runOrigin: legRunOrigin } : {}) } } : {}),
         ...(teamRole !== undefined ? { teamRole } : {}),
         ...(fileHistory !== undefined ? { fileHistory } : {}),
         ...(permissionMode !== undefined ? { permissionMode } : {}),
@@ -816,14 +811,21 @@ export function humanInputEventData(ev) {
     const attachments = Array.isArray(ev.attachments)
         ? ev.attachments
             .filter((m) => typeof m === "object" && m !== null && !Array.isArray(m))
-            .map((m) => ({
-            ...(typeof m.ordinal === "number" && Number.isFinite(m.ordinal) ? { ordinal: m.ordinal } : {}),
-            ...(str(m.kind) !== undefined ? { kind: m.kind } : {}),
-            ...(str(m.outcome) !== undefined ? { outcome: m.outcome } : {}),
-            ...(str(m.label) !== undefined ? { label: seatText("trace-frame-text", String(m.label)) } : {}),
-        }))
+            .map((m) => {
+            const declinedBy = extensionRequesterOf(m.declinedBy, "human_input.attachments", "declinedBy");
+            return {
+                ...(typeof m.ordinal === "number" && Number.isFinite(m.ordinal) ? { ordinal: m.ordinal } : {}),
+                ...(str(m.kind) !== undefined ? { kind: m.kind } : {}),
+                ...(str(m.outcome) !== undefined ? { outcome: m.outcome } : {}),
+                ...(str(m.label) !== undefined ? { label: seatText("trace-frame-text", String(m.label)) } : {}),
+                ...(declinedBy !== undefined ? { declinedBy } : {}),
+            };
+        })
         : undefined;
     const rewrittenBy = Array.isArray(ev.rewrittenBy) ? ev.rewrittenBy.filter((n) => str(n) !== undefined) : [];
+    const author = inputAuthorOnFrame(ev.author);
+    const extension = inputExtensionOnFrame(ev.extension);
+    const runOrigin = runOriginOnFrame(ev.runOrigin);
     const actor = {
         ...(str(a.id) !== undefined ? { id: seatText("trace-frame-text", String(a.id)) } : {}),
         ...(typeof a.hostAsserted === "boolean" ? { hostAsserted: a.hostAsserted } : {}),
@@ -840,9 +842,40 @@ export function humanInputEventData(ev) {
         ...(str(ev.entryId) !== undefined ? { entryId: ev.entryId } : {}),
         ...(attachments !== undefined ? { attachments } : {}),
         ...(rewrittenBy.length > 0 ? { rewrittenBy } : {}),
+        ...(author !== undefined ? { author } : {}),
+        ...(extension !== undefined ? { extension } : {}),
+        ...(runOrigin !== undefined ? { runOrigin } : {}),
         ...identityFields(ev),
     };
 }
+function runOriginOnFrame(v) {
+    if (v === undefined)
+        return undefined;
+    if (isRunOrigin(v))
+        return v;
+    return dropProjectedFace("human_input.runOrigin is not a member of the engine's RUN_ORIGINS");
+}
+function runOriginOnLeg(v) {
+    if (v === undefined)
+        return undefined;
+    if (isRunOrigin(v))
+        return v;
+    return dropProjectedFace("wiring_manifest.leg.runOrigin is not a member of the engine's RUN_ORIGINS");
+}
+function inputAuthorOnFrame(v) {
+    if (v === undefined)
+        return undefined;
+    if (isInputAuthor(v) && v !== "operator")
+        return v;
+    return dropProjectedFace("human_input.author is not a non-operator word of the engine's INPUT_AUTHORS");
+}
+function inputExtensionOnFrame(v) {
+    if (v === undefined)
+        return undefined;
+    if (typeof v === "string" && v !== "")
+        return sanitizeWireText(v);
+    return dropProjectedFace("human_input.extension is not a non-empty registration name");
+}
 export function brainStatusEventData(ev) {
     const num = (v) => typeof v === "number" && Number.isFinite(v);
     return {

package/dist/trace/redact.d.ts

@@ -20,7 +20,41 @@
  * 不回退到剥后产物、不吞:装着的 core 上运行期不可达,换 core 时契约钉先红。
  */
 export declare function mapNormalizedToOriginal(text: string, normalized: string): Int32Array;
+/** 测试可见:同一张表的谓词(测试不抄第二份属性转义)。 */
+export declare function isReadingIgnorableForTest(cp: number): boolean;
 export declare const REDACTION_TOKEN_RE_SRC: string;
+/**
+ * 🔴 **扫描器读原文的唯一口**(九只手写扫描器与它们的读者的原文参数类型 —— 类型上拿不到裸串,也拿不到文本长度):
+ * 活流交出点的 `view` 项({@link FRONTIER_TERMS})读它 —— 一次尝试**真读到了文本末尾**(内容读的下标 ≥ 文本长)⇒ 这一次尝试开着,它的判定可能随续文改。读口三类(闭集):
+ *  · **内容读**(`charCodeAt` / `atEnd` / `startsWith` / `slice` / `readEnd`):读到末尾即记开着,记在当前尝试寄存器上 —— 文本在哪儿结束,只有经这几只读口才看得见;
+ *  · **找锚**(`indexOf` / `search`):找下一枚字面 / 头,没找到是 `-1` / `null`,**不记** —— 「后面再没有锚」、段界参数都不是读到了末尾
+ *    (锚写了一半由池按成员登记的头族派生,{@link HeadReading});找的是内容的收尾(没收尾的串值、收尾栅栏),那一支由臂自己按 head 读法标成未决尾({@link RedactionExtent});
+ *  · **尝试寄存器**(`attempt(from)`):每次尝试的头上设一次,`from` = 这一次尝试在任何续文下可能产出的跨度的最早起点(视图下标)。
+ * 寄存器没设过就读到了末尾 ⇒ 按视图起点记开着(fail-closed:整读扣住,不是少扣),池响亮记 `server.redact.scan-view-unattributed`。
+ * 读数只作前沿元数据:不进候选、不进出处表、不参与覆盖位(head 读法的候选与出口座读数逐条不变)。
+ */
+interface ScanView {
+    /** 内容读:码元 `i`;`i ≥ 文本长` ⇒ 记开着,得 `NaN`(与串的越界读同值)。 */
+    charCodeAt(i: number): number;
+    /** 内容界:`i` 到了文本末尾吗(到了 ⇒ 记开着)。 */
+    atEnd(i: number): boolean;
+    /** 读文本在哪儿结束(= 文本长):恒记开着 —— 只在判定本就要读到末尾的那一支用(从起点遮到末尾、到末尾的量问)。 */
+    readEnd(): number;
+    /** 内容读:`at` 起写着 `lit` 吗;逐码元比到文本末尾还对得上(写了一半)⇒ 记开着,答否。 */
+    startsWith(lit: string, at: number): boolean;
+    /** 内容读:`[a, b)` 的原文;`b` 越过文本末尾 ⇒ 记开着,交到末尾为止的那一截。 */
+    slice(a: number, b: number): string;
+    /** 找锚:`from` 起下一枚 `lit` 的位置;没有 ⇒ `-1`(不记)。 */
+    indexOf(lit: string, from?: number): number;
+    /** 找锚:带 `g` 旗的头正则从 `from` 起的下一枚命中;没有 ⇒ `null`(不记)。 */
+    search(re: RegExp, from: number): RegExpExecArray | null;
+    /** 找锚:最后一枚 `lit` 的位置;没有 ⇒ `-1`(不记)。 */
+    lastIndexOf(lit: string): number;
+    /** 设尝试寄存器(这一次尝试的跨度起点下界,视图下标)。 */
+    attempt(from: number): void;
+    /** 本次尝试(上一次 {@link ScanView.attempt} 以来)读到了文本末尾吗。 */
+    reachedEnd(): boolean;
+}
 export declare function armPoolBudgetForTest(): {
     spanCount: number;
     coveredPositions: number;
@@ -44,6 +78,18 @@ export declare function armPoolBudgetForTest(): {
     windowEvaluations: number;
 };
 export declare function resetArmPoolBudgetForTest(): void;
+/**
+ * 🔴 **合并律(一条;全仓唯一)** —— 认出来的跨度怎么变成记号,只有这一条律:按 `start` 升序(同起点取**更长**的一条,再按 `tie` 定;缺省 = 输入序,
+ * JS 排序稳定),后一条的起点 ≤ 当前段的终点 ⇒ 并进当前段(**相交或相接**:两段之间没有原文字节);一段渲染成**一枚**替换串 = 段首那条的。
+ * **交出点**(`joints`,同一段文本上已经交出去的那些位置:流式口的块交付点与跳过点、`opts.before` 的前文终点)是**渲染边界**:跨过交出点的候选在交出点处切成两截,
+ * 合并律只在两个交出点之间施加 —— 相接或重叠都不越过交出点。交出点之前的那一截已经以它自己的记号出门了;越过去并,后一截只能重出一遍前一段的记号
+ * (且流式口冲刷时判对不上)。切开的后一截按它自己候选的替换串出(与认领律「后一条只认领露出来的尾巴」在交出点上同读)。
+ * 施加点两处、同一只函数:脱敏器 {@link runRedaction} 的收尾(各读法存活的候选原样映回原文之后,一次)与出口座(`exit-seat.ts`:引擎主机身份跨度与脱敏器的段同一次合并);
+ * 渲染只有 {@link renderRedactionSpans} 一只。于是同一个凭据值在每个出口面上是同一枚记号(trace 帧 / 结果面 / 审批面 / 终局错误 / 完成帧 / 日志 / 活流)。
+ * 覆盖的原文字节 = 输入跨度之并(并集不变 ⇒ 方向不弱);变的只是相接 / 部分重叠处的记号个数(两枚 ⇒ 一枚)—— 契约早已写明记号个数与 `:partial` 后缀不是身份位。
+ * 中间隔着原文字节(含视图里被删掉的格式字符:紧包映射把它留在两段外,{@link createViewToOriginal})的两段不相接 ⇒ 两枚,那些字节原位。
+ */
+export declare function mergeRedactionSpans<S extends RedactionSpan>(spans: readonly S[], tie?: (a: S, b: S) => number, joints?: readonly number[]): S[];
 /**
  * 🔴 **脱敏的两个档 —— 「这段文本是自由文本,还是一个结构有界的单元」**([ref],闭集两词)。
  *
@@ -66,6 +112,15 @@ export declare function resetArmPoolBudgetForTest(): void;
 type RedactionScope = "free-text" | "bounded-unit" | "diagnostic";
 /** 🧪 值词表里 `type-name` 一列的词(增补纪律钉读:每个类型名在基线门 c 组都有一格语料)。 */
 export declare function lineKeyTypeNamesForTest(): readonly string[];
+/**
+ * 🔴 **最长识别跨度(读法单元;单源,由识别表派生)**:一枚凭据从它的起点算起,脱敏器要往后读多远才能给出和整段读法同样的判定。两类结构:
+ *  · **有界结构**:识别表里整条长度有上界的只有栅栏块 —— SSH2 块两端都是定长字面(起始栅栏行 + 至多 {@link ARMOR_BODY_MAX} 的体 + 收尾栅栏行),总长上界就是这三段之和;
+ *    PEM 块的体同一个上界、栅栏行的标签不设上界(合法标签由它的未决尾接管,见 {@link RedactionExtent});
+ *  · **判定距离**:正则臂 / 扫描器自己声明的「这里成不成」要读多远,全池最大值 {@link MAX_DECISION_REACH};扫描窗前移的地平线是它的 {@link STREAM_WINDOW_HORIZON} 倍(加载期自证不超过本常量)。
+ * 不设上界的结构(值 run、JSON 串值、URL userinfo、带引号的强锚值 …)不在这个数里:它们在窗尾被切断时由 head 读法从起点遮到窗尾({@link RedactionExtent} 的未决尾)。
+ * **读者**:出口座扫描窗的余量(`trace/exit-seat.ts`)—— 窗 = 出门区 + 这个数,起于出门区、总长不超过它的有界结构整段落在窗内,与整段读法同判;越过它的不保证同判(窗读法多遮,不漏)。
+ */
+export declare const MAX_RECOGNITION_SPAN: number;
 /** 本模块会写进文本的全部替换 token(`«…»` 字面),从三张表现算 —— 表改这里自动跟,不另抄一份。
  *  🔴 **[ref] v2 修复轮起它只剩一个语义:闭形闭集的加载期校验**。运行期「这一段是不是一枚记号」已经由
  *  记号行的闭**形**一处答完({@link tokenUnits} / {@link tokenEnd}),按闭**集**再认一遍的
@@ -174,7 +229,8 @@ export type RedactionLayout = "multi-line" | "single-line";
  *    ① **收尾没见到** —— JSON 串值(要收尾引号)· URL authority(要 `@`;authority 一路走到末尾没有 `/` / 空白,里面有没有 `@` 都读成还在 userinfo 里)·
  *    SSH2 / PEM 栅栏(要收尾栅栏)· 带引号的强锚值(要收尾引号)· PuTTY 容器(终止符之后到末尾没见下一个版本头);
  *    ② **起头没读完**(起头本身不设长度上界,起点可以离末尾很远)—— PEM 起始栅栏行(标签之后到末尾一枚 `-----` 都没有,已读到的部分也还可能是合法栅栏行的前缀)· PuTTY 版本头(`<数字串>: ` 没写完)·
- *    无头 .ppk 字段(`Private-Lines: <数字串>` 之后下一个体行的判定没走完)· 词法关键字臂(`Bearer` / `Basic` / `token`)的起头(完整关键字之后跟着不设长度上界的分隔段、值被窗尾切在窗外,见 {@link undecidedKeywordStart};
+ *    无头 .ppk 字段(`Private-Lines: <数字串>` 之后下一个体行的判定没走完)· 带头 PEM 体(最后一段的头行 / 体读者读到了这一段末尾才停 —— 头行没见换行、头行之后的体 run / 分隔符 / 下一条头行的 token 写到末尾:
+ *    头行区里「最右的 ≥ 8 位串」与体还在长,{@link collectPemFragmentSpans})· 词法关键字臂(`Bearer` / `Basic` / `token`)的起头(完整关键字之后跟着不设长度上界的分隔段、值被窗尾切在窗外,见 {@link undecidedKeywordStart};
  *    关键字写了一半 / 关键字紧贴值的起点离窗尾至多几十个字符,不另立一支)。
  *    PuTTY 容器臂的「无合格终止 ⇒ 吃到输入末尾」本来就是这一律在整段文本上的形,两种范围都吃到末尾;区别只在留痕 —— 整段读法上它是兜底(记 `server.redact.ppk-eat-to-end`),
  *    head 读法上终止可能在更远处,是未决(不记)。**未决一律不记 fail-open**:它是这一律的正常读数,不是回退;
@@ -202,7 +258,7 @@ export declare const WHOLE_EXTENT: RedactionExtent;
 export declare function readingHeadEnd(text: string, layout: RedactionLayout, units: number, from?: number): number;
 /**
  * `opts.before` = 这段文本的**前文**(同一段里先到、已经交出去的那一截):判定在 `before + text` 上做(前文里的锚照样认得出后文的值),交出的只是 `text` 那一截的读法 ——
- * 与整段读法逐字节同一份,除了一条起头在前文里、止点在 `text` 里的跨度(它的原文字节一个不出,整枚换记号,与流式口 {@link renderRange} 同一条渲染律)。
+ * 与整段读法逐字节同一份,除了一条起头在前文里、止点在 `text` 里的跨度(它的原文字节一个不出,整枚换记号,与流式口 {@link renderRedactionSpans} 同一条渲染律)。
  * 命中只计止点在前文之后的跨度(前文那一截上一次已计)。读者:段末帧 `text_end` 的正文(引擎的一块接在本段前文之后判,`observability/run-terminal.ts` 的 `redactModelText`)。
  */
 export declare function redactSecrets(text: string, opts?: {
@@ -257,10 +313,9 @@ export declare function redactionSpansForTest(text: string, opts?: {
  *
  * 同一只 {@link runRedaction}、同一张不可见字符读法格、同一次观察者计数(座上的一次脱敏就是一次主扫),交出**原文坐标**上的跨度与各自的替换串:臂认什么、档里有哪些臂、
  * 一段文本有几种读法,仍然只由本模块答。`layout` = 这一行出口的出门形({@link RedactionLayout};必填 —— 出口自己说它把文本压不压成一行,第 ④ 类读不读随之定)。
- * 座拿它做**一次区间合并 + 一次渲染 + 按出门形整形 + 按记号边界切**(合并律与渲染律住在座里,本模块不拼第二份产物给座)。
- *
- * 第一期交的是池解完重叠之后的那一份(升序、两两不交);第二期改交未解重叠的原始候选,池内并集律 {@link resolveSpanOverlaps} 与
- * {@link applySpans} 随之删除 —— 那时本口是自由文本脱敏的唯一出口。
+ * 交出的是**段**(合并律 {@link mergeRedactionSpans} 已在 {@link runRedaction} 收尾施加:升序、两两不相接)—— 与 {@link redactSecrets} 渲染的是同一份段,座只在上面
+ * 做渲染({@link renderRedactionSpans},出门区终点 = `until`)+ 按出门形整形 + 按记号边界切;声明 `hostLeaks` 的行把引擎的主机身份跨度与段再过同一只合并律。
+ * `json` = 座表那一行声明「这一行出门的是一条 `JSON.stringify` 的产物」(语义 ⑦,与 {@link redactSecrets} 的 `opts.json` 同义;今天只有日志出口接缝的记录行):必填 —— 出口自己陈述它的文本形,本模块不猜。
  */
 export type RedactionSpan = {
     readonly start: number;
@@ -268,24 +323,43 @@ export type RedactionSpan = {
     readonly repl: string;
 };
 export type { RedactionScope };
-export declare function proposeRedactionSpans(text: string, scope: RedactionScope, layout: RedactionLayout, extent: RedactionExtent): readonly RedactionSpan[];
+export declare function proposeRedactionSpans(text: string, scope: RedactionScope, layout: RedactionLayout, extent: RedactionExtent, json: boolean): readonly RedactionSpan[];
 /**
- * 🔴 **未决尾的长度上界**(读法单元):一段还在长的文本,末尾这么多个读法单元里起头的候选,本脱敏器**还判不了**(判定要读到文本之外)。
- * 它不是另立的常数,是候选池成员表的同一份读数 —— 每条臂的**判定距离**取最大({@link MemberIdentity.reach} 的意义见那里):正则臂从正则源读出
+ * 🔴 **全池的最大判定距离**(读法单元):候选池成员表的同一份读数 —— 每条臂的**判定距离**取最大({@link MemberIdentity.reach} 的意义见那里):正则臂从正则源读出
  * (前缀 + 前瞻判据 + 值 run 的最少重复;熵谓词 {@link ENTROPY_SCAN_MAX} 两窗由此进来),手写扫描器陈述它起头要读全的字面锚。
- * 判定在**无界**远处的结构(没收尾的 JSON 串值 / URL userinfo / 栅栏 / 带引号的值、起头不设长度上界的栅栏行 / 版本头 / 关键字分隔段)不靠它:
- * head 读法把它们读成未决尾、从起点遮到文本末尾({@link RedactionExtent}),流式口在它的起点前停下,直到它判定或冲刷。
+ * 它**不是放行规则**:活流交出点由读口闭集按实际判定定({@link FRONTIER_TERMS};正则臂的判定距离逐臂进 `view` 项)。它只剩一个用途 —— 扫描窗前移地平线的单位
+ * ({@link STREAM_WINDOW_HORIZON}:前移点之后留够「判定距离之内、可能被后文补成跨度」的那几个词,窗的几何,不随一次读数变)。
  * 加一条判定距离更远的臂,这个数随之变大(钉 `test/live-model-text-hold-law.test.ts` 读每条成员的读数与最大值)。
  */
-export declare const PENDING_TAIL_UNITS: number;
+export declare const MAX_DECISION_REACH: number;
 /** 测试可见:正则臂判定距离的读法本身(读得出的几形与加载期抛的几形)。 */
 export declare function regexDecisionReachForTest(re: RegExp, lexical: boolean): number;
 /** 测试可见:候选池每条成员的判定距离(成员的替换串、池序、读数)。 */
-export declare function pendingTailReachForTest(): ReadonlyArray<{
+export declare function decisionReachForTest(): ReadonlyArray<{
     readonly token: string;
     readonly order: number;
     readonly reach: number;
 }>;
+/**
+ * 🔴 **活流交出点的读口闭集**(律:一位「已判定」⇔ 可能盖住它的判定都没读到「文本末尾之后才定的东西」)。五类读一律算,每类一项:
+ *  · `view`:视图原文(含前瞻)—— 一次判定真读到了视图末尾的最早影响位:扫描器经读口 {@link ScanView} 记(内容读到末尾才算,找锚没找到不算)、正则臂由池按头族与判定距离派生
+ *    ({@link HeadReading};命中止于视图末尾也算)、扫描器的锚写了一半;臂自标的未决跨度(head 读法)由交出点之后的「横跨 / 触尾回退」接住 —— 同一律的两种回报形;
+ *  · `lattice`:读法格末尾未定段 —— 各张原始控制字符视图里还没写完的转义写法,与删掉原始控制字符之后末尾的孤高代理({@link latticeOpenOf});
+ *  · `token`:记号层 —— 末尾写了一半、还可能成形的 `«…`,与止于末尾的已收好记号单元(首尾相接的几枚并成一段,{@link tokenUnits}:再来一枚紧接的记号,字符类读口的回答就变;{@link tokenTailOpen});
+ *  · `evidence`:出处表 —— 取证执行的足迹碰到证据地平线即开着,它的起点下界拉低交出点;证据地平线沿最终出处表行的依赖范围闭包({@link createEvidenceFrontier});
+ *  · `coverage`:覆盖位重试 —— 只在已收跨度盖住的位置上重试;盖住它的判定开着时那些位置都不早于交出点,关着时重试读数与 P 上逐字同 ⇒ 恒不拉低(列出只为闭集完整)。
+ * 每一项 = 「给定当前交出点 `f`,这一类读报的最早开着位」(不开 = 文本长);只有 `evidence` 读 `f`(证据项依赖证据地平线,证据地平线依赖 `f`)。
+ * 交出点 = 各项轮流取 min 到不动点({@link settledFrontier};各项对 `f` 单调不增)。映射类型:少一项 ⇒ TS2741 编译红(与 {@link LANES} 同形)。
+ */
+type ReadPort = "view" | "lattice" | "token" | "evidence" | "coverage";
+/** 测试可见:证据项本身(恒等映射):执行 `[lo, hi, 起点下界]`、行 `[起点, 终点, 收尾位]`(收尾位 -1 = 不完整),从 `f` 出发的证据下界。 */
+export declare function evidenceFrontierForTest(execs: ReadonlyArray<readonly [number, number, number]>, rows: ReadonlyArray<readonly [number, number, number]>, f: number): number;
+/** 测试可见:整段 head 读法(出门区 = 整段)下各读法记下的取证执行(原文坐标 `[lo, hi, 起点下界]`;{@link noteExecution})。 */
+export declare function forensicExecutionsForTest(text: string): ReadonlyArray<readonly [number, number, number]>;
+/** 🔴 **渲染器(一只;全仓唯一)**:原文 `[from, until)` 按 `spans`({@link mergeRedactionSpans} 的产物:升序、两两不相接)渲染 —— 与它相交的段整枚换成替换串:
+ *  起头在 `from` 之前的那一段也整枚换(它的原文字节一个都不出),横跨 `until` 的那一段同样整枚、其后不再出。脱敏池的产物、流式口的每一次交出、`opts.before` 的那一截、
+ *  出口座的渲染(出门区终点 = `until`)都是它 —— 一段一枚记号这件事只写这一次。 */
+export declare function renderRedactionSpans(text: string, spans: readonly RedactionSpan[], from: number, until: number): string;
 /** 测试可见:扫描窗的两张字母表 —— 全池成员的声明再加 `extra`(造一条新臂的声明),与生产同一只派生、同一份自证(不成立照样抛)。 */
 export declare function streamWindowAlphabetsForTest(extra?: readonly PriorReading[]): {
     readonly isBlank: (unit: number) => boolean;
@@ -299,6 +373,10 @@ export declare function escapeGrammarForTest(): {
     };
     readonly isBodyUnit: (unit: number) => boolean;
 };
+/** 认证的读数(闭集;第一条没过的那一条,全过 = `independent`)。 */
+type WindowVerdict = "independent" | "span-straddles" | "view-straddles" | "footprint-straddles" | "row-straddles" | "spans-differ" | "rows-differ";
+/** 测试可见:前移点认证的读数(哪一条挡下;同 {@link windowIndependentAt} 的同一只实现)。 */
+export declare function windowVerdictAtForTest(text: string, q: number): WindowVerdict;
 /** 测试可见:扫描窗的前移点候选(`-1` = 窗尾有一枚还没写完的转义写法;`0` = 没有),字母表按全池成员的声明再加 `extra` 现算({@link streamWindowAlphabetsForTest})。 */
 export declare function windowAdvancePointForTest(text: string, units: number, extra?: readonly PriorReading[]): number;
 /** 测试可见:扫描窗前移点的认证(生产里 `q` 恒是行首;单测拿非行首的 `q` 钉住「名字在 `q` 之前、值在 `q` 之后」「跨度横跨 `q`」两形各自被认证挡下)。 */
@@ -307,24 +385,25 @@ export declare function windowIndependentAtForTest(text: string, q: number): boo
  * 🔴 **流式口 —— 同一只脱敏器的三口**(live 面逐块到达的模型文本 `text_delta` / `reasoning_delta` 的唯一放行器;登记册在 `trace/model-segment.ts`)。
  * 同一只 {@link runRedaction}、同一张表,只多一件事:知道文本还在长。
  *  · **喂入**({@link RedactionStream.feed}):原文追加进本段;
- *  · **取已判定前缀**({@link RedactionStream.takeSettled}):从上次取到的位置起,已判定的那一截的脱敏读法 —— head 读法,出门区终点 = 末尾 {@link PENDING_TAIL_UNITS}
- *    个读法单元之前;切点再退到横跨它的那一条跨度的起点(一枚可能还在长、或判定在更远处的凭据整条不出)与码点边界。按重扫节律({@link streamRescanStep})才真扫;
+ *  · **取已判定前缀**({@link RedactionStream.takeSettled}):从上次取到的位置起,已判定的那一截的脱敏读法 —— head 读法(出门区 = 整窗),切点 = 读口闭集的交出点({@link settledFrontier}:
+ *    最小的「可能盖住它的判定读到了文本末尾之后」的位),再退到横跨它、或止于文本末尾的那一条跨度的起点(一枚可能还在长、或判定在更远处的凭据整条不出)与码点边界({@link settledCut})——
+ *    扫描器读到末尾、正则臂的头写在判定距离之内、读法格 / 记号层末尾没写完、取证执行问过的证据碰到证据地平线(URL 口令里粘着一枚还没判定的别臂候选,口令不先出)。按重扫节律({@link streamRescanStep})才真扫;
  *  · **交付点**({@link RedactionStream.takeAll}):已喂入的字节全部交出 —— 整段读法、文本到此为止(引擎关了一个文字块:那一块现在就要交付,不等后文);流不结束,
  *    之后喂入的字节仍在整段上下文里判(前文的锚认得出后文的值)。一条凭据形恰横跨交付点 ⇒ 交付时那一截按到此为止判(读得出的半形出记号),之后横跨的那一条整枚换记号、
  *    冲刷时的核对对不上(`diverged`,一段计一次)—— 判定读不到交付点之后的字节,这是交付点的定义,不是第二套规则;
  *  · **收尾冲刷**({@link RedactionStream.flush}):整段读法交出其余字节,并核对已取出的字节在整段读法下是不是同一份。
- * 律:各次取出依次拼接 + 冲刷 = 整段读法(`redactSecrets(全段)`)逐字节 —— 只喂一次再冲刷就是整段口本身。前提是 {@link PENDING_TAIL_UNITS} 读对了每条臂的判定距离;
- * 读错的那一形在冲刷时现形(`diverged`),调用方响亮留痕。
- * 延迟上界:一个字节在它之后又到 {@link PENDING_TAIL_UNITS} 个读法单元之后的下一次重扫时交出;盖住它的跨度判定之前(或冲刷之前)不交出。
+ * 律:各次取出依次拼接 + 冲刷 = 整段读法(`redactSecrets(全段)`)逐字节 —— 只喂一次再冲刷就是整段口本身。前提是读口闭集读全了每一类「读到末尾之后」的读
+ * ({@link FRONTIER_TERMS};编译期管不到的两处 —— 扫描器某次尝试漏设寄存器、取证级数封顶 —— 各有响亮计数);读漏的那一形在冲刷时现形(`diverged`),调用方响亮留痕。
+ * 延迟:一个字节在盖住它的判定都不再读到末尾之后的下一次重扫时交出(没有开着的判定 ⇒ 喂入它的那一次重扫);盖住它的跨度判定之前(或冲刷之前)不交出。
  * 不喂观察者(`observe:false`,与影子重扫同口):命中只在段末那一次整段脱敏里计(段末帧的铸点),逐块重扫不重复计数。扫描器抛 ⇒ 原样抛(放行位不动)。
  *
  * 🔴 **扫描窗**(多块长段的扫描量;与上面「押在窗里的字节」的窗不是一回事 —— 那是还没交出的未决尾,这是判定要读的前文):一段里每个块的交付点都要「前文 + 本块」一起判(锚在前一块、值在这一块),整段重扫则一段 N 块的总扫描量随 N 平方涨。流式口因此只留判定还需要的那一截前文 ——
  * **扫描窗** = 全段的一个后缀 `[base, 全段长)`:取已判定前缀、交付点与前文({@link RedactionStream.blockContext})都只在窗上扫;只有收尾冲刷仍是整段一遍(一段一次),窗若曾判错,对不上在这里现形(`diverged`)。
  * 扫描窗只在块界({@link RedactionStream.endBlock})前移,前移点 `q` 同时满足:① 是行首(其前一码元是换行 —— 行内向左读的臂不会读过它);② 其后至少留
- * {@link STREAM_WINDOW_HORIZON} × 未决尾个**非空白**读法单元({@link windowAdvancePoint}:任何判定距离之内的候选与它们的证据邻居都在窗里;键与冒号已到、值的起引号还隔着一段任意长的空白在后文里的锚,
+ * {@link STREAM_WINDOW_HORIZON} × 全池最大判定距离个**非空白**读法单元({@link windowAdvancePoint}:任何判定距离之内的候选与它们的证据邻居都在窗里;键与冒号已到、值的起引号还隔着一段任意长的空白在后文里的锚,
  * 此刻不显现为任何跨度,只有「后文接在窗尾」能补全它 —— 空白不挤掉它们);③ 已交出到段尾(没有未交出的字节落在 `q` 之前);
  * ④ 被丢的前缀里没有容器类臂的定界字面({@link STREAM_WINDOW_ALPHABETS} 的 `containerDelimiters`:孤立收尾、无头体、「前面有过起始栅栏」读的是整段之前任意远的前文);
- * ⑤ 经 {@link windowIndependentAt} 认证(head 读法下:没有跨度横跨 `q`;从 `q` 起单独扫的跨度与整窗里同一截逐条相同)。
+ * ⑤ 经 {@link windowIndependentAt} 认证(head 读法下:没有跨度横跨 `q`;没有取证执行的足迹、没有出处表行的依赖范围横跨 `q`;从 `q` 起单独扫的跨度与出处表行与整窗里同一截逐条相同;没有判定从 `q` 之前起读到窗尾)。
  * 没有满足这五条的点(没有换行的超长单行、一枚始终没收尾的多块结构、整段里出现过密钥栅栏 / PuTTY 密钥头、整窗只有一行 …)⇒ 窗不动、读法不变,代价退回「窗长」(= 与改前同阶)。扫描窗能前移时,每块的扫描量是 O(块长 + 地平线 + 最长行),与段长无关。
  * 🔴 **五条规则健全的三条前提,都由构造成立、不靠手抄**(臂集一变,窗随之变;没有一份要人记得同步的镜像):
  *  ① 每条臂任意长间隔里的字符,地平线都不数 —— 地平线不数的字符**就是**全池 `bounded` 声明的间隔之并({@link STREAM_WINDOW_ALPHABETS},{@link PriorReading});
@@ -362,8 +441,27 @@ export declare function createRedactionStream(): RedactionStream;
 export declare function createRedactionStreamWithoutWindowForTest(): RedactionStream;
 /** 测试可见:同一只流式口,前移点的认证换成调用方给的函数(造「认证扫描抛」的形:真扫描器造不出来;断言抛出后窗与块界的状态一个字节没改)。 */
 export declare function createRedactionStreamWithCertifierForTest(certify: (text: string, q: number) => boolean): RedactionStream;
-/** 测试可见:同一只流式口,未决尾按调用方给的数(比 {@link PENDING_TAIL_UNITS} 小 ⇒ 律被打破的那一形,冲刷时 `diverged` 现形 —— 响亮臂的触发器;生产调用方只有上面那一只)。 */
-export declare function createRedactionStreamWithTailForTest(units: number): RedactionStream;
+/** 测试可见:同一只流式口,切点人为往后挪 `adjust` 个码元(越过读口闭集的交出点 ⇒ 律被打破的那一形,冲刷时 `diverged` 现形 —— 响亮臂的触发器;生产调用方只有上面那一只)。 */
+export declare function createRedactionStreamWithFrontierForTest(adjust: number): RedactionStream;
+/** 测试可见:把整段 `text` 当作还在长的一段(还没交出过字节)时,取已判定前缀的切点(原文下标,码点边界调整之前)与那一截的脱敏读法(= 第一次取出),
+ *  连同交出点与它的每一项在交出点上的读数({@link FRONTIER_TERMS} 的同一份;不开 = 文本长)。 */
+export declare function settledCutsForTest(text: string): {
+    readonly cut: number;
+    readonly settled: string;
+    readonly frontier: number;
+    readonly terms: {
+        readonly [K in ReadPort]: number;
+    };
+    readonly rounds: number;
+};
+/** 测试可见:一只扫描器读口(读数:最早开着位 / 寄存器没设就读到了末尾)—— 钉读口三类读的记法。 */
+export declare function createScanViewForTest(text: string): {
+    readonly view: ScanView;
+    readonly open: () => number;
+    readonly unattributed: () => boolean;
+};
+/** 测试可见:正则臂头族的逐位展开(串数;数不住即抛 —— 加载期同一只)。 */
+export declare function expandHeadUnitsForTest(src: string, flags?: string): number;
 /**
  * 🔴 环 + 深度预算(2026-07-25 补)。原实现是纯递归、**既不记已访问节点也不限深度**,而它的调用位置是
  * **最不可信的边界**:`toolStart`/`toolEnd` 把工具的 `args`/`output`/`structured` 直接喂进来。后果两条:
@@ -435,9 +533,6 @@ export declare function redactedPreview(value: unknown, cap?: number): string |
  *  ([ref] 的「违反格」要造一个「位置律漏了一段」的世界,而拿上游的现成缺陷当触发器会在它修好那天失效);
  *  生产调用方**不传**这个参数。 */
 export type PositionalUrlLaw = (url: string) => string;
-/** 测试口(与 `observability/fail-open.ts` 的 `resetFailOpenRecorderForTest` 同姿势):一次性 warn 的闸是
- *  模块级的,而「只 warn 一次」本身要被钉,所以给测试一个复位口。生产零调用。 */
-export declare function resetDisplaySafeFailClosedWarnForTest(): void;
 /**
  * 🔴 **[ref] 的不变量 —— 形状律在 query / fragment 区间上有一条凭据跨度 ⇒ 那一整段不出门**。
  *
@@ -463,8 +558,9 @@ export declare function resetDisplaySafeFailClosedWarnForTest(): void;
  * (改前是逐参数遮)。方向一致,而且干净的根**零影响** —— Azure 式 `?api-version=…&deployment=…` 上
  * 形状律一条跨度都没有,结构上走不到这一步([ref]-e 单独钉住)。path 区间的凭据**不**走这条路:位置律
  * 逐字保留 `pathname`,形状律在产物上照常认得它([ref]-f 的并集格)。
- * 🔴 这是 fail-**closed**(扣下信息),**不**登记 `recordFailOpen` —— 那张表记的是「放行了本该拒的」。
- *    只打一条一次性 warn(**不含原文**:原文就是那段凭据)。
+ * 🔴 这是 fail-**closed**(扣下信息):与本模块其余「整段扣下」的臂(`server.redact.ppk-eat-to-end` / `forensic-level-cap` 一族)同一条律,
+ *    走登记过的 F 类兜底臂 `server.redact.display-safe-fail-closed`({@link noteDisplaySafeFailClosed}:逐次计数 + 探针,一次性宣告经 fail-open 记录器 → 日志出口接缝),
+ *    detail 只报扣下的那一级(**不含原文**:原文就是那段凭据)。
  */
 export declare function buildDisplaySafeUrl(raw: string, positionalLaw?: PositionalUrlLaw): string;
 /**