@sema-agent/server 7.132.0 → 7.133.0

package/dist/trace/project.js

@@ -3,6 +3,7 @@ import { MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROL
 import { Value } from "typebox/value";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets, redactDeep } from "./redact.js";
+import { seatText } from "./exit-seat.js";
 import { sanitizeWireText } from "./engine-notice-wire.js";
 import { projectToolOutput, projectToolStructured } from "./tool-output-media.js";
 import { injectionTierOrAbsent } from "./injection-tier.js";
@@ -270,14 +271,14 @@ export function taskProgressEventData(ev) {
         ...(typeof ev.seq === "number" ? { seq: ev.seq } : {}),
         ...(typeof ev.taskType === "string" && ev.taskType.length > 0 ? { taskType: ev.taskType } : {}),
         ...(ev.parentTaskId ? { parentTaskId: ev.parentTaskId } : {}),
-        ...(ev.name ? { name: redactSecrets(ev.name) } : {}),
+        ...(ev.name ? { name: seatText("trace-frame-text", ev.name) } : {}),
         ...(ev.spawnName ? { spawnName: ev.spawnName } : {}),
         ...(typeof ev.model === "string" && ev.model.length > 0 ? { model: ev.model } : {}),
         ...(ev.status !== undefined ? { status: ev.status } : {}),
         ...(ev.usage ? { usage: ev.usage } : {}),
-        ...(ev.currentAction ? { currentAction: redactSecrets(ev.currentAction) } : {}),
+        ...(ev.currentAction ? { currentAction: seatText("trace-frame-text", ev.currentAction) } : {}),
         ...(ev.workflowRunId ? { workflowRunId: ev.workflowRunId } : {}),
-        ...(ev.workflowAgentLabel ? { workflowAgentLabel: redactSecrets(ev.workflowAgentLabel) } : {}),
+        ...(ev.workflowAgentLabel ? { workflowAgentLabel: seatText("trace-frame-text", ev.workflowAgentLabel) } : {}),
         ...identityFields(ev),
     };
 }
