@sema-agent/server 7.138.0 → 7.140.0

package/dist/terminal.d.ts

@@ -129,6 +129,33 @@ export declare function nestedPauseOf(terminal: TerminalCause): PausedCause | un
  * status 恒 `"failed"`)。因由形下两条路径合成一句话,规则从二变一。
  */
 export declare function pausedCauseOf(terminal: TerminalCause): PausedCause | undefined;
+/**
+ * **宿主边界上的诚实终局** —— 宿主 run 行停不停、停在哪个词上,只问这一只判官。
+ *
+ *  · 本腿自己的 `paused` ⇒ 原样(它就是宿主腿的停驻);
+ *  · `failed.nestedPause` 且 `result.sessionId === hostSessionId` ⇒ 把那次停驻**整只**提成本腿的终局因由
+ *    (门 / 凭据 / `checkpointId` 同址;结果的其余格 —— `stats` / `verification` / … —— 原样);
+ *  · 其余 ⇒ **同一引用**原样(真失败;或嵌套停驻的卡不在宿主会话上)。
+ *
+ * 为什么判据是「停驻的那条腿跑在宿主会话上」:宿主的续跑链按会话把一张卡连回 run —— 决定腿按卡的会话找行
+ * (`getActiveTaskId`)与续跑输入(`getCtx`),取消按 run 的会话找待决卡,过期收割按会话相等连行与卡。卡在宿主会话上,
+ * 这条 run 才兑现得了它;判官只把兑现得了的停驻判成停驻。verify 的实现腿与修复轮跑在宿主会话上 ⇒ 提;cascade
+ * 每级被引擎剥掉会话、级上的卡落在级自己现铸的会话上 ⇒ 不提(照常终局)。这不是按组合器分的特例:引擎让级上的卡落到
+ * 宿主可连的会话上的那一天,答案随事实翻,本函数一个字不改。读 `result.sessionId` 而不去店里读卡:它与卡行的会话是同一次
+ * `runTask` 的同一个量,零 I/O。
+ *
+ * 前提:结果出自 core 的组合器(可信产者)—— `failed.nestedPause` 只由引擎的嵌套边界包停驻铸,`paused` 只在卡行写入确认之后返回。
+ * 判官**不**验证那张卡在不在、是不是这一张、此刻什么态;会话相等不是对卡的校验。验证器**自己**的停驻
+ * (`verification.verifierPause`)不在结果因由里,本函数看不见它 —— 那一形照常终局。
+ *
+ * 纯函数,不读店、不抛。凭据随提升上来,摘除仍归 {@link sealResultForExit}(调用方照旧先 graft 后封口)。
+ * 判官只答「该不该停驻」;认领保不保得住是停驻写口**写成功**与否的事(行写口对 `running` / `suspended` 行 CAS)。
+ * `hostSessionId` 缺席 = 没有宿主会话 ⇒ 没有续跑链兑现得了嵌套停驻 ⇒ 原样(相等判自然为假,不另设臂)。
+ */
+export declare function atHostBoundary<T extends {
+    readonly terminal: TerminalCause;
+    readonly sessionId: string;
+}>(result: T, hostSessionId: string | undefined): T;
 /**
  * **持久 blob 的平面读面** —— 把一条**任何年代**的持久终局结果读成五词 `status` + 三个平面文本格。
  *

package/dist/terminal.js

@@ -45,6 +45,12 @@ export function nestedPauseOf(terminal) {
 export function pausedCauseOf(terminal) {
     return terminal.kind === "paused" ? terminal : nestedPauseOf(terminal);
 }
+export function atHostBoundary(result, hostSessionId) {
+    const parked = nestedPauseOf(result.terminal);
+    if (parked === undefined || result.sessionId !== hostSessionId)
+        return result;
+    return { ...result, terminal: parked };
+}
 export function persistedPlaneOf(result) {
     if (result === null || typeof result !== "object")
         return {};

package/dist/tool-approval.d.ts

@@ -1,3 +1,4 @@
+import type { ExecutionLane } from "./execution-lane-caps.js";
 import { type ApprovalDecidedBy, type HostSettledBy, type RetiredDecisionKeyFacts } from "./host-decision.js";
 import type { IncomingMessage } from "node:http";
 import { type AskClass, type AskRequest, type AskOutcome, type PermissionResult, type CheckpointGate, type PendingAction, type PersistedRuleMandate, type ReadRootGrantCandidate, type RuleOffer, type AutoModeFallbackCause, type BoundGrantAbsence, type BoundSkillGrants, type ToolApprovalCard, type ReopenReason } from "@sema-agent/core";
@@ -872,6 +873,8 @@ interface ToolApprovalRunContextBase {
     taskId: string;
     sessionId?: string;
     owner: string | null;
+    /** 这条腿的执行车道 —— 装配点写所在边界执行上下文的 `ctx.lane`(`http/execution-context.ts`)。出处带车道:这只席造的问在铸行时记下它。 */
+    executionLane: ExecutionLane;
     abortSignal?: AbortSignal;
     /** [ref]([ref] §3.1 askId 派生的腿轴;车3 刀 3a 换轴:原 `leg?: number` → `legKey?: string`)。
      *  = `sha256(resume checkpoint token)` 的 hex,**首腿缺席折空串**(空串是首腿的真值,不是「未知」)。
@@ -1770,6 +1773,7 @@ export declare class ToolApprovalCoordinator {
         owner: string | null;
         taskId: string;
         sessionId?: string;
+        executionLane: ExecutionLane;
     }, why: LegUnattended) => ((req: AskRequest) => Promise<AskOutcome>);
     /**
      * 🔴 session grant 短路前的**持久出处复核**([ref] 的 codex R1-[high] 补丁;[ref] 换判据;[ref] / SN-C1 换读口)。
@@ -1968,6 +1972,8 @@ export declare class ToolApprovalCoordinator {
         /** [ref] 车3 刀 3b(§7.3):本腿的 walltime deadline —— 与 `legKey` 同源同理由,随**出处**走
          *  (子代经继承链拿到的是宿主腿的闭包,窗必须按宿主腿的剩余 walltime 算)。 */
         legDeadlineMonotonic?: number;
+        /** 宿主腿的执行车道(装配点写执行上下文的 `ctx.lane`);子代经继承链冻同一闭包 ⇒ 子代的问记宿主腿的车道。 */
+        executionLane: ExecutionLane;
     }) => ((req: AskRequest, signal?: AbortSignal) => Promise<AskOutcome>);
     /** 广播版裁决路径——`ask()`(ALS,恒单元素数组)与 `boundAsk`([ref]四多活集合,可能多元素)共用。
      *  全体 `ctxs` 保证同一 (owner, sessionId)(streamKey 分组不变式;单元素数组平凡成立)。

package/dist/tool-approval.js

@@ -1015,7 +1015,7 @@ export class ToolApprovalCoordinator {
     }
     boundUnattendedAsk = (identity, why) => {
         return async (req) => {
-            const origin = { owner: identity.owner, taskId: identity.taskId, ...(identity.sessionId !== undefined ? { sessionId: identity.sessionId } : {}), legKey: "" };
+            const origin = { owner: identity.owner, taskId: identity.taskId, ...(identity.sessionId !== undefined ? { sessionId: identity.sessionId } : {}), legKey: "", executionLane: identity.executionLane };
             if (await this.standingGrantSettles(origin, req, this.governanceForcedOf(origin, req)))
                 return true;
             return this.unattendedAskOutcome({ ...why, taskId: identity.taskId, owner: identity.owner, toolName: req.toolName });
@@ -1267,6 +1267,7 @@ export class ToolApprovalCoordinator {
             owner: ctx.owner,
             ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
             legKey: ctx.legKey ?? "",
+            executionLane: ctx.executionLane,
             ...(ctx.legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic: ctx.legDeadlineMonotonic } : {}),
         }, [ctx], req, signal);
     };
@@ -1279,6 +1280,7 @@ export class ToolApprovalCoordinator {
                 owner: identity.owner,
                 ...(identity.sessionId !== undefined ? { sessionId: identity.sessionId } : {}),
                 legKey: identity.legKey ?? "",
+                executionLane: identity.executionLane,
                 ...(identity.legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic: identity.legDeadlineMonotonic } : {}),
             }, live, req, signal);
         };
@@ -1383,6 +1385,7 @@ export class ToolApprovalCoordinator {
         const card = this.askStore ? buildApprovalCard(frame, req, req.requiresRealApproval === true) : undefined;
         let cardForFrame = card;
         let persistedExpiresAtMs = expiresAtMs;
+        let entryExecutionLane = origin.executionLane;
         let lateEnsuredRow;
         let lateTerminalRow;
         let abandonedAs;
@@ -1422,6 +1425,7 @@ export class ToolApprovalCoordinator {
                     sourceTaskId,
                     sessionId: origin.sessionId ?? origin.taskId,
                     owner: origin.owner,
+                    executionLane: origin.executionLane,
                     batchId,
                     toolCallId: req.toolCallId,
                     legKey,
@@ -1458,6 +1462,7 @@ export class ToolApprovalCoordinator {
                     return existingOrCreated.inserted ? this.landUnattendedOutcome(unattended, existingOrCreated.row) : unattended;
                 }
                 persistedExpiresAtMs = existingOrCreated.row.expiresAtMs;
+                entryExecutionLane = existingOrCreated.row.executionLane;
                 cardForFrame = persistedEnvelope.card;
                 if (cardForFrame.governanceForced === true)
                     frame.governanceForced = true;
@@ -1936,6 +1941,7 @@ export class ToolApprovalCoordinator {
             ...(entryDeploymentListQuestion ? { deploymentListQuestion: true } : {}),
             registeredAtMs: Date.now(),
             expiresAtMs: persistedExpiresAtMs,
+            executionLane: entryExecutionLane,
             ...(ruleLaneMaterial !== undefined ? { ruleLane: ruleLaneMaterial } : {}),
             ...(effectiveGovernanceForced ? { governanceForced: true } : {}),
             ...(req.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
@@ -2899,6 +2905,7 @@ export class ToolApprovalCoordinator {
             forceParkNow: release,
             settleParkRoute: (cause) => leave({ outcome: SETTLE_OUTCOME.EXPIRED, cause, parked: this.unattendedRoutesToPark }),
             owner: row.owner,
+            executionLane: row.executionLane,
             ...(row.sessionId !== row.taskId ? { sessionId: row.sessionId } : {}),
             ...(card.fromSubagent === true ? { originTaskId: row.sourceTaskId } : {}),
             toolName: card.toolName,

package/dist/trace/project.d.ts

@@ -1016,6 +1016,7 @@ export declare function brainStatusEventData(ev: {
     providerConditionSource?: string;
     waitSegment?: string;
     sleptMs?: number;
+    seat?: string;
     eventId?: string;
     parentToolCallId?: string;
 }): FrameData<{

package/dist/trace/project.js

@@ -822,6 +822,7 @@ export function brainStatusEventData(ev) {
         ...(num(ev.timeoutMs) ? { timeoutMs: ev.timeoutMs } : {}),
         ...(typeof ev.waitSegment === "string" && ev.waitSegment.length > 0 ? { waitSegment: ev.waitSegment } : {}),
         ...(num(ev.sleptMs) ? { sleptMs: ev.sleptMs } : {}),
+        ...(typeof ev.seat === "string" && ev.seat.length > 0 ? { seat: ev.seat } : {}),
         ...(num(ev.errorStatus) ? { errorStatus: ev.errorStatus } : {}),
         ...(typeof ev.errClass === "string" && ev.errClass.length > 0 ? { errClass: ev.errClass } : {}),
         ...(typeof ev.providerCondition === "string" && ev.providerCondition.length > 0 ? { providerCondition: ev.providerCondition } : {}),

package/dist/trace/redact.d.ts

@@ -54,6 +54,8 @@ export declare function resetArmPoolBudgetForTest(): void;
  * 闭集:加一个档而不在 {@link armPool} 的档表里处置 ⇒ **编译**红。
  */
 type RedactionScope = "free-text" | "bounded-unit";
+/** 测试座:{@link unitCountWithin} 的数组形(`table` 须是合法的已并表:升序、两两不交不相接)。 */
+export declare function unitCountWithinForTest(table: ReadonlyArray<readonly [number, number]>, from: number, to: number, max: number): boolean;
 /** 本模块会写进文本的全部替换 token(`«…»` 字面),从三张表现算 —— 表改这里自动跟,不另抄一份。
  *  🔴 **[ref] v2 修复轮起它只剩一个语义:闭形闭集的加载期校验**。运行期「这一段是不是一枚记号」已经由
  *  {@link credentialSpans} 的闭**形**那一支一处答完({@link opaqueUnitEnd}),按闭**集**再认一遍的
@@ -67,7 +69,7 @@ declare const DISPLAY_SAFE_URL_TOKEN = "\u00ABredacted:url\u00BB";
 export { DISPLAY_SAFE_URL_TOKEN };
 /**
  * 🔴 **取证相的重扫模式(测试座,[ref])** —— 生产恒 `"incremental"`;`"full"` 是**参照语义** = 「没有可复用的上一次执行」:
- * 每级五条取证臂整段重跑、URL 臂每段重扫,既不读足迹也不回放(池把每一级的脏区间当作「未知」交下去,与级 0 同一个读法)。
+ * 每级全部取证臂整段重跑、URL 臂每段重扫,既不读足迹也不回放(池把每一级的脏区间当作「未知」交下去,与级 0 同一个读法)。
  * 证据表的建法(级 0 记号档 + 逐级折入)与收敛判据(脏区间为空)两种模式是同一条,所以两种模式只差「复用与否」这一位 ——
  * 增量重扫的全部正确性主张只有一句:**任何输入上两种模式输出逐字相同**(`test/forensic-incremental-rescan.test.ts` 并跑比对;
  * 折入本身与整表重建的对拍是那个测试文件里的一份测试本地参照)。

package/dist/trace/redact.js

@@ -1168,21 +1168,37 @@ function unitCountWithin(scan, from, to, max) {
         return true;
     noteEvidenceRead(scan, from);
     noteEvidenceRead(scan, to);
-    const st = scan.table.starts;
-    if (st.length === 0)
-        return false;
-    const k = firstCredentialSpanFrom(scan.table, from);
-    if (k >= st.length || st[k] >= to)
+    const t = scan.table;
+    const lo = firstCredentialSpanFrom(t, from);
+    let a = lo;
+    let b = t.ends.length;
+    while (a < b) {
+        const mid = (a + b) >>> 1;
+        if (t.ends[mid] <= to)
+            a = mid + 1;
+        else
+            b = mid;
+    }
+    if (a === lo)
         return false;
-    let n = 0;
-    for (let p = from; p < to;) {
-        if (n > max)
-            return false;
-        const unit = opaqueUnitEnd(scan, p);
-        p = unit > 0 && unit <= to ? unit : p + 1;
-        n += 1;
+    const saved = unitSavings(t);
+    return to - from - (saved[a] - saved[lo]) <= max;
+}
+const UNIT_SAVINGS = new WeakMap();
+function unitSavings(t) {
+    let saved = UNIT_SAVINGS.get(t);
+    if (saved === undefined) {
+        const n = t.starts.length;
+        saved = new Float64Array(n + 1);
+        for (let k = 0; k < n; k++)
+            saved[k + 1] = saved[k] + (t.ends[k] - t.starts[k] - 1);
+        UNIT_SAVINGS.set(t, saved);
     }
-    return n <= max;
+    return saved;
+}
+export function unitCountWithinForTest(table, from, to, max) {
+    const t = { starts: Int32Array.from(table, (x) => x[0]), ends: Int32Array.from(table, (x) => x[1]) };
+    return unitCountWithin(buildForensicScan(t, 1), from, to, max);
 }
 function collectSsh2FenceSpans(scan, text, span, isHead) {
     let cachedFrom = 0;
@@ -1241,16 +1257,20 @@ function pemFenceLineEnd(text, labelFrom) {
     }
     return isPemFenceLabel(text, labelFrom, close) ? close + PEM_FENCE_CLOSE.length : PEM_LINE_INVALID;
 }
-function collectPemFenceSpans(text, span, isHead) {
+function collectPemFenceSpans(scan, text, span, isHead) {
     let endFrom = -1;
     let endAt = -1;
     let endAfter = -1;
+    const visibleEndLine = (b) => {
+        const after = pemFenceLineEnd(text, b + PEM_END_OPEN.length);
+        return after >= 0 && !inOpaqueUnit(scan, b) ? after : -1;
+    };
     const earliestEndFence = (from) => {
         if (endFrom >= 0 && from >= endFrom && (endAt < 0 || endAt >= from))
             return;
         let b = text.indexOf(PEM_END_OPEN, from);
         let after = -1;
-        while (b >= 0 && (after = pemFenceLineEnd(text, b + PEM_END_OPEN.length)) < 0)
+        while (b >= 0 && (after = visibleEndLine(b)) < 0)
             b = text.indexOf(PEM_END_OPEN, b + 1);
         endFrom = from;
         endAt = b;
@@ -1260,6 +1280,10 @@ function collectPemFenceSpans(text, span, isHead) {
         const fence = text.indexOf(PEM_FENCE_OPEN, from);
         if (fence < 0)
             return;
+        if (inOpaqueUnit(scan, fence)) {
+            from = fence + 1;
+            continue;
+        }
         const bodyFrom = pemFenceLineEnd(text, fence + PEM_FENCE_OPEN.length);
         if (bodyFrom === PEM_LINE_INVALID) {
             from = fence + 1;
@@ -1272,7 +1296,7 @@ function collectPemFenceSpans(text, span, isHead) {
                 span(fence, text.length, true);
             return;
         }
-        if (endAt - bodyFrom > PEM_FENCE_BODY_MAX) {
+        if (!unitCountWithin(scan, bodyFrom, endAt, PEM_FENCE_BODY_MAX)) {
             from = fence + 1;
             continue;
         }
@@ -1610,7 +1634,7 @@ let forensicRescanMode = "incremental";
 export function setForensicRescanModeForTest(mode) {
     forensicRescanMode = mode;
 }
-function foldCredentialSpans(prev, spans, from) {
+function foldCredentialSpans(prev, spans, from, admit) {
     const cap = spans.length - from;
     if (cap === 0)
         return { next: prev, dirty: NO_CREDENTIAL_SPANS };
@@ -1619,6 +1643,8 @@ function foldCredentialSpans(prev, spans, from) {
     let m = 0;
     for (let i = from; i < spans.length; i++) {
         const sp = spans[i];
+        if (admit !== undefined && !admit(sp))
+            continue;
         const k = firstCredentialSpanFrom(prev, sp.start + 1) - 1;
         if (k >= 0 && prev.ends[k] >= sp.end)
             continue;
@@ -1742,7 +1768,7 @@ function buildForensicScan(table, armCount) {
         hdr: { search: 0, contentEnd: 0, next: 0, hitLimit: false, jsonEnd: false },
     };
 }
-function advanceEvidence(scan, table, dirty) {
+function useEvidenceView(scan, table, dirty) {
     scan.table = table;
     scan.cursor = 0;
     scan.dirty = dirty;
@@ -2417,7 +2443,7 @@ export function structuralScannerForTest(arm) {
         case "json-secret-field":
             return { declared: new RegExp(JSON_SECRET_FIELD_PATTERN[0].source, JSON_SECRET_FIELD_PATTERN[0].flags), spans: collect(collectJsonSecretFieldSpans) };
         case "pem-fence":
-            return { declared: new RegExp(PEM_FENCE_PATTERN[0].source, PEM_FENCE_PATTERN[0].flags), spans: collect(collectPemFenceSpans) };
+            return { declared: new RegExp(PEM_FENCE_PATTERN[0].source, PEM_FENCE_PATTERN[0].flags), spans: collect((text, span, isHead) => collectPemFenceSpans(buildForensicScan(NO_CREDENTIAL_SPANS, 1), text, span, isHead)) };
     }
 }
 let ppkScanBytes = 0;
@@ -2574,6 +2600,7 @@ const armPool = (() => {
             retry: boundary === undefined ? undefined : (text, at, out) => collectStickySpans(boundary, text, at, out),
             headSrc: boundary === undefined ? undefined : headSrc,
             headFirst: boundary === undefined ? undefined : headFirst,
+            family: undefined,
         };
     };
     const scannerMember = (token, order, arm, rank = ARM_RANK.structural, lexical = false) => {
@@ -2588,9 +2615,12 @@ const armPool = (() => {
             retry: undefined,
             headSrc: undefined,
             headFirst: undefined,
+            family: undefined,
         };
     };
-    const forensicMember = (token, order, arm) => {
+    const forensicMember = (token, order, arm, family = undefined, view = "all") => {
+        if (view === "other-families" && family === undefined)
+            throw new Error(`redact: forensic arm ${token} reads the other-families evidence view but declares no credential family`);
         const repl = spanRepl(token);
         const rank = ARM_RANK.structural;
         return {
@@ -2603,11 +2633,13 @@ const armPool = (() => {
             retry: undefined,
             headSrc: undefined,
             headFirst: undefined,
+            family,
+            view,
         };
     };
     const structuralScannerMember = (row, order) => {
         if (row === PEM_FENCE_PATTERN)
-            return scannerMember(row[1], order, (text, _json, _eat, span, isHead) => collectPemFenceSpans(text, span, isHead));
+            return forensicMember(row[1], order, (scan, text, _json, _eat, span, isHead) => collectPemFenceSpans(scan, text, span, isHead), "pem-armor", "other-families");
         if (row === SSH2_FENCE_PATTERN)
             return forensicMember(row[1], order, (scan, text, _json, _eat, span, isHead) => collectSsh2FenceSpans(scan, text, span, isHead));
         if (row === URL_CREDENTIAL_PATTERN)
@@ -2620,7 +2652,7 @@ const armPool = (() => {
     for (const row of STRUCTURAL_SECRET_PATTERNS)
         members.push(structuralScannerMember(row, members.length));
     members.push(forensicMember(PPK_CONTAINER_TOKEN, members.length, (scan, text, _json, eat, span, isHead) => collectPpkContainerSpans(scan, text, eat, span, isHead)));
-    members.push(forensicMember(PEM_FRAGMENT_TOKEN, members.length, (scan, text, json, _eat, span) => collectPemFragmentSpans(scan, text, json, span)));
+    members.push(forensicMember(PEM_FRAGMENT_TOKEN, members.length, (scan, text, json, _eat, span) => collectPemFragmentSpans(scan, text, json, span), "pem-armor"));
     members.push(forensicMember(HEADLESS_PPK_TOKEN, members.length, (scan, text, _json, _eat, span, isHead) => collectHeadlessPpkSpans(scan, text, span, isHead)));
     members.push(scannerMember(ANCHORED_VALUE_TOKEN, members.length, (text, json, _eat, span, isHead) => collectAnchoredValueSpans(text, json, span, isHead), ARM_RANK.keyword, true));
     for (const row of KEYWORD_SECRET_PATTERNS)
@@ -2636,6 +2668,13 @@ const armPool = (() => {
     const retryMembers = members.filter((m) => m.retry !== undefined);
     const phase1 = members.filter((m) => m.phase === 1);
     const phase2 = members.filter((m) => m.phase === 2);
+    const familyOfOrder = members.map((m) => m.family);
+    const viewKeyOf = (m) => {
+        switch (m.view) {
+            case "all": return undefined;
+            case "other-families": return m.family;
+        }
+    };
     const laneOf = (scope) => {
         const inScope = (m) => {
             switch (scope) {
@@ -2643,7 +2682,9 @@ const armPool = (() => {
                 case "bounded-unit": return !m.lexical;
             }
         };
-        return { phase1: phase1.filter(inScope), phase2: phase2.filter(inScope), retry: retryMembers.filter(inScope) };
+        const lanePhase2 = phase2.filter(inScope);
+        const viewKeys = [...new Set(lanePhase2.map(viewKeyOf))];
+        return { phase1: phase1.filter(inScope), phase2: lanePhase2, retry: retryMembers.filter(inScope), viewKeys, viewOf: lanePhase2.map((m) => viewKeys.indexOf(viewKeyOf(m))) };
     };
     const LANES = {
         "free-text": laneOf("free-text"),
@@ -2694,18 +2735,22 @@ const armPool = (() => {
             m.collect(text, json, eat, spans, isHead);
         closeCoveragePositions(0);
         if (lane.phase2.length > 0) {
-            const scan = buildForensicScan(credentialSpans(text), lane.phase2.length);
+            const tokens = credentialSpans(text);
+            const scan = buildForensicScan(tokens, lane.phase2.length);
             const reuse = forensicRescanMode === "incremental";
             const foot = scan.armFoot;
+            const views = lane.viewKeys.map((key) => ({ key, table: tokens, dirty: undefined }));
             let folded = 0;
             for (let level = 0;; level += 1) {
                 const before = spans.length;
                 for (let j = 0; j < lane.phase2.length; j++) {
-                    const dirty = scan.dirty;
+                    const view = views[lane.viewOf[j]];
+                    const dirty = view.dirty;
                     if (dirty !== undefined && footprintClean(dirty, foot[2 * j], foot[2 * j + 1])) {
                         forensicSkips += 1;
                         continue;
                     }
+                    useEvidenceView(scan, view.table, dirty);
                     scan.footLo = FOOT_NONE;
                     scan.footHi = -1;
                     lane.phase2[j].collect(scan, text, json, level === 0 ? eat : undefined, spans, isHead);
@@ -2715,11 +2760,18 @@ const armPool = (() => {
                 }
                 closeCoveragePositions(before);
                 forensicLevels += 1;
-                const grown = foldCredentialSpans(scan.table, spans, folded);
+                let grew = false;
+                for (const view of views) {
+                    const key = view.key;
+                    const grown = foldCredentialSpans(view.table, spans, folded, key === undefined ? undefined : (sp) => familyOfOrder[sp.order] !== key);
+                    if (grown.dirty.starts.length > 0)
+                        grew = true;
+                    view.table = grown.next;
+                    view.dirty = reuse ? grown.dirty : undefined;
+                }
                 folded = spans.length;
-                if (grown.dirty.starts.length === 0)
+                if (!grew)
                     break;
-                advanceEvidence(scan, grown.next, reuse ? grown.dirty : undefined);
             }
         }
         poolSpanCount += spans.length;