@@ -288,11 +289,11 @@ export function taskStartedEventData(ev) {
         ...(typeof ev.taskType === "string" && ev.taskType.length > 0 ? { taskType: ev.taskType } : {}),
         ...(typeof ev.seq === "number" ? { seq: ev.seq } : {}),
         ...(ev.workflowRunId ? { workflowRunId: ev.workflowRunId } : {}),
-        ...(ev.workflowAgentLabel ? { workflowAgentLabel: redactSecrets(ev.workflowAgentLabel) } : {}),
+        ...(ev.workflowAgentLabel ? { workflowAgentLabel: seatText("trace-frame-text", ev.workflowAgentLabel) } : {}),
         ...(ev.parentTaskId ? { parentTaskId: ev.parentTaskId } : {}),
         ...(ev.parentSessionId ? { parentSessionId: ev.parentSessionId } : {}),
         ...(ev.rootSessionId ? { rootSessionId: ev.rootSessionId } : {}),
-        ...(ev.name ? { name: redactSecrets(ev.name) } : {}),
+        ...(ev.name ? { name: seatText("trace-frame-text", ev.name) } : {}),
         ...(ev.spawnName ? { spawnName: ev.spawnName } : {}),
         ...(ev.agentType ? { agentType: ev.agentType } : {}),
         model: ev.model,
@@ -310,10 +311,10 @@ export function taskNotificationEventData(ev) {
         ...(n.toolUseId !== undefined ? { toolUseId: n.toolUseId } : {}),
         status: n.status,
         ...(n.seq !== undefined ? { seq: n.seq } : {}),
-        ...(n.lines !== undefined ? { lines: n.lines.map((l) => redactSecrets(l)) } : {}),
+        ...(n.lines !== undefined ? { lines: n.lines.map((l) => seatText("trace-frame-text", l)) } : {}),
         ...(n.stoppedBy !== undefined ? { stoppedBy: n.stoppedBy } : {}),
         ...(n.completionId !== undefined ? { completionId: n.completionId } : {}),
-        ...(n.error !== undefined ? { error: redactSecrets(n.error) } : {}),
+        ...(n.error !== undefined ? { error: seatText("trace-frame-text", n.error) } : {}),
         ...(n.errorCode !== undefined ? { errorCode: n.errorCode } : {}),
         ...(n.apiFailure !== undefined
             ? {
@@ -323,20 +324,20 @@ export function taskNotificationEventData(ev) {
                 },
             }
             : {}),
-        ...(n.source !== undefined ? { source: redactSecrets(n.source) } : {}),
+        ...(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: redactSecrets(n.diagnostics) } : {}),
+        ...(n.diagnostics !== undefined ? { diagnostics: seatText("trace-frame-text", n.diagnostics) } : {}),
         ...(n.recentSteps !== undefined
-            ? { recentSteps: n.recentSteps.map((s) => ({ tool: s.tool, target: redactSecrets(s.target), outcome: redactSecrets(s.outcome) })) }
+            ? { recentSteps: n.recentSteps.map((s) => ({ tool: s.tool, target: seatText("trace-frame-text", s.target), outcome: seatText("trace-frame-text", s.outcome) })) }
             : {}),
-        ...(n.editedFiles !== undefined ? { editedFiles: n.editedFiles.map((f) => ({ path: redactSecrets(f.path), edits: f.edits })) } : {}),
+        ...(n.editedFiles !== undefined ? { editedFiles: n.editedFiles.map((f) => ({ path: seatText("trace-frame-text", f.path), edits: f.edits })) } : {}),
         ...(n.resumable !== undefined ? { resumable: n.resumable } : {}),
-        summary: redactSecrets(n.summary),
-        ...(n.result !== undefined ? { result: redactSecrets(n.result) } : {}),
-        ...(n.output_file !== undefined ? { output_file: redactSecrets(n.output_file) } : {}),
+        summary: seatText("trace-frame-text", n.summary),
+        ...(n.result !== undefined ? { result: seatText("trace-frame-text", n.result) } : {}),
+        ...(n.output_file !== undefined ? { output_file: seatText("trace-frame-text", n.output_file) } : {}),
         ...(n.usage !== undefined ? { usage: n.usage } : {}),
-        ...(n.agentMessage !== undefined ? { agentMessage: { from: n.agentMessage.from, body: redactSecrets(n.agentMessage.body) } } : {}),
+        ...(n.agentMessage !== undefined ? { agentMessage: { from: n.agentMessage.from, body: seatText("trace-frame-text", n.agentMessage.body) } } : {}),
         ...(() => {
             if (n._sema_provenance === undefined)
                 return {};
@@ -355,13 +356,13 @@ export function taskNotificationEventData(ev) {
 export function diagnosticsEventData(ev) {
     return {
         files: (Array.isArray(ev.files) ? ev.files : []).map((f) => ({
-            uri: redactSecrets(String(f.uri)),
+            uri: seatText("trace-frame-text", String(f.uri)),
             diagnostics: (Array.isArray(f.diagnostics) ? f.diagnostics : []).map((d) => ({
-                message: redactSecrets(String(d.message)),
+                message: seatText("trace-frame-text", String(d.message)),
                 ...(d.severity !== undefined ? { severity: d.severity } : {}),
                 ...(d.range !== undefined ? { range: d.range } : {}),
-                ...(d.code !== undefined ? { code: typeof d.code === "number" ? d.code : redactSecrets(String(d.code)) } : {}),
-                ...(d.source !== undefined ? { source: redactSecrets(String(d.source)) } : {}),
+                ...(d.code !== undefined ? { code: typeof d.code === "number" ? d.code : seatText("trace-frame-text", String(d.code)) } : {}),
+                ...(d.source !== undefined ? { source: seatText("trace-frame-text", String(d.source)) } : {}),
             })),
         })),
         isNew: ev.isNew === true,
@@ -371,7 +372,7 @@ export function diagnosticsEventData(ev) {
 export function steeringInjectedEventData(ev) {
     return {
         source: String(ev.source),
-        preview: redactSecrets(String(ev.preview)),
+        preview: seatText("trace-frame-text", String(ev.preview)),
         ...identityFields(ev),
     };
 }
@@ -380,7 +381,7 @@ export function compactionOutcomeEventData(ev) {
     return {
         ...(s(ev.outcome) !== undefined ? { outcome: s(ev.outcome) } : {}),
         ...(s(ev.trigger) !== undefined ? { trigger: s(ev.trigger) } : {}),
-        ...(ev.reason !== undefined ? { reason: redactSecrets(String(ev.reason)) } : {}),
+        ...(ev.reason !== undefined ? { reason: seatText("trace-frame-text", String(ev.reason)) } : {}),
         ...(s(ev.pass) !== undefined ? { pass: s(ev.pass) } : {}),
         ...identityFields(ev),
     };
@@ -396,7 +397,7 @@ export function compactionStartedEventData(ev) {
 }
 export function workspaceChangedEventData(ev) {
     return {
-        cwd: redactSecrets(String(ev.cwd)).slice(0, 300),
+        cwd: seatText("trace-frame-line", String(ev.cwd)),
         ...identityFields(ev),
     };
 }
@@ -629,11 +630,23 @@ export function wiringManifestEventData(ev, instructions) {
             return dropProjectedFace("wiring_manifest.fileHistory is not a non-empty string");
         return word;
     })();
+    const permissionMode = (() => {
+        if (m.permissionMode === undefined)
+            return undefined;
+        const seg = sec(m.permissionMode);
+        const effective = str(seg?.effective);
+        const requested = seg?.requested === undefined ? undefined : str(seg.requested);
+        const foldedBy = seg?.foldedBy === undefined ? undefined : str(seg.foldedBy);
+        if (effective === undefined || (seg?.requested !== undefined && requested === undefined) || (seg?.foldedBy !== undefined && foldedBy === undefined))
+            return dropProjectedFace("wiring_manifest.permissionMode is not a receipt shape (effective a non-empty string, requested / foldedBy absent or non-empty strings)");
+        return { ...(requested !== undefined ? { requested } : {}), effective, ...(foldedBy !== undefined ? { foldedBy } : {}) };
+    })();
     return {
         ...(num(m.schemaVersion) !== undefined ? { schemaVersion: m.schemaVersion } : {}),
         ...(str(legIn.kind) !== undefined ? { leg: { kind: legIn.kind } } : {}),
         ...(teamRole !== undefined ? { teamRole } : {}),
         ...(fileHistory !== undefined ? { fileHistory } : {}),
+        ...(permissionMode !== undefined ? { permissionMode } : {}),
         ...(ask !== undefined ? { ask } : {}),
         ...(question !== undefined ? { question } : {}),
         ...(str(interactionIn.posture) !== undefined ? { interaction: { posture: interactionIn.posture } } : {}),
@@ -712,13 +725,13 @@ export function humanInputEventData(ev) {
             ...(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: redactSecrets(String(m.label)) } : {}),
+            ...(str(m.label) !== undefined ? { label: seatText("trace-frame-text", String(m.label)) } : {}),
         }))
         : undefined;
     const actor = {
-        ...(str(a.id) !== undefined ? { id: redactSecrets(String(a.id)) } : {}),
+        ...(str(a.id) !== undefined ? { id: seatText("trace-frame-text", String(a.id)) } : {}),
         ...(typeof a.hostAsserted === "boolean" ? { hostAsserted: a.hostAsserted } : {}),
-        ...(str(a.issuer) !== undefined ? { issuer: redactSecrets(String(a.issuer)) } : {}),
+        ...(str(a.issuer) !== undefined ? { issuer: seatText("trace-frame-text", String(a.issuer)) } : {}),
     };
     return {
         ...(str(ev.inputId) !== undefined ? { inputId: ev.inputId } : {}),
@@ -726,7 +739,7 @@ export function humanInputEventData(ev) {
         ...(str(ev.carrier) !== undefined ? { carrier: ev.carrier } : {}),
         ...(str(ev.source) !== undefined ? { source: ev.source } : {}),
         ...(str(ev.delivery) !== undefined ? { delivery: ev.delivery } : {}),
-        ...(str(ev.issuer) !== undefined ? { issuer: redactSecrets(String(ev.issuer)) } : {}),
+        ...(str(ev.issuer) !== undefined ? { issuer: seatText("trace-frame-text", String(ev.issuer)) } : {}),
         ...(Object.keys(actor).length > 0 ? { actor } : {}),
         ...(str(ev.entryId) !== undefined ? { entryId: ev.entryId } : {}),
         ...(attachments !== undefined ? { attachments } : {}),
@@ -737,7 +750,7 @@ export function brainStatusEventData(ev) {
     const num = (v) => typeof v === "number" && Number.isFinite(v);
     return {
         phase: String(ev.phase),
-        ...(typeof ev.detail === "string" && ev.detail.length > 0 ? { detail: redactSecrets(ev.detail).slice(0, 300) } : {}),
+        ...(typeof ev.detail === "string" && ev.detail.length > 0 ? { detail: seatText("trace-frame-line", ev.detail) } : {}),
         ...(num(ev.retryInSec) ? { retryInSec: ev.retryInSec } : {}),
         ...(num(ev.attempt) ? { attempt: ev.attempt } : {}),
         ...(num(ev.maxRetries) ? { maxRetries: ev.maxRetries } : {}),
@@ -777,7 +790,7 @@ export function compactedEventData(ev) {
             const files = ev.attachedFiles
                 .filter((f) => typeof f === "object" && f !== null && typeof f.path === "string"
                 && num(f.chars) !== undefined && typeof f.truncated === "boolean")
-                .map((f) => ({ path: redactSecrets(f.path), chars: f.chars, truncated: f.truncated }));
+                .map((f) => ({ path: seatText("trace-frame-text", f.path), chars: f.chars, truncated: f.truncated }));
             return files.length > 0 ? { attachedFiles: files } : {};
         })(),
         ...(ev.modelFallback === true ? { modelFallback: true } : {}),

package/dist/trace/projection-table.d.ts

@@ -0,0 +1,100 @@
+/**
+ * **投影处置表**:一个 core 类型在一张出口面上的样子,只由一张表回答。
+ *
+ * ## 一条规则
+ * 表对该类型的**每一个键**给四词之一,表外键 = tsc 红(`satisfies DispositionTable<T, …>`):
+ *  · `"forward"` —— 原值出门(只配叶值:原语或原语列表);`{ forward: 读法 }` = 读法认得才出门(读不出 ⇒ 键缺席并计一次),值不改;
+ *  · `"strip"`   —— 本面不出现;
+ *  · `{ redact: 入口 }` —— 原值经**点名的既有脱敏入口**出门(词就是那只导出的名字,本模块不另铸脱敏逻辑);
+ *  · `{ nested: 子表 }` —— 成员级子表;对象逐成员、列表逐元素(列表必须写 `rows`:`"each"` = 每个元素,或一只**只做选取 / 排序**的函数
+ *    —— 运行期按身份核它交回的元素都来自原列表,值仍逐个过子表,带不出表外值);`admit` = 整只对象的读法。
+ * 本仓**自铸**的键(core 没有的派生事实)以 `{ mint: (src, root) => 值 }` 写在表里它的出口位次上 —— 它不是处置词,类型上不许与 core 键同名。
+ * ⚠️ 铸键读到的是**原值**(要从原值算计数 / 时长 / 展示词):它只许回派生事实,不许把原值或其片段回出去 —— 这是表里唯一一处
+ * 表本身拦不住、要靠复审看的地方。
+ * 值形限制写在类型上(整只值形一起判,不按联合分配):叶值(联合每一臂都是原语 / 原语列表)才能 `forward`,文本才能 `redact`,
+ * `nested` 不收各臂键不同的联合(`keyof` 只给交集,某一臂独有的键会悄悄没有处置),core 写成 `unknown` / `any` 的值只能 `strip`;
+ * **一格只许一词** —— 类型上把其余词的键写成 `never`(展开也混不进第二个词),运行期再核一次,两词同在 ⇒ 响亮抛。
+ * 投影函数是表的解释器 {@link projectByTable};`core-keyset-guard.ts` 读表({@link TableCoreKeys})—— 门与投影只有一个写者。
+ *
+ * ## 三条读法(所有表同一条)
+ *  · **缺席即缺席**:源值 `undefined` ⇒ 键缺席(不补 `[]` / `false` / 默认值);
+ *  · **表序 = 出口序**:表字面量按出口顺序写,铸键按位插 ⇒ 输出的键序就是表的键序;
+ *  · **在场却读不出 ⇒ 计一次并丢**(`dropProjectedFace`,F 类;缺席从不计数):读法拒、`redact` 位不是文本、嵌套位不是对象、
+ *    写了 `rows` 的位不是列表、列表元素不是对象 —— 那一格丢,其余照投,不抛、不 500。表里出现解释器不认识的词(只可能经运行期旁路造出)⇒ 响亮抛。
+ *
+ * ## 凭据
+ * `redact` 管「**可能含**凭据的文本」;「**本身是**凭据的值」(赎回令牌)写 `strip`。core 打了品牌的凭据型(`CheckpointToken`)上,
+ * 类型层写不出 `forward`。
+ */
+import type { CheckpointToken } from "@sema-agent/core";
+/** `redact` 可点名的既有脱敏入口(闭集;一词 = 一只既有导出的名字,解释器原样调用)。 */
+export type RedactEntry = "redactSecrets" | "redactErrorMessage";
+/** 窄读:认得 ⇒ `true`(原值出门),认不得 ⇒ 键缺席并计一次。只判不改。 */
+export type Admit = (raw: unknown) => boolean;
+/** 列表位怎么带:`"each"` = 每个元素;函数 = 选取 / 排序(只许交回原列表里的元素 —— 运行期按身份核,交回别的就响亮抛)。 */
+type RowsOf<E, R> = "each" | ((list: readonly E[], root: R) => readonly E[]);
+/** 一格只许一词:对象形的处置把其余词的键写成 `never` —— 多余属性检查之外,经展开 / 赋值也写不进第二个词。 */
+type DispositionKey = "forward" | "redact" | "nested" | "rows" | "admit" | "mint";
+type Only<K extends DispositionKey, T> = T & {
+    readonly [P in Exclude<DispositionKey, K>]?: never;
+};
+/** 不透明值(core 型写成 `unknown` / `any`):本仓写不出它的成员表,也说不出它是不是文本 ⇒ 只能 `strip`。 */
+type IsOpaque<V> = unknown extends V ? true : false;
+/** 叶值:联合的**每一臂**都是原语,或元素每一臂都是原语的列表(不透明元素不算)。 */
+type LeafMember<M> = M extends readonly (infer E)[] ? (unknown extends E ? false : [Extract<E, object>] extends [never] ? true : false) : M extends object ? false : true;
+type IsLeaf<V> = false extends LeafMember<NonNullable<V>> ? false : true;
+/** 联合的任一臂(或列表元素的任一臂)是 core 的品牌凭据。 */
+type TokenMember<M> = M extends readonly (infer E)[] ? ([Extract<E, CheckpointToken>] extends [never] ? false : true) : [Extract<M, CheckpointToken>] extends [never] ? false : true;
+type HoldsToken<V> = true extends TokenMember<NonNullable<V>> ? true : false;
+/** 判别联合的各臂键并集;`nested` 只收「各臂键相同」的对象型 —— 否则 `keyof` 只给交集,只在某一臂上的键会悄悄没有处置。 */
+type ArmKeys<E> = E extends unknown ? keyof E : never;
+type NestedTarget<E> = [ArmKeys<E>] extends [keyof E] ? true : false;
+/** 值形决定可写哪几个词:叶值才能 `forward`(对象 / 对象列表的成员必须逐个处置),文本才能 `redact`,对象 / 对象列表才能 `nested`
+ *  (列表必须写 `rows`、对象不许写),品牌凭据写不出 `forward`,不透明值只能 `strip`。判断都**不按联合分配**:整只值形一起判。 */
+type NestedOf<V, R> = [
+    NonNullable<V>
+] extends [readonly (infer E)[]] ? [E] extends [object] ? NestedTarget<E> extends true ? Only<"nested" | "rows" | "admit", {
+    readonly nested: CoreTable<E, R>;
+    readonly rows: RowsOf<E, R>;
+    readonly admit?: Admit;
+}> : never : never : [NonNullable<V>] extends [object] ? NestedTarget<NonNullable<V>> extends true ? Only<"nested" | "admit", {
+    readonly nested: CoreTable<NonNullable<V>, R>;
+    readonly admit?: Admit;
+}> : never : never;
+type ForwardOf<V> = IsLeaf<V> extends true ? (HoldsToken<V> extends true ? never : "forward" | Only<"forward", {
+    readonly forward: Admit;
+}>) : never;
+/** 一个 core 键在一张面上的处置(四词;`R` = 铸键能读到的根)。 */
+export type Disposition<V, R> = IsOpaque<V> extends true ? "strip" : ForwardOf<V> | "strip" | (NonNullable<V> extends string ? Only<"redact", {
+    readonly redact: RedactEntry;
+}> : never) | NestedOf<V, R>;
+/** 本仓铸键:core 没有的派生事实,值 = `mint(源, 根)`,`undefined` ⇒ 缺席。 */
+export type Mint<T, R> = Only<"mint", {
+    readonly mint: (src: T, root: R) => unknown;
+}>;
+/** `T` 的全量处置(每个键恰一词;可选键也必须写)。 */
+export type CoreTable<T, R> = {
+    readonly [K in keyof T]-?: Disposition<T[K], R>;
+};
+/**
+ * 一张处置表的类型:`T` 的全量处置 + 名为 `M` 的铸键。`M` 与 `keyof T` 相交 ⇒ 整张表型变成错误标记(两个写者抢一个键)。
+ * 用法:`export const X_DISPOSITIONS = { … } as const satisfies DispositionTable<T, R, "铸键A" | "铸键B">`。
+ */
+export type DispositionTable<T, R = T, M extends string = never> = [Extract<M, keyof T>] extends [never] ? CoreTable<T, R> & {
+    readonly [K in M]: Mint<T, R>;
+} : {
+    readonly __mintCollidesWithCoreKey: Extract<M, keyof T>;
+};
+/** 表里处置 core 键的那些键(铸键除外)—— `core-keyset-guard.ts` 读这个。 */
+export type TableCoreKeys<Tbl> = {
+    [K in keyof Tbl]-?: Tbl[K] extends {
+        readonly mint: unknown;
+    } ? never : K;
+}[keyof Tbl];
+/**
+ * 按表投影一个值。`face` = 计数 / 报错里的面名(`<面>.<键路径>`);`root` = 铸键与 `rows` 读到的根(面的顶层值)。
+ * 纯数据进、纯数据出;不改入参。
+ */
+export declare function projectByTable<T extends object, R>(face: string, table: CoreTable<T, R>, value: T, root: R): Record<string, unknown>;
+export {};
+//# sourceMappingURL=projection-table.d.ts.map

package/dist/trace/projection-table.js

@@ -0,0 +1,130 @@
+import { redactErrorMessage } from "../observability/run-terminal.js";
+import { dropProjectedFace } from "./projection-drop.js";
+import { redactSecrets } from "./redact.js";
+export function projectByTable(face, table, value, root) {
+    return projectNode(face, table, value, root);
+}
+const isRecord = (v) => typeof v === "object" && v !== null;
+const DISPOSITION_KEYS = ["mint", "forward", "redact", "nested", "rows", "admit"];
+function projectNode(path, table, value, root) {
+    const out = {};
+    for (const [key, entry] of Object.entries(table)) {
+        const at = `${path}.${key}`;
+        if (entry === "strip")
+            continue;
+        if (entry === "forward") {
+            const raw = Reflect.get(value, key);
+            if (raw !== undefined)
+                out[key] = raw;
+            continue;
+        }
+        if (!isRecord(entry))
+            throw unknownWord(at, entry);
+        const present = DISPOSITION_KEYS.filter((k) => Object.hasOwn(entry, k));
+        const words = present.filter((k) => k !== "rows" && k !== "admit");
+        if (words.length === 0)
+            throw unknownWord(at, entry);
+        if (words.length > 1 || (words[0] !== "nested" && present.length > 1)) {
+            throw new Error(`projection_table: ${at} carries more than one disposition (${present.join(", ")}) — one cell, one word`);
+        }
+        if (words[0] === "mint") {
+            if (typeof entry.mint !== "function")
+                throw unknownWord(at, entry);
+            const minted = entry.mint(value, root);
+            if (minted !== undefined)
+                out[key] = minted;
+            continue;
+        }
+        const raw = Reflect.get(value, key);
+        if (raw === undefined)
+            continue;
+        if (words[0] === "forward") {
+            if (typeof entry.forward !== "function")
+                throw unknownWord(at, entry);
+            if (entry.forward(raw) === true)
+                out[key] = raw;
+            else
+                drop(at, "is present but its narrow read rejects it");
+            continue;
+        }
+        if (words[0] === "redact") {
+            if (typeof entry.redact !== "string")
+                throw unknownWord(at, entry);
+            const redacted = redactWith(entry.redact, raw, at);
+            if (redacted !== undefined)
+                out[key] = redacted;
+            continue;
+        }
+        const projected = projectNested(at, entry, raw, root);
+        if (projected !== undefined)
+            out[key] = projected;
+    }
+    return out;
+}
+function projectNested(at, entry, raw, root) {
+    const sub = entry.nested;
+    if (!isRecord(sub))
+        throw unknownWord(at, entry);
+    if (entry.admit !== undefined && typeof entry.admit !== "function")
+        throw unknownWord(at, entry);
+    if (typeof entry.admit === "function" && entry.admit(raw) !== true) {
+        return drop(at, "is present but its narrow read rejects it");
+    }
+    const rows = entry.rows;
+    if (rows === undefined) {
+        if (!isRecord(raw) || Array.isArray(raw))
+            return drop(at, "is present but not an object");
+        return projectNode(at, sub, raw, root);
+    }
+    if (!Array.isArray(raw))
+        return drop(at, "is present but not a list");
+    let carried;
+    if (rows === "each")
+        carried = raw;
+    else if (typeof rows === "function") {
+        const selected = rows(raw, root);
+        if (!Array.isArray(selected))
+            throw new Error(`projection_table: ${at} rows selector returned a non-list`);
+        const pool = new Set(raw);
+        if (selected.some((element) => !pool.has(element))) {
+            throw new Error(`projection_table: ${at} rows selector returned an element that is not in the list — rows may only select / reorder`);
+        }
+        carried = selected;
+    }
+    else
+        throw unknownWord(at, entry);
+    const out = [];
+    for (const element of carried) {
+        if (isRecord(element) && !Array.isArray(element))
+            out.push(projectNode(`${at}[]`, sub, element, root));
+        else
+            drop(`${at}[]`, "element is present but not an object");
+    }
+    return out;
+}
+function redactWith(word, raw, at) {
+    const entry = word;
+    const asText = (scrub) => (typeof raw === "string" ? scrub(raw) : drop(at, "is present but not text"));
+    switch (entry) {
+        case "redactSecrets":
+            return asText(redactSecrets);
+        case "redactErrorMessage":
+            return asText(redactErrorMessage);
+        default: {
+            const unhandled = entry;
+            throw unknownWord(at, { redact: unhandled });
+        }
+    }
+}
+function drop(at, why) {
+    return dropProjectedFace("projection_table." + at + " " + why);
+}
+function unknownWord(at, entry) {
+    const shown = typeof entry === "string"
+        ? JSON.stringify(entry)
+        : isRecord(entry)
+            ? `{${Object.entries(entry).map(([k, v]) => `${k}:${typeof v === "string" ? v : typeof v}`).join(",")}}`
+            : String(entry);
+    return new Error(`projection_table: ${at} carries a disposition the interpreter does not know: ${shown}`);
+}
+//# sourceMappingURL=projection-table.js.map

package/dist/trace/redact.d.ts

@@ -29,10 +29,30 @@ export declare function armPoolBudgetForTest(): {
     armCount: number;
     boundaryArmCount: number;
     forensicLevels: number;
+    forensicRuns: number;
+    forensicSkips: number;
+    urlSegmentRuns: number;
+    urlSegmentReplays: number;
     ssh2ScanBytes: number;
     mappedUnits: number;
 };
 export declare function resetArmPoolBudgetForTest(): void;
+/**
+ * 🔴 **脱敏的两个档 —— 「这段文本是自由文本,还是一个结构有界的单元」**(S-526,闭集两词)。
+ *
+ * · `"free-text"`:CoT / 日志 / 任意字节。臂**全员**在场,读数就是 {@link redactSecrets} 的对外语义。
+ * · `"bounded-unit"`:一个 URL 路径段、一个 query 键名或值 —— 边界由**结构**给(WHATWG 已经把界告诉我们了)。
+ *   这一档**去掉词法关键字臂**:它们的判别力来自自由文本的语法,而单元里没有那种语法(见
+ *   {@link unitCarriesCredential} 顶注的病理)。值形臂与结构锚臂两族都**留在档里** —— 判别力分别是
+ *   「前缀 + 值形」与一条**字面结构锚**(`-----BEGIN` / `://u:p@` / JSON 秘密字段名)。
+ *   ⚠️ **只有值形臂那一族在单元里真的开火**(异源复审 270 形实测纠错):结构锚臂**留着但恒空转** —— 锚里的
+ *   空格 / `:` / `@` / `"` / `{` 不属于**任何**臂的值字符类,{@link boundedUnitView} 的补位会把它们逐个换掉,
+ *   锚在每一份视图里都被摧毁。把结构锚臂一并踢出本档,270 形读数**零差**。留着它们是因为「谁的判别力依赖
+ *   自由文本语法」这条**判据**上它们本就不该被排除(踢掉是另一条理由),不是因为它们在这里还起作用。
+ *
+ * 闭集:加一个档而不在 {@link armPool} 的档表里处置 ⇒ **编译**红。
+ */
+type RedactionScope = "free-text" | "bounded-unit";
 /** 本模块会写进文本的全部替换 token(`«…»` 字面),从三张表现算 —— 表改这里自动跟,不另抄一份。
  *  🔴 **S-223 v2 修复轮起它只剩一个语义:闭形闭集的加载期校验**。运行期「这一段是不是一枚记号」已经由
  *  {@link credentialSpans} 的闭**形**那一支一处答完({@link opaqueUnitEnd}),按闭**集**再认一遍的
@@ -44,6 +64,23 @@ declare const DISPLAY_SAFE_URL_TOKEN = "\u00ABredacted:url\u00BB";
 /** S-776:出网代理 URL 的回显尺(`outbound-dispatcher.ts` `displayProxyUrl`)形不干净时整只用**同一枚**占位 —— 单独一行导出,
  *  上面那行字面量保持 `const NAME = "…";` 形(`test/api-notice-text-freeze.test.ts` §6 的冻结扫描按这一形认替换 token)。 */
 export { DISPLAY_SAFE_URL_TOKEN };
+/**
+ * 🔴 **取证相的重扫模式(测试座,S-375)** —— 生产恒 `"incremental"`;`"full"` 是**参照语义** = 「没有可复用的上一次执行」:
+ * 每级五条取证臂整段重跑、URL 臂每段重扫,既不读足迹也不回放(池把每一级的脏区间当作「未知」交下去,与级 0 同一个读法)。
+ * 证据表的建法(级 0 记号档 + 逐级折入)与收敛判据(脏区间为空)两种模式是同一条,所以两种模式只差「复用与否」这一位 ——
+ * 增量重扫的全部正确性主张只有一句:**任何输入上两种模式输出逐字相同**(`test/forensic-incremental-rescan.test.ts` 并跑比对;
+ * 折入本身与整表重建的对拍是那个测试文件里的一份测试本地参照)。
+ */
+export type ForensicRescanMode = "incremental" | "full";
+export declare function setForensicRescanModeForTest(mode: ForensicRescanMode): void;
+/** 测试座:折入函数的数组形(`prev` 须是合法的已并表:升序、两两不交不相接)。 */
+export declare function credentialSpansFoldForTest(prev: ReadonlyArray<readonly [number, number]>, add: ReadonlyArray<readonly [number, number]>): {
+    next: Array<[number, number]>;
+    dirty: Array<[number, number]>;
+};
+/** 🧪 结构读数(与 {@link ppkScanBytesForTest} 同一条技法):本扫描器读过的单元数,线性钉用。 */
+export declare function anchoredScanUnitsForTest(): number;
+export declare function resetAnchoredScanUnitsForTest(): void;
 /** 测试可见(S-265 真值表的两半):结构段里**表行只作声明、实现是手写扫描器**的臂 —— 声明正则的**新拷贝**
  *  (`lastIndex` 不与模块内那一枚共享)+ 扫描器在一份原文上产的候选跨度 `[起, 止)`。臂名是闭集 ⇒ 穷尽 `switch`
  *  (少一个 `case` = 缺返回 = 编译红)。 */
@@ -125,6 +162,23 @@ export declare function redactionSpansForTest(text: string, opts?: {
         readonly end: number;
     }>;
 };
+/**
+ * 🔴 **出口座的提案口**(S-485 / RH-1 第一期;座 = `src/trace/exit-seat.ts` 的 `seatText`)。
+ *
+ * 同一只 {@link runRedaction}、同一遍扫描、同一次观察者计数(`observe` 与 {@link redactSecrets} 的缺省同口 —— 座上的一次脱敏就是一次
+ * 主扫),交出**原文坐标**上的跨度与各自的替换串:臂认什么、档里有哪些臂,仍然只由本模块答。座拿它做**一次区间合并 + 一次渲染**
+ * (合并律与渲染律住在座里,本模块不拼第二份产物给座)。
+ *
+ * 第一期交的是池解完重叠之后的那一份(升序、两两不交);第二期改交未解重叠的原始候选,池内并集律 {@link resolveSpanOverlaps} 与
+ * {@link applySpans} 随之删除 —— 那时本口是自由文本脱敏的唯一出口。
+ */
+export type RedactionSpan = {
+    readonly start: number;
+    readonly end: number;
+    readonly repl: string;
+};
+export type { RedactionScope };
+export declare function proposeRedactionSpans(text: string, scope: RedactionScope): readonly RedactionSpan[];
 /**
  * 🔴 环 + 深度预算(2026-07-25 补)。原实现是纯递归、**既不记已访问节点也不限深度**,而它的调用位置是
  * **最不可信的边界**:`toolStart`/`toolEnd` 把工具的 `args`/`output`/`structured` 直接喂进来。后果两条: